src/meshLibrary/utilities/octrees/meshOctree/meshOctreeModifier/meshOctreeModifier.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | cfMesh: A library for mesh generation
   4    \\    /   O peration     |
   5     \\  /    A nd           | Author: Franjo Juretic (franjo.juretic@c-fields.com)
   6      \\/     M anipulation  | Copyright (C) Creative Fields, Ltd.
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of cfMesh.
  10
  11     cfMesh 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     cfMesh 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 cfMesh.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 Class
  25     meshOctreeModifier
  26
  27 Description
  28     Octree for mesh generation
  29
  30 SourceFiles
  31     meshOctreeModifier.C
  32
  33 \*---------------------------------------------------------------------------*/
  34
  35 #ifndef meshOctreeModifier_H
  36 #define meshOctreeModifier_H
  37
  38 #include "meshOctree.H"
  39
  40 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  41
  42 namespace Foam
  43 {
  44
  45 /*---------------------------------------------------------------------------*\
  46                     Class meshOctreeModifier Declaration
  47 \*---------------------------------------------------------------------------*/
  48
  49 class meshOctreeModifier
  50 {
  51     // Private data
  52         //- Reference to the octree
  53         meshOctree& octree_;
  54
  55     // Private member functions
  56         //- correct refinement such that it produces 1-irregular octree
  57         void ensureCorrectRegularity(List<direction>& refineBox);
  58
  59         //- add additional refinement with the following rule. If a son
  60         //- of a father box is refined, then refine all other sons
  61         bool ensureCorrectRegularitySons(List<direction>& refineBox);
  62
  63     // Private copy constructor
  64         //- Disallow default bitwise copy construct
  65         meshOctreeModifier(const meshOctreeModifier&);
  66
  67         //- Disallow default bitwise assignment
  68         void operator=(const meshOctreeModifier&);
  69
  70 public:
  71
  72     // Constructors
  73
  74         //- Construct from octree
  75         meshOctreeModifier(meshOctree&);
  76
  77     // Destructor
  78
  79         ~meshOctreeModifier();
  80
  81
  82     // Member Functions
  83         //- return octree
  84         inline const meshOctree& octree() const;
  85
  86         //- return neighbour processors
  87         inline labelList& neiProcsAccess();
  88
  89         //- return rootBox
  90         inline boundBox& rootBoxAccess();
  91
  92         //- return isRootInitialised_
  93         inline bool& isRootInitialisedAccess();
  94
  95         //- return search range
  96         inline scalar& searchRangeAccess();
  97
  98         //- return the range of leaves at each processor
  99         inline List<Pair<meshOctreeCubeCoordinates> >& neiRangeAccess();
 100
 101         //- return initial cube
 102         inline meshOctreeCube& initialCubeAccess();
 103
 104         //- return octree slots
 105         inline List<meshOctreeSlot>& dataSlotsAccess();
 106
 107         //- return the pointer to the meshOctreeCube at the given position
 108         inline meshOctreeCube* findCubeForPosition
 109         (
 110             const meshOctreeCubeCoordinates&
 111         ) const;
 112
 113         //- find leaves contained in a given boundBox
 114         inline void findLeavesContainedInBox
 115         (
 116             const boundBox&,
 117             DynList<const meshOctreeCube*, 256>&
 118         ) const;
 119
 120         //- return leaves
 121         inline LongList<meshOctreeCube*>& leavesAccess();
 122
 123         //- create leaves
 124         inline void createListOfLeaves();
 125
 126         //- mark additional layers around the leaves selected for refinement
 127         void markAdditionalLayers
 128         (
 129             List<direction>& refineBox,
 130             const direction nLayers = 1
 131         ) const;
 132
 133         //- refine leaves marked for refinement
 134         //- hexRefinement is activated when it is required to refine all
 135         //- sons of the same father, if a single son gets marked for refinement
 136         void refineSelectedBoxes
 137         (
 138             List<direction>& refineBox,
 139             const bool hexRefinement = false
 140         );
 141
 142     // functions for parallel runs
 143         //- distribute leaves of the initial octree to processors
 144         //- each processor creates a list of neighbouring processors
 145         void distributeLeavesToProcessors();
 146
 147         //- move octree cubes from one processor to another
 148         void loadDistribution(const direction usedType = 0);
 149
 150         //- refine the tree to add cubes transferred from other processors
 151         void refineTreeForCoordinates
 152         (
 153             const meshOctreeCubeCoordinates&,
 154             const short procNo = Pstream::myProcNo(),
 155             const direction cubeType = meshOctreeCubeBasic::UNKNOWN
 156         );
 157
 158         void refineTreeForCoordinates
 159         (
 160             const meshOctreeCubeCoordinates&,
 161             const labelList& containedTriangles,
 162             const labelList& containedEdges,
 163             const short procNo = Pstream::myProcNo(),
 164             const direction cubeType = meshOctreeCubeBasic::UNKNOWN
 165
 166         );
 167
 168         //- update the communication pattern between the processors
 169         //- this function is used for load balancing
 170         void updateCommunicationPattern();
 171
 172         //- add an additional layer of boxes which belongs to the neighbouring
 173         //- processors. This simplifies the process of extracting the mesh
 174         //- template from the octree in a parallel run
 175         void addLayerFromNeighbouringProcessors();
 176
 177         //- reduce memory consumption by deleting unnecessary data
 178         void reduceMemoryConsumption();
 179 };
 180
 181
 182 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 183
 184 } // End namespace Foam
 185
 186 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 187
 188 #include "meshOctreeModifierI.H"
 189
 190 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 191
 192 #endif
 193
 194 // ************************************************************************* //