src/OpenFOAM/meshes/meshShapes/triFace/triFaceI.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 2004-2011 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
  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 \*---------------------------------------------------------------------------*/
  25
  26 #include "IOstreams.H"
  27 #include "face.H"
  28 #include "triPointRef.H"
  29 #include "Swap.H"
  30
  31 // * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * //
  32
  33 inline int Foam::triFace::compare(const triFace& a, const triFace& b)
  34 {
  35     if
  36     (
  37         (a[0] == b[0] && a[1] == b[1] && a[2] == b[2])
  38      || (a[0] == b[1] && a[1] == b[2] && a[2] == b[0])
  39      || (a[0] == b[2] && a[1] == b[0] && a[2] == b[1])
  40     )
  41     {
  42         // identical
  43         return 1;
  44     }
  45     else if
  46     (
  47         (a[0] == b[2] && a[1] == b[1] && a[2] == b[0])
  48      || (a[0] == b[1] && a[1] == b[0] && a[2] == b[2])
  49      || (a[0] == b[0] && a[1] == b[2] && a[2] == b[1])
  50     )
  51     {
  52         // same face, but reversed orientation
  53         return -1;
  54     }
  55     else
  56     {
  57         return 0;
  58     }
  59 }
  60
  61
  62 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  63
  64 inline Foam::triFace::triFace()
  65 {}
  66
  67
  68 inline Foam::triFace::triFace
  69 (
  70     const label a,
  71     const label b,
  72     const label c
  73 )
  74 {
  75     operator[](0) = a;
  76     operator[](1) = b;
  77     operator[](2) = c;
  78 }
  79
  80
  81 inline Foam::triFace::triFace(const labelUList& lst)
  82 :
  83     FixedList<label, 3>(lst)
  84 {}
  85
  86
  87 inline Foam::triFace::triFace(Istream& is)
  88 :
  89     FixedList<label, 3>(is)
  90 {}
  91
  92
  93 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
  94
  95 inline Foam::label Foam::triFace::collapse()
  96 {
  97     // we cannot resize a FixedList, so mark duplicates with '-1'
  98     // (the lower vertex is retained)
  99     // catch any '-1' (eg, if called twice)
 100
 101     label n = 3;
 102     if (operator[](0) == operator[](1) || operator[](1) == -1)
 103     {
 104         operator[](1) = -1;
 105         n--;
 106     }
 107     else if (operator[](1) == operator[](2) || operator[](2) == -1)
 108     {
 109         operator[](2) = -1;
 110         n--;
 111     }
 112     if (operator[](0) == operator[](2))
 113     {
 114         operator[](2) = -1;
 115         n--;
 116     }
 117
 118     return n;
 119 }
 120
 121
 122 inline void Foam::triFace::flip()
 123 {
 124     Swap(operator[](1), operator[](2));
 125 }
 126
 127
 128 inline Foam::pointField Foam::triFace::points(const pointField& points) const
 129 {
 130     pointField p(3);
 131
 132     p[0] = points[operator[](0)];
 133     p[1] = points[operator[](1)];
 134     p[2] = points[operator[](2)];
 135
 136     return p;
 137 }
 138
 139
 140 inline Foam::face Foam::triFace::triFaceFace() const
 141 {
 142     Foam::face f(3);
 143
 144     f[0] = operator[](0);
 145     f[1] = operator[](1);
 146     f[2] = operator[](2);
 147
 148     return f;
 149 }
 150
 151
 152 inline Foam::triPointRef Foam::triFace::tri(const pointField& points) const
 153 {
 154     return triPointRef
 155     (
 156         points[operator[](0)],
 157         points[operator[](1)],
 158         points[operator[](2)]
 159     );
 160 }
 161
 162
 163 inline Foam::point Foam::triFace::centre(const pointField& points) const
 164 {
 165     return (1.0/3.0)*
 166     (
 167         points[operator[](0)]
 168       + points[operator[](1)]
 169       + points[operator[](2)]
 170     );
 171 }
 172
 173
 174 inline Foam::scalar Foam::triFace::mag(const pointField& points) const
 175 {
 176     return ::Foam::mag(normal(points));
 177 }
 178
 179
 180 // could also delegate to triPointRef(...).normal()
 181 inline Foam::vector Foam::triFace::normal(const pointField& points) const
 182 {
 183     return 0.5*
 184     (
 185         (points[operator[](1)] - points[operator[](0)])
 186        ^(points[operator[](2)] - points[operator[](0)])
 187     );
 188 }
 189
 190
 191 inline Foam::label Foam::triFace::nTriangles() const
 192 {
 193     return 1;
 194 }
 195
 196
 197 inline Foam::triFace Foam::triFace::reverseFace() const
 198 {
 199     // The starting points of the original and reverse face are identical.
 200     return triFace(operator[](0), operator[](2), operator[](1));
 201 }
 202
 203
 204 inline Foam::scalar Foam::triFace::sweptVol
 205 (
 206     const pointField& opts,
 207     const pointField& npts
 208 ) const
 209 {
 210     return (1.0/6.0)*
 211     (
 212         (
 213             (npts[operator[](0)] - opts[operator[](0)])
 214           & (
 215                 (opts[operator[](1)] - opts[operator[](0)])
 216               ^ (opts[operator[](2)] - opts[operator[](0)])
 217             )
 218         )
 219       + (
 220             (npts[operator[](1)] - opts[operator[](1)])
 221           & (
 222                 (opts[operator[](2)] - opts[operator[](1)])
 223               ^ (npts[operator[](0)] - opts[operator[](1)])
 224             )
 225         )
 226       + (
 227             (opts[operator[](2)] - npts[operator[](2)])
 228           & (
 229                 (npts[operator[](1)] - npts[operator[](2)])
 230               ^ (npts[operator[](0)] - npts[operator[](2)])
 231             )
 232         )
 233     );
 234 }
 235
 236
 237 Foam::tensor Foam::triFace::inertia
 238 (
 239     const pointField& points,
 240     const point& refPt,
 241     scalar density
 242 ) const
 243 {
 244     // a triangle, do a direct calculation
 245     return this->tri(points).inertia(refPt, density);
 246 }
 247
 248
 249 inline Foam::pointHit Foam::triFace::ray
 250 (
 251     const point& p,
 252     const vector& q,
 253     const pointField& points,
 254     const intersection::algorithm alg,
 255     const intersection::direction dir
 256 ) const
 257 {
 258     return this->tri(points).ray(p, q, alg, dir);
 259 }
 260
 261
 262
 263 inline Foam::pointHit Foam::triFace::intersection
 264 (
 265     const point& p,
 266     const vector& q,
 267     const pointField& points,
 268     const intersection::algorithm alg,
 269     const scalar tol
 270 ) const
 271 {
 272     return this->tri(points).intersection(p, q, alg, tol);
 273 }
 274
 275
 276 inline Foam::pointHit Foam::triFace::nearestPoint
 277 (
 278     const point& p,
 279     const pointField& points
 280 ) const
 281 {
 282     return this->tri(points).nearestPoint(p);
 283 }
 284
 285
 286 inline Foam::pointHit Foam::triFace::nearestPointClassify
 287 (
 288     const point& p,
 289     const pointField& points,
 290     label& nearType,
 291     label& nearLabel
 292 ) const
 293 {
 294     return this->tri(points).nearestPointClassify(p, nearType, nearLabel);
 295 }
 296
 297
 298 inline Foam::label Foam::triFace::nEdges() const
 299 {
 300     return 3;
 301 }
 302
 303
 304 inline Foam::edgeList Foam::triFace::edges() const
 305 {
 306     edgeList e(3);
 307
 308     e[0].start() = operator[](0);
 309     e[0].end()   = operator[](1);
 310
 311     e[1].start() = operator[](1);
 312     e[1].end()   = operator[](2);
 313
 314     e[2].start() = operator[](2);
 315     e[2].end()   = operator[](0);
 316
 317     return e;
 318 }
 319
 320
 321 inline Foam::edge Foam::triFace::faceEdge(const label n) const
 322 {
 323     return edge(operator[](n), operator[](fcIndex(n)));
 324 }
 325
 326
 327 // return
 328 //  - +1: forward (counter-clockwise) on the face
 329 //  - -1: reverse (clockwise) on the face
 330 //  -  0: edge not found on the face
 331 inline int Foam::triFace::edgeDirection(const edge& e) const
 332 {
 333     if
 334     (
 335         (operator[](0) == e.start() && operator[](1) == e.end())
 336      || (operator[](1) == e.start() && operator[](2) == e.end())
 337      || (operator[](2) == e.start() && operator[](0) == e.end())
 338     )
 339     {
 340         return 1;
 341     }
 342     else if
 343     (
 344         (operator[](0) == e.end() && operator[](1) == e.start())
 345      || (operator[](1) == e.end() && operator[](2) == e.start())
 346      || (operator[](2) == e.end() && operator[](0) == e.start())
 347     )
 348     {
 349         return -1;
 350     }
 351     else
 352     {
 353         return 0;
 354     }
 355 }
 356
 357
 358 // * * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * //
 359
 360 inline bool Foam::operator==(const triFace& a, const triFace& b)
 361 {
 362     return triFace::compare(a,b) != 0;
 363 }
 364
 365
 366 inline bool Foam::operator!=(const triFace& a, const triFace& b)
 367 {
 368     return triFace::compare(a,b) == 0;
 369 }
 370
 371
 372 // ************************************************************************* //