src/dynamicMesh/dynamicTopoFvMesh/fieldMapping/topoSurfaceMapper.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     topoSurfaceMapper
  26
  27 Description
  28     Implementation of the topoSurfaceMapper class
  29
  30 Author
  31     Sandeep Menon
  32     University of Massachusetts Amherst
  33     All rights reserved
  34
  35 \*---------------------------------------------------------------------------*/
  36
  37 #include "topoMapper.H"
  38 #include "mapPolyMesh.H"
  39 #include "topoSurfaceMapper.H"
  40 #include "demandDrivenData.H"
  41
  42 namespace Foam
  43 {
  44
  45 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
  46
  47 //- Clear out local storage
  48 void topoSurfaceMapper::clearOut()
  49 {
  50     deleteDemandDrivenData(directAddrPtr_);
  51     deleteDemandDrivenData(interpolationAddrPtr_);
  52     deleteDemandDrivenData(weightsPtr_);
  53     deleteDemandDrivenData(insertedFaceLabelsPtr_);
  54 }
  55
  56
  57 //- Calculate the insertedFaceLabels list
  58 void topoSurfaceMapper::calcInsertedFaceLabels() const
  59 {
  60     if (insertedFaceLabelsPtr_)
  61     {
  62         FatalErrorIn
  63         (
  64             "void topoSurfaceMapper::calcInsertedFaceLabels() const"
  65         )   << " Inserted labels has already been calculated."
  66             << abort(FatalError);
  67     }
  68
  69     // Allocate for inserted face labels
  70     label nInsertedFaces = 0;
  71
  72     insertedFaceLabelsPtr_ = new labelList(size(), -1);
  73     labelList& insertedFaces = *insertedFaceLabelsPtr_;
  74
  75     label nIntFaces = size();
  76
  77     // Loop through the facesFromFaces map, and ensure that
  78     // inserted internal faces are not mapped from any parent faces.
  79     const List<objectMap>& fff = mpm_.facesFromFacesMap();
  80
  81     forAll(fff, objectI)
  82     {
  83         const objectMap& fffI = fff[objectI];
  84
  85         // Only pick internal faces
  86         if (fffI.index() < nIntFaces)
  87         {
  88             insertedFaces[nInsertedFaces++] = fffI.index();
  89         }
  90     }
  91
  92     // Shorten inserted faces to actual size
  93     insertedFaces.setSize(nInsertedFaces);
  94 }
  95
  96
  97 //- Calculate addressing for mapping
  98 void topoSurfaceMapper::calcAddressing() const
  99 {
 100     if
 101     (
 102         directAddrPtr_
 103      || interpolationAddrPtr_
 104     )
 105     {
 106         FatalErrorIn("void topoSurfaceMapper::calcAddressing() const")
 107             << "Addressing already calculated."
 108             << abort(FatalError);
 109     }
 110
 111     if (direct())
 112     {
 113         // Direct addressing, no weights - slice to size
 114         directAddrPtr_ =
 115         (
 116             new labelList
 117             (
 118                 labelList::subList(mpm_.faceMap(), size())
 119             )
 120         );
 121
 122         labelList& addr = *directAddrPtr_;
 123
 124         // Loop through the addressing list,
 125         // and set dummy addressing for newly created faces.
 126         forAll(addr, faceI)
 127         {
 128             if (addr[faceI] < 0)
 129             {
 130                 addr[faceI] = 0;
 131             }
 132         }
 133     }
 134     else
 135     {
 136         FatalErrorIn("void topoSurfaceMapper::calcAddressing() const")
 137             << " Request for interpolative addressing"
 138             << " on internal surface fields. The surfaceMapper"
 139             << " is not designed to do this. Interpolate volFields"
 140             << " to surfaceFields instead."
 141             << abort(FatalError);
 142     }
 143 }
 144
 145
 146 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 147
 148 // Construct from components
 149 topoSurfaceMapper::topoSurfaceMapper
 150 (
 151     const mapPolyMesh& mpm,
 152     const topoMapper& mapper
 153 )
 154 :
 155     mesh_(mpm.mesh()),
 156     mpm_(mpm),
 157     tMapper_(mapper),
 158     direct_(false),
 159     sizeBeforeMapping_(mpm.nOldInternalFaces()),
 160     directAddrPtr_(NULL),
 161     interpolationAddrPtr_(NULL),
 162     weightsPtr_(NULL),
 163     insertedFaceLabelsPtr_(NULL)
 164 {
 165     // Fetch offset sizes from topoMapper
 166     const labelList& sizes = tMapper_.faceSizes();
 167
 168     // Add offset sizes
 169     if (sizes.size())
 170     {
 171         forAll(sizes, pI)
 172         {
 173             sizeBeforeMapping_ += sizes[pI];
 174         }
 175     }
 176
 177     // Calculate the insertedFaces list
 178     calcInsertedFaceLabels();
 179
 180     // Set to direct mapping.
 181     direct_ = true;
 182 }
 183
 184 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 185
 186 topoSurfaceMapper::~topoSurfaceMapper()
 187 {
 188     clearOut();
 189 }
 190
 191 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 192
 193 //- Return size
 194 label topoSurfaceMapper::size() const
 195 {
 196     return mesh_.nInternalFaces();
 197 }
 198
 199
 200 //- Return size before mapping
 201 label topoSurfaceMapper::sizeBeforeMapping() const
 202 {
 203     return sizeBeforeMapping_;
 204 }
 205
 206
 207 //- Is the mapping direct
 208 bool topoSurfaceMapper::direct() const
 209 {
 210     return direct_;
 211 }
 212
 213
 214 //- Return direct addressing
 215 const unallocLabelList& topoSurfaceMapper::directAddressing() const
 216 {
 217     if (!direct())
 218     {
 219         FatalErrorIn
 220         (
 221             "const unallocLabelList& "
 222             "topoSurfaceMapper::directAddressing() const"
 223         )   << "Requested direct addressing for an interpolative mapper."
 224             << abort(FatalError);
 225     }
 226
 227     if (!directAddrPtr_)
 228     {
 229         calcAddressing();
 230     }
 231
 232     return *directAddrPtr_;
 233 }
 234
 235
 236 //- Return interpolation addressing
 237 const labelListList& topoSurfaceMapper::addressing() const
 238 {
 239     if (direct())
 240     {
 241         FatalErrorIn
 242         (
 243             "const labelListList& "
 244             "topoSurfaceMapper::addressing() const"
 245         )   << "Requested interpolative addressing for a direct mapper."
 246             << abort(FatalError);
 247     }
 248
 249     if (!interpolationAddrPtr_)
 250     {
 251         calcAddressing();
 252     }
 253
 254     return *interpolationAddrPtr_;
 255 }
 256
 257
 258 //- Return weights
 259 const scalarListList& topoSurfaceMapper::weights() const
 260 {
 261     if (direct())
 262     {
 263         FatalErrorIn
 264         (
 265             "const scalarListList& "
 266             "topoSurfaceMapper::weights() const"
 267         )   << "Requested interpolative weights for a direct mapper."
 268             << abort(FatalError);
 269     }
 270
 271     if (!weightsPtr_)
 272     {
 273         calcAddressing();
 274     }
 275
 276     return *weightsPtr_;
 277 }
 278
 279
 280 //- Are there any inserted faces
 281 bool topoSurfaceMapper::insertedObjects() const
 282 {
 283     return insertedObjectLabels().size();
 284 }
 285
 286
 287 //- Return list of inserted faces
 288 const labelList& topoSurfaceMapper::insertedObjectLabels() const
 289 {
 290     if (!insertedFaceLabelsPtr_)
 291     {
 292         calcInsertedFaceLabels();
 293     }
 294
 295     return *insertedFaceLabelsPtr_;
 296 }
 297
 298
 299 //- Return flux flip map
 300 const labelHashSet& topoSurfaceMapper::flipFaceFlux() const
 301 {
 302     return mpm_.flipFaceFlux();
 303 }
 304
 305
 306 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 307
 308 void topoSurfaceMapper::operator=(const topoSurfaceMapper& rhs)
 309 {
 310     // Check for assignment to self
 311     if (this == &rhs)
 312     {
 313         FatalErrorIn("void topoSurfaceMapper::operator=")
 314             << "Attempted assignment to self"
 315             << abort(FatalError);
 316     }
 317 }
 318
 319 } // End namespace Foam
 320
 321 // ************************************************************************* //