src/dynamicMesh/dynamicTopoFvMesh/coupledMesh/coupledInfo.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 Class
  25     coupledInfo
  26
  27 Description
  28     An interface class that provides patch coupling functionality
  29
  30 Author
  31     Sandeep Menon
  32     University of Massachusetts Amherst
  33     All rights reserved
  34
  35 SourceFiles
  36     coupledInfo.C
  37
  38 \*---------------------------------------------------------------------------*/
  39
  40 #ifndef coupledInfo_H
  41 #define coupledInfo_H
  42
  43 #include "autoPtr.H"
  44 #include "coupleMap.H"
  45 #include "volFieldsFwd.H"
  46 #include "fvPatchFieldMapper.H"
  47
  48 namespace Foam
  49 {
  50
  51 // Class forward declarations
  52 class fvBoundaryMesh;
  53
  54 /*---------------------------------------------------------------------------*\
  55                          Class coupledInfo Declaration
  56 \*---------------------------------------------------------------------------*/
  57
  58 template <class MeshType>
  59 class coupledInfo
  60 {
  61
  62     // Private data
  63
  64         // Reference to the parent mesh
  65         const MeshType& mesh_;
  66
  67         // Auto pointer to a subMesh
  68         autoPtr<MeshType> subMesh_;
  69
  70         // Flag to determine whether maps have been built.
  71         bool builtMaps_;
  72
  73         // For locally coupled patches,
  74         // specify a master / slave index
  75         coupleMap map_;
  76
  77         // Zone IDs for patches associated with faceZones
  78         label masterFaceZone_;
  79         label slaveFaceZone_;
  80
  81     // Private member functions
  82
  83         // Disallow default bitwise assignment
  84         inline void operator=(const coupledInfo&);
  85
  86 public:
  87
  88     //- Constructors
  89
  90         // Construct given mesh, coupleMap and master / slave indices
  91         inline coupledInfo
  92         (
  93             const MeshType& mesh,
  94             const coupleMap& cMap,
  95             const label mfzIndex = -1,
  96             const label sfzIndex = -1
  97         );
  98
  99         // Construct from components
 100         inline coupledInfo
 101         (
 102             const MeshType& mesh,
 103             const bool isTwoDMesh,
 104             const bool isLocal,
 105             const bool isSend,
 106             const label patchIndex,
 107             const label mPatch,
 108             const label sPatch,
 109             const label mfzIndex = -1,
 110             const label sfzIndex = -1
 111         );
 112
 113     //- Access
 114
 115         // Return a const reference to the parent mesh
 116         inline const MeshType& baseMesh() const;
 117
 118         // Set a new subMesh
 119         inline void setMesh(label index, MeshType* mesh);
 120
 121         // Return a reference to the subMesh
 122         inline MeshType& subMesh();
 123
 124         // Return a const reference to the subMesh
 125         inline const MeshType& subMesh() const;
 126
 127         // Return if maps have been built
 128         inline bool builtMaps() const;
 129
 130         // Set internal state of maps as built
 131         inline void setBuiltMaps();
 132
 133         // Return a reference to the coupleMap
 134         inline coupleMap& map();
 135
 136         // Return a const reference to the coupleMap
 137         inline const coupleMap& map() const;
 138
 139         // Return the master face zone ID
 140         inline label masterFaceZone() const;
 141
 142         // Return the slave face zone ID
 143         inline label slaveFaceZone() const;
 144
 145     //- Interpolation
 146
 147         //- Generic subMesh mapper
 148         class subMeshMapper
 149         :
 150             public fvPatchFieldMapper
 151         {
 152             label sizeBeforeMapping_;
 153
 154             labelField directAddressing_;
 155
 156         public:
 157
 158             // Constructors
 159
 160                 //- Construct from components
 161                 inline subMeshMapper
 162                 (
 163                     const label sbm,
 164                     const labelList& da
 165                 )
 166                 :
 167                     sizeBeforeMapping_(sbm),
 168                     directAddressing_(da)
 169                 {}
 170
 171                 //- Construct given addressing
 172                 inline subMeshMapper
 173                 (
 174                     const coupledInfo& cInfo,
 175                     const label patchI
 176                 );
 177
 178             // Destructor
 179
 180                 virtual ~subMeshMapper()
 181                 {}
 182
 183             // Member Functions
 184
 185                 label size() const
 186                 {
 187                     return directAddressing_.size();
 188                 }
 189
 190                 label sizeBeforeMapping() const
 191                 {
 192                     return sizeBeforeMapping_;
 193                 }
 194
 195                 bool direct() const
 196                 {
 197                     return true;
 198                 }
 199
 200                 const unallocLabelList& directAddressing() const
 201                 {
 202                     return directAddressing_;
 203                 }
 204         };
 205
 206         // Subset geometric field
 207         template <class GeomField, class ZeroType>
 208         tmp<GeomField>
 209         subSetField
 210         (
 211             const GeomField& f,
 212             const ZeroType& zeroValue,
 213             const labelList& internalMapper
 214         ) const;
 215
 216         // Subset geometric fields from registry to output stream
 217         template <class GeomField, class ZeroType>
 218         void send
 219         (
 220             const wordList& fieldNames,
 221             const word& fieldType,
 222             const ZeroType& zeroValue,
 223             const labelList& internalMapper,
 224             OSstream& strStream
 225         ) const;
 226
 227         // Set geometric field pointers from input dictionary
 228         template <class GeomField>
 229         void setField
 230         (
 231             const wordList& fieldNames,
 232             const dictionary& fieldDicts,
 233             const label internalSize,
 234             PtrList<GeomField>& fields
 235         ) const;
 236
 237         // Resize map for individual field
 238         template <class GeomField>
 239         static void resizeMap
 240         (
 241             const label srcIndex,
 242             const subMeshMapper& internalMapper,
 243             const List<labelList>& internalReverseMaps,
 244             const PtrList<subMeshMapper>& boundaryMapper,
 245             const List<labelListList>& boundaryReverseMaps,
 246             const List<PtrList<GeomField> >& srcFields,
 247             GeomField& field
 248         );
 249
 250         // Resize map for all fields in registry
 251         template <class GeomField>
 252         static void resizeMap
 253         (
 254             const wordList& fieldNames,
 255             const objectRegistry& mesh,
 256             const subMeshMapper& internalMapper,
 257             const List<labelList>& internalReverseMaps,
 258             const PtrList<subMeshMapper>& boundaryMapper,
 259             const List<labelListList>& boundaryReverseMaps,
 260             const List<PtrList<GeomField> >& srcFields
 261         );
 262
 263         // Resize boundaryFields for all fields in the registry
 264         template <class GeomField>
 265         static void resizeBoundaries
 266         (
 267             const objectRegistry& mesh,
 268             const fvBoundaryMesh& boundary
 269         );
 270 };
 271
 272 } // End namespace Foam
 273
 274 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 275
 276 #ifdef NoRepository
 277 #    include "coupledInfo.C"
 278 #endif
 279
 280 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 281
 282 #endif
 283
 284 // ************************************************************************* //