Nektar++
Classes | Typedefs | Functions | Variables
Nektar::GlobalMapping Namespace Reference

Classes

class  Mapping
 Base class for mapping to be applied to the coordinate system. More...
 
class  MappingGeneral
 
class  MappingTranslation
 
class  MappingXofXZ
 
class  MappingXofZ
 
class  MappingXYofXY
 
class  MappingXYofZ
 

Typedefs

typedef LibUtilities::NekFactory< std::string, Mapping, const LibUtilities::SessionReaderSharedPtr &, const Array< OneD, MultiRegions::ExpListSharedPtr > &, const TiXmlElement * > MappingFactory
 Declaration of the mapping factory. More...
 

Functions

void UpdateGeometry (SpatialDomains::MeshGraphSharedPtr graph, Array< OneD, MultiRegions::ExpListSharedPtr > &fields, Array< OneD, Array< OneD, NekDouble > > &PhysVals, bool modal)
 Update geometry according to displacement that is in current fields. More...
 
MappingFactory & GetMappingFactory ()
 Declaration of the mapping factory singleton. More...
 

Variables

GLOBAL_MAPPING_EXPORT typedef std::shared_ptr< Mapping > MappingSharedPtr
 A shared pointer to a Mapping object. More...
 

Typedef Documentation

◆ MappingFactory

typedef LibUtilities::NekFactory< std::string, Mapping, const LibUtilities::SessionReaderSharedPtr &, const Array<OneD, MultiRegions::ExpListSharedPtr> &, const TiXmlElement *> Nektar::GlobalMapping::MappingFactory

Declaration of the mapping factory.

Definition at line 63 of file Mapping.h.

Function Documentation

◆ GetMappingFactory()

GLOBAL_MAPPING_EXPORT MappingFactory & Nektar::GlobalMapping::GetMappingFactory ( )

Declaration of the mapping factory singleton.

Definition at line 47 of file Mapping.cpp.

48{
49 static MappingFactory instance;
50 return instance;
51}
Nektar::LibUtilities::NekFactory
Provides a generic Factory class.
Definition: BasicUtils/NekFactory.hpp:104

Referenced by Nektar::GlobalMapping::Mapping::Load().

◆ UpdateGeometry()

GLOBAL_MAPPING_EXPORT void Nektar::GlobalMapping::UpdateGeometry ( SpatialDomains::MeshGraphSharedPtr  graph,
Array< OneD, MultiRegions::ExpListSharedPtr > &  fields,
Array< OneD, Array< OneD, NekDouble > > &  PhysVals,
bool  modal 
)

Update geometry according to displacement that is in current fields.

Adds a summary item to the summary info list.

Parameters
graphThe MeshGraph of the current geometry.
fieldsThe fields containing the displacement.

Definition at line 53 of file Deform.cpp.

