Nektar::LibUtilities Namespace Reference

Namespaces
namespace	CheckCastUnitTest
namespace	CompressData
namespace	H5
namespace	StdHexData
namespace	StdPrismData
namespace	StdPyrData
namespace	StdQuadData
namespace	StdSegData
namespace	StdTetData
namespace	StdTriData

Classes
class	AdamsBashforthOrder1TimeIntegrationScheme
class	AdamsBashforthOrder2TimeIntegrationScheme
class	AdamsBashforthOrder3TimeIntegrationScheme
class	AdamsBashforthOrder4TimeIntegrationScheme
class	AdamsBashforthTimeIntegrationScheme
class	AdamsMoultonOrder1TimeIntegrationScheme
class	AdamsMoultonOrder2TimeIntegrationScheme
class	AdamsMoultonOrder3TimeIntegrationScheme
class	AdamsMoultonOrder4TimeIntegrationScheme
class	AdamsMoultonTimeIntegrationScheme
class	BackwardEulerTimeIntegrationScheme
class	Basis
	Represents a basis of a given type. More...
class	BasisKey
	Describes the specification for a Basis. More...
class	BDFImplicitOrder1TimeIntegrationScheme
class	BDFImplicitOrder2TimeIntegrationScheme
class	BDFImplicitOrder3TimeIntegrationScheme
class	BDFImplicitOrder4TimeIntegrationScheme
class	BDFImplicitTimeIntegrationScheme
class	BLPoints
class	ClassicalRungeKutta4TimeIntegrationScheme
struct	CmdLineArg
class	CNABTimeIntegrationScheme
class	Comm
	Base communications class. More...
class	CommCwipi
	A global linear system. More...
class	CommDataTypeTraits
class	CommDataTypeTraits< Array< OneD, elemT > >
class	CommDataTypeTraits< std::vector< elemT > >
class	CommMpi
	A global linear system. More...
class	CommRequest
	Class for communicator request type. More...
class	CommRequestMpi
	Class for communicator request type. More...
class	CommSerial
	A global linear system. More...
class	CsvIO
class	DataSource
struct	defOpLessCreator
class	DIRKOrder1TimeIntegrationScheme
class	DIRKOrder2TimeIntegrationScheme
class	DIRKOrder3_ES5TimeIntegrationScheme
class	DIRKOrder3TimeIntegrationScheme
class	DIRKOrder4_ES6TimeIntegrationScheme
class	DIRKTimeIntegrationScheme
struct	DomainRange
class	Equation
class	EulerExponentialTimeIntegrationScheme
class	EulerTimeIntegrationScheme
class	ExplicitTimeIntegrationSchemeSDC
struct	FieldDefinitions
	Metadata that describes the storage properties of field output. More...
class	FieldIO
	Class for operating on Nektar++ input/output files. More...
class	FieldIOHdf5
class	FieldIOXml
class	ForwardEulerTimeIntegrationScheme
class	FourierPoints
class	FourierSingleModePoints
class	FractionalInTimeIntegrationScheme
	Class for fractional-in-time integration. More...
struct	func
struct	functions
struct	FunctionVariableDefinition
class	GaussPoints
class	GitConsts
class	Graph
class	GraphEdgeObject
class	GraphVertexObject
class	H5DataSource
class	H5TagWriter
class	IMEXdirk_1_1_1TimeIntegrationScheme
class	IMEXdirk_1_2_1TimeIntegrationScheme
class	IMEXdirk_1_2_2TimeIntegrationScheme
class	IMEXdirk_2_2_2TimeIntegrationScheme
class	IMEXdirk_2_3_2TimeIntegrationScheme
class	IMEXdirk_2_3_3TimeIntegrationScheme
class	IMEXdirk_3_4_3TimeIntegrationScheme
class	IMEXdirk_4_4_3TimeIntegrationScheme
class	IMEXdirkTimeIntegrationScheme
class	IMEXGearTimeIntegrationScheme
class	IMEXOrder1TimeIntegrationScheme
class	IMEXOrder2TimeIntegrationScheme
class	IMEXOrder3TimeIntegrationScheme
class	IMEXOrder4TimeIntegrationScheme
class	IMEXTimeIntegrationScheme
class	IMEXTimeIntegrationSchemeSDC
class	ImplicitTimeIntegrationSchemeSDC
class	Interpolator
	A class that contains algorithms for interpolation between pts fields, expansions and different meshes. More...
class	Interpreter
	Interpreter class for the evaluation of mathematical expressions. More...
class	MCNABTimeIntegrationScheme
class	NekFactory
	Provides a generic Factory class. More...
class	NekFFTW
class	NekLinSysIter
class	NekLinSysIterCG
class	NekLinSysIterCGLoc
class	NekLinSysIterFixedpointJacobi
class	NekLinSysIterGMRES
class	NekLinSysIterGMRESLoc
class	NekManager
class	NekNonlinSys
class	NekNonlinSysNewton
class	NekSys
class	NekSysKey
class	NekSysOperators
class	NektarFFT
class	NodalHexElec
class	NodalPrismElec
class	NodalPrismEvenlySpaced
class	NodalPrismSPI
class	NodalQuadElec
class	NodalTetElec
class	NodalTetEvenlySpaced
class	NodalTetSPI
class	NodalTriElec
class	NodalTriEvenlySpaced
class	NodalTriFekete
class	NodalTriSPI
class	NodalUtil
	A class to assist in the construction of nodal simplex and hybrid elements in two and three dimensions. More...
class	NodalUtilHex
	Specialisation of the NodalUtil class to support nodal hex elements. More...
class	NodalUtilPrism
	Specialisation of the NodalUtil class to support nodal prismatic elements. More...
class	NodalUtilQuad
	Specialisation of the NodalUtil class to support nodal quad elements. More...
class	NodalUtilTetrahedron
	Specialisation of the NodalUtil class to support nodal tetrahedral elements. More...
class	NodalUtilTriangle
	Specialisation of the NodalUtil class to support nodal triangular elements. More...
class	NoSchemeTimeIntegrationScheme
	Base class for No time integration schemes. More...
class	Points
	Stores a set of points of datatype DataT, defined by a PointKey. More...
class	PointsKey
	Defines a specification for a set of points. More...
class	PolyEPoints
class	PtsField
class	PtsIO
class	RungeKutta1TimeIntegrationScheme
class	RungeKutta2_ImprovedEulerTimeIntegrationScheme
class	RungeKutta2_SSPTimeIntegrationScheme
class	RungeKutta2TimeIntegrationScheme
class	RungeKutta3_SSPTimeIntegrationScheme
class	RungeKutta3TimeIntegrationScheme
class	RungeKutta4TimeIntegrationScheme
class	RungeKutta5TimeIntegrationScheme
class	RungeKuttaTimeIntegrationScheme
class	SessionReader
	Reads and parses information from a Nektar++ XML session file. More...
class	TagWriter
	Base class for writing hierarchical data (XML or HDF5). More...
class	TimeIntegrationAlgorithmGLM
class	TimeIntegrationScheme
	Base class for time integration schemes. More...
class	TimeIntegrationSchemeGEM
	Class for spectral deferred correction integration. More...
class	TimeIntegrationSchemeGLM
	Base class for GLM time integration schemes. More...
class	TimeIntegrationSchemeOperators
	Binds a set of functions for use by time integration schemes. More...
class	TimeIntegrationSchemeSDC
	Class for spectral deferred correction integration. More...
class	TimeIntegrationSolutionGLM
struct	TimeIntScheme
class	Timer
class	Transposition
class	XmlDataSource
class	XmlTagWriter

Typedefs
typedef std::shared_ptr< CsvIO >	CsvIOSharedPtr
typedef std::shared_ptr< DomainRange >	DomainRangeShPtr
typedef std::shared_ptr< Equation >	EquationSharedPtr
typedef std::map< std::string, std::string >	FieldMetaDataMap
typedef std::shared_ptr< TagWriter >	TagWriterSharedPtr
typedef std::shared_ptr< DataSource >	DataSourceSharedPtr
typedef std::shared_ptr< FieldDefinitions >	FieldDefinitionsSharedPtr
typedef LibUtilities::NekFactory< std::string, FieldIO, LibUtilities::CommSharedPtr, bool >	FieldIOFactory
	Datatype of the NekFactory used to instantiate classes. More...
typedef std::shared_ptr< FieldIO >	FieldIOSharedPtr
typedef std::shared_ptr< H5DataSource >	H5DataSourceSharedPtr
typedef std::shared_ptr< H5TagWriter >	H5TagWriterSharedPtr
typedef std::shared_ptr< XmlDataSource >	XmlDataSourceSharedPtr
typedef std::shared_ptr< XmlTagWriter >	XmlTagWriterSharedPtr
typedef std::shared_ptr< Interpolator >	InterpolatorSharedPtr
typedef std::shared_ptr< PtsField >	PtsFieldSharedPtr
typedef std::map< std::string, std::string >	PtsMetaDataMap
typedef std::shared_ptr< PtsIO >	PtsIOSharedPtr
typedef std::map< std::string, std::string >	SolverInfoMap
typedef std::map< std::string, NekDouble >	ParameterMap
typedef std::map< std::string, std::string >	GeometricInfoMap
typedef std::vector< std::string >	VariableList
typedef std::map< std::string, std::string >	TagMap
typedef std::map< std::string, std::string >	FilterParams
typedef std::vector< std::pair< std::string, FilterParams > >	FilterMap
typedef std::map< std::string, CmdLineArg >	CmdLineArgMap
typedef std::map< std::string, int >	EnumMap
typedef std::map< std::string, EnumMap >	EnumMapList
typedef std::map< std::string, std::string >	GloSysInfoMap
typedef std::map< std::string, GloSysInfoMap >	GloSysSolnInfoList
typedef std::map< std::pair< std::string, int >, FunctionVariableDefinition >	FunctionVariableMap
typedef std::map< std::string, FunctionVariableMap >	FunctionMap
typedef std::shared_ptr< SessionReader >	SessionReaderSharedPtr
typedef std::shared_ptr< Comm >	CommSharedPtr
	Pointer to a Communicator object. More...
typedef LibUtilities::NekFactory< std::string, Comm, int, char ** >	CommFactory
	Datatype of the NekFactory used to instantiate classes derived from the EquationSystem class. More...
typedef std::shared_ptr< CommRequest >	CommRequestSharedPtr
typedef std::shared_ptr< CommCwipi >	CommCwipiSharedPtr
	Pointer to a Communicator object. More...
typedef unsigned int	CommDataType
typedef std::shared_ptr< CommMpi >	CommMpiSharedPtr
	Pointer to a Communicator object. More...
typedef std::shared_ptr< CommRequestMpi >	CommRequestMpiSharedPtr
typedef std::shared_ptr< CommSerial >	CommSerialSharedPtr
	Pointer to a Communicator object. More...
typedef std::shared_ptr< Transposition >	TranspositionSharedPtr
typedef std::shared_ptr< NekFFTW >	NekFFTWSharedPtr
typedef std::shared_ptr< NektarFFT >	NektarFFTSharedPtr
typedef LibUtilities::NekFactory< std::string, NektarFFT, int >	NektarFFTFactory
	Datatype of the NekFactory used to instantiate classes derived from the NektarFFT class. More...
typedef std::vector< BasisKey >	BasisKeyVector
	Name for a vector of BasisKeys. More...
typedef std::shared_ptr< Basis >	BasisSharedPtr
typedef std::vector< BasisSharedPtr >	BasisVector
typedef Points< NekDouble >	PointsBaseType
typedef std::shared_ptr< Points< NekDouble > >	PointsSharedPtr
typedef size_t	GraphVertexID
typedef NekManager< PointsKey, Points< NekDouble >, PointsKey::opLess >	PointsManagerT
typedef NekManager< BasisKey, Basis, BasisKey::opLess >	BasisManagerT
typedef std::shared_ptr< NekMatrix< NekDouble > >	SharedMatrix
typedef std::vector< PointsKey >	PointsKeyVector
typedef NekDouble(*	PFD) ()
typedef NekDouble(*	PFD1) (NekDouble)
typedef NekDouble(*	PFD2) (NekDouble, NekDouble)
typedef NekDouble(*	PFD3) (NekDouble, NekDouble, NekDouble)
typedef NekDouble(*	PFD4) (NekDouble, NekDouble, NekDouble, NekDouble)
typedef std::shared_ptr< Interpreter >	InterpreterSharedPtr
typedef std::shared_ptr< NekLinSysIter >	NekLinSysIterSharedPtr
typedef LibUtilities::NekFactory< std::string, NekLinSysIter, const LibUtilities::SessionReaderSharedPtr &, const LibUtilities::CommSharedPtr &, const int, const NekSysKey & >	NekLinSysIterFactory
typedef std::shared_ptr< NekLinSysIterCG >	NekLinSysIterCGSharedPtr
typedef std::shared_ptr< NekLinSysIterCGLoc >	NekLinSysIterCGLocSharedPtr
typedef std::shared_ptr< NekLinSysIterFixedpointJacobi >	NekLinSysIterFixedpointJacobiSharedPtr
typedef std::shared_ptr< NekNonlinSys >	NekNonlinSysSharedPtr
typedef LibUtilities::NekFactory< std::string, NekNonlinSys, const LibUtilities::SessionReaderSharedPtr &, const LibUtilities::CommSharedPtr &, const int, const NekSysKey & >	NekNonlinSysFactory
typedef std::shared_ptr< NekSys >	NekSysSharedPtr
typedef NekFactory< std::string, TimeIntegrationScheme, std::string, size_t, std::vector< NekDouble > >	TimeIntegrationSchemeFactory
	Datatype of the NekFactory used to instantiate classes derived from the EquationSystem class. More...
typedef std::shared_ptr< TimeIntegrationSchemeOperators >	TimeIntegrationSchemeOperatorsSharedPtr
template<class T >
using	AT = Array< OneD, T >
typedef const AT< const AT< AT< NekDouble > > >	ConstTripleArray
typedef AT< AT< AT< NekDouble > > >	TripleArray
typedef const AT< const AT< NekDouble > >	ConstDoubleArray
typedef AT< AT< NekDouble > >	DoubleArray
typedef const AT< const NekDouble >	ConstSingleArray
typedef AT< NekDouble >	SingleArray
typedef AT< AT< AT< std::complex< NekDouble > > > >	ComplexTripleArray
typedef const AT< const AT< std::complex< NekDouble > > >	ConstComplexDoubleArray
typedef AT< AT< std::complex< NekDouble > > >	ComplexDoubleArray
typedef const AT< const std::complex< NekDouble > >	ConstComplexSingleArray
typedef AT< std::complex< NekDouble > >	ComplexSingleArray
typedef std::shared_ptr< TimeIntegrationScheme >	TimeIntegrationSchemeSharedPtr
typedef std::vector< TimeIntegrationSchemeSharedPtr >	TimeIntegrationSchemeVector
typedef std::shared_ptr< NoSchemeTimeIntegrationScheme >	NoTimeIntegrationSchemeSharedPtr
typedef std::shared_ptr< FractionalInTimeIntegrationScheme >	FractionalInTimeIntegrationSchemeSharedPtr
typedef std::vector< FractionalInTimeIntegrationSchemeSharedPtr >	FractionalInTimeIntegrationSchemeVector
typedef std::shared_ptr< TimeIntegrationSchemeGLM >	TimeIntegrationSchemeGLMSharedPtr
typedef std::vector< TimeIntegrationSchemeGLMSharedPtr >	TimeIntegrationSchemeGLMVector
typedef std::shared_ptr< TimeIntegrationAlgorithmGLM >	TimeIntegrationAlgorithmGLMSharedPtr
typedef std::vector< TimeIntegrationAlgorithmGLMSharedPtr >	TimeIntegrationAlgorithmGLMVector
typedef std::shared_ptr< TimeIntegrationSolutionGLM >	TimeIntegrationSolutionGLMSharedPtr
typedef std::vector< TimeIntegrationSolutionGLMSharedPtr >	TimeIntegrationSolutionGLMVector
typedef std::shared_ptr< TimeIntegrationSchemeGEM >	TimeIntegrationSchemeGEMSharedPtr
typedef std::vector< TimeIntegrationSchemeGEMSharedPtr >	TimeIntegrationSchemeGEMVector
typedef std::shared_ptr< TimeIntegrationSchemeSDC >	TimeIntegrationSchemeSDCSharedPtr
typedef std::vector< TimeIntegrationSchemeSDCSharedPtr >	TimeIntegrationSchemeSDCVector

Enumerations
enum	EndianType {   eEndianUnknown , eEndianBig , eEndianLittle , eEndianBigWord ,   eEndianLittleWord }
enum	FieldIOType { eXML , eHDF5 }
	Enumerator for auto-detection of FieldIO types. More...
enum	InterpMethod {   eNoMethod , eNearestNeighbour , eQuadratic , eShepard ,   eGauss }
enum	PtsType {   ePtsFile , ePtsLine , ePtsPlane , ePtsBox ,   ePtsSegBlock , ePtsTriBlock , ePtsTetBlock }
enum	PtsInfo { eIsEquiSpacedData , ePtsPerElmtEdge }
enum	FunctionType { eFunctionTypeExpression , eFunctionTypeFile , eFunctionTypeTransientFile , eSIZE_FunctionType }
enum	ShapeType {   eNoShapeType , ePoint , eSegment , eTriangle ,   eQuadrilateral , eTetrahedron , ePyramid , ePrism ,   eHexahedron , SIZE_ShapeType , Point = ePoint , Seg = eSegment ,   Tri = eTriangle , Quad = eQuadrilateral , Tet = eTetrahedron , Pyr = ePyramid ,   Prism = ePrism , Hex = eHexahedron }
enum	ReduceOperator { ReduceSum , ReduceMax , ReduceMin , SIZE_ReduceOperator }
	Type of operation to perform in AllReduce. More...
enum	TranspositionDir {   eXYtoZ , eZtoXY , eXtoYZ , eYZtoX ,   eYZtoZY , eZYtoYZ , eXtoY , eYtoZ ,   eZtoX , eNoTrans }
enum	BasisType {   eNoBasisType , eOrtho_A , eOrtho_B , eOrtho_C ,   eModified_A , eModified_B , eModified_C , eOrthoPyr_C ,   eModifiedPyr_C , eFourier , eGLL_Lagrange , eGauss_Lagrange ,   h_p , eChebyshev , P , eFourierSingleMode ,   eFourierHalfModeRe , eFourierHalfModeIm , SIZE_BasisType }
enum	PointsType {   eNoPointsType , eGaussGaussLegendre , eGaussRadauMLegendre , eGaussRadauPLegendre ,   eGaussLobattoLegendre , eGaussGaussChebyshev , eGaussRadauMChebyshev , eGaussRadauPChebyshev ,   eGaussLobattoChebyshev , eGaussRadauMAlpha0Beta1 , beta , beta ,   beta , beta , eGaussRadauKronrodMLegendre , eGaussRadauKronrodMAlpha1Beta0 ,   eGaussLobattoKronrodLegendre , ePolyEvenlySpaced , eFourierEvenlySpaced , eFourierSingleModeSpaced ,   eBoundaryLayerPoints , eBoundaryLayerPointsRev , eNodalTriElec , eNodalTriFekete ,   eNodalTriEvenlySpaced , eNodalTetEvenlySpaced , eNodalTetElec , eNodalPrismEvenlySpaced ,   eNodalPrismElec , eNodalTriSPI , eNodalTetSPI , eNodalPrismSPI ,   eNodalQuadElec , eNodalHexElec , SIZE_PointsType }
enum	TimeIntegrationSchemeType {   eNoTimeIntegrationSchemeType , eExplicit , eDiagonallyImplicit , eIMEX ,   eImplicit , eExponential , eFractionalInTime }

Functions
template<class To , class Ti , class = typename std::enable_if< std::is_floating_point< typename std::remove_reference<Ti>::type>::value && std::is_integral< typename std::remove_reference<To>::type>::value>::type>
To	checked_cast (const Ti param)
	checked cast from float types only to int types More...
EndianType	Endianness (void)
FieldIOFactory &	GetFieldIOFactory ()
	Returns the FieldIO factory. More...
void	Write (const std::string &outFile, std::vector< FieldDefinitionsSharedPtr > &fielddefs, std::vector< std::vector< NekDouble > > &fielddata, const FieldMetaDataMap &fieldinfomap, const bool backup)
	This function allows for data to be written to an FLD file when a session and/or communicator is not instantiated. Typically used in utilities which do not take XML input and operate in serial only. More...
void	Import (const std::string &infilename, std::vector< FieldDefinitionsSharedPtr > &fielddefs, std::vector< std::vector< NekDouble > > &fielddata, FieldMetaDataMap &fieldinfomap, const Array< OneD, int > &ElementIDs)
	This function allows for data to be imported from an FLD file when a session and/or communicator is not instantiated. Typically used in utilities which only operate in serial. More...
int	GetNumberOfDataPoints (const FieldDefinitionsSharedPtr &fielddefs, unsigned int &cnt)
	Compute the number of values needed to store elemental expansion. More...
static std::string	PortablePath (const fs::path &path)
	create portable path on different platforms for std::filesystem path. More...
static fs::path	UniquePath (std::string specFileStem)
	Create a unique (random) path, based on an input stem string. The returned string is a filename or directory that does not exist. More...
int	PrintProgressbar (const int position, const int goal, const std::string message, int lastprogress=-1)
	Prints a progressbar. More...
template<class T1 , class T2 , class = typename std::enable_if< std::is_floating_point<typename std::remove_cv< typename std::remove_reference<T1>::type>::type>::value && std::is_same<typename std::remove_cv< typename std::remove_reference<T1>::type>::type, typename std::remove_cv<typename std::remove_reference< T2>::type>::type>::value>::type>
bool	IsRealEqual (T1 &&lhs, T2 &&rhs, const unsigned int factor=NekConstants::kNekFloatCompFact)
	compare reals of same type with relative tolerance More...
template<class T1 , class T2 , class = typename std::enable_if< std::is_floating_point<typename std::remove_cv< typename std::remove_reference<T1>::type>::type>::value && std::is_same<typename std::remove_cv< typename std::remove_reference<T1>::type>::type, typename std::remove_cv<typename std::remove_reference< T2>::type>::type>::value>::type>
bool	IsRealClose (T1 &&lhs, T2 &&rhs, const NekDouble tol=NekConstants::kNekMachineEpsilon)
	compare reals of same type with absolute tolerance More...
TiXmlElement *	GetChildElementOrThrow (const std::string &filename, std::string elementName, const TiXmlHandle &docHandle)
int	GetNumberOfCoefficients (ShapeType shape, std::vector< unsigned int > &modes, int offset=0)
int	GetNumberOfCoefficients (ShapeType shape, int na, int nb=0, int nc=0)
CommFactory &	GetCommFactory ()
int	CommDataTypeGetSize (CommDataType dt)
	Return the size in bytes of a data type dt. More...
NektarFFTFactory &	GetNektarFFTFactory ()
bool	operator< (const BasisKey &lhs, const BasisKey &rhs)
bool	operator> (const BasisKey &lhs, const BasisKey &rhs)
std::ostream &	operator<< (std::ostream &os, const BasisKey &rhs)
bool	operator== (const BasisKey &x, const BasisKey &y)
bool	operator== (const BasisKey *x, const BasisKey &y)
bool	operator== (const BasisKey &x, const BasisKey *y)
bool	operator!= (const BasisKey &x, const BasisKey &y)
bool	operator!= (const BasisKey *x, const BasisKey &y)
bool	operator!= (const BasisKey &x, const BasisKey *y)
static const BasisKey	NullBasisKey (eNoBasisType, 0, NullPointsKey)
	Defines a null basis with no type or points. More...
