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

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 2004-2010 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 "tetMatcher.H"
  27 #include "cellMatcher.H"
  28 #include "primitiveMesh.H"
  29 #include "primitiveMesh.H"
  30 #include "cellModeller.H"
  31 #include "ListOps.H"
  32
  33 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  34
  35 const Foam::label Foam::tetMatcher::vertPerCell = 4;
  36 const Foam::label Foam::tetMatcher::facePerCell = 4;
  37 const Foam::label Foam::tetMatcher::maxVertPerFace = 3;
  38
  39
  40 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  41
  42 Foam::tetMatcher::tetMatcher()
  43 :
  44     cellMatcher
  45     (
  46         vertPerCell,
  47         facePerCell,
  48         maxVertPerFace,
  49         "tet"
  50     )
  51 {}
  52
  53
  54 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
  55
  56 Foam::tetMatcher::~tetMatcher()
  57 {}
  58
  59
  60 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
  61
  62
  63 bool Foam::tetMatcher::matchShape
  64 (
  65     const bool checkOnly,
  66     const faceList& faces,
  67     const labelList& owner,
  68     const label cellI,
  69     const labelList& myFaces
  70 )
  71 {
  72     if (!faceSizeMatch(faces, myFaces))
  73     {
  74         return false;
  75     }
  76
  77     // Tet for sure now
  78     if (checkOnly)
  79     {
  80         return true;
  81     }
  82
  83     // Calculate localFaces_ and mapping pointMap_, faceMap_
  84     label numVert = calcLocalFaces(faces, myFaces);
  85
  86     if (numVert != vertPerCell)
  87     {
  88         return false;
  89     }
  90
  91     // Set up 'edge' to face mapping.
  92     calcEdgeAddressing(numVert);
  93
  94     // Set up point on face to index-in-face mapping
  95     calcPointFaceIndex();
  96
  97     // Storage for maps -vertex to mesh and -face to mesh
  98     vertLabels_.setSize(vertPerCell);
  99     faceLabels_.setSize(facePerCell);
 100
 101     //
 102     // Try bottom face (face 3)
 103     //
 104
 105     label face3I = 0;
 106     const face& face3 = localFaces_[face3I];
 107     label face3vert0 = 0;
 108
 109     //
 110     // Try to follow prespecified path on faces of cell,
 111     // starting at face3vert0
 112     //
 113
 114     vertLabels_[0] = pointMap_[face3[face3vert0]];
 115     faceLabels_[3] = faceMap_[face3I];
 116
 117     // Walk face 3 from vertex 0 to 1
 118     label face3vert1 =
 119         nextVert
 120         (
 121             face3vert0,
 122             faceSize_[face3I],
 123             !(owner[faceMap_[face3I]] == cellI)
 124         );
 125     vertLabels_[1] = pointMap_[face3[face3vert1]];
 126
 127     // Walk face 3 from vertex 1 to 2
 128     label face3vert2 =
 129         nextVert
 130         (
 131             face3vert1,
 132             faceSize_[face3I],
 133             !(owner[faceMap_[face3I]] == cellI)
 134         );
 135     vertLabels_[2] = pointMap_[face3[face3vert2]];
 136
 137     // Jump edge from face3 to face2
 138     label face2I =
 139         otherFace
 140         (
 141             numVert,
 142             face3[face3vert0],
 143             face3[face3vert1],
 144             face3I
 145         );
 146     faceLabels_[2] = faceMap_[face2I];
 147
 148     // Jump edge from face3 to face0
 149     label face0I =
 150         otherFace
 151         (
 152             numVert,
 153             face3[face3vert1],
 154             face3[face3vert2],
 155             face3I
 156         );
 157     faceLabels_[0] = faceMap_[face0I];
 158
 159     // Jump edge from face3 to face1
 160     label face1I =
 161         otherFace
 162         (
 163             numVert,
 164             face3[face3vert2],
 165             face3[face3vert0],
 166             face3I
 167         );
 168     faceLabels_[1] = faceMap_[face1I];
 169     const face& face1 = localFaces_[face1I];
 170
 171     // Get index of vert0 in face 1
 172     label face1vert0 = pointFaceIndex_[face3[face3vert0]][face1I];
 173
 174     // Walk face 1 from vertex 0 to 3
 175     label face1vert3 =
 176         nextVert
 177         (
 178             face1vert0,
 179             faceSize_[face1I],
 180             (owner[faceMap_[face1I]] == cellI)
 181         );
 182     vertLabels_[3] = pointMap_[face1[face1vert3]];
 183
 184     return true;
 185 }
 186
 187
 188 Foam::label Foam::tetMatcher::faceHashValue() const
 189 {
 190     return 4*3;
 191 }
 192
 193
 194 bool Foam::tetMatcher::faceSizeMatch
 195 (
 196     const faceList& faces,
 197     const labelList& myFaces
 198 ) const
 199 {
 200     if (myFaces.size() != 4)
 201     {
 202         return false;
 203     }
 204
 205     forAll(myFaces, myFaceI)
 206     {
 207         label size = faces[myFaces[myFaceI]].size();
 208
 209         if (size != 3)
 210         {
 211             return false;
 212         }
 213     }
 214     return true;
 215 }
 216
 217
 218 bool Foam::tetMatcher::isA(const primitiveMesh& mesh, const label cellI)
 219 {
 220     return matchShape
 221     (
 222         true,
 223         mesh.faces(),
 224         mesh.faceOwner(),
 225         cellI,
 226         mesh.cells()[cellI]
 227     );
 228 }
 229
 230
 231 bool Foam::tetMatcher::isA(const faceList& faces)
 232 {
 233     // Do as if mesh with one cell only
 234     return matchShape
 235     (
 236         true,
 237         faces,                      // all faces in mesh
 238         labelList(faces.size(), 0), // cell 0 is owner of all faces
 239         0,                          // cell label
 240         identity(faces.size())      // faces of cell 0
 241     );
 242 }
 243
 244
 245 bool Foam::tetMatcher::matches
 246 (
 247     const primitiveMesh& mesh,
 248     const label cellI,
 249     cellShape& shape
 250 )
 251 {
 252     if
 253     (
 254         matchShape
 255         (
 256             false,
 257             mesh.faces(),
 258             mesh.faceOwner(),
 259             cellI,
 260             mesh.cells()[cellI]
 261         )
 262     )
 263     {
 264         shape = cellShape(model(), vertLabels());
 265
 266         return true;
 267     }
 268     else
 269     {
 270         return false;
 271     }
 272 }
 273
 274
 275 // ************************************************************************* //