Namespaces
	CompressData

	H5

	StdHexData

	StdPrismData

	StdPyrData

	StdQuadData

	StdSegData

	StdTetData

	StdTriData

Classes
class	Basis
	Represents a basis of a given type. More...

class	BasisKey
	Describes the specification for a Basis. More...

class	BLPoints

struct	CmdLineArg

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	CommSerial
	A global linear system. More...

class	CsvIO

class	DataSource

struct	defOpLessCreator

class	Equation

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	FourierPoints

class	FourierSingleModePoints

struct	func

struct	functions

struct	FunctionVariableDefinition

class	GaussPoints

class	GitConsts

class	Graph

class	GraphEdgeObject

class	GraphVertexObject

class	H5DataSource

class	H5TagWriter

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	Kernel

class	NekFactory
	Provides a generic Factory class. More...

class	NekFFTW

class	NekManager

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	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	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	TimeIntegrationAdamsBashforthOrder2

class	TimeIntegrationAdamsBashforthOrder3

class	TimeIntegrationAdamsBashforthOrder4

class	TimeIntegrationAdamsMoultonOrder2

class	TimeIntegrationBackwardEuler

class	TimeIntegrationBDFImplicitOrder1

class	TimeIntegrationBDFImplicitOrder2

class	TimeIntegrationClassicalRungeKutta4

class	TimeIntegrationCNAB

class	TimeIntegrationDIRKOrder2

class	TimeIntegrationDIRKOrder3

class	TimeIntegrationForwardEuler

class	TimeIntegrationIMEXdirk_1_1_1

class	TimeIntegrationIMEXdirk_1_2_1

class	TimeIntegrationIMEXdirk_1_2_2

class	TimeIntegrationIMEXdirk_2_2_2

class	TimeIntegrationIMEXdirk_2_3_2

class	TimeIntegrationIMEXdirk_2_3_3

class	TimeIntegrationIMEXdirk_3_4_3

class	TimeIntegrationIMEXdirk_4_4_3

class	TimeIntegrationIMEXGear

class	TimeIntegrationIMEXOrder1

class	TimeIntegrationIMEXOrder2

class	TimeIntegrationIMEXOrder3

class	TimeIntegrationIMEXOrder4

class	TimeIntegrationMCNAB

class	TimeIntegrationMidpoint

class	TimeIntegrationRungeKutta2

class	TimeIntegrationRungeKutta2_ImprovedEuler

class	TimeIntegrationRungeKutta2_SSP

class	TimeIntegrationRungeKutta3_SSP

class	TimeIntegrationRungeKutta4

class	TimeIntegrationRungeKutta5

class	TimeIntegrationScheme

class	TimeIntegrationSchemeKey

class	TimeIntegrationSchemeOperators

class	TimeIntegrationSolution

class	TimeIntegrationWrapper

class	Timer

class	Transposition

class	XmlDataSource

class	XmlTagWriter

Typedefs
typedef std::shared_ptr< CsvIO >	CsvIOSharedPtr

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::map< std::string, std::string >	ExpressionMap

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< CommCwipi >	CommCwipiSharedPtr
	Pointer to a Communicator object. More...

typedef std::shared_ptr< CommMpi >	CommMpiSharedPtr
	Pointer to a Communicator object. More...

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 int	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< Kernel >	KernelSharedPtr

typedef std::shared_ptr< TimeIntegrationScheme >	TimeIntegrationSchemeSharedPtr

typedef std::vector< TimeIntegrationSchemeSharedPtr >	TimeIntegrationSchemeVector

typedef std::vector< TimeIntegrationSchemeSharedPtr >::iterator	TimeIntegrationSchemeVectorIter

typedef std::shared_ptr< TimeIntegrationSolution >	TimeIntegrationSolutionSharedPtr

typedef std::vector< TimeIntegrationSolutionSharedPtr >	TimeIntegrationSolutionVector

typedef std::vector< TimeIntegrationSolutionSharedPtr >::iterator	TimeIntegrationSolutionVectorIter

typedef NekManager< TimeIntegrationSchemeKey, TimeIntegrationScheme, TimeIntegrationSchemeKey::opLess >	TimeIntegrationSchemeManagerT

typedef NekFactory< std::string, TimeIntegrationWrapper >	TimeIntegrationWrapperFactory
	Datatype of the NekFactory used to instantiate classes derived from the EquationSystem class. More...

typedef std::shared_ptr< TimeIntegrationWrapper >	TimeIntegrationWrapperSharedPtr

typedef std::shared_ptr< TimeIntegrationIMEXOrder1 >	TimeIntegrationIMEXOrder1SharedPtr

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 }

enum	ReduceOperator { ReduceSum, ReduceMax, ReduceMin, SIZE_ReduceOperator }
	Type of operation to perform in AllReduce. More...

enum	CommDataType { MPI_CHAR, MPI_INT, MPI_UNSIGNED, MPI_LONG, MPI_UNSIGNED_LONG, MPI_LONG_LONG, MPI_UNSIGNED_LONG_LONG, MPI_FLOAT, MPI_DOUBLE, MPI_LONG_DOUBLE }

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, eLegendre, eChebyshev, eMonomial, eFourierSingleMode, eFourierHalfModeRe, eFourierHalfModeIm, SIZE_BasisType }

enum	PointsType { eNoPointsType, eGaussGaussLegendre, eGaussRadauMLegendre, eGaussRadauPLegendre, eGaussLobattoLegendre, eGaussGaussChebyshev, eGaussRadauMChebyshev, eGaussRadauPChebyshev, eGaussLobattoChebyshev, eGaussRadauMAlpha0Beta1, eGaussRadauMAlpha0Beta2, eGaussRadauMAlpha1Beta0, eGaussRadauMAlpha2Beta0, eGaussKronrodLegendre, eGaussRadauKronrodMLegendre, eGaussRadauKronrodMAlpha1Beta0, eGaussLobattoKronrodLegendre, ePolyEvenlySpaced, eFourierEvenlySpaced, eFourierSingleModeSpaced, eBoundaryLayerPoints, eBoundaryLayerPointsRev, eNodalTriElec, eNodalTriFekete, eNodalTriEvenlySpaced, eNodalTetEvenlySpaced, eNodalTetElec, eNodalPrismEvenlySpaced, eNodalPrismElec, eNodalTriSPI, eNodalTetSPI, eNodalPrismSPI, eNodalQuadElec, eNodalHexElec, SIZE_PointsType }

enum	TimeIntegrationMethod { eNoTimeIntegrationMethod, eAdamsBashforthOrder1, eAdamsBashforthOrder2, eAdamsBashforthOrder3, eAdamsBashforthOrder4, eAdamsMoultonOrder1, eAdamsMoultonOrder2, eBDFImplicitOrder1, eBDFImplicitOrder2, eClassicalRungeKutta4, eRungeKutta4, eRungeKutta5, eRungeKutta3_SSP, eRungeKutta2_ImprovedEuler, eRungeKutta2_SSP, eForwardEuler, eBackwardEuler, eIMEXOrder1, eIMEXOrder2, eIMEXOrder3, eIMEXOrder4, eMidpoint, eRungeKutta2, eDIRKOrder2, eDIRKOrder3, eCNAB, eIMEXGear, eMCNAB, eIMEXdirk_1_1_1, eIMEXdirk_1_2_1, eIMEXdirk_1_2_2, eIMEXdirk_2_2_2, eIMEXdirk_2_3_2, eIMEXdirk_2_3_3, eIMEXdirk_3_4_3, eIMEXdirk_4_4_3, SIZE_TimeIntegrationMethod }

enum	TimeIntegrationSchemeType { eNoTimeIntegrationSchemeType, eExplicit, eDiagonallyImplicit, eIMEX, eImplicit }

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