bool	operator== (const GraphVertexObject &x, const GraphVertexObject &y)
bool	operator!= (const GraphVertexObject &x, const GraphVertexObject &y)
void	Interp1D (const BasisKey &fbasis0, const Array< OneD, const NekDouble > &from, const BasisKey &tbasis0, Array< OneD, NekDouble > &to)
	this function interpolates a 1D function \(f\) evaluated at the quadrature points of the basis fbasis0 to the function values at the quadrature points of the basis tbasis0 More...
void	Interp1D (const PointsKey &fpoints0, const Array< OneD, const NekDouble > &from, const PointsKey &tpoints0, Array< OneD, NekDouble > &to)
void	Interp1D (const BasisKey &fbasis0, const NekDouble *from, const BasisKey &tbasis0, NekDouble *to)
void	Interp1D (const PointsKey &fpoints0, const NekDouble *from, const PointsKey &tpoints0, NekDouble *to)
void	Interp2D (const BasisKey &fbasis0, const BasisKey &fbasis1, const Array< OneD, const NekDouble > &from, const BasisKey &tbasis0, const BasisKey &tbasis1, Array< OneD, NekDouble > &to)
	this function interpolates a 2D function \(f\) evaluated at the quadrature points of the 2D basis, constructed by fbasis0 and fbasis1, to the function values at the quadrature points of the 2D basis, constructed by tbasis0 and tbasis1 More...
void	Interp2D (const PointsKey &fpoints0, const PointsKey &fpoints1, const Array< OneD, const NekDouble > &from, const PointsKey &tpoints0, const PointsKey &tpoints1, Array< OneD, NekDouble > &to)
void	Interp2D (const PointsKey &fpoints0, const PointsKey &fpoints1, const NekDouble *from, const PointsKey &tpoints0, const PointsKey &tpoints1, NekDouble *to)
void	Interp3D (const BasisKey &fbasis0, const BasisKey &fbasis1, const BasisKey &fbasis2, const Array< OneD, const NekDouble > &from, const BasisKey &tbasis0, const BasisKey &tbasis1, const BasisKey &tbasis2, Array< OneD, NekDouble > &to)
	this function interpolates a 3D function \(f\) evaluated at the quadrature points of the 3D basis, constructed by fbasis0, fbasis1, and fbasis2 to the function values at the quadrature points of the 3D basis, constructed by tbasis0, tbasis1, and tbasis2. More...
void	Interp3D (const PointsKey &fpoints0, const PointsKey &fpoints1, const PointsKey &fpoints2, const Array< OneD, const NekDouble > &from, const PointsKey &tpoints0, const PointsKey &tpoints1, const PointsKey &tpoints2, Array< OneD, NekDouble > &to)
void	Interp3D (const PointsKey &fpoints0, const PointsKey &fpoints1, const PointsKey &fpoints2, const NekDouble *from, const PointsKey &tpoints0, const PointsKey &tpoints1, const PointsKey &tpoints2, NekDouble *to)
void	InterpCoeff1D (const BasisKey &fbasis0, const Array< OneD, const NekDouble > &from, const BasisKey &tbasis0, Array< OneD, NekDouble > &to)
void	InterpCoeff2D (const BasisKey &fbasis0, const BasisKey &fbasis1, const Array< OneD, const NekDouble > &from, const BasisKey &tbasis0, const BasisKey &tbasis1, Array< OneD, NekDouble > &to)
void	InterpCoeff2D (const BasisKey &fbasis0, const BasisKey &fbasis1, const NekDouble *from, const BasisKey &tbasis0, const BasisKey &tbasis1, NekDouble *to)
void	InterpCoeff3D (const BasisKey &fbasis0, const BasisKey &fbasis1, const BasisKey &fbasis2, const Array< OneD, const NekDouble > &from, const BasisKey &tbasis0, const BasisKey &tbasis1, const BasisKey &tbasis2, Array< OneD, NekDouble > &to)
void	InterpCoeff3D (const BasisKey &fbasis0, const BasisKey &fbasis1, const BasisKey &fbasis2, const NekDouble *from, const BasisKey &tbasis0, const BasisKey &tbasis1, const BasisKey &tbasis2, NekDouble *to)
PointsManagerT &	PointsManager (void)
BasisManagerT &	BasisManager (void)
void	PhysGalerkinProject1D (const BasisKey &fbasis0, const Array< OneD, const NekDouble > &from, const BasisKey &tbasis0, Array< OneD, NekDouble > &to)
void	PhysGalerkinProject1D (const PointsKey &fpoints0, const Array< OneD, const NekDouble > &from, const PointsKey &tpoints0, Array< OneD, NekDouble > &to)
void	PhysGalerkinProject1D (const BasisKey &fbasis0, const NekDouble *from, const BasisKey &tbasis0, NekDouble *to)
void	PhysGalerkinProject1D (const PointsKey &fpoints0, const NekDouble *from, const PointsKey &tpoints0, NekDouble *to)
void	PhysGalerkinProject2D (const BasisKey &fbasis0, const BasisKey &fbasis1, const Array< OneD, const NekDouble > &from, const BasisKey &tbasis0, const BasisKey &tbasis1, Array< OneD, NekDouble > &to)
void	PhysGalerkinProject2D (const PointsKey &fpoints0, const PointsKey &fpoints1, const Array< OneD, const NekDouble > &from, const PointsKey &tpoints0, const PointsKey &tpoints1, Array< OneD, NekDouble > &to)
void	PhysGalerkinProject2D (const PointsKey &fpoints0, const PointsKey &fpoints1, const NekDouble *from, const PointsKey &tpoints0, const PointsKey &tpoints1, NekDouble *to)
void	PhysGalerkinProject3D (const BasisKey &fbasis0, const BasisKey &fbasis1, const BasisKey &fbasis2, const Array< OneD, const NekDouble > &from, const BasisKey &tbasis0, const BasisKey &tbasis1, const BasisKey &tbasis2, Array< OneD, NekDouble > &to)
void	PhysGalerkinProject3D (const PointsKey &fpoints0, const PointsKey &fpoints1, const PointsKey &fpoints2, const Array< OneD, const NekDouble > &from, const PointsKey &tpoints0, const PointsKey &tpoints1, const PointsKey &tpoints2, Array< OneD, NekDouble > &to)
void	PhysGalerkinProject3D (const PointsKey &fpoints0, const PointsKey &fpoints1, const PointsKey &fpoints2, const NekDouble *from, const PointsKey &tpoints0, const PointsKey &tpoints1, const PointsKey &tpoints2, NekDouble *to)
bool	operator== (const PointsKey &lhs, const PointsKey &rhs)
bool	operator< (const PointsKey &lhs, const PointsKey &rhs)
std::ostream &	operator<< (std::ostream &os, const PointsKey &rhs)
static const PointsKey	NullPointsKey (0, eNoPointsType)
NekDouble	sign (NekDouble arg)
NekDouble	awgn (NekDouble sigma)
static NekDouble	rad (NekDouble x, NekDouble y)
static NekDouble	ang (NekDouble x, NekDouble y)
NekLinSysIterFactory &	GetNekLinSysIterFactory ()
NekNonlinSysFactory &	GetNekNonlinSysFactory ()
	FACTORYREGISTER (AdamsBashforth)
	FACTORYREGISTER (AdamsBashforthOrder1)
	SESSIONREGISTER (AdamsBashforthOrder1)
	FACTORYREGISTER (AdamsBashforthOrder2)
	SESSIONREGISTER (AdamsBashforthOrder2)
	FACTORYREGISTER (AdamsBashforthOrder3)
	SESSIONREGISTER (AdamsBashforthOrder3)
	FACTORYREGISTER (AdamsBashforthOrder4)
	SESSIONREGISTER (AdamsBashforthOrder4)
	FACTORYREGISTER (AdamsMoulton)
	FACTORYREGISTER (AdamsMoultonOrder1)
	SESSIONREGISTER (AdamsMoultonOrder1)
	FACTORYREGISTER (AdamsMoultonOrder2)
	SESSIONREGISTER (AdamsMoultonOrder2)
	FACTORYREGISTER (AdamsMoultonOrder3)
	SESSIONREGISTER (AdamsMoultonOrder3)
	FACTORYREGISTER (AdamsMoultonOrder4)
	SESSIONREGISTER (AdamsMoultonOrder4)
	FACTORYREGISTER (BDFImplicit)
	FACTORYREGISTER (BDFImplicitOrder1)
	SESSIONREGISTER (BDFImplicitOrder1)
	FACTORYREGISTER (BDFImplicitOrder2)
	SESSIONREGISTER (BDFImplicitOrder2)
	FACTORYREGISTER (BDFImplicitOrder3)
	SESSIONREGISTER (BDFImplicitOrder3)
	FACTORYREGISTER (BDFImplicitOrder4)
	SESSIONREGISTER (BDFImplicitOrder4)
	FACTORYREGISTER (Euler)
	FACTORYREGISTER (BackwardEuler)
	SESSIONREGISTER (BackwardEuler)
	FACTORYREGISTER (ForwardEuler)
	SESSIONREGISTER (ForwardEuler)
	FACTORYREGISTER (EulerExponential)
	FACTORYREGISTER (CNAB)
	SESSIONREGISTER (CNAB)
	FACTORYREGISTER (DIRK)
	FACTORYREGISTER (DIRKOrder1)
	SESSIONREGISTER (DIRKOrder1)
	FACTORYREGISTER (DIRKOrder2)
	SESSIONREGISTER (DIRKOrder2)
	FACTORYREGISTER (DIRKOrder3)
	SESSIONREGISTER (DIRKOrder3)
	FACTORYREGISTER (DIRKOrder3_ES5)
	SESSIONREGISTER (DIRKOrder3_ES5)
	FACTORYREGISTER (DIRKOrder4_ES6)
	SESSIONREGISTER (DIRKOrder4_ES6)
	FACTORYREGISTER (IMEXdirk)
	FACTORYREGISTER (IMEXdirk_1_1_1)
	SESSIONREGISTER (IMEXdirk_1_1_1)
	FACTORYREGISTER (IMEXdirk_1_2_1)
	SESSIONREGISTER (IMEXdirk_1_2_1)
	FACTORYREGISTER (IMEXdirk_1_2_2)
	SESSIONREGISTER (IMEXdirk_1_2_2)
	FACTORYREGISTER (IMEXdirk_2_2_2)
	SESSIONREGISTER (IMEXdirk_2_2_2)
	FACTORYREGISTER (IMEXdirk_2_3_2)
	SESSIONREGISTER (IMEXdirk_2_3_2)
	FACTORYREGISTER (IMEXdirk_2_3_3)
	SESSIONREGISTER (IMEXdirk_2_3_3)
	FACTORYREGISTER (IMEXdirk_3_4_3)
	SESSIONREGISTER (IMEXdirk_3_4_3)
	FACTORYREGISTER (IMEXdirk_4_4_3)
	SESSIONREGISTER (IMEXdirk_4_4_3)
	FACTORYREGISTER (IMEXGear)
	SESSIONREGISTER (IMEXGear)
	FACTORYREGISTER (IMEX)
	FACTORYREGISTER (IMEXOrder1)
	SESSIONREGISTER (IMEXOrder1)
	FACTORYREGISTER (IMEXOrder2)
	SESSIONREGISTER (IMEXOrder2)
	FACTORYREGISTER (IMEXOrder3)
	SESSIONREGISTER (IMEXOrder3)
	FACTORYREGISTER (IMEXOrder4)
	SESSIONREGISTER (IMEXOrder4)
	FACTORYREGISTER (MCNAB)
	SESSIONREGISTER (MCNAB)
	FACTORYREGISTER (RungeKutta)
	FACTORYREGISTER (RungeKutta1)
	SESSIONREGISTER (RungeKutta1)
	FACTORYREGISTER (RungeKutta2)
	SESSIONREGISTER (RungeKutta2)
	FACTORYREGISTER (RungeKutta2_ImprovedEuler)
	SESSIONREGISTER (RungeKutta2_ImprovedEuler)
	FACTORYREGISTER (RungeKutta2_SSP)
	SESSIONREGISTER (RungeKutta2_SSP)
	FACTORYREGISTER (RungeKutta3)
	SESSIONREGISTER (RungeKutta3)
	FACTORYREGISTER (RungeKutta3_SSP)
	SESSIONREGISTER (RungeKutta3_SSP)
	FACTORYREGISTER (ClassicalRungeKutta4)
	SESSIONREGISTER (ClassicalRungeKutta4)
	FACTORYREGISTER (RungeKutta4)
	SESSIONREGISTER (RungeKutta4)
	FACTORYREGISTER (RungeKutta5)
	SESSIONREGISTER (RungeKutta5)
	FACTORYREGISTER (NoScheme)
	SESSIONREGISTER (NoScheme)
std::ostream &	operator<< (std::ostream &os, const TimeIntegrationAlgorithmGLMSharedPtr &rhs)
std::ostream &	operator<< (std::ostream &os, const TimeIntegrationAlgorithmGLM &rhs)
TimeIntegrationSchemeFactory &	GetTimeIntegrationSchemeFactory ()
std::ostream &	operator<< (std::ostream &os, const TimeIntegrationScheme &rhs)
std::ostream &	operator<< (std::ostream &os, const TimeIntegrationSchemeSharedPtr &rhs)
std::ostream &	operator<< (std::ostream &os, const FractionalInTimeIntegrationScheme &rhs)
std::ostream &	operator<< (std::ostream &os, const FractionalInTimeIntegrationSchemeSharedPtr &rhs)
std::ostream &	operator<< (std::ostream &os, const TimeIntegrationSchemeGEM &rhs)
std::ostream &	operator<< (std::ostream &os, const TimeIntegrationSchemeGEMSharedPtr &rhs)
std::ostream &	operator<< (std::ostream &os, const TimeIntegrationSchemeGLM &rhs)
std::ostream &	operator<< (std::ostream &os, const TimeIntegrationSchemeGLMSharedPtr &rhs)
std::ostream &	operator<< (std::ostream &os, const TimeIntegrationSchemeSDC &rhs)
std::ostream &	operator<< (std::ostream &os, const TimeIntegrationSchemeSDCSharedPtr &rhs)

Variables
const std::string	EndianTypeMap []
static DomainRangeShPtr	NullDomainRangeShPtr
std::string	fldCmdFormat
static FieldMetaDataMap	NullFieldMetaDataMap
static std::map< PtsInfo, int >	NullPtsInfoMap
static PtsFieldSharedPtr	NullPtsField
static PtsMetaDataMap	NullPtsMetaDataMap
const char *const	FunctionTypeMap []
const char *const	ShapeTypeMap [SIZE_ShapeType]
constexpr unsigned int	ShapeTypeDimMap [SIZE_ShapeType]
static std::vector< NekDouble >	NullNekDoubleVector
static std::vector< unsigned int >	NullUnsignedIntVector
static std::vector< std::vector< NekDouble > >	NullVectorNekDoubleVector
const char *const	ReduceOperatorMap [] = {"ReduceSum", "ReduceMax", "ReduceMin"}
static BasisSharedPtr	NullBasisSharedPtr
static Array< OneD, BasisSharedPtr >	NullBasisSharedPtr1DArray
const char *const	BasisTypeMap []
const std::string	kPointsTypeStr []
static const size_t	perm4_3d [4][4]
static const size_t	perm6_3d [6][4]
static const size_t	perm12A_3d [12][4]
static const size_t	perm12B_3d [12][4]
static const size_t	perm12C_3d [12][4]
static const size_t	perm24_3d [24][4]
const size_t	NodalTetElecAvailable = 10
static const size_t	NodalTetElecNPTS [NodalTetElecAvailable]
static const NekDouble	NodalTetElecData [][9]
const size_t	NodalTetSPIAvailable = 10
static const size_t	NodalTetSPINPTS [NodalTetSPIAvailable]
static const NekDouble	NodalTetSPIData [][4]
static const size_t	perm3A_2d [3][3]
static const size_t	perm3B_2d [3][3]
static const size_t	perm6_2d [6][3]
const size_t	NodalTriElecAvailable = 16
static const size_t	NodalTriElecNPTS [NodalTriElecAvailable]
static const NekDouble	NodalTriElecData [][6]
static const size_t	perm3A_2d [3][3]
static const size_t	perm3B_2d [3][3]
static const size_t	perm3C_2d [3][3]
static const size_t	perm6_2d [6][3]
const size_t	NodalTriFeketeAvailable = 16
static const size_t	NodalTriFeketeNPTS [NodalTriFeketeAvailable]
static const NekDouble	NodalTriFeketeData [][6]
const size_t	NodalTriSPIAvailable = 10
static const size_t	NodalTriSPINPTS [NodalTriSPIAvailable]
static const NekDouble	NodalTriSPIData [][3]
static std::vector< LibUtilities::PointsType >	NullPointsTypeVector
Nektar::LibUtilities::functions	functions_p

Typedef Documentation

AT

template<class T >

using Nektar::LibUtilities::AT = typedef Array<OneD, T>

Definition at line 45 of file TimeIntegrationTypes.hpp.

BasisKeyVector

typedef std::vector<BasisKey> Nektar::LibUtilities::BasisKeyVector

Name for a vector of BasisKeys.

Definition at line 68 of file FoundationsFwd.hpp.

BasisManagerT

typedef NekManager<BasisKey, Basis, BasisKey::opLess> Nektar::LibUtilities::BasisManagerT

Definition at line 47 of file ManagerAccess.h.

BasisSharedPtr

typedef std::shared_ptr<Basis> Nektar::LibUtilities::BasisSharedPtr

Definition at line 69 of file FoundationsFwd.hpp.

BasisVector

typedef std::vector<BasisSharedPtr> Nektar::LibUtilities::BasisVector

Definition at line 70 of file FoundationsFwd.hpp.

CmdLineArgMap

typedef std::map<std::string, CmdLineArg> Nektar::LibUtilities::CmdLineArgMap

Definition at line 71 of file SessionReader.h.

CommCwipiSharedPtr

typedef std::shared_ptr<CommCwipi> Nektar::LibUtilities::CommCwipiSharedPtr

Pointer to a Communicator object.

Definition at line 50 of file CommCwipi.h.

CommDataType

typedef unsigned int Nektar::LibUtilities::CommDataType

Definition at line 65 of file CommDataType.h.

CommFactory

typedef LibUtilities::NekFactory<std::string, Comm, int, char **> Nektar::LibUtilities::CommFactory

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

Definition at line 59 of file Comm.h.

CommMpiSharedPtr

typedef std::shared_ptr<CommMpi> Nektar::LibUtilities::CommMpiSharedPtr

Pointer to a Communicator object.

Definition at line 56 of file CommMpi.h.

CommRequestMpiSharedPtr

typedef std::shared_ptr<CommRequestMpi> Nektar::LibUtilities::CommRequestMpiSharedPtr

Definition at line 86 of file CommMpi.h.

CommRequestSharedPtr

typedef std::shared_ptr<CommRequest> Nektar::LibUtilities::CommRequestSharedPtr

Definition at line 84 of file Comm.h.

CommSerialSharedPtr

typedef std::shared_ptr<CommSerial> Nektar::LibUtilities::CommSerialSharedPtr

Pointer to a Communicator object.

Definition at line 49 of file CommSerial.h.

CommSharedPtr

typedef std::shared_ptr<Comm> Nektar::LibUtilities::CommSharedPtr

Pointer to a Communicator object.

Definition at line 55 of file Comm.h.

ComplexDoubleArray

typedef AT< AT< std::complex<NekDouble> > > Nektar::LibUtilities::ComplexDoubleArray

Definition at line 57 of file TimeIntegrationTypes.hpp.

ComplexSingleArray

typedef AT< std::complex<NekDouble> > Nektar::LibUtilities::ComplexSingleArray

Definition at line 59 of file TimeIntegrationTypes.hpp.

ComplexTripleArray

typedef AT< AT<AT<std::complex<NekDouble> > > > Nektar::LibUtilities::ComplexTripleArray

Definition at line 55 of file TimeIntegrationTypes.hpp.

ConstComplexDoubleArray

typedef const AT<const AT< std::complex<NekDouble> > > Nektar::LibUtilities::ConstComplexDoubleArray

Definition at line 56 of file TimeIntegrationTypes.hpp.

ConstComplexSingleArray

typedef const AT< const std::complex<NekDouble> > Nektar::LibUtilities::ConstComplexSingleArray

Definition at line 58 of file TimeIntegrationTypes.hpp.

ConstDoubleArray

typedef const AT<const AT< NekDouble> > Nektar::LibUtilities::ConstDoubleArray

Definition at line 50 of file TimeIntegrationTypes.hpp.

ConstSingleArray

typedef const AT< const NekDouble> Nektar::LibUtilities::ConstSingleArray

Definition at line 52 of file TimeIntegrationTypes.hpp.

ConstTripleArray

typedef const AT<const AT<AT<NekDouble> > > Nektar::LibUtilities::ConstTripleArray

Definition at line 48 of file TimeIntegrationTypes.hpp.

CsvIOSharedPtr

typedef std::shared_ptr<CsvIO> Nektar::LibUtilities::CsvIOSharedPtr

Definition at line 74 of file CsvIO.h.

DataSourceSharedPtr

typedef std::shared_ptr<DataSource> Nektar::LibUtilities::DataSourceSharedPtr

Definition at line 88 of file FieldIO.h.

DomainRangeShPtr

typedef std::shared_ptr<DomainRange> Nektar::LibUtilities::DomainRangeShPtr

Definition at line 64 of file DomainRange.h.

DoubleArray

typedef AT< AT< NekDouble> > Nektar::LibUtilities::DoubleArray

Definition at line 51 of file TimeIntegrationTypes.hpp.

EnumMap

typedef std::map<std::string, int> Nektar::LibUtilities::EnumMap

Definition at line 73 of file SessionReader.h.

EnumMapList

typedef std::map<std::string, EnumMap> Nektar::LibUtilities::EnumMapList

Definition at line 74 of file SessionReader.h.

EquationSharedPtr

typedef std::shared_ptr<Equation> Nektar::LibUtilities::EquationSharedPtr

Definition at line 125 of file Equation.h.

FieldDefinitionsSharedPtr

typedef std::shared_ptr<FieldDefinitions> Nektar::LibUtilities::FieldDefinitionsSharedPtr

Definition at line 184 of file FieldIO.h.

FieldIOFactory

typedef LibUtilities::NekFactory<std::string, FieldIO, LibUtilities::CommSharedPtr, bool> Nektar::LibUtilities::FieldIOFactory

Datatype of the NekFactory used to instantiate classes.

Definition at line 205 of file FieldIO.h.

FieldIOSharedPtr

typedef std::shared_ptr<FieldIO> Nektar::LibUtilities::FieldIOSharedPtr

Definition at line 322 of file FieldIO.h.

FieldMetaDataMap

typedef std::map<std::string, std::string> Nektar::LibUtilities::FieldMetaDataMap

Definition at line 50 of file FieldIO.h.

FilterMap

typedef std::vector<std::pair<std::string, FilterParams> > Nektar::LibUtilities::FilterMap

Definition at line 62 of file SessionReader.h.

FilterParams

typedef std::map<std::string, std::string> Nektar::LibUtilities::FilterParams

Definition at line 61 of file SessionReader.h.

FractionalInTimeIntegrationSchemeSharedPtr

typedef std::shared_ptr<FractionalInTimeIntegrationScheme> Nektar::LibUtilities::FractionalInTimeIntegrationSchemeSharedPtr

