Nektar++
Classes | Typedefs | Enumerations | Functions | Variables
Nektar::MultiRegions Namespace Reference

Classes

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
 
struct  PeriodicEntity
 
class  Preconditioner
 
class  PreconditionerBlock
 
class  PreconditionerDiagonal
 
class  PreconditionerLinear
 
class  PreconditionerLinearWithBlock
 
class  PreconditionerLinearWithDiag
 
class  PreconditionerLinearWithLowEnergy
 
class  PreconditionerLowEnergy
 
class  PreconditionerNull
 
struct  RobinBCInfo
 
struct  RotPeriodicInfo
 
class  SubGraph
 

Typedefs

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< ExpList > ExpListSharedPtr
 Shared pointer to an ExpList object. More...
 
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. More...
 
typedef std::shared_ptr< LocTraceToTraceMap > LocTraceToTraceMapSharedPtr
 
typedef std::shared_ptr< ContField1D > ContField1DSharedPtr
 
typedef std::shared_ptr< ContField2D > ContField2DSharedPtr
 
typedef std::shared_ptr< ContField3D > ContField3DSharedPtr
 
typedef std::shared_ptr< ContField3DHomogeneous1D > ContField3DHomogeneous1DSharedPtr
 
typedef std::shared_ptr< ContField3DHomogeneous2D > ContField3DHomogeneous2DSharedPtr
 
typedef std::shared_ptr< DisContField1D > DisContField1DSharedPtr
 
typedef std::shared_ptr< DisContField2D > DisContField2DSharedPtr
 
typedef std::shared_ptr< DisContField3D > DisContField3DSharedPtr
 
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. More...
 
typedef std::shared_ptr< BlockMatrixMap > BlockMatrixMapShPtr
 A shared pointer to a BlockMatrixMap. More...
 
typedef std::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::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::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::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::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::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::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::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::map< Homogeneous1DMatType, DNekBlkMatSharedPtr > Homo1DBlockMatrixMap
 A map between homo matrix keys and their associated block matrices. More...
 
typedef std::shared_ptr< Homo1DBlockMatrixMap > Homo1DBlockMatrixMapShPtr
 A shared pointer to a BlockMatrixMap. More...
 
typedef std::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::map< Homogeneous2DMatType, DNekBlkMatSharedPtr > Homo2DBlockMatrixMap
 A map between homo matrix keys and their associated block matrices. More...
 
typedef std::shared_ptr< Homo2DBlockMatrixMap > Homo2DBlockMatrixMapShPtr
 A shared pointer to a BlockMatrixMap. More...
 
typedef std::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::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 std::shared_ptr< GlobalLinSysMap > GlobalLinSysMapShPtr
 Pointer to a GlobalLinSys/key map. More...
 
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. More...
 
typedef std::shared_ptr< GlobalLinSysDirectStaticCond > GlobalLinSysDirectStaticCondSharedPtr
 
typedef std::shared_ptr< GlobalLinSysIterativeStaticCond > GlobalLinSysIterativeStaticCondSharedPtr
 
typedef std::map< StdRegions::ConstFactorType, Array< OneD, NekDouble > > VarFactorsMap
 
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. More...
 
typedef std::map< GlobalMatrixKey, GlobalMatrixSharedPtr > GlobalMatrixMap
 Mapping from global matrix keys to global matrices. More...
 
typedef std::shared_ptr< GlobalMatrixMap > GlobalMatrixMapShPtr
 Shared pointer to a global matrix map. More...
 
typedef std::shared_ptr< GlobalMatrixKey > GlobalMatrixKeySharedPtr
 A pointer to a GlobalMatrixKey. More...
 
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< 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, eS,
  eN
}
 
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  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...
 
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 []
 
static VarFactorsMap NullVarFactorsMap
 
const char *const GlobalSysSolnTypeMap []
 
const char *const PreconditionerTypeMap []
 
const char *const MatrixStorageTypeMap []
 
static PeriodicMap NullPeriodicMap
 
static PreconditionerSharedPtr NullPreconditionerSharedPtr
 

Typedef Documentation

◆ AssemblyMapCGSharedPtr

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

Definition at line 51 of file AssemblyMapCG.h.

◆ AssemblyMapDGSharedPtr

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

Definition at line 48 of file AssemblyMapDG.h.

◆ AssemblyMapSharedPtr

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

Definition at line 52 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 97 of file ExpList.h.

◆ BlockMatrixMapShPtr

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

A shared pointer to a BlockMatrixMap.

Definition at line 99 of file ExpList.h.

◆ BndTypesVector

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

Definition at line 158 of file MultiRegions.hpp.

◆ BndTypesVectorIter

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

Definition at line 159 of file MultiRegions.hpp.

◆ BottomUpSubStructuredGraphSharedPtr

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

Definition at line 59 of file SubStructuredGraph.h.

◆ ContField1DSharedPtr

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

Definition at line 238 of file ContField1D.h.

◆ ContField2DSharedPtr

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

Definition at line 289 of file ContField2D.h.

◆ ContField3DHomogeneous1DSharedPtr

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

Definition at line 108 of file ContField3DHomogeneous1D.h.

◆ ContField3DHomogeneous2DSharedPtr

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

Definition at line 103 of file ContField3DHomogeneous2D.h.

◆ ContField3DSharedPtr

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

Definition at line 208 of file ContField3D.h.

◆ DisContField1DSharedPtr

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

Definition at line 281 of file DisContField1D.h.

◆ DisContField2DSharedPtr

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

Definition at line 306 of file DisContField2D.h.

◆ DisContField3DHomogeneous1DSharedPtr

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

Definition at line 302 of file DisContField3DHomogeneous1D.h.

◆ DisContField3DHomogeneous2DSharedPtr

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

Definition at line 162 of file DisContField3DHomogeneous2D.h.

◆ DisContField3DSharedPtr

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

Definition at line 273 of file DisContField3D.h.

◆ DofGraph

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

Definition at line 55 of file AssemblyMapCG.h.

◆ ExpList0DSharedPtr

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

Shared pointer to an ExpList0D object.

Definition at line 53 of file ExpList0D.h.

◆ ExpList0DVector

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

Vector of pointers to ExpList0D objects.

Definition at line 58 of file ExpList0D.h.

◆ ExpList1DHomogeneous2DSharedPtr

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

Shared pointer to an ExpList1DHomogeneous2D object.

Definition at line 49 of file ExpList1DHomogeneous2D.h.

◆ ExpList1DHomogeneous2DVector

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

