src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupleMap.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 Class
  26     coupleMap
  27
  28 Description
  29     Implementation of the coupleMap class
  30
  31 Author
  32     Sandeep Menon
  33     University of Massachusetts Amherst
  34     All rights reserved
  35
  36 \*---------------------------------------------------------------------------*/
  37
  38 #include "coupleMap.H"
  39 #include "boolList.H"
  40 #include "demandDrivenData.H"
  41
  42 namespace Foam
  43 {
  44
  45 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  46
  47 const char* coupleMap::names[coupleMap::INVALID + 1] =
  48 {
  49     "BISECTION",
  50     "COLLAPSE_FIRST",
  51     "COLLAPSE_SECOND",
  52     "COLLAPSE_MIDPOINT",
  53     "REMOVE_CELL",
  54     "MOVE_POINT",
  55     "CONVERT_PATCH",
  56     "INVALID"
  57 };
  58
  59 // * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * * //
  60
  61 const char* coupleMap::asText(const opType oType)
  62 {
  63     return names[oType];
  64 }
  65
  66 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  67
  68 coupleMap::coupleMap
  69 (
  70     const IOobject& io,
  71     const bool twoDMesh,
  72     const bool isLocal,
  73     const bool isSend,
  74     const label patchIndex,
  75     const label masterIndex,
  76     const label slaveIndex
  77 )
  78 :
  79     regIOobject(io),
  80     twoDMesh_(twoDMesh),
  81     isLocal_(isLocal),
  82     isSend_(isSend),
  83     patchIndex_(patchIndex),
  84     masterIndex_(masterIndex),
  85     slaveIndex_(slaveIndex),
  86     nEntities_(-1),
  87     edgesPtr_(NULL),
  88     facesPtr_(NULL),
  89     faceEdgesPtr_(NULL)
  90 {
  91     if
  92     (
  93         (io.readOpt() == IOobject::MUST_READ)
  94      || (io.readOpt() == IOobject::READ_IF_PRESENT && headerOk())
  95     )
  96     {
  97         // Construct an Istream and read from disk.
  98         readData(readStream(typeName));
  99         close();
 100     }
 101 }
 102
 103
 104 // Construct as copy
 105 coupleMap::coupleMap(const coupleMap& cm)
 106 :
 107     regIOobject(cm, true),
 108     twoDMesh_(cm.twoDMesh_),
 109     isLocal_(cm.isLocal_),
 110     isSend_(cm.isSend_),
 111     patchIndex_(cm.patchIndex_),
 112     masterIndex_(cm.masterIndex_),
 113     slaveIndex_(cm.slaveIndex_),
 114     nEntities_(cm.nEntities_),
 115     edgesPtr_(NULL),
 116     facesPtr_(NULL),
 117     faceEdgesPtr_(NULL)
 118 {
 119     if
 120     (
 121         (cm.readOpt() == IOobject::MUST_READ)
 122      || (cm.readOpt() == IOobject::READ_IF_PRESENT && headerOk())
 123     )
 124     {
 125         // Construct an Istream and read from disk.
 126         readData(readStream(typeName));
 127         close();
 128     }
 129 }
 130
 131
 132 // * * * * * * * * * * * * * * * * Destructors * * * * * * * * * * * * * * * //
 133
 134 coupleMap::~coupleMap()
 135 {
 136     clearMaps();
 137     clearBuffers();
 138     clearAddressing();
 139 }
 140
 141
 142 // * * * * * * * * * * * * * * * Private Functions * * * * * * * * * * * * * //
 143
 144 void coupleMap::clearAddressing() const
 145 {
 146     deleteDemandDrivenData(edgesPtr_);
 147     deleteDemandDrivenData(facesPtr_);
 148     deleteDemandDrivenData(faceEdgesPtr_);
 149 }
 150
 151
 152 void coupleMap::makeEdges() const
 153 {
 154     // It is an error to attempt to recalculate
 155     // if the pointer is already set
 156     if (edgesPtr_)
 157     {
 158         FatalErrorIn("void coupleMap::makeEdges() const")
 159             << "Edges have already been calculated."
 160             << abort(FatalError);
 161     }
 162
 163     label nEdges = nEntities(coupleMap::EDGE);
 164     const labelList& eBuffer = entityBuffer(coupleMap::EDGE);
 165
 166     edgesPtr_ = new edgeList(nEdges);
 167
 168     edgeList& edges = *edgesPtr_;
 169
 170     forAll(edges, edgeI)
 171     {
 172         edges[edgeI][0] = eBuffer[(2*edgeI)+0];
 173         edges[edgeI][1] = eBuffer[(2*edgeI)+1];
 174     }
 175 }
 176
 177
 178 void coupleMap::makeFaces() const
 179 {
 180     // It is an error to attempt to recalculate
 181     // if the pointer is already set
 182     if (facesPtr_ || faceEdgesPtr_)
 183     {
 184         FatalErrorIn("void coupleMap::makeFaces() const")
 185             << "Faces have already been calculated."
 186             << abort(FatalError);
 187     }
 188
 189     label nFaces = nEntities(coupleMap::FACE);
 190
 191     const labelList& fBuffer = entityBuffer(coupleMap::FACE);
 192     const labelList& feBuffer = entityBuffer(coupleMap::FACE_EDGE);
 193     const labelList& nfeBuffer = entityBuffer(coupleMap::NFE_BUFFER);
 194
 195     facesPtr_ = new faceList(nFaces);
 196     faceEdgesPtr_ = new labelListList(nFaces);
 197
 198     faceList& faces = *facesPtr_;
 199     labelListList& faceEdges = *faceEdgesPtr_;
 200
 201     label sumNFE = 0;
 202
 203     forAll(faces, faceI)
 204     {
 205         face& f = faces[faceI];
 206         labelList& fe = faceEdges[faceI];
 207
 208         // Fetch the buffer value for 2D meshes
 209         label nfe = twoDMesh_ ? nfeBuffer[faceI] : 3;
 210
 211         // Size up the lists
 212         f.setSize(nfe, -1);
 213         fe.setSize(nfe, -1);
 214
 215         for (label p = 0; p < nfe; p++)
 216         {
 217             f[p] = fBuffer[sumNFE + p];
 218             fe[p] = feBuffer[sumNFE + p];
 219         }
 220
 221         sumNFE += nfe;
 222     }
 223
 224     if (sumNFE != nEntities(coupleMap::NFE_SIZE))
 225     {
 226         FatalErrorIn("void coupleMap::makeFaces() const")
 227             << " Mismatched buffer." << nl
 228             << " sumNFE: " << sumNFE << nl
 229             << " NFE_SIZE: " << nEntities(coupleMap::NFE_SIZE) << nl
 230             << abort(FatalError);
 231     }
 232 }
 233
 234
 235 void coupleMap::makeFaceMap() const
 236 {
 237     // It is an error to attempt to recalculate
 238     // if the map is already calculated
 239     if (faceMap_.size())
 240     {
 241         FatalErrorIn("void coupleMap::makeFaceMap() const")
 242             << "faceMap has already been calculated."
 243             << abort(FatalError);
 244     }
 245
 246     const Map<label>& mapFaces = entityMap(coupleMap::FACE);
 247
 248     // Size the list
 249     faceMap_.setSize(mapFaces.size(), -1);
 250
 251     // Fill-in entries
 252     forAllConstIter(Map<label>, mapFaces, fIter)
 253     {
 254         faceMap_[fIter.key()] = fIter();
 255     }
 256 }
 257
 258
 259 void coupleMap::makeCellMap() const
 260 {
 261     // It is an error to attempt to recalculate
 262     // if the map is already calculated
 263     if (cellMap_.size())
 264     {
 265         FatalErrorIn("void coupleMap::makeCellMap() const")
 266             << "cellMap has already been calculated."
 267             << abort(FatalError);
 268     }
 269
 270     const Map<label>& mapCells = entityMap(coupleMap::CELL);
 271
 272     // Size the list
 273     cellMap_.setSize(mapCells.size(), -1);
 274
 275     // Fill-in entries
 276     forAllConstIter(Map<label>, mapCells, cIter)
 277     {
 278         cellMap_[cIter.key()] = cIter();
 279     }
 280 }
 281
 282
 283 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 284
 285 pointField& coupleMap::pointBuffer() const
 286 {
 287     return pointBuffer_;
 288 }
 289
 290
 291 pointField& coupleMap::oldPointBuffer() const
 292 {
 293     return oldPointBuffer_;
 294 }
 295
 296
 297 labelList& coupleMap::subMeshPoints() const
 298 {
 299     return subMeshPoints_;
 300 }
 301
 302
 303 List<labelPair>& coupleMap::globalProcPoints() const
 304 {
 305     return globalProcPoints_;
 306 }
 307
 308
 309 void coupleMap::allocateBuffers() const
 310 {
 311     forAll(nEntities_, entityI)
 312     {
 313         if (nEntities_[entityI] < 0)
 314         {
 315             FatalErrorIn("void coupleMap::allocateBuffers() const")
 316                 << " Entity sizes are not valid." << nl
 317                 << " nEntities: " << nEntities_
 318                 << abort(FatalError);
 319         }
 320     }
 321
 322     // Size up point buffers
 323     pointBuffer().setSize(nEntities(POINT));
 324     oldPointBuffer().setSize(nEntities(POINT));
 325
 326     // Size up connectivity buffers
 327     entityBuffer(POINT).setSize
 328     (
 329         nEntities(GLOBAL_POINT)
 330       - nEntities(SHARED_POINT)
 331     );
 332
 333     // Set edge buffer
 334     entityBuffer(EDGE).setSize(2 * nEntities(EDGE));
 335
 336     // Set addressing buffers
 337     entityBuffer(OWNER).setSize(nEntities(FACE));
 338     entityBuffer(NEIGHBOUR).setSize(nEntities(INTERNAL_FACE));
 339
 340     // Size up boundary buffers
 341     entityBuffer(FACE_STARTS).setSize(nEntities(NBDY));
 342     entityBuffer(FACE_SIZES).setSize(nEntities(NBDY));
 343     entityBuffer(EDGE_STARTS).setSize(nEntities(NBDY));
 344     entityBuffer(EDGE_SIZES).setSize(nEntities(NBDY));
 345     entityBuffer(PATCH_ID).setSize(nEntities(NBDY));
 346
 347     // nFaceEdges buffer is required only for 2D,
 348     // due to a mix of triangle / quad faces
 349     if (twoDMesh_)
 350     {
 351         entityBuffer(NFE_BUFFER).setSize(nEntities(FACE));
 352     }
 353
 354     // Allocate for variable size face-lists
 355     entityBuffer(FACE).setSize(nEntities(NFE_SIZE));
 356     entityBuffer(FACE_EDGE).setSize(nEntities(NFE_SIZE));
 357 }
 358
 359
 360 label coupleMap::findSlave
 361 (
 362     const label eType,
 363     const label Index
 364 ) const
 365 {
 366     Map<label>::const_iterator it = entityMap_[eType].find(Index);
 367
 368     if (it == entityMap_[eType].end())
 369     {
 370         return -1;
 371     }
 372     else
 373     {
 374         return it();
 375     }
 376 }
 377
 378
 379 label coupleMap::findMaster
 380 (
 381     const label eType,
 382     const label Index
 383 ) const
 384 {
 385     Map<label>::const_iterator it = reverseEntityMap_[eType].find(Index);
 386
 387     if (it == reverseEntityMap_[eType].end())
 388     {
 389         return -1;
 390     }
 391     else
 392     {
 393         return it();
 394     }
 395 }
 396
 397
 398 void coupleMap::removeSlave
 399 (
 400     const label eType,
 401     const label Index
 402 ) const
 403 {
 404     Map<label>::iterator it = reverseEntityMap_[eType].find(Index);
 405
 406     if (it != reverseEntityMap_[eType].end())
 407     {
 408         reverseEntityMap_[eType].erase(it);
 409     }
 410 }
 411
 412
 413 void coupleMap::removeMaster
 414 (
 415     const label eType,
 416     const label Index
 417 ) const
 418 {
 419     Map<label>::iterator it = entityMap_[eType].find(Index);
 420
 421     if (it != entityMap_[eType].end())
 422     {
 423         entityMap_[eType].erase(it);
 424     }
 425 }
 426
 427
 428 void coupleMap::mapSlave
 429 (
 430     const label eType,
 431     const label master,
 432     const label slave
 433 ) const
 434 {
 435     entityMap_[eType].set(master, slave);
 436 }
 437
 438
 439 void coupleMap::mapMaster
 440 (
 441     const label eType,
 442     const label slave,
 443     const label master
 444 ) const
 445 {
 446     reverseEntityMap_[eType].set(slave, master);
 447 }
 448
 449
 450 void coupleMap::pushOperation
 451 (
 452     const label index,
 453     const opType oType,
 454     const point& newPoint,
 455     const point& oldPoint
 456 ) const
 457 {
 458     entityIndices_.setSize(entityIndices_.size() + 1, index);
 459     entityOperations_.setSize(entityOperations_.size() + 1, oType);
 460
 461     if
 462     (
 463         oType == coupleMap::MOVE_POINT ||
 464         oType == coupleMap::CONVERT_PATCH
 465     )
 466     {
 467         moveNewPoints_.setSize(moveNewPoints_.size() + 1, newPoint);
 468         moveOldPoints_.setSize(moveOldPoints_.size() + 1, oldPoint);
 469     }
 470 }
 471
 472
 473 void coupleMap::transferMaps
 474 (
 475     const label eType,
 476     Map<label>& newEntityMap,
 477     Map<label>& newReverseEntityMap
 478 ) const
 479 {
 480     entityMap_[eType].transfer(newEntityMap);
 481     reverseEntityMap_[eType].transfer(newReverseEntityMap);
 482 }
 483
 484
 485 void coupleMap::clearMaps() const
 486 {
 487     faceMap_.clear();
 488     cellMap_.clear();
 489
 490     forAll(entityMap_, mapI)
 491     {
 492         entityMap_[mapI].clear();
 493         reverseEntityMap_[mapI].clear();
 494     }
 495 }
 496
 497
 498 void coupleMap::clearBuffers() const
 499 {
 500     pointBuffer_.clear();
 501     oldPointBuffer_.clear();
 502
 503     subMeshPoints_.clear();
 504     globalProcPoints_.clear();
 505
 506     forAll(entityBuffer_, bufferI)
 507     {
 508         entityBuffer_[bufferI].clear();
 509     }
 510
 511     entityIndices_.clear();
 512     entityOperations_.clear();
 513
 514     moveNewPoints_.clear();
 515     moveOldPoints_.clear();
 516 }
 517
 518
 519 label coupleMap::nInternalFaces() const
 520 {
 521     return nEntities(INTERNAL_FACE);
 522 }
 523
 524
 525 const labelList& coupleMap::owner() const
 526 {
 527     return entityBuffer(OWNER);
 528 }
 529
 530
 531 const labelList& coupleMap::neighbour() const
 532 {
 533     return entityBuffer(NEIGHBOUR);
 534 }
 535
 536
 537 const edgeList& coupleMap::edges() const
 538 {
 539     if (!edgesPtr_)
 540     {
 541         makeEdges();
 542     }
 543
 544     return *edgesPtr_;
 545 }
 546
 547
 548 const faceList& coupleMap::faces() const
 549 {
 550     if (!facesPtr_)
 551     {
 552         makeFaces();
 553     }
 554
 555     return *facesPtr_;
 556 }
 557
 558
 559 const labelListList& coupleMap::faceEdges() const
 560 {
 561     if (!faceEdgesPtr_)
 562     {
 563         makeFaces();
 564     }
 565
 566     return *faceEdgesPtr_;
 567 }
 568
 569
 570 const labelList& coupleMap::faceMap() const
 571 {
 572     if (faceMap_.empty())
 573     {
 574         makeFaceMap();
 575     }
 576
 577     return faceMap_;
 578 }
 579
 580
 581 const labelList& coupleMap::cellMap() const
 582 {
 583     if (cellMap_.empty())
 584     {
 585         makeCellMap();
 586     }
 587
 588     return cellMap_;
 589 }
 590
 591
 592 bool coupleMap::readData(Istream& is)
 593 {
 594     Map<label> tmpMap(is);
 595
 596     entityMap(coupleMap::POINT).transfer(tmpMap);
 597
 598     // Prepare the reversePointMap as well.
 599     const Map<label>& pMap = entityMap(coupleMap::POINT);
 600     Map<label>& rpMap = reverseEntityMap(coupleMap::POINT);
 601
 602     forAllConstIter(Map<label>, pMap, pIter)
 603     {
 604         rpMap.set(pIter(), pIter.key());
 605     }
 606
 607     return !is.bad();
 608 }
 609
 610
 611 bool coupleMap::writeData(Ostream& os) const
 612 {
 613     // Only write-out point-map information
 614     // to avoid geometric checking.
 615     // The rest can be constructed topologically.
 616     return (os << entityMap(coupleMap::POINT)).good();;
 617 }
 618
 619
 620 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 621
 622 void coupleMap::operator=(const coupleMap& rhs)
 623 {
 624     // Check for assignment to self
 625     if (this == &rhs)
 626     {
 627         FatalErrorIn("coupleMap::operator=(const coupleMap&)")
 628             << "Attempted assignment to self"
 629             << abort(FatalError);
 630     }
 631 }
 632
 633
 634 } // End namespace Foam
 635
 636 // ************************************************************************* //