src/conversion/meshReader/meshReader.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
   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 Namespace
  26     Foam::meshReaders
  27
  28 Description
  29     A namespace for holding various types of mesh readers.
  30
  31
  32 Class
  33     Foam::meshReader
  34
  35 Description
  36     This class supports creating polyMeshes with baffles.
  37
  38     The derived classes are responsible for providing the protected data.
  39     This implementation is somewhat messy, but could/should be restructured
  40     to provide a more generalized reader (at the moment it has been written
  41     for converting pro-STAR data).
  42
  43     The meshReader supports cellTable information (see new user's guide entry).
  44
  45 Note
  46     The boundary definitions are given as cell/face.
  47
  48 SourceFiles
  49     calcPointCells.C
  50     createPolyBoundary.C
  51     createPolyCells.C
  52     meshReader.C
  53     meshReaderAux.C
  54
  55 \*---------------------------------------------------------------------------*/
  56
  57 #ifndef meshReader_H
  58 #define meshReader_H
  59
  60 #include "polyMesh.H"
  61 #include "HashTable.H"
  62 #include "IOstream.H"
  63
  64 #include "cellTable.H"
  65
  66 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  67
  68 namespace Foam
  69 {
  70
  71 /*---------------------------------------------------------------------------*\
  72                         Class meshReader Declaration
  73 \*---------------------------------------------------------------------------*/
  74
  75 class meshReader
  76 {
  77 protected:
  78
  79     //- Identify cell faces in terms of cell Id and face Id
  80     class cellFaceIdentifier
  81     {
  82     public:
  83         // Public data
  84
  85             //- Cell Id
  86             label cell;
  87
  88             //- Face Id
  89             label face;
  90
  91
  92         // Constructors
  93
  94             //- Construct null
  95             cellFaceIdentifier() : cell(-1), face(-1) {}
  96
  97             //- Construct from cell/face components
  98             cellFaceIdentifier(label c, label f) : cell(c), face(f) {}
  99
 100
 101         // Check
 102
 103             //- Used if cell or face are non-negative
 104             bool used() const
 105             {
 106                 return (cell >= 0 && face >= 0);
 107             }
 108
 109             //- Unused if cell or face are negative
 110             bool unused() const
 111             {
 112                 return (cell < 0 || face < 0);
 113             }
 114
 115
 116         // Member Operators
 117
 118             bool operator!=(const cellFaceIdentifier& cf) const
 119             {
 120                 return (cell != cf.cell || face != cf.face);
 121             }
 122
 123             bool operator==(const cellFaceIdentifier& cf) const
 124             {
 125                 return (cell == cf.cell && face == cf.face);
 126             }
 127
 128         // IOstream Operators
 129
 130             friend Ostream& operator<<
 131             (
 132                 Ostream& os,
 133                 const cellFaceIdentifier& cf
 134             )
 135             {
 136                 os << "(" << cf.cell << "/" << cf.face << ")";
 137                 return os;
 138             }
 139         };
 140
 141
 142 private:
 143
 144     // Private data
 145
 146         //- Point-cell addressing. Used for topological analysis
 147         // Warning. This point cell addressing list potentially contains
 148         // duplicate cell entries. Use additional checking
 149         mutable labelListList* pointCellsPtr_;
 150
 151         //- Number of internal faces for polyMesh
 152         label nInternalFaces_;
 153
 154         //- Polyhedral mesh boundary patch start indices and dimensions
 155         labelList patchStarts_;
 156         labelList patchSizes_;
 157
 158         //- association between two faces
 159         List<labelPair> interfaces_;
 160
 161         //- list of cells/faces id pairs for each baffle
 162         List<List<cellFaceIdentifier> > baffleIds_;
 163
 164         //- Global face list for polyMesh
 165         faceList meshFaces_;
 166
 167         //- Cells as polyhedra for polyMesh
 168         cellList cellPolys_;
 169
 170         //- Face sets for monitoring
 171         HashTable<List<label>, word, string::hash> monitoringSets_;
 172
 173
 174     // Private Member Functions
 175
 176         //- Disallow default bitwise copy construct
 177         meshReader(const meshReader&);
 178
 179         //- Disallow default bitwise assignment
 180         void operator=(const meshReader&);
 181
 182         //- Calculate pointCells
 183         void calcPointCells() const;
 184
 185         const labelListList& pointCells() const;
 186
 187         //- Make polyhedral cells and global faces if the mesh is polyhedral
 188         void createPolyCells();
 189
 190         //- Add in boundary face
 191         void addPolyBoundaryFace
 192         (
 193             const label cellId,
 194             const label cellFaceId,
 195             const label nCreatedFaces
 196         );
 197
 198         //- Add in boundary face
 199         void addPolyBoundaryFace
 200         (
 201             const cellFaceIdentifier& identifier,
 202             const label nCreatedFaces
 203         );
 204
 205         //- Add cellZones based on cellTable Id
 206         void addCellZones(polyMesh&) const;
 207
 208         //- Add faceZones based on monitoring boundary conditions
 209         void addFaceZones(polyMesh&) const;
 210
 211         //- Make polyhedral boundary from shape boundary
 212         // (adds more faces to the face list)
 213         void createPolyBoundary();
 214
 215         //- Add polyhedral boundary
 216         List<polyPatch*> polyBoundaryPatches(const polyMesh&);
 217
 218         //- Clear extra storage before creation of the mesh to remove
 219         //  a memory peak
 220         void clearExtraStorage();
 221
 222         void writeInterfaces(const objectRegistry&) const;
 223
 224         //- Write List<label> in constant/polyMesh
 225         void writeMeshLabelList
 226         (
 227             const objectRegistry& registry,
 228             const word& propertyName,
 229             const labelList& list,
 230             IOstream::streamFormat fmt = IOstream::ASCII
 231         ) const;
 232
 233         //- Return list of faces for every cell
 234         faceListList& cellFaces() const
 235         {
 236             return const_cast<faceListList&>(cellFaces_);
 237         }
 238
 239
 240 protected:
 241
 242     // Protected data
 243
 244         //- Pointers to cell shape models
 245         static const cellModel* unknownModel;
 246         static const cellModel* tetModel;
 247         static const cellModel* pyrModel;
 248         static const cellModel* prismModel;
 249         static const cellModel* hexModel;
 250
 251         //- Referenced filename
 252         fileName geometryFile_;
 253
 254         //- Geometry scaling
 255         scalar scaleFactor_;
 256
 257         //- Points supporting the mesh
 258         pointField points_;
 259
 260         //- Lookup original Cell number for a given cell
 261         labelList origCellId_;
 262
 263         //- Identify boundary faces by cells and their faces
 264         //  for each patch
 265         List<List<cellFaceIdentifier> > boundaryIds_;
 266
 267         //- Boundary patch types
 268         wordList patchTypes_;
 269
 270         //- Boundary patch names
 271         wordList patchNames_;
 272
 273         //- Boundary patch physical types
 274         wordList patchPhysicalTypes_;
 275
 276         //- List of faces for every cell
 277         faceListList cellFaces_;
 278
 279         //- List of each baffle face
 280         faceList baffleFaces_;
 281
 282         //- Cell table id for each cell
 283         labelList cellTableId_;
 284
 285         //- Cell table persistent data saved as a dictionary
 286         cellTable cellTable_;
 287
 288
 289     // Member Functions
 290
 291         //- Subclasses are required to supply this information
 292         virtual bool readGeometry(const scalar scaleFactor = 1.0) = 0;
 293
 294         //- Return mesh points
 295         pointField& points() const
 296         {
 297             return const_cast<pointField&>(points_);
 298         }
 299
 300
 301 public:
 302
 303     // Static Members
 304
 305         //- Warn about repeated names
 306         static void warnDuplicates(const word& context, const wordList&);
 307
 308
 309     // Constructors
 310
 311         //- Construct from fileName
 312         meshReader(const fileName&, const scalar scaleFactor = 1.0);
 313
 314
 315     //- Destructor
 316     virtual ~meshReader();
 317
 318
 319     // Member Functions
 320
 321         //- Create and return polyMesh
 322         virtual autoPtr<polyMesh> mesh(const objectRegistry&);
 323
 324         //- Write auxiliary information
 325         void writeAux(const objectRegistry&) const;
 326
 327         //- Write mesh
 328         void writeMesh
 329         (
 330             const polyMesh&,
 331             IOstream::streamFormat fmt = IOstream::BINARY
 332         ) const;
 333 };
 334
 335
 336 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 337
 338 } // End namespace Foam
 339
 340 #endif
 341
 342 // ************************************************************************* //