Definition at line 78 of file TimeIntegrationTypes.hpp.

FractionalInTimeIntegrationSchemeVector

typedef std::vector<FractionalInTimeIntegrationSchemeSharedPtr> Nektar::LibUtilities::FractionalInTimeIntegrationSchemeVector

Definition at line 81 of file TimeIntegrationTypes.hpp.

FunctionMap

typedef std::map<std::string, FunctionVariableMap> Nektar::LibUtilities::FunctionMap

Definition at line 110 of file SessionReader.h.

FunctionVariableMap

typedef std::map<std::pair<std::string, int>, FunctionVariableDefinition> Nektar::LibUtilities::FunctionVariableMap

Definition at line 109 of file SessionReader.h.

GeometricInfoMap

typedef std::map<std::string, std::string> Nektar::LibUtilities::GeometricInfoMap

Definition at line 58 of file SessionReader.h.

GloSysInfoMap

typedef std::map< std::string, std::string > Nektar::LibUtilities::GloSysInfoMap

Definition at line 76 of file SessionReader.h.

GloSysSolnInfoList

typedef std::map< std::string, GloSysInfoMap > Nektar::LibUtilities::GloSysSolnInfoList

Definition at line 77 of file SessionReader.h.

GraphVertexID

typedef size_t Nektar::LibUtilities::GraphVertexID

Definition at line 74 of file FoundationsFwd.hpp.

H5DataSourceSharedPtr

typedef std::shared_ptr<H5DataSource> Nektar::LibUtilities::H5DataSourceSharedPtr

Definition at line 86 of file FieldIOHdf5.h.

H5TagWriterSharedPtr

typedef std::shared_ptr<H5TagWriter> Nektar::LibUtilities::H5TagWriterSharedPtr

Definition at line 117 of file FieldIOHdf5.h.

InterpolatorSharedPtr

typedef std::shared_ptr<Interpolator> Nektar::LibUtilities::InterpolatorSharedPtr

Definition at line 223 of file LibUtilities/BasicUtils/Interpolator.h.

InterpreterSharedPtr

typedef std::shared_ptr<Interpreter> Nektar::LibUtilities::InterpreterSharedPtr

Definition at line 322 of file Interpreter.h.

NekFFTWSharedPtr

typedef std::shared_ptr<NekFFTW> Nektar::LibUtilities::NekFFTWSharedPtr

Definition at line 57 of file NekFFTW.h.

NekLinSysIterCGLocSharedPtr

typedef std::shared_ptr<NekLinSysIterCGLoc> Nektar::LibUtilities::NekLinSysIterCGLocSharedPtr

Definition at line 46 of file NekLinSysIterCGLoc.h.

NekLinSysIterCGSharedPtr

typedef std::shared_ptr<NekLinSysIterCG> Nektar::LibUtilities::NekLinSysIterCGSharedPtr

Definition at line 46 of file NekLinSysIterCG.h.

NekLinSysIterFactory

typedef LibUtilities::NekFactory< std::string, NekLinSysIter, const LibUtilities::SessionReaderSharedPtr &, const LibUtilities::CommSharedPtr &, const int, const NekSysKey &> Nektar::LibUtilities::NekLinSysIterFactory

Definition at line 51 of file NekLinSysIter.h.

NekLinSysIterFixedpointJacobiSharedPtr

typedef std::shared_ptr<NekLinSysIterFixedpointJacobi> Nektar::LibUtilities::NekLinSysIterFixedpointJacobiSharedPtr

Definition at line 46 of file NekLinSysIterFixedpointJacobi.h.

NekLinSysIterSharedPtr

typedef std::shared_ptr<NekLinSysIter> Nektar::LibUtilities::NekLinSysIterSharedPtr

Definition at line 46 of file NekLinSysIter.h.

NekNonlinSysFactory

typedef LibUtilities::NekFactory< std::string, NekNonlinSys, const LibUtilities::SessionReaderSharedPtr &, const LibUtilities::CommSharedPtr &, const int, const NekSysKey &> Nektar::LibUtilities::NekNonlinSysFactory

Definition at line 51 of file NekNonlinSys.h.

NekNonlinSysSharedPtr

typedef std::shared_ptr<NekNonlinSys> Nektar::LibUtilities::NekNonlinSysSharedPtr

Definition at line 46 of file NekNonlinSys.h.

NekSysSharedPtr

typedef std::shared_ptr<NekSys> Nektar::LibUtilities::NekSysSharedPtr

Definition at line 230 of file NekSys.h.

NektarFFTFactory

typedef LibUtilities::NekFactory<std::string, NektarFFT, int> Nektar::LibUtilities::NektarFFTFactory

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

Definition at line 62 of file NektarFFT.h.

NektarFFTSharedPtr

typedef std::shared_ptr<NektarFFT> Nektar::LibUtilities::NektarFFTSharedPtr

Definition at line 58 of file NektarFFT.h.

NoTimeIntegrationSchemeSharedPtr

typedef std::shared_ptr<NoSchemeTimeIntegrationScheme> Nektar::LibUtilities::NoTimeIntegrationSchemeSharedPtr

Definition at line 72 of file TimeIntegrationTypes.hpp.

ParameterMap

typedef std::map<std::string, NekDouble> Nektar::LibUtilities::ParameterMap

Definition at line 57 of file SessionReader.h.

PFD

typedef NekDouble(* Nektar::LibUtilities::PFD) ()

Definition at line 90 of file Interpreter/Interpreter.cpp.

PFD1

typedef NekDouble(* Nektar::LibUtilities::PFD1) (NekDouble)

Definition at line 91 of file Interpreter/Interpreter.cpp.

PFD2

typedef NekDouble(* Nektar::LibUtilities::PFD2) (NekDouble, NekDouble)

Definition at line 92 of file Interpreter/Interpreter.cpp.

PFD3

typedef NekDouble(* Nektar::LibUtilities::PFD3) (NekDouble, NekDouble, NekDouble)

Definition at line 93 of file Interpreter/Interpreter.cpp.

PFD4

typedef NekDouble(* Nektar::LibUtilities::PFD4) (NekDouble, NekDouble, NekDouble, NekDouble)

Definition at line 94 of file Interpreter/Interpreter.cpp.

PointsBaseType

typedef Points<NekDouble> Nektar::LibUtilities::PointsBaseType

Definition at line 72 of file FoundationsFwd.hpp.

PointsKeyVector

typedef std::vector<PointsKey> Nektar::LibUtilities::PointsKeyVector

Definition at line 231 of file Points.h.

PointsManagerT

typedef NekManager<PointsKey, Points<NekDouble>, PointsKey::opLess> Nektar::LibUtilities::PointsManagerT

Definition at line 46 of file ManagerAccess.h.

PointsSharedPtr

typedef std::shared_ptr<Points<NekDouble> > Nektar::LibUtilities::PointsSharedPtr

Definition at line 73 of file FoundationsFwd.hpp.

PtsFieldSharedPtr

typedef std::shared_ptr<PtsField> Nektar::LibUtilities::PtsFieldSharedPtr

Definition at line 184 of file PtsField.h.

PtsIOSharedPtr

typedef std::shared_ptr<PtsIO> Nektar::LibUtilities::PtsIOSharedPtr

Definition at line 90 of file PtsIO.h.

PtsMetaDataMap

typedef std::map<std::string, std::string> Nektar::LibUtilities::PtsMetaDataMap

Definition at line 56 of file PtsIO.h.

SessionReaderSharedPtr

typedef std::shared_ptr<SessionReader> Nektar::LibUtilities::SessionReaderSharedPtr

Definition at line 113 of file SessionReader.h.

SharedMatrix

typedef std::shared_ptr<NekMatrix<NekDouble> > Nektar::LibUtilities::SharedMatrix

Definition at line 49 of file NodalUtil.h.

SingleArray

typedef AT< NekDouble> Nektar::LibUtilities::SingleArray

Definition at line 53 of file TimeIntegrationTypes.hpp.

SolverInfoMap

typedef std::map<std::string, std::string> Nektar::LibUtilities::SolverInfoMap

Definition at line 56 of file SessionReader.h.

TagMap

typedef std::map<std::string, std::string> Nektar::LibUtilities::TagMap

Definition at line 60 of file SessionReader.h.

TagWriterSharedPtr

typedef std::shared_ptr<TagWriter> Nektar::LibUtilities::TagWriterSharedPtr

Definition at line 78 of file FieldIO.h.

TimeIntegrationAlgorithmGLMSharedPtr

typedef std::shared_ptr<TimeIntegrationAlgorithmGLM> Nektar::LibUtilities::TimeIntegrationAlgorithmGLMSharedPtr

Definition at line 96 of file TimeIntegrationTypes.hpp.

TimeIntegrationAlgorithmGLMVector

typedef std::vector<TimeIntegrationAlgorithmGLMSharedPtr> Nektar::LibUtilities::TimeIntegrationAlgorithmGLMVector

Definition at line 99 of file TimeIntegrationTypes.hpp.

TimeIntegrationSchemeFactory

typedef NekFactory<std::string, TimeIntegrationScheme, std::string, size_t, std::vector<NekDouble> > Nektar::LibUtilities::TimeIntegrationSchemeFactory

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

Definition at line 61 of file TimeIntegrationScheme.h.

TimeIntegrationSchemeGEMSharedPtr

typedef std::shared_ptr<TimeIntegrationSchemeGEM> Nektar::LibUtilities::TimeIntegrationSchemeGEMSharedPtr

Definition at line 114 of file TimeIntegrationTypes.hpp.

TimeIntegrationSchemeGEMVector

typedef std::vector<TimeIntegrationSchemeGEMSharedPtr> Nektar::LibUtilities::TimeIntegrationSchemeGEMVector

Definition at line 117 of file TimeIntegrationTypes.hpp.

TimeIntegrationSchemeGLMSharedPtr

typedef std::shared_ptr<TimeIntegrationSchemeGLM> Nektar::LibUtilities::TimeIntegrationSchemeGLMSharedPtr

Definition at line 87 of file TimeIntegrationTypes.hpp.

TimeIntegrationSchemeGLMVector

typedef std::vector<TimeIntegrationSchemeGLMSharedPtr> Nektar::LibUtilities::TimeIntegrationSchemeGLMVector

Definition at line 90 of file TimeIntegrationTypes.hpp.

TimeIntegrationSchemeOperatorsSharedPtr

typedef std::shared_ptr<TimeIntegrationSchemeOperators> Nektar::LibUtilities::TimeIntegrationSchemeOperatorsSharedPtr

Definition at line 56 of file TimeIntegrationSchemeOperators.h.

TimeIntegrationSchemeSDCSharedPtr

typedef std::shared_ptr<TimeIntegrationSchemeSDC> Nektar::LibUtilities::TimeIntegrationSchemeSDCSharedPtr

Definition at line 123 of file TimeIntegrationTypes.hpp.

TimeIntegrationSchemeSDCVector

typedef std::vector<TimeIntegrationSchemeSDCSharedPtr> Nektar::LibUtilities::TimeIntegrationSchemeSDCVector

Definition at line 126 of file TimeIntegrationTypes.hpp.

TimeIntegrationSchemeSharedPtr

typedef std::shared_ptr<TimeIntegrationScheme> Nektar::LibUtilities::TimeIntegrationSchemeSharedPtr

Definition at line 65 of file TimeIntegrationTypes.hpp.

TimeIntegrationSchemeVector

typedef std::vector<TimeIntegrationSchemeSharedPtr> Nektar::LibUtilities::TimeIntegrationSchemeVector

Definition at line 67 of file TimeIntegrationTypes.hpp.

TimeIntegrationSolutionGLMSharedPtr

typedef std::shared_ptr<TimeIntegrationSolutionGLM> Nektar::LibUtilities::TimeIntegrationSolutionGLMSharedPtr

Definition at line 105 of file TimeIntegrationTypes.hpp.

TimeIntegrationSolutionGLMVector

typedef std::vector<TimeIntegrationSolutionGLMSharedPtr> Nektar::LibUtilities::TimeIntegrationSolutionGLMVector

Definition at line 108 of file TimeIntegrationTypes.hpp.

TranspositionSharedPtr

typedef std::shared_ptr<Transposition> Nektar::LibUtilities::TranspositionSharedPtr

Definition at line 160 of file Transposition.h.

TripleArray

typedef AT< AT<AT<NekDouble> > > Nektar::LibUtilities::TripleArray

Definition at line 49 of file TimeIntegrationTypes.hpp.

VariableList

typedef std::vector<std::string> Nektar::LibUtilities::VariableList

Definition at line 59 of file SessionReader.h.

XmlDataSourceSharedPtr

typedef std::shared_ptr<XmlDataSource> Nektar::LibUtilities::XmlDataSourceSharedPtr

Definition at line 109 of file FieldIOXml.h.

XmlTagWriterSharedPtr

typedef std::shared_ptr<XmlTagWriter> Nektar::LibUtilities::XmlTagWriterSharedPtr

Definition at line 166 of file FieldIOXml.h.

Enumeration Type Documentation

BasisType

enum Nektar::LibUtilities::BasisType

Enumerator
eNoBasisType
eOrtho_A	Principle Orthogonal Functions \(\widetilde{\psi}^a_p(z_i)\).
eOrtho_B	Principle Orthogonal Functions \(\widetilde{\psi}^b_{pq}(z_i)\).
eOrtho_C	Principle Orthogonal Functions \(\widetilde{\psi}^c_{pqr}(z_i)\).
eModified_A	Principle Modified Functions \( \phi^a_p(z_i) \).
eModified_B	Principle Modified Functions \( \phi^b_{pq}(z_i) \).
eModified_C	Principle Modified Functions \( \phi^c_{pqr}(z_i) \).
eOrthoPyr_C	Principle Orthogonal Functions \(\widetilde{\psi}^c_{pqr}(z_i) for Pyramids\).
eModifiedPyr_C	Principle Modified Functions.
eFourier	Fourier Expansion \( \exp(i p\pi z_i)\).
eGLL_Lagrange	Lagrange for SEM basis \( h_p(z_i) \).
eGauss_Lagrange	Lagrange Polynomials using the Gauss points.
h_p	Legendre Polynomials \( L_p(z_i) = P^{0,0}_p(z_i)\). Same as Ortho_A.
eChebyshev	Chebyshev Polynomials.
P	Monomial polynomials \( L_p(z_i) = z_i^{p}\).
eFourierSingleMode	Fourier ModifiedExpansion with just the first mode \( \exp(i \pi z_i)\).
eFourierHalfModeRe	Fourier Modified expansions with just the real part of the first mode \( Re[\exp(i \pi z_i)]\).
eFourierHalfModeIm	Fourier Modified expansions with just the imaginary part of the first mode \( Im[\exp(i \pi z_i)]\).
SIZE_BasisType	Length of enum list.

Definition at line 39 of file BasisType.h.

{
    eNoBasisType,
    eOrtho_A,        //!< Principle Orthogonal Functions
                     //!< \f$\widetilde{\psi}^a_p(z_i)\f$
    eOrtho_B,        //!< Principle Orthogonal Functions
                     //!< \f$\widetilde{\psi}^b_{pq}(z_i)\f$
    eOrtho_C,        //!< Principle Orthogonal Functions
                     //!< \f$\widetilde{\psi}^c_{pqr}(z_i)\f$
    eModified_A,     //!< Principle Modified Functions \f$ \phi^a_p(z_i) \f$
    eModified_B,     //!< Principle Modified Functions \f$ \phi^b_{pq}(z_i) \f$
    eModified_C,     //!< Principle Modified Functions \f$ \phi^c_{pqr}(z_i) \f$
    eOrthoPyr_C,     //!< Principle Orthogonal Functions
                     //!< \f$\widetilde{\psi}^c_{pqr}(z_i) for Pyramids\f$
    eModifiedPyr_C,  //!< Principle Modified Functions \f$ \phi^c_{pqr}(z_i) for
                     //!< Pyramids\f$
    eFourier,        //!< Fourier Expansion \f$ \exp(i p\pi  z_i)\f$
    eGLL_Lagrange,   //!< Lagrange for SEM basis \f$ h_p(z_i) \f$
    eGauss_Lagrange, //!< Lagrange Polynomials using the Gauss points \f$
                     //!< h_p(z_i) \f$
    eLegendre,  //!< Legendre Polynomials \f$ L_p(z_i) = P^{0,0}_p(z_i)\f$. Same
                //!< as Ortho_A
    eChebyshev, //!< Chebyshev Polynomials \f$ T_p(z_i) =
                //!< P^{-1/2,-1/2}_p(z_i)\f$
    eMonomial,  //!< Monomial polynomials \f$ L_p(z_i) = z_i^{p}\f$
    eFourierSingleMode, //!< Fourier ModifiedExpansion with just the first mode
                        //!< \f$ \exp(i \pi  z_i)\f$
    eFourierHalfModeRe, //!< Fourier Modified expansions with just the real part
                        //!< of the first mode  \f$ Re[\exp(i \pi  z_i)]\f$
    eFourierHalfModeIm, //!< Fourier Modified expansions with just the imaginary
                        //!< part of the first mode  \f$ Im[\exp(i \pi  z_i)]\f$
    SIZE_BasisType      //!< Length of enum list
};

EndianType

enum Nektar::LibUtilities::EndianType

Enumerator
eEndianUnknown
eEndianBig
eEndianLittle
eEndianBigWord
eEndianLittleWord

Definition at line 48 of file CompressData.h.

{
    eEndianUnknown,
    eEndianBig,
    eEndianLittle,
    eEndianBigWord,   /* Middle-endian, Honeywell 316 style */
    eEndianLittleWord /* Middle-endian, PDP-11 style */
};

FieldIOType

enum Nektar::LibUtilities::FieldIOType

Enumerator for auto-detection of FieldIO types.

Enumerator
eXML
eHDF5

Definition at line 77 of file FieldIO.cpp.

{
    eXML,
    eHDF5
};

FunctionType

enum Nektar::LibUtilities::FunctionType

Enumerator
eFunctionTypeExpression
eFunctionTypeFile
eFunctionTypeTransientFile
eSIZE_FunctionType

Definition at line 90 of file SessionReader.h.

{
    eFunctionTypeExpression,
    eFunctionTypeFile,
    eFunctionTypeTransientFile,
    eSIZE_FunctionType,
};

InterpMethod

enum Nektar::LibUtilities::InterpMethod

Enumerator
eNoMethod
eNearestNeighbour
eQuadratic
eShepard
eGauss

Definition at line 60 of file LibUtilities/BasicUtils/Interpolator.h.

{
    eNoMethod,
    eNearestNeighbour,
    eQuadratic,
    eShepard,
    eGauss,
};

PointsType

enum Nektar::LibUtilities::PointsType

Enumerator
eNoPointsType
eGaussGaussLegendre	1D Gauss-Gauss-Legendre quadrature points
eGaussRadauMLegendre	1D Gauss-Radau-Legendre quadrature points, pinned at x=-1
eGaussRadauPLegendre	1D Gauss-Radau-Legendre quadrature points, pinned at x=1
eGaussLobattoLegendre	1D Gauss-Lobatto-Legendre quadrature points
eGaussGaussChebyshev	1D Gauss-Gauss-Chebyshev quadrature points
eGaussRadauMChebyshev	1D Gauss-Radau-Chebyshev quadrature points, pinned at x=-1
eGaussRadauPChebyshev	1D Gauss-Radau-Chebyshev quadrature points, pinned at x=1
eGaussLobattoChebyshev	1D Gauss-Lobatto-Legendre quadrature points
eGaussRadauMAlpha0Beta1	Gauss Radau pinned at x=-1,.
beta	Gauss Radau pinned at x=-1,. 1D Gauss-Kronrod-Legendre quadrature points
beta	Gauss Radau pinned at x=-1,. 1D Gauss-Kronrod-Legendre quadrature points
beta	Gauss Radau pinned at x=-1,. 1D Gauss-Kronrod-Legendre quadrature points
beta	Gauss Radau pinned at x=-1,. 1D Gauss-Kronrod-Legendre quadrature points
eGaussRadauKronrodMLegendre	1D Gauss-Radau-Kronrod-Legendre quadrature points, pinned at x=-1
eGaussRadauKronrodMAlpha1Beta0	1D Gauss-Radau-Kronrod-Legendre pinned at x=-1,
eGaussLobattoKronrodLegendre	1D Lobatto Kronrod quadrature points
ePolyEvenlySpaced	1D Evenly-spaced points using Lagrange polynomial
eFourierEvenlySpaced	1D Evenly-spaced points using Fourier Fit
eFourierSingleModeSpaced	1D Non Evenly-spaced points for Single Mode analysis
eBoundaryLayerPoints	1D power law distribution for boundary layer points
eBoundaryLayerPointsRev	1D power law distribution for boundary layer points
eNodalTriElec	2D Nodal Electrostatic Points on a Triangle
eNodalTriFekete	2D Nodal Fekete Points on a Triangle
eNodalTriEvenlySpaced	2D Evenly-spaced points on a Triangle
eNodalTetEvenlySpaced	3D Evenly-spaced points on a Tetrahedron
eNodalTetElec	3D Nodal Electrostatic Points on a Tetrahedron
eNodalPrismEvenlySpaced	3D Evenly-spaced points on a Prism
eNodalPrismElec	3D electrostatically spaced points on a Prism
eNodalTriSPI	2D Nodal Symmetric positive internal triangle (Whitherden, Vincent)
eNodalTetSPI	3D Nodal Symmetric positive internal tet (Whitherden, Vincent)
eNodalPrismSPI	3D prism SPI
eNodalQuadElec	2D GLL for quad
eNodalHexElec	3D GLL for hex
SIZE_PointsType	Length of enum list.

Definition at line 43 of file PointsType.h.

