src/edgeMesh/extendedFeatureEdgeMesh/extendedFeatureEdgeMesh.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::extendedFeatureEdgeMesh
  26
  27 Description
  28
  29     Description of feature edges and points.
  30
  31     Feature points are a sorted subset at the start of the overall points list:
  32         0 .. concaveStart_-1                : convex points (w.r.t normals)
  33         concaveStart_-1 .. mixedStart_-1    : concave points
  34         mixedStart_ .. nonFeatureStart_     : mixed internal/external points
  35         nonFeatureStart_ .. size-1          : non-feature points
  36
  37     Feature edges are the edgeList of the edgeMesh and are sorted:
  38         0 .. internalStart_-1           : external edges (convex w.r.t normals)
  39         internalStart_ .. flatStart_-1  : internal edges (concave)
  40         flatStart_ .. openStart_-1      : flat edges (neither concave or convex)
  41                                           can arise from region interfaces on
  42                                           flat surfaces
  43         openStart_ .. multipleStart_-1  : open edges (e.g. from baffle surfaces)
  44         multipleStart_ .. size-1        : multiply connected edges
  45
  46     The edge direction and feature edge and feature point adjacent normals
  47     are stored.
  48
  49 SourceFiles
  50     extendedFeatureEdgeMeshI.H
  51     extendedFeatureEdgeMesh.C
  52
  53 \*---------------------------------------------------------------------------*/
  54
  55 #ifndef extendedFeatureEdgeMesh_H
  56 #define extendedFeatureEdgeMesh_H
  57
  58 #include "edgeMesh.H"
  59 #include "surfaceFeatures.H"
  60 #include "objectRegistry.H"
  61 #include "IOdictionary.H"
  62 #include "indexedOctree.H"
  63 #include "treeDataEdge.H"
  64 #include "pointIndexHit.H"
  65
  66 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  67
  68 namespace Foam
  69 {
  70
  71 /*---------------------------------------------------------------------------*\
  72                        Class extendedFeatureEdgeMesh Declaration
  73 \*---------------------------------------------------------------------------*/
  74
  75 class extendedFeatureEdgeMesh
  76 :
  77     public regIOobject,
  78     public edgeMesh
  79 {
  80
  81 public:
  82
  83     //- Runtime type information
  84     TypeName("extendedFeatureEdgeMesh");
  85
  86     enum pointStatus
  87     {
  88         CONVEX,     // Fully convex point (w.r.t normals)
  89         CONCAVE,    // Fully concave point
  90         MIXED,      // A point surrounded by both convex and concave edges
  91         NONFEATURE  // Not a feature point
  92     };
  93
  94     enum edgeStatus
  95     {
  96         EXTERNAL,   // "Convex" edge
  97         INTERNAL,   // "Concave" edge
  98         FLAT,       // Neither concave or convex, on a flat surface
  99         OPEN,       // i.e. only connected to one face
 100         MULTIPLE,   // Multiply connected (connected to more than two faces)
 101         NONE        // Not a classified feature edge (consistency with
 102                     // surfaceFeatures)
 103     };
 104
 105 private:
 106
 107     // Static data
 108
 109         //- Angular closeness tolerance for treating normals as the same
 110         static scalar cosNormalAngleTol_;
 111
 112         //- Index of the start of the convex feature points - static as 0
 113         static label convexStart_;
 114
 115         //- Index of the start of the external feature edges - static as 0
 116         static label externalStart_;
 117
 118
 119     // Private data
 120
 121         //- Index of the start of the concave feature points
 122         label concaveStart_;
 123
 124         //- Index of the start of the mixed type feature points
 125         label mixedStart_;
 126
 127         //- Index of the start of the non-feature points
 128         label nonFeatureStart_;
 129
 130         //- Index of the start of the internal feature edges
 131         label internalStart_;
 132
 133         //- Index of the start of the flat feature edges
 134         label flatStart_;
 135
 136         //- Index of the start of the open feature edges
 137         label openStart_;
 138
 139         //- Index of the start of the multiply-connected feature edges
 140         label multipleStart_;
 141
 142         //- Normals of the features, to be referred to by index by both feature
 143         //  points and edges, unsorted
 144         vectorField normals_;
 145
 146         //- Flat and open edges require the direction of the edge
 147         vectorField edgeDirections_;
 148
 149         //- Indices of the normals that are adjacent to the feature edges
 150         labelListList edgeNormals_;
 151
 152         //- Indices of the normals that are adjacent to the feature points
 153         labelListList featurePointNormals_;
 154
 155         //- Feature edges which are on the boundary between regions
 156         labelList regionEdges_;
 157
 158         //- Search tree for all edges
 159         mutable autoPtr<indexedOctree<treeDataEdge> > edgeTree_;
 160
 161         //- Individual search trees for each type of edge
 162         mutable PtrList<indexedOctree<treeDataEdge> > edgeTreesByType_;
 163
 164
 165     // Private Member Functions
 166
 167         //- Classify the type of feature point.  Requires valid stored member
 168         //  data for edges and normals.
 169         pointStatus classifyFeaturePoint(label ptI) const;
 170
 171         //- Classify the type of feature edge.  Requires face centre 0 to face
 172         //  centre 1 vector to distinguish internal from external
 173         edgeStatus classifyEdge
 174         (
 175             const List<vector>& norms,
 176             const labelList& edNorms,
 177             const vector& fC0tofC1
 178         ) const;
 179
 180
 181 public:
 182
 183     // Static data
 184
 185         //- Number of possible point types (i.e. number of slices)
 186         static label nPointTypes;
 187
 188         //- Number of possible feature edge types (i.e. number of slices)
 189         static label nEdgeTypes;
 190
 191     // Constructors
 192
 193         //- Construct (read) given an IOobject
 194         extendedFeatureEdgeMesh(const IOobject&);
 195
 196         //- Construct as copy
 197         explicit extendedFeatureEdgeMesh
 198         (
 199             const IOobject&,
 200             const extendedFeatureEdgeMesh&
 201         );
 202
 203         //- Construct by transferring components (points, edges)
 204         extendedFeatureEdgeMesh
 205         (
 206             const IOobject&,
 207             const Xfer<pointField>&,
 208             const Xfer<edgeList>&
 209         );
 210
 211         //- Construct (read) given surfaceFeatures, an objectRegistry and a
 212         //  fileName to write to.  Extracts, classifies and reorders the data
 213         //  from surfaceFeatures.
 214         extendedFeatureEdgeMesh
 215         (
 216             const surfaceFeatures& sFeat,
 217             const objectRegistry& obr,
 218             const fileName& sFeatFileName
 219         );
 220
 221         //- Construct from all components
 222         extendedFeatureEdgeMesh
 223         (
 224             const IOobject& io,
 225             const pointField& pts,
 226             const edgeList& eds,
 227             label concaveStart,
 228             label mixedStart,
 229             label nonFeatureStart,
 230             label internalStart,
 231             label flatStart,
 232             label openStart,
 233             label multipleStart,
 234             const vectorField& normals,
 235             const vectorField& edgeDirections,
 236             const labelListList& edgeNormals,
 237             const labelListList& featurePointNormals,
 238             const labelList& regionEdges
 239         );
 240
 241
 242     //- Destructor
 243     ~extendedFeatureEdgeMesh();
 244
 245
 246     // Member Functions
 247
 248         // Find
 249
 250             //- Find nearest surface edge for the sample point.
 251             void nearestFeatureEdge
 252             (
 253                 const point& sample,
 254                 scalar searchDistSqr,
 255                 pointIndexHit& info
 256             ) const;
 257
 258             //- Find nearest surface edge for each sample point.
 259             void nearestFeatureEdge
 260             (
 261                 const pointField& samples,
 262                 const scalarField& searchDistSqr,
 263                 List<pointIndexHit>& info
 264             ) const;
 265
 266             //- Find the nearest point on each type of feature edge
 267             void nearestFeatureEdgeByType
 268             (
 269                 const point& sample,
 270                 const scalarField& searchDistSqr,
 271                 List<pointIndexHit>& info
 272             ) const;
 273
 274         // Access
 275
 276             //- Return the index of the start of the convex feature points
 277             inline label convexStart() const;
 278
 279             //- Return the index of the start of the concave feature points
 280             inline label concaveStart() const;
 281
 282             //- Return the index of the start of the mixed type feature points
 283             inline label mixedStart() const;
 284
 285             //- Return the index of the start of the non-feature points
 286             inline label nonFeatureStart() const;
 287
 288             //- Return the index of the start of the external feature edges
 289             inline label externalStart() const;
 290
 291             //- Return the index of the start of the internal feature edges
 292             inline label internalStart() const;
 293
 294             //- Return the index of the start of the flat feature edges
 295             inline label flatStart() const;
 296
 297             //- Return the index of the start of the open feature edges
 298             inline label openStart() const;
 299
 300             //- Return the index of the start of the multiply-connected feature
 301             //  edges
 302             inline label multipleStart() const;
 303
 304             //- Return whether or not the point index is a feature point
 305             inline bool featurePoint(label ptI) const;
 306
 307             //- Return the normals of the surfaces adjacent to the feature edges
 308             //  and points
 309             inline const vectorField& normals() const;
 310
 311             //- Return the edgeDirection vectors
 312             inline const vectorField& edgeDirections() const;
 313
 314             //- Return the direction of edgeI, pointing away from ptI
 315             inline vector edgeDirection(label edgeI, label ptI) const;
 316
 317             //- Return the indices of the normals that are adjacent to the
 318             //  feature edges
 319             inline const labelListList& edgeNormals() const;
 320
 321             //- Return the normal vectors for a given set of normal indices
 322             inline vectorField edgeNormals(const labelList& edgeNormIs) const;
 323
 324             //- Return the normal vectors for a given edge
 325             inline vectorField edgeNormals(label edgeI) const;
 326
 327             //- Return the indices of the normals that are adjacent to the
 328             //  feature points
 329             inline const labelListList& featurePointNormals() const;
 330
 331             //- Return the normal vectors for a given feature point
 332             inline vectorField featurePointNormals(label ptI) const;
 333
 334             //- Return the feature edges which are on the boundary between
 335             //  regions
 336             inline const labelList& regionEdges() const;
 337
 338             //- Return the pointStatus of a specified point
 339             inline pointStatus getPointStatus(label ptI) const;
 340
 341             //- Return the edgeStatus of a specified edge
 342             inline edgeStatus getEdgeStatus(label edgeI) const;
 343
 344             //- Demand driven construction of octree for boundary edges
 345             const indexedOctree<treeDataEdge>& edgeTree() const;
 346
 347             //- Demand driven construction of octree for boundary edges by type
 348             const PtrList<indexedOctree<treeDataEdge> >&
 349             edgeTreesByType() const;
 350
 351
 352         // Write
 353
 354             //- Write all components of the extendedFeatureEdgeMesh as obj files
 355             void writeObj(const fileName& prefix) const;
 356
 357             //- Give precedence to the regIOobject write
 358             using regIOobject::write;
 359
 360             //- WriteData function required for regIOobject write operation
 361             virtual bool writeData(Ostream&) const;
 362 };
 363
 364
 365 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 366
 367 } // End namespace Foam
 368
 369 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 370
 371 #include "extendedFeatureEdgeMeshI.H"
 372
 373 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 374
 375 #endif
 376
 377 // ************************************************************************* //