Classes
class	AllToAll

class	AllToAllV

class	AssemblyCommDG
	Implements communication for populating forward and backwards spaces across processors in the discontinuous Galerkin routines. More...

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	ContField
	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	ContField3DHomogeneous1D

class	ContField3DHomogeneous2D

class	DisContField
	This class is the abstractio n of a global discontinuous two- dimensional spectral/hp element expansion which approximates the solution of a set of partial differential equations. More...

class	DisContField3DHomogeneous1D

class	DisContField3DHomogeneous2D

class	ExchangeMethod

class	ExpList
	Base class for all multi-elemental spectral/hp expansions. More...

class	ExpList2DHomogeneous1D
	Abstraction of a two-dimensional multi-elemental expansion which is merely a collection of local expansions. More...

class	ExpList2DHomogeneous2D
	Abstraction of a one-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	GJPStabilisation

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	InterfaceExchange

class	InterfaceMapDG

class	InterfaceTrace

class	LocTraceToTraceMap
	A helper class to deal with trace operations in the discontinuous Galerkin code. More...

class	MultiLevelBisectedGraph

class	NeighborAllToAllV

class	Pairwise

class	PatchMap

struct	PeriodicEntity

class	Preconditioner

class	PreconditionerBlock

class	PreconditionerDiagonal

class	PreconditionerJacobi

class	PreconditionerLinear

class	PreconditionerLinearWithBlock

class	PreconditionerLinearWithDiag

class	PreconditionerLinearWithLowEnergy

class	PreconditionerLOR
	Low-order representation (LOR) preconditioner. More...

class	PreconditionerLowEnergy

class	PreconditionerNull

struct	RobinBCInfo

struct	RotPeriodicInfo

class	Serial

class	SubGraph

struct	TraceFieldMapEssential

struct	TraceInterpEssential

Typedefs
typedef std::shared_ptr< ExchangeMethod >	ExchangeMethodSharedPtr

typedef std::shared_ptr< AssemblyCommDG >	AssemblyCommDGSharedPtr

typedef std::shared_ptr< AssemblyMap >	AssemblyMapSharedPtr

typedef std::shared_ptr< AssemblyMapCG >	AssemblyMapCGSharedPtr

typedef std::tuple< int, int, NekDouble >	ExtraDirDof

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

typedef std::shared_ptr< AssemblyMapDG >	AssemblyMapDGSharedPtr

typedef std::shared_ptr< InterfaceTrace >	InterfaceTraceSharedPtr

typedef std::shared_ptr< InterfaceExchange >	InterfaceExchangeSharedPtr

typedef std::shared_ptr< InterfaceMapDG >	InterfaceMapDGSharedPtr

typedef std::shared_ptr< ExpList >	ExpListSharedPtr
	Shared pointer to an ExpList object.

typedef std::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.

typedef std::shared_ptr< LocTraceToTraceMap >	LocTraceToTraceMapSharedPtr

typedef std::shared_ptr< ContField >	ContFieldSharedPtr

typedef std::shared_ptr< ContField3DHomogeneous1D >	ContField3DHomogeneous1DSharedPtr

typedef std::shared_ptr< ContField3DHomogeneous2D >	ContField3DHomogeneous2DSharedPtr

typedef std::shared_ptr< DisContField >	DisContFieldSharedPtr

typedef std::shared_ptr< DisContField3DHomogeneous1D >	DisContField3DHomogeneous1DSharedPtr

typedef std::shared_ptr< DisContField3DHomogeneous2D >	DisContField3DHomogeneous2DSharedPtr

typedef std::map< GlobalMatrixKey, DNekScalBlkMatSharedPtr >	BlockMatrixMap
	A map between global matrix keys and their associated block matrices.

typedef std::shared_ptr< BlockMatrixMap >	BlockMatrixMapShPtr
	A shared pointer to a BlockMatrixMap.

typedef std::shared_ptr< ExpList2DHomogeneous1D >	ExpList2DHomogeneous1DSharedPtr
	Shared pointer to an ExpList2DHomogeneous1D object.

typedef std::vector< ExpList2DHomogeneous1DSharedPtr >	ExpList2DHomogeneous1DVector
	Vector of pointers to ExpList2DHomogeneous1D objects.

typedef std::shared_ptr< ExpList2DHomogeneous2D >	ExpList2DHomogeneous2DSharedPtr
	Shared pointer to an ExpList2DHomogeneous2D object.

typedef std::vector< ExpList2DHomogeneous2DSharedPtr >	ExpList2DHomogeneous2DVector
	Vector of pointers to ExpList2DHomogeneous2D objects.

typedef std::shared_ptr< ExpList3DHomogeneous1D >	ExpList3DHomogeneous1DSharedPtr
	Shared pointer to an ExpList3DHomogeneous1D object.

typedef std::vector< ExpList3DHomogeneous1DSharedPtr >	ExpList3DHomogeneous1DVector
	Vector of pointers to ExpList3DHomogeneous1D objects.

typedef std::shared_ptr< ExpList3DHomogeneous2D >	ExpList3DHomogeneous2DSharedPtr
	Shared pointer to an ExpList3DHomogeneous2D object.

typedef std::vector< ExpList3DHomogeneous2DSharedPtr >	ExpList3DHomogeneous2DVector
	Vector of pointers to ExpList3DHomogeneous2D objects.

typedef std::map< Homogeneous1DMatType, DNekBlkMatSharedPtr >	Homo1DBlockMatrixMap
	A map between homo matrix keys and their associated block matrices.

typedef std::shared_ptr< Homo1DBlockMatrixMap >	Homo1DBlockMatrixMapShPtr
	A shared pointer to a BlockMatrixMap.

typedef std::shared_ptr< ExpListHomogeneous1D >	ExpListHomogeneous1DSharedPtr
	Shared pointer to an ExpList3DHomogeneous1D object.

typedef std::vector< ExpListHomogeneous1DSharedPtr >	ExpListHomogeneous1DVector
	Vector of pointers to ExpList3DHomogeneous1D objects.

typedef std::map< Homogeneous2DMatType, DNekBlkMatSharedPtr >	Homo2DBlockMatrixMap
	A map between homo matrix keys and their associated block matrices.

typedef std::shared_ptr< Homo2DBlockMatrixMap >	Homo2DBlockMatrixMapShPtr
	A shared pointer to a BlockMatrixMap.

typedef std::shared_ptr< ExpListHomogeneous2D >	ExpListHomogeneous2DSharedPtr
	Shared pointer to an ExpList3DHomogeneous2D object.

typedef std::vector< ExpListHomogeneous2DSharedPtr >	ExpListHomogeneous2DVector
	Vector of pointers to ExpList3DHomogeneous2D objects.

