Nektar::MultiRegions Namespace Reference

Classes
struct	_PeriodicEntity
class	AssemblyMap
	Base class for constructing local to global mapping of degrees of freedom. More...
class	AssemblyMapCG
	Constructs mappings for the C0 scalar continuous Galerkin formulation. More...
class	AssemblyMapDG
class	BottomUpSubStructuredGraph
struct	cmpop
class	ContField1D
	Abstraction of a global continuous one-dimensional spectral/hp element expansion which approximates the solution of a set of partial differential equations. More...
class	ContField2D
	This class is the abstraction of a global continuous two- dimensional spectral/hp element expansion which approximates the solution of a set of partial differential equations. More...
class	ContField3D
class	ContField3DHomogeneous1D
class	ContField3DHomogeneous2D
class	DisContField1D
	This class is the abstraction of a global discontinuous two- dimensional spectral/hp element expansion which approximates the solution of a set of partial differential equations. More...
class	DisContField2D
class	DisContField3D
class	DisContField3DHomogeneous1D
class	DisContField3DHomogeneous2D
class	ExpList
	Base class for all multi-elemental spectral/hp expansions. More...
class	ExpList0D
	This class is the abstraction of a collection of zero-dimensional expansions which is merely a collection of points/values. More...
class	ExpList1D
	This class is the abstraction of a one-dimensional multi-elemental expansions which is merely a collection of local expansions. More...
class	ExpList1DHomogeneous2D
	Abstraction of a one-dimensional multi-elemental expansion which is merely a collection of local expansions. More...
class	ExpList2D
	Abstraction of a two-dimensional multi-elemental expansion which is merely a collection of local expansions. More...
class	ExpList2DHomogeneous1D
	Abstraction of a two-dimensional multi-elemental expansion which is merely a collection of local expansions. More...
class	ExpList3D
	Abstraction of a three-dimensional multi-elemental expansion which is merely a collection of local expansions. More...
class	ExpList3DHomogeneous1D
	Abstraction of a two-dimensional multi-elemental expansion which is merely a collection of local expansions. More...
class	ExpList3DHomogeneous2D
	Abstraction of a one-dimensional multi-elemental expansion which is merely a collection of local expansions. More...
class	ExpListHomogeneous1D
	Abstraction of a two-dimensional multi-elemental expansion which is merely a collection of local expansions. More...
class	ExpListHomogeneous2D
	Abstraction of a two-dimensional multi-elemental expansion which is merely a collection of local expansions. More...
class	GlobalLinSys
	A global linear system. More...
class	GlobalLinSysDirect
	A global linear system. More...
class	GlobalLinSysDirectFull
	A global linear system. More...
class	GlobalLinSysDirectStaticCond
	A global linear system. More...
class	GlobalLinSysIterative
	A global linear system. More...
class	GlobalLinSysIterativeFull
	A global linear system. More...
class	GlobalLinSysIterativeStaticCond
	A global linear system. More...
class	GlobalLinSysKey
	Describe a linear system. More...
class	GlobalLinSysPETSc
	A PETSc global linear system. More...
class	GlobalLinSysPETScFull
	A global linear system. More...
class	GlobalLinSysPETScStaticCond
	A global linear system. More...
class	GlobalLinSysStaticCond
	A global linear system. More...
class	GlobalLinSysXxt
class	GlobalLinSysXxtFull
	A global linear system. More...
class	GlobalLinSysXxtStaticCond
	A global linear system. More...
class	GlobalMatrix
	Represents a matrix of all degrees of freedom. More...
class	GlobalMatrixKey
	Describes a matrix with ordering defined by a local to global map. More...
class	LocTraceToTraceMap
	A helper class to deal with trace operations in the discontinuous Galerkin code. More...
class	MultiLevelBisectedGraph
class	PatchMap
class	Preconditioner
class	PreconditionerBlock
class	PreconditionerDiagonal
class	PreconditionerLinear
class	PreconditionerLinearWithBlock
class	PreconditionerLinearWithDiag
class	PreconditionerLinearWithLowEnergy
class	PreconditionerLowEnergy
class	PreconditionerNull
struct	RobinBCInfo
class	SubGraph

Typedefs
typedef boost::shared_ptr < AssemblyMap >	AssemblyMapSharedPtr
typedef boost::shared_ptr < AssemblyMapCG >	AssemblyMapCGSharedPtr
typedef boost::tuple< int, int, NekDouble >	ExtraDirDof
typedef std::vector< std::map < int, int > >	DofGraph
typedef boost::shared_ptr < AssemblyMapDG >	AssemblyMapDGSharedPtr
typedef boost::shared_ptr < ExpList >	ExpListSharedPtr
	Shared pointer to an ExpList object. More...
typedef boost::tuple < LibUtilities::PointsKey, LibUtilities::PointsKey, LibUtilities::PointsKey, LibUtilities::PointsKey >	TraceInterpPoints
	Map holding points distributions required for interpolation of local traces onto global trace in two and three dimensions. More...
typedef boost::shared_ptr < LocTraceToTraceMap >	LocTraceToTraceMapSharedPtr
typedef boost::shared_ptr < ContField1D >	ContField1DSharedPtr
typedef boost::shared_ptr < ContField2D >	ContField2DSharedPtr
typedef boost::shared_ptr < ContField3D >	ContField3DSharedPtr
typedef boost::shared_ptr < ContField3DHomogeneous1D >	ContField3DHomogeneous1DSharedPtr
typedef boost::shared_ptr < ContField3DHomogeneous2D >	ContField3DHomogeneous2DSharedPtr
typedef boost::shared_ptr < DisContField1D >	DisContField1DSharedPtr
typedef boost::shared_ptr < DisContField2D >	DisContField2DSharedPtr
typedef boost::shared_ptr < DisContField3D >	DisContField3DSharedPtr
typedef boost::shared_ptr < DisContField3DHomogeneous1D >	DisContField3DHomogeneous1DSharedPtr
typedef boost::shared_ptr < DisContField3DHomogeneous2D >	DisContField3DHomogeneous2DSharedPtr
typedef std::map < GlobalMatrixKey, DNekScalBlkMatSharedPtr >	BlockMatrixMap
	A map between global matrix keys and their associated block matrices. More...
typedef boost::shared_ptr < BlockMatrixMap >	BlockMatrixMapShPtr
	A shared pointer to a BlockMatrixMap. More...
typedef boost::shared_ptr < ExpList0D >	ExpList0DSharedPtr
	Shared pointer to an ExpList0D object. More...
typedef std::vector < ExpList0DSharedPtr >	ExpList0DVector
	Vector of pointers to ExpList0D objects. More...
typedef std::vector < ExpList0DSharedPtr > ::iterator	ExpList0DVectorIter
	Iterator for the vector of ExpList0D pointers. More...
typedef boost::shared_ptr < ExpList1D >	ExpList1DSharedPtr
	Shared pointer to an ExpList1D object. More...
typedef std::vector < ExpList1DSharedPtr >	ExpList1DVector
	Vector of pointers to ExpList1D objects. More...
typedef std::vector < ExpList1DSharedPtr > ::iterator	ExpList1DVectorIter
	Iterator for the vector of ExpList1D pointers. More...
typedef boost::shared_ptr < ExpList1DHomogeneous2D >	ExpList1DHomogeneous2DSharedPtr
	Shared pointer to an ExpList1DHomogeneous2D object. More...
typedef std::vector < ExpList1DHomogeneous2DSharedPtr >	ExpList1DHomogeneous2DVector
	Vector of pointers to ExpList1DHomogeneous2D objects. More...
typedef std::vector < ExpList1DHomogeneous2DSharedPtr > ::iterator	ExpList1DHomogeneous2DVectorIter
	Iterator for the vector of ExpList1DHomogeneous2D pointers. More...
typedef boost::shared_ptr < ExpList2D >	ExpList2DSharedPtr
	Shared pointer to an ExpList2D object. More...
typedef std::vector < ExpList2DSharedPtr >	ExpList2DVector
	Vector of pointers to ExpList2D objects. More...
typedef std::vector < ExpList2DSharedPtr > ::iterator	ExpList2DVectorIter
	Iterator for the vector of ExpList2D pointers. More...
typedef boost::shared_ptr < ExpList2DHomogeneous1D >	ExpList2DHomogeneous1DSharedPtr
	Shared pointer to an ExpList2DHomogeneous1D object. More...
typedef std::vector < ExpList2DHomogeneous1DSharedPtr >	ExpList2DHomogeneous1DVector
	Vector of pointers to ExpList2DHomogeneous1D objects. More...
typedef std::vector < ExpList2DHomogeneous1DSharedPtr > ::iterator	ExpList2DHomogeneous1DVectorIter
	Iterator for the vector of ExpList2DHomogeneous1D pointers. More...
typedef boost::shared_ptr < ExpList3D >	ExpList3DSharedPtr
	Shared pointer to an ExpList3D object. More...
typedef std::vector < ExpList3DSharedPtr >	ExpList3DVector
	Vector of pointers to ExpList3D objects. More...
typedef std::vector < ExpList3DSharedPtr > ::iterator	ExpList3DVectorIter
	Iterator over an ExpList3DVector. More...
typedef boost::shared_ptr < ExpList3DHomogeneous1D >	ExpList3DHomogeneous1DSharedPtr
	Shared pointer to an ExpList3DHomogeneous1D object. More...
typedef std::vector < ExpList3DHomogeneous1DSharedPtr >	ExpList3DHomogeneous1DVector
	Vector of pointers to ExpList3DHomogeneous1D objects. More...
typedef std::vector < ExpList3DHomogeneous1DSharedPtr > ::iterator	ExpList3DHomogeneous1DVectorIter
	Iterator for the vector of ExpList3DHomogeneous1D pointers. More...
typedef boost::shared_ptr < ExpList3DHomogeneous2D >	ExpList3DHomogeneous2DSharedPtr
	Shared pointer to an ExpList3DHomogeneous2D object. More...
typedef std::vector < ExpList3DHomogeneous2DSharedPtr >	ExpList3DHomogeneous2DVector
	Vector of pointers to ExpList3DHomogeneous2D objects. More...
typedef std::vector < ExpList3DHomogeneous2DSharedPtr > ::iterator	ExpList3DHomogeneous2DVectorIter
	Iterator for the vector of ExpList3DHomogeneous2D pointers. More...
typedef std::map < Homogeneous1DMatType, DNekBlkMatSharedPtr >	Homo1DBlockMatrixMap
	A map between homo matrix keys and their associated block matrices. More...
typedef boost::shared_ptr < Homo1DBlockMatrixMap >	Homo1DBlockMatrixMapShPtr
	A shared pointer to a BlockMatrixMap. More...
typedef boost::shared_ptr < ExpListHomogeneous1D >	ExpListHomogeneous1DSharedPtr
	Shared pointer to an ExpList3DHomogeneous1D object. More...
