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