#include <StdMatrixKey.h>

Inheritance diagram for Nektar::StdRegions::StdMatrixKey:

Collaboration diagram for Nektar::StdRegions::StdMatrixKey:

Classes
struct	opLess
	Used to lookup the create function in NekManager. More...

Public Member Functions
	StdMatrixKey (const StdRegions::MatrixType matrixType, const LibUtilities::ShapeType shapeType, const StdRegions::StdExpansion &stdExpansion, const ConstFactorMap &factorMap=NullConstFactorMap, const VarCoeffMap &varCoeffMap=NullVarCoeffMap, LibUtilities::PointsType nodalType=LibUtilities::eNoPointsType)

	StdMatrixKey (const StdMatrixKey &rhs, const StdRegions::MatrixType matrixType)

	StdMatrixKey (const StdMatrixKey &rhs)

virtual	~StdMatrixKey ()

MatrixType	GetMatrixType () const

LibUtilities::ShapeType	GetShapeType () const

LibUtilities::PointsType	GetNodalPointsType () const

int	GetNcoeffs () const

const Array< OneD, const LibUtilities::BasisSharedPtr > &	GetBase () const

std::vector< std::size_t >	GetVarCoeffHashes () const

const LibUtilities::BasisSharedPtr	GetBasis (int dir) const

int	GetNConstFactors () const

NekDouble	GetConstFactor (const ConstFactorType &factor) const

bool	ConstFactorExists (const ConstFactorType &factor) const

const ConstFactorMap &	GetConstFactors () const

int	GetNVarCoeff () const

const Array< OneD, const NekDouble > &	GetVarCoeff (const StdRegions::VarCoeffType &coeff) const

const VarCoeffMap	GetVarCoeffAsMap (const VarCoeffType &coeff) const

const VarCoeffMap &	GetVarCoeffs () const

bool	HasVarCoeff (const StdRegions::VarCoeffType &coeff) const

Protected Attributes
LibUtilities::ShapeType	m_shapeType

Array< OneD, const LibUtilities::BasisSharedPtr >	m_base

unsigned int	m_ncoeffs

MatrixType	m_matrixType

LibUtilities::PointsType	m_nodalPointsType

ConstFactorMap	m_factors

VarCoeffMap	m_varcoeffs

std::vector< std::size_t >	m_varcoeff_hashes

Private Member Functions
	StdMatrixKey ()

Friends
bool	operator< (const StdMatrixKey &lhs, const StdMatrixKey &rhs)
	Used for finding value given the key in NekManager. More...

bool	operator== (const StdMatrixKey &lhs, const StdMatrixKey &rhs)

bool	opLess::operator() (const StdMatrixKey &lhs, const StdMatrixKey &rhs) const

Detailed Description

Definition at line 52 of file StdMatrixKey.h.

Constructor & Destructor Documentation

Nektar::StdRegions::StdMatrixKey::StdMatrixKey	(	const StdRegions::MatrixType	matrixType,
		const LibUtilities::ShapeType	shapeType,
		const StdRegions::StdExpansion &	stdExpansion,
		const ConstFactorMap &	factorMap = `NullConstFactorMap`,
		const VarCoeffMap &	varCoeffMap = `NullVarCoeffMap`,
		LibUtilities::PointsType	nodalType = `LibUtilities::eNoPointsType`
	)

Definition at line 44 of file StdMatrixKey.cpp.

References Nektar::StdRegions::StdExpansion::GetTotPoints(), and m_varcoeff_hashes.

                                                                      :
             m_shapeType(shapeType),
             m_base(stdExpansion.GetBase()),
             m_ncoeffs(stdExpansion.GetNcoeffs()),
             m_matrixType(matrixType),
             m_nodalPointsType(nodalType),
             m_factors(factorMap),
             m_varcoeffs(varCoeffMap),
             m_varcoeff_hashes(varCoeffMap.size())
         {
             // Create hash
             int i = 0;
             for (VarCoeffMap::const_iterator x = varCoeffMap.begin(); x != varCoeffMap.end(); ++x)
             {
                 m_varcoeff_hashes[i] = boost::hash_range(x->second.begin(), x->second.begin() + stdExpansion.GetTotPoints());
                 boost::hash_combine(m_varcoeff_hashes[i], (int)x->first);
                 i++;
             }
         }

