src/OpenFOAM/meshes/meshShapes/cellMatcher/prismMatcher.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 1991-2008 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 "prismMatcher.H"
  28 #include "primitiveMesh.H"
  29
  30 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  31
  32 const Foam::label Foam::prismMatcher::vertPerCell = 6;
  33 const Foam::label Foam::prismMatcher::facePerCell = 5;
  34 const Foam::label Foam::prismMatcher::maxVertPerFace = 4;
  35
  36
  37 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  38
  39 // Construct from components
  40 Foam::prismMatcher::prismMatcher()
  41 :
  42     cellMatcher
  43     (
  44         vertPerCell,
  45         facePerCell,
  46         maxVertPerFace,
  47         "prism"
  48     )
  49 {}
  50
  51 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
  52
  53 Foam::prismMatcher::~prismMatcher()
  54 {}
  55
  56 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
  57
  58 bool Foam::prismMatcher::matchShape
  59 (
  60     const bool checkOnly,
  61     const faceList& faces,
  62     const labelList& owner,
  63     const label cellI,
  64     const labelList& myFaces
  65 )
  66 {
  67     if (!faceSizeMatch(faces, myFaces))
  68     {
  69         return false;
  70     }
  71
  72     // Calculate localFaces_ and mapping pointMap_, faceMap_
  73     label numVert = calcLocalFaces(faces, myFaces);
  74
  75     if (numVert != vertPerCell)
  76     {
  77         return false;
  78     }
  79
  80     // Set up 'edge' to face mapping.
  81     calcEdgeAddressing(numVert);
  82
  83     // Set up point on face to index-in-face mapping
  84     calcPointFaceIndex();
  85
  86     // Storage for maps -vertex to mesh and -face to mesh
  87     vertLabels_.setSize(vertPerCell);
  88     faceLabels_.setSize(facePerCell);
  89
  90     //
  91     // Try first triangular face.
  92     // Only need to try one orientation of this face since prism is
  93     // rotation symmetric
  94     //
  95
  96     label face0I = -1;
  97     forAll(faceSize_, faceI)
  98     {
  99         if (faceSize_[faceI] == 3)
 100         {
 101             face0I = faceI;
 102             break;
 103         }
 104     }
 105
 106     const face& face0 = localFaces_[face0I];
 107     label face0vert0 = 0;
 108
 109     //
 110     // Try to follow prespecified path on faces of cell,
 111     // starting at face0vert0
 112     //
 113
 114     vertLabels_[0] = pointMap_[face0[face0vert0]];
 115     faceLabels_[0] = faceMap_[face0I];
 116     //Info<< endl << "Prism vertex 0: vertex " <<  face0[face0vert0]
 117     //    << " at position " << face0vert0 << " in face " << face0
 118     //    << endl;
 119
 120     // Walk face 0 from vertex 0 to 1
 121     label face0vert1 =
 122         nextVert
 123         (
 124             face0vert0,
 125             faceSize_[face0I],
 126             !(owner[faceMap_[face0I]] == cellI)
 127         );
 128     vertLabels_[1] = pointMap_[face0[face0vert1]];
 129     //Info<< "Prism vertex 1: vertex " <<  face0[face0vert1]
 130     //    << " at position " << face0vert1 << " in face " << face0
 131     //    << endl;
 132
 133     // Jump edge from face0 to face4
 134     label face4I =
 135         otherFace
 136         (
 137             numVert,
 138             face0[face0vert0],
 139             face0[face0vert1],
 140             face0I
 141         );
 142     const face& face4 = localFaces_[face4I];
 143     //Info<< "Stepped to prism face 4 " << face4
 144     //    << " across edge " << face0[face0vert0] << " "
 145     //    << face0[face0vert1]
 146     //    << endl;
 147
 148     if (faceSize_[face4I] != 4)
 149     {
 150         //Info<< "Cannot be Prism Face 4 since size="
 151         //    << faceSize_[face4I] << endl;
 152         return false;
 153     }
 154     faceLabels_[4] = faceMap_[face4I];
 155
 156     label face4vert1 = pointFaceIndex_[face0[face0vert1]][face4I];
 157
 158     //Info<< "Prism vertex 1 also: vertex " <<  face4[face4vert1]
 159     //    << " at position " << face4vert1 << " in face " << face4
 160     //    << endl;
 161
 162     // Walk face 4 from vertex 1 to 4
 163     label face4vert4 =
 164         nextVert
 165         (
 166             face4vert1,
 167             faceSize_[face4I],
 168             (owner[faceMap_[face4I]] == cellI)
 169         );
 170     vertLabels_[4] = pointMap_[face4[face4vert4]];
 171     //Info<< "Prism vertex 4: vertex " <<  face4[face4vert4]
 172     //    << " at position " << face4vert4 << " in face " << face4
 173     //    << endl;
 174
 175     // Walk face 4 from vertex 1 to 3
 176     label face4vert3 =
 177         nextVert
 178         (
 179             face4vert4,
 180             faceSize_[face4I],
 181             (owner[faceMap_[face4I]] == cellI)
 182         );
 183     vertLabels_[3] = pointMap_[face4[face4vert3]];
 184     //Info<< "Prism vertex 3: vertex " <<  face4[face4vert3]
 185     //    << " at position " << face4vert3 << " in face " << face4
 186     //    << endl;
 187
 188     // Jump edge from face4 to face1
 189     label face1I =
 190         otherFace
 191         (
 192             numVert,
 193             face4[face4vert3],
 194             face4[face4vert4],
 195             face4I
 196         );
 197     //const face& face1 = localFaces_[face1I];
 198     //Info<< "Stepped to prism face 1 " << face1
 199     //    << " across edge " << face4[face4vert3] << " "
 200     //    << face4[face4vert4]
 201     //    << endl;
 202
 203     if (faceSize_[face1I] != 3)
 204     {
 205         //Info<< "Cannot be Prism Face 1 since size="
 206         //    << faceSize_[face1I] << endl;
 207         return false;
 208     }
 209
 210     // Is prism for sure now
 211     if (checkOnly)
 212     {
 213         return true;
 214     }
 215
 216     faceLabels_[1] = faceMap_[face1I];
 217
 218
 219     //
 220     // Walk to other faces and assign mapping.
 221     //
 222
 223
 224     // Walk face 0 from vertex 1 to 2
 225     label face0vert2 =
 226         nextVert
 227         (
 228             face0vert1,
 229             faceSize_[face0I],
 230             !(owner[faceMap_[face0I]] == cellI)
 231         );
 232     vertLabels_[2] = pointMap_[face0[face0vert2]];
 233     //Info<< "Prism vertex 2: vertex " <<  face0[face0vert2]
 234     //    << " at position " << face0vert2 << " in face " << face0
 235     //    << endl;
 236
 237     // Jump edge from face0 to face3
 238     label face3I =
 239         otherFace
 240         (
 241             numVert,
 242             face0[face0vert1],
 243             face0[face0vert2],
 244             face0I
 245         );
 246     faceLabels_[3] = faceMap_[face3I];
 247     const face& face3 = localFaces_[face3I];
 248     //Info<< "Stepped to prism face 3 " << face3
 249     //    << " across edge " << face0[face0vert1] << " "
 250     //    << face0[face0vert2]
 251     //    << endl;
 252
 253     label face3vert2 = pointFaceIndex_[face0[face0vert2]][face3I];
 254
 255     //Info<< "Prism vertex 2 also: vertex " <<  face3[face3vert2]
 256     //    << " at position " << face3vert2 << " in face " << face3
 257     //    << endl;
 258
 259     label face3vert5 =
 260         nextVert
 261         (
 262             face3vert2,
 263             faceSize_[face3I],
 264             (owner[faceMap_[face3I]] == cellI)
 265         );
 266     vertLabels_[5] = pointMap_[face3[face3vert5]];
 267     //Info<< "Prism vertex 5: vertex " <<  face3[face3vert5]
 268     //    << " at position " << face3vert5 << " in face " << face3
 269     //    << endl;
 270
 271     // Jump edge from face0 to face2
 272     label face2I =
 273         otherFace
 274         (
 275             numVert,
 276             face0[face0vert2],
 277             face0[face0vert0],
 278             face0I
 279         );
 280     faceLabels_[2] = faceMap_[face2I];
 281     //const face& face2 = localFaces_[face2I];
 282     //Info<< "Stepped to prism face 2 " << face2
 283     //    << " across edge " << face0[face0vert2] << " "
 284     //    << face0[face0vert0]
 285     //    << endl;
 286
 287     //label face2vert2 = pointFaceIndex_[face0[face0vert2]][face2I];
 288     //Info<< "Prism vertex 2 also: vertex " <<  face2[face2vert2]
 289     //    << " at position " << face2vert2 << " in face " << face2
 290     //    << endl;
 291
 292     return true;
 293 }
 294
 295
 296 Foam::label Foam::prismMatcher::faceHashValue() const
 297 {
 298     return 2*3 + 4*4;
 299 }
 300
 301
 302 bool Foam::prismMatcher::faceSizeMatch
 303 (
 304     const faceList& faces,
 305     const labelList& myFaces
 306 ) const
 307 {
 308     if (myFaces.size() != 5)
 309     {
 310         return false;
 311     }
 312
 313     label nTris = 0;
 314     label nQuads = 0;
 315
 316     forAll(myFaces, myFaceI)
 317     {
 318         label size = faces[myFaces[myFaceI]].size();
 319
 320         if (size == 3)
 321         {
 322             nTris++;
 323         }
 324         else if (size == 4)
 325         {
 326             nQuads++;
 327         }
 328         else
 329         {
 330             return false;
 331         }
 332     }
 333     if ((nTris == 2) && (nQuads == 3))
 334     {
 335         return true;
 336     }
 337     else
 338     {
 339         return false;
 340     }
 341 }
 342
 343
 344 bool Foam::prismMatcher::isA(const primitiveMesh& mesh, const label cellI)
 345 {
 346     return matchShape
 347     (
 348         true,
 349         mesh.faces(),
 350         mesh.faceOwner(),
 351         cellI,
 352         mesh.cells()[cellI]
 353     );
 354 }
 355
 356
 357 bool Foam::prismMatcher::isA(const faceList& faces)
 358 {
 359     // Do as if mesh with one cell only
 360     return matchShape
 361     (
 362         true,
 363         faces,                      // all faces in mesh
 364         labelList(faces.size(), 0), // cell 0 is owner of all faces
 365         0,                          // cell label
 366         makeIdentity(faces.size())  // faces of cell 0
 367     );
 368 }
 369
 370
 371 bool Foam::prismMatcher::matches
 372 (
 373     const primitiveMesh& mesh,
 374     const label cellI,
 375     cellShape& shape
 376 )
 377 {
 378     if
 379     (
 380         matchShape
 381         (
 382             false,
 383             mesh.faces(),
 384             mesh.faceOwner(),
 385             cellI,
 386             mesh.cells()[cellI]
 387         )
 388     )
 389     {
 390         shape = cellShape(model(), vertLabels());
 391
 392         return true;
 393     }
 394     else
 395     {
 396         return false;
 397     }
 398 }
 399
 400
 401 // ************************************************************************* //