std::string	PortablePath (const boost::filesystem::path &path)
	create portable path on different platforms for boost::filesystem path More...

int	PrintProgressbar (const int position, const int goal, const std::string message, int lastprogress=-1)
	Prints a progressbar. More...

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

int	GetNumberOfCoefficients (ShapeType shape, int na, int nb, int nc)

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)

TimeIntegrationSchemeManagerT &	TimeIntegrationSchemeManager (void)

bool	operator== (const TimeIntegrationSchemeKey &lhs, const TimeIntegrationSchemeKey &rhs)

bool	operator< (const TimeIntegrationSchemeKey &lhs, const TimeIntegrationSchemeKey &rhs)

std::ostream &	operator<< (std::ostream &os, const TimeIntegrationSchemeKey &rhs)

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

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

static const TimeIntegrationSchemeKey	NullTimeIntegrationSchemeKey (eNoTimeIntegrationMethod)

TimeIntegrationWrapperFactory &	GetTimeIntegrationWrapperFactory ()

Variables
const std::string	EndianTypeMap []

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 []

const unsigned int	ShapeTypeDimMap [SIZE_ShapeType]

static std::vector< NekDouble >	NullNekDoubleVector

static std::vector< unsigned int >	NullUnsignedIntVector

static std::vector< std::vector< NekDouble > >	NullVectorNekDoubleVector = { NullNekDoubleVector }

const char *const	ReduceOperatorMap []

static BasisSharedPtr	NullBasisSharedPtr

static Array< OneD, BasisSharedPtr >	NullBasisSharedPtr1DArray

const char *const	BasisTypeMap []

const std::string	kPointsTypeStr []

static const unsigned int	perm4_3d [4][4] = {{0,1,2,3},{3,0,1,2},{2,3,0,1},{1,2,3,0}}

static const unsigned int	perm6_3d [6][4] = {{0,1,2,3},{0,2,1,3},{0,2,3,1},{2,0,1,3},{2,0,3,1},{2,3,0,1}}

static const unsigned int	perm12A_3d [12][4]

static const unsigned int	perm12B_3d [12][4]

static const unsigned int	perm12C_3d [12][4]

static const unsigned int	perm24_3d [24][4]

const unsigned int	NodalTetElecAvailable = 10

static const unsigned int	NodalTetElecNPTS [NodalTetElecAvailable] = {1,2,3,5,6,9,11,15,18,23}

static const NekDouble	NodalTetElecData [][9]

const unsigned int	NodalTetSPIAvailable = 10

static const unsigned int	NodalTetSPINPTS [NodalTetSPIAvailable]

static const NekDouble	NodalTetSPIData [][4]

static const unsigned int	perm3A_2d [3][3] = {{0,1,2},{2,0,1},{0,2,1}}

static const unsigned int	perm3B_2d [3][3] = {{0,1,2},{1,0,2},{1,2,0}}

static const unsigned int	perm6_2d [6][3]

const unsigned int	NodalTriElecAvailable = 16

static const unsigned int	NodalTriElecNPTS [NodalTriElecAvailable] = {1,2,3,4,5,7,8,10,12,14,16,19,21,24,27,30}

static const NekDouble	NodalTriElecData [][6]

static const unsigned int	perm3A_2d [3][3] = {{0,1,2},{2,0,1},{0,2,1}}

static const unsigned int	perm3B_2d [3][3] = {{0,1,2},{1,0,2},{1,2,0}}

static const unsigned int	perm3C_2d [3][3] = {{0,1,2},{2,0,1},{1,2,0}}

static const unsigned int	perm6_2d [6][3]

const unsigned int	NodalTriFeketeAvailable = 16

static const unsigned int	NodalTriFeketeNPTS [NodalTriFeketeAvailable] = {1,2,3,4,5,7,8,10,12,14,16,19,21,24,27,30}

static const NekDouble	NodalTriFeketeData [][6]

const unsigned int	NodalTriSPIAvailable = 10

static const unsigned int	NodalTriSPINPTS [NodalTriSPIAvailable]

static const NekDouble	NodalTriSPIData [][3]

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

Nektar::LibUtilities::functions	functions_p

const char *const	TimeIntegrationMethodMap []

const char *const	TimeIntegrationSchemeTypeMap []

Typedef Documentation

◆ 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 50 of file ManagerAccess.h.

◆ BasisSharedPtr

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

Definition at line 74 of file FoundationsFwd.hpp.

◆ BasisVector

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

Definition at line 75 of file FoundationsFwd.hpp.

◆ CmdLineArgMap

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

Definition at line 74 of file SessionReader.h.

◆ CommCwipiSharedPtr

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

Pointer to a Communicator object.

Definition at line 49 of file CommCwipi.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 60 of file Comm.h.

◆ CommMpiSharedPtr

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

Pointer to a Communicator object.

Definition at line 54 of file CommMpi.h.

◆ CommSerialSharedPtr

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

Pointer to a Communicator object.

Definition at line 48 of file CommSerial.h.

◆ CommSharedPtr

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

Pointer to a Communicator object.

Definition at line 53 of file Comm.h.

◆ CsvIOSharedPtr

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

Definition at line 81 of file CsvIO.h.

◆ DataSourceSharedPtr

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

Definition at line 79 of file FieldIO.h.

◆ EnumMap

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

Definition at line 76 of file SessionReader.h.

◆ EnumMapList

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

Definition at line 77 of file SessionReader.h.

◆ EquationSharedPtr

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

Definition at line 131 of file Equation.h.

◆ ExpressionMap

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

Definition at line 60 of file SessionReader.h.

◆ FieldDefinitionsSharedPtr

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

Definition at line 179 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 195 of file FieldIO.h.

◆ FieldIOSharedPtr

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

Definition at line 306 of file FieldIO.h.

◆ FieldMetaDataMap

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

Definition at line 52 of file FieldIO.h.

◆ FilterMap

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

Definition at line 65 of file SessionReader.h.

◆ FilterParams

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

Definition at line 63 of file SessionReader.h.

◆ 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 108 of file SessionReader.h.

◆ GeometricInfoMap

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

Definition at line 59 of file SessionReader.h.

◆ GloSysInfoMap

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

Definition at line 79 of file SessionReader.h.

◆ GloSysSolnInfoList

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

Definition at line 80 of file SessionReader.h.

◆ GraphVertexID

typedef int Nektar::LibUtilities::GraphVertexID

Definition at line 79 of file FoundationsFwd.hpp.

◆ H5DataSourceSharedPtr

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

Definition at line 88 of file FieldIOHdf5.h.

◆ H5TagWriterSharedPtr

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

Definition at line 116 of file FieldIOHdf5.h.

◆ InterpolatorSharedPtr

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

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

◆ InterpreterSharedPtr

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

Definition at line 325 of file Interpreter.h.

◆ KernelSharedPtr

typedef std::shared_ptr<Kernel> Nektar::LibUtilities::KernelSharedPtr

Definition at line 214 of file kernel.h.

◆ NekFFTWSharedPtr

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

Definition at line 55 of file NekFFTW.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 55 of file NektarFFT.h.

◆ ParameterMap

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

Definition at line 58 of file SessionReader.h.

◆ PFD

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

Definition at line 100 of file Interpreter.cpp.

◆ PFD1

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

Definition at line 101 of file Interpreter.cpp.

◆ PFD2

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

Definition at line 102 of file Interpreter.cpp.

◆ PFD3

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

Definition at line 103 of file Interpreter.cpp.

◆ PFD4

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

Definition at line 104 of file Interpreter.cpp.

◆ PointsBaseType

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

Definition at line 77 of file FoundationsFwd.hpp.

◆ PointsKeyVector

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

Definition at line 246 of file Points.h.

◆ PointsManagerT

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

Definition at line 49 of file ManagerAccess.h.

