pointZoneSet.C
Go to the documentation of this file.
1/*---------------------------------------------------------------------------*\
2 ========= |
3 \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
4 \\ / O peration |
5 \\ / A nd | www.openfoam.com
6 \\/ M anipulation |
7-------------------------------------------------------------------------------
8 Copyright (C) 2011-2017 OpenFOAM Foundation
9 Copyright (C) 2018-2020 OpenCFD Ltd.
10-------------------------------------------------------------------------------
11License
12 This file is part of OpenFOAM.
13
14 OpenFOAM is free software: you can redistribute it and/or modify it
15 under the terms of the GNU General Public License as published by
16 the Free Software Foundation, either version 3 of the License, or
17 (at your option) any later version.
18
19 OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
20 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
21 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
22 for more details.
23
24 You should have received a copy of the GNU General Public License
25 along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
26
27\*---------------------------------------------------------------------------*/
28
29#include "pointZoneSet.H"
30#include "mapPolyMesh.H"
31#include "polyMesh.H"
32#include "processorPolyPatch.H"
33#include "cyclicPolyPatch.H"
35
36// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
37
38namespace Foam
39{
44}
45
46// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
47
49{
50 labelList order(sortedOrder(addressing_));
51 inplaceReorder(order, addressing_);
52
54 pointSet::resize(2*addressing_.size());
55 pointSet::set(addressing_);
56}
57
58
59// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
60
62(
63 const polyMesh& mesh,
64 const word& name,
65 readOption r,
67)
68:
69 pointSet(mesh, name, 1024), // do not read pointSet
70 mesh_(mesh),
71 addressing_()
72{
73 const pointZoneMesh& pointZones = mesh.pointZones();
74 label zoneID = pointZones.findZoneID(name);
75
76 if
77 (
80 || (r == IOobject::READ_IF_PRESENT && zoneID != -1)
81 )
82 {
83 const pointZone& fz = pointZones[zoneID];
84 addressing_ = fz;
85 }
86
87 updateSet();
88
90}
91
92
94(
95 const polyMesh& mesh,
96 const word& name,
97 const label size,
99)
100:
101 pointSet(mesh, name, size, w),
102 mesh_(mesh),
103 addressing_()
104{
105 updateSet();
106}
107
108
110(
111 const polyMesh& mesh,
112 const word& name,
113 const topoSet& set,
115)
116:
117 pointSet(mesh, name, set.size(), w),
118 mesh_(mesh),
119 addressing_(refCast<const pointZoneSet>(set).addressing())
120{
121 updateSet();
122}
123
124
125// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
126
127void Foam::pointZoneSet::invert(const label maxLen)
128{
129 // Count
130 label n = 0;
131
132 for (label pointi = 0; pointi < maxLen; ++pointi)
133 {
134 if (!found(pointi))
135 {
136 ++n;
137 }
138 }
139
140 // Fill
141 addressing_.setSize(n);
142 n = 0;
143
144 for (label pointi = 0; pointi < maxLen; ++pointi)
145 {
146 if (!found(pointi))
147 {
148 addressing_[n] = pointi;
149 ++n;
150 }
151 }
152 updateSet();
153}
154
155
157{
158 DynamicList<label> newAddressing(addressing_.size());
159
160 const pointZoneSet& zoneSet = refCast<const pointZoneSet>(set);
161
162 for (const label pointi : zoneSet.addressing())
163 {
164 if (found(pointi))
165 {
166 newAddressing.append(pointi);
167 }
168 }
169
170 addressing_.transfer(newAddressing);
171 updateSet();
172}
173
174
176{
177 DynamicList<label> newAddressing(addressing_);
178
179 const pointZoneSet& zoneSet = refCast<const pointZoneSet>(set);
180
181 for (const label pointi : zoneSet.addressing())
182 {
183 if (!found(pointi))
184 {
185 newAddressing.append(pointi);
186 }
187 }
188
189 addressing_.transfer(newAddressing);
190 updateSet();
191}
192
193
195{
196 DynamicList<label> newAddressing(addressing_.size());
197
198 const pointZoneSet& zoneSet = refCast<const pointZoneSet>(set);
199
200 for (label pointi : addressing_)
201 {
202 if (!zoneSet.found(pointi))
203 {
204 // Not found in zoneSet so add
205 newAddressing.append(pointi);
206 }
207 }
208
209 addressing_.transfer(newAddressing);
210 updateSet();
211}
212
213
215{
217
218 // Take over contents of pointSet into addressing.
219 addressing_ = sortedToc();
220 updateSet();
221}
222
223
225{
226 return mesh.nPoints();
227}
228
229
231(
232 IOstreamOption streamOpt,
233 const bool valid
234) const
235{
236 // Write shadow pointSet
237 word oldTypeName = typeName;
238 const_cast<word&>(type()) = pointSet::typeName;
239 bool ok = pointSet::writeObject(streamOpt, valid);
240 const_cast<word&>(type()) = oldTypeName;
241
242 // Modify pointZone
243 pointZoneMesh& pointZones = const_cast<polyMesh&>(mesh_).pointZones();
244 label zoneID = pointZones.findZoneID(name());
245
246 if (zoneID == -1)
247 {
248 zoneID = pointZones.size();
249
250 pointZones.setSize(zoneID+1);
251 pointZones.set
252 (
253 zoneID,
254 new pointZone
255 (
256 name(),
257 addressing_,
258 zoneID,
259 pointZones
260 )
261 );
262 }
263 else
264 {
265 pointZones[zoneID] = addressing_;
266 }
267 pointZones.clearAddressing();
268
269 return ok && pointZones.write(valid);
270}
271
272
274{
275 // pointZone
276 labelList newAddressing(addressing_.size());
277
278 label n = 0;
279 for (const label pointi : addressing_)
280 {
281 const label newPointi = morphMap.reversePointMap()[pointi];
282 if (newPointi >= 0)
283 {
284 newAddressing[n] = newPointi;
285 ++n;
286 }
287 }
288 newAddressing.resize(n);
289
290 addressing_.transfer(newAddressing);
291
292 updateSet();
293}
294
295
297(
298 Ostream& os,
299 const primitiveMesh& mesh,
300 const label maxLen
301) const
302{
303 pointSet::writeDebug(os, mesh, maxLen);
304}
305
306
307// ************************************************************************* //
bool found
label n
Macros for easy insertion into run-time selection tables.
#define addToRunTimeSelectionTable(baseType, thisType, argNames)
Add to construction table with typeName as the key.
label maxSize() const
The max row length used.
void invert()
Return the matrix inverse into itself if no elem is equal to zero.
A 1D vector of objects of type <T> that resizes itself as necessary to accept the new objects.
Definition: DynamicList.H:72
void append(const T &val)
Copy append an element to the end of this list.
Definition: DynamicListI.H:503
virtual bool resize()
Resize the ODE solver.
Definition: Euler.C:53
const word & name() const noexcept
Return the object name.
Definition: IOobjectI.H:65
writeOption
Enumeration defining the write options.
Definition: IOobject.H:186
readOption
Enumeration defining the read options.
Definition: IOobject.H:177
@ MUST_READ_IF_MODIFIED
Definition: IOobject.H:180
The IOstreamOption is a simple container for options an IOstream can normally have.
void resize(const label len)
Adjust allocated size of list.
Definition: ListI.H:139
An Ostream is an abstract base class for all output systems (streams, files, token lists,...
Definition: Ostream.H:62
void clearStorage()
Clear the list and delete storage.
Definition: PackedListI.H:520
const T * set(const label i) const
Definition: PtrList.H:138
void setSize(const label newLen)
Same as resize()
Definition: PtrList.H:151
void size(const label n)
Older name for setAddressableSize.
Definition: UList.H:114
label size() const noexcept
The number of elements in the list.
Definition: UPtrListI.H:106
label findZoneID(const word &zoneName) const
Find zone index by name, return -1 if not found.
Definition: ZoneMesh.C:525
void clearAddressing()
Clear addressing.
Definition: ZoneMesh.C:715
virtual bool writeObject(IOstreamOption streamOpt, const bool valid) const
Write using stream options.
void sync()
Do all: synchronise all IOFields and objectRegistry.
Definition: syncObjects.C:70
Class containing mesh-to-mesh mapping information after a change in polyMesh topology.
Definition: mapPolyMesh.H:162
const labelList & reversePointMap() const
Reverse point map.
Definition: mapPolyMesh.H:469
void updateMesh()
Update for new mesh topology.
A set of point labels.
Definition: pointSet.H:54
Like pointSet but -reads data from pointZone -updates pointZone when writing.
Definition: pointZoneSet.H:55
virtual void subtractSet(const topoSet &set)
Subtract elements present in set.
Definition: pointZoneSet.C:194
const labelList & addressing() const
Definition: pointZoneSet.H:105
virtual bool writeObject(IOstreamOption streamOpt, const bool valid) const
Write pointZone using stream options.
Definition: pointZoneSet.C:231
virtual void addSet(const topoSet &set)
Add elements present in set.
Definition: pointZoneSet.C:175
virtual void subset(const topoSet &set)
Subset contents. Only elements present in both sets remain.
Definition: pointZoneSet.C:156
void updateSet()
Sort addressing and make pointSet part consistent with addressing.
Definition: pointZoneSet.C:48
A subset of mesh points.
Definition: pointZone.H:68
Mesh consisting of general polyhedral cells.
Definition: polyMesh.H:81
const pointZoneMesh & pointZones() const noexcept
Return point zone mesh.
Definition: polyMesh.H:492
Cell-face mesh analysis engine.
Definition: primitiveMesh.H:79
label nPoints() const noexcept
Number of mesh points.
void writeDebug() const
Debug write.
virtual bool write(const bool valid=true) const
Write using setting from DB.
General set of labels of mesh quantity (points, cells, faces).
Definition: topoSet.H:67
virtual bool found(const label id) const
Has the given index?
Definition: topoSet.C:508
virtual void check(const label maxSize)
Check limits on addressable range.
Definition: topoSet.C:203
bool set() const
Are all the vector set.
Definition: triadI.H:76
A class for handling words, derived from Foam::string.
Definition: word.H:68
#define defineTypeNameAndDebug(Type, DebugSwitch)
Define the typeName and debug information.
Definition: className.H:121
dynamicFvMesh & mesh
OBJstream os(runTime.globalPath()/outputName)
const labelIOList & zoneID
Namespace for OpenFOAM.
To & refCast(From &r)
Reference type cast template function.
Definition: typeInfo.H:131
fileName::Type type(const fileName &name, const bool followLink=true)
Return the file type: DIRECTORY or FILE, normally following symbolic links.
Definition: MSwindows.C:598
void inplaceReorder(const labelUList &oldToNew, ListType &input, const bool prune=false)
Inplace reorder the elements of a list.
labelList sortedOrder(const UList< T > &input)
Return the (stable) sort order for the list.
word name(const expressions::valueTypeCode typeCode)
A word representation of a valueTypeCode. Empty for INVALID.
Definition: exprTraits.C:59
label newPointi
Definition: readKivaGrid.H:496
static const char *const typeName
The type name used in ensight case files.