45 namespace LocalRegions
56 boost::bind(&
TriExp::CreateMatrix, this, _1),
57 std::string(
"TriExpMatrix")),
58 m_staticCondMatrixManager(
59 boost::bind(&
TriExp::CreateStaticCondMatrix, this, _1),
60 std::string(
"TriExpStaticCondMatrix"))
71 m_matrixManager(T.m_matrixManager),
72 m_staticCondMatrixManager(T.m_staticCondMatrixManager)
85 int nquad0 =
m_base[0]->GetNumPoints();
86 int nquad1 =
m_base[1]->GetNumPoints();
94 Vmath::Vmul(nquad0*nquad1, jac, 1, inarray, 1,tmp, 1);
98 Vmath::Smul(nquad0*nquad1, jac[0], inarray, 1, tmp, 1);
102 ival = StdTriExp::v_Integral(tmp);
112 int nquad0 =
m_base[0]->GetNumPoints();
113 int nquad1 =
m_base[1]->GetNumPoints();
114 int nqtot = nquad0*nquad1;
121 StdTriExp::v_PhysDeriv(inarray, diff0, diff1);
125 if(out_d0.num_elements())
128 Vmath::Vvtvp (nqtot,df[1],1,diff1,1, out_d0, 1, out_d0,1);
131 if(out_d1.num_elements())
134 Vmath::Vvtvp (nqtot,df[3],1,diff1,1, out_d1, 1, out_d1,1);
137 if(out_d2.num_elements())
140 Vmath::Vvtvp (nqtot,df[5],1,diff1,1, out_d2, 1, out_d2,1);
145 if(out_d0.num_elements())
147 Vmath::Smul (nqtot, df[0][0], diff0, 1, out_d0, 1);
148 Blas::Daxpy (nqtot, df[1][0], diff1, 1, out_d0, 1);
151 if(out_d1.num_elements())
153 Vmath::Smul (nqtot, df[2][0], diff0, 1, out_d1, 1);
154 Blas::Daxpy (nqtot, df[3][0], diff1, 1, out_d1, 1);
157 if(out_d2.num_elements())
159 Vmath::Smul (nqtot, df[4][0], diff0, 1, out_d2, 1);
160 Blas::Daxpy (nqtot, df[5][0], diff1, 1, out_d2, 1);
189 ASSERTL1(
false,
"input dir is out of range");
200 if(! out.num_elements())
205 int nquad0 =
m_base[0]->GetNumPoints();
206 int nquad1 =
m_base[1]->GetNumPoints();
207 int nqtot = nquad0*nquad1;
216 StdTriExp::v_PhysDeriv(inarray, diff0, diff1);
225 for (
int i=0; i< 2; ++i)
228 for (
int k=0; k<(
m_geom->GetCoordim()); ++k)
230 Vmath::Vvtvp(nqtot,&df[2*k+i][0],1,&direction[k*nqtot],1,&tangmat[i][0],1,&tangmat[i][0],1);
235 Vmath::Vmul (nqtot,&tangmat[0][0],1,&diff0[0],1, &out[0], 1);
236 Vmath::Vvtvp (nqtot,&tangmat[1][0],1,&diff1[0],1, &out[0], 1, &out[0],1);
267 int npoints[2] = {
m_base[0]->GetNumPoints(),
268 m_base[1]->GetNumPoints()};
269 int nmodes[2] = {
m_base[0]->GetNumModes(),
270 m_base[1]->GetNumModes()};
272 fill(outarray.get(), outarray.get()+
m_ncoeffs, 0.0 );
276 for(i = 0; i < 3; i++)
283 for(i = 0; i < npoints[0]; i++)
285 physEdge[0][i] = inarray[i];
289 for(i = 0; i < npoints[1]; i++)
291 physEdge[1][i] = inarray[npoints[0]-1+i*npoints[0]];
292 physEdge[2][i] = inarray[i*npoints[0]];
300 for(i = 1; i < 3; i++)
307 for(i = 1; i < 3; i++)
312 m_base[0]->GetPointsKey(),physEdge[i]);
314 npoints[1] = npoints[0];
325 for(i = 0; i < 3; i++)
327 segexp[i]->FwdTrans_BndConstrained(physEdge[i],coeffEdge[i]);
332 for(j=0; j < nmodes[i!=0]; j++)
335 outarray[ mapArray[j] ] = sign * coeffEdge[i][j];
340 int nInteriorDofs =
m_ncoeffs - nBoundaryDofs;
342 if (nInteriorDofs > 0) {
363 for(i = 0; i < nInteriorDofs; i++)
365 rhs[i] = tmp1[ mapArray[i] ];
368 Blas::Dgemv(
'N', nInteriorDofs, nInteriorDofs, matsys->Scale(), &((matsys->GetOwnedMatrix())->GetPtr())[0],
369 nInteriorDofs,rhs.get(),1,0.0,result.get(),1);
371 for(i = 0; i < nInteriorDofs; i++)
373 outarray[ mapArray[i] ] = result[i];
396 bool multiplybyweights)
398 int nquad0 =
m_base[0]->GetNumPoints();
399 int nquad1 =
m_base[1]->GetNumPoints();
400 int order0 =
m_base[0]->GetNumModes();
402 if(multiplybyweights)
415 inarray,outarray,wsp);
427 Blas::Dgemv(
'N',
m_ncoeffs,nq,iprodmat->Scale(),(iprodmat->GetOwnedMatrix())->GetPtr().get(),
428 m_ncoeffs, inarray.get(), 1, 0.0, outarray.get(), 1);
437 ASSERTL1((dir==0)||(dir==1)||(dir==2),
"Invalid direction.");
438 ASSERTL1((dir==2)?(
m_geom->GetCoordim()==3):
true,
"Invalid direction.");
441 int nquad0 =
m_base[0]->GetNumPoints();
442 int nquad1 =
m_base[1]->GetNumPoints();
443 int nqtot = nquad0*nquad1;
444 int nmodes0 =
m_base[0]->GetNumModes();
445 int wspsize = max(max(nqtot,
m_ncoeffs),nquad1*nmodes0);
461 for(i = 0; i < nquad1; ++i)
463 gfac0[i] = 2.0/(1-z1[i]);
465 for(i = 0; i < nquad0; ++i)
467 gfac1[i] = 0.5*(1+z0[i]);
470 for(i = 0; i < nquad1; ++i)
472 Vmath::Smul(nquad0,gfac0[i],&inarray[0]+i*nquad0,1,&tmp0[0]+i*nquad0,1);
475 for(i = 0; i < nquad1; ++i)
477 Vmath::Vmul(nquad0,&gfac1[0],1,&tmp0[0]+i*nquad0,1,&tmp1[0]+i*nquad0,1);
482 Vmath::Vmul(nqtot,&df[2*dir][0], 1,&tmp0[0], 1,&tmp0[0],1);
483 Vmath::Vmul(nqtot,&df[2*dir+1][0],1,&tmp1[0], 1,&tmp1[0],1);
484 Vmath::Vmul(nqtot,&df[2*dir+1][0],1,&inarray[0],1,&tmp2[0],1);
488 Vmath::Smul(nqtot, df[2*dir][0], tmp0, 1, tmp0, 1);
489 Vmath::Smul(nqtot, df[2*dir+1][0], tmp1, 1, tmp1, 1);
490 Vmath::Smul(nqtot, df[2*dir+1][0], inarray, 1, tmp2, 1);
529 ASSERTL1(
false,
"input dir is out of range");
537 Blas::Dgemv(
'N',
m_ncoeffs,nq,iprodmat->Scale(),(iprodmat->GetOwnedMatrix())->GetPtr().get(),
538 m_ncoeffs, inarray.get(), 1, 0.0, outarray.get(), 1);
548 int nq =
m_base[0]->GetNumPoints()*
m_base[1]->GetNumPoints();
558 &normals[1][0],1,&Fy[0],1,&Fn[0],1);
559 Vmath::Vvtvp (nq,&normals[2][0],1,&Fz[0],1,&Fn[0],1,&Fn[0],1);
564 normals[1][0],&Fy[0],1,&Fn[0],1);
565 Vmath::Svtvp (nq,normals[2][0],&Fz[0],1,&Fn[0],1,&Fn[0],1);
583 m_base[1]->GetBasisKey());
589 2,
m_base[0]->GetPointsKey());
591 2,
m_base[1]->GetPointsKey());
602 ASSERTL1(Lcoords[0] >= -1.0 && Lcoords[1] <= 1.0 &&
603 Lcoords[1] >= -1.0 && Lcoords[1] <=1.0,
604 "Local coordinates are not in region [-1,1]");
608 for(i = 0; i <
m_geom->GetCoordim(); ++i)
610 coords[i] =
m_geom->GetCoord(i,Lcoords);
633 return StdTriExp::v_PhysEvaluate(Lcoord,physvals);
641 m_geom->GetLocCoords(coord,Lcoord);
643 return StdTriExp::v_PhysEvaluate(Lcoord, physvals);
662 int nquad0 =
m_base[0]->GetNumPoints();
663 int nquad1 =
m_base[1]->GetNumPoints();
688 -nquad0, &(outarray[0]),1);
695 -nquad0,&(outarray[0]),1);
704 ASSERTL0(
false,
"edge value (< 3) is out of range");
713 int nquad0 =
m_base[0]->GetNumPoints();
714 int nquad1 =
m_base[1]->GetNumPoints();
720 Vmath::Vcopy(nquad0, &(inarray[0]), 1, &(outarray[0]), 1);
724 nquad0, &(outarray[0]), 1);
727 Vmath::Vcopy(nquad1, &(inarray[0]), nquad0, &(outarray[0]), 1);
730 ASSERTL0(
false,
"edge value (< 3) is out of range");
735 if(
m_base[edge?1:0]->GetPointsKey() != EdgeExp->GetBasis(0)->GetPointsKey())
743 EdgeExp->GetBasis(0)->GetPointsKey(),
762 "Routine not implemented for triangular elements");
770 "Routine not implemented for triangular elements");
779 int nquad0 =
m_base[0]->GetNumPoints();
780 int nquad1 =
m_base[1]->GetNumPoints();
787 for (
int i = 0; i < nquad0; ++i)
794 for (
int i = 0; i < nquad1; ++i)
796 outarray[i] = (nquad0-1) + i * nquad0;
801 for (
int i = 0; i < nquad1; ++i)
803 outarray[i] = i*nquad0;
807 ASSERTL0(
false,
"edge value (< 3) is out of range");
822 int nqe =
m_base[0]->GetNumPoints();
827 for (i = 0; i < dim; ++i)
848 Vmath::Fill(nqe,df[2*i+1][0] + df[2*i][0],normal[i],1);
858 ASSERTL0(
false,
"Edge is out of range (edge < 3)");
865 fac += normal[i][0]*normal[i][0];
877 int nquad0 = ptsKeys[0].GetNumPoints();
878 int nquad1 = ptsKeys[1].GetNumPoints();
891 for(j = 0; j < nquad0; ++j)
896 normals[i*nquad0+j] = -df[2*i+1][j]*edgejac[j];
899 from_key = ptsKeys[0];
902 for(j = 0; j < nquad1; ++j)
904 edgejac[j] = jac[nquad0*j+nquad0-1];
907 normals[i*nquad1+j] = (df[2*i][nquad0*j + nquad0-1] + df[2*i+1][nquad0*j + nquad0-1])*edgejac[j];
910 from_key = ptsKeys[1];
913 for(j = 0; j < nquad1; ++j)
915 edgejac[j] = jac[nquad0*j];
918 normals[i*nquad1+j] = -df[2*i][nquad0*j]*edgejac[j];
921 from_key = ptsKeys[1];
924 ASSERTL0(
false,
"edge is out of range (edge < 3)");
946 Vmath::Vvtvp(nqe,normal[i],1, normal[i],1,work,1,work,1);
981 return m_geom->GetCoordim();
987 const std::vector<unsigned int > &nummodes,
988 const int mode_offset,
990 std::vector<LibUtilities::BasisType> &fromType)
992 int data_order0 = nummodes[mode_offset];
993 int fillorder0 = min(
m_base[0]->GetNumModes(),data_order0);
994 int data_order1 = nummodes[mode_offset+1];
995 int order1 =
m_base[1]->GetNumModes();
996 int fillorder1 = min(order1,data_order1);
1007 "Extraction routine not set up for this basis");
1010 for(i = 0; i < fillorder0; ++i)
1012 Vmath::Vcopy(fillorder1-i,&data[cnt],1,&coeffs[cnt1],1);
1013 cnt += data_order1-i;
1019 ASSERTL0(
false,
"basis is either not set up or not hierarchicial");
1032 return GetGeom2D()->GetCartesianEorient(edge);
1038 ASSERTL1(dir >= 0 &&dir <= 1,
"input dir is out of range");
1064 returnval = StdTriExp::v_GenMatrix(mkey);
1079 return tmp->GetStdMatrix(mkey);
1169 int rows = deriv0.GetRows();
1170 int cols = deriv1.GetColumns();
1173 (*WeakDeriv) = df[2*dir][0]*deriv0 + df[2*dir+1][0]*deriv1;
1206 int rows = lap00.GetRows();
1207 int cols = lap00.GetColumns();
1211 (*lap) = gmat[0][0] * lap00 +
1212 gmat[1][0] * (lap01 +
Transpose(lap01)) +
1235 int rows = LapMat.GetRows();
1236 int cols = LapMat.GetColumns();
1241 (*helm) = LapMat + factor*MassMat;
1302 int rows = stdiprod0.GetRows();
1303 int cols = stdiprod1.GetColumns();
1306 (*mat) = df[2*dir][0]*stdiprod0 + df[2*dir+1][0]*stdiprod1;
1359 unsigned int nint = (
unsigned int)(
m_ncoeffs - nbdry);
1360 unsigned int exp_size[] = {nbdry,nint};
1361 unsigned int nblks = 2;
1372 goto UseLocRegionsMatrix;
1377 goto UseStdRegionsMatrix;
1382 goto UseLocRegionsMatrix;
1384 UseStdRegionsMatrix:
1399 UseLocRegionsMatrix:
1417 for(i = 0; i < nbdry; ++i)
1419 for(j = 0; j < nbdry; ++j)
1421 (*A)(i,j) = mat(bmap[i],bmap[j]);
1424 for(j = 0; j < nint; ++j)
1426 (*B)(i,j) = mat(bmap[i],imap[j]);
1430 for(i = 0; i < nint; ++i)
1432 for(j = 0; j < nbdry; ++j)
1434 (*C)(i,j) = mat(imap[i],bmap[j]);
1437 for(j = 0; j < nint; ++j)
1439 (*D)(i,j) = mat(imap[i],imap[j]);
1448 (*A) = (*A) - (*B)*(*C);
1487 StdExpansion::MassMatrixOp_MatFree(inarray,outarray,mkey);
1504 StdExpansion::LaplacianMatrixOp_MatFree(k1,k2,inarray,outarray,mkey);
1513 StdExpansion::WeakDerivMatrixOp_MatFree(i,inarray,outarray,mkey);
1521 StdExpansion::WeakDirectionalDerivMatrixOp_MatFree(inarray,outarray,mkey);
1529 StdExpansion::MassLevelCurvatureMatrixOp_MatFree(inarray,outarray,mkey);
1547 if(inarray.get() == outarray.get())
1552 Blas::Dgemv(
'N',
m_ncoeffs,
m_ncoeffs,mat->Scale(),(mat->GetOwnedMatrix())->GetPtr().get(),
1553 m_ncoeffs, tmp.get(), 1, 0.0, outarray.get(), 1);
1557 Blas::Dgemv(
'N',
m_ncoeffs,
m_ncoeffs,mat->Scale(),(mat->GetOwnedMatrix())->GetPtr().get(),
1558 m_ncoeffs, inarray.get(), 1, 0.0, outarray.get(), 1);
1573 int nquad0 =
m_base[0]->GetNumPoints();
1574 int nquad1 =
m_base[1]->GetNumPoints();
1575 int nqtot = nquad0*nquad1;
1576 int nmodes0 =
m_base[0]->GetNumModes();
1577 int nmodes1 =
m_base[1]->GetNumModes();
1578 int wspsize = max(max(max(nqtot,
m_ncoeffs),nquad1*nmodes0),nquad0*nmodes1);
1580 ASSERTL1(wsp.num_elements() >= 3*wspsize,
1581 "Workspace is of insufficient size.");
1596 StdExpansion2D::PhysTensorDeriv(inarray,wsp1,wsp2);
1602 Vmath::Vvtvvtp(nqtot,&metric00[0],1,&wsp1[0],1,&metric01[0],1,&wsp2[0],1,&wsp0[0],1);
1603 Vmath::Vvtvvtp(nqtot,&metric01[0],1,&wsp1[0],1,&metric11[0],1,&wsp2[0],1,&wsp2[0],1);
1626 const unsigned int dim = 2;
1635 for (i = 0; i < dim; ++i)
1637 for (j = i; j < dim; ++j)
1645 const unsigned int nquad0 =
m_base[0]->GetNumPoints();
1646 const unsigned int nquad1 =
m_base[1]->GetNumPoints();
1650 for(i = 0; i < nquad1; i++)
1652 Blas::Dscal(nquad0,2.0/(1-z1[i]),&dEta_dXi[0][0]+i*nquad0,1);
1653 Blas::Dscal(nquad0,2.0/(1-z1[i]),&dEta_dXi[1][0]+i*nquad0,1);
1655 for(i = 0; i < nquad0; i++)
1657 Blas::Dscal(nquad1,0.5*(1+z0[i]),&dEta_dXi[1][0]+i,nquad0);
1664 Vmath::Smul (nqtot,df[0][0],&dEta_dXi[0][0],1,&tmp[0],1);
1665 Vmath::Svtvp(nqtot,df[1][0],&dEta_dXi[1][0],1,&tmp[0],1,&tmp[0],1);
1671 Vmath::Smul (nqtot,df[2][0],&dEta_dXi[0][0],1,&tmp[0],1);
1672 Vmath::Svtvp(nqtot,df[3][0],&dEta_dXi[1][0],1,&tmp[0],1,&tmp[0],1);
1679 Vmath::Smul (nqtot,df[4][0],&dEta_dXi[0][0],1,&tmp[0],1);
1680 Vmath::Svtvp(nqtot,df[5][0],&dEta_dXi[1][0],1,&tmp[0],1,&tmp[0],1);
1686 NekDouble g2 = df[1][0]*df[1][0] + df[3][0]*df[3][0];
1689 g2 += df[5][0]*df[5][0];
1696 Vmath::Vmul (nqtot,&df[0][0],1,&dEta_dXi[0][0],1,&tmp[0],1);
1697 Vmath::Vvtvp(nqtot,&df[1][0],1,&dEta_dXi[1][0],1,&tmp[0],1,&tmp[0],1);
1704 Vmath::Vmul (nqtot,&df[2][0],1,&dEta_dXi[0][0],1,&tmp[0],1);
1705 Vmath::Vvtvp(nqtot,&df[3][0],1,&dEta_dXi[1][0],1,&tmp[0],1,&tmp[0],1);
1713 Vmath::Vmul (nqtot,&df[4][0],1,&dEta_dXi[0][0],1,&tmp[0],1);
1714 Vmath::Vvtvp(nqtot,&df[5][0],1,&dEta_dXi[1][0],1,&tmp[0],1,&tmp[0],1);
1722 for (
unsigned int i = 0; i < dim; ++i)
1724 for (
unsigned int j = i; j < dim; ++j)
1750 int n_coeffs = inarray.num_elements();
1751 int nquad0 =
m_base[0]->GetNumPoints();
1752 int nquad1 =
m_base[1]->GetNumPoints();
1753 int nqtot = nquad0*nquad1;
1754 int nmodes0 =
m_base[0]->GetNumModes();
1755 int nmodes1 =
m_base[1]->GetNumModes();
1756 int numMin2 = nmodes0, i;
1790 m_TriExp ->BwdTrans(inarray,phys_tmp);
1791 m_OrthoTriExp->FwdTrans(phys_tmp, coeff);
1793 for (i = 0; i < n_coeffs; i++)
1798 numMin += numMin2 - 1;
1803 m_OrthoTriExp->BwdTrans(coeff,phys_tmp);
1804 m_TriExp ->FwdTrans(phys_tmp, outarray);
1830 StdTriExp::v_SVVLaplacianFilter( array, mkey);
LibUtilities::NekManager< MatrixKey, DNekScalMat, MatrixKey::opLess > m_matrixManager
void ComputeLaplacianMetric()
const LibUtilities::PointsKeyVector GetPointsKeys() const
boost::shared_ptr< StdTriExp > StdTriExpSharedPtr
virtual NekDouble v_StdPhysEvaluate(const Array< OneD, const NekDouble > &Lcoord, const Array< OneD, const NekDouble > &physvals)
LibUtilities::ShapeType DetShapeType() const
This function returns the shape of the expansion domain.
NekDouble GetConstFactor(const ConstFactorType &factor) const
DNekMatSharedPtr GenMatrix(const StdMatrixKey &mkey)
#define ASSERTL0(condition, msg)
StdRegions::Orientation GetCartesianEorient(int edge)
const ConstFactorMap & GetConstFactors() const
const VarCoeffMap & GetVarCoeffs() const
std::vector< PointsKey > PointsKeyVector
virtual int v_GetCoordim()
MatrixType GetMatrixType() const
virtual DNekScalBlkMatSharedPtr v_GetLocStaticCondMatrix(const MatrixKey &mkey)
void MassMatrixOp(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
static Array< OneD, NekDouble > NullNekDouble1DArray
LibUtilities::NekManager< MatrixKey, DNekScalBlkMat, MatrixKey::opLess > m_staticCondMatrixManager
virtual StdRegions::StdExpansionSharedPtr v_GetLinStdExp(void) const
static boost::shared_ptr< DataType > AllocateSharedPtr()
Allocate a shared pointer from the memory pool.
#define sign(a, b)
return the sign(b)*a
void IProductWRTDerivBase_SumFac(const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
void Vsqrt(int n, const T *x, const int incx, T *y, const int incy)
sqrt y = sqrt(x)
virtual int v_GetNumPoints(const int dir) const
void MultiplyByQuadratureMetric(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
virtual void v_MassLevelCurvatureMatrixOp(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey)
virtual void v_IProductWRTDerivBase(const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
General purpose memory allocation routines with the ability to allocate from thread specific memory p...
void 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.
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.
void LaplacianMatrixOp_MatFree(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
virtual void v_WeakDirectionalDerivMatrixOp(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey)
int GetNumPoints(const int dir) const
This function returns the number of quadrature points in the dir direction.
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 .
void NormVectorIProductWRTBase(const Array< OneD, const NekDouble > &Fx, Array< OneD, NekDouble > &outarray)
std::map< int, StdRegions::NormalVector > m_edgeNormals
SpatialDomains::GeomFactorsSharedPtr m_metricinfo
StdRegions::Orientation GetEorient(int edge)
void Sdiv(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Scalar multiply y = alpha/y.
DNekMatSharedPtr BuildVertexMatrix(const DNekScalMatSharedPtr &r_bnd)
LibUtilities::ShapeType GetShapeType() const
virtual void v_GetCoords(Array< OneD, NekDouble > &coords_1, Array< OneD, NekDouble > &coords_2, Array< OneD, NekDouble > &coords_3)
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
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.
DNekScalBlkMatSharedPtr GetLocStaticCondMatrix(const LocalRegions::MatrixKey &mkey)
boost::shared_ptr< DNekMat > DNekMatSharedPtr
virtual DNekMatSharedPtr v_GenMatrix(const StdRegions::StdMatrixKey &mkey)
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.
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)
DNekMatSharedPtr GetStdMatrix(const StdMatrixKey &mkey)
boost::shared_ptr< DNekScalMat > DNekScalMatSharedPtr
void IProductWRTBase_SumFac(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, bool multiplybyweights=true)
virtual void v_GetEdgePhysVals(const int edge, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
Extract the physical values along edge edge from inarray into outarray following the local edge orien...
virtual void v_HelmholtzMatrixOp(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey)
Principle Orthogonal Functions .
virtual void v_ExtractDataToCoeffs(const NekDouble *data, const std::vector< unsigned int > &nummodes, const int mode_offset, NekDouble *coeffs, std::vector< LibUtilities::BasisType > &fromType)
bool ConstFactorExists(const ConstFactorType &factor) const
int GetTotPoints() const
This function returns the total number of quadrature points used in the element.
virtual void v_IProductWRTDerivBase_MatOp(const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
virtual void v_IProductWRTDerivBase_SumFac(const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
virtual void v_ComputeEdgeNormal(const int edge)
int NumBndryCoeffs(void) const
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)
DNekBlkMatSharedPtr GetStdStaticCondMatrix(const StdMatrixKey &mkey)
boost::shared_ptr< SegExp > SegExpSharedPtr
virtual void v_ComputeLaplacianMetric()
SpatialDomains::Geometry2DSharedPtr GetGeom2D() const
void Reverse(int n, const T *x, const int incx, T *y, const int incy)
void Smul(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Scalar multiply y = alpha*y.
int getNumberOfCoefficients(int Na)
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_IProductWRTBase_MatOp(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_GetTracePhysVals(const int edge, const StdRegions::StdExpansionSharedPtr &EdgeExp, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, StdRegions::Orientation orient)
Principle Modified Functions .
virtual void v_GetCoords(Array< OneD, NekDouble > &coords_1, Array< OneD, NekDouble > &coords_2, Array< OneD, NekDouble > &coords_3)
virtual void v_GetEdgeQFactors(const int edge, Array< OneD, NekDouble > &outarray)
boost::shared_ptr< DNekScalBlkMat > DNekScalBlkMatSharedPtr
virtual DNekScalBlkMatSharedPtr CreateStaticCondMatrix(const MatrixKey &mkey)
void GetInteriorMap(Array< OneD, unsigned int > &outarray)
Principle Orthogonal Functions .
NekMatrix< InnerMatrixType, BlockMatrixTag > Transpose(NekMatrix< InnerMatrixType, BlockMatrixTag > &rhs)
Defines a specification for a set of points.
Expansion3DSharedPtr GetLeftAdjacentElementExp() const
virtual StdRegions::StdExpansionSharedPtr v_GetStdExp(void) const
virtual DNekMatSharedPtr v_GenMatrix(const StdRegions::StdMatrixKey &mkey)
LibUtilities::BasisType GetBasisType(const int dir) const
This function returns the type of basis used in the dir direction.
virtual const LibUtilities::BasisSharedPtr & v_GetBasis(int dir) const
virtual void v_GeneralMatrixOp_MatOp(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey)
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.
boost::shared_ptr< DNekBlkMat > DNekBlkMatSharedPtr
DNekScalMatSharedPtr GetLocMatrix(const LocalRegions::MatrixKey &mkey)
virtual void v_FwdTrans_BndConstrained(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
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 void v_ReduceOrderCoeffs(int numMin, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
virtual StdRegions::Orientation v_GetCartesianEorient(int edge)
SpatialDomains::GeometrySharedPtr GetGeom() const
boost::shared_ptr< GeomFactors > GeomFactorsSharedPtr
Pointer to a GeomFactors object.
void GetEdgeToElementMap(const int eid, const Orientation edgeOrient, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray, int P=-1)
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 DNekScalMatSharedPtr v_GetLocMatrix(const MatrixKey &mkey)
#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 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 HelmholtzMatrixOp_MatFree(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
unsigned int GetNumPoints() const
virtual void v_WeakDerivMatrixOp(const int i, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey)
virtual void v_SVVLaplacianFilter(Array< OneD, NekDouble > &array, const StdRegions::StdMatrixKey &mkey)
void ComputeQuadratureMetric()
virtual void v_MassMatrixOp(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey)
boost::shared_ptr< TriGeom > TriGeomSharedPtr
virtual void v_GetCoord(const Array< OneD, const NekDouble > &Lcoords, Array< OneD, NekDouble > &coords)
int GetLeftAdjacentElementFace() const
virtual StdRegions::Orientation v_GetEorient(int edge)
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):
virtual void v_IProductWRTBase_SumFac(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, bool multiplybyweights=true)
virtual void v_LaplacianMatrixOp(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)
GeomType
Indicates the type of element geometry.
boost::shared_ptr< Basis > BasisSharedPtr
virtual void v_LaplacianMatrixOp_MatFree_Kernel(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, Array< OneD, NekDouble > &wsp)
void Zero(int n, T *x, const int incx)
Zero vector.
void v_DropLocStaticCondMatrix(const MatrixKey &mkey)
boost::shared_ptr< StdExpansion > StdExpansionSharedPtr
LibUtilities::PointsType GetPointsType(const int dir) const
This function returns the type of quadrature points used in the dir direction.
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
virtual void v_GetEdgePhysMap(const int edge, Array< OneD, int > &outarray)
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)
virtual DNekMatSharedPtr v_CreateStdMatrix(const StdRegions::StdMatrixKey &mkey)
Describes the specification for a Basis.
1D Gauss-Lobatto-Legendre quadrature points
void Vadd(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Add vector z = x+y.
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 void v_GetEdgeInterpVals(const int edge, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
virtual DNekScalMatSharedPtr CreateMatrix(const MatrixKey &mkey)