Nektar::StdRegions::StdMatrixKey::StdMatrixKey	(	const StdMatrixKey &	rhs,
		const StdRegions::MatrixType	matrixType
	)

Definition at line 69 of file StdMatrixKey.cpp.

                                                              :
             m_shapeType(rhs.m_shapeType),
             m_base(rhs.m_base),
             m_ncoeffs(rhs.m_ncoeffs),
             m_matrixType(matrixType),
             m_nodalPointsType(rhs.m_nodalPointsType),
             m_factors(rhs.m_factors),
             m_varcoeffs(rhs.m_varcoeffs),
             m_varcoeff_hashes(rhs.m_varcoeff_hashes)
         {
         }

Nektar::StdRegions::StdMatrixKey::StdMatrixKey ( const StdMatrixKey & rhs )

Definition at line 82 of file StdMatrixKey.cpp.

                                                           :
             m_shapeType(rhs.m_shapeType),
             m_base(rhs.m_base),
             m_ncoeffs(rhs.m_ncoeffs),
             m_matrixType(rhs.m_matrixType),
             m_nodalPointsType(rhs.m_nodalPointsType),
             m_factors(rhs.m_factors),
             m_varcoeffs(rhs.m_varcoeffs),
             m_varcoeff_hashes(rhs.m_varcoeff_hashes)
         {
         }

virtual Nektar::StdRegions::StdMatrixKey::~StdMatrixKey ( )

inlinevirtual

Definition at line 67 of file StdMatrixKey.h.

68 {

69 }

Nektar::StdRegions::StdMatrixKey::StdMatrixKey ( )

private

Member Function Documentation

bool Nektar::StdRegions::StdMatrixKey::ConstFactorExists ( const ConstFactorType & factor ) const

inline

Definition at line 131 of file StdMatrixKey.h.

References m_factors.

             {
                 ConstFactorMap::const_iterator x = m_factors.find(factor);
                 if(x != m_factors.end())
                 {
                     return true;
                 }
                 
                 return false;
             }

const Array<OneD, const LibUtilities::BasisSharedPtr>& Nektar::StdRegions::StdMatrixKey::GetBase ( ) const

inline

Definition at line 102 of file StdMatrixKey.h.

References m_base.

Referenced by Nektar::StdRegions::operator<<().

             {
                 return m_base;
             }

const LibUtilities::BasisSharedPtr Nektar::StdRegions::StdMatrixKey::GetBasis ( int dir ) const

inline

Definition at line 112 of file StdMatrixKey.h.

References m_base.

             {
                 return(m_base[dir]);
             }

NekDouble Nektar::StdRegions::StdMatrixKey::GetConstFactor ( const ConstFactorType & factor ) const

inline

Definition at line 122 of file StdMatrixKey.h.

References ASSERTL1, Nektar::StdRegions::ConstFactorTypeMap, and m_factors.

             {
                 ConstFactorMap::const_iterator x = m_factors.find(factor);
                 ASSERTL1(x != m_factors.end(),
                         "Constant factor not defined: "
                         + std::string(StdRegions::ConstFactorTypeMap[factor]));
                 return x->second;
             }

const ConstFactorMap& Nektar::StdRegions::StdMatrixKey::GetConstFactors ( ) const

inline

Definition at line 142 of file StdMatrixKey.h.

References m_factors.

             {
                 return m_factors;
             }

MatrixType Nektar::StdRegions::StdMatrixKey::GetMatrixType ( ) const

inline

Definition at line 82 of file StdMatrixKey.h.

References m_matrixType.

             {
                 return m_matrixType;
             }

int Nektar::StdRegions::StdMatrixKey::GetNcoeffs ( void ) const

inline

Definition at line 97 of file StdMatrixKey.h.

References m_ncoeffs.

