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

Classes

class  ExchangeMethod
 
class  Serial
 
class  AllToAll
 
class  AllToAllV
 
class  NeighborAllToAllV
 
class  Pairwise
 
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  InterfaceTrace
 
class  InterfaceExchange
 
class  InterfaceMapDG
 
struct  cmpop
 
class  LocTraceToTraceMap
 A helper class to deal with trace operations in the discontinuous Galerkin code. More...
 
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  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...
 
struct  RobinBCInfo
 
struct  PeriodicEntity
 
struct  RotPeriodicInfo
 
class  Preconditioner
 
class  PreconditionerBlock
 
class  PreconditionerDiagonal
 
class  PreconditionerNull
 
class  PreconditionerLinear
 
class  PreconditionerLinearWithBlock
 
class  PreconditionerLinearWithDiag
 
class  PreconditionerLinearWithLowEnergy
 
class  PreconditionerLowEnergy
 
class  PatchMap
 
class  SubGraph
 
class  MultiLevelBisectedGraph
 
class  BottomUpSubStructuredGraph
 

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. 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< 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. More...
 
typedef std::shared_ptr< BlockMatrixMap > BlockMatrixMapShPtr
 A shared pointer to a BlockMatrixMap. 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< ExpList2DHomogeneous2D > ExpList2DHomogeneous2DSharedPtr
 Shared pointer to an ExpList2DHomogeneous2D object. More...
 
typedef std::vector< ExpList2DHomogeneous2DSharedPtr > ExpList2DHomogeneous2DVector
 Vector of pointers to ExpList2DHomogeneous2D 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< GJPStabilisation > GJPStabilisationSharedPtr
 
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  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  LinSysIterSolver { eNoLinSysIterSolver , eConjugateGradient , eGMRES }
 
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...
 
static GlobalLinSysKey NullGlobalLinSysKey (StdRegions::eNoMatrixType)
 
GlobalLinSysFactory & GetGlobalLinSysFactory ()
 
GlobalVecLinSysFactory & GetGlobalVecLinSysFactory ()
 
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
 
static LocTraceToTraceMapSharedPtr NullLocTraceToTraceMapSharedPtr
 
MultiRegions::Direction const DirCartesianMap [] = {eX, eY, eZ}
 
static ExpList NullExpList
 An empty ExpList object. More...
 
static ExpListSharedPtr NullExpListSharedPtr
 
static LibUtilities::NekManager< GlobalLinSysKey, GlobalLinSys > NullGlobalLinSysManager
 
static const Array< OneD, ExpListSharedPtr > NullExpListSharedPtrArray
 
const char *const LocalMatrixStorageStrategyMap []
 
static VarFactorsMap NullVarFactorsMap
 
const char *const GlobalSysSolnTypeMap []
 
const char *const PreconditionerTypeMap []
 
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 302 of file AssemblyCommDG.h.

◆ AssemblyMapCGSharedPtr

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

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

◆ BlockMatrixMapShPtr

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

A shared pointer to a BlockMatrixMap.

Definition at line 97 of file ExpList.h.

◆ BndTypesVector

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

Definition at line 149 of file MultiRegions.hpp.

◆ BndTypesVectorIter

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

Definition at line 151 of file MultiRegions.hpp.

◆ BottomUpSubStructuredGraphSharedPtr

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

Definition at line 62 of file SubStructuredGraph.h.

◆ ContField3DHomogeneous1DSharedPtr

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

Definition at line 105 of file ContField3DHomogeneous1D.h.

◆ ContField3DHomogeneous2DSharedPtr

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

Definition at line 98 of file ContField3DHomogeneous2D.h.

◆ ContFieldSharedPtr

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

Definition at line 289 of file ContField.h.

◆ DisContField3DHomogeneous1DSharedPtr

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

Definition at line 219 of file DisContField3DHomogeneous1D.h.

◆ DisContField3DHomogeneous2DSharedPtr

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

Definition at line 138 of file DisContField3DHomogeneous2D.h.

