src/mesh/cfMesh/utilities/meshes/polyMeshGenAddressing/polyMeshGenAddressingEdgeFaces.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | cfMesh: A library for mesh generation
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright held by the original author
   6      \\/     M anipulation  |
   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 \*---------------------------------------------------------------------------*/
  25
  26 #include "polyMeshGenAddressing.H"
  27 #include "VRWGraphSMPModifier.H"
  28
  29 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  30
  31 namespace Foam
  32 {
  33
  34 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
  35
  36 void polyMeshGenAddressing::calcEdgeFaces() const
  37 {
  38     if( efPtr_ )
  39     {
  40         FatalErrorIn("polyMeshGenAddressing::calcEdges() const")
  41             << "edgeFaces already calculated"
  42             << abort(FatalError);
  43     }
  44     else
  45     {
  46         const faceListPMG& faces = mesh_.faces();
  47         const VRWGraph& pointFaces = this->pointFaces();
  48         const edgeList& edges = this->edges();
  49
  50         efPtr_ = new VRWGraph();
  51         VRWGraph& edgeFaceAddr = *efPtr_;
  52
  53         labelList nef(edges.size());
  54
  55         # ifdef USE_OMP
  56         const label nThreads = 3 * omp_get_num_procs();
  57         # endif
  58
  59         # ifdef USE_OMP
  60         # pragma omp parallel num_threads(nThreads) if( edges.size() > 10000 )
  61         # endif
  62         {
  63             # ifdef USE_OMP
  64             # pragma omp for schedule(static)
  65             # endif
  66             forAll(nef, edgeI)
  67                 nef[edgeI] = 0;
  68
  69             # ifdef USE_OMP
  70             # pragma omp for schedule(static)
  71             # endif
  72             forAll(edges, edgeI)
  73             {
  74                 const edge& ee = edges[edgeI];
  75                 const label s = ee.start();
  76
  77                 forAllRow(pointFaces, s, pfI)
  78                 {
  79                     const label faceI = pointFaces(s, pfI);
  80
  81                     const face& f = faces[faceI];
  82
  83                     forAll(f, eI)
  84                     {
  85                         if( f.faceEdge(eI) == ee )
  86                         {
  87                             ++nef[edgeI];
  88                             break;
  89                         }
  90                     }
  91                 }
  92             }
  93
  94             # ifdef USE_OMP
  95             # pragma omp barrier
  96
  97             # pragma omp master
  98             # endif
  99             VRWGraphSMPModifier(edgeFaceAddr).setSizeAndRowSize(nef);
 100
 101             # ifdef USE_OMP
 102             # pragma omp barrier
 103
 104             # pragma omp for schedule(static)
 105             # endif
 106             forAll(edges, edgeI)
 107             {
 108                 const edge& ee = edges[edgeI];
 109                 const label s = ee.start();
 110
 111                 DynList<label> eFaces;
 112                 forAllRow(pointFaces, s, pfI)
 113                 {
 114                     const label faceI = pointFaces(s, pfI);
 115
 116                     const face& f = faces[faceI];
 117
 118                     forAll(f, eI)
 119                     {
 120                         if( f.faceEdge(eI) == ee )
 121                         {
 122                             eFaces.append(faceI);
 123                             break;
 124                         }
 125                     }
 126                 }
 127
 128                 edgeFaceAddr.setRow(edgeI, eFaces);
 129             }
 130         }
 131     }
 132 }
 133
 134 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 135
 136 const VRWGraph& polyMeshGenAddressing::edgeFaces() const
 137 {
 138     if( !efPtr_ )
 139     {
 140         # ifdef USE_OMP
 141         if( omp_in_parallel() )
 142             FatalErrorIn
 143             (
 144                 "const VRWGraph& polyMeshGenAddressing::edgeFaces() const"
 145             ) << "Calculating addressing inside a parallel region."
 146                 << " This is not thread safe" << exit(FatalError);
 147         # endif
 148
 149         calcEdgeFaces();
 150     }
 151
 152     return *efPtr_;
 153 }
 154
 155 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 156
 157 } // End namespace Foam
 158
 159 // ************************************************************************* //