◆ PointsSharedPtr

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

Definition at line 78 of file FoundationsFwd.hpp.

◆ PtsFieldSharedPtr

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

Definition at line 179 of file PtsField.h.

◆ PtsIOSharedPtr

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

Definition at line 96 of file PtsIO.h.

◆ PtsMetaDataMap

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

Definition at line 57 of file PtsIO.h.

◆ SessionReaderSharedPtr

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

Definition at line 112 of file SessionReader.h.

◆ SharedMatrix

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

Definition at line 55 of file NodalUtil.h.

◆ SolverInfoMap

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

Definition at line 57 of file SessionReader.h.

◆ TagMap

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

Definition at line 62 of file SessionReader.h.

◆ TagWriterSharedPtr

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

Definition at line 69 of file FieldIO.h.

◆ TimeIntegrationIMEXOrder1SharedPtr

typedef std::shared_ptr<TimeIntegrationIMEXOrder1> Nektar::LibUtilities::TimeIntegrationIMEXOrder1SharedPtr

Definition at line 119 of file TimeIntegrationWrapper.h.

◆ TimeIntegrationSchemeManagerT

typedef NekManager<TimeIntegrationSchemeKey, TimeIntegrationScheme, TimeIntegrationSchemeKey::opLess> Nektar::LibUtilities::TimeIntegrationSchemeManagerT

Definition at line 371 of file TimeIntegrationScheme.h.

◆ TimeIntegrationSchemeSharedPtr

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

Definition at line 52 of file TimeIntegrationScheme.h.

◆ TimeIntegrationSchemeVector

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

Definition at line 56 of file TimeIntegrationScheme.h.

◆ TimeIntegrationSchemeVectorIter

typedef std::vector<TimeIntegrationSchemeSharedPtr>::iterator Nektar::LibUtilities::TimeIntegrationSchemeVectorIter

Definition at line 57 of file TimeIntegrationScheme.h.

◆ TimeIntegrationSolutionSharedPtr

typedef std::shared_ptr<TimeIntegrationSolution> Nektar::LibUtilities::TimeIntegrationSolutionSharedPtr

Definition at line 58 of file TimeIntegrationScheme.h.

◆ TimeIntegrationSolutionVector

typedef std::vector<TimeIntegrationSolutionSharedPtr> Nektar::LibUtilities::TimeIntegrationSolutionVector

Definition at line 59 of file TimeIntegrationScheme.h.

◆ TimeIntegrationSolutionVectorIter

typedef std::vector<TimeIntegrationSolutionSharedPtr>::iterator Nektar::LibUtilities::TimeIntegrationSolutionVectorIter

Definition at line 60 of file TimeIntegrationScheme.h.

◆ TimeIntegrationWrapperFactory

typedef NekFactory< std::string, TimeIntegrationWrapper > Nektar::LibUtilities::TimeIntegrationWrapperFactory

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

Definition at line 45 of file TimeIntegrationWrapper.h.

◆ TimeIntegrationWrapperSharedPtr

typedef std::shared_ptr<TimeIntegrationWrapper> Nektar::LibUtilities::TimeIntegrationWrapperSharedPtr

Definition at line 56 of file TimeIntegrationWrapper.h.

◆ TranspositionSharedPtr

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

Definition at line 165 of file Transposition.h.

◆ VariableList

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

Definition at line 61 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 163 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 \( \phi^c_{pqr}(z_i) for Pyramids\).
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(z_i) \).
eLegendre	Legendre Polynomials \( L_p(z_i) = P^{0,0}_p(z_i)\). Same as Ortho_A.
eChebyshev	Chebyshev Polynomials \( T_p(z_i) = P^{-1/2,-1/2}_p(z_i)\).
eMonomial	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 42 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
         };

◆ CommDataType

enum Nektar::LibUtilities::CommDataType

Enumerator
MPI_CHAR
MPI_INT
MPI_UNSIGNED
MPI_LONG
MPI_UNSIGNED_LONG
MPI_LONG_LONG
MPI_UNSIGNED_LONG_LONG
MPI_FLOAT
MPI_DOUBLE
MPI_LONG_DOUBLE

Definition at line 70 of file CommDataType.h.

 {
     MPI_CHAR,
     MPI_INT,
     MPI_UNSIGNED,
     MPI_LONG,
     MPI_UNSIGNED_LONG,
     MPI_LONG_LONG,
     MPI_UNSIGNED_LONG_LONG,
     MPI_FLOAT,
     MPI_DOUBLE,
     MPI_LONG_DOUBLE
 };

◆ EndianType

enum Nektar::LibUtilities::EndianType

Enumerator
eEndianUnknown
eEndianBig
eEndianLittle
eEndianBigWord
eEndianLittleWord

Definition at line 50 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 79 of file FieldIO.cpp.

                  {
     eXML,
     eHDF5
 };

◆ FunctionType

enum Nektar::LibUtilities::FunctionType

Enumerator
eFunctionTypeExpression
eFunctionTypeFile
eFunctionTypeTransientFile
eSIZE_FunctionType

Definition at line 85 of file SessionReader.h.

         {
             eFunctionTypeExpression,
             eFunctionTypeFile,
             eFunctionTypeTransientFile,
             eSIZE_FunctionType,
         };

◆ InterpMethod

enum Nektar::LibUtilities::InterpMethod

Enumerator
eNoMethod
eNearestNeighbour
eQuadratic
eShepard
eGauss

Definition at line 59 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, \( \alpha = 0, \beta = 1 \).
eGaussRadauMAlpha0Beta2	Gauss Radau pinned at x=-1, \( \alpha = 0, \beta = 2 \).
eGaussRadauMAlpha1Beta0	Gauss Radau pinned at x=-1, \( \alpha = 1, \beta = 0 \).
eGaussRadauMAlpha2Beta0	Gauss Radau pinned at x=-1, \( \alpha = 2, \beta = 0 \).
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, \( \alpha = 1, \beta = 0 \)
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 45 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 64 of file PtsField.h.

 {
     eIsEquiSpacedData,
     ePtsPerElmtEdge
 };

◆ PtsType

enum Nektar::LibUtilities::PtsType

Enumerator
ePtsFile
ePtsLine
ePtsPlane
ePtsBox
ePtsSegBlock
ePtsTriBlock
ePtsTetBlock

Definition at line 53 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 65 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

Definition at line 53 of file ShapeType.hpp.

         {
             eNoShapeType,
             ePoint,
             eSegment,
             eTriangle,
             eQuadrilateral,
             eTetrahedron,
             ePyramid,
             ePrism,
             eHexahedron,
             SIZE_ShapeType
         };

◆ TimeIntegrationMethod

enum Nektar::LibUtilities::TimeIntegrationMethod