◆ DisContFieldSharedPtr

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

Definition at line 341 of file DisContField.h.

◆ DofGraph

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

Definition at line 55 of file AssemblyMapCG.h.

◆ ExchangeMethodSharedPtr

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

Definition at line 75 of file AssemblyCommDG.h.

◆ ExpList2DHomogeneous1DSharedPtr

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

Shared pointer to an ExpList2DHomogeneous1D object.

Definition at line 52 of file ExpList2DHomogeneous1D.h.

◆ ExpList2DHomogeneous1DVector

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

Vector of pointers to ExpList2DHomogeneous1D objects.

Definition at line 55 of file ExpList2DHomogeneous1D.h.

◆ ExpList2DHomogeneous2DSharedPtr

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

Shared pointer to an ExpList2DHomogeneous2D object.

Definition at line 52 of file ExpList2DHomogeneous2D.h.

◆ ExpList2DHomogeneous2DVector

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

Vector of pointers to ExpList2DHomogeneous2D objects.

Definition at line 55 of file ExpList2DHomogeneous2D.h.

◆ ExpList3DHomogeneous1DSharedPtr

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

Shared pointer to an ExpList3DHomogeneous1D object.

Definition at line 54 of file ExpList3DHomogeneous1D.h.

◆ ExpList3DHomogeneous1DVector

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

Vector of pointers to ExpList3DHomogeneous1D objects.

Definition at line 57 of file ExpList3DHomogeneous1D.h.

◆ ExpList3DHomogeneous2DSharedPtr

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

Shared pointer to an ExpList3DHomogeneous2D object.

Definition at line 52 of file ExpList3DHomogeneous2D.h.

◆ ExpList3DHomogeneous2DVector

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

Vector of pointers to ExpList3DHomogeneous2D objects.

Definition at line 55 of file ExpList3DHomogeneous2D.h.

◆ ExpListHomogeneous1DSharedPtr

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

Shared pointer to an ExpList3DHomogeneous1D object.

Definition at line 69 of file ExpListHomogeneous1D.h.

◆ ExpListHomogeneous1DVector

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

Vector of pointers to ExpList3DHomogeneous1D objects.

Definition at line 71 of file ExpListHomogeneous1D.h.

◆ ExpListHomogeneous2DSharedPtr

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

Shared pointer to an ExpList3DHomogeneous2D object.

Definition at line 73 of file ExpListHomogeneous2D.h.

◆ ExpListHomogeneous2DVector

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

Vector of pointers to ExpList3DHomogeneous2D objects.

Definition at line 75 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 53 of file AssemblyMapCG.h.

◆ GJPStabilisationSharedPtr

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

Definition at line 104 of file GJPStabilisation.h.

◆ GlobalLinSysDirectStaticCondSharedPtr

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

Definition at line 50 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 51 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 51 of file GlobalLinSysPETScStaticCond.h.

◆ GlobalLinSysSharedPtr

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

Pointer to a GlobalLinSys object.

Definition at line 53 of file GlobalLinSys.h.

◆ GlobalLinSysStaticCondSharedPtr

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

Definition at line 52 of file GlobalLinSysStaticCond.h.

◆ GlobalLinSysXxtStaticCondSharedPtr

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

Definition at line 54 of file GlobalLinSysXxtStaticCond.h.

◆ GlobalMatrixKeySharedPtr

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

A pointer to a GlobalMatrixKey.

Definition at line 116 of file GlobalMatrixKey.h.

◆ GlobalMatrixMap

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

Mapping from global matrix keys to global matrices.

Definition at line 88 of file GlobalMatrix.h.

◆ GlobalMatrixMapShPtr

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

Shared pointer to a global matrix map.

Definition at line 90 of file GlobalMatrix.h.

◆ GlobalMatrixSharedPtr

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

Shared pointer to a GlobalMatrix object.

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

◆ Homo1DBlockMatrixMapShPtr

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

A shared pointer to a BlockMatrixMap.

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

◆ Homo2DBlockMatrixMapShPtr

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

