applications/utilities/mesh/conversion/sammToFoam/readCells.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 1991-2009 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 Description
  26     Create intermediate mesh from SAMM files
  27
  28 \*---------------------------------------------------------------------------*/
  29
  30 #include "sammMesh.H"
  31 #include "IFstream.H"
  32
  33 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  34
  35 void sammMesh::addRegularCell
  36 (
  37     const labelList& labels,
  38     const label nCreatedCells
  39 )
  40 {
  41     // Momory management
  42     static labelList labelsHex(8);
  43     static labelList labelsWedge(7);
  44     static labelList labelsPrism(6);
  45     static labelList labelsPyramid(5);
  46     static labelList labelsTet(4);
  47     static labelList labelsTetWedge(5);
  48
  49     if      // Tetrahedron
  50     (
  51         labels[2] == labels[3]
  52      && labels[4] == labels[5]
  53      && labels[5] == labels[6]
  54      && labels[6] == labels[7]
  55     )
  56     {
  57         labelsTet[0] = labels[0];
  58         labelsTet[1] = labels[1];
  59         labelsTet[2] = labels[2];
  60         labelsTet[3] = labels[4];
  61         cellShapes_[nCreatedCells] = cellShape(*tetPtr_, labelsTet);
  62     }
  63
  64     else if // Square-based pyramid
  65     (
  66         labels[4] == labels[5]
  67      && labels[5] == labels[6]
  68      && labels[6] == labels[7]
  69     )
  70     {
  71         labelsPyramid[0] = labels[0];
  72         labelsPyramid[1] = labels[1];
  73         labelsPyramid[2] = labels[2];
  74         labelsPyramid[3] = labels[3];
  75         labelsPyramid[4] = labels[4];
  76         cellShapes_[nCreatedCells] = cellShape(*pyrPtr_, labelsPyramid);
  77     }
  78
  79     else if // Tet Wedge
  80     (
  81         labels[2] == labels[3]
  82      && labels[4] == labels[5]
  83      && labels[6] == labels[7]
  84     )
  85     {
  86         labelsTetWedge[0] = labels[0];
  87         labelsTetWedge[1] = labels[1];
  88         labelsTetWedge[2] = labels[2];
  89         labelsTetWedge[3] = labels[4];
  90         labelsTetWedge[4] = labels[6];
  91         cellShapes_[nCreatedCells] = cellShape(*tetWedgePtr_, labelsTetWedge);
  92     }
  93
  94     else if // Triangular prism
  95     (
  96         labels[2] == labels[3]
  97      && labels[6] == labels[7]
  98     )
  99     {
 100         labelsPrism[0] = labels[0];
 101         labelsPrism[1] = labels[1];
 102         labelsPrism[2] = labels[2];
 103         labelsPrism[3] = labels[4];
 104         labelsPrism[4] = labels[5];
 105         labelsPrism[5] = labels[6];
 106         cellShapes_[nCreatedCells] = cellShape(*prismPtr_, labelsPrism);
 107     }
 108
 109     else if // Wedge
 110     (
 111         labels[4] == labels[7]
 112     )
 113     {
 114         labelsWedge[0] = labels[7];
 115         labelsWedge[1] = labels[6];
 116         labelsWedge[2] = labels[5];
 117         labelsWedge[3] = labels[3];
 118         labelsWedge[4] = labels[2];
 119         labelsWedge[5] = labels[1];
 120         labelsWedge[6] = labels[0];
 121         cellShapes_[nCreatedCells] = cellShape(*wedgePtr_, labelsWedge);
 122     }
 123
 124     else    // Hex
 125     {
 126         labelsHex[0] = labels[0];
 127         labelsHex[1] = labels[1];
 128         labelsHex[2] = labels[2];
 129         labelsHex[3] = labels[3];
 130         labelsHex[4] = labels[4];
 131         labelsHex[5] = labels[5];
 132         labelsHex[6] = labels[6];
 133         labelsHex[7] = labels[7];
 134         cellShapes_[nCreatedCells] = cellShape(*hexPtr_, labelsHex);
 135     }
 136 }
 137
 138
 139 void sammMesh::addSAMMcell
 140 (
 141     const label typeFlag,
 142     const labelList& globalLabels,
 143     const label nCreatedCells
 144 )
 145 {
 146
 147     // grab the shape from the table
 148     if (!sammShapeLookup[typeFlag] || !sammAddressingTable[typeFlag])
 149     {
 150         FatalErrorIn
 151         (
 152             "sammMesh::addRegularCell(const labelList& labels, "
 153             "const label nCreatedCells)"
 154         )   << "SAMM type " << typeFlag << " has no registered label. BUG!"
 155             << abort(FatalError);
 156     }
 157
 158      const cellModel& curModel = *(sammShapeLookup[typeFlag]);
 159
 160     // get reference to the addressing list
 161     const label* addressing = sammAddressingTable[typeFlag];
 162
 163     // make a list of labels
 164     labelList sammCellLabels(curModel.nPoints(), -1);
 165
 166     forAll (sammCellLabels, labelI)
 167     {
 168         sammCellLabels[labelI] = globalLabels[addressing[labelI]];
 169     }
 170
 171     cellShapes_[nCreatedCells] = cellShape(curModel, sammCellLabels);
 172 }
 173
 174
 175 void sammMesh::readCells()
 176 {
 177     label nCells = 0;
 178     label maxLabel = -1;
 179
 180     fileName cellsFileName(casePrefix_ + ".cel");
 181
 182     {
 183         IFstream cellsFile(cellsFileName);
 184
 185         if (cellsFile.good())
 186         {
 187             label lineLabel, cellLabel = -1, pointLabel, regionLabel, typeFlag;
 188
 189             maxLabel = -1;
 190             while (!(cellsFile >> lineLabel).eof())
 191             {
 192                 maxLabel = max(maxLabel, lineLabel);
 193                 for (int i=0; i<8; i++)
 194                 {
 195                     cellsFile >> pointLabel;
 196                 }
 197
 198                 cellsFile >> regionLabel;
 199                 cellsFile >> typeFlag;
 200
 201                 if (lineLabel != cellLabel)
 202                 {
 203                     cellLabel = lineLabel;
 204                     nCells++;
 205                 }
 206             }
 207         }
 208         else
 209         {
 210             FatalErrorIn("sammMesh::readCells()")
 211                 << "Cannot read file "
 212                 << cellsFileName
 213                 << abort(FatalError);
 214         }
 215     }
 216
 217     Info<< "Number of cells = " << nCells << endl << endl;
 218
 219     cellShapes_.setSize(nCells);
 220
 221     starCellLabelLookup_.setSize(maxLabel+1);
 222
 223     // reset point labels to invalid value
 224     forAll (starCellLabelLookup_, i)
 225     {
 226         starCellLabelLookup_[i] = -1;
 227     }
 228
 229
 230     if (nCells > 0)
 231     {
 232         IFstream cellsFile(cellsFileName);
 233
 234         labelList labels(24, -1);
 235         label lineLabel, sammLabel, regionLabel, typeFlag;
 236
 237         for (label cellI = 0; cellI < nCells; cellI++)
 238         {
 239             label nLabels = 0;
 240
 241             bool addOnToCell = false;
 242
 243             do
 244             {
 245                 if (nLabels > 24)
 246                 {
 247                     FatalErrorIn("sammMesh::readCells()")
 248                         << "Unknown SAMM cell. "
 249                         << "More than 24 vertices"
 250                         << abort(FatalError);
 251                 }
 252
 253                 if ((cellsFile >> lineLabel).eof())
 254                 {
 255                     FatalErrorIn("sammMesh::readCells()")
 256                         << "Reached end of cells file before "
 257                         << "all cells are read in."
 258                         << abort(FatalError);
 259                 }
 260
 261                 // prepare for possible continuation
 262                 nLabels += 8;
 263
 264                 for (int i=nLabels-8; i<nLabels; i++)
 265                 {
 266                     cellsFile >> sammLabel;
 267
 268                     if (sammLabel != 0)
 269                     {
 270                         // Convert Samm vertex number to point label
 271                         labels[i] = starPointLabelLookup_[sammLabel];
 272
 273                         if (labels[i] < 0)
 274                         {
 275                             Info<< "Cell file not consistent with vertex file. "
 276                                 << "Samm vertex number " << sammLabel
 277                                 << " does not exist\n";
 278                         }
 279                     }
 280                     else
 281                     {
 282                         labels[i] = -1;
 283                     }
 284                 }
 285
 286                 cellsFile >> regionLabel;
 287                 cellsFile >> typeFlag;
 288
 289                 // check for continuation line
 290                 if (!addOnToCell && typeFlag == 255)
 291                 {
 292                     addOnToCell = true;
 293                 }
 294                 else
 295                 {
 296                     addOnToCell = false;
 297                 }
 298
 299             } while (typeFlag == -1 || addOnToCell);
 300
 301             starCellLabelLookup_[lineLabel] = cellI;
 302
 303             if (nLabels == 8)
 304             {
 305                 addRegularCell(labels, cellI);
 306             }
 307             else
 308             {
 309                 addSAMMcell(typeFlag, labels, cellI);
 310             }
 311         }
 312     }
 313     else
 314     {
 315         FatalErrorIn("sammMesh::readCells()")
 316             << "No cells in file "
 317             << cellsFileName
 318             << abort(FatalError);
 319     }
 320 }
 321
 322
 323 // ************************************************************************* //