typedef std::vector < ExpListHomogeneous1DSharedPtr >	ExpListHomogeneous1DVector
	Vector of pointers to ExpList3DHomogeneous1D objects. More...
typedef std::vector < ExpListHomogeneous1DSharedPtr > ::iterator	ExpListHomogeneous1DVectorIter
	Iterator for the vector of ExpList3DHomogeneous1D pointers. More...
typedef std::map < Homogeneous2DMatType, DNekBlkMatSharedPtr >	Homo2DBlockMatrixMap
	A map between homo matrix keys and their associated block matrices. More...
typedef boost::shared_ptr < Homo2DBlockMatrixMap >	Homo2DBlockMatrixMapShPtr
	A shared pointer to a BlockMatrixMap. More...
typedef boost::shared_ptr < ExpListHomogeneous2D >	ExpListHomogeneous2DSharedPtr
	Shared pointer to an ExpList3DHomogeneous2D object. More...
typedef std::vector < ExpListHomogeneous2DSharedPtr >	ExpListHomogeneous2DVector
	Vector of pointers to ExpList3DHomogeneous2D objects. More...
typedef std::vector < ExpListHomogeneous2DSharedPtr > ::iterator	ExpListHomogeneous2DVectorIter
	Iterator for the vector of ExpList3DHomogeneous2D pointers. More...
typedef boost::shared_ptr < GlobalLinSys >	GlobalLinSysSharedPtr
	Pointer to a GlobalLinSys object. More...
typedef std::map < GlobalLinSysKey, GlobalLinSysSharedPtr >	GlobalLinSysMap
	Mapping between GlobalLinSys objects and their associated keys. More...
typedef boost::shared_ptr < GlobalLinSysMap >	GlobalLinSysMapShPtr
	Pointer to a GlobalLinSys/key map. More...
typedef boost::shared_ptr < Preconditioner >	PreconditionerSharedPtr
typedef LibUtilities::NekFactory < std::string, GlobalLinSys, const GlobalLinSysKey &, const boost::weak_ptr< ExpList > &, const boost::shared_ptr < AssemblyMap > & >	GlobalLinSysFactory
	Datatype of the NekFactory used to instantiate classes derived from the EquationSystem class. More...
typedef boost::shared_ptr < GlobalLinSysDirectStaticCond >	GlobalLinSysDirectStaticCondSharedPtr
typedef boost::shared_ptr < GlobalLinSysIterativeStaticCond >	GlobalLinSysIterativeStaticCondSharedPtr
typedef boost::shared_ptr < GlobalLinSysPETScStaticCond >	GlobalLinSysPETScStaticCondSharedPtr
typedef boost::shared_ptr < GlobalLinSysStaticCond >	GlobalLinSysStaticCondSharedPtr
typedef boost::shared_ptr < GlobalLinSysXxtStaticCond >	GlobalLinSysXxtStaticCondSharedPtr
typedef boost::shared_ptr < GlobalMatrix >	GlobalMatrixSharedPtr
	Shared pointer to a GlobalMatrix object. More...
typedef std::map < GlobalMatrixKey, GlobalMatrixSharedPtr >	GlobalMatrixMap
	Mapping from global matrix keys to global matrices. More...
typedef boost::shared_ptr < GlobalMatrixMap >	GlobalMatrixMapShPtr
	Shared pointer to a global matrix map. More...
typedef boost::shared_ptr < GlobalMatrixKey >	GlobalMatrixKeySharedPtr
	A pointer to a GlobalMatrixKey. More...
typedef std::vector < SpatialDomains::BoundaryConditionType >	BndTypesVector
typedef std::vector < SpatialDomains::BoundaryConditionType > ::iterator	BndTypesVectorIter
typedef boost::shared_ptr < RobinBCInfo >	RobinBCInfoSharedPtr
typedef struct Nektar::MultiRegions::_PeriodicEntity	PeriodicEntity
typedef std::map< int, std::vector< PeriodicEntity > >	PeriodicMap
typedef LibUtilities::NekFactory < std::string, Preconditioner, const boost::shared_ptr < GlobalLinSys > &, const boost::shared_ptr< AssemblyMap > & >	PreconFactory
typedef boost::shared_ptr < PreconditionerBlock >	PreconditionerBlockSharedPtr
typedef boost::shared_ptr < PreconditionerDiagonal >	PreconditionerDiagonalSharedPtr
typedef boost::shared_ptr < PreconditionerNull >	PreconditionerNullSharedPtr
typedef boost::shared_ptr < PreconditionerLinear >	PreconditionerLinearSharedPtr
typedef boost::shared_ptr < PreconditionerLinearWithBlock >	PreconditionerLinearWithBlockSharedPtr
typedef boost::shared_ptr < PreconditionerLinearWithDiag >	PreconditionerLinearWithDiagSharedPtr
typedef boost::shared_ptr < PreconditionerLinearWithLowEnergy >	PreconditionerLinearWithLowEnergySharedPtr
typedef boost::shared_ptr < PreconditionerLowEnergy >	PreconditionerLowEnergySharedPtr
typedef boost::shared_ptr < BottomUpSubStructuredGraph >	BottomUpSubStructuredGraphSharedPtr
typedef boost::shared_ptr < SubGraph >	SubGraphSharedPtr
typedef boost::shared_ptr < MultiLevelBisectedGraph >	MultiLevelBisectedGraphSharedPtr
typedef boost::shared_ptr < PatchMap >	PatchMapSharedPtr

Enumerations
enum	InterpLocTraceToTrace {   eNoInterp, eInterpDir0, eInterpEndPtDir0, eInterpDir1,   eInterpEndPtDir1, eInterpBothDirs, eInterpEndPtDir0InterpDir1 }
enum	Direction {   eX, eY, eZ, eS,   eN }
enum	ExpansionType {   e0D, e1D, e2D, e3DH1D,   e3DH2D, e3D, eNoType }
enum	Homogeneous1DMatType { eForwardsCoeffSpace1D, eBackwardsCoeffSpace1D, eForwardsPhysSpace1D, eBackwardsPhysSpace1D }
enum	Homogeneous2DMatType {   eForwardsCoeffSpaceY1D, eForwardsCoeffSpaceZ1D, eBackwardsCoeffSpaceY1D, eBackwardsCoeffSpaceZ1D,   eForwardsPhysSpaceY1D, eForwardsPhysSpaceZ1D, eBackwardsPhysSpaceY1D, eBackwardsPhysSpaceZ1D }
enum	LocalMatrixStorageStrategy { eNoStrategy, eContiguous, eNonContiguous, eSparse }
enum	PETScMatMult { ePETScMatMultSparse, ePETScMatMultShell }
	Enumerator. More...
enum	CoeffState { eNotSet, eLocal, eHybrid, eGlobal }
enum	AdjacentTraceOrientation { eAdjacentEdgeIsForwards, eAdjacentEdgeIsBackwards }
enum	AdjacentFaceOrientation {   eAdjacentFaceDir1FwdDir1_Dir2FwdDir2, eAdjacentFaceDir1FwdDir1_Dir2BwdDir2, eAdjacentFaceDir1BwdDir1_Dir2FwdDir2, eAdjacentFaceDir1BwdDir1_Dir2BwdDir2,   eAdjacentFaceDir1FwdDir2_Dir2FwdDir1, eAdjacentFaceDir1FwdDir2_Dir2BwdDir1, eAdjacentFaceDir1BwdDir2_Dir2FwdDir1, eAdjacentFaceDir1BwdDir2_Dir2BwdDir1 }
enum	GlobalSysSolnType {   eNoSolnType, eDirectFullMatrix, eDirectStaticCond, eDirectMultiLevelStaticCond,   eIterativeFull, eIterativeStaticCond, eIterativeMultiLevelStaticCond, eXxtFullMatrix,   eXxtStaticCond, eXxtMultiLevelStaticCond, ePETScFullMatrix, ePETScStaticCond,   ePETScMultiLevelStaticCond, eSIZE_GlobalSysSolnType }
enum	ProjectionType { eGalerkin, eDiscontinuous, eMixed_CG_Discontinuous }
	Type of Galerkin projection. More...
enum	PreconditionerType {   eNull, eDiagonal, eLinearWithDiagonal, eLinear,   eLowEnergy, eLinearWithLowEnergy, eBlock, eLinearWithBlock }
enum	MatrixStorageType { eSmvBSR }
enum	LinearPreconSolver { eLinearPreconXxt, eLinearPreconPETSc }

Functions
int	RoundNekDoubleToInt (NekDouble x)
	Rounds a double precision number to an integer. More...
void	RoundNekDoubleToInt (const Array< OneD, const NekDouble > inarray, Array< OneD, int > outarray)
	Rounds an array of double precision numbers to integers. More...
pair< int, StdRegions::Orientation >	DeterminePeriodicEdgeOrientId (int meshEdgeId, StdRegions::Orientation edgeOrient, const vector< PeriodicEntity > &periodicEdges)
	Determine orientation of an edge to its periodic equivalents, as well as the ID of the representative edge. More...
StdRegions::Orientation	DeterminePeriodicFaceOrient (StdRegions::Orientation faceOrient, StdRegions::Orientation perFaceOrient)
	Determine relative orientation between two faces. More...
StdRegions::StdExpansionSharedPtr	GetStdExp (StdRegions::StdExpansionSharedPtr exp)
void	AlignFace (const StdRegions::Orientation orient, const int nquad1, const int nquad2, const Array< OneD, const NekDouble > &in, Array< OneD, NekDouble > &out)
	Helper function to re-align face to a given orientation. More...
GlobalLinSysFactory &	GetGlobalLinSysFactory ()
bool	operator< (const GlobalLinSysKey &lhs, const GlobalLinSysKey &rhs)
std::ostream &	operator<< (std::ostream &os, const GlobalLinSysKey &rhs)
	Writes information about the object to a given stream. More...
bool	operator< (const GlobalMatrixKey &lhs, const GlobalMatrixKey &rhs)
std::ostream &	operator<< (std::ostream &os, const GlobalMatrixKey &rhs)
	Writes statistics about the matrix key to an output stream. More...
PreconFactory &	GetPreconFactory ()
bool	SubGraphWithoutVerts (const SubGraphSharedPtr g)
void	CuthillMckeeReordering (const BoostGraph &graph, Array< OneD, int > &perm, Array< OneD, int > &iperm)
void	MultiLevelBisectionReordering (const BoostGraph &graph, Array< OneD, int > &perm, Array< OneD, int > &iperm, BottomUpSubStructuredGraphSharedPtr &substructgraph, std::set< int > partVerts, int mdswitch)
void	NoReordering (const BoostGraph &graph, Array< OneD, int > &perm, Array< OneD, int > &iperm)