A shared pointer to a BlockMatrixMap.

Definition at line 67 of file ExpListHomogeneous2D.h.

◆ InterfaceExchangeSharedPtr

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

Definition at line 216 of file InterfaceMapDG.h.

◆ InterfaceMapDGSharedPtr

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

Definition at line 269 of file InterfaceMapDG.h.

◆ InterfaceTraceSharedPtr

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

Definition at line 103 of file InterfaceMapDG.h.

◆ LocTraceToTraceMapSharedPtr

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

Definition at line 412 of file LocTraceToTraceMap.h.

◆ MultiLevelBisectedGraphSharedPtr

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

Definition at line 65 of file SubStructuredGraph.h.

◆ PatchMapSharedPtr

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

Definition at line 66 of file SubStructuredGraph.h.

◆ PeriodicMap

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

Definition at line 191 of file MultiRegions.hpp.

◆ PreconditionerBlockSharedPtr

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

Definition at line 48 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 47 of file PreconditionerLinearWithBlock.h.

◆ PreconditionerLinearWithDiagSharedPtr

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

Definition at line 49 of file PreconditionerLinearWithDiag.h.

◆ PreconditionerLinearWithLowEnergySharedPtr

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

Definition at line 47 of file PreconditionerLinearWithLowEnergy.h.

◆ PreconditionerLowEnergySharedPtr

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

Definition at line 51 of file PreconditionerLowEnergy.h.

◆ PreconditionerNullSharedPtr

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

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

◆ RobinBCInfoSharedPtr

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

Definition at line 169 of file MultiRegions.hpp.

◆ SubGraphSharedPtr

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

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

◆ VarFactorsMap

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

Definition at line 47 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 56 of file MultiRegions.hpp.

57 {
58  eAdjacentFaceDir1FwdDir1_Dir2FwdDir2,
59  eAdjacentFaceDir1FwdDir1_Dir2BwdDir2,
60  eAdjacentFaceDir1BwdDir1_Dir2FwdDir2,
61  eAdjacentFaceDir1BwdDir1_Dir2BwdDir2,
62  eAdjacentFaceDir1FwdDir2_Dir2FwdDir1,
63  eAdjacentFaceDir1FwdDir2_Dir2BwdDir1,
64  eAdjacentFaceDir1BwdDir2_Dir2FwdDir1,
65  eAdjacentFaceDir1BwdDir2_Dir2BwdDir1
66 };

◆ AdjacentTraceOrientation

enum Nektar::MultiRegions::AdjacentTraceOrientation
Enumerator
eAdjacentEdgeIsForwards 
eAdjacentEdgeIsBackwards 

Definition at line 48 of file MultiRegions.hpp.

49 {
50  eAdjacentEdgeIsForwards,
51  eAdjacentEdgeIsBackwards
52 };

◆ Direction

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

Definition at line 70 of file ExpList.h.

71 {
72  eX,
73  eY,
74  eZ,
75  eS,
76  eN
77 };

◆ ExpansionType

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

Definition at line 79 of file ExpList.h.

80 {
81  e0D,
82  e1D,
83  e2D,
84  e2DH1D,
85  e3DH1D,
86  e3DH2D,
87  e3D,
88  eNoType
89 };

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

69 {
70  eNoSolnType, ///< No Solution type specified
71  eDirectFullMatrix,
72  eDirectStaticCond,
73  eDirectMultiLevelStaticCond,
74  eIterativeFull,
75  eIterativeStaticCond,
76  eIterativeMultiLevelStaticCond,
77  eXxtFullMatrix,
78  eXxtStaticCond,
79  eXxtMultiLevelStaticCond,
80  ePETScFullMatrix,
81  ePETScStaticCond,
82  ePETScMultiLevelStaticCond,
83  eSIZE_GlobalSysSolnType
84 };
Nektar::MultiRegions::eNoSolnType
@ eNoSolnType
No Solution type specified.
Definition: MultiRegions.hpp:70

◆ 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 47 of file PreconditionerLinear.h.