{
    eNoPointsType,
    eGaussGaussLegendre,     //!<  1D Gauss-Gauss-Legendre quadrature points
    eGaussRadauMLegendre,    //!<  1D Gauss-Radau-Legendre quadrature points,
                             //!<  pinned at x=-1
    eGaussRadauPLegendre,    //!<  1D Gauss-Radau-Legendre quadrature points,
                             //!<  pinned at x=1
    eGaussLobattoLegendre,   //!<  1D Gauss-Lobatto-Legendre quadrature points
    eGaussGaussChebyshev,    //!<  1D Gauss-Gauss-Chebyshev quadrature points
    eGaussRadauMChebyshev,   //!<  1D Gauss-Radau-Chebyshev quadrature points,
                             //!<  pinned at x=-1
    eGaussRadauPChebyshev,   //!<  1D Gauss-Radau-Chebyshev quadrature points,
                             //!<  pinned at x=1
    eGaussLobattoChebyshev,  //!<  1D Gauss-Lobatto-Legendre quadrature points
    eGaussRadauMAlpha0Beta1, //!<  Gauss Radau pinned at x=-1, \f$ \alpha = 0,
                             //!<  \beta =    1 \f$
    eGaussRadauMAlpha0Beta2, //!<  Gauss Radau pinned at x=-1, \f$ \alpha = 0,
                             //!<  \beta =    2 \f$
    eGaussRadauMAlpha1Beta0, //!<  Gauss Radau pinned at x=-1, \f$ \alpha = 1,
                             //!<  \beta =    0 \f$
    eGaussRadauMAlpha2Beta0, //!<  Gauss Radau pinned at x=-1, \f$ \alpha = 2,
                             //!<  \beta =    0 \f$
    eGaussKronrodLegendre,   //!<  1D Gauss-Kronrod-Legendre quadrature points
    eGaussRadauKronrodMLegendre,    //!<  1D Gauss-Radau-Kronrod-Legendre
                                    //!<  quadrature points, pinned at x=-1
    eGaussRadauKronrodMAlpha1Beta0, //!<  1D Gauss-Radau-Kronrod-Legendre pinned
                                    //!<  at x=-1, \f$ \alpha =    1, \beta = 0
                                    //!<  \f$
    eGaussLobattoKronrodLegendre,   //!<  1D Lobatto Kronrod quadrature points
    ePolyEvenlySpaced, //!<  1D Evenly-spaced points using Lagrange polynomial
    eFourierEvenlySpaced,     //!<  1D Evenly-spaced points using Fourier Fit
    eFourierSingleModeSpaced, //!<  1D Non Evenly-spaced points for Single Mode
                              //!<  analysis
    eBoundaryLayerPoints,     //!<  1D power law distribution for boundary layer
                              //!<  points
    eBoundaryLayerPointsRev,  //!<  1D power law distribution for boundary layer
                              //!<  points
    eNodalTriElec,            //!<  2D Nodal Electrostatic Points on a Triangle
    eNodalTriFekete,          //!<  2D Nodal Fekete Points on a Triangle
    eNodalTriEvenlySpaced,    //!<  2D Evenly-spaced points on a Triangle
    eNodalTetEvenlySpaced,    //!<  3D Evenly-spaced points on a Tetrahedron
    eNodalTetElec, //!<  3D Nodal Electrostatic Points on a Tetrahedron
    eNodalPrismEvenlySpaced, //!<  3D Evenly-spaced points on a Prism
    eNodalPrismElec,         //!<  3D electrostatically spaced points on a Prism
    eNodalTriSPI,            //!<  2D Nodal Symmetric positive internal triangle
                             //!<  (Whitherden, Vincent)
    eNodalTetSPI,   //!<  3D Nodal Symmetric positive internal tet (Whitherden,
                    //!<  Vincent)
    eNodalPrismSPI, //!<  3D prism SPI
    eNodalQuadElec, //!<  2D GLL for quad
    eNodalHexElec,  //!<  3D GLL for hex
    SIZE_PointsType //!<  Length of enum list
};

PtsInfo

enum Nektar::LibUtilities::PtsInfo

Enumerator
eIsEquiSpacedData
ePtsPerElmtEdge

Definition at line 60 of file PtsField.h.

{
    eIsEquiSpacedData,
    ePtsPerElmtEdge
};

PtsType

enum Nektar::LibUtilities::PtsType

Enumerator
ePtsFile
ePtsLine
ePtsPlane
ePtsBox
ePtsSegBlock
ePtsTriBlock
ePtsTetBlock

Definition at line 49 of file PtsField.h.

{
    ePtsFile,
    ePtsLine,
    ePtsPlane,
    ePtsBox,
    ePtsSegBlock,
    ePtsTriBlock,
    ePtsTetBlock
};

ReduceOperator

enum Nektar::LibUtilities::ReduceOperator

Type of operation to perform in AllReduce.

Enumerator
ReduceSum
ReduceMax
ReduceMin
SIZE_ReduceOperator

Definition at line 64 of file Comm.h.

{
    ReduceSum,
    ReduceMax,
    ReduceMin,
    SIZE_ReduceOperator
};

ShapeType

enum Nektar::LibUtilities::ShapeType

Enumerator
eNoShapeType
ePoint
eSegment
eTriangle
eQuadrilateral
eTetrahedron
ePyramid
ePrism
eHexahedron
SIZE_ShapeType
Point
Seg
Tri
Quad
Tet
Pyr
Prism
Hex

Definition at line 51 of file ShapeType.hpp.

{
    eNoShapeType,
    ePoint,
    eSegment,
    eTriangle,
    eQuadrilateral,
    eTetrahedron,
    ePyramid,
    ePrism,
    eHexahedron,
    SIZE_ShapeType,
 
    // These are the short names used for MatrixFree operators
    Point = ePoint,
    Seg   = eSegment,
    Tri   = eTriangle,
    Quad  = eQuadrilateral,
    Tet   = eTetrahedron,
    Pyr   = ePyramid,
    Prism = ePrism,
    Hex   = eHexahedron,
};

TimeIntegrationSchemeType

enum Nektar::LibUtilities::TimeIntegrationSchemeType

Enumerator
eNoTimeIntegrationSchemeType
eExplicit	Formally explicit scheme.
eDiagonallyImplicit	Diagonally implicit scheme (e.g. the DIRK schemes)
eIMEX	Implicit Explicit General Linear Method.
eImplicit	Fully implicit scheme.
eExponential	Exponential scheme.
eFractionalInTime	Fractional in Time scheme.

Definition at line 129 of file TimeIntegrationTypes.hpp.

{
    eNoTimeIntegrationSchemeType,
    eExplicit,           //!< Formally explicit scheme
    eDiagonallyImplicit, //!< Diagonally implicit scheme (e.g. the DIRK schemes)
    eIMEX,               //!< Implicit Explicit General Linear Method
    eImplicit,           //!< Fully implicit scheme
    eExponential,        //!< Exponential scheme
    eFractionalInTime,   //!< Fractional in Time scheme
};

TranspositionDir

enum Nektar::LibUtilities::TranspositionDir

Enumerator
eXYtoZ
eZtoXY
eXtoYZ
eYZtoX
eYZtoZY
eZYtoYZ
eXtoY
eYtoZ
eZtoX
eNoTrans

Definition at line 49 of file Transposition.h.

{
    eXYtoZ,
    eZtoXY,
    eXtoYZ,
    eYZtoX,
    eYZtoZY,
    eZYtoYZ,
    eXtoY,
    eYtoZ,
    eZtoX,
    eNoTrans
};

Function Documentation

ang()

static NekDouble Nektar::LibUtilities::ang ( NekDouble  x, NekDouble  y  )

static

Definition at line 81 of file Interpreter/Interpreter.cpp.

{
    return (x != 0.0 || y != 0.0) ? atan2(y, x) : 0.0;
}

Referenced by Nektar::LibUtilities::Interpreter::ExpressionEvaluator::ExpressionEvaluator(), Nektar::LibUtilities::functions::functions(), Nektar::LibUtilities::Interpreter::ExpressionEvaluator::EvalAng::run_many(), and Nektar::LibUtilities::Interpreter::ExpressionEvaluator::EvalAng::run_once().

awgn()

NekDouble Nektar::LibUtilities::awgn

(

NekDouble

sigma

)

Definition at line 68 of file Interpreter/Interpreter.cpp.

{
 
    std::random_device rd;
    std::mt19937 gen(rd());
    return std::normal_distribution<>(0, sigma)(gen);
}

Referenced by Nektar::LibUtilities::functions::functions().

BasisManager()

BasisManagerT & Nektar::LibUtilities::BasisManager

(

void

)

Definition at line 46 of file ManagerAccess.cpp.

{
    static BasisManagerT instance;
    return instance;
}

Referenced by Basis_Create(), Nektar::LibUtilities::Basis::CalculateInterpMatrix(), Nektar::MultiRegions::ExpListHomogeneous1D::ExpListHomogeneous1D(), Nektar::MultiRegions::ExpListHomogeneous2D::ExpListHomogeneous2D(), Nektar::LibUtilities::Basis::GenBasis(), InterpCoeff1D(), InterpCoeff2D(), InterpCoeff3D(), Nektar::MultiRegions::ExpListHomogeneous2D::SetPaddingBase(), Nektar::StdRegions::StdExpansion::StdExpansion(), Nektar::MultiRegions::DisContField::v_AddTraceIntegral(), and Nektar::StdRegions::StdQuadExp::v_GenMatrix().

checked_cast()

template<class To , class Ti , class = typename std::enable_if< std::is_floating_point< typename std::remove_reference<Ti>::type>::value && std::is_integral< typename std::remove_reference<To>::type>::value>::type>

To Nektar::LibUtilities::checked_cast ( const Ti  param )

inline

checked cast from float types only to int types

Definition at line 51 of file CheckedCast.hpp.

{
    Ti min = std::numeric_limits<To>::min();
    Ti max = std::numeric_limits<To>::max();
    ASSERTL0(param >= min, "Casting would narrow (underflow).");
    ASSERTL0(param <= max, "Casting would narrow (overflow).");
    return static_cast<To>(param);
}

References ASSERTL0.

CommDataTypeGetSize()

int Nektar::LibUtilities::CommDataTypeGetSize

(

CommDataType

dt

)

Return the size in bytes of a data type dt.

Parameters

dt

Data type

Returns

Size of dt in bytes.

Definition at line 52 of file CommDataType.cpp.

{
#ifdef NEKTAR_USE_MPI
    int size;
    MPI_Type_size(dt, &size);
    return size;
#elif NEKTAR_USING_PETSC
    if (dt == MPI_CHAR)
        return sizeof(char);
    else if (dt == MPI_INT)
        return sizeof(int);
    else if (dt == MPI_UNSIGNED)
        return sizeof(unsigned);
    else if (dt == MPI_LONG)
        return sizeof(long);
    else if (dt == MPI_UNSIGNED_LONG)
        return sizeof(unsigned long);
    else if (dt == MPI_LONG_LONG)
        return sizeof(long long);
    else if (dt == MPI_UNSIGNED_LONG_LONG)
        return sizeof(unsigned long long);
    else if (dt == MPI_FLOAT)
        return sizeof(float);
    else if (dt == MPI_DOUBLE)
        return sizeof(double);
    else if (dt == MPI_LONG_DOUBLE)
        return sizeof(long double);
    return sizeof(int);
#else
    switch (dt)
    {
        case MPI_CHAR:
            return sizeof(char);
        case MPI_INT:
            return sizeof(int);
        case MPI_UNSIGNED:
            return sizeof(unsigned);
        case MPI_LONG:
            return sizeof(long);
        case MPI_UNSIGNED_LONG:
            return sizeof(unsigned long);
        case MPI_LONG_LONG:
            return sizeof(long long);
        case MPI_UNSIGNED_LONG_LONG:
            return sizeof(unsigned long long);
        case MPI_FLOAT:
            return sizeof(float);
        case MPI_DOUBLE:
            return sizeof(double);
        case MPI_LONG_DOUBLE:
            return sizeof(long double);
        default:
            ASSERTL0(false, "Unrecognised datatype!");
    }
    return sizeof(int);
#endif
}

References ASSERTL0, MPI_CHAR, MPI_DOUBLE, MPI_FLOAT, MPI_INT, MPI_LONG, MPI_LONG_DOUBLE, MPI_LONG_LONG, MPI_UNSIGNED, MPI_UNSIGNED_LONG, and MPI_UNSIGNED_LONG_LONG.

Referenced by Nektar::LibUtilities::CommSerial::v_Gather(), and Nektar::LibUtilities::CommSerial::v_Scatter().

Endianness()

EndianType Nektar::LibUtilities::Endianness

(

void

)

run time determination of endianness, returning an EndianType

Definition at line 65 of file CompressData.cpp.

{
    union
    {
        std::uint32_t value;
        std::uint8_t data[sizeof(std::uint32_t)];
    } number;
 
    number.data[0] = 0x00;
    number.data[1] = 0x01;
    number.data[2] = 0x02;
    number.data[3] = 0x03;
 
    switch (number.value)
    {
        case UINT32_C(0x00010203):
            return eEndianBig;
        case UINT32_C(0x03020100):
            return eEndianLittle;
        case UINT32_C(0x02030001):
            return eEndianBigWord;
        case UINT32_C(0x01000302):
            return eEndianLittleWord;
        default:
            return eEndianUnknown;
    }
}

References eEndianBig, eEndianBigWord, eEndianLittle, eEndianLittleWord, and eEndianUnknown.

Referenced by Nektar::LibUtilities::CompressData::GetCompressString(), and Nektar::FieldUtils::InputSemtex::v_Process().

FACTORYREGISTER() [1/53]

Nektar::LibUtilities::FACTORYREGISTER

(

AdamsBashforth

)

FACTORYREGISTER() [2/53]

Nektar::LibUtilities::FACTORYREGISTER

(

AdamsBashforthOrder1

)

FACTORYREGISTER() [3/53]

Nektar::LibUtilities::FACTORYREGISTER

(

AdamsBashforthOrder2

)

FACTORYREGISTER() [4/53]

Nektar::LibUtilities::FACTORYREGISTER

(

AdamsBashforthOrder3

)

FACTORYREGISTER() [5/53]

Nektar::LibUtilities::FACTORYREGISTER

(

AdamsBashforthOrder4

)

FACTORYREGISTER() [6/53]

Nektar::LibUtilities::FACTORYREGISTER

(

AdamsMoulton

)

FACTORYREGISTER() [7/53]

Nektar::LibUtilities::FACTORYREGISTER

(

AdamsMoultonOrder1

)

FACTORYREGISTER() [8/53]

Nektar::LibUtilities::FACTORYREGISTER

(

AdamsMoultonOrder2

)

FACTORYREGISTER() [9/53]

Nektar::LibUtilities::FACTORYREGISTER

(

AdamsMoultonOrder3

)

FACTORYREGISTER() [10/53]

Nektar::LibUtilities::FACTORYREGISTER

(

AdamsMoultonOrder4

)

FACTORYREGISTER() [11/53]

Nektar::LibUtilities::FACTORYREGISTER

(

BackwardEuler

)

FACTORYREGISTER() [12/53]

Nektar::LibUtilities::FACTORYREGISTER

(

BDFImplicit

)

FACTORYREGISTER() [13/53]

Nektar::LibUtilities::FACTORYREGISTER

(

BDFImplicitOrder1

)

FACTORYREGISTER() [14/53]

Nektar::LibUtilities::FACTORYREGISTER

(

BDFImplicitOrder2

)

FACTORYREGISTER() [15/53]

Nektar::LibUtilities::FACTORYREGISTER

(

BDFImplicitOrder3

)

FACTORYREGISTER() [16/53]

Nektar::LibUtilities::FACTORYREGISTER

(

BDFImplicitOrder4

)

FACTORYREGISTER() [17/53]

Nektar::LibUtilities::FACTORYREGISTER

(

ClassicalRungeKutta4

)

FACTORYREGISTER() [18/53]

Nektar::LibUtilities::FACTORYREGISTER

(

CNAB

)

FACTORYREGISTER() [19/53]

Nektar::LibUtilities::FACTORYREGISTER

(

DIRK

)

FACTORYREGISTER() [20/53]

Nektar::LibUtilities::FACTORYREGISTER

(

DIRKOrder1

)

FACTORYREGISTER() [21/53]

Nektar::LibUtilities::FACTORYREGISTER

(

DIRKOrder2

)

FACTORYREGISTER() [22/53]

Nektar::LibUtilities::FACTORYREGISTER

(

DIRKOrder3

)

FACTORYREGISTER() [23/53]

Nektar::LibUtilities::FACTORYREGISTER

(

DIRKOrder3_ES5

)

FACTORYREGISTER() [24/53]

Nektar::LibUtilities::FACTORYREGISTER

(

DIRKOrder4_ES6

)

FACTORYREGISTER() [25/53]

Nektar::LibUtilities::FACTORYREGISTER

(

Euler

)

FACTORYREGISTER() [26/53]

Nektar::LibUtilities::FACTORYREGISTER

(

EulerExponential

)

FACTORYREGISTER() [27/53]

Nektar::LibUtilities::FACTORYREGISTER

(

ForwardEuler

)

FACTORYREGISTER() [28/53]

Nektar::LibUtilities::FACTORYREGISTER

(

IMEX

)

FACTORYREGISTER() [29/53]

Nektar::LibUtilities::FACTORYREGISTER

(

IMEXdirk

)

FACTORYREGISTER() [30/53]

Nektar::LibUtilities::FACTORYREGISTER

(

IMEXdirk_1_1_1

)

FACTORYREGISTER() [31/53]

Nektar::LibUtilities::FACTORYREGISTER

(

IMEXdirk_1_2_1

)

FACTORYREGISTER() [32/53]

Nektar::LibUtilities::FACTORYREGISTER

(

IMEXdirk_1_2_2

)

FACTORYREGISTER() [33/53]

Nektar::LibUtilities::FACTORYREGISTER

(

IMEXdirk_2_2_2

)

FACTORYREGISTER() [34/53]

Nektar::LibUtilities::FACTORYREGISTER

(

IMEXdirk_2_3_2

)

FACTORYREGISTER() [35/53]

Nektar::LibUtilities::FACTORYREGISTER

(

IMEXdirk_2_3_3

)

FACTORYREGISTER() [36/53]

Nektar::LibUtilities::FACTORYREGISTER

(

IMEXdirk_3_4_3

)

FACTORYREGISTER() [37/53]

Nektar::LibUtilities::FACTORYREGISTER

(

IMEXdirk_4_4_3

)

FACTORYREGISTER() [38/53]

Nektar::LibUtilities::FACTORYREGISTER

(

IMEXGear

)

FACTORYREGISTER() [39/53]

Nektar::LibUtilities::FACTORYREGISTER

(

IMEXOrder1

)

FACTORYREGISTER() [40/53]

Nektar::LibUtilities::FACTORYREGISTER

(

IMEXOrder2

)

FACTORYREGISTER() [41/53]

Nektar::LibUtilities::FACTORYREGISTER

(

IMEXOrder3

)

FACTORYREGISTER() [42/53]

Nektar::LibUtilities::FACTORYREGISTER

(

IMEXOrder4

)

FACTORYREGISTER() [43/53]

Nektar::LibUtilities::FACTORYREGISTER

(

MCNAB

)

FACTORYREGISTER() [44/53]

Nektar::LibUtilities::FACTORYREGISTER

(

NoScheme

)

FACTORYREGISTER() [45/53]

Nektar::LibUtilities::FACTORYREGISTER

(

RungeKutta

)

FACTORYREGISTER() [46/53]

Nektar::LibUtilities::FACTORYREGISTER

(

RungeKutta1

)

FACTORYREGISTER() [47/53]

Nektar::LibUtilities::FACTORYREGISTER

(

RungeKutta2

)

FACTORYREGISTER() [48/53]

Nektar::LibUtilities::FACTORYREGISTER

(

RungeKutta2_ImprovedEuler

)

FACTORYREGISTER() [49/53]

Nektar::LibUtilities::FACTORYREGISTER

(

RungeKutta2_SSP

)

FACTORYREGISTER() [50/53]

Nektar::LibUtilities::FACTORYREGISTER

(

RungeKutta3

)

FACTORYREGISTER() [51/53]

Nektar::LibUtilities::FACTORYREGISTER

(

RungeKutta3_SSP

)

FACTORYREGISTER() [52/53]

Nektar::LibUtilities::FACTORYREGISTER

(

RungeKutta4

)

FACTORYREGISTER() [53/53]

Nektar::LibUtilities::FACTORYREGISTER

(

RungeKutta5

)

GetChildElementOrThrow()

TiXmlElement * Nektar::LibUtilities::GetChildElementOrThrow	(	const std::string &	filename,
		std::string	elementName,
		const TiXmlHandle &	docHandle
	)

Helper function that gets a pointer to a child element, or throws an exception if no such element exists

Definition at line 2562 of file BasicUtils/SessionReader.cpp.

{
    TiXmlElement *element = docHandle.FirstChildElement(elementName).Element();
 
    if (!element)
    {
        NEKERROR(ErrorUtil::efatal, "Unable to find '" + elementName +
                                        "' XML node in " + filename);
    }
 
    return element;
}

References Nektar::ErrorUtil::efatal, and NEKERROR.

Referenced by Nektar::LibUtilities::SessionReader::MergeDoc().

GetCommFactory()

CommFactory & Nektar::LibUtilities::GetCommFactory

(

)

Definition at line 60 of file Communication/Comm.cpp.

{
    static CommFactory instance;
    return instance;
}

Referenced by Nektar::LibUtilities::SessionReader::CreateComm(), Field_Init(), Import(), main(), Nektar::SpatialDomains::MeshPartition::ReadExpansions(), SessionReader_CreateInstance(), Nektar::SpatialDomains::MeshGraphHDF5::v_PartitionMesh(), Nektar::FieldUtils::ProcessInterpField::v_Process(), Nektar::FieldUtils::ProcessInterpPoints::v_Process(), Nektar::FieldUtils::ProcessPointDataToFld::v_Process(), Write(), and Nektar::FieldUtils::OutputFileBase::WriteFile().

GetFieldIOFactory()

FieldIOFactory & Nektar::LibUtilities::GetFieldIOFactory

(

)

Returns the FieldIO factory.

Definition at line 70 of file FieldIO.cpp.

{
    static FieldIOFactory instance;
    return instance;
}

Referenced by Nektar::LibUtilities::FieldIO::CreateDefault(), Nektar::LibUtilities::FieldIO::CreateForFile(), Nektar::MultiRegions::ExpList::ExtractCoeffsFromFile(), Nektar::FieldUtils::Field::FieldIOForFile(), Import(), Nektar::SpatialDomains::MeshPartition::ReadExpansions(), Nektar::FieldUtils::OutputFld::v_OutputFromData(), Nektar::FieldUtils::OutputFld::v_OutputFromExp(), Nektar::FieldUtils::OutputInfo::v_Process(), and Write().

GetNekLinSysIterFactory()

NekLinSysIterFactory & Nektar::LibUtilities::GetNekLinSysIterFactory

(

)

Definition at line 47 of file NekLinSysIter.cpp.

{
    static NekLinSysIterFactory instance;
    return instance;
}

Referenced by Nektar::LibUtilities::NekNonlinSys::NekNonlinSys(), Nektar::MultiRegions::GlobalLinSysIterativeFull::v_SolveLinearSystem(), and Nektar::MultiRegions::GlobalLinSysIterativeStaticCond::v_SolveLinearSystem().

GetNekNonlinSysFactory()

NekNonlinSysFactory & Nektar::LibUtilities::GetNekNonlinSysFactory

(

)

Definition at line 47 of file NekNonlinSys.cpp.

{
    static NekNonlinSysFactory instance;
    return instance;
}

Referenced by Nektar::CFSImplicit::InitialiseNonlinSysSolver().

GetNektarFFTFactory()

NektarFFTFactory & Nektar::LibUtilities::GetNektarFFTFactory

(

)

Definition at line 65 of file NektarFFT.cpp.

{
    static NektarFFTFactory instance;
    return instance;
}

Referenced by Nektar::LinearisedAdvection::DFT(), Nektar::SolverUtils::FileFieldInterpolator::DFT(), Nektar::MultiRegions::ExpListHomogeneous1D::ExpListHomogeneous1D(), Nektar::MultiRegions::ExpListHomogeneous2D::ExpListHomogeneous2D(), and Nektar::ForcingMovingBody::InitialiseCableModel().

GetNumberOfCoefficients() [1/2]

int Nektar::LibUtilities::GetNumberOfCoefficients ( ShapeType  shape, int  na, int  nb = 0, int  nc = 0  )

inline

Definition at line 345 of file ShapeType.hpp.

{
    int returnval = 0;
    switch (shape)
    {
        case eSegment:
            returnval = na;
            break;
        case eTriangle:
            returnval = StdTriData::getNumberOfCoefficients(na, nb);
            break;
        case eQuadrilateral:
            returnval = na * nb;
            break;
        case eTetrahedron:
            returnval = StdTetData::getNumberOfCoefficients(na, nb, nc);
            break;
        case ePyramid:
            returnval = StdPyrData::getNumberOfCoefficients(na, nb, nc);
            break;
        case ePrism:
            returnval = StdPrismData::getNumberOfCoefficients(na, nb, nc);
            break;
        case eHexahedron:
            returnval = na * nb * nc;
            break;
        default:
            NEKERROR(ErrorUtil::efatal, "Unknown Shape Type");
            break;
    }
 
    return returnval;
}

