src/conversion/meshTables/cellTable.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 Class
  26     Foam::cellTable
  27
  28 Description
  29     The cellTable persistent data saved as a Map<dictionary>.
  30
  31     The meshReader supports cellTable information.
  32
  33     The <tt>constant/cellTable</tt> file is an @c IOMap<dictionary> that is
  34     used to save the information persistently. It contains the cellTable
  35     information of the following form:
  36
  37     @verbatim
  38         (
  39             ID
  40             {
  41                 Label           WORD;
  42                 MaterialType    WORD;
  43                 MaterialId      INT;
  44                 PorosityId      INT;
  45                 ColorIdx        INT;
  46                 ...
  47             }
  48         ...
  49         )
  50     @endverbatim
  51
  52     If the @a Label is missing, a value <tt>cellTable_{ID}</tt> will be
  53     inferred. If the @a MaterialType is missing, the value @a fluid will
  54     be inferred.
  55
  56 SourceFiles
  57     cellTable.C
  58
  59 \*---------------------------------------------------------------------------*/
  60
  61 #ifndef cellTable_H
  62 #define cellTable_H
  63
  64 #include "polyMesh.H"
  65 #include "Map.H"
  66 #include "dictionary.H"
  67 #include "labelList.H"
  68
  69 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  70
  71 namespace Foam
  72 {
  73
  74 /*---------------------------------------------------------------------------*\
  75                          Class cellTable Declaration
  76 \*---------------------------------------------------------------------------*/
  77
  78 class cellTable
  79 :
  80     public Map<dictionary>
  81 {
  82     // Private data
  83
  84        static const char* const defaultMaterial_;
  85
  86
  87     // Private Member Functions
  88
  89         //- Map from cellTable ID => zone number
  90         Map<label> zoneMap() const;
  91
  92         //- A contiguous list of cellTable names
  93         List<word> namesList() const;
  94
  95         //- Add required entries - MaterialType
  96         void addDefaults();
  97
  98         void setEntry(const label& id, const word& keyWord, const word& value);
  99
 100         //- Disallow default bitwise copy construct
 101         cellTable(const cellTable&);
 102
 103
 104 public:
 105
 106     // Constructors
 107
 108         //- Construct null
 109         cellTable();
 110
 111         //- Construct read from registry, name. instance
 112         cellTable
 113         (
 114             const objectRegistry&,
 115             const word& name = "cellTable",
 116             const fileName& instance = "constant"
 117         );
 118
 119
 120     //- Destructor
 121     ~cellTable();
 122
 123
 124     // Member Functions
 125
 126         //- Append to the end, return index
 127         label append(const dictionary&);
 128
 129         //- Return index corresponding to name
 130         //  returns -1 if not found
 131         label findIndex(const word& name) const;
 132
 133         //- Return the name corresponding to id
 134         //  returns cellTable_ID if not otherwise defined
 135         word name(const label& id) const;
 136
 137         //- Return a Map of (id => name)
 138         Map<word> names() const;
 139
 140         //- Return a Map of (id => name) for materialType (fluid | solid | shell)
 141         Map<word> selectType(const word& materialType) const;
 142
 143         //- Return a Map of (id => name) for fluids
 144         Map<word> fluids() const;
 145
 146         //- Return a Map of (id => name) for shells
 147         Map<word> shells() const;
 148
 149         //- Return a Map of (id => name) for solids
 150         Map<word> solids() const;
 151
 152         //- Return a Map of (id => fluid|solid|shell)
 153         Map<word> materialTypes() const;
 154
 155         //- Assign material Type
 156         void setMaterial(const label&, const word&);
 157
 158         //- Assign name
 159         void setName(const label&, const word&);
 160
 161         //- Assign default name if not already set
 162         void setName(const label&);
 163
 164         //- Read constant/cellTable
 165         void readDict
 166         (
 167             const objectRegistry&,
 168             const word& name = "cellTable",
 169             const fileName& instance = "constant"
 170         );
 171
 172         //- write constant/cellTable for later reuse
 173         void writeDict
 174         (
 175             const objectRegistry&,
 176             const word& name = "cellTable",
 177             const fileName& instance = "constant"
 178         ) const;
 179
 180
 181     // Member Operators
 182
 183         //- Assignment
 184         void operator=(const cellTable&);
 185
 186         //- Assign from Map<dictionary>
 187         void operator=(const Map<dictionary>&);
 188
 189         //- Assign from cellZones
 190         void operator=(const polyMesh&);
 191
 192
 193     // Friend Functions
 194
 195         //- Classify tableIds into cellZones according to the cellTable
 196         void addCellZones(polyMesh&, const labelList& tableIds) const;
 197
 198         //- Combine tableIds together
 199         //  each dictionary entry is a wordList
 200         void combine(const dictionary&, labelList& tableIds);
 201 };
 202
 203 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 204
 205 } // End namespace Foam
 206
 207 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 208
 209 #endif
 210
 211 // ************************************************************************* //