src/dynamicMesh/dynamicTopoFvMesh/fieldMapping/topoMapper.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | foam-extend: Open Source CFD
   4    \\    /   O peration     | Version:     3.2
   5     \\  /    A nd           | Web:         http://www.foam-extend.org
   6      \\/     M anipulation  | For copyright notice see file Copyright
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of foam-extend.
  10
  11     foam-extend 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 3 of the License, or (at your
  14     option) any later version.
  15
  16     foam-extend is distributed in the hope that it will be useful, but
  17     WITHOUT ANY WARRANTY; without even the implied warranty of
  18     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19     General Public License for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 Class
  25     topoMapper
  26
  27 Description
  28     Implementation of topoMapper
  29
  30 Author
  31     Sandeep Menon
  32     University of Massachusetts Amherst
  33     All rights reserved
  34
  35 \*----------------------------------------------------------------------------*/
  36
  37 #include "topoMapper.H"
  38 #include "fluxCorrector.H"
  39 #include "topoCellMapper.H"
  40 #include "topoSurfaceMapper.H"
  41 #include "topoBoundaryMeshMapper.H"
  42
  43 namespace Foam
  44 {
  45
  46 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
  47
  48 //- Store gradients prior to mesh reset
  49 void topoMapper::storeGradients() const
  50 {
  51     // Go in order of highest to lowest rank,
  52     // to avoid double storage
  53     storeGradients<vector>(gradTable_, vGradPtrs_);
  54     storeGradients<scalar>(gradTable_, sGradPtrs_);
  55
  56     if (fvMesh::debug)
  57     {
  58         Info<< "Registered gradients: " << gradientTable() << endl;
  59     }
  60 }
  61
  62
  63 //- Store geometric information
  64 void topoMapper::storeGeometry() const
  65 {
  66     typedef volVectorField::PatchFieldType PatchFieldType;
  67     typedef volVectorField::GeometricBoundaryField GeomBdyFieldType;
  68     typedef volVectorField::DimensionedInternalField DimInternalField;
  69
  70     // Wipe out existing information
  71     deleteDemandDrivenData(cellCentresPtr_);
  72
  73     vectorField Cv(mesh_.cellCentres());
  74     vectorField Cf(mesh_.faceCentres());
  75
  76     // Create and map the patch field values
  77     label nPatches = mesh_.boundary().size();
  78
  79     // Create field parts
  80     PtrList<PatchFieldType> volCentrePatches(nPatches);
  81
  82     // Define patch type names
  83     word emptyType("empty");
  84     word fixedValueType("fixedValue");
  85
  86     // Create dummy types for initial field creation
  87     forAll(volCentrePatches, patchI)
  88     {
  89         if (mesh_.boundary()[patchI].type() == emptyType)
  90         {
  91             volCentrePatches.set
  92             (
  93                 patchI,
  94                 PatchFieldType::New
  95                 (
  96                     emptyType,
  97                     mesh_.boundary()[patchI],
  98                     DimInternalField::null()
  99                 )
 100             );
 101         }
 102         else
 103         {
 104             volCentrePatches.set
 105             (
 106                 patchI,
 107                 PatchFieldType::New
 108                 (
 109                     fixedValueType,
 110                     mesh_.boundary()[patchI],
 111                     DimInternalField::null()
 112                 )
 113             );
 114         }
 115     }
 116
 117     // Set the cell-centres pointer.
 118     cellCentresPtr_ =
 119     (
 120         new volVectorField
 121         (
 122             IOobject
 123             (
 124                 "cellCentres",
 125                 mesh_.time().timeName(),
 126                 mesh_,
 127                 IOobject::NO_READ,
 128                 IOobject::NO_WRITE,
 129                 true
 130             ),
 131             mesh_,
 132             dimLength,
 133             SubField<vector>(Cv, mesh_.nCells()),
 134             volCentrePatches
 135         )
 136     );
 137
 138     // Alias for convenience
 139     volVectorField& centres = *cellCentresPtr_;
 140
 141     // Set correct references for patch internal fields
 142     GeomBdyFieldType& bf = centres.boundaryField();
 143
 144     forAll(bf, patchI)
 145     {
 146         if (mesh_.boundary()[patchI].type() == emptyType)
 147         {
 148             bf.set
 149             (
 150                 patchI,
 151                 PatchFieldType::New
 152                 (
 153                     emptyType,
 154                     mesh_.boundary()[patchI],
 155                     centres.dimensionedInternalField()
 156                 )
 157             );
 158         }
 159         else
 160         {
 161             bf.set
 162             (
 163                 patchI,
 164                 PatchFieldType::New
 165                 (
 166                     fixedValueType,
 167                     mesh_.boundary()[patchI],
 168                     centres.dimensionedInternalField()
 169                 )
 170             );
 171
 172             // Slice field to patch (forced assignment)
 173             bf[patchI] == mesh_.boundaryMesh()[patchI].patchSlice(Cf);
 174         }
 175     }
 176
 177     // Set the cell-volumes pointer
 178     cellVolumesPtr_ = new scalarField(mesh_.cellVolumes());
 179 }
 180
 181 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 182
 183 //- Construct from mesh and dictionary
 184 topoMapper::topoMapper
 185 (
 186     const fvMesh& mesh,
 187     const dictionary& dict
 188 )
 189 :
 190     mesh_(mesh),
 191     dict_(dict),
 192     cellMap_(NULL),
 193     surfaceMap_(NULL),
 194     boundaryMap_(NULL),
 195     fluxCorrector_(fluxCorrector::New(mesh, dict)),
 196     cellVolumesPtr_(NULL),
 197     cellCentresPtr_(NULL)
 198 {}
 199
 200
 201 // * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * *  //
 202
 203 topoMapper::~topoMapper()
 204 {
 205     clear();
 206 }
 207
 208 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 209
 210 //- Return reference to the mesh
 211 const fvMesh& topoMapper::mesh() const
 212 {
 213     return mesh_;
 214 }
 215
 216
 217 //- Return reference to objectRegistry storing fields.
 218 const objectRegistry& topoMapper::thisDb() const
 219 {
 220     return mesh_;
 221 }
 222
 223
 224 //- Set mapping information
 225 void topoMapper::setMapper(const mapPolyMesh& mpm) const
 226 {
 227     if
 228     (
 229         cellMap_.valid() ||
 230         surfaceMap_.valid() ||
 231         boundaryMap_.valid()
 232     )
 233     {
 234         FatalErrorIn
 235         (
 236             "void topoMapper::setMapper() const"
 237         ) << nl << " Mapper has already been set. "
 238           << abort(FatalError);
 239     }
 240
 241     // Set pointers
 242     cellMap_.set(new topoCellMapper(mpm, *this));
 243     surfaceMap_.set(new topoSurfaceMapper(mpm, *this));
 244     boundaryMap_.set(new topoBoundaryMeshMapper(mesh(), mpm, *this));
 245 }
 246
 247
 248 //- Set face weighting information
 249 void topoMapper::setFaceWeights
 250 (
 251     const Xfer<List<scalarField> >& weights,
 252     const Xfer<List<vectorField> >& centres
 253 ) const
 254 {
 255     faceWeights_.transfer(weights());
 256     faceCentres_.transfer(centres());
 257 }
 258
 259
 260 //- Set cell weighting information
 261 void topoMapper::setCellWeights
 262 (
 263     const Xfer<List<scalarField> >& weights,
 264     const Xfer<List<vectorField> >& centres
 265 ) const
 266 {
 267     cellWeights_.transfer(weights());
 268     cellCentres_.transfer(centres());
 269 }
 270
 271
 272 //- Set cell / patch offset information
 273 void topoMapper::setOffsets
 274 (
 275     const labelList& cellSizes,
 276     const labelList& cellStarts,
 277     const labelList& faceSizes,
 278     const labelList& faceStarts,
 279     const labelListList& patchSizes,
 280     const labelListList& patchStarts
 281 ) const
 282 {
 283     cellSizes_ = cellSizes;
 284     cellStarts_ = cellStarts;
 285     faceSizes_ = faceSizes;
 286     faceStarts_ = faceStarts;
 287     patchSizes_ = patchSizes;
 288     patchStarts_ = patchStarts;
 289 }
 290
 291
 292 //- Fetch face weights
 293 const List<scalarField>& topoMapper::faceWeights() const
 294 {
 295     return faceWeights_;
 296 }
 297
 298
 299 //- Fetch cell weights
 300 const List<scalarField>& topoMapper::cellWeights() const
 301 {
 302     return cellWeights_;
 303 }
 304
 305
 306 //- Fetch face centres
 307 const List<vectorField>& topoMapper::faceCentres() const
 308 {
 309     return faceCentres_;
 310 }
 311
 312
 313 //- Fetch cell centres
 314 const List<vectorField>& topoMapper::cellCentres() const
 315 {
 316     return cellCentres_;
 317 }
 318
 319
 320 //- Fetch cell sizes
 321 const labelList& topoMapper::cellSizes() const
 322 {
 323     return cellSizes_;
 324 }
 325
 326
 327 //- Fetch face sizes
 328 const labelList& topoMapper::faceSizes() const
 329 {
 330     return faceSizes_;
 331 }
 332
 333
 334 //- Fetch patch sizes
 335 const labelListList& topoMapper::patchSizes() const
 336 {
 337     return patchSizes_;
 338 }
 339
 340
 341 //- Fetch cell starts
 342 const labelList& topoMapper::cellStarts() const
 343 {
 344     return cellStarts_;
 345 }
 346
 347
 348 //- Fetch face starts
 349 const labelList& topoMapper::faceStarts() const
 350 {
 351     return faceStarts_;
 352 }
 353
 354
 355 //- Fetch patch starts
 356 const labelListList& topoMapper::patchStarts() const
 357 {
 358     return patchStarts_;
 359 }
 360
 361
 362 //- Store mesh information for the mapping stage
 363 void topoMapper::storeMeshInformation() const
 364 {
 365     // Store field-gradients
 366     storeGradients();
 367
 368     // Store geometry
 369     storeGeometry();
 370 }
 371
 372 //- Return non-const access to cell centres
 373 volVectorField& topoMapper::volCentres() const
 374 {
 375     if (!cellCentresPtr_)
 376     {
 377         FatalErrorIn
 378         (
 379             "const vectorField& topoMapper::volCentres() const"
 380         ) << nl << " Pointer has not been set. "
 381           << abort(FatalError);
 382     }
 383
 384     return *cellCentresPtr_;
 385 }
 386
 387
 388 //- Return stored cell centre information
 389 const vectorField& topoMapper::internalCentres() const
 390 {
 391     if (!cellCentresPtr_)
 392     {
 393         FatalErrorIn
 394         (
 395             "const vectorField& topoMapper::internalCentres() const"
 396         ) << nl << " Pointer has not been set. "
 397           << abort(FatalError);
 398     }
 399
 400     return *cellCentresPtr_;
 401 }
 402
 403
 404 //- Return non-const access to cell volumes
 405 scalarField& topoMapper::internalVolumes() const
 406 {
 407     if (!cellVolumesPtr_)
 408     {
 409         FatalErrorIn
 410         (
 411             "scalarField& topoMapper::internalVolumes() const"
 412         ) << nl << " Pointer has not been set. "
 413           << abort(FatalError);
 414     }
 415
 416     return *cellVolumesPtr_;
 417 }
 418
 419
 420 //- Return stored patch centre information
 421 const vectorField& topoMapper::patchCentres(const label i) const
 422 {
 423     if (!cellCentresPtr_)
 424     {
 425         FatalErrorIn
 426         (
 427             "const vectorField& topoMapper::patchCentres"
 428             "(const label i) const"
 429         ) << nl << " Pointer has not been set. index: " << i
 430           << abort(FatalError);
 431     }
 432
 433     return (*cellCentresPtr_).boundaryField()[i];
 434 }
 435
 436
 437 //- Return names of stored gradients
 438 const wordList topoMapper::gradientTable() const
 439 {
 440     return gradTable_.toc();
 441 }
 442
 443
 444 //- Fetch the gradient field (template specialisation)
 445 template <>
 446 volVectorField& topoMapper::gradient(const word& name) const
 447 {
 448     if (!gradTable_.found(name))
 449     {
 450         FatalErrorIn
 451         (
 452             "volVectorField& topoMapper::gradient(const word& name) const"
 453         ) << nl << " Gradient for: " << name
 454           << " has not been stored."
 455           << abort(FatalError);
 456     }
 457
 458     return sGradPtrs_[gradTable_[name].second()];
 459 }
 460
 461
 462 //- Fetch the gradient field (template specialisation)
 463 template <>
 464 volTensorField& topoMapper::gradient(const word& name) const
 465 {
 466     if (!gradTable_.found(name))
 467     {
 468         FatalErrorIn
 469         (
 470             "volTensorField& topoMapper::gradient(const word& name) const"
 471         ) << nl << " Gradient for: " << name
 472           << " has not been stored."
 473           << abort(FatalError);
 474     }
 475
 476     return vGradPtrs_[gradTable_[name].second()];
 477 }
 478
 479
 480 //- Deregister gradient fields and centres,
 481 //  but retain for mapping
 482 void topoMapper::deregisterMeshInformation() const
 483 {
 484     // Check out scalar gradients
 485     forAll(sGradPtrs_, fieldI)
 486     {
 487         mesh_.objectRegistry::checkOut(sGradPtrs_[fieldI]);
 488     }
 489
 490     // Check out vector gradients
 491     forAll(vGradPtrs_, fieldI)
 492     {
 493         mesh_.objectRegistry::checkOut(vGradPtrs_[fieldI]);
 494     }
 495
 496     // Check out cell centres
 497     mesh_.objectRegistry::checkOut(*cellCentresPtr_);
 498 }
 499
 500
 501 //- Correct fluxes after topology changes, if required
 502 void topoMapper::correctFluxes() const
 503 {
 504     if (surfaceFluxCorrector().required())
 505     {
 506         // Supply a list of inserted faces for interpolation
 507         surfaceFluxCorrector().interpolateFluxes
 508         (
 509             surfaceMap().insertedObjectLabels()
 510         );
 511
 512         // Update fluxes
 513         surfaceFluxCorrector().updateFluxes();
 514     }
 515 }
 516
 517
 518 //- Return volume mapper
 519 const topoCellMapper& topoMapper::volMap() const
 520 {
 521     if (!cellMap_.valid())
 522     {
 523         FatalErrorIn
 524         (
 525             "const topoCellMapper& topoMapper::volMap() const"
 526         ) << nl << " Volume mapper has not been set. "
 527           << abort(FatalError);
 528     }
 529
 530     return cellMap_();
 531 }
 532
 533
 534 //- Return surface mapper
 535 const topoSurfaceMapper& topoMapper::surfaceMap() const
 536 {
 537     if (!surfaceMap_.valid())
 538     {
 539         FatalErrorIn
 540         (
 541             "const topoSurfaceMapper& topoMapper::surfaceMap() const"
 542         ) << nl << " Surface mapper has not been set. "
 543           << abort(FatalError);
 544     }
 545
 546     return surfaceMap_();
 547 }
 548
 549
 550 //- Return boundary mapper
 551 const topoBoundaryMeshMapper& topoMapper::boundaryMap() const
 552 {
 553     if (!boundaryMap_.valid())
 554     {
 555         FatalErrorIn
 556         (
 557             "const topoBoundaryMeshMapper& topoMapper::boundaryMap() const"
 558         ) << nl << " Boundary mapper has not been set. "
 559           << abort(FatalError);
 560     }
 561
 562     return boundaryMap_();
 563 }
 564
 565
 566 //- Return flux-corrector
 567 const fluxCorrector& topoMapper::surfaceFluxCorrector() const
 568 {
 569     if (!fluxCorrector_.valid())
 570     {
 571         FatalErrorIn
 572         (
 573             "const fluxCorrector& topoMapper::surfaceFluxCorrector() const"
 574         ) << nl << " fluxCorrector has not been set. "
 575           << abort(FatalError);
 576     }
 577
 578     return fluxCorrector_();
 579 }
 580
 581
 582 //- Clear out member data
 583 void topoMapper::clear() const
 584 {
 585     // Clear out mappers
 586     cellMap_.clear();
 587     surfaceMap_.clear();
 588     boundaryMap_.clear();
 589
 590     // Clear index maps
 591     gradTable_.clear();
 592
 593     // Clear stored gradients
 594     sGradPtrs_.clear();
 595     vGradPtrs_.clear();
 596
 597     // Wipe out geomtry information
 598     deleteDemandDrivenData(cellVolumesPtr_);
 599     deleteDemandDrivenData(cellCentresPtr_);
 600
 601     // Clear maps
 602     faceWeights_.clear();
 603     cellWeights_.clear();
 604
 605     faceCentres_.clear();
 606     cellCentres_.clear();
 607
 608     // Clear sizes / offsets
 609     cellSizes_.clear();
 610     cellStarts_.clear();
 611
 612     faceSizes_.clear();
 613     faceStarts_.clear();
 614
 615     patchSizes_.clear();
 616     patchStarts_.clear();
 617 }
 618
 619
 620 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 621 void topoMapper::operator=(const topoMapper& rhs)
 622 {
 623     // Check for assignment to self
 624     if (this == &rhs)
 625     {
 626         FatalErrorIn
 627         (
 628             "topoMapper::operator=(const topoMapper&)"
 629         )
 630             << "Attempted assignment to self"
 631             << abort(FatalError);
 632     }
 633 }
 634
 635 } // End namespace Foam
 636
 637 // ************************************************************************* //