Referenced by Nektar::StdRegions::operator<<().

             {
                 return m_ncoeffs;
             }

int Nektar::StdRegions::StdMatrixKey::GetNConstFactors ( ) const

inline

Definition at line 117 of file StdMatrixKey.h.

References m_factors.

             {
                 return m_factors.size();
             }

LibUtilities::PointsType Nektar::StdRegions::StdMatrixKey::GetNodalPointsType ( ) const

inline

Definition at line 92 of file StdMatrixKey.h.

References m_nodalPointsType.

Referenced by Nektar::StdRegions::StdExpansion::CreateGeneralMatrix().

             {
                 return m_nodalPointsType;
             }

int Nektar::StdRegions::StdMatrixKey::GetNVarCoeff ( ) const

inline

Definition at line 147 of file StdMatrixKey.h.

References m_varcoeffs.

Referenced by Nektar::LocalRegions::PyrExp::CreateMatrix(), Nektar::LocalRegions::TetExp::CreateMatrix(), Nektar::LocalRegions::PrismExp::CreateMatrix(), Nektar::LocalRegions::TriExp::CreateMatrix(), Nektar::LocalRegions::QuadExp::CreateMatrix(), Nektar::LocalRegions::SegExp::CreateMatrix(), Nektar::LocalRegions::HexExp::CreateMatrix(), Nektar::LocalRegions::TetExp::CreateStaticCondMatrix(), Nektar::LocalRegions::QuadExp::CreateStaticCondMatrix(), Nektar::LocalRegions::TriExp::CreateStaticCondMatrix(), Nektar::LocalRegions::HexExp::CreateStaticCondMatrix(), Nektar::StdRegions::StdExpansion::LaplacianMatrixOp_MatFree(), Nektar::StdRegions::StdExpansion::LaplacianMatrixOp_MatFree_GenericImpl(), Nektar::StdRegions::StdExpansion::LinearAdvectionDiffusionReactionMatrixOp_MatFree(), Nektar::StdRegions::StdExpansion2D::v_HelmholtzMatrixOp_MatFree(), Nektar::StdRegions::StdExpansion3D::v_HelmholtzMatrixOp_MatFree(), Nektar::StdRegions::StdExpansion2D::v_LaplacianMatrixOp_MatFree(), and Nektar::StdRegions::StdExpansion3D::v_LaplacianMatrixOp_MatFree().

             {
                 return m_varcoeffs.size();
             }

LibUtilities::ShapeType Nektar::StdRegions::StdMatrixKey::GetShapeType ( ) const

inline

Definition at line 87 of file StdMatrixKey.h.

References m_shapeType.

Referenced by Nektar::StdRegions::StdExpansion::CreateGeneralMatrix(), Nektar::LocalRegions::PyrExp::CreateMatrix(), Nektar::LocalRegions::NodalTriExp::CreateMatrix(), Nektar::LocalRegions::TetExp::CreateMatrix(), Nektar::LocalRegions::PrismExp::CreateMatrix(), Nektar::LocalRegions::QuadExp::CreateMatrix(), Nektar::LocalRegions::TriExp::CreateMatrix(), Nektar::LocalRegions::SegExp::CreateMatrix(), Nektar::LocalRegions::HexExp::CreateMatrix(), and Nektar::StdRegions::operator<<().

             {
                 return m_shapeType;
             }

const Array<OneD, const NekDouble>& Nektar::StdRegions::StdMatrixKey::GetVarCoeff ( const StdRegions::VarCoeffType & coeff ) const

inline

Definition at line 152 of file StdMatrixKey.h.

References ASSERTL1, m_varcoeffs, and Nektar::StdRegions::VarCoeffTypeMap.

