Commit 5745e063 authored by Dave Moxey's avatar Dave Moxey
Browse files

Fixed compiler warnings in LoclRegions.

parent 82ba5c00
......@@ -39,8 +39,8 @@ namespace Nektar
{
namespace LocalRegions
{
Expansion0D::Expansion0D() : StdExpansion0D(),
Expansion(), StdExpansion()
Expansion0D::Expansion0D() : StdExpansion(), Expansion(),
StdExpansion0D()
{
m_elementVertexLeft = -1;
m_elementVertexRight = -1;
......
......@@ -42,7 +42,6 @@ namespace Nektar
DNekMatSharedPtr Expansion1D::v_GenMatrix(const StdRegions::StdMatrixKey &mkey)
{
DNekMatSharedPtr returnval;
switch(mkey.GetMatrixType())
......@@ -141,7 +140,6 @@ namespace Nektar
{
int j,k,dir;
int nbndry = NumDGBndryCoeffs();
int nquad = GetNumPoints(0);
int ncoeffs = GetNcoeffs();
Array<OneD,NekDouble> lambda(nbndry);
......@@ -159,9 +157,6 @@ namespace Nektar
returnval = MemoryManager<DNekMat>::AllocateSharedPtr(ncoeffs,nbndry);
DNekMat &Qmat = *returnval;
// Helmholtz matrix
DNekScalMat &invHmat = *GetLocMatrix(StdRegions::eInvHybridDGHelmholtz, factors);
// Lambda to U matrix
DNekScalMat &lamToU = *GetLocMatrix(StdRegions::eHybridDGLamToU, factors);
......@@ -284,7 +279,7 @@ namespace Nektar
}
}
void Expansion1D::v_AddHDGHelmholtzTraceTerms(const NekDouble tau,
void Expansion1D::AddHDGHelmholtzTraceTerms(const NekDouble tau,
const Array<OneD,const NekDouble> &inarray, Array<OneD,NekDouble> &outarray)
{
int i,n;
......
......@@ -77,14 +77,14 @@ namespace Nektar
int edge,
Expansion2DSharedPtr &e);
protected:
virtual DNekMatSharedPtr v_GenMatrix(const StdRegions::StdMatrixKey &mkey);
virtual void v_AddHDGHelmholtzTraceTerms(
void AddHDGHelmholtzTraceTerms(
const NekDouble tau,
const Array<OneD,const NekDouble> &inarray,
Array<OneD,NekDouble> &outarray);
protected:
virtual DNekMatSharedPtr v_GenMatrix(const StdRegions::StdMatrixKey &mkey);
virtual void v_AddRobinMassMatrix(
const int vert,
const Array<OneD, const NekDouble > &primCoeffs,
......
......@@ -44,7 +44,7 @@ namespace Nektar
namespace LocalRegions
{
Expansion2D::Expansion2D() :
StdExpansion2D(), Expansion(), StdExpansion()
StdExpansion(), Expansion(), StdExpansion2D()
{
m_elementFaceLeft = -1;
m_elementFaceRight = -1;
......@@ -67,7 +67,6 @@ namespace Nektar
// is enforced here by taking the minimum size and padding with
// zeros.
int nquad_e = min(EdgeExp->GetNumPoints(0), int(normals[0].num_elements()));
int coordim = GetCoordim();
Vmath::Zero(EdgeExp->GetNumPoints(0),EdgeExp->UpdatePhys(),1);
Vmath::Vmul(nquad_e,normals[0],1,Fx,1,
......@@ -184,40 +183,6 @@ namespace Nektar
}
}
// void Expansion2D::v_AddEdgeNormBoundaryBiInt(const int edge,
// StdRegions::StdExpansion1DSharedPtr &EdgeExp,
// const Array<OneD, const NekDouble> &Fwd,
// const Array<OneD, const NekDouble> &Bwd,
// Array<OneD, NekDouble> &outarray)
// {
// int i;
// int order_e = EdgeExp->GetNcoeffs();
// Array<OneD,unsigned int> map;
// Array<OneD,int> sign;
// StdRegions::Orientation edgedir = GetEorient(edge);
//
// // ASSERTL1(v_GetCoordim() == 2,"Routine only set up for two-dimensions");
//
// GetEdgeToElementMap(edge,edgedir,map,sign);
//
// if(edgedir == StdRegions::eForwards)
// {
// EdgeExp->IProductWRTBase(Fwd,EdgeExp->UpdateCoeffs());
// }
//
// else if(edgedir == StdRegions::eBackwards)
// {
// EdgeExp->IProductWRTBase(Bwd,EdgeExp->UpdateCoeffs());
// }
//
// // add data to outarray if forward edge normal is outwards
// for(i = 0; i < order_e; ++i)
// {
// outarray[map[i]] += sign[i]*EdgeExp->GetCoeff(i);
// }
// }
void Expansion2D::SetTraceToGeomOrientation(Array<OneD,StdRegions::StdExpansionSharedPtr> &EdgeExp, Array<OneD, NekDouble> &inout)
{
int i,cnt = 0;
......@@ -237,7 +202,7 @@ namespace Nektar
* Computes the C matrix entries due to the presence of the identity
* matrix in Eqn. 32.
*/
void Expansion2D::v_AddNormTraceInt(const int dir,
void Expansion2D::AddNormTraceInt(const int dir,
Array<OneD, const NekDouble> &inarray,
Array<OneD,StdRegions::StdExpansionSharedPtr> &EdgeExp,
Array<OneD,NekDouble> &outarray,
......@@ -246,7 +211,6 @@ namespace Nektar
int i,e,cnt;
int order_e,nquad_e;
int nedges = GetNedges();
int coordim = GetCoordim();
cnt = 0;
for(e = 0; e < nedges; ++e)
......@@ -267,17 +231,17 @@ namespace Nektar
// Multiply by variable coefficient
/// @TODO: Document this
StdRegions::VarCoeffType VarCoeff[3] = {StdRegions::eVarCoeffD00,
StdRegions::eVarCoeffD11,
StdRegions::eVarCoeffD22};
StdRegions::VarCoeffMap::const_iterator x;
Array<OneD, NekDouble> varcoeff_work(nquad_e);
// if ((x = varcoeffs.find(VarCoeff[dir])) != varcoeffs.end())
// {
// GetPhysEdgeVarCoeffsFromElement(e,EdgeExp[e],x->second,varcoeff_work);
// Vmath::Vmul(nquad_e,varcoeff_work,1,EdgeExp[e]->GetPhys(),1,EdgeExp[e]->UpdatePhys(),1);
// }
// StdRegions::VarCoeffType VarCoeff[3] = {StdRegions::eVarCoeffD00,
// StdRegions::eVarCoeffD11,
// StdRegions::eVarCoeffD22};
// StdRegions::VarCoeffMap::const_iterator x;
// Array<OneD, NekDouble> varcoeff_work(nquad_e);
// if ((x = varcoeffs.find(VarCoeff[dir])) != varcoeffs.end())
// {
// GetPhysEdgeVarCoeffsFromElement(e,EdgeExp[e],x->second,varcoeff_work);
// Vmath::Vmul(nquad_e,varcoeff_work,1,EdgeExp[e]->GetPhys(),1,EdgeExp[e]->UpdatePhys(),1);
// }
Vmath::Vmul(nquad_e,normals[dir],1,
EdgeExp[e]->GetPhys(),1,
......@@ -287,7 +251,7 @@ namespace Nektar
}
}
void Expansion2D::v_AddNormTraceInt(const int dir,
void Expansion2D::AddNormTraceInt(const int dir,
Array<OneD,StdRegions::StdExpansionSharedPtr> &EdgeExp,
Array<OneD,NekDouble> &outarray)
{
......@@ -318,7 +282,7 @@ namespace Nektar
/**
* For a given edge add the \tilde{F}_1j contributions
*/
void Expansion2D::v_AddEdgeBoundaryInt(const int edge,
void Expansion2D::AddEdgeBoundaryInt(const int edge,
StdRegions::StdExpansionSharedPtr &EdgeExp,
Array <OneD,NekDouble > &outarray,
const StdRegions::VarCoeffMap &varcoeffs)
......@@ -357,7 +321,7 @@ namespace Nektar
// This method assumes that data in EdgeExp is orientated
// according to elemental counter clockwise format
// AddHDGHelmholtzTraceTerms with directions
void Expansion2D::v_AddHDGHelmholtzTraceTerms(const NekDouble tau,
void Expansion2D::AddHDGHelmholtzTraceTerms(const NekDouble tau,
const Array<OneD, const NekDouble> &inarray,
Array<OneD,StdRegions::StdExpansionSharedPtr> &EdgeExp,
const StdRegions::VarCoeffMap &dirForcing,
......@@ -390,7 +354,7 @@ namespace Nektar
// evaluate additional terms in HDG edges. Not that this assumes that
// edges are unpacked into local cartesian order.
void Expansion2D::v_AddHDGHelmholtzEdgeTerms(const NekDouble tau,
void Expansion2D::AddHDGHelmholtzEdgeTerms(const NekDouble tau,
const int edge,
Array <OneD, StdRegions::StdExpansionSharedPtr > &EdgeExp,
const StdRegions::VarCoeffMap &varcoeffs,
......@@ -632,7 +596,6 @@ namespace Nektar
int nbndry = NumDGBndryCoeffs();
int ncoeffs = GetNcoeffs();
int nedges = GetNedges();
NekDouble lambdaval = mkey.GetConstFactor(StdRegions::eFactorLambda);
NekDouble tau = mkey.GetConstFactor(StdRegions::eFactorTau);
Array<OneD,NekDouble> lambda(nbndry);
......@@ -696,7 +659,6 @@ namespace Nektar
{
int i,j,k,dir;
int nbndry = NumDGBndryCoeffs();
int nquad = GetNumPoints(0);
int ncoeffs = GetNcoeffs();
int nedges = GetNedges();
......@@ -974,7 +936,6 @@ namespace Nektar
StdRegions::eWeakDeriv2};
int ncoeffs = GetNcoeffs();
int nedges = GetNedges();
DNekScalMat &InvMass = *GetLocMatrix(StdRegions::eInvMass);
DNekScalMat &Dmat = *GetLocMatrix(DerivType[dir]);
......
......@@ -104,39 +104,11 @@ namespace Nektar
virtual DNekMatSharedPtr v_GenMatrix(const StdRegions::StdMatrixKey &mkey);
// Hybridized DG routines
virtual void v_AddNormTraceInt(const int dir,
Array<OneD,StdRegions::StdExpansionSharedPtr> &EdgeExp,
Array<OneD,NekDouble> &outarray);
virtual void v_AddNormTraceInt(const int dir,
Array<OneD, const NekDouble> &inarray,
Array<OneD,StdRegions::StdExpansionSharedPtr> &EdgeExp,
Array<OneD,NekDouble> &outarray,
const StdRegions::VarCoeffMap &varcoeffs);
virtual void v_AddHDGHelmholtzEdgeTerms(const NekDouble tau,
const int edge,
Array <OneD, StdRegions::StdExpansionSharedPtr > &EdgeExp,
const StdRegions::VarCoeffMap &dirForcing,
Array <OneD,NekDouble > &outarray);
virtual void v_AddEdgeBoundaryInt(const int edge,
StdRegions::StdExpansionSharedPtr &EdgeExp,
Array <OneD,NekDouble > &outarray,
const StdRegions::VarCoeffMap &varcoeffs);
virtual void v_DGDeriv(const int dir,
const Array<OneD, const NekDouble>&incoeffs,
Array<OneD,StdRegions::StdExpansionSharedPtr> &EdgeExp,
Array<OneD, NekDouble> &out_d);
virtual void v_AddHDGHelmholtzTraceTerms(const NekDouble tau,
const Array<OneD, const NekDouble> &inarray,
Array<OneD,StdRegions::StdExpansionSharedPtr> &EdgeExp,
const StdRegions::VarCoeffMap &dirForcing,
Array<OneD,NekDouble> &outarray);
virtual void v_AddEdgeNormBoundaryInt(
const int edge,
StdRegions::StdExpansionSharedPtr &EdgeExp,
......@@ -149,12 +121,6 @@ namespace Nektar
StdRegions::StdExpansionSharedPtr &EdgeExp,
const Array<OneD, const NekDouble> &Fn,
Array<OneD, NekDouble> &outarray);
//
// virtual void v_AddEdgeNormBoundaryBiInt(const int edge,
// StdRegions::StdExpansion1DSharedPtr &EdgeExp,
// const Array<OneD, const NekDouble> &Fwd,
// const Array<OneD, const NekDouble> &Bwd,
// Array<OneD, NekDouble> &outarray);
virtual void v_AddRobinMassMatrix(const int edgeid, const Array<OneD, const NekDouble > &primCoeffs, DNekMatSharedPtr &inoutmat);
......@@ -199,48 +165,6 @@ namespace Nektar
m_edgeExp[edge] = e;
}
inline void Expansion2D::AddNormTraceInt(const int dir,
Array<OneD,StdRegions::StdExpansionSharedPtr> &EdgeExp,
Array<OneD,NekDouble> &outarray)
{
v_AddNormTraceInt(dir, EdgeExp, outarray);
}
inline void Expansion2D::AddNormTraceInt(const int dir,
Array<OneD, const NekDouble> &inarray,
Array<OneD,StdRegions::StdExpansionSharedPtr> &EdgeExp,
Array<OneD,NekDouble> &outarray,
const StdRegions::VarCoeffMap &varcoeffs)
{
v_AddNormTraceInt(dir, inarray, EdgeExp, outarray, varcoeffs);
}
inline void Expansion2D::AddEdgeBoundaryInt(const int edge,
StdRegions::StdExpansionSharedPtr &EdgeExp,
Array <OneD,NekDouble > &outarray,
const StdRegions::VarCoeffMap &varcoeffs)
{
v_AddEdgeBoundaryInt(edge, EdgeExp, outarray, varcoeffs);
}
inline void Expansion2D::AddHDGHelmholtzEdgeTerms(const NekDouble tau,
const int edge,
Array <OneD, StdRegions::StdExpansionSharedPtr > &EdgeExp,
const StdRegions::VarCoeffMap &dirForcing,
Array <OneD,NekDouble > &outarray)
{
v_AddHDGHelmholtzEdgeTerms(tau, edge, EdgeExp, dirForcing, outarray);
}
inline void Expansion2D::AddHDGHelmholtzTraceTerms(const NekDouble tau,
const Array<OneD, const NekDouble> &inarray,
Array<OneD,StdRegions::StdExpansionSharedPtr> &EdgeExp,
const StdRegions::VarCoeffMap &dirForcing,
Array<OneD,NekDouble> &outarray)
{
v_AddHDGHelmholtzTraceTerms(tau, inarray, EdgeExp, dirForcing, outarray);
}
inline Expansion3DSharedPtr Expansion2D::GetLeftAdjacentElementExp() const
{
ASSERTL1(m_elementLeft.lock().get(), "Left adjacent element not set.");
......
......@@ -44,7 +44,7 @@ namespace Nektar
{
Expansion3D::Expansion3D(){}
void Expansion3D::v_AddHDGHelmholtzTraceTerms(const NekDouble tau,
void Expansion3D::AddHDGHelmholtzTraceTerms(const NekDouble tau,
const Array<OneD, const NekDouble> &inarray,
Array<OneD,StdRegions::StdExpansionSharedPtr> &FaceExp,
const StdRegions::VarCoeffMap &dirForcing,
......@@ -77,7 +77,7 @@ namespace Nektar
// evaluate additional terms in HDG face. Note that this assumes that
// edges are unpacked into local cartesian order.
void Expansion3D::v_AddHDGHelmholtzFaceTerms(const NekDouble tau,
void Expansion3D::AddHDGHelmholtzFaceTerms(const NekDouble tau,
const int face,
StdRegions::StdExpansionSharedPtr FaceExp,
const StdRegions::VarCoeffMap &varcoeffs,
......@@ -190,7 +190,7 @@ namespace Nektar
* Computes the C matrix entries due to the presence of the identity
* matrix in Eqn. 32.
*/
void Expansion3D::v_AddNormTraceInt(const int dir,
void Expansion3D::AddNormTraceInt(const int dir,
Array<OneD, const NekDouble> &inarray,
Array<OneD,StdRegions::StdExpansionSharedPtr> &FaceExp,
Array<OneD,NekDouble> &outarray,
......@@ -199,7 +199,6 @@ namespace Nektar
int i,f,cnt;
int order_f,nquad_f;
int nfaces = GetNfaces();
int coordim = GetCoordim();
cnt = 0;
for(f = 0; f < nfaces; ++f)
......@@ -244,14 +243,13 @@ namespace Nektar
/**
* For a given face add the \tilde{F}_1j contributions
*/
void Expansion3D::v_AddFaceBoundaryInt(const int face,
void Expansion3D::AddFaceBoundaryInt(const int face,
StdRegions::StdExpansionSharedPtr &FaceExp,
Array <OneD,NekDouble > &outarray,
const StdRegions::VarCoeffMap &varcoeffs)
{
int i;
int order_f = FaceExp->GetNcoeffs();
int nquad_f = FaceExp->GetNumPoints(0)*FaceExp->GetNumPoints(1);
Array<OneD,unsigned int> map;
Array<OneD,int> sign;
Array<OneD, NekDouble> coeff(order_f);
......@@ -333,6 +331,7 @@ namespace Nektar
cnt += GetFaceNcoeffs(i);
}
}
/**
* Computes matrices needed for the HDG formulation. References to
* equations relate to the following paper (with a suitable changes in formulation to adapt to 3D):
......@@ -379,9 +378,9 @@ namespace Nektar
DNekMat &Mat = *returnval;
Vmath::Zero(ncoeffs*ncoeffs,Mat.GetPtr(),1);
StdRegions::VarCoeffType Coeffs[3] = {StdRegions::eVarCoeffD00,
StdRegions::eVarCoeffD11,
StdRegions::eVarCoeffD22};
// StdRegions::VarCoeffType Coeffs[3] = {StdRegions::eVarCoeffD00,
// StdRegions::eVarCoeffD11,
// StdRegions::eVarCoeffD22};
for(i=0; i < coordim; ++i)
{
......@@ -448,7 +447,6 @@ namespace Nektar
int nbndry = NumDGBndryCoeffs();
int ncoeffs = GetNcoeffs();
int nfaces = GetNfaces();
NekDouble lambdaval = mkey.GetConstFactor(StdRegions::eFactorLambda);
NekDouble tau = mkey.GetConstFactor(StdRegions::eFactorTau);
Array<OneD,NekDouble> lambda(nbndry);
......@@ -647,7 +645,6 @@ namespace Nektar
int i,j,f,cnt;
int order_f, nquad_f;
int nbndry = NumDGBndryCoeffs();
int coordim = GetCoordim();
int nfaces = GetNfaces();
NekDouble tau = mkey.GetConstFactor(StdRegions::eFactorTau);
......
......@@ -61,25 +61,29 @@ namespace Nektar
LOCAL_REGIONS_EXPORT void SetTraceToGeomOrientation(Array<OneD, NekDouble> &inout);
LOCAL_REGIONS_EXPORT void SetFaceToGeomOrientation(const int face, Array<OneD, NekDouble> &inout);
inline void AddHDGHelmholtzFaceTerms(const NekDouble tau,
inline void AddHDGHelmholtzFaceTerms(
const NekDouble tau,
const int edge,
StdRegions::StdExpansionSharedPtr FaceExp,
const StdRegions::VarCoeffMap &dirForcing,
Array <OneD,NekDouble > &outarray);
Array <OneD, NekDouble> &outarray);
inline void AddHDGHelmholtzTraceTerms(const NekDouble tau,
inline void AddHDGHelmholtzTraceTerms(
const NekDouble tau,
const Array<OneD, const NekDouble> &inarray,
Array<OneD,StdRegions::StdExpansionSharedPtr> &FaceExp,
const StdRegions::VarCoeffMap &dirForcing,
Array<OneD,NekDouble> &outarray);
inline void AddNormTraceInt(const int dir,
inline void AddNormTraceInt(
const int dir,
Array<OneD, const NekDouble> &inarray,
Array<OneD,StdRegions::StdExpansionSharedPtr> &FaceExp,
Array<OneD,NekDouble> &outarray,
const StdRegions::VarCoeffMap &varcoeffs);
inline void AddFaceBoundaryInt(const int face,
inline void AddFaceBoundaryInt(
const int face,
StdRegions::StdExpansionSharedPtr &FaceExp,
Array <OneD,NekDouble > &outarray,
const StdRegions::VarCoeffMap &varcoeffs = StdRegions::NullVarCoeffMap);
......@@ -97,29 +101,6 @@ namespace Nektar
const Array<OneD, const NekDouble> &primCoeffs,
DNekMatSharedPtr &inoutmat);
virtual void v_AddHDGHelmholtzFaceTerms(const NekDouble tau,
const int face,
StdRegions::StdExpansionSharedPtr FaceExp,
const StdRegions::VarCoeffMap &dirForcing,
Array <OneD,NekDouble > &outarray);
virtual void v_AddHDGHelmholtzTraceTerms(const NekDouble tau,
const Array<OneD, const NekDouble> &inarray,
Array<OneD,StdRegions::StdExpansionSharedPtr> &FaceExp,
const StdRegions::VarCoeffMap &dirForcing,
Array<OneD,NekDouble> &outarray);
virtual void v_AddNormTraceInt(const int dir,
Array<OneD, const NekDouble> &inarray,
Array<OneD,StdRegions::StdExpansionSharedPtr> &FaceExp,
Array<OneD,NekDouble> &outarray,
const StdRegions::VarCoeffMap &varcoeffs);
virtual void v_AddFaceBoundaryInt(const int face,
StdRegions::StdExpansionSharedPtr &FaceExp,
Array <OneD,NekDouble > &outarray,
const StdRegions::VarCoeffMap &varcoeffs);
private:
// Do not add members here since it may lead to conflicts.
// Only use this class for member functions
......@@ -132,41 +113,6 @@ namespace Nektar
typedef boost::weak_ptr<Expansion3D> Expansion3DWeakPtr;
typedef std::vector< Expansion3DSharedPtr > Expansion3DVector;
typedef std::vector< Expansion3DSharedPtr >::iterator Expansion3DVectorIter;
inline void Expansion3D::AddHDGHelmholtzFaceTerms(const NekDouble tau,
const int face,
StdRegions::StdExpansionSharedPtr FaceExp,
const StdRegions::VarCoeffMap &dirForcing,
Array <OneD,NekDouble > &outarray)
{
v_AddHDGHelmholtzFaceTerms(tau, face, FaceExp, dirForcing, outarray);
}
inline void Expansion3D::AddHDGHelmholtzTraceTerms(const NekDouble tau,
const Array<OneD, const NekDouble> &inarray,
Array<OneD,StdRegions::StdExpansionSharedPtr> &FaceExp,
const StdRegions::VarCoeffMap &dirForcing,
Array<OneD,NekDouble> &outarray)
{
v_AddHDGHelmholtzTraceTerms(tau, inarray, FaceExp, dirForcing, outarray);
}
inline void Expansion3D::AddNormTraceInt(const int dir,
Array<OneD, const NekDouble> &inarray,
Array<OneD,StdRegions::StdExpansionSharedPtr> &FaceExp,
Array<OneD,NekDouble> &outarray,
const StdRegions::VarCoeffMap &varcoeffs)
{
v_AddNormTraceInt(dir, inarray, FaceExp, outarray, varcoeffs);
}
inline void Expansion3D::AddFaceBoundaryInt(const int face,
StdRegions::StdExpansionSharedPtr &FaceExp,
Array <OneD,NekDouble > &outarray,
const StdRegions::VarCoeffMap &varcoeffs)
{
v_AddFaceBoundaryInt(face, FaceExp, outarray, varcoeffs);
}
} //end of namespace
} //end of namespace
......
......@@ -60,9 +60,10 @@ namespace Nektar
const LibUtilities::BasisKey &Bc,
const SpatialDomains::HexGeomSharedPtr &geom):
StdExpansion (Ba.GetNumModes()*Bb.GetNumModes()*Bc.GetNumModes(),3,Ba,Bb,Bc),
Expansion (),
StdExpansion3D(Ba.GetNumModes()*Bb.GetNumModes()*Bc.GetNumModes(),Ba,Bb,Bc),
StdRegions::StdHexExp(Ba,Bb,Bc),
Expansion (),
Expansion3D (),
m_geom(geom),
m_metricinfo(m_geom->GetGeomFactors(m_base)),
m_matrixManager(
......@@ -82,10 +83,10 @@ namespace Nektar
*/
HexExp::HexExp(const HexExp &T):
StdExpansion(T),
Expansion(T),
StdExpansion3D(T),
Expansion3D(T),
StdRegions::StdHexExp(T),
Expansion(T),
Expansion3D(T),
m_geom(T.m_geom),
m_metricinfo(T.m_metricinfo),
m_matrixManager(T.m_matrixManager),
......@@ -325,77 +326,31 @@ namespace Nektar
* @param outarray Output array of data.
*/
void HexExp::v_IProductWRTBase(
const Array<OneD, const NekDouble>& inarray,
Array<OneD, NekDouble> & outarray)
{
HexExp::v_IProductWRTBase(m_base[0]->GetBdata(),
m_base[1]->GetBdata(),
m_base[2]->GetBdata(),
inarray,outarray,1);
}
/**
* \brief Calculate the inner product of inarray with respect to the
* given basis B = base0 * base1 * base2.
*
* \f$ \begin{array}{rcl} I_{pqr} = (\phi_{pqr}, u)_{\delta}
* & = & \sum_{i=0}^{nq_0} \sum_{j=0}^{nq_1} \sum_{k=0}^{nq_2}
* \psi_{p}^{a} (\xi_{1i}) \psi_{q}^{a} (\xi_{2j}) \psi_{r}^{a}
* (\xi_{3k}) w_i w_j w_k u(\xi_{1,i} \xi_{2,j} \xi_{3,k})
* J_{i,j,k}\\ & = & \sum_{i=0}^{nq_0} \psi_p^a(\xi_{1,i})
* \sum_{j=0}^{nq_1} \psi_{q}^a(\xi_{2,j}) \sum_{k=0}^{nq_2}
* \psi_{r}^a u(\xi_{1i},\xi_{2j},\xi_{3k})
* J_{i,j,k} \end{array} \f$ \n
* where
* \f$ \phi_{pqr} (\xi_1 , \xi_2 , \xi_3)
* = \psi_p^a ( \xi_1) \psi_{q}^a (\xi_2) \psi_{r}^a (\xi_3) \f$ \n
* which can be implemented as \n
* \f$f_{r} (\xi_{3k})
* = \sum_{k=0}^{nq_3} \psi_{r}^a u(\xi_{1i},\xi_{2j},\xi_{3k})
* J_{i,j,k} = {\bf B_3 U} \f$ \n
* \f$ g_{q} (\xi_{3k}) = \sum_{j=0}^{nq_1} \psi_{q}^a (\xi_{2j})
* f_{r} (\xi_{3k}) = {\bf B_2 F} \f$ \n
* \f$ (\phi_{pqr}, u)_{\delta}
* = \sum_{k=0}^{nq_0} \psi_{p}^a (\xi_{3k}) g_{q} (\xi_{3k})
* = {\bf B_1 G} \f$
*
* @param base0 Basis to integrate wrt in first dimension.
* @param base1 Basis to integrate wrt in second dimension.
* @param base2 Basis to integrate wrt in third dimension.
* @param inarray Input array.
* @param outarray Output array.
* @param coll_check (not used)
*/
void HexExp::v_IProductWRTBase(
const Array<OneD, const NekDouble>& base0,
const Array<OneD, const NekDouble>& base1,
const Array<OneD, const NekDouble>& base2,
const Array<OneD, const NekDouble>& inarray,
Array<OneD, NekDouble> & outarray,
int coll_check)
const Array<OneD, const NekDouble> &inarray,
Array<OneD, NekDouble> &outarray)
{
int nquad0 = m_base[0]->GetNumPoints();