48 {
49  eLinearPreconXxt,
50  eLinearPreconPETSc
51 };

◆ LinSysIterSolver

enum Nektar::MultiRegions::LinSysIterSolver
Enumerator
eNoLinSysIterSolver 

No Solution type specified.

eConjugateGradient 
eGMRES 

Definition at line 130 of file MultiRegions.hpp.

131 {
132  eNoLinSysIterSolver, ///< No Solution type specified
133  eConjugateGradient,
134  eGMRES
135 };
Nektar::MultiRegions::eNoLinSysIterSolver
@ eNoLinSysIterSolver
No Solution type specified.
Definition: MultiRegions.hpp:132

◆ LocalMatrixStorageStrategy

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

Definition at line 53 of file GlobalLinSysIterativeStaticCond.h.

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

◆ MatrixStorageType

enum Nektar::MultiRegions::MatrixStorageType
Enumerator
eSmvBSR 

Definition at line 142 of file MultiRegions.hpp.

143 {
144  eSmvBSR
145 };

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

109 {
110  eNull, ///< No Solution type specified
111  eDiagonal,
112  eLinearWithDiagonal,
113  eLinear,
114  eLowEnergy,
115  eLinearWithLowEnergy,
116  eBlock,
117  eLinearWithBlock
118 };
Nektar::MultiRegions::eNull
@ eNull
No Solution type specified.
Definition: MultiRegions.hpp:110

◆ ProjectionType

enum Nektar::MultiRegions::ProjectionType

Type of Galerkin projection.

Enumerator
eGalerkin 
eDiscontinuous 
eMixed_CG_Discontinuous 

Definition at line 101 of file MultiRegions.hpp.

102 {
103  eGalerkin,
104  eDiscontinuous,
105  eMixed_CG_Discontinuous
106 };

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 3948 of file ExpList.cpp.

3951 {
3952  // Copy transpose.
3953  if (orient == StdRegions::eDir1FwdDir2_Dir2FwdDir1 ||
3954  orient == StdRegions::eDir1BwdDir2_Dir2FwdDir1 ||
3955  orient == StdRegions::eDir1FwdDir2_Dir2BwdDir1 ||
3956  orient == StdRegions::eDir1BwdDir2_Dir2BwdDir1)
3957  {
3958  for (int i = 0; i < nquad2; ++i)
3959  {
3960  for (int j = 0; j < nquad1; ++j)
3961  {
3962  out[i * nquad1 + j] = in[j * nquad2 + i];
3963  }
3964  }
3965  }
3966  else
3967  {
3968  for (int i = 0; i < nquad2; ++i)
3969  {
3970  for (int j = 0; j < nquad1; ++j)
3971  {
3972  out[i * nquad1 + j] = in[i * nquad1 + j];
3973  }
3974  }
3975  }
3976 
3977  if (orient == StdRegions::eDir1BwdDir1_Dir2FwdDir2 ||
3978  orient == StdRegions::eDir1BwdDir1_Dir2BwdDir2 ||
3979  orient == StdRegions::eDir1BwdDir2_Dir2FwdDir1 ||
3980  orient == StdRegions::eDir1BwdDir2_Dir2BwdDir1)
3981  {
3982  // Reverse x direction
3983  for (int i = 0; i < nquad2; ++i)
3984  {
3985  for (int j = 0; j < nquad1 / 2; ++j)
3986  {
3987  swap(out[i * nquad1 + j], out[i * nquad1 + nquad1 - j - 1]);
3988  }
3989  }
3990  }
3991 
3992  if (orient == StdRegions::eDir1FwdDir1_Dir2BwdDir2 ||
3993  orient == StdRegions::eDir1BwdDir1_Dir2BwdDir2 ||
3994  orient == StdRegions::eDir1FwdDir2_Dir2BwdDir1 ||
3995  orient == StdRegions::eDir1BwdDir2_Dir2BwdDir1)
3996  {
3997  // Reverse y direction
3998  for (int j = 0; j < nquad1; ++j)
3999  {
4000  for (int i = 0; i < nquad2 / 2; ++i)
4001  {
4002  swap(out[i * nquad1 + j], out[(nquad2 - i - 1) * nquad1 + j]);
4003  }
4004  }
4005  }
4006 }

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::ExpList::GetElmtNormalLength().

