35 #include <boost/core/ignore_unused.hpp>
49 namespace LocalRegions
54 : StdExpansion(Ba.GetNumModes() * Bb.GetNumModes(), 2, Ba, Bb),
55 StdExpansion2D(Ba.GetNumModes() * Bb.GetNumModes(), Ba, Bb),
58 std::bind(&
Expansion2D::CreateMatrix, this, std::placeholders::_1),
59 std::string(
"QuadExpMatrix")),
60 m_staticCondMatrixManager(std::bind(&
Expansion::CreateStaticCondMatrix,
61 this, std::placeholders::_1),
62 std::string(
"QuadExpStaticCondMatrix"))
67 : StdExpansion(T), StdExpansion2D(T), StdQuadExp(T),
Expansion(T),
69 m_staticCondMatrixManager(T.m_staticCondMatrixManager)
79 int nquad0 =
m_base[0]->GetNumPoints();
80 int nquad1 =
m_base[1]->GetNumPoints();
88 Vmath::Vmul(nquad0 * nquad1, jac, 1, inarray, 1, tmp, 1);
92 Vmath::Smul(nquad0 * nquad1, jac[0], inarray, 1, tmp, 1);
96 ival = StdQuadExp::v_Integral(tmp);
105 int nquad0 =
m_base[0]->GetNumPoints();
106 int nquad1 =
m_base[1]->GetNumPoints();
107 int nqtot = nquad0 * nquad1;
113 StdQuadExp::v_PhysDeriv(inarray, diff0, diff1);
120 Vmath::Vvtvp(nqtot, df[1], 1, diff1, 1, out_d0, 1, out_d0, 1);
126 Vmath::Vvtvp(nqtot, df[3], 1, diff1, 1, out_d1, 1, out_d1, 1);
132 Vmath::Vvtvp(nqtot, df[5], 1, diff1, 1, out_d2, 1, out_d2, 1);
183 ASSERTL1(
false,
"input dir is out of range");
193 int nquad0 =
m_base[0]->GetNumPoints();
194 int nquad1 =
m_base[1]->GetNumPoints();
195 int nqtot = nquad0 * nquad1;
203 StdQuadExp::v_PhysDeriv(inarray, diff0, diff1);
210 for (
int i = 0; i < 2; ++i)
213 for (
int k = 0; k < (
m_geom->GetCoordim()); ++k)
215 Vmath::Vvtvp(nqtot, &df[2 * k + i][0], 1, &direction[k * nqtot],
216 1, &tangmat[i][0], 1, &tangmat[i][0], 1);
223 Vmath::Vmul(nqtot, &tangmat[0][0], 1, &diff0[0], 1, &out[0], 1);
224 Vmath::Vvtvp(nqtot, &tangmat[1][0], 1, &diff1[0], 1, &out[0], 1,
238 if ((
m_base[0]->Collocation()) && (
m_base[1]->Collocation()))
254 out = (*matsys) * in;
262 if ((
m_base[0]->Collocation()) && (
m_base[1]->Collocation()))
269 int npoints[2] = {
m_base[0]->GetNumPoints(),
m_base[1]->GetNumPoints()};
270 int nmodes[2] = {
m_base[0]->GetNumModes(),
m_base[1]->GetNumModes()};
272 fill(outarray.get(), outarray.get() +
m_ncoeffs, 0.0);
274 if (nmodes[0] == 1 && nmodes[1] == 1)
276 outarray[0] = inarray[0];
283 for (i = 0; i < 4; i++)
290 for (i = 0; i < npoints[0]; i++)
292 physEdge[0][i] = inarray[i];
293 physEdge[2][i] = inarray[npoints[0] * (npoints[1] - 1) + i];
296 for (i = 0; i < npoints[1]; i++)
298 physEdge[1][i] = inarray[npoints[0] - 1 + i * npoints[0]];
299 physEdge[3][i] = inarray[i * npoints[0]];
302 for (i = 0; i < 4; i++)
306 reverse((physEdge[i]).get(),
307 (physEdge[i]).get() + npoints[i % 2]);
312 for (i = 0; i < 4; i++)
322 for (i = 0; i < 4; i++)
324 segexp[i % 2]->FwdTransBndConstrained(physEdge[i], coeffEdge[i]);
327 for (j = 0; j < nmodes[i % 2]; j++)
330 outarray[mapArray[j]] =
sign * coeffEdge[i][j];
335 int nInteriorDofs =
m_ncoeffs - nBoundaryDofs;
337 if (nInteriorDofs > 0)
361 for (i = 0; i < nInteriorDofs; i++)
363 rhs[i] = tmp1[mapArray[i]];
366 Blas::Dgemv(
'N', nInteriorDofs, nInteriorDofs, matsys->Scale(),
367 &((matsys->GetOwnedMatrix())->GetPtr())[0],
368 nInteriorDofs, rhs.get(), 1, 0.0, result.get(), 1);
370 for (i = 0; i < nInteriorDofs; i++)
372 outarray[mapArray[i]] = result[i];
381 if (
m_base[0]->Collocation() &&
m_base[1]->Collocation())
402 int nquad0 =
m_base[0]->GetNumPoints();
403 int nquad1 =
m_base[1]->GetNumPoints();
404 int order0 =
m_base[0]->GetNumModes();
406 if (multiplybyweights)
412 StdQuadExp::IProductWRTBase_SumFacKernel(
m_base[0]->GetBdata(),
413 m_base[1]->GetBdata(), tmp,
414 outarray, wsp,
true,
true);
420 StdQuadExp::IProductWRTBase_SumFacKernel(
m_base[0]->GetBdata(),
421 m_base[1]->GetBdata(), inarray,
422 outarray, wsp,
true,
true);
435 (iprodmat->GetOwnedMatrix())->GetPtr().get(),
m_ncoeffs,
436 inarray.get(), 1, 0.0, outarray.get(), 1);
443 ASSERTL1((dir == 0) || (dir == 1) || (dir == 2),
"Invalid direction.");
445 "Invalid direction.");
447 int nquad0 =
m_base[0]->GetNumPoints();
448 int nquad1 =
m_base[1]->GetNumPoints();
449 int nqtot = nquad0 * nquad1;
450 int nmodes0 =
m_base[0]->GetNumModes();
467 tmp1, tmp3, tmp4,
false,
true);
469 tmp2, outarray, tmp4,
true,
false);
477 ASSERTL1((dir == 0) || (dir == 1) || (dir == 2),
"Invalid direction.");
479 "Invalid direction.");
481 int nquad0 =
m_base[0]->GetNumPoints();
482 int nquad1 =
m_base[1]->GetNumPoints();
483 int nqtot = nquad0 * nquad1;
484 int nmodes0 =
m_base[0]->GetNumModes();
496 Vmath::Vmul(nqtot, &df[2 * dir][0], 1, inarray.get(), 1, tmp1.get(), 1);
497 Vmath::Vmul(nqtot, &df[2 * dir + 1][0], 1, inarray.get(), 1, tmp2.get(),
502 Vmath::Smul(nqtot, df[2 * dir][0], inarray.get(), 1, tmp1.get(), 1);
503 Vmath::Smul(nqtot, df[2 * dir + 1][0], inarray.get(), 1, tmp2.get(), 1);
533 ASSERTL1(
false,
"input dir is out of range");
542 (iprodmat->GetOwnedMatrix())->GetPtr().get(),
m_ncoeffs,
543 inarray.get(), 1, 0.0, outarray.get(), 1);
551 int nq =
m_base[0]->GetNumPoints() *
m_base[1]->GetNumPoints();
560 Vmath::Vvtvvtp(nq, &normals[0][0], 1, &Fx[0], 1, &normals[1][0], 1,
561 &Fy[0], 1, &Fn[0], 1);
562 Vmath::Vvtvp(nq, &normals[2][0], 1, &Fz[0], 1, &Fn[0], 1, &Fn[0], 1);
566 Vmath::Svtsvtp(nq, normals[0][0], &Fx[0], 1, normals[1][0], &Fy[0], 1,
568 Vmath::Svtvp(nq, normals[2][0], &Fz[0], 1, &Fn[0], 1, &Fn[0], 1);
590 m_base[0]->GetPointsKey());
592 m_base[1]->GetPointsKey());
610 ASSERTL1(Lcoords[0] >= -1.0 && Lcoords[1] <= 1.0 && Lcoords[1] >= -1.0 &&
612 "Local coordinates are not in region [-1,1]");
615 for (i = 0; i <
m_geom->GetCoordim(); ++i)
617 coords[i] =
m_geom->GetCoord(i, Lcoords);
631 return StdQuadExp::v_PhysEvaluate(Lcoord, physvals);
640 m_geom->GetLocCoords(coord, Lcoord);
642 return StdQuadExp::v_PhysEvaluate(Lcoord, physvals);
652 int nquad0 =
m_base[0]->GetNumPoints();
653 int nquad1 =
m_base[1]->GetNumPoints();
661 Vmath::Vcopy(nquad0, &(inarray[0]), 1, &(outarray[0]), 1);
672 Vmath::Vcopy(nquad1, &(inarray[0]) + (nquad0 - 1), nquad0,
677 Vmath::Vcopy(nquad1, &(inarray[0]) + (nquad0 * nquad1 - 1),
678 -nquad0, &(outarray[0]), 1);
684 Vmath::Vcopy(nquad0, &(inarray[0]) + (nquad0 * nquad1 - 1), -1,
689 Vmath::Vcopy(nquad0, &(inarray[0]) + nquad0 * (nquad1 - 1), 1,
696 Vmath::Vcopy(nquad1, &(inarray[0]) + nquad0 * (nquad1 - 1),
697 -nquad0, &(outarray[0]), 1);
701 Vmath::Vcopy(nquad1, &(inarray[0]), nquad0, &(outarray[0]), 1);
705 ASSERTL0(
false,
"edge value (< 3) is out of range");
715 int nquad0 =
m_base[0]->GetNumPoints();
716 int nquad1 =
m_base[1]->GetNumPoints();
725 Vmath::Vcopy(nquad0, &(inarray[0]), 1, &(outarray[0]), 1);
728 Vmath::Vcopy(nquad1, &(inarray[0]) + (nquad0 - 1), nquad0,
732 Vmath::Vcopy(nquad0, &(inarray[0]) + nquad0 * (nquad1 - 1), 1,
736 Vmath::Vcopy(nquad1, &(inarray[0]), nquad0, &(outarray[0]), 1);
739 ASSERTL0(
false,
"edge value (< 3) is out of range");
749 if (
m_base[edge % 2]->GetPointsKey() !=
750 EdgeExp->GetBasis(0)->GetPointsKey())
757 EdgeExp->GetBasis(0)->GetPointsKey(), outarray);
767 Vmath::Reverse(EdgeExp->GetNumPoints(0), &outarray[0], 1, &outarray[0],
777 int nq0 =
m_base[0]->GetNumPoints();
778 int nq1 =
m_base[1]->GetNumPoints();
792 for (i = 0; i < nq0; i++)
795 Blas::Ddot(nq1, mat_gauss->GetOwnedMatrix()->GetPtr().get(),
796 1, &inarray[i], nq0);
802 for (i = 0; i < nq1; i++)
805 Blas::Ddot(nq0, mat_gauss->GetOwnedMatrix()->GetPtr().get(),
806 1, &inarray[i * nq0], 1);
812 for (i = 0; i < nq0; i++)
815 Blas::Ddot(nq1, mat_gauss->GetOwnedMatrix()->GetPtr().get(),
816 1, &inarray[i], nq0);
822 for (i = 0; i < nq1; i++)
825 Blas::Ddot(nq0, mat_gauss->GetOwnedMatrix()->GetPtr().get(),
826 1, &inarray[i * nq0], 1);
831 ASSERTL0(
false,
"edge value (< 3) is out of range");
838 int nquad0 =
m_base[0]->GetNumPoints();
839 int nquad1 =
m_base[1]->GetNumPoints();
846 for (
int i = 0; i < nquad0; ++i)
853 for (
int i = 0; i < nquad1; ++i)
855 outarray[i] = (nquad0 - 1) + i * nquad0;
860 for (
int i = 0; i < nquad0; ++i)
862 outarray[i] = i + nquad0 * (nquad1 - 1);
867 for (
int i = 0; i < nquad1; ++i)
869 outarray[i] = i * nquad0;
873 ASSERTL0(
false,
"edge value (< 3) is out of range");
882 int nquad0 =
m_base[0]->GetNumPoints();
883 int nquad1 =
m_base[1]->GetNumPoints();
909 for (i = 0; i < nquad0; ++i)
912 j[i] *
sqrt(g1[i] * g1[i] + g3[i] * g3[i]);
916 Vmath::Vcopy(nquad1, &(df[0][0]) + (nquad0 - 1), nquad0,
919 Vmath::Vcopy(nquad1, &(df[2][0]) + (nquad0 - 1), nquad0,
925 for (i = 0; i < nquad1; ++i)
928 j[i] *
sqrt(g0[i] * g0[i] + g2[i] * g2[i]);
933 Vmath::Vcopy(nquad0, &(df[1][0]) + (nquad0 * (nquad1 - 1)),
936 Vmath::Vcopy(nquad0, &(df[3][0]) + (nquad0 * (nquad1 - 1)),
939 Vmath::Vcopy(nquad0, &(jac[0]) + (nquad0 * (nquad1 - 1)), 1,
942 for (i = 0; i < nquad0; ++i)
945 j[i] *
sqrt(g1[i] * g1[i] + g3[i] * g3[i]);
954 for (i = 0; i < nquad1; ++i)
957 j[i] *
sqrt(g0[i] * g0[i] + g2[i] * g2[i]);
961 ASSERTL0(
false,
"edge value (< 3) is out of range");
967 int nqtot = nquad0 * nquad1;
988 for (i = 0; i < nquad0; ++i)
990 outarray[i] =
sqrt(g1_edge[i] * g1_edge[i] +
991 g3_edge[i] * g3_edge[i]);
1003 for (i = 0; i < nquad1; ++i)
1005 outarray[i] =
sqrt(g0_edge[i] * g0_edge[i] +
1006 g2_edge[i] * g2_edge[i]);
1013 &(tmp_gmat1[0]), 1);
1015 &(tmp_gmat3[0]), 1);
1019 for (i = 0; i < nquad0; ++i)
1021 outarray[i] =
sqrt(g1_edge[i] * g1_edge[i] +
1022 g3_edge[i] * g3_edge[i]);
1030 &(tmp_gmat0[0]), 1);
1032 &(tmp_gmat2[0]), 1);
1036 for (i = 0; i < nquad1; ++i)
1038 outarray[i] =
sqrt(g0_edge[i] * g0_edge[i] +
1039 g2_edge[i] * g2_edge[i]);
1046 ASSERTL0(
false,
"edge value (< 3) is out of range");
1058 for (i = 0; i < nquad0; ++i)
1060 outarray[i] = jac[0] *
sqrt(df[1][0] * df[1][0] +
1061 df[3][0] * df[3][0]);
1065 for (i = 0; i < nquad1; ++i)
1067 outarray[i] = jac[0] *
sqrt(df[0][0] * df[0][0] +
1068 df[2][0] * df[2][0]);
1072 for (i = 0; i < nquad0; ++i)
1074 outarray[i] = jac[0] *
sqrt(df[1][0] * df[1][0] +
1075 df[3][0] * df[3][0]);
1079 for (i = 0; i < nquad1; ++i)
1081 outarray[i] = jac[0] *
sqrt(df[0][0] * df[0][0] +
1082 df[2][0] * df[2][0]);
1086 ASSERTL0(
false,
"edge value (< 3) is out of range");
1100 for (i = 0; i < ptsKeys.size(); ++i)
1111 geomFactors->GetDerivFactors(ptsKeys);
1114 if (edge == 0 || edge == 2)
1116 nqe =
m_base[0]->GetNumPoints();
1120 nqe =
m_base[1]->GetNumPoints();
1126 for (i = 0; i < vCoordDim; ++i)
1145 for (i = 0; i < vCoordDim; ++i)
1147 Vmath::Fill(nqe, -df[2 * i + 1][0], normal[i], 1);
1151 for (i = 0; i < vCoordDim; ++i)
1157 for (i = 0; i < vCoordDim; ++i)
1163 for (i = 0; i < vCoordDim; ++i)
1169 ASSERTL0(
false,
"edge is out of range (edge < 4)");
1174 for (i = 0; i < vCoordDim; ++i)
1176 fac += normal[i][0] * normal[i][0];
1178 fac = 1.0 /
sqrt(fac);
1182 for (i = 0; i < vCoordDim; ++i)
1184 Vmath::Smul(nqe, fac, normal[i], 1, normal[i], 1);
1191 int nquad0 = ptsKeys[0].GetNumPoints();
1192 int nquad1 = ptsKeys[1].GetNumPoints();
1210 for (j = 0; j < nquad0; ++j)
1212 edgejac[j] = jac[j];
1213 for (i = 0; i < vCoordDim; ++i)
1215 normals[i * nquad0 + j] =
1216 -df[2 * i + 1][j] * edgejac[j];
1219 from_key = ptsKeys[0];
1222 for (j = 0; j < nquad1; ++j)
1224 edgejac[j] = jac[nquad0 * j + nquad0 - 1];
1225 for (i = 0; i < vCoordDim; ++i)
1227 normals[i * nquad1 + j] =
1228 df[2 * i][nquad0 * j + nquad0 - 1] * edgejac[j];
1231 from_key = ptsKeys[1];
1234 for (j = 0; j < nquad0; ++j)
1236 edgejac[j] = jac[nquad0 * (nquad1 - 1) + j];
1237 for (i = 0; i < vCoordDim; ++i)
1239 normals[i * nquad0 + j] =
1240 (df[2 * i + 1][nquad0 * (nquad1 - 1) + j]) *
1244 from_key = ptsKeys[0];
1247 for (j = 0; j < nquad1; ++j)
1249 edgejac[j] = jac[nquad0 * j];
1250 for (i = 0; i < vCoordDim; ++i)
1252 normals[i * nquad1 + j] =
1253 -df[2 * i][nquad0 * j] * edgejac[j];
1256 from_key = ptsKeys[1];
1259 ASSERTL0(
false,
"edge is out of range (edge < 3)");
1264 int nqtot = nquad0 * nquad1;
1271 for (j = 0; j < nquad0; ++j)
1273 for (i = 0; i < vCoordDim; ++i)
1275 Vmath::Vmul(nqtot, &(df[2 * i + 1][0]), 1, &jac[0],
1276 1, &(tmp_gmat[0]), 1);
1279 normals[i * nquad0 + j] = -tmp_gmat_edge[j];
1282 from_key = ptsKeys[0];
1285 for (j = 0; j < nquad1; ++j)
1287 for (i = 0; i < vCoordDim; ++i)
1289 Vmath::Vmul(nqtot, &(df[2 * i][0]), 1, &jac[0], 1,
1293 normals[i * nquad1 + j] = tmp_gmat_edge[j];
1296 from_key = ptsKeys[1];
1299 for (j = 0; j < nquad0; ++j)
1301 for (i = 0; i < vCoordDim; ++i)
1303 Vmath::Vmul(nqtot, &(df[2 * i + 1][0]), 1, &jac[0],
1304 1, &(tmp_gmat[0]), 1);
1307 normals[i * nquad0 + j] = tmp_gmat_edge[j];
1310 from_key = ptsKeys[0];
1313 for (j = 0; j < nquad1; ++j)
1315 for (i = 0; i < vCoordDim; ++i)
1317 Vmath::Vmul(nqtot, &(df[2 * i][0]), 1, &jac[0], 1,
1321 normals[i * nquad1 + j] = -tmp_gmat_edge[j];
1324 from_key = ptsKeys[1];
1327 ASSERTL0(
false,
"edge is out of range (edge < 3)");
1342 m_base[0]->GetPointsKey(), &normal[i][0]);
1343 Vmath::Vmul(nqe, work, 1, normal[i], 1, normal[i], 1);
1350 Vmath::Vvtvp(nqe, normal[i], 1, normal[i], 1, work, 1, work, 1);
1360 Vmath::Vmul(nqe, normal[i], 1, work, 1, normal[i], 1);
1365 for (i = 0; i < vCoordDim; ++i)
1382 return m_geom->GetCoordim();
1386 const NekDouble *data,
const std::vector<unsigned int> &nummodes,
1388 std::vector<LibUtilities::BasisType> &fromType)
1390 int data_order0 = nummodes[mode_offset];
1391 int fillorder0 = std::min(
m_base[0]->GetNumModes(), data_order0);
1393 int data_order1 = nummodes[mode_offset + 1];
1394 int order1 =
m_base[1]->GetNumModes();
1395 int fillorder1 = min(order1, data_order1);
1406 m_base[0]->GetPointsKey()),
1408 m_base[1]->GetPointsKey()));
1410 m_base[1]->GetBasisKey());
1432 "Extraction routine not set up for this basis");
1435 for (i = 0; i < fillorder0; ++i)
1437 Vmath::Vcopy(fillorder1, data + cnt, 1, coeffs + cnt1, 1);
1471 ASSERTL0(
false,
"basis is either not set up or not hierarchicial");
1477 return m_geom->GetEorient(edge);
1482 ASSERTL1(dir >= 0 && dir <= 1,
"input dir is out of range");
1506 returnval = StdQuadExp::v_GenMatrix(mkey);
1518 return tmp->GetStdMatrix(mkey);
1540 StdExpansion::MassMatrixOp_MatFree(inarray, outarray, mkey);
1555 StdExpansion::LaplacianMatrixOp_MatFree(k1, k2, inarray, outarray, mkey);
1563 StdExpansion::WeakDerivMatrixOp_MatFree(i, inarray, outarray, mkey);
1570 StdExpansion::WeakDirectionalDerivMatrixOp_MatFree(inarray, outarray, mkey);
1577 StdExpansion::MassLevelCurvatureMatrixOp_MatFree(inarray, outarray, mkey);
1594 if (inarray.get() == outarray.get())
1600 (mat->GetOwnedMatrix())->GetPtr().get(),
m_ncoeffs,
1601 tmp.get(), 1, 0.0, outarray.get(), 1);
1606 (mat->GetOwnedMatrix())->GetPtr().get(),
m_ncoeffs,
1607 inarray.get(), 1, 0.0, outarray.get(), 1);
1615 int n_coeffs = inarray.size();
1621 int nmodes0 =
m_base[0]->GetNumModes();
1622 int nmodes1 =
m_base[1]->GetNumModes();
1623 int numMax = nmodes0;
1641 for (
int i = 0; i < numMin + 1; ++i)
1643 Vmath::Vcopy(numMin, tmp = coeff + cnt, 1, tmp2 = coeff_tmp + cnt, 1);
1660 int nquad0 =
m_base[0]->GetNumPoints();
1661 int nquad1 =
m_base[1]->GetNumPoints();
1662 int nqtot = nquad0 * nquad1;
1663 int nmodes0 =
m_base[0]->GetNumModes();
1664 int nmodes1 =
m_base[1]->GetNumModes();
1666 max(max(max(nqtot,
m_ncoeffs), nquad1 * nmodes0), nquad0 * nmodes1);
1668 ASSERTL1(wsp.size() >= 3 * wspsize,
"Workspace is of insufficient size.");
1686 StdExpansion2D::PhysTensorDeriv(inarray, wsp1, wsp2);
1692 Vmath::Vvtvvtp(nqtot, &metric00[0], 1, &wsp1[0], 1, &metric01[0], 1,
1693 &wsp2[0], 1, &wsp0[0], 1);
1694 Vmath::Vvtvvtp(nqtot, &metric01[0], 1, &wsp1[0], 1, &metric11[0], 1,
1695 &wsp2[0], 1, &wsp2[0], 1);
1717 const unsigned int dim = 2;
1725 for (
unsigned int i = 0; i < dim; ++i)
1727 for (
unsigned int j = i; j < dim; ++j)
1766 StdQuadExp::v_SVVLaplacianFilter(array, mkey);
1782 boost::ignore_unused(d2factors);
1789 if (d0factors.size() != 4)
1795 if (d0factors[0].size() != nquad0)
1803 if (d0factors[1].size() != nquad1)
1821 int ncoords = normal_0.size();
1828 for (
int i = 0; i < nquad0; ++i)
1830 d0factors[0][i] = df[0][i] * normal_0[0][i];
1831 d0factors[2][i] = df[0][nquad0 * (nquad1 - 1) + i] * normal_2[0][i];
1833 d1factors[0][i] = df[1][i] * normal_0[0][i];
1834 d1factors[2][i] = df[1][nquad0 * (nquad1 - 1) + i] * normal_2[0][i];
1837 for (
int n = 1; n < ncoords; ++n)
1841 for (
int i = 0; i < nquad0; ++i)
1843 d0factors[0][i] += df[2 * n][i] * normal_0[n][i];
1845 df[2 * n][nquad0 * (nquad1 - 1) + i] * normal_2[n][i];
1847 d1factors[0][i] += df[2 * n + 1][i] * normal_0[n][i];
1849 df[2 * n + 1][nquad0 * (nquad1 - 1) + i] * normal_2[n][i];
1854 for (
int i = 0; i < nquad1; ++i)
1856 d0factors[1][i] = df[0][(i + 1) * nquad0 - 1] * normal_1[0][i];
1857 d0factors[3][i] = df[0][i * nquad0] * normal_3[0][i];
1859 d1factors[1][i] = df[1][(i + 1) * nquad0 - 1] * normal_1[0][i];
1860 d1factors[3][i] = df[1][i * nquad0] * normal_3[0][i];
1863 for (
int n = 1; n < ncoords; ++n)
1865 for (
int i = 0; i < nquad1; ++i)
1868 df[2 * n][(i + 1) * nquad0 - 1] * normal_1[n][i];
1869 d0factors[3][i] += df[2 * n][i * nquad0] * normal_3[n][i];
1872 df[2 * n + 1][(i + 1) * nquad0 - 1] * normal_1[n][i];
1873 d1factors[3][i] += df[2 * n + 1][i * nquad0] * normal_3[n][i];
1880 for (
int i = 0; i < nquad0; ++i)
1882 d1factors[0][i] = df[1][0] * normal_0[0][i];
1883 d1factors[2][i] = df[1][0] * normal_2[0][i];
1887 for (
int i = 0; i < nquad1; ++i)
1889 d0factors[1][i] = df[0][0] * normal_1[0][i];
1890 d0factors[3][i] = df[0][0] * normal_3[0][i];
1893 for (
int n = 1; n < ncoords; ++n)
1897 for (
int i = 0; i < nquad0; ++i)
1899 d1factors[0][i] += df[2 * n + 1][0] * normal_0[n][i];
1900 d1factors[2][i] += df[2 * n + 1][0] * normal_2[n][i];
1905 for (
int i = 0; i < nquad1; ++i)
1907 d0factors[1][i] += df[2 * n][0] * normal_1[n][i];
1908 d0factors[3][i] += df[2 * n][0] * normal_3[n][i];
1914 for (
int i = 0; i < nquad0; ++i)
1916 d0factors[0][i] = df[0][0] * normal_0[0][i];
1917 d0factors[2][i] = df[0][0] * normal_2[0][i];
1921 for (
int i = 0; i < nquad1; ++i)
1923 d1factors[1][i] = df[1][0] * normal_1[0][i];
1924 d1factors[3][i] = df[1][0] * normal_3[0][i];
1927 for (
int n = 1; n < ncoords; ++n)
1931 for (
int i = 0; i < nquad0; ++i)
1933 d0factors[0][i] += df[2 * n][0] * normal_0[n][i];
1934 d0factors[2][i] += df[2 * n][0] * normal_2[n][i];
1939 for (
int i = 0; i < nquad1; ++i)
1941 d1factors[1][i] += df[2 * n + 1][0] * normal_1[n][i];
1942 d1factors[3][i] += df[2 * n + 1][0] * normal_3[n][i];
#define ASSERTL0(condition, msg)
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode....
#define sign(a, b)
return the sign(b)*a
Describes the specification for a Basis.
Defines a specification for a set of points.
unsigned int GetNumPoints() const
virtual DNekMatSharedPtr v_GenMatrix(const StdRegions::StdMatrixKey &mkey)
SpatialDomains::Geometry2DSharedPtr GetGeom2D() const
std::map< int, NormalVector > m_traceNormals
std::map< int, Array< OneD, NekDouble > > m_elmtBndNormDirElmtLen
the element length in each element boundary(Vertex, edge or face) normal direction calculated based o...
SpatialDomains::GeometrySharedPtr GetGeom() const
SpatialDomains::GeometrySharedPtr m_geom
ExpansionSharedPtr GetLeftAdjacentElementExp() const
void ComputeLaplacianMetric()
int GetLeftAdjacentElementTrace() const
void ComputeQuadratureMetric()
SpatialDomains::GeomFactorsSharedPtr m_metricinfo
virtual void v_GetCoords(Array< OneD, NekDouble > &coords_1, Array< OneD, NekDouble > &coords_2, Array< OneD, NekDouble > &coords_3)
StdRegions::Orientation GetTraceOrient(int trace)
DNekScalMatSharedPtr GetLocMatrix(const LocalRegions::MatrixKey &mkey)
const NormalVector & GetTraceNormal(const int id)
virtual NekDouble v_PhysEvaluate(const Array< OneD, const NekDouble > &coord, const Array< OneD, const NekDouble > &physvals)
This function evaluates the expansion at a single (arbitrary) point of the domain.
virtual DNekScalMatSharedPtr v_GetLocMatrix(const MatrixKey &mkey)
virtual const SpatialDomains::GeomFactorsSharedPtr & v_GetMetricInfo() const
virtual void v_FwdTransBndConstrained(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
virtual void v_AlignVectorToCollapsedDir(const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, Array< OneD, NekDouble >> &outarray)
virtual void v_ComputeTraceNormal(const int edge)
virtual void v_PhysDirectionalDeriv(const Array< OneD, const NekDouble > &inarray, const Array< OneD, const NekDouble > &direction, Array< OneD, NekDouble > &out)
Physical derivative along a direction vector.
virtual void v_IProductWRTDerivBase_MatOp(const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
virtual void v_SVVLaplacianFilter(Array< OneD, NekDouble > &array, const StdRegions::StdMatrixKey &mkey)
virtual DNekMatSharedPtr v_CreateStdMatrix(const StdRegions::StdMatrixKey &mkey)
virtual void v_WeakDerivMatrixOp(const int i, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey)
virtual int v_GetCoordim()
virtual void v_ReduceOrderCoeffs(int numMin, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
virtual void v_MassMatrixOp(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey)
virtual void v_LaplacianMatrixOp(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey)
virtual void v_IProductWRTBase_MatOp(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
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*base1 and put into outarray.
virtual NekDouble v_StdPhysEvaluate(const Array< OneD, const NekDouble > &Lcoord, const Array< OneD, const NekDouble > &physvals)
virtual void v_HelmholtzMatrixOp(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey)
virtual void v_IProductWRTDerivBase_SumFac(const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
virtual DNekMatSharedPtr v_GenMatrix(const StdRegions::StdMatrixKey &mkey)
virtual StdRegions::Orientation v_GetTraceOrient(int edge)
virtual void v_GetTracePhysMap(const int edge, Array< OneD, int > &outarray)
virtual void v_NormalTraceDerivFactors(Array< OneD, Array< OneD, NekDouble >> &factors, Array< OneD, Array< OneD, NekDouble >> &d0factors, Array< OneD, Array< OneD, NekDouble >> &d1factors)
: This method gets all of the factors which are required as part of the Gradient Jump Penalty (GJP) s...
virtual void v_GetEdgePhysVals(const int edge, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
virtual void v_GetCoord(const Array< OneD, const NekDouble > &Lcoords, Array< OneD, NekDouble > &coords)
LibUtilities::NekManager< MatrixKey, DNekScalMat, MatrixKey::opLess > m_matrixManager
virtual void v_ComputeLaplacianMetric()
virtual DNekScalBlkMatSharedPtr v_GetLocStaticCondMatrix(const MatrixKey &mkey)
virtual void v_GetCoords(Array< OneD, NekDouble > &coords_1, Array< OneD, NekDouble > &coords_2, Array< OneD, NekDouble > &coords_3)
LibUtilities::NekManager< MatrixKey, DNekScalBlkMat, MatrixKey::opLess > m_staticCondMatrixManager
virtual void v_NormVectorIProductWRTBase(const Array< OneD, const NekDouble > &Fx, const Array< OneD, const NekDouble > &Fy, const Array< OneD, const NekDouble > &Fz, Array< OneD, NekDouble > &outarray)
virtual void v_GetTracePhysVals(const int edge, const StdRegions::StdExpansionSharedPtr &EdgeExp, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, StdRegions::Orientation orient)
virtual void v_MassLevelCurvatureMatrixOp(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey)
void v_DropLocStaticCondMatrix(const MatrixKey &mkey)
virtual void v_GeneralMatrixOp_MatOp(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey)
virtual void v_WeakDirectionalDerivMatrixOp(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey)
virtual void v_GetTraceQFactors(const int edge, Array< OneD, NekDouble > &outarray)
virtual void v_LaplacianMatrixOp_MatFree_Kernel(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, Array< OneD, NekDouble > &wsp)
virtual const LibUtilities::BasisSharedPtr & v_GetBasis(int dir) const
virtual StdRegions::StdExpansionSharedPtr v_GetStdExp(void) const
virtual void v_ExtractDataToCoeffs(const NekDouble *data, const std::vector< unsigned int > &nummodes, const int mode_offset, NekDouble *coeffs, std::vector< LibUtilities::BasisType > &fromType)
virtual StdRegions::StdExpansionSharedPtr v_GetLinStdExp(void) const
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 int v_GetNumPoints(const int dir) const
virtual void v_IProductWRTBase_SumFac(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, bool multiplybyweights=true)
virtual void v_GetEdgeInterpVals(const int edge, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
virtual NekDouble v_Integral(const Array< OneD, const NekDouble > &inarray)
Integrates the specified function over the domain.
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 void v_IProductWRTDerivBase(const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
static std::shared_ptr< DataType > AllocateSharedPtr(const Args &...args)
Allocate a shared pointer from the memory pool.
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)
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.
LibUtilities::BasisType GetBasisType(const int dir) const
This function returns the type of basis used in the dir direction.
void HelmholtzMatrixOp_MatFree(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
int NumBndryCoeffs(void) const
const LibUtilities::PointsKeyVector GetPointsKeys() const
void MassMatrixOp(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
void IProductWRTDerivBase_SumFac(const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
void NormVectorIProductWRTBase(const Array< OneD, const NekDouble > &Fx, Array< OneD, NekDouble > &outarray)
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...
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 GetInteriorMap(Array< OneD, unsigned int > &outarray)
void BwdTrans(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
This function performs the Backward transformation from coefficient space to physical space.
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.
int GetNumPoints(const int dir) const
This function returns the number of quadrature points in the dir direction.
void IProductWRTBase_SumFac(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, bool multiplybyweights=true)
void MultiplyByQuadratureMetric(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
Array< OneD, LibUtilities::BasisSharedPtr > m_base
MatrixType GetMatrixType() const
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 double Ddot(const int &n, const double *x, const int &incx, const double *y, const int &incy)
BLAS level 1: output = .
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.
std::shared_ptr< Basis > BasisSharedPtr
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 InterpCoeff2D(const BasisKey &fbasis0, const BasisKey &fbasis1, const Array< OneD, const NekDouble > &from, const BasisKey &tbasis0, const BasisKey &tbasis1, Array< OneD, NekDouble > &to)
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,...
std::vector< PointsKey > PointsKeyVector
@ eGaussLobattoLegendre
1D Gauss-Lobatto-Legendre quadrature points
@ eGaussGaussLegendre
1D Gauss-Gauss-Legendre quadrature points
@ eGauss_Lagrange
Lagrange Polynomials using the Gauss points.
@ eOrtho_A
Principle Orthogonal Functions .
@ eGLL_Lagrange
Lagrange for SEM basis .
@ eModified_A
Principle Modified Functions .
std::shared_ptr< SegExp > SegExpSharedPtr
std::shared_ptr< GeomFactors > GeomFactorsSharedPtr
Pointer to a GeomFactors object.
GeomType
Indicates the type of element geometry.
@ eRegular
Geometry is straight-sided with constant geometric factors.
@ eMovingRegular
Currently unused.
@ eDeformed
Geometry is curved or has non-constant factors.
std::shared_ptr< Geometry2D > Geometry2DSharedPtr
std::shared_ptr< StdQuadExp > StdQuadExpSharedPtr
std::shared_ptr< StdExpansion > StdExpansionSharedPtr
@ eInvLaplacianWithUnityMean
std::map< ConstFactorType, NekDouble > ConstFactorMap
The above copyright notice and this permission notice shall be included.
std::shared_ptr< DNekScalMat > DNekScalMatSharedPtr
std::shared_ptr< DNekScalBlkMat > DNekScalBlkMatSharedPtr
static Array< OneD, NekDouble > NullNekDouble1DArray
std::shared_ptr< DNekMat > DNekMatSharedPtr
void Vsqrt(int n, const T *x, const int incx, T *y, const int incy)
sqrt y = sqrt(x)
void Svtsvtp(int n, const T alpha, const T *x, int incx, const T beta, const T *y, int incy, T *z, int incz)
vvtvvtp (scalar times vector plus scalar times vector):
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 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 Vdiv(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 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 Reverse(int n, const T *x, const int incx, T *y, const int incy)
void Vvtvvtp(int n, const T *v, int incv, const T *w, int incw, const T *x, int incx, const T *y, int incy, T *z, int incz)
vvtvvtp (vector times vector plus vector times vector):
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)