src/meshTools/sets/topoSets/topoSet.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright held by original author
   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 the
  13     Free Software Foundation; either version 2 of the License, or (at your
  14     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, write to the Free Software Foundation,
  23     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  24
  25 \*---------------------------------------------------------------------------*/
  26
  27 #include "topoSet.H"
  28 #include "mapPolyMesh.H"
  29 #include "polyMesh.H"
  30 #include "boundBox.H"
  31
  32 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  33
  34 namespace Foam
  35 {
  36
  37 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  38
  39 defineTypeNameAndDebug(topoSet, 0);
  40 defineRunTimeSelectionTable(topoSet, word);
  41 defineRunTimeSelectionTable(topoSet, size);
  42 defineRunTimeSelectionTable(topoSet, set);
  43
  44
  45 // Construct named object from existing set.
  46 autoPtr<topoSet> topoSet::New
  47 (
  48     const word& setType,
  49     const polyMesh& mesh,
  50     const word& name,
  51     readOption r,
  52     writeOption w
  53 )
  54 {
  55     wordConstructorTable::iterator cstrIter =
  56         wordConstructorTablePtr_->find(setType);
  57
  58     if (cstrIter == wordConstructorTablePtr_->end())
  59     {
  60         FatalErrorIn
  61         (
  62             "topoSet::New(const word&, "
  63             "const polyMesh&, const word&, readOption, writeOption)"
  64         )   << "Unknown set type " << setType
  65             << endl << endl
  66             << "Valid set types : " << endl
  67             << wordConstructorTablePtr_->toc()
  68             << exit(FatalError);
  69     }
  70
  71     return autoPtr<topoSet>(cstrIter()(mesh, name, r, w));
  72 }
  73
  74
  75 // Construct named object from size (non-existing set).
  76 autoPtr<topoSet> topoSet::New
  77 (
  78     const word& setType,
  79     const polyMesh& mesh,
  80     const word& name,
  81     const label size,
  82     writeOption w
  83 )
  84 {
  85     sizeConstructorTable::iterator cstrIter =
  86         sizeConstructorTablePtr_->find(setType);
  87
  88     if (cstrIter == sizeConstructorTablePtr_->end())
  89     {
  90         FatalErrorIn
  91         (
  92             "topoSet::New(const word&, "
  93             "const polyMesh&, const word&, const label, writeOption)"
  94         )   << "Unknown set type " << setType
  95             << endl << endl
  96             << "Valid set types : " << endl
  97             << sizeConstructorTablePtr_->toc()
  98             << exit(FatalError);
  99     }
 100
 101     return autoPtr<topoSet>(cstrIter()(mesh, name, size, w));
 102 }
 103
 104
 105 // Construct named object from existing set.
 106 autoPtr<topoSet> topoSet::New
 107 (
 108     const polyMesh& mesh,
 109     const word& name,
 110     const topoSet& set,
 111     writeOption w
 112 )
 113 {
 114     setConstructorTable::iterator cstrIter =
 115         setConstructorTablePtr_->find(set.type());
 116
 117     if (cstrIter == setConstructorTablePtr_->end())
 118     {
 119         FatalErrorIn
 120         (
 121             "topoSet::New(const polyMesh&, const word&, "
 122             "const topoSet&, writeOption)"
 123         )   << "Unknown set type " << set.type()
 124             << endl << endl
 125             << "Valid set types : " << endl
 126             << setConstructorTablePtr_->toc()
 127             << exit(FatalError);
 128     }
 129
 130     return autoPtr<topoSet>(cstrIter()(mesh, name, set, w));
 131 }
 132
 133
 134 Foam::fileName topoSet::topoSet::localPath
 135 (
 136     const polyMesh& mesh,
 137     const word& name
 138 )
 139 {
 140     return mesh.pointsInstance()/polyMesh::meshSubDir/"sets"/name;
 141 }
 142
 143
 144 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 145
 146 // Update stored cell numbers using map.
 147 // Do in two passes to prevent allocation if nothing changed.
 148 void topoSet::topoSet::updateLabels(const labelList& map)
 149 {
 150     // Iterate over map to see if anything changed
 151     bool changed = false;
 152
 153     for
 154     (
 155         labelHashSet::const_iterator iter = begin();
 156         iter != end();
 157         ++iter
 158     )
 159     {
 160         if ((iter.key() < 0) || (iter.key() > map.size()))
 161         {
 162             FatalErrorIn
 163             (
 164                 "topoSet::updateLabels(const labelList&, labelHashSet)"
 165             )   << "Illegal content " << iter.key() << " of set:" << name()
 166                 << " of type " << type() << endl
 167                 << "Value should be between 0 and " << map.size()-1
 168                 << abort(FatalError);
 169         }
 170
 171         label newCellI = map[iter.key()];
 172
 173         if (newCellI != iter.key())
 174         {
 175             changed = true;
 176
 177             break;
 178         }
 179     }
 180
 181     // Relabel (use second Map to prevent overlapping)
 182     if (changed)
 183     {
 184         labelHashSet newSet(2*size());
 185
 186         for
 187         (
 188             labelHashSet::const_iterator iter = begin();
 189             iter != end();
 190             ++iter
 191         )
 192         {
 193             label newCellI = map[iter.key()];
 194
 195             if (newCellI >= 0)
 196             {
 197                 newSet.insert(newCellI);
 198             }
 199         }
 200
 201         transfer(newSet);
 202     }
 203 }
 204
 205
 206 void topoSet::topoSet::check(const label maxLabel)
 207 {
 208     for
 209     (
 210         topoSet::const_iterator iter = begin();
 211         iter != end();
 212         ++iter
 213     )
 214     {
 215         if ((iter.key() < 0) || (iter.key() > maxLabel))
 216         {
 217             FatalErrorIn("topoSet::check(const label)")
 218                 << "Illegal content " << iter.key() << " of set:" << name()
 219                 << " of type " << type() << endl
 220                 << "Value should be between 0 and " << maxLabel
 221                 << abort(FatalError);
 222         }
 223     }
 224 }
 225
 226
 227 // Write maxElem elements, starting at iter. Updates iter and elemI.
 228 void topoSet::writeDebug
 229 (
 230     Ostream& os,
 231     const label maxElem,
 232     topoSet::const_iterator& iter,
 233     label& elemI
 234 ) const
 235 {
 236     label n = 0;
 237
 238     for (; (iter != end()) && (n < maxElem); ++iter)
 239     {
 240         if ((n != 0) && ((n % 10) == 0))
 241         {
 242             os << endl;
 243         }
 244         os << iter.key() << ' ';
 245
 246         n++;
 247         elemI++;
 248     }
 249 }
 250
 251
 252 // Write maxElem elements, starting at iter. Updates iter and elemI.
 253 void topoSet::writeDebug
 254 (
 255     Ostream& os,
 256     const pointField& coords,
 257     const label maxElem,
 258     topoSet::const_iterator& iter,
 259     label& elemI
 260 ) const
 261 {
 262     label n = 0;
 263
 264     for (; (iter != end()) && (n < maxElem); ++iter)
 265     {
 266         if ((n != 0) && ((n % 3) == 0))
 267         {
 268             os << endl;
 269         }
 270         os << iter.key() << coords[iter.key()] << ' ';
 271
 272         n++;
 273         elemI++;
 274     }
 275 }
 276
 277
 278 void topoSet::writeDebug
 279 (
 280     Ostream& os,
 281     const pointField& coords,
 282     const label maxLen
 283 ) const
 284 {
 285     // Bounding box of contents.
 286     boundBox bb(pointField(coords, toc()), true);
 287
 288     os  << "Set bounding box: min = "
 289         << bb.min() << "    max = " << bb.max() << " meters. " << endl << endl;
 290
 291     label n = 0;
 292
 293     topoSet::const_iterator iter = begin();
 294
 295     if (size() <= maxLen)
 296     {
 297         writeDebug(os, coords, maxLen, iter, n);
 298     }
 299     else
 300     {
 301         label halfLen = maxLen/2;
 302
 303         os  << "Size larger than " << maxLen << ". Printing first and last "
 304             << halfLen << " elements:" << endl << endl;
 305
 306         writeDebug(os, coords, halfLen, iter, n);
 307
 308         os<< endl
 309           << "  .." << endl
 310           << endl;
 311
 312         for (; n < size() - halfLen; ++n)
 313         {
 314             ++iter;
 315         }
 316
 317         writeDebug(os, coords, halfLen, iter, n);
 318     }
 319 }
 320
 321
 322 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 323
 324 topoSet::topoSet(const IOobject& obj, const word& wantedType)
 325 :
 326     regIOobject(obj)
 327 {
 328     if
 329     (
 330         readOpt() == IOobject::MUST_READ
 331      || (
 332             readOpt() == IOobject::READ_IF_PRESENT
 333          && headerOk()
 334         )
 335     )
 336     {
 337         if (readStream(wantedType).good())
 338         {
 339             readStream(wantedType) >> static_cast<labelHashSet&>(*this);
 340
 341             close();
 342         }
 343     }
 344 }
 345
 346
 347 topoSet::topoSet
 348 (
 349     const polyMesh& mesh,
 350     const word& wantedType,
 351     const word& name,
 352     readOption r,
 353     writeOption w
 354 )
 355 :
 356     regIOobject
 357     (
 358         IOobject
 359         (
 360             name,
 361             mesh.pointsInstance(),
 362             polyMesh::meshSubDir/"sets",
 363             mesh,
 364             r,
 365             w
 366         )
 367     )
 368 {
 369     if
 370     (
 371         readOpt() == IOobject::MUST_READ
 372      || (
 373             readOpt() == IOobject::READ_IF_PRESENT
 374          && headerOk()
 375         )
 376     )
 377     {
 378         if (readStream(wantedType).good())
 379         {
 380             readStream(wantedType) >> static_cast<labelHashSet&>(*this);
 381
 382             close();
 383         }
 384     }
 385 }
 386
 387
 388 topoSet::topoSet
 389 (
 390     const polyMesh& mesh,
 391     const word& name,
 392     const label size,
 393     writeOption w
 394 )
 395 :
 396     regIOobject
 397     (
 398         IOobject
 399         (
 400             name,
 401             mesh.pointsInstance(),
 402             polyMesh::meshSubDir/"sets",
 403             mesh,
 404             NO_READ,
 405             w
 406         )
 407     ),
 408     labelHashSet(size)
 409 {}
 410
 411
 412 topoSet::topoSet
 413 (
 414     const polyMesh& mesh,
 415     const word& name,
 416     const labelHashSet& set,
 417     writeOption w
 418 )
 419 :
 420     regIOobject
 421     (
 422         IOobject
 423         (
 424             name,
 425             mesh.pointsInstance(),
 426             polyMesh::meshSubDir/"sets",
 427             mesh,
 428             NO_READ,
 429             w
 430         )
 431     ),
 432     labelHashSet(set)
 433 {}
 434
 435
 436 topoSet::topoSet(const IOobject& obj, const label size)
 437 :
 438     regIOobject(obj),
 439     labelHashSet(size)
 440 {}
 441
 442
 443 topoSet::topoSet(const IOobject& obj, const labelHashSet& set)
 444 :
 445     regIOobject(obj),
 446     labelHashSet(set)
 447 {}
 448
 449
 450
 451 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 452
 453 topoSet::~topoSet()
 454 {}
 455
 456
 457 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 458
 459 void topoSet::invert(const label maxLen)
 460 {
 461     // Keep copy of current set.
 462     labelHashSet currentSet(*this);
 463
 464     clear();
 465     resize(2*(maxLen - currentSet.size()));
 466
 467     for (label cellI = 0; cellI < maxLen; cellI++)
 468     {
 469         if (!currentSet.found(cellI))
 470         {
 471             insert(cellI);
 472         }
 473     }
 474
 475 }
 476
 477
 478 void topoSet::subset(const topoSet& set)
 479 {
 480     // Keep copy of current set.
 481     labelHashSet currentSet(*this);
 482
 483     clear();
 484     resize(2*min(currentSet.size(), set.size()));
 485
 486     for
 487     (
 488         labelHashSet::const_iterator iter = currentSet.begin();
 489         iter != currentSet.end();
 490         ++iter
 491     )
 492     {
 493         if (set.found(iter.key()))
 494         {
 495             // element present in both currentSet and set.
 496             insert(iter.key());
 497         }
 498     }
 499 }
 500
 501
 502 void topoSet::addSet(const topoSet& set)
 503 {
 504     for
 505     (
 506         topoSet::const_iterator iter = set.begin();
 507         iter != set.end();
 508         ++iter
 509     )
 510     {
 511         insert(iter.key());
 512     }
 513 }
 514
 515
 516 void topoSet::deleteSet(const topoSet& set)
 517 {
 518     for
 519     (
 520         topoSet::const_iterator iter = set.begin();
 521         iter != set.end();
 522         ++iter
 523     )
 524     {
 525         erase(iter.key());
 526     }
 527 }
 528
 529
 530 void topoSet::sync(const polyMesh&)
 531 {
 532     notImplemented("topoSet::sync(const polyMesh&)");
 533 }
 534
 535
 536 void topoSet::writeDebug(Ostream& os, const label maxLen) const
 537 {
 538     label n = 0;
 539
 540     topoSet::const_iterator iter = begin();
 541
 542     if (size() <= maxLen)
 543     {
 544         writeDebug(os, maxLen, iter, n);
 545     }
 546     else
 547     {
 548         label halfLen = maxLen/2;
 549
 550         os  << "Size larger than " << maxLen << ". Printing first and last "
 551             << halfLen << " elements:" << endl << endl;
 552
 553         writeDebug(os, halfLen, iter, n);
 554
 555         os<< endl
 556           << "  .." << endl
 557           << endl;
 558
 559         for (; n < size() - halfLen; ++n)
 560         {
 561             ++iter;
 562         }
 563
 564         writeDebug(os, halfLen, iter, n);
 565     }
 566 }
 567
 568
 569 void topoSet::writeDebug
 570 (
 571     Ostream&,
 572     const primitiveMesh&,
 573     const label
 574 ) const
 575 {
 576     notImplemented
 577     (
 578         "topoSet::writeDebug(Ostream&, const primitiveMesh&, const label)"
 579     );
 580 }
 581
 582
 583 bool topoSet::writeData(Ostream& os) const
 584 {
 585     return (os << *this).good();
 586 }
 587
 588
 589 void topoSet::updateMesh(const mapPolyMesh&)
 590 {
 591     notImplemented("topoSet::updateMesh(const mapPolyMesh&)");
 592 }
 593
 594
 595 //- Return max index+1.
 596 label topoSet::maxSize(const polyMesh&) const
 597 {
 598     notImplemented("topoSet::maxSize(const polyMesh&)");
 599
 600     return -1;
 601 }
 602
 603 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 604
 605 void topoSet::operator=(const topoSet& rhs)
 606 {
 607     labelHashSet::operator=(rhs);
 608 }
 609
 610
 611 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 612
 613 } // End namespace Foam
 614
 615 // ************************************************************************* //