35 #include <boost/core/ignore_unused.hpp>
49 StdTriExp::StdTriExp()
56 Ba.GetNumModes(), Bb.GetNumModes()),
59 Ba.GetNumModes(), Bb.GetNumModes()),
63 "order in 'a' direction is higher than order "
81 int nquad1 =
m_base[1]->GetNumPoints();
90 case LibUtilities::eGaussRadauMAlpha1Beta0:
99 for (i = 0; i < nquad1; ++i)
101 w1_tmp[i] = 0.5 * (1 - z1[i]) * w1[i];
131 boost::ignore_unused(out_d2);
134 int nquad0 =
m_base[0]->GetNumPoints();
135 int nquad1 =
m_base[1]->GetNumPoints();
145 if (out_d0.size() > 0)
149 for (i = 0; i < nquad1; ++i)
151 Blas::Dscal(nquad0, wsp[i], &out_d0[0] + i * nquad0, 1);
155 if (out_d1.size() > 0)
161 for (i = 0; i < nquad1; ++i)
163 Vmath::Vvtvp(nquad0, &wsp[0], 1, &out_d0[0] + i * nquad0, 1,
164 &out_d1[0] + i * nquad0, 1,
165 &out_d1[0] + i * nquad0, 1);
169 else if (out_d1.size() > 0)
174 for (i = 0; i < nquad1; ++i)
176 Blas::Dscal(nquad0, wsp[i], &diff0[0] + i * nquad0, 1);
182 for (i = 0; i < nquad1; ++i)
184 Vmath::Vvtvp(nquad0, &wsp[0], 1, &diff0[0] + i * nquad0, 1,
185 &out_d1[0] + i * nquad0, 1, &out_d1[0] + i * nquad0,
209 ASSERTL1(
false,
"input dir is out of range");
220 boost::ignore_unused(out_d2);
250 m_base[1]->GetNumModes());
261 bool doCheckCollDir0,
bool doCheckCollDir1)
263 boost::ignore_unused(doCheckCollDir0, doCheckCollDir1);
267 int nquad0 =
m_base[0]->GetNumPoints();
268 int nquad1 =
m_base[1]->GetNumPoints();
269 int nmodes0 =
m_base[0]->GetNumModes();
270 int nmodes1 =
m_base[1]->GetNumModes();
272 ASSERTL1(wsp.size() >= nquad0 * nmodes1,
273 "Workspace size is not sufficient");
276 "Basis[1] is not of general tensor type");
278 for (i = mode = 0; i < nmodes0; ++i)
280 Blas::Dgemv(
'N', nquad1, nmodes1 - i, 1.0, base1.get() + mode * nquad1,
281 nquad1, &inarray[0] + mode, 1, 0.0, &wsp[0] + i * nquad1,
289 Blas::Daxpy(nquad1, inarray[1], base1.get() + nquad1, 1,
290 &wsp[0] + nquad1, 1);
293 Blas::Dgemm(
'N',
'T', nquad0, nquad1, nmodes0, 1.0, base0.get(), nquad0,
294 &wsp[0], nquad1, 0.0, &outarray[0], nquad0);
310 out = (*matsys) * in;
318 int npoints[2] = {
m_base[0]->GetNumPoints(),
m_base[1]->GetNumPoints()};
319 int nmodes[2] = {
m_base[0]->GetNumModes(),
m_base[1]->GetNumModes()};
321 fill(outarray.get(), outarray.get() +
m_ncoeffs, 0.0);
325 for (i = 0; i < 3; i++)
331 for (i = 0; i < npoints[0]; i++)
333 physEdge[0][i] = inarray[i];
336 for (i = 0; i < npoints[1]; i++)
338 physEdge[1][i] = inarray[npoints[0] - 1 + i * npoints[0]];
340 inarray[(npoints[1] - 1) * npoints[0] - i * npoints[0]];
345 m_base[0]->GetBasisKey()),
347 m_base[1]->GetBasisKey())};
353 for (i = 0; i < 3; i++)
355 segexp[i != 0]->FwdTransBndConstrained(physEdge[i], coeffEdge[i]);
358 for (j = 0; j < nmodes[i != 0]; j++)
361 outarray[mapArray[j]] =
sign * coeffEdge[i][j];
381 int nInteriorDofs =
m_ncoeffs - nBoundaryDofs;
388 for (i = 0; i < nInteriorDofs; i++)
390 rhs[i] = tmp1[mapArray[i]];
393 Blas::Dgemv(
'N', nInteriorDofs, nInteriorDofs, 1.0, &(matsys->GetPtr())[0],
394 nInteriorDofs, rhs.get(), 1, 0.0, result.get(), 1);
396 for (i = 0; i < nInteriorDofs; i++)
398 outarray[mapArray[i]] = result[i];
459 inarray.get(), 1, 0.0, outarray.get(), 1);
466 int nquad0 =
m_base[0]->GetNumPoints();
467 int nquad1 =
m_base[1]->GetNumPoints();
468 int order0 =
m_base[0]->GetNumModes();
470 if (multiplybyweights)
478 m_base[1]->GetBdata(), tmp, outarray, wsp);
484 m_base[1]->GetBdata(), inarray, outarray,
494 bool doCheckCollDir0,
bool doCheckCollDir1)
496 boost::ignore_unused(doCheckCollDir0, doCheckCollDir1);
500 int nquad0 =
m_base[0]->GetNumPoints();
501 int nquad1 =
m_base[1]->GetNumPoints();
502 int nmodes0 =
m_base[0]->GetNumModes();
503 int nmodes1 =
m_base[1]->GetNumModes();
505 ASSERTL1(wsp.size() >= nquad1 * nmodes0,
506 "Workspace size is not sufficient");
508 Blas::Dgemm(
'T',
'N', nquad1, nmodes0, nquad0, 1.0, inarray.get(), nquad0,
509 base0.get(), nquad0, 0.0, wsp.get(), nquad1);
512 for (mode = i = 0; i < nmodes0; ++i)
514 Blas::Dgemv(
'T', nquad1, nmodes1 - i, 1.0, base1.get() + mode * nquad1,
515 nquad1, wsp.get() + i * nquad1, 1, 0.0,
516 outarray.get() + mode, 1);
524 Blas::Ddot(nquad1, base1.get() + nquad1, 1, wsp.get() + nquad1, 1);
556 ASSERTL1(
false,
"input dir is out of range");
565 inarray.get(), 1, 0.0, outarray.get(), 1);
573 int nquad0 =
m_base[0]->GetNumPoints();
574 int nquad1 =
m_base[1]->GetNumPoints();
575 int nqtot = nquad0 * nquad1;
576 int nmodes0 =
m_base[0]->GetNumModes();
577 int wspsize = max(max(nqtot,
m_ncoeffs), nquad1 * nmodes0);
585 for (i = 0; i < nquad1; ++i)
587 gfac0[i] = 2.0 / (1 - z1[i]);
590 for (i = 0; i < nquad1; ++i)
592 Vmath::Smul(nquad0, gfac0[i], &inarray[0] + i * nquad0, 1,
593 &tmp0[0] + i * nquad0, 1);
603 m_base[1]->GetBdata(), tmp0, outarray,
612 for (i = 0; i < nquad0; ++i)
614 gfac0[i] = 0.5 * (1 + z0[i]);
617 for (i = 0; i < nquad1; ++i)
619 Vmath::Vmul(nquad0, &gfac0[0], 1, &tmp0[0] + i * nquad0, 1,
620 &tmp0[0] + i * nquad0, 1);
624 m_base[1]->GetBdata(), tmp0, tmp3,
629 m_base[1]->GetDbdata(), tmp0, outarray,
637 ASSERTL1(
false,
"input dir is out of range");
662 eta[0] = 2. * (1. + xi[0]) / d1 - 1.0;
669 xi[0] = (1.0 + eta[0]) * (1.0 - eta[1]) * 0.5 - 1.0;
676 int nquad0 =
m_base[0]->GetNumPoints();
677 int nquad1 =
m_base[1]->GetNumPoints();
678 int order0 =
m_base[0]->GetNumModes();
679 int order1 =
m_base[1]->GetNumModes();
685 "total expansion order");
688 for (i = 0; i < order0; ++i, m += order1 - i)
704 for (i = 0; i < nquad1; ++i)
707 &outarray[0] + i * nquad0, 1);
711 for (i = 0; i < nquad0; ++i)
714 &outarray[0] + i, nquad0, &outarray[0] + i, nquad0);
726 const int nm1 =
m_base[1]->GetNumModes();
727 const double c = 1 + 2 * nm1;
728 const int mode0 = floor(0.5 * (c -
sqrt(c * c - 8 * mode)));
733 return StdExpansion::BaryEvaluateBasis<1>(coll[1], 1);
737 return StdExpansion::BaryEvaluateBasis<0>(coll[0], mode0) *
738 StdExpansion::BaryEvaluateBasis<1>(coll[1], mode);
760 "BasisType is not a boundary interior form");
762 "BasisType is not a boundary interior form");
770 "BasisType is not a boundary interior form");
772 "BasisType is not a boundary interior form");
779 ASSERTL2(i >= 0 && i <= 2,
"edge id is out of range");
793 ASSERTL2((i >= 0) && (i <= 2),
"edge id is out of range");
806 const std::vector<unsigned int> &nummodes,
int &modes_offset)
809 nummodes[modes_offset], nummodes[modes_offset + 1]);
819 boost::ignore_unused(coords_2);
827 for (i = 0; i < nq1; ++i)
829 for (j = 0; j < nq0; ++j)
831 coords_0[i * nq0 + j] = (1 + z0[j]) * (1 - z1[i]) / 2.0 - 1.0;
833 Vmath::Fill(nq0, z1[i], &coords_1[0] + i * nq0, 1);
846 boost::ignore_unused(j);
847 ASSERTL2(i >= 0 && i <= 2,
"edge id is out of range");
861 case LibUtilities::eGaussRadauMAlpha1Beta0:
920 "Unexpected points distribution " +
923 " in StdTriExp::v_GetTraceBasisKey");
930 "Information not available to set edge key");
945 "Mapping not defined for this type of basis");
948 if (useCoeffPacking ==
true)
950 switch (localVertexId)
964 localDOF =
m_base[1]->GetNumModes();
969 ASSERTL0(
false,
"eid must be between 0 and 2");
976 switch (localVertexId)
985 localDOF =
m_base[1]->GetNumModes();
995 ASSERTL0(
false,
"eid must be between 0 and 2");
1008 "Expansion not of a proper type");
1012 int nummodes0, nummodes1;
1019 nummodes0 =
m_base[0]->GetNumModes();
1020 nummodes1 =
m_base[1]->GetNumModes();
1022 startvalue = 2 * nummodes1;
1024 for (i = 0; i < nummodes0 - 2; i++)
1026 for (j = 0; j < nummodes1 - 3 - i; j++)
1028 outarray[cnt++] = startvalue + j;
1030 startvalue += nummodes1 - 2 - i;
1038 "Expansion not of expected type");
1041 int nummodes0, nummodes1;
1049 nummodes0 =
m_base[0]->GetNumModes();
1050 nummodes1 =
m_base[1]->GetNumModes();
1052 value = 2 * nummodes1 - 1;
1053 for (i = 0; i < value; i++)
1059 for (i = 0; i < nummodes0 - 2; i++)
1061 outarray[cnt++] = value;
1062 value += nummodes1 - 2 - i;
1072 "Mapping not defined for this type of basis");
1074 ASSERTL1(eid < 3,
"eid must be between 0 and 2");
1077 int order0 =
m_base[0]->GetNumModes();
1078 int order1 =
m_base[1]->GetNumModes();
1079 int numModes = (eid == 0) ? order0 : order1;
1081 if (maparray.size() != numModes)
1091 for (i = 0; i < numModes; cnt += order1 - i, ++i)
1099 maparray[0] = order1;
1101 for (i = 2; i < numModes; i++)
1103 maparray[i] = order1 - 1 + i;
1109 for (i = 0; i < numModes; i++)
1116 ASSERTL0(
false,
"eid must be between 0 and 2");
1127 "Mapping not defined for this type of basis");
1129 const int nummodes1 =
m_base[1]->GetNumModes();
1132 if (maparray.size() != nEdgeIntCoeffs)
1137 if (signarray.size() != nEdgeIntCoeffs)
1143 fill(signarray.get(), signarray.get() + nEdgeIntCoeffs, 1);
1150 int cnt = 2 * nummodes1 - 1;
1151 for (i = 0; i < nEdgeIntCoeffs; cnt += nummodes1 - 2 - i, ++i)
1159 for (i = 0; i < nEdgeIntCoeffs; i++)
1161 maparray[i] = nummodes1 + 1 + i;
1167 for (i = 0; i < nEdgeIntCoeffs; i++)
1169 maparray[i] = 2 + i;
1175 ASSERTL0(
false,
"eid must be between 0 and 2");
1182 for (i = 1; i < nEdgeIntCoeffs; i += 2)
1206 nq0 =
m_base[0]->GetNumPoints();
1207 nq1 =
m_base[1]->GetNumPoints();
1228 for (
int i = 0; i < nq; ++i)
1230 for (
int j = 0; j < nq - i; ++j, ++cnt)
1233 coords[cnt][0] = -1.0 + 2 * j / (
NekDouble)(nq - 1);
1234 coords[cnt][1] = -1.0 + 2 * i / (
NekDouble)(nq - 1);
1238 for (
int i = 0; i < neq; ++i)
1242 I[0] =
m_base[0]->GetI(coll);
1243 I[1] =
m_base[1]->GetI(coll + 1);
1246 for (
int j = 0; j < nq1; ++j)
1252 Mat->GetRawPtr() + j * nq0 * neq + i, neq);
1316 int qa =
m_base[0]->GetNumPoints();
1317 int qb =
m_base[1]->GetNumPoints();
1318 int nmodes_a =
m_base[0]->GetNumModes();
1319 int nmodes_b =
m_base[1]->GetNumModes();
1332 OrthoExp.
FwdTrans(array, orthocoeffs);
1343 for (
int j = 0; j < nmodes_a; ++j)
1345 for (
int k = 0; k < nmodes_b - j; ++k, ++cnt)
1348 pow((1.0 * j) / (nmodes_a - 1), cutoff * nmodes_a),
1349 pow((1.0 * k) / (nmodes_b - 1), cutoff * nmodes_b));
1351 orthocoeffs[cnt] *= (SvvDiffCoeff * fac);
1362 max_ab = max(max_ab, 0);
1366 for (
int j = 0; j < nmodes_a; ++j)
1368 for (
int k = 0; k < nmodes_b - j; ++k, ++cnt)
1370 int maxjk = max(j, k);
1373 orthocoeffs[cnt] *= SvvDiffCoeff *
kSVVDGFilter[max_ab][maxjk];
1382 min(nmodes_a, nmodes_b));
1385 int nmodes = min(nmodes_a, nmodes_b);
1390 for (
int j = 0; j < nmodes_a; ++j)
1392 for (
int k = 0; k < nmodes_b - j; ++k)
1394 if (j + k >= cutoff)
1398 exp(-(j + k - nmodes) * (j + k - nmodes) /
1399 ((
NekDouble)((j + k - cutoff + epsilon) *
1400 (j + k - cutoff + epsilon)))));
1404 orthocoeffs[cnt] *= 0.0;
1412 OrthoExp.
BwdTrans(orthocoeffs, array);
1419 int n_coeffs = inarray.size();
1420 int nquad0 =
m_base[0]->GetNumPoints();
1421 int nquad1 =
m_base[1]->GetNumPoints();
1426 int nqtot = nquad0 * nquad1;
1429 int nmodes0 =
m_base[0]->GetNumModes();
1430 int nmodes1 =
m_base[1]->GetNumModes();
1431 int numMin2 = nmodes0;
1452 m_TriExp->BwdTrans(inarray, phys_tmp);
1453 m_OrthoTriExp->FwdTrans(phys_tmp, coeff);
1455 for (i = 0; i < n_coeffs; i++)
1460 numMin += numMin2 - 1;
1465 m_OrthoTriExp->BwdTrans(coeff, phys_tmp);
1466 m_TriExp->FwdTrans(phys_tmp, outarray);
1475 if (inarray.get() == outarray.get())
1481 m_ncoeffs, tmp.get(), 1, 0.0, outarray.get(), 1);
1486 m_ncoeffs, inarray.get(), 1, 0.0, outarray.get(), 1);
1499 int nquad0 =
m_base[0]->GetNumPoints();
1500 int nquad1 =
m_base[1]->GetNumPoints();
1507 for (i = 0; i < nquad1; ++i)
1509 Vmath::Vmul(nquad0, inarray.get() + i * nquad0, 1, w0.get(), 1,
1510 outarray.get() + i * nquad0, 1);
1516 case LibUtilities::eGaussRadauMAlpha1Beta0:
1517 for (i = 0; i < nquad1; ++i)
1519 Blas::Dscal(nquad0, 0.5 * w1[i], outarray.get() + i * nquad0,
1525 for (i = 0; i < nquad1; ++i)
1528 outarray.get() + i * nquad0, 1);
1537 boost::ignore_unused(standard);
1539 int np1 =
m_base[0]->GetNumPoints();
1540 int np2 =
m_base[1]->GetNumPoints();
1541 int np = max(np1, np2);
1548 for (
int i = 0; i < np - 1; ++i)
1551 for (
int j = 0; j < np - i - 2; ++j)
1553 conn[cnt++] = row + j;
1554 conn[cnt++] = row + j + 1;
1555 conn[cnt++] = rowp1 + j;
1557 conn[cnt++] = rowp1 + j + 1;
1558 conn[cnt++] = rowp1 + j;
1559 conn[cnt++] = row + j + 1;
1562 conn[cnt++] = row + np - i - 2;
1563 conn[cnt++] = row + np - i - 1;
1564 conn[cnt++] = rowp1 + np - i - 2;
#define ASSERTL0(condition, msg)
#define NEKERROR(type, msg)
Assert Level 0 – Fundamental assert which is used whether in FULLDEBUG, DEBUG or OPT compilation mode...
#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.
int GetNumModes() const
Returns the order of the basis.
Defines a specification for a set of points.
static std::shared_ptr< DataType > AllocateSharedPtr(const Args &...args)
Allocate a shared pointer from the memory pool.
void PhysTensorDeriv(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray_d0, Array< OneD, NekDouble > &outarray_d1)
Calculate the 2D derivative in the local tensor/collapsed coordinate at the physical points.
NekDouble Integral(const Array< OneD, const NekDouble > &inarray, const Array< OneD, const NekDouble > &w0, const Array< OneD, const NekDouble > &w1)
void BwdTrans_SumFacKernel(const Array< OneD, const NekDouble > &base0, const Array< OneD, const NekDouble > &base1, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, Array< OneD, NekDouble > &wsp, bool doCheckCollDir0=true, bool doCheckCollDir1=true)
virtual void v_HelmholtzMatrixOp_MatFree(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey)
virtual void v_LaplacianMatrixOp_MatFree(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey)
void IProductWRTBase_SumFacKernel(const Array< OneD, const NekDouble > &base0, const Array< OneD, const NekDouble > &base1, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, Array< OneD, NekDouble > &wsp, bool doCheckCollDir0=true, bool doCheckCollDir1=true)
The base class for all shapes.
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.
const LibUtilities::BasisSharedPtr & GetBasis(int dir) const
This function gets the shared point to basis in the dir direction.
void WeakDerivMatrixOp_MatFree(const int i, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
LibUtilities::BasisType GetBasisType(const int dir) const
This function returns the type of basis used in the dir direction.
int NumBndryCoeffs(void) const
DNekMatSharedPtr GetStdMatrix(const StdMatrixKey &mkey)
void LocCoordToLocCollapsed(const Array< OneD, const NekDouble > &xi, Array< OneD, NekDouble > &eta)
Convert local cartesian coordinate xi into local collapsed coordinates eta.
void MassMatrixOp(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
DNekMatSharedPtr CreateGeneralMatrix(const StdMatrixKey &mkey)
this function generates the mass matrix
void LaplacianMatrixOp_MatFree(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
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 BwdTrans(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
This function performs the Backward transformation from coefficient space to physical space.
int GetTraceNcoeffs(const int i) const
This function returns the number of expansion coefficients belonging to the i-th trace.
LibUtilities::PointsType GetPointsType(const int dir) const
This function returns the type of quadrature points used in the dir direction.
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, DNekBlkMat, StdMatrixKey::opLess > m_stdStaticCondMatrixManager
int GetNumPoints(const int dir) const
This function returns the number of quadrature points in the dir direction.
void MultiplyByQuadratureMetric(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
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.
Array< OneD, LibUtilities::BasisSharedPtr > m_base
void MassMatrixOp_MatFree(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
MatrixType GetMatrixType() const
NekDouble GetConstFactor(const ConstFactorType &factor) const
bool ConstFactorExists(const ConstFactorType &factor) const
virtual void v_GetCoords(Array< OneD, NekDouble > &coords_x, Array< OneD, NekDouble > &coords_y, Array< OneD, NekDouble > &coords_z)
virtual void v_BwdTrans_SumFacKernel(const Array< OneD, const NekDouble > &base0, const Array< OneD, const NekDouble > &base1, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, Array< OneD, NekDouble > &wsp, bool doCheckCollDir0, bool doCheckCollDir1)
virtual void v_GetTraceCoeffMap(const unsigned int traceid, Array< OneD, unsigned int > &maparray)
virtual void v_FwdTransBndConstrained(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
virtual void v_GeneralMatrixOp_MatOp(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
virtual void v_GetSimplexEquiSpacedConnectivity(Array< OneD, int > &conn, bool standard=true)
virtual NekDouble v_Integral(const Array< OneD, const NekDouble > &inarray)
Integrates the specified function over the domain.
virtual int v_GetVertexMap(int localVertexId, bool useCoeffPacking=false)
virtual int v_GetTraceNcoeffs(const int i) const
virtual int v_NumBndryCoeffs() const
virtual DNekMatSharedPtr v_GenMatrix(const StdMatrixKey &mkey)
virtual int v_GetTraceNumPoints(const int i) const
virtual void v_BwdTrans_SumFac(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
virtual void v_WeakDerivMatrixOp(const int i, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
virtual void v_LocCollapsedToLocCoord(const Array< OneD, const NekDouble > &eta, Array< OneD, NekDouble > &xi)
virtual void v_StdPhysDeriv(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_d0, Array< OneD, NekDouble > &out_d1, Array< OneD, NekDouble > &out_d2=NullNekDouble1DArray)
virtual void v_GetTraceInteriorToElementMap(const int eid, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray, const Orientation edgeOrient=eForwards)
virtual void v_HelmholtzMatrixOp(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
virtual void v_GetBoundaryMap(Array< OneD, unsigned int > &outarray)
virtual int v_GetNtraces() const
virtual void v_LocCoordToLocCollapsed(const Array< OneD, const NekDouble > &xi, Array< OneD, NekDouble > &eta)
virtual void v_IProductWRTBase_MatOp(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
virtual void v_GetInteriorMap(Array< OneD, unsigned int > &outarray)
virtual void v_SVVLaplacianFilter(Array< OneD, NekDouble > &array, const StdMatrixKey &mkey)
virtual int v_NumDGBndryCoeffs() const
virtual int v_CalcNumberOfCoefficients(const std::vector< unsigned int > &nummodes, int &modes_offset)
virtual void v_IProductWRTBase(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
Calculate the inner product of inarray with respect to the basis B=base0[p]*base1[pq] and put into ou...
virtual void v_BwdTrans(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
Backward tranform for triangular elements.
virtual int v_GetNverts() const
virtual void v_IProductWRTBase_SumFac(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, bool multiplybyweights=true)
virtual bool v_IsBoundaryInteriorExpansion()
virtual void v_IProductWRTDerivBase_MatOp(const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
virtual void v_MultiplyByStdQuadratureMetric(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
virtual void v_ReduceOrderCoeffs(int numMin, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
virtual void v_FwdTrans(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
Transform a given function from physical quadrature space to coefficient space.
virtual void v_PhysDeriv(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_d0, Array< OneD, NekDouble > &out_d1, Array< OneD, NekDouble > &out_d2=NullNekDouble1DArray)
Calculate the derivative of the physical points.
virtual LibUtilities::ShapeType v_DetShapeType() const
virtual void v_FillMode(const int mode, Array< OneD, NekDouble > &outarray)
NekDouble v_PhysEvaluateBasis(const Array< OneD, const NekDouble > &coords, int mode) final
virtual void v_LaplacianMatrixOp(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
virtual void v_IProductWRTBase_SumFacKernel(const Array< OneD, const NekDouble > &base0, const Array< OneD, const NekDouble > &base1, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, Array< OneD, NekDouble > &wsp, bool doCheckCollDir0, bool doCheckCollDir1)
virtual void v_IProductWRTDerivBase_SumFac(const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
virtual const LibUtilities::BasisKey v_GetTraceBasisKey(const int i, const int j) const
virtual void v_MassMatrixOp(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
virtual void v_IProductWRTDerivBase(const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
virtual DNekMatSharedPtr v_CreateStdMatrix(const StdMatrixKey &mkey)
static void Dgemv(const char &trans, const int &m, const int &n, const double &alpha, const double *a, const int &lda, const double *x, const int &incx, const double &beta, double *y, const int &incy)
BLAS level 2: Matrix vector multiply y = A x where A[m x n].
static void Dscal(const int &n, const double &alpha, double *x, const int &incx)
BLAS level 1: x = alpha x.
static double Ddot(const int &n, const double *x, const int &incx, const double *y, const int &incy)
BLAS level 1: output = .
static void Dgemm(const char &transa, const char &transb, const int &m, const int &n, const int &k, const double &alpha, const double *a, const int &lda, const double *b, const int &ldb, const double &beta, double *c, const int &ldc)
BLAS level 3: Matrix-matrix multiply C = A x B where op(A)[m x k], op(B)[k x n], C[m x n] DGEMM perfo...
static void Daxpy(const int &n, const double &alpha, const double *x, const int &incx, const double *y, const int &incy)
BLAS level 1: y = alpha x plus y.
int getNumberOfCoefficients(int Na)
int getNumberOfCoefficients(int Na, int Nb)
static const BasisKey NullBasisKey(eNoBasisType, 0, NullPointsKey)
Defines a null basis with no type or points.
const std::string kPointsTypeStr[]
@ eGaussRadauMLegendre
1D Gauss-Radau-Legendre quadrature points, pinned at x=-1
@ eGaussLobattoLegendre
1D Gauss-Lobatto-Legendre quadrature points
@ ePolyEvenlySpaced
1D Evenly-spaced points using Lagrange polynomial
@ eModified_B
Principle Modified Functions .
@ eOrtho_A
Principle Orthogonal Functions .
@ eOrtho_B
Principle Orthogonal Functions .
@ eModified_A
Principle Modified Functions .
static const NekDouble kNekZeroTol
@ eFactorSVVDGKerDiffCoeff
@ eFactorSVVPowerKerDiffCoeff
const int kSVVDGFiltermodesmin
const int kSVVDGFiltermodesmax
const NekDouble kSVVDGFilter[9][11]
@ ePhysInterpToEquiSpaced
std::shared_ptr< StdTriExp > StdTriExpSharedPtr
std::shared_ptr< StdSegExp > StdSegExpSharedPtr
The above copyright notice and this permission notice shall be included.
static Array< OneD, NekDouble > NullNekDouble1DArray
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 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 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.
void Smul(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Scalar multiply y = alpha*x.
void Sdiv(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Scalar multiply y = alpha/y.
void Fill(int n, const T alpha, T *x, const int incx)
Fill a vector with a constant value.
void Sadd(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Add vector y = alpha - x.
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
void Vsub(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Subtract vector z = x-y.
scalarT< T > sqrt(scalarT< T > in)