src/surfMesh/UnsortedMeshedSurface/UnsortedMeshedSurface.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
   6      \\/     M anipulation  |
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of OpenFOAM.
  10
  11     OpenFOAM is free software: you can redistribute it and/or modify it
  12     under the terms of the GNU General Public License as published by
  13     the Free Software Foundation, either version 3 of the License, or
  14     (at your option) any later version.
  15
  16     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
  17     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  19     for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 \*---------------------------------------------------------------------------*/
  25
  26 #include "MeshedSurface.H"
  27 #include "UnsortedMeshedSurface.H"
  28 #include "MeshedSurfaceProxy.H"
  29 #include "IFstream.H"
  30 #include "OFstream.H"
  31 #include "Time.H"
  32 #include "polyBoundaryMesh.H"
  33 #include "polyMesh.H"
  34
  35 // * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * //
  36
  37 template<class Face>
  38 Foam::wordHashSet Foam::UnsortedMeshedSurface<Face>::readTypes()
  39 {
  40     return wordHashSet(*fileExtensionConstructorTablePtr_);
  41 }
  42
  43
  44 template<class Face>
  45 Foam::wordHashSet Foam::UnsortedMeshedSurface<Face>::writeTypes()
  46 {
  47     return wordHashSet(*writefileExtensionMemberFunctionTablePtr_);
  48 }
  49
  50
  51 template<class Face>
  52 bool Foam::UnsortedMeshedSurface<Face>::canReadType
  53 (
  54     const word& ext,
  55     const bool verbose
  56 )
  57 {
  58    return fileFormats::surfaceFormatsCore::checkSupport
  59    (
  60        readTypes() | ParentType::readTypes(),
  61        ext,
  62        verbose,
  63        "reading"
  64    );
  65 }
  66
  67
  68 template<class Face>
  69 bool Foam::UnsortedMeshedSurface<Face>::canWriteType
  70 (
  71     const word& ext,
  72     const bool verbose
  73 )
  74 {
  75     return fileFormats::surfaceFormatsCore::checkSupport
  76     (
  77         writeTypes(),
  78         ext,
  79         verbose,
  80         "writing"
  81     );
  82 }
  83
  84
  85 template<class Face>
  86 bool Foam::UnsortedMeshedSurface<Face>::canRead
  87 (
  88     const fileName& name,
  89     const bool verbose
  90 )
  91 {
  92     word ext = name.ext();
  93     if (ext == "gz")
  94     {
  95         ext = name.lessExt().ext();
  96     }
  97     return canReadType(ext, verbose);
  98 }
  99
 100
 101 template<class Face>
 102 void Foam::UnsortedMeshedSurface<Face>::write
 103 (
 104     const fileName& name,
 105     const UnsortedMeshedSurface<Face>& surf
 106 )
 107 {
 108     if (debug)
 109     {
 110         Info<< "UnsortedMeshedSurface::write"
 111             "(const fileName&, const UnsortedMeshedSurface&) : "
 112             "writing to " << name
 113             << endl;
 114     }
 115
 116     const word ext = name.ext();
 117
 118     typename writefileExtensionMemberFunctionTable::iterator mfIter =
 119         writefileExtensionMemberFunctionTablePtr_->find(ext);
 120
 121     if (mfIter == writefileExtensionMemberFunctionTablePtr_->end())
 122     {
 123         // no direct writer, delegate to proxy if possible
 124         wordHashSet supported = ProxyType::writeTypes();
 125
 126         if (supported.found(ext))
 127         {
 128             MeshedSurfaceProxy<Face>(surf).write(name);
 129         }
 130         else
 131         {
 132             FatalErrorIn
 133             (
 134                 "UnsortedMeshedSurface::write"
 135                 "(const fileName&, const UnsortedMeshedSurface&)"
 136             )   << "Unknown file extension " << ext << nl << nl
 137                 << "Valid types are :" << endl
 138                 << (supported | writeTypes())
 139                 << exit(FatalError);
 140         }
 141     }
 142     else
 143     {
 144         mfIter()(name, surf);
 145     }
 146 }
 147
 148
 149 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 150
 151 template<class Face>
 152 Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface()
 153 :
 154     ParentType()
 155 {}
 156
 157
 158 template<class Face>
 159 Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface
 160 (
 161     const Xfer<pointField>& pointLst,
 162     const Xfer<List<Face> >& faceLst,
 163     const Xfer<List<label> >& zoneIds,
 164     const Xfer<surfZoneIdentifierList>& zoneTofc
 165 )
 166 :
 167     ParentType(pointLst, faceLst),
 168     zoneIds_(zoneIds),
 169     zoneToc_(zoneTofc)
 170 {}
 171
 172
 173 template<class Face>
 174 Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface
 175 (
 176     const Xfer<pointField>& pointLst,
 177     const Xfer<List<Face> >& faceLst,
 178     const labelUList& zoneSizes,
 179     const UList<word>& zoneNames
 180 )
 181 :
 182     ParentType(pointLst, faceLst)
 183 {
 184     if (zoneSizes.size())
 185     {
 186         if (zoneNames.size())
 187         {
 188             setZones(zoneSizes, zoneNames);
 189         }
 190         else
 191         {
 192             setZones(zoneSizes);
 193         }
 194     }
 195     else
 196     {
 197         setOneZone();
 198     }
 199 }
 200
 201
 202 template<class Face>
 203 Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface
 204 (
 205     const UnsortedMeshedSurface<Face>& surf
 206 )
 207 :
 208     ParentType
 209     (
 210         xferCopy(surf.points()),
 211         xferCopy(surf.faces())
 212     ),
 213     zoneIds_(surf.zoneIds()),
 214     zoneToc_(surf.zoneToc())
 215 {}
 216
 217
 218 template<class Face>
 219 Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface
 220 (
 221     const MeshedSurface<Face>& surf
 222 )
 223 :
 224     ParentType
 225     (
 226         xferCopy(surf.points()),
 227         xferCopy(surf.faces())
 228     )
 229 {
 230     setZones(surf.surfZones());
 231 }
 232
 233
 234 template<class Face>
 235 Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface
 236 (
 237     const Xfer<UnsortedMeshedSurface<Face> >& surf
 238 )
 239 :
 240     ParentType()
 241 {
 242     transfer(surf());
 243 }
 244
 245
 246 template<class Face>
 247 Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface
 248 (
 249     const Xfer<MeshedSurface<Face> >& surf
 250 )
 251 :
 252     ParentType()
 253 {
 254     transfer(surf());
 255 }
 256
 257
 258 template<class Face>
 259 Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface
 260 (
 261     const fileName& name,
 262     const word& ext
 263 )
 264 :
 265     ParentType()
 266 {
 267     read(name, ext);
 268 }
 269
 270
 271 template<class Face>
 272 Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface(const fileName& name)
 273 :
 274     ParentType()
 275 {
 276     read(name);
 277 }
 278
 279
 280 template<class Face>
 281 Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface
 282 (
 283     const Time& t,
 284     const word& surfName
 285 )
 286 :
 287     ParentType()
 288 {
 289     MeshedSurface<Face> surf(t, surfName);
 290     transfer(surf);
 291 }
 292
 293
 294 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 295
 296 template<class Face>
 297 Foam::UnsortedMeshedSurface<Face>::~UnsortedMeshedSurface()
 298 {}
 299
 300
 301 // * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
 302
 303 template<class Face>
 304 void Foam::UnsortedMeshedSurface<Face>::setOneZone()
 305 {
 306     zoneIds_.setSize(size());
 307     zoneIds_ = 0;
 308
 309     word zoneName;
 310     if (zoneToc_.size())
 311     {
 312         zoneName = zoneToc_[0].name();
 313     }
 314     if (zoneName.empty())
 315     {
 316         zoneName = "zone0";
 317     }
 318
 319     // set single default zone
 320     zoneToc_.setSize(1);
 321     zoneToc_[0] = surfZoneIdentifier(zoneName, 0);
 322 }
 323
 324
 325 template<class Face>
 326 void Foam::UnsortedMeshedSurface<Face>::setZones
 327 (
 328     const surfZoneList& zoneLst
 329 )
 330 {
 331     zoneIds_.setSize(size());
 332     zoneToc_.setSize(zoneLst.size());
 333
 334     forAll(zoneToc_, zoneI)
 335     {
 336         const surfZone& zone = zoneLst[zoneI];
 337         zoneToc_[zoneI] = zone;
 338
 339         // assign sub-zone Ids
 340         SubList<label> subZone(zoneIds_, zone.size(), zone.start());
 341         subZone = zoneI;
 342     }
 343 }
 344
 345
 346 template<class Face>
 347 void Foam::UnsortedMeshedSurface<Face>::setZones
 348 (
 349     const labelUList& sizes,
 350     const UList<word>& names
 351 )
 352 {
 353     zoneIds_.setSize(size());
 354     zoneToc_.setSize(sizes.size());
 355
 356     label start = 0;
 357     forAll(zoneToc_, zoneI)
 358     {
 359         zoneToc_[zoneI] = surfZoneIdentifier(names[zoneI], zoneI);
 360
 361         // assign sub-zone Ids
 362         SubList<label> subZone(zoneIds_, sizes[zoneI], start);
 363         subZone = zoneI;
 364
 365         start += sizes[zoneI];
 366     }
 367 }
 368
 369
 370 template<class Face>
 371 void Foam::UnsortedMeshedSurface<Face>::setZones
 372 (
 373     const labelUList& sizes
 374 )
 375 {
 376     zoneIds_.setSize(size());
 377     zoneToc_.setSize(sizes.size());
 378
 379     label start = 0;
 380     forAll(zoneToc_, zoneI)
 381     {
 382         zoneToc_[zoneI] = surfZoneIdentifier
 383         (
 384             word("zone") + ::Foam::name(zoneI),
 385             zoneI
 386         );
 387
 388         // assign sub-zone Ids
 389         SubList<label> subZone(zoneIds_, sizes[zoneI], start);
 390         subZone = zoneI;
 391
 392         start += sizes[zoneI];
 393     }
 394 }
 395
 396
 397 template<class Face>
 398 void Foam::UnsortedMeshedSurface<Face>::remapFaces
 399 (
 400     const labelUList& faceMap
 401 )
 402 {
 403     // re-assign the zone Ids
 404     if (&faceMap && faceMap.size())
 405     {
 406         if (zoneToc_.empty())
 407         {
 408             setOneZone();
 409         }
 410         else if (zoneToc_.size() == 1)
 411         {
 412             // optimized for single-zone case
 413             zoneIds_ = 0;
 414         }
 415         else
 416         {
 417             List<label> newZones(faceMap.size());
 418
 419             forAll(faceMap, faceI)
 420             {
 421                 newZones[faceI] = zoneIds_[faceMap[faceI]];
 422             }
 423             zoneIds_.transfer(newZones);
 424         }
 425     }
 426 }
 427
 428
 429 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 430
 431 template<class Face>
 432 void Foam::UnsortedMeshedSurface<Face>::setSize(const label s)
 433 {
 434     this->storedFaces().setSize(s);
 435     // if zones extend: set with last zoneId
 436     zoneIds_.setSize(s, zoneToc_.size() - 1);
 437 }
 438
 439
 440 template<class Face>
 441 void Foam::UnsortedMeshedSurface<Face>::clear()
 442 {
 443     ParentType::clear();
 444     zoneIds_.clear();
 445     zoneToc_.clear();
 446 }
 447
 448
 449 template<class Face>
 450 Foam::surfZoneList Foam::UnsortedMeshedSurface<Face>::sortedZones
 451 (
 452     labelList& faceMap
 453 ) const
 454 {
 455     // supply some zone names
 456     Map<word> zoneNames;
 457     forAll(zoneToc_, zoneI)
 458     {
 459         zoneNames.insert(zoneI, zoneToc_[zoneI].name());
 460     }
 461
 462     // std::sort() really seems to mix up the order.
 463     // and std::stable_sort() might take too long / too much memory
 464
 465     // Assuming that we have relatively fewer zones compared to the
 466     // number of items, just do it ourselves
 467
 468     // step 1: get zone sizes and store (origId => zoneI)
 469     Map<label> lookup;
 470     forAll(zoneIds_, faceI)
 471     {
 472         const label origId = zoneIds_[faceI];
 473
 474         Map<label>::iterator fnd = lookup.find(origId);
 475         if (fnd != lookup.end())
 476         {
 477             fnd()++;
 478         }
 479         else
 480         {
 481             lookup.insert(origId, 1);
 482         }
 483     }
 484
 485     // step 2: assign start/size (and name) to the newZones
 486     // re-use the lookup to map (zoneId => zoneI)
 487     surfZoneList zoneLst(lookup.size());
 488     label start = 0;
 489     label zoneI = 0;
 490     forAllIter(Map<label>, lookup, iter)
 491     {
 492         label origId = iter.key();
 493
 494         word name;
 495         Map<word>::const_iterator fnd = zoneNames.find(origId);
 496         if (fnd != zoneNames.end())
 497         {
 498             name = fnd();
 499         }
 500         else
 501         {
 502             name = word("zone") + ::Foam::name(zoneI);
 503         }
 504
 505         zoneLst[zoneI] = surfZone
 506         (
 507             name,
 508             0,           // initialize with zero size
 509             start,
 510             zoneI
 511         );
 512
 513         // increment the start for the next zone
 514         // and save the (zoneId => zoneI) mapping
 515         start += iter();
 516         iter() = zoneI++;
 517     }
 518
 519
 520     // step 3: build the re-ordering
 521     faceMap.setSize(zoneIds_.size());
 522
 523     forAll(zoneIds_, faceI)
 524     {
 525         label zoneI = lookup[zoneIds_[faceI]];
 526         faceMap[faceI] = zoneLst[zoneI].start() + zoneLst[zoneI].size()++;
 527     }
 528
 529     // with reordered faces registered in faceMap
 530     return zoneLst;
 531 }
 532
 533
 534 template<class Face>
 535 Foam::UnsortedMeshedSurface<Face>
 536 Foam::UnsortedMeshedSurface<Face>::subsetMesh
 537 (
 538     const labelHashSet& include,
 539     labelList& pointMap,
 540     labelList& faceMap
 541 ) const
 542 {
 543     const pointField&  locPoints = this->localPoints();
 544     const List<Face>&  locFaces  = this->localFaces();
 545
 546     // Fill pointMap, faceMap
 547     PatchTools::subsetMap(*this, include, pointMap, faceMap);
 548
 549     // Create compact coordinate list and forward mapping array
 550     pointField newPoints(pointMap.size());
 551     labelList  oldToNew(locPoints.size());
 552     forAll(pointMap, pointI)
 553     {
 554         newPoints[pointI] = locPoints[pointMap[pointI]];
 555         oldToNew[pointMap[pointI]] = pointI;
 556     }
 557
 558     // Renumber face node labels and compact
 559     List<Face>  newFaces(faceMap.size());
 560     List<label> newZones(faceMap.size());
 561
 562     forAll(faceMap, faceI)
 563     {
 564         const label origFaceI = faceMap[faceI];
 565         newFaces[faceI] = Face(locFaces[origFaceI]);
 566
 567         // Renumber labels for face
 568         Face& f = newFaces[faceI];
 569         forAll(f, fp)
 570         {
 571             f[fp] = oldToNew[f[fp]];
 572         }
 573
 574         newZones[faceI] = zoneIds_[origFaceI];
 575     }
 576     oldToNew.clear();
 577
 578     // construct a sub-surface
 579     return UnsortedMeshedSurface
 580     (
 581         xferMove(newPoints),
 582         xferMove(newFaces),
 583         xferMove(newZones),
 584         xferCopy(zoneToc_)
 585     );
 586 }
 587
 588
 589 template<class Face>
 590 Foam::UnsortedMeshedSurface<Face> Foam::UnsortedMeshedSurface<Face>::subsetMesh
 591 (
 592     const labelHashSet& include
 593 ) const
 594 {
 595     labelList pointMap, faceMap;
 596     return subsetMesh(include, pointMap, faceMap);
 597 }
 598
 599
 600 template<class Face>
 601 void Foam::UnsortedMeshedSurface<Face>::reset
 602 (
 603     const Xfer<pointField>& pointLst,
 604     const Xfer<List<Face> >& faceLst,
 605     const Xfer<List<label> >& zoneIds
 606 )
 607 {
 608     ParentType::reset
 609     (
 610         pointLst,
 611         faceLst,
 612         Xfer<surfZoneList>()
 613     );
 614
 615     if (&zoneIds)
 616     {
 617         zoneIds_.transfer(zoneIds());
 618     }
 619 }
 620
 621
 622 template<class Face>
 623 void Foam::UnsortedMeshedSurface<Face>::reset
 624 (
 625     const Xfer<List<point> >& pointLst,
 626     const Xfer<List<Face> >& faceLst,
 627     const Xfer<List<label> >& zoneIds
 628 )
 629 {
 630     ParentType::reset
 631     (
 632         pointLst,
 633         faceLst,
 634         Xfer<surfZoneList>()
 635     );
 636
 637     if (&zoneIds)
 638     {
 639         zoneIds_.transfer(zoneIds());
 640     }
 641 }
 642
 643
 644 template<class Face>
 645 void Foam::UnsortedMeshedSurface<Face>::transfer
 646 (
 647     UnsortedMeshedSurface<Face>& surf
 648 )
 649 {
 650     ParentType::reset
 651     (
 652         xferMove(surf.storedPoints()),
 653         xferMove(surf.storedFaces()),
 654         Xfer<surfZoneList>()
 655     );
 656
 657     zoneIds_.transfer(surf.zoneIds_);
 658     zoneToc_.transfer(surf.zoneToc_);
 659
 660     surf.clear();
 661 }
 662
 663
 664 template<class Face>
 665 void Foam::UnsortedMeshedSurface<Face>::transfer
 666 (
 667     MeshedSurface<Face>& surf
 668 )
 669 {
 670     ParentType::reset
 671     (
 672         xferMove(surf.storedPoints()),
 673         xferMove(surf.storedFaces()),
 674         Xfer<surfZoneList>()
 675     );
 676
 677     setZones(surf.surfZones());
 678     surf.clear();
 679 }
 680
 681
 682 template<class Face>
 683 Foam::Xfer<Foam::UnsortedMeshedSurface<Face> >
 684 Foam::UnsortedMeshedSurface<Face>::xfer()
 685 {
 686     return xferMove(*this);
 687 }
 688
 689
 690 // Read from file, determine format from extension
 691 template<class Face>
 692 bool Foam::UnsortedMeshedSurface<Face>::read(const fileName& name)
 693 {
 694     word ext = name.ext();
 695     if (ext == "gz")
 696     {
 697         fileName unzipName = name.lessExt();
 698         return read(unzipName, unzipName.ext());
 699     }
 700     else
 701     {
 702         return read(name, ext);
 703     }
 704 }
 705
 706
 707 // Read from file in given format
 708 template<class Face>
 709 bool Foam::UnsortedMeshedSurface<Face>::read
 710 (
 711     const fileName& name,
 712     const word& ext
 713 )
 714 {
 715     clear();
 716
 717     // read via use selector mechanism
 718     transfer(New(name, ext)());
 719     return true;
 720 }
 721
 722
 723 template<class Face>
 724 void Foam::UnsortedMeshedSurface<Face>::write
 725 (
 726     const Time& t,
 727     const word& surfName
 728 ) const
 729 {
 730     MeshedSurfaceProxy<Face>(*this).write(t, surfName);
 731 }
 732
 733
 734 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 735
 736 template<class Face>
 737 void Foam::UnsortedMeshedSurface<Face>::operator=
 738 (
 739     const UnsortedMeshedSurface<Face>& surf
 740 )
 741 {
 742     clear();
 743
 744     this->storedPoints() = surf.points();
 745     this->storedFaces()  = surf.faces();
 746     zoneIds_ = surf.zoneIds_;
 747     zoneToc_ = surf.zoneToc_;
 748 }
 749
 750
 751 template<class Face>
 752 Foam::UnsortedMeshedSurface<Face>::operator
 753 Foam::MeshedSurfaceProxy<Face>() const
 754 {
 755     labelList faceMap;
 756     List<surfZone> zoneLst = this->sortedZones(faceMap);
 757
 758     return MeshedSurfaceProxy<Face>
 759     (
 760         this->points(),
 761         this->faces(),
 762         zoneLst,
 763         faceMap
 764     );
 765 }
 766
 767
 768 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 769
 770 #include "UnsortedMeshedSurfaceNew.C"
 771
 772 // ************************************************************************* //