Variables
static AssemblyMapSharedPtr	NullAssemblyMapSharedPtr
static std::map< int, int >	NullIntIntMap
static const std::vector < std::map< int, int > >	NullVecIntIntMap
MultiRegions::Direction const	DirCartesianMap []
static ExpList	NullExpList
	An empty ExpList object. More...
static ExpListSharedPtr	NullExpListSharedPtr
static const Array< OneD, ExpListSharedPtr >	NullExpListSharedPtrArray
static const Array< OneD, ExpList0DSharedPtr >	NullExpList0DSharedPtrArray
	Empty ExpList0D object. More...
static const Array< OneD, ExpList1DSharedPtr >	NullExpList1DSharedPtrArray
	Empty ExpList1D object. More...
static const Array< OneD, ExpList2DSharedPtr >	NullExpList2DSharedPtrArray
	Empty ExpList2D object. More...
const char *const	LocalMatrixStorageStrategyMap []
const char *const	GlobalSysSolnTypeMap []
const char *const	PreconditionerTypeMap []
const char *const	MatrixStorageTypeMap []
static PeriodicMap	NullPeriodicMap
static PreconditionerSharedPtr	NullPreconditionerSharedPtr

Typedef Documentation

typedef boost::shared_ptr<AssemblyMapCG> Nektar::MultiRegions::AssemblyMapCGSharedPtr

Definition at line 52 of file AssemblyMapCG.h.

typedef boost::shared_ptr<AssemblyMapDG> Nektar::MultiRegions::AssemblyMapDGSharedPtr

Definition at line 49 of file AssemblyMapDG.h.

typedef boost::shared_ptr< AssemblyMap > Nektar::MultiRegions::AssemblyMapSharedPtr

Definition at line 53 of file AssemblyMap.h.

typedef std::map<GlobalMatrixKey,DNekScalBlkMatSharedPtr> Nektar::MultiRegions::BlockMatrixMap

A map between global matrix keys and their associated block matrices.

Definition at line 95 of file ExpList.h.

typedef boost::shared_ptr<BlockMatrixMap> Nektar::MultiRegions::BlockMatrixMapShPtr

A shared pointer to a BlockMatrixMap.

Definition at line 97 of file ExpList.h.

typedef std::vector<SpatialDomains::BoundaryConditionType> Nektar::MultiRegions::BndTypesVector

Definition at line 159 of file MultiRegions.hpp.

typedef std::vector<SpatialDomains::BoundaryConditionType>::iterator Nektar::MultiRegions::BndTypesVectorIter

Definition at line 160 of file MultiRegions.hpp.

typedef boost::shared_ptr<BottomUpSubStructuredGraph> Nektar::MultiRegions::BottomUpSubStructuredGraphSharedPtr

Definition at line 60 of file SubStructuredGraph.h.

typedef boost::shared_ptr<ContField1D> Nektar::MultiRegions::ContField1DSharedPtr

Definition at line 236 of file ContField1D.h.

typedef boost::shared_ptr<ContField2D> Nektar::MultiRegions::ContField2DSharedPtr

Definition at line 287 of file ContField2D.h.

typedef boost::shared_ptr<ContField3DHomogeneous1D> Nektar::MultiRegions::ContField3DHomogeneous1DSharedPtr

Definition at line 106 of file ContField3DHomogeneous1D.h.

typedef boost::shared_ptr<ContField3DHomogeneous2D> Nektar::MultiRegions::ContField3DHomogeneous2DSharedPtr

Definition at line 99 of file ContField3DHomogeneous2D.h.

typedef boost::shared_ptr<ContField3D> Nektar::MultiRegions::ContField3DSharedPtr

Definition at line 206 of file ContField3D.h.

typedef boost::shared_ptr<DisContField1D> Nektar::MultiRegions::DisContField1DSharedPtr

Definition at line 277 of file DisContField1D.h.

typedef boost::shared_ptr<DisContField2D> Nektar::MultiRegions::DisContField2DSharedPtr

Definition at line 301 of file DisContField2D.h.

typedef boost::shared_ptr<DisContField3DHomogeneous1D> Nektar::MultiRegions::DisContField3DHomogeneous1DSharedPtr

Definition at line 299 of file DisContField3DHomogeneous1D.h.

typedef boost::shared_ptr<DisContField3DHomogeneous2D> Nektar::MultiRegions::DisContField3DHomogeneous2DSharedPtr

Definition at line 156 of file DisContField3DHomogeneous2D.h.

typedef boost::shared_ptr<DisContField3D> Nektar::MultiRegions::DisContField3DSharedPtr

Definition at line 271 of file DisContField3D.h.

typedef std::vector<std::map<int, int> > Nektar::MultiRegions::DofGraph

Definition at line 56 of file AssemblyMapCG.h.

typedef boost::shared_ptr<ExpList0D> Nektar::MultiRegions::ExpList0DSharedPtr

Shared pointer to an ExpList0D object.

Definition at line 54 of file ExpList0D.h.

typedef std::vector<ExpList0DSharedPtr> Nektar::MultiRegions::ExpList0DVector

Vector of pointers to ExpList0D objects.

Definition at line 59 of file ExpList0D.h.

typedef std::vector<ExpList0DSharedPtr>::iterator Nektar::MultiRegions::ExpList0DVectorIter

Iterator for the vector of ExpList0D pointers.

Definition at line 61 of file ExpList0D.h.

typedef boost::shared_ptr<ExpList1DHomogeneous2D> Nektar::MultiRegions::ExpList1DHomogeneous2DSharedPtr

Shared pointer to an ExpList1DHomogeneous2D object.

Definition at line 50 of file ExpList1DHomogeneous2D.h.

typedef std::vector< ExpList1DHomogeneous2DSharedPtr > Nektar::MultiRegions::ExpList1DHomogeneous2DVector

Vector of pointers to ExpList1DHomogeneous2D objects.

Definition at line 55 of file ExpList1DHomogeneous2D.h.

typedef std::vector< ExpList1DHomogeneous2DSharedPtr >::iterator Nektar::MultiRegions::ExpList1DHomogeneous2DVectorIter

Iterator for the vector of ExpList1DHomogeneous2D pointers.

Definition at line 57 of file ExpList1DHomogeneous2D.h.

typedef boost::shared_ptr<ExpList1D> Nektar::MultiRegions::ExpList1DSharedPtr

Shared pointer to an ExpList1D object.

Definition at line 50 of file ExpList1D.h.

typedef std::vector<ExpList1DSharedPtr> Nektar::MultiRegions::ExpList1DVector

Vector of pointers to ExpList1D objects.

Definition at line 55 of file ExpList1D.h.

typedef std::vector<ExpList1DSharedPtr>::iterator Nektar::MultiRegions::ExpList1DVectorIter

Iterator for the vector of ExpList1D pointers.

Definition at line 57 of file ExpList1D.h.

typedef boost::shared_ptr<ExpList2DHomogeneous1D> Nektar::MultiRegions::ExpList2DHomogeneous1DSharedPtr

Shared pointer to an ExpList2DHomogeneous1D object.

Definition at line 50 of file ExpList2DHomogeneous1D.h.

typedef std::vector< ExpList2DHomogeneous1DSharedPtr > Nektar::MultiRegions::ExpList2DHomogeneous1DVector

Vector of pointers to ExpList2DHomogeneous1D objects.

Definition at line 57 of file ExpList2DHomogeneous1D.h.

typedef std::vector< ExpList2DHomogeneous1DSharedPtr >::iterator Nektar::MultiRegions::ExpList2DHomogeneous1DVectorIter

Iterator for the vector of ExpList2DHomogeneous1D pointers.

Definition at line 60 of file ExpList2DHomogeneous1D.h.

typedef boost::shared_ptr<ExpList2D> Nektar::MultiRegions::ExpList2DSharedPtr

Shared pointer to an ExpList2D object.

Definition at line 49 of file ExpList2D.h.

typedef std::vector< ExpList2DSharedPtr > Nektar::MultiRegions::ExpList2DVector

Vector of pointers to ExpList2D objects.

Definition at line 54 of file ExpList2D.h.

typedef std::vector< ExpList2DSharedPtr >::iterator Nektar::MultiRegions::ExpList2DVectorIter

Iterator for the vector of ExpList2D pointers.

Definition at line 56 of file ExpList2D.h.

typedef boost::shared_ptr<ExpList3DHomogeneous1D> Nektar::MultiRegions::ExpList3DHomogeneous1DSharedPtr

Shared pointer to an ExpList3DHomogeneous1D object.

Definition at line 50 of file ExpList3DHomogeneous1D.h.

typedef std::vector< ExpList3DHomogeneous1DSharedPtr > Nektar::MultiRegions::ExpList3DHomogeneous1DVector

Vector of pointers to ExpList3DHomogeneous1D objects.

Definition at line 55 of file ExpList3DHomogeneous1D.h.

typedef std::vector< ExpList3DHomogeneous1DSharedPtr >::iterator Nektar::MultiRegions::ExpList3DHomogeneous1DVectorIter

Iterator for the vector of ExpList3DHomogeneous1D pointers.

Definition at line 57 of file ExpList3DHomogeneous1D.h.

typedef boost::shared_ptr<ExpList3DHomogeneous2D> Nektar::MultiRegions::ExpList3DHomogeneous2DSharedPtr

Shared pointer to an ExpList3DHomogeneous2D object.

Definition at line 50 of file ExpList3DHomogeneous2D.h.

typedef std::vector< ExpList3DHomogeneous2DSharedPtr > Nektar::MultiRegions::ExpList3DHomogeneous2DVector

Vector of pointers to ExpList3DHomogeneous2D objects.

Definition at line 55 of file ExpList3DHomogeneous2D.h.

typedef std::vector< ExpList3DHomogeneous2DSharedPtr >::iterator Nektar::MultiRegions::ExpList3DHomogeneous2DVectorIter

Iterator for the vector of ExpList3DHomogeneous2D pointers.

Definition at line 57 of file ExpList3DHomogeneous2D.h.

typedef boost::shared_ptr<ExpList3D> Nektar::MultiRegions::ExpList3DSharedPtr

Shared pointer to an ExpList3D object.

Definition at line 115 of file ExpList3D.h.

typedef std::vector<ExpList3DSharedPtr> Nektar::MultiRegions::ExpList3DVector

Vector of pointers to ExpList3D objects.

Definition at line 117 of file ExpList3D.h.

typedef std::vector<ExpList3DSharedPtr>::iterator Nektar::MultiRegions::ExpList3DVectorIter

Iterator over an ExpList3DVector.

Definition at line 119 of file ExpList3D.h.

typedef boost::shared_ptr<ExpListHomogeneous1D> Nektar::MultiRegions::ExpListHomogeneous1DSharedPtr

Shared pointer to an ExpList3DHomogeneous1D object.

Definition at line 66 of file ExpListHomogeneous1D.h.