Vector of pointers to ExpList1DHomogeneous2D objects.

Definition at line 54 of file ExpList1DHomogeneous2D.h.

◆ ExpList1DSharedPtr

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

Shared pointer to an ExpList1D object.

Definition at line 49 of file ExpList1D.h.

◆ ExpList1DVector

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

Vector of pointers to ExpList1D objects.

Definition at line 54 of file ExpList1D.h.

◆ ExpList2DHomogeneous1DSharedPtr

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

Shared pointer to an ExpList2DHomogeneous1D object.

Definition at line 49 of file ExpList2DHomogeneous1D.h.

◆ ExpList2DHomogeneous1DVector

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

Vector of pointers to ExpList2DHomogeneous1D objects.

Definition at line 56 of file ExpList2DHomogeneous1D.h.

◆ ExpList2DSharedPtr

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

Shared pointer to an ExpList2D object.

Definition at line 48 of file ExpList2D.h.

◆ ExpList2DVector

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

Vector of pointers to ExpList2D objects.

Definition at line 53 of file ExpList2D.h.

◆ ExpList3DHomogeneous1DSharedPtr

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

Shared pointer to an ExpList3DHomogeneous1D object.

Definition at line 51 of file ExpList3DHomogeneous1D.h.

◆ ExpList3DHomogeneous1DVector

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

Vector of pointers to ExpList3DHomogeneous1D objects.

Definition at line 56 of file ExpList3DHomogeneous1D.h.

◆ ExpList3DHomogeneous2DSharedPtr

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

Shared pointer to an ExpList3DHomogeneous2D object.

Definition at line 49 of file ExpList3DHomogeneous2D.h.

◆ ExpList3DHomogeneous2DVector

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

Vector of pointers to ExpList3DHomogeneous2D objects.

Definition at line 54 of file ExpList3DHomogeneous2D.h.

◆ ExpList3DSharedPtr

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

Shared pointer to an ExpList3D object.

Definition at line 111 of file ExpList3D.h.

◆ ExpList3DVector

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

Vector of pointers to ExpList3D objects.

Definition at line 113 of file ExpList3D.h.

◆ ExpListHomogeneous1DSharedPtr

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

Shared pointer to an ExpList3DHomogeneous1D object.

Definition at line 65 of file ExpListHomogeneous1D.h.

◆ ExpListHomogeneous1DVector

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

Vector of pointers to ExpList3DHomogeneous1D objects.

Definition at line 70 of file ExpListHomogeneous1D.h.

◆ ExpListHomogeneous2DSharedPtr

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

Shared pointer to an ExpList3DHomogeneous2D object.

Definition at line 69 of file ExpListHomogeneous2D.h.

◆ ExpListHomogeneous2DVector

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

Vector of pointers to ExpList3DHomogeneous2D objects.

Definition at line 74 of file ExpListHomogeneous2D.h.

◆ ExpListSharedPtr

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

Shared pointer to an ExpList object.

Definition at line 55 of file LocTraceToTraceMap.h.

◆ ExtraDirDof

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

Definition at line 53 of file AssemblyMapCG.h.

◆ GlobalLinSysDirectStaticCondSharedPtr

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

Definition at line 47 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 67 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 55 of file GlobalLinSys.h.

◆ GlobalLinSysMapShPtr

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

Pointer to a GlobalLinSys/key map.

Definition at line 57 of file GlobalLinSys.h.

◆ GlobalLinSysPETScStaticCondSharedPtr

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

Definition at line 48 of file GlobalLinSysPETScStaticCond.h.

◆ GlobalLinSysSharedPtr

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

Pointer to a GlobalLinSys object.

Definition at line 50 of file GlobalLinSys.h.

◆ GlobalLinSysStaticCondSharedPtr

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

Definition at line 50 of file GlobalLinSysStaticCond.h.

◆ GlobalLinSysXxtStaticCondSharedPtr

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

Definition at line 51 of file GlobalLinSysXxtStaticCond.h.

◆ GlobalMatrixKeySharedPtr

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

A pointer to a GlobalMatrixKey.

Definition at line 112 of file GlobalMatrixKey.h.

◆ GlobalMatrixMap

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

Mapping from global matrix keys to global matrices.

Definition at line 90 of file GlobalMatrix.h.

◆ GlobalMatrixMapShPtr

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

Shared pointer to a global matrix map.

Definition at line 92 of file GlobalMatrix.h.

◆ GlobalMatrixSharedPtr

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

Shared pointer to a GlobalMatrix object.

Definition at line 88 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 60 of file ExpListHomogeneous1D.h.

◆ Homo1DBlockMatrixMapShPtr

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

A shared pointer to a BlockMatrixMap.

Definition at line 62 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 64 of file ExpListHomogeneous2D.h.

◆ Homo2DBlockMatrixMapShPtr

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

A shared pointer to a BlockMatrixMap.

Definition at line 66 of file ExpListHomogeneous2D.h.

◆ LocTraceToTraceMapSharedPtr

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

Definition at line 272 of file LocTraceToTraceMap.h.

◆ MultiLevelBisectedGraphSharedPtr

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

Definition at line 66 of file SubStructuredGraph.h.

◆ PatchMapSharedPtr

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

Definition at line 68 of file SubStructuredGraph.h.

◆ PeriodicMap

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

Definition at line 200 of file MultiRegions.hpp.

◆ PreconditionerBlockSharedPtr

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

Definition at line 47 of file PreconditionerBlock.h.

◆ PreconditionerDiagonalSharedPtr

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

Definition at line 46 of file PreconditionerDiagonal.h.

◆ PreconditionerLinearSharedPtr

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

Definition at line 54 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 50 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 60 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 61 of file Preconditioner.h.

◆ RobinBCInfoSharedPtr

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

Definition at line 180 of file MultiRegions.hpp.

◆ SubGraphSharedPtr

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

Definition at line 64 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 81 of file LocTraceToTraceMap.h.

◆ VarFactorsMap

typedef std::map<StdRegions::ConstFactorType, Array<OneD, NekDouble> > Nektar::MultiRegions::VarFactorsMap

Definition at line 46 of file GlobalLinSysKey.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 64 of file MultiRegions.hpp.

65  {
66  eAdjacentFaceDir1FwdDir1_Dir2FwdDir2,
67  eAdjacentFaceDir1FwdDir1_Dir2BwdDir2,
68  eAdjacentFaceDir1BwdDir1_Dir2FwdDir2,
69  eAdjacentFaceDir1BwdDir1_Dir2BwdDir2,
70  eAdjacentFaceDir1FwdDir2_Dir2FwdDir1,
71  eAdjacentFaceDir1FwdDir2_Dir2BwdDir1,
72  eAdjacentFaceDir1BwdDir2_Dir2FwdDir1,
73  eAdjacentFaceDir1BwdDir2_Dir2BwdDir1
74  };

