duplicatePoints.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) 2011 OpenFOAM Foundation
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 "duplicatePoints.H"
27 #include "localPointRegion.H"
28 #include "polyTopoChange.H"
29 #include "polyAddPoint.H"
30 #include "polyModifyFace.H"
31 #include "polyMesh.H"
32 #include "OFstream.H"
33 #include "meshTools.H"
34 #include "Time.H"
35 
36 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
37 
38 namespace Foam
39 {
40 
41 defineTypeNameAndDebug(duplicatePoints, 0);
42 
43 }
44 
45 
46 // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
47 
48 // Construct from mesh
49 Foam::duplicatePoints::duplicatePoints(const polyMesh& mesh)
50 :
51  mesh_(mesh),
52  duplicates_(0)
53 {}
54 
55 
56 // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
57 
59 (
60  const localPointRegion& regionSide,
61  polyTopoChange& meshMod
62 )
63 {
64  const Map<label>& meshPointMap = regionSide.meshPointMap();
65  const labelListList& pointRegions = regionSide.pointRegions();
66  const Map<label>& meshFaceMap = regionSide.meshFaceMap();
67  const faceList& faceRegions = regionSide.faceRegions();
68  const polyBoundaryMesh& patches = mesh_.boundaryMesh();
69 
70  // Create duplicates for points. One for each region.
71  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
72 
73  // Per point-to-be-duplicated, in order of the regions the point added.
74  duplicates_.setSize(meshPointMap.size());
75 
76  forAllConstIter(Map<label>, meshPointMap, iter)
77  {
78  label pointI = iter.key();
79  label localI = iter();
80  const labelList& regions = pointRegions[localI];
81 
82  duplicates_[localI].setSize(regions.size());
83  duplicates_[localI][0] = pointI;
84  for (label i = 1; i < regions.size(); i++)
85  {
86  duplicates_[localI][i] = meshMod.addPoint
87  (
88  mesh_.points()[pointI], // point
89  pointI, // master point
90  -1, // zone for point
91  true // supports a cell
92  );
93  }
94 
95  //Pout<< "For point:" << pointI << " coord:" << mesh_.points()[pointI]
96  // << endl;
97  //forAll(duplicates_[localI], i)
98  //{
99  // Pout<< " region:" << regions[i]
100  // << " addedpoint:" << duplicates_[localI][i]
101  // << endl;
102  //}
103  }
104 
105 
106 
107  // Modfify faces according to face region
108  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
109 
110  face newFace;
111 
112  forAllConstIter(Map<label>, meshFaceMap, iter)
113  {
114  label faceI = iter.key();
115  label localI = iter();
116 
117  // Replace points with duplicated ones.
118  const face& fRegion = faceRegions[localI];
119  const face& f = mesh_.faces()[faceI];
120 
121  newFace.setSize(f.size());
122  forAll(f, fp)
123  {
124  label pointI = f[fp];
125 
126  Map<label>::const_iterator iter = meshPointMap.find(pointI);
127 
128  if (iter != meshPointMap.end())
129  {
130  // Point has been duplicated. Find correct one for my
131  // region.
132 
133  // Get the regions and added points for this point
134  const labelList& regions = pointRegions[iter()];
135  const labelList& dupPoints = duplicates_[iter()];
136 
137  // Look up index of my region in the regions for this point
138  label index = findIndex(regions, fRegion[fp]);
139  // Get the corresponding added point
140  newFace[fp] = dupPoints[index];
141  }
142  else
143  {
144  newFace[fp] = pointI;
145  }
146  }
147 
148  // Get current zone info
149  label zoneID = mesh_.faceZones().whichZone(faceI);
150  bool zoneFlip = false;
151  if (zoneID >= 0)
152  {
153  const faceZone& fZone = mesh_.faceZones()[zoneID];
154  zoneFlip = fZone.flipMap()[fZone.whichFace(faceI)];
155  }
156 
157 
158  if (mesh_.isInternalFace(faceI))
159  {
160  meshMod.modifyFace
161  (
162  newFace, // modified face
163  faceI, // label of face being modified
164  mesh_.faceOwner()[faceI], // owner
165  mesh_.faceNeighbour()[faceI], // neighbour
166  false, // face flip
167  -1, // patch for face
168  zoneID, // zone for face
169  zoneFlip // face flip in zone
170  );
171  }
172  else
173  {
174  meshMod.modifyFace
175  (
176  newFace, // modified face
177  faceI, // label of face being modified
178  mesh_.faceOwner()[faceI], // owner
179  -1, // neighbour
180  false, // face flip
181  patches.whichPatch(faceI), // patch for face
182  zoneID, // zone for face
183  zoneFlip // face flip in zone
184  );
185  }
186  }
187 
188 
189  if (debug)
190  {
191  // Output duplicated points
192  {
193  OFstream str(mesh_.time().path()/"duplicatedPoints.obj");
194  forAllConstIter(Map<label>, meshPointMap, iter)
195  {
196  label localI = iter();
197  const labelList& dups = duplicates_[localI];
198 
199  forAll(dups, i)
200  {
201  meshTools::writeOBJ(str, meshMod.points()[dups[i]]);
202  }
203  }
204  }
205  }
206 }
207 
208 
210 {
211  forAll(duplicates_, masterI)
212  {
213  inplaceRenumber(map.reversePointMap(), duplicates_[masterI]);
214  }
215 }
216 
217 
218 // ************************************************************************* //
Output to file stream.
Definition: OFstream.H:81
const boolList & flipMap() const
Return face flip map.
Definition: faceZone.H:249
const faceZoneMesh & faceZones() const
Return face zone mesh.
Definition: polyMesh.H:463
void updateMesh(const mapPolyMesh &)
Force recalculation of locally stored data on topological change.
label findIndex(const ListType &, typename ListType::const_reference, const label start=0)
Find first occurence of given element and return index,.
fileName path() const
Return path.
Definition: Time.H:281
label whichZone(const label objectIndex) const
Given a global object index, return the zone it is in.
Definition: ZoneMesh.C:232
labelList f(nPoints)
Class containing mesh-to-mesh mapping information after a change in polyMesh topology.
Definition: mapPolyMesh.H:158
const labelList & reversePointMap() const
Reverse point map.
Definition: mapPolyMesh.H:465
const faceList & faceRegions() const
Per face the region of its points.
A subset of mesh faces organised as a primitive patch.
Definition: faceZone.H:64
intWM_LABEL_SIZE_t label
A label is an int32_t or int64_t as specified by the pre-processor macro WM_LABEL_SIZE.
Definition: label.H:59
void size(const label)
Override size to be inconsistent with allocated storage.
Definition: ListI.H:76
dynamicFvMesh & mesh
Namespace for OpenFOAM.
const DynamicList< point > & points() const
Points. Shrunk after constructing mesh (or calling of compact())
label whichFace(const label globalCellID) const
Helper function to re-direct to zone::localID(...)
Definition: faceZone.C:317
patches[0]
forAllConstIter(PtrDictionary< phaseModel >, mixture.phases(), phase)
Definition: pEqn.H:39
A face is a list of labels corresponding to mesh vertices.
Definition: face.H:75
const labelListList & pointRegions() const
Per local point the regions it is in.
void setRefinement(const localPointRegion &regionSide, polyTopoChange &)
Play commands into polyTopoChange to duplicate points. Gets.
void setSize(const label)
Reset size of List.
Definition: List.C:318
virtual const pointField & points() const
Return raw points.
Definition: polyMesh.C:1035
Foam::polyBoundaryMesh.
#define forAll(list, i)
Definition: UList.H:421
label addPoint(const point &, const label masterPointID, const label zoneID, const bool inCell)
Add point. Return new point label.
label whichPatch(const label faceIndex) const
Return patch index for a given face label.
label size() const
Return number of elements in table.
Definition: HashTableI.H:65
virtual const labelList & faceOwner() const
Return face owner.
Definition: polyMesh.C:1073
const polyBoundaryMesh & boundaryMesh() const
Return boundary mesh.
Definition: polyMesh.H:421
void modifyFace(const face &f, const label faceI, const label own, const label nei, const bool flipFaceFlux, const label patchID, const label zoneID, const bool zoneFlip)
Modify vertices or cell of face.
Mesh consisting of general polyhedral cells.
Definition: polyMesh.H:74
const Map< label > & meshPointMap() const
Per point that is to be duplicated the local index.
Direct mesh changes based on v1.3 polyTopoChange syntax.
static iteratorEnd end()
iteratorEnd set to beyond the end of any HashTable
Definition: HashTable.H:106
const Time & time() const
Return time.
Takes mesh with &#39;baffles&#39; (= boundary faces sharing points). Determines for selected points on bounda...
const Map< label > & meshFaceMap() const
Per face that uses a duplicated point the local index.
virtual const faceList & faces() const
Return raw faces.
Definition: polyMesh.C:1060
iterator find(const Key &)
Find and return an iterator set at the hashedEntry.
Definition: HashTable.C:139
virtual const labelList & faceNeighbour() const
Return face neighbour.
Definition: polyMesh.C:1079
void writeOBJ(Ostream &os, const point &pt)
Write obj representation of point.
Definition: meshTools.C:209
void inplaceRenumber(const labelUList &oldToNew, ListType &)
Inplace renumber the values of a list.
defineTypeNameAndDebug(combustionModel, 0)
bool isInternalFace(const label faceIndex) const
Return true if given face label is internal to the mesh.