50 namespace SolverUtils {
73 set<int> updatedVerts, updatedEdges, updatedFaces;
75 dim = graph->GetSpaceDimension();
79 for (i = 0; i < fields[0]->GetExpSize(); ++i)
82 int offset = fields[0]->GetPhys_Offset(i);
83 int nquad = exp->GetTotPoints();
87 for (j = 0; j < dim; ++j)
90 nquad, fields[j]->UpdatePhys() + offset);
97 exp->GetCoords(coord[0], coord[1]);
103 for (j = 0; j < exp->GetNedges(); ++j)
108 if (updatedEdges.find(edge->GetGlobalID()) !=
115 int nEdgePts = exp->GetEdgeNumPoints(j);
126 for (k = 0; k < dim; ++k)
130 exp->GetEdgePhysVals(j, seg, phys [k], edgePhys [k]);
131 exp->GetEdgePhysVals(j, seg, coord[k], edgeCoord[k]);
135 for (k = 0; k < 2; ++k)
137 int id = edge->GetVid(k);
138 if (updatedVerts.find(
id) != updatedVerts.end())
147 (*pt)(0) + edgePhys[0][k*(nEdgePts-1)],
148 (*pt)(1) + edgePhys[1][k*(nEdgePts-1)],
151 updatedVerts.insert(
id);
160 for (k = 0; k < nEdgePts; ++k)
165 dim, edge->GetGlobalID(),
166 edgeCoord[0][k] + edgePhys[0][k],
167 edgeCoord[1][k] + edgePhys[1][k], 0.0);
169 curve->m_points.push_back(vert);
172 curvedEdges[edge->GetGlobalID()] =
curve;
173 updatedEdges.insert(edge->GetGlobalID());
178 exp->GetCoords(coord[0], coord[1], coord[2]);
184 for (j = 0; j < exp->GetNfaces(); ++j)
189 if (updatedFaces.find(face->GetGlobalID()) !=
205 "Deformation requires GLL points in both "
206 "directions on a face.");
224 for (k = 0; k < dim; ++k)
228 exp->GetFacePhysVals(
229 j, faceexp, phys [k], tmp, orient);
230 exp->GetFacePhysVals(
231 j, faceexp, coord[k], newPos[k], orient);
233 nq0*nq1, tmp, 1, newPos[k], 1, newPos[k], 1);
238 int nq = max(nq0, nq1);
249 for (k = 0; k < dim; ++k)
253 faceexp->GetPointsKeys()[0],
254 faceexp->GetPointsKeys()[1],
255 newPos[k], edgePts, edgePts, intPos[k]);
258 int edgeOff[2][4][2] = {
273 for (k = 0; k < face->GetNumVerts(); ++k)
276 int id = face->GetVid(k);
280 if (updatedVerts.find(
id) == updatedVerts.end())
285 intPos[0][edgeOff[o][k][0]],
286 intPos[1][edgeOff[o][k][0]],
287 intPos[2][edgeOff[o][k][0]]);
288 updatedVerts.insert(
id);
292 id = face->GetEid(k);
293 if (updatedEdges.find(
id) == updatedEdges.end())
303 const int offset = edgeOff[o][k][0];
304 const int pos = edgeOff[o][k][1];
308 for (l = nq-1; l >= 0; --l)
310 int m = offset + pos*l;
314 dim, edge->GetGlobalID(),
315 intPos[0][m], intPos[1][m],
317 curve->m_points.push_back(vert);
322 for (l = 0; l < nq; ++l)
324 int m = offset + pos*l;
328 dim, edge->GetGlobalID(),
329 intPos[0][m], intPos[1][m],
331 curve->m_points.push_back(vert);
335 curvedEdges[edge->GetGlobalID()] =
curve;
336 updatedEdges.insert(edge->GetGlobalID());
367 for (k = 0; k < dim; ++k)
372 faceexp->GetBasis(0)->GetBasisKey(),
373 faceexp->GetBasis(1)->GetBasisKey(),
374 newPos[k], B0, B1, nodal);
384 for (l = 0; l < nq*(nq+1)/2; ++l)
389 dim, face->GetGlobalID(),
390 newPos[0][l], newPos[1][l], newPos[2][l]);
391 curve->m_points.push_back(vert);
396 for (l = 0; l < nq*nq; ++l)
401 dim, face->GetGlobalID(),
402 intPos[0][l], intPos[1][l], intPos[2][l]);
403 curve->m_points.push_back(vert);
407 curvedFaces[face->GetGlobalID()] =
curve;
408 updatedFaces.insert(face->GetGlobalID());
414 for (i = 0; i < fields.num_elements(); ++i)
void ModalToNodal(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
General purpose memory allocation routines with the ability to allocate from thread specific memory p...
void UpdateGeometry(SpatialDomains::MeshGraphSharedPtr graph, Array< OneD, MultiRegions::ExpListSharedPtr > &fields, bool modal)
Update geometry according to displacement that is in current fields.
Principle Modified Functions .
Geometry2DSharedPtr GetFace(int i)
Return face i in this element.
PointsType GetPointsType() const
Return type of quadrature.
boost::shared_ptr< Curve > CurveSharedPtr
Gauss Radau pinned at x=-1, .
Principle Orthogonal Functions .
Class representing a segment element in reference space.
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...
boost::shared_ptr< StdExpansion2D > StdExpansion2DSharedPtr
int GetNumPoints() const
Return points order at which basis is defined.
boost::shared_ptr< StdExpansion1D > StdExpansion1DSharedPtr
Principle Orthogonal Functions .
Defines a specification for a set of points.
boost::shared_ptr< Expansion > ExpansionSharedPtr
boost::shared_ptr< Geometry2D > Geometry2DSharedPtr
const Geometry1DSharedPtr GetEdge(int i) const
boost::shared_ptr< Geometry1D > Geometry1DSharedPtr
boost::unordered_map< int, CurveSharedPtr > CurveMap
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
boost::shared_ptr< MeshGraph > MeshGraphSharedPtr
Describes the specification for a Basis.
boost::shared_ptr< PointGeom > PointGeomSharedPtr
1D Gauss-Lobatto-Legendre quadrature points
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.
2D Nodal Electrostatic Points on a Triangle
boost::shared_ptr< Geometry3D > Geometry3DSharedPtr
void FwdTrans(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
This function performs the Forward transformation from physical space to coefficient space...