typedef std::shared_ptr< GJPStabilisation >	GJPStabilisationSharedPtr

typedef std::shared_ptr< GlobalLinSys >	GlobalLinSysSharedPtr
	Pointer to a GlobalLinSys object.

typedef std::map< GlobalLinSysKey, GlobalLinSysSharedPtr >	GlobalLinSysMap
	Mapping between GlobalLinSys objects and their associated keys.

typedef std::shared_ptr< GlobalLinSysMap >	GlobalLinSysMapShPtr
	Pointer to a GlobalLinSys/key map.

typedef std::shared_ptr< Preconditioner >	PreconditionerSharedPtr

typedef LibUtilities::NekFactory< std::string, GlobalLinSys, const GlobalLinSysKey &, const std::weak_ptr< ExpList > &, const std::shared_ptr< AssemblyMap > & >	GlobalLinSysFactory
	Datatype of the NekFactory used to instantiate classes derived from the EquationSystem class.

typedef std::shared_ptr< GlobalLinSysDirectStaticCond >	GlobalLinSysDirectStaticCondSharedPtr

typedef std::shared_ptr< GlobalLinSysIterativeStaticCond >	GlobalLinSysIterativeStaticCondSharedPtr

typedef std::shared_ptr< GlobalLinSysPETScStaticCond >	GlobalLinSysPETScStaticCondSharedPtr

typedef std::shared_ptr< GlobalLinSysStaticCond >	GlobalLinSysStaticCondSharedPtr

typedef std::shared_ptr< GlobalLinSysXxtStaticCond >	GlobalLinSysXxtStaticCondSharedPtr

typedef std::shared_ptr< GlobalMatrix >	GlobalMatrixSharedPtr
	Shared pointer to a GlobalMatrix object.

typedef std::map< GlobalMatrixKey, GlobalMatrixSharedPtr >	GlobalMatrixMap
	Mapping from global matrix keys to global matrices.

typedef std::shared_ptr< GlobalMatrixMap >	GlobalMatrixMapShPtr
	Shared pointer to a global matrix map.

typedef std::shared_ptr< GlobalMatrixKey >	GlobalMatrixKeySharedPtr
	A pointer to a GlobalMatrixKey.

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

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

typedef std::shared_ptr< RobinBCInfo >	RobinBCInfoSharedPtr

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

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

typedef std::shared_ptr< PreconditionerBlock >	PreconditionerBlockSharedPtr

typedef std::shared_ptr< PreconditionerDiagonal >	PreconditionerDiagonalSharedPtr

typedef std::shared_ptr< PreconditionerNull >	PreconditionerNullSharedPtr

typedef std::shared_ptr< PreconditionerJacobi >	PreconditionerJacobiSharedPtr

typedef std::shared_ptr< PreconditionerLinear >	PreconditionerLinearSharedPtr

typedef std::shared_ptr< PreconditionerLinearWithBlock >	PreconditionerLinearWithBlockSharedPtr

typedef std::shared_ptr< PreconditionerLinearWithDiag >	PreconditionerLinearWithDiagSharedPtr

typedef std::shared_ptr< PreconditionerLinearWithLowEnergy >	PreconditionerLinearWithLowEnergySharedPtr

typedef std::shared_ptr< PreconditionerLowEnergy >	PreconditionerLowEnergySharedPtr

typedef std::shared_ptr< BottomUpSubStructuredGraph >	BottomUpSubStructuredGraphSharedPtr

typedef std::shared_ptr< SubGraph >	SubGraphSharedPtr

typedef std::shared_ptr< MultiLevelBisectedGraph >	MultiLevelBisectedGraphSharedPtr

typedef std::shared_ptr< PatchMap >	PatchMapSharedPtr

Enumerations
enum	InterpLocTraceToTrace { eNoInterp , eInterpDir0 , eInterpEndPtDir0 , eInterpDir1 , eInterpEndPtDir1 , eInterpBothDirs , eInterpEndPtDir0InterpDir1 }

enum	Direction { eX , eY , eZ }

enum	ExpansionType { e0D , e1D , e2D , e2DH1D , e3DH1D , e3DH2D , e3D , eNoType }

enum	Homogeneous1DMatType { eForwardsCoeffSpace1D , eBackwardsCoeffSpace1D , eForwardsPhysSpace1D , eBackwardsPhysSpace1D }

enum	Homogeneous2DMatType { eForwardsCoeffSpaceY1D , eForwardsCoeffSpaceZ1D , eBackwardsCoeffSpaceY1D , eBackwardsCoeffSpaceZ1D , eForwardsPhysSpaceY1D , eForwardsPhysSpaceZ1D , eBackwardsPhysSpaceY1D , eBackwardsPhysSpaceZ1D }

enum	GJPFormulation { eGJPNoFormulation , eGJPExplicit , eGJPImplicit , eGJPSemiImplicit }

enum	LocalMatrixStorageStrategy { eNoStrategy , eContiguous , eNonContiguous , eSparse }

enum	PETScMatMult { ePETScMatMultSparse , ePETScMatMultShell }
	Enumerator. More...

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	GJPStabilisationType { eNoGJPStabilisation , eExplicitGJPStabilisation , eFullImplicitGJPStabilisation , eSemiImplicitGJPStabilisation }

enum	LinSysIterSolver { eNoLinSysIterSolver , eConjugateGradient , eConjugateGradientLoc , eGMRES , eGMRESLoc , eDirectEigenValues }

enum	MatrixStorageType { eSmvBSR }

enum	LinearPreconSolver { eLinearPreconXxt , eLinearPreconPETSc }

Functions
int	RoundNekDoubleToInt (NekDouble x)
	Rounds a double precision number to an integer.

void	RoundNekDoubleToInt (const Array< OneD, const NekDouble > inarray, Array< OneD, int > outarray)
	Rounds an array of double precision numbers to integers.

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.

StdRegions::Orientation	DeterminePeriodicFaceOrient (StdRegions::Orientation faceOrient, StdRegions::Orientation perFaceOrient)
	Determine relative orientation between two faces.

static GlobalLinSysKey	NullGlobalLinSysKey (StdRegions::eNoMatrixType)

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.

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.

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

static LocTraceToTraceMapSharedPtr	NullLocTraceToTraceMapSharedPtr

MultiRegions::Direction const	DirCartesianMap [] = {eX, eY, eZ}

static ExpList	NullExpList
	An empty ExpList object.

static ExpListSharedPtr	NullExpListSharedPtr

static LibUtilities::NekManager< GlobalLinSysKey, GlobalLinSys >	NullGlobalLinSysManager

static const Array< OneD, ExpListSharedPtr >	NullExpListSharedPtrArray

const char *const	LocalMatrixStorageStrategyMap []

