src/OpenFOAM/meshes/primitiveMesh/PrimitivePatch/PrimitivePatch.C

   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 \*---------------------------------------------------------------------------*/
  26
  27 #include "Map.H"
  28
  29 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  30
  31 // Construct from components
  32 template
  33 <
  34     class Face,
  35     template<class> class FaceList,
  36     class PointField,
  37     class PointType
  38 >
  39
  40 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
  41 PrimitivePatch
  42 (
  43     const FaceList<Face>& faces,
  44     const Field<PointType>& points
  45 )
  46 :
  47     FaceList<Face>(faces),
  48     points_(points),
  49     edgesPtr_(NULL),
  50     nInternalEdges_(-1),
  51     boundaryPointsPtr_(NULL),
  52     faceFacesPtr_(NULL),
  53     edgeFacesPtr_(NULL),
  54     faceEdgesPtr_(NULL),
  55     pointEdgesPtr_(NULL),
  56     pointFacesPtr_(NULL),
  57     localFacesPtr_(NULL),
  58     meshPointsPtr_(NULL),
  59     meshPointMapPtr_(NULL),
  60     edgeLoopsPtr_(NULL),
  61     localPointsPtr_(NULL),
  62     localPointOrderPtr_(NULL),
  63     faceNormalsPtr_(NULL),
  64     pointNormalsPtr_(NULL)
  65 {}
  66
  67
  68 // Construct from components
  69 template
  70 <
  71     class Face,
  72     template<class> class FaceList,
  73     class PointField,
  74     class PointType
  75 >
  76
  77 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
  78 PrimitivePatch
  79 (
  80     FaceList<Face>& faces,
  81     Field<PointType>& points,
  82     const bool reUse
  83 )
  84 :
  85     FaceList<Face>(faces, reUse),
  86     points_(points, reUse),
  87     edgesPtr_(NULL),
  88     nInternalEdges_(-1),
  89     boundaryPointsPtr_(NULL),
  90     faceFacesPtr_(NULL),
  91     edgeFacesPtr_(NULL),
  92     faceEdgesPtr_(NULL),
  93     pointEdgesPtr_(NULL),
  94     pointFacesPtr_(NULL),
  95     localFacesPtr_(NULL),
  96     meshPointsPtr_(NULL),
  97     meshPointMapPtr_(NULL),
  98     edgeLoopsPtr_(NULL),
  99     localPointsPtr_(NULL),
 100     localPointOrderPtr_(NULL),
 101     faceNormalsPtr_(NULL),
 102     pointNormalsPtr_(NULL)
 103 {}
 104
 105
 106 // Construct as copy
 107 template
 108 <
 109     class Face,
 110     template<class> class FaceList,
 111     class PointField,
 112     class PointType
 113 >
 114
 115 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 116 PrimitivePatch
 117 (
 118     const PrimitivePatch<Face, FaceList, PointField, PointType>& pp
 119 )
 120 :
 121     PrimitivePatchName(),
 122     FaceList<Face>(pp),
 123     points_(pp.points_),
 124     edgesPtr_(NULL),
 125     nInternalEdges_(-1),
 126     boundaryPointsPtr_(NULL),
 127     faceFacesPtr_(NULL),
 128     edgeFacesPtr_(NULL),
 129     faceEdgesPtr_(NULL),
 130     pointEdgesPtr_(NULL),
 131     pointFacesPtr_(NULL),
 132     localFacesPtr_(NULL),
 133     meshPointsPtr_(NULL),
 134     meshPointMapPtr_(NULL),
 135     edgeLoopsPtr_(NULL),
 136     localPointsPtr_(NULL),
 137     localPointOrderPtr_(NULL),
 138     faceNormalsPtr_(NULL),
 139     pointNormalsPtr_(NULL)
 140 {}
 141
 142
 143 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 144
 145 template
 146 <
 147     class Face,
 148     template<class> class FaceList,
 149     class PointField,
 150     class PointType
 151 >
 152
 153 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::~PrimitivePatch()
 154 {
 155     clearOut();
 156 }
 157
 158
 159 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 160
 161 // Correct patch after moving points
 162 template
 163 <
 164     class Face,
 165     template<class> class FaceList,
 166     class PointField,
 167     class PointType
 168 >
 169
 170 void
 171 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 172 movePoints
 173 (
 174     const Field<PointType>&
 175 )
 176 {
 177     if (debug)
 178     {
 179         Pout<< "PrimitivePatch<Face, FaceList, PointField, PointType>::"
 180             << "movePoints() : "
 181             << "recalculating PrimitivePatch geometry following mesh motion"
 182             << endl;
 183     }
 184
 185     clearGeom();
 186 }
 187
 188
 189 template
 190 <
 191     class Face,
 192     template<class> class FaceList,
 193     class PointField,
 194     class PointType
 195 >
 196
 197 const Foam::edgeList&
 198 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 199 edges() const
 200 {
 201     if (!edgesPtr_)
 202     {
 203         calcAddressing();
 204     }
 205
 206     return *edgesPtr_;
 207 }
 208
 209
 210 template
 211 <
 212     class Face,
 213     template<class> class FaceList,
 214     class PointField,
 215     class PointType
 216 >
 217
 218 Foam::label
 219 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 220 nInternalEdges() const
 221 {
 222     if (!edgesPtr_)
 223     {
 224         calcAddressing();
 225     }
 226
 227     return nInternalEdges_;
 228 }
 229
 230
 231 template
 232 <
 233     class Face,
 234     template<class> class FaceList,
 235     class PointField,
 236     class PointType
 237 >
 238
 239 const Foam::labelList&
 240 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 241 boundaryPoints() const
 242 {
 243     if (!boundaryPointsPtr_)
 244     {
 245         calcBdryPoints();
 246     }
 247
 248     return *boundaryPointsPtr_;
 249 }
 250
 251
 252 template
 253 <
 254     class Face,
 255     template<class> class FaceList,
 256     class PointField,
 257     class PointType
 258 >
 259
 260 const Foam::labelListList&
 261 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 262 faceFaces() const
 263 {
 264     if (!faceFacesPtr_)
 265     {
 266         calcAddressing();
 267     }
 268
 269     return *faceFacesPtr_;
 270 }
 271
 272
 273 template
 274 <
 275     class Face,
 276     template<class> class FaceList,
 277     class PointField,
 278     class PointType
 279 >
 280
 281 const Foam::labelListList&
 282 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 283 edgeFaces() const
 284 {
 285     if (!edgeFacesPtr_)
 286     {
 287         calcAddressing();
 288     }
 289
 290     return *edgeFacesPtr_;
 291 }
 292
 293
 294 template
 295 <
 296     class Face,
 297     template<class> class FaceList,
 298     class PointField,
 299     class PointType
 300 >
 301
 302 const Foam::labelListList&
 303 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 304 faceEdges() const
 305 {
 306     if (!faceEdgesPtr_)
 307     {
 308         calcAddressing();
 309     }
 310
 311     return *faceEdgesPtr_;
 312 }
 313
 314
 315 template
 316 <
 317     class Face,
 318     template<class> class FaceList,
 319     class PointField,
 320     class PointType
 321 >
 322
 323 const Foam::labelListList&
 324 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 325 pointEdges() const
 326 {
 327     if (!pointEdgesPtr_)
 328     {
 329         calcPointEdges();
 330     }
 331
 332     return *pointEdgesPtr_;
 333 }
 334
 335
 336 template
 337 <
 338     class Face,
 339     template<class> class FaceList,
 340     class PointField,
 341     class PointType
 342 >
 343
 344 const Foam::labelListList&
 345 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 346 pointFaces() const
 347 {
 348     if (!pointFacesPtr_)
 349     {
 350         calcPointFaces();
 351     }
 352
 353     return *pointFacesPtr_;
 354 }
 355
 356
 357 template
 358 <
 359     class Face,
 360     template<class> class FaceList,
 361     class PointField,
 362     class PointType
 363 >
 364
 365 const Foam::List<Face>&
 366 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 367 localFaces() const
 368 {
 369     if (!localFacesPtr_)
 370     {
 371         calcMeshData();
 372     }
 373
 374     return *localFacesPtr_;
 375 }
 376
 377
 378 template
 379 <
 380     class Face,
 381     template<class> class FaceList,
 382     class PointField,
 383     class PointType
 384 >
 385
 386 const Foam::labelList&
 387 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 388 meshPoints() const
 389 {
 390     if (!meshPointsPtr_)
 391     {
 392         calcMeshData();
 393     }
 394
 395     return *meshPointsPtr_;
 396 }
 397
 398
 399 template
 400 <
 401     class Face,
 402     template<class> class FaceList,
 403     class PointField,
 404     class PointType
 405 >
 406
 407 const Foam::Map<Foam::label>&
 408 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 409 meshPointMap() const
 410 {
 411     if (!meshPointMapPtr_)
 412     {
 413         calcMeshPointMap();
 414     }
 415
 416     return *meshPointMapPtr_;
 417 }
 418
 419
 420 template
 421 <
 422     class Face,
 423     template<class> class FaceList,
 424     class PointField,
 425     class PointType
 426 >
 427
 428 const Foam::Field<PointType>&
 429 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 430 localPoints() const
 431 {
 432     if (!localPointsPtr_)
 433     {
 434         calcLocalPoints();
 435     }
 436
 437     return *localPointsPtr_;
 438 }
 439
 440
 441 template
 442 <
 443     class Face,
 444     template<class> class FaceList,
 445     class PointField,
 446     class PointType
 447 >
 448
 449 const Foam::labelList&
 450 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 451 localPointOrder() const
 452 {
 453     if (!localPointOrderPtr_)
 454     {
 455         calcLocalPointOrder();
 456     }
 457
 458     return *localPointOrderPtr_;
 459 }
 460
 461
 462 template
 463 <
 464     class Face,
 465     template<class> class FaceList,
 466     class PointField,
 467     class PointType
 468 >
 469
 470 Foam::label
 471 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 472 whichPoint
 473 (
 474     const label gp
 475 ) const
 476 {
 477     Map<label>::const_iterator fnd = meshPointMap().find(gp);
 478
 479     if (fnd != meshPointMap().end())
 480     {
 481         return fnd();
 482     }
 483     else
 484     {
 485         // Not found
 486         return -1;
 487     }
 488 }
 489
 490
 491 template
 492 <
 493     class Face,
 494     template<class> class FaceList,
 495     class PointField,
 496     class PointType
 497 >
 498
 499 const Foam::Field<PointType>&
 500 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 501 faceNormals() const
 502 {
 503     if (!faceNormalsPtr_)
 504     {
 505         calcFaceNormals();
 506     }
 507
 508     return *faceNormalsPtr_;
 509 }
 510
 511
 512 template
 513 <
 514     class Face,
 515     template<class> class FaceList,
 516     class PointField,
 517     class PointType
 518 >
 519
 520 const Foam::Field<PointType>&
 521 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 522 pointNormals() const
 523 {
 524     if (!pointNormalsPtr_)
 525     {
 526         calcPointNormals();
 527     }
 528
 529     return *pointNormalsPtr_;
 530 }
 531
 532
 533 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 534
 535 template
 536 <
 537     class Face,
 538     template<class> class FaceList,
 539     class PointField,
 540     class PointType
 541 >
 542
 543 void
 544 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 545 operator=
 546 (
 547     const PrimitivePatch<Face, FaceList, PointField, PointType>& pp
 548 )
 549 {
 550     clearOut();
 551
 552     FaceList<Face>::operator=(pp);
 553 }
 554
 555 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 556
 557 #include "PrimitivePatchAddressing.C"
 558 #include "PrimitivePatchEdgeLoops.C"
 559 #include "PrimitivePatchClear.C"
 560 #include "PrimitivePatchBdryPoints.C"
 561 #include "PrimitivePatchLocalPointOrder.C"
 562 #include "PrimitivePatchMeshData.C"
 563 #include "PrimitivePatchMeshEdges.C"
 564 #include "PrimitivePatchPointAddressing.C"
 565 #include "PrimitivePatchProjectPoints.C"
 566 #include "PrimitivePatchCheck.C"
 567
 568 // ************************************************************************* //