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