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) 1991-2009 OpenCFD Ltd.
   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 the
  13     Free Software Foundation; either version 2 of the License, or (at your
  14     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, write to the Free Software Foundation,
  23     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  24
  25 Class
  26     Foam::triFace
  27
  28 Description
  29     A triangle face primitive using a FixedList.
  30
  31 SourceFiles
  32     triFaceI.H
  33
  34 \*---------------------------------------------------------------------------*/
  35
  36 #ifndef triFace_H
  37 #define triFace_H
  38
  39 #include "FixedList.H"
  40 #include "edgeList.H"
  41 #include "pointHit.H"
  42 #include "intersection.H"
  43 #include "pointField.H"
  44 #include "triPointRef.H"
  45
  46 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  47
  48 namespace Foam
  49 {
  50
  51 class face;
  52
  53 // Forward declaration of friend functions and operators
  54
  55 class triFace;
  56 inline bool operator==(const triFace&, const triFace&);
  57 inline bool operator!=(const triFace&, const triFace&);
  58
  59
  60 /*---------------------------------------------------------------------------*\
  61                           class triFace Declaration
  62 \*---------------------------------------------------------------------------*/
  63
  64 class triFace
  65 :
  66     public FixedList<label, 3>
  67 {
  68
  69 public:
  70
  71     // Constructors
  72
  73         //- Construct null
  74         inline triFace();
  75
  76         //- Construct from three point labels
  77         inline triFace
  78         (
  79             const label a,
  80             const label b,
  81             const label c
  82         );
  83
  84         //- Construct from a UList<label>
  85         explicit inline triFace(const UList<label>&);
  86
  87         //- Construct from Istream
  88         inline triFace(Istream&);
  89
  90
  91     // Member Functions
  92
  93         //- Collapse face by removing duplicate point labels
  94         //  return the collapsed size, set collapsed point labels to -1
  95         inline label collapse();
  96
  97         //- Return the edge direction on the face
  98         //  - +1: forward (counter-clockwise) on the face
  99         //  - -1: reverse (clockwise) on the face
 100         //  -  0: edge not found on the face
 101         inline int edgeDirection(const edge&) const;
 102
 103
 104         // Properties
 105
 106             //- Return the points corresponding to this face
 107             inline pointField points(const pointField& points) const;
 108
 109             //- Return triangle as a face
 110             inline face triFaceFace() const;
 111
 112             //- Return number of edges
 113             inline label nEdges() const;
 114
 115             //- Return edges
 116             inline edgeList edges() const;
 117
 118             //- Return centre (centroid)
 119             inline point centre(const pointField&) const;
 120
 121             //- Return scalar magnitude
 122             inline scalar mag(const pointField&) const;
 123
 124             //- Return vector normal
 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             inline triFace reverseFace() const;
 132
 133             //- Return swept-volume
 134             inline scalar sweptVol
 135             (
 136                 const pointField& oldPoints,
 137                 const pointField& newPoints
 138             ) const;
 139
 140             //- Return point intersection with a ray starting at p, with
 141             //  direction n.
 142             inline pointHit ray
 143             (
 144                 const point& p,
 145                 const vector& q,
 146                 const pointField& points,
 147                 const intersection::algorithm = intersection::FULL_RAY,
 148                 const intersection::direction dir = intersection::VECTOR
 149             ) const;
 150
 151             //- Return the triangle
 152             inline triPointRef tri(const pointField&) const;
 153
 154         //- compare triFaces
 155         //  -  0: different
 156         //  - +1: identical
 157         //  - -1: same face, but different orientation
 158         static inline int compare(const triFace&, const triFace&);
 159
 160     // Friend Operators
 161
 162         friend bool operator==(const triFace&, const triFace&);
 163         friend bool operator!=(const triFace&, const triFace&);
 164 };
 165
 166
 167 //- Hash specialization for hashing triFace - a commutative hash value.
 168 //  Hash incrementally.
 169 template<>
 170 inline unsigned Hash<triFace>::operator()(const triFace& t, unsigned seed) const
 171 {
 172     // Fortunately we don't need this very often
 173     const uLabel t0(t[0]);
 174     const uLabel t1(t[1]);
 175     const uLabel t2(t[2]);
 176
 177     const uLabel val = (t0*t1*t2 + t0+t1+t2);
 178
 179     return Hash<uLabel>()(val, seed);
 180 }
 181
 182
 183 //- Hash specialization for hashing triFace - a commutative hash value.
 184 //  Hash incrementally.
 185 template<>
 186 inline unsigned Hash<triFace>::operator()(const triFace& t) const
 187 {
 188     return Hash<triFace>::operator()(t, 0);
 189 }
 190
 191
 192 template<>
 193 inline bool contiguous<triFace>()  {return true;}
 194
 195
 196 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 197
 198 } // End namespace Foam
 199
 200 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 201
 202 #include "triFaceI.H"
 203
 204 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 205
 206 #endif
 207
 208 // ************************************************************************* //