typedef std::vector< ExpListHomogeneous1DSharedPtr > Nektar::MultiRegions::ExpListHomogeneous1DVector

Vector of pointers to ExpList3DHomogeneous1D objects.

Definition at line 71 of file ExpListHomogeneous1D.h.

typedef std::vector< ExpListHomogeneous1DSharedPtr >::iterator Nektar::MultiRegions::ExpListHomogeneous1DVectorIter

Iterator for the vector of ExpList3DHomogeneous1D pointers.

Definition at line 73 of file ExpListHomogeneous1D.h.

typedef boost::shared_ptr<ExpListHomogeneous2D> Nektar::MultiRegions::ExpListHomogeneous2DSharedPtr

Shared pointer to an ExpList3DHomogeneous2D object.

Definition at line 70 of file ExpListHomogeneous2D.h.

typedef std::vector< ExpListHomogeneous2DSharedPtr > Nektar::MultiRegions::ExpListHomogeneous2DVector

Vector of pointers to ExpList3DHomogeneous2D objects.

Definition at line 75 of file ExpListHomogeneous2D.h.

typedef std::vector< ExpListHomogeneous2DSharedPtr >::iterator Nektar::MultiRegions::ExpListHomogeneous2DVectorIter

Iterator for the vector of ExpList3DHomogeneous2D pointers.

Definition at line 77 of file ExpListHomogeneous2D.h.

typedef boost::shared_ptr< ExpList > Nektar::MultiRegions::ExpListSharedPtr

Shared pointer to an ExpList object.

Definition at line 56 of file LocTraceToTraceMap.h.

typedef boost::tuple<int, int, NekDouble> Nektar::MultiRegions::ExtraDirDof

Definition at line 54 of file AssemblyMapCG.h.

typedef boost::shared_ptr<GlobalLinSysDirectStaticCond> Nektar::MultiRegions::GlobalLinSysDirectStaticCondSharedPtr

Definition at line 48 of file GlobalLinSysDirectStaticCond.h.

typedef LibUtilities::NekFactory< std::string, GlobalLinSys, const GlobalLinSysKey&, const boost::weak_ptr<ExpList>&, const boost::shared_ptr<AssemblyMap>& > Nektar::MultiRegions::GlobalLinSysFactory

Datatype of the NekFactory used to instantiate classes derived from the EquationSystem class.

Definition at line 69 of file GlobalLinSys.h.

typedef boost::shared_ptr<GlobalLinSysIterativeStaticCond> Nektar::MultiRegions::GlobalLinSysIterativeStaticCondSharedPtr

Definition at line 50 of file GlobalLinSysIterativeStaticCond.h.

typedef std::map<GlobalLinSysKey,GlobalLinSysSharedPtr> Nektar::MultiRegions::GlobalLinSysMap

Mapping between GlobalLinSys objects and their associated keys.

Definition at line 57 of file GlobalLinSys.h.

typedef boost::shared_ptr<GlobalLinSysMap> Nektar::MultiRegions::GlobalLinSysMapShPtr

Pointer to a GlobalLinSys/key map.

Definition at line 59 of file GlobalLinSys.h.

typedef boost::shared_ptr<GlobalLinSysPETScStaticCond> Nektar::MultiRegions::GlobalLinSysPETScStaticCondSharedPtr

Definition at line 49 of file GlobalLinSysPETScStaticCond.h.

typedef boost::shared_ptr<GlobalLinSys> Nektar::MultiRegions::GlobalLinSysSharedPtr

Pointer to a GlobalLinSys object.

Definition at line 52 of file GlobalLinSys.h.

typedef boost::shared_ptr<GlobalLinSysStaticCond> Nektar::MultiRegions::GlobalLinSysStaticCondSharedPtr

Definition at line 49 of file GlobalLinSysStaticCond.h.

typedef boost::shared_ptr<GlobalLinSysXxtStaticCond> Nektar::MultiRegions::GlobalLinSysXxtStaticCondSharedPtr

Definition at line 52 of file GlobalLinSysXxtStaticCond.h.

typedef boost::shared_ptr<GlobalMatrixKey> Nektar::MultiRegions::GlobalMatrixKeySharedPtr

A pointer to a GlobalMatrixKey.

Definition at line 113 of file GlobalMatrixKey.h.

typedef std::map<GlobalMatrixKey,GlobalMatrixSharedPtr> Nektar::MultiRegions::GlobalMatrixMap

Mapping from global matrix keys to global matrices.

Definition at line 91 of file GlobalMatrix.h.

typedef boost::shared_ptr<GlobalMatrixMap> Nektar::MultiRegions::GlobalMatrixMapShPtr

Shared pointer to a global matrix map.

Definition at line 93 of file GlobalMatrix.h.

typedef boost::shared_ptr<GlobalMatrix> Nektar::MultiRegions::GlobalMatrixSharedPtr

Shared pointer to a GlobalMatrix object.

Definition at line 89 of file GlobalMatrix.h.

typedef std::map< Homogeneous1DMatType, DNekBlkMatSharedPtr> Nektar::MultiRegions::Homo1DBlockMatrixMap

A map between homo matrix keys and their associated block matrices.

Definition at line 61 of file ExpListHomogeneous1D.h.

typedef boost::shared_ptr<Homo1DBlockMatrixMap> Nektar::MultiRegions::Homo1DBlockMatrixMapShPtr

A shared pointer to a BlockMatrixMap.

Definition at line 63 of file ExpListHomogeneous1D.h.

typedef std::map< Homogeneous2DMatType, DNekBlkMatSharedPtr> Nektar::MultiRegions::Homo2DBlockMatrixMap

A map between homo matrix keys and their associated block matrices.

Definition at line 65 of file ExpListHomogeneous2D.h.

typedef boost::shared_ptr<Homo2DBlockMatrixMap> Nektar::MultiRegions::Homo2DBlockMatrixMapShPtr

A shared pointer to a BlockMatrixMap.

Definition at line 67 of file ExpListHomogeneous2D.h.

typedef boost::shared_ptr<LocTraceToTraceMap> Nektar::MultiRegions::LocTraceToTraceMapSharedPtr

Definition at line 273 of file LocTraceToTraceMap.h.

typedef boost::shared_ptr<MultiLevelBisectedGraph> Nektar::MultiRegions::MultiLevelBisectedGraphSharedPtr

Definition at line 67 of file SubStructuredGraph.h.

typedef boost::shared_ptr<PatchMap> Nektar::MultiRegions::PatchMapSharedPtr

Definition at line 69 of file SubStructuredGraph.h.

typedef struct Nektar::MultiRegions::_PeriodicEntity Nektar::MultiRegions::PeriodicEntity

typedef std::map<int, std::vector<PeriodicEntity> > Nektar::MultiRegions::PeriodicMap

Definition at line 201 of file MultiRegions.hpp.

typedef boost::shared_ptr<PreconditionerBlock> Nektar::MultiRegions::PreconditionerBlockSharedPtr

Definition at line 48 of file PreconditionerBlock.h.

typedef boost::shared_ptr<PreconditionerDiagonal> Nektar::MultiRegions::PreconditionerDiagonalSharedPtr

Definition at line 47 of file PreconditionerDiagonal.h.

typedef boost::shared_ptr<PreconditionerLinear> Nektar::MultiRegions::PreconditionerLinearSharedPtr

Definition at line 55 of file PreconditionerLinear.h.

typedef boost::shared_ptr<PreconditionerLinearWithBlock> Nektar::MultiRegions::PreconditionerLinearWithBlockSharedPtr

Definition at line 46 of file PreconditionerLinearWithBlock.h.

typedef boost::shared_ptr<PreconditionerLinearWithDiag> Nektar::MultiRegions::PreconditionerLinearWithDiagSharedPtr

Definition at line 48 of file PreconditionerLinearWithDiag.h.

typedef boost::shared_ptr<PreconditionerLinearWithLowEnergy> Nektar::MultiRegions::PreconditionerLinearWithLowEnergySharedPtr

Definition at line 46 of file PreconditionerLinearWithLowEnergy.h.

typedef boost::shared_ptr<PreconditionerLowEnergy> Nektar::MultiRegions::PreconditionerLowEnergySharedPtr

Definition at line 50 of file PreconditionerLowEnergy.h.

typedef boost::shared_ptr<PreconditionerNull> Nektar::MultiRegions::PreconditionerNullSharedPtr

Definition at line 99 of file PreconditionerDiagonal.h.

typedef boost::shared_ptr< Preconditioner > Nektar::MultiRegions::PreconditionerSharedPtr

Definition at line 62 of file GlobalLinSys.h.

typedef LibUtilities::NekFactory< std::string, Preconditioner, const boost::shared_ptr<GlobalLinSys>&, const boost::shared_ptr<AssemblyMap>& > Nektar::MultiRegions::PreconFactory

Definition at line 63 of file Preconditioner.h.

typedef boost::shared_ptr<RobinBCInfo> Nektar::MultiRegions::RobinBCInfoSharedPtr

Definition at line 181 of file MultiRegions.hpp.

typedef boost::shared_ptr<SubGraph> Nektar::MultiRegions::SubGraphSharedPtr

Definition at line 65 of file SubStructuredGraph.h.

typedef boost::tuple<LibUtilities::PointsKey, LibUtilities::PointsKey, LibUtilities::PointsKey, LibUtilities::PointsKey> Nektar::MultiRegions::TraceInterpPoints

Map holding points distributions required for interpolation of local traces onto global trace in two and three dimensions.

The tuple contains four PointsKey entries. All four are used in 3D, but for 2D only two are used. The first two denote the local elemental points distributions, the latter the target trace distributions. In the 2D case, unused trace directions are set to LibUtilities::eNoPointsType.

Definition at line 82 of file LocTraceToTraceMap.h.

Enumeration Type Documentation

enum Nektar::MultiRegions::AdjacentFaceOrientation

Enumerator
eAdjacentFaceDir1FwdDir1_Dir2FwdDir2
eAdjacentFaceDir1FwdDir1_Dir2BwdDir2
eAdjacentFaceDir1BwdDir1_Dir2FwdDir2
eAdjacentFaceDir1BwdDir1_Dir2BwdDir2
eAdjacentFaceDir1FwdDir2_Dir2FwdDir1
eAdjacentFaceDir1FwdDir2_Dir2BwdDir1
eAdjacentFaceDir1BwdDir2_Dir2FwdDir1
eAdjacentFaceDir1BwdDir2_Dir2BwdDir1

Definition at line 65 of file MultiRegions.hpp.

        {
            eAdjacentFaceDir1FwdDir1_Dir2FwdDir2,
            eAdjacentFaceDir1FwdDir1_Dir2BwdDir2,
            eAdjacentFaceDir1BwdDir1_Dir2FwdDir2,
            eAdjacentFaceDir1BwdDir1_Dir2BwdDir2,
            eAdjacentFaceDir1FwdDir2_Dir2FwdDir1,
            eAdjacentFaceDir1FwdDir2_Dir2BwdDir1,
            eAdjacentFaceDir1BwdDir2_Dir2FwdDir1,
            eAdjacentFaceDir1BwdDir2_Dir2BwdDir1
        };