Enumerator
eNoTimeIntegrationMethod
eAdamsBashforthOrder1	Adams-Bashforth Forward multi-step scheme of order 1.
eAdamsBashforthOrder2	Adams-Bashforth Forward multi-step scheme of order 2.
eAdamsBashforthOrder3	Adams-Bashforth Forward multi-step scheme of order 3.
eAdamsBashforthOrder4	Adams-Bashforth Forward multi-step scheme of order 4.
eAdamsMoultonOrder1	Adams-Moulton Forward multi-step scheme of order 1.
eAdamsMoultonOrder2	Adams-Moulton Forward multi-step scheme of order 2.
eBDFImplicitOrder1	BDF multi-step scheme of order 1 (implicit)
eBDFImplicitOrder2	BDF multi-step scheme of order 2 (implicit)
eClassicalRungeKutta4	Runge-Kutta multi-stage scheme 4th order explicit (old name)
eRungeKutta4	Classical RungeKutta4 method (new name for eClassicalRungeKutta4)
eRungeKutta5	RungeKutta5 method.
eRungeKutta3_SSP	Nonlinear SSP RungeKutta3 explicit.
eRungeKutta2_ImprovedEuler	Improved RungeKutta2 explicit (old name meaning Heun's method)
eRungeKutta2_SSP	Nonlinear SSP RungeKutta2 explicit (surrogate for eRungeKutta2_ImprovedEuler)
eForwardEuler	Forward Euler scheme.
eBackwardEuler	Backward Euler scheme.
eIMEXOrder1	IMEX 1st order scheme using Euler Backwards/Euler Forwards.
eIMEXOrder2	IMEX 2nd order scheme using Backward Different Formula & Extrapolation.
eIMEXOrder3	IMEX 3rd order scheme using Backward Different Formula & Extrapolation.
eIMEXOrder4	IMEX 4th order scheme using Backward Different Formula & Extrapolation.
eMidpoint	midpoint method (old name)
eRungeKutta2	Classical RungeKutta2 method (new name for eMidpoint)
eDIRKOrder2	Diagonally Implicit Runge Kutta scheme of order 2.
eDIRKOrder3	Diagonally Implicit Runge Kutta scheme of order 3.
eCNAB	Crank-Nicolson/Adams-Bashforth Order 2 (CNAB)
eIMEXGear	IMEX Gear Order 2.
eMCNAB	Modified Crank-Nicolson/Adams-Bashforth Order 2 (MCNAB)
eIMEXdirk_1_1_1	Forward-Backward Euler IMEX DIRK(1,1,1)
eIMEXdirk_1_2_1	Forward-Backward Euler IMEX DIRK(1,2,1)
eIMEXdirk_1_2_2	Implicit-Explicit Midpoint IMEX DIRK(1,2,2)
eIMEXdirk_2_2_2	L-stable, two stage, second order IMEX DIRK(2,2,2)
eIMEXdirk_2_3_2	L-stable, three stage, third order IMEX DIRK(3,4,3)
eIMEXdirk_2_3_3	L-stable, two stage, third order IMEX DIRK(2,3,3)
eIMEXdirk_3_4_3	L-stable, three stage, third order IMEX DIRK(3,4,3)
eIMEXdirk_4_4_3	L-stable, four stage, third order IMEX DIRK(4,4,3)
SIZE_TimeIntegrationMethod	Length of enum list.

Definition at line 65 of file TimeIntegrationScheme.h.

         {
             eNoTimeIntegrationMethod,
             eAdamsBashforthOrder1,            //!< Adams-Bashforth Forward multi-step scheme of order 1
             eAdamsBashforthOrder2,            //!< Adams-Bashforth Forward multi-step scheme of order 2
             eAdamsBashforthOrder3,            //!< Adams-Bashforth Forward multi-step scheme of order 3
             eAdamsBashforthOrder4,            //!< Adams-Bashforth Forward multi-step scheme of order 4
             eAdamsMoultonOrder1,              //!< Adams-Moulton Forward multi-step scheme of order 1
             eAdamsMoultonOrder2,              //!< Adams-Moulton Forward multi-step scheme of order 2
             eBDFImplicitOrder1,               //!< BDF multi-step scheme of order 1 (implicit)
             eBDFImplicitOrder2,               //!< BDF multi-step scheme of order 2 (implicit)
             eClassicalRungeKutta4,            //!< Runge-Kutta multi-stage scheme 4th order explicit (old name)
             eRungeKutta4,                     //!< Classical RungeKutta4 method (new name for eClassicalRungeKutta4)
             eRungeKutta5,                     //!< RungeKutta5 method
             eRungeKutta3_SSP,                 //!< Nonlinear SSP RungeKutta3 explicit
             eRungeKutta2_ImprovedEuler,       //!< Improved RungeKutta2 explicit (old name meaning Heun's method)
             eRungeKutta2_SSP,                 //!< Nonlinear SSP RungeKutta2 explicit (surrogate for eRungeKutta2_ImprovedEuler)
             eForwardEuler,                    //!< Forward Euler scheme
             eBackwardEuler,                   //!< Backward Euler scheme
             eIMEXOrder1,                      //!< IMEX 1st order scheme using Euler Backwards/Euler Forwards
             eIMEXOrder2,                      //!< IMEX 2nd order scheme using Backward Different Formula & Extrapolation
             eIMEXOrder3,                      //!< IMEX 3rd order scheme using Backward Different Formula & Extrapolation
             eIMEXOrder4,                      //!< IMEX 4th order scheme using Backward Different Formula & Extrapolation
             eMidpoint,                        //!< midpoint method (old name)
             eRungeKutta2,                     //!< Classical RungeKutta2 method (new name for eMidpoint)
             eDIRKOrder2,                      //!< Diagonally Implicit Runge Kutta scheme of order 2
             eDIRKOrder3,                      //!< Diagonally Implicit Runge Kutta scheme of order 3
             eCNAB,                            //!< Crank-Nicolson/Adams-Bashforth Order 2 (CNAB)
             eIMEXGear,                        //!< IMEX Gear Order 2
             eMCNAB,                           //!< Modified Crank-Nicolson/Adams-Bashforth Order 2 (MCNAB)
             eIMEXdirk_1_1_1,                  //!< Forward-Backward Euler IMEX DIRK(1,1,1)
             eIMEXdirk_1_2_1,                  //!< Forward-Backward Euler IMEX DIRK(1,2,1)
             eIMEXdirk_1_2_2,                  //!< Implicit-Explicit Midpoint IMEX DIRK(1,2,2)
             eIMEXdirk_2_2_2,                  //!< L-stable, two stage, second order IMEX DIRK(2,2,2)
             eIMEXdirk_2_3_2,                  //!< L-stable, three stage, third order IMEX DIRK(3,4,3)
             eIMEXdirk_2_3_3,                  //!< L-stable, two stage, third order IMEX DIRK(2,3,3)
             eIMEXdirk_3_4_3,                  //!< L-stable, three stage, third order IMEX DIRK(3,4,3)
             eIMEXdirk_4_4_3,                  //!< L-stable, four stage, third order IMEX DIRK(4,4,3)
             SIZE_TimeIntegrationMethod        //!< Length of enum list
         };

◆ 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.

Definition at line 146 of file TimeIntegrationScheme.h.

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

◆ TranspositionDir

enum Nektar::LibUtilities::TranspositionDir

Enumerator
eXYtoZ
eZtoXY
eXtoYZ
eYZtoX
eYZtoZY
eZYtoYZ
eXtoY
eYtoZ
eZtoX
eNoTrans

Definition at line 54 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 91 of file Interpreter.cpp.

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

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

◆ awgn()

NekDouble Nektar::LibUtilities::awgn ( NekDouble sigma )

Definition at line 78 of file Interpreter.cpp.

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

 {
     boost::mt19937 rng;
     boost::variate_generator<boost::mt19937 &, boost::normal_distribution<>>
         _normal(rng, boost::normal_distribution<>(0, sigma));
     return _normal();
 }

◆ BasisManager()

BasisManagerT & Nektar::LibUtilities::BasisManager ( void )

Definition at line 48 of file ManagerAccess.cpp.

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::DisContField1D::v_AddTraceIntegral(), and Nektar::StdRegions::StdQuadExp::v_GenMatrix().

 {
     static BasisManagerT instance;
     return instance;
 }

◆ 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 57 of file CheckedCast.hpp.

References ASSERTL0.

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

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

◆ 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 54 of file CommDataType.cpp.

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

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

◆ Endianness()

EndianType Nektar::LibUtilities::Endianness ( void )

run time determination of endianness, returning an EndianType

Definition at line 68 of file CompressData.cpp.

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

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

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

◆ GetCommFactory()

CommFactory & Nektar::LibUtilities::GetCommFactory ( )

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

Referenced by Nektar::LibUtilities::SessionReader::CreateComm(), Import(), main(), Nektar::FieldUtils::ProcessInterpField::Process(), Nektar::FieldUtils::ProcessPointDataToFld::Process(), Nektar::FieldUtils::ProcessInterpPoints::Process(), Nektar::SpatialDomains::MeshPartition::ReadExpansions(), Nektar::Utilities::ProcessCurve::v_GenerateEdgeNodes(), Write(), and Nektar::FieldUtils::OutputFileBase::WriteFile().

 {
     static CommFactory instance;
     return instance;
 }

◆ GetFieldIOFactory()

FieldIOFactory & Nektar::LibUtilities::GetFieldIOFactory ( )

Returns the FieldIO factory.

Definition at line 72 of file FieldIO.cpp.

Referenced by Nektar::LibUtilities::FieldIO::CreateDefault(), Nektar::LibUtilities::FieldIO::CreateForFile(), Nektar::MultiRegions::ExpList::ExtractFileBCs(), Nektar::FieldUtils::Field::FieldIOForFile(), Nektar::LibUtilities::H5::DataTypeTraits< T >::GetType(), Import(), Nektar::FieldUtils::OutputFld::OutputFromData(), Nektar::FieldUtils::OutputFld::OutputFromExp(), Nektar::FieldUtils::OutputInfo::Process(), Nektar::SpatialDomains::MeshPartition::ReadExpansions(), and Write().

 {
     static FieldIOFactory instance;
     return instance;
 }

◆ GetNektarFFTFactory()

NektarFFTFactory & Nektar::LibUtilities::GetNektarFFTFactory ( )

Definition at line 69 of file NektarFFT.cpp.

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

         {
                     static NektarFFTFactory instance;
                     return instance;
         }

◆ GetNumberOfCoefficients() [1/2]

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

inline

Definition at line 313 of file ShapeType.hpp.

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.

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

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

◆ GetNumberOfCoefficients() [2/2]

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

inline

Definition at line 348 of file ShapeType.hpp.

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.

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

◆ GetTimeIntegrationWrapperFactory()

TimeIntegrationWrapperFactory & Nektar::LibUtilities::GetTimeIntegrationWrapperFactory ( )

Definition at line 41 of file TimeIntegrationWrapper.cpp.

     {
         static TimeIntegrationWrapperFactory instance;
         return instance;
     }

◆ 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 293 of file FieldIO.cpp.

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

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

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

◆ 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 53 of file Interp.cpp.

References Nektar::LibUtilities::BasisKey::GetPointsKey().

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

◆ Interp1D() [2/4]

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

Definition at line 61 of file Interp.cpp.

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

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

◆ Interp1D() [3/4]

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

Definition at line 83 of file Interp.cpp.

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

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

◆ Interp1D() [4/4]

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

Definition at line 91 of file Interp.cpp.

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

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

◆ 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 115 of file Interp.cpp.

References Nektar::LibUtilities::BasisKey::GetPointsKey().

Referenced by Nektar::FieldUtils::ProcessEquiSpacedOutput::GenOrthoModes(), Nektar::FieldUtils::ProcessQualityMetric::GetQ(), Nektar::SpatialDomains::GeomFactors::Interp(), Interp2D(), Nektar::GlobalMapping::UpdateGeometry(), Nektar::LocalRegions::TetExp::v_ComputeFaceNormal(), Nektar::LocalRegions::PrismExp::v_ComputeFaceNormal(), Nektar::LocalRegions::PyrExp::v_ComputeFaceNormal(), Nektar::LocalRegions::HexExp::v_ComputeFaceNormal(), Nektar::LocalRegions::QuadExp::v_ExtractDataToCoeffs(), Nektar::SpatialDomains::QuadGeom::v_FillGeom(), Nektar::SpatialDomains::TriGeom::v_FillGeom(), Nektar::LocalRegions::Expansion::v_GetCoords(), Nektar::LocalRegions::Expansion3D::v_GetFacePhysVals(), Nektar::MultiRegions::ExpList2D::v_GetNormals(), and Nektar::MultiRegions::ExpList2D::v_PhysInterp1DScaled().

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

◆ 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 126 of file Interp.cpp.

References Interp2D().

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

◆ 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 136 of file Interp.cpp.

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

         {
             // 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
 
             int fnp0 = fpoints0.GetNumPoints();
             int fnp1 = fpoints1.GetNumPoints();
             int tnp0 = tpoints0.GetNumPoints();
             int 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);     
             }
         }

