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