applications/utilities/mesh/conversion/foamMeshToFluent/fluentFvMesh.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 \*---------------------------------------------------------------------------*/
  25
  26 #include <fstream>
  27 #include <iostream>
  28
  29 using std::ofstream;
  30 using std::ios;
  31
  32 #include "objectRegistry.H"
  33 #include "foamTime.H"
  34 #include "fluentFvMesh.H"
  35 #include "primitiveMesh.H"
  36 #include "wallFvPatch.H"
  37 #include "symmetryFvPatch.H"
  38 #include "cellModeller.H"
  39
  40 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  41
  42 Foam::fluentFvMesh::fluentFvMesh(const IOobject& io)
  43 :
  44     fvMesh(io)
  45 {}
  46
  47
  48 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
  49
  50 void Foam::fluentFvMesh::writeFluentMesh() const
  51 {
  52     // make a directory called proInterface in the case
  53     mkDir(time().rootPath()/time().caseName()/"fluentInterface");
  54
  55     // open a file for the mesh
  56     ofstream fluentMeshFile
  57     (
  58         (
  59             time().rootPath()/
  60             time().caseName()/
  61             "fluentInterface"/
  62             time().caseName() + ".msh"
  63         ).c_str()
  64     );
  65
  66     Info << "Writing Header" << endl;
  67
  68     fluentMeshFile
  69         << "(0 \"FOAM to Fluent Mesh File\")" << std::endl << std::endl
  70         << "(0 \"Dimension:\")" << std::endl
  71         << "(2 3)" << std::endl << std::endl
  72         << "(0 \"Grid dimensions:\")" << std::endl;
  73
  74     // Writing number of points
  75     fluentMeshFile
  76             << "(10 (0 1 ";
  77
  78     // Writing hex
  79     fluentMeshFile.setf(ios::hex, ios::basefield);
  80
  81     fluentMeshFile
  82         << nPoints() << " 0 3))" << std::endl;
  83
  84     // Writing number of cells
  85     fluentMeshFile
  86         << "(12 (0 1 "
  87         << nCells() << " 0 0))" << std::endl;
  88
  89     // Writing number of faces
  90     label nFcs = nFaces();
  91
  92     fluentMeshFile
  93             << "(13 (0 1 ";
  94
  95     // Still writing hex
  96     fluentMeshFile
  97         << nFcs << " 0 0))" << std::endl << std::endl;
  98
  99     // Return to dec
 100     fluentMeshFile.setf(ios::dec, ios::basefield);
 101
 102     // Writing points
 103     fluentMeshFile
 104             << "(10 (1 1 ";
 105
 106     fluentMeshFile.setf(ios::hex, ios::basefield);
 107     fluentMeshFile
 108         << nPoints() << " 1 3)"
 109         << std::endl << "(" << std::endl;
 110
 111     fluentMeshFile.precision(10);
 112     fluentMeshFile.setf(ios::scientific);
 113
 114     const pointField& p = points();
 115
 116     forAll (p, pointI)
 117     {
 118         fluentMeshFile
 119             << "    "
 120             << p[pointI].x() << " "
 121             << p[pointI].y()
 122             << " " << p[pointI].z() << std::endl;
 123     }
 124
 125     fluentMeshFile
 126         << "))" << std::endl << std::endl;
 127
 128     const unallocLabelList& own = owner();
 129     const unallocLabelList& nei = neighbour();
 130
 131     const faceList& fcs = faces();
 132
 133     // Writing (mixed) internal faces
 134     fluentMeshFile
 135         << "(13 (2 1 "
 136         << own.size() << " 2 0)" << std::endl << "(" << std::endl;
 137
 138     forAll (own, faceI)
 139     {
 140         const labelList& l = fcs[faceI];
 141
 142         fluentMeshFile << "    ";
 143
 144         fluentMeshFile << l.size() << " ";
 145
 146         forAll (l, lI)
 147         {
 148             fluentMeshFile << l[lI] + 1 << " ";
 149         }
 150
 151         fluentMeshFile << nei[faceI] + 1 << " ";
 152         fluentMeshFile << own[faceI] + 1 << std::endl;
 153     }
 154
 155     fluentMeshFile << "))" << std::endl;
 156
 157     label nWrittenFaces = own.size();
 158
 159     // Writing boundary faces
 160     forAll (boundary(), patchI)
 161     {
 162         const unallocFaceList& patchFaces = boundaryMesh()[patchI];
 163
 164         const labelList& patchFaceCells =
 165             boundaryMesh()[patchI].faceCells();
 166
 167         // The face group will be offset by 10 from the patch label
 168
 169         // Write header
 170         fluentMeshFile
 171             << "(13 (" << patchI + 10 << " " << nWrittenFaces + 1
 172             << " " << nWrittenFaces + patchFaces.size() << " ";
 173
 174         nWrittenFaces += patchFaces.size();
 175
 176         // Write patch type
 177         if (isA<wallFvPatch>(boundary()[patchI]))
 178         {
 179             fluentMeshFile << 3;
 180         }
 181         else if (isA<symmetryFvPatch>(boundary()[patchI]))
 182         {
 183             fluentMeshFile << 7;
 184         }
 185         else
 186         {
 187             fluentMeshFile << 4;
 188         }
 189
 190         fluentMeshFile
 191             <<" 0)" << std::endl << "(" << std::endl;
 192
 193         forAll (patchFaces, faceI)
 194         {
 195             const labelList& l = patchFaces[faceI];
 196
 197             fluentMeshFile << "    ";
 198
 199             fluentMeshFile << l.size() << " ";
 200
 201             // Note: In Fluent, all boundary faces point inwards, which is
 202             // opposite from the FOAM convention. Turn them round on printout
 203             forAllReverse (l, lI)
 204             {
 205                 fluentMeshFile << l[lI] + 1 << " ";
 206             }
 207
 208             fluentMeshFile << patchFaceCells[faceI] + 1 << " 0" << std::endl;
 209         }
 210
 211         fluentMeshFile << "))" << std::endl;
 212     }
 213
 214     // Writing cells
 215     fluentMeshFile
 216         << "(12 (1 1 "
 217         << nCells() << " 1 0)(" << std::endl;
 218
 219     const cellModel& hex = *(cellModeller::lookup("hex"));
 220     const cellModel& prism = *(cellModeller::lookup("prism"));
 221     const cellModel& pyr = *(cellModeller::lookup("pyr"));
 222     const cellModel& tet = *(cellModeller::lookup("tet"));
 223
 224     const cellShapeList& cells = cellShapes();
 225
 226     bool hasWarned = false;
 227
 228     forAll (cells, cellI)
 229     {
 230         if (cells[cellI].model() == tet)
 231         {
 232             fluentMeshFile << " " << 2;
 233         }
 234         else if (cells[cellI].model() == hex)
 235         {
 236             fluentMeshFile << " " << 4;
 237         }
 238         else if (cells[cellI].model() == pyr)
 239         {
 240             fluentMeshFile << " " << 5;
 241         }
 242         else if (cells[cellI].model() == prism)
 243         {
 244             fluentMeshFile << " " << 6;
 245         }
 246         else
 247         {
 248             if (!hasWarned)
 249             {
 250                 hasWarned = true;
 251
 252                 WarningIn("void fluentFvMesh::writeFluentMesh() const")
 253                     << "foamMeshToFluent: cell shape for cell "
 254                     << cellI << " only supported by Fluent polyhedral meshes."
 255                     << nl
 256                     << "    Suppressing any further messages for polyhedral"
 257                     << " cells." << endl;
 258             }
 259             fluentMeshFile << " " << 7;
 260         }
 261     }
 262
 263     fluentMeshFile << ")())" << std::endl;
 264
 265     // Return to dec
 266     fluentMeshFile.setf(ios::dec, ios::basefield);
 267
 268     // Writing patch types
 269     fluentMeshFile << "(39 (1 fluid fluid-1)())" << std::endl;
 270     fluentMeshFile << "(39 (2 interior interior-1)())" << std::endl;
 271
 272     // Writing boundary patch types
 273     forAll (boundary(), patchI)
 274     {
 275         fluentMeshFile
 276             << "(39 (" << patchI + 10 << " ";
 277
 278         // Write patch type
 279         if (isA<wallFvPatch>(boundary()[patchI]))
 280         {
 281             fluentMeshFile << "wall ";
 282         }
 283         else if (isA<symmetryFvPatch>(boundary()[patchI]))
 284         {
 285             fluentMeshFile << "symmetry ";
 286         }
 287         else
 288         {
 289             fluentMeshFile << "pressure-outlet ";
 290         }
 291
 292         fluentMeshFile
 293             << boundary()[patchI].name() << ")())" << std::endl;
 294     }
 295 }
 296
 297
 298 // ************************************************************************* //