src/finiteVolume/fvMesh/fvMeshCutSurface/meshCut/meshCutSurfaceInterpolate.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
   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 "meshCutSurface.H"
  28 #include "pyramidEdge.H"
  29 #include "faceEdge.H"
  30 #include "centreEdge.H"
  31 #include "diagonalEdge.H"
  32 #include "faceDecompCuts.H"
  33 #include "cellDecompCuts.H"
  34
  35 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
  36
  37 template <class T>
  38 Foam::tmp<Foam::Field<T> > Foam::meshCutSurface::interpolate
  39 (
  40     const faceDecompCuts& cuts,
  41     const Field<T>& vField,
  42     const Field<T>& fField,
  43     const Field<T>& pField
  44 )
  45 {
  46     const primitiveMesh& mesh = cuts.mesh();
  47
  48     tmp<Field<T> > tvals(new Field<T>(cuts.size()));
  49     Field<T>& vals = tvals();
  50
  51     label pointI = 0;
  52
  53     forAll(cuts.meshVerts(), cutVertI)
  54     {
  55         vals[pointI++] = pField[cuts.meshVerts()[cutVertI]];
  56     }
  57
  58     forAll(cuts.meshFaceCentres(), cutFaceCentreI)
  59     {
  60         label faceI = cuts.meshFaceCentres()[cutFaceCentreI];
  61
  62         vals[pointI++] = fField[faceI];
  63     }
  64
  65     forAll(cuts.meshCellCentres(), cutCellCentreI)
  66     {
  67         label cellI = cuts.meshCellCentres()[cutCellCentreI];
  68
  69         vals[pointI++] = vField[cellI];
  70     }
  71
  72     forAll(cuts.meshEdges(), meshCutSurfaceEdgeI)
  73     {
  74         label edgeI = cuts.meshEdges()[meshCutSurfaceEdgeI];
  75
  76         const edge& e = mesh.edges()[edgeI];
  77
  78         scalar weight = cuts.meshEdgeWeights()[meshCutSurfaceEdgeI];
  79
  80         vals[pointI++] = weight*pField[e.start()] + (1-weight)*pField[e.end()];
  81     }
  82
  83     forAll(cuts.pyrEdges(), edgeI)
  84     {
  85         const pyramidEdge& e = cuts.pyrEdges()[edgeI];
  86
  87         scalar weight = cuts.pyrEdgeWeights()[edgeI];
  88
  89         vals[pointI++] = e.interpolate(vField, pField, weight);
  90     }
  91
  92     forAll(cuts.centreEdges(), edgeI)
  93     {
  94         const centreEdge& e = cuts.centreEdges()[edgeI];
  95
  96         scalar weight = cuts.centreEdgeWeights()[edgeI];
  97
  98         vals[pointI++] = e.interpolate(mesh, vField, fField, weight);
  99     }
 100
 101     forAll(cuts.faceEdges(), edgeI)
 102     {
 103         const faceEdge& e = cuts.faceEdges()[edgeI];
 104
 105         scalar weight = cuts.faceEdgeWeights()[edgeI];
 106
 107         vals[pointI++] = e.interpolate(mesh, fField, pField, weight);
 108     }
 109
 110     return tvals;
 111 }
 112
 113
 114 template <class T>
 115 Foam::tmp<Foam::Field<T> > Foam::meshCutSurface::interpolate
 116 (
 117     const cellDecompCuts& cuts,
 118     const Field<T>& vField,
 119     const Field<T>& pField
 120 )
 121 {
 122     const primitiveMesh& mesh = cuts.mesh();
 123
 124     tmp<Field<T> > tvals(new Field<T>(cuts.size()));
 125     Field<T>& vals = tvals();
 126
 127     label pointI = 0;
 128
 129     forAll(cuts.meshVerts(), cutVertI)
 130     {
 131         vals[pointI++] = pField[cuts.meshVerts()[cutVertI]];
 132     }
 133
 134     forAll(cuts.meshCellCentres(), cutCellCentreI)
 135     {
 136         label cellI = cuts.meshCellCentres()[cutCellCentreI];
 137
 138         vals[pointI++] = vField[cellI];
 139     }
 140
 141     forAll(cuts.meshEdges(), meshCutSurfaceEdgeI)
 142     {
 143         label edgeI = cuts.meshEdges()[meshCutSurfaceEdgeI];
 144
 145         const edge& e = mesh.edges()[edgeI];
 146
 147         scalar weight = cuts.meshEdgeWeights()[meshCutSurfaceEdgeI];
 148
 149         vals[pointI++] = weight*pField[e.start()] + (1-weight)*pField[e.end()];
 150     }
 151
 152     forAll(cuts.pyrEdges(), edgeI)
 153     {
 154         const pyramidEdge& e = cuts.pyrEdges()[edgeI];
 155
 156         scalar weight = cuts.pyrEdgeWeights()[edgeI];
 157
 158         vals[pointI++] = e.interpolate(vField, pField, weight);
 159     }
 160
 161     forAll(cuts.diagEdges(), edgeI)
 162     {
 163         const diagonalEdge& e = cuts.diagEdges()[edgeI];
 164
 165         scalar weight = cuts.diagEdgeWeights()[edgeI];
 166
 167         vals[pointI++] = e.interpolate(mesh, pField, weight);
 168     }
 169
 170     return tvals;
 171 }
 172
 173
 174 // ************************************************************************* //