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