UnsortedMeshedSurface.H
Go to the documentation of this file.
1 /*---------------------------------------------------------------------------*\
2  ========= |
3  \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
4  \\ / O peration |
5  \\ / A nd | Copyright (C) 2011-2015 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 Class
25  Foam::UnsortedMeshedSurface
26 
27 Description
28  A surface geometry mesh, in which the surface zone information is
29  conveyed by the 'zoneId' associated with each face.
30 
31  This form of surface description is particularly useful for reading in
32  surface meshes from third-party formats (eg, obj, stl, gts, etc.). It
33  can also be particularly useful for situations in which the surface
34  many be adjusted in an arbitrary manner without worrying about needed
35  to adjust the zone information (eg, surface refinement).
36 
37 See Also
38  The Foam::MeshedSurface - which is organized as a surface mesh, but
39  with independent zone information.
40 
41 SourceFiles
42  UnsortedMeshedSurface.C
43 
44 \*---------------------------------------------------------------------------*/
45 
46 #ifndef UnsortedMeshedSurface_H
47 #define UnsortedMeshedSurface_H
48 
49 #include "MeshedSurface.H"
50 #include "surfZoneIdentifierList.H"
51 #include "surfZoneList.H"
52 #include "surfaceFormatsCore.H"
53 #include "runTimeSelectionTables.H"
55 #include "HashSet.H"
56 
57 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
58 
59 namespace Foam
60 {
61 
62 // Forward declaration of friend functions and operators
63 
64 class Time;
65 class IFstream;
66 
67 template<class Face> class MeshedSurface;
68 template<class Face> class MeshedSurfaceProxy;
69 template<class Face> class UnsortedMeshedSurface;
70 
71 /*---------------------------------------------------------------------------*\
72  Class UnsortedMeshedSurface Declaration
73 \*---------------------------------------------------------------------------*/
74 
75 template<class Face>
76 class UnsortedMeshedSurface
77 :
78  public MeshedSurface<Face>
79 {
80  // friends - despite different face representationsx
81  template<class Face2> friend class MeshedSurface;
82  template<class Face2> friend class UnsortedMeshedSurface;
83  friend class surfMesh;
84 
85 private:
86 
87  // Private typedefs for convenience
88 
89  typedef MeshedSurface<Face> ParentType;
90  typedef MeshedSurface<Face> FriendType;
91  typedef MeshedSurfaceProxy<Face> ProxyType;
92 
93 
94  // Private Member Data
95 
96  //- The zone Id associated with each face
97  labelList zoneIds_;
98 
99  //- Zone information (face ordering nFaces/startFace only used
100  // during reading and writing)
101  List<surfZoneIdentifier> zoneToc_;
102 
103 
104  // Private Member Functions
105 
106  //- Disable resize with value
107  void resize(const label, const Face&);
108 
109  //- Disable setSize with value
110  void setSize(const label, const Face&);
111 
112 
113 protected:
114 
115  // Protected Member functions
116 
117  //- Return non-const access to the zone Ids
119  {
120  return zoneIds_;
121  }
122 
123  //- Return non-const access to the zone table-of-contents
125  {
126  return zoneToc_;
127  }
128 
129  //- Set new zones from faceMap
130  virtual void remapFaces(const labelUList& faceMap);
131 
132 
133 public:
134 
135  // Public typedefs
136 
137  //- Face type used
138  typedef Face FaceType;
139 
140  //- Runtime type information
141  TypeName("UnsortedMeshedSurface");
142 
143 
144  // Static
145 
146  //- Can we read this file format?
147  static bool canReadType(const word& ext, const bool verbose=false);
148 
149  //- Can we read this file format?
150  static bool canRead(const fileName&, const bool verbose=false);
151 
152  //- Can we write this file format?
153  static bool canWriteType(const word& ext, const bool verbose=false);
154 
155  static wordHashSet readTypes();
156  static wordHashSet writeTypes();
157 
158 
159  // Constructors
160 
161  //- Construct null
163 
164  //- Construct by transferring components
165  // (points, faces, zone ids, zone info).
167  (
168  const Xfer<pointField>&,
169  const Xfer<List<Face> >&,
170  const Xfer<List<label> >& zoneIds,
172  );
173 
174  //- Construct by transferring points, faces.
175  // Use zone information, or set single default zone
177  (
178  const Xfer<pointField>&,
179  const Xfer<List<Face> >&,
180  const labelUList& zoneSizes = labelUList(),
181  const UList<word>& zoneNames = UList<word>()
182  );
183 
184  //- Construct as copy
186 
187  //- Construct from a meshedSurface
189 
190  //- Construct by transferring the contents from a UnsortedMeshedSurface
192 
193  //- Construct by transferring the contents from a meshedSurface
195 
196  //- Construct from file name (uses extension to determine type)
198 
199  //- Construct from file name (uses extension to determine type)
200  UnsortedMeshedSurface(const fileName&, const word&);
201 
202  //- Construct from objectRegistry and a named surface
203  UnsortedMeshedSurface(const Time&, const word& surfName="");
204 
205 
206  // Declare run-time constructor selection table
207 
209  (
210  autoPtr,
212  fileExtension,
213  (
214  const fileName& name
215  ),
216  (name)
217  );
218 
219 
220  // Selectors
221 
222  //- Select constructed from filename (explicit extension)
224  (
225  const fileName&,
226  const word& ext
227  );
228 
229  //- Select constructed from filename (implicit extension)
231 
232 
233  //- Destructor
234  virtual ~UnsortedMeshedSurface();
235 
236 
237  // Member Function Selectors
238 
240  (
241  void,
243  write,
244  fileExtension,
245  (
246  const fileName& name,
247  const UnsortedMeshedSurface<Face>& surf
248  ),
249  (name, surf)
250  );
251 
252  //- Write to file
253  static void write(const fileName&, const UnsortedMeshedSurface<Face>&);
254 
255 
256  // Member Functions
257 
258  // Access
259 
260  //- The surface size is the number of faces
261  label size() const
262  {
263  return ParentType::size();
264  }
265 
266  //- Reset size of face and zone list
267  void setSize(const label);
268 
269  //- Return const access to the zone ids
270  const List<label>& zoneIds() const
271  {
272  return zoneIds_;
273  }
274 
275  //- Return const access to the zone table-of-contents
276  const List<surfZoneIdentifier>& zoneToc() const
277  {
278  return zoneToc_;
279  }
280 
281  //- Sort faces according to zoneIds
282  // Returns a surfZoneList and sets faceMap to index within faces()
283  // (i.e. map from original,unsorted to sorted)
284  surfZoneList sortedZones(labelList& faceMap) const;
285 
286  //- Set zones to 0 and set a single zone
287  void setOneZone();
288 
289  //- Set zone ids and zones
290  void setZones(const surfZoneList&);
291 
292  //- Set zone ids and zones
293  void setZones(const labelUList& sizes, const UList<word>& names);
294 
295  //- Set zone ids and zones with default names
296  void setZones(const labelUList& sizes);
297 
298 
299  // Edit
300 
301  //- Clear all storage
302  virtual void clear();
303 
304  //- Return new surface.
305  // Returns return pointMap, faceMap from subsetMeshMap
307  (
308  const labelHashSet& include,
309  labelList& pointMap,
310  labelList& faceMap
311  ) const;
312 
313  //- Return new surface.
315  (
316  const labelHashSet& include
317  ) const;
318 
319  //- Inherit reset from MeshedSurface<Face>
321 
322  //- Transfer components (points, faces, zone ids).
323  virtual void reset
324  (
325  const Xfer<pointField>&,
326  const Xfer<List<Face> >&,
327  const Xfer<List<label> >& zoneIds
328  );
329 
330  //- Transfer components (points, faces, zone ids).
331  virtual void reset
332  (
333  const Xfer<List<point> >&,
334  const Xfer<List<Face> >&,
335  const Xfer<List<label> >& zoneIds
336  );
337 
338  //- Transfer the contents of the argument and annul the argument
340 
341  //- Transfer the contents of the argument and annul the argument
343 
344  //- Transfer contents to the Xfer container
346 
347 
348  // Read
349 
350  //- Read from file. Chooses reader based on explicit extension
351  bool read(const fileName&, const word& ext);
352 
353  //- Read from file. Chooses reader based on detected extension
354  virtual bool read(const fileName&);
355 
356 
357  // Write
358 
359  //- Generic write routine. Chooses writer based on extension.
360  virtual void write(const fileName& name) const
361  {
362  write(name, *this);
363  }
364 
365  //- Write to database
366  void write(const Time&, const word& surfName="") const;
367 
368 
369  // Member operators
370 
372 
373  //- Conversion operator to MeshedSurfaceProxy
374  operator MeshedSurfaceProxy<Face>() const;
375 };
376 
377 
378 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
379 
380 } // End namespace Foam
381 
382 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
383 
384 #ifdef NoRepository
385 # include "UnsortedMeshedSurface.C"
386 #endif
387 
388 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
389 
390 #endif
391 
392 // ************************************************************************* //
List< label > & storedZoneIds()
Return non-const access to the zone Ids.
A surface mesh consisting of general polygon faces.
Definition: surfMesh.H:55
void operator=(const UnsortedMeshedSurface< Face > &)
TypeName("UnsortedMeshedSurface")
Runtime type information.
UList< label > labelUList
Definition: UList.H:63
const List< surfZoneIdentifier > & zoneToc() const
Return const access to the zone table-of-contents.
Xfer< UnsortedMeshedSurface< Face > > xfer()
Transfer contents to the Xfer container.
Macros to ease declaration of run-time selection tables.
A proxy for writing MeshedSurface, UnsortedMeshedSurface and surfMesh to various file formats...
Definition: MeshedSurface.H:73
A simple container for copying or transferring objects of type <T>.
Definition: Xfer.H:85
const List< label > & zoneIds() const
Return const access to the zone ids.
A class for handling words, derived from string.
Definition: word.H:59
static autoPtr< UnsortedMeshedSurface > New(const fileName &, const word &ext)
Select constructed from filename (explicit extension)
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
label size() const
The surface size is the number of faces.
bool read(const fileName &, const word &ext)
Read from file. Chooses reader based on explicit extension.
Namespace for OpenFOAM.
void setOneZone()
Set zones to 0 and set a single zone.
virtual void clear()
Clear all storage.
declareMemberFunctionSelectionTable(void, UnsortedMeshedSurface, write, fileExtension,( const fileName &name, const UnsortedMeshedSurface< Face > &surf ),(name, surf))
Class to control time during OpenFOAM simulations that is also the top-level objectRegistry.
Definition: Time.H:68
label size() const
The surface size is the number of faces.
void transfer(UnsortedMeshedSurface< Face > &)
Transfer the contents of the argument and annul the argument.
static bool canWriteType(const word &ext, const bool verbose=false)
Can we write this file format?
static bool canReadType(const word &ext, const bool verbose=false)
Can we read this file format?
points setSize(newPointi)
A surface geometry mesh, in which the surface zone information is conveyed by the &#39;zoneId&#39; associated...
Definition: MeshedSurface.H:74
UnsortedMeshedSurface subsetMesh(const labelHashSet &include, labelList &pointMap, labelList &faceMap) const
Return new surface.
virtual ~UnsortedMeshedSurface()
Destructor.
A class for handling file names.
Definition: fileName.H:69
A 1D vector of objects of type <T>, where the size of the vector is known and can be used for subscri...
Definition: HashTable.H:60
A HashTable with keys but without contents.
Definition: HashSet.H:59
List< surfZoneIdentifier > & storedZoneToc()
Return non-const access to the zone table-of-contents.
A surface geometry mesh with zone information, not to be confused with the similarly named surfaceMes...
Definition: MeshedSurface.H:72
void setZones(const surfZoneList &)
Set zone ids and zones.
virtual void remapFaces(const labelUList &faceMap)
Set new zones from faceMap.
declareRunTimeSelectionTable(autoPtr, UnsortedMeshedSurface, fileExtension,( const fileName &name ),(name))
static void write(const fileName &, const UnsortedMeshedSurface< Face > &)
Write to file.
An auto-pointer similar to the STL auto_ptr but with automatic casting to a reference to the type and...
Definition: PtrList.H:117
surfZoneList sortedZones(labelList &faceMap) const
Sort faces according to zoneIds.
virtual void reset(const Xfer< pointField > &, const Xfer< List< Face > > &, const Xfer< List< label > > &zoneIds)
Transfer components (points, faces, zone ids).
static bool canRead(const fileName &, const bool verbose=false)
Can we read this file format?
triSurfaceToAgglom resize(surfacesMesh.size())