src/meshTools/sets/topoSets/faceSet.C

   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 \*---------------------------------------------------------------------------*/
  26
  27 #include "faceSet.H"
  28 #include "mapPolyMesh.H"
  29 #include "polyMesh.H"
  30 #include "processorPolyPatch.H"
  31 #include "cyclicPolyPatch.H"
  32
  33 #include "addToRunTimeSelectionTable.H"
  34
  35 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  36
  37 namespace Foam
  38 {
  39
  40 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  41
  42 defineTypeNameAndDebug(faceSet, 0);
  43
  44 addToRunTimeSelectionTable(topoSet, faceSet, word);
  45 addToRunTimeSelectionTable(topoSet, faceSet, size);
  46 addToRunTimeSelectionTable(topoSet, faceSet, set);
  47
  48
  49 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  50
  51 faceSet::faceSet(const IOobject& obj)
  52 :
  53     topoSet(obj, typeName)
  54 {}
  55
  56
  57 faceSet::faceSet
  58 (
  59     const polyMesh& mesh,
  60     const word& name,
  61     readOption r,
  62     writeOption w
  63 )
  64 :
  65     topoSet(mesh, typeName, name, r, w)
  66 {
  67     check(mesh.nFaces());
  68 }
  69
  70
  71 faceSet::faceSet
  72 (
  73     const polyMesh& mesh,
  74     const word& name,
  75     const label size,
  76     writeOption w
  77 )
  78 :
  79     topoSet(mesh, name, size, w)
  80 {}
  81
  82
  83 faceSet::faceSet
  84 (
  85     const polyMesh& mesh,
  86     const word& name,
  87     const topoSet& set,
  88     writeOption w
  89 )
  90 :
  91     topoSet(mesh, name, set, w)
  92 {}
  93
  94
  95 faceSet::faceSet
  96 (
  97     const polyMesh& mesh,
  98     const word& name,
  99     const labelHashSet& set,
 100     writeOption w
 101 )
 102 :
 103     topoSet(mesh, name, set, w)
 104 {}
 105
 106
 107 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 108
 109 faceSet::~faceSet()
 110 {}
 111
 112
 113 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 114
 115 void faceSet::sync(const polyMesh& mesh)
 116 {
 117     const polyBoundaryMesh& patches = mesh.boundaryMesh();
 118
 119     label nAdded = 0;
 120
 121     if (Pstream::parRun())
 122     {
 123         // Send faces in set that are on a processorPatch. Send as patch face
 124         // indices.
 125         forAll(patches, patchI)
 126         {
 127             const polyPatch& pp = patches[patchI];
 128
 129             if (isA<processorPolyPatch>(pp))
 130             {
 131                 const processorPolyPatch& procPatch =
 132                     refCast<const processorPolyPatch>(pp);
 133
 134                 // Convert faceSet locally to labelList.
 135                 DynamicList<label> setFaces(pp.size());
 136
 137                 forAll(pp, i)
 138                 {
 139                     if (found(pp.start() + i))
 140                     {
 141                         setFaces.append(i);
 142                     }
 143                 }
 144                 setFaces.shrink();
 145
 146                 OPstream toNeighbour
 147                 (
 148                     Pstream::blocking,
 149                     procPatch.neighbProcNo()
 150                 );
 151
 152                 toNeighbour << setFaces;
 153             }
 154         }
 155
 156         // Receive
 157         forAll(patches, patchI)
 158         {
 159             const polyPatch& pp = patches[patchI];
 160
 161             if (isA<processorPolyPatch>(pp))
 162             {
 163                 const processorPolyPatch& procPatch =
 164                     refCast<const processorPolyPatch>(pp);
 165
 166                 IPstream fromNeighbour
 167                 (
 168                     Pstream::blocking,
 169                     procPatch.neighbProcNo()
 170                 );
 171
 172                 labelList setFaces(fromNeighbour);
 173
 174                 forAll(setFaces, i)
 175                 {
 176                     if (insert(pp.start() + setFaces[i]))
 177                     {
 178                         nAdded++;
 179                     }
 180                 }
 181             }
 182         }
 183     }
 184
 185     // Couple cyclic patches
 186     forAll (patches, patchI)
 187     {
 188         const polyPatch& pp = patches[patchI];
 189
 190         if (isA<cyclicPolyPatch>(pp))
 191         {
 192             const cyclicPolyPatch& cycPatch =
 193                 refCast<const cyclicPolyPatch>(pp);
 194
 195             forAll (cycPatch, i)
 196             {
 197                 label thisFaceI = cycPatch.start() + i;
 198                 label otherFaceI = cycPatch.transformGlobalFace(thisFaceI);
 199
 200                 if (found(thisFaceI))
 201                 {
 202                     if (insert(otherFaceI))
 203                     {
 204                         nAdded++;
 205                     }
 206                 }
 207                 else if (found(otherFaceI))
 208                 {
 209                     if (insert(thisFaceI))
 210                     {
 211                         nAdded++;
 212                     }
 213                 }
 214             }
 215         }
 216     }
 217
 218
 219     reduce(nAdded, sumOp<label>());
 220
 221     //if (nAdded > 0)
 222     //{
 223     //    Info<< "Added an additional " << nAdded
 224     //        << " faces on coupled patches. "
 225     //        << "(processorPolyPatch, cyclicPolyPatch)" << endl;
 226     //}
 227 }
 228
 229
 230 label faceSet::maxSize(const polyMesh& mesh) const
 231 {
 232     return mesh.nFaces();
 233 }
 234
 235
 236 void faceSet::updateMesh(const mapPolyMesh& morphMap)
 237 {
 238     updateLabels(morphMap.reverseFaceMap());
 239 }
 240
 241
 242 void faceSet::writeDebug
 243 (
 244     Ostream& os,
 245     const primitiveMesh& mesh,
 246     const label maxLen
 247 ) const
 248 {
 249     topoSet::writeDebug(os, mesh.faceCentres(), maxLen);
 250 }
 251
 252
 253 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 254
 255 } // End namespace Foam
 256
 257 // ************************************************************************* //