51 : StdExpansion(),
Expansion(pGeom), StdExpansion2D()
61 "Geometric information is not set up");
96 "Need to specify eFactorGJP to construct "
97 "a HelmholtzGJP matrix");
101 factor /= MassMat.Scale();
103 int ntot = MassMat.GetRows() * MassMat.GetColumns();
106 MassMat.GetRawPtr(), 1, &NDTraceMat->GetPtr()[0], 1);
109 MassMat.Scale(), NDTraceMat);
181 int rows = deriv0.GetRows();
182 int cols = deriv1.GetColumns();
187 df[2 * dir][0] * deriv0 + df[2 * dir + 1][0] * deriv1;
253 int rows = derivxi.GetRows();
254 int cols = deriveta.GetColumns();
259 (*WeakDirDeriv) = derivxi + deriveta;
271 (*WeakDirDeriv) = (*WeakDirDeriv) + (*DiveMassmat);
316 int rows = lap00.GetRows();
317 int cols = lap00.GetColumns();
322 (*lap) = gmat[0][0] * lap00 +
323 gmat[1][0] * (lap01 +
Transpose(lap01)) +
348 int rows = LapMat.GetRows();
349 int cols = LapMat.GetColumns();
355 (*helm) = LapMat + factor * MassMat;
371 "Need to specify eFactorGJP to construct "
372 "a HelmholtzGJP matrix");
376 factor /= HelmMat.Scale();
378 int ntot = HelmMat.GetRows() * HelmMat.GetColumns();
381 HelmMat.GetRawPtr(), 1, &NDTraceMat->GetPtr()[0], 1);
384 HelmMat.Scale(), NDTraceMat);
432 int rows = LapMat.GetRows();
433 int cols = LapMat.GetColumns();
439 (*adr) = LapMat - lambda * MassMat + AdvMat;
498 "Need to specify eFactorGJP to construct "
499 "a LinearAdvectionDiffusionReactionGJP matrix");
501 int rows = LapMat.GetRows();
502 int cols = LapMat.GetColumns();
509 LapMat - lambda * MassMat + AdvMat + gjpfactor * NDTraceMat;
587 int rows = stdiprod0.GetRows();
588 int cols = stdiprod1.GetColumns();
593 df[2 * dir][0] * stdiprod0 + df[2 * dir + 1][0] * stdiprod1;
618 "Matrix only setup for quad elements currently");
624 coords[0] = (edge == 0 || edge == 3) ? -1.0 : 1.0;
626 m_Ix =
m_base[(edge + 1) % 2]->GetI(coords);
674 for (
int i = 0; i < nedges; ++i)
680 if (edgeExp->GetRightAdjacentElementExp())
682 if (edgeExp->GetRightAdjacentElementExp()
684 ->GetGlobalID() ==
GetGeom()->GetGlobalID())
696 int nquad_e = min(EdgeExp->GetNumPoints(0),
int(normals[0].size()));
698 int nEdgePts = EdgeExp->GetTotPoints();
700 Vmath::Vmul(nquad_e, normals[0], 1, Fx, 1, edgePhys, 1);
701 Vmath::Vvtvp(nquad_e, normals[1], 1, Fy, 1, edgePhys, 1, edgePhys, 1);
707 if (locExp->GetRightAdjacentElementExp()->GetGeom()->GetGlobalID() ==
728 for (i = 0; i < nedges; ++i)
734 if (edgeExp->GetRightAdjacentElementExp())
736 if (edgeExp->GetRightAdjacentElementExp()
738 ->GetGlobalID() ==
GetGeom()->GetGlobalID())
752 int order_e = map->size();
754 int n_coeffs = EdgeExp->GetNcoeffs();
757 if (n_coeffs != order_e)
759 EdgeExp->FwdTrans(Fn, edgeCoeffs);
771 EdgeExp->GetBasis(0)->GetNumModes(),
772 EdgeExp->GetBasis(0)->GetPointsKey());
774 EdgeExp->GetBasis(0)->GetNumModes(),
775 EdgeExp->GetBasis(0)->GetPointsKey());
779 for (i = order_e; i < n_coeffs; i++)
788 EdgeExp->MassMatrixOp(edgeCoeffs, edgeCoeffs, masskey);
792 EdgeExp->IProductWRTBase(Fn, edgeCoeffs);
806 for (i = 0; i < order_e; ++i)
808 outarray[(*map)[i].index] += (*map)[i].sign * edgeCoeffs[i];
813 int nCoeffs0, nCoeffs1;
827 nCoeffs1 =
m_base[1]->GetNumModes();
829 for (i = 0; i < order_e; ++i)
831 for (j = 0; j < nCoeffs1; j++)
833 outarray[(*map)[i].index + j * order_e] +=
834 mat_gauss->GetPtr()[j] * (*map)[i].sign *
842 nCoeffs0 =
m_base[0]->GetNumModes();
844 for (i = 0; i < order_e; ++i)
846 for (j = 0; j < nCoeffs0; j++)
848 outarray[(*map)[i].index - j] +=
849 mat_gauss->GetPtr()[order_e - 1 - j] *
850 (*map)[i].sign * edgeCoeffs[i];
857 nCoeffs1 =
m_base[1]->GetNumModes();
859 for (i = 0; i < order_e; ++i)
861 for (j = 0; j < nCoeffs1; j++)
863 outarray[(*map)[i].index - j * order_e] +=
864 mat_gauss->GetPtr()[order_e - 1 - j] *
865 (*map)[i].sign * edgeCoeffs[i];
872 nCoeffs0 =
m_base[0]->GetNumModes();
874 for (i = 0; i < order_e; ++i)
876 for (j = 0; j < nCoeffs0; j++)
878 outarray[(*map)[i].index + j] +=
879 mat_gauss->GetPtr()[j] * (*map)[i].sign *
886 ASSERTL0(
false,
"edge value (< 3) is out of range");
899 for (i = 0; i < nedges; ++i)
901 EdgeExp[i]->SetCoeffsToOrientation(
918 int order_e, nquad_e;
922 for (e = 0; e < nedges; ++e)
924 order_e = EdgeExp[e]->GetNcoeffs();
925 nquad_e = EdgeExp[e]->GetNumPoints(0);
932 for (i = 0; i < order_e; ++i)
934 edgeCoeffs[i] = inarray[i + cnt];
938 EdgeExp[e]->BwdTrans(edgeCoeffs, edgePhys);
960 Vmath::Vmul(nquad_e, ncdotMF_e, 1, edgePhys, 1, edgePhys, 1);
964 Vmath::Vmul(nquad_e, normals[dir], 1, edgePhys, 1, edgePhys, 1);
980 for (e = 0; e < nedges; ++e)
982 nquad_e = EdgeExp[e]->GetNumPoints(0);
988 EdgeExp[e]->BwdTrans(edgeCoeffs[e], edgePhys);
990 Vmath::Vmul(nquad_e, normals[dir], 1, edgePhys, 1, edgePhys, 1);
1006 int order_e = EdgeExp->GetNcoeffs();
1007 int nquad_e = EdgeExp->GetNumPoints(0);
1017 StdRegions::VarCoeffMap::const_iterator x;
1020 if ((x = varcoeffs.find(VarCoeff[0])) != varcoeffs.end())
1025 Vmath::Vmul(nquad_e, work, 1, edgePhys, 1, edgePhys, 1);
1028 EdgeExp->IProductWRTBase(edgePhys, coeff);
1031 for (i = 0; i < order_e; ++i)
1033 outarray[map[i]] +=
sign[i] * coeff[i];
1045 ASSERTL0(&inarray[0] != &outarray[0],
1046 "Input and output arrays use the same memory");
1053 for (e = 0; e < nedges; ++e)
1055 order_e = EdgeExp[e]->GetNcoeffs();
1059 Vmath::Vcopy(order_e, tmp = inarray + cnt, 1, edgeCoeffs, 1);
1060 EdgeExp[e]->BwdTrans(edgeCoeffs, edgePhys);
1077 int nquad_e = EdgeExp[edge]->GetNumPoints(0);
1078 int order_e = EdgeExp[edge]->GetNcoeffs();
1107 StdRegions::VarCoeffMap::const_iterator x;
1109 if ((x = varcoeffs.find(VarCoeff[0])) != varcoeffs.end())
1113 x->second.GetValue(), work);
1114 Vmath::Vmul(nquad_e, work, 1, edgePhys, 1, edgePhys, 1);
1120 EdgeExp[edge]->IProductWRTBase(edgePhys, outcoeff);
1122 for (i = 0; i < order_e; ++i)
1124 outarray[emap[i]] +=
sign[i] * tau * outcoeff[i];
1134 for (n = 0; n < coordim; ++n)
1149 Vmath::Vmul(nquad_e, ncdotMF_e, 1, edgePhys, 1, inval, 1);
1153 Vmath::Vmul(nquad_e, normals[n], 1, edgePhys, 1, inval, 1);
1167 EdgeExp[edge]->IProductWRTBase(inval, outcoeff);
1170 for (i = 0; i < ncoeffs; ++i)
1173 for (j = 0; j < order_e; ++j)
1175 tmpcoeff[i] += (*invMass)(i, emap[j]) *
sign[j] * outcoeff[j];
1183 GetMF(n, coordim, varcoeffs);
1193 Coeffs = Coeffs + Dmat * Tmpcoeff;
1197 if (varcoeffs.find(VarCoeff[n]) != varcoeffs.end())
1203 Coeffs = Coeffs + Dmat * Tmpcoeff;
1208 Coeffs = Coeffs + Dmat * Tmpcoeff;
1234 for (
unsigned int i = 0; i < EdgeExp->GetNcoeffs(); ++i)
1236 edgetmp[i] = tmp[emap[i]];
1240 EdgeExp->BwdTrans(edgetmp, outarray);
1260 "HybridDGHelmholtz matrix not set up "
1261 "for non boundary-interior expansions");
1284 DNekMat LocMat(ncoeffs, ncoeffs);
1295 StdRegions::VarCoeffMap::const_iterator x;
1297 for (i = 0; i < coordim; ++i)
1305 GetMF(i, shapedim, varcoeffs);
1326 Mat = Mat + Dmat * invMass *
Transpose(Dmat);
1339 Mat = Mat + DmatL * invMass *
Transpose(DmatR);
1344 Mat = Mat + Dmat * invMass *
Transpose(Dmat);
1350 Mat = Mat + lambdaval * Mass;
1353 for (i = 0; i < nedges; ++i)
1356 order_e = EdgeExp->GetNcoeffs();
1358 int nq = EdgeExp->GetNumPoints(0);
1377 for (j = 0; j < order_e; ++j)
1379 for (k = 0; k < order_e; ++k)
1381 Mat(emap[j], emap[k]) =
1382 Mat(emap[j], emap[k]) +
1420 for (i = 0; i < nedges; ++i)
1428 for (j = 0; j < nbndry; ++j)
1445 for (k = 0; k < ncoeffs; ++k)
1447 Umat(k, j) = Ulam[k];
1493 for (i = 0; i < nedges; ++i)
1515 ASSERTL0(
false,
"Direction not known");
1524 GetMF(dir, shapedim, varcoeffs);
1560 for (j = 0; j < nbndry; ++j)
1566 for (k = 0; k < ncoeffs; ++k)
1568 Ulam[k] = lamToU(k, j);
1586 &(Qmat.GetPtr())[0] + j * ncoeffs, 1);
1594 int order_e, nquad_e;
1599 StdRegions::VarCoeffMap::const_iterator x;
1648 for (i = 0; i < nedges; ++i)
1654 for (i = 0; i < nbndry; ++i)
1662 for (e = 0; e < nedges; ++e)
1664 order_e = EdgeExp[e]->GetNcoeffs();
1665 nquad_e = EdgeExp[e]->GetNumPoints(0);
1682 for (j = 0; j < order_e; ++j)
1684 edgeCoeffs[j] =
sign[j] * (*LamToQ[0])(emap[j], i);
1687 EdgeExp[e]->BwdTrans(edgeCoeffs, edgePhys);
1700 0, e, EdgeExp[e], normals, varcoeffs);
1701 Vmath::Vmul(nquad_e, ncdotMF, 1, edgePhys, 1, work, 1);
1705 Vmath::Vmul(nquad_e, normals[0], 1, edgePhys, 1, work,
1710 for (j = 0; j < order_e; ++j)
1712 edgeCoeffs[j] =
sign[j] * (*LamToQ[1])(emap[j], i);
1715 EdgeExp[e]->BwdTrans(edgeCoeffs, edgePhys);
1730 1, e, EdgeExp[e], normals, varcoeffs);
1731 Vmath::Vvtvp(nquad_e, ncdotMF, 1, edgePhys, 1, work, 1,
1736 Vmath::Vvtvp(nquad_e, normals[1], 1, edgePhys, 1, work,
1743 for (j = 0; j < order_e; ++j)
1745 edgeCoeffs[j] =
sign[j] * (*LamToQ[2])(emap[j], i);
1748 EdgeExp[e]->BwdTrans(edgeCoeffs, edgePhys);
1759 Vmath::Vvtvp(nquad_e, normals[2], 1, edgePhys, 1, work,
1765 for (j = 0; j < order_e; ++j)
1768 sign[j] * LamToU(emap[j], i) - lam[cnt + j];
1771 EdgeExp[e]->BwdTrans(edgeCoeffs, edgePhys);
1774 if ((x = varcoeffs.find(VarCoeff[0])) != varcoeffs.end())
1777 e, EdgeExp[e], x->second.GetValue(), varcoeff_work);
1778 Vmath::Vmul(nquad_e, varcoeff_work, 1, edgePhys, 1,
1782 Vmath::Svtvp(nquad_e, -tau, edgePhys, 1, work, 1, work, 1);
1784 EdgeExp[e]->IProductWRTBase(work, edgeCoeffs);
1786 EdgeExp[e]->SetCoeffsToOrientation(edgedir, edgeCoeffs,
1789 for (j = 0; j < order_e; ++j)
1791 BndMat(cnt + j, i) = edgeCoeffs[j];
1807 LapMat.GetRows(), LapMat.GetColumns());
1837 for (
int d = 0;
d < ncoords; ++
d)
1845 for (
int t = 0; t < ntraces; ++t)
1848 tracepts[t] = traceExp[t]->GetTotPoints();
1849 maxtpts = (maxtpts > tracepts[t]) ? maxtpts : tracepts[t];
1855 for (
int t = 0; t < ntraces; ++t)
1864 PhysDeriv(phys, Deriv[0], Deriv[1], Deriv[2]);
1866 for (
int t = 0; t < ntraces; ++t)
1872 traceExp[t]->GetBasis(0)->GetBasisKey();
1873 bool DoInterp = (fromkey != tokey);
1877 for (
int d = 0;
d < ncoords; ++
d)
1893 tmp = dphidn[t] + i * tracepts[t], 1,
1894 tmp1 = dphidn[t] + i * tracepts[t], 1);
1899 for (
int t = 0; t < ntraces; ++t)
1901 int nt = tracepts[t];
1907 (
p == 1) ? 0.02 * h * h : 0.8 * pow(
p + 1, -4.0) * h * h;
1914 dphidn[t] + j * nt, 1, val, 1);
1916 Mat(i, j) + scale * traceExp[t]->Integral(val);
1924 for (
int j = 0; j < i; ++j)
1926 Mat(i, j) = Mat(j, i);
1933 "This matrix type cannot be generated from this class");
1970 Out_d = InvMass * Coeffs;
1985 "Not set up for non boundary-interior expansions");
1986 ASSERTL1(inoutmat->GetRows() == inoutmat->GetColumns(),
1987 "Assuming that input matrix was square");
1991 int order_e = edgeExp->GetNcoeffs();
2002 DNekScalMat &edgemat = *edgeExp->GetLocMatrix(mkey);
2016 int rows = inoutmat->GetRows();
2031 for (i = 0; i < order_e; ++i)
2033 for (j = 0; j < nbndry; ++j)
2035 if (map[i] == bmap[j])
2041 ASSERTL1(j != nbndry,
"Did not find number in map");
2051 for (i = 0; i < edge; ++i)
2056 for (i = 0; i < order_e; ++i)
2063 switch (edgeExp->GetBasis(0)->GetBasisType())
2066 reverse(map.get(), map.get() + order_e);
2069 reverse(map.get(), map.get() + order_e);
2073 swap(map[0], map[1]);
2074 for (i = 3; i < order_e; i += 2)
2082 "Edge boundary type not valid for this method");
2088 ASSERTL0(
false,
"Could not identify matrix type from dimension");
2091 for (i = 0; i < order_e; ++i)
2094 for (j = 0; j < order_e; ++j)
2097 (*inoutmat)(id1, id2) += edgemat(i, j) *
sign[i] *
sign[j];
2115 "Not set up for non boundary-interior expansions");
2118 int order_e = edgeExp->GetNcoeffs();
2129 DNekScalMat &edgemat = *edgeExp->GetLocMatrix(mkey);
2135 for (i = 0; i < order_e; ++i)
2137 vEdgeCoeffs[i] = incoeffs[map[i]] *
sign[i];
2140 vEdgeCoeffs = edgemat * vEdgeCoeffs;
2142 for (i = 0; i < order_e; ++i)
2144 coeffs[map[i]] += vEdgeCoeffs[i] *
sign[i];
2154 int nVerts, vid1, vid2, vMap1, vMap2;
2161 DNekMat &VertexMat = (*m_vertexmatrix);
2163 for (vid1 = 0; vid1 < nVerts; ++vid1)
2167 for (vid2 = 0; vid2 < nVerts; ++vid2)
2170 VertexValue = (*r_bnd)(vMap1, vMap2);
2171 VertexMat.SetValue(vid1, vid2, VertexValue);
2175 return m_vertexmatrix;
2195 map<int, int> invmap;
2196 for (j = 0; j < nBndCoeffs; ++j)
2198 invmap[bmap[j]] = j;
2214 for (n = 0; n < nEdgeCoeffs; ++n)
2216 edgemaparray[n] = invmap[maparray[n]];
2219 return edgemaparray;
2229 [[maybe_unused]]
const int nq1)
2231 if (idmap.size() != nq0)
2239 for (
int i = 0; i < nq0; ++i)
2247 for (
int i = 0; i < nq0; ++i)
2249 idmap[i] = nq0 - 1 - i;
2254 ASSERTL0(
false,
"Unknown orientation");
2265 int nquad_e = EdgeExp_e->GetNumPoints(0);
2267 int nquad0 =
m_base[0]->GetNumPoints();
2268 int nquad1 =
m_base[1]->GetNumPoints();
2269 int nqtot = nquad0 * nquad1;
2281 StdRegions::VarCoeffMap::const_iterator MFdir;
2286 for (
int k = 0; k < coordim; k++)
2288 MFdir = varcoeffs.find(MMFCoeffs[dir * 5 + k]);
2289 tmp = MFdir->second.GetValue();
2293 Vmath::Vvtvp(nquad_e, &tmp_e[0], 1, &normals[k][0], 1, &ncdotMF[0], 1,
2308 Vmath::Vmul(nq, &vec[0][0], 1, &normals[0][0], 1, &Fn[0], 1);
2309 Vmath::Vvtvp(nq, &vec[1][0], 1, &normals[1][0], 1, &Fn[0], 1, &Fn[0], 1);
2310 Vmath::Vvtvp(nq, &vec[2][0], 1, &normals[2][0], 1, &Fn[0], 1, &Fn[0], 1);
2312 return StdExpansion::Integral(Fn);
2319 int nverts = geom->GetNumVerts();
2327 *geom->
GetVertex((traceid + (nverts - 1)) % nverts);
2339 h =
sqrt(h1 * h1 - d1 * d1 / lenDx);
2344 h1 = ev1.
dist(vadj1);
2345 Dx1.
Sub(vadj1, ev1);
2348 h = (h +
sqrt(h1 * h1 - d1 * d1 / lenDx)) * 0.5;
2350 int dirn = (geom->GetDir(traceid) == 0) ? 1 : 0;
#define ASSERTL0(condition, msg)
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode....
#define ASSERTL2(condition, msg)
Assert Level 2 – Debugging which is used FULLDEBUG compilation mode. This level assert is designed to...
#define sign(a, b)
return the sign(b)*a
Describes the specification for a Basis.
void v_AddEdgeNormBoundaryInt(const int edge, const ExpansionSharedPtr &EdgeExp, const Array< OneD, const NekDouble > &Fx, const Array< OneD, const NekDouble > &Fy, Array< OneD, NekDouble > &outarray) override
DNekMatSharedPtr v_GenMatrix(const StdRegions::StdMatrixKey &mkey) override
std::vector< bool > m_requireNeg
void v_AddRobinTraceContribution(const int traceid, const Array< OneD, const NekDouble > &primCoeffs, const Array< OneD, NekDouble > &incoeffs, Array< OneD, NekDouble > &coeffs) override
void v_SetUpPhysNormals(const int edge) override
void v_AddRobinMassMatrix(const int edgeid, const Array< OneD, const NekDouble > &primCoeffs, DNekMatSharedPtr &inoutmat) override
Array< OneD, NekDouble > GetnEdgecdotMF(const int dir, const int edge, ExpansionSharedPtr &EdgeExp_e, const Array< OneD, const Array< OneD, NekDouble > > &normals, const StdRegions::VarCoeffMap &varcoeffs)
void SetTraceToGeomOrientation(Array< OneD, ExpansionSharedPtr > &EdgeExp, Array< OneD, NekDouble > &inout)
DNekMatSharedPtr v_BuildVertexMatrix(const DNekScalMatSharedPtr &r_bnd) override
NekDouble v_VectorFlux(const Array< OneD, Array< OneD, NekDouble > > &vec) override
DNekScalMatSharedPtr CreateMatrix(const MatrixKey &mkey)
Array< OneD, unsigned int > GetTraceInverseBoundaryMap(int eid)
void v_ReOrientTracePhysMap(const StdRegions::Orientation orient, Array< OneD, int > &idmap, const int nq0, const int nq1) override
Expansion2D(SpatialDomains::Geometry2DSharedPtr pGeom)
void AddNormTraceInt(const int dir, Array< OneD, ExpansionSharedPtr > &EdgeExp, Array< OneD, Array< OneD, NekDouble > > &edgeCoeffs, Array< OneD, NekDouble > &outarray)
SpatialDomains::Geometry2DSharedPtr GetGeom2D() const
void AddHDGHelmholtzEdgeTerms(const NekDouble tau, const int edge, Array< OneD, ExpansionSharedPtr > &EdgeExp, Array< OneD, NekDouble > &edgePhys, const StdRegions::VarCoeffMap &dirForcing, Array< OneD, NekDouble > &outarray)
void v_DGDeriv(const int dir, const Array< OneD, const NekDouble > &incoeffs, Array< OneD, ExpansionSharedPtr > &EdgeExp, Array< OneD, Array< OneD, NekDouble > > &edgeCoeffs, Array< OneD, NekDouble > &out_d) override
void v_TraceNormLen(const int traceid, NekDouble &h, NekDouble &p) override
void GetPhysEdgeVarCoeffsFromElement(const int edge, ExpansionSharedPtr &EdgeExp, const Array< OneD, const NekDouble > &varcoeff, Array< OneD, NekDouble > &outarray)
void AddEdgeBoundaryInt(const int edge, ExpansionSharedPtr &EdgeExp, Array< OneD, NekDouble > &edgePhys, Array< OneD, NekDouble > &outarray, const StdRegions::VarCoeffMap &varcoeffs=StdRegions::NullVarCoeffMap)
void AddHDGHelmholtzTraceTerms(const NekDouble tau, const Array< OneD, const NekDouble > &inarray, Array< OneD, ExpansionSharedPtr > &EdgeExp, const StdRegions::VarCoeffMap &dirForcing, Array< OneD, NekDouble > &outarray)
void v_GenTraceExp(const int traceid, ExpansionSharedPtr &exp) override
SpatialDomains::GeometrySharedPtr GetGeom() const
SpatialDomains::GeometrySharedPtr m_geom
void DropLocMatrix(const LocalRegions::MatrixKey &mkey)
ExpansionSharedPtr GetLeftAdjacentElementExp() const
DNekMatSharedPtr BuildVertexMatrix(const DNekScalMatSharedPtr &r_bnd)
void ComputeGmatcdotMF(const Array< TwoD, const NekDouble > &df, const Array< OneD, const NekDouble > &direction, Array< OneD, Array< OneD, NekDouble > > &dfdir)
virtual void v_ComputeTraceNormal(const int id)
Array< OneD, NekDouble > GetMFMag(const int dir, const StdRegions::VarCoeffMap &varcoeffs)
int GetLeftAdjacentElementTrace() const
void GetTracePhysVals(const int trace, const StdRegions::StdExpansionSharedPtr &TraceExp, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, StdRegions::Orientation orient=StdRegions::eNoOrientation)
std::map< int, ExpansionWeakPtr > m_traceExp
void AddEdgeNormBoundaryInt(const int edge, const std::shared_ptr< Expansion > &EdgeExp, const Array< OneD, const NekDouble > &Fx, const Array< OneD, const NekDouble > &Fy, Array< OneD, NekDouble > &outarray)
SpatialDomains::GeomFactorsSharedPtr m_metricinfo
virtual StdRegions::Orientation v_GetTraceOrient(int trace)
ExpansionSharedPtr GetTraceExp(const int traceid)
StdRegions::Orientation GetTraceOrient(int trace)
IndexMapValuesSharedPtr GetIndexMap(const IndexMapKey &ikey)
DNekScalMatSharedPtr GetLocMatrix(const LocalRegions::MatrixKey &mkey)
Array< OneD, NekDouble > GetMFDiv(const int dir, const StdRegions::VarCoeffMap &varcoeffs)
void TraceNormLen(const int traceid, NekDouble &h, NekDouble &p)
const NormalVector & GetTraceNormal(const int id)
Array< OneD, NekDouble > GetMF(const int dir, const int shapedim, const StdRegions::VarCoeffMap &varcoeffs)
static std::shared_ptr< DataType > AllocateSharedPtr(const Args &...args)
Allocate a shared pointer from the memory pool.
PointGeomSharedPtr GetVertex(int i) const
Returns vertex i of this object.
void Sub(PointGeom &a, PointGeom &b)
NekDouble dot(PointGeom &a)
retun the dot product between this and input a
NekDouble dist(PointGeom &a)
return distance between this and input a
void GetBoundaryMap(Array< OneD, unsigned int > &outarray)
int GetNcoeffs(void) const
This function returns the total number of coefficients used in the expansion.
int GetTotPoints() const
This function returns the total number of quadrature points used in the element.
void FillMode(const int mode, Array< OneD, NekDouble > &outarray)
This function fills the array outarray with the mode-th mode of the expansion.
int NumBndryCoeffs(void) const
DNekMatSharedPtr GetStdMatrix(const StdMatrixKey &mkey)
const LibUtilities::PointsKeyVector GetPointsKeys() const
int NumDGBndryCoeffs(void) const
DNekScalBlkMatSharedPtr GetLocStaticCondMatrix(const LocalRegions::MatrixKey &mkey)
const LibUtilities::BasisKey GetTraceBasisKey(const int i, int k=-1) const
This function returns the basis key belonging to the i-th trace.
int GetVertexMap(const int localVertexId, bool useCoeffPacking=false)
void IProductWRTBase(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
this function calculates the inner product of a given function f with the different modes of the expa...
int GetNtraces() const
Returns the number of trace elements connected to this element.
int GetNverts() const
This function returns the number of vertices of the expansion domain.
void GetTraceToElementMap(const int tid, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray, Orientation traceOrient=eForwards, int P=-1, int Q=-1)
LibUtilities::ShapeType DetShapeType() const
This function returns the shape of the expansion domain.
void GetTraceInteriorToElementMap(const int tid, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray, const Orientation traceOrient=eForwards)
int GetTraceNcoeffs(const int i) const
This function returns the number of expansion coefficients belonging to the i-th trace.
DNekMatSharedPtr GenMatrix(const StdMatrixKey &mkey)
void FwdTrans(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
This function performs the Forward transformation from physical space to coefficient space.
LibUtilities::NekManager< StdMatrixKey, DNekMat, StdMatrixKey::opLess > m_stdMatrixManager
int GetBasisNumModes(const int dir) const
This function returns the number of expansion modes in the dir direction.
void PhysDeriv(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_d0, Array< OneD, NekDouble > &out_d1=NullNekDouble1DArray, Array< OneD, NekDouble > &out_d2=NullNekDouble1DArray)
Array< OneD, LibUtilities::BasisSharedPtr > m_base
bool IsBoundaryInteriorExpansion() const
LibUtilities::ShapeType GetShapeType() const
const VarCoeffMap & GetVarCoeffs() const
MatrixType GetMatrixType() const
bool HasVarCoeff(const StdRegions::VarCoeffType &coeff) const
const ConstFactorMap & GetConstFactors() const
const Array< OneD, const NekDouble > & GetVarCoeff(const StdRegions::VarCoeffType &coeff) const
NekDouble GetConstFactor(const ConstFactorType &factor) const
bool ConstFactorExists(const ConstFactorType &factor) const
const VarCoeffMap GetVarCoeffAsMap(const VarCoeffType &coeff) const
void Interp1D(const BasisKey &fbasis0, const Array< OneD, const NekDouble > &from, const BasisKey &tbasis0, Array< OneD, NekDouble > &to)
this function interpolates a 1D function evaluated at the quadrature points of the basis fbasis0 to ...
void InterpCoeff1D(const BasisKey &fbasis0, const Array< OneD, const NekDouble > &from, const BasisKey &tbasis0, Array< OneD, NekDouble > &to)
std::vector< PointsKey > PointsKeyVector
@ eGauss_Lagrange
Lagrange Polynomials using the Gauss points.
@ eGLL_Lagrange
Lagrange for SEM basis .
@ eModified_A
Principle Modified Functions .
std::shared_ptr< Expansion > ExpansionSharedPtr
std::shared_ptr< IndexMapValues > IndexMapValuesSharedPtr
std::shared_ptr< Expansion1D > Expansion1DSharedPtr
@ eNoGeomType
No type defined.
@ eDeformed
Geometry is curved or has non-constant factors.
std::shared_ptr< Geometry2D > Geometry2DSharedPtr
std::shared_ptr< Geometry > GeometrySharedPtr
@ eLinearAdvectionDiffusionReaction
@ eLinearAdvectionDiffusionReactionGJP
@ eInvLaplacianWithUnityMean
std::map< ConstFactorType, NekDouble > ConstFactorMap
static ConstFactorMap NullConstFactorMap
static VarCoeffMap NullVarCoeffMap
std::map< StdRegions::VarCoeffType, VarCoeffEntry > VarCoeffMap
std::vector< double > d(NPUPPER *NPUPPER)
StdRegions::ConstFactorMap factors
std::shared_ptr< DNekScalMat > DNekScalMatSharedPtr
std::shared_ptr< DNekScalBlkMat > DNekScalBlkMatSharedPtr
static Array< OneD, NekDouble > NullNekDouble1DArray
NekMatrix< InnerMatrixType, BlockMatrixTag > Transpose(NekMatrix< InnerMatrixType, BlockMatrixTag > &rhs)
std::shared_ptr< DNekMat > DNekMatSharedPtr
void Vmul(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Multiply vector z = x*y.
void Svtvp(int n, const T alpha, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Svtvp (scalar times vector plus vector): z = alpha*x + y.
void Neg(int n, T *x, const int incx)
Negate x = -x.
void Vvtvp(int n, const T *w, const int incw, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
vvtvp (vector times vector plus vector): z = w*x + y
void Zero(int n, T *x, const int incx)
Zero vector.
void Fill(int n, const T alpha, T *x, const int incx)
Fill a vector with a constant value.
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
scalarT< T > sqrt(scalarT< T > in)