src/edgeMesh/edgeMesh.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::edgeMesh
  26
  27 Description
  28     Points connected by edges.
  29
  30 SourceFiles
  31     edgeMeshI.H
  32     edgeMesh.C
  33     edgeMeshIO.C
  34
  35 \*---------------------------------------------------------------------------*/
  36
  37 #ifndef edgeMesh_H
  38 #define edgeMesh_H
  39
  40 #include "pointField.H"
  41 #include "edgeList.H"
  42 #include "edgeFormatsCore.H"
  43 #include "runTimeSelectionTables.H"
  44 #include "memberFunctionSelectionTables.H"
  45 #include "HashSet.H"
  46
  47 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  48
  49 namespace Foam
  50 {
  51
  52 // Forward declaration of classes
  53 class Istream;
  54 class Ostream;
  55
  56 // Forward declaration of friend functions and operators
  57 class edgeMesh;
  58 Istream& operator>>(Istream&, edgeMesh&);
  59 Ostream& operator<<(Ostream&, const edgeMesh&);
  60
  61
  62 /*---------------------------------------------------------------------------*\
  63                            Class edgeMesh Declaration
  64 \*---------------------------------------------------------------------------*/
  65
  66 class edgeMesh
  67 :
  68     public fileFormats::edgeFormatsCore
  69 {
  70     // Private data
  71
  72         //- Vertices of the edges
  73         pointField points_;
  74
  75         //- The edges defining the boundary
  76         edgeList edges_;
  77
  78         //- From point to edges
  79         mutable autoPtr<labelListList> pointEdgesPtr_;
  80
  81     // Private Member Functions
  82
  83         //- Calculate point-edge addressing (inverse of edges)
  84         void calcPointEdges() const;
  85
  86
  87 protected:
  88
  89     // Protected Member Functions
  90
  91         //- Non-const access to global points
  92         inline pointField& storedPoints();
  93
  94         //- Non-const access to the edges
  95         inline edgeList& storedEdges();
  96
  97
  98 public:
  99
 100         //- Runtime type information
 101         TypeName("edgeMesh");
 102
 103
 104     // Static
 105
 106         //- Can we read this file format?
 107         static bool canRead(const fileName&, const bool verbose=false);
 108
 109         //- Can we read this file format?
 110         static bool canReadType(const word& ext, const bool verbose=false);
 111
 112         //- Can we write this file format type?
 113         static bool canWriteType(const word& ext, const bool verbose=false);
 114
 115         static wordHashSet readTypes();
 116         static wordHashSet writeTypes();
 117
 118
 119     // Constructors
 120
 121         //- Construct null
 122         edgeMesh();
 123
 124         //- Construct from components
 125         edgeMesh(const pointField&, const edgeList&);
 126
 127         //- Construct by transferring components (points, edges).
 128         edgeMesh
 129         (
 130             const Xfer<pointField>&,
 131             const Xfer<edgeList>&
 132         );
 133
 134         //- Construct as copy
 135         edgeMesh(const edgeMesh&);
 136
 137         //- Construct from file name (uses extension to determine type)
 138         edgeMesh(const fileName&);
 139
 140         //- Construct from file name (uses extension to determine type)
 141         edgeMesh(const fileName&, const word& ext);
 142
 143         //- Construct from Istream
 144         edgeMesh(Istream&);
 145
 146
 147     // Declare run-time constructor selection table
 148
 149         declareRunTimeSelectionTable
 150         (
 151             autoPtr,
 152             edgeMesh,
 153             fileExtension,
 154             (
 155                 const fileName& name
 156             ),
 157             (name)
 158         );
 159
 160
 161     // Selectors
 162
 163         //- Select constructed from filename (explicit extension)
 164         static autoPtr<edgeMesh> New
 165         (
 166             const fileName&,
 167             const word& ext
 168         );
 169
 170         //- Select constructed from filename (implicit extension)
 171         static autoPtr<edgeMesh> New(const fileName&);
 172
 173
 174     //- Destructor
 175     virtual ~edgeMesh();
 176
 177
 178     // Member Function Selectors
 179
 180         declareMemberFunctionSelectionTable
 181         (
 182             void,
 183             edgeMesh,
 184             write,
 185             fileExtension,
 186             (
 187                 const fileName& name,
 188                 const edgeMesh& mesh
 189             ),
 190             (name, mesh)
 191         );
 192
 193         //- Write to file
 194         static void write(const fileName&, const edgeMesh&);
 195
 196
 197     // Member Functions
 198
 199         //- Transfer the contents of the argument and annul the argument
 200         void transfer(edgeMesh&);
 201
 202         //- Transfer contents to the Xfer container
 203         Xfer<edgeMesh > xfer();
 204
 205     // Read
 206
 207         //- Read from file. Chooses reader based on explicit extension
 208         bool read(const fileName&, const word& ext);
 209
 210         //- Read from file. Chooses reader based on detected extension
 211         virtual bool read(const fileName&);
 212
 213
 214     // Access
 215
 216         //- Return points
 217         inline const pointField& points() const;
 218
 219         //- Return edges
 220         inline const edgeList& edges() const;
 221
 222         //- Return edges
 223         inline const labelListList& pointEdges() const;
 224
 225         //- Find connected regions. Set region number per edge.
 226         //  Returns number of regions.
 227         label regions(labelList& edgeRegion) const;
 228
 229
 230     // Edit
 231
 232         //- Clear all storage
 233         virtual void clear();
 234
 235         //- Reset primitive data (points, edges)
 236         //  Note, optimized to avoid overwriting data (with Xfer::null)
 237         virtual void reset
 238         (
 239             const Xfer<pointField>& points,
 240             const Xfer<edgeList>& edges
 241         );
 242
 243         //- Scale points. A non-positive factor is ignored
 244         virtual void scalePoints(const scalar);
 245
 246         //- Merge common points (points within mergeDist)
 247         void mergePoints(const scalar mergeDist);
 248
 249
 250     // Write
 251
 252         void writeStats(Ostream&) const;
 253
 254         //- Generic write routine. Chooses writer based on extension.
 255         virtual void write(const fileName& name) const
 256         {
 257             write(name, *this);
 258         }
 259
 260
 261     // Member Operators
 262
 263         inline void operator=(const edgeMesh&);
 264
 265         // Ostream Operator
 266
 267             friend Ostream& operator<<(Ostream&, const edgeMesh&);
 268             friend Istream& operator>>(Istream&, edgeMesh&);
 269
 270 };
 271
 272
 273 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 274
 275 } // End namespace Foam
 276
 277 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 278
 279 #include "edgeMeshI.H"
 280
 281 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 282
 283 #endif
 284
 285 // ************************************************************************* //