References Nektar::ErrorUtil::efatal, eHexahedron, ePrism, ePyramid, eQuadrilateral, eSegment, eTetrahedron, eTriangle, Nektar::LibUtilities::StdTriData::getNumberOfCoefficients(), Nektar::LibUtilities::StdTetData::getNumberOfCoefficients(), Nektar::LibUtilities::StdPyrData::getNumberOfCoefficients(), Nektar::LibUtilities::StdPrismData::getNumberOfCoefficients(), and NEKERROR.

GetNumberOfCoefficients() [2/2]

int Nektar::LibUtilities::GetNumberOfCoefficients ( ShapeType  shape, std::vector< unsigned int > &  modes, int  offset = 0  )

inline

Definition at line 305 of file ShapeType.hpp.

{
    int returnval = 0;
    switch (shape)
    {
        case eSegment:
            returnval = modes[offset];
            break;
        case eTriangle:
            returnval = StdTriData::getNumberOfCoefficients(modes[offset],
                                                            modes[offset + 1]);
            break;
        case eQuadrilateral:
            returnval = modes[offset] * modes[offset + 1];
            break;
        case eTetrahedron:
            returnval = StdTetData::getNumberOfCoefficients(
                modes[offset], modes[offset + 1], modes[offset + 2]);
            break;
        case ePyramid:
            returnval = StdPyrData::getNumberOfCoefficients(
                modes[offset], modes[offset + 1], modes[offset + 2]);
            break;
        case ePrism:
            returnval = StdPrismData::getNumberOfCoefficients(
                modes[offset], modes[offset + 1], modes[offset + 2]);
            break;
        case eHexahedron:
            returnval = modes[offset] * modes[offset + 1] * modes[offset + 2];
            break;
        default:
            NEKERROR(ErrorUtil::efatal, "Unknown Shape Type");
            break;
    }
 
    return returnval;
}

References Nektar::ErrorUtil::efatal, eHexahedron, ePrism, ePyramid, eQuadrilateral, eSegment, eTetrahedron, eTriangle, Nektar::LibUtilities::StdTriData::getNumberOfCoefficients(), Nektar::LibUtilities::StdTetData::getNumberOfCoefficients(), Nektar::LibUtilities::StdPyrData::getNumberOfCoefficients(), Nektar::LibUtilities::StdPrismData::getNumberOfCoefficients(), CG_Iterations::modes, and NEKERROR.

Referenced by Nektar::StdRegions::StdExpansion::PhysInterpToSimplexEquiSpaced(), Nektar::MultiRegions::ExpList::v_ExtractDataToCoeffs(), Nektar::MultiRegions::ExpListHomogeneous1D::v_ExtractDataToCoeffs(), and Nektar::FieldUtils::ProcessHalfModeToFourier::v_Process().

GetNumberOfDataPoints()

int Nektar::LibUtilities::GetNumberOfDataPoints	(	const FieldDefinitionsSharedPtr &	fielddefs,
		unsigned int &	cnt
	)

Compute the number of values needed to store elemental expansion.

Parameters

fielddefs	Field definitions
cnt	Counter into the fielddefs->m_numModes array. This variable is updated by the function

Definition at line 587 of file FieldIO.cpp.

{
    int NCoeffs = 0;
 
    switch (fielddefs->m_shapeType)
    {
        case eSegment:
        {
            int l = fielddefs->m_numModes[cnt++];
            if (fielddefs->m_numHomogeneousDir == 1)
            {
                NCoeffs = l * fielddefs->m_homogeneousZIDs.size();
                cnt++;
            }
            else if (fielddefs->m_numHomogeneousDir == 2)
            {
                NCoeffs = l * fielddefs->m_homogeneousYIDs.size();
                cnt += 2;
            }
            else
            {
                NCoeffs = l;
            }
        }
        break;
        case eTriangle:
        {
            int l = fielddefs->m_numModes[cnt++];
            int m = fielddefs->m_numModes[cnt++];
            if (fielddefs->m_numHomogeneousDir == 1)
            {
                NCoeffs = StdTriData::getNumberOfCoefficients(l, m) *
                          fielddefs->m_homogeneousZIDs.size();
                cnt++;
            }
            else
            {
                NCoeffs = StdTriData::getNumberOfCoefficients(l, m);
            }
        }
        break;
        case eQuadrilateral:
        {
            int l = fielddefs->m_numModes[cnt++];
            int m = fielddefs->m_numModes[cnt++];
            if (fielddefs->m_numHomogeneousDir == 1)
            {
                NCoeffs = StdQuadData::getNumberOfCoefficients(l, m) *
                          fielddefs->m_homogeneousZIDs.size();
                cnt++;
            }
            else
            {
                NCoeffs = StdQuadData::getNumberOfCoefficients(l, m);
            }
        }
        break;
        case eTetrahedron:
        {
            int l   = fielddefs->m_numModes[cnt++];
            int m   = fielddefs->m_numModes[cnt++];
            int n   = fielddefs->m_numModes[cnt++];
            NCoeffs = StdTetData::getNumberOfCoefficients(l, m, n);
        }
        break;
        case ePyramid:
        {
            int l   = fielddefs->m_numModes[cnt++];
            int m   = fielddefs->m_numModes[cnt++];
            int n   = fielddefs->m_numModes[cnt++];
            NCoeffs = StdPyrData::getNumberOfCoefficients(l, m, n);
        }
        break;
        case ePrism:
        {
            int l   = fielddefs->m_numModes[cnt++];
            int m   = fielddefs->m_numModes[cnt++];
            int n   = fielddefs->m_numModes[cnt++];
            NCoeffs = StdPrismData::getNumberOfCoefficients(l, m, n);
        }
        break;
        case eHexahedron:
        {
            int l   = fielddefs->m_numModes[cnt++];
            int m   = fielddefs->m_numModes[cnt++];
            int n   = fielddefs->m_numModes[cnt++];
            NCoeffs = StdHexData::getNumberOfCoefficients(l, m, n);
        }
        break;
        default:
            NEKERROR(ErrorUtil::efatal, "Unsupported shape type.");
            break;
    }
 
    return NCoeffs;
}

References Nektar::ErrorUtil::efatal, eHexahedron, ePrism, ePyramid, eQuadrilateral, eSegment, eTetrahedron, eTriangle, Nektar::LibUtilities::StdTriData::getNumberOfCoefficients(), Nektar::LibUtilities::StdQuadData::getNumberOfCoefficients(), Nektar::LibUtilities::StdHexData::getNumberOfCoefficients(), Nektar::LibUtilities::StdTetData::getNumberOfCoefficients(), Nektar::LibUtilities::StdPyrData::getNumberOfCoefficients(), Nektar::LibUtilities::StdPrismData::getNumberOfCoefficients(), and NEKERROR.

Referenced by Nektar::LibUtilities::FieldIO::CheckFieldDefinition(), and Nektar::LibUtilities::FieldIO::GetNumberOfCoeffsPerElement().

GetTimeIntegrationSchemeFactory()

LUE TimeIntegrationSchemeFactory & Nektar::LibUtilities::GetTimeIntegrationSchemeFactory

(

)

Definition at line 47 of file TimeIntegrationScheme.cpp.

{
    static TimeIntegrationSchemeFactory instance;
    return instance;
}

Referenced by Nektar::UnsteadyAdvectionDiffusion::SetUpSubSteppingTimeIntegration(), Diffusion::TimeIntegrate(), Nektar::SolverUtils::UnsteadySystem::v_InitObject(), and Nektar::SubSteppingExtrapolate::v_SubSteppingTimeIntegration().

Import()

void Nektar::LibUtilities::Import	(	const std::string &	infilename,
		std::vector< FieldDefinitionsSharedPtr > &	fielddefs,
		std::vector< std::vector< NekDouble > > &	fielddata,
		FieldMetaDataMap &	fieldinfomap,
		const Array< OneD, int > &	ElementIDs
	)

This function allows for data to be imported from an FLD file when a session and/or communicator is not instantiated. Typically used in utilities which only operate in serial.

Parameters

infilename	Input filename (or directory if parallel format)
fielddefs	On return contains field definitions as read from the input.
fielddata	On return, contains binary field data that stores the input corresponding to fielddefs.
fieldinfo	On returnm, contains the associated field metadata map.
ElementIDs	Element IDs that lie on this processor, which can be optionally supplied to avoid reading the entire file on each processor.

Definition at line 288 of file FieldIO.cpp.

{
#ifdef NEKTAR_USE_MPI
    int size;
    int init;
    MPI_Initialized(&init);
 
    // If MPI has been initialised we can check the number of processes
    // and, if > 1, tell the user he should not be running this
    // function in parallel. If it is not initialised, we do not
    // initialise it here, and assume the user knows what they are
    // doing.
    if (init)
    {
        MPI_Comm_size(MPI_COMM_WORLD, &size);
        ASSERTL0(size == 1,
                 "This static function is not available in parallel. Please"
                 "instantiate a FieldIO object for parallel use.");
    }
#endif
    CommSharedPtr c         = GetCommFactory().CreateInstance("Serial", 0, 0);
    const std::string iofmt = FieldIO::GetFileType(infilename, c);
    FieldIOSharedPtr f = GetFieldIOFactory().CreateInstance(iofmt, c, false);
    f->Import(infilename, fielddefs, fielddata, fieldinfomap, ElementIDs);
}

References ASSERTL0, Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::CreateInstance(), GetCommFactory(), GetFieldIOFactory(), and Nektar::LibUtilities::FieldIO::GetFileType().

Referenced by GetStreakLocation(), Nektar::SolverUtils::EquationSystem::ImportFldToMultiDomains(), and main().

Interp1D() [1/4]

void Nektar::LibUtilities::Interp1D	(	const BasisKey &	fbasis0,
		const Array< OneD, const NekDouble > &	from,
		const BasisKey &	tbasis0,
		Array< OneD, NekDouble > &	to
	)

this function interpolates a 1D function \(f\) evaluated at the quadrature points of the basis fbasis0 to the function values at the quadrature points of the basis tbasis0

Given a function \( f\) evaluated at the Q quadrature points of the basis fbasis0, this routine calculates, using (Q-1)th order polynomial interpolation, the function values at the Q2 quadrature points of the basis tbasis0.

Parameters

fbasis0	the basis at which's quadrature points the function is given
from	the array containg the function \( f\) evaluated at the quadrature points of fbasis0
tbasis0	the basis to which's quadrature points the function should be interpolated
to	the array containg the function \( f\) evaluated at the quadrature points of tbasis0 (output of the function)

Definition at line 47 of file Interp.cpp.

{
    Interp1D(fbasis0.GetPointsKey(), from, tbasis0.GetPointsKey(), to);
}

References Nektar::LibUtilities::BasisKey::GetPointsKey(), and Interp1D().

Referenced by Nektar::MultiRegions::ExpList::GetElmtNormalLength(), Nektar::SpatialDomains::GeomFactors::Interp(), Interp1D(), Nektar::LocalRegions::NodalTriExp::v_ComputeTraceNormal(), Nektar::LocalRegions::QuadExp::v_ComputeTraceNormal(), Nektar::LocalRegions::TriExp::v_ComputeTraceNormal(), Nektar::LocalRegions::SegExp::v_ExtractDataToCoeffs(), Nektar::LocalRegions::TriExp::v_FwdTransBndConstrained(), Nektar::LocalRegions::Expansion2D::v_GenMatrix(), Nektar::LocalRegions::Expansion::v_GetCoords(), Nektar::MultiRegions::ExpList::v_GetNormals(), Nektar::LocalRegions::QuadExp::v_GetTracePhysVals(), and Nektar::LocalRegions::TriExp::v_GetTracePhysVals().

Interp1D() [2/4]

void Nektar::LibUtilities::Interp1D	(	const BasisKey &	fbasis0,
		const NekDouble *	from,
		const BasisKey &	tbasis0,
		NekDouble *	to
	)

Definition at line 74 of file Interp.cpp.

{
    Interp1D(fbasis0.GetPointsKey(), from, tbasis0.GetPointsKey(), to);
}

References Nektar::LibUtilities::BasisKey::GetPointsKey(), and Interp1D().

Interp1D() [3/4]

void Nektar::LibUtilities::Interp1D	(	const PointsKey &	fpoints0,
		const Array< OneD, const NekDouble > &	from,
		const PointsKey &	tpoints0,
		Array< OneD, NekDouble > &	to
	)

Definition at line 53 of file Interp.cpp.

{
    if (fpoints0 == tpoints0) // check to see if the same
    {
        Vmath::Vcopy(fpoints0.GetNumPoints(), from, 1, to, 1);
    }
    else // interpolate
    {
        DNekMatSharedPtr I0;
 
        I0 = PointsManager()[fpoints0]->GetI(tpoints0);
 
        NekVector<NekDouble> in(fpoints0.GetNumPoints(), from, eWrapper);
        NekVector<NekDouble> out(tpoints0.GetNumPoints(), to, eWrapper);
 
        out = (*I0) * in;
    }
}

References Nektar::eWrapper, Nektar::LibUtilities::PointsKey::GetNumPoints(), PointsManager(), and Vmath::Vcopy().

Interp1D() [4/4]

void Nektar::LibUtilities::Interp1D	(	const PointsKey &	fpoints0,
		const NekDouble *	from,
		const PointsKey &	tpoints0,
		NekDouble *	to
	)

Definition at line 80 of file Interp.cpp.

{
    if (fpoints0 == tpoints0) // check to see if the same
    {
        Vmath::Vcopy(fpoints0.GetNumPoints(), from, 1, to, 1);
    }
    else // interpolate
    {
 
        DNekMatSharedPtr I0;
 
        I0 = PointsManager()[fpoints0]->GetI(tpoints0);
 
        Blas::Dgemv('N', tpoints0.GetNumPoints(), fpoints0.GetNumPoints(), 1.0,
                    I0->GetPtr().get(), tpoints0.GetNumPoints(), from, 1, 0.0,
                    to, 1);
    }
}

References Blas::Dgemv(), Nektar::LibUtilities::PointsKey::GetNumPoints(), PointsManager(), and Vmath::Vcopy().

Interp2D() [1/3]

void Nektar::LibUtilities::Interp2D	(	const BasisKey &	fbasis0,
		const BasisKey &	fbasis1,
		const Array< OneD, const NekDouble > &	from,
		const BasisKey &	tbasis0,
		const BasisKey &	tbasis1,
		Array< OneD, NekDouble > &	to
	)

this function interpolates a 2D function \(f\) evaluated at the quadrature points of the 2D basis, constructed by fbasis0 and fbasis1, to the function values at the quadrature points of the 2D basis, constructed by tbasis0 and tbasis1

Given a function \( f\) evaluated at the Q quadrature points of the first expansion basis, this routine calculates, using (Q-1)th order polynomial interpolation, the function values at the Q2 quadrature points of the second basis.

Parameters

fbasis0	the basis at which's quadrature points the function is given
from	the array containg the function \( f\) evaluated at the quadrature points of fbasis0
tbasis0	the basis to which's quadrature points the function should be interpolated
to	the array containg the function \( f\) evaluated at the quadrature points of tbasis0 (output of the function)

Definition at line 101 of file Interp.cpp.

{
    Interp2D(fbasis0.GetPointsKey(), fbasis1.GetPointsKey(), from.data(),
             tbasis0.GetPointsKey(), tbasis1.GetPointsKey(), to.data());
}

References Nektar::LibUtilities::BasisKey::GetPointsKey(), and Interp2D().

Referenced by Nektar::FieldUtils::ProcessEquiSpacedOutput::GenOrthoModes(), Nektar::MultiRegions::ExpList::GetElmtNormalLength(), Nektar::FieldUtils::ProcessQualityMetric::GetQ(), Nektar::SpatialDomains::GeomFactors::Interp(), Interp2D(), Nektar::GlobalMapping::UpdateGeometry(), Nektar::LocalRegions::HexExp::v_ComputeTraceNormal(), Nektar::LocalRegions::PrismExp::v_ComputeTraceNormal(), Nektar::LocalRegions::PyrExp::v_ComputeTraceNormal(), Nektar::LocalRegions::TetExp::v_ComputeTraceNormal(), Nektar::LocalRegions::QuadExp::v_ExtractDataToCoeffs(), Nektar::SpatialDomains::QuadGeom::v_FillGeom(), Nektar::SpatialDomains::TriGeom::v_FillGeom(), Nektar::LocalRegions::Expansion3D::v_GenMatrix(), Nektar::LocalRegions::Expansion::v_GetCoords(), Nektar::MultiRegions::ExpList::v_GetNormals(), and Nektar::LocalRegions::Expansion3D::v_GetTracePhysVals().

Interp2D() [2/3]

void Nektar::LibUtilities::Interp2D	(	const PointsKey &	fpoints0,
		const PointsKey &	fpoints1,
		const Array< OneD, const NekDouble > &	from,
		const PointsKey &	tpoints0,
		const PointsKey &	tpoints1,
		Array< OneD, NekDouble > &	to
	)

Definition at line 109 of file Interp.cpp.

{
    Interp2D(fpoints0, fpoints1, from.data(), tpoints0, tpoints1, to.data());
}

References Interp2D().

Interp2D() [3/3]

void Nektar::LibUtilities::Interp2D	(	const PointsKey &	fpoints0,
		const PointsKey &	fpoints1,
		const NekDouble *	from,
		const PointsKey &	tpoints0,
		const PointsKey &	tpoints1,
		NekDouble *	to
	)

Definition at line 117 of file Interp.cpp.

{
    // default interpolation
    if ((fpoints0 == tpoints0) && (fpoints1 == tpoints1))
    {
        Vmath::Vcopy(tpoints0.GetNumPoints() * tpoints1.GetNumPoints(), from, 1,
                     to, 1);
        return;
    }
 
    DNekMatSharedPtr I0, I1;
    Array<OneD, NekDouble> wsp(tpoints1.GetNumPoints() *
                               fpoints0.GetNumPoints()); // fnp0*tnp1
 
    size_t fnp0 = fpoints0.GetNumPoints();
    size_t fnp1 = fpoints1.GetNumPoints();
    size_t tnp0 = tpoints0.GetNumPoints();
    size_t tnp1 = tpoints1.GetNumPoints();
 
    if (fpoints1 == tpoints1)
    {
        Vmath::Vcopy(fnp0 * tnp1, from, 1, wsp.get(), 1);
    }
    else
    {
        I1 = PointsManager()[fpoints1]->GetI(tpoints1);
        Blas::Dgemm('N', 'T', fnp0, tnp1, fnp1, 1.0, from, fnp0,
                    I1->GetPtr().get(), tnp1, 0.0, wsp.get(), fnp0);
    }
 
    if (fpoints0 == tpoints0)
    {
        Vmath::Vcopy(tnp0 * tnp1, wsp.get(), 1, to, 1);
    }
    else
    {
        I0 = PointsManager()[fpoints0]->GetI(tpoints0);
        Blas::Dgemm('N', 'N', tnp0, tnp1, fnp0, 1.0, I0->GetPtr().get(), tnp0,
                    wsp.get(), fnp0, 0.0, to, tnp0);
    }
}

References Blas::Dgemm(), Nektar::LibUtilities::PointsKey::GetNumPoints(), PointsManager(), and Vmath::Vcopy().

Interp3D() [1/3]

void Nektar::LibUtilities::Interp3D	(	const BasisKey &	fbasis0,
		const BasisKey &	fbasis1,
		const BasisKey &	fbasis2,
		const Array< OneD, const NekDouble > &	from,
		const BasisKey &	tbasis0,
		const BasisKey &	tbasis1,
		const BasisKey &	tbasis2,
		Array< OneD, NekDouble > &	to
	)

this function interpolates a 3D function \(f\) evaluated at the quadrature points of the 3D basis, constructed by fbasis0, fbasis1, and fbasis2 to the function values at the quadrature points of the 3D basis, constructed by tbasis0, tbasis1, and tbasis2.

Given a function \( f\) evaluated at the Q quadrature points of the first expansion basis, this routine calculates, using (Q-1)th order polynomial interpolation, the function values at the Q2 quadrature points of the second basis, and the function values at the Q3 quadrature points of the third basis.

Parameters

fbasis0	the basis at which's quadrature points the function is given
from	the array containg the function \( f\) evaluated at the quadrature points of fbasis0
tbasis0	the basis to which's quadrature points the function should be interpolated
to	the array containg the function \( f\) evaluated at the quadrature points of tbasis0 (output of the function)

Definition at line 162 of file Interp.cpp.

{
    Interp3D(fbasis0.GetPointsKey(), fbasis1.GetPointsKey(),
             fbasis2.GetPointsKey(), from.data(), tbasis0.GetPointsKey(),
             tbasis1.GetPointsKey(), tbasis2.GetPointsKey(), to.data());
}

References Nektar::LibUtilities::BasisKey::GetPointsKey(), and Interp3D().

Referenced by Nektar::FieldUtils::ProcessQualityMetric::GetQ(), Nektar::SpatialDomains::GeomFactors::Interp(), Interp3D(), Nektar::LocalRegions::HexExp::v_ExtractDataToCoeffs(), and Nektar::LocalRegions::Expansion::v_GetCoords().

Interp3D() [2/3]

void Nektar::LibUtilities::Interp3D	(	const PointsKey &	fpoints0,
		const PointsKey &	fpoints1,
		const PointsKey &	fpoints2,
		const Array< OneD, const NekDouble > &	from,
		const PointsKey &	tpoints0,
		const PointsKey &	tpoints1,
		const PointsKey &	tpoints2,
		Array< OneD, NekDouble > &	to
	)

Definition at line 172 of file Interp.cpp.

{
    Interp3D(fpoints0, fpoints1, fpoints2, from.data(), tpoints0, tpoints1,
             tpoints2, to.data());
}

References Interp3D().

Interp3D() [3/3]

void Nektar::LibUtilities::Interp3D	(	const PointsKey &	fpoints0,
		const PointsKey &	fpoints1,
		const PointsKey &	fpoints2,
		const NekDouble *	from,
		const PointsKey &	tpoints0,
		const PointsKey &	tpoints1,
		const PointsKey &	tpoints2,
		NekDouble *	to
	)

Definition at line 182 of file Interp.cpp.

{
    size_t i;
    DNekMatSharedPtr I0, I1, I2;
 
    size_t fnp0 = fpoints0.GetNumPoints();
    size_t fnp1 = fpoints1.GetNumPoints();
    size_t fnp2 = fpoints2.GetNumPoints();
    size_t tnp0 = tpoints0.GetNumPoints();
    size_t tnp1 = tpoints1.GetNumPoints();
    size_t tnp2 = tpoints2.GetNumPoints();
 
    Array<OneD, NekDouble> wsp1(tnp0 * tnp1 * fnp2);
    Array<OneD, NekDouble> wsp2(tnp0 * fnp1 * fnp2);
 
    I0 = PointsManager()[fpoints0]->GetI(tpoints0);
    I1 = PointsManager()[fpoints1]->GetI(tpoints1);
    I2 = PointsManager()[fpoints2]->GetI(tpoints2);
 
    Blas::Dgemm('N', 'N', tnp0, fnp1 * fnp2, fnp0, 1.0, I0->GetPtr().get(),
                tnp0, from, fnp0, 0.0, wsp2.get(), tnp0);
 
    for (i = 0; i < fnp2; i++)
    {
        Blas::Dgemm('N', 'T', tnp0, tnp1, fnp1, 1.0,
                    wsp2.get() + i * tnp0 * fnp1, tnp0, I1->GetPtr().get(),
                    tnp1, 0.0, wsp1.get() + i * tnp0 * tnp1, tnp0);
    }
 
    Blas::Dgemm('N', 'T', tnp0 * tnp1, tnp2, fnp2, 1.0, wsp1.get(), tnp0 * tnp1,
                I2->GetPtr().get(), tnp2, 0.0, to, tnp0 * tnp1);
}