Referenced by GetVarCoeffAsMap(), Nektar::StdRegions::StdExpansion::LaplacianMatrixOp_MatFree(), Nektar::StdRegions::StdExpansion::LinearAdvectionDiffusionReactionMatrixOp_MatFree(), Nektar::StdRegions::StdExpansion::MassMatrixOp_MatFree(), Nektar::LocalRegions::Expansion2D::v_GenMatrix(), Nektar::StdRegions::StdTriExp::v_SVVLaplacianFilter(), Nektar::StdRegions::StdQuadExp::v_SVVLaplacianFilter(), and Nektar::StdRegions::StdExpansion::WeakDerivMatrixOp_MatFree().

             {
                 VarCoeffMap::const_iterator x = m_varcoeffs.find(coeff);
                 ASSERTL1(x != m_varcoeffs.end(),
                         "Variable coefficient not defined: "
                         + std::string(StdRegions::VarCoeffTypeMap[coeff]));
                 return x->second;
             }

const VarCoeffMap Nektar::StdRegions::StdMatrixKey::GetVarCoeffAsMap ( const VarCoeffType & coeff ) const

inline

Definition at line 161 of file StdMatrixKey.h.

References GetVarCoeff().

Referenced by Nektar::LocalRegions::Expansion2D::v_GenMatrix().

             {
                 VarCoeffMap m;
                 m[coeff] = GetVarCoeff(coeff);
                 return m;
             }

std::vector<std::size_t> Nektar::StdRegions::StdMatrixKey::GetVarCoeffHashes ( ) const

inline

Definition at line 107 of file StdMatrixKey.h.

References m_varcoeff_hashes.

Referenced by Nektar::StdRegions::operator<<().

             {
                 return m_varcoeff_hashes;
             }

const VarCoeffMap& Nektar::StdRegions::StdMatrixKey::GetVarCoeffs ( ) const

inline

Definition at line 168 of file StdMatrixKey.h.

References m_varcoeffs.

Referenced by Nektar::LocalRegions::PyrExp::CreateMatrix(), Nektar::LocalRegions::TetExp::CreateMatrix(), Nektar::LocalRegions::PrismExp::CreateMatrix(), Nektar::LocalRegions::TriExp::CreateMatrix(), Nektar::LocalRegions::QuadExp::CreateMatrix(), Nektar::LocalRegions::SegExp::CreateMatrix(), Nektar::LocalRegions::HexExp::CreateMatrix(), Nektar::StdRegions::operator<<(), Nektar::LocalRegions::Expansion3D::v_GenMatrix(), and Nektar::LocalRegions::Expansion2D::v_GenMatrix().

             {
                 return m_varcoeffs;
             }

bool Nektar::StdRegions::StdMatrixKey::HasVarCoeff ( const StdRegions::VarCoeffType & coeff ) const

inline

Definition at line 173 of file StdMatrixKey.h.

References m_varcoeffs.

Referenced by Nektar::StdRegions::StdExpansion::LaplacianMatrixOp_MatFree(), Nektar::StdRegions::StdExpansion::MassMatrixOp_MatFree(), Nektar::LocalRegions::Expansion3D::v_GenMatrix(), Nektar::LocalRegions::Expansion2D::v_GenMatrix(), Nektar::StdRegions::StdTriExp::v_SVVLaplacianFilter(), Nektar::StdRegions::StdQuadExp::v_SVVLaplacianFilter(), and Nektar::StdRegions::StdExpansion::WeakDerivMatrixOp_MatFree().

             {
                 return (m_varcoeffs.find(coeff) != m_varcoeffs.end());
             }

Friends And Related Function Documentation

bool operator<	(	const StdMatrixKey &	lhs,
		const StdMatrixKey &	rhs
	)

friend

Used for finding value given the key in NekManager.