◆ 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 185 of file Interp.cpp.

References Nektar::LibUtilities::BasisKey::GetPointsKey().

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

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

◆ 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 201 of file Interp.cpp.

References Interp3D().

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

◆ 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 214 of file Interp.cpp.

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

         {
             int i;
             DNekMatSharedPtr I0, I1, I2;
             
             int fnp0 = fpoints0.GetNumPoints();
             int fnp1 = fpoints1.GetNumPoints();
             int fnp2 = fpoints2.GetNumPoints();
             int tnp0 = tpoints0.GetNumPoints();
             int tnp1 = tpoints1.GetNumPoints();
             int 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);         
         }

◆ InterpCoeff1D()

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

Definition at line 46 of file InterpCoeff.cpp.

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

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

◆ 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 72 of file InterpCoeff.cpp.

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

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

◆ 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 83 of file InterpCoeff.cpp.

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

         {
             const int fnm0 = fbasis0.GetNumModes();
             const int fnm1 = fbasis1.GetNumModes();
             const int tnm0 = tbasis0.GetNumModes();
             const int 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);
             }
         }

◆ 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 124 of file InterpCoeff.cpp.

Referenced by Nektar::LocalRegions::HexExp::v_ReduceOrderCoeffs().

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

◆ 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 137 of file InterpCoeff.cpp.

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

         {
             const int fnm0 = fbasis0.GetNumModes();
             const int fnm1 = fbasis1.GetNumModes();
             const int fnm2 = fbasis2.GetNumModes();
             const int tnm0 = tbasis0.GetNumModes();
             const int tnm1 = tbasis1.GetNumModes();
             const int 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 (int 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);
         }

◆ NullBasisKey()

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

static

Defines a null basis with no type or points.

◆ NullPointsKey()

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

static

Referenced by Nektar::LibUtilities::BasisKey::BasisKey(), Nektar::StdRegions::StdExpansion::v_GetFacePointsKey(), and Nektar::StdRegions::StdExpansion::v_GetNodalPointsKey().

◆ NullTimeIntegrationSchemeKey()

static const TimeIntegrationSchemeKey Nektar::LibUtilities::NullTimeIntegrationSchemeKey ( eNoTimeIntegrationMethod )

static

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

◆ operator!=() [1/4]

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

Definition at line 62 of file Graph.cpp.

References Nektar::LibUtilities::GraphVertexObject::m_id.

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

◆ operator!=() [2/4]

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

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

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

◆ operator!=() [3/4]

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

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

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

◆ operator!=() [4/4]

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

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

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

◆ operator<() [1/3]

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

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

References Nektar::LibUtilities::BasisKey::GetPointsKey(), Nektar::LibUtilities::BasisKey::m_basistype, and Nektar::LibUtilities::BasisKey::m_nummodes.

Referenced by Nektar::LibUtilities::TimeIntegrationSchemeKey::operator!=(), and Nektar::LibUtilities::TimeIntegrationSchemeKey::TimeIntegrationSchemeKey().

         {
             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/3]

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

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

References Nektar::LibUtilities::PointsKey::m_factor, Nektar::LibUtilities::PointsKey::m_numpoints, and Nektar::LibUtilities::PointsKey::m_pointstype.

         {
             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 true;
             }
 
             return false;
         }

◆ operator<() [3/3]

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

