src/dynamicMesh/dynamicTopoFvMesh/meshOps.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     meshOps
  26
  27 Description
  28     Various utility functions that perform mesh-related operations.
  29
  30 Author
  31     Sandeep Menon
  32     University of Massachusetts Amherst
  33     All rights reserved
  34
  35 SourceFiles
  36     meshOpsI.H
  37     meshOps.C
  38
  39 \*---------------------------------------------------------------------------*/
  40
  41 #ifndef meshOps_H
  42 #define meshOps_H
  43
  44 #include "Map.H"
  45 #include "point.H"
  46 #include "label.H"
  47 #include "scalar.H"
  48 #include "HashSet.H"
  49 #include "cellList.H"
  50 #include "edgeList.H"
  51 #include "faceList.H"
  52 #include "triPointRef.H"
  53 #include "tetPointRef.H"
  54 #include "vectorField.H"
  55 #include "linePointRef.H"
  56
  57 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  58
  59 namespace Foam
  60 {
  61
  62 class polyMesh;
  63
  64 /*---------------------------------------------------------------------------*\
  65                         Namespace meshOps Declaration
  66 \*---------------------------------------------------------------------------*/
  67
  68 namespace meshOps
  69 {
  70     // Method to find the common-edge between two faces.
  71     inline bool findCommonEdge
  72     (
  73         const label first,
  74         const label second,
  75         const UList<labelList>& faceEdges,
  76         label& common
  77     );
  78
  79     // Method to find the interior/boundary faces
  80     // for an input quad-face and adjacent triangle-prism cell.
  81     inline void findPrismFaces
  82     (
  83         const label fIndex,
  84         const label cIndex,
  85         const UList<face>& faces,
  86         const UList<cell>& cells,
  87         const UList<label>& neighbour,
  88         FixedList<face,2>& bdyf,
  89         FixedList<label,2>& bidx,
  90         FixedList<face,2>& intf,
  91         FixedList<label,2>& iidx
  92     );
  93
  94     // Utility method to build a hull of cells
  95     // connected to the edge (for 2D simplical meshes)
  96     inline void constructPrismHull
  97     (
  98         const label eIndex,
  99         const UList<face>& faces,
 100         const UList<cell>& cells,
 101         const UList<label>& owner,
 102         const UList<label>& neighbour,
 103         const UList<labelList>& edgeFaces,
 104         labelList& hullTriFaces,
 105         labelList& hullCells
 106     );
 107
 108     // Utility method to build a hull of cells (and faces)
 109     // around an edge (for 3D simplical meshes)
 110     inline void constructHull
 111     (
 112         const label eIndex,
 113         const UList<face>& faces,
 114         const UList<edge>& edges,
 115         const UList<cell>& cells,
 116         const UList<label>& owner,
 117         const UList<label>& neighbour,
 118         const UList<labelList>& faceEdges,
 119         const UList<labelList>& edgeFaces,
 120         const labelList& hullVertices,
 121         labelList& hullEdges,
 122         labelList& hullFaces,
 123         labelList& hullCells,
 124         labelListList& ringEntities
 125     );
 126
 127     // Utility method to find the isolated point
 128     // given two triangular faces.
 129     inline label findIsolatedPoint
 130     (
 131         const face& baseFace,
 132         const face& checkFace
 133     );
 134
 135     // Method to find the isolated point on a triangular face
 136     // that doesn't lie on the specified edge
 137     inline void findIsolatedPoint
 138     (
 139         const face& f,
 140         const edge& e,
 141         label& ptIndex,
 142         label& nextPtIndex
 143     );
 144
 145     // Given a face and cell index, find the apex point for a tet cell.
 146     inline label tetApexPoint
 147     (
 148         const label cIndex,
 149         const label fIndex,
 150         const UList<face>& faces,
 151         const UList<cell>& cells
 152     );
 153
 154     // Given a cell index, find the centroid / volume of a cell.
 155     inline void cellCentreAndVolume
 156     (
 157         const label cIndex,
 158         const vectorField& points,
 159         const UList<face>& faces,
 160         const UList<cell>& cells,
 161         const UList<label>& owner,
 162         vector& centre,
 163         scalar& volume
 164     );
 165
 166     // Determine whether a segment intersects a triangular face
 167     inline bool segmentTriFaceIntersection
 168     (
 169         const triPointRef& faceToCheck,
 170         const linePointRef& edgeToCheck,
 171         vector& intPoint
 172     );
 173
 174     // Determine whether the particular point lies
 175     // inside the given triangular face
 176     inline bool pointInTriFace
 177     (
 178         const triPointRef& faceToCheck,
 179         const vector& checkPoint,
 180         bool testCoplanarity
 181     );
 182
 183     // Dijkstra's algorithm for the shortest path problem
 184     inline bool Dijkstra
 185     (
 186         const Map<point>& points,
 187         const Map<edge>& edges,
 188         const label startPoint,
 189         const label endPoint,
 190         Map<label>& pi
 191     );
 192
 193     // Method to insert a label between two labels in a list
 194     inline void insertLabel
 195     (
 196         const label newLabel,
 197         const label labelA,
 198         const label labelB,
 199         labelList& list
 200     );
 201
 202     // Utility method to replace a label in a given list
 203     inline void replaceLabel
 204     (
 205          const label original,
 206          const label replacement,
 207          labelList& list
 208     );
 209
 210     // Utility method to size-up the list to include an item
 211     template <class Type>
 212     inline void sizeUpList
 213     (
 214         const Type& item,
 215         List<Type>& list
 216     );
 217
 218     // Utility method to size-down the list to remove an item
 219     template <class Type>
 220     inline void sizeDownList
 221     (
 222         const Type& item,
 223         List<Type>& list
 224     );
 225
 226     // Remove an item at a particular index in the list
 227     template <class Type>
 228     inline void removeIndex
 229     (
 230         const label index,
 231         List<Type>& list
 232     );
 233
 234     // Parallel send
 235     inline void pWrite
 236     (
 237         const label toID,
 238         const label& data,
 239         bool blocking = true
 240     );
 241
 242     // Parallel send (for fixed lists)
 243     template <class Type, unsigned Size>
 244     inline void pWrite
 245     (
 246         const label toID,
 247         const FixedList<Type,Size>& data
 248     );
 249
 250     // Parallel send (for lists)
 251     template <class Type>
 252     inline void pWrite
 253     (
 254         const label toID,
 255         const UList<Type>& data
 256     );
 257
 258     // Parallel receive
 259     inline void pRead
 260     (
 261         const label fromID,
 262         label& data,
 263         bool blocking = true
 264     );
 265
 266     // Parallel receive (for fixed lists)
 267     template <class Type, unsigned Size>
 268     inline void pRead
 269     (
 270         const label fromID,
 271         FixedList<Type,Size>& data
 272     );
 273
 274     // Parallel receive (for lists)
 275     template <class Type>
 276     inline void pRead
 277     (
 278         const label fromID,
 279         UList<Type>& data
 280     );
 281
 282     // Wait for buffer transfer completion.
 283     inline void waitForBuffers();
 284
 285     // Select a list of elements from connectivity,
 286     // and output to a VTK format
 287     inline void writeVTK
 288     (
 289         const polyMesh& mesh,
 290         const word& name,
 291         const labelList& cList,
 292         const label primitiveType,
 293         const UList<point>& meshPoints,
 294         const UList<edge>& edges = List<edge>(0),
 295         const UList<face>& faces = List<face>(0),
 296         const UList<cell>& cells = List<cell>(0),
 297         const UList<label>& owner = List<label>(0),
 298         const UList<scalar>& scalField = UList<scalar>(),
 299         const UList<label>& lablField = UList<label>(),
 300         const UList<vector>& vectField = UList<vector>()
 301     );
 302
 303     // Actual routine to write out the VTK file
 304     inline void writeVTK
 305     (
 306         const polyMesh& mesh,
 307         const word& name,
 308         const label nPoints,
 309         const label nCells,
 310         const label nTotalCells,
 311         const vectorField& points,
 312         const labelListList& cpList = labelListList(0),
 313         const label primitiveType = 3,
 314         const Map<label>& reversePointMap = Map<label>(),
 315         const Map<label>& reverseCellMap = Map<label>(),
 316         const UList<scalar>& scalField = UList<scalar>(),
 317         const UList<label>& lablField = UList<label>(),
 318         const UList<vector>& vectField = UList<vector>()
 319     );
 320
 321 } // End namespace meshOps
 322
 323 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 324
 325 // Add additional operations missing in ops.H
 326 template<class T>
 327 class lessOp
 328 { public: T operator()(const T& x, const T& y) const { return x < y; } };
 329
 330 template<class T>
 331 class lessEqOp
 332 { public: T operator()(const T& x, const T& y) const { return x <= y; } };
 333
 334 template<class T>
 335 class greaterOp
 336 { public: T operator()(const T& x, const T& y) const { return x > y; } };
 337
 338 template<class T>
 339 class greaterEqOp
 340 { public: T operator()(const T& x, const T& y) const { return x >= y; } };
 341
 342 } // End namespace Foam
 343
 344 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 345
 346 #include "meshOpsI.H"
 347
 348 #ifdef NoRepository
 349 #    include "meshOps.C"
 350 #endif
 351
 352 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 353
 354 #endif
 355
 356 // ************************************************************************* //