const char *const	GlobalSysSolnTypeMap []

const char *const	LinSysIterSolverMap []

const char *const	MatrixStorageTypeMap [] = {"SmvBSR"}

static PeriodicMap	NullPeriodicMap

static PreconditionerSharedPtr	NullPreconditionerSharedPtr

Typedef Documentation

◆ AssemblyCommDGSharedPtr

typedef std::shared_ptr<AssemblyCommDG> Nektar::MultiRegions::AssemblyCommDGSharedPtr

Definition at line 299 of file AssemblyCommDG.h.

◆ AssemblyMapCGSharedPtr

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

Definition at line 50 of file AssemblyMapCG.h.

◆ AssemblyMapDGSharedPtr

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

Definition at line 46 of file AssemblyMapDG.h.

◆ AssemblyMapSharedPtr

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

Definition at line 50 of file AssemblyMap.h.

◆ BlockMatrixMap

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

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

Definition at line 90 of file ExpList.h.

◆ BlockMatrixMapShPtr

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

A shared pointer to a BlockMatrixMap.

Definition at line 92 of file ExpList.h.

◆ BndTypesVector

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

Definition at line 138 of file MultiRegions.hpp.

◆ BndTypesVectorIter

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

Definition at line 140 of file MultiRegions.hpp.

◆ BottomUpSubStructuredGraphSharedPtr

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

Definition at line 60 of file SubStructuredGraph.h.

◆ ContField3DHomogeneous1DSharedPtr

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

Definition at line 103 of file ContField3DHomogeneous1D.h.

◆ ContField3DHomogeneous2DSharedPtr

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

Definition at line 96 of file ContField3DHomogeneous2D.h.

◆ ContFieldSharedPtr

typedef std::shared_ptr<ContField> Nektar::MultiRegions::ContFieldSharedPtr

Definition at line 295 of file ContField.h.

◆ DisContField3DHomogeneous1DSharedPtr

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

Definition at line 217 of file DisContField3DHomogeneous1D.h.

◆ DisContField3DHomogeneous2DSharedPtr

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

Definition at line 135 of file DisContField3DHomogeneous2D.h.

◆ DisContFieldSharedPtr

typedef std::shared_ptr<DisContField> Nektar::MultiRegions::DisContFieldSharedPtr

Definition at line 389 of file DisContField.h.

◆ DofGraph

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

Definition at line 53 of file AssemblyMapCG.h.

◆ ExchangeMethodSharedPtr

typedef std::shared_ptr<ExchangeMethod> Nektar::MultiRegions::ExchangeMethodSharedPtr

Definition at line 73 of file AssemblyCommDG.h.

◆ ExpList2DHomogeneous1DSharedPtr

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

Shared pointer to an ExpList2DHomogeneous1D object.

Definition at line 50 of file ExpList2DHomogeneous1D.h.

◆ ExpList2DHomogeneous1DVector

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

Vector of pointers to ExpList2DHomogeneous1D objects.

Definition at line 53 of file ExpList2DHomogeneous1D.h.

◆ ExpList2DHomogeneous2DSharedPtr

typedef std::shared_ptr<ExpList2DHomogeneous2D> Nektar::MultiRegions::ExpList2DHomogeneous2DSharedPtr

Shared pointer to an ExpList2DHomogeneous2D object.

Definition at line 50 of file ExpList2DHomogeneous2D.h.

◆ ExpList2DHomogeneous2DVector

typedef std::vector<ExpList2DHomogeneous2DSharedPtr> Nektar::MultiRegions::ExpList2DHomogeneous2DVector

Vector of pointers to ExpList2DHomogeneous2D objects.

Definition at line 53 of file ExpList2DHomogeneous2D.h.

◆ ExpList3DHomogeneous1DSharedPtr

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

Shared pointer to an ExpList3DHomogeneous1D object.

Definition at line 50 of file ExpList3DHomogeneous1D.h.

◆ ExpList3DHomogeneous1DVector

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

Vector of pointers to ExpList3DHomogeneous1D objects.

Definition at line 53 of file ExpList3DHomogeneous1D.h.

◆ ExpList3DHomogeneous2DSharedPtr

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

Shared pointer to an ExpList3DHomogeneous2D object.

Definition at line 50 of file ExpList3DHomogeneous2D.h.

◆ ExpList3DHomogeneous2DVector

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

Vector of pointers to ExpList3DHomogeneous2D objects.

Definition at line 53 of file ExpList3DHomogeneous2D.h.

◆ ExpListHomogeneous1DSharedPtr

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

Shared pointer to an ExpList3DHomogeneous1D object.

Definition at line 67 of file ExpListHomogeneous1D.h.

◆ ExpListHomogeneous1DVector

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

Vector of pointers to ExpList3DHomogeneous1D objects.

Definition at line 69 of file ExpListHomogeneous1D.h.

◆ ExpListHomogeneous2DSharedPtr

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

Shared pointer to an ExpList3DHomogeneous2D object.

Definition at line 71 of file ExpListHomogeneous2D.h.

◆ ExpListHomogeneous2DVector

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

Vector of pointers to ExpList3DHomogeneous2D objects.

Definition at line 73 of file ExpListHomogeneous2D.h.

◆ ExpListSharedPtr

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

Shared pointer to an ExpList object.

Definition at line 56 of file LocTraceToTraceMap.h.

◆ ExtraDirDof

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

Definition at line 51 of file AssemblyMapCG.h.

◆ GJPStabilisationSharedPtr

typedef std::shared_ptr<GJPStabilisation> Nektar::MultiRegions::GJPStabilisationSharedPtr

Definition at line 153 of file GJPStabilisation.h.

◆ GlobalLinSysDirectStaticCondSharedPtr

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

Definition at line 48 of file GlobalLinSysDirectStaticCond.h.

◆ GlobalLinSysFactory

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

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

Definition at line 65 of file GlobalLinSys.h.

◆ GlobalLinSysIterativeStaticCondSharedPtr

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

Definition at line 49 of file GlobalLinSysIterativeStaticCond.h.

◆ GlobalLinSysMap

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

Mapping between GlobalLinSys objects and their associated keys.

Definition at line 53 of file GlobalLinSys.h.

◆ GlobalLinSysMapShPtr

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

Pointer to a GlobalLinSys/key map.

Definition at line 55 of file GlobalLinSys.h.

◆ GlobalLinSysPETScStaticCondSharedPtr

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

Definition at line 49 of file GlobalLinSysPETScStaticCond.h.

◆ GlobalLinSysSharedPtr

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

Pointer to a GlobalLinSys object.

Definition at line 51 of file GlobalLinSys.h.

◆ GlobalLinSysStaticCondSharedPtr

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

Definition at line 48 of file GlobalLinSysStaticCond.h.

