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

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