Definition at line 100 of file StdMatrixKey.cpp.

         {
             if(lhs.m_matrixType < rhs.m_matrixType)
             {
                 return true;
             }
             
             if(lhs.m_matrixType > rhs.m_matrixType)
             {
                 return false;
             }
             
             if(lhs.m_ncoeffs < rhs.m_ncoeffs) // probably do not need this check since checking the m_base below? 
             {
                 return true;
             }
             
             if(lhs.m_ncoeffs > rhs.m_ncoeffs)
             {
                 return false;
             }
             
             for(unsigned int i = 0; i < LibUtilities::ShapeTypeDimMap[lhs.m_shapeType]; ++i)
             {
                 if(lhs.m_base[i].get() < rhs.m_base[i].get())
                 {
                     return true;
                 }
                 
                 if(lhs.m_base[i].get() > rhs.m_base[i].get())
                 {
                     return false;
                 }
             }
 
             if(lhs.m_factors.size() < rhs.m_factors.size())
             {
                 return true;
             }
             else if(lhs.m_factors.size() > rhs.m_factors.size())
             {
                 return false;
             }
             else 
             {
                 ConstFactorMap::const_iterator x, y;
                 for(x = lhs.m_factors.begin(), y = rhs.m_factors.begin();
                     x != lhs.m_factors.end(); ++x, ++y)
                 {
                     if (x->second < y->second)
                     {
                         return true;
                     }
                     if (x->second > y->second)
                     {
                         return false;
                     }
                 }
             }
 
             if(lhs.m_varcoeffs.size() < rhs.m_varcoeffs.size())
             {
                 return true;
             }
 
             if(lhs.m_varcoeffs.size() > rhs.m_varcoeffs.size())
             {
                 return false;
             }
 
             for (unsigned int i = 0; i < lhs.m_varcoeff_hashes.size(); ++i)
             {
                 if(lhs.m_varcoeff_hashes[i] < rhs.m_varcoeff_hashes[i])
                 {
                     return true;
                 }
                 if(lhs.m_varcoeff_hashes[i] > rhs.m_varcoeff_hashes[i])
                 {
                     return false;
                 }
             }
             
             if(lhs.m_nodalPointsType < rhs.m_nodalPointsType)
             {
                 return true;
             }
             
             if(lhs.m_nodalPointsType > rhs.m_nodalPointsType)
             {
                 return false;
             }
             
             return false;
         }

bool operator==	(	const StdMatrixKey &	lhs,
		const StdMatrixKey &	rhs
	)

friend

Definition at line 195 of file StdMatrixKey.cpp.

         {
             if(lhs.m_matrixType != rhs.m_matrixType)
             {
                 return false;
             }
 
             if(lhs.m_ncoeffs != rhs.m_ncoeffs)
             {
                 return false;
             }
 
             for(unsigned int i = 0; i < LibUtilities::ShapeTypeDimMap[lhs.m_shapeType]; ++i)
             {
                 if(lhs.m_base[i].get() != rhs.m_base[i].get())
                 {
                     return false;
                 }
             }
 
             if(lhs.m_factors.size() != rhs.m_factors.size())
             {
                 return false;
             }
             else
             {
                 ConstFactorMap::const_iterator x, y;
                 for(x = lhs.m_factors.begin(), y = rhs.m_factors.begin();
                         x != lhs.m_factors.end(); ++x, ++y)
                 {
                     if (x->second != y->second)
                     {
                         return false;
                     }
                 }
             }
 
             if(lhs.m_nodalPointsType != rhs.m_nodalPointsType)
             {
                 return false;
             }
 
             if(lhs.m_varcoeffs.size() != rhs.m_varcoeffs.size())
             {
                 return false;
             }
 
             for (unsigned int i = 0; i < lhs.m_varcoeff_hashes.size(); ++i)
             {
                 if(lhs.m_varcoeff_hashes[i] != rhs.m_varcoeff_hashes[i])
                 {
                     return false;
                 }
             }
 
             VarCoeffMap::const_iterator x;
             for (x = lhs.m_varcoeffs.begin(); x != lhs.m_varcoeffs.end(); ++x)
             {
                 VarCoeffMap::const_iterator y;
                 // Check var coeff is found
                 if ((y = rhs.m_varcoeffs.find(x->first)) == rhs.m_varcoeffs.end())
                 {
                     return false;
                 }
 
                 if (x->second != y->second)
                 {
                     return false;
                 }
             }
             for (unsigned int i = 0; i < lhs.m_varcoeffs.size(); ++i)
             {
                 if(lhs.m_varcoeff_hashes[i] != rhs.m_varcoeff_hashes[i])
                 {
                     return false;
                 }
             }
 
             return true;
         }