applications/utilities/postProcessing/graphics/PV3FoamReader/vtkPV3Foam/vtkPV3FoamFaceField.H

   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 InClass
  26     vtkPV3Foam
  27
  28 \*---------------------------------------------------------------------------*/
  29
  30 #ifndef vtkPV3FoamFaceField_H
  31 #define vtkPV3FoamFaceField_H
  32
  33 // VTK includes
  34 #include "vtkCellData.h"
  35 #include "vtkFloatArray.h"
  36 #include "vtkMultiBlockDataSet.h"
  37 #include "vtkPolyData.h"
  38
  39 #include "vtkOpenFOAMTupleRemap.H"
  40
  41 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  42
  43 template<class Type>
  44 void Foam::vtkPV3Foam::convertFaceField
  45 (
  46     const GeometricField<Type, fvPatchField, volMesh>& tf,
  47     vtkMultiBlockDataSet* output,
  48     const partInfo& selector,
  49     const label datasetNo,
  50     const fvMesh& mesh,
  51     const labelList& faceLabels
  52 )
  53 {
  54     const label nComp = pTraits<Type>::nComponents;
  55     const label nInternalFaces = mesh.nInternalFaces();
  56     const label nFaces = mesh.nFaces();
  57     const labelList& faceOwner = mesh.faceOwner();
  58     const labelList& faceNeigh = mesh.faceNeighbour();
  59
  60     vtkFloatArray *cellData = vtkFloatArray::New();
  61     cellData->SetNumberOfTuples( faceLabels.size() );
  62     cellData->SetNumberOfComponents( nComp );
  63     cellData->Allocate( nComp*faceLabels.size() );
  64     cellData->SetName( tf.name().c_str() );
  65
  66     if (debug)
  67     {
  68         Info<< "convert convertFaceField: "
  69             << tf.name()
  70             << " size = " << tf.size()
  71             << " nComp=" << nComp
  72             << " nTuples = " << faceLabels.size() <<  endl;
  73     }
  74
  75     float vec[nComp];
  76
  77     // for interior faces: average owner/neighbour
  78     // for boundary faces: owner
  79     forAll(faceLabels, faceI)
  80     {
  81         // Bug fix: filter inactive faces.  HJ, 21/Mar/2011
  82         const label faceNo = faceLabels[faceI];
  83
  84         if (faceNo < nInternalFaces)
  85         {
  86             Type t = 0.5*(tf[faceOwner[faceNo]] + tf[faceNeigh[faceNo]]);
  87
  88             for (direction d = 0; d < nComp; d++)
  89             {
  90                 vec[d] = component(t, d);
  91             }
  92         }
  93         else if (faceNo < nFaces)
  94         {
  95             const Type& t = tf[faceOwner[faceNo]];
  96             for (direction d = 0; d < nComp; d++)
  97             {
  98                 vec[d] = component(t, d);
  99             }
 100         }
 101         else
 102         {
 103             for (direction d = 0; d < nComp; d++)
 104             {
 105                 vec[d] = 0;
 106             }
 107         }
 108         vtkOpenFOAMTupleRemap<Type>(vec);
 109
 110         cellData->InsertTuple(faceI, vec);
 111     }
 112
 113
 114     vtkPolyData::SafeDownCast
 115     (
 116         GetDataSetFromBlock(output, selector, datasetNo)
 117     )   ->GetCellData()
 118         ->AddArray(cellData);
 119
 120     cellData->Delete();
 121 }
 122
 123
 124 template<class Type>
 125 void Foam::vtkPV3Foam::convertFaceField
 126 (
 127     const GeometricField<Type, fvPatchField, volMesh>& tf,
 128     vtkMultiBlockDataSet* output,
 129     const partInfo& selector,
 130     const label datasetNo,
 131     const fvMesh& mesh,
 132     const faceSet& fSet
 133 )
 134 {
 135     const label nComp = pTraits<Type>::nComponents;
 136     const label nInternalFaces = mesh.nInternalFaces();
 137     const label nFaces = mesh.nFaces();
 138     const labelList& faceOwner = mesh.faceOwner();
 139     const labelList& faceNeigh = mesh.faceNeighbour();
 140
 141     vtkFloatArray *cellData = vtkFloatArray::New();
 142     cellData->SetNumberOfTuples( fSet.size() );
 143     cellData->SetNumberOfComponents( nComp );
 144     cellData->Allocate( nComp*fSet.size() );
 145     cellData->SetName( tf.name().c_str() );
 146
 147     if (debug)
 148     {
 149         Info<< "convert convertFaceField: "
 150             << tf.name()
 151             << " size = " << tf.size()
 152             << " nComp=" << nComp
 153             << " nTuples = " << fSet.size() <<  endl;
 154     }
 155
 156     float vec[nComp];
 157
 158     // for interior faces: average owner/neighbour
 159     // for boundary faces: owner
 160     label faceI = 0;
 161     forAllConstIter(faceSet, fSet, iter)
 162     {
 163         const label faceNo = iter.key();
 164
 165         // Bug fix: filter inactive faces.  HJ, 21/Mar/2011
 166         if (faceNo < nInternalFaces)
 167         {
 168             Type t = 0.5*(tf[faceOwner[faceNo]] + tf[faceNeigh[faceNo]]);
 169
 170             for (direction d = 0; d < nComp; d++)
 171             {
 172                 vec[d] = component(t, d);
 173             }
 174         }
 175         else if (faceNo < nFaces)
 176         {
 177             const Type& t = tf[faceOwner[faceNo]];
 178             for (direction d = 0; d < nComp; d++)
 179             {
 180                 vec[d] = component(t, d);
 181             }
 182         }
 183         else
 184         {
 185             for (direction d = 0; d < nComp; d++)
 186             {
 187                 vec[d] = 0;
 188             }
 189         }
 190         vtkOpenFOAMTupleRemap<Type>(vec);
 191
 192         cellData->InsertTuple(faceI, vec);
 193         ++faceI;
 194     }
 195
 196
 197     vtkPolyData::SafeDownCast
 198     (
 199         GetDataSetFromBlock(output, selector, datasetNo)
 200     )   ->GetCellData()
 201         ->AddArray(cellData);
 202
 203     cellData->Delete();
 204 }
 205
 206 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 207
 208 #endif
 209
 210 // ************************************************************************* //