45 namespace LocalRegions
67 Ba.GetNumModes(), Bb.GetNumModes(), Bc.GetNumModes()),
71 Ba.GetNumModes(), Bb.GetNumModes(), Bc.GetNumModes()),
73 StdRegions::StdTetExp(Ba,Bb,Bc),
77 boost::bind(&
TetExp::CreateMatrix, this, _1),
78 std::string(
"TetExpMatrix")),
79 m_staticCondMatrixManager(
80 boost::bind(&
TetExp::CreateStaticCondMatrix, this, _1),
81 std::string(
"TetExpStaticCondMatrix"))
92 StdRegions::StdTetExp(T),
95 m_matrixManager(T.m_matrixManager),
96 m_staticCondMatrixManager(T.m_staticCondMatrixManager)
125 int nquad0 =
m_base[0]->GetNumPoints();
126 int nquad1 =
m_base[1]->GetNumPoints();
127 int nquad2 =
m_base[2]->GetNumPoints();
145 retrunVal = StdTetExp::v_Integral(tmp);
169 int TotPts =
m_base[0]->GetNumPoints()*
m_base[1]->GetNumPoints()*
170 m_base[2]->GetNumPoints();
178 StdTetExp::v_PhysDeriv(inarray, Diff0, Diff1, Diff2);
182 if(out_d0.num_elements())
184 Vmath::Vmul (TotPts,&df[0][0],1,&Diff0[0],1, &out_d0[0], 1);
185 Vmath::Vvtvp (TotPts,&df[1][0],1,&Diff1[0],1, &out_d0[0], 1,&out_d0[0],1);
186 Vmath::Vvtvp (TotPts,&df[2][0],1,&Diff2[0],1, &out_d0[0], 1,&out_d0[0],1);
189 if(out_d1.num_elements())
191 Vmath::Vmul (TotPts,&df[3][0],1,&Diff0[0],1, &out_d1[0], 1);
192 Vmath::Vvtvp (TotPts,&df[4][0],1,&Diff1[0],1, &out_d1[0], 1,&out_d1[0],1);
193 Vmath::Vvtvp (TotPts,&df[5][0],1,&Diff2[0],1, &out_d1[0], 1,&out_d1[0],1);
196 if(out_d2.num_elements())
198 Vmath::Vmul (TotPts,&df[6][0],1,&Diff0[0],1, &out_d2[0], 1);
199 Vmath::Vvtvp (TotPts,&df[7][0],1,&Diff1[0],1, &out_d2[0], 1, &out_d2[0],1);
200 Vmath::Vvtvp (TotPts,&df[8][0],1,&Diff2[0],1, &out_d2[0], 1, &out_d2[0],1);
205 if(out_d0.num_elements())
207 Vmath::Smul (TotPts,df[0][0],&Diff0[0],1, &out_d0[0], 1);
208 Blas::Daxpy (TotPts,df[1][0],&Diff1[0],1, &out_d0[0], 1);
209 Blas::Daxpy (TotPts,df[2][0],&Diff2[0],1, &out_d0[0], 1);
212 if(out_d1.num_elements())
214 Vmath::Smul (TotPts,df[3][0],&Diff0[0],1, &out_d1[0], 1);
215 Blas::Daxpy (TotPts,df[4][0],&Diff1[0],1, &out_d1[0], 1);
216 Blas::Daxpy (TotPts,df[5][0],&Diff2[0],1, &out_d1[0], 1);
219 if(out_d2.num_elements())
221 Vmath::Smul (TotPts,df[6][0],&Diff0[0],1, &out_d2[0], 1);
222 Blas::Daxpy (TotPts,df[7][0],&Diff1[0],1, &out_d2[0], 1);
223 Blas::Daxpy (TotPts,df[8][0],&Diff2[0],1, &out_d2[0], 1);
245 if((
m_base[0]->Collocation())&&(
m_base[1]->Collocation())&&(
m_base[2]->Collocation()))
305 bool multiplybyweights)
307 const int nquad0 =
m_base[0]->GetNumPoints();
308 const int nquad1 =
m_base[1]->GetNumPoints();
309 const int nquad2 =
m_base[2]->GetNumPoints();
310 const int order0 =
m_base[0]->GetNumModes();
311 const int order1 =
m_base[1]->GetNumModes();
313 nquad2*order0*(order1+1)/2);
315 if(multiplybyweights)
331 inarray,outarray,wsp,
371 const int nquad0 =
m_base[0]->GetNumPoints();
372 const int nquad1 =
m_base[1]->GetNumPoints();
373 const int nquad2 =
m_base[2]->GetNumPoints();
374 const int order0 =
m_base[0]->GetNumModes ();
375 const int order1 =
m_base[1]->GetNumModes ();
376 const int nqtot = nquad0*nquad1*nquad2;
394 nquad2*order0*(order1+1)/2);
403 Vmath::Vmul(nqtot,&df[3*dir][0], 1,tmp1.get(),1,tmp2.get(),1);
404 Vmath::Vmul(nqtot,&df[3*dir+1][0],1,tmp1.get(),1,tmp3.get(),1);
405 Vmath::Vmul(nqtot,&df[3*dir+2][0],1,tmp1.get(),1,tmp4.get(),1);
409 Vmath::Smul(nqtot, df[3*dir ][0],tmp1.get(),1,tmp2.get(), 1);
410 Vmath::Smul(nqtot, df[3*dir+1][0],tmp1.get(),1,tmp3.get(), 1);
411 Vmath::Smul(nqtot, df[3*dir+2][0],tmp1.get(),1,tmp4.get(), 1);
414 const int nq01 = nquad0*nquad1;
415 const int nq12 = nquad1*nquad2;
417 for(j = 0; j < nquad2; ++j)
419 for(i = 0; i < nquad1; ++i)
422 &h0[0]+i*nquad0 + j*nq01,1);
424 &h1[0]+i*nquad0 + j*nq01,1);
426 &h2[0]+i*nquad0 + j*nq01,1);
428 &h3[0]+i*nquad0 + j*nq01,1);
432 for(i = 0; i < nquad0; i++)
434 Blas::Dscal(nq12, 1+z0[i], &h1[0]+i, nquad0);
439 &tmp3[0], 1, &h1[0], 1,
442 &tmp5[0], 1, &tmp5[0], 1);
452 &tmp4[0], 1, &h3[0], 1,
488 return StdTetExp::v_PhysEvaluate(Lcoord,physvals);
504 m_geom->GetLocCoords(coord,Lcoord);
507 return StdTetExp::v_PhysEvaluate(Lcoord,physvals);
519 ASSERTL1(Lcoords[0] <= -1.0 && Lcoords[0] >= 1.0 &&
520 Lcoords[1] <= -1.0 && Lcoords[1] >= 1.0 &&
521 Lcoords[2] <= -1.0 && Lcoords[2] >= 1.0,
522 "Local coordinates are not in region [-1,1]");
526 for(i = 0; i <
m_geom->GetCoordim(); ++i)
528 coords[i] =
m_geom->GetCoord(i,Lcoords);
558 m_base[2]->GetBasisKey());
563 return m_geom->GetCoordim();
568 const std::vector<unsigned int > &nummodes,
569 const int mode_offset,
572 int data_order0 = nummodes[mode_offset];
573 int fillorder0 = min(
m_base[0]->GetNumModes(),data_order0);
574 int data_order1 = nummodes[mode_offset+1];
575 int order1 =
m_base[1]->GetNumModes();
576 int fillorder1 = min(order1,data_order1);
577 int data_order2 = nummodes[mode_offset+2];
578 int order2 =
m_base[2]->GetNumModes();
579 int fillorder2 = min(order2,data_order2);
591 "Extraction routine not set up for this basis");
594 "Extraction routine not set up for this basis");
597 for(j = 0; j < fillorder0; ++j)
599 for(i = 0; i < fillorder1-j; ++i)
603 cnt += data_order2-j-i;
608 for(i = fillorder1-j; i < data_order1-j; ++i)
610 cnt += data_order2-j-i;
613 for(i = fillorder1-j; i < order1-j; ++i)
622 ASSERTL0(
false,
"basis is either not set up or not "
633 int nquad0 =
m_base[0]->GetNumPoints();
634 int nquad1 =
m_base[1]->GetNumPoints();
635 int nquad2 =
m_base[2]->GetNumPoints();
647 if(outarray.num_elements()!=nq0*nq1)
652 for (
int i = 0; i < nquad0*nquad1; ++i)
663 if(outarray.num_elements()!=nq0*nq1)
669 for (
int k=0; k<nquad2; k++)
671 for(
int i = 0; i < nquad0; ++i)
673 outarray[k*nquad0+i] = (nquad0*nquad1*k)+i;
682 if(outarray.num_elements()!=nq0*nq1)
688 for(
int j = 0; j < nquad1*nquad2; ++j)
690 outarray[j] = nquad0-1 + j*nquad0;
698 if(outarray.num_elements() != nq0*nq1)
704 for(
int j = 0; j < nquad1*nquad2; ++j)
706 outarray[j] = j*nquad0;
711 ASSERTL0(
false,
"face value (> 3) is out of range");
740 for (i = 0; i < vCoordDim; ++i)
756 for (i = 0; i < vCoordDim; ++i)
758 normal[i][0] = -df[3*i+2][0];
765 for (i = 0; i < vCoordDim; ++i)
767 normal[i][0] = -df[3*i+1][0];
774 for (i = 0; i < vCoordDim; ++i)
776 normal[i][0] = df[3*i][0]+df[3*i+1][0]+
784 for(i = 0; i < vCoordDim; ++i)
786 normal[i][0] = -df[3*i][0];
791 ASSERTL0(
false,
"face is out of range (edge < 3)");
796 for (i = 0; i < vCoordDim; ++i)
798 fac += normal[i][0]*normal[i][0];
802 for (i = 0; i < vCoordDim; ++i)
812 int nq0 = ptsKeys[0].GetNumPoints();
813 int nq1 = ptsKeys[1].GetNumPoints();
814 int nq2 = ptsKeys[2].GetNumPoints();
845 for(j = 0; j < nq01; ++j)
847 normals[j] = -df[2][j]*jac[j];
848 normals[nqtot+j] = -df[5][j]*jac[j];
849 normals[2*nqtot+j] = -df[8][j]*jac[j];
853 points0 = ptsKeys[0];
854 points1 = ptsKeys[1];
860 for (j = 0; j < nq0; ++j)
862 for(k = 0; k < nq2; ++k)
866 -df[1][tmp]*jac[tmp];
867 normals[nqtot+j+k*nq0] =
868 -df[4][tmp]*jac[tmp];
869 normals[2*nqtot+j+k*nq0] =
870 -df[7][tmp]*jac[tmp];
871 faceJac[j+k*nq0] = jac[tmp];
875 points0 = ptsKeys[0];
876 points1 = ptsKeys[2];
882 for (j = 0; j < nq1; ++j)
884 for(k = 0; k < nq2; ++k)
886 int tmp = nq0-1+nq0*j+nq01*k;
888 (df[0][tmp]+df[1][tmp]+df[2][tmp])*
890 normals[nqtot+j+k*nq1] =
891 (df[3][tmp]+df[4][tmp]+df[5][tmp])*
893 normals[2*nqtot+j+k*nq1] =
894 (df[6][tmp]+df[7][tmp]+df[8][tmp])*
896 faceJac[j+k*nq1] = jac[tmp];
900 points0 = ptsKeys[1];
901 points1 = ptsKeys[2];
907 for (j = 0; j < nq1; ++j)
909 for(k = 0; k < nq2; ++k)
911 int tmp = j*nq0+nq01*k;
913 -df[0][tmp]*jac[tmp];
914 normals[nqtot+j+k*nq1] =
915 -df[3][tmp]*jac[tmp];
916 normals[2*nqtot+j+k*nq1] =
917 -df[6][tmp]*jac[tmp];
918 faceJac[j+k*nq1] = jac[tmp];
922 points0 = ptsKeys[1];
923 points1 = ptsKeys[2];
928 ASSERTL0(
false,
"face is out of range (face < 3)");
937 Vmath::Sdiv(nq_face, 1.0, &work[0], 1, &work[0], 1);
940 for(i = 0; i < vCoordDim; ++i)
947 Vmath::Vmul(nq_face,work,1,normal[i],1,normal[i],1);
954 Vmath::Vvtvp(nq_face,normal[i],1,normal[i],1,work,1,work,1);
962 Vmath::Vmul(nq_face,normal[i],1,work,1,normal[i],1);
994 StdExpansion::LaplacianMatrixOp_MatFree(k1,k2,inarray,outarray,
1021 StdTetExp::v_SVVLaplacianFilter( array, mkey);
1048 returnval = StdTetExp::v_GenMatrix(mkey);
1146 int rows = deriv0.GetRows();
1147 int cols = deriv1.GetColumns();
1151 (*WeakDeriv) = df[3*dir][0]*deriv0
1152 + df[3*dir+1][0]*deriv1
1153 + df[3*dir+2][0]*deriv2;
1197 int rows = lap00.GetRows();
1198 int cols = lap00.GetColumns();
1203 (*lap) = gmat[0][0]*lap00
1208 + gmat[7][0]*(lap12 +
Transpose(lap12));
1223 int rows = LapMat.GetRows();
1224 int cols = LapMat.GetColumns();
1229 (*helm) = LapMat + factor*MassMat;
1373 unsigned int nint = (
unsigned int)(
m_ncoeffs - nbdry);
1374 unsigned int exp_size[] = {nbdry, nint};
1375 unsigned int nblks = 2;
1387 goto UseLocRegionsMatrix;
1394 goto UseLocRegionsMatrix;
1399 factor = mat->Scale();
1400 goto UseStdRegionsMatrix;
1403 UseStdRegionsMatrix:
1418 UseLocRegionsMatrix:
1434 for(i = 0; i < nbdry; ++i)
1436 for(j = 0; j < nbdry; ++j)
1438 (*A)(i,j) = mat(bmap[i],bmap[j]);
1441 for(j = 0; j < nint; ++j)
1443 (*B)(i,j) = mat(bmap[i],imap[j]);
1447 for(i = 0; i < nint; ++i)
1449 for(j = 0; j < nbdry; ++j)
1451 (*C)(i,j) = mat(imap[i],bmap[j]);
1454 for(j = 0; j < nint; ++j)
1456 (*D)(i,j) = mat(imap[i],imap[j]);
1465 (*A) = (*A) - (*B)*(*C);
1490 return tmp->GetStdMatrix(mkey);
1515 if(inarray.get() == outarray.get())
1520 Blas::Dgemv(
'N',
m_ncoeffs,
m_ncoeffs,mat->Scale(),(mat->GetOwnedMatrix())->GetPtr().get(),
1521 m_ncoeffs, tmp.get(), 1, 0.0, outarray.get(), 1);
1525 Blas::Dgemv(
'N',
m_ncoeffs,
m_ncoeffs,mat->Scale(),(mat->GetOwnedMatrix())->GetPtr().get(),
1526 m_ncoeffs, inarray.get(), 1, 0.0, outarray.get(), 1);
1543 int nquad0 =
m_base[0]->GetNumPoints();
1544 int nquad1 =
m_base[1]->GetNumPoints();
1545 int nquad2 =
m_base[2]->GetNumPoints();
1546 int nqtot = nquad0*nquad1*nquad2;
1548 ASSERTL1(wsp.num_elements() >= 6*nqtot,
1549 "Insufficient workspace size.");
1551 "Workspace not set up for ncoeffs > nqtot");
1578 StdExpansion3D::PhysTensorDeriv(inarray,wsp0,wsp1,wsp2);
1584 Vmath::Vvtvvtp(nqtot,&metric00[0],1,&wsp0[0],1,&metric01[0],1,&wsp1[0],1,&wsp3[0],1);
1585 Vmath::Vvtvp (nqtot,&metric02[0],1,&wsp2[0],1,&wsp3[0],1,&wsp3[0],1);
1586 Vmath::Vvtvvtp(nqtot,&metric01[0],1,&wsp0[0],1,&metric11[0],1,&wsp1[0],1,&wsp4[0],1);
1587 Vmath::Vvtvp (nqtot,&metric12[0],1,&wsp2[0],1,&wsp4[0],1,&wsp4[0],1);
1588 Vmath::Vvtvvtp(nqtot,&metric02[0],1,&wsp0[0],1,&metric12[0],1,&wsp1[0],1,&wsp5[0],1);
1589 Vmath::Vvtvp (nqtot,&metric22[0],1,&wsp2[0],1,&wsp5[0],1,&wsp5[0],1);
1610 const unsigned int dim = 3;
1616 for (
unsigned int i = 0; i < dim; ++i)
1618 for (
unsigned int j = i; j < dim; ++j)
1651 const unsigned int nquad0 =
m_base[0]->GetNumPoints();
1652 const unsigned int nquad1 =
m_base[1]->GetNumPoints();
1653 const unsigned int nquad2 =
m_base[2]->GetNumPoints();
1655 for(j = 0; j < nquad2; ++j)
1657 for(i = 0; i < nquad1; ++i)
1659 Vmath::Fill(nquad0, 4.0/(1.0-z1[i])/(1.0-z2[j]), &h0[0]+i*nquad0 + j*nquad0*nquad1,1);
1660 Vmath::Fill(nquad0, 2.0/(1.0-z1[i])/(1.0-z2[j]), &h1[0]+i*nquad0 + j*nquad0*nquad1,1);
1661 Vmath::Fill(nquad0, 2.0/(1.0-z2[j]), &h2[0]+i*nquad0 + j*nquad0*nquad1,1);
1662 Vmath::Fill(nquad0, (1.0+z1[i])/(1.0-z2[j]), &h3[0]+i*nquad0 + j*nquad0*nquad1,1);
1665 for(i = 0; i < nquad0; i++)
1667 Blas::Dscal(nquad1*nquad2, 1+z0[i], &h1[0]+i, nquad0);
1676 Vmath::Vadd(nqtot, &df[1][0], 1, &df[2][0], 1, &wsp4[0], 1);
1677 Vmath::Vvtvvtp(nqtot, &df[0][0], 1, &h0[0], 1, &wsp4[0], 1, &h1[0], 1, &wsp4[0], 1);
1679 Vmath::Vadd(nqtot, &df[4][0], 1, &df[5][0], 1, &wsp5[0], 1);
1680 Vmath::Vvtvvtp(nqtot, &df[3][0], 1, &h0[0], 1, &wsp5[0], 1, &h1[0], 1, &wsp5[0], 1);
1682 Vmath::Vadd(nqtot, &df[7][0], 1, &df[8][0], 1, &wsp6[0], 1);
1683 Vmath::Vvtvvtp(nqtot, &df[6][0], 1, &h0[0], 1, &wsp6[0], 1, &h1[0], 1, &wsp6[0], 1);
1686 Vmath::Vvtvvtp(nqtot, &wsp4[0], 1, &wsp4[0], 1, &wsp5[0], 1, &wsp5[0], 1, &g0[0], 1);
1687 Vmath::Vvtvp (nqtot, &wsp6[0], 1, &wsp6[0], 1, &g0[0], 1, &g0[0], 1);
1690 Vmath::Vvtvvtp(nqtot, &df[2][0], 1, &wsp4[0], 1, &df[5][0], 1, &wsp5[0], 1, &g4[0], 1);
1691 Vmath::Vvtvp (nqtot, &df[8][0], 1, &wsp6[0], 1, &g4[0], 1, &g4[0], 1);
1695 Vmath::Vvtvvtp(nqtot, &df[1][0], 1, &h2[0], 1, &df[2][0], 1, &h3[0], 1, &wsp7[0], 1);
1697 Vmath::Vvtvvtp(nqtot, &df[4][0], 1, &h2[0], 1, &df[5][0], 1, &h3[0], 1, &wsp8[0], 1);
1699 Vmath::Vvtvvtp(nqtot, &df[7][0], 1, &h2[0], 1, &df[8][0], 1, &h3[0], 1, &wsp9[0], 1);
1702 Vmath::Vvtvvtp(nqtot, &wsp4[0], 1, &wsp7[0], 1, &wsp5[0], 1, &wsp8[0], 1, &g3[0], 1);
1703 Vmath::Vvtvp (nqtot, &wsp6[0], 1, &wsp9[0], 1, &g3[0], 1, &g3[0], 1);
1707 Vmath::Vvtvvtp(nqtot, &wsp7[0], 1, &wsp7[0], 1, &wsp8[0], 1, &wsp8[0], 1, &g1[0], 1);
1708 Vmath::Vvtvp (nqtot, &wsp9[0], 1, &wsp9[0], 1, &g1[0], 1, &g1[0], 1);
1711 Vmath::Vvtvvtp(nqtot, &df[2][0], 1, &wsp7[0], 1, &df[5][0], 1, &wsp8[0], 1, &g5[0], 1);
1712 Vmath::Vvtvp (nqtot, &df[8][0], 1, &wsp9[0], 1, &g5[0], 1, &g5[0], 1);
1715 Vmath::Vvtvvtp(nqtot, &df[2][0], 1, &df[2][0], 1, &df[5][0], 1, &df[5][0], 1, &g2[0], 1);
1716 Vmath::Vvtvp (nqtot, &df[8][0], 1, &df[8][0], 1, &g2[0], 1, &g2[0], 1);
1721 Vmath::Svtsvtp(nqtot, df[0][0], &h0[0], 1, df[1][0] + df[2][0], &h1[0], 1, &wsp4[0], 1);
1723 Vmath::Svtsvtp(nqtot, df[3][0], &h0[0], 1, df[4][0] + df[5][0], &h1[0], 1, &wsp5[0], 1);
1725 Vmath::Svtsvtp(nqtot, df[6][0], &h0[0], 1, df[7][0] + df[8][0], &h1[0], 1, &wsp6[0], 1);
1728 Vmath::Vvtvvtp(nqtot, &wsp4[0], 1, &wsp4[0], 1, &wsp5[0], 1, &wsp5[0], 1, &g0[0], 1);
1729 Vmath::Vvtvp (nqtot, &wsp6[0], 1, &wsp6[0], 1, &g0[0], 1, &g0[0], 1);
1732 Vmath::Svtsvtp(nqtot, df[2][0], &wsp4[0], 1, df[5][0], &wsp5[0], 1, &g4[0], 1);
1733 Vmath::Svtvp (nqtot, df[8][0], &wsp6[0], 1, &g4[0], 1, &g4[0], 1);
1737 Vmath::Svtsvtp(nqtot, df[1][0], &h2[0], 1, df[2][0], &h3[0], 1, &wsp7[0], 1);
1739 Vmath::Svtsvtp(nqtot, df[4][0], &h2[0], 1, df[5][0], &h3[0], 1, &wsp8[0], 1);
1741 Vmath::Svtsvtp(nqtot, df[7][0], &h2[0], 1, df[8][0], &h3[0], 1, &wsp9[0], 1);
1744 Vmath::Vvtvvtp(nqtot, &wsp4[0], 1, &wsp7[0], 1, &wsp5[0], 1, &wsp8[0], 1, &g3[0], 1);
1745 Vmath::Vvtvp (nqtot, &wsp6[0], 1, &wsp9[0], 1, &g3[0], 1, &g3[0], 1);
1749 Vmath::Vvtvvtp(nqtot, &wsp7[0], 1, &wsp7[0], 1, &wsp8[0], 1, &wsp8[0], 1, &g1[0], 1);
1750 Vmath::Vvtvp (nqtot, &wsp9[0], 1, &wsp9[0], 1, &g1[0], 1, &g1[0], 1);
1753 Vmath::Svtsvtp(nqtot, df[2][0], &wsp7[0], 1, df[5][0], &wsp8[0], 1, &g5[0], 1);
1754 Vmath::Svtvp (nqtot, df[8][0], &wsp9[0], 1, &g5[0], 1, &g5[0], 1);
1757 Vmath::Fill(nqtot, df[2][0]*df[2][0] + df[5][0]*df[5][0] + df[8][0]*df[8][0], &g2[0], 1);
1760 for (
unsigned int i = 0; i < dim; ++i)
1762 for (
unsigned int j = i; j < dim; ++j)
void ComputeLaplacianMetric()
const LibUtilities::PointsKeyVector GetPointsKeys() const
virtual DNekScalMatSharedPtr v_GetLocMatrix(const MatrixKey &mkey)
NekDouble GetConstFactor(const ConstFactorType &factor) const
DNekMatSharedPtr GenMatrix(const StdMatrixKey &mkey)
#define ASSERTL0(condition, msg)
const ConstFactorMap & GetConstFactors() const
virtual NekDouble v_Integral(const Array< OneD, const NekDouble > &inarray)
Integrate the physical point list inarray over region.
const VarCoeffMap & GetVarCoeffs() const
void GeneralMatrixOp_MatOp(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey)
std::vector< PointsKey > PointsKeyVector
Principle Modified Functions .
DNekMatSharedPtr BuildTransformationMatrix(const DNekScalMatSharedPtr &r_bnd, const StdRegions::MatrixType matrixType)
MatrixType GetMatrixType() const
static boost::shared_ptr< DataType > AllocateSharedPtr()
Allocate a shared pointer from the memory pool.
virtual void v_LaplacianMatrixOp_MatFree(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey)
void Vsqrt(int n, const T *x, const int incx, T *y, const int incy)
sqrt y = sqrt(x)
void MultiplyByQuadratureMetric(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...
virtual NekDouble v_StdPhysEvaluate(const Array< OneD, const NekDouble > &Lcoord, const Array< OneD, const NekDouble > &physvals)
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 Fill(int n, const T alpha, T *x, const int incx)
Fill a vector with a constant value.
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
Principle Modified Functions .
SpatialDomains::GeomFactorsSharedPtr m_metricinfo
void Sdiv(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Scalar multiply y = alpha/y.
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=m_base0*m_base1*m_base2 and put in...
LibUtilities::NekManager< MatrixKey, DNekScalMat, MatrixKey::opLess > m_matrixManager
DNekMatSharedPtr BuildVertexMatrix(const DNekScalMatSharedPtr &r_bnd)
LibUtilities::ShapeType GetShapeType() const
virtual void v_FwdTrans(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
Forward transform from physical quadrature space stored in inarray and evaluate the expansion coeffic...
virtual void v_HelmholtzMatrixOp(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey)
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.
SpatialDomains::GeometrySharedPtr m_geom
DNekScalBlkMatSharedPtr GetLocStaticCondMatrix(const LocalRegions::MatrixKey &mkey)
boost::shared_ptr< DNekMat > DNekMatSharedPtr
virtual DNekMatSharedPtr v_GenMatrix(const StdRegions::StdMatrixKey &mkey)
DNekMatSharedPtr GetStdMatrix(const StdMatrixKey &mkey)
boost::shared_ptr< DNekScalMat > DNekScalMatSharedPtr
LibUtilities::ShapeType DetShapeType() const
DNekScalBlkMatSharedPtr CreateStaticCondMatrix(const MatrixKey &mkey)
bool ConstFactorExists(const ConstFactorType &factor) const
virtual void v_LaplacianMatrixOp(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey)
int GetTotPoints() const
This function returns the total number of quadrature points used in the element.
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...
int NumBndryCoeffs(void) const
DNekBlkMatSharedPtr GetStdStaticCondMatrix(const StdMatrixKey &mkey)
void IProductWRTBase_SumFacKernel(const Array< OneD, const NekDouble > &base0, const Array< OneD, const NekDouble > &base1, const Array< OneD, const NekDouble > &base2, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, Array< OneD, NekDouble > &wsp, bool doCheckCollDir0, bool doCheckCollDir1, bool doCheckCollDir2)
virtual void v_ExtractDataToCoeffs(const NekDouble *data, const std::vector< unsigned int > &nummodes, const int mode_offset, NekDouble *coeffs)
Unpack data from input file assuming it comes from the same expansion type.
virtual DNekMatSharedPtr v_CreateStdMatrix(const StdRegions::StdMatrixKey &mkey)
void Smul(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Scalar multiply y = alpha*y.
LibUtilities::NekManager< MatrixKey, DNekScalBlkMat, MatrixKey::opLess > m_staticCondMatrixManager
int getNumberOfCoefficients(int Na)
Principle Modified Functions .
virtual void v_GetCoords(Array< OneD, NekDouble > &coords_1, Array< OneD, NekDouble > &coords_2, Array< OneD, NekDouble > &coords_3)
int GetNumPoints() const
Return points order at which basis is defined.
boost::shared_ptr< DNekScalBlkMat > DNekScalBlkMatSharedPtr
virtual void v_IProductWRTBase_SumFac(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, bool multiplybyweights=true)
void GetInteriorMap(Array< OneD, unsigned int > &outarray)
NekMatrix< InnerMatrixType, BlockMatrixTag > Transpose(NekMatrix< InnerMatrixType, BlockMatrixTag > &rhs)
Defines a specification for a set of points.
void v_ComputeFaceNormal(const int face)
Compute the normal of a triangular face.
virtual void v_GetFacePhysMap(const int face, Array< OneD, int > &outarray)
Returns the physical values at the quadrature points of a face.
virtual void v_SVVLaplacianFilter(Array< OneD, NekDouble > &array, const StdRegions::StdMatrixKey &mkey)
std::map< int, NormalVector > m_faceNormals
virtual DNekScalBlkMatSharedPtr v_GetLocStaticCondMatrix(const MatrixKey &mkey)
LibUtilities::BasisType GetBasisType(const int dir) const
This function returns the type of basis used in the dir direction.
virtual StdRegions::StdExpansionSharedPtr v_GetStdExp(void) const
virtual void v_LaplacianMatrixOp_MatFree_Kernel(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, Array< OneD, NekDouble > &wsp)
boost::shared_ptr< DNekBlkMat > DNekBlkMatSharedPtr
DNekScalMatSharedPtr GetLocMatrix(const LocalRegions::MatrixKey &mkey)
virtual NekDouble v_PhysEvaluate(const Array< OneD, const NekDouble > &coords, const Array< OneD, const NekDouble > &physvals)
virtual int v_GetCoordim()
virtual DNekMatSharedPtr v_GenMatrix(const StdRegions::StdMatrixKey &mkey)
PointsKey GetPointsKey() const
Return distribution of points.
SpatialDomains::GeometrySharedPtr GetGeom() const
boost::shared_ptr< GeomFactors > GeomFactorsSharedPtr
Pointer to a GeomFactors object.
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):
virtual void v_IProductWRTDerivBase(const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
Calculates the inner product .
#define ASSERTL2(condition, msg)
Assert Level 2 – Debugging which is used FULLDEBUG compilation mode. This level assert is designed t...
Geometry is straight-sided with constant geometric factors.
void ComputeQuadratureMetric()
boost::shared_ptr< TetGeom > TetGeomSharedPtr
virtual void v_GetCoord(const Array< OneD, const NekDouble > &Lcoords, Array< OneD, NekDouble > &coords)
Get the coordinates "coords" at the local coordinates "Lcoords".
int GetNcoeffs(void) const
This function returns the total number of coefficients used in the expansion.
DNekScalMatSharedPtr CreateMatrix(const MatrixKey &mkey)
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):
const LibUtilities::BasisKey DetFaceBasisKey(const int i, const int k) const
boost::shared_ptr< StdTetExp > StdTetExpSharedPtr
GeomType
Indicates the type of element geometry.
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)
Differentiate inarray in the three coordinate directions.
void Zero(int n, T *x, const int incx)
Zero vector.
boost::shared_ptr< StdExpansion > StdExpansionSharedPtr
virtual void v_HelmholtzMatrixOp_MatFree(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey)
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Array< OneD, LibUtilities::BasisSharedPtr > m_base
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Geometry is curved or has non-constant factors.
void GetBoundaryMap(Array< OneD, unsigned int > &outarray)
void v_DropLocStaticCondMatrix(const MatrixKey &mkey)
Describes the specification for a Basis.
virtual void v_ComputeLaplacianMetric()
virtual void v_GetCoords(Array< OneD, NekDouble > &coords_1, Array< OneD, NekDouble > &coords_2, Array< OneD, NekDouble > &coords_3)
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 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.
virtual LibUtilities::ShapeType v_DetShapeType() const
Return Shape of region, using ShapeType enum list.