src/dynamicMesh/polyMeshModifiers/slidingInterface/enrichedPatch/enrichedPatch.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 Class
  26     Foam::enrichedPatch
  27
  28 Description
  29     The enriched patch contains a double set of faces from the two
  30     sides of the sliding interface before the cutting.
  31
  32     The patch basically consists of two over-lapping sets of faces sitting
  33     on a common point support, where every edge may be shared by more than
  34     2 faces.  The patch points are collected in a map.  Additional
  35     information needed for cutting is the point insertion into every edge
  36     of master and slave.
  37
  38     Note:
  39     If new points are created during master-slave edge cutting, they
  40     should be registred with the pointMap.
  41
  42 Author
  43     Hrvoje Jasak, Nabla Ltd. and Wikki Ltd.  All rights reserved.
  44     Copyright Hrvoje Jasak
  45
  46 SourceFiles
  47     enrichedPatch.C
  48     enrichedPatchCutFaces.C
  49     enrichedPatchFaces.C
  50     enrichedPatchPointMap.C
  51     enrichedPatchPointMergeMap.C
  52     enrichedPatchPointPoints.C
  53
  54 \*---------------------------------------------------------------------------*/
  55
  56 #ifndef enrichedPatch_H
  57 #define enrichedPatch_H
  58
  59 #include "primitiveFacePatch.H"
  60 #include "Map.H"
  61 #include "point.H"
  62
  63 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  64
  65 namespace Foam
  66 {
  67
  68 // Forward declaration of classes
  69
  70 /*---------------------------------------------------------------------------*\
  71                           Class enrichedPatch Declaration
  72 \*---------------------------------------------------------------------------*/
  73
  74 class enrichedPatch
  75 {
  76     // Private data
  77
  78         //- Reference to master patch
  79         const primitiveFacePatch& masterPatch_;
  80
  81         //- Reference to slave patch
  82         const primitiveFacePatch& slavePatch_;
  83
  84         //- Map of points supporting patch faces
  85         mutable Map<point> pointMap_;
  86
  87         //- Has the point map been completed?
  88         mutable bool pointMapComplete_;
  89
  90         //- Map of point merges
  91         mutable Map<label> pointMergeMap_;
  92
  93         //- Slave point point hits
  94         const labelList& slavePointPointHits_;
  95
  96         //- Slave point edge hits
  97         const labelList& slavePointEdgeHits_;
  98
  99         //- Slave point face hits
 100         const List<objectHit>& slavePointFaceHits_;
 101
 102
 103     // Demand-driven private data
 104
 105         //- Enriched patch
 106         mutable faceList* enrichedFacesPtr_;
 107
 108         //- Mesh points
 109         mutable labelList* meshPointsPtr_;
 110
 111         //- Local faces
 112         mutable faceList* localFacesPtr_;
 113
 114         //- Local points
 115         mutable pointField* localPointsPtr_;
 116
 117         //- Point-point addressing
 118         mutable labelListList* pointPointsPtr_;
 119
 120         // Master point addressing
 121         mutable Map<labelList>* masterPointFacesPtr_;
 122
 123
 124         // Cut faces and addressing
 125
 126             //- Cut faces
 127             mutable faceList* cutFacesPtr_;
 128
 129             //- Cut face master
 130             //  - the face on the master patch for internal faces
 131             //  - the creator face for boundary face
 132             mutable labelList* cutFaceMasterPtr_;
 133
 134             //- Cut face slave
 135             //  - the face on the slave patch for internal faces
 136             //  - -1 for boundary face
 137             mutable labelList* cutFaceSlavePtr_;
 138
 139             //- Local cut faces
 140             mutable faceList* localCutFacesPtr_;
 141
 142
 143     // Private Member Functions
 144
 145         //- Disallow default bitwise copy construct
 146         enrichedPatch(const enrichedPatch&);
 147
 148         //- Disallow default bitwise assignment
 149         void operator=(const enrichedPatch&);
 150
 151         // Creation of demand-driven private data
 152
 153             //- Calculate point merge map
 154             void calcPointMergeMap() const;
 155
 156             //- Calculate mesh points
 157             void calcMeshPoints() const;
 158
 159             //- Calculate local points
 160             void calcLocalPoints() const;
 161
 162             //- Calculate local faces
 163             void calcLocalFaces() const;
 164
 165             //- Calculate point-point addressing
 166             void calcPointPoints() const;
 167
 168             //- Calculate master point addressing
 169             void calcMasterPointFaces() const;
 170
 171             //- Calculate cut faces
 172             void calcCutFaces() const;
 173
 174             //- Calculate local cut faces
 175             void calcLocalCutFaces() const;
 176
 177             //- Clear cut faces
 178             void clearCutFaces();
 179
 180             //- Clear out demand-driven data
 181             void clearOut();
 182
 183
 184     // Static data members
 185
 186         //- Estimated ratio of original-to-enriched face size
 187         static const label enrichedFaceRatio_;
 188
 189         //- Estimated number of master face hits by slave points
 190         static const label nFaceHits_;
 191
 192         //- Size of face on which the check is forced
 193         static const label maxFaceSizeDebug_;
 194
 195         //- Out of plane tolerance used to reject points in right-hand walk
 196         static const scalar outOfPlaneTol_;
 197
 198
 199 public:
 200
 201     // Static data members
 202     ClassName("enrichedPatch");
 203
 204     // Constructors
 205
 206         //- Construct from components
 207         enrichedPatch
 208         (
 209             const primitiveFacePatch& masterPatch,
 210             const primitiveFacePatch& slavePatch,
 211             const labelList& slavePointPointHits,
 212             const labelList& slavePointEdgeHits,
 213             const List<objectHit>& slavePointFaceHits
 214         );
 215
 216
 217     // Destructor
 218
 219         ~enrichedPatch();
 220
 221
 222     // Member Functions
 223
 224         // Access
 225
 226             //- Return non-const access to point map to add points
 227             Map<point>& pointMap();
 228
 229             //- Return map of points
 230             const Map<point>& pointMap() const;
 231
 232             //- Return map of point merges
 233             Map<label>& pointMergeMap()
 234             {
 235                 return pointMergeMap_;
 236             }
 237
 238             //- Return map of point merges
 239             const Map<label>& pointMergeMap() const
 240             {
 241                 return pointMergeMap_;
 242             }
 243
 244             //- Complete point map
 245             void completePointMap() const;
 246
 247
 248         // Topological data
 249
 250             //- Calculate enriched faces
 251             void calcEnrichedFaces
 252             (
 253                 const labelListList& pointsIntoMasterEdges,
 254                 const labelListList& pointsIntoSlaveEdges,
 255                 const pointField& projectedSlavePoints
 256             );
 257
 258             //- Return enriched faces
 259             const faceList& enrichedFaces() const;
 260
 261             //- Return mesh points
 262             const labelList& meshPoints() const;
 263
 264             //- Return local faces
 265             const faceList& localFaces() const;
 266
 267             //- Return local points
 268             const pointField& localPoints() const;
 269
 270             //- Return point-point addressing
 271             const labelListList& pointPoints() const;
 272
 273             //- Master point face addressing
 274             const Map<labelList>& masterPointFaces() const;
 275
 276
 277         // Cut faces
 278
 279             //- Return list of cut faces
 280             const faceList& cutFaces() const;
 281
 282             //- Return cut face master list
 283             const labelList& cutFaceMaster() const;
 284
 285             //- Return cut face slave list
 286             const labelList& cutFaceSlave() const;
 287
 288             //- Return local cut faces
 289             const faceList& localCutFaces() const;
 290
 291
 292         //- Check if the patch is fully supported
 293         bool checkSupport() const;
 294 };
 295
 296
 297 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 298
 299 } // End namespace Foam
 300
 301 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 302
 303 #endif
 304
 305 // ************************************************************************* //