◆ GlobalLinSysXxtStaticCondSharedPtr

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

Definition at line 52 of file GlobalLinSysXxtStaticCond.h.

◆ GlobalMatrixKeySharedPtr

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

A pointer to a GlobalMatrixKey.

Definition at line 114 of file GlobalMatrixKey.h.

◆ GlobalMatrixMap

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

Mapping from global matrix keys to global matrices.

Definition at line 86 of file GlobalMatrix.h.

◆ GlobalMatrixMapShPtr

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

Shared pointer to a global matrix map.

Definition at line 88 of file GlobalMatrix.h.

◆ GlobalMatrixSharedPtr

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

Shared pointer to a GlobalMatrix object.

Definition at line 84 of file GlobalMatrix.h.

◆ Homo1DBlockMatrixMap

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

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

Definition at line 59 of file ExpListHomogeneous1D.h.

◆ Homo1DBlockMatrixMapShPtr

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

A shared pointer to a BlockMatrixMap.

Definition at line 61 of file ExpListHomogeneous1D.h.

◆ Homo2DBlockMatrixMap

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

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

Definition at line 63 of file ExpListHomogeneous2D.h.

◆ Homo2DBlockMatrixMapShPtr

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

A shared pointer to a BlockMatrixMap.

Definition at line 65 of file ExpListHomogeneous2D.h.

◆ InterfaceExchangeSharedPtr

typedef std::shared_ptr<InterfaceExchange> Nektar::MultiRegions::InterfaceExchangeSharedPtr

Definition at line 243 of file InterfaceMapDG.h.

◆ InterfaceMapDGSharedPtr

typedef std::shared_ptr<InterfaceMapDG> Nektar::MultiRegions::InterfaceMapDGSharedPtr

Definition at line 303 of file InterfaceMapDG.h.

◆ InterfaceTraceSharedPtr

typedef std::shared_ptr<InterfaceTrace> Nektar::MultiRegions::InterfaceTraceSharedPtr

Definition at line 128 of file InterfaceMapDG.h.

◆ LocTraceToTraceMapSharedPtr

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

Definition at line 514 of file LocTraceToTraceMap.h.

◆ MultiLevelBisectedGraphSharedPtr

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

Definition at line 63 of file SubStructuredGraph.h.

◆ PatchMapSharedPtr

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

Definition at line 64 of file SubStructuredGraph.h.

◆ PeriodicMap

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

Definition at line 180 of file MultiRegions.hpp.

◆ PreconditionerBlockSharedPtr

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

Definition at line 46 of file PreconditionerBlock.h.

◆ PreconditionerDiagonalSharedPtr

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

Definition at line 44 of file PreconditionerDiagonal.h.

◆ PreconditionerJacobiSharedPtr

typedef std::shared_ptr<PreconditionerJacobi> Nektar::MultiRegions::PreconditionerJacobiSharedPtr

Definition at line 138 of file PreconditionerDiagonal.h.

◆ PreconditionerLinearSharedPtr

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

Definition at line 52 of file PreconditionerLinear.h.

◆ PreconditionerLinearWithBlockSharedPtr

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

Definition at line 45 of file PreconditionerLinearWithBlock.h.

◆ PreconditionerLinearWithDiagSharedPtr

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

Definition at line 47 of file PreconditionerLinearWithDiag.h.

◆ PreconditionerLinearWithLowEnergySharedPtr

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

Definition at line 45 of file PreconditionerLinearWithLowEnergy.h.

◆ PreconditionerLowEnergySharedPtr

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

Definition at line 49 of file PreconditionerLowEnergy.h.

◆ PreconditionerNullSharedPtr

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

Definition at line 95 of file PreconditionerDiagonal.h.

◆ PreconditionerSharedPtr

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

Definition at line 58 of file GlobalLinSys.h.

◆ PreconFactory

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

Definition at line 60 of file Preconditioner.h.

◆ RobinBCInfoSharedPtr

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

Definition at line 158 of file MultiRegions.hpp.

◆ SubGraphSharedPtr

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

Definition at line 61 of file SubStructuredGraph.h.

◆ TraceInterpPoints

typedef std::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 80 of file LocTraceToTraceMap.h.

Enumeration Type Documentation

◆ AdjacentFaceOrientation

enum Nektar::MultiRegions::AdjacentFaceOrientation

Enumerator
eAdjacentFaceDir1FwdDir1_Dir2FwdDir2
eAdjacentFaceDir1FwdDir1_Dir2BwdDir2
eAdjacentFaceDir1BwdDir1_Dir2FwdDir2
eAdjacentFaceDir1BwdDir1_Dir2BwdDir2
eAdjacentFaceDir1FwdDir2_Dir2FwdDir1
eAdjacentFaceDir1FwdDir2_Dir2BwdDir1
eAdjacentFaceDir1BwdDir2_Dir2FwdDir1
eAdjacentFaceDir1BwdDir2_Dir2BwdDir1

Definition at line 54 of file MultiRegions.hpp.

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

◆ AdjacentTraceOrientation

enum Nektar::MultiRegions::AdjacentTraceOrientation

Enumerator
eAdjacentEdgeIsForwards
eAdjacentEdgeIsBackwards

Definition at line 46 of file MultiRegions.hpp.

{
    eAdjacentEdgeIsForwards,
    eAdjacentEdgeIsBackwards
};

◆ Direction

enum Nektar::MultiRegions::Direction

Enumerator
eX
eY
eZ

Definition at line 67 of file ExpList.h.

{
    eX,
    eY,
    eZ,
};

◆ ExpansionType

enum Nektar::MultiRegions::ExpansionType

Enumerator
e0D
e1D
e2D
e2DH1D
e3DH1D
e3DH2D
e3D
eNoType

Definition at line 74 of file ExpList.h.

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

◆ GJPFormulation

enum Nektar::MultiRegions::GJPFormulation

Enumerator
eGJPNoFormulation
eGJPExplicit
eGJPImplicit
eGJPSemiImplicit

Definition at line 46 of file GJPStabilisation.h.

{
    eGJPNoFormulation,
    eGJPExplicit,
    eGJPImplicit,
    eGJPSemiImplicit
};

◆ GJPStabilisationType

enum Nektar::MultiRegions::GJPStabilisationType

Enumerator
eNoGJPStabilisation
eExplicitGJPStabilisation
eFullImplicitGJPStabilisation
eSemiImplicitGJPStabilisation

Definition at line 106 of file MultiRegions.hpp.

{
    eNoGJPStabilisation,
    eExplicitGJPStabilisation,
    eFullImplicitGJPStabilisation,
    eSemiImplicitGJPStabilisation
};

◆ GlobalSysSolnType

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 66 of file MultiRegions.hpp.

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

