src/sampling/sampledSurface/sampledPatchInternalField/sampledPatchInternalFieldTemplates.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 "sampledPatchInternalField.H"
  27 #include "interpolationCellPoint.H"
  28 #include "PrimitivePatchInterpolation.H"
  29
  30 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
  31
  32 template <class Type>
  33 Foam::tmp<Foam::Field<Type> >
  34 Foam::sampledPatchInternalField::sampleField
  35 (
  36     const GeometricField<Type, fvPatchField, volMesh>& vField
  37 ) const
  38 {
  39     // One value per face
  40     tmp<Field<Type> > tvalues(new Field<Type>(patchFaceLabels().size()));
  41     Field<Type>& values = tvalues();
  42
  43     forAll(patchStart(), i)
  44     {
  45         // Get patchface wise data by sampling internal field
  46         Field<Type> interpVals = vField.internalField();
  47         mappers_[i].map().distribute(interpVals);
  48
  49         // Store at correct position in values
  50         label end =
  51         (
  52             i < patchStart().size()-1
  53           ? patchStart()[i+1]
  54           : patchFaceLabels().size()
  55         );
  56
  57         for (label triI = patchStart()[i]; triI < end; triI++)
  58         {
  59             values[triI] = interpVals[patchFaceLabels()[triI]];
  60         }
  61     }
  62
  63     return tvalues;
  64 }
  65
  66
  67 template <class Type>
  68 Foam::tmp<Foam::Field<Type> >
  69 Foam::sampledPatchInternalField::interpolateField
  70 (
  71     const interpolation<Type>& interpolator
  72 ) const
  73 {
  74     label sz = 0;
  75     forAll(patchIDs(), i)
  76     {
  77         sz += mesh().boundaryMesh()[patchIDs()[i]].size();
  78     }
  79
  80     Field<Type> allPatchVals(sz);
  81     sz = 0;
  82
  83     forAll(patchIDs(), i)
  84     {
  85         // See directMappedFixedValueFvPatchField
  86         const mapDistribute& distMap = mappers_[i].map();
  87
  88         // Send back sample points to processor that holds the cell.
  89         // Mark cells with point::max so we know which ones we need
  90         // to interpolate (since expensive).
  91         vectorField samples(mappers_[i].samplePoints());
  92         distMap.reverseDistribute(mesh().nCells(), point::max, samples);
  93
  94         Field<Type> patchVals(mesh().nCells());
  95
  96         forAll(samples, cellI)
  97         {
  98             if (samples[cellI] != point::max)
  99             {
 100                 patchVals[cellI] = interpolator.interpolate
 101                 (
 102                     samples[cellI],
 103                     cellI
 104                 );
 105             }
 106         }
 107
 108         distMap.distribute(patchVals);
 109
 110         // Now patchVals holds the interpolated data in patch face order.
 111         // Collect.
 112         SubList<Type>(allPatchVals, patchVals.size(), sz).assign(patchVals);
 113         sz += patchVals.size();
 114     }
 115
 116     // Interpolate to points. Reconstruct the patch of all faces to aid
 117     // interpolation.
 118
 119     labelList meshFaceLabels(allPatchVals.size());
 120     sz = 0;
 121     forAll(patchIDs(), i)
 122     {
 123         const polyPatch& pp = mesh().boundaryMesh()[patchIDs()[i]];
 124         forAll(pp, i)
 125         {
 126             meshFaceLabels[sz++] = pp.start()+i;
 127         }
 128     }
 129
 130     indirectPrimitivePatch allPatches
 131     (
 132         IndirectList<face>(mesh().faces(), meshFaceLabels),
 133         mesh().points()
 134     );
 135
 136     return PrimitivePatchInterpolation<indirectPrimitivePatch>
 137     (
 138         allPatches
 139     ).faceToPointInterpolate(allPatchVals);
 140 }
 141
 142
 143 // ************************************************************************* //