duplicatePoints.C
Go to the documentation of this file.
1 /*---------------------------------------------------------------------------*\
2  ========= |
3  \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
4  \\ / O peration | Website: https://openfoam.org
5  \\ / A nd | Copyright (C) 2011-2019 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
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  // Modify 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 // ************************************************************************* //
const polyBoundaryMesh & boundaryMesh() const
Return boundary mesh.
Definition: polyMesh.H:434
#define forAll(list, i)
Loop across all elements in list.
Definition: UList.H:434
const labelListList & pointRegions() const
Per local point the regions it is in.
const labelList & reversePointMap() const
Reverse point map.
Definition: mapPolyMesh.H:458
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
const faceList & faceRegions() const
Per face the region of its points.
void inplaceRenumber(const labelUList &oldToNew, ListType &)
Inplace renumber the values of a list.
static iteratorEnd end()
iteratorEnd set to beyond the end of any HashTable
Definition: HashTable.H:112
A face is a list of labels corresponding to mesh vertices.
Definition: face.H:75
virtual const labelList & faceNeighbour() const
Return face neighbour.
Definition: polyMesh.C:1175
Output to file stream.
Definition: OFstream.H:82
void size(const label)
Override size to be inconsistent with allocated storage.
Definition: ListI.H:164
const boolList & flipMap() const
Return face flip map.
Definition: faceZone.H:248
void writeOBJ(Ostream &os, const point &pt)
Write obj representation of point.
Definition: meshTools.C:203
label whichFace(const label globalCellID) const
Helper function to re-direct to zone::localID(...)
Definition: faceZone.C:306
patches[0]
const Map< label > & meshPointMap() const
Per point that is to be duplicated the local index.
label size() const
Return number of elements in table.
Definition: HashTableI.H:65
Class containing mesh-to-mesh mapping information after a change in polyMesh topology.
Definition: mapPolyMesh.H:158
Takes mesh with &#39;baffles&#39; (= boundary faces sharing points). Determines for selected points on bounda...
virtual const pointField & points() const
Return raw points.
Definition: polyMesh.C:1131
duplicatePoints(const polyMesh &mesh)
Construct from mesh.
iterator find(const Key &)
Find and return an iterator set at the hashedEntry.
Definition: HashTable.C:142
dynamicFvMesh & mesh
const DynamicList< point > & points() const
Points. Shrunk after constructing mesh (or calling of compact())
const Map< label > & meshFaceMap() const
Per face that uses a duplicated point the local index.
virtual const labelList & faceOwner() const
Return face owner.
Definition: polyMesh.C:1169
label addPoint(const point &, const label masterPointID, const label zoneID, const bool inCell)
Add point. Return new point label.
virtual const faceList & faces() const
Return raw faces.
Definition: polyMesh.C:1156
forAllConstIter(PtrDictionary< phaseModel >, mixture.phases(), phase)
Definition: pEqn.H:29
Foam::polyBoundaryMesh.
bool isInternalFace(const label faceIndex) const
Return true if given face label is internal to the mesh.
const Time & time() const
Return time.
defineTypeNameAndDebug(combustionModel, 0)
labelList f(nPoints)
label findIndex(const ListType &, typename ListType::const_reference, const label start=0)
Find first occurrence of given element and return index,.
void setSize(const label)
Reset size of List.
Definition: List.C:281
label whichZone(const label objectIndex) const
Given a global object index, return the zone it is in.
Definition: MeshZones.C:221
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.
const meshFaceZones & faceZones() const
Return face zones.
Definition: polyMesh.H:476
Direct mesh changes based on v1.3 polyTopoChange syntax.
void setRefinement(const localPointRegion &regionSide, polyTopoChange &)
Play commands into polyTopoChange to duplicate points. Gets.
void updateMesh(const mapPolyMesh &)
Force recalculation of locally stored data on topological change.
Mesh consisting of general polyhedral cells.
Definition: polyMesh.H:74
A subset of mesh faces organised as a primitive patch.
Definition: faceZone.H:64
fileName path() const
Return path.
Definition: TimePaths.H:139
label whichPatch(const label faceIndex) const
Return patch index for a given face label.
Namespace for OpenFOAM.