◆ Homogeneous1DMatType

enum Nektar::MultiRegions::Homogeneous1DMatType

Enumerator
eForwardsCoeffSpace1D
eBackwardsCoeffSpace1D
eForwardsPhysSpace1D
eBackwardsPhysSpace1D

Definition at line 48 of file ExpListHomogeneous1D.h.

{
    eForwardsCoeffSpace1D,
    eBackwardsCoeffSpace1D,
    eForwardsPhysSpace1D,
    eBackwardsPhysSpace1D
};

◆ Homogeneous2DMatType

enum Nektar::MultiRegions::Homogeneous2DMatType

Enumerator
eForwardsCoeffSpaceY1D
eForwardsCoeffSpaceZ1D
eBackwardsCoeffSpaceY1D
eBackwardsCoeffSpaceZ1D
eForwardsPhysSpaceY1D
eForwardsPhysSpaceZ1D
eBackwardsPhysSpaceY1D
eBackwardsPhysSpaceZ1D

Definition at line 48 of file ExpListHomogeneous2D.h.

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

◆ InterpLocTraceToTrace

enum Nektar::MultiRegions::InterpLocTraceToTrace

Enumerator
eNoInterp
eInterpDir0
eInterpEndPtDir0
eInterpDir1
eInterpEndPtDir1
eInterpBothDirs
eInterpEndPtDir0InterpDir1

Definition at line 58 of file LocTraceToTraceMap.h.

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

◆ LinearPreconSolver

enum Nektar::MultiRegions::LinearPreconSolver

Enumerator
eLinearPreconXxt
eLinearPreconPETSc

Definition at line 45 of file PreconditionerLinear.h.

{
    eLinearPreconXxt,
    eLinearPreconPETSc
};

◆ LinSysIterSolver

enum Nektar::MultiRegions::LinSysIterSolver

Enumerator
eNoLinSysIterSolver	No Solution type specified.
eConjugateGradient	Conjugate Gradient.
eConjugateGradientLoc	Conjugate Gradient in Local Storage.
eGMRES	GMRES.
eGMRESLoc	GMRES in Local storage.
eDirectEigenValues	Compute and output eigenvalues of global matrix via dgeev.

Definition at line 114 of file MultiRegions.hpp.

{
    eNoLinSysIterSolver,   ///< No Solution type specified
    eConjugateGradient,    ///< Conjugate Gradient
    eConjugateGradientLoc, ///< Conjugate Gradient in Local Storage
    eGMRES,                ///< GMRES
    eGMRESLoc,             ///< GMRES in Local storage
    eDirectEigenValues ///< Compute and output eigenvalues of global matrix via
                       ///< dgeev
};

◆ LocalMatrixStorageStrategy

enum Nektar::MultiRegions::LocalMatrixStorageStrategy

Enumerator
eNoStrategy
eContiguous
eNonContiguous
eSparse

Definition at line 51 of file GlobalLinSysIterativeStaticCond.h.

{
    eNoStrategy,
    eContiguous,
    eNonContiguous,
    eSparse
};

◆ MatrixStorageType

enum Nektar::MultiRegions::MatrixStorageType

Enumerator
eSmvBSR

Definition at line 131 of file MultiRegions.hpp.

{
    eSmvBSR
};

◆ PETScMatMult

enum Nektar::MultiRegions::PETScMatMult

Enumerator.

Enumerator
ePETScMatMultSparse
ePETScMatMultShell

Definition at line 49 of file GlobalLinSysPETSc.h.

{
    ePETScMatMultSparse,
    ePETScMatMultShell
};

◆ ProjectionType

enum Nektar::MultiRegions::ProjectionType

Type of Galerkin projection.

Enumerator
eGalerkin
eDiscontinuous
eMixed_CG_Discontinuous

Definition at line 99 of file MultiRegions.hpp.

{
    eGalerkin,
    eDiscontinuous,
    eMixed_CG_Discontinuous
};

Function Documentation

◆ CuthillMckeeReordering()

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

Definition at line 682 of file SubStructuredGraph.cpp.

{
    int nGraphVerts = boost::num_vertices(graph);
 
    ASSERTL1(perm.size() >= nGraphVerts && iperm.size() >= 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;
    }
}

References ASSERTL1.

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

◆ DeterminePeriodicEdgeOrientId()

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 2203 of file AssemblyMapCG.cpp.

{
    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);
}

References Nektar::StdRegions::eBackwards, Nektar::StdRegions::eForwards, and tinysimd::min().

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

◆ DeterminePeriodicFaceOrient()

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 2251 of file AssemblyMapCG.cpp.

{
    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;
}

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().

◆ GetGlobalLinSysFactory()

GlobalLinSysFactory & Nektar::MultiRegions::GetGlobalLinSysFactory ( )

Definition at line 91 of file GlobalLinSys.cpp.

{
    static GlobalLinSysFactory instance;
    return instance;
}

◆ GetPreconFactory()

PreconFactory & Nektar::MultiRegions::GetPreconFactory ( )

Definition at line 64 of file Preconditioner.cpp.

{
    static PreconFactory instance;
    return instance;
}

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

◆ MultiLevelBisectionReordering()

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 703 of file SubStructuredGraph.cpp.

