src/meshTools/sets/topoSets/faceZoneSet.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 2004-2010 OpenCFD Ltd.
   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
  13     the Free Software Foundation, either version 3 of the License, or
  14     (at your 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, see <http://www.gnu.org/licenses/>.
  23
  24 \*---------------------------------------------------------------------------*/
  25
  26 #include "faceZoneSet.H"
  27 #include "mapPolyMesh.H"
  28 #include "polyMesh.H"
  29
  30 #include "addToRunTimeSelectionTable.H"
  31
  32 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  33
  34 namespace Foam
  35 {
  36
  37 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  38
  39 defineTypeNameAndDebug(faceZoneSet, 0);
  40
  41 addToRunTimeSelectionTable(topoSet, faceZoneSet, word);
  42 addToRunTimeSelectionTable(topoSet, faceZoneSet, size);
  43 addToRunTimeSelectionTable(topoSet, faceZoneSet, set);
  44
  45
  46 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
  47
  48 void faceZoneSet::updateSet()
  49 {
  50     labelList order;
  51     sortedOrder(addressing_, order);
  52     inplaceReorder(order, addressing_);
  53     inplaceReorder(order, flipMap_);
  54
  55     faceSet::clearStorage();
  56     faceSet::resize(2*addressing_.size());
  57     forAll(addressing_, i)
  58     {
  59         faceSet::insert(addressing_[i]);
  60     }
  61 }
  62
  63
  64 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  65
  66 faceZoneSet::faceZoneSet
  67 (
  68     const polyMesh& mesh,
  69     const word& name,
  70     readOption r,
  71     writeOption w
  72 )
  73 :
  74     faceSet(mesh, name, 1000),  // do not read faceSet
  75     mesh_(mesh),
  76     addressing_(0),
  77     flipMap_(0)
  78 {
  79     const faceZoneMesh& faceZones = mesh.faceZones();
  80     label zoneID = faceZones.findZoneID(name);
  81
  82     if
  83     (
  84         (r == IOobject::MUST_READ)
  85      || (r == IOobject::MUST_READ_IF_MODIFIED)
  86      || (r == IOobject::READ_IF_PRESENT && zoneID != -1)
  87     )
  88     {
  89         const faceZone& fz = faceZones[zoneID];
  90         addressing_ = fz;
  91         flipMap_ = fz.flipMap();
  92     }
  93
  94     updateSet();
  95
  96     check(mesh.nFaces());
  97 }
  98
  99
 100 faceZoneSet::faceZoneSet
 101 (
 102     const polyMesh& mesh,
 103     const word& name,
 104     const label size,
 105     writeOption w
 106 )
 107 :
 108     faceSet(mesh, name, size, w),
 109     mesh_(mesh),
 110     addressing_(0),
 111     flipMap_(0)
 112 {
 113     updateSet();
 114 }
 115
 116
 117 faceZoneSet::faceZoneSet
 118 (
 119     const polyMesh& mesh,
 120     const word& name,
 121     const topoSet& set,
 122     writeOption w
 123 )
 124 :
 125     faceSet(mesh, name, set.size(), w),
 126     mesh_(mesh),
 127     addressing_(refCast<const faceZoneSet>(set).addressing()),
 128     flipMap_(refCast<const faceZoneSet>(set).flipMap())
 129 {
 130     updateSet();
 131 }
 132
 133
 134 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 135
 136 faceZoneSet::~faceZoneSet()
 137 {}
 138
 139
 140 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 141
 142 void faceZoneSet::invert(const label maxLen)
 143 {
 144     label n = 0;
 145
 146     for (label faceI = 0; faceI < maxLen; faceI++)
 147     {
 148         if (!found(faceI))
 149         {
 150             addressing_[n] = faceI;
 151             flipMap_[n] = false;         //? or true?
 152             n++;
 153         }
 154     }
 155     addressing_.setSize(n);
 156     flipMap_.setSize(n);
 157     updateSet();
 158 }
 159
 160
 161 void faceZoneSet::subset(const topoSet& set)
 162 {
 163     label nConflict = 0;
 164
 165     DynamicList<label> newAddressing(addressing_.size());
 166     DynamicList<bool> newFlipMap(flipMap_.size());
 167
 168     Map<label> faceToIndex(addressing_.size());
 169     forAll(addressing_, i)
 170     {
 171         faceToIndex.insert(addressing_[i], i);
 172     }
 173
 174     const faceZoneSet& fSet = refCast<const faceZoneSet>(set);
 175
 176     forAll(fSet.addressing(), i)
 177     {
 178         label faceI = fSet.addressing()[i];
 179
 180         Map<label>::const_iterator iter = faceToIndex.find(faceI);
 181
 182         if (iter != faceToIndex.end())
 183         {
 184             label index = iter();
 185
 186             if (fSet.flipMap()[i] != flipMap_[index])
 187             {
 188                 nConflict++;
 189             }
 190             newAddressing.append(faceI);
 191             newFlipMap.append(flipMap_[index]);
 192         }
 193     }
 194
 195     if (nConflict > 0)
 196     {
 197         WarningIn(" faceZoneSet::subset(const topoSet&)")
 198             << "subset : there are " << nConflict
 199             << " faces with different orientation in faceZonesSets "
 200             << name() << " and " << set.name() << endl;
 201     }
 202
 203     addressing_.transfer(newAddressing);
 204     flipMap_.transfer(newFlipMap);
 205     updateSet();
 206 }
 207
 208
 209 void faceZoneSet::addSet(const topoSet& set)
 210 {
 211     label nConflict = 0;
 212
 213     DynamicList<label> newAddressing(addressing_);
 214     DynamicList<bool> newFlipMap(flipMap_);
 215
 216     Map<label> faceToIndex(addressing_.size());
 217     forAll(addressing_, i)
 218     {
 219         faceToIndex.insert(addressing_[i], i);
 220     }
 221
 222     const faceZoneSet& fSet = refCast<const faceZoneSet>(set);
 223
 224     forAll(fSet.addressing(), i)
 225     {
 226         label faceI = fSet.addressing()[i];
 227
 228         Map<label>::const_iterator iter = faceToIndex.find(faceI);
 229
 230         if (iter != faceToIndex.end())
 231         {
 232             label index = iter();
 233
 234             if (fSet.flipMap()[i] != flipMap_[index])
 235             {
 236                 nConflict++;
 237             }
 238         }
 239         else
 240         {
 241             newAddressing.append(faceI);
 242             newFlipMap.append(fSet.flipMap()[i]);
 243         }
 244     }
 245
 246     if (nConflict > 0)
 247     {
 248         WarningIn("faceZoneSet::addSet(const topoSet&)")
 249             << "addSet : there are " << nConflict
 250             << " faces with different orientation in faceZonesSets "
 251             << name() << " and " << set.name() << endl;
 252     }
 253
 254     addressing_.transfer(newAddressing);
 255     flipMap_.transfer(newFlipMap);
 256     updateSet();
 257 }
 258
 259
 260 void faceZoneSet::deleteSet(const topoSet& set)
 261 {
 262     label nConflict = 0;
 263
 264     DynamicList<label> newAddressing(addressing_.size());
 265     DynamicList<bool> newFlipMap(flipMap_.size());
 266
 267     const faceZoneSet& fSet = refCast<const faceZoneSet>(set);
 268
 269     Map<label> faceToIndex(fSet.addressing().size());
 270     forAll(fSet.addressing(), i)
 271     {
 272         faceToIndex.insert(fSet.addressing()[i], i);
 273     }
 274
 275     forAll(addressing_, i)
 276     {
 277         label faceI = addressing_[i];
 278
 279         Map<label>::const_iterator iter = faceToIndex.find(faceI);
 280
 281         if (iter != faceToIndex.end())
 282         {
 283             label index = iter();
 284
 285             if (fSet.flipMap()[index] != flipMap_[i])
 286             {
 287                 nConflict++;
 288             }
 289         }
 290         else
 291         {
 292             // Not found in fSet so add
 293             newAddressing.append(faceI);
 294             newFlipMap.append(fSet.flipMap()[i]);
 295         }
 296     }
 297
 298     if (nConflict > 0)
 299     {
 300         WarningIn("faceZoneSet::deleteSet(const topoSet&)")
 301             << "deleteSet : there are " << nConflict
 302             << " faces with different orientation in faceZonesSets "
 303             << name() << " and " << set.name() << endl;
 304     }
 305
 306     addressing_.transfer(newAddressing);
 307     flipMap_.transfer(newFlipMap);
 308     updateSet();
 309 }
 310
 311
 312 void faceZoneSet::sync(const polyMesh& mesh)
 313 {}
 314
 315
 316 label faceZoneSet::maxSize(const polyMesh& mesh) const
 317 {
 318     return mesh.nFaces();
 319 }
 320
 321
 322 //- Write using given format, version and compression
 323 bool faceZoneSet::writeObject
 324 (
 325     IOstream::streamFormat s,
 326     IOstream::versionNumber v,
 327     IOstream::compressionType c
 328 ) const
 329 {
 330     // Write shadow faceSet
 331     word oldTypeName = typeName;
 332     const_cast<word&>(type()) = faceSet::typeName;
 333     bool ok = faceSet::writeObject(s, v, c);
 334     const_cast<word&>(type()) = oldTypeName;
 335
 336     // Modify faceZone
 337     faceZoneMesh& faceZones = const_cast<polyMesh&>(mesh_).faceZones();
 338     label zoneID = faceZones.findZoneID(name());
 339
 340     if (zoneID == -1)
 341     {
 342         zoneID = faceZones.size();
 343
 344         faceZones.setSize(zoneID+1);
 345         faceZones.set
 346         (
 347             zoneID,
 348             new faceZone
 349             (
 350                 name(),
 351                 addressing_,
 352                 flipMap_,
 353                 zoneID,
 354                 faceZones
 355             )
 356         );
 357     }
 358     else
 359     {
 360         faceZones[zoneID].resetAddressing(addressing_, flipMap_);
 361     }
 362     faceZones.clearAddressing();
 363
 364     return ok && faceZones.write();
 365 }
 366
 367
 368 void faceZoneSet::updateMesh(const mapPolyMesh& morphMap)
 369 {
 370     // faceZone
 371     labelList newAddressing(addressing_.size());
 372     boolList newFlipMap(flipMap_.size());
 373
 374     label n = 0;
 375     forAll(addressing_, i)
 376     {
 377         label faceI = addressing_[i];
 378         label newFaceI = morphMap.reverseFaceMap()[faceI];
 379         if (newFaceI >= 0)
 380         {
 381             newAddressing[n] = newFaceI;
 382             newFlipMap[n] = flipMap_[i];
 383             n++;
 384         }
 385     }
 386     newAddressing.setSize(n);
 387     newFlipMap.setSize(n);
 388
 389     addressing_.transfer(newAddressing);
 390     flipMap_.transfer(newFlipMap);
 391
 392     updateSet();
 393 }
 394
 395
 396 void faceZoneSet::writeDebug
 397 (
 398     Ostream& os,
 399     const primitiveMesh& mesh,
 400     const label maxLen
 401 ) const
 402 {
 403     faceSet::writeDebug(os, mesh, maxLen);
 404 }
 405
 406
 407 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 408
 409 } // End namespace Foam
 410
 411 // ************************************************************************* //