◆ CuthillMckeeReordering()

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

Definition at line 684 of file SubStructuredGraph.cpp.

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

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

2226 {
2227  int minId = periodicEdges[0].id;
2228  int minIdK = 0;
2229  int k;
2230 
2231  for (k = 1; k < periodicEdges.size(); ++k)
2232  {
2233  if (periodicEdges[k].id < minId)
2234  {
2235  minId = min(minId, periodicEdges[k].id);
2236  minIdK = k;
2237  }
2238  }
2239 
2240  minId = min(minId, meshEdgeId);
2241 
2242  if (meshEdgeId != minId)
2243  {
2244  if (periodicEdges[minIdK].orient == StdRegions::eBackwards)
2245  {
2246  // Swap edge orientation
2247  edgeOrient = (edgeOrient == StdRegions::eForwards)
2248  ? StdRegions::eBackwards
2249  : StdRegions::eForwards;
2250  }
2251  }
2252 
2253  return make_pair(minId, edgeOrient);
2254 }

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

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

2273 {
2274  StdRegions::Orientation returnval = faceOrient;
2275 
2276  if (perFaceOrient != StdRegions::eDir1FwdDir1_Dir2FwdDir2)
2277  {
2278  int tmp1 = (int)faceOrient - 5;
2279  int tmp2 = (int)perFaceOrient - 5;
2280 
2281  int flipDir1Map[8] = {2, 3, 0, 1, 6, 7, 4, 5};
2282  int flipDir2Map[8] = {1, 0, 3, 2, 5, 4, 7, 6};
2283  int transposeMap[8] = {4, 5, 6, 7, 0, 2, 1, 3};
2284 
2285  // Transpose orientation
2286  if (tmp2 > 3)
2287  {
2288  tmp1 = transposeMap[tmp1];
2289  }
2290 
2291  // Reverse orientation in direction 1.
2292  if (tmp2 == 2 || tmp2 == 3 || tmp2 == 6 || tmp2 == 7)
2293  {
2294  tmp1 = flipDir1Map[tmp1];
2295  }
2296 
2297  // Reverse orientation in direction 2
2298  if (tmp2 % 2 == 1)
2299  {
2300  tmp1 = flipDir2Map[tmp1];
2301  }
2302 
2303  returnval = (StdRegions::Orientation)(tmp1 + 5);
2304  }
2305  return returnval;
2306 }

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 202 of file GlobalLinSys.cpp.

203 {
204  static GlobalLinSysFactory instance;
205  return instance;
206 }
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

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

◆ GetGlobalVecLinSysFactory()

GlobalVecLinSysFactory& Nektar::MultiRegions::GetGlobalVecLinSysFactory ( )

Definition at line 69 of file GlobalLinSysBlockDiagonal.cpp.

70 {
71  static GlobalVecLinSysFactory instance;
72  return instance;
73 }

◆ GetPreconFactory()

PreconFactory & Nektar::MultiRegions::GetPreconFactory ( )

Definition at line 86 of file Preconditioner.cpp.

87 {
88  static PreconFactory instance;
89  return instance;
90 }
Nektar::MultiRegions::PreconFactory
LibUtilities::NekFactory< std::string, Preconditioner, const std::shared_ptr< GlobalLinSys > &, const std::shared_ptr< AssemblyMap > & > PreconFactory
Definition: Preconditioner.h:62

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

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

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

