47 StdTriExp::StdTriExp()
65 "order in 'a' direction is higher than order "
86 int nquad1 =
m_base[1]->GetNumPoints();
103 for(i = 0; i < nquad1; ++i)
105 w1_tmp[i] = 0.5*(1-z1[i])*w1[i];
137 int nquad0 =
m_base[0]->GetNumPoints();
138 int nquad1 =
m_base[1]->GetNumPoints();
145 for (i = 0; i < nquad1; ++i)
147 wsp[i] = 2.0/(1-z1[i]);
150 if (out_d0.num_elements() > 0)
154 for (i = 0; i < nquad1; ++i)
156 Blas::Dscal(nquad0,wsp[i],&out_d0[0]+i*nquad0,1);
160 if (out_d1.num_elements() > 0)
163 for (i = 0; i < nquad0; ++i)
165 wsp[i] = 0.5*(1+z0[i]);
168 for (i = 0; i < nquad1; ++i)
171 1,&out_d1[0]+i*nquad0,
172 1,&out_d1[0]+i*nquad0,1);
176 else if (out_d1.num_elements() > 0)
181 for (i = 0; i < nquad1; ++i)
183 Blas::Dscal(nquad0,wsp[i],&diff0[0]+i*nquad0,1);
186 for (i = 0; i < nquad0; ++i)
188 wsp[i] = 0.5*(1+z0[i]);
191 for (i = 0; i < nquad1; ++i)
194 1,&out_d1[0]+i*nquad0,
195 1,&out_d1[0]+i*nquad0,1);
219 ASSERTL1(
false,
"input dir is out of range");
265 m_base[1]->GetNumModes());
269 inarray,outarray,wsp);
278 bool doCheckCollDir0,
279 bool doCheckCollDir1)
283 int nquad0 =
m_base[0]->GetNumPoints();
284 int nquad1 =
m_base[1]->GetNumPoints();
285 int nmodes0 =
m_base[0]->GetNumModes();
286 int nmodes1 =
m_base[1]->GetNumModes();
288 ASSERTL1(wsp.num_elements() >= nquad0*nmodes1,
289 "Workspace size is not sufficient");
292 "Basis[1] is not of general tensor type");
294 for (i = mode = 0; i < nmodes0; ++i)
296 Blas::Dgemv(
'N', nquad1,nmodes1-i,1.0,base1.get()+mode*nquad1,
297 nquad1,&inarray[0]+mode,1,0.0,&wsp[0]+i*nquad1,1);
304 Blas::Daxpy(nquad1,inarray[1],base1.get()+nquad1,1,
308 Blas::Dgemm(
'N',
'T', nquad0,nquad1,nmodes0,1.0, base0.get(),nquad0,
309 &wsp[0], nquad1,0.0, &outarray[0], nquad0);
335 int npoints[2] = {
m_base[0]->GetNumPoints(),
336 m_base[1]->GetNumPoints()};
337 int nmodes[2] = {
m_base[0]->GetNumModes(),
338 m_base[1]->GetNumModes()};
340 fill(outarray.get(), outarray.get()+
m_ncoeffs, 0.0 );
344 for(i = 0; i < 3; i++)
350 for(i = 0; i < npoints[0]; i++)
352 physEdge[0][i] = inarray[i];
355 for(i = 0; i < npoints[1]; i++)
357 physEdge[1][i] = inarray[npoints[0]-1+i*npoints[0]];
358 physEdge[2][i] = inarray[(npoints[1]-1)*npoints[0]-i*npoints[0]];
363 m_base[0]->GetBasisKey()),
372 for (i = 0; i < 3; i++)
375 segexp[i!=0]->FwdTrans_BndConstrained(physEdge[i],coeffEdge[i]);
378 for (j = 0; j < nmodes[i != 0]; j++)
381 outarray[ mapArray[j] ] = sign * coeffEdge[i][j];
401 int nInteriorDofs =
m_ncoeffs - nBoundaryDofs;
408 for (i = 0; i < nInteriorDofs; i++)
410 rhs[i] = tmp1[ mapArray[i] ];
413 Blas::Dgemv(
'N',nInteriorDofs,nInteriorDofs,
414 1.0,&(matsys->GetPtr())[0],nInteriorDofs,
418 for (i = 0; i < nInteriorDofs; i++)
420 outarray[ mapArray[i] ] = result[i];
481 Blas::Dgemv(
'N',
m_ncoeffs,nq,1.0,iprodmat->GetPtr().get(),
482 m_ncoeffs, inarray.get(), 1, 0.0, outarray.get(), 1);
488 bool multiplybyweights)
490 int nquad0 =
m_base[0]->GetNumPoints();
491 int nquad1 =
m_base[1]->GetNumPoints();
492 int order0 =
m_base[0]->GetNumModes();
494 if(multiplybyweights)
510 inarray,outarray,wsp);
520 bool doCheckCollDir0,
521 bool doCheckCollDir1)
525 int nquad0 =
m_base[0]->GetNumPoints();
526 int nquad1 =
m_base[1]->GetNumPoints();
527 int nmodes0 =
m_base[0]->GetNumModes();
528 int nmodes1 =
m_base[1]->GetNumModes();
530 ASSERTL1(wsp.num_elements() >= nquad1*nmodes0,
531 "Workspace size is not sufficient");
533 Blas::Dgemm(
'T',
'N',nquad1,nmodes0,nquad0,1.0,inarray.get(),nquad0,
534 base0.get(),nquad0,0.0,wsp.get(),nquad1);
537 for (mode=i=0; i < nmodes0; ++i)
539 Blas::Dgemv(
'T',nquad1,nmodes1-i,1.0, base1.get()+mode*nquad1,
540 nquad1,wsp.get()+i*nquad1,1, 0.0,
541 outarray.get() + mode,1);
548 outarray[1] +=
Blas::Ddot(nquad1,base1.get()+nquad1,1,
583 ASSERTL1(
false,
"input dir is out of range");
591 Blas::Dgemv(
'N',
m_ncoeffs,nq,1.0,iprodmat->GetPtr().get(),
592 m_ncoeffs, inarray.get(), 1, 0.0, outarray.get(), 1);
601 int nquad0 =
m_base[0]->GetNumPoints();
602 int nquad1 =
m_base[1]->GetNumPoints();
603 int nqtot = nquad0*nquad1;
604 int nmodes0 =
m_base[0]->GetNumModes();
605 int wspsize = max(max(nqtot,
m_ncoeffs),nquad1*nmodes0);
613 for(i = 0; i < nquad1; ++i)
615 gfac0[i] = 2.0/(1-z1[i]);
618 for(i = 0; i < nquad1; ++i)
620 Vmath::Smul(nquad0,gfac0[i],&inarray[0]+i*nquad0,1,
621 &tmp0[0]+i*nquad0,1);
632 tmp0,outarray,gfac0);
640 for (i = 0; i < nquad0; ++i)
642 gfac0[i] = 0.5*(1+z0[i]);
645 for (i = 0; i < nquad1; ++i)
647 Vmath::Vmul(nquad0,&gfac0[0],1,&tmp0[0]+i*nquad0,1,
648 &tmp0[0]+i*nquad0,1);
658 tmp0,outarray,gfac0);
665 ASSERTL1(
false,
"input dir is out of range");
687 eta[0] = 2*(1+xi[0])/(1-xi[1])-1.0;
696 int nquad0 =
m_base[0]->GetNumPoints();
697 int nquad1 =
m_base[1]->GetNumPoints();
698 int order0 =
m_base[0]->GetNumModes();
699 int order1 =
m_base[1]->GetNumModes();
705 "calling argument mode is larger than "
706 "total expansion order");
709 for (i = 0; i < order0; ++i, m+=order1-i)
726 for (i = 0; i < nquad1; ++i)
729 1,&outarray[0]+i*nquad0,1);
733 for(i = 0; i < nquad0; ++i)
736 1,&outarray[0]+i,nquad0,&outarray[0]+i,nquad0);
759 "BasisType is not a boundary interior form");
761 "BasisType is not a boundary interior form");
769 "BasisType is not a boundary interior form");
771 "BasisType is not a boundary interior form");
778 ASSERTL2(i >= 0 && i <= 2,
"edge id is out of range");
792 ASSERTL2((i >= 0)&&(i <= 2),
"edge id is out of range");
805 const std::vector<unsigned int> &nummodes,
809 nummodes[modes_offset],
810 nummodes[modes_offset+1]);
818 ASSERTL2(i >= 0 && i <= 2,
"edge id is out of range");
841 for(i = 0; i < nq1; ++i)
843 for(j = 0; j < nq0; ++j)
845 coords_0[i*nq0+j] = (1+z0[j])*(1-z1[i])/2.0 - 1.0;
859 ASSERTL2(edge >= 0 && edge <= 2,
"edge id is out of range");
861 return edge == 0 ? 0 : 1;
867 ASSERTL2(i >= 0 && i <= 2,
"edge id is out of range");
884 m_base[1]->GetBasisKey().GetPointsKey().
889 m_base[1]->GetNumModes(),pkey);
894 ASSERTL0(
false,
"unexpected points distribution");
899 ASSERTL0(
false,
"Information not available to set edge key");
921 "Mapping not defined for this type of basis");
925 int order0 =
m_base[0]->GetNumModes();
926 int order1 =
m_base[1]->GetNumModes();
939 bool checkForZeroedModes =
false;
944 else if(P != numModes)
946 checkForZeroedModes =
true;
950 if(maparray.num_elements() != P)
955 if(signarray.num_elements() != P)
961 fill(signarray.get() , signarray.get()+P, 1);
969 for(i = 0; i < P; cnt+=order1-i, ++i)
976 swap( maparray[0] , maparray[1] );
978 for(i = 3; i < P; i+=2)
987 maparray[0] = order1;
989 for(i = 2; i < P; i++)
991 maparray[i] = order1-1+i;
996 swap( maparray[0] , maparray[1] );
998 for(i = 3; i < P; i+=2)
1007 for(i = 0; i < P; i++)
1014 swap( maparray[0] , maparray[1] );
1016 for(i = 3; i < P; i+=2)
1024 ASSERTL0(
false,
"eid must be between 0 and 2");
1029 if (checkForZeroedModes)
1033 for (
int j = numModes; j < P; j++)
1036 maparray[j] = maparray[0];
1046 "Mapping not defined for this type of basis");
1049 if(useCoeffPacking ==
true)
1051 switch(localVertexId)
1065 localDOF =
m_base[1]->GetNumModes();
1070 ASSERTL0(
false,
"eid must be between 0 and 2");
1077 switch(localVertexId)
1086 localDOF =
m_base[1]->GetNumModes();
1096 ASSERTL0(
false,
"eid must be between 0 and 2");
1113 "Mapping not defined for this type of basis");
1115 const int nummodes1 =
m_base[1]->GetNumModes();
1118 if(maparray.num_elements() != nEdgeIntCoeffs)
1123 if(signarray.num_elements() != nEdgeIntCoeffs)
1129 fill( signarray.get() , signarray.get()+nEdgeIntCoeffs, 1 );
1136 int cnt = 2*nummodes1 - 1;
1137 for(i = 0; i < nEdgeIntCoeffs; cnt+=nummodes1-2-i, ++i)
1144 for(i = 1; i < nEdgeIntCoeffs; i+=2)
1153 for(i = 0; i < nEdgeIntCoeffs; i++)
1155 maparray[i] = nummodes1+1+i;
1160 for(i = 1; i < nEdgeIntCoeffs; i+=2)
1169 for(i = 0; i < nEdgeIntCoeffs; i++)
1176 for(i = 1; i < nEdgeIntCoeffs; i+=2)
1185 ASSERTL0(
false,
"eid must be between 0 and 2");
1195 "Expansion not of a proper type");
1199 int nummodes0, nummodes1;
1206 nummodes0 =
m_base[0]->GetNumModes();
1207 nummodes1 =
m_base[1]->GetNumModes();
1209 startvalue = 2*nummodes1;
1211 for(i = 0; i < nummodes0-2; i++)
1213 for(j = 0; j < nummodes1-3-i; j++)
1215 outarray[cnt++]=startvalue+j;
1217 startvalue+=nummodes1-2-i;
1225 "Expansion not of expected type");
1228 int nummodes0, nummodes1;
1236 nummodes0 =
m_base[0]->GetNumModes();
1237 nummodes1 =
m_base[1]->GetNumModes();
1239 value = 2*nummodes1-1;
1240 for(i = 0; i < value; i++)
1246 for(i = 0; i < nummodes0-2; i++)
1248 outarray[cnt++]=value;
1249 value += nummodes1-2-i;
1271 nq0 =
m_base[0]->GetNumPoints();
1272 nq1 =
m_base[1]->GetNumPoints();
1295 for(
int i = 0; i < nq; ++i)
1297 for(
int j = 0; j < nq-i; ++j,++cnt)
1300 coords[cnt][0] = -1.0 + 2*j/(
NekDouble)(nq-1);
1301 coords[cnt][1] = -1.0 + 2*i/(
NekDouble)(nq-1);
1305 for(
int i = 0; i < neq; ++i)
1309 I[0] =
m_base[0]->GetI(coll);
1310 I[1] =
m_base[1]->GetI(coll+1);
1313 for (
int j = 0; j < nq1; ++j)
1319 Mat->GetRawPtr() + j*nq0*neq + i, neq);
1369 k1,k2,inarray,outarray,mkey);
1393 int qa =
m_base[0]->GetNumPoints();
1394 int qb =
m_base[1]->GetNumPoints();
1395 int nmodes_a =
m_base[0]->GetNumModes();
1396 int nmodes_b =
m_base[1]->GetNumModes();
1397 int nmodes = min(nmodes_a,nmodes_b);
1425 OrthoExp.
FwdTrans(tmp,orthocoeffs);
1428 for(
int j = 0; j < nmodes_a; ++j)
1430 for(
int k = 0; k < nmodes_b-j; ++k, ++cnt)
1434 *pow(j/(nmodes_a-1)+k/(nmodes_b-1),0.5*nmodes));
1439 OrthoExp.
BwdTrans(orthocoeffs,tmp);
1449 min(nmodes_a,nmodes_b));
1452 int nmodes = min(nmodes_a,nmodes_b);
1455 OrthoExp.
FwdTrans(array,orthocoeffs);
1458 for(j = 0; j < nmodes_a; ++j)
1460 for(k = 0; k < nmodes_b-j; ++k)
1464 orthocoeffs[cnt] *= (SvvDiffCoeff
1465 *exp(-(j+k-nmodes)*(j+k-nmodes)
1467 *(j+k-cutoff+epsilon)))));
1471 orthocoeffs[cnt] *= 0.0;
1478 OrthoExp.
BwdTrans(orthocoeffs,array);
1487 int n_coeffs = inarray.num_elements();
1488 int nquad0 =
m_base[0]->GetNumPoints();
1489 int nquad1 =
m_base[1]->GetNumPoints();
1494 int nqtot = nquad0*nquad1;
1497 int nmodes0 =
m_base[0]->GetNumModes();
1498 int nmodes1 =
m_base[1]->GetNumModes();
1499 int numMin2 = nmodes0;
1521 m_TriExp ->BwdTrans(inarray,phys_tmp);
1522 m_OrthoTriExp->FwdTrans(phys_tmp, coeff);
1524 for (i = 0; i < n_coeffs; i++)
1529 numMin += numMin2 - 1;
1534 m_OrthoTriExp->BwdTrans(coeff,phys_tmp);
1535 m_TriExp ->FwdTrans(phys_tmp, outarray);
1546 if(inarray.get() == outarray.get())
1552 m_ncoeffs, tmp.get(), 1, 0.0, outarray.get(), 1);
1557 m_ncoeffs, inarray.get(), 1, 0.0, outarray.get(), 1);
1570 int nquad0 =
m_base[0]->GetNumPoints();
1571 int nquad1 =
m_base[1]->GetNumPoints();
1578 for(i = 0; i < nquad1; ++i)
1581 w0.get(),1, outarray.get()+i*nquad0,1);
1589 for(i = 0; i < nquad1; ++i)
1591 Blas::Dscal(nquad0,0.5*(1-z1[i])*w1[i],
1592 outarray.get()+i*nquad0,1);
1598 for(i = 0; i < nquad1; ++i)
1600 Blas::Dscal(nquad0,0.5*w1[i],outarray.get()+i*nquad0,1);
1605 ASSERTL0(
false,
"Unsupported quadrature points type.");
1614 int np1 =
m_base[0]->GetNumPoints();
1615 int np2 =
m_base[1]->GetNumPoints();
1616 int np = max(np1,np2);
1623 for(
int i = 0; i < np-1; ++i)
1626 for(
int j = 0; j < np-i-2; ++j)
1628 conn[cnt++] = row +j;
1629 conn[cnt++] = row +j+1;
1630 conn[cnt++] = rowp1 +j;
1632 conn[cnt++] = rowp1 +j+1;
1633 conn[cnt++] = rowp1 +j;
1634 conn[cnt++] = row +j+1;
1637 conn[cnt++] = row +np-i-2;
1638 conn[cnt++] = row +np-i-1;
1639 conn[cnt++] = rowp1+np-i-2;
boost::shared_ptr< StdTriExp > StdTriExpSharedPtr
LibUtilities::ShapeType DetShapeType() const
This function returns the shape of the expansion domain.
virtual void v_IProductWRTDerivBase_MatOp(const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
NekDouble GetConstFactor(const ConstFactorType &factor) const
#define ASSERTL0(condition, msg)
const LibUtilities::BasisSharedPtr & GetBasis(int dir) const
This function gets the shared point to basis in the dir direction.
virtual void v_GeneralMatrixOp_MatOp(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
MatrixType GetMatrixType() const
virtual void v_BwdTrans(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
Backward tranform for triangular elements.
virtual void v_GetEdgeToElementMap(const int eid, const Orientation edgeOrient, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray, int P=-1)
void MassMatrixOp(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
static Array< OneD, NekDouble > NullNekDouble1DArray
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)
static boost::shared_ptr< DataType > AllocateSharedPtr()
Allocate a shared pointer from the memory pool.
int GetBasisNumModes(const int dir) const
This function returns the number of expansion modes in the dir direction.
bool HasVarCoeff(const StdRegions::VarCoeffType &coeff) const
#define sign(a, b)
return the sign(b)*a
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)
virtual void v_MultiplyByStdQuadratureMetric(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
virtual LibUtilities::ShapeType v_DetShapeType() const
void Fill(int n, const T alpha, T *x, const int incx)
Fill a vector with a constant value.
virtual int v_NumDGBndryCoeffs() const
virtual void v_WeakDerivMatrixOp(const int i, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
void LaplacianMatrixOp_MatFree(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
virtual void v_FwdTrans_BndConstrained(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
const Array< OneD, const NekDouble > & GetVarCoeff(const StdRegions::VarCoeffType &coeff) const
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...
int GetNumPoints(const int dir) const
This function returns the number of quadrature points in the dir direction.
virtual void v_HelmholtzMatrixOp(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
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 LocCoordToLocCollapsed(const Array< OneD, const NekDouble > &xi, Array< OneD, NekDouble > &eta)
Convert local cartesian coordinate xi into local collapsed coordinates eta.
NekDouble Integral(const Array< OneD, const NekDouble > &inarray, const Array< OneD, const NekDouble > &w0, const Array< OneD, const NekDouble > &w1)
virtual void v_IProductWRTDerivBase_SumFac(const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
virtual void v_LaplacianMatrixOp_MatFree(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey)
LibUtilities::NekManager< StdMatrixKey, DNekBlkMat, StdMatrixKey::opLess > m_stdStaticCondMatrixManager
virtual int v_GetEdgeNumPoints(const int i) const
int GetEdgeNcoeffs(const int i) const
This function returns the number of expansion coefficients belonging to the i-th edge.
boost::shared_ptr< StdSegExp > StdSegExpSharedPtr
boost::shared_ptr< DNekMat > DNekMatSharedPtr
virtual void v_GetInteriorMap(Array< OneD, unsigned int > &outarray)
virtual void v_SVVLaplacianFilter(Array< OneD, NekDouble > &array, const StdMatrixKey &mkey)
virtual void v_LocCoordToLocCollapsed(const Array< OneD, const NekDouble > &xi, Array< OneD, NekDouble > &eta)
DNekMatSharedPtr GetStdMatrix(const StdMatrixKey &mkey)
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...
Gauss Radau pinned at x=-1, .
virtual int v_DetCartesianDirOfEdge(const int edge)
virtual int v_NumBndryCoeffs() const
virtual DNekMatSharedPtr v_GenMatrix(const StdMatrixKey &mkey)
Principle Orthogonal Functions .
bool ConstFactorExists(const ConstFactorType &factor) const
1D Evenly-spaced points using Lagrange polynomial
int GetTotPoints() const
This function returns the total number of quadrature points used in the element.
virtual int v_CalcNumberOfCoefficients(const std::vector< unsigned int > &nummodes, int &modes_offset)
virtual void v_GetSimplexEquiSpacedConnectivity(Array< OneD, int > &conn, bool standard=true)
virtual void v_ReduceOrderCoeffs(int numMin, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
virtual int v_GetNverts() const
int NumBndryCoeffs(void) const
LibUtilities::BasisType GetEdgeBasisType(const int i) const
This function returns the type of expansion basis on the i-th edge.
virtual LibUtilities::BasisType v_GetEdgeBasisType(const int i) const
The base class for all shapes.
virtual void v_GetBoundaryMap(Array< OneD, unsigned int > &outarray)
static const NekDouble kNekZeroTol
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_MassMatrixOp(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
Principle Modified Functions .
virtual void v_LaplacianMatrixOp(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
virtual DNekMatSharedPtr v_CreateStdMatrix(const StdMatrixKey &mkey)
void WeakDerivMatrixOp_MatFree(const int i, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
int getNumberOfCoefficients(int Na, int Nb)
DNekMatSharedPtr CreateGeneralMatrix(const StdMatrixKey &mkey)
this function generates the mass matrix
Principle Orthogonal Functions .
Defines a specification for a set of points.
virtual void v_IProductWRTBase_SumFac(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, bool multiplybyweights=true)
virtual void v_IProductWRTBase_MatOp(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
virtual void v_BwdTrans_SumFac(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
T Ddot(int n, const Array< OneD, const T > &w, const int incw, const Array< OneD, const T > &x, const int incx, const Array< OneD, const int > &y, const int incy)
LibUtilities::BasisType GetBasisType(const int dir) const
This function returns the type of basis used in the dir direction.
virtual int v_GetEdgeNcoeffs(const int i) const
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)
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.
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 NekDouble v_Integral(const Array< OneD, const NekDouble > &inarray)
Integrates the specified function over the domain.
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_IProductWRTDerivBase(const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
#define ASSERTL2(condition, msg)
Assert Level 2 – Debugging which is used FULLDEBUG compilation mode. This level assert is designed t...
void MassMatrixOp_MatFree(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
virtual bool v_IsBoundaryInteriorExpansion()
void BwdTrans(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
This function performs the Backward transformation from coefficient space to physical space...
virtual int v_GetVertexMap(int localVertexId, bool useCoeffPacking=false)
virtual void v_FillMode(const int mode, Array< OneD, NekDouble > &outarray)
virtual int v_GetNedges() const
static const BasisKey NullBasisKey(eNoBasisType, 0, NullPointsKey)
Defines a null basis with no type or points.
int GetNcoeffs(void) const
This function returns the total number of coefficients used in the expansion.
LibUtilities::NekManager< StdMatrixKey, DNekMat, StdMatrixKey::opLess > m_stdMatrixManager
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 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 GetNumModes() const
Returns the order of the basis.
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_GetEdgeInteriorMap(const int eid, const Orientation edgeOrient, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray)
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...
Array< OneD, LibUtilities::BasisSharedPtr > m_base
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
virtual void v_GetCoords(Array< OneD, NekDouble > &coords_x, Array< OneD, NekDouble > &coords_y, Array< OneD, NekDouble > &coords_z)
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_HelmholtzMatrixOp_MatFree(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey)
virtual const LibUtilities::BasisKey v_DetEdgeBasisKey(const int edge) const
void FwdTrans(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
This function performs the Forward transformation from physical space to coefficient space...