◆ AdjacentTraceOrientation

enum Nektar::MultiRegions::AdjacentTraceOrientation
Enumerator
eAdjacentEdgeIsForwards 
eAdjacentEdgeIsBackwards 

Definition at line 56 of file MultiRegions.hpp.

57  {
58  eAdjacentEdgeIsForwards,
59  eAdjacentEdgeIsBackwards
60  };

◆ CoeffState

enum Nektar::MultiRegions::CoeffState
Enumerator
eNotSet 

No state set.

eLocal 

Local coefficients.

eHybrid 

Hybrid coefficients.

eGlobal 

Global coefficients.

Definition at line 46 of file MultiRegions.hpp.

47  {
48  eNotSet, ///< No state set
49  eLocal, ///< Local coefficients
50  eHybrid, ///< Hybrid coefficients
51  eGlobal, ///< Global coefficients
52  };
Nektar::MultiRegions::eLocal
Local coefficients.
Definition: MultiRegions.hpp:49
Nektar::MultiRegions::eHybrid
Hybrid coefficients.
Definition: MultiRegions.hpp:50
Nektar::MultiRegions::eGlobal
Global coefficients.
Definition: MultiRegions.hpp:51

◆ Direction

enum Nektar::MultiRegions::Direction
Enumerator
eX 
eY 
eZ 
eS 
eN 

Definition at line 67 of file ExpList.h.

68  {
69  eX,
70  eY,
71  eZ,
72  eS,
73  eN
74  };

◆ ExpansionType

enum Nektar::MultiRegions::ExpansionType
Enumerator
e0D 
e1D 
e2D 
e2DH1D 
e3DH1D 
e3DH2D 
e3D 
eNoType 

Definition at line 76 of file ExpList.h.

77  {
78  e0D,
79  e1D,
80  e2D,
81  e2DH1D,
82  e3DH1D,
83  e3DH2D,
84  e3D,
85  eNoType
86  };

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

77  {
78  eNoSolnType, ///< No Solution type specified
79  eDirectFullMatrix,
80  eDirectStaticCond,
81  eDirectMultiLevelStaticCond,
82  eIterativeFull,
83  eIterativeStaticCond,
84  eIterativeMultiLevelStaticCond,
85  eXxtFullMatrix,
86  eXxtStaticCond,
87  eXxtMultiLevelStaticCond,
88  ePETScFullMatrix,
89  ePETScStaticCond,
90  ePETScMultiLevelStaticCond,
91  eSIZE_GlobalSysSolnType
92  };
Nektar::MultiRegions::eNoSolnType
No Solution type specified.
Definition: MultiRegions.hpp:78

◆ Homogeneous1DMatType

enum Nektar::MultiRegions::Homogeneous1DMatType
Enumerator
eForwardsCoeffSpace1D 
eBackwardsCoeffSpace1D 
eForwardsPhysSpace1D 
eBackwardsPhysSpace1D 

Definition at line 50 of file ExpListHomogeneous1D.h.

51  {
52  eForwardsCoeffSpace1D,
53  eBackwardsCoeffSpace1D,
54  eForwardsPhysSpace1D,
55  eBackwardsPhysSpace1D
56  };

◆ Homogeneous2DMatType

enum Nektar::MultiRegions::Homogeneous2DMatType
Enumerator
eForwardsCoeffSpaceY1D 
eForwardsCoeffSpaceZ1D 
eBackwardsCoeffSpaceY1D 
eBackwardsCoeffSpaceZ1D 
eForwardsPhysSpaceY1D 
eForwardsPhysSpaceZ1D 
eBackwardsPhysSpaceY1D 
eBackwardsPhysSpaceZ1D 

Definition at line 50 of file ExpListHomogeneous2D.h.

51  {
52  eForwardsCoeffSpaceY1D,
53  eForwardsCoeffSpaceZ1D,
54  eBackwardsCoeffSpaceY1D,
55  eBackwardsCoeffSpaceZ1D,
56  eForwardsPhysSpaceY1D,
57  eForwardsPhysSpaceZ1D,
58  eBackwardsPhysSpaceY1D,
59  eBackwardsPhysSpaceZ1D
60  };

◆ InterpLocTraceToTrace

enum Nektar::MultiRegions::InterpLocTraceToTrace
Enumerator
eNoInterp 
eInterpDir0 
eInterpEndPtDir0 
eInterpDir1 
eInterpEndPtDir1 
eInterpBothDirs 
eInterpEndPtDir0InterpDir1 

Definition at line 58 of file LocTraceToTraceMap.h.

59 {
60  eNoInterp,
61  eInterpDir0,
62  eInterpEndPtDir0,
63  eInterpDir1,
64  eInterpEndPtDir1,
65  eInterpBothDirs,
66  eInterpEndPtDir0InterpDir1
67 };

◆ LinearPreconSolver

enum Nektar::MultiRegions::LinearPreconSolver
Enumerator
eLinearPreconXxt 
eLinearPreconPETSc 

Definition at line 48 of file PreconditionerLinear.h.

49  {
50  eLinearPreconXxt,
51  eLinearPreconPETSc
52  };

◆ LocalMatrixStorageStrategy

enum Nektar::MultiRegions::LocalMatrixStorageStrategy
Enumerator
eNoStrategy 
eContiguous 
eNonContiguous 
eSparse 

Definition at line 54 of file GlobalLinSysIterativeStaticCond.h.

55  {
56  eNoStrategy,
57  eContiguous,
58  eNonContiguous,
59  eSparse
60  };

◆ MatrixStorageType

enum Nektar::MultiRegions::MatrixStorageType
Enumerator
eSmvBSR 

Definition at line 147 of file MultiRegions.hpp.

148  {
149  eSmvBSR
150  };

◆ PETScMatMult

enum Nektar::MultiRegions::PETScMatMult

Enumerator.

Enumerator
ePETScMatMultSparse 
ePETScMatMultShell 

Definition at line 51 of file GlobalLinSysPETSc.h.

52  {
53  ePETScMatMultSparse,
54  ePETScMatMultShell
55  };

◆ PreconditionerType

enum Nektar::MultiRegions::PreconditionerType
Enumerator
eNull 

No Solution type specified.