Definition at line 57 of file TimeIntegrationScheme.cpp.

References Nektar::LibUtilities::TimeIntegrationSchemeKey::m_method.

         {
             return (lhs.m_method < rhs.m_method);
         }

◆ operator<<() [1/5]

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

Definition at line 67 of file TimeIntegrationScheme.cpp.

References Nektar::LibUtilities::TimeIntegrationSchemeKey::GetIntegrationMethod(), and TimeIntegrationMethodMap.

         {
             os << "Time Integration Scheme: " << TimeIntegrationMethodMap[rhs.GetIntegrationMethod()] << std::endl;
 
             return os;
         }

◆ operator<<() [2/5]

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

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

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

Referenced by Nektar::LibUtilities::Basis::Basis(), operator<<(), and Nektar::LibUtilities::TimeIntegrationSchemeKey::TimeIntegrationSchemeKey().

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

◆ operator<<() [3/5]

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

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

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

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

◆ operator<<() [4/5]

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

Definition at line 1929 of file TimeIntegrationScheme.cpp.

References operator<<().

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

◆ operator<<() [5/5]

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

Definition at line 1934 of file TimeIntegrationScheme.cpp.

         {
             int i,j;
             int r = rhs.GetNsteps();
             int s = rhs.GetNstages();
             TimeIntegrationSchemeType type = rhs.GetIntegrationSchemeType();
 
             int oswidth = 9;
             int osprecision = 6;
 
             os << "Time Integration Scheme: " << TimeIntegrationMethodMap[rhs.GetIntegrationMethod()] << std::endl;
             os << "- number of steps:  " << r << std::endl;
             os << "- number of stages: " << s << std::endl;
             os << "- type of scheme:   " << TimeIntegrationSchemeTypeMap[rhs.GetIntegrationSchemeType()] << std::endl;
             os << "General linear method tableau: " << std::endl;
 
             for(i = 0; i < s; i++)
             {
                 for(j = 0; j < s; j++)
                 {
                     os.width(oswidth);
                     os.precision(osprecision);
                     os << std::right << rhs.A(i,j) << " ";
                 }
                 if(type == eIMEX)
                 {
                     os << " '"; 
                     for(j = 0; j < s; j++)
                     {
                         os.width(oswidth);
                         os.precision(osprecision);
                         os << std::right << rhs.A_IMEX(i,j) << " ";
                     }
                 }
                 os << " |"; 
 
                 for(j = 0; j < r; j++)
                 {
                     os.width(oswidth);
                     os.precision(osprecision);
                     os << std::right << rhs.U(i,j);
                 }
                 os << std::endl;
             }
             int imexflag = (type == eIMEX)?2:1;
             for(int i = 0; i < (r+imexflag*s)*(oswidth+1)+imexflag*2-1; i++)
             {
                 os << "-";
             }
             os << std::endl;
             for(i = 0; i < r; i++)
             {
                 for(j = 0; j < s; j++)
                 {
                     os.width(oswidth);
                     os.precision(osprecision);
                     os << std::right << rhs.B(i,j) << " ";
                 }
                 if(type == eIMEX)
                 {
                     os << " '"; 
                     for(j = 0; j < s; j++)
                     {
                         os.width(oswidth);
                         os.precision(osprecision);
                         os << std::right << rhs.B_IMEX(i,j) << " ";
                     }
                 }
                 os << " |"; 
 
                 for(j = 0; j < r; j++)
                 {
                     os.width(oswidth);
                     os.precision(osprecision);
                     os << std::right << rhs.V(i,j);
                 }
                 os << std::endl;
             }
             return os;
         }

◆ operator==() [1/6]

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

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

References Nektar::LibUtilities::PointsKey::m_numpoints, and Nektar::LibUtilities::PointsKey::m_pointstype.

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

◆ operator==() [2/6]

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

Definition at line 52 of file TimeIntegrationScheme.cpp.

References Nektar::LibUtilities::TimeIntegrationSchemeKey::m_method.

         {
             return (lhs.m_method == rhs.m_method);
         }

◆ operator==() [3/6]

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

Definition at line 57 of file Graph.cpp.

References Nektar::LibUtilities::GraphVertexObject::m_id.

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

◆ operator==() [4/6]

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

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

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

Referenced by Nektar::LibUtilities::TimeIntegrationSchemeKey::operator!=(), and Nektar::LibUtilities::TimeIntegrationSchemeKey::TimeIntegrationSchemeKey().

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

◆ operator==() [5/6]

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

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

         {
             return (*x == y);
         }

◆ operator==() [6/6]

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

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

         {
             return (x == *y);
         }

◆ operator>()

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

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

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

         {
             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 52 of file PhysGalerkinProject.cpp.

References Nektar::LibUtilities::BasisKey::GetPointsKey().

Referenced by PhysGalerkinProject1D().

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

◆ PhysGalerkinProject1D() [2/4]

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

Definition at line 60 of file PhysGalerkinProject.cpp.

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

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

◆ PhysGalerkinProject1D() [3/4]

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

Definition at line 83 of file PhysGalerkinProject.cpp.

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

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

◆ PhysGalerkinProject1D() [4/4]

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

Definition at line 91 of file PhysGalerkinProject.cpp.

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

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

◆ 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 115 of file PhysGalerkinProject.cpp.

References Nektar::LibUtilities::BasisKey::GetPointsKey().

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

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

◆ 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 126 of file PhysGalerkinProject.cpp.

References PhysGalerkinProject2D().

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

◆ 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 136 of file PhysGalerkinProject.cpp.

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

         {
             DNekMatSharedPtr GP0,GP1;
             Array<OneD, NekDouble> wsp(tpoints1.GetNumPoints()*fpoints0.GetNumPoints()); // fnp0*tnp1
 
             int fnp0 = fpoints0.GetNumPoints();
             int fnp1 = fpoints1.GetNumPoints();
             int tnp0 = tpoints0.GetNumPoints();
             int 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);     
             }
         }

◆ 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 177 of file PhysGalerkinProject.cpp.

References Nektar::LibUtilities::BasisKey::GetPointsKey().

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

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

◆ 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 196 of file PhysGalerkinProject.cpp.

References PhysGalerkinProject3D().

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

◆ 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 209 of file PhysGalerkinProject.cpp.

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

         {
             DNekMatSharedPtr GP0,GP1,GP2;
 
             int fnp0 = fpoints0.GetNumPoints();
             int fnp1 = fpoints1.GetNumPoints();
             int fnp2 = fpoints2.GetNumPoints();
             int tnp0 = tpoints0.GetNumPoints();
             int tnp1 = tpoints1.GetNumPoints();
             int 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(int 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);
         }

◆ PointsManager()

PointsManagerT & Nektar::LibUtilities::PointsManager ( void )

Definition at line 42 of file ManagerAccess.cpp.

 {
     static PointsManagerT instance;
     return instance;
 }

◆ PortablePath()

std::string Nektar::LibUtilities::PortablePath ( const boost::filesystem::path & path )

create portable path on different platforms for boost::filesystem path

Definition at line 41 of file FileSystem.cpp.

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

◆ 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 67 of file Progressbar.hpp.

References ISTTY.

Referenced by Nektar::NekMeshUtils::Octree::CompileSourcePointList(), Nektar::Utilities::ProcessVarOpti::CreateColoursets(), Nektar::Utilities::ProcessSpherigon::FindNormalFromPlyFile(), Nektar::FieldUtils::Iso::GlobalCondense(), Nektar::NekMeshUtils::Mesh::MakeOrder(), Nektar::FieldUtils::ProcessInterpField::PrintProgressbar(), Nektar::FieldUtils::ProcessInterpPoints::PrintProgressbar(), Nektar::FieldUtils::ProcessInterpPtsToPts::PrintProgressbar(), Nektar::FieldUtils::ProcessInterpPointDataToFld::PrintProgressbar(), Nektar::SolverUtils::SessionFunction::PrintProgressbar(), Nektar::SolverUtils::EquationSystem::PrintProgressbar(), Nektar::NekMeshUtils::HOSurfaceMesh::Process(), Nektar::NekMeshUtils::SurfaceMesh::Process(), Nektar::NekMeshUtils::Generator2D::Process(), Nektar::Utilities::ProcessProjectCAD::Process(), and Nektar::FieldUtils::Iso::SeparateRegions().

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

