applications/utilities/mesh/conversion/foamMeshToFluent/fluentFvMesh.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
   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
  13     the Free Software Foundation, either version 3 of the License, or
  14     (at your 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, 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 "Time.H"
  33 #include "fluentFvMesh.H"
  34 #include "primitiveMesh.H"
  35 #include "wallFvPatch.H"
  36 #include "symmetryFvPatch.H"
  37 #include "cellModeller.H"
  38
  39 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  40
  41 Foam::fluentFvMesh::fluentFvMesh(const IOobject& io)
  42 :
  43     fvMesh(io)
  44 {}
  45
  46
  47 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
  48
  49 void Foam::fluentFvMesh::writeFluentMesh() const
  50 {
  51     // make a directory called proInterface in the case
  52     mkDir(time().rootPath()/time().caseName()/"fluentInterface");
  53
  54     // open a file for the mesh
  55     ofstream fluentMeshFile
  56     (
  57         (
  58             time().rootPath()/
  59             time().caseName()/
  60             "fluentInterface"/
  61             time().caseName() + ".msh"
  62         ).c_str()
  63     );
  64
  65     Info<< "Writing Header" << endl;
  66
  67     fluentMeshFile
  68         << "(0 \"FOAM to Fluent Mesh File\")" << std::endl << std::endl
  69         << "(0 \"Dimension:\")" << std::endl
  70         << "(2 3)" << std::endl << std::endl
  71         << "(0 \"Grid dimensions:\")" << std::endl;
  72
  73     // Writing number of points
  74     fluentMeshFile
  75             << "(10 (0 1 ";
  76
  77     // Writing hex
  78     fluentMeshFile.setf(ios::hex, ios::basefield);
  79
  80     fluentMeshFile
  81         << nPoints() << " 0 3))" << std::endl;
  82
  83     // Writing number of cells
  84     fluentMeshFile
  85         << "(12 (0 1 "
  86         << nCells() << " 0 0))" << std::endl;
  87
  88     // Writing number of faces
  89     label nFcs = nFaces();
  90
  91     fluentMeshFile
  92             << "(13 (0 1 ";
  93
  94     // Still writing hex
  95     fluentMeshFile
  96         << nFcs << " 0 0))" << std::endl << std::endl;
  97
  98     // Return to dec
  99     fluentMeshFile.setf(ios::dec, ios::basefield);
 100
 101     // Writing points
 102     fluentMeshFile
 103             << "(10 (1 1 ";
 104
 105     fluentMeshFile.setf(ios::hex, ios::basefield);
 106     fluentMeshFile
 107         << nPoints() << " 1 3)"
 108         << std::endl << "(" << std::endl;
 109
 110     fluentMeshFile.precision(10);
 111     fluentMeshFile.setf(ios::scientific);
 112
 113     const pointField& p = points();
 114
 115     forAll(p, pointI)
 116     {
 117         fluentMeshFile
 118             << "    "
 119             << p[pointI].x() << " "
 120             << p[pointI].y()
 121             << " " << p[pointI].z() << std::endl;
 122     }
 123
 124     fluentMeshFile
 125         << "))" << std::endl << std::endl;
 126
 127     const labelUList& own = owner();
 128     const labelUList& nei = neighbour();
 129
 130     const faceList& fcs = faces();
 131
 132     // Writing (mixed) internal faces
 133     fluentMeshFile
 134         << "(13 (2 1 "
 135         << own.size() << " 2 0)" << std::endl << "(" << std::endl;
 136
 137     forAll(own, faceI)
 138     {
 139         const labelList& l = fcs[faceI];
 140
 141         fluentMeshFile << "    ";
 142
 143         fluentMeshFile << l.size() << " ";
 144
 145         forAll(l, lI)
 146         {
 147             fluentMeshFile << l[lI] + 1 << " ";
 148         }
 149
 150         fluentMeshFile << nei[faceI] + 1 << " ";
 151         fluentMeshFile << own[faceI] + 1 << std::endl;
 152     }
 153
 154     fluentMeshFile << "))" << std::endl;
 155
 156     label nWrittenFaces = own.size();
 157
 158     // Writing boundary faces
 159     forAll(boundary(), patchI)
 160     {
 161         const faceUList& patchFaces = boundaryMesh()[patchI];
 162
 163         const labelList& patchFaceCells =
 164             boundaryMesh()[patchI].faceCells();
 165
 166         // The face group will be offset by 10 from the patch label
 167
 168         // Write header
 169         fluentMeshFile
 170             << "(13 (" << patchI + 10 << " " << nWrittenFaces + 1
 171             << " " << nWrittenFaces + patchFaces.size() << " ";
 172
 173         nWrittenFaces += patchFaces.size();
 174
 175         // Write patch type
 176         if (isA<wallFvPatch>(boundary()[patchI]))
 177         {
 178             fluentMeshFile << 3;
 179         }
 180         else if (isA<symmetryFvPatch>(boundary()[patchI]))
 181         {
 182             fluentMeshFile << 7;
 183         }
 184         else
 185         {
 186             fluentMeshFile << 4;
 187         }
 188
 189         fluentMeshFile
 190             <<" 0)" << std::endl << "(" << std::endl;
 191
 192         forAll(patchFaces, faceI)
 193         {
 194             const labelList& l = patchFaces[faceI];
 195
 196             fluentMeshFile << "    ";
 197
 198             fluentMeshFile << l.size() << " ";
 199
 200             // Note: In Fluent, all boundary faces point inwards, which is
 201             // opposite from the OpenFOAM convention.
 202             // Turn them around 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 // ************************************************************************* //