References Blas::Dgemm(), Nektar::LibUtilities::PointsKey::GetNumPoints(), and PointsManager().

InterpCoeff1D()

void Nektar::LibUtilities::InterpCoeff1D	(	const BasisKey &	fbasis0,
		const Array< OneD, const NekDouble > &	from,
		const BasisKey &	tbasis0,
		Array< OneD, NekDouble > &	to
	)

Definition at line 42 of file InterpCoeff.cpp.

{
    ASSERTL0(fbasis0.GetNumModes() == tbasis0.GetNumModes(),
             "Number of modes must be the same for "
             "interpolating coefficients");
 
    // Check to see if the same basis
    if (fbasis0.GetBasisType() == tbasis0.GetBasisType())
    {
        Vmath::Vcopy(fbasis0.GetNumModes(), from, 1, to, 1);
    }
    else
    {
        // interpolate
        DNekMatSharedPtr ftB = BasisManager()[fbasis0]->GetI(tbasis0);
 
        NekVector<NekDouble> in(fbasis0.GetNumModes(), from, eWrapper);
        NekVector<NekDouble> out(tbasis0.GetNumModes(), to, eWrapper);
 
        out = (*ftB) * in;
    }
}

References ASSERTL0, BasisManager(), Nektar::eWrapper, Nektar::LibUtilities::BasisKey::GetBasisType(), Nektar::LibUtilities::BasisKey::GetNumModes(), and Vmath::Vcopy().

Referenced by Nektar::LocalRegions::Expansion2D::v_AddEdgeNormBoundaryInt(), Nektar::StdRegions::StdSegExp::v_ReduceOrderCoeffs(), and Nektar::SolverUtils::FilterEnergy1D::v_Update().

InterpCoeff2D() [1/2]

void Nektar::LibUtilities::InterpCoeff2D	(	const BasisKey &	fbasis0,
		const BasisKey &	fbasis1,
		const Array< OneD, const NekDouble > &	from,
		const BasisKey &	tbasis0,
		const BasisKey &	tbasis1,
		Array< OneD, NekDouble > &	to
	)

Definition at line 67 of file InterpCoeff.cpp.

{
    InterpCoeff2D(fbasis0, fbasis1, from.data(), tbasis0, tbasis1, to.data());
}

References InterpCoeff2D().

Referenced by InterpCoeff2D(), Nektar::LocalRegions::QuadExp::v_ReduceOrderCoeffs(), and Nektar::StdRegions::StdQuadExp::v_ReduceOrderCoeffs().

InterpCoeff2D() [2/2]

void Nektar::LibUtilities::InterpCoeff2D	(	const BasisKey &	fbasis0,
		const BasisKey &	fbasis1,
		const NekDouble *	from,
		const BasisKey &	tbasis0,
		const BasisKey &	tbasis1,
		NekDouble *	to
	)

Definition at line 75 of file InterpCoeff.cpp.

{
    const size_t fnm0 = fbasis0.GetNumModes();
    const size_t fnm1 = fbasis1.GetNumModes();
    const size_t tnm0 = tbasis0.GetNumModes();
    const size_t tnm1 = tbasis1.GetNumModes();
 
    Array<OneD, NekDouble> wsp(tnm1 * fnm0);
 
    if (fbasis1.GetBasisType() == tbasis1.GetBasisType())
    {
        Vmath::Vcopy(fnm0 * tnm1, from, 1, wsp.get(), 1);
    }
    else
    {
        // interpolate
        DNekMatSharedPtr ft1 = BasisManager()[fbasis1]->GetI(tbasis1);
 
        Blas::Dgemm('N', 'T', fnm0, tnm1, fnm1, 1.0, from, fnm0,
                    ft1->GetPtr().get(), tnm1, 0.0, wsp.get(), fnm0);
    }
 
    if (fbasis0.GetBasisType() == tbasis0.GetBasisType())
    {
        Vmath::Vcopy(tnm0 * tnm1, wsp.get(), 1, to, 1);
    }
    else
    {
        // interpolate
        DNekMatSharedPtr ft0 = BasisManager()[fbasis0]->GetI(tbasis0);
 
        Blas::Dgemm('N', 'N', tnm0, tnm1, fnm0, 1.0, ft0->GetPtr().get(), tnm0,
                    wsp.get(), fnm0, 0.0, to, tnm0);
    }
}

References BasisManager(), Blas::Dgemm(), Nektar::LibUtilities::BasisKey::GetBasisType(), Nektar::LibUtilities::BasisKey::GetNumModes(), and Vmath::Vcopy().

InterpCoeff3D() [1/2]

void Nektar::LibUtilities::InterpCoeff3D	(	const BasisKey &	fbasis0,
		const BasisKey &	fbasis1,
		const BasisKey &	fbasis2,
		const Array< OneD, const NekDouble > &	from,
		const BasisKey &	tbasis0,
		const BasisKey &	tbasis1,
		const BasisKey &	tbasis2,
		Array< OneD, NekDouble > &	to
	)

Definition at line 113 of file InterpCoeff.cpp.

{
    InterpCoeff3D(fbasis0, fbasis1, fbasis2, from.data(), tbasis0, tbasis1,
                  tbasis2, to.data());
}

References InterpCoeff3D().

Referenced by InterpCoeff3D(), and Nektar::LocalRegions::HexExp::v_ReduceOrderCoeffs().

InterpCoeff3D() [2/2]

void Nektar::LibUtilities::InterpCoeff3D	(	const BasisKey &	fbasis0,
		const BasisKey &	fbasis1,
		const BasisKey &	fbasis2,
		const NekDouble *	from,
		const BasisKey &	tbasis0,
		const BasisKey &	tbasis1,
		const BasisKey &	tbasis2,
		NekDouble *	to
	)

Definition at line 123 of file InterpCoeff.cpp.

{
    const size_t fnm0 = fbasis0.GetNumModes();
    const size_t fnm1 = fbasis1.GetNumModes();
    const size_t fnm2 = fbasis2.GetNumModes();
    const size_t tnm0 = tbasis0.GetNumModes();
    const size_t tnm1 = tbasis1.GetNumModes();
    const size_t tnm2 = tbasis2.GetNumModes();
 
    Array<OneD, NekDouble> wsp1(tnm0 * tnm1 * fnm2);
    Array<OneD, NekDouble> wsp2(tnm0 * fnm1 * fnm2);
 
    DNekMatSharedPtr ft0 = BasisManager()[fbasis0]->GetI(tbasis0);
    DNekMatSharedPtr ft1 = BasisManager()[fbasis1]->GetI(tbasis1);
    DNekMatSharedPtr ft2 = BasisManager()[fbasis2]->GetI(tbasis2);
 
    Blas::Dgemm('N', 'N', tnm0, fnm1 * fnm2, fnm0, 1.0, ft0->GetPtr().get(),
                tnm0, from, fnm0, 0.0, wsp2.get(), tnm0);
 
    for (size_t i = 0; i < fnm2; i++)
    {
        Blas::Dgemm('N', 'T', tnm0, tnm1, fnm1, 1.0,
                    wsp2.get() + i * tnm0 * fnm1, tnm0, ft1->GetPtr().get(),
                    tnm1, 0.0, wsp1.get() + i * tnm0 * tnm1, tnm0);
    }
 
    Blas::Dgemm('N', 'T', tnm0 * tnm1, tnm2, fnm2, 1.0, wsp1.get(), tnm0 * tnm1,
                ft2->GetPtr().get(), tnm2, 0.0, to, tnm0 * tnm1);
}

References BasisManager(), Blas::Dgemm(), and Nektar::LibUtilities::BasisKey::GetNumModes().

IsRealClose()

template<class T1 , class T2 , class = typename std::enable_if< std::is_floating_point<typename std::remove_cv< typename std::remove_reference<T1>::type>::type>::value && std::is_same<typename std::remove_cv< typename std::remove_reference<T1>::type>::type, typename std::remove_cv<typename std::remove_reference< T2>::type>::type>::value>::type>

bool Nektar::LibUtilities::IsRealClose ( T1 &&  lhs, T2 &&  rhs, const NekDouble  tol = NekConstants::kNekMachineEpsilon  )

inline

compare reals of same type with absolute tolerance

Definition at line 76 of file RealComparison.hpp.

{
    // Check if tolerance is positive
    ASSERTL1(tol >= 0, "real comparison tolerance needs to be >= 0");
    // Check if distance is within tolerance
    return std::abs(lhs - rhs) < tol;
}

References tinysimd::abs(), and ASSERTL1.

IsRealEqual()

template<class T1 , class T2 , class = typename std::enable_if< std::is_floating_point<typename std::remove_cv< typename std::remove_reference<T1>::type>::type>::value && std::is_same<typename std::remove_cv< typename std::remove_reference<T1>::type>::type, typename std::remove_cv<typename std::remove_reference< T2>::type>::type>::value>::type>

bool Nektar::LibUtilities::IsRealEqual ( T1 &&  lhs, T2 &&  rhs, const unsigned int  factor = NekConstants::kNekFloatCompFact  )

inline

compare reals of same type with relative tolerance

Definition at line 56 of file RealComparison.hpp.

{
    // Check precondition in debug mode
    ASSERTL1(factor >= 1, "real comparison factor needs to be >= 1");
    // Relative distance normalized by machine epsilon
    return boost::math::epsilon_difference(lhs, rhs) < factor;
}

References ASSERTL1.

Referenced by Nektar::RealComparisonUnitTests::BOOST_AUTO_TEST_CASE(), and Nektar::IsEqualImpl().

NullBasisKey()

static const BasisKey Nektar::LibUtilities::NullBasisKey ( eNoBasisType  , 0  , NullPointsKey    )

static

Defines a null basis with no type or points.

Referenced by Nektar::MultiRegions::ExpList::CreateCollections(), Nektar::StdRegions::EvaluateQuadFaceBasisKey(), Nektar::StdRegions::EvaluateTriFaceBasisKey(), Nektar::MultiRegions::ExpList::ExpList(), Nektar::MultiRegions::ExpListHomogeneous1D::ExpListHomogeneous1D(), Nektar::MultiRegions::ExpListHomogeneous2D::ExpListHomogeneous2D(), Nektar::StdRegions::StdExpansion::StdExpansion(), Nektar::StdRegions::StdTriExp::v_GetTraceBasisKey(), Nektar::StdRegions::StdExpansion::v_GetTraceBasisKey(), Nektar::StdRegions::StdPrismExp::v_GetTraceBasisKey(), Nektar::StdRegions::StdPyrExp::v_GetTraceBasisKey(), and Nektar::StdRegions::StdTetExp::v_GetTraceBasisKey().

NullPointsKey()

static const PointsKey Nektar::LibUtilities::NullPointsKey ( 0  , eNoPointsType    )

static

Referenced by Nektar::StdRegions::StdExpansion::v_GetNodalPointsKey(), and Nektar::StdRegions::StdExpansion::v_GetTracePointsKey().

operator!=() [1/4]

bool Nektar::LibUtilities::operator!=	(	const BasisKey &	x,
		const BasisKey &	y
	)

Definition at line 922 of file Foundations/Basis.cpp.

{
    return (!(x == y));
}

operator!=() [2/4]

bool Nektar::LibUtilities::operator!=	(	const BasisKey &	x,
		const BasisKey *	y
	)

Definition at line 934 of file Foundations/Basis.cpp.

{
    return (!(x == *y));
}

operator!=() [3/4]

bool Nektar::LibUtilities::operator!=	(	const BasisKey *	x,
		const BasisKey &	y
	)

Definition at line 928 of file Foundations/Basis.cpp.

{
    return (!(*x == y));
}

operator!=() [4/4]

bool Nektar::LibUtilities::operator!=	(	const GraphVertexObject &	x,
		const GraphVertexObject &	y
	)

Definition at line 60 of file Graph.cpp.

{
    return (x.m_id != y.m_id);
}

operator<() [1/2]

bool Nektar::LibUtilities::operator<	(	const BasisKey &	lhs,
		const BasisKey &	rhs
	)

Definition at line 44 of file Foundations/Basis.cpp.

{
    PointsKey lhsPointsKey = lhs.GetPointsKey();
    PointsKey rhsPointsKey = rhs.GetPointsKey();
 
    if (lhsPointsKey < rhsPointsKey)
    {
        return true;
    }
    if (lhsPointsKey != rhsPointsKey)
    {
        return false;
    }
 
    if (lhs.m_nummodes < rhs.m_nummodes)
    {
        return true;
    }
    if (lhs.m_nummodes > rhs.m_nummodes)
    {
        return false;
    }
 
    return (lhs.m_basistype < rhs.m_basistype);
}

operator<() [2/2]

bool Nektar::LibUtilities::operator<	(	const PointsKey &	lhs,
		const PointsKey &	rhs
	)

Definition at line 51 of file Foundations/Points.cpp.

{
    if (lhs.m_pointstype < rhs.m_pointstype)
    {
        return true;
    }
 
    if (lhs.m_pointstype > rhs.m_pointstype)
    {
        return false;
    }
 
    if (lhs.m_numpoints < rhs.m_numpoints)
    {
        return true;
    }
 
    if (lhs.m_numpoints > rhs.m_numpoints)
    {
        return false;
    }
 
    if (lhs.m_factor < rhs.m_factor)
    {
        return true;
    }
 
    if (lhs.m_factor > rhs.m_factor)
    {
        return false;
    }
 
    return false;
}

operator<<() [1/14]

std::ostream & Nektar::LibUtilities::operator<<	(	std::ostream &	os,
		const BasisKey &	rhs
	)

Definition at line 81 of file Foundations/Basis.cpp.

{
    os << "NumModes: " << rhs.GetNumModes()
       << " BasisType: " << BasisTypeMap[rhs.GetBasisType()];
    os << " " << rhs.GetPointsKey() << std::endl;
 
    return os;
}

References BasisTypeMap, Nektar::LibUtilities::BasisKey::GetBasisType(), Nektar::LibUtilities::BasisKey::GetNumModes(), and Nektar::LibUtilities::BasisKey::GetPointsKey().

operator<<() [2/14]

LUE std::ostream & Nektar::LibUtilities::operator<<	(	std::ostream &	os,
		const FractionalInTimeIntegrationScheme &	rhs
	)

Definition at line 1070 of file TimeIntegrationSchemeFIT.cpp.

{
    rhs.print(os);
 
    return os;
}

operator<<() [3/14]

LUE std::ostream & Nektar::LibUtilities::operator<<	(	std::ostream &	os,
		const FractionalInTimeIntegrationSchemeSharedPtr &	rhs
	)

Definition at line 1078 of file TimeIntegrationSchemeFIT.cpp.

{
    os << *rhs.get();
 
    return os;
}

operator<<() [4/14]

std::ostream & Nektar::LibUtilities::operator<<	(	std::ostream &	os,
		const PointsKey &	rhs
	)

Definition at line 92 of file Foundations/Points.cpp.

{
    os << "NumPoints: " << rhs.GetNumPoints()
       << " PointsType: " << kPointsTypeStr[rhs.GetPointsType()] << std::endl;
 
    return os;
}

References Nektar::LibUtilities::PointsKey::GetNumPoints(), Nektar::LibUtilities::PointsKey::GetPointsType(), and kPointsTypeStr.

operator<<() [5/14]

LUE std::ostream & Nektar::LibUtilities::operator<<	(	std::ostream &	os,
		const TimeIntegrationAlgorithmGLM &	rhs
	)

Definition at line 932 of file TimeIntegrationAlgorithmGLM.cpp.

{
    size_t r                       = rhs.m_numsteps;
    size_t s                       = rhs.m_numstages;
    TimeIntegrationSchemeType type = rhs.m_schemeType;
 
    size_t oswidth     = 9;
    size_t osprecision = 6;
 
    os << "Time Integration Scheme (Master): " << rhs.m_parent->GetFullName()
       << "\n"
       << "Time Integration Phase  : " << rhs.m_name << "\n"
       << "- number of steps:  " << r << "\n"
       << "- number of stages: " << s << "\n"
       << "General linear method tableau:\n";
 
    for (size_t i = 0; i < s; i++)
    {
        for (size_t j = 0; j < s; j++)
        {
            os.width(oswidth);
            os.precision(osprecision);
            os << std::right << rhs.A(i, j) << " ";
        }
        if (type == eIMEX)
        {
            os << " '";
            for (size_t j = 0; j < s; j++)
            {
                os.width(oswidth);
                os.precision(osprecision);
                os << std::right << rhs.A_IMEX(i, j) << " ";
            }
        }
 
        os << " |";
 
        for (size_t j = 0; j < r; j++)
        {
            os.width(oswidth);
            os.precision(osprecision);
            os << std::right << rhs.U(i, j);
        }
        os << std::endl;
    }
 
    size_t imexflag = (type == eIMEX) ? 2 : 1;
    for (size_t i = 0;
         i < (r + imexflag * s) * (oswidth + 1) + imexflag * 2 - 1; i++)
    {
        os << "-";
    }
    os << std::endl;
 
    for (size_t i = 0; i < r; i++)
    {
        for (size_t j = 0; j < s; j++)
        {
            os.width(oswidth);
            os.precision(osprecision);
            os << std::right << rhs.B(i, j) << " ";
        }
        if (type == eIMEX)
        {
            os << " '";
            for (size_t j = 0; j < s; j++)
            {
                os.width(oswidth);
                os.precision(osprecision);
                os << std::right << rhs.B_IMEX(i, j) << " ";
            }
        }
 
        os << " |";
 
        for (size_t j = 0; j < r; j++)
        {
            os.width(oswidth);
            os.precision(osprecision);
            os << std::right << rhs.V(i, j);
        }
 
        os << "  |";
 
        os.width(oswidth);
        os.precision(osprecision);
        os << std::right << rhs.m_timeLevelOffset[i];
 
        if (i < rhs.m_numMultiStepValues)
        {
            os << std::right << " value";
        }
        else
        {
            os << std::right << " derivative";
        }
 
        os << std::endl;
    }
 
    if (type == eExponential)
    {
        for (size_t k = 0; k < rhs.m_nvars; k++)
        {
            os << std::endl
               << "General linear method exponential tableau for variable " << k
               << ":\n";
 
            for (size_t i = 0; i < s; i++)
            {
                for (size_t j = 0; j < s; j++)
                {
                    os.width(oswidth);
                    os.precision(osprecision);
                    os << std::right << rhs.A(k, i, j) << " ";
                }
 
                os << " |";
 
                for (size_t j = 0; j < r; j++)
                {
                    os.width(oswidth);
                    os.precision(osprecision);
                    os << std::right << rhs.B(k, i, j);
                }
                os << std::endl;
            }
 
            size_t imexflag = (type == eIMEX) ? 2 : 1;
            for (size_t i = 0;
                 i < (r + imexflag * s) * (oswidth + 1) + imexflag * 2 - 1; i++)
            {
                os << "-";
            }
            os << std::endl;
 
            for (size_t i = 0; i < r; i++)
            {
                for (size_t j = 0; j < s; j++)
                {
                    os.width(oswidth);
                    os.precision(osprecision);
                    os << std::right << rhs.B(k, i, j) << " ";
                }
 
                os << " |";
 
                for (size_t j = 0; j < r; j++)
                {
                    os.width(oswidth);
                    os.precision(osprecision);
                    os << std::right << rhs.V(k, i, j);
                }
                os << std::endl;
            }
        }
    }
 
    return os;
} // end function operator<<

operator<<() [6/14]

LUE std::ostream & Nektar::LibUtilities::operator<<	(	std::ostream &	os,
		const TimeIntegrationAlgorithmGLMSharedPtr &	rhs
	)

Definition at line 926 of file TimeIntegrationAlgorithmGLM.cpp.

{
    return operator<<(os, *rhs);
}

operator<<() [7/14]

LUE std::ostream & Nektar::LibUtilities::operator<<	(	std::ostream &	os,
		const TimeIntegrationScheme &	rhs
	)

Definition at line 66 of file TimeIntegrationScheme.cpp.

{
    rhs.print(os);
 
    return os;
}

operator<<() [8/14]

LUE std::ostream & Nektar::LibUtilities::operator<<	(	std::ostream &	os,
		const TimeIntegrationSchemeGEM &	rhs
	)

Definition at line 428 of file TimeIntegrationSchemeGEM.cpp.

{
    rhs.print(os);
 
    return os;
}

References Nektar::LibUtilities::TimeIntegrationScheme::print().

operator<<() [9/14]

LUE std::ostream & Nektar::LibUtilities::operator<<	(	std::ostream &	os,
		const TimeIntegrationSchemeGEMSharedPtr &	rhs
	)

Definition at line 435 of file TimeIntegrationSchemeGEM.cpp.

{
    os << *rhs.get();
 
    return os;
}

operator<<() [10/14]

LUE std::ostream & Nektar::LibUtilities::operator<<	(	std::ostream &	os,
		const TimeIntegrationSchemeGLM &	rhs
	)

Definition at line 145 of file TimeIntegrationSchemeGLM.cpp.

{
    rhs.print(os);
 
    return os;
}

operator<<() [11/14]

LUE std::ostream & Nektar::LibUtilities::operator<<	(	std::ostream &	os,
		const TimeIntegrationSchemeGLMSharedPtr &	rhs
	)

Definition at line 152 of file TimeIntegrationSchemeGLM.cpp.

{
    os << *rhs.get();
 
    return os;
}

operator<<() [12/14]

std::ostream & Nektar::LibUtilities::operator<<	(	std::ostream &	os,
		const TimeIntegrationSchemeSDC &	rhs
	)

Definition at line 341 of file TimeIntegrationSchemeSDC.cpp.

{
    rhs.print(os);
 
    return os;
}

References Nektar::LibUtilities::TimeIntegrationScheme::print().

operator<<() [13/14]

std::ostream & Nektar::LibUtilities::operator<<	(	std::ostream &	os,
		const TimeIntegrationSchemeSDCSharedPtr &	rhs
	)

Definition at line 348 of file TimeIntegrationSchemeSDC.cpp.

{
    os << *rhs.get();
 
    return os;
}

operator<<() [14/14]

LUE std::ostream & Nektar::LibUtilities::operator<<	(	std::ostream &	os,
		const TimeIntegrationSchemeSharedPtr &	rhs
	)

Definition at line 73 of file TimeIntegrationScheme.cpp.

{
    os << *rhs.get();
 
    return os;
}

operator==() [1/5]

bool Nektar::LibUtilities::operator==	(	const BasisKey &	x,
		const BasisKey &	y
	)

Definition at line 902 of file Foundations/Basis.cpp.

{
    return (x.GetPointsKey() == y.GetPointsKey() &&
            x.m_basistype == y.m_basistype &&
            x.GetNumModes() == y.GetNumModes());
}

operator==() [2/5]

bool Nektar::LibUtilities::operator==	(	const BasisKey &	x,
		const BasisKey *	y
	)

Definition at line 916 of file Foundations/Basis.cpp.

{
    return (x == *y);
}

operator==() [3/5]

bool Nektar::LibUtilities::operator==	(	const BasisKey *	x,
		const BasisKey &	y
	)

Definition at line 910 of file Foundations/Basis.cpp.

