applications/utilities/postProcessing/dataConversion/foamToTecplot360/tecplotWriter.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright held by original author
   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 \*---------------------------------------------------------------------------*/
  26
  27 #include "objectRegistry.H"
  28 #include "tecplotWriter.H"
  29 #include "fvMesh.H"
  30
  31 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  32
  33 // Construct from components
  34 Foam::tecplotWriter::tecplotWriter(const Time& runTime)
  35 :
  36     runTime_(runTime)
  37 {}
  38
  39
  40 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
  41
  42 void Foam::tecplotWriter::writeInit
  43 (
  44     const word& name,
  45     const string& varNames,
  46     const fileName& fName,
  47     INTEGER4 tecplotFileType
  48 ) const
  49 {
  50 Pout<< endl
  51     << endl
  52     << "Name:" << name
  53     << " varNames:" << varNames
  54     << " to file:" << fName
  55     << " of type:" << tecplotFileType
  56     << endl;
  57
  58     INTEGER4 IsDouble = 0;  //float
  59     INTEGER4 Debug = 0;     //nodebug
  60     if
  61     (
  62         !TECINI112
  63         (
  64             const_cast<char*>(name.c_str()),       /* Data Set Title       */
  65             const_cast<char*>(varNames.c_str()),   /* Variable List        */
  66             const_cast<char*>(fName.c_str()),      /* File Name            */
  67             const_cast<char*>(runTime_.path().c_str()), /* Scratch Directory */
  68             &tecplotFileType,
  69             &Debug,
  70             &IsDouble
  71         )
  72     )
  73     {
  74 //        FatalErrorIn("tecplotWriter::writeInit(..) const")
  75 //            << "Error in TECINI112." << exit(FatalError);
  76     }
  77 }
  78
  79
  80 void Foam::tecplotWriter::writePolyhedralZone
  81 (
  82     const word& zoneName,
  83     INTEGER4 strandID,
  84     const fvMesh& mesh,
  85     const List<INTEGER4>& varLocArray,
  86     INTEGER4 nFaceNodes
  87 ) const
  88 {
  89     /* Call TECZNE112 */
  90     INTEGER4  NumNodes   = mesh.nPoints();         /* number of unique nodes */
  91     INTEGER4  NumElems   = mesh.nCells();         /* number of elements */
  92     INTEGER4  NumFaces   = mesh.nFaces();         /* number of unique faces */
  93
  94     INTEGER4  ICellMax   = 0;         /* Not Used, set to zero */
  95     INTEGER4  JCellMax   = 0;         /* Not Used, set to zero */
  96     INTEGER4  KCellMax   = 0;         /* Not Used, set to zero */
  97
  98     double    SolTime    = runTime_.value();     /* solution time   */
  99     INTEGER4  ParentZone = 0;         /* no parent zone  */
 100
 101     INTEGER4  IsBlock    = 1;         /* block format  */
 102
 103     INTEGER4  NFConns    = 0;         /* not used for FEPolyhedron
 104                                        * zones
 105                                        */
 106     INTEGER4  FNMode     = 0;         /* not used for FEPolyhedron
 107                                        * zones
 108                                        */
 109 Pout<< "zoneName:" << zoneName
 110     //<< " varLocArray:" << varLocArray
 111     << " solTime:" << SolTime
 112     << endl;
 113
 114
 115
 116     INTEGER4 *PassiveVarArray = NULL;
 117     INTEGER4 *VarShareArray   = NULL;
 118     INTEGER4  ShrConn         = 0;
 119
 120     INTEGER4  NumBConns       = 0;   /* No Boundary Connections */
 121     INTEGER4  NumBItems       = 0;   /* No Boundary Items */
 122
 123     INTEGER4  ZoneType = ZoneType_FEPolyhedron;
 124
 125     if
 126     (
 127        !TECZNE112
 128         (
 129             const_cast<char*>(zoneName.c_str()),
 130             &ZoneType,
 131             &NumNodes,
 132             &NumElems,
 133             &NumFaces,
 134             &ICellMax,
 135             &JCellMax,
 136             &KCellMax,
 137             &SolTime,
 138             &strandID,
 139             &ParentZone,
 140             &IsBlock,
 141             &NFConns,
 142             &FNMode,
 143             &nFaceNodes,
 144             &NumBConns,
 145             &NumBItems,
 146             PassiveVarArray,
 147             const_cast<INTEGER4*>(varLocArray.begin()),
 148             VarShareArray,
 149             &ShrConn
 150         )
 151     )
 152     {
 153 //        FatalErrorIn("tecplotWriter::writePolyhedralZone(..) const")
 154 //            << "Error in TECZNE112." << exit(FatalError);
 155     }
 156 }
 157
 158
 159 void Foam::tecplotWriter::writePolygonalZone
 160 (
 161     const word& zoneName,
 162     INTEGER4 strandID,
 163     const indirectPrimitivePatch& pp,
 164     const List<INTEGER4>& varLocArray
 165 ) const
 166 {
 167     /* Call TECZNE112 */
 168     INTEGER4  NumNodes   = pp.nPoints();         /* number of unique nodes */
 169     INTEGER4  NumElems   = pp.size();         /* number of elements */
 170     INTEGER4  NumFaces   = pp.nEdges();         /* number of unique faces */
 171
 172     INTEGER4  ICellMax   = 0;         /* Not Used, set to zero */
 173     INTEGER4  JCellMax   = 0;         /* Not Used, set to zero */
 174     INTEGER4  KCellMax   = 0;         /* Not Used, set to zero */
 175
 176     double    SolTime    = runTime_.value();     /* solution time   */
 177     INTEGER4  ParentZone = 0;         /* no parent zone  */
 178
 179     INTEGER4  IsBlock    = 1;         /* block format  */
 180
 181     INTEGER4  NFConns    = 0;         /* not used for FEPolyhedron
 182                                        * zones
 183                                        */
 184     INTEGER4  FNMode     = 0;         /* not used for FEPolyhedron
 185                                        * zones
 186                                        */
 187     INTEGER4  NumFaceNodes    = 2*pp.nEdges();
 188
 189 Pout<< "zoneName:" << zoneName
 190     << " strandID:" << strandID
 191     //<< " varLocArray:" << varLocArray
 192     << " solTime:" << SolTime
 193     << endl;
 194
 195
 196     INTEGER4 *PassiveVarArray = NULL;
 197     INTEGER4 *VarShareArray   = NULL;
 198     INTEGER4  ShrConn         = 0;
 199
 200     INTEGER4  NumBConns       = 0;   /* No Boundary Connections */
 201     INTEGER4  NumBItems       = 0;   /* No Boundary Items */
 202
 203     INTEGER4  ZoneType = ZoneType_FEPolygon;
 204
 205     if
 206     (
 207        !TECZNE112
 208         (
 209             const_cast<char*>(zoneName.c_str()),
 210             &ZoneType,
 211             &NumNodes,
 212             &NumElems,
 213             &NumFaces,
 214             &ICellMax,
 215             &JCellMax,
 216             &KCellMax,
 217             &SolTime,
 218             &strandID,
 219             &ParentZone,
 220             &IsBlock,
 221             &NFConns,
 222             &FNMode,
 223             &NumFaceNodes,
 224             &NumBConns,
 225             &NumBItems,
 226             PassiveVarArray,
 227             const_cast<INTEGER4*>(varLocArray.begin()),
 228             VarShareArray,
 229             &ShrConn
 230         )
 231     )
 232     {
 233 //        FatalErrorIn("tecplotWriter::writePolygonalZone(..) const")
 234 //            << "Error in TECZNE112." << exit(FatalError);
 235     }
 236 }
 237
 238
 239 void Foam::tecplotWriter::writeOrderedZone
 240 (
 241     const word& zoneName,
 242     INTEGER4 strandID,
 243     const label n,
 244     const List<INTEGER4>& varLocArray
 245 ) const
 246 {
 247     /* Call TECZNE112 */
 248     INTEGER4  IMax   = n;         /* number of unique nodes */
 249     INTEGER4  JMax   = 1;         /* number of elements */
 250     INTEGER4  KMax   = 1;         /* number of unique faces */
 251
 252     INTEGER4  ICellMax   = 0;         /* Not Used, set to zero */
 253     INTEGER4  JCellMax   = 0;         /* Not Used, set to zero */
 254     INTEGER4  KCellMax   = 0;         /* Not Used, set to zero */
 255
 256     double    SolTime    = runTime_.value();     /* solution time   */
 257     INTEGER4  ParentZone = 0;         /* no parent zone  */
 258
 259     INTEGER4  IsBlock    = 1;         /* block format  */
 260
 261     INTEGER4  NFConns    = 0;         /* not used for FEPolyhedron
 262                                        * zones
 263                                        */
 264     INTEGER4  FNMode     = 0;         /* not used for FEPolyhedron
 265                                        * zones
 266                                        */
 267     INTEGER4  NumFaceNodes    = 1;
 268     INTEGER4  NumBConns       = 1;   /* No Boundary Connections */
 269     INTEGER4  NumBItems       = 1;   /* No Boundary Items */
 270
 271 Pout<< "zoneName:" << zoneName
 272     << " strandID:" << strandID
 273     //<< " varLocArray:" << varLocArray
 274     << " solTime:" << SolTime
 275     << endl;
 276
 277
 278     INTEGER4 *PassiveVarArray = NULL;
 279     INTEGER4 *VarShareArray   = NULL;
 280     INTEGER4  ShrConn         = 0;
 281
 282
 283     INTEGER4  ZoneType = ZoneType_Ordered;
 284
 285     if
 286     (
 287        !TECZNE112
 288         (
 289             const_cast<char*>(zoneName.c_str()),
 290             &ZoneType,
 291             &IMax,
 292             &JMax,
 293             &KMax,
 294             &ICellMax,
 295             &JCellMax,
 296             &KCellMax,
 297             &SolTime,
 298             &strandID,
 299             &ParentZone,
 300             &IsBlock,
 301             &NFConns,
 302             &FNMode,
 303             &NumFaceNodes,
 304             &NumBConns,
 305             &NumBItems,
 306             PassiveVarArray,
 307             const_cast<INTEGER4*>(varLocArray.begin()),
 308             VarShareArray,
 309             &ShrConn
 310         )
 311     )
 312     {
 313 //        FatalErrorIn("tecplotWriter::writePolygonalZone(..) const")
 314 //            << "Error in TECZNE112." << exit(FatalError);
 315     }
 316 }
 317
 318
 319 void Foam::tecplotWriter::writeConnectivity(const fvMesh& mesh) const
 320 {
 321     List<INTEGER4> FaceNodeCounts(mesh.nFaces());
 322
 323     forAll(mesh.faces(), faceI)
 324     {
 325         const face& f = mesh.faces()[faceI];
 326         FaceNodeCounts[faceI] = INTEGER4(f.size());
 327     }
 328
 329
 330     INTEGER4 nFaceNodes = 0;
 331     forAll(mesh.faces(), faceI)
 332     {
 333         nFaceNodes += mesh.faces()[faceI].size();
 334     }
 335
 336
 337     List<INTEGER4> FaceNodes(nFaceNodes);
 338     label nodeI = 0;
 339     forAll(mesh.faces(), faceI)
 340     {
 341         const face& f = mesh.faces()[faceI];
 342         forAll(f, fp)
 343         {
 344             FaceNodes[nodeI++] = INTEGER4(f[fp]+1);
 345         }
 346     }
 347
 348
 349     List<INTEGER4> FaceLeftElems(mesh.nFaces());
 350     forAll(mesh.faceOwner(), faceI)
 351     {
 352         FaceLeftElems[faceI] = mesh.faceOwner()[faceI]+1;
 353     }
 354
 355     List<INTEGER4> FaceRightElems(mesh.nFaces());
 356     forAll(mesh.faceNeighbour(), faceI)
 357     {
 358         FaceRightElems[faceI] = mesh.faceNeighbour()[faceI]+1;
 359     }
 360     for
 361     (
 362         label faceI = mesh.nInternalFaces();
 363         faceI < mesh.nFaces();
 364         faceI++
 365     )
 366     {
 367         FaceRightElems[faceI] = 0;
 368     }
 369
 370     if
 371     (
 372        !TECPOLY112
 373         (
 374             FaceNodeCounts.begin(), /* The face node counts array */
 375             FaceNodes.begin(),      /* The face nodes array */
 376             FaceLeftElems.begin(),  /* The left elements array  */
 377             FaceRightElems.begin(), /* The right elements array  */
 378             NULL,       /* No boundary connection counts */
 379             NULL,       /* No boundary connection elements */
 380             NULL        /* No boundary connection zones */
 381         )
 382     )
 383     {
 384 //        FatalErrorIn("tecplotWriter::writeConnectivity(const fvMesh&) const")
 385 //            << "Error in TECPOLY112." << exit(FatalError);
 386     }
 387 }
 388
 389
 390 void Foam::tecplotWriter::writeConnectivity
 391 (
 392     const indirectPrimitivePatch& pp
 393 ) const
 394 {
 395     INTEGER4  NumFaces   = pp.nEdges();         /* number of unique faces */
 396     INTEGER4  NumFaceNodes    = 2*pp.nEdges();
 397
 398     // All faces (=edges) have 2 nodes
 399     List<INTEGER4> FaceNodeCounts(NumFaces, 2);
 400
 401     List<INTEGER4> FaceNodes(NumFaceNodes);
 402     label nodeI = 0;
 403     forAll(pp.edges(), edgeI)
 404     {
 405         edge e = pp.edges()[edgeI];
 406         if (e[0] > e[1])
 407         {
 408             e = e.reverseEdge();
 409         }
 410
 411         FaceNodes[nodeI++] = INTEGER4(e[0]+1);
 412         FaceNodes[nodeI++] = INTEGER4(e[1]+1);
 413     }
 414
 415     /* Define the right and left elements of each face.
 416      *
 417      * The last step for writing out the polyhedral data is to
 418      * define the right and left neighboring elements for each
 419      * face.  The neighboring elements can be determined using the
 420      * right-hand rule.  For each face, place your right-hand along
 421      * the face which your fingers pointing the direction of
 422      * incrementing node numbers (i.e. from node 1 to node 2).
 423      * Your right thumb will point towards the right element; the
 424      * element on the other side of your hand is the left element.
 425      *
 426      * The number zero is used to indicate that there isn't an
 427      * element on that side of the face.
 428      *
 429      * Because of the way we numbered the nodes and faces, the
 430      * right element for every face is the element itself
 431      * (element 1) and the left element is "no-neighboring element"
 432      * (element 0).
 433      */
 434
 435     List<INTEGER4> FaceLeftElems(NumFaces);
 436     List<INTEGER4> FaceRightElems(NumFaces);
 437
 438     const labelListList& edgeFaces = pp.edgeFaces();
 439     forAll(edgeFaces, edgeI)
 440     {
 441         const labelList& eFaces = edgeFaces[edgeI];
 442
 443         if (eFaces.size() == 1)
 444         {
 445             FaceLeftElems[edgeI] = 0;
 446             FaceRightElems[edgeI] = eFaces[0]+1;
 447         }
 448         else if (eFaces.size() == 2)
 449         {
 450             edge e = pp.edges()[edgeI];
 451             if (e[0] > e[1])
 452             {
 453                 e = e.reverseEdge();
 454             }
 455
 456             const face& f0 = pp.localFaces()[eFaces[0]];
 457
 458             // The face that uses the vertices of e in increasing order
 459             // is the left face.
 460
 461             label fp = findIndex(f0, e[0]);
 462             bool f0IsLeft = (f0.nextLabel(fp) == e[1]);
 463
 464             if (f0IsLeft)
 465             {
 466                 FaceLeftElems[edgeI] = eFaces[0]+1;
 467                 FaceRightElems[edgeI] = eFaces[1]+1;
 468             }
 469             else
 470             {
 471                 FaceLeftElems[edgeI] = eFaces[1]+1;
 472                 FaceRightElems[edgeI] = eFaces[0]+1;
 473             }
 474         }
 475         else
 476         {
 477             // non-manifold. Treat as if open.
 478             FaceLeftElems[edgeI] = 0;
 479             FaceRightElems[edgeI] = eFaces[0]+1;
 480         }
 481     }
 482
 483     /* Write the face map (created above) using TECPOLY112. */
 484     if
 485     (
 486        !TECPOLY112
 487         (
 488             FaceNodeCounts.begin(), /* The face node counts array */
 489             FaceNodes.begin(),      /* The face nodes array */
 490             FaceLeftElems.begin(),  /* The left elements array  */
 491             FaceRightElems.begin(), /* The right elements array  */
 492             NULL,       /* No boundary connection counts */
 493             NULL,       /* No boundary connection elements */
 494             NULL        /* No boundary connection zones */
 495         )
 496     )
 497     {
 498 //        FatalErrorIn("tecplotWriter::writeConnectivity(..) const")
 499 //            << "Error in TECPOLY112." << exit(FatalError);
 500     }
 501 }
 502
 503
 504 void Foam::tecplotWriter::writeEnd() const
 505 {
 506 Pout<< "writeEnd" << endl;
 507
 508     if (!TECEND112())
 509     {
 510 //        FatalErrorIn("tecplotWriter::writeEnd() const")
 511 //            << "Error in TECEND112." << exit(FatalError);
 512     }
 513
 514 }
 515
 516
 517 // ************************************************************************* //