enum Nektar::MultiRegions::AdjacentTraceOrientation

Enumerator
eAdjacentEdgeIsForwards
eAdjacentEdgeIsBackwards

Definition at line 57 of file MultiRegions.hpp.

        {
            eAdjacentEdgeIsForwards,
            eAdjacentEdgeIsBackwards
        };

enum Nektar::MultiRegions::CoeffState

Enumerator
eNotSet	No state set.
eLocal	Local coefficients.
eHybrid	Hybrid coefficients.
eGlobal	Global coefficients.

Definition at line 47 of file MultiRegions.hpp.

        {
            eNotSet,   ///< No state set
            eLocal,    ///< Local  coefficients 
            eHybrid,   ///< Hybrid coefficients
            eGlobal,   ///< Global coefficients 
        };

enum Nektar::MultiRegions::Direction

Enumerator
eX
eY
eZ
eS
eN

Definition at line 66 of file ExpList.h.

        {
            eX,
            eY,
            eZ,
            eS,
            eN
        };

enum Nektar::MultiRegions::ExpansionType

Enumerator
e0D
e1D
e2D
e3DH1D
e3DH2D
e3D
eNoType

Definition at line 75 of file ExpList.h.

        {
            e0D,
            e1D,
            e2D,
            e3DH1D,
            e3DH2D,
            e3D,
            eNoType
        };       

enum Nektar::MultiRegions::GlobalSysSolnType

Enumerator
eNoSolnType	No Solution type specified.
eDirectFullMatrix
eDirectStaticCond
eDirectMultiLevelStaticCond
eIterativeFull
eIterativeStaticCond
eIterativeMultiLevelStaticCond
eXxtFullMatrix
eXxtStaticCond
eXxtMultiLevelStaticCond
ePETScFullMatrix
ePETScStaticCond
ePETScMultiLevelStaticCond
eSIZE_GlobalSysSolnType

Definition at line 77 of file MultiRegions.hpp.

        {
            eNoSolnType,    ///< No Solution type specified
            eDirectFullMatrix,
            eDirectStaticCond,
            eDirectMultiLevelStaticCond,
            eIterativeFull,
            eIterativeStaticCond,
            eIterativeMultiLevelStaticCond,
            eXxtFullMatrix,
            eXxtStaticCond,
            eXxtMultiLevelStaticCond,
            ePETScFullMatrix,
            ePETScStaticCond,
            ePETScMultiLevelStaticCond,
            eSIZE_GlobalSysSolnType
        };

enum Nektar::MultiRegions::Homogeneous1DMatType

Enumerator
eForwardsCoeffSpace1D
eBackwardsCoeffSpace1D
eForwardsPhysSpace1D
eBackwardsPhysSpace1D

Definition at line 51 of file ExpListHomogeneous1D.h.

        {
            eForwardsCoeffSpace1D,
            eBackwardsCoeffSpace1D,
            eForwardsPhysSpace1D,
            eBackwardsPhysSpace1D
        };

enum Nektar::MultiRegions::Homogeneous2DMatType

Enumerator
eForwardsCoeffSpaceY1D
eForwardsCoeffSpaceZ1D
eBackwardsCoeffSpaceY1D
eBackwardsCoeffSpaceZ1D
eForwardsPhysSpaceY1D
eForwardsPhysSpaceZ1D
eBackwardsPhysSpaceY1D
eBackwardsPhysSpaceZ1D

Definition at line 51 of file ExpListHomogeneous2D.h.

        {
            eForwardsCoeffSpaceY1D,
            eForwardsCoeffSpaceZ1D,
            eBackwardsCoeffSpaceY1D,
            eBackwardsCoeffSpaceZ1D,
            eForwardsPhysSpaceY1D,
            eForwardsPhysSpaceZ1D,
            eBackwardsPhysSpaceY1D,
            eBackwardsPhysSpaceZ1D
        };

enum Nektar::MultiRegions::InterpLocTraceToTrace

Enumerator
eNoInterp
eInterpDir0
eInterpEndPtDir0
eInterpDir1
eInterpEndPtDir1
eInterpBothDirs
eInterpEndPtDir0InterpDir1

Definition at line 59 of file LocTraceToTraceMap.h.

{
    eNoInterp,
    eInterpDir0,
    eInterpEndPtDir0,
    eInterpDir1,
    eInterpEndPtDir1,
    eInterpBothDirs,
    eInterpEndPtDir0InterpDir1
};

enum Nektar::MultiRegions::LinearPreconSolver

Enumerator
eLinearPreconXxt
eLinearPreconPETSc

Definition at line 49 of file PreconditionerLinear.h.

        {
            eLinearPreconXxt,
            eLinearPreconPETSc
        };

enum Nektar::MultiRegions::LocalMatrixStorageStrategy

Enumerator
eNoStrategy
eContiguous
eNonContiguous
eSparse

Definition at line 55 of file GlobalLinSysIterativeStaticCond.h.

        {
            eNoStrategy,
            eContiguous,
            eNonContiguous,
            eSparse
        };

enum Nektar::MultiRegions::MatrixStorageType

Enumerator
eSmvBSR

Definition at line 148 of file MultiRegions.hpp.

        {
            eSmvBSR
        };

enum Nektar::MultiRegions::PETScMatMult

Enumerator.

Enumerator
ePETScMatMultSparse
ePETScMatMultShell

Definition at line 52 of file GlobalLinSysPETSc.h.

        {
            ePETScMatMultSparse,
            ePETScMatMultShell
        };

enum Nektar::MultiRegions::PreconditionerType

Enumerator
eNull	No Solution type specified.
eDiagonal
eLinearWithDiagonal
eLinear
eLowEnergy
eLinearWithLowEnergy
eBlock
eLinearWithBlock

Definition at line 121 of file MultiRegions.hpp.

        {
            eNull,    ///< No Solution type specified
            eDiagonal,
            eLinearWithDiagonal,
            eLinear,
            eLowEnergy,
            eLinearWithLowEnergy,
            eBlock,
            eLinearWithBlock
        };

enum Nektar::MultiRegions::ProjectionType

Type of Galerkin projection.

Enumerator
eGalerkin
eDiscontinuous
eMixed_CG_Discontinuous

Definition at line 114 of file MultiRegions.hpp.

        {
            eGalerkin,
            eDiscontinuous,
            eMixed_CG_Discontinuous
        };

Function Documentation

void Nektar::MultiRegions::AlignFace	(	const StdRegions::Orientation	orient,
		const int	nquad1,
		const int	nquad2,
		const Array< OneD, const NekDouble > &	in,
		Array< OneD, NekDouble > &	out
	)

Helper function to re-align face to a given orientation.

Definition at line 967 of file ExpList2D.cpp.

References Nektar::StdRegions::eDir1BwdDir1_Dir2BwdDir2, Nektar::StdRegions::eDir1BwdDir1_Dir2FwdDir2, Nektar::StdRegions::eDir1BwdDir2_Dir2BwdDir1, Nektar::StdRegions::eDir1BwdDir2_Dir2FwdDir1, Nektar::StdRegions::eDir1FwdDir1_Dir2BwdDir2, Nektar::StdRegions::eDir1FwdDir2_Dir2BwdDir1, and Nektar::StdRegions::eDir1FwdDir2_Dir2FwdDir1.

Referenced by Nektar::MultiRegions::ExpList2D::v_GetNormals().

        {
            // Copy transpose.
            if (orient == StdRegions::eDir1FwdDir2_Dir2FwdDir1 ||
                orient == StdRegions::eDir1BwdDir2_Dir2FwdDir1 ||
                orient == StdRegions::eDir1FwdDir2_Dir2BwdDir1 ||
                orient == StdRegions::eDir1BwdDir2_Dir2BwdDir1)
            {
                for (int i = 0; i < nquad2; ++i)
                {
                    for (int j = 0; j < nquad1; ++j)
                    {
                        out[i*nquad1 + j] = in[j*nquad2 + i];
                    }
                }
            }
            else
            {
                for (int i = 0; i < nquad2; ++i)
                {
                    for (int j = 0; j < nquad1; ++j)
                    {
                        out[i*nquad1 + j] = in[i*nquad1 + j];
                    }
                }
            }

            if (orient == StdRegions::eDir1BwdDir1_Dir2FwdDir2 ||
                orient == StdRegions::eDir1BwdDir1_Dir2BwdDir2 ||
                orient == StdRegions::eDir1BwdDir2_Dir2FwdDir1 ||
                orient == StdRegions::eDir1BwdDir2_Dir2BwdDir1)
            {
                // Reverse x direction
                for (int i = 0; i < nquad2; ++i)
                {
                    for (int j = 0; j < nquad1/2; ++j)
                    {
                        swap(out[i*nquad1 + j],
                             out[i*nquad1 + nquad1-j-1]);
                    }
                }
            }

            if (orient == StdRegions::eDir1FwdDir1_Dir2BwdDir2 ||
                orient == StdRegions::eDir1BwdDir1_Dir2BwdDir2 ||
                orient == StdRegions::eDir1FwdDir2_Dir2BwdDir1 ||
                orient == StdRegions::eDir1BwdDir2_Dir2BwdDir1)
            {
                // Reverse y direction
                for (int j = 0; j < nquad1; ++j)
                {
                    for (int i = 0; i < nquad2/2; ++i)
                    {
                        swap(out[i*nquad1 + j],
                             out[(nquad2-i-1)*nquad1 + j]);
                    }
                }
            }
        }

void Nektar::MultiRegions::CuthillMckeeReordering	(	const BoostGraph &	graph,
		Array< OneD, int > &	perm,
		Array< OneD, int > &	iperm
	)

Definition at line 839 of file SubStructuredGraph.cpp.

References ASSERTL1.

Referenced by Nektar::MultiRegions::AssemblyMapDG::AssemblyMapDG(), and Nektar::MultiRegions::AssemblyMapCG::CreateGraph().

        {
            int nGraphVerts = boost::num_vertices(graph);

            ASSERTL1(perm. num_elements() >= nGraphVerts &&
                     iperm.num_elements() >= nGraphVerts,
                     "Non-matching dimensions");

            // Call boost::cuthill_mckee_ordering to reorder the graph-vertices
            // using the reverse Cuthill-Mckee algorithm
            std::vector<BoostVertex> reorderedVerts(nGraphVerts);
            boost::cuthill_mckee_ordering(graph, reorderedVerts.rbegin());

            //copy the reordering to the Arrays perm and iperm
            for(int i = 0; i < nGraphVerts; i++)
            {
                perm[i] = reorderedVerts[i];
                iperm[ reorderedVerts[i] ] = i;
            }
        }

