src/dynamicMesh/polyMeshModifiers/slidingInterface/slidingInterface.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::slidingInterface
  27
  28 Description
  29     Sliding interface mesh modifier.  Given two face zones, couple the
  30     master and slave side using a cutting procedure.
  31
  32     The coupled faces are collected into the "coupled" zone and can become
  33     either internal or placed into a master and slave coupled zone.  The
  34     remaining faces (uncovered master or slave) are placed into the master
  35     and slave patch.
  36
  37     The definition of the sliding interface can be either integral or partial.
  38     Integral interface implies that the slave side completely covers
  39     the master (i.e. no faces are uncovered); partial interface
  40     implies that the uncovered part of master/slave face zone should
  41     become boundary faces.
  42
  43 Author
  44     Hrvoje Jasak, Nabla Ltd. and Wikki Ltd.  All rights reserved.
  45     Copyright Hrvoje Jasak
  46
  47 SourceFiles
  48     slidingInterface.C
  49     coupleSlidingInterface.C
  50     decoupleSlidingInterface.C
  51     slidingInterfaceProjectPoints.C
  52     slidingInterfaceAttachedAddressing.C
  53     slidingInterfaceClearCouple.C
  54     writeSlidingInterfaceVTK.C
  55
  56 \*---------------------------------------------------------------------------*/
  57
  58 #ifndef slidingInterface_H
  59 #define slidingInterface_H
  60
  61 #include "polyMeshModifier.H"
  62 #include "primitiveFacePatch.H"
  63 #include "polyPatchID.H"
  64 #include "ZoneIDs.H"
  65 #include "intersection.H"
  66 #include "Pair.H"
  67
  68 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  69
  70 namespace Foam
  71 {
  72
  73 // Forward declaration of classes
  74 class objectHit;
  75
  76 /*---------------------------------------------------------------------------*\
  77                       Class slidingInterface Declaration
  78 \*---------------------------------------------------------------------------*/
  79
  80 class slidingInterface
  81 :
  82     public polyMeshModifier
  83 {
  84 public:
  85
  86     // Public enumerations
  87
  88         //- Type of match
  89         enum typeOfMatch
  90         {
  91             INTEGRAL,
  92             PARTIAL
  93         };
  94
  95         //- Direction names
  96         static const NamedEnum<typeOfMatch, 2> typeOfMatchNames_;
  97
  98
  99 private:
 100
 101     // Private data
 102
 103         //- Master face zone ID
 104         faceZoneID masterFaceZoneID_;
 105
 106         //- Slave face zone ID
 107         faceZoneID slaveFaceZoneID_;
 108
 109         //- Cut point zone ID
 110         pointZoneID cutPointZoneID_;
 111
 112         //- Cut face zone ID
 113         faceZoneID cutFaceZoneID_;
 114
 115         //- Master patch ID
 116         polyPatchID masterPatchID_;
 117
 118         //- Slave patch ID
 119         polyPatchID slavePatchID_;
 120
 121         //- Type of match
 122         const typeOfMatch matchType_;
 123
 124         //- Couple-decouple operation.
 125         //  If the interface is coupled, decouple it and vice versa.
 126         //  Used in conjuction with automatic mesh motion
 127         mutable Switch coupleDecouple_;
 128
 129         //- State of the modifier
 130         mutable Switch attached_;
 131
 132         //- Point projection algorithm
 133         intersection::algorithm projectionAlgo_;
 134
 135         //- Trigger topological change
 136         mutable bool trigger_;
 137
 138
 139         // Private addressing data.
 140
 141             //- Cut face master face.  Gives the index of face in master patch
 142             //  the cut face has been created from.  For a slave-only face
 143             //  this will be -1
 144             mutable labelList* cutFaceMasterPtr_;
 145
 146             //- Cut face slave face.  Gives the index of face in slave patch
 147             //  the cut face has been created from.  For a master-only face
 148             //  this will be -1
 149             mutable labelList* cutFaceSlavePtr_;
 150
 151             //- Master zone faceCells
 152             mutable labelList* masterFaceCellsPtr_;
 153
 154             //- Slave zone faceCells
 155             mutable labelList* slaveFaceCellsPtr_;
 156
 157             //- Master stick-out faces
 158             mutable labelList* masterStickOutFacesPtr_;
 159
 160             //- Slave stick-out faces
 161             mutable labelList* slaveStickOutFacesPtr_;
 162
 163             //- Retired point mapping.
 164             //  For every retired slave side point, gives the label of the
 165             //  master point that replaces it
 166             mutable Map<label>* retiredPointMapPtr_;
 167
 168             //- Cut edge pairs
 169             //  For cut points created by intersection two edges,
 170             //  store the master-slave edge pair used in creation
 171             mutable Map<Pair<edge> >* cutPointEdgePairMapPtr_;
 172
 173             //- Slave point hit.  The index of master point hit by the
 174             //  slave point in projection.  For no point hit, set to -1
 175             mutable labelList* slavePointPointHitsPtr_;
 176
 177             //- Slave edge hit.  The index of master edge hit by the
 178             //  slave point in projection.  For point or no edge  hit, set to -1
 179             mutable labelList* slavePointEdgeHitsPtr_;
 180
 181             //- Slave face hit.  The index of master face hit by the
 182             //  slave point in projection.
 183             mutable List<objectHit>* slavePointFaceHitsPtr_;
 184
 185             //- Master point edge hit.  The index of slave edge hit by
 186             //  a master point.  For no hit set to -1
 187             mutable labelList* masterPointEdgeHitsPtr_;
 188
 189             //- Projected slave points
 190             mutable pointField* projectedSlavePointsPtr_;
 191
 192
 193     // Private Member Functions
 194
 195         //- Disallow default bitwise copy construct
 196         slidingInterface(const slidingInterface&);
 197
 198         //- Disallow default bitwise assignment
 199         void operator=(const slidingInterface&);
 200
 201         //- Clear out
 202         void clearOut() const;
 203
 204
 205         //- Check validity of construction data
 206         void checkDefinition() const;
 207
 208         //- Calculate attached addressing
 209         void calcAttachedAddressing() const;
 210
 211         //- Calculate decoupled zone face-cell addressing
 212         void renumberAttachedAddressing(const mapPolyMesh&) const;
 213
 214         //- Clear attached addressing
 215         void clearAttachedAddressing() const;
 216
 217
 218         // Topological changes
 219
 220             //- Master faceCells
 221             const labelList& masterFaceCells() const;
 222
 223             //- Slave faceCells
 224             const labelList& slaveFaceCells() const;
 225
 226             //- Master stick-out faces
 227             const labelList& masterStickOutFaces() const;
 228
 229             //- Slave stick-out faces
 230             const labelList& slaveStickOutFaces() const;
 231
 232             //- Retired point map
 233             const Map<label>& retiredPointMap() const;
 234
 235             //- Cut point edge pair map
 236             const Map<Pair<edge> >& cutPointEdgePairMap() const;
 237
 238              //- Clear addressing
 239              void clearAddressing() const;
 240
 241             //- Project slave points and compare with the current projection.
 242             //  If the projection has changed, the sliding interface
 243             //  changes topologically
 244             bool projectPoints() const;
 245
 246             //- Couple sliding interface
 247             void coupleInterface(polyTopoChange& ref) const;
 248
 249             //- Clear projection
 250             void clearPointProjection() const;
 251
 252             //- Clear old couple
 253             void clearCouple(polyTopoChange& ref) const;
 254
 255             //- Decouple interface (returns it to decoupled state)
 256             //  Note: this should not be used in normal operation of the
 257             //  sliding mesh, but only to return the mesh to its
 258             //  original state
 259             void decoupleInterface(polyTopoChange& ref) const;
 260
 261
 262     // Static data members
 263
 264         //- Point merge tolerance
 265         static const scalar pointMergeTol_;
 266
 267         //- Edge merge tolerance
 268         static const scalar edgeMergeTol_;
 269
 270         //- Estimated number of faces an edge goes through
 271         static const label nFacesPerSlaveEdge_;
 272
 273         //- Edge-face interaction escape limit
 274         static const label edgeFaceEscapeLimit_;
 275
 276         //- Integral match point adjustment tolerance
 277         static const scalar integralAdjTol_;
 278
 279         //- Edge intersection master catch fraction
 280         static const scalar edgeMasterCatchFraction_;
 281
 282         //- Edge intersection co-planar tolerance
 283         static const scalar edgeCoPlanarTol_;
 284
 285         //- Edge end cut-off tolerance
 286         static const scalar edgeEndCutoffTol_;
 287
 288
 289 public:
 290
 291     //- Runtime type information
 292     TypeName("slidingInterface");
 293
 294
 295     // Constructors
 296
 297         //- Construct from components
 298         slidingInterface
 299         (
 300             const word& name,
 301             const label index,
 302             const polyTopoChanger& mme,
 303             const word& masterFaceZoneName,
 304             const word& slaveFaceZoneName,
 305             const word& cutPointZoneName,
 306             const word& cutFaceZoneName,
 307             const word& masterPatchName,
 308             const word& slavePatchName,
 309             const typeOfMatch tom,
 310             const bool coupleDecouple,
 311             const intersection::algorithm algo
 312         );
 313
 314         //- Construct from dictionary
 315         slidingInterface
 316         (
 317             const word& name,
 318             const dictionary& dict,
 319             const label index,
 320             const polyTopoChanger& mme
 321         );
 322
 323
 324     // Destructor
 325
 326         virtual ~slidingInterface();
 327
 328
 329     // Member Functions
 330
 331         //- Return master face zone ID
 332         const faceZoneID& masterFaceZoneID() const;
 333
 334         //- Return slave face zone ID
 335         const faceZoneID& slaveFaceZoneID() const;
 336
 337         //- Return cut point zone ID
 338         const pointZoneID& cutPointZoneID() const;
 339
 340         //- Return cut face zone ID
 341         const faceZoneID& cutFaceZoneID() const;
 342
 343         //- Return true if attached
 344         bool attached() const
 345         {
 346             return attached_;
 347         }
 348
 349         //- Check for topology change
 350         virtual bool changeTopology() const;
 351
 352         //- Insert the layer addition/removal instructions
 353         //  into the topological change
 354         virtual void setRefinement(polyTopoChange&) const;
 355
 356         //- Modify motion points to comply with the topological change
 357         virtual void modifyMotionPoints(pointField& motionPoints) const;
 358
 359         //- Force recalculation of locally stored data on topological change
 360         virtual void updateMesh(const mapPolyMesh&);
 361
 362         //- Return projected points for a slave patch
 363         const pointField& pointProjection() const;
 364
 365
 366         //- Write
 367         virtual void write(Ostream&) const;
 368
 369         //- Write dictionary
 370         virtual void writeDict(Ostream&) const;
 371 };
 372
 373
 374 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 375
 376 } // End namespace Foam
 377
 378 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 379
 380 #endif
 381
 382 // ************************************************************************* //