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();
148 if (out_d0.num_elements() > 0)
152 for (i = 0; i < nquad1; ++i)
154 Blas::Dscal(nquad0,wsp[i],&out_d0[0]+i*nquad0,1);
158 if (out_d1.num_elements() > 0)
164 for (i = 0; i < nquad1; ++i)
167 1,&out_d1[0]+i*nquad0,
168 1,&out_d1[0]+i*nquad0,1);
172 else if (out_d1.num_elements() > 0)
177 for (i = 0; i < nquad1; ++i)
179 Blas::Dscal(nquad0,wsp[i],&diff0[0]+i*nquad0,1);
185 for (i = 0; i < nquad1; ++i)
188 1,&out_d1[0]+i*nquad0,
189 1,&out_d1[0]+i*nquad0,1);
213 ASSERTL1(
false,
"input dir is out of range");
259 m_base[1]->GetNumModes());
263 inarray,outarray,wsp);
272 bool doCheckCollDir0,
273 bool doCheckCollDir1)
277 int nquad0 =
m_base[0]->GetNumPoints();
278 int nquad1 =
m_base[1]->GetNumPoints();
279 int nmodes0 =
m_base[0]->GetNumModes();
280 int nmodes1 =
m_base[1]->GetNumModes();
282 ASSERTL1(wsp.num_elements() >= nquad0*nmodes1,
283 "Workspace size is not sufficient");
286 "Basis[1] is not of general tensor type");
288 for (i = mode = 0; i < nmodes0; ++i)
290 Blas::Dgemv(
'N', nquad1,nmodes1-i,1.0,base1.get()+mode*nquad1,
291 nquad1,&inarray[0]+mode,1,0.0,&wsp[0]+i*nquad1,1);
298 Blas::Daxpy(nquad1,inarray[1],base1.get()+nquad1,1,
302 Blas::Dgemm(
'N',
'T', nquad0,nquad1,nmodes0,1.0, base0.get(),nquad0,
303 &wsp[0], nquad1,0.0, &outarray[0], nquad0);
329 int npoints[2] = {
m_base[0]->GetNumPoints(),
330 m_base[1]->GetNumPoints()};
331 int nmodes[2] = {
m_base[0]->GetNumModes(),
332 m_base[1]->GetNumModes()};
334 fill(outarray.get(), outarray.get()+
m_ncoeffs, 0.0 );
338 for(i = 0; i < 3; i++)
344 for(i = 0; i < npoints[0]; i++)
346 physEdge[0][i] = inarray[i];
349 for(i = 0; i < npoints[1]; i++)
351 physEdge[1][i] = inarray[npoints[0]-1+i*npoints[0]];
352 physEdge[2][i] = inarray[(npoints[1]-1)*npoints[0]-i*npoints[0]];
357 m_base[0]->GetBasisKey()),
366 for (i = 0; i < 3; i++)
369 segexp[i!=0]->FwdTrans_BndConstrained(physEdge[i],coeffEdge[i]);
372 for (j = 0; j < nmodes[i != 0]; j++)
375 outarray[ mapArray[j] ] = sign * coeffEdge[i][j];
395 int nInteriorDofs =
m_ncoeffs - nBoundaryDofs;
402 for (i = 0; i < nInteriorDofs; i++)
404 rhs[i] = tmp1[ mapArray[i] ];
407 Blas::Dgemv(
'N',nInteriorDofs,nInteriorDofs,
408 1.0,&(matsys->GetPtr())[0],nInteriorDofs,
412 for (i = 0; i < nInteriorDofs; i++)
414 outarray[ mapArray[i] ] = result[i];
475 Blas::Dgemv(
'N',
m_ncoeffs,nq,1.0,iprodmat->GetPtr().get(),
476 m_ncoeffs, inarray.get(), 1, 0.0, outarray.get(), 1);
482 bool multiplybyweights)
484 int nquad0 =
m_base[0]->GetNumPoints();
485 int nquad1 =
m_base[1]->GetNumPoints();
486 int order0 =
m_base[0]->GetNumModes();
488 if(multiplybyweights)
504 inarray,outarray,wsp);
514 bool doCheckCollDir0,
515 bool doCheckCollDir1)
519 int nquad0 =
m_base[0]->GetNumPoints();
520 int nquad1 =
m_base[1]->GetNumPoints();
521 int nmodes0 =
m_base[0]->GetNumModes();
522 int nmodes1 =
m_base[1]->GetNumModes();
524 ASSERTL1(wsp.num_elements() >= nquad1*nmodes0,
525 "Workspace size is not sufficient");
527 Blas::Dgemm(
'T',
'N',nquad1,nmodes0,nquad0,1.0,inarray.get(),nquad0,
528 base0.get(),nquad0,0.0,wsp.get(),nquad1);
531 for (mode=i=0; i < nmodes0; ++i)
533 Blas::Dgemv(
'T',nquad1,nmodes1-i,1.0, base1.get()+mode*nquad1,
534 nquad1,wsp.get()+i*nquad1,1, 0.0,
535 outarray.get() + mode,1);
542 outarray[1] +=
Blas::Ddot(nquad1,base1.get()+nquad1,1,
577 ASSERTL1(
false,
"input dir is out of range");
585 Blas::Dgemv(
'N',
m_ncoeffs,nq,1.0,iprodmat->GetPtr().get(),
586 m_ncoeffs, inarray.get(), 1, 0.0, outarray.get(), 1);
595 int nquad0 =
m_base[0]->GetNumPoints();
596 int nquad1 =
m_base[1]->GetNumPoints();
597 int nqtot = nquad0*nquad1;
598 int nmodes0 =
m_base[0]->GetNumModes();
599 int wspsize = max(max(nqtot,
m_ncoeffs),nquad1*nmodes0);
607 for(i = 0; i < nquad1; ++i)
609 gfac0[i] = 2.0/(1-z1[i]);
612 for(i = 0; i < nquad1; ++i)
614 Vmath::Smul(nquad0,gfac0[i],&inarray[0]+i*nquad0,1,
615 &tmp0[0]+i*nquad0,1);
626 tmp0,outarray,gfac0);
634 for (i = 0; i < nquad0; ++i)
636 gfac0[i] = 0.5*(1+z0[i]);
639 for (i = 0; i < nquad1; ++i)
641 Vmath::Vmul(nquad0,&gfac0[0],1,&tmp0[0]+i*nquad0,1,
642 &tmp0[0]+i*nquad0,1);
652 tmp0,outarray,gfac0);
659 ASSERTL1(
false,
"input dir is out of range");
681 eta[0] = 2*(1+xi[0])/(1-xi[1])-1.0;
690 int nquad0 =
m_base[0]->GetNumPoints();
691 int nquad1 =
m_base[1]->GetNumPoints();
692 int order0 =
m_base[0]->GetNumModes();
693 int order1 =
m_base[1]->GetNumModes();
699 "calling argument mode is larger than "
700 "total expansion order");
703 for (i = 0; i < order0; ++i, m+=order1-i)
720 for (i = 0; i < nquad1; ++i)
723 1,&outarray[0]+i*nquad0,1);
727 for(i = 0; i < nquad0; ++i)
730 1,&outarray[0]+i,nquad0,&outarray[0]+i,nquad0);
753 "BasisType is not a boundary interior form");
755 "BasisType is not a boundary interior form");
763 "BasisType is not a boundary interior form");
765 "BasisType is not a boundary interior form");
772 ASSERTL2(i >= 0 && i <= 2,
"edge id is out of range");
786 ASSERTL2((i >= 0)&&(i <= 2),
"edge id is out of range");
799 const std::vector<unsigned int> &nummodes,
803 nummodes[modes_offset],
804 nummodes[modes_offset+1]);
812 ASSERTL2(i >= 0 && i <= 2,
"edge id is out of range");
835 for(i = 0; i < nq1; ++i)
837 for(j = 0; j < nq0; ++j)
839 coords_0[i*nq0+j] = (1+z0[j])*(1-z1[i])/2.0 - 1.0;
853 ASSERTL2(edge >= 0 && edge <= 2,
"edge id is out of range");
855 return edge == 0 ? 0 : 1;
861 ASSERTL2(i >= 0 && i <= 2,
"edge id is out of range");
878 m_base[1]->GetBasisKey().GetPointsKey().
883 m_base[1]->GetNumModes(),pkey);
888 ASSERTL0(
false,
"unexpected points distribution");
893 ASSERTL0(
false,
"Information not available to set edge key");
915 "Mapping not defined for this type of basis");
919 int order0 =
m_base[0]->GetNumModes();
920 int order1 =
m_base[1]->GetNumModes();
933 bool checkForZeroedModes =
false;
938 else if(P != numModes)
940 checkForZeroedModes =
true;
944 if(maparray.num_elements() !=
P)
949 if(signarray.num_elements() !=
P)
955 fill(signarray.get() , signarray.get()+
P, 1);
963 for(i = 0; i <
P; cnt+=order1-i, ++i)
970 swap( maparray[0] , maparray[1] );
972 for(i = 3; i <
P; i+=2)
981 maparray[0] = order1;
983 for(i = 2; i <
P; i++)
985 maparray[i] = order1-1+i;
990 swap( maparray[0] , maparray[1] );
992 for(i = 3; i <
P; i+=2)
1001 for(i = 0; i <
P; i++)
1008 swap( maparray[0] , maparray[1] );
1010 for(i = 3; i <
P; i+=2)
1018 ASSERTL0(
false,
"eid must be between 0 and 2");
1023 if (checkForZeroedModes)
1027 for (
int j = numModes; j <
P; j++)
1030 maparray[j] = maparray[0];
1040 "Mapping not defined for this type of basis");
1043 if(useCoeffPacking ==
true)
1045 switch(localVertexId)
1059 localDOF =
m_base[1]->GetNumModes();
1064 ASSERTL0(
false,
"eid must be between 0 and 2");
1071 switch(localVertexId)
1080 localDOF =
m_base[1]->GetNumModes();
1090 ASSERTL0(
false,
"eid must be between 0 and 2");
1107 "Mapping not defined for this type of basis");
1109 const int nummodes1 =
m_base[1]->GetNumModes();
1112 if(maparray.num_elements() != nEdgeIntCoeffs)
1117 if(signarray.num_elements() != nEdgeIntCoeffs)
1123 fill( signarray.get() , signarray.get()+nEdgeIntCoeffs, 1 );
1130 int cnt = 2*nummodes1 - 1;
1131 for(i = 0; i < nEdgeIntCoeffs; cnt+=nummodes1-2-i, ++i)
1138 for(i = 1; i < nEdgeIntCoeffs; i+=2)
1147 for(i = 0; i < nEdgeIntCoeffs; i++)
1149 maparray[i] = nummodes1+1+i;
1154 for(i = 1; i < nEdgeIntCoeffs; i+=2)
1163 for(i = 0; i < nEdgeIntCoeffs; i++)
1170 for(i = 1; i < nEdgeIntCoeffs; i+=2)
1179 ASSERTL0(
false,
"eid must be between 0 and 2");
1189 "Expansion not of a proper type");
1193 int nummodes0, nummodes1;
1200 nummodes0 =
m_base[0]->GetNumModes();
1201 nummodes1 =
m_base[1]->GetNumModes();
1203 startvalue = 2*nummodes1;
1205 for(i = 0; i < nummodes0-2; i++)
1207 for(j = 0; j < nummodes1-3-i; j++)
1209 outarray[cnt++]=startvalue+j;
1211 startvalue+=nummodes1-2-i;
1219 "Expansion not of expected type");
1222 int nummodes0, nummodes1;
1230 nummodes0 =
m_base[0]->GetNumModes();
1231 nummodes1 =
m_base[1]->GetNumModes();
1233 value = 2*nummodes1-1;
1234 for(i = 0; i < value; i++)
1240 for(i = 0; i < nummodes0-2; i++)
1242 outarray[cnt++]=value;
1243 value += nummodes1-2-i;
1265 nq0 =
m_base[0]->GetNumPoints();
1266 nq1 =
m_base[1]->GetNumPoints();
1289 for(
int i = 0; i < nq; ++i)
1291 for(
int j = 0; j < nq-i; ++j,++cnt)
1294 coords[cnt][0] = -1.0 + 2*j/(
NekDouble)(nq-1);
1295 coords[cnt][1] = -1.0 + 2*i/(
NekDouble)(nq-1);
1299 for(
int i = 0; i < neq; ++i)
1303 I[0] =
m_base[0]->GetI(coll);
1304 I[1] =
m_base[1]->GetI(coll+1);
1307 for (
int j = 0; j < nq1; ++j)
1313 Mat->GetRawPtr() + j*nq0*neq + i, neq);
1363 k1,k2,inarray,outarray,mkey);
1387 int qa =
m_base[0]->GetNumPoints();
1388 int qb =
m_base[1]->GetNumPoints();
1389 int nmodes_a =
m_base[0]->GetNumModes();
1390 int nmodes_b =
m_base[1]->GetNumModes();
1391 int nmodes = min(nmodes_a,nmodes_b);
1419 OrthoExp.
FwdTrans(tmp,orthocoeffs);
1422 for(
int j = 0; j < nmodes_a; ++j)
1424 for(
int k = 0; k < nmodes_b-j; ++k, ++cnt)
1428 *pow(j/(nmodes_a-1)+k/(nmodes_b-1),0.5*nmodes));
1433 OrthoExp.
BwdTrans(orthocoeffs,tmp);
1443 min(nmodes_a,nmodes_b));
1446 int nmodes = min(nmodes_a,nmodes_b);
1449 OrthoExp.
FwdTrans(array,orthocoeffs);
1452 for(j = 0; j < nmodes_a; ++j)
1454 for(k = 0; k < nmodes_b-j; ++k)
1458 orthocoeffs[cnt] *= (SvvDiffCoeff
1459 *exp(-(j+k-nmodes)*(j+k-nmodes)
1461 *(j+k-cutoff+epsilon)))));
1465 orthocoeffs[cnt] *= 0.0;
1472 OrthoExp.
BwdTrans(orthocoeffs,array);
1481 int n_coeffs = inarray.num_elements();
1482 int nquad0 =
m_base[0]->GetNumPoints();
1483 int nquad1 =
m_base[1]->GetNumPoints();
1488 int nqtot = nquad0*nquad1;
1491 int nmodes0 =
m_base[0]->GetNumModes();
1492 int nmodes1 =
m_base[1]->GetNumModes();
1493 int numMin2 = nmodes0;
1515 m_TriExp ->BwdTrans(inarray,phys_tmp);
1516 m_OrthoTriExp->FwdTrans(phys_tmp, coeff);
1518 for (i = 0; i < n_coeffs; i++)
1523 numMin += numMin2 - 1;
1528 m_OrthoTriExp->BwdTrans(coeff,phys_tmp);
1529 m_TriExp ->FwdTrans(phys_tmp, outarray);
1540 if(inarray.get() == outarray.get())
1546 m_ncoeffs, tmp.get(), 1, 0.0, outarray.get(), 1);
1551 m_ncoeffs, inarray.get(), 1, 0.0, outarray.get(), 1);
1564 int nquad0 =
m_base[0]->GetNumPoints();
1565 int nquad1 =
m_base[1]->GetNumPoints();
1572 for(i = 0; i < nquad1; ++i)
1575 w0.get(),1, outarray.get()+i*nquad0,1);
1583 for(i = 0; i < nquad1; ++i)
1585 Blas::Dscal(nquad0,0.5*(1-z1[i])*w1[i],
1586 outarray.get()+i*nquad0,1);
1592 for(i = 0; i < nquad1; ++i)
1594 Blas::Dscal(nquad0,0.5*w1[i],outarray.get()+i*nquad0,1);
1599 ASSERTL0(
false,
"Unsupported quadrature points type.");
1608 int np1 =
m_base[0]->GetNumPoints();
1609 int np2 =
m_base[1]->GetNumPoints();
1610 int np = max(np1,np2);
1617 for(
int i = 0; i < np-1; ++i)
1620 for(
int j = 0; j < np-i-2; ++j)
1622 conn[cnt++] = row +j;
1623 conn[cnt++] = row +j+1;
1624 conn[cnt++] = rowp1 +j;
1626 conn[cnt++] = rowp1 +j+1;
1627 conn[cnt++] = rowp1 +j;
1628 conn[cnt++] = row +j+1;
1631 conn[cnt++] = row +np-i-2;
1632 conn[cnt++] = row +np-i-1;
1633 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 Sdiv(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Scalar multiply y = alpha/y.
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)
void Sadd(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Add vector y = alpha + x.
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...