{
    return (*x == y);
}

operator==() [4/5]

bool Nektar::LibUtilities::operator==	(	const GraphVertexObject &	x,
		const GraphVertexObject &	y
	)

Definition at line 55 of file Graph.cpp.

{
    return (x.m_id == y.m_id);
}

operator==() [5/5]

bool Nektar::LibUtilities::operator==	(	const PointsKey &	lhs,
		const PointsKey &	rhs
	)

Definition at line 45 of file Foundations/Points.cpp.

{
    return (lhs.m_numpoints == rhs.m_numpoints &&
            lhs.m_pointstype == rhs.m_pointstype);
}

operator>()

bool Nektar::LibUtilities::operator>	(	const BasisKey &	lhs,
		const BasisKey &	rhs
	)

Definition at line 70 of file Foundations/Basis.cpp.

{
    return (rhs < lhs);
}

PhysGalerkinProject1D() [1/4]

void Nektar::LibUtilities::PhysGalerkinProject1D	(	const BasisKey &	fbasis0,
		const Array< OneD, const NekDouble > &	from,
		const BasisKey &	tbasis0,
		Array< OneD, NekDouble > &	to
	)

Definition at line 49 of file PhysGalerkinProject.cpp.

{
    PhysGalerkinProject1D(fbasis0.GetPointsKey(), from, tbasis0.GetPointsKey(),
                          to);
}

References Nektar::LibUtilities::BasisKey::GetPointsKey(), and PhysGalerkinProject1D().

Referenced by PhysGalerkinProject1D().

PhysGalerkinProject1D() [2/4]

void Nektar::LibUtilities::PhysGalerkinProject1D	(	const BasisKey &	fbasis0,
		const NekDouble *	from,
		const BasisKey &	tbasis0,
		NekDouble *	to
	)

Definition at line 80 of file PhysGalerkinProject.cpp.

{
    PhysGalerkinProject1D(fbasis0.GetPointsKey(), from, tbasis0.GetPointsKey(),
                          to);
}

References Nektar::LibUtilities::BasisKey::GetPointsKey(), and PhysGalerkinProject1D().

PhysGalerkinProject1D() [3/4]

void Nektar::LibUtilities::PhysGalerkinProject1D	(	const PointsKey &	fpoints0,
		const Array< OneD, const NekDouble > &	from,
		const PointsKey &	tpoints0,
		Array< OneD, NekDouble > &	to
	)

Definition at line 57 of file PhysGalerkinProject.cpp.

{
    if (fpoints0 == tpoints0) // check to see if the same
    {
        Vmath::Vcopy(fpoints0.GetNumPoints(), from, 1, to, 1);
    }
    else // interpolate
    {
        DNekMatSharedPtr GP0;
 
        GP0 = PointsManager()[tpoints0]->GetGalerkinProjection(fpoints0);
 
        NekVector<NekDouble> in(fpoints0.GetNumPoints(), from, eWrapper);
        NekVector<NekDouble> out(tpoints0.GetNumPoints(), to, eWrapper);
 
        GP0->Transpose();
        out = (*GP0) * in;
    }
}

References Nektar::eWrapper, Nektar::LibUtilities::PointsKey::GetNumPoints(), PointsManager(), and Vmath::Vcopy().

PhysGalerkinProject1D() [4/4]

void Nektar::LibUtilities::PhysGalerkinProject1D	(	const PointsKey &	fpoints0,
		const NekDouble *	from,
		const PointsKey &	tpoints0,
		NekDouble *	to
	)

Definition at line 87 of file PhysGalerkinProject.cpp.

{
    if (fpoints0 == tpoints0) // check to see if the same
    {
        Vmath::Vcopy(fpoints0.GetNumPoints(), from, 1, to, 1);
    }
    else // interpolate
    {
 
        DNekMatSharedPtr GP0;
 
        GP0 = PointsManager()[tpoints0]->GetGalerkinProjection(fpoints0);
 
        Blas::Dgemv('T', tpoints0.GetNumPoints(), fpoints0.GetNumPoints(), 1.0,
                    GP0->GetPtr().get(), tpoints0.GetNumPoints(), from, 1, 0.0,
                    to, 1);
    }
}

References Blas::Dgemv(), Nektar::LibUtilities::PointsKey::GetNumPoints(), PointsManager(), and Vmath::Vcopy().

PhysGalerkinProject2D() [1/3]

void Nektar::LibUtilities::PhysGalerkinProject2D	(	const BasisKey &	fbasis0,
		const BasisKey &	fbasis1,
		const Array< OneD, const NekDouble > &	from,
		const BasisKey &	tbasis0,
		const BasisKey &	tbasis1,
		Array< OneD, NekDouble > &	to
	)

Definition at line 108 of file PhysGalerkinProject.cpp.

{
    PhysGalerkinProject2D(fbasis0.GetPointsKey(), fbasis1.GetPointsKey(),
                          from.data(), tbasis0.GetPointsKey(),
                          tbasis1.GetPointsKey(), to.data());
}

References Nektar::LibUtilities::BasisKey::GetPointsKey(), and PhysGalerkinProject2D().

Referenced by PhysGalerkinProject2D(), and Nektar::MultiRegions::ExpList::v_PhysGalerkinProjection1DScaled().

PhysGalerkinProject2D() [2/3]

void Nektar::LibUtilities::PhysGalerkinProject2D	(	const PointsKey &	fpoints0,
		const PointsKey &	fpoints1,
		const Array< OneD, const NekDouble > &	from,
		const PointsKey &	tpoints0,
		const PointsKey &	tpoints1,
		Array< OneD, NekDouble > &	to
	)

Definition at line 118 of file PhysGalerkinProject.cpp.

{
    PhysGalerkinProject2D(fpoints0, fpoints1, from.data(), tpoints0, tpoints1,
                          to.data());
}

References PhysGalerkinProject2D().

PhysGalerkinProject2D() [3/3]

void Nektar::LibUtilities::PhysGalerkinProject2D	(	const PointsKey &	fpoints0,
		const PointsKey &	fpoints1,
		const NekDouble *	from,
		const PointsKey &	tpoints0,
		const PointsKey &	tpoints1,
		NekDouble *	to
	)

Definition at line 127 of file PhysGalerkinProject.cpp.

{
    DNekMatSharedPtr GP0, GP1;
    Array<OneD, NekDouble> wsp(tpoints1.GetNumPoints() *
                               fpoints0.GetNumPoints()); // fnp0*tnp1
 
    size_t fnp0 = fpoints0.GetNumPoints();
    size_t fnp1 = fpoints1.GetNumPoints();
    size_t tnp0 = tpoints0.GetNumPoints();
    size_t tnp1 = tpoints1.GetNumPoints();
 
    if (fpoints1 == tpoints1)
    {
        Vmath::Vcopy(fnp0 * tnp1, from, 1, wsp.get(), 1);
    }
    else
    {
        GP1 = PointsManager()[tpoints1]->GetGalerkinProjection(fpoints1);
        Blas::Dgemm('N', 'T', fnp0, tnp1, fnp1, 1.0, from, fnp0,
                    GP1->GetPtr().get(), tnp1, 0.0, wsp.get(), fnp0);
    }
 
    if (fpoints0 == tpoints0)
    {
        Vmath::Vcopy(tnp0 * tnp1, wsp.get(), 1, to, 1);
    }
    else
    {
        GP0 = PointsManager()[tpoints0]->GetGalerkinProjection(fpoints0);
        Blas::Dgemm('N', 'N', tnp0, tnp1, fnp0, 1.0, GP0->GetPtr().get(), tnp0,
                    wsp.get(), fnp0, 0.0, to, tnp0);
    }
}

References Blas::Dgemm(), Nektar::LibUtilities::PointsKey::GetNumPoints(), PointsManager(), and Vmath::Vcopy().

PhysGalerkinProject3D() [1/3]

void Nektar::LibUtilities::PhysGalerkinProject3D	(	const BasisKey &	fbasis0,
		const BasisKey &	fbasis1,
		const BasisKey &	fbasis2,
		const Array< OneD, const NekDouble > &	from,
		const BasisKey &	tbasis0,
		const BasisKey &	tbasis1,
		const BasisKey &	tbasis2,
		Array< OneD, NekDouble > &	to
	)

Definition at line 164 of file PhysGalerkinProject.cpp.

{
    PhysGalerkinProject3D(fbasis0.GetPointsKey(), fbasis1.GetPointsKey(),
                          fbasis2.GetPointsKey(), from.data(),
                          tbasis0.GetPointsKey(), tbasis1.GetPointsKey(),
                          tbasis2.GetPointsKey(), to.data());
}

References Nektar::LibUtilities::BasisKey::GetPointsKey(), and PhysGalerkinProject3D().

Referenced by PhysGalerkinProject3D(), and Nektar::MultiRegions::ExpList::v_PhysGalerkinProjection1DScaled().

PhysGalerkinProject3D() [2/3]

void Nektar::LibUtilities::PhysGalerkinProject3D	(	const PointsKey &	fpoints0,
		const PointsKey &	fpoints1,
		const PointsKey &	fpoints2,
		const Array< OneD, const NekDouble > &	from,
		const PointsKey &	tpoints0,
		const PointsKey &	tpoints1,
		const PointsKey &	tpoints2,
		Array< OneD, NekDouble > &	to
	)

Definition at line 176 of file PhysGalerkinProject.cpp.

{
    PhysGalerkinProject3D(fpoints0, fpoints1, fpoints2, from.data(), tpoints0,
                          tpoints1, tpoints2, to.data());
}

References PhysGalerkinProject3D().

PhysGalerkinProject3D() [3/3]

void Nektar::LibUtilities::PhysGalerkinProject3D	(	const PointsKey &	fpoints0,
		const PointsKey &	fpoints1,
		const PointsKey &	fpoints2,
		const NekDouble *	from,
		const PointsKey &	tpoints0,
		const PointsKey &	tpoints1,
		const PointsKey &	tpoints2,
		NekDouble *	to
	)

Definition at line 187 of file PhysGalerkinProject.cpp.

{
    DNekMatSharedPtr GP0, GP1, GP2;
 
    size_t fnp0 = fpoints0.GetNumPoints();
    size_t fnp1 = fpoints1.GetNumPoints();
    size_t fnp2 = fpoints2.GetNumPoints();
    size_t tnp0 = tpoints0.GetNumPoints();
    size_t tnp1 = tpoints1.GetNumPoints();
    size_t tnp2 = tpoints2.GetNumPoints();
 
    Array<OneD, NekDouble> wsp1(fnp0 * tnp1 * tnp2);
    Array<OneD, NekDouble> wsp2(fnp0 * fnp1 * tnp2);
 
    GP2 = PointsManager()[tpoints2]->GetGalerkinProjection(fpoints2);
    Blas::Dgemm('N', 'T', fnp0 * fnp1, tnp2, fnp2, 1.0, from, fnp0 * fnp1,
                GP2->GetPtr().get(), tnp2, 0.0, wsp2.get(), fnp0 * fnp1);
 
    GP1 = PointsManager()[tpoints1]->GetGalerkinProjection(fpoints1);
    for (size_t i = 0; i < tnp2; i++)
    {
        Blas::Dgemm('N', 'T', fnp0, tnp1, fnp1, 1.0,
                    wsp2.get() + i * fnp0 * fnp1, fnp0, GP1->GetPtr().get(),
                    tnp1, 0.0, wsp1.get() + i * fnp0 * tnp1, fnp0);
    }
 
    GP0 = PointsManager()[tpoints0]->GetGalerkinProjection(fpoints0);
    Blas::Dgemm('N', 'N', tnp0, tnp1 * tnp2, fnp0, 1.0, GP0->GetPtr().get(),
                tnp0, wsp1.get(), fnp0, 0.0, to, tnp0);
}

References Blas::Dgemm(), Nektar::LibUtilities::PointsKey::GetNumPoints(), and PointsManager().

PointsManager()

PointsManagerT & Nektar::LibUtilities::PointsManager

(

void

)

Definition at line 40 of file ManagerAccess.cpp.

{
    static PointsManagerT instance;
    return instance;
}

Referenced by Nektar::LibUtilities::GaussPoints::CalculateGalerkinProjectionMatrix(), Nektar::LibUtilities::FourierPoints::CreateMatrix(), Nektar::LibUtilities::GaussPoints::CreateMatrix(), Nektar::LibUtilities::Basis::GenBasis(), Nektar::StdRegions::StdNodalTriExp::GetNodalPoints(), Nektar::StdRegions::StdNodalPrismExp::GetNodalPoints(), Nektar::StdRegions::StdNodalTetExp::GetNodalPoints(), Interp1D(), Interp2D(), Interp3D(), Nektar::Collections::PhysInterp1DScaled_NoCollection::operator()(), PhysGalerkinProject1D(), PhysGalerkinProject2D(), PhysGalerkinProject3D(), Points_Create(), Nektar::SolverUtils::DriverPFASST::SetTimeInterpolator(), Nektar::MultiRegions::LocTraceToTraceMap::Setup(), Nektar::LibUtilities::TimeIntegrationSchemeSDC::TimeIntegrationSchemeSDC(), Nektar::LibUtilities::NodalHexElec::v_CalculatePoints(), Nektar::LibUtilities::NodalPrismElec::v_CalculatePoints(), Nektar::LibUtilities::NodalPrismSPI::v_CalculatePoints(), Nektar::LibUtilities::NodalQuadElec::v_CalculatePoints(), Nektar::LibUtilities::PolyEPoints::v_CalculateWeights(), Nektar::SpatialDomains::SegGeom::v_FillGeom(), Nektar::SpatialDomains::TriGeom::v_FillGeom(), Nektar::LibUtilities::NodalPrismElec::v_GetI(), Nektar::LibUtilities::NodalPrismEvenlySpaced::v_GetI(), Nektar::LibUtilities::NodalTetElec::v_GetI(), Nektar::LibUtilities::NodalTetEvenlySpaced::v_GetI(), Nektar::LibUtilities::NodalTriElec::v_GetI(), Nektar::LibUtilities::NodalTriEvenlySpaced::v_GetI(), Nektar::LibUtilities::NodalTriFekete::v_GetI(), and Nektar::LibUtilities::PolyEPoints::v_GetI().

PortablePath()

static std::string Nektar::LibUtilities::PortablePath ( const fs::path &  path )

inlinestatic

create portable path on different platforms for std::filesystem path.

Definition at line 56 of file Filesystem.hpp.

{
    return fs::path(path).make_preferred().string();
}

Referenced by Nektar::MetricFile::CalculateHash(), Nektar::SolverUtils::ForcingMovingReferenceFrame::CheckForRestartTime(), Nektar::SolverUtils::UnsteadySystem::CheckForRestartTime(), Nektar::LibUtilities::FieldIO::GetFileType(), Nektar::LibUtilities::PtsIO::Import(), Nektar::LibUtilities::SessionReader::LoadDoc(), main(), Nektar::FieldUtils::OutputVtkBase::PrepareOutput(), Nektar::LibUtilities::FieldIOXml::SetUpFieldMetaData(), Nektar::LibUtilities::PtsIO::SetUpFieldMetaData(), Nektar::LibUtilities::FieldIO::SetUpOutput(), Nektar::LibUtilities::FieldIOXml::v_Import(), Nektar::SpatialDomains::MeshGraphXml::v_PartitionMesh(), Nektar::FieldUtils::OutputInfo::v_Process(), Nektar::IterativeElasticSystem::WriteGeometry(), Nektar::FieldUtils::OutputVtk::WritePVtu(), Nektar::FieldUtils::OutputVtkBase::WritePVtu(), Nektar::FieldUtils::OutputTecplot::WriteTecplotFile(), and Nektar::SpatialDomains::MeshGraphXml::WriteXMLGeometry().

PrintProgressbar()

int Nektar::LibUtilities::PrintProgressbar ( const int  position, const int  goal, const std::string  message, int  lastprogress = -1  )

inline

Prints a progressbar.

Parameters

position	State of the current process
goal	Goal of the current process
message	Short Description of the current process

This function plots a simple progressbar to the console or log file to visualize the current state of an ongoing process. Make sure you minimize calling this routine. Ideally, this should be called only when the percentage is increased by an integer.

Definition at line 65 of file Progressbar.hpp.

{
    std::cout.unsetf(std::ios::floatfield);
    if (ISTTY)
    {
        float progress = position / float(goal);
        int numeq      = static_cast<int>(ceil(progress * 49));
        if (lastprogress == numeq)
        {
            return numeq;
        }
        else
        {
            // carriage return
            std::cout << "\r";
 
            std::cout << message << ": ";
 
            std::cout << std::setw(3) << ceil(100 * progress) << "% [";
            for (int j = 0; j < numeq; j++)
            {
                std::cout << "=";
            }
            for (int j = numeq; j < 49; j++)
            {
                std::cout << " ";
            }
            std::cout << "]" << std::flush;
            return numeq;
        }
    }
    else
    {
        // print only every 2 percent
        if (int(ceil(double(100 * position / goal))) % 2 == 0)
        {
            std::cout << "." << std::flush;
        }
        return -1;
    }
}

References ISTTY.

Referenced by Nektar::FieldUtils::Iso::GlobalCondense(), Nektar::FieldUtils::ProcessInterpField::PrintProgressbar(), Nektar::FieldUtils::ProcessInterpPointDataToFld::PrintProgressbar(), Nektar::FieldUtils::ProcessInterpPoints::PrintProgressbar(), Nektar::FieldUtils::ProcessInterpPtsToPts::PrintProgressbar(), Nektar::SolverUtils::SessionFunction::PrintProgressbar(), Nektar::SolverUtils::EquationSystem::PrintProgressbar(), and Nektar::FieldUtils::Iso::SeparateRegions().

rad()

static NekDouble Nektar::LibUtilities::rad ( NekDouble  x, NekDouble  y  )

static

Definition at line 76 of file Interpreter/Interpreter.cpp.

{
    return (x != 0.0 || y != 0.0) ? sqrt(x * x + y * y) : 0.0;
}

References tinysimd::sqrt().

Referenced by Nektar::LibUtilities::Interpreter::ExpressionEvaluator::ExpressionEvaluator(), Nektar::LibUtilities::functions::functions(), Nektar::MMFMaxwell::GaussianPulse(), Nektar::MMFMaxwell::GenerateSigmaPML(), Nektar::MMFDiffusion::PlanePhiWave(), Nektar::LibUtilities::Interpreter::ExpressionEvaluator::EvalRad::run_many(), Nektar::LibUtilities::Interpreter::ExpressionEvaluator::EvalRad::run_once(), Nektar::IncNavierStokes::SetUpWomersley(), Nektar::MMFMaxwell::v_DoSolve(), and Nektar::SolverUtils::MMFSystem::v_GenerateSummary().

SESSIONREGISTER() [1/44]

Nektar::LibUtilities::SESSIONREGISTER

(

AdamsBashforthOrder1

)

SESSIONREGISTER() [2/44]

Nektar::LibUtilities::SESSIONREGISTER

(

AdamsBashforthOrder2

)

SESSIONREGISTER() [3/44]

Nektar::LibUtilities::SESSIONREGISTER

(

AdamsBashforthOrder3

)

SESSIONREGISTER() [4/44]

Nektar::LibUtilities::SESSIONREGISTER

(

AdamsBashforthOrder4

)

SESSIONREGISTER() [5/44]

Nektar::LibUtilities::SESSIONREGISTER

(

AdamsMoultonOrder1

)

SESSIONREGISTER() [6/44]

Nektar::LibUtilities::SESSIONREGISTER

(

AdamsMoultonOrder2

)

SESSIONREGISTER() [7/44]

Nektar::LibUtilities::SESSIONREGISTER

(

AdamsMoultonOrder3

)

SESSIONREGISTER() [8/44]

Nektar::LibUtilities::SESSIONREGISTER

(

AdamsMoultonOrder4

)

SESSIONREGISTER() [9/44]

Nektar::LibUtilities::SESSIONREGISTER

(

BackwardEuler

)

SESSIONREGISTER() [10/44]

Nektar::LibUtilities::SESSIONREGISTER

(

BDFImplicitOrder1

)

SESSIONREGISTER() [11/44]

Nektar::LibUtilities::SESSIONREGISTER

(

BDFImplicitOrder2

)

SESSIONREGISTER() [12/44]

Nektar::LibUtilities::SESSIONREGISTER

(

BDFImplicitOrder3

)

SESSIONREGISTER() [13/44]

Nektar::LibUtilities::SESSIONREGISTER

(

BDFImplicitOrder4

)

SESSIONREGISTER() [14/44]

Nektar::LibUtilities::SESSIONREGISTER

(

ClassicalRungeKutta4

)

SESSIONREGISTER() [15/44]

Nektar::LibUtilities::SESSIONREGISTER

(

CNAB

)

SESSIONREGISTER() [16/44]

Nektar::LibUtilities::SESSIONREGISTER

(

DIRKOrder1

)

SESSIONREGISTER() [17/44]

Nektar::LibUtilities::SESSIONREGISTER

(

DIRKOrder2

)

SESSIONREGISTER() [18/44]

Nektar::LibUtilities::SESSIONREGISTER

(

DIRKOrder3

)

SESSIONREGISTER() [19/44]

Nektar::LibUtilities::SESSIONREGISTER

(

DIRKOrder3_ES5

)

SESSIONREGISTER() [20/44]

Nektar::LibUtilities::SESSIONREGISTER

(

DIRKOrder4_ES6

)

SESSIONREGISTER() [21/44]

Nektar::LibUtilities::SESSIONREGISTER

(

ForwardEuler

)

SESSIONREGISTER() [22/44]

Nektar::LibUtilities::SESSIONREGISTER

(

IMEXdirk_1_1_1

)

SESSIONREGISTER() [23/44]

Nektar::LibUtilities::SESSIONREGISTER

(

IMEXdirk_1_2_1

)

SESSIONREGISTER() [24/44]

Nektar::LibUtilities::SESSIONREGISTER

(

IMEXdirk_1_2_2

)

SESSIONREGISTER() [25/44]

Nektar::LibUtilities::SESSIONREGISTER

(

IMEXdirk_2_2_2

)

SESSIONREGISTER() [26/44]

Nektar::LibUtilities::SESSIONREGISTER

(

IMEXdirk_2_3_2

)

SESSIONREGISTER() [27/44]

Nektar::LibUtilities::SESSIONREGISTER

(

IMEXdirk_2_3_3

)

SESSIONREGISTER() [28/44]

Nektar::LibUtilities::SESSIONREGISTER

(

IMEXdirk_3_4_3

)

SESSIONREGISTER() [29/44]

Nektar::LibUtilities::SESSIONREGISTER

(

IMEXdirk_4_4_3

)

SESSIONREGISTER() [30/44]

Nektar::LibUtilities::SESSIONREGISTER

(

IMEXGear

)

SESSIONREGISTER() [31/44]

Nektar::LibUtilities::SESSIONREGISTER

(

IMEXOrder1

)

SESSIONREGISTER() [32/44]

Nektar::LibUtilities::SESSIONREGISTER

(

IMEXOrder2

)

SESSIONREGISTER() [33/44]

Nektar::LibUtilities::SESSIONREGISTER

(

IMEXOrder3

)

SESSIONREGISTER() [34/44]

Nektar::LibUtilities::SESSIONREGISTER

(

IMEXOrder4

)

SESSIONREGISTER() [35/44]

Nektar::LibUtilities::SESSIONREGISTER

(

MCNAB

)

SESSIONREGISTER() [36/44]

Nektar::LibUtilities::SESSIONREGISTER

(

NoScheme

)