◆ rad()

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

static

Definition at line 86 of file Interpreter.cpp.

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

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

◆ sign()

NekDouble Nektar::LibUtilities::sign ( NekDouble arg )

Definition at line 70 of file Interpreter.cpp.

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

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

◆ TimeIntegrationSchemeManager()

TimeIntegrationSchemeManagerT & Nektar::LibUtilities::TimeIntegrationSchemeManager ( void )

Definition at line 44 of file TimeIntegrationScheme.cpp.

References Nektar::LibUtilities::TimeIntegrationScheme::Create(), and Nektar::LibUtilities::NekManager< KeyType, ValueT, opLessCreator >::RegisterGlobalCreator().

         {
             static TimeIntegrationSchemeManagerT instance;
             instance.RegisterGlobalCreator(TimeIntegrationScheme::Create);
             return instance;
         }

◆ 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 249 of file FieldIO.cpp.

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

Referenced by main(), Nektar::PulseWaveSystem::WriteVessels(), and Nektar::LibUtilities::FieldIO::~FieldIO().

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

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 46 of file Foundations.hpp.

Referenced by export_Basis(), Nektar::LibUtilities::FieldIOXml::ImportFieldDefs(), operator<<(), Nektar::SpatialDomains::MeshGraph::ReadExpansions(), 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 59 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 66 of file FieldIO.cpp.

◆ functions_p

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

static

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

◆ FunctionTypeMap

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

Initial value:

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

Definition at line 92 of file SessionReader.h.

◆ kPointsTypeStr

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

Definition at line 70 of file Foundations.hpp.

Referenced by export_Points(), Nektar::LibUtilities::FieldIOHdf5::ImportFieldDef(), Nektar::LibUtilities::FieldIOXml::ImportFieldDefs(), operator<<(), Nektar::SpatialDomains::MeshGraphXml::ReadCurves(), Nektar::SpatialDomains::MeshGraph::ReadExpansions(), and Nektar::SpatialDomains::MeshGraphXml::WriteCurves().

◆ NodalTetElecAvailable

const unsigned int Nektar::LibUtilities::NodalTetElecAvailable = 10

Definition at line 23 of file NodalTetElecData.h.

◆ NodalTetElecData

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

static

Definition at line 25 of file NodalTetElecData.h.

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

◆ NodalTetElecNPTS

const unsigned int Nektar::LibUtilities::NodalTetElecNPTS[NodalTetElecAvailable] = {1,2,3,5,6,9,11,15,18,23}

static

Definition at line 24 of file NodalTetElecData.h.

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

◆ NodalTetSPIAvailable

const unsigned int Nektar::LibUtilities::NodalTetSPIAvailable = 10

Definition at line 42 of file NodalTetSPIData.h.

◆ NodalTetSPIData

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

static

Definition at line 46 of file NodalTetSPIData.h.

Referenced by Nektar::LibUtilities::NodalTetSPI::CalculatePoints(), and Nektar::LibUtilities::NodalTetSPI::CalculateWeights().

◆ NodalTetSPINPTS

const unsigned int Nektar::LibUtilities::NodalTetSPINPTS[NodalTetSPIAvailable]

static

Initial value:

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

Definition at line 43 of file NodalTetSPIData.h.

Referenced by Nektar::LibUtilities::NodalTetSPI::CalculatePoints(), and Nektar::LibUtilities::NodalTetSPI::CalculateWeights().

◆ NodalTriElecAvailable

const unsigned int Nektar::LibUtilities::NodalTriElecAvailable = 16

Definition at line 10 of file NodalTriElecData.h.

◆ NodalTriElecData

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

static

Definition at line 12 of file NodalTriElecData.h.

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

◆ NodalTriElecNPTS

const unsigned int Nektar::LibUtilities::NodalTriElecNPTS[NodalTriElecAvailable] = {1,2,3,4,5,7,8,10,12,14,16,19,21,24,27,30}

static

Definition at line 11 of file NodalTriElecData.h.

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

◆ NodalTriFeketeAvailable

const unsigned int Nektar::LibUtilities::NodalTriFeketeAvailable = 16

Definition at line 10 of file NodalTriFeketeData.h.

◆ NodalTriFeketeData

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

static

Definition at line 12 of file NodalTriFeketeData.h.

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

◆ NodalTriFeketeNPTS

const unsigned int Nektar::LibUtilities::NodalTriFeketeNPTS[NodalTriFeketeAvailable] = {1,2,3,4,5,7,8,10,12,14,16,19,21,24,27,30}

static

Definition at line 11 of file NodalTriFeketeData.h.

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

◆ NodalTriSPIAvailable

const unsigned int Nektar::LibUtilities::NodalTriSPIAvailable = 10

Definition at line 42 of file NodalTriSPIData.h.

◆ NodalTriSPIData

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

static

Definition at line 46 of file NodalTriSPIData.h.

Referenced by Nektar::LibUtilities::NodalTriSPI::CalculatePoints(), and Nektar::LibUtilities::NodalTriSPI::CalculateWeights().

◆ NodalTriSPINPTS

const unsigned int Nektar::LibUtilities::NodalTriSPINPTS[NodalTriSPIAvailable]

static

Initial value:

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

Definition at line 43 of file NodalTriSPIData.h.

Referenced by Nektar::LibUtilities::NodalTriSPI::CalculatePoints(), and Nektar::LibUtilities::NodalTriSPI::CalculateWeights().

◆ NullBasisSharedPtr

BasisSharedPtr Nektar::LibUtilities::NullBasisSharedPtr

static

Definition at line 365 of file Basis.h.

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

◆ NullBasisSharedPtr1DArray

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

static

Definition at line 366 of file Basis.h.

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

◆ NullFieldMetaDataMap

FieldMetaDataMap Nektar::LibUtilities::NullFieldMetaDataMap

static

Definition at line 53 of file FieldIO.h.

Referenced by Nektar::LibUtilities::FieldIO::AddInfoTag(), Nektar::SolverUtils::UnsteadySystem::CheckForRestartTime(), Nektar::SolverUtils::SessionFunction::EvaluateFld(), Nektar::LibUtilities::FieldIOXml::GetClassName(), Nektar::LinearisedAdvection::ImportFldBase(), Nektar::SpatialDomains::MeshGraphHDF5::MeshGraphHDF5(), Nektar::FieldUtils::ProcessInterpField::Process(), Nektar::FieldUtils::ProcessInnerProduct::Process(), Nektar::FieldUtils::ProcessMultiShear::Process(), Nektar::FieldUtils::ProcessAddFld::Process(), Nektar::FieldUtils::ProcessInterpPoints::Process(), Nektar::LibUtilities::FieldIOXml::~FieldIOXml(), Nektar::SpatialDomains::MeshGraphXml::~MeshGraphXml(), and Nektar::LibUtilities::PtsIO::~PtsIO().

◆ NullNekDoubleVector

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

static

Definition at line 809 of file SharedArray.hpp.

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

◆ NullPointsTypeVector

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

static

Definition at line 84 of file PointsType.h.

◆ NullPtsField

PtsFieldSharedPtr Nektar::LibUtilities::NullPtsField

static

Definition at line 180 of file PtsField.h.

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

◆ NullPtsInfoMap

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

