src/mesh/cfMesh/meshLibrary/utilities/smoothers/topology/checkCellConnectionsOverFaces/checkCellConnectionsOverFaces.C

   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 Description
  25
  26 \*---------------------------------------------------------------------------*/
  27
  28 #include "checkCellConnectionsOverFaces.H"
  29 #include "labelLongList.H"
  30 #include "labelledPair.H"
  31
  32 # ifdef USE_OMP
  33 #include <omp.h>
  34 # endif
  35
  36 #include <set>
  37 #include <map>
  38
  39 #include "helperFunctions.H"
  40
  41 //#define DEBUGCheck
  42
  43 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  44
  45 namespace Foam
  46 {
  47
  48 // * * * * * * * * * * Private member functions * * * * * * * * * * * * * * * //
  49
  50 namespace meshConnectionsHelper
  51 {
  52
  53 class meshConnectionsNeighbourOperator
  54 {
  55     const polyMeshGen& mesh_;
  56
  57 public:
  58
  59     meshConnectionsNeighbourOperator(const polyMeshGen& mesh)
  60     :
  61         mesh_(mesh)
  62     {}
  63
  64     label size() const
  65     {
  66         return mesh_.cells().size();
  67     }
  68
  69     void operator()(const label cellI, DynList<label>& neighbourCells) const
  70     {
  71         neighbourCells.clear();
  72
  73         const labelList& owner = mesh_.owner();
  74         const labelList& neighbour = mesh_.neighbour();
  75
  76         const cell& c = mesh_.cells()[cellI];
  77
  78         forAll(c, fI)
  79         {
  80             label nei = owner[c[fI]];
  81
  82             if( nei == cellI )
  83                 nei = neighbour[c[fI]];
  84
  85             if( nei >= 0 )
  86                 neighbourCells.append(nei);
  87         }
  88     }
  89
  90     template<class labelListType>
  91     void collectGroups
  92     (
  93         std::map<label, DynList<label> >& neiGroups,
  94         const labelListType& elementInGroup,
  95         const DynList<label>& localGroupLabel
  96     ) const
  97     {
  98         const PtrList<processorBoundaryPatch>& procBoundaries =
  99             mesh_.procBoundaries();
 100         const labelList& owner = mesh_.owner();
 101
 102         //- send the data to other processors
 103         forAll(procBoundaries, patchI)
 104         {
 105             const label start = procBoundaries[patchI].patchStart();
 106             const label size = procBoundaries[patchI].patchSize();
 107
 108             labelList groupOwner(procBoundaries[patchI].patchSize());
 109             for(label faceI=0;faceI<size;++faceI)
 110             {
 111                 const label groupI = elementInGroup[owner[start+faceI]];
 112
 113                 if( groupI < 0 )
 114                 {
 115                     groupOwner[faceI] = -1;
 116                     continue;
 117                 }
 118
 119                 groupOwner[faceI] = localGroupLabel[groupI];
 120             }
 121
 122             OPstream toOtherProc
 123             (
 124                 Pstream::blocking,
 125                 procBoundaries[patchI].neiProcNo(),
 126                 groupOwner.byteSize()
 127             );
 128
 129             toOtherProc << groupOwner;
 130         }
 131
 132         //- receive data from other processors
 133         forAll(procBoundaries, patchI)
 134         {
 135             const label start = procBoundaries[patchI].patchStart();
 136
 137             labelList receivedData;
 138
 139             IPstream fromOtherProc
 140             (
 141                 Pstream::blocking,
 142                 procBoundaries[patchI].neiProcNo()
 143             );
 144
 145             fromOtherProc >> receivedData;
 146
 147             forAll(receivedData, faceI)
 148             {
 149                 if( receivedData[faceI] < 0 )
 150                     continue;
 151
 152                 const label groupI = elementInGroup[owner[start+faceI]];
 153
 154                 if( groupI < 0 )
 155                     continue;
 156
 157                 DynList<label>& ng = neiGroups[localGroupLabel[groupI]];
 158
 159                 //- store the connection over the inter-processor boundary
 160                 ng.appendIfNotIn(receivedData[faceI]);
 161             }
 162         }
 163     }
 164 };
 165
 166 class meshConnectionsSelectorOperator
 167 {
 168
 169 public:
 170
 171     meshConnectionsSelectorOperator()
 172     {}
 173
 174     bool operator()(const label cellI) const
 175     {
 176         return true;
 177     }
 178 };
 179
 180 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 181
 182 } // End namespace meshConnectionsHelper
 183
 184 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 185
 186 void checkCellConnectionsOverFaces::findCellGroups()
 187 {
 188     Info << "Checking cell connections" << endl;
 189
 190     mesh_.owner();
 191     nGroups_ =
 192         help::groupMarking
 193         (
 194             cellGroup_,
 195             meshConnectionsHelper::meshConnectionsNeighbourOperator(mesh_),
 196             meshConnectionsHelper::meshConnectionsSelectorOperator()
 197         );
 198
 199     Info << "Finished checking cell connections" << endl;
 200 }
 201
 202 // * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * * * * * //
 203 // Constructors
 204
 205 checkCellConnectionsOverFaces::checkCellConnectionsOverFaces(polyMeshGen& mesh)
 206 :
 207     mesh_(mesh),
 208     cellGroup_(mesh.cells().size(), -1),
 209     nGroups_(0)
 210 {
 211     findCellGroups();
 212 }
 213
 214 // * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * * * * * //
 215
 216 checkCellConnectionsOverFaces::~checkCellConnectionsOverFaces()
 217 {}
 218
 219 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 220
 221 bool checkCellConnectionsOverFaces::checkCellGroups()
 222 {
 223     if( nGroups_ == 1 )
 224         return false;
 225
 226     Warning << "Mesh has " << nGroups_ << " unconnected regions" << endl;
 227
 228     labelList nCellsInGroup(nGroups_, 0);
 229
 230     forAll(cellGroup_, cI)
 231         ++nCellsInGroup[cellGroup_[cI]];
 232
 233     if( Pstream::parRun() )
 234     {
 235         forAll(nCellsInGroup, groupI)
 236             reduce(nCellsInGroup[groupI], sumOp<label>());
 237     }
 238
 239     //- find groups which has most cells this group will be kept
 240     label maxGroup(-1);
 241     forAll(nCellsInGroup, groupI)
 242         if( nCellsInGroup[groupI] > maxGroup )
 243         {
 244             maxGroup = nCellsInGroup[groupI];
 245             nGroups_ = groupI;
 246         }
 247
 248     //- remove cells which are not in the group which has max num of cells
 249     boolList removeCell(mesh_.cells().size(), false);
 250     forAll(cellGroup_, cellI)
 251         if( cellGroup_[cellI] != nGroups_ )
 252             removeCell[cellI] = true;
 253
 254     polyMeshGenModifier(mesh_).removeCells(removeCell);
 255
 256     return true;
 257 }
 258
 259 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 260
 261 } // End namespace Foam
 262
 263 // ************************************************************************* //