src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoMapper.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     topoMapper
  27
  28 Description
  29     Implementation of topoMapper
  30
  31 Author
  32     Sandeep Menon
  33     University of Massachusetts Amherst
  34     All rights reserved
  35
  36 \*----------------------------------------------------------------------------*/
  37
  38 #include "topoMapper.H"
  39 #include "fluxCorrector.H"
  40 #include "topoCellMapper.H"
  41 #include "topoSurfaceMapper.H"
  42 #include "topoBoundaryMeshMapper.H"
  43 #include "fixedValueFvPatchFields.H"
  44
  45 namespace Foam
  46 {
  47
  48 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
  49
  50 //- Store gradients prior to mesh reset
  51 void topoMapper::storeGradients() const
  52 {
  53     storeGradients<scalar>(sGrads_);
  54     storeGradients<vector>(vGrads_);
  55
  56     if (fvMesh::debug)
  57     {
  58         Info<< "Registered volScalarFields: " << scalarGrads() << endl;
  59         Info<< "Registered volVectorFields: " << vectorGrads() << endl;
  60     }
  61 }
  62
  63
  64 //- Store geometric information
  65 void topoMapper::storeGeometry() const
  66 {
  67     // Wipe out existing information
  68     deleteDemandDrivenData(cellCentresPtr_);
  69
  70     vectorField Cv(mesh_.cellCentres());
  71     vectorField Cf(mesh_.faceCentres());
  72
  73     // Create and map the patch field values
  74     label nPatches = mesh_.boundary().size();
  75
  76     // Create field parts
  77     PtrList<fvPatchField<vector> > volCentrePatches(nPatches);
  78
  79     // Over-ride and set all patches to fixedValue
  80     for (label patchI = 0; patchI < nPatches; patchI++)
  81     {
  82         volCentrePatches.set
  83         (
  84             patchI,
  85             new fixedValueFvPatchField<vector>
  86             (
  87                 mesh_.boundary()[patchI],
  88                 DimensionedField<vector, volMesh>::null()
  89             )
  90         );
  91
  92         // Slice field to patch (forced assignment)
  93         volCentrePatches[patchI] ==
  94         (
  95             mesh_.boundaryMesh()[patchI].patchSlice(Cf)
  96         );
  97     }
  98
  99     // Set the cell-centres pointer.
 100     cellCentresPtr_ =
 101     (
 102         new volVectorField
 103         (
 104             IOobject
 105             (
 106                 "cellCentres",
 107                 mesh_.time().timeName(),
 108                 mesh_,
 109                 IOobject::NO_READ,
 110                 IOobject::NO_WRITE,
 111                 false
 112             ),
 113             mesh_,
 114             dimLength,
 115             SubField<vector>(Cv, mesh_.nCells()),
 116             volCentrePatches
 117         )
 118     );
 119 }
 120
 121 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 122
 123 //- Construct from mesh and dictionary
 124 topoMapper::topoMapper
 125 (
 126     const fvMesh& mesh,
 127     const dictionary& dict
 128 )
 129 :
 130     mesh_(mesh),
 131     dict_(dict),
 132     cellMap_(NULL),
 133     surfaceMap_(NULL),
 134     boundaryMap_(NULL),
 135     fluxCorrector_(fluxCorrector::New(mesh, dict)),
 136     cellCentresPtr_(NULL)
 137 {}
 138
 139
 140 // * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * *  //
 141
 142 topoMapper::~topoMapper()
 143 {
 144     clear();
 145 }
 146
 147 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 148
 149 //- Return reference to the mesh
 150 const fvMesh& topoMapper::mesh() const
 151 {
 152     return mesh_;
 153 }
 154
 155
 156 //- Return reference to objectRegistry storing fields.
 157 const objectRegistry& topoMapper::thisDb() const
 158 {
 159     return mesh_;
 160 }
 161
 162
 163 //- Set mapping information
 164 void topoMapper::setMapper(const mapPolyMesh& mpm) const
 165 {
 166     if
 167     (
 168         cellMap_.valid() ||
 169         surfaceMap_.valid() ||
 170         boundaryMap_.valid()
 171     )
 172     {
 173         FatalErrorIn
 174         (
 175             "void topoMapper::setMapper() const"
 176         ) << nl << " Mapper has already been set. "
 177           << abort(FatalError);
 178     }
 179
 180     // Set pointers
 181     cellMap_.set(new topoCellMapper(mpm, *this));
 182     surfaceMap_.set(new topoSurfaceMapper(mpm, *this));
 183     boundaryMap_.set(new topoBoundaryMeshMapper(mesh(), mpm, *this));
 184 }
 185
 186
 187 //- Set face weighting information
 188 void topoMapper::setFaceWeights
 189 (
 190     const Xfer<List<scalarField> >& weights,
 191     const Xfer<List<vectorField> >& centres
 192 ) const
 193 {
 194     faceWeights_.transfer(weights());
 195     faceCentres_.transfer(centres());
 196 }
 197
 198
 199 //- Set cell weighting information
 200 void topoMapper::setCellWeights
 201 (
 202     const Xfer<List<scalarField> >& weights,
 203     const Xfer<List<vectorField> >& centres
 204 ) const
 205 {
 206     cellWeights_.transfer(weights());
 207     cellCentres_.transfer(centres());
 208 }
 209
 210
 211 //- Set cell / patch offset information
 212 void topoMapper::setOffsets
 213 (
 214     const labelList& cellSizes,
 215     const labelList& cellStarts,
 216     const labelList& faceSizes,
 217     const labelList& faceStarts,
 218     const labelListList& patchSizes,
 219     const labelListList& patchStarts
 220 ) const
 221 {
 222     cellSizes_ = cellSizes;
 223     cellStarts_ = cellStarts;
 224     faceSizes_ = faceSizes;
 225     faceStarts_ = faceStarts;
 226     patchSizes_ = patchSizes;
 227     patchStarts_ = patchStarts;
 228 }
 229
 230
 231 //- Fetch face weights
 232 const List<scalarField>& topoMapper::faceWeights() const
 233 {
 234     return faceWeights_;
 235 }
 236
 237
 238 //- Fetch cell weights
 239 const List<scalarField>& topoMapper::cellWeights() const
 240 {
 241     return cellWeights_;
 242 }
 243
 244
 245 //- Fetch face centres
 246 const List<vectorField>& topoMapper::faceCentres() const
 247 {
 248     return faceCentres_;
 249 }
 250
 251
 252 //- Fetch cell centres
 253 const List<vectorField>& topoMapper::cellCentres() const
 254 {
 255     return cellCentres_;
 256 }
 257
 258
 259 //- Fetch cell sizes
 260 const labelList& topoMapper::cellSizes() const
 261 {
 262     return cellSizes_;
 263 }
 264
 265
 266 //- Fetch face sizes
 267 const labelList& topoMapper::faceSizes() const
 268 {
 269     return faceSizes_;
 270 }
 271
 272
 273 //- Fetch patch sizes
 274 const labelListList& topoMapper::patchSizes() const
 275 {
 276     return patchSizes_;
 277 }
 278
 279
 280 //- Fetch cell starts
 281 const labelList& topoMapper::cellStarts() const
 282 {
 283     return cellStarts_;
 284 }
 285
 286
 287 //- Fetch face starts
 288 const labelList& topoMapper::faceStarts() const
 289 {
 290     return faceStarts_;
 291 }
 292
 293
 294 //- Fetch patch starts
 295 const labelListList& topoMapper::patchStarts() const
 296 {
 297     return patchStarts_;
 298 }
 299
 300
 301 //- Store mesh information for the mapping stage
 302 void topoMapper::storeMeshInformation() const
 303 {
 304     // Store field-gradients
 305     storeGradients();
 306
 307     // Store geometry
 308     storeGeometry();
 309 }
 310
 311 //- Return non-const access to cell centres
 312 volVectorField& topoMapper::volCentres() const
 313 {
 314     if (!cellCentresPtr_)
 315     {
 316         FatalErrorIn
 317         (
 318             "const vectorField& topoMapper::volCentres() const"
 319         ) << nl << " Pointer has not been set. "
 320           << abort(FatalError);
 321     }
 322
 323     return *cellCentresPtr_;
 324 }
 325
 326
 327 //- Return stored cell centre information
 328 const vectorField& topoMapper::internalCentres() const
 329 {
 330     if (!cellCentresPtr_)
 331     {
 332         FatalErrorIn
 333         (
 334             "const vectorField& topoMapper::internalCentres() const"
 335         ) << nl << " Pointer has not been set. "
 336           << abort(FatalError);
 337     }
 338
 339     return *cellCentresPtr_;
 340 }
 341
 342
 343 //- Return stored patch centre information
 344 const vectorField& topoMapper::patchCentres(const label i) const
 345 {
 346     if (!cellCentresPtr_)
 347     {
 348         FatalErrorIn
 349         (
 350             "const vectorField& topoMapper::patchCentres"
 351             "(const label i) const"
 352         ) << nl << " Pointer has not been set. index: " << i
 353           << abort(FatalError);
 354     }
 355
 356     return (*cellCentresPtr_).boundaryField()[i];
 357 }
 358
 359
 360 //- Return names of stored scalar gradients
 361 const wordList topoMapper::scalarGrads() const
 362 {
 363     return sGrads_.toc();
 364 }
 365
 366
 367 //- Return names of stored vector gradients
 368 const wordList topoMapper::vectorGrads() const
 369 {
 370     return vGrads_.toc();
 371 }
 372
 373
 374 //- Fetch the gradient field (template specialisation)
 375 template <>
 376 volVectorField& topoMapper::gradient(const word& name) const
 377 {
 378     if (!sGrads_.found(name))
 379     {
 380         FatalErrorIn
 381         (
 382             "volVectorField& topoMapper::gradient(const word& name) const"
 383         ) << nl << " Gradient for: " << name
 384           << " has not been stored."
 385           << abort(FatalError);
 386     }
 387
 388     return sGrads_[name]();
 389 }
 390
 391
 392 //- Fetch the gradient field (template specialisation)
 393 template <>
 394 volTensorField& topoMapper::gradient(const word& name) const
 395 {
 396     if (!vGrads_.found(name))
 397     {
 398         FatalErrorIn
 399         (
 400             "volTensorField& topoMapper::gradient(const word& name) const"
 401         ) << nl << " Gradient for: " << name
 402           << " has not been stored."
 403           << abort(FatalError);
 404     }
 405
 406     return vGrads_[name]();
 407 }
 408
 409
 410 //- Correct fluxes after topology changes, if required
 411 void topoMapper::correctFluxes() const
 412 {
 413     if (surfaceFluxCorrector().required())
 414     {
 415         // Supply a list of inserted faces for interpolation
 416         surfaceFluxCorrector().interpolateFluxes
 417         (
 418             surfaceMap().insertedObjectLabels()
 419         );
 420
 421         // Update fluxes
 422         surfaceFluxCorrector().updateFluxes();
 423     }
 424 }
 425
 426
 427 //- Return volume mapper
 428 const topoCellMapper& topoMapper::volMap() const
 429 {
 430     if (!cellMap_.valid())
 431     {
 432         FatalErrorIn
 433         (
 434             "const topoCellMapper& topoMapper::volMap() const"
 435         ) << nl << " Volume mapper has not been set. "
 436           << abort(FatalError);
 437     }
 438
 439     return cellMap_();
 440 }
 441
 442
 443 //- Return surface mapper
 444 const topoSurfaceMapper& topoMapper::surfaceMap() const
 445 {
 446     if (!surfaceMap_.valid())
 447     {
 448         FatalErrorIn
 449         (
 450             "const topoSurfaceMapper& topoMapper::surfaceMap() const"
 451         ) << nl << " Surface mapper has not been set. "
 452           << abort(FatalError);
 453     }
 454
 455     return surfaceMap_();
 456 }
 457
 458
 459 //- Return boundary mapper
 460 const topoBoundaryMeshMapper& topoMapper::boundaryMap() const
 461 {
 462     if (!boundaryMap_.valid())
 463     {
 464         FatalErrorIn
 465         (
 466             "const topoBoundaryMeshMapper& topoMapper::boundaryMap() const"
 467         ) << nl << " Boundary mapper has not been set. "
 468           << abort(FatalError);
 469     }
 470
 471     return boundaryMap_();
 472 }
 473
 474
 475 //- Return flux-corrector
 476 const fluxCorrector& topoMapper::surfaceFluxCorrector() const
 477 {
 478     if (!fluxCorrector_.valid())
 479     {
 480         FatalErrorIn
 481         (
 482             "const fluxCorrector& topoMapper::surfaceFluxCorrector() const"
 483         ) << nl << " fluxCorrector has not been set. "
 484           << abort(FatalError);
 485     }
 486
 487     return fluxCorrector_();
 488 }
 489
 490
 491 //- Clear out member data
 492 void topoMapper::clear() const
 493 {
 494     // Clear out mappers
 495     cellMap_.clear();
 496     surfaceMap_.clear();
 497     boundaryMap_.clear();
 498
 499     // Clear stored gradients
 500     sGrads_.clear();
 501     vGrads_.clear();
 502
 503     // Wipe out geomtry information
 504     deleteDemandDrivenData(cellCentresPtr_);
 505
 506     // Clear maps
 507     faceWeights_.clear();
 508     cellWeights_.clear();
 509
 510     faceCentres_.clear();
 511     cellCentres_.clear();
 512
 513     // Clear sizes / offsets
 514     cellSizes_.clear();
 515     cellStarts_.clear();
 516
 517     faceSizes_.clear();
 518     faceStarts_.clear();
 519
 520     patchSizes_.clear();
 521     patchStarts_.clear();
 522 }
 523
 524
 525 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 526 void topoMapper::operator=(const topoMapper& rhs)
 527 {
 528     // Check for assignment to self
 529     if (this == &rhs)
 530     {
 531         FatalErrorIn
 532         (
 533             "topoMapper::operator=(const topoMapper&)"
 534         )
 535             << "Attempted assignment to self"
 536             << abort(FatalError);
 537     }
 538 }
 539
 540 } // End namespace Foam
 541
 542 // ************************************************************************* //