src/meshTools/sets/topoSets/pointZoneSet.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
   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 "pointZoneSet.H"
  27 #include "mapPolyMesh.H"
  28 #include "polyMesh.H"
  29 #include "processorPolyPatch.H"
  30 #include "cyclicPolyPatch.H"
  31
  32 #include "addToRunTimeSelectionTable.H"
  33
  34 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  35
  36 namespace Foam
  37 {
  38
  39 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  40
  41 defineTypeNameAndDebug(pointZoneSet, 0);
  42
  43 addToRunTimeSelectionTable(topoSet, pointZoneSet, word);
  44 addToRunTimeSelectionTable(topoSet, pointZoneSet, size);
  45 addToRunTimeSelectionTable(topoSet, pointZoneSet, set);
  46
  47
  48 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
  49
  50 void pointZoneSet::updateSet()
  51 {
  52     labelList order;
  53     sortedOrder(addressing_, order);
  54     inplaceReorder(order, addressing_);
  55
  56     pointSet::clearStorage();
  57     pointSet::resize(2*addressing_.size());
  58     forAll(addressing_, i)
  59     {
  60         pointSet::insert(addressing_[i]);
  61     }
  62 }
  63
  64
  65 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  66
  67 pointZoneSet::pointZoneSet
  68 (
  69     const polyMesh& mesh,
  70     const word& name,
  71     readOption r,
  72     writeOption w
  73 )
  74 :
  75     pointSet(mesh, name, 1000),  // do not read pointSet
  76     mesh_(mesh),
  77     addressing_(0)
  78 {
  79     const pointZoneMesh& pointZones = mesh.pointZones();
  80     label zoneID = pointZones.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 pointZone& fz = pointZones[zoneID];
  90         addressing_ = fz;
  91     }
  92
  93     updateSet();
  94
  95     check(mesh.nPoints());
  96 }
  97
  98
  99 pointZoneSet::pointZoneSet
 100 (
 101     const polyMesh& mesh,
 102     const word& name,
 103     const label size,
 104     writeOption w
 105 )
 106 :
 107     pointSet(mesh, name, size, w),
 108     mesh_(mesh),
 109     addressing_(0)
 110 {
 111     updateSet();
 112 }
 113
 114
 115 pointZoneSet::pointZoneSet
 116 (
 117     const polyMesh& mesh,
 118     const word& name,
 119     const topoSet& set,
 120     writeOption w
 121 )
 122 :
 123     pointSet(mesh, name, set.size(), w),
 124     mesh_(mesh),
 125     addressing_(refCast<const pointZoneSet>(set).addressing())
 126 {
 127     updateSet();
 128 }
 129
 130
 131 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 132
 133 pointZoneSet::~pointZoneSet()
 134 {}
 135
 136
 137 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 138
 139 void pointZoneSet::invert(const label maxLen)
 140 {
 141     label n = 0;
 142
 143     for (label pointI = 0; pointI < maxLen; pointI++)
 144     {
 145         if (!found(pointI))
 146         {
 147             addressing_[n] = pointI;
 148             n++;
 149         }
 150     }
 151     addressing_.setSize(n);
 152     updateSet();
 153 }
 154
 155
 156 void pointZoneSet::subset(const topoSet& set)
 157 {
 158     DynamicList<label> newAddressing(addressing_.size());
 159
 160     const pointZoneSet& fSet = refCast<const pointZoneSet>(set);
 161
 162     forAll(fSet.addressing(), i)
 163     {
 164         label pointI = fSet.addressing()[i];
 165
 166         if (found(pointI))
 167         {
 168             newAddressing.append(pointI);
 169         }
 170     }
 171
 172     addressing_.transfer(newAddressing);
 173     updateSet();
 174 }
 175
 176
 177 void pointZoneSet::addSet(const topoSet& set)
 178 {
 179     DynamicList<label> newAddressing(addressing_);
 180
 181     const pointZoneSet& fSet = refCast<const pointZoneSet>(set);
 182
 183     forAll(fSet.addressing(), i)
 184     {
 185         label pointI = fSet.addressing()[i];
 186
 187         if (!found(pointI))
 188         {
 189             newAddressing.append(pointI);
 190         }
 191     }
 192
 193     addressing_.transfer(newAddressing);
 194     updateSet();
 195 }
 196
 197
 198 void pointZoneSet::deleteSet(const topoSet& set)
 199 {
 200     DynamicList<label> newAddressing(addressing_.size());
 201
 202     const pointZoneSet& fSet = refCast<const pointZoneSet>(set);
 203
 204     forAll(addressing_, i)
 205     {
 206         label pointI = addressing_[i];
 207
 208         if (!fSet.found(pointI))
 209         {
 210             // Not found in fSet so add
 211             newAddressing.append(pointI);
 212         }
 213     }
 214
 215     addressing_.transfer(newAddressing);
 216     updateSet();
 217 }
 218
 219
 220 void pointZoneSet::sync(const polyMesh& mesh)
 221 {}
 222
 223
 224 label pointZoneSet::maxSize(const polyMesh& mesh) const
 225 {
 226     return mesh.nPoints();
 227 }
 228
 229
 230 //- Write using given format, version and compression
 231 bool pointZoneSet::writeObject
 232 (
 233     IOstream::streamFormat s,
 234     IOstream::versionNumber v,
 235     IOstream::compressionType c
 236 ) const
 237 {
 238     // Write shadow pointSet
 239     word oldTypeName = typeName;
 240     const_cast<word&>(type()) = pointSet::typeName;
 241     bool ok = pointSet::writeObject(s, v, c);
 242     const_cast<word&>(type()) = oldTypeName;
 243
 244     // Modify pointZone
 245     pointZoneMesh& pointZones = const_cast<polyMesh&>(mesh_).pointZones();
 246     label zoneID = pointZones.findZoneID(name());
 247
 248     if (zoneID == -1)
 249     {
 250         zoneID = pointZones.size();
 251
 252         pointZones.setSize(zoneID+1);
 253         pointZones.set
 254         (
 255             zoneID,
 256             new pointZone
 257             (
 258                 name(),
 259                 addressing_,
 260                 zoneID,
 261                 pointZones
 262             )
 263         );
 264     }
 265     else
 266     {
 267         pointZones[zoneID] = addressing_;
 268     }
 269     pointZones.clearAddressing();
 270
 271     return ok && pointZones.write();
 272 }
 273
 274
 275 void pointZoneSet::updateMesh(const mapPolyMesh& morphMap)
 276 {
 277     // pointZone
 278     labelList newAddressing(addressing_.size());
 279
 280     label n = 0;
 281     forAll(addressing_, i)
 282     {
 283         label pointI = addressing_[i];
 284         label newPointI = morphMap.reversePointMap()[pointI];
 285         if (newPointI >= 0)
 286         {
 287             newAddressing[n] = newPointI;
 288             n++;
 289         }
 290     }
 291     newAddressing.setSize(n);
 292
 293     addressing_.transfer(newAddressing);
 294
 295     updateSet();
 296 }
 297
 298
 299 void pointZoneSet::writeDebug
 300 (
 301     Ostream& os,
 302     const primitiveMesh& mesh,
 303     const label maxLen
 304 ) const
 305 {
 306     pointSet::writeDebug(os, mesh, maxLen);
 307 }
 308
 309
 310 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 311
 312 } // End namespace Foam
 313
 314 // ************************************************************************* //