eDiagonal 
eLinearWithDiagonal 
eLinear 
eLowEnergy 
eLinearWithLowEnergy 
eBlock 
eLinearWithBlock 

Definition at line 120 of file MultiRegions.hpp.

121  {
122  eNull, ///< No Solution type specified
123  eDiagonal,
124  eLinearWithDiagonal,
125  eLinear,
126  eLowEnergy,
127  eLinearWithLowEnergy,
128  eBlock,
129  eLinearWithBlock
130  };
Nektar::MultiRegions::eNull
No Solution type specified.
Definition: MultiRegions.hpp:122

◆ ProjectionType

enum Nektar::MultiRegions::ProjectionType

Type of Galerkin projection.

Enumerator
eGalerkin 
eDiscontinuous 
eMixed_CG_Discontinuous 

Definition at line 113 of file MultiRegions.hpp.

114  {
115  eGalerkin,
116  eDiscontinuous,
117  eMixed_CG_Discontinuous
118  };

Function Documentation

◆ AlignFace()

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

970  {
971  // Copy transpose.
972  if (orient == StdRegions::eDir1FwdDir2_Dir2FwdDir1 ||
973  orient == StdRegions::eDir1BwdDir2_Dir2FwdDir1 ||
974  orient == StdRegions::eDir1FwdDir2_Dir2BwdDir1 ||
975  orient == StdRegions::eDir1BwdDir2_Dir2BwdDir1)
976  {
977  for (int i = 0; i < nquad2; ++i)
978  {
979  for (int j = 0; j < nquad1; ++j)
980  {
981  out[i*nquad1 + j] = in[j*nquad2 + i];
982  }
983  }
984  }
985  else
986  {
987  for (int i = 0; i < nquad2; ++i)
988  {
989  for (int j = 0; j < nquad1; ++j)
990  {
991  out[i*nquad1 + j] = in[i*nquad1 + j];
992  }
993  }
994  }
995 
996  if (orient == StdRegions::eDir1BwdDir1_Dir2FwdDir2 ||
997  orient == StdRegions::eDir1BwdDir1_Dir2BwdDir2 ||
998  orient == StdRegions::eDir1BwdDir2_Dir2FwdDir1 ||
999  orient == StdRegions::eDir1BwdDir2_Dir2BwdDir1)
1000  {
1001  // Reverse x direction
1002  for (int i = 0; i < nquad2; ++i)
1003  {
1004  for (int j = 0; j < nquad1/2; ++j)
1005  {
1006  swap(out[i*nquad1 + j],
1007  out[i*nquad1 + nquad1-j-1]);
1008  }
1009  }
1010  }
1011 
1012  if (orient == StdRegions::eDir1FwdDir1_Dir2BwdDir2 ||
1013  orient == StdRegions::eDir1BwdDir1_Dir2BwdDir2 ||
1014  orient == StdRegions::eDir1FwdDir2_Dir2BwdDir1 ||
1015  orient == StdRegions::eDir1BwdDir2_Dir2BwdDir1)
1016  {
1017  // Reverse y direction
1018  for (int j = 0; j < nquad1; ++j)
1019  {
1020  for (int i = 0; i < nquad2/2; ++i)
1021  {
1022  swap(out[i*nquad1 + j],
1023  out[(nquad2-i-1)*nquad1 + j]);
1024  }
1025  }
1026  }
1027  }

◆ CuthillMckeeReordering()

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

Definition at line 679 of file SubStructuredGraph.cpp.

References ASSERTL1.

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

682  {
683  int nGraphVerts = boost::num_vertices(graph);
684 
685  ASSERTL1(perm. num_elements() >= nGraphVerts &&
686  iperm.num_elements() >= nGraphVerts,
687  "Non-matching dimensions");
688 
689  // Call boost::cuthill_mckee_ordering to reorder the graph-vertices
690  // using the reverse Cuthill-Mckee algorithm
691  std::vector<BoostVertex> reorderedVerts(nGraphVerts);
692  boost::cuthill_mckee_ordering(graph, reorderedVerts.rbegin());
693 
694  //copy the reordering to the Arrays perm and iperm
695  for(int i = 0; i < nGraphVerts; i++)
696  {
697  perm[i] = reorderedVerts[i];
698  iperm[ reorderedVerts[i] ] = i;
699  }
700  }
ASSERTL1
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:250

◆ 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
meshEdgeIdID of a periodic edge.
edgeOrientEdge orientation of meshEdgeId with respect to its parent element.
periodicEdgesThe 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 2089 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().

2093  {
2094  int minId = periodicEdges[0].id;
2095  int minIdK = 0;
2096  int k;
2097 
2098  for (k = 1; k < periodicEdges.size(); ++k)
2099  {
2100  if (periodicEdges[k].id < minId)
2101  {
2102  minId = min(minId, periodicEdges[k].id);
2103  minIdK = k;
2104  }
2105  }
2106 
2107  minId = min(minId, meshEdgeId);
2108 
2109  if (meshEdgeId != minId)
2110  {
2111  if (periodicEdges[minIdK].orient == StdRegions::eBackwards)
2112  {
2113  // Swap edge orientation
2114  edgeOrient = (edgeOrient == StdRegions::eForwards) ?
2115  StdRegions::eBackwards : StdRegions::eForwards;
2116  }
2117  }
2118 
2119  return make_pair(minId, edgeOrient);
2120  }

◆ 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
faceOrientOrientation of the face with respect to its parent element.
perFaceOrientOrientation of the representative/global face.
Returns
Orientation between the two faces.

Definition at line 2137 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().

2140  {
2141  StdRegions::Orientation returnval = faceOrient;
2142 
2143  if(perFaceOrient != StdRegions::eDir1FwdDir1_Dir2FwdDir2)
2144  {
2145  int tmp1 = (int)faceOrient - 5;
2146  int tmp2 = (int)perFaceOrient - 5;
2147 
2148  int flipDir1Map [8] = {2,3,0,1,6,7,4,5};
2149  int flipDir2Map [8] = {1,0,3,2,5,4,7,6};
2150  int transposeMap[8] = {4,5,6,7,0,2,1,3};
2151 
2152  // Transpose orientation
2153  if (tmp2 > 3)
2154  {
2155  tmp1 = transposeMap[tmp1];
2156  }
2157 
2158  // Reverse orientation in direction 1.
2159  if (tmp2 == 2 || tmp2 == 3 || tmp2 == 6 || tmp2 == 7)
2160  {
2161  tmp1 = flipDir1Map[tmp1];
2162  }
2163 
2164  // Reverse orientation in direction 2
2165  if (tmp2 % 2 == 1)
2166  {
2167  tmp1 = flipDir2Map[tmp1];
2168  }
2169 
2170  returnval = (StdRegions::Orientation)(tmp1+5);
2171  }
2172  return returnval;
2173  }