std::pair< int, StdRegions::Orientation > Nektar::MultiRegions::DeterminePeriodicEdgeOrientId	(	int	meshEdgeId,
		StdRegions::Orientation	edgeOrient,
		const vector< PeriodicEntity > &	periodicEdges
	)

Determine orientation of an edge to its periodic equivalents, as well as the ID of the representative edge.

Since an edge may be periodic with more than one other edge (e.g. a periodic cube has sets of four periodic edges in each coordinate direction), we have to define a 'representative' edge. In this assembly map we define it to be the one with the minimum ID. This routine is set up to calculate the orientation of a given edge with ID meshEdgeId with respect to the edge ID.

Parameters

meshEdgeId	ID of a periodic edge.
edgeOrient	Edge orientation of meshEdgeId with respect to its parent element.
periodicEdges	The map of all periodic edges.

Returns

Pair containing the ID of the periodic edge and the orientation of meshEdgeID with respect to this edge.

Definition at line 2074 of file AssemblyMapCG.cpp.

References Nektar::StdRegions::eBackwards, and Nektar::StdRegions::eForwards.

Referenced by Nektar::MultiRegions::AssemblyMapCG::AssemblyMapCG(), Nektar::MultiRegions::PreconditionerBlock::BlockPreconditionerCG(), Nektar::CoupledLocalToGlobalC0ContMap::CoupledLocalToGlobalC0ContMap(), and Nektar::MultiRegions::AssemblyMapCG::SetUpUniversalC0ContMap().

        {
            int minId  = periodicEdges[0].id;
            int minIdK = 0;
            int k;

            for (k = 1; k < periodicEdges.size(); ++k)
            {
                if (periodicEdges[k].id < minId)
                {
                    minId  = min(minId, periodicEdges[k].id);
                    minIdK = k;
                }
            }

            minId = min(minId, meshEdgeId);

            if (meshEdgeId != minId)
            {
                if (periodicEdges[minIdK].orient == StdRegions::eBackwards)
                {
                    // Swap edge orientation
                    edgeOrient = (edgeOrient == StdRegions::eForwards) ?
                        StdRegions::eBackwards : StdRegions::eForwards;
                }
            }

            return make_pair(minId, edgeOrient);
        }

StdRegions::Orientation Nektar::MultiRegions::DeterminePeriodicFaceOrient	(	StdRegions::Orientation	faceOrient,
		StdRegions::Orientation	perFaceOrient
	)

Determine relative orientation between two faces.

Given the orientation of a local element to its local face, defined as faceOrient, and perFaceOrient which states the alignment of one periodic face to the other global face, this routine determines the orientation that takes this local element face to the global/unique face.

Parameters

faceOrient	Orientation of the face with respect to its parent element.
perFaceOrient	Orientation of the representative/global face.

Returns

Orientation between the two faces.

Definition at line 2122 of file AssemblyMapCG.cpp.

References Nektar::StdRegions::eDir1FwdDir1_Dir2FwdDir2.

Referenced by Nektar::MultiRegions::AssemblyMapCG::AssemblyMapCG(), Nektar::MultiRegions::PreconditionerBlock::BlockPreconditionerCG(), Nektar::MultiRegions::AssemblyMapCG::SetUpUniversalC0ContMap(), and Nektar::MultiRegions::PreconditionerLowEnergy::v_BuildPreconditioner().

        {
            StdRegions::Orientation  returnval = faceOrient;

            if(perFaceOrient != StdRegions::eDir1FwdDir1_Dir2FwdDir2)
            {
                int tmp1 = (int)faceOrient    - 5;
                int tmp2 = (int)perFaceOrient - 5;

                int flipDir1Map [8] = {2,3,0,1,6,7,4,5};
                int flipDir2Map [8] = {1,0,3,2,5,4,7,6};
                int transposeMap[8] = {4,5,6,7,0,2,1,3};

                // Transpose orientation
                if (tmp2 > 3)
                {
                    tmp1 = transposeMap[tmp1];
                }

                // Reverse orientation in direction 1.
                if (tmp2 == 2 || tmp2 == 3 || tmp2 == 6 || tmp2 == 7)
                {
                    tmp1 = flipDir1Map[tmp1];
                }

                // Reverse orientation in direction 2
                if (tmp2 % 2 == 1)
                {
                    tmp1 = flipDir2Map[tmp1];
                }

                returnval = (StdRegions::Orientation)(tmp1+5);
            }
            return returnval;
        }

GlobalLinSysFactory & Nektar::MultiRegions::GetGlobalLinSysFactory

(

)

Definition at line 204 of file GlobalLinSys.cpp.

Referenced by Nektar::MultiRegions::ExpList::GenGlobalBndLinSys(), and Nektar::MultiRegions::ExpList::GenGlobalLinSys().

        {
            typedef Loki::SingletonHolder<GlobalLinSysFactory,
                Loki::CreateUsingNew,
                Loki::NoDestroy,
                Loki::SingleThreaded> Type;
            return Type::Instance();
        }

PreconFactory & Nektar::MultiRegions::GetPreconFactory

(

)

Definition at line 88 of file Preconditioner.cpp.

Referenced by Nektar::MultiRegions::GlobalLinSys::CreatePrecon(), Nektar::MultiRegions::PreconditionerLinearWithBlock::v_InitObject(), Nektar::MultiRegions::PreconditionerLinearWithLowEnergy::v_InitObject(), and Nektar::MultiRegions::PreconditionerLinearWithDiag::v_InitObject().

        {
            typedef Loki::SingletonHolder<PreconFactory,
                Loki::CreateUsingNew,
                Loki::NoDestroy,
                Loki::SingleThreaded> Type;
            return Type::Instance();
        }

StdRegions::StdExpansionSharedPtr Nektar::MultiRegions::GetStdExp

(

StdRegions::StdExpansionSharedPtr

exp

)

Definition at line 3059 of file ExpList.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, Nektar::LibUtilities::eHexahedron, Nektar::LibUtilities::ePrism, Nektar::LibUtilities::ePyramid, Nektar::LibUtilities::eQuadrilateral, Nektar::LibUtilities::eSegment, Nektar::LibUtilities::eTetrahedron, and Nektar::LibUtilities::eTriangle.

        {

            StdRegions::StdExpansionSharedPtr stdExp;

            switch(exp->DetShapeType())
            {
            case LibUtilities::eSegment:
                stdExp = MemoryManager<StdRegions::StdSegExp>
                    ::AllocateSharedPtr(exp->GetBasis(0)->GetBasisKey());
                break;
            case LibUtilities::eTriangle:
                {
                    StdRegions::StdNodalTriExpSharedPtr nexp;
                    if((nexp = exp->as<StdRegions::StdNodalTriExp>()))
                    {
                        stdExp = MemoryManager<StdRegions::StdNodalTriExp>
                            ::AllocateSharedPtr(exp->GetBasis(0)->GetBasisKey(),
                                                exp->GetBasis(1)->GetBasisKey(),
                                                nexp->GetNodalPointsKey().GetPointsType());
                    }
                    else
                    {
                        stdExp = MemoryManager<StdRegions::StdTriExp>
                            ::AllocateSharedPtr(exp->GetBasis(0)->GetBasisKey(),
                                                exp->GetBasis(1)->GetBasisKey());
                    }
                }
                break;
            case LibUtilities::eQuadrilateral:
                stdExp = MemoryManager<StdRegions::StdQuadExp>
                    ::AllocateSharedPtr(exp->GetBasis(0)->GetBasisKey(),
                                        exp->GetBasis(1)->GetBasisKey());
                break;
            case LibUtilities::eTetrahedron:
                    stdExp = MemoryManager<StdRegions::StdTetExp>
                        ::AllocateSharedPtr(exp->GetBasis(0)->GetBasisKey(),
                                            exp->GetBasis(1)->GetBasisKey(),
                                            exp->GetBasis(2)->GetBasisKey());
                    break;
            case LibUtilities::ePyramid:
                stdExp = MemoryManager<StdRegions::StdPyrExp>
                    ::AllocateSharedPtr(exp->GetBasis(0)->GetBasisKey(),
                                        exp->GetBasis(1)->GetBasisKey(),
                                        exp->GetBasis(2)->GetBasisKey());
                break;
            case LibUtilities::ePrism:
                stdExp = MemoryManager<StdRegions::StdPrismExp>
                    ::AllocateSharedPtr(exp->GetBasis(0)->GetBasisKey(),
                                        exp->GetBasis(1)->GetBasisKey(),
                                        exp->GetBasis(2)->GetBasisKey());
                break;
            case LibUtilities::eHexahedron:
                    stdExp = MemoryManager<StdRegions::StdHexExp>
                        ::AllocateSharedPtr(exp->GetBasis(0)->GetBasisKey(),
                                            exp->GetBasis(1)->GetBasisKey(),
                                            exp->GetBasis(2)->GetBasisKey());
                    break;
            default:
                ASSERTL0(false,"Shape type not setup");
                break;
            }

            return stdExp;
        }

void Nektar::MultiRegions::MultiLevelBisectionReordering	(	const BoostGraph &	graph,
		Array< OneD, int > &	perm,
		Array< OneD, int > &	iperm,
		BottomUpSubStructuredGraphSharedPtr &	substructgraph,
		std::set< int >	partVerts,
		int	mdswitch
	)

Definition at line 862 of file SubStructuredGraph.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Metis::as_onmetis(), ASSERTL0, ASSERTL1, ErrorUtil::efatal, Nektar::iterator, NEKERROR, and Vmath::Vcopy().

