applications/utilities/postProcessing/dataConversion/foamToVTK/patchWriter.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 "patchWriter.H"
  27 #include "writeFuns.H"
  28
  29 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  30
  31 Foam::patchWriter::patchWriter
  32 (
  33     const vtkMesh& vMesh,
  34     const bool binary,
  35     const bool nearCellValue,
  36     const fileName& fName,
  37     const labelList& patchIDs
  38 )
  39 :
  40     vMesh_(vMesh),
  41     binary_(binary),
  42     nearCellValue_(nearCellValue),
  43     fName_(fName),
  44     patchIDs_(patchIDs),
  45     os_(fName.c_str())
  46 {
  47     const fvMesh& mesh = vMesh_.mesh();
  48     const polyBoundaryMesh& patches = mesh.boundaryMesh();
  49
  50     // Write header
  51     if (patchIDs_.size() == 1)
  52     {
  53         writeFuns::writeHeader(os_, binary_, patches[patchIDs_[0]].name());
  54     }
  55     else
  56     {
  57         writeFuns::writeHeader(os_, binary_, "patches");
  58     }
  59     os_ << "DATASET POLYDATA" << std::endl;
  60
  61     // Write topology
  62     nPoints_ = 0;
  63     nFaces_ = 0;
  64     label nFaceVerts = 0;
  65
  66     forAll(patchIDs_, i)
  67     {
  68         const polyPatch& pp = patches[patchIDs_[i]];
  69
  70         nPoints_ += pp.nPoints();
  71         nFaces_ += pp.size();
  72
  73         forAll(pp, faceI)
  74         {
  75             nFaceVerts += pp[faceI].size() + 1;
  76         }
  77     }
  78
  79     os_ << "POINTS " << nPoints_ << " float" << std::endl;
  80
  81     DynamicList<floatScalar> ptField(3*nPoints_);
  82
  83     forAll(patchIDs_, i)
  84     {
  85         const polyPatch& pp = patches[patchIDs_[i]];
  86
  87         writeFuns::insert(pp.localPoints(), ptField);
  88     }
  89     writeFuns::write(os_, binary_, ptField);
  90
  91     os_ << "POLYGONS " << nFaces_ << ' ' << nFaceVerts << std::endl;
  92
  93     DynamicList<label> vertLabels(nFaceVerts);
  94
  95     label offset = 0;
  96
  97     forAll(patchIDs_, i)
  98     {
  99         const polyPatch& pp = patches[patchIDs_[i]];
 100
 101         forAll(pp, faceI)
 102         {
 103             const face& f = pp.localFaces()[faceI];
 104
 105             vertLabels.append(f.size());
 106             writeFuns::insert(f + offset, vertLabels);
 107         }
 108         offset += pp.nPoints();
 109     }
 110     writeFuns::write(os_, binary_, vertLabels);
 111 }
 112
 113
 114 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 115
 116 void Foam::patchWriter::writePatchIDs()
 117 {
 118     const fvMesh& mesh = vMesh_.mesh();
 119
 120     DynamicList<floatScalar> fField(nFaces_);
 121
 122     os_ << "patchID 1 " << nFaces_ << " float" << std::endl;
 123
 124     forAll(patchIDs_, i)
 125     {
 126         label patchI = patchIDs_[i];
 127
 128         const polyPatch& pp = mesh.boundaryMesh()[patchI];
 129
 130         if (!isA<emptyPolyPatch>(pp))
 131         {
 132             writeFuns::insert(scalarField(pp.size(), patchI), fField);
 133         }
 134     }
 135     writeFuns::write(os_, binary_, fField);
 136 }
 137
 138
 139 // ************************************************************************* //