◆ GetGlobalLinSysFactory()

GlobalLinSysFactory & Nektar::MultiRegions::GetGlobalLinSysFactory ( )

Definition at line 212 of file GlobalLinSys.cpp.

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

213  {
214  static GlobalLinSysFactory instance;
215  return instance;
216  }
Nektar::MultiRegions::GlobalLinSysFactory
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...
Definition: GlobalLinSys.h:67

◆ GetPreconFactory()

PreconFactory & Nektar::MultiRegions::GetPreconFactory ( )

Definition at line 89 of file Preconditioner.cpp.

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

90  {
91  static PreconFactory instance;
92  return instance;
93  }
Nektar::MultiRegions::PreconFactory
LibUtilities::NekFactory< std::string, Preconditioner, const std::shared_ptr< GlobalLinSys > &, const std::shared_ptr< AssemblyMap > &> PreconFactory
Definition: Preconditioner.h:61

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

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

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

709  {
710 #ifndef NEKTAR_USE_SCOTCH
711  boost::ignore_unused(graph, perm, iperm, substructgraph, partVerts,
712  mdswitch);
713  ASSERTL0(false, "Multi-level static condensation requires Nektar++"
714  " to be built with SCOTCH.");
715 #else
716  int nGraphVerts = boost::num_vertices(graph);
717  int nGraphEdges = boost::num_edges (graph);
718 
719  ASSERTL1(perm. num_elements() >= nGraphVerts &&
720  iperm.num_elements() >= nGraphVerts,
721  "Non-matching dimensions");
722 
723  // We will now use Scotch to reorder the graph. For the purpose of
724  // multi-level static condensation, we will use a Scotch routine
725  // that partitions the graph recursively using a multi-level nested
726  // bisection algorithm. The name of this routine is
727  // SCOTCH_graphOrder and it was originally designed to reorder the
728  // DOFs in a matrix in order to minimise the fill-in when applying a
729  // factorisation technique (such as Cholesky). However, this
730  // reordering of DOFs also seems to be perfectly suited in the
731  // context of multilevel substructuring. Therefore, we will use this
732  // Scotch routine instead of the more well-known graph-partitioning
733  // routines.
734  if(nGraphEdges)
735  {
736  //
737  // Step 1: Convert boost graph to a graph in adjncy-list format
738  // as required by Scotch.
739  //
740  int acnt = 0, vcnt = 0, i, cnt;
741  int nPartition = partVerts.size();
742  int nNonPartition = nGraphVerts - partVerts.size();
743 
744  Array<OneD, int> xadj(nNonPartition+1,0);
745  Array<OneD, int> adjncy(2*nGraphEdges);
746  Array<OneD, int> initial_perm(nGraphVerts);
747  Array<OneD, int> iinitial_perm(nGraphVerts);
748  Array<OneD, int> perm_tmp (nNonPartition);
749  Array<OneD, int> iperm_tmp(nNonPartition);
750 
751  // Perform an initial reordering of the vertices, so that
752  // partition nodes are at the end. This allows Scotch to
753  // partition the interior nodes from values starting at zero.
754  for (i = cnt = 0; i < nGraphVerts; ++i)
755  {
756  if (partVerts.count(i) == 0)
757  {
758  initial_perm [i] = cnt;
759  iinitial_perm[cnt++] = i;
760  }
761  }
762 
763  for (i = 0; i < nGraphVerts; ++i)
764  {
765  if (partVerts.count(i) > 0)
766  {
767  initial_perm [i] = cnt;
768  iinitial_perm[cnt++] = i;
769  }
770  }
771 
772  // Apply this reordering to the graph.
773  boost::property_map<BoostGraph, boost::vertex_index_t>::type
774  index = get(boost::vertex_index, graph);
775 
776  // Now construct the adjaceny list using
777  // boost::adjacent_vertices.
778  auto verts = boost::vertices(graph);
779  for (auto vertit = verts.first; vertit != verts.second; ++vertit)
780  {
781  if (partVerts.count(index[*vertit]) > 0)
782  {
783  continue;
784  }
785 
786  auto adjverts = boost::adjacent_vertices(*vertit,graph);
787  for (auto adjvertit = adjverts.first;
788  adjvertit != adjverts.second; ++adjvertit)
789  {
790  if (partVerts.count(index[*adjvertit]) > 0)
791  {
792  continue;
793  }
794  adjncy[acnt++] = initial_perm[*adjvertit];
795  }
796  xadj[++vcnt] = acnt;
797  }
798 
799  //
800  // Step 2: pass the graph to Scotch and perform the nested
801  // dissection to obtain a separator tree.
802  //
803 
804  // Pass the adjaceny graph into Scotch.
805  SCOTCH_Graph scGraph;
806  SCOTCH_CALL(SCOTCH_graphBuild,
807  (&scGraph, 0, nNonPartition, &xadj[0], &xadj[1],
808  NULL, NULL, xadj[nNonPartition], &adjncy[0], NULL));
809 
810  // This horrible looking string defines the Scotch graph
811  // reordering strategy, which essentially does a nested
812  // dissection + compression. We take this almost directly from
813  // the SCOTCH_stratGraphOrderBuild function (defined in
814  // library_graph_order.c), but by specifying the string
815  // manually, we can replace the subdivision strategy to allow us
816  // to control the number of vertices used to determine whether
817  // to perform another dissection using the mdswitch
818  // parameter. The below is essentially equivalent to calling
819  // SCOTCH_stratGraphOrderBuild with the flags
820  // SCOTCH_STRATLEAFSIMPLE and SCOTCH_STRATSEPASIMPLE to make
821  // sure leaf nodes do not have any reordering applied to them.
822  std::string strat_str =
823  "c{rat=0.7,cpr=n{sep=/(<TSTS>)?m{rat=0.7,vert=100,low="
824  "h{pass=10},asc=b{width=3,bnd=f{bal=<BBAL>},"
825  "org=(|h{pass=10})f{bal=<BBAL>}}}<SEPA>;,"
826  "ole=<OLEA>,ose=<OSEP>},unc=n{sep=/(<TSTS>)?m{rat=0.7,"
827  "vert=100,low=h{pass=10},asc=b{width=3,bnd=f{bal=<BBAL>},"
828  "org=(|h{pass=10})f{bal=<BBAL>}}}<SEPA>;"
829  ",ole=<OLEA>,ose=<OSEP>}}";
830 
831  // Replace flags in the string with appropriate values.
832  boost::replace_all(
833  strat_str, "<SEPA>", "|m{rat=0.7,vert=100,low=h{pass=10},"
834  "asc=b{width=3,bnd=f{bal=<BBAL>},"
835  "org=(|h{pass=10})f{bal=<BBAL>}}}");
836  boost::replace_all(strat_str, "<OSEP>", "s");
837  boost::replace_all(strat_str, "<OLEA>", "s");
838  boost::replace_all(strat_str, "<BBAL>", "0.1");
839  boost::replace_all(
840  strat_str, "<TSTS>",
841  "vert>"+std::to_string(mdswitch));
842 
843  // Set up the re-ordering strategy.
844  SCOTCH_Strat strat;
845  SCOTCH_CALL(SCOTCH_stratInit, (&strat));
846  SCOTCH_CALL(SCOTCH_stratGraphOrder, (&strat, strat_str.c_str()));
847 
848  // As output, Scotch will give us the total number of 'blocks'
849  // (i.e. the separators and all of the leaves), the separator
850  // tree as a mapping of block to parent block, and the range of
851  // indices that is contained within each block. Reordering of
852  // the vertices goes from largest index (at the top level) to
853  // smallest (at the bottom level). The precise ordering is given
854  // in the Scotch user guide.
855  //
856  // Note that we pass in iperm into the 'permtab' field of
857  // graphOrder and 'perm' into the 'peritab' field; this is
858  // because our definition of the permutation is the opposite of
859  // what's defined in Scotch (this is leftover from a previous
860  // implementation that used Metis).
861  Array<OneD, int> treetab(nNonPartition);
862  Array<OneD, int> rangtab(nNonPartition + 1);
863  int cblknbr = 0;
864  SCOTCH_CALL(SCOTCH_graphOrder,
865  (&scGraph, &strat, &iperm_tmp[0], &perm_tmp[0],
866  &cblknbr, &rangtab[0], &treetab[0]));
867 
868  // We're now done with Scotch: clean up the created structures.
869  SCOTCH_graphExit(&scGraph);
870  SCOTCH_stratExit(&strat);
871 
872  //
873  // Step 3: create a MultiLevelBisectedGraph by reading the
874  // separator tree we obtained from Scotch.
875  //
876 
877  // Setup root block, which lies at the end of the blocks
878  // described in treetab[].
879  std::vector<MultiLevelBisectedGraphSharedPtr> graphs(cblknbr);
880 
881  // The strategy now is to traverse backwards over the blocks
882  // described in treetab to set up the levels of the top-down
883  // graph. rangtab allows us to calculate how many degrees of
884  // freedom lie in the separator.
885  for (i = cblknbr-1; i >= 0; --i)
886  {
887  // Set up this block.
888  graphs[i] = MemoryManager<MultiLevelBisectedGraph>
889  ::AllocateSharedPtr(rangtab[i+1] - rangtab[i]);
890 
891  // If we're a root block (treetab[i] == -1) we don't need to
892  // do anything, just move onto the next block.
893  if (treetab[i] == -1)
894  {
895  continue;
896  }
897 
898  // Now use treetab[i] to figure out the parent block. We
899  // have to be a bit careful in setting left/right daughters
900  // here. The left daughter's degrees of freedom are ordered
901  // _first_ in the iperm/perm arrays returned from Scotch,
902  // but if there is both a left and right daughter, we'll
903  // come across the right daughter first because the
904  // separators are being traversed backwards. We'll therefore
905  // insert this at the beginning of the daughter graphs
906  // vector.
907  MultiLevelBisectedGraphSharedPtr tmp = graphs[treetab[i]];
908  std::vector<MultiLevelBisectedGraphSharedPtr> &daughters =
909  tmp->GetDaughterGraphs();
910  daughters.insert(daughters.begin(), graphs[i]);
911  }
912 
913  // Change permutations from Scotch to account for initial offset
914  // in case we had partition vertices.
915  for (i = 0; i < nGraphVerts; ++i)
916  {
917  if (partVerts.count(i) == 0)
918  {
919  iperm[i] = iperm_tmp[initial_perm[i]];
920  perm[iperm[i]] = i;
921  }
922  }
923 
924  auto it = partVerts.begin(), it2 = partVerts.end();
925  for (i = nNonPartition; it != it2; ++it, ++i)
926  {
927  perm [i] = *it;
928  iperm[*it] = i;
929  }
930 
931  for (i = 0; i < nGraphVerts; ++i)
932  {
933  ASSERTL1(perm[iperm[i]] == i, "Perm error "
934  + std::to_string(i));
935  }
936 
937  // If we were passed a graph with disconnected regions, we need
938  // to create a bisected graph with the appropriate roots.
939  std::vector<int> rootBlocks;
940  for (i = 0; i < cblknbr; ++i)
941  {
942  if (treetab[i] == -1)
943  {
944  rootBlocks.push_back(i);
945  }
946  }
947 
948  MultiLevelBisectedGraphSharedPtr root;
949  if (rootBlocks.size() == 1)
950  {
951  root = graphs[rootBlocks[0]];
952  }
953  else
954  {
955  root = MemoryManager<MultiLevelBisectedGraph>
956  ::AllocateSharedPtr(0);
957 
958  for (int i = 0; i < rootBlocks.size(); ++i)
959  {
960  root->GetDaughterGraphs().push_back(graphs[rootBlocks[i]]);
961  }
962  }
963 
964  // Check that our degree of freedom count in the constructed
965  // graph is the same as the number of degrees of freedom that we
966  // were given in the function input.
967  ASSERTL0(root->GetTotDofs() == nNonPartition,
968  "Error in constructing Scotch graph for multi-level"
969  " static condensation.");
970 
971  //
972  // Step 4: Set up the bottom-up graph from the top-down graph,
973  // and reorder the permutation from Scotch.
974  //
975  substructgraph = MemoryManager<BottomUpSubStructuredGraph>::
976  AllocateSharedPtr(root, nPartition, true);
977 
978  // Important: we cannot simply use the ordering given by Scotch
979  // as it does not order the different blocks as we would like
980  // it. Therefore, we use following command to re-order them
981  // again in the context of the bottom-up substructuring. As a
982  // result, we will now obtain an ordering where the interior
983  // degrees of freedom of the first (=bottom) level will be
984  // ordered last (block by block ofcoarse). The interior degrees
985  // of freedom of the second level will be ordered second to
986  // last, etc ... As a result, the boundary degrees of freedom of
987  // the last level (i.e. the dofs that will have to solved
988  // non-recursively) will be ordered first (after the Dirichlet
989  // Dofs that is). (this way, we actually follow the same idea
990  // and convention in the standard (non-multi-level) static
991  // condensation approach).
992  substructgraph->UpdateBottomUpReordering(perm,iperm);
993  }
994  else
995  {
996  // This is the very special case of a graph without any
997  // connectivity i.e. a collection of vertices without any edges
998  for(int i = 0; i < nGraphVerts; i++)
999  {
1000  perm[i] = i;
1001  iperm[i] = i;
1002  }
1003  substructgraph = MemoryManager<BottomUpSubStructuredGraph>::
1004  AllocateSharedPtr(nGraphVerts);
1005  }
1006 #endif
1007  }
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:216
SCOTCH_CALL
#define SCOTCH_CALL(scotchFunc, args)
Definition: MeshPartitionPtScotch.cpp:42
Nektar::MultiRegions::MultiLevelBisectedGraphSharedPtr
std::shared_ptr< MultiLevelBisectedGraph > MultiLevelBisectedGraphSharedPtr
Definition: SubStructuredGraph.h:66
ASSERTL1
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:250