Referenced by Nektar::MultiRegions::AssemblyMapDG::AssemblyMapDG(), and Nektar::MultiRegions::AssemblyMapCG::CreateGraph().

        {
            int nGraphVerts = boost::num_vertices(graph);
            int nGraphEdges = boost::num_edges   (graph);

            ASSERTL1(perm. num_elements() >= nGraphVerts &&
                     iperm.num_elements() >= nGraphVerts,
                     "Non-matching dimensions");

            // We will now use METIS to reorder the graph.  For the purpose of
            // multi-level static condensation, we will use a METIS routine that
            // partitions the graph recursively using a multi-level bisection
            // algorithm.  The name of this routine is METIS_NodeND and it was
            // originally designed to reorder the DOFs in a matrix in order to
            // minimise the fill-in when applying a factorisation technique
            // (such as Cholesky).  However, this reordering of DOFs also seems
            // to be perfectly suited in the context of multilevel
            // substructering. Therefore, we will use this metis routine instead
            // of the more well-known graph-partitioning routines. However, as
            // the standard metis implementation of METIS_NodeND only gives the
            // resulting re-ordering as an output, we we will use an modified
            // version of this routine that also returns information about the
            // structure of the multi-level bisected partitioning.

            // This modified implementation has been written by W. GAO and
            // collaborators and it additionally returns the separator tree
            // compared to the standard implementation.

            // The name of this modified routine AS_METIS_NodeND (where AS
            // stands for automated substructering) More information can be
            // found in the paper:
            //
            //   W. Gao, S. Li Xiaoye, C. Yang and Z. Bai
            //   'An implementation and evaluation of the AMLS method 
            //   for sparse eigenvalue problems'
            //   - ACM Trans. Math. Softw. 34, 4, Article 20 (July 2008)
            
            if(nGraphEdges)
            {
                // Step 1: Convert boost graph to a graph in adjncy-list format
                // as required by METIS
                int acnt = 0;
                int vcnt = 0;
                int i, cnt;
                int nPartition    = partVerts.size();
                int nNonPartition = nGraphVerts - partVerts.size();
                BoostVertexIterator    vertit, vertit_end;
                BoostAdjacencyIterator adjvertit, adjvertit_end;
                Array<OneD, int> xadj(nNonPartition+1,0);
                Array<OneD, int> adjncy(2*nGraphEdges);
                Array<OneD, int> initial_perm(nGraphVerts);
                Array<OneD, int> iinitial_perm(nGraphVerts);
                Array<OneD, int> perm_tmp (nNonPartition);
                Array<OneD, int> iperm_tmp(nNonPartition);

                std::set<int>::iterator it;
                
                // First reorder vertices so that partition nodes are at the
                // end. This allows METIS to partition the interior nodes.
                for (i = cnt = 0; i < nGraphVerts; ++i)
                {
                    if (partVerts.count(i) == 0)
                    {
                        initial_perm [i]     = cnt;
                        iinitial_perm[cnt++] = i;
                    }
                }

                for (i = 0; i < nGraphVerts; ++i)
                {
                    if (partVerts.count(i) > 0)
                    {
                        initial_perm [i]     = cnt;
                        iinitial_perm[cnt++] = i;
                    }
                }

                // Apply this reordering to the graph.
                boost::property_map<BoostGraph, boost::vertex_index_t>::type 
                    index = get(boost::vertex_index, graph);
                
                for (boost::tie(vertit, vertit_end) = boost::vertices(graph); 
                     vertit != vertit_end; ++vertit) 
                {
                    if (partVerts.count(index[*vertit]) > 0)
                    {
                        continue;
                    }
                    
                    for (boost::tie(adjvertit, adjvertit_end) = 
                             boost::adjacent_vertices(*vertit,graph);
                         adjvertit != adjvertit_end;
                         ++adjvertit) 
                    {
                        if (partVerts.count(index[*adjvertit]) > 0)
                        {
                            continue;
                        }
                        adjncy[acnt++] = initial_perm[*adjvertit];
                    }
                    xadj[++vcnt] = acnt;
                }
                
                // Step 2: use metis to reorder the dofs. We do not know on
                // forehand the size of the separator tree that METIS will
                // return, so we just assume a really big value and try with
                // that
                int sizeSeparatorTree = nGraphVerts*10;
                Array<OneD,int> septreeTmp(sizeSeparatorTree,-1);  
                
                // The separator tree returned by metis has the following
                // structure: It is a one dimensional array and information per
                // level is contained per 5 elements:
                //
                // m_septree[i*5 + 0]: the level of recursion (top-level = 1)
                // m_septree[i*5 + 1]: is this substructure a left or right
                //                     branch? 1 = left branch, 2 = right branch
                // m_septree[i*5 + 2]: the number of 'interior' DOFs in left 
                //                     branch
                // m_septree[i*5 + 3]: the number of 'interior' DOFs in right 
                //                     branch
                // m_septree[i*5 + 4]: the number of 'boundary' DOFs     
                
                // Now try to call Call METIS.
                try
                {
                    Metis::as_onmetis(
                        nNonPartition,xadj,adjncy,perm_tmp,iperm_tmp,
                        septreeTmp, mdswitch);
                }
                catch(...)
                {
                    NEKERROR(ErrorUtil::efatal,
                             "Error in calling metis (the size of the separator"
                             " tree might not be sufficient)");
                }
                
                // Change permutations from METIS to account for initial offset.
                for (i = 0; i < nGraphVerts; ++i)
                {
                    if (partVerts.count(i) == 0)
                    {
                        iperm[i] = iperm_tmp[initial_perm[i]];
                        perm[iperm[i]] = i;
                    }
                }
                
                for (i = nNonPartition, it = partVerts.begin(); 
                     it != partVerts.end(); ++it, ++i)
                {
                    perm [i]   = *it;
                    iperm[*it] = i;
                }
                
                for (i = 0; i < nGraphVerts; ++i)
                {
                    ASSERTL0(perm[iperm[i]] == i, 
                             "Perm error " + boost::lexical_cast<std::string>(i));
                }
                
                // Post-process the separator tree
                int trueSizeSepTree = 0;
                for (i = 0; septreeTmp[i] != -1; i++)
                {
                    trueSizeSepTree++;
                }
                Array<OneD,int> septree(trueSizeSepTree);
                Vmath::Vcopy(trueSizeSepTree,septreeTmp,1,septree,1);
                
                // Based upon the separator tree, where are going to set up an
                // object of the class BottomUpSubStructuredGraph. The
                // constructor will read the separatortree and will interprete
                // the information from a bottom-up point of view.
                substructgraph = MemoryManager<BottomUpSubStructuredGraph>::
                    AllocateSharedPtr(septree, nPartition);
                
                // Important, we cannot simply use the ordering given by metis
                // as it does not order the different blocks as we would like
                // it. Therefore, we use following command to re-order them
                // again in the context of the bottom-up substructering. As a
                // result, we will now obtain an ordering where the interior
                // degrees of freedom of the first (=bottom) level will be
                // ordered last (block by block ofcoarse). The interior degrees
                // of freedom of the second level will be ordered second to
                // last, etc ... As a result, the boundary degrees of freedom of
                // the last level (i.e. the dofs that will have to solved
                // non-recursively) will be ordered first (after the Dirichlet
                // Dofs that is).  (this way, we actually follow the same idea
                // and convention in the standard (non-multi-level) static
                // condensation approach)
                substructgraph->UpdateBottomUpReordering(perm,iperm);
            }
            else
            {
                // This is the very special case of a graph without any
                // connectivity i.e. a collection of vertices without any edges
                for(int i = 0; i < nGraphVerts; i++)
                {
                    perm[i] = i;
                    iperm[i] = i;
                }
                substructgraph = MemoryManager<BottomUpSubStructuredGraph>::
                    AllocateSharedPtr(nGraphVerts);
            }
        }

void Nektar::MultiRegions::NoReordering	(	const BoostGraph &	graph,
		Array< OneD, int > &	perm,
		Array< OneD, int > &	iperm
	)

Definition at line 1074 of file SubStructuredGraph.cpp.

References ASSERTL1.

Referenced by Nektar::MultiRegions::AssemblyMapDG::AssemblyMapDG(), and Nektar::MultiRegions::AssemblyMapCG::CreateGraph().

        {
            int nGraphVerts = boost::num_vertices(graph);

            ASSERTL1(perm. num_elements() >= nGraphVerts &&
                     iperm.num_elements() >= nGraphVerts,
                     "Non-matching dimensions");

            for (int i = 0; i < nGraphVerts; i++)
            {
                perm [i] = i;
                iperm[i] = i;
            }
        }

bool Nektar::MultiRegions::operator<	(	const GlobalMatrixKey &	lhs,
		const GlobalMatrixKey &	rhs
	)

Definition at line 80 of file GlobalMatrixKey.cpp.