{
#ifndef NEKTAR_USE_SCOTCH
    ASSERTL0(false, "Multi-level static condensation requires Nektar++"
                    " to be built with SCOTCH.");
#else
    int nGraphVerts = boost::num_vertices(graph);
    int nGraphEdges = boost::num_edges(graph);
 
    ASSERTL1(perm.size() >= nGraphVerts && iperm.size() >= nGraphVerts,
             "Non-matching dimensions");
 
    // We will now use Scotch to reorder the graph.  For the purpose of
    // multi-level static condensation, we will use a Scotch routine
    // that partitions the graph recursively using a multi-level nested
    // bisection algorithm.  The name of this routine is
    // SCOTCH_graphOrder 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 substructuring. Therefore, we will use this
    // Scotch routine instead of the more well-known graph-partitioning
    // routines.
    if (nGraphEdges)
    {
        //
        // Step 1: Convert boost graph to a graph in adjncy-list format
        // as required by Scotch.
        //
        int acnt = 0, vcnt = 0, i, cnt;
        int nPartition    = partVerts.size();
        int nNonPartition = nGraphVerts - partVerts.size();
 
        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);
 
        // Perform an initial reordering of the vertices, so that
        // partition nodes are at the end. This allows Scotch to
        // partition the interior nodes from values starting at zero.
        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);
 
        // Now construct the adjaceny list using
        // boost::adjacent_vertices.
        auto verts = boost::vertices(graph);
        for (auto vertit = verts.first; vertit != verts.second; ++vertit)
        {
            if (partVerts.count(index[*vertit]) > 0)
            {
                continue;
            }
 
            auto adjverts = boost::adjacent_vertices(*vertit, graph);
            for (auto adjvertit = adjverts.first; adjvertit != adjverts.second;
                 ++adjvertit)
            {
                if (partVerts.count(index[*adjvertit]) > 0)
                {
                    continue;
                }
                adjncy[acnt++] = initial_perm[*adjvertit];
            }
            xadj[++vcnt] = acnt;
        }
 
        //
        // Step 2: pass the graph to Scotch and perform the nested
        // dissection to obtain a separator tree.
        //
 
        // Pass the adjaceny graph into Scotch.
        SCOTCH_Graph scGraph;
 
        ASSERTL0(SCOTCH_graphInit(&scGraph) == 0,
                 "Failed to initialise Scotch graph for substructuring.");
 
        SCOTCH_CALL(SCOTCH_graphBuild,
                    (&scGraph, 0, nNonPartition, &xadj[0], &xadj[1], nullptr,
                     nullptr, xadj[nNonPartition], &adjncy[0], nullptr));
 
        // This horrible looking string defines the Scotch graph
        // reordering strategy, which essentially does a nested
        // dissection + compression. We take this almost directly from
        // the SCOTCH_stratGraphOrderBuild function (defined in
        // library_graph_order.c), but by specifying the string
        // manually, we can replace the subdivision strategy to allow us
        // to control the number of vertices used to determine whether
        // to perform another dissection using the mdswitch
        // parameter. The below is essentially equivalent to calling
        // SCOTCH_stratGraphOrderBuild with the flags
        // SCOTCH_STRATLEAFSIMPLE and SCOTCH_STRATSEPASIMPLE to make
        // sure leaf nodes do not have any reordering applied to them.
        std::string strat_str =
            "c{rat=0.7,cpr=n{sep=/(<TSTS>)?m{rat=0.7,vert=100,low="
            "h{pass=10},asc=b{width=3,bnd=f{bal=<BBAL>},"
            "org=(|h{pass=10})f{bal=<BBAL>}}}<SEPA>;,"
            "ole=<OLEA>,ose=<OSEP>},unc=n{sep=/(<TSTS>)?m{rat=0.7,"
            "vert=100,low=h{pass=10},asc=b{width=3,bnd=f{bal=<BBAL>},"
            "org=(|h{pass=10})f{bal=<BBAL>}}}<SEPA>;"
            ",ole=<OLEA>,ose=<OSEP>}}";
 
        // Replace flags in the string with appropriate values.
        boost::replace_all(strat_str, "<SEPA>",
                           "|m{rat=0.7,vert=100,low=h{pass=10},"
                           "asc=b{width=3,bnd=f{bal=<BBAL>},"
                           "org=(|h{pass=10})f{bal=<BBAL>}}}");
        boost::replace_all(strat_str, "<OSEP>", "s");
        boost::replace_all(strat_str, "<OLEA>", "s");
        boost::replace_all(strat_str, "<BBAL>", "0.1");
        boost::replace_all(strat_str, "<TSTS>",
                           "vert>" + std::to_string(mdswitch));
 
        // Set up the re-ordering strategy.
        SCOTCH_Strat strat;
        SCOTCH_CALL(SCOTCH_stratInit, (&strat));
        SCOTCH_CALL(SCOTCH_stratGraphOrder, (&strat, strat_str.c_str()));
 
        // As output, Scotch will give us the total number of 'blocks'
        // (i.e. the separators and all of the leaves), the separator
        // tree as a mapping of block to parent block, and the range of
        // indices that is contained within each block. Reordering of
        // the vertices goes from largest index (at the top level) to
        // smallest (at the bottom level). The precise ordering is given
        // in the Scotch user guide.
        //
        // Note that we pass in iperm into the 'permtab' field of
        // graphOrder and 'perm' into the 'peritab' field; this is
        // because our definition of the permutation is the opposite of
        // what's defined in Scotch (this is leftover from a previous
        // implementation that used Metis).
        Array<OneD, int> treetab(nNonPartition);
        Array<OneD, int> rangtab(nNonPartition + 1);
        int cblknbr = 0;
        SCOTCH_CALL(SCOTCH_graphOrder,
                    (&scGraph, &strat, &iperm_tmp[0], &perm_tmp[0], &cblknbr,
                     &rangtab[0], &treetab[0]));
 
        // We're now done with Scotch: clean up the created structures.
        SCOTCH_stratExit(&strat);
        SCOTCH_graphExit(&scGraph);
 
        //
        // Step 3: create a MultiLevelBisectedGraph by reading the
        // separator tree we obtained from Scotch.
        //
 
        // Setup root block, which lies at the end of the blocks
        // described in treetab[].
        std::vector<MultiLevelBisectedGraphSharedPtr> graphs(cblknbr);
 
        // The strategy now is to traverse backwards over the blocks
        // described in treetab to set up the levels of the top-down
        // graph. rangtab allows us to calculate how many degrees of
        // freedom lie in the separator.
        for (i = cblknbr - 1; i >= 0; --i)
        {
            // Set up this block.
            graphs[i] =
                MemoryManager<MultiLevelBisectedGraph>::AllocateSharedPtr(
                    rangtab[i + 1] - rangtab[i]);
 
            // If we're a root block (treetab[i] == -1) we don't need to
            // do anything, just move onto the next block.
            if (treetab[i] == -1)
            {
                continue;
            }
 
            // Now use treetab[i] to figure out the parent block.  We
            // have to be a bit careful in setting left/right daughters
            // here. The left daughter's degrees of freedom are ordered
            // _first_ in the iperm/perm arrays returned from Scotch,
            // but if there is both a left and right daughter, we'll
            // come across the right daughter first because the
            // separators are being traversed backwards. We'll therefore
            // insert this at the beginning of the daughter graphs
            // vector.
            MultiLevelBisectedGraphSharedPtr tmp = graphs[treetab[i]];
            std::vector<MultiLevelBisectedGraphSharedPtr> &daughters =
                tmp->GetDaughterGraphs();
            daughters.insert(daughters.begin(), graphs[i]);
        }
 
        // Change permutations from Scotch to account for initial offset
        // in case we had partition vertices.
        for (i = 0; i < nGraphVerts; ++i)
        {
            if (partVerts.count(i) == 0)
            {
                iperm[i]       = iperm_tmp[initial_perm[i]];
                perm[iperm[i]] = i;
            }
        }
 
        auto it = partVerts.begin(), it2 = partVerts.end();
        for (i = nNonPartition; it != it2; ++it, ++i)
        {
            perm[i]    = *it;
            iperm[*it] = i;
        }
 
        for (i = 0; i < nGraphVerts; ++i)
        {
            ASSERTL1(perm[iperm[i]] == i, "Perm error " + std::to_string(i));
        }
 
        // If we were passed a graph with disconnected regions, we need
        // to create a bisected graph with the appropriate roots.
        std::vector<int> rootBlocks;
        for (i = 0; i < cblknbr; ++i)
        {
            if (treetab[i] == -1)
            {
                rootBlocks.push_back(i);
            }
        }
 
        MultiLevelBisectedGraphSharedPtr root;
        if (rootBlocks.size() == 1)
        {
            root = graphs[rootBlocks[0]];
        }
        else
        {
            root = MemoryManager<MultiLevelBisectedGraph>::AllocateSharedPtr(0);
 
            for (int i = 0; i < rootBlocks.size(); ++i)
            {
                root->GetDaughterGraphs().push_back(graphs[rootBlocks[i]]);
            }
        }
 
        // Check that our degree of freedom count in the constructed
        // graph is the same as the number of degrees of freedom that we
        // were given in the function input.
        ASSERTL0(root->GetTotDofs() == nNonPartition,
                 "Error in constructing Scotch graph for multi-level"
                 " static condensation.");
 
        //
        // Step 4: Set up the bottom-up graph from the top-down graph,
        // and reorder the permutation from Scotch.
        //
        substructgraph =
            MemoryManager<BottomUpSubStructuredGraph>::AllocateSharedPtr(
                root, nPartition, true);
 
        // Important: we cannot simply use the ordering given by Scotch
        // 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 substructuring. 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);
    }
