src/surfMesh/UnsortedMeshedSurface/UnsortedMeshedSurface.H

   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 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"
  54 #include "memberFunctionSelectionTables.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
 118         List<label>& storedZoneIds()
 119         {
 120             return zoneIds_;
 121         }
 122
 123         //- Return non-const access to the zone table-of-contents
 124         List<surfZoneIdentifier>& storedZoneToc()
 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
 162         UnsortedMeshedSurface();
 163
 164         //- Construct by transferring components
 165         //  (points, faces, zone ids, zone info).
 166         UnsortedMeshedSurface
 167         (
 168             const Xfer<pointField>&,
 169             const Xfer<List<Face> >&,
 170             const Xfer<List<label> >& zoneIds,
 171             const Xfer<surfZoneIdentifierList>&
 172         );
 173
 174         //- Construct by transferring points, faces.
 175         //  Use zone information, or set single default zone
 176         UnsortedMeshedSurface
 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
 185         UnsortedMeshedSurface(const UnsortedMeshedSurface<Face>&);
 186
 187         //- Construct from a meshedSurface
 188         UnsortedMeshedSurface(const MeshedSurface<Face>&);
 189
 190         //- Construct by transferring the contents from a UnsortedMeshedSurface
 191         UnsortedMeshedSurface(const Xfer<UnsortedMeshedSurface<Face> >&);
 192
 193         //- Construct by transferring the contents from a meshedSurface
 194         UnsortedMeshedSurface(const Xfer<MeshedSurface<Face> >&);
 195
 196         //- Construct from file name (uses extension to determine type)
 197         UnsortedMeshedSurface(const fileName&);
 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
 208         declareRunTimeSelectionTable
 209         (
 210             autoPtr,
 211             UnsortedMeshedSurface,
 212             fileExtension,
 213             (
 214                 const fileName& name
 215             ),
 216             (name)
 217         );
 218
 219
 220     // Selectors
 221
 222         //- Select constructed from filename (explicit extension)
 223         static autoPtr<UnsortedMeshedSurface> New
 224         (
 225             const fileName&,
 226             const word& ext
 227         );
 228
 229         //- Select constructed from filename (implicit extension)
 230         static autoPtr<UnsortedMeshedSurface> New(const fileName&);
 231
 232
 233     //- Destructor
 234     virtual ~UnsortedMeshedSurface();
 235
 236
 237     // Member Function Selectors
 238
 239         declareMemberFunctionSelectionTable
 240         (
 241             void,
 242             UnsortedMeshedSurface,
 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             surfZoneList sortedZones(labelList& faceMap) const;
 284
 285             //- Set zones to 0 and set a single zone
 286             void setOneZone();
 287
 288             //- Set zone ids and zones
 289             void setZones(const surfZoneList&);
 290
 291             //- Set zone ids and zones
 292             void setZones(const labelUList& sizes, const UList<word>& names);
 293
 294             //- Set zone ids and zones with default names
 295             void setZones(const labelUList& sizes);
 296
 297
 298         // Edit
 299
 300             //- Clear all storage
 301             virtual void clear();
 302
 303             //- Return new surface.
 304             //  Returns return pointMap, faceMap from subsetMeshMap
 305             UnsortedMeshedSurface subsetMesh
 306             (
 307                 const labelHashSet& include,
 308                 labelList& pointMap,
 309                 labelList& faceMap
 310             ) const;
 311
 312             //- Return new surface.
 313             UnsortedMeshedSurface subsetMesh
 314             (
 315                 const labelHashSet& include
 316             ) const;
 317
 318             //- Transfer components (points, faces, zone ids).
 319             virtual void reset
 320             (
 321                 const Xfer<pointField>&,
 322                 const Xfer<List<Face> >&,
 323                 const Xfer<List<label> >& zoneIds
 324             );
 325
 326             //- Transfer components (points, faces, zone ids).
 327             virtual void reset
 328             (
 329                 const Xfer<List<point> >&,
 330                 const Xfer<List<Face> >&,
 331                 const Xfer<List<label> >& zoneIds
 332             );
 333
 334             //- Transfer the contents of the argument and annul the argument
 335             void transfer(UnsortedMeshedSurface<Face>&);
 336
 337             //- Transfer the contents of the argument and annul the argument
 338             void transfer(MeshedSurface<Face>&);
 339
 340             //- Transfer contents to the Xfer container
 341             Xfer<UnsortedMeshedSurface<Face> > xfer();
 342
 343
 344         // Read
 345
 346             //- Read from file. Chooses reader based on explicit extension
 347             bool read(const fileName&, const word& ext);
 348
 349             //- Read from file. Chooses reader based on detected extension
 350             virtual bool read(const fileName&);
 351
 352
 353         // Write
 354
 355             //- Generic write routine. Chooses writer based on extension.
 356             virtual void write(const fileName& name) const
 357             {
 358                 write(name, *this);
 359             }
 360
 361             //- Write to database
 362             void write(const Time&, const word& surfName="") const;
 363
 364
 365         // Member operators
 366
 367             void operator=(const UnsortedMeshedSurface<Face>&);
 368
 369             //- Conversion operator to MeshedSurfaceProxy
 370             operator MeshedSurfaceProxy<Face>() const;
 371 };
 372
 373
 374 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 375
 376 } // End namespace Foam
 377
 378 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 379
 380 #ifdef NoRepository
 381 #   include "UnsortedMeshedSurface.C"
 382 #endif
 383
 384 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 385
 386 #endif
 387
 388 // ************************************************************************* //