topoSet.C
Go to the documentation of this file.
1 /*---------------------------------------------------------------------------*\
2  ========= |
3  \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
4  \\ / O peration | Website: https://openfoam.org
5  \\ / A nd | Copyright (C) 2011-2018 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 Application
25  topoSet
26 
27 Description
28  Operates on cellSets/faceSets/pointSets through a dictionary.
29 
30 \*---------------------------------------------------------------------------*/
31 
32 #include "argList.H"
33 #include "Time.H"
34 #include "polyMesh.H"
35 #include "topoSetSource.H"
36 #include "globalMeshData.H"
37 #include "timeSelector.H"
38 #include "IOobjectList.H"
39 #include "cellZoneSet.H"
40 #include "faceZoneSet.H"
41 #include "pointZoneSet.H"
42 #include "IOdictionary.H"
43 
44 using namespace Foam;
45 
46 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
47 
48 void printMesh(const Time& runTime, const polyMesh& mesh)
49 {
50  Info<< "Time:" << runTime.timeName()
51  << " cells:" << mesh.globalData().nTotalCells()
52  << " faces:" << mesh.globalData().nTotalFaces()
53  << " points:" << mesh.globalData().nTotalPoints()
54  << " patches:" << mesh.boundaryMesh().size()
55  << " bb:" << mesh.bounds() << nl;
56 }
57 
58 
59 template<class ZoneType>
60 void removeZone
61 (
63  const word& setName
64 )
65 {
66  label zoneID = zones.findZoneID(setName);
67 
68  if (zoneID != -1)
69  {
70  Info<< "Removing zone " << setName << " at index " << zoneID << endl;
71  // Shuffle to last position
72  labelList oldToNew(zones.size());
73  label newI = 0;
74  forAll(oldToNew, i)
75  {
76  if (i != zoneID)
77  {
78  oldToNew[i] = newI++;
79  }
80  }
81  oldToNew[zoneID] = newI;
82  zones.reorder(oldToNew);
83  // Remove last element
84  zones.setSize(zones.size()-1);
85  zones.clearAddressing();
86  zones.write();
87  fileHandler().flush();
88  }
89 }
90 
91 
92 // Physically remove a set
93 void removeSet
94 (
95  const polyMesh& mesh,
96  const word& setType,
97  const word& setName
98 )
99 {
100  // Remove the file
102  (
103  mesh,
104  mesh.time().findInstance
105  (
106  polyMesh::meshSubDir/"sets",
107  word::null,
109  mesh.facesInstance()
110  ),
111  polyMesh::meshSubDir/"sets"
112  );
113 
114  if (objects.found(setName))
115  {
116  // Remove file
117  fileName object = objects[setName]->objectPath();
118  Info<< "Removing file " << object << endl;
119  rm(object);
120  }
121 
122  // See if zone
123  if (setType == cellZoneSet::typeName)
124  {
125  removeZone
126  (
127  const_cast<cellZoneMesh&>(mesh.cellZones()),
128  setName
129  );
130  }
131  else if (setType == faceZoneSet::typeName)
132  {
133  removeZone
134  (
135  const_cast<faceZoneMesh&>(mesh.faceZones()),
136  setName
137  );
138  }
139  else if (setType == pointZoneSet::typeName)
140  {
141  removeZone
142  (
143  const_cast<pointZoneMesh&>(mesh.pointZones()),
144  setName
145  );
146  }
147 }
148 
149 
150 polyMesh::readUpdateState meshReadUpdate(polyMesh& mesh)
151 {
153 
154  switch(stat)
155  {
156  case polyMesh::UNCHANGED:
157  {
158  Info<< " mesh not changed." << endl;
159  break;
160  }
162  {
163  Info<< " points moved; topology unchanged." << endl;
164  break;
165  }
167  {
168  Info<< " topology changed; patches unchanged." << nl
169  << " ";
170  printMesh(mesh.time(), mesh);
171  break;
172  }
174  {
175  Info<< " topology changed and patches changed." << nl
176  << " ";
177  printMesh(mesh.time(), mesh);
178 
179  break;
180  }
181  default:
182  {
184  << "Illegal mesh update state "
185  << stat << abort(FatalError);
186  break;
187  }
188  }
189  return stat;
190 }
191 
192 
193 
194 int main(int argc, char *argv[])
195 {
196  timeSelector::addOptions(true, false);
197  #include "addDictOption.H"
198  #include "addRegionOption.H"
200  (
201  "noSync",
202  "do not synchronise selection across coupled patches"
203  );
204 
205  #include "setRootCase.H"
206  #include "createTime.H"
207 
208  instantList timeDirs = timeSelector::selectIfPresent(runTime, args);
209 
210  #include "createNamedPolyMesh.H"
211 
212  const bool noSync = args.optionFound("noSync");
213 
214  const word dictName("topoSetDict");
215  #include "setSystemMeshDictionaryIO.H"
216 
217  Info<< "Reading " << dictName << "\n" << endl;
218 
219  IOdictionary topoSetDict(dictIO);
220 
221  // Read set construct info from dictionary
222  PtrList<dictionary> actions(topoSetDict.lookup("actions"));
223 
224  forAll(timeDirs, timeI)
225  {
226  runTime.setTime(timeDirs[timeI], timeI);
227  Info<< "Time = " << runTime.timeName() << endl;
228 
229  // Optionally re-read mesh
230  meshReadUpdate(mesh);
231 
232  // Execute all actions
233  forAll(actions, i)
234  {
235  const dictionary& dict = actions[i];
236 
237  const word setName(dict.lookup("name"));
238  const word actionName(dict.lookup("action"));
239  const word setType(dict.lookup("type"));
240 
241 
243  (
244  actionName
245  );
246 
247  autoPtr<topoSet> currentSet;
248  if
249  (
250  (action == topoSetSource::NEW)
251  || (action == topoSetSource::CLEAR)
252  )
253  {
254  currentSet = topoSet::New(setType, mesh, setName, 10000);
255  Info<< "Created " << currentSet().type() << " "
256  << setName << endl;
257  }
258  else if (action == topoSetSource::REMOVE)
259  {
260  //?
261  }
262  else
263  {
264  currentSet = topoSet::New
265  (
266  setType,
267  mesh,
268  setName,
270  );
271  Info<< "Read set " << currentSet().type() << " "
272  << setName << " with size "
273  << returnReduce(currentSet().size(), sumOp<label>())
274  << endl;
275  }
276 
277 
278 
279  // Handle special actions (clear, invert) locally, rest through
280  // sources.
281  switch (action)
282  {
283  case topoSetSource::NEW:
284  case topoSetSource::ADD:
286  {
287  Info<< " Applying source " << word(dict.lookup("source"))
288  << endl;
290  (
291  dict.lookup("source"),
292  mesh,
293  dict.subDict("sourceInfo")
294  );
295 
296  source().applyToSet(action, currentSet());
297  // Synchronize for coupled patches.
298  if (!noSync) currentSet().sync(mesh);
299  currentSet().write();
300  fileHandler().flush();
301  }
302  break;
303 
305  {
306  Info<< " Applying source " << word(dict.lookup("source"))
307  << endl;
309  (
310  dict.lookup("source"),
311  mesh,
312  dict.subDict("sourceInfo")
313  );
314 
315  // Backup current set.
316  autoPtr<topoSet> oldSet
317  (
319  (
320  setType,
321  mesh,
322  currentSet().name() + "_old2",
323  currentSet()
324  )
325  );
326 
327  currentSet().clear();
328  source().applyToSet(topoSetSource::NEW, currentSet());
329 
330  // Combine new value of currentSet with old one.
331  currentSet().subset(oldSet());
332  // Synchronize for coupled patches.
333  if (!noSync) currentSet().sync(mesh);
334  currentSet().write();
335  fileHandler().flush();
336  }
337  break;
338 
340  Info<< " Clearing " << currentSet().type() << endl;
341  currentSet().clear();
342  currentSet().write();
343  fileHandler().flush();
344  break;
345 
347  Info<< " Inverting " << currentSet().type() << endl;
348  currentSet().invert(currentSet().maxSize(mesh));
349  currentSet().write();
350  fileHandler().flush();
351  break;
352 
354  Info<< " Removing set" << endl;
355  removeSet(mesh, setType, setName);
356  break;
357 
358 
359  default:
361  << "Unhandled action " << action << endl;
362  break;
363  }
364 
365  if (currentSet.valid())
366  {
367  Info<< " " << currentSet().type() << " "
368  << currentSet().name()
369  << " now size "
370  << returnReduce(currentSet().size(), sumOp<label>())
371  << endl;
372  }
373  }
374  }
375 
376  Info<< "End\n" << endl;
377 
378  return 0;
379 }
380 
381 
382 // ************************************************************************* //
const polyBoundaryMesh & boundaryMesh() const
Return boundary mesh.
Definition: polyMesh.H:434
void reorder(const labelUList &oldToNew)
Reorders elements. Ordering does not have to be done in.
Definition: PtrList.C:197
#define forAll(list, i)
Loop across all elements in list.
Definition: UList.H:434
static autoPtr< topoSet > New(const word &setType, const polyMesh &mesh, const word &name, readOption r=MUST_READ, writeOption w=NO_WRITE)
Return a pointer to a toposet read from file.
void clearAddressing()
Clear addressing.
Definition: ZoneMesh.C:387
intWM_LABEL_SIZE_t label
A label is an int32_t or int64_t as specified by the pre-processor macro WM_LABEL_SIZE.
Definition: label.H:59
A class for handling file names.
Definition: fileName.H:79
List of IOobjects with searching and retrieving facilities.
Definition: IOobjectList.H:50
const faceZoneMesh & faceZones() const
Return face zone mesh.
Definition: polyMesh.H:476
const fileName & facesInstance() const
Return the current instance directory for faces.
Definition: polyMesh.C:808
error FatalError
A list of keyword definitions, which are a keyword followed by any number of values (e...
Definition: dictionary.H:158
#define FatalErrorInFunction
Report an error message using Foam::FatalError.
Definition: error.H:319
label nTotalPoints() const
Return total number of points in decomposed mesh. Not.
static word meshSubDir
Return the mesh sub-directory name (usually "polyMesh")
Definition: polyMesh.H:312
Ostream & endl(Ostream &os)
Add newline and flush stream.
Definition: Ostream.H:256
bool optionFound(const word &opt) const
Return true if the named option is found.
Definition: argListI.H:108
word findInstance(const fileName &dir, const word &name=word::null, const IOobject::readOption rOpt=IOobject::MUST_READ, const word &stopInstance=word::null) const
Return the location of "dir" containing the file "name".
Definition: Time.C:649
label nTotalCells() const
Return total number of cells in decomposed mesh.
A list of mesh zones.
static word timeName(const scalar, const int precision=precision_)
Return time name of given scalar time.
Definition: Time.C:626
Class to control time during OpenFOAM simulations that is also the top-level objectRegistry.
Definition: Time.H:68
IOdictionary is derived from dictionary and IOobject to give the dictionary automatic IO functionalit...
Definition: IOdictionary.H:52
const dictionary & subDict(const word &) const
Find and return a sub-dictionary.
Definition: dictionary.C:699
void clear()
Delete object (if the pointer is valid) and set pointer to.
Definition: autoPtrI.H:126
label nTotalFaces() const
Return total number of faces in decomposed mesh. Not.
dynamicFvMesh & mesh
label findZoneID(const word &zoneName) const
Find zone index given a name.
Definition: ZoneMesh.C:341
const pointZoneMesh & pointZones() const
Return point zone mesh.
Definition: polyMesh.H:470
A class for handling words, derived from string.
Definition: word.H:59
const cellZoneMesh & cellZones() const
Return cell zone mesh.
Definition: polyMesh.H:482
setAction
Enumeration defining the valid actions.
Definition: topoSetSource.H:82
static const word null
An empty word.
Definition: word.H:77
const globalMeshData & globalData() const
Return parallel info.
Definition: polyMesh.C:1394
const word dictName("particleTrackDict")
static instantList selectIfPresent(Time &runTime, const argList &args)
If any time option provided return the set of times (as select0)
Definition: timeSelector.C:283
virtual void setTime(const Time &)
Reset the time and time-index to those of the given time.
Definition: Time.C:873
const fileOperation & fileHandler()
Get current file handler.
bool valid() const
Return true if the autoPtr valid (ie, the pointer is set)
Definition: autoPtrI.H:83
errorManip< error > abort(error &err)
Definition: errorManip.H:131
void setSize(const label)
Reset size of PtrList. If extending the PtrList, new entries are.
Definition: PtrList.C:131
static const char nl
Definition: Ostream.H:265
objects
const Time & time() const
Return time.
static autoPtr< topoSetSource > New(const word &topoSetSourceType, const polyMesh &mesh, const dictionary &dict)
Return a reference to the selected topoSetSource.
Definition: topoSetSource.C:74
word name(const complex &)
Return a string representation of a complex.
Definition: complex.C:47
IOobject dictIO(dictName, runTime.constant(), mesh, IOobject::MUST_READ_IF_MODIFIED, IOobject::NO_WRITE)
virtual void flush() const
Forcibly wait until all output done. Flush any cached data.
label size() const
Return the number of elements in the UPtrList.
Definition: UPtrListI.H:29
const boundBox & bounds() const
Return mesh bounding box.
Definition: polyMesh.H:440
#define WarningInFunction
Report a warning using Foam::Warning.
A templated 1D list of pointers to objects of type <T>, where the size of the array is known and used...
Definition: List.H:70
messageStream Info
static setAction toAction(const word &actionName)
Convert string to action.
T returnReduce(const T &Value, const BinaryOp &bop, const int tag=Pstream::msgType(), const label comm=UPstream::worldComm)
An auto-pointer similar to the STL auto_ptr but with automatic casting to a reference to the type and...
Definition: PtrList.H:52
Mesh consisting of general polyhedral cells.
Definition: polyMesh.H:74
static void addBoolOption(const word &opt, const string &usage="")
Add to a bool option to validOptions with usage information.
Definition: argList.C:117
readUpdateState
Enumeration defining the state of the mesh after a read update.
Definition: polyMesh.H:88
virtual bool write(const bool write=true) const
Write using setting from DB.
virtual readUpdateState readUpdate()
Update the mesh based on the mesh files saved in.
Definition: polyMeshIO.C:71
bool rm(const fileName &)
Remove a file, returning true if successful otherwise false.
Definition: POSIX.C:1021
Foam::argList args(argc, argv)
static void addOptions(const bool constant=true, const bool withZero=false)
Add the options handled by timeSelector to argList::validOptions.
Definition: timeSelector.C:114
Namespace for OpenFOAM.
ITstream & lookup(const word &, bool recursive=false, bool patternMatch=true) const
Find and return an entry data stream.
Definition: dictionary.C:583