1010 {
1011  int nGraphVerts = boost::num_vertices(graph);
1012 
1013  ASSERTL1(perm.size() >= nGraphVerts && iperm.size() >= nGraphVerts,
1014  "Non-matching dimensions");
1015 
1016  for (int i = 0; i < nGraphVerts; i++)
1017  {
1018  perm[i] = i;
1019  iperm[i] = i;
1020  }
1021 }

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::ExpList::v_HelmSolve(), Nektar::MultiRegions::ContField3DHomogeneous1D::v_HelmSolve(), Nektar::MultiRegions::ContField3DHomogeneous2D::v_HelmSolve(), Nektar::MultiRegions::DisContField::v_HelmSolve(), Nektar::MultiRegions::DisContField3DHomogeneous1D::v_HelmSolve(), Nektar::MultiRegions::DisContField3DHomogeneous2D::v_HelmSolve(), and Nektar::MultiRegions::ExpList::v_LinearAdvectionDiffusionReactionSolve().

◆ 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
lhsFirst operand.
rhsSecond operand.
Returns
true if the first operand is considered less than the second operand.

Definition at line 108 of file GlobalLinSysKey.cpp.

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

◆ operator<() [2/2]

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

Definition at line 72 of file GlobalMatrixKey.cpp.

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

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

153 {
154  os << "MatrixType: " << StdRegions::MatrixTypeMap[rhs.GetMatrixType()]
155  << ", ShapeType: " << LibUtilities::ShapeTypeMap[rhs.GetShapeType()]
156  << std::endl;
157  os << "Solution Type: " << GlobalSysSolnTypeMap[rhs.GetGlobalSysSolnType()]
158  << endl;
159  os << "Number of constants: " << rhs.GetNConstFactors() << endl;
160  for (auto &x : rhs.GetConstFactors())
161  {
162  os << " Constant " << StdRegions::ConstFactorTypeMap[x.first] << ": "
163  << x.second << endl;
164  }
165  os << "Number of variable coefficients: " << rhs.GetNVarCoeffs() << endl;
166 
167  os << "Number of variable factors : " << rhs.GetNVarFactors() << endl;
168 
169  return os;
170 }
Nektar::LibUtilities::ShapeTypeMap
const char *const ShapeTypeMap[SIZE_ShapeType]
Definition: ShapeType.hpp:79
Nektar::MultiRegions::GlobalSysSolnTypeMap
const char *const GlobalSysSolnTypeMap[]
Definition: MultiRegions.hpp:86
Nektar::StdRegions::ConstFactorTypeMap
const char *const ConstFactorTypeMap[]
Definition: StdRegions.hpp:382
Nektar::StdRegions::MatrixTypeMap
const char *const MatrixTypeMap[]
Definition: StdRegions.hpp:143

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 161 of file GlobalMatrixKey.cpp.

162 {
163  os << "MatrixType: " << rhs.GetMatrixType() << endl;
164  os << "Number of constants: " << rhs.GetNConstFactors() << endl;
165  for (auto &x : rhs.GetConstFactors())
166  {
167  os << " Constant " << StdRegions::ConstFactorTypeMap[x.first] << ": "
168  << x.second << endl;
169  }
170  os << "Number of variable coefficients: " << rhs.GetNVarCoeffs() << endl;
171 
172  return os;
173 }

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

66 {
67  int size = inarray.size();
68  ASSERTL1(outarray.size() >= size, "Array sizes not compatible");
69 
70  NekDouble x;
71  for (int i = 0; i < size; i++)
72  {
73  x = inarray[i];
74  outarray[i] = int(x > 0.0 ? x + 0.5 : x - 0.5);
75  }
76 }
Nektar::NekDouble
double NekDouble
Definition: NektarUnivTypeDefs.hpp:43

References ASSERTL1.

◆ RoundNekDoubleToInt() [2/2]

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

Rounds a double precision number to an integer.

Definition at line 58 of file AssemblyMap.cpp.

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

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

◆ SubGraphWithoutVerts()

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

Definition at line 667 of file SubStructuredGraph.cpp.

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

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

Variable Documentation

◆ DirCartesianMap

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

Definition at line 91 of file ExpList.h.