#endif
}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, ASSERTL1, and SCOTCH_CALL.

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

◆ NoReordering()

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

Definition at line 1010 of file SubStructuredGraph.cpp.

{
    int nGraphVerts = boost::num_vertices(graph);
 
    ASSERTL1(perm.size() >= nGraphVerts && iperm.size() >= nGraphVerts,
             "Non-matching dimensions");
 
    for (int i = 0; i < nGraphVerts; i++)
    {
        perm[i]  = i;
        iperm[i] = i;
    }
}

References ASSERTL1.

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

◆ NullGlobalLinSysKey()

static GlobalLinSysKey Nektar::MultiRegions::NullGlobalLinSysKey ( StdRegions::eNoMatrixType )

static

Referenced by Nektar::MultiRegions::ContField3DHomogeneous1D::v_HelmSolve(), Nektar::MultiRegions::ContField3DHomogeneous2D::v_HelmSolve(), Nektar::MultiRegions::DisContField::v_HelmSolve(), Nektar::MultiRegions::DisContField3DHomogeneous1D::v_HelmSolve(), and Nektar::MultiRegions::DisContField3DHomogeneous2D::v_HelmSolve().

◆ operator<() [1/2]

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 106 of file GlobalLinSysKey.cpp.

{
    if (lhs.m_solnType < rhs.m_solnType)
    {
        return true;
    }
 
    if (lhs.m_solnType > rhs.m_solnType)
    {
        return false;
    }
 
    if (lhs.m_varFactors.size() < rhs.m_varFactors.size())
    {
        return true;
    }
 
    if (lhs.m_varFactors.size() > rhs.m_varFactors.size())
    {
        return false;
    }
 
    for (unsigned int i = 0; i < lhs.m_varFactors_hashes.size(); ++i)
    {
        if (lhs.m_varFactors_hashes[i] < rhs.m_varFactors_hashes[i])
        {
            return true;
        }
        if (lhs.m_varFactors_hashes[i] > rhs.m_varFactors_hashes[i])
        {
            return false;
        }
    }
 
    return (*dynamic_cast<const GlobalMatrixKey *>(&lhs) <
            *dynamic_cast<const GlobalMatrixKey *>(&rhs));
}

◆ operator<() [2/2]

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

Definition at line 70 of file GlobalMatrixKey.cpp.

{
    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.GetHash() < y->second.GetHash())
            {
                return true;
            }
            if (x->second.GetHash() > y->second.GetHash())
            {
                return false;
            }
        }
    }
 
    if (!rhs.m_locToGloMap.lock().get())
    {
        return false;
    }
    else if (!lhs.m_locToGloMap.lock().get() && rhs.m_locToGloMap.lock().get())
    {
        return true;
    }
    if (lhs.m_locToGloMap.lock()->GetHash() <
        rhs.m_locToGloMap.lock()->GetHash())
    {
        return true;
    }
 
    return false;
}

◆ operator<<() [1/2]

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 150 of file GlobalLinSysKey.cpp.

{
    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;
    for (auto &x : rhs.GetConstFactors())
    {
        os << "  Constant " << StdRegions::ConstFactorTypeMap[x.first] << ": "
           << x.second << endl;
    }
    os << "Number of variable coefficients: " << rhs.GetNVarCoeffs() << endl;
 
    os << "Number of variable factors : " << rhs.GetNVarFactors() << endl;
 
    return os;
}

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::GlobalLinSysKey::GetNVarFactors(), Nektar::MultiRegions::GlobalMatrixKey::GetShapeType(), GlobalSysSolnTypeMap, Nektar::StdRegions::MatrixTypeMap, and Nektar::LibUtilities::ShapeTypeMap.

◆ operator<<() [2/2]

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

Writes statistics about the matrix key to an output stream.

Definition at line 159 of file GlobalMatrixKey.cpp.

{
    os << "MatrixType: " << rhs.GetMatrixType() << endl;
    os << "Number of constants: " << rhs.GetNConstFactors() << endl;
    for (auto &x : rhs.GetConstFactors())
    {
        os << "  Constant " << StdRegions::ConstFactorTypeMap[x.first] << ": "
           << x.second << endl;
    }
    os << "Number of variable coefficients: " << rhs.GetNVarCoeffs() << endl;
 
    return os;
}

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

◆ RoundNekDoubleToInt() [1/2]

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 62 of file AssemblyMap.cpp.

{
    int size = inarray.size();
    ASSERTL1(outarray.size() >= 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);
    }
}

References ASSERTL1.

◆ RoundNekDoubleToInt() [2/2]

int Nektar::MultiRegions::RoundNekDoubleToInt ( NekDouble x )

Rounds a double precision number to an integer.

Definition at line 56 of file AssemblyMap.cpp.

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

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

◆ SubGraphWithoutVerts()

bool Nektar::MultiRegions::SubGraphWithoutVerts ( const SubGraphSharedPtr g )

Definition at line 665 of file SubStructuredGraph.cpp.

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

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

Variable Documentation

◆ DirCartesianMap

MultiRegions::Direction const Nektar::MultiRegions::DirCartesianMap[] = {eX, eY, eZ}

Definition at line 86 of file ExpList.h.

86{eX, eY, eZ};

