src/dynamicMesh/dynamicTopoFvMesh/eMesh/eBoundaryMesh/eBoundaryMesh.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 Description
  25
  26 \*---------------------------------------------------------------------------*/
  27
  28 #include "eBoundaryMesh.H"
  29 #include "eMesh.H"
  30 #include "primitiveMesh.H"
  31
  32 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  33
  34 namespace Foam
  35 {
  36
  37 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  38
  39 defineTypeNameAndDebug(eBoundaryMesh, 0);
  40
  41
  42 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
  43
  44
  45 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  46
  47 // Construct from dictionary
  48 eBoundaryMesh::eBoundaryMesh
  49 (
  50     const IOobject& io,
  51     const eMesh& mesh
  52 )
  53 :
  54     ePatchList(),
  55     regIOobject(io),
  56     mesh_(mesh)
  57 {
  58     if
  59     (
  60         (readOpt() == IOobject::MUST_READ) ||
  61         (readOpt() == IOobject::READ_IF_PRESENT && headerOk())
  62     )
  63     {
  64         readFromInputStream();
  65     }
  66 }
  67
  68
  69 // Construct given size. Patches will be set later
  70 eBoundaryMesh::eBoundaryMesh
  71 (
  72     const IOobject& io,
  73     const eMesh& em,
  74     const label size
  75 )
  76 :
  77     ePatchList(size),
  78     regIOobject(io),
  79     mesh_(em)
  80 {}
  81
  82
  83 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
  84
  85 //- Read from input stream
  86 void eBoundaryMesh::readFromInputStream()
  87 {
  88     ePatchList& patches = *this;
  89
  90     // Read polyPatchList
  91     Istream& is = readStream(typeName);
  92
  93     PtrList<entry> patchEntries(is);
  94     patches.setSize(patchEntries.size());
  95
  96     forAll(patches, patchI)
  97     {
  98         patches.set
  99         (
 100             patchI,
 101             ePatch::New
 102             (
 103                 patchEntries[patchI].keyword(),
 104                 patchEntries[patchI].dict(),
 105                 patchI,
 106                 *this
 107             )
 108         );
 109     }
 110
 111     // Check state of IOstream
 112     is.check
 113     (
 114         "eBoundaryMesh::eBoundaryMesh"
 115         "(const IOobject&, const faMesh&)"
 116     );
 117
 118     close();
 119 }
 120
 121 // Return the mesh reference
 122 const eMesh& eBoundaryMesh::mesh() const
 123 {
 124     return mesh_;
 125 }
 126
 127
 128 // Return a list of patch types
 129 wordList eBoundaryMesh::types() const
 130 {
 131     const ePatchList& patches = *this;
 132
 133     wordList t(patches.size());
 134
 135     forAll (patches, patchI)
 136     {
 137         t[patchI] = patches[patchI].type();
 138     }
 139
 140     return t;
 141 }
 142
 143
 144 // Return a list of patch names
 145 wordList eBoundaryMesh::names() const
 146 {
 147     const ePatchList& patches = *this;
 148
 149     wordList t(patches.size());
 150
 151     forAll (patches, patchI)
 152     {
 153         t[patchI] = patches[patchI].name();
 154     }
 155
 156     return t;
 157 }
 158
 159
 160 // Return a list of patch sizes
 161 labelList eBoundaryMesh::patchSizes() const
 162 {
 163     const ePatchList& patches = *this;
 164
 165     labelList t(patches.size());
 166
 167     forAll (patches, patchI)
 168     {
 169         t[patchI] = patches[patchI].size();
 170     }
 171
 172     return t;
 173 }
 174
 175
 176 // Return a list of patch starts
 177 labelList eBoundaryMesh::patchStarts() const
 178 {
 179     const ePatchList& patches = *this;
 180
 181     labelList t(patches.size());
 182
 183     forAll (patches, patchI)
 184     {
 185         t[patchI] = patches[patchI].start();
 186     }
 187
 188     return t;
 189 }
 190
 191
 192 //- Return patch index for a given edge label
 193 label eBoundaryMesh::whichPatch(const label edgeIndex) const
 194 {
 195     // Find out which patch the current edge belongs to by comparing label
 196     // with patch start labels.
 197     // If the face is internal, return -1;
 198     // if it is off the end of the list, abort
 199     if (edgeIndex >= mesh().nEdges())
 200     {
 201         FatalErrorIn
 202         (
 203             "eBoundaryMesh::whichPatch(const label edgeIndex) const"
 204         )   << "given label greater than the number of geometric edges"
 205             << abort(FatalError);
 206     }
 207
 208     if (edgeIndex < mesh().nInternalEdges())
 209     {
 210         return -1;
 211     }
 212
 213     forAll (*this, patchI)
 214     {
 215         const ePatch& bp = operator[](patchI);
 216
 217         if
 218         (
 219             edgeIndex >= bp.start()
 220          && edgeIndex < bp.start() + bp.size()
 221         )
 222         {
 223             return patchI;
 224         }
 225     }
 226
 227     // If not in any of above, it is trouble!
 228     FatalErrorIn
 229     (
 230         "label eBoundaryMesh::whichPatch(const label edgeIndex) const"
 231     )   << "Cannot find edge " << edgeIndex << " in any of the patches "
 232         << names() << nl
 233         << "It seems your patches are not consistent with the mesh :"
 234         << " internalEdges:" << mesh().nInternalEdges()
 235         << "  total number of edges:" << mesh().nEdges()
 236         << abort(FatalError);
 237
 238     return -1;
 239 }
 240
 241
 242 label eBoundaryMesh::findPatchID(const word& patchName) const
 243 {
 244     const ePatchList& patches = *this;
 245
 246     forAll (patches, patchI)
 247     {
 248         if (patches[patchI].name() == patchName)
 249         {
 250             return patchI;
 251         }
 252     }
 253
 254     // Patch not found
 255     return -1;
 256 }
 257
 258
 259 // writeData member function required by regIOobject
 260 bool eBoundaryMesh::writeData(Ostream& os) const
 261 {
 262     const ePatchList& patches = *this;
 263
 264     os  << patches.size() << nl << token::BEGIN_LIST << incrIndent << nl;
 265
 266     forAll(patches, patchi)
 267     {
 268         os  << indent << patches[patchi].name() << nl
 269             << indent << token::BEGIN_BLOCK << nl
 270             << incrIndent << patches[patchi] << decrIndent
 271             << indent << token::END_BLOCK << endl;
 272     }
 273
 274     os  << decrIndent << token::END_LIST;
 275
 276     // Check state of IOstream
 277     os.check("eBoundaryMesh::writeData(Ostream& os) const");
 278
 279     return os.good();
 280 }
 281
 282
 283 Ostream& operator<<(Ostream& os, const eBoundaryMesh& bm)
 284 {
 285     bm.writeData(os);
 286     return os;
 287 }
 288
 289
 290 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 291
 292 } // End namespace Foam
 293
 294 // ************************************************************************* //