Referenced by Nektar::GlobalMapping::MappingGeneral::CalculateChristoffel(), Nektar::GlobalMapping::MappingXYofXY::CalculateChristoffel(), Nektar::SolverUtils::FilterAeroForces::CalculateForcesMapping(), Nektar::GlobalMapping::MappingGeneral::CalculateMetricTerms(), Nektar::LinearSWE::DoOdeRhs(), Nektar::NonlinearSWE::DoOdeRhs(), Nektar::VCSMapping::MappingAccelerationCorrection(), Nektar::FieldUtils::ProcessGrad::ProcessCartesianFld(), Nektar::FieldUtils::ProcessGrad::ProcessMappingFld(), Nektar::SmoothedProfileMethod::SetUpCorrectionPressure(), Nektar::CoupledLinearNS::SetUpCoupledMatrix(), Nektar::LEE::v_AddLinTerm(), Nektar::AlternateSkewAdvection::v_Advect(), Nektar::NavierStokesAdvection::v_Advect(), Nektar::SkewSymmetricAdvection::v_Advect(), Nektar::MappingExtrapolate::v_CalcNeumannPressureBCs(), Nektar::MappingExtrapolate::v_CorrectPressureBCs(), Nektar::GlobalMapping::Mapping::v_Divergence(), Nektar::VCSMapping::v_DoInitialise(), Nektar::GlobalMapping::Mapping::v_DotGradJacobian(), Nektar::ShallowWaterSystem::v_InitObject(), Nektar::ForcingQuasi1D::v_InitObject(), Nektar::MultiRegions::ExpList::v_PhysDeriv(), Nektar::FieldUtils::ProcessStreamFunction::v_Process(), Nektar::VelocityCorrectionScheme::v_SetUpPressureForcing(), Nektar::VCSMapping::v_SetUpPressureForcing(), Nektar::VCSMapping::v_SolvePressure(), Nektar::GlobalMapping::MappingXofXZ::v_UpdateGeomInfo(), Nektar::GlobalMapping::MappingXofZ::v_UpdateGeomInfo(), Nektar::GlobalMapping::MappingXYofXY::v_UpdateGeomInfo(), Nektar::GlobalMapping::MappingXYofZ::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 86 of file MultiRegions.hpp.

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

◆ LinSysIterSolverMap

const char* const Nektar::MultiRegions::LinSysIterSolverMap[]
Initial value:
= {"NoLinSysIterSolver",
"ConjugateGradient", "GMRES"}

Definition at line 137 of file MultiRegions.hpp.

◆ LocalMatrixStorageStrategyMap

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

Definition at line 61 of file GlobalLinSysIterativeStaticCond.h.

◆ MatrixStorageTypeMap

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

Definition at line 147 of file MultiRegions.hpp.

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

◆ NullAssemblyMapSharedPtr

AssemblyMapSharedPtr Nektar::MultiRegions::NullAssemblyMapSharedPtr
static

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

◆ NullExpListSharedPtr

ExpListSharedPtr Nektar::MultiRegions::NullExpListSharedPtr
static

Definition at line 1479 of file ExpList.h.

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

◆ NullExpListSharedPtrArray

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

Definition at line 2266 of file ExpList.h.

◆ NullGlobalLinSysManager

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

Definition at line 1483 of file ExpList.h.

Referenced by Nektar::MultiRegions::ExpList::v_GetGlobalLinSysManager().

◆ NullIntIntMap

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

Definition at line 48 of file AssemblyMapCG.h.

◆ NullLocTraceToTraceMapSharedPtr

LocTraceToTraceMapSharedPtr Nektar::MultiRegions::NullLocTraceToTraceMapSharedPtr
static

Definition at line 414 of file LocTraceToTraceMap.h.

Referenced by Nektar::MultiRegions::ExpList::v_GetLocTraceToTraceMap().

◆ NullPeriodicMap

PeriodicMap Nektar::MultiRegions::NullPeriodicMap
static

Definition at line 192 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 48 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 120 of file MultiRegions.hpp.

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

Generated on Sat Mar 25 2023 12:35:59 for Nektar++ by doxygen 1.9.1