◆ GlobalSysSolnTypeMap

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 84 of file MultiRegions.hpp.

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

Referenced by Nektar::MultiRegions::AssemblyMapCG::CreateGraph(), operator<<(), and Nektar::MultiRegions::PreconditionerLOR::v_BuildPreconditioner().

◆ LinSysIterSolverMap

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

Initial value:

= {
    "NoLinSysIterSolver", "ConjugateGradient", "ConjugateGradientLoc", "GMRES",
    "GMRESLoc",           "EvsDirect"}

Definition at line 125 of file MultiRegions.hpp.

                                          {
    "NoLinSysIterSolver", "ConjugateGradient", "ConjugateGradientLoc", "GMRES",
    "GMRESLoc",           "EvsDirect"};

◆ LocalMatrixStorageStrategyMap

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

Initial value:

= {

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

Definition at line 59 of file GlobalLinSysIterativeStaticCond.h.

59 {

60 "Contiguous", "Non-contiguous", "Sparse"};

◆ MatrixStorageTypeMap

const char* const Nektar::MultiRegions::MatrixStorageTypeMap[] = {"SmvBSR"}

Definition at line 136 of file MultiRegions.hpp.

136{"SmvBSR"};

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

◆ NullAssemblyMapSharedPtr

AssemblyMapSharedPtr Nektar::MultiRegions::NullAssemblyMapSharedPtr

static

Definition at line 51 of file AssemblyMap.h.

Referenced by Nektar::MultiRegions::GlobalLinSysKey::GlobalLinSysKey(), and Nektar::MultiRegions::DisContField::v_HelmSolve().

◆ NullExpList

ExpList Nektar::MultiRegions::NullExpList

static

An empty ExpList object.

Definition at line 1593 of file ExpList.h.

◆ NullExpListSharedPtr

ExpListSharedPtr Nektar::MultiRegions::NullExpListSharedPtr

static

Definition at line 1594 of file ExpList.h.

Referenced by Nektar::MultiRegions::DisContField::DisContField(), Nektar::MultiRegions::DisContField::SetUpDG(), and Nektar::MultiRegions::DisContField::v_GetTrace().

◆ NullExpListSharedPtrArray

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

static

Definition at line 2450 of file ExpList.h.

◆ NullGlobalLinSysManager

LibUtilities::NekManager<GlobalLinSysKey, GlobalLinSys> Nektar::MultiRegions::NullGlobalLinSysManager

static

Definition at line 1598 of file ExpList.h.

◆ NullIntIntMap

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

static

Definition at line 46 of file AssemblyMapCG.h.

◆ NullLocTraceToTraceMapSharedPtr

LocTraceToTraceMapSharedPtr Nektar::MultiRegions::NullLocTraceToTraceMapSharedPtr

static

Definition at line 516 of file LocTraceToTraceMap.h.

◆ NullPeriodicMap

PeriodicMap Nektar::MultiRegions::NullPeriodicMap

static

Definition at line 181 of file MultiRegions.hpp.

◆ NullPreconditionerSharedPtr

PreconditionerSharedPtr Nektar::MultiRegions::NullPreconditionerSharedPtr

static

Definition at line 55 of file Preconditioner.h.

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

◆ NullVecIntIntMap

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

static

Definition at line 47 of file AssemblyMapCG.h.

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ AssemblyCommDGSharedPtr

◆ AssemblyMapCGSharedPtr

◆ AssemblyMapDGSharedPtr

◆ AssemblyMapSharedPtr

◆ BlockMatrixMap

◆ BlockMatrixMapShPtr

◆ BndTypesVector

◆ BndTypesVectorIter

◆ BottomUpSubStructuredGraphSharedPtr

◆ ContField3DHomogeneous1DSharedPtr

◆ ContField3DHomogeneous2DSharedPtr

◆ ContFieldSharedPtr

◆ DisContField3DHomogeneous1DSharedPtr

◆ DisContField3DHomogeneous2DSharedPtr

◆ DisContFieldSharedPtr

◆ DofGraph

◆ ExchangeMethodSharedPtr

◆ ExpList2DHomogeneous1DSharedPtr

◆ ExpList2DHomogeneous1DVector

◆ ExpList2DHomogeneous2DSharedPtr

◆ ExpList2DHomogeneous2DVector

◆ ExpList3DHomogeneous1DSharedPtr

◆ ExpList3DHomogeneous1DVector

◆ ExpList3DHomogeneous2DSharedPtr

◆ ExpList3DHomogeneous2DVector

◆ ExpListHomogeneous1DSharedPtr

◆ ExpListHomogeneous1DVector

◆ ExpListHomogeneous2DSharedPtr

◆ ExpListHomogeneous2DVector

◆ ExpListSharedPtr

◆ ExtraDirDof

◆ GJPStabilisationSharedPtr

◆ GlobalLinSysDirectStaticCondSharedPtr

◆ GlobalLinSysFactory

◆ GlobalLinSysIterativeStaticCondSharedPtr

◆ GlobalLinSysMap

◆ GlobalLinSysMapShPtr

◆ GlobalLinSysPETScStaticCondSharedPtr

◆ GlobalLinSysSharedPtr

◆ GlobalLinSysStaticCondSharedPtr

◆ GlobalLinSysXxtStaticCondSharedPtr

◆ GlobalMatrixKeySharedPtr

◆ GlobalMatrixMap

◆ GlobalMatrixMapShPtr

◆ GlobalMatrixSharedPtr

◆ Homo1DBlockMatrixMap

◆ Homo1DBlockMatrixMapShPtr

◆ Homo2DBlockMatrixMap

◆ Homo2DBlockMatrixMapShPtr

◆ InterfaceExchangeSharedPtr

◆ InterfaceMapDGSharedPtr

◆ InterfaceTraceSharedPtr

◆ LocTraceToTraceMapSharedPtr

◆ MultiLevelBisectedGraphSharedPtr

◆ PatchMapSharedPtr

◆ PeriodicMap

◆ PreconditionerBlockSharedPtr

◆ PreconditionerDiagonalSharedPtr

◆ PreconditionerJacobiSharedPtr

◆ PreconditionerLinearSharedPtr

◆ PreconditionerLinearWithBlockSharedPtr

◆ PreconditionerLinearWithDiagSharedPtr

◆ PreconditionerLinearWithLowEnergySharedPtr

◆ PreconditionerLowEnergySharedPtr

◆ PreconditionerNullSharedPtr

◆ PreconditionerSharedPtr

◆ PreconFactory

◆ RobinBCInfoSharedPtr

◆ SubGraphSharedPtr

◆ TraceInterpPoints

Enumeration Type Documentation

◆ AdjacentFaceOrientation

◆ AdjacentTraceOrientation

◆ Direction