63 "order in 'a' direction is higher than order "
84 int nquad1 =
m_base[1]->GetNumPoints();
101 for(i = 0; i < nquad1; ++i)
103 w1_tmp[i] = 0.5*(1-z1[i])*w1[i];
135 int nquad0 =
m_base[0]->GetNumPoints();
136 int nquad1 =
m_base[1]->GetNumPoints();
143 for (i = 0; i < nquad1; ++i)
145 wsp[i] = 2.0/(1-z1[i]);
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)
161 for (i = 0; i < nquad0; ++i)
163 wsp[i] = 0.5*(1+z0[i]);
166 for (i = 0; i < nquad1; ++i)
169 1,&out_d1[0]+i*nquad0,
170 1,&out_d1[0]+i*nquad0,1);
174 else if (out_d1.num_elements() > 0)
179 for (i = 0; i < nquad1; ++i)
181 Blas::Dscal(nquad0,wsp[i],&diff0[0]+i*nquad0,1);
184 for (i = 0; i < nquad0; ++i)
186 wsp[i] = 0.5*(1+z0[i]);
189 for (i = 0; i < nquad1; ++i)
192 1,&out_d1[0]+i*nquad0,
193 1,&out_d1[0]+i*nquad0,1);
217 ASSERTL1(
false,
"input dir is out of range");
263 m_base[1]->GetNumModes());
267 inarray,outarray,wsp);
276 bool doCheckCollDir0,
277 bool doCheckCollDir1)
281 int nquad0 =
m_base[0]->GetNumPoints();
282 int nquad1 =
m_base[1]->GetNumPoints();
283 int nmodes0 =
m_base[0]->GetNumModes();
284 int nmodes1 =
m_base[1]->GetNumModes();
286 ASSERTL1(wsp.num_elements() >= nquad0*nmodes1,
287 "Workspace size is not sufficient");
290 "Basis[1] is not of general tensor type");
292 for (i = mode = 0; i < nmodes0; ++i)
294 Blas::Dgemv(
'N', nquad1,nmodes1-i,1.0,base1.get()+mode*nquad1,
295 nquad1,&inarray[0]+mode,1,0.0,&wsp[0]+i*nquad1,1);
302 Blas::Daxpy(nquad1,inarray[1],base1.get()+nquad1,1,
306 Blas::Dgemm(
'N',
'T', nquad0,nquad1,nmodes0,1.0, base0.get(),nquad0,
307 &wsp[0], nquad1,0.0, &outarray[0], nquad0);
333 int npoints[2] = {
m_base[0]->GetNumPoints(),
334 m_base[1]->GetNumPoints()};
335 int nmodes[2] = {
m_base[0]->GetNumModes(),
336 m_base[1]->GetNumModes()};
338 fill(outarray.get(), outarray.get()+
m_ncoeffs, 0.0 );
342 for(i = 0; i < 3; i++)
348 for(i = 0; i < npoints[0]; i++)
350 physEdge[0][i] = inarray[i];
353 for(i = 0; i < npoints[1]; i++)
355 physEdge[1][i] = inarray[npoints[0]-1+i*npoints[0]];
356 physEdge[2][i] = inarray[(npoints[1]-1)*npoints[0]-i*npoints[0]];
361 m_base[0]->GetBasisKey()),
370 for (i = 0; i < 3; i++)
373 segexp[i!=0]->FwdTrans_BndConstrained(physEdge[i],coeffEdge[i]);
376 for (j = 0; j < nmodes[i != 0]; j++)
379 outarray[ mapArray[j] ] = sign * coeffEdge[i][j];
399 int nInteriorDofs =
m_ncoeffs - nBoundaryDofs;
406 for (i = 0; i < nInteriorDofs; i++)
408 rhs[i] = tmp1[ mapArray[i] ];
411 Blas::Dgemv(
'N',nInteriorDofs,nInteriorDofs,
412 1.0,&(matsys->GetPtr())[0],nInteriorDofs,
416 for (i = 0; i < nInteriorDofs; i++)
418 outarray[ mapArray[i] ] = result[i];
479 Blas::Dgemv(
'N',
m_ncoeffs,nq,1.0,iprodmat->GetPtr().get(),
480 m_ncoeffs, inarray.get(), 1, 0.0, outarray.get(), 1);
486 bool multiplybyweights)
488 int nquad0 =
m_base[0]->GetNumPoints();
489 int nquad1 =
m_base[1]->GetNumPoints();
490 int order0 =
m_base[0]->GetNumModes();
492 if(multiplybyweights)
508 inarray,outarray,wsp);
518 bool doCheckCollDir0,
519 bool doCheckCollDir1)
523 int nquad0 =
m_base[0]->GetNumPoints();
524 int nquad1 =
m_base[1]->GetNumPoints();
525 int nmodes0 =
m_base[0]->GetNumModes();
526 int nmodes1 =
m_base[1]->GetNumModes();
528 ASSERTL1(wsp.num_elements() >= nquad1*nmodes0,
529 "Workspace size is not sufficient");
531 Blas::Dgemm(
'T',
'N',nquad1,nmodes0,nquad0,1.0,inarray.get(),nquad0,
532 base0.get(),nquad0,0.0,wsp.get(),nquad1);
535 for (mode=i=0; i < nmodes0; ++i)
537 Blas::Dgemv(
'T',nquad1,nmodes1-i,1.0, base1.get()+mode*nquad1,
538 nquad1,wsp.get()+i*nquad1,1, 0.0,
539 outarray.get() + mode,1);
546 outarray[1] +=
Blas::Ddot(nquad1,base1.get()+nquad1,1,
581 ASSERTL1(
false,
"input dir is out of range");
589 Blas::Dgemv(
'N',
m_ncoeffs,nq,1.0,iprodmat->GetPtr().get(),
590 m_ncoeffs, inarray.get(), 1, 0.0, outarray.get(), 1);
599 int nquad0 =
m_base[0]->GetNumPoints();
600 int nquad1 =
m_base[1]->GetNumPoints();
601 int nqtot = nquad0*nquad1;
602 int nmodes0 =
m_base[0]->GetNumModes();
603 int wspsize = max(max(nqtot,
m_ncoeffs),nquad1*nmodes0);
611 for(i = 0; i < nquad1; ++i)
613 gfac0[i] = 2.0/(1-z1[i]);
616 for(i = 0; i < nquad1; ++i)
618 Vmath::Smul(nquad0,gfac0[i],&inarray[0]+i*nquad0,1,
619 &tmp0[0]+i*nquad0,1);
630 tmp0,outarray,gfac0);
638 for (i = 0; i < nquad0; ++i)
640 gfac0[i] = 0.5*(1+z0[i]);
643 for (i = 0; i < nquad1; ++i)
645 Vmath::Vmul(nquad0,&gfac0[0],1,&tmp0[0]+i*nquad0,1,
646 &tmp0[0]+i*nquad0,1);
656 tmp0,outarray,gfac0);
663 ASSERTL1(
false,
"input dir is out of range");
685 eta[0] = 2*(1+xi[0])/(1-xi[1])-1.0;
694 int nquad0 =
m_base[0]->GetNumPoints();
695 int nquad1 =
m_base[1]->GetNumPoints();
696 int order0 =
m_base[0]->GetNumModes();
697 int order1 =
m_base[1]->GetNumModes();
703 "calling argument mode is larger than "
704 "total expansion order");
707 for (i = 0; i < order0; ++i, m+=order1-i)
724 for (i = 0; i < nquad1; ++i)
727 1,&outarray[0]+i*nquad0,1);
731 for(i = 0; i < nquad0; ++i)
734 1,&outarray[0]+i,nquad0,&outarray[0]+i,nquad0);
757 "BasisType is not a boundary interior form");
759 "BasisType is not a boundary interior form");
767 "BasisType is not a boundary interior form");
769 "BasisType is not a boundary interior form");
776 ASSERTL2(i >= 0 && i <= 2,
"edge id is out of range");
790 ASSERTL2((i >= 0)&&(i <= 2),
"edge id is out of range");
803 const std::vector<unsigned int> &nummodes,
807 nummodes[modes_offset],
808 nummodes[modes_offset+1]);
816 ASSERTL2(i >= 0 && i <= 2,
"edge id is out of range");
839 for(i = 0; i < nq1; ++i)
841 for(j = 0; j < nq0; ++j)
843 coords_0[i*nq0+j] = (1+z0[j])*(1-z1[i])/2.0 - 1.0;
857 ASSERTL2(edge >= 0 && edge <= 2,
"edge id is out of range");
859 return edge == 0 ? 0 : 1;
865 ASSERTL2(i >= 0 && i <= 2,
"edge id is out of range");
882 m_base[1]->GetBasisKey().GetPointsKey().
887 m_base[1]->GetNumModes(),pkey);
892 ASSERTL0(
false,
"unexpected points distribution");
897 ASSERTL0(
false,
"Information not available to set edge key");
919 "Mapping not defined for this type of basis");
923 int order0 =
m_base[0]->GetNumModes();
924 int order1 =
m_base[1]->GetNumModes();
937 bool checkForZeroedModes =
false;
942 else if(P != numModes)
944 checkForZeroedModes =
true;
948 if(maparray.num_elements() != P)
953 if(signarray.num_elements() != P)
959 fill(signarray.get() , signarray.get()+P, 1);
967 for(i = 0; i < P; cnt+=order1-i, ++i)
974 swap( maparray[0] , maparray[1] );
976 for(i = 3; i < P; i+=2)
985 maparray[0] = order1;
987 for(i = 2; i < P; i++)
989 maparray[i] = order1-1+i;
994 swap( maparray[0] , maparray[1] );
996 for(i = 3; i < P; i+=2)
1005 for(i = 0; i < P; i++)
1012 swap( maparray[0] , maparray[1] );
1014 for(i = 3; i < P; i+=2)
1022 ASSERTL0(
false,
"eid must be between 0 and 2");
1027 if (checkForZeroedModes)
1031 for (
int j = numModes; j < P; j++)
1034 maparray[j] = maparray[0];
1044 "Mapping not defined for this type of basis");
1047 if(useCoeffPacking ==
true)
1049 switch(localVertexId)
1063 localDOF =
m_base[1]->GetNumModes();
1068 ASSERTL0(
false,
"eid must be between 0 and 2");
1075 switch(localVertexId)
1084 localDOF =
m_base[1]->GetNumModes();
1094 ASSERTL0(
false,
"eid must be between 0 and 2");
1111 "Mapping not defined for this type of basis");
1113 const int nummodes1 =
m_base[1]->GetNumModes();
1116 if(maparray.num_elements() != nEdgeIntCoeffs)
1121 if(signarray.num_elements() != nEdgeIntCoeffs)
1127 fill( signarray.get() , signarray.get()+nEdgeIntCoeffs, 1 );
1134 int cnt = 2*nummodes1 - 1;
1135 for(i = 0; i < nEdgeIntCoeffs; cnt+=nummodes1-2-i, ++i)
1142 for(i = 1; i < nEdgeIntCoeffs; i+=2)
1151 for(i = 0; i < nEdgeIntCoeffs; i++)
1153 maparray[i] = nummodes1+1+i;
1158 for(i = 1; i < nEdgeIntCoeffs; i+=2)
1167 for(i = 0; i < nEdgeIntCoeffs; i++)
1174 for(i = 1; i < nEdgeIntCoeffs; i+=2)
1183 ASSERTL0(
false,
"eid must be between 0 and 2");
1193 "Expansion not of a proper type");
1197 int nummodes0, nummodes1;
1204 nummodes0 =
m_base[0]->GetNumModes();
1205 nummodes1 =
m_base[1]->GetNumModes();
1207 startvalue = 2*nummodes1;
1209 for(i = 0; i < nummodes0-2; i++)
1211 for(j = 0; j < nummodes1-3-i; j++)
1213 outarray[cnt++]=startvalue+j;
1215 startvalue+=nummodes1-2-i;
1223 "Expansion not of expected type");
1226 int nummodes0, nummodes1;
1234 nummodes0 =
m_base[0]->GetNumModes();
1235 nummodes1 =
m_base[1]->GetNumModes();
1237 value = 2*nummodes1-1;
1238 for(i = 0; i < value; i++)
1244 for(i = 0; i < nummodes0-2; i++)
1246 outarray[cnt++]=value;
1247 value += nummodes1-2-i;
1269 nq0 =
m_base[0]->GetNumPoints();
1270 nq1 =
m_base[1]->GetNumPoints();
1293 for(
int i = 0; i < nq; ++i)
1295 for(
int j = 0; j < nq-i; ++j,++cnt)
1298 coords[cnt][0] = -1.0 + 2*j/(
NekDouble)(nq-1);
1299 coords[cnt][1] = -1.0 + 2*i/(
NekDouble)(nq-1);
1303 for(
int i = 0; i < neq; ++i)
1307 I[0] =
m_base[0]->GetI(coll);
1308 I[1] =
m_base[1]->GetI(coll+1);
1311 for (
int j = 0; j < nq1; ++j)
1317 Mat->GetRawPtr() + j*nq0*neq + i, neq);
1367 k1,k2,inarray,outarray,mkey);
1391 int qa =
m_base[0]->GetNumPoints();
1392 int qb =
m_base[1]->GetNumPoints();
1393 int nmodes_a =
m_base[0]->GetNumModes();
1394 int nmodes_b =
m_base[1]->GetNumModes();
1395 int nmodes = min(nmodes_a,nmodes_b);
1423 OrthoExp.
FwdTrans(tmp,orthocoeffs);
1426 for(
int j = 0; j < nmodes_a; ++j)
1428 for(
int k = 0; k < nmodes_b-j; ++k, ++cnt)
1432 *pow(j/(nmodes_a-1)+k/(nmodes_b-1),0.5*nmodes));
1437 OrthoExp.
BwdTrans(orthocoeffs,tmp);
1447 min(nmodes_a,nmodes_b));
1450 int nmodes = min(nmodes_a,nmodes_b);
1453 OrthoExp.
FwdTrans(array,orthocoeffs);
1456 for(j = 0; j < nmodes_a; ++j)
1458 for(k = 0; k < nmodes_b-j; ++k)
1462 orthocoeffs[cnt] *= (SvvDiffCoeff
1463 *exp(-(j+k-nmodes)*(j+k-nmodes)
1465 *(j+k-cutoff+epsilon)))));
1469 orthocoeffs[cnt] *= 0.0;
1476 OrthoExp.
BwdTrans(orthocoeffs,array);
1485 int n_coeffs = inarray.num_elements();
1486 int nquad0 =
m_base[0]->GetNumPoints();
1487 int nquad1 =
m_base[1]->GetNumPoints();
1492 int nqtot = nquad0*nquad1;
1495 int nmodes0 =
m_base[0]->GetNumModes();
1496 int nmodes1 =
m_base[1]->GetNumModes();
1497 int numMin2 = nmodes0;
1519 m_TriExp ->BwdTrans(inarray,phys_tmp);
1520 m_OrthoTriExp->FwdTrans(phys_tmp, coeff);
1522 for (i = 0; i < n_coeffs; i++)
1527 numMin += numMin2 - 1;
1532 m_OrthoTriExp->BwdTrans(coeff,phys_tmp);
1533 m_TriExp ->FwdTrans(phys_tmp, outarray);
1544 if(inarray.get() == outarray.get())
1550 m_ncoeffs, tmp.get(), 1, 0.0, outarray.get(), 1);
1555 m_ncoeffs, inarray.get(), 1, 0.0, outarray.get(), 1);
1568 int nquad0 =
m_base[0]->GetNumPoints();
1569 int nquad1 =
m_base[1]->GetNumPoints();
1576 for(i = 0; i < nquad1; ++i)
1579 w0.get(),1, outarray.get()+i*nquad0,1);
1587 for(i = 0; i < nquad1; ++i)
1589 Blas::Dscal(nquad0,0.5*(1-z1[i])*w1[i],
1590 outarray.get()+i*nquad0,1);
1596 for(i = 0; i < nquad1; ++i)
1598 Blas::Dscal(nquad0,0.5*w1[i],outarray.get()+i*nquad0,1);
1603 ASSERTL0(
false,
"Unsupported quadrature points type.");
1612 int np1 =
m_base[0]->GetNumPoints();
1613 int np2 =
m_base[1]->GetNumPoints();
1614 int np = max(np1,np2);
1621 for(
int i = 0; i < np-1; ++i)
1624 for(
int j = 0; j < np-i-2; ++j)
1626 conn[cnt++] = row +j;
1627 conn[cnt++] = row +j+1;
1628 conn[cnt++] = rowp1 +j;
1630 conn[cnt++] = rowp1 +j+1;
1631 conn[cnt++] = rowp1 +j;
1632 conn[cnt++] = row +j+1;
1635 conn[cnt++] = row +np-i-2;
1636 conn[cnt++] = row +np-i-1;
1637 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...