SESSIONREGISTER() [37/44]

Nektar::LibUtilities::SESSIONREGISTER

(

RungeKutta1

)

SESSIONREGISTER() [38/44]

Nektar::LibUtilities::SESSIONREGISTER

(

RungeKutta2

)

SESSIONREGISTER() [39/44]

Nektar::LibUtilities::SESSIONREGISTER

(

RungeKutta2_ImprovedEuler

)

SESSIONREGISTER() [40/44]

Nektar::LibUtilities::SESSIONREGISTER

(

RungeKutta2_SSP

)

SESSIONREGISTER() [41/44]

Nektar::LibUtilities::SESSIONREGISTER

(

RungeKutta3

)

SESSIONREGISTER() [42/44]

Nektar::LibUtilities::SESSIONREGISTER

(

RungeKutta3_SSP

)

SESSIONREGISTER() [43/44]

Nektar::LibUtilities::SESSIONREGISTER

(

RungeKutta4

)

SESSIONREGISTER() [44/44]

Nektar::LibUtilities::SESSIONREGISTER

(

RungeKutta5

)

sign()

NekDouble Nektar::LibUtilities::sign

(

NekDouble

arg

)

Definition at line 60 of file Interpreter/Interpreter.cpp.

{
    return (arg > 0.0) - (arg < 0.0);
}

Referenced by Nektar::LibUtilities::Interpreter::ExpressionEvaluator::ExpressionEvaluator(), and Nektar::LibUtilities::functions::functions().

UniquePath()

static fs::path Nektar::LibUtilities::UniquePath ( std::string  specFileStem )

inlinestatic

Create a unique (random) path, based on an input stem string. The returned string is a filename or directory that does not exist.

Given specFileStem as a parameter, this returns a string in the form tmp_<stem>_abcdef where the final 6 characters are random characters and digits.

Definition at line 69 of file Filesystem.hpp.

{
    std::random_device rd;
    std::mt19937 generator(rd());
    fs::path tmp;
 
    do
    {
        std::string chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                            "abcdefghijklmnopqrstuvwxyz";
 
        std::shuffle(chars.begin(), chars.end(), generator);
        tmp = fs::path("tmp_" + specFileStem + "_" + chars.substr(0, 6));
    } while (fs::exists(tmp));
 
    return tmp;
}

Referenced by Nektar::VarcoeffHashingTest::createSessionFile(), and main().

Write()

void Nektar::LibUtilities::Write	(	const std::string &	outFile,
		std::vector< FieldDefinitionsSharedPtr > &	fielddefs,
		std::vector< std::vector< NekDouble > > &	fielddata,
		const FieldMetaDataMap &	fieldinfomap,
		const bool	backup
	)

This function allows for data to be written to an FLD file when a session and/or communicator is not instantiated. Typically used in utilities which do not take XML input and operate in serial only.

Parameters

outFile	Output filename
fielddefs	Field definitions that define the output
fielddata	Binary field data that stores the output corresponding to fielddefs.
fieldinfomap	Associated field metadata map.

Definition at line 245 of file FieldIO.cpp.

{
#ifdef NEKTAR_USE_MPI
    int size;
    int init;
    MPI_Initialized(&init);
 
    // If MPI has been initialised we can check the number of processes
    // and, if > 1, tell the user he should not be running this
    // function in parallel. If it is not initialised, we do not
    // initialise it here, and assume the user knows what they are
    // doing.
    if (init)
    {
        MPI_Comm_size(MPI_COMM_WORLD, &size);
        ASSERTL0(size == 1,
                 "This static function is not available in parallel. Please"
                 "instantiate a FieldIO object for parallel use.");
    }
#endif
    CommSharedPtr c    = GetCommFactory().CreateInstance("Serial", 0, 0);
    FieldIOSharedPtr f = GetFieldIOFactory().CreateInstance("Xml", c, false);
    f->Write(outFile, fielddefs, fielddata, fieldinfomap, backup);
}

References ASSERTL0, Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::CreateInstance(), GetCommFactory(), and GetFieldIOFactory().

Referenced by main().

Variable Documentation

BasisTypeMap

const char* const Nektar::LibUtilities::BasisTypeMap[]

Initial value:

= {
    "NoBasisType",       "Ortho_A",           "Ortho_B",
    "Ortho_C",           "Modified_A",        "Modified_B",
    "Modified_C",        "OrthoPyr_C",        "ModifiedPyr_C",
    "Fourier",           "GLL_Lagrange",      "Gauss_Lagrange",
    "Legendre",          "Chebyshev",         "Monomial",
    "FourierSingleMode", "FourierHalfModeRe", "FourierHalfModeIm"}

Definition at line 44 of file Foundations.hpp.

Referenced by export_Basis(), Nektar::LibUtilities::FieldIOXml::ImportFieldDefs(), operator<<(), Nektar::SpatialDomains::MeshGraph::ReadExpansionInfo(), Nektar::SolverUtils::DriverAdaptive::ReplaceExpansion(), and Nektar::LibUtilities::FieldIOXml::v_Write().

EndianTypeMap

const std::string Nektar::LibUtilities::EndianTypeMap[]

Initial value:

= {"UnknownEndian", "BigEndian",
                                     "LittleEndian", "BigWordEndian",
                                     "LittleWordEndian"}

Definition at line 57 of file CompressData.h.

Referenced by Nektar::LibUtilities::CompressData::GetCompressString().

fldCmdFormat

std::string Nektar::LibUtilities::fldCmdFormat

Initial value:

= SessionReader::RegisterCmdLineArgument(
    "io-format", "i", "Default input/output format (e.g. Xml, Hdf5)")

Definition at line 64 of file FieldIO.cpp.

functions_p

Nektar::LibUtilities::functions Nektar::LibUtilities::functions_p

static

Referenced by Nektar::LibUtilities::Interpreter::ExpressionEvaluator::AnalyticExpression::definition< ScannerT >::definition().

FunctionTypeMap

const char* const Nektar::LibUtilities::FunctionTypeMap[]

Initial value:

= {"No Function type", "Expression",
                                       "File"}

Definition at line 97 of file SessionReader.h.

kPointsTypeStr

const std::string Nektar::LibUtilities::kPointsTypeStr[]

Definition at line 52 of file Foundations.hpp.

Referenced by export_Points(), Nektar::LibUtilities::FieldIOHdf5::ImportFieldDef(), Nektar::LibUtilities::FieldIOXml::ImportFieldDefs(), operator<<(), Nektar::SpatialDomains::MeshGraph::ReadExpansionInfo(), Nektar::StdRegions::StdTriExp::v_GetTraceBasisKey(), Nektar::SpatialDomains::MeshGraphXml::v_ReadCurves(), and Nektar::SpatialDomains::MeshGraphXml::v_WriteCurves().

NodalTetElecAvailable

const size_t Nektar::LibUtilities::NodalTetElecAvailable = 10

Definition at line 65 of file NodalTetElecData.h.

NodalTetElecData

const NekDouble Nektar::LibUtilities::NodalTetElecData[][9]

static

Definition at line 68 of file NodalTetElecData.h.

Referenced by Nektar::LibUtilities::NodalTetElec::v_CalculatePoints().

NodalTetElecNPTS

const size_t Nektar::LibUtilities::NodalTetElecNPTS[NodalTetElecAvailable]

static

Initial value:

= {
    1, 2, 3, 5, 6, 9, 11, 15, 18, 23}

Definition at line 66 of file NodalTetElecData.h.

Referenced by Nektar::LibUtilities::NodalTetElec::v_CalculatePoints().

NodalTetSPIAvailable

const size_t Nektar::LibUtilities::NodalTetSPIAvailable = 10

Definition at line 40 of file NodalTetSPIData.h.

NodalTetSPIData

const NekDouble Nektar::LibUtilities::NodalTetSPIData[][4]

static

Definition at line 43 of file NodalTetSPIData.h.

Referenced by Nektar::LibUtilities::NodalTetSPI::v_CalculatePoints(), and Nektar::LibUtilities::NodalTetSPI::v_CalculateWeights().

NodalTetSPINPTS

const size_t Nektar::LibUtilities::NodalTetSPINPTS[NodalTetSPIAvailable]

static

Initial value:

= {
    1, 4, 8, 14, 14, 28, 36, 81, 121, 180}

Definition at line 41 of file NodalTetSPIData.h.

Referenced by Nektar::LibUtilities::NodalTetSPI::v_CalculatePoints(), and Nektar::LibUtilities::NodalTetSPI::v_CalculateWeights().

NodalTriElecAvailable

const size_t Nektar::LibUtilities::NodalTriElecAvailable = 16

Definition at line 44 of file NodalTriElecData.h.

NodalTriElecData

const NekDouble Nektar::LibUtilities::NodalTriElecData[][6]

static

Definition at line 47 of file NodalTriElecData.h.

Referenced by Nektar::LibUtilities::NodalTriElec::v_CalculatePoints().

NodalTriElecNPTS

const size_t Nektar::LibUtilities::NodalTriElecNPTS[NodalTriElecAvailable]

static

Initial value:

= {
    1, 2, 3, 4, 5, 7, 8, 10, 12, 14, 16, 19, 21, 24, 27, 30}

Definition at line 45 of file NodalTriElecData.h.

Referenced by Nektar::LibUtilities::NodalTriElec::v_CalculatePoints().

NodalTriFeketeAvailable

const size_t Nektar::LibUtilities::NodalTriFeketeAvailable = 16

Definition at line 46 of file NodalTriFeketeData.h.

NodalTriFeketeData

const NekDouble Nektar::LibUtilities::NodalTriFeketeData[][6]

static

Definition at line 49 of file NodalTriFeketeData.h.

Referenced by Nektar::LibUtilities::NodalTriFekete::v_CalculatePoints().

NodalTriFeketeNPTS

const size_t Nektar::LibUtilities::NodalTriFeketeNPTS[NodalTriFeketeAvailable]

static

Initial value:

= {
    1, 2, 3, 4, 5, 7, 8, 10, 12, 14, 16, 19, 21, 24, 27, 30}

Definition at line 47 of file NodalTriFeketeData.h.

Referenced by Nektar::LibUtilities::NodalTriFekete::v_CalculatePoints().

NodalTriSPIAvailable

const size_t Nektar::LibUtilities::NodalTriSPIAvailable = 10

Definition at line 40 of file NodalTriSPIData.h.

NodalTriSPIData

const NekDouble Nektar::LibUtilities::NodalTriSPIData[][3]

static

Definition at line 43 of file NodalTriSPIData.h.

Referenced by Nektar::LibUtilities::NodalTriSPI::v_CalculatePoints(), and Nektar::LibUtilities::NodalTriSPI::v_CalculateWeights().

NodalTriSPINPTS

const size_t Nektar::LibUtilities::NodalTriSPINPTS[NodalTriSPIAvailable]

static

Initial value:

= {
    1, 3, 6, 6, 7, 13, 16, 18, 22, 25}

Definition at line 41 of file NodalTriSPIData.h.

Referenced by Nektar::LibUtilities::NodalTriSPI::v_CalculatePoints(), and Nektar::LibUtilities::NodalTriSPI::v_CalculateWeights().

NullBasisSharedPtr

BasisSharedPtr Nektar::LibUtilities::NullBasisSharedPtr

static

Definition at line 350 of file Basis.h.

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

NullBasisSharedPtr1DArray

Array<OneD, BasisSharedPtr> Nektar::LibUtilities::NullBasisSharedPtr1DArray

static

Definition at line 351 of file Basis.h.

NullDomainRangeShPtr

DomainRangeShPtr Nektar::LibUtilities::NullDomainRangeShPtr

static

Definition at line 65 of file DomainRange.h.

Referenced by Nektar::SpatialDomains::MeshGraph::CheckRange(), Nektar::SpatialDomains::MeshGraph::SetDomainRange(), Nektar::SolverUtils::DriverParallelInTime::SetParallelInTimeEquationSystem(), Nektar::LibUtilities::CsvIO::v_ImportPtsFieldData(), Nektar::SpatialDomains::MeshGraphXml::v_PartitionMesh(), and Nektar::FieldUtils::InputXml::v_Process().

NullFieldMetaDataMap

FieldMetaDataMap Nektar::LibUtilities::NullFieldMetaDataMap

static

Definition at line 51 of file FieldIO.h.

Referenced by Nektar::LibUtilities::FieldIO::AddInfoTag(), Nektar::SolverUtils::ForcingMovingReferenceFrame::CheckForRestartTime(), Nektar::SolverUtils::UnsteadySystem::CheckForRestartTime(), Nektar::SolverUtils::SessionFunction::EvaluateFld(), ExpList_LoadField(), export_MeshGraph(), Nektar::LinearisedAdvection::ImportFldBase(), Nektar::SolverUtils::FileFieldInterpolator::ImportFldBase(), Nektar::FieldUtils::ProcessAddFld::v_Process(), Nektar::FieldUtils::ProcessAverageFld::v_Process(), Nektar::FieldUtils::ProcessInnerProduct::v_Process(), Nektar::FieldUtils::ProcessInterpField::v_Process(), Nektar::FieldUtils::ProcessInterpPointDataToFld::v_Process(), Nektar::FieldUtils::ProcessInterpPoints::v_Process(), and Nektar::FieldUtils::ProcessMultiShear::v_Process().

NullNekDoubleVector

std::vector<NekDouble> Nektar::LibUtilities::NullNekDoubleVector

static

Definition at line 949 of file SharedArray.hpp.

NullPointsTypeVector

std::vector<LibUtilities::PointsType> Nektar::LibUtilities::NullPointsTypeVector

static

Definition at line 98 of file PointsType.h.

NullPtsField

PtsFieldSharedPtr Nektar::LibUtilities::NullPtsField

static

Definition at line 185 of file PtsField.h.

Referenced by Nektar::FieldUtils::Field::ClearField(), Nektar::SolverUtils::FilterFieldConvert::CreateFields(), Nektar::FieldUtils::OutputFileBase::v_Process(), and Nektar::FieldUtils::ProcessInterpPtsToPts::v_Process().

NullPtsInfoMap

std::map<PtsInfo, int> Nektar::LibUtilities::NullPtsInfoMap

static

Definition at line 66 of file PtsField.h.

Referenced by Nektar::LibUtilities::PtsIO::v_ImportPtsFieldData(), and Nektar::FieldUtils::ProcessWallNormalData::v_Process().

NullPtsMetaDataMap

PtsMetaDataMap Nektar::LibUtilities::NullPtsMetaDataMap

static

Definition at line 57 of file PtsIO.h.

NullUnsignedIntVector

std::vector<unsigned int> Nektar::LibUtilities::NullUnsignedIntVector

static

Definition at line 950 of file SharedArray.hpp.

Referenced by Nektar::MultiRegions::ExpListHomogeneous2D::v_GetFieldDefinitions().

NullVectorNekDoubleVector

std::vector<std::vector<NekDouble> > Nektar::LibUtilities::NullVectorNekDoubleVector

static

Initial value:

= {
    NullNekDoubleVector}

Definition at line 951 of file SharedArray.hpp.

Referenced by Nektar::LibUtilities::FieldIOHdf5::v_Import(), and Nektar::LibUtilities::FieldIOXml::v_Import().

perm12A_3d

const size_t Nektar::LibUtilities::perm12A_3d[12][4]

static

Initial value:

= {
    {0, 1, 2, 3}, {0, 1, 3, 2}, {0, 2, 1, 3}, {0, 2, 3, 1},
    {0, 3, 1, 2}, {0, 3, 2, 1}, {2, 0, 1, 3}, {2, 0, 3, 1},
    {2, 3, 0, 1}, {3, 0, 1, 2}, {3, 0, 2, 1}, {3, 2, 0, 1}}

Definition at line 45 of file NodalTetElecData.h.

Referenced by Nektar::LibUtilities::NodalTetElec::v_CalculatePoints().

perm12B_3d

const size_t Nektar::LibUtilities::perm12B_3d[12][4]

static

Initial value:

= {
    {0, 1, 2, 3}, {0, 2, 1, 3}, {0, 2, 3, 1}, {1, 0, 2, 3},
    {1, 2, 0, 3}, {1, 2, 3, 0}, {2, 0, 1, 3}, {2, 0, 3, 1},
    {2, 1, 0, 3}, {2, 1, 3, 0}, {2, 3, 0, 1}, {2, 3, 1, 0}}

Definition at line 49 of file NodalTetElecData.h.

Referenced by Nektar::LibUtilities::NodalTetElec::v_CalculatePoints().

perm12C_3d

const size_t Nektar::LibUtilities::perm12C_3d[12][4]

static

Initial value:

= {
    {0, 1, 2, 3}, {0, 1, 3, 2}, {0, 3, 1, 2}, {1, 0, 2, 3},
    {1, 0, 3, 2}, {1, 2, 0, 3}, {1, 2, 3, 0}, {1, 3, 0, 2},
    {1, 3, 2, 0}, {3, 0, 1, 2}, {3, 1, 0, 2}, {3, 1, 2, 0}}

Definition at line 53 of file NodalTetElecData.h.

Referenced by Nektar::LibUtilities::NodalTetElec::v_CalculatePoints().

perm24_3d

const size_t Nektar::LibUtilities::perm24_3d[24][4]

static

Initial value:

= {
    {0, 1, 2, 3}, {0, 1, 3, 2}, {0, 2, 1, 3}, {0, 2, 3, 1}, {0, 3, 1, 2},
    {0, 3, 2, 1}, {1, 0, 2, 3}, {1, 0, 3, 2}, {1, 2, 0, 3}, {1, 2, 3, 0},
    {1, 3, 0, 2}, {1, 3, 2, 0}, {2, 0, 1, 3}, {2, 0, 3, 1}, {2, 1, 0, 3},
    {2, 1, 3, 0}, {2, 3, 0, 1}, {2, 3, 1, 0}, {3, 0, 1, 2}, {3, 0, 2, 1},
    {3, 1, 0, 2}, {3, 1, 2, 0}, {3, 2, 0, 1}, {3, 2, 1, 0}}

Definition at line 58 of file NodalTetElecData.h.

Referenced by Nektar::LibUtilities::NodalTetElec::v_CalculatePoints().

perm3A_2d [1/2]

const size_t Nektar::LibUtilities::perm3A_2d[3][3]

static

Initial value:

= {
    {0, 1, 2}, {2, 0, 1}, {0, 2, 1}}

Definition at line 37 of file NodalTriElecData.h.

Referenced by Nektar::LibUtilities::NodalTriElec::v_CalculatePoints(), and Nektar::LibUtilities::NodalTriFekete::v_CalculatePoints().

perm3A_2d [2/2]

const size_t Nektar::LibUtilities::perm3A_2d[3][3]

static

Initial value:

= {
    {0, 1, 2}, {2, 0, 1}, {0, 2, 1}}

Definition at line 37 of file NodalTriFeketeData.h.

perm3B_2d [1/2]

const size_t Nektar::LibUtilities::perm3B_2d[3][3]

static

Initial value:

= {
    {0, 1, 2}, {1, 0, 2}, {1, 2, 0}}

Definition at line 39 of file NodalTriElecData.h.

Referenced by Nektar::LibUtilities::NodalTriElec::v_CalculatePoints(), and Nektar::LibUtilities::NodalTriFekete::v_CalculatePoints().

perm3B_2d [2/2]

const size_t Nektar::LibUtilities::perm3B_2d[3][3]

static

Initial value:

= {
    {0, 1, 2}, {1, 0, 2}, {1, 2, 0}}

Definition at line 39 of file NodalTriFeketeData.h.

perm3C_2d

const size_t Nektar::LibUtilities::perm3C_2d[3][3]

static

Initial value:

= {
    {0, 1, 2}, {2, 0, 1}, {1, 2, 0}}

Definition at line 41 of file NodalTriFeketeData.h.

perm4_3d

const size_t Nektar::LibUtilities::perm4_3d[4][4]

static

Initial value:

= {{0, 1, 2, 3},
                                      {3, 0, 1, 2},
                                      {2, 3, 0, 1},
                                      {1, 2, 3, 0}}

Definition at line 37 of file NodalTetElecData.h.

Referenced by Nektar::LibUtilities::NodalTetElec::v_CalculatePoints().

perm6_2d [1/2]

const size_t Nektar::LibUtilities::perm6_2d[6][3]

static

Initial value:

= {
    {0, 1, 2}, {1, 0, 2}, {2, 0, 1}, 
    {2, 1, 0}, {0, 2, 1}, {1, 2, 0}}

Definition at line 41 of file NodalTriElecData.h.

Referenced by Nektar::LibUtilities::NodalTriElec::v_CalculatePoints(), and Nektar::LibUtilities::NodalTriFekete::v_CalculatePoints().

perm6_2d [2/2]

const size_t Nektar::LibUtilities::perm6_2d[6][3]

static

Initial value:

= {{0, 1, 2}, {1, 0, 2},
                                      {2, 0, 1}, {2, 1, 0},
                                      {0, 2, 1}, {1, 2, 0}}

Definition at line 43 of file NodalTriFeketeData.h.

perm6_3d

const size_t Nektar::LibUtilities::perm6_3d[6][4]

static

Initial value:

= {
    {0, 1, 2, 3}, {0, 2, 1, 3}, {0, 2, 3, 1},
    {2, 0, 1, 3}, {2, 0, 3, 1}, {2, 3, 0, 1}}

Definition at line 41 of file NodalTetElecData.h.

Referenced by Nektar::LibUtilities::NodalTetElec::v_CalculatePoints().

ReduceOperatorMap

const char* const Nektar::LibUtilities::ReduceOperatorMap[] = {"ReduceSum", "ReduceMax", "ReduceMin"}

Definition at line 72 of file Comm.h.

Referenced by export_Comm().

ShapeTypeDimMap

constexpr unsigned int Nektar::LibUtilities::ShapeTypeDimMap[SIZE_ShapeType]

constexpr

Initial value:

= {
    0, 
    0, 
    1, 
    2, 
    2, 
    3, 
    3, 
    3, 
    3, 
}

Definition at line 81 of file ShapeType.hpp.

Referenced by Nektar::StdRegions::operator<<(), and Nektar::Collections::CollectionOptimisation::ReadCollOps().

ShapeTypeMap

const char* const Nektar::LibUtilities::ShapeTypeMap[SIZE_ShapeType]

Initial value:

= {
    "NoGeomShapeType", "Point",   "Segment", "Triangle",   "Quadrilateral",
    "Tetrahedron",     "Pyramid", "Prism",   "Hexahedron",
}

Definition at line 75 of file ShapeType.hpp.

Referenced by Nektar::Collections::CollectionOptimisation::CollectionOptimisation(), export_ShapeType(), Nektar::LibUtilities::FieldIOHdf5::ImportFieldDef(), Nektar::LibUtilities::FieldIOXml::ImportFieldDefs(), Nektar::SpatialDomains::Movement::Movement(), Nektar::MultiRegions::operator<<(), Nektar::StdRegions::operator<<(), Nektar::FieldUtils::OutputVtk::OutputFromExpHighOrder(), Nektar::Collections::CollectionOptimisation::ReadCollOps(), Nektar::SolverUtils::DriverAdaptive::ReplaceExpansion(), Nektar::Collections::CollectionOptimisation::SetWithTimings(), Nektar::StdRegions::StdExpansion::v_GetSimplexEquiSpacedConnectivity(), Nektar::StdRegions::StdExpansion::v_PhysEvaluate(), Nektar::FieldUtils::InputXml::v_Process(), Nektar::LibUtilities::FieldIOHdf5::v_Write(), and Nektar::LibUtilities::FieldIOXml::v_Write().