◆ NoReordering()

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

Definition at line 1009 of file SubStructuredGraph.cpp.

References ASSERTL1.

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

1012  {
1013  int nGraphVerts = boost::num_vertices(graph);
1014 
1015  ASSERTL1(perm. num_elements() >= nGraphVerts &&
1016  iperm.num_elements() >= nGraphVerts,
1017  "Non-matching dimensions");
1018 
1019  for (int i = 0; i < nGraphVerts; i++)
1020  {
1021  perm [i] = i;
1022  iperm[i] = i;
1023  }
1024  }
ASSERTL1
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:250

◆ operator<() [1/2]

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

Definition at line 79 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.

80  {
81  if(lhs.m_matrixType < rhs.m_matrixType)
82  {
83  return true;
84  }
85 
86  if(lhs.m_matrixType > rhs.m_matrixType)
87  {
88  return false;
89  }
90 
91 
92  if(lhs.m_shapeType < rhs.m_shapeType)
93  {
94  return true;
95  }
96 
97 
98  if(lhs.m_shapeType > rhs.m_shapeType)
99  {
100  return false;
101  }
102 
103  if(lhs.m_constFactors.size() < rhs.m_constFactors.size())
104  {
105  return true;
106  }
107  else if(lhs.m_constFactors.size() > rhs.m_constFactors.size())
108  {
109  return false;
110  }
111  else
112  {
113  StdRegions::ConstFactorMap::const_iterator x, y;
114  for(x = lhs.m_constFactors.begin(), y = rhs.m_constFactors.begin();
115  x != lhs.m_constFactors.end(); ++x, ++y)
116  {
117  if (x->second < y->second)
118  {
119  return true;
120  }
121  if (x->second > y->second)
122  {
123  return false;
124  }
125  }
126  }
127 
128  if(lhs.m_varCoeffs.size() < rhs.m_varCoeffs.size())
129  {
130  return true;
131  }
132  else if(lhs.m_varCoeffs.size() > rhs.m_varCoeffs.size())
133  {
134  return false;
135  }
136 // else
137 // {
138 // StdRegions::VarCoeffMap::const_iterator x, y;
139 // for (x = lhs.m_varCoeffs.begin(), y = rhs.m_varCoeffs.begin();
140 // x != lhs.m_varCoeffs.end(); ++x, ++y)
141 // {
142 // if (x->second.get() < y->second.get())
143 // {
144 // return true;
145 // }
146 // if (x->second.get() > y->second.get())
147 // {
148 // return false;
149 // }
150 // }
151 // }
152 
153  if(!rhs.m_locToGloMap.lock().get())
154  {
155  return false;
156  }
157  else if(!lhs.m_locToGloMap.lock().get() && rhs.m_locToGloMap.lock().get() )
158  {
159  return true;
160  }
161  if(lhs.m_locToGloMap.lock()->GetHash() < rhs.m_locToGloMap.lock()->GetHash())
162  {
163  return true;
164  }
165 
166  return false;
167  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ operator<() [2/2]

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

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

Parameters
lhsFirst operand.
rhsSecond operand.
Returns
true if the first operand is considered less than the second operand.

Definition at line 109 of file GlobalLinSysKey.cpp.

References Nektar::MultiRegions::GlobalLinSysKey::m_solnType, Nektar::MultiRegions::GlobalLinSysKey::m_varFactors, Nektar::MultiRegions::GlobalLinSysKey::m_varFactors_hashes, and Nektar::rhs.

110  {
111  if(lhs.m_solnType < rhs.m_solnType)
112  {
113  return true;
114  }
115 
116  if(lhs.m_solnType > rhs.m_solnType)
117  {
118  return false;
119  }
120 
121  if(lhs.m_varFactors.size() < rhs.m_varFactors.size())
122  {
123  return true;
124  }
125 
126  if(lhs.m_varFactors.size() > rhs.m_varFactors.size())
127  {
128  return false;
129  }
130 
131  for (unsigned int i = 0; i < lhs.m_varFactors_hashes.size(); ++i)
132  {
133  if(lhs.m_varFactors_hashes[i] < rhs.m_varFactors_hashes[i])
134  {
135  return true;
136  }
137  if(lhs.m_varFactors_hashes[i] > rhs.m_varFactors_hashes[i])
138  {
139  return false;
140  }
141  }
142 
143  return (*dynamic_cast<const GlobalMatrixKey*>(&lhs)
144  < *dynamic_cast<const GlobalMatrixKey*>(&rhs));
145  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ 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
osOutput stream.
rhsGlobalLinSys object to use.
Returns
Reference to the output stream os.

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

155  {
156  os << "MatrixType: " << StdRegions::MatrixTypeMap[rhs.GetMatrixType()] << ", ShapeType: "
157  << LibUtilities::ShapeTypeMap[rhs.GetShapeType()]
158  << std::endl;
159  os << "Solution Type: "
160  << GlobalSysSolnTypeMap[rhs.GetGlobalSysSolnType()] << endl;
161  os << "Number of constants: " << rhs.GetNConstFactors() << endl;
162  for (auto &x : rhs.GetConstFactors())
163  {
164  os << " Constant " << StdRegions::ConstFactorTypeMap[x.first]
165  << ": " << x.second << endl;
166  }
167  os << "Number of variable coefficients: "
168  << rhs.GetNVarCoeffs() << endl;
169 
170  os << "Number of variable factors : "
171  << rhs.GetNVarFactors() << endl;
172 
173  return os;
174  }
Nektar::StdRegions::ConstFactorTypeMap
const char *const ConstFactorTypeMap[]
Definition: StdRegions.hpp:282
Nektar::LibUtilities::ShapeTypeMap
const char *const ShapeTypeMap[]
Definition: ShapeType.hpp:67
Nektar::MultiRegions::GlobalSysSolnTypeMap
const char *const GlobalSysSolnTypeMap[]
Definition: MultiRegions.hpp:95
Nektar::StdRegions::MatrixTypeMap
const char *const MatrixTypeMap[]
Definition: StdRegions.hpp:149
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

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

170  {
171  os << "MatrixType: " << rhs.GetMatrixType() << endl;
172  os << "Number of constants: " << rhs.GetNConstFactors() << endl;
173  for(auto &x : rhs.GetConstFactors())
174  {
175  os << " Constant " << StdRegions::ConstFactorTypeMap[x.first]
176  << ": " << x.second << endl;
177  }
178  os << "Number of variable coefficients: "
179  << rhs.GetNVarCoeffs() << endl;
180 
181  return os;
182  }
Nektar::StdRegions::ConstFactorTypeMap
const char *const ConstFactorTypeMap[]
Definition: StdRegions.hpp:282
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ RoundNekDoubleToInt() [1/2]

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

Rounds a double precision number to an integer.

Definition at line 58 of file AssemblyMap.cpp.

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

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

◆ RoundNekDoubleToInt() [2/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 64 of file AssemblyMap.cpp.

References ASSERTL1.

65  {
66  int size = inarray.num_elements();
67  ASSERTL1(outarray.num_elements()>=size,"Array sizes not compatible");
68 
69  NekDouble x;
70  for(int i = 0; i < size; i++)
71  {
72  x = inarray[i];
73  outarray[i] = int(x > 0.0 ? x + 0.5 : x - 0.5);
74  }
75  }
Nektar::NekDouble
double NekDouble
Definition: NektarUnivTypeDefs.hpp:43
ASSERTL1
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:250

◆ SubGraphWithoutVerts()

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

Definition at line 661 of file SubStructuredGraph.cpp.

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

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

Variable Documentation

◆ DirCartesianMap

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

Definition at line 88 of file ExpList.h.

Referenced by Nektar::GlobalMapping::MappingGeneral::CalculateChristoffel(), Nektar::GlobalMapping::MappingXYofXY::CalculateChristoffel(), Nektar::SolverUtils::FilterAeroForces::CalculateForcesMapping(), Nektar::SolverUtils::ForcingMovingReferenceFrame::CalculateGradient(), Nektar::GlobalMapping::MappingGeneral::CalculateMetricTerms(), Nektar::NonlinearSWE::DoOdeRhs(), Nektar::LinearSWE::DoOdeRhs(), Nektar::VCSMapping::MappingAccelerationCorrection(), Nektar::FieldUtils::ProcessStreamFunction::Process(), Nektar::FieldUtils::ProcessGrad::Process(), Nektar::CoupledLinearNS::SetUpCoupledMatrix(), Nektar::LEE::v_AddLinTerm(), 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::ForcingQuasi1D::v_InitObject(), 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(), and Nektar::GlobalMapping::Mapping::v_VelocityLaplacian().

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

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

◆ LocalMatrixStorageStrategyMap

const char* const Nektar::MultiRegions::LocalMatrixStorageStrategyMap[]
Initial value:
=
{
"Contiguous",
"Non-contiguous",
"Sparse"
}

Definition at line 62 of file GlobalLinSysIterativeStaticCond.h.

◆ MatrixStorageTypeMap

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

Definition at line 152 of file MultiRegions.hpp.

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

◆ NullAssemblyMapSharedPtr

AssemblyMapSharedPtr Nektar::MultiRegions::NullAssemblyMapSharedPtr
static

Definition at line 54 of file AssemblyMap.h.

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

◆ NullExpList

ExpList Nektar::MultiRegions::NullExpList
static

An empty ExpList object.

Definition at line 1549 of file ExpList.h.

◆ NullExpList0DSharedPtrArray

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

Empty ExpList0D object.

Definition at line 103 of file ExpList0D.h.

◆ NullExpList1DSharedPtrArray

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

Empty ExpList1D object.

Definition at line 204 of file ExpList1D.h.

◆ NullExpList2DSharedPtrArray

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

Empty ExpList2D object.

Definition at line 168 of file ExpList2D.h.

◆ NullExpListSharedPtr

ExpListSharedPtr Nektar::MultiRegions::NullExpListSharedPtr
static

Definition at line 1550 of file ExpList.h.

Referenced by Nektar::SolverUtils::EquationSystem::GetSession(), 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().

◆ NullExpListSharedPtrArray

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

Definition at line 2449 of file ExpList.h.

◆ NullIntIntMap

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

Definition at line 48 of file AssemblyMapCG.h.

◆ NullPeriodicMap

PeriodicMap Nektar::MultiRegions::NullPeriodicMap
static

Definition at line 201 of file MultiRegions.hpp.

◆ NullPreconditionerSharedPtr

PreconditionerSharedPtr Nektar::MultiRegions::NullPreconditionerSharedPtr
static

Definition at line 57 of file Preconditioner.h.

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

◆ NullVarFactorsMap

VarFactorsMap Nektar::MultiRegions::NullVarFactorsMap
static

Definition at line 47 of file GlobalLinSysKey.h.

Referenced by Nektar::VCSWeakPressure::v_SolvePressure(), and Nektar::VelocityCorrectionScheme::v_SolveViscous().

◆ NullVecIntIntMap

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

Definition at line 49 of file AssemblyMapCG.h.

◆ PreconditionerTypeMap

const char* const Nektar::MultiRegions::PreconditionerTypeMap[]
Initial value:
=
{
"Null",
"Diagonal",
"FullLinearSpaceWithDiagonal",
"FullLinearSpace",
"LowEnergyBlock",
"FullLinearSpaceWithLowEnergyBlock",
"Block",
"FullLinearSpaceWithBlock"
}

Definition at line 132 of file MultiRegions.hpp.

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

Generated on Wed Jan 20 2021 03:34:04 for Nektar++ by   doxygen 1.8.13