References Nektar::MultiRegions::GlobalMatrixKey::m_constFactors, Nektar::MultiRegions::GlobalMatrixKey::m_locToGloMap, Nektar::MultiRegions::GlobalMatrixKey::m_matrixType, Nektar::MultiRegions::GlobalMatrixKey::m_shapeType, and Nektar::MultiRegions::GlobalMatrixKey::m_varCoeffs.

        {
            if(lhs.m_matrixType < rhs.m_matrixType)
            {
                return true;
            }

            if(lhs.m_matrixType > rhs.m_matrixType)
            {
                return false;
            }


            if(lhs.m_shapeType < rhs.m_shapeType)
            {
                return true;
            }
            

            if(lhs.m_shapeType > rhs.m_shapeType)
            {
                return false;
            }
            
            if(lhs.m_constFactors.size() < rhs.m_constFactors.size())
            {
                return true;
            }
            else if(lhs.m_constFactors.size() > rhs.m_constFactors.size())
            {
                return false;
            }
            else
            {
                StdRegions::ConstFactorMap::const_iterator x, y;
                for(x = lhs.m_constFactors.begin(), y = rhs.m_constFactors.begin();
                    x != lhs.m_constFactors.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;
            }
            else if(lhs.m_varCoeffs.size() > rhs.m_varCoeffs.size())
            {
                return false;
            }
//            else
//            {
//                StdRegions::VarCoeffMap::const_iterator x, y;
//                for (x = lhs.m_varCoeffs.begin(), y = rhs.m_varCoeffs.begin();
//                     x != lhs.m_varCoeffs.end(); ++x, ++y)
//                {
//                    if (x->second.get() < y->second.get())
//                    {
//                        return true;
//                    }
//                    if (x->second.get() > y->second.get())
//                    {
//                        return false;
//                    }
//                }
//            }

            if(!rhs.m_locToGloMap.get())
            {
                return false;
            }
            else if(!lhs.m_locToGloMap.get() && rhs.m_locToGloMap.get() )
            {
                return true;
            }
            if(lhs.m_locToGloMap->GetHash() < rhs.m_locToGloMap->GetHash())
            {
                return true;
            }

            return false;
        }

bool Nektar::MultiRegions::operator<	(	const GlobalLinSysKey &	lhs,
		const GlobalLinSysKey &	rhs
	)

Compares two GlobalLinSysKeys by comparing their solution types and matrix keys.

Parameters

lhs	First operand.
rhs	Second operand.

Returns

true if the first operand is considered less than the second operand.

Definition at line 96 of file GlobalLinSysKey.cpp.

References Nektar::MultiRegions::GlobalLinSysKey::m_solnType.

        {
            if(lhs.m_solnType < rhs.m_solnType)
            {
                return true;
            }

            if(lhs.m_solnType > rhs.m_solnType)
            {
                return false;
            }

            return (*dynamic_cast<const GlobalMatrixKey*>(&lhs)
                    < *dynamic_cast<const GlobalMatrixKey*>(&rhs));
        }

std::ostream & Nektar::MultiRegions::operator<<	(	std::ostream &	os,
		const GlobalLinSysKey &	rhs
	)

Writes information about the object to a given stream.

Writes the vital statistics of a global linear system to a stream.

Parameters

os	Output stream.
rhs	GlobalLinSys object to use.

Returns

Reference to the output stream os.

Definition at line 119 of file GlobalLinSysKey.cpp.

References Nektar::StdRegions::ConstFactorTypeMap, Nektar::MultiRegions::GlobalMatrixKey::GetConstFactors(), Nektar::MultiRegions::GlobalLinSysKey::GetGlobalSysSolnType(), Nektar::MultiRegions::GlobalMatrixKey::GetMatrixType(), Nektar::MultiRegions::GlobalMatrixKey::GetNConstFactors(), Nektar::MultiRegions::GlobalMatrixKey::GetNVarCoeffs(), Nektar::MultiRegions::GlobalMatrixKey::GetShapeType(), GlobalSysSolnTypeMap, Nektar::StdRegions::MatrixTypeMap, and Nektar::LibUtilities::ShapeTypeMap.

        {
            os << "MatrixType: " << StdRegions::MatrixTypeMap[rhs.GetMatrixType()] << ", ShapeType: "
               << LibUtilities::ShapeTypeMap[rhs.GetShapeType()]
                            << std::endl;
            os << "Solution Type: " 
               << GlobalSysSolnTypeMap[rhs.GetGlobalSysSolnType()] << endl;
            os << "Number of constants: " << rhs.GetNConstFactors() << endl;
            StdRegions::ConstFactorMap::const_iterator x;
            for (x = rhs.GetConstFactors().begin(); x != rhs.GetConstFactors().end(); ++x)
            {
                os << "  Constant " << StdRegions::ConstFactorTypeMap[x->first]
                   << ": " << x->second << endl;
            }
            os << "Number of variable coefficients: " 
               << rhs.GetNVarCoeffs() << endl;
            
            return os;
        }

std::ostream & Nektar::MultiRegions::operator<<	(	std::ostream &	os,
		const GlobalMatrixKey &	rhs
	)

Writes statistics about the matrix key to an output stream.

Definition at line 170 of file GlobalMatrixKey.cpp.

References Nektar::StdRegions::ConstFactorTypeMap, Nektar::MultiRegions::GlobalMatrixKey::GetConstFactors(), Nektar::MultiRegions::GlobalMatrixKey::GetMatrixType(), Nektar::MultiRegions::GlobalMatrixKey::GetNConstFactors(), and Nektar::MultiRegions::GlobalMatrixKey::GetNVarCoeffs().

        {
            os << "MatrixType: " << rhs.GetMatrixType() << endl;
            os << "Number of constants: " << rhs.GetNConstFactors() << endl;
            StdRegions::ConstFactorMap::const_iterator x;
            for(x = rhs.GetConstFactors().begin(); x != rhs.GetConstFactors().end(); ++x)
            {
                os << "  Constant " << StdRegions::ConstFactorTypeMap[x->first]
                   << ": " << x->second << endl;
            }
            os << "Number of variable coefficients: " 
               << rhs.GetNVarCoeffs() << endl;

            return os;
        }

int Nektar::MultiRegions::RoundNekDoubleToInt

(

NekDouble

x

)

Rounds a double precision number to an integer.

Definition at line 57 of file AssemblyMap.cpp.

Referenced by Nektar::MultiRegions::AssemblyMap::AssemblyMap().

        {
            return int(x > 0.0 ? x + 0.5 : x - 0.5);
        }

void Nektar::MultiRegions::RoundNekDoubleToInt	(	const Array< OneD, const NekDouble >	inarray,
		Array< OneD, int >	outarray
	)

Rounds an array of double precision numbers to integers.

Definition at line 63 of file AssemblyMap.cpp.

References ASSERTL1.

        {
            int size = inarray.num_elements();
            ASSERTL1(outarray.num_elements()>=size,"Array sizes not compatible");

            NekDouble x;
            for(int i = 0; i < size; i++)
            {
                x = inarray[i];
                outarray[i] =  int(x > 0.0 ? x + 0.5 : x - 0.5);
            }
        }

bool Nektar::MultiRegions::SubGraphWithoutVerts

(

const SubGraphSharedPtr

g

)

Definition at line 817 of file SubStructuredGraph.cpp.

Referenced by Nektar::MultiRegions::BottomUpSubStructuredGraph::ExpandGraphWithVertexWeights().

        {
            return g->GetNverts() == 0;
        } 

Variable Documentation

MultiRegions::Direction const Nektar::MultiRegions::DirCartesianMap[]

Initial value:

=
        {
            eX,
            eY,
            eZ
        }

Definition at line 86 of file ExpList.h.

Referenced by Nektar::GlobalMapping::MappingGeneral::CalculateChristoffel(), Nektar::GlobalMapping::MappingXYofXY::CalculateChristoffel(), Nektar::SolverUtils::FilterAeroForces::CalculateForcesMapping(), Nektar::GlobalMapping::MappingGeneral::CalculateMetricTerms(), Nektar::NonlinearSWE::DoOdeRhs(), Nektar::LinearSWE::DoOdeRhs(), main(), Nektar::VCSMapping::MappingAccelerationCorrection(), Nektar::FieldUtils::ProcessGrad::Process(), Nektar::CoupledLinearNS::SetUpCoupledMatrix(), Nektar::AlternateSkewAdvection::v_Advect(), Nektar::SkewSymmetricAdvection::v_Advect(), Nektar::NavierStokesAdvection::v_Advect(), Nektar::MappingExtrapolate::v_CalcNeumannPressureBCs(), Nektar::MappingExtrapolate::v_CorrectPressureBCs(), Nektar::GlobalMapping::Mapping::v_Divergence(), Nektar::VCSMapping::v_DoInitialise(), Nektar::GlobalMapping::Mapping::v_DotGradJacobian(), Nektar::ShallowWaterSystem::v_InitObject(), Nektar::MultiRegions::ExpList::v_PhysDeriv(), Nektar::VCSMapping::v_SetUpPressureForcing(), Nektar::VelocityCorrectionScheme::v_SetUpPressureForcing(), Nektar::VCSMapping::v_SolvePressure(), Nektar::GlobalMapping::MappingXYofZ::v_UpdateGeomInfo(), Nektar::GlobalMapping::MappingXYofXY::v_UpdateGeomInfo(), Nektar::GlobalMapping::MappingXofZ::v_UpdateGeomInfo(), Nektar::GlobalMapping::MappingXofXZ::v_UpdateGeomInfo(), Nektar::GlobalMapping::Mapping::v_VelocityLaplacian(), and Nektar::SolverUtils::EquationSystem::WeakAdvectionDivergenceForm().

const char* const Nektar::MultiRegions::GlobalSysSolnTypeMap[]

Initial value:

=
            {
            "No Solution Type",
            "DirectFull",
            "DirectStaticCond",
            "DirectMultiLevelStaticCond",
            "IterativeFull",
            "IterativeStaticCond",
            "IterativeMultiLevelStaticCond",
            "XxtFull",
            "XxtStaticCond",
            "XxtMultiLevelStaticCond",
            "PETScFull",
            "PETScStaticCond",
            "PETScMultiLevelStaticCond"
        }

Definition at line 96 of file MultiRegions.hpp.

Referenced by Nektar::MultiRegions::AssemblyMapCG::CreateGraph(), Nektar::MultiRegions::ExpList::GenGlobalBndLinSys(), Nektar::MultiRegions::ExpList::GenGlobalLinSys(), and operator<<().

const char* const Nektar::MultiRegions::LocalMatrixStorageStrategyMap[]

Initial value:

=
        {
            "Contiguous",
            "Non-contiguous",
            "Sparse"
        }

Definition at line 63 of file GlobalLinSysIterativeStaticCond.h.

const char* const Nektar::MultiRegions::MatrixStorageTypeMap[]

Initial value:

=
        {
            "SmvBSR"
        }

Definition at line 153 of file MultiRegions.hpp.

Referenced by Nektar::MultiRegions::GlobalMatrix::GlobalMatrix().

AssemblyMapSharedPtr Nektar::MultiRegions::NullAssemblyMapSharedPtr

static

Definition at line 55 of file AssemblyMap.h.

Referenced by Nektar::MultiRegions::DisContField3D::v_HelmSolve(), Nektar::MultiRegions::DisContField2D::v_HelmSolve(), and Nektar::MultiRegions::DisContField1D::v_HelmSolve().

ExpList Nektar::MultiRegions::NullExpList

static

An empty ExpList object.

Definition at line 1484 of file ExpList.h.

const Array<OneD, ExpList0DSharedPtr> Nektar::MultiRegions::NullExpList0DSharedPtrArray

static

Empty ExpList0D object.

Definition at line 107 of file ExpList0D.h.

const Array<OneD, ExpList1DSharedPtr> Nektar::MultiRegions::NullExpList1DSharedPtrArray

static

Empty ExpList1D object.

Definition at line 197 of file ExpList1D.h.

const Array<OneD, ExpList2DSharedPtr> Nektar::MultiRegions::NullExpList2DSharedPtrArray

static

Empty ExpList2D object.

Definition at line 161 of file ExpList2D.h.

ExpListSharedPtr Nektar::MultiRegions::NullExpListSharedPtr

static

Definition at line 1485 of file ExpList.h.

Referenced by Nektar::MultiRegions::DisContField3D::SetUpDG(), Nektar::MultiRegions::DisContField2D::SetUpDG(), Nektar::MultiRegions::DisContField1D::SetUpDG(), Nektar::MultiRegions::ExpList::v_GetPlane(), Nektar::MultiRegions::DisContField2D::v_GetTrace(), and Nektar::MultiRegions::DisContField3D::v_GetTrace().

const Array<OneD, ExpListSharedPtr> Nektar::MultiRegions::NullExpListSharedPtrArray

static

Definition at line 2342 of file ExpList.h.

std::map<int,int> Nektar::MultiRegions::NullIntIntMap

static

Definition at line 49 of file AssemblyMapCG.h.

PeriodicMap Nektar::MultiRegions::NullPeriodicMap

static

Definition at line 202 of file MultiRegions.hpp.

PreconditionerSharedPtr Nektar::MultiRegions::NullPreconditionerSharedPtr

static

Definition at line 59 of file Preconditioner.h.

Referenced by Nektar::LinearElasticSystem::v_DoSolve().

const std::vector<std::map<int,int> > Nektar::MultiRegions::NullVecIntIntMap

static

Definition at line 50 of file AssemblyMapCG.h.

const char* const Nektar::MultiRegions::PreconditionerTypeMap[]

Initial value:

=
        {
            "Null",
            "Diagonal",
            "FullLinearSpaceWithDiagonal",
            "FullLinearSpace",
            "LowEnergyBlock",
            "FullLinearSpaceWithLowEnergyBlock",
            "Block",
            "FullLinearSpaceWithBlock"
        }

Definition at line 133 of file MultiRegions.hpp.

Referenced by Nektar::MultiRegions::GlobalLinSys::CreatePrecon().