src/surfMesh/MeshedSurface/MeshedSurfaceZones.C

   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 \*---------------------------------------------------------------------------*/
  25
  26 #include "MeshedSurface.H"
  27
  28 // * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
  29
  30 template<class Face>
  31 void Foam::MeshedSurface<Face>::checkZones()
  32 {
  33     // extra safety, ensure we have at some zones
  34     // and they cover all the faces - fix start silently
  35     surfZoneList& zones = this->storedZones();
  36     if (zones.size())
  37     {
  38         label count = 0;
  39         forAll(zones, zoneI)
  40         {
  41             zones[zoneI].start() = count;
  42             count += zones[zoneI].size();
  43         }
  44
  45         if (count < this->size())
  46         {
  47             WarningIn
  48             (
  49                 "MeshedSurface::checkZones()\n"
  50             )
  51                 << "more faces " << this->size() << " than zones " << count
  52                 << " ... extending final zone"
  53                 << endl;
  54
  55             zones[zones.size()-1].size() += count - this->size();
  56         }
  57         else if (count > this->size())
  58         {
  59             FatalErrorIn
  60             (
  61                 "MeshedSurface::checkZones()\n"
  62             )
  63                 << "more zones " << count << " than faces " << this->size()
  64                 << exit(FatalError);
  65         }
  66     }
  67 }
  68
  69
  70 template<class Face>
  71 void Foam::MeshedSurface<Face>::sortFacesAndStore
  72 (
  73     const Xfer< List<Face> >& unsortedFaces,
  74     const Xfer< List<label> >& zoneIds,
  75     const bool sorted
  76 )
  77 {
  78     List<Face>  oldFaces(unsortedFaces);
  79     List<label> zones(zoneIds);
  80
  81     if (sorted)
  82     {
  83         // already sorted - simply transfer faces
  84         this->storedFaces().transfer(oldFaces);
  85     }
  86     else
  87     {
  88         // unsorted - determine the sorted order:
  89         // avoid SortableList since we discard the main list anyhow
  90         List<label> faceMap;
  91         sortedOrder(zones, faceMap);
  92         zones.clear();
  93
  94         // sorted faces
  95         List<Face> newFaces(faceMap.size());
  96         forAll(faceMap, faceI)
  97         {
  98             // use transfer to recover memory where possible
  99             newFaces[faceI].transfer(oldFaces[faceMap[faceI]]);
 100         }
 101         this->storedFaces().transfer(newFaces);
 102     }
 103     zones.clear();
 104 }
 105
 106
 107 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 108
 109 template<class Face>
 110 void Foam::MeshedSurface<Face>::addZones
 111 (
 112     const UList<surfZone>& srfZones,
 113     const bool cullEmpty
 114 )
 115 {
 116     label nZone = 0;
 117
 118     surfZoneList& zones = this->storedZones();
 119     zones.setSize(zones.size());
 120     forAll(zones, zoneI)
 121     {
 122         if (srfZones[zoneI].size() || !cullEmpty)
 123         {
 124             zones[nZone] = surfZone(srfZones[zoneI], nZone);
 125             nZone++;
 126         }
 127     }
 128     zones.setSize(nZone);
 129 }
 130
 131
 132 template<class Face>
 133 void Foam::MeshedSurface<Face>::addZones
 134 (
 135     const UList<label>& sizes,
 136     const UList<word>& names,
 137     const bool cullEmpty
 138 )
 139 {
 140     label start   = 0;
 141     label nZone = 0;
 142
 143     surfZoneList& zones = this->storedZones();
 144     zones.setSize(sizes.size());
 145     forAll(zones, zoneI)
 146     {
 147         if (sizes[zoneI] || !cullEmpty)
 148         {
 149             zones[nZone] = surfZone
 150             (
 151                 names[zoneI],
 152                 sizes[zoneI],
 153                 start,
 154                 nZone
 155             );
 156             start += sizes[zoneI];
 157             nZone++;
 158         }
 159     }
 160     zones.setSize(nZone);
 161 }
 162
 163
 164 template<class Face>
 165 void Foam::MeshedSurface<Face>::addZones
 166 (
 167     const UList<label>& sizes,
 168     const bool cullEmpty
 169 )
 170 {
 171     label start   = 0;
 172     label nZone = 0;
 173
 174     surfZoneList& zones = this->storedZones();
 175     zones.setSize(sizes.size());
 176     forAll(zones, zoneI)
 177     {
 178         if (sizes[zoneI] || !cullEmpty)
 179         {
 180             zones[nZone] = surfZone
 181             (
 182                 word("zone") + ::Foam::name(nZone),
 183                 sizes[zoneI],
 184                 start,
 185                 nZone
 186             );
 187             start += sizes[zoneI];
 188             nZone++;
 189         }
 190     }
 191     zones.setSize(nZone);
 192 }
 193
 194
 195 template<class Face>
 196 void Foam::MeshedSurface<Face>::removeZones()
 197 {
 198     this->storedZones().clear();
 199 }
 200
 201
 202 // ************************************************************************* //