src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupleMapI.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 \*---------------------------------------------------------------------------*/
  26
  27 namespace Foam
  28 {
  29
  30 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  31
  32 //- Interpolate point field
  33 template<class Type>
  34 tmp<Field<Type> >
  35 coupleMap::pointInterpolate
  36 (
  37     const Map<label>& mPointMap,
  38     const Map<label>& sPointMap,
  39     const Field<Type>& pf,
  40     bool reverse
  41 ) const
  42 {
  43     const Map<label>& pointMap = entityMap(coupleMap::POINT);
  44
  45     if (pf.size() != pointMap.size())
  46     {
  47         FatalErrorIn
  48         (
  49             "coupleMap::pointInterpolate"
  50             "(const Field<Type> pf)"
  51         )   << "given field does not correspond to patch. Patch size: "
  52             << pointMap.size() << " field size: " << pf.size()
  53             << abort(FatalError);
  54     }
  55
  56     tmp<Field<Type> > tresult
  57     (
  58         new Field<Type>
  59         (
  60             pointMap.size(),
  61             pTraits<Type>::zero
  62         )
  63     );
  64
  65     Field<Type>& result = tresult();
  66
  67     if (reverse)
  68     {
  69         forAllConstIter(Map<label>, pointMap, pIter)
  70         {
  71             result[mPointMap[pIter.key()]] = pf[sPointMap[pIter()]];
  72         }
  73     }
  74     else
  75     {
  76         forAllConstIter(Map<label>, pointMap, pIter)
  77         {
  78             result[sPointMap[pIter()]] = pf[mPointMap[pIter.key()]];
  79         }
  80     }
  81
  82     return tresult;
  83 }
  84
  85
  86 template<class Type>
  87 tmp<Field<Type> >
  88 coupleMap::pointInterpolate
  89 (
  90     const Map<label>& mPointMap,
  91     const Map<label>& sPointMap,
  92     const tmp<Field<Type> >& tpf,
  93     bool reverse
  94 ) const
  95 {
  96     tmp<Field<Type> > tint =
  97     (
  98         pointInterpolate<Type>(mPointMap, sPointMap, tpf(), reverse)
  99     );
 100     tpf.clear();
 101     return tint;
 102 }
 103
 104
 105 //- Interpolate point field
 106 template<class Type>
 107 tmp<Field<Type> >
 108 coupleMap::faceInterpolate
 109 (
 110     const label mStart,
 111     const label sStart,
 112     const Field<Type>& pf,
 113     bool reverse
 114 ) const
 115 {
 116     const Map<label>& faceMap = entityMap(coupleMap::FACE);
 117
 118     if (pf.size() != faceMap.size())
 119     {
 120         FatalErrorIn
 121         (
 122             "coupleMap::faceInterpolate"
 123             "(const Field<Type> pf)"
 124         )   << "given field does not correspond to patch. Patch size: "
 125             << faceMap.size() << " field size: " << pf.size()
 126             << abort(FatalError);
 127     }
 128
 129     tmp<Field<Type> > tresult
 130     (
 131         new Field<Type>
 132         (
 133             faceMap.size(),
 134             pTraits<Type>::zero
 135         )
 136     );
 137
 138     Field<Type>& result = tresult();
 139
 140     if (reverse)
 141     {
 142         forAllConstIter(Map<label>, faceMap, fIter)
 143         {
 144             result[fIter.key() - mStart] = pf[fIter() - sStart];
 145         }
 146     }
 147     else
 148     {
 149         forAllConstIter(Map<label>, faceMap, fIter)
 150         {
 151             result[fIter() - sStart] = pf[fIter.key() - mStart];
 152         }
 153     }
 154
 155     return tresult;
 156 }
 157
 158
 159 template<class Type>
 160 tmp<Field<Type> >
 161 coupleMap::faceInterpolate
 162 (
 163     const label mStart,
 164     const label sStart,
 165     const tmp<Field<Type> >& tpf,
 166     bool reverse
 167 ) const
 168 {
 169     tmp<Field<Type> > tint =
 170     (
 171         faceInterpolate<Type>(mStart, sStart, tpf(), reverse)
 172     );
 173     tpf.clear();
 174     return tint;
 175 }
 176
 177
 178 inline label& coupleMap::patchIndex() const
 179 {
 180     return patchIndex_;
 181 }
 182
 183
 184 inline label coupleMap::masterIndex() const
 185 {
 186     return masterIndex_;
 187 }
 188
 189
 190 inline label coupleMap::slaveIndex() const
 191 {
 192     return slaveIndex_;
 193 }
 194
 195
 196 inline bool coupleMap::isTwoDMesh() const
 197 {
 198     return twoDMesh_;
 199 }
 200
 201
 202 inline bool coupleMap::isLocal() const
 203 {
 204     return isLocal_;
 205 }
 206
 207
 208 inline bool coupleMap::isProcessor() const
 209 {
 210     return !isLocal_;
 211 }
 212
 213
 214 inline bool coupleMap::isSend() const
 215 {
 216     return isSend_;
 217 }
 218
 219
 220 inline bool coupleMap::isRecv() const
 221 {
 222     return !isSend_;
 223 }
 224
 225
 226 inline FixedList<label,10>& coupleMap::nEntities() const
 227 {
 228     return nEntities_;
 229 }
 230
 231
 232 inline label& coupleMap::nEntities(const label eType) const
 233 {
 234     return nEntities_[eType];
 235 }
 236
 237
 238 inline Map<label>& coupleMap::entityMap(const label eType) const
 239 {
 240     return entityMap_[eType];
 241 }
 242
 243
 244 inline Map<label>& coupleMap::reverseEntityMap(const label eType) const
 245 {
 246     return reverseEntityMap_[eType];
 247 }
 248
 249
 250 inline FixedList<labelList,12>& coupleMap::entityBuffer() const
 251 {
 252     return entityBuffer_;
 253 }
 254
 255
 256 inline labelList& coupleMap::entityBuffer(const label eType) const
 257 {
 258     return entityBuffer_[eType];
 259 }
 260
 261
 262 inline labelList& coupleMap::entityIndices() const
 263 {
 264     return entityIndices_;
 265 }
 266
 267
 268 inline List<coupleMap::opType>& coupleMap::entityOperations() const
 269 {
 270     return entityOperations_;
 271 }
 272
 273
 274 inline pointField& coupleMap::moveNewPoints() const
 275 {
 276     return moveNewPoints_;
 277 }
 278
 279
 280 inline pointField& coupleMap::moveOldPoints() const
 281 {
 282     return moveOldPoints_;
 283 }
 284
 285
 286 } // End namespace Foam
 287
 288 // ************************************************************************* //