static

Definition at line 70 of file PtsField.h.

Referenced by Nektar::LibUtilities::PtsIO::v_ImportFieldData().

◆ NullPtsMetaDataMap

PtsMetaDataMap Nektar::LibUtilities::NullPtsMetaDataMap

static

Definition at line 58 of file PtsIO.h.

◆ NullUnsignedIntVector

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

static

Definition at line 810 of file SharedArray.hpp.

Referenced by Nektar::MultiRegions::ExpList::GetNumElmts(), and Nektar::MultiRegions::ExpListHomogeneous2D::v_GetFieldDefinitions().

◆ NullVectorNekDoubleVector

std::vector<std::vector<NekDouble> > Nektar::LibUtilities::NullVectorNekDoubleVector = { NullNekDoubleVector }

static

Definition at line 812 of file SharedArray.hpp.

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

◆ perm12A_3d

const unsigned int 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 9 of file NodalTetElecData.h.

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

◆ perm12B_3d

const unsigned int 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 11 of file NodalTetElecData.h.

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

◆ perm12C_3d

const unsigned int 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 13 of file NodalTetElecData.h.

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

◆ perm24_3d

const unsigned int 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 16 of file NodalTetElecData.h.

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

◆ perm3A_2d [1/2]

const unsigned int Nektar::LibUtilities::perm3A_2d[3][3] = {{0,1,2},{2,0,1},{0,2,1}}

static

Definition at line 5 of file NodalTriFeketeData.h.

◆ perm3A_2d [2/2]

const unsigned int Nektar::LibUtilities::perm3A_2d[3][3] = {{0,1,2},{2,0,1},{0,2,1}}

static

Definition at line 6 of file NodalTriElecData.h.

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

◆ perm3B_2d [1/2]

const unsigned int Nektar::LibUtilities::perm3B_2d[3][3] = {{0,1,2},{1,0,2},{1,2,0}}

static

Definition at line 6 of file NodalTriFeketeData.h.

◆ perm3B_2d [2/2]

const unsigned int Nektar::LibUtilities::perm3B_2d[3][3] = {{0,1,2},{1,0,2},{1,2,0}}

static

Definition at line 7 of file NodalTriElecData.h.

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

◆ perm3C_2d

const unsigned int Nektar::LibUtilities::perm3C_2d[3][3] = {{0,1,2},{2,0,1},{1,2,0}}

static

Definition at line 7 of file NodalTriFeketeData.h.

◆ perm4_3d

const unsigned int Nektar::LibUtilities::perm4_3d[4][4] = {{0,1,2,3},{3,0,1,2},{2,3,0,1},{1,2,3,0}}

static

Definition at line 6 of file NodalTetElecData.h.

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

◆ perm6_2d [1/2]

const unsigned int 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 8 of file NodalTriFeketeData.h.

◆ perm6_2d [2/2]

const unsigned int 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 8 of file NodalTriElecData.h.

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

◆ perm6_3d

const unsigned int Nektar::LibUtilities::perm6_3d[6][4] = {{0,1,2,3},{0,2,1,3},{0,2,3,1},{2,0,1,3},{2,0,3,1},{2,3,0,1}}

static

Definition at line 7 of file NodalTetElecData.h.

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

◆ ReduceOperatorMap

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

Initial value:

=
{
    "ReduceSum",
    "ReduceMax",
    "ReduceMin"
}

Definition at line 73 of file Comm.h.

Referenced by export_Comm().

◆ ShapeTypeDimMap

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

Initial value:

Definition at line 82 of file ShapeType.hpp.

Referenced by Nektar::StdRegions::operator<(), Nektar::StdRegions::operator<<(), and Nektar::StdRegions::operator==().

◆ ShapeTypeMap

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

Initial value:

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

Definition at line 67 of file ShapeType.hpp.

Referenced by Nektar::Collections::CollectionOptimisation::CollectionOptimisation(), export_ShapeType(), Nektar::LibUtilities::FieldIOHdf5::ImportFieldDef(), Nektar::LibUtilities::FieldIOXml::ImportFieldDefs(), Nektar::MultiRegions::operator<<(), Nektar::StdRegions::operator<<(), Nektar::NekMeshUtils::Mesh::PrintStats(), Nektar::Utilities::InputGmsh::Process(), Nektar::FieldUtils::InputXml::Process(), Nektar::Utilities::ProcessJac::Process(), Nektar::SolverUtils::DriverAdaptive::ReplaceExpansion(), Nektar::Collections::CollectionOptimisation::SetWithTimings(), Nektar::LibUtilities::FieldIOHdf5::v_Write(), and Nektar::LibUtilities::FieldIOXml::v_Write().

◆ TimeIntegrationMethodMap

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

Definition at line 106 of file TimeIntegrationScheme.h.

Referenced by operator<<(), Nektar::VCSWeakPressure::v_GenerateSummary(), Nektar::SolverUtils::UnsteadySystem::v_GenerateSummary(), and Nektar::VelocityCorrectionScheme::v_GenerateSummary().

◆ TimeIntegrationSchemeTypeMap

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

Initial value:

= 
        {
            "NoTimeIntegrationSchemeType",
            "Explicit",
            "DiagonallyImplicit",
            "IMEX",
            "Implicit"
        }

Definition at line 155 of file TimeIntegrationScheme.h.

Referenced by operator<<().

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ BasisKeyVector

◆ BasisManagerT

◆ BasisSharedPtr

◆ BasisVector

◆ CmdLineArgMap

◆ CommCwipiSharedPtr

◆ CommFactory

◆ CommMpiSharedPtr

◆ CommSerialSharedPtr

◆ CommSharedPtr

◆ CsvIOSharedPtr

◆ DataSourceSharedPtr

◆ EnumMap

◆ EnumMapList

◆ EquationSharedPtr

◆ ExpressionMap

◆ FieldDefinitionsSharedPtr

◆ FieldIOFactory

◆ FieldIOSharedPtr

◆ FieldMetaDataMap

◆ FilterMap

◆ FilterParams

◆ FunctionMap

◆ FunctionVariableMap

◆ GeometricInfoMap

◆ GloSysInfoMap

◆ GloSysSolnInfoList

◆ GraphVertexID

◆ H5DataSourceSharedPtr

◆ H5TagWriterSharedPtr

◆ InterpolatorSharedPtr

◆ InterpreterSharedPtr

◆ KernelSharedPtr

◆ NekFFTWSharedPtr

◆ NektarFFTFactory

◆ NektarFFTSharedPtr

◆ ParameterMap

◆ PFD

◆ PFD1

◆ PFD2

◆ PFD3

◆ PFD4

◆ PointsBaseType

◆ PointsKeyVector

◆ PointsManagerT

◆ PointsSharedPtr

◆ PtsFieldSharedPtr

◆ PtsIOSharedPtr

◆ PtsMetaDataMap

◆ SessionReaderSharedPtr

◆ SharedMatrix

◆ SolverInfoMap

◆ TagMap

◆ TagWriterSharedPtr

◆ TimeIntegrationIMEXOrder1SharedPtr

◆ TimeIntegrationSchemeManagerT

◆ TimeIntegrationSchemeSharedPtr

◆ TimeIntegrationSchemeVector

◆ TimeIntegrationSchemeVectorIter

◆ TimeIntegrationSolutionSharedPtr

◆ TimeIntegrationSolutionVector

◆ TimeIntegrationSolutionVectorIter

◆ TimeIntegrationWrapperFactory

◆ TimeIntegrationWrapperSharedPtr

◆ TranspositionSharedPtr

◆ VariableList

◆ XmlDataSourceSharedPtr

◆ XmlTagWriterSharedPtr

Enumeration Type Documentation

◆ BasisType

◆ CommDataType

◆ EndianType

◆ FieldIOType