56{
57 // Clear existing curvature.
58 SpatialDomains::CurveMap &curvedEdges = graph->GetCurvedEdges();
59 SpatialDomains::CurveMap &curvedFaces = graph->GetCurvedFaces();
60 curvedEdges.clear();
61 curvedFaces.clear();
62
63 int i, j, k, l, dim;
64
65 // Sets to hold IDs of updated vertices to avoid duplicating effort.
66 std::set<int> updatedVerts, updatedEdges, updatedFaces;
67
68 dim = graph->GetSpaceDimension();
69 Array<OneD, Array<OneD, NekDouble>> phys(dim);
70 Array<OneD, Array<OneD, NekDouble>> coord(dim);
71
72 for (i = 0; i < fields[0]->GetExpSize(); ++i)
73 {
74 LocalRegions::ExpansionSharedPtr exp = fields[0]->GetExp(i);
75 int offset = fields[0]->GetPhys_Offset(i);
76 int nquad = exp->GetTotPoints();
77
78 // Extract displacement for this element, allocate storage for
79 // elemental coordinates.
80 for (j = 0; j < dim; ++j)
81 {
82 phys[j] = Array<OneD, NekDouble>(nquad, PhysVals[j] + offset);
83 coord[j] = Array<OneD, NekDouble>(nquad);
84 }
85
86 // In 2D loop over edges.
87 if (dim == 2)
88 {
89 exp->GetCoords(coord[0], coord[1]);
90
91 SpatialDomains::Geometry2DSharedPtr geom =
92 std::dynamic_pointer_cast<SpatialDomains::Geometry2D>(
93 exp->GetGeom());
94
95 for (j = 0; j < exp->GetGeom()->GetNumEdges(); ++j)
96 {
97 SpatialDomains::Geometry1DSharedPtr edge = geom->GetEdge(j);
98
99 // This edge has already been processed.
100 if (updatedEdges.find(edge->GetGlobalID()) !=
101 updatedEdges.end())
102 {
103 continue;
104 }
105
106 // Extract edge displacement.
107 int nEdgePts = exp->GetTraceNumPoints(j);
108 Array<OneD, Array<OneD, NekDouble>> edgePhys(dim);
109 Array<OneD, Array<OneD, NekDouble>> edgeCoord(dim);
110
111 const LibUtilities::BasisKey B(
112 LibUtilities::eModified_A, nEdgePts,
113 LibUtilities::PointsKey(
114 nEdgePts, LibUtilities::eGaussLobattoLegendre));
115 StdRegions::StdExpansion1DSharedPtr seg =
116 MemoryManager<StdRegions::StdSegExp>::AllocateSharedPtr(B);
117
118 for (k = 0; k < dim; ++k)
119 {
120 edgePhys[k] = Array<OneD, NekDouble>(nEdgePts);
121 edgeCoord[k] = Array<OneD, NekDouble>(nEdgePts);
122 exp->GetTracePhysVals(j, seg, phys[k], edgePhys[k]);
123 exp->GetTracePhysVals(j, seg, coord[k], edgeCoord[k]);
124 }
125
126 // Update verts
127 for (k = 0; k < 2; ++k)
128 {
129 int id = edge->GetVid(k);
130 if (updatedVerts.find(id) != updatedVerts.end())
131 {
132 continue;
133 }
134
135 SpatialDomains::PointGeomSharedPtr pt = edge->GetVertex(k);
136
137 pt->UpdatePosition(
138 (*pt)(0) + edgePhys[0][k * (nEdgePts - 1)],
139 (*pt)(1) + edgePhys[1][k * (nEdgePts - 1)], (*pt)(2));
140
141 updatedVerts.insert(id);
142 }
143
144 // Update curve
145 SpatialDomains::CurveSharedPtr curve =
146 MemoryManager<SpatialDomains::Curve>::AllocateSharedPtr(
147 edge->GetGlobalID(),
148 LibUtilities::eGaussLobattoLegendre);
149
150 for (k = 0; k < nEdgePts; ++k)
151 {
152 SpatialDomains::PointGeomSharedPtr vert =
153 MemoryManager<SpatialDomains::PointGeom>::
154 AllocateSharedPtr(dim, edge->GetGlobalID(),
155 edgeCoord[0][k] + edgePhys[0][k],
156 edgeCoord[1][k] + edgePhys[1][k],
157 0.0);
158
159 curve->m_points.push_back(vert);
160 }
161
162 curvedEdges[edge->GetGlobalID()] = curve;
163 updatedEdges.insert(edge->GetGlobalID());
164 }
165 }
166 else if (dim == 3)
167 {
168 exp->GetCoords(coord[0], coord[1], coord[2]);
169
170 SpatialDomains::Geometry3DSharedPtr geom =
171 std::dynamic_pointer_cast<SpatialDomains::Geometry3D>(
172 exp->GetGeom());
173
174 for (j = 0; j < exp->GetNtraces(); ++j)
175 {
176 SpatialDomains::Geometry2DSharedPtr face = geom->GetFace(j);
177
178 LocalRegions::Expansion3DSharedPtr exp3d =
179 exp->as<LocalRegions::Expansion3D>();
180
181 // This edge has already been processed.
182 if (updatedFaces.find(face->GetGlobalID()) !=
183 updatedFaces.end())
184 {
185 continue;
186 }
187
188 // Extract face displacement.
189 LibUtilities::BasisKey B0 = exp->GetTraceBasisKey(j, 0);
190 LibUtilities::BasisKey B1 = exp->GetTraceBasisKey(j, 1);
191 int nq0 = B0.GetNumPoints();
192 int nq1 = B1.GetNumPoints();
193
194 ASSERTL1(B0.GetPointsType() ==
195 LibUtilities::eGaussLobattoLegendre &&
196 B1.GetPointsType() ==
197 LibUtilities::eGaussLobattoLegendre,
198 "Deformation requires GLL points in both "
199 "directions on a face.");
200
201 Array<OneD, Array<OneD, NekDouble>> newPos(dim);
202
203 StdRegions::StdExpansion2DSharedPtr faceexp;
204 StdRegions::Orientation orient = exp->GetTraceOrient(j);
205
206 if (face->GetShapeType() == LibUtilities::eTriangle)
207 {
208 faceexp =
209 MemoryManager<StdRegions::StdTriExp>::AllocateSharedPtr(
210 B0, B1);
211 }
212 else
213 {
214 faceexp = MemoryManager<
215 StdRegions::StdQuadExp>::AllocateSharedPtr(B0, B1);
216 }
217
218 for (k = 0; k < dim; ++k)
219 {
220 Array<OneD, NekDouble> tmp(nq0 * nq1);
221 newPos[k] = Array<OneD, NekDouble>(nq0 * nq1);
222 exp3d->GetTracePhysVals(j, faceexp, phys[k], tmp, orient);
223 exp3d->GetTracePhysVals(j, faceexp, coord[k], newPos[k],
224 orient);
225 Vmath::Vadd(nq0 * nq1, tmp, 1, newPos[k], 1, newPos[k], 1);
226 }
227
228 // Now interpolate face onto a more reasonable set of
229 // points.
230 int nq = std::max(nq0, nq1);
231 if (!modal)
232 {
233 nq--;
234 }
235
236 LibUtilities::PointsKey edgePts(
237 nq, LibUtilities::eGaussLobattoLegendre);
238 LibUtilities::PointsKey triPts(nq, LibUtilities::eNodalTriElec);
239
240 Array<OneD, Array<OneD, NekDouble>> intPos(dim);
241
242 for (k = 0; k < dim; ++k)
243 {
244 intPos[k] = Array<OneD, NekDouble>(nq * nq);
245 LibUtilities::Interp2D(faceexp->GetPointsKeys()[0],
246 faceexp->GetPointsKeys()[1],
247 newPos[k], edgePts, edgePts,
248 intPos[k]);
249 }
250
251 int edgeOff[2][4][2] = {
252 {{0, 1}, {nq - 1, nq}, {nq * (nq - 1), -nq}, {-1, -1}},
253 {{0, 1},
254 {nq - 1, nq},
255 {nq * nq - 1, -1},
256 {nq * (nq - 1), -nq}}};
257
258 for (k = 0; k < face->GetNumVerts(); ++k)
259 {
260 // Update verts
261 int id = face->GetVid(k);
262 const int o =
263 face->GetShapeType() - LibUtilities::eTriangle;
264
265 if (updatedVerts.find(id) == updatedVerts.end())
266 {
267 SpatialDomains::PointGeomSharedPtr pt =
268 face->GetVertex(k);
269 pt->UpdatePosition(intPos[0][edgeOff[o][k][0]],
270 intPos[1][edgeOff[o][k][0]],
271 intPos[2][edgeOff[o][k][0]]);
272 updatedVerts.insert(id);
273 }
274
275 // Update edges
276 id = face->GetEid(k);
277 if (updatedEdges.find(id) == updatedEdges.end())
278 {
279 SpatialDomains::Geometry1DSharedPtr edge =
280 face->GetEdge(k);
281 SpatialDomains::CurveSharedPtr curve =
282 MemoryManager<SpatialDomains::Curve>::
283 AllocateSharedPtr(
284 edge->GetGlobalID(),
285 LibUtilities::eGaussLobattoLegendre);
286
287 const int offset = edgeOff[o][k][0];
288 const int pos = edgeOff[o][k][1];
289
290 if (face->GetEorient(k) == StdRegions::eBackwards)
291 {
292 for (l = nq - 1; l >= 0; --l)
293 {
294 int m = offset + pos * l;
295 SpatialDomains::PointGeomSharedPtr vert =
296 MemoryManager<SpatialDomains::PointGeom>::
297 AllocateSharedPtr(
298 dim, edge->GetGlobalID(),
299 intPos[0][m], intPos[1][m],
300 intPos[2][m]);
301 curve->m_points.push_back(vert);
302 }
303 }
304 else
305 {
306 for (l = 0; l < nq; ++l)
307 {
308 int m = offset + pos * l;
309 SpatialDomains::PointGeomSharedPtr vert =
310 MemoryManager<SpatialDomains::PointGeom>::
311 AllocateSharedPtr(
312 dim, edge->GetGlobalID(),
313 intPos[0][m], intPos[1][m],
314 intPos[2][m]);
315 curve->m_points.push_back(vert);
316 }
317 }
318
319 curvedEdges[edge->GetGlobalID()] = curve;
320 updatedEdges.insert(edge->GetGlobalID());
321 }
322 }
323
324 // Update face-interior curvature
325 LibUtilities::PointsType pType =
326 face->GetShapeType() == LibUtilities::eTriangle
327 ? LibUtilities::eNodalTriElec
328 : LibUtilities::eGaussLobattoLegendre;
329
330 SpatialDomains::CurveSharedPtr curve =
331 MemoryManager<SpatialDomains::Curve>::AllocateSharedPtr(
332 face->GetGlobalID(), pType);
333
334 if (face->GetShapeType() == LibUtilities::eTriangle)
335 {
336 // This code is probably pretty crappy. Have to go from
337 // GLL-GLL points -> GLL-Gauss-Radau -> nodal triangle
338 // points.
339 const LibUtilities::BasisKey B0(
340 LibUtilities::eOrtho_A, nq,
341 LibUtilities::PointsKey(
342 nq, LibUtilities::eGaussLobattoLegendre));
343 const LibUtilities::BasisKey B1(
344 LibUtilities::eOrtho_B, nq,
345 LibUtilities::PointsKey(
346 nq, LibUtilities::eGaussRadauMAlpha1Beta0));
347 StdRegions::StdNodalTriExp nodalTri(B0, B1, pType);
348 StdRegions::StdTriExp tri(B0, B1);
349
350 for (k = 0; k < dim; ++k)
351 {
352 Array<OneD, NekDouble> nodal(nq * nq);
353
354 LibUtilities::Interp2D(
355 faceexp->GetBasis(0)->GetBasisKey(),
356 faceexp->GetBasis(1)->GetBasisKey(), newPos[k], B0,
357 B1, nodal);
358
359 Array<OneD, NekDouble> tmp1(nq * (nq + 1) / 2);
360 Array<OneD, NekDouble> tmp2(nq * (nq + 1) / 2);
361
362 tri.FwdTrans(nodal, tmp1);
363 nodalTri.ModalToNodal(tmp1, tmp2);
364 newPos[k] = tmp2;
365 }
366
367 for (l = 0; l < nq * (nq + 1) / 2; ++l)
368 {
369 SpatialDomains::PointGeomSharedPtr vert =
370 MemoryManager<SpatialDomains::PointGeom>::
371 AllocateSharedPtr(dim, face->GetGlobalID(),
372 newPos[0][l], newPos[1][l],
373 newPos[2][l]);
374 curve->m_points.push_back(vert);
375 }
376 }
377 else
378 {
379 for (l = 0; l < nq * nq; ++l)
380 {
381 SpatialDomains::PointGeomSharedPtr vert =
382 MemoryManager<SpatialDomains::PointGeom>::
383 AllocateSharedPtr(dim, face->GetGlobalID(),
384 intPos[0][l], intPos[1][l],
385 intPos[2][l]);
386 curve->m_points.push_back(vert);
387 }
388 }
389
390 curvedFaces[face->GetGlobalID()] = curve;
391 updatedFaces.insert(face->GetGlobalID());
392 }
393 }
394 }
395
396 // Reset geometry information
397 for (i = 0; i < fields.size(); ++i)
398 {
399 fields[i]->Reset();
400 }
401}
ASSERTL1
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode....
Definition: ErrorUtil.hpp:242
Nektar::LibUtilities::Interp2D
void Interp2D(const BasisKey &fbasis0, const BasisKey &fbasis1, const Array< OneD, const NekDouble > &from, const BasisKey &tbasis0, const BasisKey &tbasis1, Array< OneD, NekDouble > &to)
this function interpolates a 2D function evaluated at the quadrature points of the 2D basis,...
Definition: Interp.cpp:101
Nektar::LibUtilities::eNodalTriElec
@ eNodalTriElec
2D Nodal Electrostatic Points on a Triangle
Definition: PointsType.h:81
Nektar::LibUtilities::eGaussLobattoLegendre
@ eGaussLobattoLegendre
1D Gauss-Lobatto-Legendre quadrature points
Definition: PointsType.h:51
Nektar::LibUtilities::eOrtho_A
@ eOrtho_A
Principle Orthogonal Functions .
Definition: BasisType.h:42
Nektar::LibUtilities::eOrtho_B
@ eOrtho_B
Principle Orthogonal Functions .
Definition: BasisType.h:44
Nektar::LibUtilities::eModified_A
@ eModified_A
Principle Modified Functions .
Definition: BasisType.h:48
Nektar::LocalRegions::ExpansionSharedPtr
std::shared_ptr< Expansion > ExpansionSharedPtr
Definition: Expansion.h:66
Nektar::LocalRegions::Expansion3DSharedPtr
std::shared_ptr< Expansion3D > Expansion3DSharedPtr
Definition: Expansion2D.h:47
Nektar::SpatialDomains::CurveSharedPtr
std::shared_ptr< Curve > CurveSharedPtr
Definition: Curve.hpp:58
Nektar::SpatialDomains::CurveMap
std::unordered_map< int, CurveSharedPtr > CurveMap
Definition: Curve.hpp:59
Nektar::SpatialDomains::PointGeomSharedPtr
std::shared_ptr< PointGeom > PointGeomSharedPtr
Definition: Geometry.h:57
Nektar::SpatialDomains::Geometry2DSharedPtr
std::shared_ptr< Geometry2D > Geometry2DSharedPtr
Definition: Geometry.h:62
Nektar::SpatialDomains::Geometry1DSharedPtr
std::shared_ptr< Geometry1D > Geometry1DSharedPtr
Definition: Geometry.h:61
Nektar::SpatialDomains::Geometry3DSharedPtr
std::shared_ptr< Geometry3D > Geometry3DSharedPtr
Definition: Geometry3D.h:50
Nektar::StdRegions::StdExpansion2DSharedPtr
std::shared_ptr< StdExpansion2D > StdExpansion2DSharedPtr
Definition: StdExpansion2D.h:220
Nektar::StdRegions::StdExpansion1DSharedPtr
std::shared_ptr< StdExpansion1D > StdExpansion1DSharedPtr
Definition: StdExpansion1D.h:105
Vmath::Vadd
void Vadd(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Add vector z = x+y.
Definition: Vmath.hpp:180

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL1, Nektar::StdRegions::eBackwards, Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eModified_A, Nektar::LibUtilities::eNodalTriElec, Nektar::LibUtilities::eOrtho_A, Nektar::LibUtilities::eOrtho_B, Nektar::LibUtilities::eTriangle, Nektar::StdRegions::StdExpansion::FwdTrans(), Nektar::LibUtilities::BasisKey::GetNumPoints(), Nektar::LibUtilities::BasisKey::GetPointsType(), Nektar::LibUtilities::Interp2D(), Nektar::StdRegions::StdNodalTriExp::ModalToNodal(), and Vmath::Vadd().

Referenced by Nektar::IterativeElasticSystem::v_DoSolve(), and Nektar::FieldUtils::ProcessDeform::v_Process().

Variable Documentation

◆ MappingSharedPtr

GLOBAL_MAPPING_EXPORT typedef std::shared_ptr<Mapping> Nektar::GlobalMapping::MappingSharedPtr

A shared pointer to a Mapping object.

Definition at line 57 of file Mapping.h.

Referenced by Nektar::GlobalMapping::MappingGeneral::create(), Nektar::GlobalMapping::MappingTranslation::create(), Nektar::GlobalMapping::MappingXofXZ::create(), Nektar::GlobalMapping::MappingXofZ::create(), Nektar::GlobalMapping::MappingXYofXY::create(), Nektar::GlobalMapping::MappingXYofZ::create(), Nektar::FieldUtils::ProcessMapping::GetMapping(), Nektar::FieldUtils::ProcessBodyFittedVelocity::GetVelAndConvertToCartSys(), Nektar::FieldUtils::ProcessGrad::ProcessMappingFld(), Nektar::SolverUtils::DriverAdaptive::v_Execute(), Nektar::FieldUtils::ProcessMapping::v_Process(), Nektar::FieldUtils::ProcessVelocityDivergence::v_Process(), Nektar::FieldUtils::ProcessVorticity::v_Process(), and Nektar::SolverUtils::EquationSystem::WriteFld().

Generated on Wed May 28 2025 19:03:47 for Nektar++ by doxygen 1.9.4