src/OpenFOAM/meshes/meshShapes/triFace/triFace.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::triFace
  26
  27 Description
  28     A triangular face using a FixedList of labels corresponding to mesh
  29     vertices.
  30
  31 SeeAlso
  32     Foam::face, Foam::triangle
  33
  34 SourceFiles
  35     triFaceI.H
  36     triFaceTemplates.C
  37
  38 \*---------------------------------------------------------------------------*/
  39
  40 #ifndef triFace_H
  41 #define triFace_H
  42
  43 #include "FixedList.H"
  44 #include "edgeList.H"
  45 #include "pointHit.H"
  46 #include "intersection.H"
  47 #include "pointField.H"
  48 #include "triPointRef.H"
  49
  50 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  51
  52 namespace Foam
  53 {
  54
  55 // Forward declaration of friend functions and operators
  56
  57 class face;
  58 class triFace;
  59
  60 inline bool operator==(const triFace&, const triFace&);
  61 inline bool operator!=(const triFace&, const triFace&);
  62
  63
  64 /*---------------------------------------------------------------------------*\
  65                           Class triFace Declaration
  66 \*---------------------------------------------------------------------------*/
  67
  68 class triFace
  69 :
  70     public FixedList<label, 3>
  71 {
  72
  73 public:
  74
  75     // Constructors
  76
  77         //- Construct null
  78         inline triFace();
  79
  80         //- Construct from three point labels
  81         inline triFace
  82         (
  83             const label a,
  84             const label b,
  85             const label c
  86         );
  87
  88         //- Construct from a list of labels
  89         explicit inline triFace(const labelUList&);
  90
  91         //- Construct from Istream
  92         inline triFace(Istream&);
  93
  94
  95     // Member Functions
  96
  97         //- Collapse face by removing duplicate point labels
  98         //  return the collapsed size, set collapsed point labels to -1
  99         inline label collapse();
 100
 101         //- Flip the face in-place.
 102         //  The starting points of the original and flipped face are identical.
 103         inline void flip();
 104
 105         //- Return the points corresponding to this face
 106         inline pointField points(const pointField&) const;
 107
 108         //- Return triangle as a face
 109         inline face triFaceFace() const;
 110
 111         //- Return the triangle
 112         inline triPointRef tri(const pointField&) const;
 113
 114         //- Return centre (centroid)
 115         inline point centre(const pointField&) const;
 116
 117         //- Calculate average value at centroid of face
 118         template<class Type>
 119         Type average(const pointField&, const Field<Type>&) const;
 120
 121         //- Magnitude of face area
 122         inline scalar mag(const pointField&) const;
 123
 124         //- Vector normal; magnitude is equal to area of face
 125         inline vector normal(const pointField&) const;
 126
 127         //- Number of triangles after splitting
 128         inline label nTriangles() const;
 129
 130         //- Return face with reverse direction
 131         //  The starting points of the original and reverse face are identical.
 132         inline triFace reverseFace() const;
 133
 134         //- Return swept-volume
 135         inline scalar sweptVol
 136         (
 137             const pointField& oldPoints,
 138             const pointField& newPoints
 139         ) const;
 140
 141         //- Return the inertia tensor, with optional reference
 142         //  point and density specification
 143         inline tensor inertia
 144         (
 145             const pointField&,
 146             const point& refPt = vector::zero,
 147             scalar density = 1.0
 148         ) const;
 149
 150         //- Return point intersection with a ray starting at p,
 151         //  with direction q.
 152         inline pointHit ray
 153         (
 154             const point& p,
 155             const vector& q,
 156             const pointField& points,
 157             const intersection::algorithm = intersection::FULL_RAY,
 158             const intersection::direction dir = intersection::VECTOR
 159         ) const;
 160
 161         //- Fast intersection with a ray.
 162         inline pointHit intersection
 163         (
 164             const point& p,
 165             const vector& q,
 166             const pointField& points,
 167             const intersection::algorithm alg,
 168             const scalar tol = 0.0
 169         ) const;
 170
 171         //- Return nearest point to face
 172         inline pointHit nearestPoint
 173         (
 174             const point& p,
 175             const pointField& points
 176         ) const;
 177
 178
 179         //- Return nearest point to face and classify it:
 180         //  + near point (nearType=POINT, nearLabel=0, 1, 2)
 181         //  + near edge (nearType=EDGE, nearLabel=0, 1, 2)
 182         //    Note: edges are counted from starting vertex so
 183         //    e.g. edge n is from f[n] to f[0], where the face has n + 1
 184         //    points
 185         inline pointHit nearestPointClassify
 186         (
 187             const point& p,
 188             const pointField& points,
 189             label& nearType,
 190             label& nearLabel
 191         ) const;
 192
 193         //- Return number of edges
 194         inline label nEdges() const;
 195
 196         //- Return edges in face point ordering,
 197         //  i.e. edges()[0] is edge between [0] and [1]
 198         inline edgeList edges() const;
 199
 200         //- Return n-th face edge
 201         inline edge faceEdge(const label n) const;
 202
 203         //- Return the edge direction on the face
 204         //  Returns:
 205         //  - +1: forward (counter-clockwise) on the face
 206         //  - -1: reverse (clockwise) on the face
 207         //  -  0: edge not found on the face
 208         inline int edgeDirection(const edge&) const;
 209
 210         //- compare triFaces
 211         //  Returns:
 212         //  -  0: different
 213         //  - +1: identical
 214         //  - -1: same face, but different orientation
 215         static inline int compare(const triFace&, const triFace&);
 216
 217     // Friend Operators
 218
 219         inline friend bool operator==(const triFace&, const triFace&);
 220         inline friend bool operator!=(const triFace&, const triFace&);
 221 };
 222
 223
 224 //- Hash specialization for hashing triFace - a commutative hash value.
 225 //  Hash incrementally.
 226 template<>
 227 inline unsigned Hash<triFace>::operator()(const triFace& t, unsigned seed) const
 228 {
 229     // Fortunately we don't need this very often
 230     const uLabel t0(t[0]);
 231     const uLabel t1(t[1]);
 232     const uLabel t2(t[2]);
 233
 234     const uLabel val = (t0*t1*t2 + t0+t1+t2);
 235
 236     return Hash<uLabel>()(val, seed);
 237 }
 238
 239
 240 //- Hash specialization for hashing triFace - a commutative hash value.
 241 template<>
 242 inline unsigned Hash<triFace>::operator()(const triFace& t) const
 243 {
 244     return Hash<triFace>::operator()(t, 0);
 245 }
 246
 247
 248 template<>
 249 inline bool contiguous<triFace>()  {return true;}
 250
 251
 252 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 253
 254 } // End namespace Foam
 255
 256 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 257
 258 #include "triFaceI.H"
 259
 260 #ifdef NoRepository
 261 #   include "triFaceTemplates.C"
 262 #endif
 263
 264 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 265
 266 #endif
 267
 268 // ************************************************************************* //