Nektar Namespace Reference

The above copyright notice and this permission notice shall be included. More...

Namespaces
	Collections
	detail
	FieldUtils
	GlobalMapping
	LibUtilities
	LocalRegions
	MultiRegions
	NekConstants
	RiemannTests
	SolverUtils
	SpatialDomains
	StdRegions
	The namespace associated with the the StdRegions library (StdRegions introduction)
	Thread

Classes
struct	OneD
struct	TwoD
struct	ThreeD
struct	FourD
class	FlagList
	Defines a list of flags. More...
class	ArrayInitializationPolicy
class	ArrayInitializationPolicy< ObjectType, typename std::enable_if< std::is_fundamental< ObjectType >::value >::type >
class	ArrayInitializationPolicy< ObjectType, typename std::enable_if<!std::is_fundamental< ObjectType >::value >::type >
class	ArrayDestructionPolicy
class	ArrayDestructionPolicy< ObjectType, typename std::enable_if< std::is_fundamental< ObjectType >::value >::type >
class	ArrayDestructionPolicy< ObjectType, typename std::enable_if<!std::is_fundamental< ObjectType >::value >::type >
struct	ConsistentObjectAccess
struct	ConsistentObjectAccess< DataType * >
struct	ConsistentObjectAccess< std::shared_ptr< DataType > >
class	ErrorUtil
struct	EnumHash
struct	PairHash
struct	PushBackFunctor
	Helper functors for holding a vector of numbers to be parsed by boost::spirit. More...
class	ParseUtils
struct	RawType
struct	RawType< std::shared_ptr< T > >
struct	RawType< const std::shared_ptr< T > >
struct	RawType< volatile std::shared_ptr< T > >
struct	RawType< const volatile std::shared_ptr< T > >
class	Array
class	Array< OneD, const DataType >
	1D Array of constant elements with garbage collection and bounds checking. More...
class	Array< TwoD, const DataType >
	2D array with garbage collection and bounds checking. More...
class	Array< OneD, DataType >
	1D Array More...
class	Array< TwoD, DataType >
	A 2D array. More...
class	NekMatrix< NekMatrix< DataType, InnerMatrixType >, BlockMatrixTag >
struct	CanGetRawPtr
struct	CanGetRawPtr< NekMatrix< T, StandardMatrixTag > >
struct	CanGetRawPtr< NekMatrix< NekMatrix< T, R >, ScaledMatrixTag > >
struct	CanGetRawPtr< NekMatrix< T, M > >
class	ConstMatrix
class	Matrix
struct	BandedMatrixFuncs
struct	FullMatrixFuncs
struct	TriangularMatrixFuncs
struct	UpperTriangularMatrixFuncs
struct	LowerTriangularMatrixFuncs
struct	SymmetricMatrixFuncs
struct	DiagonalMatrixFuncs
struct	TriangularBandedMatrixFuncs
struct	UpperTriangularBandedMatrixFuncs
struct	LowerTriangularBandedMatrixFuncs
struct	SymmetricBandedMatrixFuncs
struct	IsSharedPointer
struct	IsSharedPointer< std::shared_ptr< DataType > >
struct	LinearSystemSolver
class	LinearSystem
class	NekMatrix
class	NekPoint
class	NekVector
struct	IsVector
struct	IsVector< NekVector< DataType > >
class	NekMatrix< NekMatrix< DataType, InnerMatrixType >, ScaledMatrixTag >
class	NekSparseDiagBlkMatrix
class	NekSparseMatrix
class	StorageSmvBsr
class	NekMatrix< DataType, StandardMatrixTag >
	Standard Matrix. More...
class	MemoryManager
	General purpose memory allocation routines with the ability to allocate from thread specific memory pools. More...
class	MemPool
class	AcousticSystem
class	APE
class	LEE
class	AcousticSolver
class	APELaxFriedrichsSolver
class	APEUpwindSolver
class	LEELaxFriedrichsSolver
class	LEESolver
class	LEEUpwindSolver
class	CFLtester
class	EigenValuesAdvection
class	Helmholtz
class	Laplace
class	MMFAdvection
class	Poisson
class	Projection
class	SteadyAdvectionDiffusion
class	SteadyAdvectionDiffusionReaction
class	UnsteadyAdvection
class	UnsteadyAdvectionDiffusion
class	UnsteadyDiffusion
class	UnsteadyInviscidBurger
class	UnsteadyReactionDiffusion
class	UnsteadyViscousBurgers
class	CellModelAlievPanfilov
	Aliev Panfilov model. More...
class	CellModel
	Cell model base class. More...
class	CourtemancheRamirezNattel98
class	FentonKarma
class	CellModelFitzHughNagumo
	FitzHugh-Nagumo model. More...
class	Fox02
class	LuoRudy91
class	PanditGilesDemir03
class	TenTusscher06
class	Winslow99
class	Bidomain
	A model for cardiac conduction. More...
class	BidomainRoth
	A model for cardiac conduction. More...
class	Monodomain
	A model for cardiac conduction. More...
class	FilterBenchmark
	Records activation and repolarisation times. More...
class	FilterCellHistoryPoints
class	FilterCheckpointCellModel
class	FilterElectrogram
class	Protocol
	Protocol base class. More...
class	ProtocolS1
	Protocol base class. More...
class	ProtocolS1S2
	Protocol base class. More...
class	ProtocolSingle
	Protocol base class. More...
class	Stimulus
	Stimulus base class. More...
class	StimulusCirc
	Protocol base class. More...
class	StimulusPoint
	Protocol base class. More...
class	StimulusRect
	Protocol base class. More...
class	ArtificialDiffusion
	Encapsulates the artificial diffusion used in shock capture. More...
class	NonSmoothShockCapture
	Non Smooth artificial diffusion for shock capture for compressible flow problems. More...
class	CFSBndCond
	Encapsulates the user-defined boundary conditions for compressible flow solver. More...
class	ExtrapOrder0BC
	Extrapolation of order 0 for all the variables such that, at the boundaries, a trivial Riemann problem is solved. More...
class	IsentropicVortexBC
	Wall boundary conditions for compressible flow problems. More...
class	PressureInflowFileBC
	Pressure inflow boundary conditions for compressible flow problems where either the density and the velocities are assigned from a file or the full state is assigned from a file (depending on the problem type, either subsonic or supersonic). More...
class	PressureMachTemperatureBC
	Boundary condition in terms of pressure, Mach number and temperature. P should be defined in the "rho" entry, T in the "E" entry and the Mach number in each direction in the corresponding momentum variable. This state is converted to conserved variables and a Dirichlet condition is applied. More...
class	PressureOutflowBC
	Pressure outflow boundary conditions for compressible flow problems. More...
class	PressureOutflowNonReflectiveBC
	Pressure outflow non-reflective boundary conditions for compressible flow problems. More...
class	RiemannInvariantBC
	Outflow characteristic boundary conditions for compressible flow problems. More...
class	RinglebFlowBC
	Wall boundary conditions for compressible flow problems. More...
class	StagnationInflowBC
	Stagnation conditions inflow boundary conditions for compressible flow problems where the energy and density are prescribed. More...
class	SymmetryBC
	Symmetry boundary conditions for compressible flow problems. More...
class	TimeDependentBC
	Time dependent boundary condition. More...
class	WallBC
	Wall boundary conditions for compressible flow problems. More...
class	WallViscousBC
	Wall boundary conditions for viscous compressible flow problems. More...
class	DiffusionLDGNS
class	CompressibleFlowSystem
class	CFSImplicit
class	EulerCFE
class	EulerImplicitCFE
class	IsentropicVortex
class	NavierStokesCFE
class	NavierStokesCFEAxisym
class	NavierStokesImplicitCFE
class	RinglebFlow
class	ForcingAxiSymmetric
class	ForcingQuasi1D
class	EquationOfState
	Encapsulates equations of state allowing us to obtain thermodynamic properties: most relations are in the form X(rho,e) More...
class	IdealGasEoS
	Ideal gas equation of state: p = rho * R * T. More...
class	PengRobinsonEoS
	Peng-Robinson equation of state: p = RT/(1/rho - b) - a*Alpha(T/Tc) / (1/rho^2 + 2*b/rho - b^2) with a = 0.45724 * (R*Tc)^2 / Pc b = 0.0778 * (R*Tc) / Pc Alpha(T/Tc) = [1 + fw * (1 - sqrt(T/ Tc))]^2 fw = 0.37464 + 1.54226*omega - 0.2699*omega*omega. More...
class	RedlichKwongEoS
	Redlich-Kwong equation of state: p = RT/(1/rho - b) - a/( sqrt(T / Tc) * (1/rho^2 + b/rho) with a = 0.42748 * (R*Tc)^2 / Pc b = 0.08664 * (R*Tc) / Pc. More...
class	VanDerWaalsEoS
	van der Waals equation of state: p = RT/(1/rho - b) - a * rho^2 with a = 27/64 * (R*Tc)^2 / Pc b = 1/8 * (R*Tc) / Pc More...
class	VariableConverter
class	PreconCfs
class	PreconCfsBRJ
class	NekPreconCfsOperators
class	PreconCfsOp
class	AUSM0Solver
class	AUSM1Solver
class	AUSM2Solver
class	AUSM3Solver
class	AverageSolver
class	CompressibleSolver
class	ExactSolverToro
class	HLLCSolver
class	HLLSolver
class	LaxFriedrichsSolver
class	RoeSolver
class	RoeSolverSIMD
class	MMFDiffusion
	A model for cardiac conduction. More...
class	Dummy
class	ImageWarpingSystem
class	AdjointAdvection
	Advection for the adjoint form of the linearised Navier-Stokes equations. More...
class	AlternateSkewAdvection
class	LinearisedAdvection
class	NavierStokesAdvection
class	NoAdvection
class	SkewSymmetricAdvection
struct	coupledSolverMatrices
class	CoupledLinearNS
class	CoupledLocalToGlobalC0ContMap
class	Extrapolate
struct	HighOrderOutflow
struct	WomersleyParams
class	IncNavierStokes
	This class is the base class for Navier Stokes problems. More...
class	MappingExtrapolate
class	SmoothedProfileMethod
class	StandardExtrapolate
class	SubSteppingExtrapolate
class	SubSteppingExtrapolateWeakPressure
class	VCSMapping
class	VelocityCorrectionScheme
class	VCSWeakPressure
class	WeakPressureExtrapolate
class	FilterAeroForcesSPM
class	FilterMovingBody
class	ForcingMovingBody
class	ForcingStabilityCoupledLNS
class	CoupledAssemblyMap
	Modified version of MultiRegions::AssemblyMapCG that allows for coupled fields [u,v,w] instead of individual scalar fields u, v and w. More...
class	IterativeElasticSystem
	Class for iterative elastic system, in which linear elasticity is applied in substeps to attain a large deformation. More...
class	LinearElasticSystem
	Base class for linear elastic system. More...
class	MMFMaxwell
class	AInflow
class	BetaPressureArea
class	EmpiricalPressureArea
class	PowerPressureArea
class	PulseWaveBoundary
class	PulseWavePressureArea
class	PulseWavePropagation
struct	InterfacePoint
class	PulseWaveSystem
	Base class for unsteady solvers. More...
class	QInflow
class	RCROutflow
class	ROutflow
class	TemplatePressureArea
class	TerminalOutflow
	A global linear system. More...
class	TimeDependentInflow
class	UInflow
	A global linear system. More...
class	UndefinedInOutflow
class	UpwindPulseSolver
class	PulseWaveSystemOutput
	Base class for unsteady solvers. More...
class	LinearSWE
class	MMFSWE
class	NonlinearPeregrine
class	NonlinearSWE
class	ShallowWaterSystem
	Base class for unsteady solvers. More...
class	LinearAverageSolver
class	LinearHLLSolver
class	LinearSWESolver
class	NonlinearSWESolver
class	NoSolver
class	VortexWaveInteraction

Typedefs
typedef double	NekDouble
typedef float	NekSingle
typedef std::int32_t	NekInt
typedef std::int32_t	NekInt32
typedef std::int64_t	NekInt64
typedef std::uint32_t	NekUInt
typedef std::uint32_t	NekUInt32
typedef std::uint64_t	NekUInt64
template<typename T >
using	RawType_t = typename RawType< T >::type
template<class T >
using	TensorOfArray2D = Array< OneD, Array< OneD, T > >
template<class T >
using	TensorOfArray3D = Array< OneD, Array< OneD, Array< OneD, T > > >
template<class T >
using	TensorOfArray4D = Array< OneD, Array< OneD, Array< OneD, Array< OneD, T > > > >
template<class T >
using	TensorOfArray5D = Array< OneD, Array< OneD, Array< OneD, Array< OneD, Array< OneD, T > > > > >
typedef std::shared_ptr< NekMatrix< NekDouble, StandardMatrixTag > >	SharedNekMatrixPtr
typedef NekMatrix< NekMatrix< NekDouble, StandardMatrixTag >, ScaledMatrixTag >	DNekScalMat
typedef std::shared_ptr< DNekScalMat >	DNekScalMatSharedPtr
typedef std::shared_ptr< NekMatrix< NekSingle, StandardMatrixTag > >	SharedSNekMatrixPtr
typedef NekMatrix< NekMatrix< NekSingle, StandardMatrixTag >, ScaledMatrixTag >	SNekScalMat
typedef std::shared_ptr< SNekScalMat >	SNekScalMatSharedPtr
typedef NekVector< NekDouble >	DNekVec
typedef NekMatrix< NekDouble, StandardMatrixTag >	DNekMat
typedef NekMatrix< NekDouble, StandardMatrixTag >	DenseMatrix
typedef NekMatrix< DenseMatrix, ScaledMatrixTag >	ScaledMatrix
typedef NekMatrix< NekMatrix< NekDouble, StandardMatrixTag >, BlockMatrixTag >	DNekBlkMat
typedef NekMatrix< DenseMatrix, BlockMatrixTag >	BlockMatrix
typedef NekMatrix< NekMatrix< NekMatrix< NekDouble, StandardMatrixTag >, BlockMatrixTag >, BlockMatrixTag >	BlkMatDNekBlkMat
typedef NekMatrix< NekMatrix< NekMatrix< NekDouble, StandardMatrixTag >, ScaledMatrixTag >, BlockMatrixTag >	DNekScalBlkMat
typedef NekMatrix< NekMatrix< NekMatrix< NekMatrix< NekDouble, StandardMatrixTag >, ScaledMatrixTag >, BlockMatrixTag >, BlockMatrixTag >	BlkMatDNekScalBlkMat
typedef std::shared_ptr< DNekMat >	DNekMatSharedPtr
typedef std::shared_ptr< DNekBlkMat >	DNekBlkMatSharedPtr
typedef std::shared_ptr< BlkMatDNekBlkMat >	BlkMatDNekBlkMatSharedPtr
typedef std::shared_ptr< DNekScalBlkMat >	DNekScalBlkMatSharedPtr
typedef std::shared_ptr< BlkMatDNekScalBlkMat >	BlkMatDNekScalBlkMatSharedPtr
typedef LinearSystem	DNekLinSys
typedef std::shared_ptr< DNekLinSys >	DNekLinSysSharedPtr
typedef LinearSystem	DNekScalLinSys
typedef std::shared_ptr< DNekScalLinSys >	DNekScalLinSysSharedPtr
typedef NekVector< NekSingle >	SNekVec
typedef NekMatrix< NekSingle, StandardMatrixTag >	SNekMat
typedef NekMatrix< NekSingle, StandardMatrixTag >	SDenseMatrix
typedef NekMatrix< SDenseMatrix, ScaledMatrixTag >	SScaledMatrix
typedef NekMatrix< NekMatrix< NekSingle, StandardMatrixTag >, BlockMatrixTag >	SNekBlkMat
typedef NekMatrix< SDenseMatrix, BlockMatrixTag >	SBlockMatrix
typedef NekMatrix< NekMatrix< NekMatrix< NekSingle, StandardMatrixTag >, BlockMatrixTag >, BlockMatrixTag >	BlkMatSNekBlkMat
typedef NekMatrix< NekMatrix< NekMatrix< NekSingle, StandardMatrixTag >, ScaledMatrixTag >, BlockMatrixTag >	SNekScalBlkMat
typedef NekMatrix< NekMatrix< NekMatrix< NekMatrix< NekSingle, StandardMatrixTag >, ScaledMatrixTag >, BlockMatrixTag >, BlockMatrixTag >	BlkMatSNekScalBlkMat
typedef std::shared_ptr< SNekMat >	SNekMatSharedPtr
typedef std::shared_ptr< SNekBlkMat >	SNekBlkMatSharedPtr
typedef std::shared_ptr< BlkMatSNekBlkMat >	BlkMatSNekBlkMatSharedPtr
typedef std::shared_ptr< SNekScalBlkMat >	SNekScalBlkMatSharedPtr
typedef std::shared_ptr< BlkMatSNekScalBlkMat >	BlkMatSNekScalBlkMatSharedPtr
typedef unsigned int	IndexType
typedef Array< OneD, IndexType >	IndexVector
typedef std::pair< IndexType, IndexType >	CoordType
typedef NekDouble	COOEntryType
typedef std::map< CoordType, NekDouble >	COOMatType
typedef COOMatType::const_iterator	COOMatTypeConstIt
typedef std::shared_ptr< COOMatType >	COOMatTypeSharedPtr
typedef Array< OneD, COOMatType >	COOMatVector
typedef Array< OneD, NekDouble >	BCOEntryType
typedef std::map< CoordType, BCOEntryType >	BCOMatType
typedef BCOMatType::const_iterator	BCOMatTypeConstIt
typedef std::shared_ptr< BCOMatType >	BCOMatTypeSharedPtr
typedef Array< OneD, BCOMatType >	BCOMatVector
typedef std::vector< std::pair< std::string, std::string > >	SummaryList
typedef std::shared_ptr< CellModel >	CellModelSharedPtr
	A shared pointer to an EquationSystem object. More...
typedef LibUtilities::NekFactory< std::string, CellModel, const LibUtilities::SessionReaderSharedPtr &, const MultiRegions::ExpListSharedPtr & >	CellModelFactory
	Datatype of the NekFactory used to instantiate classes derived from the EquationSystem class. More...
typedef std::shared_ptr< Protocol >	ProtocolSharedPtr
	A shared pointer to an EquationSystem object. More...
typedef LibUtilities::NekFactory< std::string, Protocol, const LibUtilities::SessionReaderSharedPtr &, const TiXmlElement * >	ProtocolFactory
	Datatype of the NekFactory used to instantiate classes derived from the EquationSystem class. More...
typedef std::shared_ptr< Stimulus >	StimulusSharedPtr
	A shared pointer to an EquationSystem object. More...
typedef LibUtilities::NekFactory< std::string, Stimulus, const LibUtilities::SessionReaderSharedPtr &, const MultiRegions::ExpListSharedPtr &, const TiXmlElement * >	StimulusFactory
	Datatype of the NekFactory used to instantiate classes derived from the EquationSystem class. More...
typedef std::shared_ptr< ArtificialDiffusion >	ArtificialDiffusionSharedPtr
	A shared pointer to a artificial diffusion object. More...
typedef LibUtilities::NekFactory< std::string, ArtificialDiffusion, const LibUtilities::SessionReaderSharedPtr &, const Array< OneD, MultiRegions::ExpListSharedPtr > &, const int >	ArtificialDiffusionFactory
	Declaration of the artificial diffusion factory. More...
typedef std::shared_ptr< CFSBndCond >	CFSBndCondSharedPtr
	A shared pointer to a boundary condition object. More...
typedef LibUtilities::NekFactory< std::string, CFSBndCond, const LibUtilities::SessionReaderSharedPtr &, const Array< OneD, MultiRegions::ExpListSharedPtr > &, const Array< OneD, Array< OneD, NekDouble > > &, const int, const int, const int >	CFSBndCondFactory
	Declaration of the boundary condition factory. More...
typedef std::shared_ptr< DiffusionLDGNS >	DiffusionLDGNSSharedPtr
typedef std::shared_ptr< EquationOfState >	EquationOfStateSharedPtr
	A shared pointer to an equation of state object. More...
typedef LibUtilities::NekFactory< std::string, EquationOfState, const LibUtilities::SessionReaderSharedPtr & >	EquationOfStateFactory
	Declaration of the equation of state factory. More...
using	vec_t = tinysimd::simd< NekDouble >
typedef std::shared_ptr< VariableConverter >	VariableConverterSharedPtr
typedef std::shared_ptr< PreconCfs >	PreconCfsSharedPtr
typedef std::shared_ptr< PreconCfsOp >	PreconCfsOpSharedPtr
typedef LibUtilities::NekFactory< std::string, PreconCfsOp, const Array< OneD, MultiRegions::ExpListSharedPtr > &, const LibUtilities::SessionReaderSharedPtr &, const LibUtilities::CommSharedPtr & >	PreconCfsOpFactory
	Declaration of the boundary condition factory. More...
typedef struct Nektar::coupledSolverMatrices	CoupledSolverMatrices
typedef std::shared_ptr< CoupledLocalToGlobalC0ContMap >	CoupledLocalToGlobalC0ContMapSharedPtr
typedef std::shared_ptr< Extrapolate >	ExtrapolateSharedPtr
typedef LibUtilities::NekFactory< std::string, Extrapolate, const LibUtilities::SessionReaderSharedPtr &, Array< OneD, MultiRegions::ExpListSharedPtr > &, MultiRegions::ExpListSharedPtr &, const Array< OneD, int > &, const SolverUtils::AdvectionSharedPtr & >	ExtrapolateFactory
typedef std::shared_ptr< HighOrderOutflow >	HighOrderOutflowSharedPtr
typedef std::complex< double >	NekComplexDouble
typedef std::shared_ptr< WomersleyParams >	WomersleyParamsSharedPtr
typedef std::shared_ptr< IncNavierStokes >	IncNavierStokesSharedPtr
typedef std::shared_ptr< MappingExtrapolate >	MappingExtrapolateSharedPtr
typedef std::shared_ptr< SmoothedProfileMethod >	SmoothedProfileMethodSharedPtr
typedef std::shared_ptr< StandardExtrapolate >	StandardExtrapolateSharedPtr
typedef std::shared_ptr< SubSteppingExtrapolate >	SubSteppingExtrapolateSharedPtr
typedef std::shared_ptr< SubSteppingExtrapolateWeakPressure >	SubSteppingExtrapolateWeakPressureSharedPtr
typedef std::shared_ptr< VCSMapping >	VCSMappingSharedPtr
typedef std::shared_ptr< VelocityCorrectionScheme >	VelocityCorrectionSchemeSharedPtr
typedef std::shared_ptr< VCSWeakPressure >	VCSWeakPressureSharedPtr
typedef std::shared_ptr< WeakPressureExtrapolate >	WeakPressureExtrapolateSharedPtr
typedef std::shared_ptr< FilterAeroForcesSPM >	FilterAeroForcesSPMSharedPtr
typedef std::shared_ptr< FilterMovingBody >	FilterMovingBodySharedPtr
typedef std::map< std::string, std::string >	FilterParams
typedef std::pair< std::string, FilterParams >	FilterMap
typedef std::shared_ptr< CoupledAssemblyMap >	CoupledAssemblyMapSharedPtr
typedef std::shared_ptr< AInflow >	AInflowSharedPtr
typedef std::shared_ptr< BetaPressureArea >	BetaPressureAreaSharedPtr
typedef std::shared_ptr< EmpiricalPressureArea >	EmpiricalPressureAreaSharedPtr
typedef std::shared_ptr< PowerPressureArea >	PowerPressureAreaSharedPtr
typedef std::shared_ptr< PulseWaveBoundary >	PulseWaveBoundarySharedPtr
typedef LibUtilities::NekFactory< std::string, PulseWaveBoundary, Array< OneD, MultiRegions::ExpListSharedPtr > &, const LibUtilities::SessionReaderSharedPtr &, PulseWavePressureAreaSharedPtr & >	BoundaryFactory
typedef std::shared_ptr< PulseWavePressureArea >	PulseWavePressureAreaSharedPtr
typedef LibUtilities::NekFactory< std::string, PulseWavePressureArea, Array< OneD, MultiRegions::ExpListSharedPtr > &, const LibUtilities::SessionReaderSharedPtr & >	PressureAreaFactory
typedef std::shared_ptr< InterfacePoint >	InterfacePointShPtr
typedef std::shared_ptr< PulseWaveSystem >	PulseWaveSystemSharedPtr
typedef std::shared_ptr< QInflow >	QInflowSharedPtr
typedef std::shared_ptr< RCROutflow >	RCROutflowSharedPtr
typedef std::shared_ptr< ROutflow >	ROutflowSharedPtr
typedef std::shared_ptr< TemplatePressureArea >	TemplatePressureAreaSharedPtr
typedef std::shared_ptr< TerminalOutflow >	TerminalOutflowSharedPtr
	Pointer to a PulseWaveOutflow object. More...
typedef std::shared_ptr< TimeDependentInflow >	TimeDependentInflowSharedPtr
typedef std::shared_ptr< UInflow >	UInflowSharedPtr
	Pointer to a PulseWaveOutflow object. More...
typedef std::shared_ptr< UndefinedInOutflow >	UndefinedInOutflowSharedPtr
typedef std::shared_ptr< PulseWaveSystemOutput >	PulseWaveSystemOutputSharedPtr

Enumerations
enum	Direction { xDir = 0 , yDir = 1 , zDir = 2 }
enum	OutputFormat {   eTecplot , eTecplotZones , eTecplotSingleBlock , eGmsh ,   eGnuplot }
enum	FlagType { eUseGlobal }
	Enumeration of flags for passing a list of options. More...
enum	AllowWrappingOfConstArrays { eVECTOR_WRAPPER }
enum	MatrixStorage {   eFULL , eDIAGONAL , eUPPER_TRIANGULAR , eLOWER_TRIANGULAR ,   eSYMMETRIC , ePOSITIVE_DEFINITE_SYMMETRIC , eBANDED , eSYMMETRIC_BANDED ,   ePOSITIVE_DEFINITE_SYMMETRIC_BANDED , eUPPER_TRIANGULAR_BANDED , eLOWER_TRIANGULAR_BANDED }
enum	PointerWrapper { eWrapper , eCopy }
	Specifies if the pointer passed to a NekMatrix or NekVector is copied into an internal representation or used directly. More...
enum	PrecType { eNull , eDiagonal , eSparse }
enum	TestType {   eTestPlane , eTestCube , eTestLinearSphere , eTestNonlinearSphere ,   eFHNStandard , eFHNRogers , eFHNAlievPanf , SIZE_TestType ,   eTestPlane , eTestSteadyZonal , eTestUnsteadyZonal , eTestIsolatedMountain ,   eTestUnstableJet , eTestRossbyWave , SIZE_TestType }
enum	InitWaveType {   eLeft , eBothEnds , eCenter , eLeftBottomCorner ,   ePoint , eSpiralDock , SIZE_InitWaveType }
enum	HBCType { eNOHBC , eHBCNeumann , eOBC , eConvectiveOBC }
enum	EquationType {   eNoEquationType , eSteadyStokes , eSteadyOseen , eSteadyLinearisedNS ,   eUnsteadyStokes , eUnsteadyLinearisedNS , eUnsteadyNavierStokes , eSteadyNavierStokes ,   eEquationTypeSize }
enum	AdvectionForm {   eNoAdvectionForm , eConvective , eNonConservative , eLinearised ,   eAdjoint , eSkewSymmetric , eNoAdvection , eAdvectionFormSize }
enum	UpwindTypePulse { eNotSetPulse , eUpwindPulse , SIZE_UpwindTypePulse }
enum	TestType {   eTestPlane , eTestCube , eTestLinearSphere , eTestNonlinearSphere ,   eFHNStandard , eFHNRogers , eFHNAlievPanf , SIZE_TestType ,   eTestPlane , eTestSteadyZonal , eTestUnsteadyZonal , eTestIsolatedMountain ,   eTestUnstableJet , eTestRossbyWave , SIZE_TestType }
enum	ProblemType { eGeneral , eSolitaryWave , SIZE_ProblemType }
enum	VWIIterationType {   eFixedAlpha , eFixedWaveForcing , eFixedAlphaWaveForcing , eFixedWaveForcingWithSubIterationOnAlpha ,   eVWIIterationTypeSize }

Functions
template<typename Dim , typename DataType , typename ExtentListType >
std::shared_ptr< boost::multi_array_ref< DataType, Dim::Value > >	CreateStorage (const ExtentListType &extent)
template<typename DataType >
std::shared_ptr< boost::multi_array_ref< DataType, 1 > >	CreateStorage (size_t d1)
template<typename DataType >
std::shared_ptr< boost::multi_array_ref< DataType, 2 > >	CreateStorage (size_t d1, size_t d2)
template<typename DataType >
std::shared_ptr< boost::multi_array_ref< DataType, 3 > >	CreateStorage (size_t d1, size_t d2, size_t d3)
void	hash_combine (std::size_t &seed)
template<typename T , typename... Args>
void	hash_combine (std::size_t &seed, const T &v, Args... args)
template<typename T , typename... Args>
std::size_t	hash_combine (const T &v, Args... args)
template<typename Iter >
std::size_t	hash_range (Iter first, Iter last)
template<typename Iter >
void	hash_range (std::size_t &seed, Iter first, Iter last)
template<typename T >
bool	IsEqualImpl (const T &lhs, const T &rhs, std::false_type)
template<typename T >
bool	IsEqualImpl (const T &lhs, const T &rhs, std::true_type)
template<typename T >
bool	IsEqual (const T &lhs, const T &rhs)
template<typename T1 , typename T2 >
bool	operator== (const Array< OneD, T1 > &lhs, const Array< OneD, T2 > &rhs)
template<typename T1 , typename T2 >
bool	operator!= (const Array< OneD, T1 > &lhs, const Array< OneD, T2 > &rhs)
template<typename DataType >
Array< OneD, DataType >	operator+ (const Array< OneD, DataType > &lhs, typename Array< OneD, DataType >::size_type offset)
template<typename DataType >
Array< OneD, DataType >	operator+ (typename Array< OneD, DataType >::size_type offset, const Array< OneD, DataType > &rhs)
template<typename ConstDataType , typename DataType >
void	CopyArray (const Array< OneD, ConstDataType > &source, Array< OneD, DataType > &dest)
template<typename ConstDataType , typename DataType >
void	CopyArrayN (const Array< OneD, ConstDataType > &source, Array< OneD, DataType > &dest, typename Array< OneD, DataType >::size_type n)
template<typename T1 , typename T2 >
bool	operator== (const Array< TwoD, T1 > &lhs, const Array< TwoD, T2 > &rhs)
template<typename T1 , typename T2 >
bool	operator!= (const Array< TwoD, T1 > &lhs, const Array< TwoD, T2 > &rhs)
template<typename InnerMatrixType >
NekMatrix< InnerMatrixType, BlockMatrixTag >	Transpose (NekMatrix< InnerMatrixType, BlockMatrixTag > &rhs)
template<typename ResultDataType , typename LhsDataType , typename LhsMatrixType >
void	Multiply (NekMatrix< ResultDataType, StandardMatrixTag > &result, const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const ResultDataType &rhs)
	NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX (Multiply, NEKTAR_ALL_MATRIX_TYPES,(1,(void)),(1,(DNekMat &)),(1,(const NekDouble &))) NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX(Multiply
template<typename DataType , typename LhsDataType , typename LhsMatrixType >
SNekMat const NekSingle &NekMatrix< typename NekMatrix< LhsDataType, LhsMatrixType >::NumberType, StandardMatrixTag >	Multiply (const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const DataType &rhs)
	NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX (Multiply, NEKTAR_ALL_MATRIX_TYPES,(1,(DNekMat)),(0,()),(1,(const NekDouble &))) NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX(Multiply
template<typename RhsDataType , typename RhsMatrixType , typename ResultDataType >
const NekSingle &void	Multiply (NekMatrix< ResultDataType, StandardMatrixTag > &result, const ResultDataType &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
	NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX (Multiply, NEKTAR_ALL_MATRIX_TYPES,(1,(void)),(2,(DNekMat &, const NekDouble &)),(0,())) NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX(Multiply
template<typename DataType , typename RhsDataType , typename RhsMatrixType >
SNekMat const NekSingle NekMatrix< typename NekMatrix< RhsDataType, RhsMatrixType >::NumberType, StandardMatrixTag >	Multiply (const DataType &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
	NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX (Multiply, NEKTAR_ALL_MATRIX_TYPES,(1,(DNekMat)),(1,(const NekDouble &)),(0,())) NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX(Multiply
template<typename LhsDataType >
const NekSingle void	MultiplyEqual (NekMatrix< LhsDataType, StandardMatrixTag > &lhs, typename boost::call_traits< LhsDataType >::const_reference rhs)
	NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX (MultiplyEqual,(1,(DNekMat &)),(1,(void)),(0,()),(1,(const NekDouble &))) NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX(MultiplyEqual
template<typename ResultType , typename LhsDataType , typename RhsDataType , typename LhsMatrixType , typename RhsMatrixType >
SNekMat const NekSingle &void	NekMultiplyDefaultImpl (NekMatrix< ResultType, StandardMatrixTag > &result, const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
template<typename ResultType , typename LhsDataType , typename RhsDataType , typename LhsMatrixType , typename RhsMatrixType >
void	NekMultiplyFullMatrixFullMatrix (NekMatrix< ResultType, StandardMatrixTag > &result, const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
template<typename LhsDataType , typename RhsDataType , typename DataType , typename LhsMatrixType , typename RhsMatrixType >
void	Multiply (NekMatrix< DataType, StandardMatrixTag > &result, const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
	NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES (Multiply, NEKTAR_ALL_MATRIX_TYPES, NEKTAR_ALL_MATRIX_TYPES,(1,(void)),(1,(DNekMat &)),(0,())) NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES(Multiply
template<typename DataType , typename RhsDataType , typename RhsMatrixType >
SNekMat void	AddEqual (NekMatrix< DataType, StandardMatrixTag > &result, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
template<typename DataType , typename RhsDataType , typename RhsMatrixType >
void	AddEqualNegatedLhs (NekMatrix< DataType, StandardMatrixTag > &result, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
	NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX (AddEqual, NEKTAR_ALL_MATRIX_TYPES,(1,(void)),(1,(DNekMat &)),(0,())) NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX(AddEqual
template<typename DataType , typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >
SNekMat SNekMat void	Add (NekMatrix< DataType, StandardMatrixTag > &result, const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
template<typename DataType , typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >
void	AddNegatedLhs (NekMatrix< DataType, StandardMatrixTag > &result, const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
	NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES (Add, NEKTAR_ALL_MATRIX_TYPES, NEKTAR_ALL_MATRIX_TYPES,(1,(void)),(1,(DNekMat &)),(0,())) NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES(Add
template<typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >
SNekMat SNekMat NekMatrix< typename NekMatrix< LhsDataType, LhsMatrixType >::NumberType, StandardMatrixTag >	Add (const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
	NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES (Add, NEKTAR_ALL_MATRIX_TYPES, NEKTAR_ALL_MATRIX_TYPES,(1,(DNekMat)),(0,()),(0,())) NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES(Add
template<typename DataType , typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >
void	Subtract (NekMatrix< DataType, StandardMatrixTag > &result, const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
template<typename DataType , typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >
void	SubtractNegatedLhs (NekMatrix< DataType, StandardMatrixTag > &result, const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
	NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES (Subtract, NEKTAR_ALL_MATRIX_TYPES, NEKTAR_ALL_MATRIX_TYPES,(1,(void)),(1,(DNekMat &)),(0,())) NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES(Subtract
SNekMat	NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES (SubtractNegatedLhs, NEKTAR_ALL_MATRIX_TYPES, NEKTAR_ALL_MATRIX_TYPES,(1,(void)),(1,(DNekMat &)),(0,())) NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES(SubtractNegatedLhs
template<typename DataType , typename RhsDataType , typename RhsMatrixType >
SNekMat SNekMat void	SubtractEqual (NekMatrix< DataType, StandardMatrixTag > &result, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
template<typename DataType , typename RhsDataType , typename RhsMatrixType >
void	SubtractEqualNegatedLhs (NekMatrix< DataType, StandardMatrixTag > &result, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
	NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX (SubtractEqual, NEKTAR_ALL_MATRIX_TYPES,(1,(void)),(1,(DNekMat &)),(0,())) NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX(SubtractEqual
SNekMat	NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX (SubtractEqualNegatedLhs, NEKTAR_ALL_MATRIX_TYPES,(1,(void)),(1,(DNekMat &)),(0,())) NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX(SubtractEqualNegatedLhs
template<typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >
SNekMat SNekMat NekMatrix< typename NekMatrix< LhsDataType, LhsMatrixType >::NumberType, StandardMatrixTag >	Subtract (const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
	NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES (Subtract, NEKTAR_ALL_MATRIX_TYPES, NEKTAR_ALL_MATRIX_TYPES,(1,(DNekMat)),(0,()),(0,())) NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES(Subtract
template<typename DataType , typename LhsDataType , typename MatrixType >
NekVector< DataType >	Multiply (const NekMatrix< LhsDataType, MatrixType > &lhs, const NekVector< DataType > &rhs)
template<typename DataType , typename LhsDataType , typename MatrixType >
void	Multiply (NekVector< DataType > &result, const NekMatrix< LhsDataType, MatrixType > &lhs, const NekVector< DataType > &rhs)
template<typename DataType , typename LhsInnerMatrixType >
void	Multiply (NekVector< DataType > &result, const NekMatrix< LhsInnerMatrixType, BlockMatrixTag > &lhs, const NekVector< DataType > &rhs)
template<typename DataType , typename LhsDataType , typename MatrixType >
NekVector< DataType >	operator* (const NekMatrix< LhsDataType, MatrixType > &lhs, const NekVector< DataType > &rhs)
void	DiagonalBlockFullScalMatrixMultiply (NekVector< double > &result, const NekMatrix< NekMatrix< NekMatrix< NekDouble, StandardMatrixTag >, ScaledMatrixTag >, BlockMatrixTag > &lhs, const NekVector< double > &rhs)
void	DiagonalBlockFullScalMatrixMultiply (NekVector< NekSingle > &result, const NekMatrix< NekMatrix< NekMatrix< NekSingle, StandardMatrixTag >, ScaledMatrixTag >, BlockMatrixTag > &lhs, const NekVector< NekSingle > &rhs)
template<typename DataType , typename LhsDataType , typename LhsMatrixType >
NekMatrix< typename NekMatrix< LhsDataType, LhsMatrixType >::NumberType, StandardMatrixTag >	Multiply (const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const DataType &rhs)
template<typename RhsDataType , typename RhsMatrixType , typename ResultDataType >
void	Multiply (NekMatrix< ResultDataType, StandardMatrixTag > &result, const ResultDataType &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
template<typename DataType , typename RhsDataType , typename RhsMatrixType >
NekMatrix< typename NekMatrix< RhsDataType, RhsMatrixType >::NumberType, StandardMatrixTag >	Multiply (const DataType &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
template<typename DataType , typename RhsDataType , typename RhsMatrixType >
NekMatrix< typename NekMatrix< RhsDataType, RhsMatrixType >::NumberType, StandardMatrixTag >	operator* (const DataType &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
template<typename DataType , typename RhsDataType , typename RhsMatrixType >
NekMatrix< typename NekMatrix< RhsDataType, RhsMatrixType >::NumberType, StandardMatrixTag >	operator* (const NekMatrix< RhsDataType, RhsMatrixType > &lhs, const DataType &rhs)
template<typename LhsDataType >
void	MultiplyEqual (NekMatrix< LhsDataType, StandardMatrixTag > &lhs, typename boost::call_traits< LhsDataType >::const_reference rhs)
template<typename LhsDataType , typename RhsDataType , typename LhsMatrixType , typename RhsMatrixType >
void	NekMultiplyFullMatrixFullMatrix (NekMatrix< LhsDataType, StandardMatrixTag > &result, const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs, typename std::enable_if< CanGetRawPtr< NekMatrix< LhsDataType, LhsMatrixType >>::value &&CanGetRawPtr< NekMatrix< RhsDataType, RhsMatrixType >>::value >::type *p=0)
template<typename RhsInnerType , typename RhsMatrixType >
void	MultiplyEqual (NekMatrix< RhsInnerType, StandardMatrixTag > &result, const NekMatrix< RhsInnerType, RhsMatrixType > &rhs, typename std::enable_if< std::is_same< RawType_t< typename NekMatrix< RhsInnerType, RhsMatrixType >::NumberType >, RhsInnerType >::value &&CanGetRawPtr< NekMatrix< RhsInnerType, RhsMatrixType >>::value >::type *t=0)
template<typename DataType , typename RhsInnerType , typename RhsMatrixType >
void	MultiplyEqual (NekMatrix< DataType, StandardMatrixTag > &result, const NekMatrix< RhsInnerType, RhsMatrixType > &rhs, typename std::enable_if< !std::is_same< RawType_t< typename NekMatrix< RhsInnerType, RhsMatrixType >::NumberType >, DataType >::value||!CanGetRawPtr< NekMatrix< RhsInnerType, RhsMatrixType >>::value >::type *t=0)
template<typename LhsDataType , typename RhsDataType , typename LhsMatrixType , typename RhsMatrixType >
NekMatrix< typename std::remove_const< typename NekMatrix< LhsDataType, LhsMatrixType >::NumberType >::type, StandardMatrixTag >	Multiply (const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
template<typename LhsDataType , typename RhsDataType , typename LhsMatrixType , typename RhsMatrixType >
NekMatrix< typename std::remove_const< typename NekMatrix< LhsDataType, LhsMatrixType >::NumberType >::type, StandardMatrixTag >	operator* (const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
template<typename DataType , typename RhsDataType , typename RhsMatrixType >
void	AddEqual (NekMatrix< DataType, StandardMatrixTag > &result, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
template<typename DataType , typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >
void	Add (NekMatrix< DataType, StandardMatrixTag > &result, const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
template<typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >
NekMatrix< typename NekMatrix< LhsDataType, LhsMatrixType >::NumberType, StandardMatrixTag >	Add (const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
template<typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >
NekMatrix< typename NekMatrix< LhsDataType, LhsMatrixType >::NumberType, StandardMatrixTag >	operator+ (const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
template<typename DataType , typename RhsDataType , typename RhsMatrixType >
void	SubtractEqual (NekMatrix< DataType, StandardMatrixTag > &result, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
template<typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >
NekMatrix< typename NekMatrix< LhsDataType, LhsMatrixType >::NumberType, StandardMatrixTag >	Subtract (const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
template<typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >
NekMatrix< typename NekMatrix< LhsDataType, LhsMatrixType >::NumberType, StandardMatrixTag >	operator- (const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
template<typename DataType , typename LhsDataType , typename MatrixType >
void	NekMultiplyUnspecializedMatrixType (DataType *result, const NekMatrix< LhsDataType, MatrixType > &lhs, const DataType *rhs)
template<typename DataType , typename LhsDataType , typename MatrixType >
void	NekMultiplyDiagonalMatrix (DataType *result, const NekMatrix< LhsDataType, MatrixType > &lhs, const DataType *rhs)
template<typename DataType , typename LhsDataType >
void	NekMultiplyDiagonalMatrix (DataType *result, const NekMatrix< LhsDataType, StandardMatrixTag > &lhs, const DataType *rhs)
template<typename DataType , typename LhsDataType , typename MatrixType >
void	NekMultiplyBandedMatrix (DataType *result, const NekMatrix< LhsDataType, MatrixType > &lhs, const DataType *rhs, typename std::enable_if< CanGetRawPtr< NekMatrix< LhsDataType, MatrixType > >::value >::type *p=0)
template<typename DataType , typename LhsDataType >
void	NekMultiplyBandedMatrix (DataType *result, const NekMatrix< LhsDataType, BlockMatrixTag > &lhs, const DataType *rhs, typename std::enable_if< !CanGetRawPtr< NekMatrix< LhsDataType, BlockMatrixTag > >::value >::type *p=0)
template<typename DataType , typename LhsInnerMatrixType >
void	FullBlockMatrixMultiply (NekVector< DataType > &result, const NekMatrix< LhsInnerMatrixType, BlockMatrixTag > &lhs, const NekVector< DataType > &rhs)
template<typename DataType , typename LhsInnerMatrixType >
void	DiagonalBlockMatrixMultiply (NekVector< DataType > &result, const NekMatrix< LhsInnerMatrixType, BlockMatrixTag > &lhs, const NekVector< DataType > &rhs)
template<typename DataType >
void	NekMultiplyLowerTriangularMatrix (DataType *result, const NekMatrix< DataType, StandardMatrixTag > &lhs, const DataType *rhs)
template<typename DataType >
void	NekMultiplyLowerTriangularMatrix (DataType *result, const NekMatrix< NekMatrix< DataType, StandardMatrixTag >, ScaledMatrixTag > &lhs, const DataType *rhs)
template<typename DataType , typename LhsDataType , typename MatrixType >
void	NekMultiplyLowerTriangularMatrix (DataType *result, const NekMatrix< LhsDataType, MatrixType > &lhs, const DataType *rhs)
template<typename DataType >
void	NekMultiplyUpperTriangularMatrix (DataType *result, const NekMatrix< DataType, StandardMatrixTag > &lhs, const DataType *rhs)
template<typename DataType >
void	NekMultiplyUpperTriangularMatrix (DataType *result, const NekMatrix< NekMatrix< DataType, StandardMatrixTag >, ScaledMatrixTag > &lhs, const DataType *rhs)
template<typename DataType , typename LhsDataType , typename MatrixType >
void	NekMultiplyUpperTriangularMatrix (DataType *result, const NekMatrix< LhsDataType, MatrixType > &lhs, const DataType *rhs)
template<typename DataType , typename InnerMatrixType , typename MatrixTag >
void	NekMultiplySymmetricMatrix (DataType *result, const NekMatrix< InnerMatrixType, MatrixTag > &lhs, const DataType *rhs, typename std::enable_if< CanGetRawPtr< NekMatrix< InnerMatrixType, MatrixTag > >::value >::type *p=0)
template<typename DataType , typename InnerMatrixType , typename MatrixTag >
void	NekMultiplySymmetricMatrix (DataType *result, const NekMatrix< InnerMatrixType, MatrixTag > &lhs, const DataType *rhs, typename std::enable_if<!CanGetRawPtr< NekMatrix< InnerMatrixType, MatrixTag > >::value >::type *p=0)
template<typename DataType , typename InnerMatrixType , typename MatrixTag >
void	NekMultiplyFullMatrix (DataType *result, const NekMatrix< InnerMatrixType, MatrixTag > &lhs, const DataType *rhs, typename std::enable_if< CanGetRawPtr< NekMatrix< InnerMatrixType, MatrixTag > >::value >::type *p=0)
template<typename DataType , typename InnerMatrixType , typename MatrixTag >
void	NekMultiplyFullMatrix (DataType *result, const NekMatrix< InnerMatrixType, MatrixTag > &lhs, const DataType *rhs, typename std::enable_if<!CanGetRawPtr< NekMatrix< InnerMatrixType, MatrixTag > >::value >::type *p=0)
template<typename DataType , typename LhsDataType , typename MatrixType >
void	Multiply (DataType *result, const NekMatrix< LhsDataType, MatrixType > &lhs, const DataType *rhs)
	NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX (Multiply, NEKTAR_STANDARD_AND_SCALED_MATRICES,(1,(void)),(1,(NekVector< NekDouble > &)),(1,(const NekVector< NekDouble > &))) NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX(Multiply
template<typename DataType , typename LhsInnerMatrixType >
NekVector< NekSingle > const NekVector< NekSingle > &void	Multiply (NekVector< DataType > &result, const NekMatrix< LhsInnerMatrixType, BlockMatrixTag > &lhs, const NekVector< DataType > &rhs)
	NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX (Multiply, NEKTAR_BLOCK_MATRIX_TYPES,(1,(void)),(1,(NekVector< NekDouble > &)),(1,(const NekVector< NekDouble > &))) NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX(Multiply
template<typename DataType , typename LhsDataType , typename MatrixType >
NekVector< NekSingle > const NekVector< NekSingle > &NekVector< DataType >	Multiply (const NekMatrix< LhsDataType, MatrixType > &lhs, const NekVector< DataType > &rhs)
	NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX (Multiply, NEKTAR_ALL_MATRIX_TYPES,(1,(NekVector< NekDouble >)),(0,()),(1,(const NekVector< NekDouble > &))) NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX(Multiply
template<typename DataType >
std::vector< NekVector< DataType > >	GramSchmidtOrthogonalization (const std::vector< NekVector< DataType > > &x)
	Calculates the orthogonal, normalized vectors from linearly independent input. More...
template<typename DataType , typename FormType >
std::ostream &	operator<< (std::ostream &os, const NekMatrix< DataType, FormType > &rhs)
template<typename DataType , typename FormType >
std::ostream &	operator>> (std::ostream &os, const NekMatrix< DataType, FormType > &rhs)
template<typename DataType >
void	negate (NekPoint< DataType > &rhs)
template<typename DataType >
NekPoint< DataType >	operator+ (const NekPoint< DataType > &lhs, const NekPoint< DataType > &rhs)
template<typename DataType >
NekPoint< DataType >	operator+ (typename boost::call_traits< DataType >::const_reference lhs, const NekPoint< DataType > &rhs)
template<typename DataType >
NekPoint< DataType >	operator+ (const NekPoint< DataType > &lhs, typename boost::call_traits< DataType >::const_reference rhs)
template<typename DataType >
NekPoint< DataType >	operator- (const NekPoint< DataType > &lhs, const NekPoint< DataType > &rhs)
template<typename DataType >
NekPoint< DataType >	operator- (typename boost::call_traits< DataType >::const_reference lhs, const NekPoint< DataType > &rhs)
template<typename DataType >
NekPoint< DataType >	operator- (const NekPoint< DataType > &lhs, typename boost::call_traits< DataType >::const_reference rhs)
template<typename DataType , typename dim , typename space , typename ScalarType >
NekPoint< DataType >	operator* (const ScalarType &lhs, const NekPoint< DataType > &rhs)
template<typename DataType , typename dim , typename space , typename ScalarType >
NekPoint< DataType >	operator* (const NekPoint< DataType > &lhs, const ScalarType &rhs)
template<typename DataType >
NekPoint< DataType >	operator/ (const NekPoint< DataType > &lhs, typename boost::call_traits< DataType >::param_type rhs)
template<typename DataType >
boost::call_traits< DataType >::value_type	distanceBetween (const NekPoint< DataType > &lhs, const NekPoint< DataType > &rhs)
template<typename DataType >
bool	fromString (const std::string &str, NekPoint< DataType > &result)
template<typename DataType >
std::ostream &	operator<< (std::ostream &os, const NekPoint< DataType > &p)
template<typename DataType >
void	Add (NekVector< DataType > &result, const NekVector< DataType > &lhs, const NekVector< DataType > &rhs)
template<typename DataType >
void	AddNegatedLhs (NekVector< DataType > &result, const NekVector< DataType > &lhs, const NekVector< DataType > &rhs)
template void	Add (NekVector< NekDouble > &result, const NekVector< NekDouble > &lhs, const NekVector< NekDouble > &rhs)
template void	AddNegatedLhs (NekVector< NekDouble > &result, const NekVector< NekDouble > &lhs, const NekVector< NekDouble > &rhs)
template void	Add (NekVector< NekSingle > &result, const NekVector< NekSingle > &lhs, const NekVector< NekSingle > &rhs)
template void	AddNegatedLhs (NekVector< NekSingle > &result, const NekVector< NekSingle > &lhs, const NekVector< NekSingle > &rhs)
template<typename DataType >
void	AddEqual (NekVector< DataType > &result, const NekVector< DataType > &rhs)
template<typename DataType >
void	AddEqualNegatedLhs (NekVector< DataType > &result, const NekVector< DataType > &rhs)
template void	AddEqual (NekVector< NekDouble > &result, const NekVector< NekDouble > &rhs)
template void	AddEqualNegatedLhs (NekVector< NekDouble > &result, const NekVector< NekDouble > &rhs)
template void	AddEqual (NekVector< NekSingle > &result, const NekVector< NekSingle > &rhs)
template void	AddEqualNegatedLhs (NekVector< NekSingle > &result, const NekVector< NekSingle > &rhs)
template<typename LhsDataType , typename RhsDataType >
NekVector< LhsDataType >	Add (const NekVector< LhsDataType > &lhs, const NekVector< RhsDataType > &rhs)
template NekVector< NekDouble >	Add (const NekVector< NekDouble > &lhs, const NekVector< NekDouble > &rhs)
template NekVector< NekSingle >	Add (const NekVector< NekSingle > &lhs, const NekVector< NekSingle > &rhs)
template<typename ResultDataType , typename InputDataType >
void	Subtract (NekVector< ResultDataType > &result, const NekVector< InputDataType > &lhs, const NekVector< InputDataType > &rhs)
template<typename ResultDataType , typename InputDataType >
void	SubtractNegatedLhs (NekVector< ResultDataType > &result, const NekVector< InputDataType > &lhs, const NekVector< InputDataType > &rhs)
template void	Subtract (NekVector< NekDouble > &result, const NekVector< NekDouble > &lhs, const NekVector< NekDouble > &rhs)
template void	SubtractNegatedLhs (NekVector< NekDouble > &result, const NekVector< NekDouble > &lhs, const NekVector< NekDouble > &rhs)
template void	Subtract (NekVector< NekSingle > &result, const NekVector< NekSingle > &lhs, const NekVector< NekSingle > &rhs)
template void	SubtractNegatedLhs (NekVector< NekSingle > &result, const NekVector< NekSingle > &lhs, const NekVector< NekSingle > &rhs)
template<typename ResultDataType , typename InputDataType >
void	SubtractEqual (NekVector< ResultDataType > &result, const NekVector< InputDataType > &rhs)
template<typename ResultDataType , typename InputDataType >
void	SubtractEqualNegatedLhs (NekVector< ResultDataType > &result, const NekVector< InputDataType > &rhs)
template void	SubtractEqual (NekVector< NekDouble > &result, const NekVector< NekDouble > &rhs)
template void	SubtractEqualNegatedLhs (NekVector< NekDouble > &result, const NekVector< NekDouble > &rhs)
template void	SubtractEqual (NekVector< NekSingle > &result, const NekVector< NekSingle > &rhs)
template void	SubtractEqualNegatedLhs (NekVector< NekSingle > &result, const NekVector< NekSingle > &rhs)
template<typename DataType >
NekVector< DataType >	Subtract (const NekVector< DataType > &lhs, const NekVector< DataType > &rhs)
template NekVector< NekDouble >	Subtract (const NekVector< NekDouble > &lhs, const NekVector< NekDouble > &rhs)
template NekVector< NekSingle >	Subtract (const NekVector< NekSingle > &lhs, const NekVector< NekSingle > &rhs)
template<typename ResultDataType , typename InputDataType >
void	Divide (NekVector< ResultDataType > &result, const NekVector< InputDataType > &lhs, const NekDouble &rhs)
template<typename ResultDataType , typename InputDataType >
void	Divide (NekVector< ResultDataType > &result, const NekVector< InputDataType > &lhs, const NekSingle &rhs)
template void	Divide (NekVector< NekDouble > &result, const NekVector< NekDouble > &lhs, const NekDouble &rhs)
template void	Divide (NekVector< NekSingle > &result, const NekVector< NekSingle > &lhs, const NekSingle &rhs)
template<typename ResultDataType >
void	DivideEqual (NekVector< ResultDataType > &result, const NekDouble &rhs)
template<typename ResultDataType >
void	DivideEqual (NekVector< ResultDataType > &result, const NekSingle &rhs)
template void	DivideEqual (NekVector< NekDouble > &result, const NekDouble &rhs)
template void	DivideEqual (NekVector< NekSingle > &result, const NekSingle &rhs)
template<typename DataType >
NekVector< DataType >	Divide (const NekVector< DataType > &lhs, const NekDouble &rhs)
template<typename DataType >
NekVector< DataType >	Divide (const NekVector< DataType > &lhs, const NekSingle &rhs)
template NekVector< NekDouble >	Divide (const NekVector< NekDouble > &lhs, const NekDouble &rhs)
template NekVector< NekSingle >	Divide (const NekVector< NekSingle > &lhs, const NekSingle &rhs)
template<typename ResultDataType , typename InputDataType >
void	Multiply (NekVector< ResultDataType > &result, const NekVector< InputDataType > &lhs, const NekVector< InputDataType > &rhs)
template void	Multiply (NekVector< NekDouble > &result, const NekVector< NekDouble > &lhs, const NekVector< NekDouble > &rhs)
template void	Multiply (NekVector< NekSingle > &result, const NekVector< NekSingle > &lhs, const NekVector< NekSingle > &rhs)
template<typename ResultDataType , typename InputDataType >
void	MultiplyEqual (NekVector< ResultDataType > &result, const NekVector< InputDataType > &rhs)
template void	MultiplyEqual (NekVector< NekDouble > &result, const NekVector< NekDouble > &rhs)
template void	MultiplyEqual (NekVector< NekSingle > &result, const NekVector< NekSingle > &rhs)
template<typename DataType , typename InputDataType >
NekVector< DataType >	Multiply (const NekVector< DataType > &lhs, const NekVector< InputDataType > &rhs)
template NekVector< NekDouble >	Multiply (const NekVector< NekDouble > &lhs, const NekVector< NekDouble > &rhs)
template NekVector< NekSingle >	Multiply (const NekVector< NekSingle > &lhs, const NekVector< NekSingle > &rhs)
template<typename ResultDataType , typename InputDataType >
void	Multiply (NekVector< ResultDataType > &result, const NekVector< InputDataType > &lhs, const NekDouble &rhs)
template<typename ResultDataType , typename InputDataType >
void	Multiply (NekVector< ResultDataType > &result, const NekVector< InputDataType > &lhs, const NekSingle &rhs)
template void	Multiply (NekVector< NekDouble > &result, const NekVector< NekDouble > &lhs, const NekDouble &rhs)
template void	Multiply (NekVector< NekSingle > &result, const NekVector< NekSingle > &lhs, const NekSingle &rhs)
template<typename ResultDataType >
void	MultiplyEqual (NekVector< ResultDataType > &result, const NekDouble &rhs)
template<typename ResultDataType >
void	MultiplyEqual (NekVector< ResultDataType > &result, const NekSingle &rhs)
template void	MultiplyEqual (NekVector< NekDouble > &result, const NekDouble &rhs)
template void	MultiplyEqual (NekVector< NekSingle > &result, const NekSingle &rhs)
template<typename DataType >
NekVector< DataType >	Multiply (const NekVector< DataType > &lhs, const NekDouble &rhs)
template<typename DataType >
NekVector< DataType >	Multiply (const NekVector< DataType > &lhs, const NekSingle &rhs)
template NekVector< NekDouble >	Multiply (const NekVector< NekDouble > &lhs, const NekDouble &rhs)
template NekVector< NekSingle >	Multiply (const NekVector< NekSingle > &lhs, const NekSingle &rhs)
template<typename ResultDataType , typename InputDataType >
void	Multiply (NekVector< ResultDataType > &result, const NekDouble &lhs, const NekVector< InputDataType > &rhs)
template<typename ResultDataType , typename InputDataType >
void	MultiplyInvertedLhs (NekVector< ResultDataType > &result, const NekDouble &lhs, const NekVector< InputDataType > &rhs)
template<typename ResultDataType , typename InputDataType >
void	Multiply (NekVector< ResultDataType > &result, const NekSingle &lhs, const NekVector< InputDataType > &rhs)
template<typename ResultDataType , typename InputDataType >
void	MultiplyInvertedLhs (NekVector< ResultDataType > &result, const NekSingle &lhs, const NekVector< InputDataType > &rhs)
template void	MultiplyInvertedLhs (NekVector< NekDouble > &result, const NekDouble &lhs, const NekVector< NekDouble > &rhs)
template void	Multiply (NekVector< NekDouble > &result, const NekDouble &lhs, const NekVector< NekDouble > &rhs)
template void	MultiplyInvertedLhs (NekVector< NekSingle > &result, const NekSingle &lhs, const NekVector< NekSingle > &rhs)
template void	Multiply (NekVector< NekSingle > &result, const NekSingle &lhs, const NekVector< NekSingle > &rhs)
template<typename DataType >
NekVector< DataType >	Multiply (const DataType &lhs, const NekVector< DataType > &rhs)
template NekVector< NekDouble >	Multiply (const NekDouble &lhs, const NekVector< NekDouble > &rhs)
template NekVector< NekSingle >	Multiply (const NekSingle &lhs, const NekVector< NekSingle > &rhs)
template<typename DataType >
std::ostream &	operator<< (std::ostream &os, const NekVector< DataType > &rhs)
template std::ostream &	operator<< (std::ostream &os, const NekVector< NekDouble > &rhs)
template std::ostream &	operator<< (std::ostream &os, const NekVector< NekSingle > &rhs)
template<typename DataType >
NekVector< DataType >	createVectorFromPoints (const NekPoint< DataType > &source, const NekPoint< DataType > &dest)
template NekVector< NekDouble >	createVectorFromPoints (const NekPoint< NekDouble > &source, const NekPoint< NekDouble > &dest)
template NekVector< NekSingle >	createVectorFromPoints (const NekPoint< NekSingle > &source, const NekPoint< NekSingle > &dest)
template<typename DataType >
NekPoint< DataType >	findPointAlongVector (const NekVector< DataType > &lhs, const DataType &t)
template NekPoint< NekDouble >	findPointAlongVector (const NekVector< NekDouble > &lhs, const NekDouble &t)
template NekPoint< NekSingle >	findPointAlongVector (const NekVector< NekSingle > &lhs, const NekSingle &t)
template<typename DataType >
bool	operator== (const NekVector< DataType > &lhs, const NekVector< DataType > &rhs)
template bool	operator== (const NekVector< NekDouble > &lhs, const NekVector< NekDouble > &rhs)
template bool	operator== (const NekVector< NekSingle > &lhs, const NekVector< NekSingle > &rhs)
template<typename DataType >
bool	operator!= (const NekVector< DataType > &lhs, const NekVector< DataType > &rhs)
template bool	operator!= (const NekVector< NekDouble > &lhs, const NekVector< NekDouble > &rhs)
template bool	operator!= (const NekVector< NekSingle > &lhs, const NekVector< NekSingle > &rhs)
template<typename DataType >
std::vector< DataType >	FromString (const std::string &str)
template<typename DataType >
DataType	L1Norm (const NekVector< DataType > &v)
template NekDouble	L1Norm (const NekVector< NekDouble > &v)
template NekSingle	L1Norm (const NekVector< NekSingle > &v)
template<typename DataType >
DataType	L2Norm (const NekVector< DataType > &v)
template NekDouble	L2Norm (const NekVector< NekDouble > &v)
template NekSingle	L2Norm (const NekVector< NekSingle > &v)
template<typename DataType >
DataType	InfinityNorm (const NekVector< DataType > &v)
template NekDouble	InfinityNorm (const NekVector< NekDouble > &v)
template NekSingle	InfinityNorm (const NekVector< NekSingle > &v)
template<typename DataType >
NekVector< DataType >	Negate (const NekVector< DataType > &v)
template NekVector< NekDouble >	Negate (const NekVector< NekDouble > &v)
template NekVector< NekSingle >	Negate (const NekVector< NekSingle > &v)
template<typename DataType >
void	NegateInPlace (NekVector< DataType > &v)
template void	NegateInPlace (NekVector< NekDouble > &v)
template void	NegateInPlace (NekVector< NekSingle > &v)
template<typename DataType >
DataType	Magnitude (const NekVector< DataType > &v)
template NekDouble	Magnitude (const NekVector< NekDouble > &v)
template NekSingle	Magnitude (const NekVector< NekSingle > &v)
template<typename DataType >
DataType	Dot (const NekVector< DataType > &lhs, const NekVector< DataType > &rhs)
template NekDouble	Dot (const NekVector< NekDouble > &lhs, const NekVector< NekDouble > &rhs)
template NekSingle	Dot (const NekVector< NekSingle > &lhs, const NekVector< NekSingle > &rhs)
template<typename DataType >
void	Normalize (NekVector< DataType > &v)
template void	Normalize (NekVector< NekDouble > &v)
void	NegateInPlace (NekDouble &v)
void	InvertInPlace (NekDouble &v)
template void	Normalize (NekVector< NekSingle > &v)
void	NegateInPlace (NekSingle &v)
void	InvertInPlace (NekSingle &v)
template<typename DataType >
NekVector< DataType >	Cross (const NekVector< DataType > &lhs, const NekVector< DataType > &rhs)
template NekVector< NekDouble >	Cross (const NekVector< NekDouble > &lhs, const NekVector< NekDouble > &rhs)
template NekVector< NekSingle >	Cross (const NekVector< NekSingle > &lhs, const NekVector< NekSingle > &rhs)
template<typename DataType >
std::string	AsString (const NekVector< DataType > &v)
template std::string	AsString (const NekVector< NekDouble > &v)
template std::string	AsString (const NekVector< NekSingle > &v)
template<typename DataType >
NekVector< DataType >	operator* (const NekVector< DataType > &lhs, const NekDouble &rhs)
template<typename DataType >
NekVector< DataType >	operator* (const NekDouble &lhs, const NekVector< DataType > &rhs)
template<typename DataType >
NekVector< DataType >	operator* (const NekVector< DataType > &lhs, const NekVector< DataType > &rhs)
template<typename DataType >
NekVector< DataType >	operator/ (const NekVector< DataType > &lhs, const NekDouble &rhs)
template<typename DataType >
NekVector< DataType >	operator+ (const NekVector< DataType > &lhs, const NekVector< DataType > &rhs)
template<typename DataType >
NekVector< DataType >	operator- (const NekVector< DataType > &lhs, const NekVector< DataType > &rhs)
template<typename DataType >
NekMatrix< DataType, ScaledMatrixTag >	Transpose (NekMatrix< DataType, ScaledMatrixTag > &rhs)
template NekMatrix< NekMatrix< NekDouble, StandardMatrixTag >, ScaledMatrixTag >	Transpose (NekMatrix< NekMatrix< NekDouble, StandardMatrixTag >, ScaledMatrixTag > &rhs)
template<typename DataType >
void	NegateInPlace (NekMatrix< DataType, ScaledMatrixTag > &v)
template void	NegateInPlace (NekMatrix< NekMatrix< NekDouble, StandardMatrixTag >, ScaledMatrixTag > &v)
template NekMatrix< NekMatrix< NekSingle, StandardMatrixTag >, ScaledMatrixTag >	Transpose (NekMatrix< NekMatrix< NekSingle, StandardMatrixTag >, ScaledMatrixTag > &rhs)
template void	NegateInPlace (NekMatrix< NekMatrix< NekSingle, StandardMatrixTag >, ScaledMatrixTag > &v)
void	convertCooToBco (const unsigned int blkDim, const COOMatType &cooMat, BCOMatType &bcoMat)
template<typename SparseStorageType >
std::ostream &	operator<< (std::ostream &os, const NekSparseMatrix< SparseStorageType > &rhs)
template<typename SparseStorageType >
std::ostream &	operator<< (std::ostream &os, const NekSparseDiagBlkMatrix< SparseStorageType > &rhs)
template std::ostream &	operator<< (std::ostream &os, const NekSparseMatrix< StorageSmvBsr< NekDouble > > &rhs)
template std::ostream &	operator<< (std::ostream &os, const NekSparseDiagBlkMatrix< StorageSmvBsr< NekDouble > > &rhs)
template<typename DataType >
NekMatrix< DataType, StandardMatrixTag >	Transpose (NekMatrix< DataType, StandardMatrixTag > &rhs)
template NekMatrix< NekDouble, StandardMatrixTag >	Transpose (NekMatrix< NekDouble, StandardMatrixTag > &rhs)
template NekMatrix< NekSingle, StandardMatrixTag >	Transpose (NekMatrix< NekSingle, StandardMatrixTag > &rhs)
template<typename DataType >
void	NegateInPlace (NekMatrix< DataType, StandardMatrixTag > &m)
template void	NegateInPlace (NekMatrix< double, StandardMatrixTag > &v)
template void	NegateInPlace (NekMatrix< NekSingle, StandardMatrixTag > &v)
template<typename DataType >
bool	operator== (const MemoryManager< DataType > &lhs, const MemoryManager< DataType > &rhs)
template<typename DataType >
bool	operator!= (const MemoryManager< DataType > &lhs, const MemoryManager< DataType > &rhs)
MemPool &	GetMemoryPool ()
CellModelFactory &	GetCellModelFactory ()
ProtocolFactory &	GetProtocolFactory ()
StimulusFactory &	GetStimulusFactory ()
ArtificialDiffusionFactory &	GetArtificialDiffusionFactory ()
	Declaration of the artificial diffusion factory singleton. More...
CFSBndCondFactory &	GetCFSBndCondFactory ()
	Declaration of the boundary condition factory singleton. More...
EquationOfStateFactory &	GetEquationOfStateFactory ()
	Declaration of the equation of state factory singleton. More...
PreconCfsOpFactory &	GetPreconCfsOpFactory ()
	Declaration of the boundary condition factory singleton. More...
NekDouble	guessp (NekDouble g[], NekDouble rhoL, NekDouble uL, NekDouble pL, NekDouble cL, NekDouble rhoR, NekDouble uR, NekDouble pR, NekDouble cR)
	Use either PVRS, two-rarefaction or two-shock Riemann solvers to calculate an initial pressure for the Newton-Raphson scheme. More...
void	prefun (NekDouble *g, NekDouble p, NekDouble dk, NekDouble pk, NekDouble ck, NekDouble &f, NekDouble &fd)
	Evaluate pressure functions fL and fR in Newton iteration of Riemann solver (see equation 4.85 and 4.86 of Toro 2009). More...
template<class T , typename = typename std::enable_if < std::is_floating_point<T>::value || tinysimd::is_vector_floating_point<T>::value >::type>
void	RoeKernel (T &rhoL, T &rhouL, T &rhovL, T &rhowL, T &EL, T &rhoR, T &rhouR, T &rhovR, T &rhowR, T &ER, T &rhof, T &rhouf, T &rhovf, T &rhowf, T &Ef, NekDouble gamma)
ExtrapolateFactory &	GetExtrapolateFactory ()
DNekMat	MappingIdealToRef (SpatialDomains::GeometrySharedPtr geom)
BoundaryFactory &	GetBoundaryFactory ()
PressureAreaFactory &	GetPressureAreaFactory ()

Variables
const char *const	FlagTypeMap []
	String map for FlagType enumeration. More...
static Array< OneD, int >	NullInt1DArray
static Array< OneD, NekDouble >	NullNekDouble1DArray
static Array< OneD, Array< OneD, NekDouble > >	NullNekDoubleArrayOfArray
static Array< OneD, Array< OneD, Array< OneD, NekDouble > > >	NullNekDoubleTensorOfArray3D
	NEKTAR_ALL_MATRIX_TYPES_SINGLE
	void
SNekMat	NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX (AddEqualNegatedLhs, NEKTAR_ALL_MATRIX_TYPES,(1,(void)),(1,(DNekMat &)),(0,())) NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX(AddEqualNegatedLhs
SNekMat	NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES (AddNegatedLhs, NEKTAR_ALL_MATRIX_TYPES, NEKTAR_ALL_MATRIX_TYPES,(1,(void)),(1,(DNekMat &)),(0,())) NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES(AddNegatedLhs
	NEKTAR_STANDARD_AND_SCALED_MATRICES_SINGLE
	NEKTAR_BLOCK_MATRIX_TYPES_SINGLE
	NekVector< NekSingle >
static DNekMatSharedPtr	NullDNekMatSharedPtr
static DNekScalMatSharedPtr	NullDNekScalMatSharedPtr
static DNekScalBlkMatSharedPtr	NullDNekScalBlkMatSharedPtr
static Array< OneD, DNekBlkMatSharedPtr >	NullArrayDNekBlkMatSharedPtr
static SNekMatSharedPtr	NullSNekMatSharedPtr
static SNekScalMatSharedPtr	NullSNekScalMatSharedPtr
static SNekScalBlkMatSharedPtr	NullSNekScalBlkMatSharedPtr
static Array< OneD, SNekBlkMatSharedPtr >	NullArraySNekBlkMatSharedPtr
static const int	NistSpBlasDescra [5][9]
static NekDouble	EigenvaluesRegMeshes [10][14]
static NekDouble	EigenvaluesAnaMeshesAB2 [6][14]
static NekDouble	EigenvaluesAnaMeshesRK2 [6][14]
static NekDouble	EigenvaluesAnaMeshesRK4 [6][14]
const char *const	TestTypeMap []
const char *const	InitWaveTypeMap []
const std::string	kEquationTypeStr []
const std::string	kAdvectionFormStr []
static PulseWaveBoundarySharedPtr	NullPulseWaveBoundarySharedPtr
static PulseWavePressureAreaSharedPtr	NullPulseWavePressureAreaSharedPtr
const char *const	UpwindTypeMapPulse []
const char *const	ProblemTypeMap [] = { "General", "SolitaryWave" }
const std::string	VWIIterationTypeMap []

Detailed Description

The above copyright notice and this permission notice shall be included.

Typedef Documentation

AInflowSharedPtr

typedef std::shared_ptr<AInflow> Nektar::AInflowSharedPtr

Definition at line 48 of file AInflow.h.

ArtificialDiffusionFactory

typedef LibUtilities::NekFactory<std::string, ArtificialDiffusion, const LibUtilities::SessionReaderSharedPtr&, const Array<OneD, MultiRegions::ExpListSharedPtr>&, const int > Nektar::ArtificialDiffusionFactory

Declaration of the artificial diffusion factory.

Definition at line 59 of file ArtificialDiffusion.h.

ArtificialDiffusionSharedPtr

typedef std::shared_ptr<ArtificialDiffusion> Nektar::ArtificialDiffusionSharedPtr

A shared pointer to a artificial diffusion object.

Definition at line 53 of file ArtificialDiffusion.h.

BCOEntryType

typedef Array<OneD, NekDouble> Nektar::BCOEntryType

Definition at line 63 of file SparseMatrixFwd.hpp.

BCOMatType

typedef std::map<CoordType, BCOEntryType > Nektar::BCOMatType

Definition at line 64 of file SparseMatrixFwd.hpp.

BCOMatTypeConstIt

typedef BCOMatType::const_iterator Nektar::BCOMatTypeConstIt

Definition at line 65 of file SparseMatrixFwd.hpp.

BCOMatTypeSharedPtr

typedef std::shared_ptr<BCOMatType> Nektar::BCOMatTypeSharedPtr

Definition at line 66 of file SparseMatrixFwd.hpp.

BCOMatVector

typedef Array<OneD, BCOMatType> Nektar::BCOMatVector

Definition at line 67 of file SparseMatrixFwd.hpp.

BetaPressureAreaSharedPtr

typedef std::shared_ptr<BetaPressureArea> Nektar::BetaPressureAreaSharedPtr

Definition at line 47 of file BetaPressureArea.h.

BlkMatDNekBlkMat

typedef NekMatrix<NekMatrix<NekMatrix<NekDouble, StandardMatrixTag>, BlockMatrixTag>, BlockMatrixTag> Nektar::BlkMatDNekBlkMat

Definition at line 63 of file NekTypeDefs.hpp.

BlkMatDNekBlkMatSharedPtr

typedef std::shared_ptr<BlkMatDNekBlkMat> Nektar::BlkMatDNekBlkMatSharedPtr

Definition at line 72 of file NekTypeDefs.hpp.

BlkMatDNekScalBlkMat

typedef NekMatrix<NekMatrix<NekMatrix<NekMatrix<NekDouble, StandardMatrixTag>, ScaledMatrixTag>, BlockMatrixTag>, BlockMatrixTag> Nektar::BlkMatDNekScalBlkMat

Definition at line 67 of file NekTypeDefs.hpp.

BlkMatDNekScalBlkMatSharedPtr

typedef std::shared_ptr< BlkMatDNekScalBlkMat > Nektar::BlkMatDNekScalBlkMatSharedPtr

Definition at line 74 of file NekTypeDefs.hpp.

BlkMatSNekBlkMat

typedef NekMatrix<NekMatrix<NekMatrix<NekSingle, StandardMatrixTag>, BlockMatrixTag>, BlockMatrixTag> Nektar::BlkMatSNekBlkMat

Definition at line 108 of file NekTypeDefs.hpp.

BlkMatSNekBlkMatSharedPtr

typedef std::shared_ptr<BlkMatSNekBlkMat> Nektar::BlkMatSNekBlkMatSharedPtr

Definition at line 117 of file NekTypeDefs.hpp.

BlkMatSNekScalBlkMat

typedef NekMatrix<NekMatrix<NekMatrix<NekMatrix<NekSingle, StandardMatrixTag>, ScaledMatrixTag>, BlockMatrixTag>, BlockMatrixTag> Nektar::BlkMatSNekScalBlkMat

Definition at line 112 of file NekTypeDefs.hpp.

BlkMatSNekScalBlkMatSharedPtr

typedef std::shared_ptr< BlkMatSNekScalBlkMat > Nektar::BlkMatSNekScalBlkMatSharedPtr

Definition at line 119 of file NekTypeDefs.hpp.

BlockMatrix

typedef NekMatrix<DenseMatrix, BlockMatrixTag> Nektar::BlockMatrix

Definition at line 60 of file NekTypeDefs.hpp.

BoundaryFactory

typedef LibUtilities::NekFactory<std::string, PulseWaveBoundary, Array<OneD, MultiRegions::ExpListSharedPtr> &, const LibUtilities::SessionReaderSharedPtr &, PulseWavePressureAreaSharedPtr &> Nektar::BoundaryFactory

Definition at line 57 of file PulseWaveBoundary.h.

CellModelFactory

typedef LibUtilities::NekFactory< std::string, CellModel, const LibUtilities::SessionReaderSharedPtr&, const MultiRegions::ExpListSharedPtr&> Nektar::CellModelFactory

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

Definition at line 60 of file CellModel.h.

CellModelSharedPtr

typedef std::shared_ptr<CellModel> Nektar::CellModelSharedPtr

A shared pointer to an EquationSystem object.

Definition at line 55 of file CellModel.h.

CFSBndCondFactory

typedef LibUtilities::NekFactory<std::string, CFSBndCond, const LibUtilities::SessionReaderSharedPtr&, const Array<OneD, MultiRegions::ExpListSharedPtr>&, const Array<OneD, Array<OneD, NekDouble> >&, const int, const int, const int> Nektar::CFSBndCondFactory

Declaration of the boundary condition factory.

Definition at line 60 of file CFSBndCond.h.

CFSBndCondSharedPtr

typedef std::shared_ptr<CFSBndCond> Nektar::CFSBndCondSharedPtr

A shared pointer to a boundary condition object.

Definition at line 51 of file CFSBndCond.h.

COOEntryType

typedef NekDouble Nektar::COOEntryType

Definition at line 56 of file SparseMatrixFwd.hpp.

COOMatType

typedef std::map<CoordType, NekDouble> Nektar::COOMatType

Definition at line 57 of file SparseMatrixFwd.hpp.

COOMatTypeConstIt

typedef COOMatType::const_iterator Nektar::COOMatTypeConstIt

Definition at line 58 of file SparseMatrixFwd.hpp.

COOMatTypeSharedPtr

typedef std::shared_ptr<COOMatType> Nektar::COOMatTypeSharedPtr

Definition at line 59 of file SparseMatrixFwd.hpp.

COOMatVector

typedef Array<OneD, COOMatType> Nektar::COOMatVector

Definition at line 60 of file SparseMatrixFwd.hpp.

CoordType

typedef std::pair<IndexType, IndexType> Nektar::CoordType

Definition at line 55 of file SparseMatrixFwd.hpp.

CoupledAssemblyMapSharedPtr

typedef std::shared_ptr<CoupledAssemblyMap> Nektar::CoupledAssemblyMapSharedPtr

Definition at line 62 of file CoupledAssemblyMap.h.

CoupledLocalToGlobalC0ContMapSharedPtr

typedef std::shared_ptr<CoupledLocalToGlobalC0ContMap> Nektar::CoupledLocalToGlobalC0ContMapSharedPtr

Definition at line 64 of file CoupledLocalToGlobalC0ContMap.h.

CoupledSolverMatrices

typedef struct Nektar::coupledSolverMatrices Nektar::CoupledSolverMatrices

DenseMatrix

typedef NekMatrix<NekDouble, StandardMatrixTag> Nektar::DenseMatrix

Definition at line 52 of file NekTypeDefs.hpp.

DiffusionLDGNSSharedPtr

typedef std::shared_ptr<DiffusionLDGNS> Nektar::DiffusionLDGNSSharedPtr

Definition at line 173 of file DiffusionLDGNS.h.

DNekBlkMat

typedef NekMatrix<NekMatrix<NekDouble, StandardMatrixTag>, BlockMatrixTag> Nektar::DNekBlkMat

Definition at line 59 of file NekTypeDefs.hpp.

DNekBlkMatSharedPtr

typedef std::shared_ptr<DNekBlkMat> Nektar::DNekBlkMatSharedPtr

Definition at line 71 of file NekTypeDefs.hpp.

DNekLinSys

typedef LinearSystem Nektar::DNekLinSys

Definition at line 82 of file NekTypeDefs.hpp.

DNekLinSysSharedPtr

typedef std::shared_ptr<DNekLinSys> Nektar::DNekLinSysSharedPtr

Definition at line 83 of file NekTypeDefs.hpp.

DNekMat

typedef NekMatrix<NekDouble, StandardMatrixTag> Nektar::DNekMat

Definition at line 51 of file NekTypeDefs.hpp.

DNekMatSharedPtr

typedef std::shared_ptr<DNekMat> Nektar::DNekMatSharedPtr

Definition at line 69 of file NekTypeDefs.hpp.

DNekScalBlkMat

typedef NekMatrix<NekMatrix<NekMatrix<NekDouble, StandardMatrixTag>, ScaledMatrixTag>, BlockMatrixTag> Nektar::DNekScalBlkMat

Definition at line 65 of file NekTypeDefs.hpp.

DNekScalBlkMatSharedPtr

typedef std::shared_ptr<DNekScalBlkMat> Nektar::DNekScalBlkMatSharedPtr

Definition at line 73 of file NekTypeDefs.hpp.

DNekScalLinSys

typedef LinearSystem Nektar::DNekScalLinSys

Definition at line 85 of file NekTypeDefs.hpp.

DNekScalLinSysSharedPtr

typedef std::shared_ptr<DNekScalLinSys> Nektar::DNekScalLinSysSharedPtr

Definition at line 86 of file NekTypeDefs.hpp.

DNekScalMat

typedef NekMatrix< NekMatrix< NekDouble, StandardMatrixTag >, ScaledMatrixTag > Nektar::DNekScalMat

Definition at line 68 of file NekMatrixFwd.hpp.

DNekScalMatSharedPtr

typedef std::shared_ptr< DNekScalMat > Nektar::DNekScalMatSharedPtr

Definition at line 69 of file NekMatrixFwd.hpp.

DNekVec

typedef NekVector<NekDouble> Nektar::DNekVec

Definition at line 48 of file NekTypeDefs.hpp.

EmpiricalPressureAreaSharedPtr

typedef std::shared_ptr<EmpiricalPressureArea> Nektar::EmpiricalPressureAreaSharedPtr

Definition at line 49 of file EmpiricalPressureArea.h.

EquationOfStateFactory

typedef LibUtilities::NekFactory<std::string, EquationOfState, const LibUtilities::SessionReaderSharedPtr &> Nektar::EquationOfStateFactory

Declaration of the equation of state factory.

Definition at line 54 of file EquationOfState.h.

EquationOfStateSharedPtr

typedef std::shared_ptr<EquationOfState> Nektar::EquationOfStateSharedPtr

A shared pointer to an equation of state object.

Definition at line 49 of file EquationOfState.h.

ExtrapolateFactory

typedef LibUtilities::NekFactory< std::string, Extrapolate, const LibUtilities::SessionReaderSharedPtr& , Array<OneD, MultiRegions::ExpListSharedPtr>& , MultiRegions::ExpListSharedPtr& , const Array<OneD, int>& , const SolverUtils::AdvectionSharedPtr& > Nektar::ExtrapolateFactory

Definition at line 67 of file Extrapolate.h.

ExtrapolateSharedPtr

typedef std::shared_ptr<Extrapolate> Nektar::ExtrapolateSharedPtr

Definition at line 61 of file Extrapolate.h.

FilterAeroForcesSPMSharedPtr

typedef std::shared_ptr<FilterAeroForcesSPM> Nektar::FilterAeroForcesSPMSharedPtr

Definition at line 106 of file FilterAeroForcesSPM.h.

FilterMap

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

Definition at line 48 of file FilterMovingBody.h.

FilterMovingBodySharedPtr

typedef std::shared_ptr<FilterMovingBody> Nektar::FilterMovingBodySharedPtr

Definition at line 46 of file FilterMovingBody.h.

FilterParams

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

Definition at line 47 of file FilterMovingBody.h.

HighOrderOutflowSharedPtr

typedef std::shared_ptr<HighOrderOutflow> Nektar::HighOrderOutflowSharedPtr

Definition at line 70 of file Extrapolate.h.

IncNavierStokesSharedPtr

typedef std::shared_ptr<IncNavierStokes> Nektar::IncNavierStokesSharedPtr

Definition at line 275 of file IncNavierStokes.h.

IndexType

typedef unsigned int Nektar::IndexType

Definition at line 50 of file SparseMatrixFwd.hpp.

IndexVector

typedef Array<OneD, IndexType> Nektar::IndexVector

Definition at line 52 of file SparseMatrixFwd.hpp.

InterfacePointShPtr

typedef std::shared_ptr<InterfacePoint> Nektar::InterfacePointShPtr

Definition at line 84 of file PulseWaveSystem.h.

MappingExtrapolateSharedPtr

typedef std::shared_ptr<MappingExtrapolate> Nektar::MappingExtrapolateSharedPtr

Definition at line 49 of file MappingExtrapolate.h.

NekComplexDouble

typedef std::complex<double> Nektar::NekComplexDouble

Definition at line 100 of file IncNavierStokes.h.

NekDouble

typedef double Nektar::NekDouble

Definition at line 43 of file NektarUnivTypeDefs.hpp.

NekInt

typedef std::int32_t Nektar::NekInt

Definition at line 46 of file NektarUnivTypeDefs.hpp.

NekInt32

typedef std::int32_t Nektar::NekInt32

Definition at line 47 of file NektarUnivTypeDefs.hpp.

NekInt64

typedef std::int64_t Nektar::NekInt64

Definition at line 48 of file NektarUnivTypeDefs.hpp.

NekSingle

typedef float Nektar::NekSingle

Definition at line 44 of file NektarUnivTypeDefs.hpp.

NekUInt

typedef std::uint32_t Nektar::NekUInt

Definition at line 49 of file NektarUnivTypeDefs.hpp.

NekUInt32

typedef std::uint32_t Nektar::NekUInt32

Definition at line 50 of file NektarUnivTypeDefs.hpp.

NekUInt64

typedef std::uint64_t Nektar::NekUInt64

Definition at line 51 of file NektarUnivTypeDefs.hpp.

PowerPressureAreaSharedPtr

typedef std::shared_ptr<PowerPressureArea> Nektar::PowerPressureAreaSharedPtr

Definition at line 49 of file PowerPressureArea.h.

PreconCfsOpFactory

typedef LibUtilities::NekFactory< std::string, PreconCfsOp, const Array<OneD, MultiRegions::ExpListSharedPtr> &, const LibUtilities::SessionReaderSharedPtr &, const LibUtilities::CommSharedPtr &> Nektar::PreconCfsOpFactory

Declaration of the boundary condition factory.

Definition at line 162 of file PreconCfsOp.h.

PreconCfsOpSharedPtr

typedef std::shared_ptr< PreconCfsOp > Nektar::PreconCfsOpSharedPtr

Definition at line 154 of file PreconCfsOp.h.

PreconCfsSharedPtr

typedef std::shared_ptr<PreconCfs> Nektar::PreconCfsSharedPtr

Definition at line 108 of file PreconCfs.h.

PressureAreaFactory

typedef LibUtilities::NekFactory<std::string, PulseWavePressureArea, Array<OneD, MultiRegions::ExpListSharedPtr> &, const LibUtilities::SessionReaderSharedPtr &> Nektar::PressureAreaFactory

Definition at line 56 of file PulseWavePressureArea.h.

ProtocolFactory

typedef LibUtilities::NekFactory< std::string, Protocol, const LibUtilities::SessionReaderSharedPtr&, const TiXmlElement*> Nektar::ProtocolFactory

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

Definition at line 53 of file Protocol.h.

ProtocolSharedPtr

typedef std::shared_ptr<Protocol> Nektar::ProtocolSharedPtr

A shared pointer to an EquationSystem object.

Definition at line 47 of file Protocol.h.

PulseWaveBoundarySharedPtr

typedef std::shared_ptr<PulseWaveBoundary> Nektar::PulseWaveBoundarySharedPtr

Definition at line 50 of file PulseWaveBoundary.h.

PulseWavePressureAreaSharedPtr

typedef std::shared_ptr<PulseWavePressureArea> Nektar::PulseWavePressureAreaSharedPtr

Definition at line 49 of file PulseWavePressureArea.h.

PulseWaveSystemOutputSharedPtr

typedef std::shared_ptr<PulseWaveSystemOutput> Nektar::PulseWaveSystemOutputSharedPtr

Definition at line 77 of file PulseWaveSystemOutput.h.

PulseWaveSystemSharedPtr

typedef std::shared_ptr<PulseWaveSystem> Nektar::PulseWaveSystemSharedPtr

Definition at line 198 of file PulseWaveSystem.h.

QInflowSharedPtr

typedef std::shared_ptr<QInflow> Nektar::QInflowSharedPtr

Definition at line 48 of file QInflow.h.

RawType_t

template<typename T >

using Nektar::RawType_t = typedef typename RawType<T>::type

Definition at line 76 of file RawType.hpp.

RCROutflowSharedPtr

typedef std::shared_ptr<RCROutflow> Nektar::RCROutflowSharedPtr

Definition at line 49 of file RCROutflow.h.

ROutflowSharedPtr

typedef std::shared_ptr<ROutflow> Nektar::ROutflowSharedPtr

Definition at line 49 of file ROutflow.h.

SBlockMatrix

typedef NekMatrix<SDenseMatrix, BlockMatrixTag> Nektar::SBlockMatrix

Definition at line 105 of file NekTypeDefs.hpp.

ScaledMatrix

typedef NekMatrix<DenseMatrix, ScaledMatrixTag> Nektar::ScaledMatrix

Definition at line 56 of file NekTypeDefs.hpp.

SDenseMatrix

typedef NekMatrix<NekSingle, StandardMatrixTag> Nektar::SDenseMatrix

Definition at line 97 of file NekTypeDefs.hpp.

SharedNekMatrixPtr

typedef std::shared_ptr<NekMatrix<NekDouble, StandardMatrixTag> > Nektar::SharedNekMatrixPtr

Definition at line 67 of file NekMatrixFwd.hpp.

SharedSNekMatrixPtr

typedef std::shared_ptr<NekMatrix<NekSingle, StandardMatrixTag> > Nektar::SharedSNekMatrixPtr

Definition at line 71 of file NekMatrixFwd.hpp.

SmoothedProfileMethodSharedPtr

typedef std::shared_ptr<SmoothedProfileMethod> Nektar::SmoothedProfileMethodSharedPtr

Definition at line 179 of file SmoothedProfileMethod.h.

SNekBlkMat

typedef NekMatrix<NekMatrix<NekSingle, StandardMatrixTag>, BlockMatrixTag> Nektar::SNekBlkMat

Definition at line 104 of file NekTypeDefs.hpp.

SNekBlkMatSharedPtr

typedef std::shared_ptr<SNekBlkMat> Nektar::SNekBlkMatSharedPtr

Definition at line 116 of file NekTypeDefs.hpp.

SNekMat

Nektar::SNekMat

Definition at line 96 of file NekTypeDefs.hpp.

SNekMatSharedPtr

typedef std::shared_ptr<SNekMat> Nektar::SNekMatSharedPtr

Definition at line 114 of file NekTypeDefs.hpp.

SNekScalBlkMat

typedef NekMatrix<NekMatrix<NekMatrix<NekSingle, StandardMatrixTag>, ScaledMatrixTag>, BlockMatrixTag> Nektar::SNekScalBlkMat

Definition at line 110 of file NekTypeDefs.hpp.

SNekScalBlkMatSharedPtr

typedef std::shared_ptr<SNekScalBlkMat> Nektar::SNekScalBlkMatSharedPtr

Definition at line 118 of file NekTypeDefs.hpp.

SNekScalMat

typedef NekMatrix< NekMatrix< NekSingle, StandardMatrixTag >, ScaledMatrixTag > Nektar::SNekScalMat

Definition at line 72 of file NekMatrixFwd.hpp.

SNekScalMatSharedPtr

typedef std::shared_ptr< SNekScalMat > Nektar::SNekScalMatSharedPtr

Definition at line 73 of file NekMatrixFwd.hpp.

SNekVec

typedef NekVector<NekSingle> Nektar::SNekVec

Definition at line 93 of file NekTypeDefs.hpp.

SScaledMatrix

typedef NekMatrix<SDenseMatrix, ScaledMatrixTag> Nektar::SScaledMatrix

Definition at line 101 of file NekTypeDefs.hpp.

StandardExtrapolateSharedPtr

typedef std::shared_ptr<StandardExtrapolate> Nektar::StandardExtrapolateSharedPtr

Definition at line 55 of file StandardExtrapolate.h.

StimulusFactory

typedef LibUtilities::NekFactory< std::string, Stimulus, const LibUtilities::SessionReaderSharedPtr&, const MultiRegions::ExpListSharedPtr&, const TiXmlElement*> Nektar::StimulusFactory

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

Definition at line 59 of file Stimulus.h.

StimulusSharedPtr

typedef std::shared_ptr<Stimulus> Nektar::StimulusSharedPtr

A shared pointer to an EquationSystem object.

Definition at line 52 of file Stimulus.h.

SubSteppingExtrapolateSharedPtr

typedef std::shared_ptr<SubSteppingExtrapolate> Nektar::SubSteppingExtrapolateSharedPtr

Definition at line 55 of file SubSteppingExtrapolate.h.

SubSteppingExtrapolateWeakPressureSharedPtr

typedef std::shared_ptr<SubSteppingExtrapolateWeakPressure> Nektar::SubSteppingExtrapolateWeakPressureSharedPtr

Definition at line 48 of file SubSteppingExtrapolateWeakPressure.h.

SummaryList

typedef std::vector<std::pair<std::string, std::string> > Nektar::SummaryList

Definition at line 52 of file CellModel.h.

TemplatePressureAreaSharedPtr

typedef std::shared_ptr<TemplatePressureArea> Nektar::TemplatePressureAreaSharedPtr

Definition at line 47 of file TemplatePressureArea.h.

TensorOfArray2D

template<class T >

using Nektar::TensorOfArray2D = typedef Array<OneD, Array<OneD, T> >

Definition at line 832 of file SharedArray.hpp.

TensorOfArray3D

template<class T >

using Nektar::TensorOfArray3D = typedef Array<OneD, Array<OneD, Array<OneD, T> > >

Definition at line 838 of file SharedArray.hpp.

TensorOfArray4D

template<class T >

using Nektar::TensorOfArray4D = typedef Array<OneD, Array<OneD, Array<OneD, Array<OneD, T> > > >

Definition at line 848 of file SharedArray.hpp.

TensorOfArray5D

template<class T >

using Nektar::TensorOfArray5D = typedef Array<OneD, Array<OneD, Array<OneD, Array<OneD, Array<OneD, T> > > > >

Definition at line 860 of file SharedArray.hpp.

TerminalOutflowSharedPtr

typedef std::shared_ptr<TerminalOutflow> Nektar::TerminalOutflowSharedPtr

Pointer to a PulseWaveOutflow object.

Definition at line 49 of file TerminalOutflow.h.

TimeDependentInflowSharedPtr

typedef std::shared_ptr<TimeDependentInflow> Nektar::TimeDependentInflowSharedPtr

Definition at line 49 of file TimeDependentInflow.h.

UInflowSharedPtr

typedef std::shared_ptr<UInflow> Nektar::UInflowSharedPtr

Pointer to a PulseWaveOutflow object.

Definition at line 48 of file UInflow.h.

UndefinedInOutflowSharedPtr

typedef std::shared_ptr<UndefinedInOutflow> Nektar::UndefinedInOutflowSharedPtr

Definition at line 49 of file UndefinedInOutflow.h.

VariableConverterSharedPtr

typedef std::shared_ptr<VariableConverter> Nektar::VariableConverterSharedPtr

Definition at line 46 of file VariableConverter.h.

VCSMappingSharedPtr

typedef std::shared_ptr<VCSMapping> Nektar::VCSMappingSharedPtr

Definition at line 157 of file VCSMapping.h.

VCSWeakPressureSharedPtr

typedef std::shared_ptr<VCSWeakPressure> Nektar::VCSWeakPressureSharedPtr

Definition at line 101 of file VelocityCorrectionSchemeWeakPressure.h.

vec_t

using Nektar::vec_t = typedef tinysimd::simd<NekDouble>

Definition at line 59 of file EquationOfState.h.

VelocityCorrectionSchemeSharedPtr

typedef std::shared_ptr<VelocityCorrectionScheme> Nektar::VelocityCorrectionSchemeSharedPtr

Definition at line 234 of file VelocityCorrectionScheme.h.

WeakPressureExtrapolateSharedPtr

typedef std::shared_ptr<WeakPressureExtrapolate> Nektar::WeakPressureExtrapolateSharedPtr

Definition at line 54 of file WeakPressureExtrapolate.h.

WomersleyParamsSharedPtr

typedef std::shared_ptr<WomersleyParams> Nektar::WomersleyParamsSharedPtr

Definition at line 129 of file IncNavierStokes.h.

Enumeration Type Documentation

AdvectionForm

enum Nektar::AdvectionForm

Enumerator
eNoAdvectionForm
eConvective
eNonConservative
eLinearised
eAdjoint
eSkewSymmetric
eNoAdvection
eAdvectionFormSize

Definition at line 75 of file IncNavierStokes.h.

    {
        eNoAdvectionForm,
        eConvective,
        eNonConservative,
        eLinearised,
        eAdjoint,
        eSkewSymmetric,
        eNoAdvection,
        eAdvectionFormSize
    };

AllowWrappingOfConstArrays

enum Nektar::AllowWrappingOfConstArrays

Enumerator
eVECTOR_WRAPPER

Definition at line 524 of file SharedArray.hpp.

    {
        eVECTOR_WRAPPER
    };

Direction

enum Nektar::Direction

Enumerator
xDir
yDir
zDir

Definition at line 71 of file NektarUnivTypeDefs.hpp.

    {
        xDir = 0,
        yDir = 1,
        zDir = 2
    };

EquationType

enum Nektar::EquationType

Enumerator
eNoEquationType
eSteadyStokes
eSteadyOseen
eSteadyLinearisedNS
eUnsteadyStokes
eUnsteadyLinearisedNS
eUnsteadyNavierStokes
eSteadyNavierStokes
eEquationTypeSize

Definition at line 48 of file IncNavierStokes.h.

    {
        eNoEquationType,
        eSteadyStokes,
        eSteadyOseen,
        eSteadyLinearisedNS,
        eUnsteadyStokes,
        eUnsteadyLinearisedNS,
        eUnsteadyNavierStokes,
        eSteadyNavierStokes,
        eEquationTypeSize
    };

FlagType

enum Nektar::FlagType

Enumeration of flags for passing a list of options.

Enumerator
eUseGlobal

Definition at line 88 of file NektarUnivTypeDefs.hpp.

    {
        eUseGlobal
    };

HBCType

enum Nektar::HBCType

Enumerator
eNOHBC
eHBCNeumann
eOBC
eConvectiveOBC

Definition at line 51 of file Extrapolate.h.

    {
        eNOHBC,
        eHBCNeumann,    // Standard High Order BC
        eOBC,           // High Order outflow BC (Neumann-Dirichlet) from Dong et al JCP 2014
        eConvectiveOBC  // Convective High Order (Robin type) BC from Dong JCP 2015
    };

InitWaveType

enum Nektar::InitWaveType

Enumerator
eLeft
eBothEnds
eCenter
eLeftBottomCorner
ePoint
eSpiralDock
SIZE_InitWaveType	Length of enum list.

Definition at line 69 of file MMFDiffusion.h.

  {          
    eLeft,
    eBothEnds,
    eCenter,
    eLeftBottomCorner,
    ePoint,
    eSpiralDock,
    SIZE_InitWaveType   ///< Length of enum list
  };

MatrixStorage

enum Nektar::MatrixStorage

Enumerator
eFULL
eDIAGONAL
eUPPER_TRIANGULAR
eLOWER_TRIANGULAR
eSYMMETRIC
ePOSITIVE_DEFINITE_SYMMETRIC
eBANDED
eSYMMETRIC_BANDED
ePOSITIVE_DEFINITE_SYMMETRIC_BANDED
eUPPER_TRIANGULAR_BANDED
eLOWER_TRIANGULAR_BANDED

Definition at line 41 of file MatrixStorageType.h.

    {
        eFULL, 
        eDIAGONAL,
        eUPPER_TRIANGULAR,
        eLOWER_TRIANGULAR,
        eSYMMETRIC,
        ePOSITIVE_DEFINITE_SYMMETRIC,
        eBANDED,
        eSYMMETRIC_BANDED,
        ePOSITIVE_DEFINITE_SYMMETRIC_BANDED,
        eUPPER_TRIANGULAR_BANDED,
        eLOWER_TRIANGULAR_BANDED
    };

OutputFormat

enum Nektar::OutputFormat

Enumerator
eTecplot
eTecplotZones
eTecplotSingleBlock
eGmsh
eGnuplot

Definition at line 78 of file NektarUnivTypeDefs.hpp.

    {
        eTecplot,
        eTecplotZones,
        eTecplotSingleBlock,
        eGmsh,
        eGnuplot
    };

PointerWrapper

enum Nektar::PointerWrapper

Specifies if the pointer passed to a NekMatrix or NekVector is copied into an internal representation or used directly.

Enumerator
eWrapper
eCopy

Definition at line 42 of file PointerWrapper.h.

    { 
        eWrapper, 
        eCopy 
    };

PrecType

enum Nektar::PrecType

Enumerator
eNull	No Solution type specified.
eDiagonal
eSparse

Definition at line 45 of file PreconCfs.h.

{
    eNull, ///< No Solution type specified
    eDiagonal,
    eSparse,
};

ProblemType

enum Nektar::ProblemType

Enumerator
eGeneral	No problem defined - Default Inital data.
eSolitaryWave	First order Laitone solitary wave.
SIZE_ProblemType	Length of enum list.

Definition at line 44 of file NonlinearPeregrine.h.

{
    eGeneral,          ///< No problem defined - Default Inital data
    eSolitaryWave,     ///< First order Laitone solitary wave
    SIZE_ProblemType   ///< Length of enum list
};

TestType [1/2]

enum Nektar::TestType

Enumerator
eTestPlane
eTestCube
eTestLinearSphere
eTestNonlinearSphere
eFHNStandard
eFHNRogers
eFHNAlievPanf
SIZE_TestType	Length of enum list.
eTestPlane
eTestSteadyZonal
eTestUnsteadyZonal
eTestIsolatedMountain
eTestUnstableJet
eTestRossbyWave
SIZE_TestType	Length of enum list.

Definition at line 46 of file MMFDiffusion.h.

  {           
    eTestPlane,
    eTestCube,
    eTestLinearSphere,     
    eTestNonlinearSphere,
    eFHNStandard,
    eFHNRogers,
    eFHNAlievPanf,
    SIZE_TestType   ///< Length of enum list
  };

TestType [2/2]

enum Nektar::TestType

Enumerator
eTestPlane
eTestCube
eTestLinearSphere
eTestNonlinearSphere
eFHNStandard
eFHNRogers
eFHNAlievPanf
SIZE_TestType	Length of enum list.
eTestPlane
eTestSteadyZonal
eTestUnsteadyZonal
eTestIsolatedMountain
eTestUnstableJet
eTestRossbyWave
SIZE_TestType	Length of enum list.

Definition at line 44 of file MMFSWE.h.

{
    eTestPlane,
    eTestSteadyZonal,
    eTestUnsteadyZonal,
    eTestIsolatedMountain,
    eTestUnstableJet,
    eTestRossbyWave,
    SIZE_TestType ///< Length of enum list
};

UpwindTypePulse

enum Nektar::UpwindTypePulse

Enumerator
eNotSetPulse	flux not defined
eUpwindPulse	simple upwinding scheme
SIZE_UpwindTypePulse	Length of enum list.

Definition at line 47 of file PulseWaveSystem.h.

    {
        eNotSetPulse,            ///< flux not defined
        eUpwindPulse,            ///< simple upwinding scheme
        SIZE_UpwindTypePulse     ///< Length of enum list
    };

VWIIterationType

enum Nektar::VWIIterationType

Enumerator
eFixedAlpha
eFixedWaveForcing
eFixedAlphaWaveForcing
eFixedWaveForcingWithSubIterationOnAlpha
eVWIIterationTypeSize

Definition at line 54 of file VortexWaveInteraction.h.

    {
        eFixedAlpha,
        eFixedWaveForcing,
        eFixedAlphaWaveForcing,
        eFixedWaveForcingWithSubIterationOnAlpha,
        eVWIIterationTypeSize
    };

Function Documentation

Add() [1/10]

template<typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >

SNekMat SNekMat NekMatrix<typename NekMatrix<LhsDataType, LhsMatrixType>::NumberType, StandardMatrixTag> Nektar::Add	(	const NekMatrix< LhsDataType, LhsMatrixType > &	lhs,
		const NekMatrix< RhsDataType, RhsMatrixType > &	rhs
	)

Definition at line 288 of file MatrixOperations.cpp.

    {
        typedef typename NekMatrix<LhsDataType, LhsMatrixType>::NumberType NumberType;
        NekMatrix<NumberType, StandardMatrixTag> result(lhs.GetRows(), lhs.GetColumns());
        Add(result, lhs, rhs);
        return result;
    }

References Add().

Add() [2/10]

template<typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >

NekMatrix<typename NekMatrix<LhsDataType, LhsMatrixType>::NumberType, StandardMatrixTag> Nektar::Add	(	const NekMatrix< LhsDataType, LhsMatrixType > &	lhs,
		const NekMatrix< RhsDataType, RhsMatrixType > &	rhs
	)

Definition at line 288 of file MatrixOperations.cpp.

    {
        typedef typename NekMatrix<LhsDataType, LhsMatrixType>::NumberType NumberType;
        NekMatrix<NumberType, StandardMatrixTag> result(lhs.GetRows(), lhs.GetColumns());
        Add(result, lhs, rhs);
        return result;
    }

References Add().

Add() [3/10]

template<typename LhsDataType , typename RhsDataType >

NekVector< LhsDataType > Nektar::Add	(	const NekVector< LhsDataType > &	lhs,
		const NekVector< RhsDataType > &	rhs
	)

Definition at line 514 of file NekVector.cpp.

    {
        NekVector<LhsDataType> result(lhs.GetDimension());
        Add(result, lhs, rhs);
        return result;
    }

References Add(), and Nektar::NekVector< DataType >::GetDimension().

Add() [4/10]

template NekVector<NekDouble> Nektar::Add	(	const NekVector< NekDouble > &	lhs,
		const NekVector< NekDouble > &	rhs
	)

Add() [5/10]

template NekVector<NekSingle> Nektar::Add	(	const NekVector< NekSingle > &	lhs,
		const NekVector< NekSingle > &	rhs
	)

Add() [6/10]

template<typename DataType , typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >

SNekMat SNekMat void Nektar::Add	(	NekMatrix< DataType, StandardMatrixTag > &	result,
		const NekMatrix< LhsDataType, LhsMatrixType > &	lhs,
		const NekMatrix< RhsDataType, RhsMatrixType > &	rhs
	)

Definition at line 235 of file MatrixOperations.cpp.

    {
        ASSERTL1(lhs.GetRows() == rhs.GetRows(), std::string("Matrices with different row counts  ") + 
            std::to_string(lhs.GetRows()) + std::string(" and ") +
            std::to_string(rhs.GetRows()) + std::string(" can't be added."));
        ASSERTL1(lhs.GetColumns() == rhs.GetColumns(), std::string("Matrices with different column counts  ") + 
            std::to_string(lhs.GetColumns()) + std::string(" and ") +
            std::to_string(rhs.GetColumns()) + std::string(" can't be added."));
 
        for(unsigned int i = 0; i < lhs.GetRows(); ++i)
        {
            for(unsigned int j = 0; j < lhs.GetColumns(); ++j)
            {
                result(i,j) = lhs(i,j) + rhs(i,j);
            }
        }
    }

References ASSERTL1.

Referenced by Add(), and operator+().

Add() [7/10]

template<typename DataType , typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >

void Nektar::Add	(	NekMatrix< DataType, StandardMatrixTag > &	result,
		const NekMatrix< LhsDataType, LhsMatrixType > &	lhs,
		const NekMatrix< RhsDataType, RhsMatrixType > &	rhs
	)

Definition at line 235 of file MatrixOperations.cpp.

    {
        ASSERTL1(lhs.GetRows() == rhs.GetRows(), std::string("Matrices with different row counts  ") + 
            std::to_string(lhs.GetRows()) + std::string(" and ") +
            std::to_string(rhs.GetRows()) + std::string(" can't be added."));
        ASSERTL1(lhs.GetColumns() == rhs.GetColumns(), std::string("Matrices with different column counts  ") + 
            std::to_string(lhs.GetColumns()) + std::string(" and ") +
            std::to_string(rhs.GetColumns()) + std::string(" can't be added."));
 
        for(unsigned int i = 0; i < lhs.GetRows(); ++i)
        {
            for(unsigned int j = 0; j < lhs.GetColumns(); ++j)
            {
                result(i,j) = lhs(i,j) + rhs(i,j);
            }
        }
    }

References ASSERTL1.

Referenced by Add(), and operator+().

Add() [8/10]

template<typename DataType >

void Nektar::Add	(	NekVector< DataType > &	result,
		const NekVector< DataType > &	lhs,
		const NekVector< DataType > &	rhs
	)

Definition at line 429 of file NekVector.cpp.

    {
        DataType* r_buf = result.GetRawPtr();
        const DataType* lhs_buf = lhs.GetRawPtr();
        const DataType* rhs_buf = rhs.GetRawPtr();
        const unsigned int ldim = lhs.GetDimension();
        for(int i = 0; i < ldim; ++i)
        {
            r_buf[i] = lhs_buf[i] + rhs_buf[i];
        }
    }

References Nektar::NekVector< DataType >::GetDimension(), and Nektar::NekVector< DataType >::GetRawPtr().

Add() [9/10]

template void Nektar::Add	(	NekVector< NekDouble > &	result,
		const NekVector< NekDouble > &	lhs,
		const NekVector< NekDouble > &	rhs
	)

Add() [10/10]

template void Nektar::Add	(	NekVector< NekSingle > &	result,
		const NekVector< NekSingle > &	lhs,
		const NekVector< NekSingle > &	rhs
	)

AddEqual() [1/5]

template<typename DataType , typename RhsDataType , typename RhsMatrixType >

SNekMat void Nektar::AddEqual	(	NekMatrix< DataType, StandardMatrixTag > &	result,
		const NekMatrix< RhsDataType, RhsMatrixType > &	rhs
	)

Definition at line 185 of file MatrixOperations.cpp.

    {
        ASSERTL1(result.GetRows() == rhs.GetRows(), std::string("Matrices with different row counts  ") + 
            std::to_string(result.GetRows()) + std::string(" and ") +
            std::to_string(rhs.GetRows()) + std::string(" can't be added."));
        ASSERTL1(result.GetColumns() == rhs.GetColumns(), std::string("Matrices with different column counts  ") + 
            std::to_string(result.GetColumns()) + std::string(" and ") +
            std::to_string(rhs.GetColumns()) + std::string(" can't be added."));
 
        for(unsigned int i = 0; i < rhs.GetRows(); ++i)
        {
            for(unsigned int j = 0; j < rhs.GetColumns(); ++j)
            {
                result(i,j) += rhs(i,j);
            }
        }
    }

References ASSERTL1.

Referenced by Nektar::NekVector< DataType >::operator+=().

AddEqual() [2/5]

template<typename DataType , typename RhsDataType , typename RhsMatrixType >

void Nektar::AddEqual	(	NekMatrix< DataType, StandardMatrixTag > &	result,
		const NekMatrix< RhsDataType, RhsMatrixType > &	rhs
	)

Definition at line 185 of file MatrixOperations.cpp.

    {
        ASSERTL1(result.GetRows() == rhs.GetRows(), std::string("Matrices with different row counts  ") + 
            std::to_string(result.GetRows()) + std::string(" and ") +
            std::to_string(rhs.GetRows()) + std::string(" can't be added."));
        ASSERTL1(result.GetColumns() == rhs.GetColumns(), std::string("Matrices with different column counts  ") + 
            std::to_string(result.GetColumns()) + std::string(" and ") +
            std::to_string(rhs.GetColumns()) + std::string(" can't be added."));
 
        for(unsigned int i = 0; i < rhs.GetRows(); ++i)
        {
            for(unsigned int j = 0; j < rhs.GetColumns(); ++j)
            {
                result(i,j) += rhs(i,j);
            }
        }
    }

References ASSERTL1.

Referenced by Nektar::NekVector< DataType >::operator+=().

AddEqual() [3/5]

template<typename DataType >

void Nektar::AddEqual	(	NekVector< DataType > &	result,
		const NekVector< DataType > &	rhs
	)

Definition at line 473 of file NekVector.cpp.

    {
        DataType* r_buf = result.GetRawPtr();
        const DataType* rhs_buf = rhs.GetRawPtr();
        const unsigned int rdim = rhs.GetDimension();
        for(int i = 0; i < rdim; ++i)
        {
            r_buf[i] += rhs_buf[i];
        }
    }

References Nektar::NekVector< DataType >::GetDimension(), and Nektar::NekVector< DataType >::GetRawPtr().

AddEqual() [4/5]

template void Nektar::AddEqual	(	NekVector< NekDouble > &	result,
		const NekVector< NekDouble > &	rhs
	)

AddEqual() [5/5]

template void Nektar::AddEqual	(	NekVector< NekSingle > &	result,
		const NekVector< NekSingle > &	rhs
	)

AddEqualNegatedLhs() [1/4]

template<typename DataType , typename RhsDataType , typename RhsMatrixType >

void Nektar::AddEqualNegatedLhs	(	NekMatrix< DataType, StandardMatrixTag > &	result,
		const NekMatrix< RhsDataType, RhsMatrixType > &	rhs
	)

Definition at line 206 of file MatrixOperations.cpp.

    {
        ASSERTL1(result.GetRows() == rhs.GetRows(), std::string("Matrices with different row counts  ") + 
            std::to_string(result.GetRows()) + std::string(" and ") +
            std::to_string(rhs.GetRows()) + std::string(" can't be added."));
        ASSERTL1(result.GetColumns() == rhs.GetColumns(), std::string("Matrices with different column counts  ") + 
            std::to_string(result.GetColumns()) + std::string(" and ") +
            std::to_string(rhs.GetColumns()) + std::string(" can't be added."));
 
        for(unsigned int i = 0; i < rhs.GetRows(); ++i)
        {
            for(unsigned int j = 0; j < rhs.GetColumns(); ++j)
            {
                result(i,j) = -result(i,j) + rhs(i,j);
            }
        }
    }

References ASSERTL1, Nektar::ConstMatrix< DataType >::GetColumns(), and Nektar::ConstMatrix< DataType >::GetRows().

AddEqualNegatedLhs() [2/4]

template<typename DataType >

void Nektar::AddEqualNegatedLhs	(	NekVector< DataType > &	result,
		const NekVector< DataType > &	rhs
	)

Definition at line 486 of file NekVector.cpp.

    {
         DataType* r_buf = result.GetRawPtr();
        const DataType* rhs_buf = rhs.GetRawPtr();
        const unsigned int rdim = rhs.GetDimension();
        for(int i = 0; i < rdim; ++i)
        {
            r_buf[i] = -r_buf[i] + rhs_buf[i];
        }
    }

References Nektar::NekVector< DataType >::GetDimension(), and Nektar::NekVector< DataType >::GetRawPtr().

AddEqualNegatedLhs() [3/4]

template void Nektar::AddEqualNegatedLhs	(	NekVector< NekDouble > &	result,
		const NekVector< NekDouble > &	rhs
	)

AddEqualNegatedLhs() [4/4]

template void Nektar::AddEqualNegatedLhs	(	NekVector< NekSingle > &	result,
		const NekVector< NekSingle > &	rhs
	)

AddNegatedLhs() [1/4]

template<typename DataType , typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >

void Nektar::AddNegatedLhs	(	NekMatrix< DataType, StandardMatrixTag > &	result,
		const NekMatrix< LhsDataType, LhsMatrixType > &	lhs,
		const NekMatrix< RhsDataType, RhsMatrixType > &	rhs
	)

Definition at line 256 of file MatrixOperations.cpp.

    {
        ASSERTL1(lhs.GetRows() == rhs.GetRows(), std::string("Matrices with different row counts  ") + 
            std::to_string(lhs.GetRows()) + std::string(" and ") +
            std::to_string(rhs.GetRows()) + std::string(" can't be added."));
        ASSERTL1(lhs.GetColumns() == rhs.GetColumns(), std::string("Matrices with different column counts  ") + 
            std::to_string(lhs.GetColumns()) + std::string(" and ") +
            std::to_string(rhs.GetColumns()) + std::string(" can't be added."));
 
        for(unsigned int i = 0; i < lhs.GetRows(); ++i)
        {
            for(unsigned int j = 0; j < lhs.GetColumns(); ++j)
            {
                result(i,j) = -lhs(i,j) + rhs(i,j);
            }
        }
    }

References ASSERTL1.

AddNegatedLhs() [2/4]

template<typename DataType >

void Nektar::AddNegatedLhs	(	NekVector< DataType > &	result,
		const NekVector< DataType > &	lhs,
		const NekVector< DataType > &	rhs
	)

Definition at line 444 of file NekVector.cpp.

    {
        DataType* r_buf = result.GetRawPtr();
        const DataType* lhs_buf = lhs.GetRawPtr();
        const DataType* rhs_buf = rhs.GetRawPtr();
        const unsigned int ldim = lhs.GetDimension();
        for(int i = 0; i < ldim; ++i)
        {
            r_buf[i] = -lhs_buf[i] + rhs_buf[i];
        }
    }

References Nektar::NekVector< DataType >::GetDimension(), and Nektar::NekVector< DataType >::GetRawPtr().

AddNegatedLhs() [3/4]

template void Nektar::AddNegatedLhs	(	NekVector< NekDouble > &	result,
		const NekVector< NekDouble > &	lhs,
		const NekVector< NekDouble > &	rhs
	)

AddNegatedLhs() [4/4]

template void Nektar::AddNegatedLhs	(	NekVector< NekSingle > &	result,
		const NekVector< NekSingle > &	lhs,
		const NekVector< NekSingle > &	rhs
	)

AsString() [1/3]

template<typename DataType >

std::string Nektar::AsString

(

const NekVector< DataType > &

v

)

Definition at line 1286 of file NekVector.cpp.

    {
        unsigned int d = v.GetRows();
        std::string result = "(";
        for(unsigned int i = 0; i < d; ++i)
        {
            result += boost::lexical_cast<std::string>(v[i]);
            if( i < v.GetDimension()-1 )
            {
                result += ", ";
            }
        }
        result += ")";
        return result;
    }

References Nektar::NekVector< DataType >::GetDimension(), and Nektar::NekVector< DataType >::GetRows().

Referenced by Nektar::NekVector< DataType >::AsString().

AsString() [2/3]

template std::string Nektar::AsString

(

const NekVector< NekDouble > &

v

)

AsString() [3/3]

template std::string Nektar::AsString

(

const NekVector< NekSingle > &

v

)

convertCooToBco()

void Nektar::convertCooToBco	(	const unsigned int	blkDim,
		const COOMatType &	cooMat,
		BCOMatType &	bcoMat
	)

Definition at line 49 of file SparseUtils.cpp.

    {
        COOMatTypeConstIt  entry;
        BCOMatTypeConstIt  blk;
        int rowcoord, localRow, blkRowCoord;
        int colcoord, localCol, blkColCoord;
 
        for(entry = cooMat.begin(); entry != cooMat.end(); entry++)
        {
            rowcoord = (entry->first).first;
            colcoord = (entry->first).second;
 
            blkRowCoord = rowcoord / blkDim;
            blkColCoord = colcoord / blkDim;
 
            CoordType blkCoords = std::make_pair(blkRowCoord,blkColCoord);
            blk = bcoMat.find(blkCoords);
            if (blk == bcoMat.end())
            {
                BCOEntryType b(blkDim*blkDim, 0.0);
                bcoMat[blkCoords] = b;
            }
 
            localRow    = rowcoord % blkDim;
            localCol    = colcoord % blkDim;
 
            // transpose it: NIST SpBLAS expects Fortran ordering
            // of dense subblocks
            const unsigned int localoffset = localRow + localCol*blkDim;
            (bcoMat[blkCoords])[localoffset] = entry->second;
        }
    }

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

CopyArray()

template<typename ConstDataType , typename DataType >

void Nektar::CopyArray	(	const Array< OneD, ConstDataType > &	source,
		Array< OneD, DataType > &	dest
	)

Definition at line 797 of file SharedArray.hpp.

    {
        if( dest.size() != source.size() )
        {
            dest = Array<OneD, DataType>(source.size());
        }
 
        std::copy(source.data(), source.data() + source.size(), dest.data());
    }

References CellMLToNektar.pycml::copy(), Nektar::Array< OneD, DataType >::data(), and Nektar::Array< OneD, const DataType >::size().

Referenced by Nektar::LinearSystem::LinearSystem(), Nektar::NekVector< DataType >::NekVector(), Nektar::StdRegions::StdExpansion0D::PhysTensorDeriv(), and Nektar::StdRegions::StdExpansion1D::PhysTensorDeriv().

CopyArrayN()

template<typename ConstDataType , typename DataType >

void Nektar::CopyArrayN	(	const Array< OneD, ConstDataType > &	source,
		Array< OneD, DataType > &	dest,
		typename Array< OneD, DataType >::size_type	n
	)

Definition at line 808 of file SharedArray.hpp.

    {
        if( dest.size() != n )
        {
            dest = Array<OneD, DataType>(n);
        }
 
        std::copy(source.data(), source.data() + n, dest.data());
    }

References CellMLToNektar.pycml::copy().

Referenced by Nektar::NekMatrix< DataType, StandardMatrixTag >::NekMatrix(), Nektar::NekMatrix< DataType, StandardMatrixTag >::PerformCopyConstruction(), and Nektar::NekMatrix< DataType, StandardMatrixTag >::RemoveExcessCapacity().

CreateStorage() [1/4]

template<typename Dim , typename DataType , typename ExtentListType >

std::shared_ptr<boost::multi_array_ref<DataType, Dim::Value> > Nektar::CreateStorage

(

const ExtentListType &

extent

)

Definition at line 177 of file ArrayPolicies.hpp.

    {
        typedef boost::multi_array_ref<DataType, Dim::Value> ArrayType;
        size_t size = std::accumulate(extent.begin(), extent.end(), 1, 
            std::multiplies<size_t>());
        DataType* storage = MemoryManager<DataType>::RawAllocate(size);
        return MemoryManager<ArrayType>::AllocateSharedPtrD(
            [=](boost::multi_array_ref<DataType, Dim::Value> *ptr) {
                boost::ignore_unused(ptr);
                ArrayDestructionPolicy<DataType>::Destroy(storage, size);
                MemoryManager<DataType>::RawDeallocate(storage, size);
            },
            storage, extent);
    }

References Nektar::MemoryManager< DataType >::AllocateSharedPtrD(), Nektar::MemoryManager< DataType >::RawAllocate(), and Nektar::MemoryManager< DataType >::RawDeallocate().

Referenced by Nektar::Array< OneD, const DataType >::Array().

CreateStorage() [2/4]

template<typename DataType >

std::shared_ptr<boost::multi_array_ref<DataType, 1> > Nektar::CreateStorage

(

size_t

d1

)

Definition at line 194 of file ArrayPolicies.hpp.

    {
        std::vector<size_t> extents = { d1 };
        return CreateStorage<OneD, DataType>(extents);
    } 

CreateStorage() [3/4]

template<typename DataType >

std::shared_ptr<boost::multi_array_ref<DataType, 2> > Nektar::CreateStorage	(	size_t	d1,
		size_t	d2
	)

Definition at line 202 of file ArrayPolicies.hpp.

    {
        std::vector<size_t> extents = { d1, d2 };
        return CreateStorage<TwoD, DataType>(extents);
    }

CreateStorage() [4/4]

template<typename DataType >

std::shared_ptr<boost::multi_array_ref<DataType, 3> > Nektar::CreateStorage	(	size_t	d1,
		size_t	d2,
		size_t	d3
	)

Definition at line 210 of file ArrayPolicies.hpp.

    {
        std::vector<size_t> extents = { d1, d2, d3 };
        return CreateStorage<ThreeD, DataType>(extents);
    }

createVectorFromPoints() [1/3]

template<typename DataType >

NekVector< DataType > Nektar::createVectorFromPoints	(	const NekPoint< DataType > &	source,
		const NekPoint< DataType > &	dest
	)

Definition at line 1003 of file NekVector.cpp.

    {
        NekVector<DataType> result(3, 0.0);
        for(unsigned int i = 0; i < 3; ++i)
        {
            result[i] = dest[i]-source[i];
        }
        return result;
    }

createVectorFromPoints() [2/3]

template NekVector<NekDouble> Nektar::createVectorFromPoints	(	const NekPoint< NekDouble > &	source,
		const NekPoint< NekDouble > &	dest
	)

createVectorFromPoints() [3/3]

template NekVector<NekSingle> Nektar::createVectorFromPoints	(	const NekPoint< NekSingle > &	source,
		const NekPoint< NekSingle > &	dest
	)

Cross() [1/3]

template<typename DataType >

NekVector< DataType > Nektar::Cross	(	const NekVector< DataType > &	lhs,
		const NekVector< DataType > &	rhs
	)

Definition at line 1266 of file NekVector.cpp.

    {
        ASSERTL1(lhs.GetDimension() == 3 && rhs.GetDimension() == 3, "Cross is only valid for 3D vectors.");
 
        DataType first = lhs.y()*rhs.z() - lhs.z()*rhs.y();
        DataType second = lhs.z()*rhs.x() - lhs.x()*rhs.z();
        DataType third = lhs.x()*rhs.y() - lhs.y()*rhs.x();
 
        NekVector<DataType> result(first, second, third);
        return result;
    }

References ASSERTL1, Nektar::NekVector< DataType >::GetDimension(), Nektar::NekVector< DataType >::x(), Nektar::NekVector< DataType >::y(), and Nektar::NekVector< DataType >::z().

Referenced by Nektar::NekVector< DataType >::Cross().

Cross() [2/3]

template NekVector<NekDouble> Nektar::Cross	(	const NekVector< NekDouble > &	lhs,
		const NekVector< NekDouble > &	rhs
	)

Cross() [3/3]

template NekVector<NekSingle> Nektar::Cross	(	const NekVector< NekSingle > &	lhs,
		const NekVector< NekSingle > &	rhs
	)

DiagonalBlockFullScalMatrixMultiply() [1/2]

void Nektar::DiagonalBlockFullScalMatrixMultiply	(	NekVector< double > &	result,
		const NekMatrix< NekMatrix< NekMatrix< NekDouble, StandardMatrixTag >, ScaledMatrixTag >, BlockMatrixTag > &	lhs,
		const NekVector< double > &	rhs
	)

Definition at line 258 of file MatrixVectorMultiplication.cpp.

    {
        unsigned int numberOfBlockRows = lhs.GetNumberOfBlockRows();
        double* result_ptr = result.GetRawPtr();
        const double* rhs_ptr = rhs.GetRawPtr();
        
        Array<OneD, unsigned int> rowSizes;
        Array<OneD, unsigned int> colSizes;
        lhs.GetBlockSizes(rowSizes, colSizes);
 
        unsigned int curResultRow = 0;
        unsigned int curWrapperRow = 0;
        unsigned int rowsInBlock = 0;
        unsigned int columnsInBlock = 0;
        for(unsigned int blockRow = 0; blockRow < numberOfBlockRows; ++blockRow)
        {
            curResultRow  += rowsInBlock;
            curWrapperRow += columnsInBlock;
            if ( blockRow == 0)
            {
                rowsInBlock    = rowSizes[blockRow] + 1;
                columnsInBlock = colSizes[blockRow] + 1;
            }
            else
            {
                rowsInBlock    = rowSizes[blockRow] - rowSizes[blockRow-1];
                columnsInBlock = colSizes[blockRow] - colSizes[blockRow-1];
            }
 
            if( rowsInBlock == 0)
            {
                continue;
            }
            if( columnsInBlock == 0)
            {
                std::fill(result.begin()+curResultRow,
                         result.begin()+curResultRow + rowsInBlock, 0.0);
                continue;
            }
 
            const DNekScalMat* block = lhs.GetBlockPtr(blockRow, blockRow);
            if( !block )
            {
                continue;
            }
 
            double* resultWrapper = result_ptr + curResultRow;
            const double* rhsWrapper = rhs_ptr + curWrapperRow;
 
            // Multiply
            const unsigned int* size = block->GetSize();
            Blas::Gemv('N', size[0], size[1], block->Scale(),
                        block->GetRawPtr(), size[0], rhsWrapper, 1,
                        0.0, resultWrapper, 1);
        }
        curResultRow  += rowsInBlock;
        if (curResultRow < result.GetRows())
        {
            std::fill(result.begin()+curResultRow, result.end(), 0.0);
        }
    }

References Nektar::NekVector< DataType >::begin(), Nektar::NekVector< DataType >::end(), Blas::Gemv(), Nektar::NekVector< DataType >::GetRawPtr(), and Nektar::NekVector< DataType >::GetRows().

DiagonalBlockFullScalMatrixMultiply() [2/2]

void Nektar::DiagonalBlockFullScalMatrixMultiply	(	NekVector< NekSingle > &	result,
		const NekMatrix< NekMatrix< NekMatrix< NekSingle, StandardMatrixTag >, ScaledMatrixTag >, BlockMatrixTag > &	lhs,
		const NekVector< NekSingle > &	rhs
	)

Definition at line 322 of file MatrixVectorMultiplication.cpp.

    {
        unsigned int numberOfBlockRows = lhs.GetNumberOfBlockRows();
        NekSingle* result_ptr = result.GetRawPtr();
        const NekSingle* rhs_ptr = rhs.GetRawPtr();
        
        Array<OneD, unsigned int> rowSizes;
        Array<OneD, unsigned int> colSizes;
        lhs.GetBlockSizes(rowSizes, colSizes);
 
        unsigned int curResultRow = 0;
        unsigned int curWrapperRow = 0;
        unsigned int rowsInBlock = 0;
        unsigned int columnsInBlock = 0;
        for(unsigned int blockRow = 0; blockRow < numberOfBlockRows; ++blockRow)
        {
            curResultRow  += rowsInBlock;
            curWrapperRow += columnsInBlock;
            if ( blockRow == 0)
            {
                rowsInBlock    = rowSizes[blockRow] + 1;
                columnsInBlock = colSizes[blockRow] + 1;
            }
            else
            {
                rowsInBlock    = rowSizes[blockRow] - rowSizes[blockRow-1];
                columnsInBlock = colSizes[blockRow] - colSizes[blockRow-1];
            }
 
            if( rowsInBlock == 0)
            {
                continue;
            }
            if( columnsInBlock == 0)
            {
                std::fill(result.begin()+curResultRow,
                         result.begin()+curResultRow + rowsInBlock, 0.0);
                continue;
            }
 
            const SNekScalMat* block = lhs.GetBlockPtr(blockRow, blockRow);
            if( !block )
            {
                continue;
            }
 
            NekSingle* resultWrapper = result_ptr + curResultRow;
            const NekSingle* rhsWrapper = rhs_ptr + curWrapperRow;
 
            // Multiply
            const unsigned int* size = block->GetSize();
            Blas::Gemv('N', size[0], size[1], block->Scale(),
                        block->GetRawPtr(), size[0], rhsWrapper, 1,
                        0.0, resultWrapper, 1);
        }
        curResultRow  += rowsInBlock;
        if (curResultRow < result.GetRows())
        {
            std::fill(result.begin()+curResultRow, result.end(), 0.0);
        }
    }

References Nektar::NekVector< DataType >::begin(), Nektar::NekVector< DataType >::end(), Blas::Gemv(), Nektar::NekVector< DataType >::GetRawPtr(), and Nektar::NekVector< DataType >::GetRows().

DiagonalBlockMatrixMultiply()

template<typename DataType , typename LhsInnerMatrixType >

void Nektar::DiagonalBlockMatrixMultiply	(	NekVector< DataType > &	result,
		const NekMatrix< LhsInnerMatrixType, BlockMatrixTag > &	lhs,
		const NekVector< DataType > &	rhs
	)

Definition at line 198 of file MatrixVectorMultiplication.cpp.

    {
        unsigned int numberOfBlockRows = lhs.GetNumberOfBlockRows();
        DataType* result_ptr = result.GetRawPtr();
        const DataType* rhs_ptr = rhs.GetRawPtr();
        
        Array<OneD, unsigned int> rowSizes;
        Array<OneD, unsigned int> colSizes;
        lhs.GetBlockSizes(rowSizes, colSizes);
 
        unsigned int curResultRow = 0;
        unsigned int curWrapperRow = 0;
        unsigned int rowsInBlock = 0;
        unsigned int columnsInBlock = 0;
        for(unsigned int blockRow = 0; blockRow < numberOfBlockRows; ++blockRow)
        {
            curResultRow  += rowsInBlock;
            curWrapperRow += columnsInBlock;
            if ( blockRow == 0)
            {
                rowsInBlock    = rowSizes[blockRow] + 1;
                columnsInBlock = colSizes[blockRow] + 1;
            }
            else
            {
                rowsInBlock    = rowSizes[blockRow] - rowSizes[blockRow-1];
                columnsInBlock = colSizes[blockRow] - colSizes[blockRow-1];
            }
 
            if( rowsInBlock == 0)
            {
                continue;
            }
            if( columnsInBlock == 0)
            {
                std::fill(result.begin()+curResultRow,
                         result.begin()+curResultRow + rowsInBlock, 0.0);
                continue;
            }
 
            const LhsInnerMatrixType* block = lhs.GetBlockPtr(blockRow, blockRow);
            if( !block )
            {
                continue;
            }
 
            DataType* resultWrapper = result_ptr + curResultRow;            
            const DataType* rhsWrapper = rhs_ptr + curWrapperRow;
            Multiply(resultWrapper, *block, rhsWrapper);
            //resultWrapper = (*block)*rhsWrapper;
        }
        curResultRow  += rowsInBlock;
        if (curResultRow < result.GetRows())
        {
            std::fill(result.begin()+curResultRow, result.end(), 0.0);
        }
    }

References Nektar::NekVector< DataType >::begin(), Nektar::NekVector< DataType >::end(), Nektar::NekVector< DataType >::GetRawPtr(), Nektar::NekVector< DataType >::GetRows(), and Multiply().

Referenced by Multiply().

distanceBetween()

template<typename DataType >

boost::call_traits<DataType>::value_type Nektar::distanceBetween	(	const NekPoint< DataType > &	lhs,
		const NekPoint< DataType > &	rhs
	)

Definition at line 454 of file NekPoint.hpp.

    {
        DataType result = 0.0;
        for(unsigned int i = 0; i < 3; ++i)
        {
            DataType temp = lhs[i] - rhs[i];
            result += temp*temp;
        }
        return sqrt(result);
    }

References tinysimd::sqrt().

Divide() [1/8]

template<typename DataType >

NekVector< DataType > Nektar::Divide	(	const NekVector< DataType > &	lhs,
		const NekDouble &	rhs
	)

Definition at line 718 of file NekVector.cpp.

    {
        NekVector<DataType> result(lhs.GetDimension());
        Divide(result, lhs, rhs);
        return result;
    }

References Divide(), and Nektar::NekVector< DataType >::GetDimension().

Divide() [2/8]

template<typename DataType >

NekVector<DataType> Nektar::Divide	(	const NekVector< DataType > &	lhs,
		const NekSingle &	rhs
	)

Definition at line 728 of file NekVector.cpp.

    {
        NekVector<DataType> result(lhs.GetDimension());
        Divide(result, lhs, rhs);
        return result;
    }

References Divide(), and Nektar::NekVector< DataType >::GetDimension().

Divide() [3/8]

template NekVector<NekDouble> Nektar::Divide	(	const NekVector< NekDouble > &	lhs,
		const NekDouble &	rhs
	)

Divide() [4/8]

template NekVector<NekSingle> Nektar::Divide	(	const NekVector< NekSingle > &	lhs,
		const NekSingle &	rhs
	)

Divide() [5/8]

template void Nektar::Divide	(	NekVector< NekDouble > &	result,
		const NekVector< NekDouble > &	lhs,
		const NekDouble &	rhs
	)

Divide() [6/8]

template void Nektar::Divide	(	NekVector< NekSingle > &	result,
		const NekVector< NekSingle > &	lhs,
		const NekSingle &	rhs
	)

Divide() [7/8]

template<typename ResultDataType , typename InputDataType >

void Nektar::Divide	(	NekVector< ResultDataType > &	result,
		const NekVector< InputDataType > &	lhs,
		const NekDouble &	rhs
	)

Definition at line 643 of file NekVector.cpp.

    {
        ResultDataType* r_buf = result.GetRawPtr();
        typename std::add_const<InputDataType>::type* lhs_buf = lhs.GetRawPtr();
 
        const unsigned int ldim = lhs.GetDimension();
        for(int i = 0; i < ldim; ++i)
        {
            r_buf[i] = lhs_buf[i] / rhs;
        }
    }

References Nektar::NekVector< DataType >::GetDimension(), and Nektar::NekVector< DataType >::GetRawPtr().

Referenced by Divide(), and operator/().

Divide() [8/8]

template<typename ResultDataType , typename InputDataType >

void Nektar::Divide	(	NekVector< ResultDataType > &	result,
		const NekVector< InputDataType > &	lhs,
		const NekSingle &	rhs
	)

Definition at line 658 of file NekVector.cpp.

    {
        ResultDataType* r_buf = result.GetRawPtr();
        typename std::add_const<InputDataType>::type* lhs_buf = lhs.GetRawPtr();
 
        const unsigned int ldim = lhs.GetDimension();
        for(int i = 0; i < ldim; ++i)
        {
            r_buf[i] = lhs_buf[i] / rhs;
        }
    }

References Nektar::NekVector< DataType >::GetDimension(), and Nektar::NekVector< DataType >::GetRawPtr().

DivideEqual() [1/4]

template void Nektar::DivideEqual	(	NekVector< NekDouble > &	result,
		const NekDouble &	rhs
	)

DivideEqual() [2/4]

template void Nektar::DivideEqual	(	NekVector< NekSingle > &	result,
		const NekSingle &	rhs
	)

DivideEqual() [3/4]

template<typename ResultDataType >

void Nektar::DivideEqual	(	NekVector< ResultDataType > &	result,
		const NekDouble &	rhs
	)

Definition at line 683 of file NekVector.cpp.

    {
        ResultDataType* r_buf = result.GetRawPtr();
 
        const unsigned int resdim = result.GetDimension();
        for(int i = 0; i < resdim; ++i)
        {
            r_buf[i] /= rhs;
        }
    }

References Nektar::NekVector< DataType >::GetDimension(), and Nektar::NekVector< DataType >::GetRawPtr().

Referenced by Nektar::NekVector< DataType >::operator/=().

DivideEqual() [4/4]

template<typename ResultDataType >

void Nektar::DivideEqual	(	NekVector< ResultDataType > &	result,
		const NekSingle &	rhs
	)

Definition at line 696 of file NekVector.cpp.

    {
        ResultDataType* r_buf = result.GetRawPtr();
 
        const unsigned int resdim = result.GetDimension();
        for(int i = 0; i < resdim; ++i)
        {
            r_buf[i] /= rhs;
        }
    }

References Nektar::NekVector< DataType >::GetDimension(), and Nektar::NekVector< DataType >::GetRawPtr().

Dot() [1/3]

template<typename DataType >

DataType Nektar::Dot	(	const NekVector< DataType > &	lhs,
		const NekVector< DataType > &	rhs
	)

Definition at line 1220 of file NekVector.cpp.

    {
        ASSERTL1( lhs.GetDimension() == rhs.GetDimension(), "Dot, dimension of the two operands must be identical.");
 
        DataType result = DataType(0);
        const unsigned int ldim = lhs.GetDimension();
        for(unsigned int i = 0; i < ldim; ++i)
        {
            result += lhs[i]*rhs[i];
        }
 
        return result;
    }

References ASSERTL1, and Nektar::NekVector< DataType >::GetDimension().

Referenced by Nektar::PulseWaveSystem::BifurcationRiemann(), Nektar::NekVector< DataType >::Dot(), Nektar::PulseWaveSystem::JunctionRiemann(), and Nektar::PulseWaveSystem::MergingRiemann().

Dot() [2/3]

template NekDouble Nektar::Dot	(	const NekVector< NekDouble > &	lhs,
		const NekVector< NekDouble > &	rhs
	)

Dot() [3/3]

template NekSingle Nektar::Dot	(	const NekVector< NekSingle > &	lhs,
		const NekVector< NekSingle > &	rhs
	)

findPointAlongVector() [1/3]

template<typename DataType >

NekPoint< DataType > Nektar::findPointAlongVector	(	const NekVector< DataType > &	lhs,
		const DataType &	t
	)

Definition at line 1024 of file NekVector.cpp.

    {
        NekPoint<DataType> result;
        for(unsigned int i = 0; i < 3; ++i)
        {
            result[i] = lhs[i]*t;
        }
 
        return result;
    }

findPointAlongVector() [2/3]

template NekPoint<NekDouble> Nektar::findPointAlongVector	(	const NekVector< NekDouble > &	lhs,
		const NekDouble &	t
	)

findPointAlongVector() [3/3]

template NekPoint<NekSingle> Nektar::findPointAlongVector	(	const NekVector< NekSingle > &	lhs,
		const NekSingle &	t
	)

FromString()

template<typename DataType >

std::vector< DataType > Nektar::FromString

(

const std::string &

str

)

Definition at line 1080 of file NekVector.cpp.

    {
        std::vector<DataType> result;
 
        try
        {
            typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
            boost::char_separator<char> sep("(<,>) ");
            tokenizer tokens(str, sep);
            for( tokenizer::iterator strIter = tokens.begin(); strIter != tokens.end(); ++strIter)
            {
                result.push_back(boost::lexical_cast<DataType>(*strIter));
            }
        }
        catch(boost::bad_lexical_cast&)
        {
        }
 
        return result;
    }

fromString()

template<typename DataType >

bool Nektar::fromString	(	const std::string &	str,
		NekPoint< DataType > &	result
	)

Definition at line 467 of file NekPoint.hpp.

    {
        try
        {
            typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
            boost::char_separator<char> sep("(<,>) ");
            tokenizer tokens(str, sep);
            unsigned int i = 0;
            for(tokenizer::iterator iter = tokens.begin(); iter != tokens.end(); ++iter)
            {
                result[i] = boost::lexical_cast<DataType>(*iter);
                ++i;
            }
 
            return i == 3;
        }
        catch(boost::bad_lexical_cast&)
        {
            return false;
        }
    }

Referenced by Nektar::NekPoint< data_type >::NekPoint().

FullBlockMatrixMultiply()

template<typename DataType , typename LhsInnerMatrixType >

void Nektar::FullBlockMatrixMultiply	(	NekVector< DataType > &	result,
		const NekMatrix< LhsInnerMatrixType, BlockMatrixTag > &	lhs,
		const NekVector< DataType > &	rhs
	)

Definition at line 133 of file MatrixVectorMultiplication.cpp.

    {
        unsigned int numberOfBlockRows = lhs.GetNumberOfBlockRows();
        unsigned int numberOfBlockColumns = lhs.GetNumberOfBlockColumns();
        DataType* result_ptr = result.GetRawPtr();
        const DataType* rhs_ptr = rhs.GetRawPtr();
        
        for(unsigned int i = 0; i < result.GetDimension(); ++i)
        {
            result_ptr[i] = DataType(0);
        }
        Array<OneD, DataType> temp(result.GetDimension());
        DataType* temp_ptr = temp.get();
        
        unsigned int curResultRow = 0;
        for(unsigned int blockRow = 0; blockRow < numberOfBlockRows; ++blockRow)
        {
            unsigned int rowsInBlock = lhs.GetNumberOfRowsInBlockRow(blockRow);
 
            if( blockRow != 0 )
            {
                curResultRow += lhs.GetNumberOfRowsInBlockRow(blockRow-1);
            }
 
            if( rowsInBlock == 0 )
            {
                continue;
            }
 
            DataType* resultWrapper = result_ptr + curResultRow;
            
            unsigned int curWrapperRow = 0;
            for(unsigned int blockColumn = 0; blockColumn < numberOfBlockColumns; ++blockColumn)
            {
                if( blockColumn != 0 )
                {
                    curWrapperRow += lhs.GetNumberOfColumnsInBlockColumn(blockColumn-1);
                }
 
                //const std::shared_ptr<const LhsInnerMatrixType>& block = lhs.GetBlock(blockRow, blockColumn);
                const LhsInnerMatrixType* block = lhs.GetBlockPtr(blockRow, blockColumn);
                if( !block )
                {
                    continue;
                }
 
                unsigned int columnsInBlock = lhs.GetNumberOfColumnsInBlockColumn(blockColumn);
                if( columnsInBlock == 0 )
                {
                    continue;
                }
 
                const DataType* rhsWrapper = rhs_ptr + curWrapperRow;
                Multiply(temp_ptr, *block, rhsWrapper);
                for(unsigned int i = 0; i < rowsInBlock; ++i)
                {
                    resultWrapper[i] += temp_ptr[i];
                }
            }
        }
    }

References Nektar::Array< OneD, DataType >::get(), Nektar::NekVector< DataType >::GetDimension(), Nektar::NekVector< DataType >::GetRawPtr(), and Multiply().

Referenced by Multiply().

GetArtificialDiffusionFactory()

ArtificialDiffusionFactory & Nektar::GetArtificialDiffusionFactory

(

)

Declaration of the artificial diffusion factory singleton.

Definition at line 42 of file ArtificialDiffusion.cpp.

{
    static ArtificialDiffusionFactory instance;
    return instance;
}

Referenced by Nektar::CompressibleFlowSystem::v_InitObject().

GetBoundaryFactory()

BoundaryFactory & Nektar::GetBoundaryFactory

(

)

Definition at line 62 of file PulseWaveBoundary.cpp.

{
    static BoundaryFactory instance;
    return instance;
}

Referenced by Nektar::PulseWavePropagation::SetPulseWaveBoundaryConditions().

GetCellModelFactory()

CellModelFactory & Nektar::GetCellModelFactory

(

)

Definition at line 46 of file CellModel.cpp.

    {
        static CellModelFactory instance;
        return instance;
    }

Referenced by main(), Nektar::Bidomain::v_InitObject(), Nektar::BidomainRoth::v_InitObject(), and Nektar::Monodomain::v_InitObject().

GetCFSBndCondFactory()

CFSBndCondFactory & Nektar::GetCFSBndCondFactory

(

)

Declaration of the boundary condition factory singleton.

Definition at line 41 of file CFSBndCond.cpp.

{
    static CFSBndCondFactory instance;
    return instance;
}

Referenced by Nektar::CompressibleFlowSystem::v_InitObject().

GetEquationOfStateFactory()

EquationOfStateFactory & Nektar::GetEquationOfStateFactory

(

)

Declaration of the equation of state factory singleton.

Definition at line 41 of file EquationOfState.cpp.

{
    static EquationOfStateFactory instance;
    return instance;
}

Referenced by Nektar::CompressibleSolver::CompressibleSolver(), Nektar::DiffusionLDGNS::v_InitObject(), and Nektar::VariableConverter::VariableConverter().

GetExtrapolateFactory()

ExtrapolateFactory & Nektar::GetExtrapolateFactory

(

)

Definition at line 49 of file Extrapolate.cpp.

    {
        static ExtrapolateFactory instance;
        return instance;
    }

Referenced by Nektar::VelocityCorrectionScheme::SetUpExtrapolation(), Nektar::CoupledLinearNS::v_InitObject(), and Nektar::VCSMapping::v_InitObject().

GetMemoryPool()

MemPool & Nektar::GetMemoryPool

(

)

Definition at line 36 of file ThreadSpecificPool.cpp.

    {
        static MemPool instance;
        return instance;
    }

Referenced by Nektar::MemoryManager< DataType >::Deallocate(), Nektar::MemoryManager< DataType >::RawAllocate(), and Nektar::MemoryManager< DataType >::RawDeallocate().

GetPreconCfsOpFactory()

PreconCfsOpFactory & Nektar::GetPreconCfsOpFactory

(

)

Declaration of the boundary condition factory singleton.

Definition at line 42 of file PreconCfsOp.cpp.

{
    static PreconCfsOpFactory instance;
    return instance;
}

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

GetPressureAreaFactory()

PressureAreaFactory & Nektar::GetPressureAreaFactory

(

)

Definition at line 55 of file PulseWavePressureArea.cpp.

{
    static PressureAreaFactory instance;
    return instance;
}

Referenced by Nektar::UpwindPulseSolver::RiemannSolverUpwind(), Nektar::PulseWavePropagation::v_InitObject(), and Nektar::PulseWaveSystem::v_InitObject().

GetProtocolFactory()

ProtocolFactory & Nektar::GetProtocolFactory

(

)

Definition at line 39 of file Protocol.cpp.

    {
        static ProtocolFactory instance;
        return instance;
    }

Referenced by Nektar::Stimulus::Stimulus().

GetStimulusFactory()

StimulusFactory & Nektar::GetStimulusFactory

(

)

Definition at line 44 of file Stimulus.cpp.

    {
        static StimulusFactory instance;
        return instance;
    }

Referenced by Nektar::Stimulus::LoadStimuli().

GramSchmidtOrthogonalization()

template<typename DataType >

std::vector<NekVector<DataType> > Nektar::GramSchmidtOrthogonalization

(

const std::vector< NekVector< DataType > > &

x

)

Calculates the orthogonal, normalized vectors from linearly independent input.

Returns

A list of ortogonalized vectors corresponding to the input vectors. If the size of the output doesn't match the size of the input then an error occurred. This algorithm is taken from "Parallel Scientific Computing in C++ and MPI", Karniadakis and Kirby, page 55.

Definition at line 53 of file NekLinAlgAlgorithms.hpp.

    {
        typedef NekVector<DataType> VectorType;
        typedef NekMatrix<DataType> MatrixType;
        
        //typename dim = x[0].GetDimension(); 
        unsigned int dim = x[0].GetDimension();
        std::vector<VectorType> q(x.size(), VectorType());
        
        // This matrix holds the r_ij values.  Using the matrix object
        // is a convenience since it provides a 2D access to a table
        // of values.
        MatrixType r(dim, dim);
        r(0,0) = x[0].L2Norm();
 
        if( r(0,0) == DataType(0) )
        {
            return q;
        }
 
        q[0] = x[0]/r(0,0);
 
        for(unsigned int j = 1; j < x.size(); ++j)
        {
            for(unsigned int i = 0; i <= j-1; ++i)
            {
                r(i,j) = q[i].Dot(x[j]);
            }
            
            VectorType y = x[j];
            for(unsigned int i = 0; i <= j-1; ++i)
            {
                y = y - r(i,j)*q[i];
            }
            
            r(j,j) = y.L2Norm();
            if( r(j,j) == DataType(0) )
            {
                return q;
            }
            
            q[j] = y/r(j,j);
        }
        
        return q;
    }

guessp()

NekDouble Nektar::guessp ( NekDouble  g[], NekDouble  rhoL, NekDouble  uL, NekDouble  pL, NekDouble  cL, NekDouble  rhoR, NekDouble  uR, NekDouble  pR, NekDouble  cR  )

inline

Use either PVRS, two-rarefaction or two-shock Riemann solvers to calculate an initial pressure for the Newton-Raphson scheme.

Parameters

g	Array of calculated gamma values.
rhoL	Density left state.
rhoR	Density right state.
uL	x-velocity component left state.
uR	x-velocity component right state.
pL	Pressure component left state.
pR	Pressure component right state.
cL	Sound speed component left state.
cR	Sound speed component right state.

Returns

Computed initial guess for the Newton-Raphson scheme.

Definition at line 70 of file ExactSolverToro.cpp.

    {
        const NekDouble quser = 2.0;
        NekDouble cup, ppv, pmin, pmax, qmax;
        
        cup  = 0.25*(rhoL + rhoR)*(cL + cR);
        ppv  = 0.5 *(pL + pR) + 0.5*(uL - uR)*cup;
        ppv  = std::max(0.0, ppv);
        pmin = std::min(pL, pR);
        pmax = std::max(pL, pR);
        qmax = pmax/pmin;
        
        if (qmax <= quser && pmin <= ppv && ppv <= pmax)
        {
            // Select PVRS Riemann solver.
            return ppv;
        }
        else if (ppv < pmin)
        {
            // Select two-rarefaction Riemann solver.
            NekDouble pq = pow(pL/pR, g[1]);
            NekDouble um = (pq*uL/cL + uR/cR + g[4]*(pq - 1.0))/(pq/cL + 1.0/cR);
            NekDouble ptL = 1.0 + g[7]*(uL - um)/cL;
            NekDouble ptR = 1.0 + g[7]*(um - uR)/cR;
            return 0.5*(pL*pow(ptL, g[3]) + pR*pow(ptR, g[3]));
        }
        else
        {
            // Select two-shock Riemann solver with PVRS as estimate.
            NekDouble geL = sqrt((g[5]/rhoL)/(g[6]*pL + ppv));
            NekDouble geR = sqrt((g[5]/rhoR)/(g[6]*pR + ppv));
            return (geL*pL + geR*pR - (uR - uL))/(geL + geR);
        }
    }

References tinysimd::sqrt().

Referenced by Nektar::ExactSolverToro::v_PointSolve().

hash_combine() [1/3]

template<typename T , typename... Args>

std::size_t Nektar::hash_combine ( const T &  v, Args...  args  )

inline

Definition at line 60 of file HashUtils.hpp.

{
    boost::ignore_unused(v);
    std::size_t seed = 0;
    hash_combine(seed, args...);
    return seed;
}

References hash_combine().

hash_combine() [2/3]

void Nektar::hash_combine ( std::size_t &  seed )

inline

Definition at line 46 of file HashUtils.hpp.

{
    boost::ignore_unused(seed);
}

Referenced by Nektar::SpatialDomains::GeomFactors::GetHash(), Nektar::MultiRegions::GlobalLinSysKey::GlobalLinSysKey(), hash_combine(), hash_range(), Nektar::PairHash::operator()(), Nektar::FieldUtils::TriFaceHash::operator()(), VertexHash::operator()(), and Nektar::StdRegions::StdMatrixKey::StdMatrixKey().

hash_combine() [3/3]

template<typename T , typename... Args>

void Nektar::hash_combine ( std::size_t &  seed, const T &  v, Args...  args  )

inline

Definition at line 52 of file HashUtils.hpp.

{
    std::hash<T> hasher;
    seed ^= hasher(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
    hash_combine(seed, args...);
}

References hash_combine().

hash_range() [1/2]

template<typename Iter >

std::size_t Nektar::hash_range	(	Iter	first,
		Iter	last
	)

Definition at line 69 of file HashUtils.hpp.

{
    std::size_t seed = 0;
    for(; first != last; ++first)
    {
        hash_combine(seed, *first);
    }
    return seed;
}

References hash_combine().

Referenced by Nektar::MultiRegions::AssemblyMapCG::AssemblyMapCG(), Nektar::MultiRegions::AssemblyMapDG::AssemblyMapDG(), Nektar::CoupledAssemblyMap::CoupledAssemblyMap(), Nektar::SpatialDomains::GeomFactors::GetHash(), Nektar::MultiRegions::GlobalLinSysKey::GlobalLinSysKey(), hash_range(), Nektar::SpatialDomains::GeometryHash::operator()(), and Nektar::StdRegions::StdMatrixKey::StdMatrixKey().

hash_range() [2/2]

template<typename Iter >

void Nektar::hash_range	(	std::size_t &	seed,
		Iter	first,
		Iter	last
	)

Definition at line 80 of file HashUtils.hpp.

{
    hash_combine(seed, hash_range(first, last));
}

References hash_combine(), and hash_range().

InfinityNorm() [1/3]

template<typename DataType >

DataType Nektar::InfinityNorm

(

const NekVector< DataType > &

v

)

Definition at line 1148 of file NekVector.cpp.

    {
        DataType result = fabs(v[0]);
        const unsigned int vdim = v.GetDimension();
        for(unsigned int i = 0; i < vdim; ++i)
        {
            result = std::max(DataType(fabs(v[i])), result);
        }
        return result;
    }

References Nektar::NekVector< DataType >::GetDimension().

Referenced by Nektar::NekVector< DataType >::InfinityNorm().

InfinityNorm() [2/3]

template NekDouble Nektar::InfinityNorm

(

const NekVector< NekDouble > &

v

)

InfinityNorm() [3/3]

template NekSingle Nektar::InfinityNorm

(

const NekVector< NekSingle > &

v

)

InvertInPlace() [1/2]

void Nektar::InvertInPlace

(

NekDouble &

v

)

Definition at line 1257 of file NekVector.cpp.

{ v = 1.0/v; }

InvertInPlace() [2/2]

void Nektar::InvertInPlace

(

NekSingle &

v

)

Definition at line 1263 of file NekVector.cpp.

{ v = 1.0/v; }

IsEqual()

template<typename T >

bool Nektar::IsEqual ( const T &  lhs, const T &  rhs  )

inline

Definition at line 744 of file SharedArray.hpp.

    {
        return IsEqualImpl(lhs, rhs, std::is_floating_point<T>());
    }

References IsEqualImpl().

Referenced by operator==().

IsEqualImpl() [1/2]

template<typename T >

bool Nektar::IsEqualImpl ( const T &  lhs, const T &  rhs, std::false_type    )

inline

Definition at line 731 of file SharedArray.hpp.

    {
        return lhs == rhs;
    }

Referenced by IsEqual().

IsEqualImpl() [2/2]

template<typename T >

bool Nektar::IsEqualImpl ( const T &  lhs, const T &  rhs, std::true_type    )

inline

Definition at line 738 of file SharedArray.hpp.

    {
        return LibUtilities::IsRealEqual(lhs, rhs);
    }

References Nektar::LibUtilities::IsRealEqual().

L1Norm() [1/3]

template<typename DataType >

DataType Nektar::L1Norm

(

const NekVector< DataType > &

v

)

Todo:

Do the Norms with Blas where applicable.

Definition at line 1108 of file NekVector.cpp.

    {
        typedef NekVector<DataType> VectorType;
 
        DataType result(0);
        for(typename VectorType::const_iterator iter = v.begin(); iter != v.end(); ++iter)
        {
            result += fabs(*iter);
        }
 
        return result;
    }

References Nektar::NekVector< DataType >::begin(), and Nektar::NekVector< DataType >::end().

Referenced by Nektar::NekVector< DataType >::L1Norm().

L1Norm() [2/3]

template NekDouble Nektar::L1Norm

(

const NekVector< NekDouble > &

v

)

L1Norm() [3/3]

template NekSingle Nektar::L1Norm

(

const NekVector< NekSingle > &

v

)

L2Norm() [1/3]

template<typename DataType >

DataType Nektar::L2Norm

(

const NekVector< DataType > &

v

)

Definition at line 1128 of file NekVector.cpp.

    {
        typedef NekVector<DataType> VectorType;
 
        DataType result(0);
        for(typename VectorType::const_iterator iter = v.begin(); iter != v.end(); ++iter)
        {
            DataType v = fabs(*iter);
            result += v*v;
        }
        return sqrt(result);
    }

References Nektar::NekVector< DataType >::begin(), Nektar::NekVector< DataType >::end(), and tinysimd::sqrt().

Referenced by Nektar::NekVector< DataType >::L2Norm().

L2Norm() [2/3]

template NekDouble Nektar::L2Norm

(

const NekVector< NekDouble > &

v

)

L2Norm() [3/3]

template NekSingle Nektar::L2Norm

(

const NekVector< NekSingle > &

v

)

Magnitude() [1/3]

template<typename DataType >

DataType Nektar::Magnitude

(

const NekVector< DataType > &

v

)

Definition at line 1201 of file NekVector.cpp.

    {
        DataType result = DataType(0);
 
        const unsigned int vdim = v.GetDimension();
        for(unsigned int i = 0; i < vdim; ++i)
        {
            result += v[i]*v[i];
        }
        return sqrt(result);
    }

References Nektar::NekVector< DataType >::GetDimension(), and tinysimd::sqrt().

Referenced by Nektar::NekVector< DataType >::Magnitude().

Magnitude() [2/3]

template NekDouble Nektar::Magnitude

(

const NekVector< NekDouble > &

v

)

Magnitude() [3/3]

template NekSingle Nektar::Magnitude

(

const NekVector< NekSingle > &

v

)

MappingIdealToRef()

DNekMat Nektar::MappingIdealToRef ( SpatialDomains::GeometrySharedPtr  geom )

inline

Definition at line 75 of file LinearElasticSystem.cpp.

{
    int n = geom->GetNumVerts(), i, j;
 
    DNekMat map   (n, n, 1.0, eFULL);
    DNekMat mapref(n, n, 1.0, eFULL);
 
    // Extract coordinate information.
    for (i = 0; i < n; ++i)
    {
        for (j = 0; j < n-1; ++j)
        {
            map(j,i) = (*geom->GetVertex(i))[j];
        }
    }
 
    // Set up reference triangle or tetrahedron mapping.
    if (n == 3)
    {
        mapref(0,0) = -1.0; mapref(1,0) = -1.0;
        mapref(0,1) =  1.0; mapref(1,1) = -1.0;
        mapref(0,2) = -1.0; mapref(1,2) =  1.0;
    }
    else if (n == 4)
    {
        mapref(0,0) = -1.0; mapref(1,0) = -1.0; mapref(2,0) = -1.0;
        mapref(0,1) =  1.0; mapref(1,1) = -1.0; mapref(2,1) = -1.0;
        mapref(0,2) = -1.0; mapref(1,2) =  1.0; mapref(2,2) = -1.0;
        mapref(0,3) = -1.0; mapref(1,3) = -1.0; mapref(2,3) =  1.0;
    }
 
    map.Invert();
 
    DNekMat newmap = mapref * map;
    DNekMat mapred(n-1, n-1, 1.0, eFULL);
 
    for (i = 0; i < n-1; ++i)
    {
        for (j = 0; j < n-1; ++j)
        {
            mapred(i,j) = newmap(i,j);
        }
    }
 
    return mapred;
}

References eFULL.

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

Multiply() [1/36]

template<typename DataType , typename RhsDataType , typename RhsMatrixType >

SNekMat const NekSingle NekMatrix<typename NekMatrix<RhsDataType, RhsMatrixType>::NumberType, StandardMatrixTag> Nektar::Multiply	(	const DataType &	lhs,
		const NekMatrix< RhsDataType, RhsMatrixType > &	rhs
	)

Definition at line 94 of file MatrixOperations.cpp.

    {
        return Multiply(rhs, lhs);
    }

References Multiply().

Multiply() [2/36]

template<typename DataType , typename RhsDataType , typename RhsMatrixType >

NekMatrix<typename NekMatrix<RhsDataType, RhsMatrixType>::NumberType, StandardMatrixTag> Nektar::Multiply	(	const DataType &	lhs,
		const NekMatrix< RhsDataType, RhsMatrixType > &	rhs
	)

Definition at line 94 of file MatrixOperations.cpp.

    {
        return Multiply(rhs, lhs);
    }

References Multiply().

Multiply() [3/36]

template<typename DataType >

NekVector< DataType > Nektar::Multiply	(	const DataType &	lhs,
		const NekVector< DataType > &	rhs
	)

Definition at line 975 of file NekVector.cpp.

    {
                return Multiply(rhs, lhs);
    }

References Multiply().

Multiply() [4/36]

template NekVector<NekDouble> Nektar::Multiply	(	const NekDouble &	lhs,
		const NekVector< NekDouble > &	rhs
	)

Multiply() [5/36]

template<typename DataType , typename LhsDataType , typename LhsMatrixType >

SNekMat const NekSingle& NekMatrix<typename NekMatrix<LhsDataType, LhsMatrixType>::NumberType, StandardMatrixTag> Nektar::Multiply	(	const NekMatrix< LhsDataType, LhsMatrixType > &	lhs,
		const DataType &	rhs
	)

Definition at line 64 of file MatrixOperations.cpp.

    {
        typedef typename NekMatrix<LhsDataType, LhsMatrixType>::NumberType ResultDataType;
        NekMatrix<ResultDataType, StandardMatrixTag> result(lhs.GetRows(), lhs.GetColumns());
        Multiply(result, lhs, rhs);
        return result;
    }

References Multiply().

Multiply() [6/36]

template<typename DataType , typename LhsDataType , typename LhsMatrixType >

NekMatrix<typename NekMatrix<LhsDataType, LhsMatrixType>::NumberType, StandardMatrixTag> Nektar::Multiply	(	const NekMatrix< LhsDataType, LhsMatrixType > &	lhs,
		const DataType &	rhs
	)

Definition at line 64 of file MatrixOperations.cpp.

    {
        typedef typename NekMatrix<LhsDataType, LhsMatrixType>::NumberType ResultDataType;
        NekMatrix<ResultDataType, StandardMatrixTag> result(lhs.GetRows(), lhs.GetColumns());
        Multiply(result, lhs, rhs);
        return result;
    }

References Multiply().

Multiply() [7/36]

template<typename LhsDataType , typename RhsDataType , typename LhsMatrixType , typename RhsMatrixType >

NekMatrix<typename std::remove_const< typename NekMatrix<LhsDataType, LhsMatrixType>::NumberType>::type, StandardMatrixTag> Nektar::Multiply	(	const NekMatrix< LhsDataType, LhsMatrixType > &	lhs,
		const NekMatrix< RhsDataType, RhsMatrixType > &	rhs
	)

Definition at line 268 of file MatrixOperations.hpp.

{
    typedef typename std::remove_const<
        typename NekMatrix<LhsDataType, LhsMatrixType>::NumberType>::type
        NumberType;
    NekMatrix<NumberType, StandardMatrixTag> result(lhs.GetRows(),
                                                    rhs.GetColumns());
    Multiply(result, lhs, rhs);
    return result;
}

References Multiply().

Multiply() [8/36]

template<typename DataType , typename LhsDataType , typename MatrixType >

NekVector<DataType> Nektar::Multiply	(	const NekMatrix< LhsDataType, MatrixType > &	lhs,
		const NekVector< DataType > &	rhs
	)

Definition at line 602 of file MatrixVectorMultiplication.cpp.

    {
       NekVector<DataType> result(lhs.GetRows(), DataType(0));
       Multiply(result, lhs, rhs);
       return result;
    }

References Multiply().

Multiply() [9/36]

template<typename DataType , typename LhsDataType , typename MatrixType >

NekVector<NekSingle> const NekVector<NekSingle>& NekVector<DataType> Nektar::Multiply	(	const NekMatrix< LhsDataType, MatrixType > &	lhs,
		const NekVector< DataType > &	rhs
	)

Definition at line 602 of file MatrixVectorMultiplication.cpp.

    {
       NekVector<DataType> result(lhs.GetRows(), DataType(0));
       Multiply(result, lhs, rhs);
       return result;
    }

References Multiply().

Multiply() [10/36]

template NekVector<NekSingle> Nektar::Multiply	(	const NekSingle &	lhs,
		const NekVector< NekSingle > &	rhs
	)

Multiply() [11/36]

template<typename DataType >

NekVector< DataType > Nektar::Multiply	(	const NekVector< DataType > &	lhs,
		const NekDouble &	rhs
	)

Definition at line 878 of file NekVector.cpp.

    {
        NekVector<DataType> result(lhs.GetDimension());
        Multiply(result, lhs, rhs);
        return result;
    }

References Nektar::NekVector< DataType >::GetDimension(), and Multiply().

Multiply() [12/36]

template<typename DataType >

NekVector<DataType> Nektar::Multiply	(	const NekVector< DataType > &	lhs,
		const NekSingle &	rhs
	)

Definition at line 888 of file NekVector.cpp.

    {
        NekVector<DataType> result(lhs.GetDimension());
        Multiply(result, lhs, rhs);
        return result;
    }

References Nektar::NekVector< DataType >::GetDimension(), and Multiply().

Multiply() [13/36]

template<typename DataType , typename InputDataType >

NekVector< DataType > Nektar::Multiply	(	const NekVector< DataType > &	lhs,
		const NekVector< InputDataType > &	rhs
	)

Definition at line 788 of file NekVector.cpp.

    {
        NekVector<DataType> result(lhs.GetDimension());
        Multiply(result, lhs, rhs);
        return result;
    }

References Nektar::NekVector< DataType >::GetDimension(), and Multiply().

Multiply() [14/36]

template NekVector<NekDouble> Nektar::Multiply	(	const NekVector< NekDouble > &	lhs,
		const NekDouble &	rhs
	)

Multiply() [15/36]

template NekVector<NekDouble> Nektar::Multiply	(	const NekVector< NekDouble > &	lhs,
		const NekVector< NekDouble > &	rhs
	)

Multiply() [16/36]

template NekVector<NekSingle> Nektar::Multiply	(	const NekVector< NekSingle > &	lhs,
		const NekSingle &	rhs
	)

Multiply() [17/36]

template NekVector<NekSingle> Nektar::Multiply	(	const NekVector< NekSingle > &	lhs,
		const NekVector< NekSingle > &	rhs
	)

Multiply() [18/36]

template<typename DataType , typename LhsDataType , typename MatrixType >

void Nektar::Multiply	(	DataType *	result,
		const NekMatrix< LhsDataType, MatrixType > &	lhs,
		const DataType *	rhs
	)

Definition at line 534 of file MatrixVectorMultiplication.cpp.

    {
        switch(lhs.GetType())
        {
            case eFULL:
                NekMultiplyFullMatrix(result, lhs, rhs);
                break;
            case eDIAGONAL:
                NekMultiplyDiagonalMatrix(result, lhs, rhs);
                break;
            case eUPPER_TRIANGULAR:
                NekMultiplyUpperTriangularMatrix(result, lhs, rhs);
                break;
            case eLOWER_TRIANGULAR:
                NekMultiplyLowerTriangularMatrix(result, lhs, rhs);
                break;
            case eSYMMETRIC:
                NekMultiplySymmetricMatrix(result, lhs, rhs);
                break;
            case eBANDED:
                NekMultiplyBandedMatrix(result, lhs, rhs);
                break;
            case eSYMMETRIC_BANDED:
            case eUPPER_TRIANGULAR_BANDED:
            case eLOWER_TRIANGULAR_BANDED:
            default:
                NekMultiplyUnspecializedMatrixType(result, lhs, rhs);
        } 
    }

References eBANDED, eDIAGONAL, eFULL, eLOWER_TRIANGULAR, eLOWER_TRIANGULAR_BANDED, eSYMMETRIC, eSYMMETRIC_BANDED, eUPPER_TRIANGULAR, eUPPER_TRIANGULAR_BANDED, NekMultiplyBandedMatrix(), NekMultiplyDiagonalMatrix(), NekMultiplyFullMatrix(), NekMultiplyLowerTriangularMatrix(), NekMultiplySymmetricMatrix(), NekMultiplyUnspecializedMatrixType(), and NekMultiplyUpperTriangularMatrix().

Multiply() [19/36]

template<typename LhsDataType , typename RhsDataType , typename DataType , typename LhsMatrixType , typename RhsMatrixType >

void Nektar::Multiply	(	NekMatrix< DataType, StandardMatrixTag > &	result,
		const NekMatrix< LhsDataType, LhsMatrixType > &	lhs,
		const NekMatrix< RhsDataType, RhsMatrixType > &	rhs
	)

Definition at line 159 of file MatrixOperations.cpp.

    {
        ASSERTL1(lhs.GetColumns() == rhs.GetRows(), std::string("A left side matrix with column count ") + 
            std::to_string(lhs.GetColumns()) + 
            std::string(" and a right side matrix with row count ") + 
            std::to_string(rhs.GetRows()) + std::string(" can't be multiplied."));
 
        result.SetSize(lhs.GetRows(), rhs.GetColumns());
        if( lhs.GetType() == eFULL && rhs.GetType() == eFULL)
        {
            NekMultiplyFullMatrixFullMatrix(result, lhs, rhs);
        }
        else
        {
            NekMultiplyDefaultImpl(result, lhs, rhs);
        }
    }

References ASSERTL1, eFULL, NekMultiplyDefaultImpl(), NekMultiplyFullMatrixFullMatrix(), and Nektar::NekMatrix< DataType, StandardMatrixTag >::SetSize().

Multiply() [20/36]

template<typename ResultDataType , typename LhsDataType , typename LhsMatrixType >

void Nektar::Multiply	(	NekMatrix< ResultDataType, StandardMatrixTag > &	result,
		const NekMatrix< LhsDataType, LhsMatrixType > &	lhs,
		const ResultDataType &	rhs
	)

Definition at line 41 of file MatrixOperations.cpp.

    {
        // TODO - optimize for the different matrix types.
        int n = lhs.GetRows();
        int m = lhs.GetColumns();
        for(unsigned int i = 0; i < n; ++i)
        {
            for(unsigned int j = 0; j < m; ++j)
            {
                result(i,j) = lhs(i,j)*rhs;
            }
        }
    }

Referenced by Nektar::PulseWaveSystem::BifurcationRiemann(), DiagonalBlockMatrixMultiply(), FullBlockMatrixMultiply(), Nektar::PulseWaveSystem::JunctionRiemann(), Nektar::PulseWaveSystem::MergingRiemann(), Multiply(), operator*(), and Nektar::MultiRegions::GlobalLinSysStaticCond::v_Solve().

Multiply() [21/36]

template<typename RhsDataType , typename RhsMatrixType , typename ResultDataType >

const NekSingle& void Nektar::Multiply	(	NekMatrix< ResultDataType, StandardMatrixTag > &	result,
		const ResultDataType &	lhs,
		const NekMatrix< RhsDataType, RhsMatrixType > &	rhs
	)

Definition at line 79 of file MatrixOperations.cpp.

    {
        Multiply(result, rhs, lhs);
    }

References Multiply().

Multiply() [22/36]

template<typename RhsDataType , typename RhsMatrixType , typename ResultDataType >

void Nektar::Multiply	(	NekMatrix< ResultDataType, StandardMatrixTag > &	result,
		const ResultDataType &	lhs,
		const NekMatrix< RhsDataType, RhsMatrixType > &	rhs
	)

Definition at line 79 of file MatrixOperations.cpp.

    {
        Multiply(result, rhs, lhs);
    }

References Multiply().

Multiply() [23/36]

template<typename DataType , typename LhsDataType , typename MatrixType >

void Nektar::Multiply	(	NekVector< DataType > &	result,
		const NekMatrix< LhsDataType, MatrixType > &	lhs,
		const NekVector< DataType > &	rhs
	)

Definition at line 567 of file MatrixVectorMultiplication.cpp.

    {
                       
        ASSERTL1(lhs.GetColumns() == rhs.GetRows(), std::string("A left side matrix with column count ") + 
            std::to_string(lhs.GetColumns()) + 
            std::string(" and a right side vector with row count ") + 
            std::to_string(rhs.GetRows()) + std::string(" can't be multiplied."));
        Multiply(result.GetRawPtr(), lhs, rhs.GetRawPtr());
    }

References ASSERTL1, Nektar::NekVector< DataType >::GetRawPtr(), Nektar::NekVector< DataType >::GetRows(), and Multiply().

Multiply() [24/36]

template<typename DataType , typename LhsInnerMatrixType >

void Nektar::Multiply	(	NekVector< DataType > &	result,
		const NekMatrix< LhsInnerMatrixType, BlockMatrixTag > &	lhs,
		const NekVector< DataType > &	rhs
	)

Definition at line 583 of file MatrixVectorMultiplication.cpp.

    {
        if( lhs.GetStorageType() == eDIAGONAL )
        {
            DiagonalBlockMatrixMultiply(result, lhs, rhs);
        }
        else
        {
            FullBlockMatrixMultiply(result, lhs, rhs);
        }
    }

References DiagonalBlockMatrixMultiply(), eDIAGONAL, and FullBlockMatrixMultiply().

Multiply() [25/36]

template<typename DataType , typename LhsInnerMatrixType >

NekVector<NekSingle> const NekVector<NekSingle>& void Nektar::Multiply	(	NekVector< DataType > &	result,
		const NekMatrix< LhsInnerMatrixType, BlockMatrixTag > &	lhs,
		const NekVector< DataType > &	rhs
	)

Definition at line 583 of file MatrixVectorMultiplication.cpp.

    {
        if( lhs.GetStorageType() == eDIAGONAL )
        {
            DiagonalBlockMatrixMultiply(result, lhs, rhs);
        }
        else
        {
            FullBlockMatrixMultiply(result, lhs, rhs);
        }
    }

References DiagonalBlockMatrixMultiply(), eDIAGONAL, and FullBlockMatrixMultiply().

Multiply() [26/36]

template void Nektar::Multiply	(	NekVector< NekDouble > &	result,
		const NekDouble &	lhs,
		const NekVector< NekDouble > &	rhs
	)

Multiply() [27/36]

template void Nektar::Multiply	(	NekVector< NekDouble > &	result,
		const NekVector< NekDouble > &	lhs,
		const NekDouble &	rhs
	)

Multiply() [28/36]

template void Nektar::Multiply	(	NekVector< NekDouble > &	result,
		const NekVector< NekDouble > &	lhs,
		const NekVector< NekDouble > &	rhs
	)

Multiply() [29/36]

template void Nektar::Multiply	(	NekVector< NekSingle > &	result,
		const NekSingle &	lhs,
		const NekVector< NekSingle > &	rhs
	)

Multiply() [30/36]

template void Nektar::Multiply	(	NekVector< NekSingle > &	result,
		const NekVector< NekSingle > &	lhs,
		const NekSingle &	rhs
	)

Multiply() [31/36]

template void Nektar::Multiply	(	NekVector< NekSingle > &	result,
		const NekVector< NekSingle > &	lhs,
		const NekVector< NekSingle > &	rhs
	)

Multiply() [32/36]

template<typename ResultDataType , typename InputDataType >

void Nektar::Multiply	(	NekVector< ResultDataType > &	result,
		const NekDouble &	lhs,
		const NekVector< InputDataType > &	rhs
	)

Definition at line 907 of file NekVector.cpp.

    {
                Multiply(result, rhs, lhs);
    }

References Multiply().

Multiply() [33/36]

template<typename ResultDataType , typename InputDataType >

void Nektar::Multiply	(	NekVector< ResultDataType > &	result,
		const NekSingle &	lhs,
		const NekVector< InputDataType > &	rhs
	)

Definition at line 931 of file NekVector.cpp.

    {
                Multiply(result, rhs, lhs);
    }

References Multiply().

Multiply() [34/36]

template<typename ResultDataType , typename InputDataType >

void Nektar::Multiply	(	NekVector< ResultDataType > &	result,
		const NekVector< InputDataType > &	lhs,
		const NekDouble &	rhs
	)

Definition at line 806 of file NekVector.cpp.

    {
        ResultDataType* r_buf = result.GetRawPtr();
        const InputDataType* lhs_buf = lhs.GetRawPtr();
 
        const unsigned int ldim = lhs.GetDimension();
        for(int i = 0; i < ldim; ++i)
        {
            r_buf[i] = lhs_buf[i] * rhs;
        }
    }

References Nektar::NekVector< DataType >::GetDimension(), and Nektar::NekVector< DataType >::GetRawPtr().

Multiply() [35/36]

template<typename ResultDataType , typename InputDataType >

void Nektar::Multiply	(	NekVector< ResultDataType > &	result,
		const NekVector< InputDataType > &	lhs,
		const NekSingle &	rhs
	)

Definition at line 821 of file NekVector.cpp.

    {
        ResultDataType* r_buf = result.GetRawPtr();
        const InputDataType* lhs_buf = lhs.GetRawPtr();
 
        const unsigned int ldim = lhs.GetDimension();
        for(int i = 0; i < ldim; ++i)
        {
            r_buf[i] = lhs_buf[i] * rhs;
        }
    }

References Nektar::NekVector< DataType >::GetDimension(), and Nektar::NekVector< DataType >::GetRawPtr().

Multiply() [36/36]

template<typename ResultDataType , typename InputDataType >

void Nektar::Multiply	(	NekVector< ResultDataType > &	result,
		const NekVector< InputDataType > &	lhs,
		const NekVector< InputDataType > &	rhs
	)

Definition at line 747 of file NekVector.cpp.

    {
        ResultDataType* result_buf = result.GetRawPtr();
        const InputDataType* rhs_buf = rhs.GetRawPtr();
        const InputDataType* lhs_buf = lhs.GetRawPtr();
        const unsigned int resdim = result.GetDimension();
        for(int i = 0; i < resdim; ++i)
        {
            result_buf[i] = lhs_buf[i] * rhs_buf[i];
        }
    }

References Nektar::NekVector< DataType >::GetDimension(), and Nektar::NekVector< DataType >::GetRawPtr().

MultiplyEqual() [1/11]

template<typename DataType , typename RhsInnerType , typename RhsMatrixType >

void Nektar::MultiplyEqual	(	NekMatrix< DataType, StandardMatrixTag > &	result,
		const NekMatrix< RhsInnerType, RhsMatrixType > &	rhs,
		typename std::enable_if< !std::is_same< RawType_t< typename NekMatrix< RhsInnerType, RhsMatrixType >::NumberType >, DataType >::value||!CanGetRawPtr< NekMatrix< RhsInnerType, RhsMatrixType >>::value >::type *	t = 0
	)

Definition at line 225 of file MatrixOperations.hpp.

{
    boost::ignore_unused(t);
    ASSERTL1(result.GetColumns() == rhs.GetRows(),
             std::string("A left side matrix with column count ") +
                 std::to_string(result.GetColumns()) +
                 std::string(" and a right side matrix with row count ") +
                 std::to_string(rhs.GetRows()) +
                 std::string(" can't be multiplied."));
    NekMatrix<DataType, StandardMatrixTag> temp(result.GetRows(),
                                                result.GetColumns());
 
    for (unsigned int i = 0; i < result.GetRows(); ++i)
    {
        for (unsigned int j = 0; j < result.GetColumns(); ++j)
        {
            DataType t = DataType(0);
 
            // Set the result(i,j) element.
            for (unsigned int k = 0; k < result.GetColumns(); ++k)
            {
                t += result(i, k) * rhs(k, j);
            }
            temp(i, j) = t;
        }
    }
 
    result = temp;
}

References ASSERTL1, Nektar::ConstMatrix< DataType >::GetColumns(), and Nektar::ConstMatrix< DataType >::GetRows().

MultiplyEqual() [2/11]

template<typename LhsDataType >

const NekSingle void Nektar::MultiplyEqual	(	NekMatrix< LhsDataType, StandardMatrixTag > &	lhs,
		typename boost::call_traits< LhsDataType >::const_reference	rhs
	)

Definition at line 107 of file MatrixOperations.cpp.

    {
        typedef typename NekMatrix<LhsDataType, StandardMatrixTag>::iterator iterator;
        for( iterator iter = lhs.begin(); iter != lhs.end(); ++iter)
        {
            *iter *= rhs;
        }
    }

Referenced by Nektar::NekVector< DataType >::operator*=().

MultiplyEqual() [3/11]

template<typename LhsDataType >

void Nektar::MultiplyEqual	(	NekMatrix< LhsDataType, StandardMatrixTag > &	lhs,
		typename boost::call_traits< LhsDataType >::const_reference	rhs
	)

Definition at line 107 of file MatrixOperations.cpp.

    {
        typedef typename NekMatrix<LhsDataType, StandardMatrixTag>::iterator iterator;
        for( iterator iter = lhs.begin(); iter != lhs.end(); ++iter)
        {
            *iter *= rhs;
        }
    }

Referenced by Nektar::NekVector< DataType >::operator*=().

MultiplyEqual() [4/11]

template<typename RhsInnerType , typename RhsMatrixType >

void Nektar::MultiplyEqual	(	NekMatrix< RhsInnerType, StandardMatrixTag > &	result,
		const NekMatrix< RhsInnerType, RhsMatrixType > &	rhs,
		typename std::enable_if< std::is_same< RawType_t< typename NekMatrix< RhsInnerType, RhsMatrixType >::NumberType >, RhsInnerType >::value &&CanGetRawPtr< NekMatrix< RhsInnerType, RhsMatrixType >>::value >::type *	t = 0
	)

Definition at line 187 of file MatrixOperations.hpp.

{
    boost::ignore_unused(t);
    ASSERTL0(result.GetType() == eFULL && rhs.GetType() == eFULL,
             "Only full matrices supported.");
    unsigned int M = result.GetRows();
    unsigned int N = rhs.GetColumns();
    unsigned int K = result.GetColumns();
 
    unsigned int LDA = M;
    if (result.GetTransposeFlag() == 'T')
    {
        LDA = K;
    }
 
    unsigned int LDB = K;
    if (rhs.GetTransposeFlag() == 'T')
    {
        LDB = N;
    }
    RhsInnerType scale = rhs.Scale();
    Array<OneD, RhsInnerType> &buf = result.GetTempSpace();
    Blas::Gemm(result.GetTransposeFlag(), rhs.GetTransposeFlag(), M, N, K,
                scale, result.GetRawPtr(), LDA, rhs.GetRawPtr(), LDB, 0.0,
                buf.data(), result.GetRows());
    result.SetSize(result.GetRows(), rhs.GetColumns());
    result.SwapTempAndDataBuffers();
}

References ASSERTL0, eFULL, and Blas::Gemm().

MultiplyEqual() [5/11]

template void Nektar::MultiplyEqual	(	NekVector< NekDouble > &	result,
		const NekDouble &	rhs
	)

MultiplyEqual() [6/11]

template void Nektar::MultiplyEqual	(	NekVector< NekDouble > &	result,
		const NekVector< NekDouble > &	rhs
	)

MultiplyEqual() [7/11]

template void Nektar::MultiplyEqual	(	NekVector< NekSingle > &	result,
		const NekSingle &	rhs
	)

MultiplyEqual() [8/11]

template void Nektar::MultiplyEqual	(	NekVector< NekSingle > &	result,
		const NekVector< NekSingle > &	rhs
	)

MultiplyEqual() [9/11]

template<typename ResultDataType >

void Nektar::MultiplyEqual	(	NekVector< ResultDataType > &	result,
		const NekDouble &	rhs
	)

Definition at line 846 of file NekVector.cpp.

    {
        ResultDataType* r_buf = result.GetRawPtr();
        const unsigned int rdim = result.GetDimension();
        for(unsigned int i = 0; i < rdim; ++i)
        {
            r_buf[i] *= rhs;
        }
    }

References Nektar::NekVector< DataType >::GetDimension(), and Nektar::NekVector< DataType >::GetRawPtr().

MultiplyEqual() [10/11]

template<typename ResultDataType >

void Nektar::MultiplyEqual	(	NekVector< ResultDataType > &	result,
		const NekSingle &	rhs
	)

Definition at line 858 of file NekVector.cpp.

    {
        ResultDataType* r_buf = result.GetRawPtr();
        const unsigned int rdim = result.GetDimension();
        for(unsigned int i = 0; i < rdim; ++i)
        {
            r_buf[i] *= rhs;
        }
    }

References Nektar::NekVector< DataType >::GetDimension(), and Nektar::NekVector< DataType >::GetRawPtr().

MultiplyEqual() [11/11]

template<typename ResultDataType , typename InputDataType >

void Nektar::MultiplyEqual	(	NekVector< ResultDataType > &	result,
		const NekVector< InputDataType > &	rhs
	)

Definition at line 768 of file NekVector.cpp.

    {
        ResultDataType* result_buf = result.GetRawPtr();
        const InputDataType* rhs_buf = rhs.GetRawPtr();
        const unsigned int resdim = result.GetDimension();
        for(int i = 0; i < resdim; ++i)
        {
            result_buf[i] *= rhs_buf[i];
        }
    }

References Nektar::NekVector< DataType >::GetDimension(), and Nektar::NekVector< DataType >::GetRawPtr().

MultiplyInvertedLhs() [1/4]

template void Nektar::MultiplyInvertedLhs	(	NekVector< NekDouble > &	result,
		const NekDouble &	lhs,
		const NekVector< NekDouble > &	rhs
	)

MultiplyInvertedLhs() [2/4]

template void Nektar::MultiplyInvertedLhs	(	NekVector< NekSingle > &	result,
		const NekSingle &	lhs,
		const NekVector< NekSingle > &	rhs
	)

MultiplyInvertedLhs() [3/4]

template<typename ResultDataType , typename InputDataType >

void Nektar::MultiplyInvertedLhs	(	NekVector< ResultDataType > &	result,
		const NekDouble &	lhs,
		const NekVector< InputDataType > &	rhs
	)

Definition at line 915 of file NekVector.cpp.

    {
        ResultDataType* r_buf = result.GetRawPtr();
        const InputDataType* rhs_buf = rhs.GetRawPtr();
        NekDouble inverse = 1.0/lhs;
 
        const unsigned int rdim = rhs.GetDimension();
        for(int i = 0; i < rdim; ++i)
        {
            r_buf[i] = inverse * rhs_buf[i];
        }
    }

References Nektar::NekVector< DataType >::GetDimension(), and Nektar::NekVector< DataType >::GetRawPtr().

MultiplyInvertedLhs() [4/4]

template<typename ResultDataType , typename InputDataType >

void Nektar::MultiplyInvertedLhs	(	NekVector< ResultDataType > &	result,
		const NekSingle &	lhs,
		const NekVector< InputDataType > &	rhs
	)

Definition at line 939 of file NekVector.cpp.

    {
        ResultDataType* r_buf = result.GetRawPtr();
        const InputDataType* rhs_buf = rhs.GetRawPtr();
        NekSingle inverse = 1.0/lhs;
 
        const unsigned int rdim = rhs.GetDimension();
        for(int i = 0; i < rdim; ++i)
        {
            r_buf[i] = inverse * rhs_buf[i];
        }
    }

References Nektar::NekVector< DataType >::GetDimension(), and Nektar::NekVector< DataType >::GetRawPtr().

Negate() [1/3]

template<typename DataType >

NekVector< DataType > Nektar::Negate

(

const NekVector< DataType > &

v

)

Definition at line 1166 of file NekVector.cpp.

    {
        NekVector<DataType> temp(v);
        const unsigned int tdim = temp.GetDimension();
        for(unsigned int i = 0; i < tdim; ++i)
        {
            temp(i) = -temp(i);
        }
        return temp;
    }

References Nektar::NekVector< DataType >::GetDimension().

Referenced by Nektar::NekVector< DataType >::operator-().

Negate() [2/3]

template NekVector<NekDouble> Nektar::Negate

(

const NekVector< NekDouble > &

v

)

Negate() [3/3]

template NekVector<NekSingle> Nektar::Negate

(

const NekVector< NekSingle > &

v

)

negate()

template<typename DataType >

void Nektar::negate

(

NekPoint< DataType > &

rhs

)

Definition at line 367 of file NekPoint.hpp.

    {
        rhs.negate();
    }

References Nektar::NekPoint< data_type >::negate().

NegateInPlace() [1/11]

void Nektar::NegateInPlace

(

NekDouble &

v

)

Definition at line 1256 of file NekVector.cpp.

{ v = -v; }

NegateInPlace() [2/11]

template<typename DataType >

void Nektar::NegateInPlace

(

NekMatrix< DataType, ScaledMatrixTag > &

v

)

Definition at line 238 of file ScaledMatrix.cpp.

    {
        v.SetScale(-1.0*v.Scale());
    }

NegateInPlace() [3/11]

template<typename DataType >

void Nektar::NegateInPlace

(

NekMatrix< DataType, StandardMatrixTag > &

m

)

Definition at line 834 of file StandardMatrix.cpp.

    {
        for(unsigned int i = 0; i < m.GetRows(); ++i)
        {
            for(unsigned int j = 0; j < m.GetColumns(); ++j)
            {
                m(i,j) *= -1.0;
            }
        }
    }

References Nektar::ConstMatrix< DataType >::GetColumns(), and Nektar::ConstMatrix< DataType >::GetRows().

NegateInPlace() [4/11]

template void Nektar::NegateInPlace

(

NekMatrix< double, StandardMatrixTag > &

v

)

NegateInPlace() [5/11]

template void Nektar::NegateInPlace

(

NekMatrix< NekMatrix< NekDouble, StandardMatrixTag >, ScaledMatrixTag > &

v

)

NegateInPlace() [6/11]

template void Nektar::NegateInPlace

(

NekMatrix< NekMatrix< NekSingle, StandardMatrixTag >, ScaledMatrixTag > &

v

)

NegateInPlace() [7/11]

template void Nektar::NegateInPlace

(

NekMatrix< NekSingle, StandardMatrixTag > &

v

)

NegateInPlace() [8/11]

void Nektar::NegateInPlace

(

NekSingle &

v

)

Definition at line 1262 of file NekVector.cpp.

{ v = -v; }

NegateInPlace() [9/11]

template<typename DataType >

void Nektar::NegateInPlace

(

NekVector< DataType > &

v

)

Definition at line 1184 of file NekVector.cpp.

    {
        DataType* data = v.GetRawPtr();
        const unsigned int vdim = v.GetDimension();
        for(unsigned int i = 0; i < vdim; ++i)
        {
            data[i] = -data[i];
        }
    }

References Nektar::NekVector< DataType >::GetDimension(), and Nektar::NekVector< DataType >::GetRawPtr().

Referenced by Nektar::NekMatrix< DataType, StandardMatrixTag >::operator-().

NegateInPlace() [10/11]

template void Nektar::NegateInPlace

(

NekVector< NekDouble > &

v

)

NegateInPlace() [11/11]

template void Nektar::NegateInPlace

(

NekVector< NekSingle > &

v

)

NekMultiplyBandedMatrix() [1/2]

template<typename DataType , typename LhsDataType >

void Nektar::NekMultiplyBandedMatrix	(	DataType *	result,
		const NekMatrix< LhsDataType, BlockMatrixTag > &	lhs,
		const DataType *	rhs,
		typename std::enable_if< !CanGetRawPtr< NekMatrix< LhsDataType, BlockMatrixTag > >::value >::type *	p = 0
	)

Definition at line 121 of file MatrixVectorMultiplication.cpp.

    {
        boost::ignore_unused(result, lhs, rhs, p);
 
        NEKERROR(ErrorUtil::efatal, "Banded block matrix multiplication not yet implemented");
    }

References Nektar::ErrorUtil::efatal, NEKERROR, and CellMLToNektar.cellml_metadata::p.

NekMultiplyBandedMatrix() [2/2]

template<typename DataType , typename LhsDataType , typename MatrixType >

void Nektar::NekMultiplyBandedMatrix	(	DataType *	result,
		const NekMatrix< LhsDataType, MatrixType > &	lhs,
		const DataType *	rhs,
		typename std::enable_if< CanGetRawPtr< NekMatrix< LhsDataType, MatrixType > >::value >::type *	p = 0
	)

Definition at line 96 of file MatrixVectorMultiplication.cpp.

    {
        boost::ignore_unused(p);
 
        int m  = lhs.GetRows();
        int n  = lhs.GetColumns();
        int kl = lhs.GetNumberOfSubDiagonals();
        int ku = lhs.GetNumberOfSuperDiagonals();
        DataType alpha = lhs.Scale();
        const DataType* a = lhs.GetRawPtr();
        int lda = kl + ku + 1;
        const DataType* x = rhs;
        int incx = 1;
        DataType beta = 0.0;
        DataType* y = result;
        int incy = 1;
        Blas::Gbmv('N', m, n, kl, ku, alpha, a, lda, x, incx, beta, y, incy);
 
    }

References Blas::Gbmv(), and CellMLToNektar.cellml_metadata::p.

Referenced by Multiply().

NekMultiplyDefaultImpl()

template<typename ResultType , typename LhsDataType , typename RhsDataType , typename LhsMatrixType , typename RhsMatrixType >

SNekMat const NekSingle& void Nektar::NekMultiplyDefaultImpl	(	NekMatrix< ResultType, StandardMatrixTag > &	result,
		const NekMatrix< LhsDataType, LhsMatrixType > &	lhs,
		const NekMatrix< RhsDataType, RhsMatrixType > &	rhs
	)

Definition at line 123 of file MatrixOperations.cpp.

    {
        ASSERTL1(lhs.GetColumns() == rhs.GetRows(), std::string("A left side matrix with column count ") + 
            std::to_string(lhs.GetColumns()) + 
            std::string(" and a right side matrix with row count ") + 
            std::to_string(rhs.GetRows()) + std::string(" can't be multiplied."));
 
        for(unsigned int i = 0; i < result.GetRows(); ++i)
        {
            for(unsigned int j = 0; j < result.GetColumns(); ++j)
            {
                ResultType t = ResultType(0);
 
                // Set the result(i,j) element.
                for(unsigned int k = 0; k < lhs.GetColumns(); ++k)
                {
                    t += lhs(i,k)*rhs(k,j);
                }
                result(i,j) = t;
            }
        }
    }

References ASSERTL1.

Referenced by Multiply(), and NekMultiplyFullMatrixFullMatrix().

NekMultiplyDiagonalMatrix() [1/2]

template<typename DataType , typename LhsDataType , typename MatrixType >

void Nektar::NekMultiplyDiagonalMatrix	(	DataType *	result,
		const NekMatrix< LhsDataType, MatrixType > &	lhs,
		const DataType *	rhs
	)

Definition at line 74 of file MatrixVectorMultiplication.cpp.

    {
        int n = lhs.GetRows();
        for(unsigned int i = 0; i < n; ++i)
        {
            result[i] = lhs(i,i)*rhs[i];
        }
    }

Referenced by Multiply().

NekMultiplyDiagonalMatrix() [2/2]

template<typename DataType , typename LhsDataType >

void Nektar::NekMultiplyDiagonalMatrix	(	DataType *	result,
		const NekMatrix< LhsDataType, StandardMatrixTag > &	lhs,
		const DataType *	rhs
	)

Definition at line 86 of file MatrixVectorMultiplication.cpp.

    {
        int n = lhs.GetRows();
        const DataType* mat_ptr = lhs.GetRawPtr();
        Vmath::Vmul(n, mat_ptr, 1, rhs, 1, result, 1);
    }

References Vmath::Vmul().

NekMultiplyFullMatrix() [1/2]

template<typename DataType , typename InnerMatrixType , typename MatrixTag >

void Nektar::NekMultiplyFullMatrix	(	DataType *	result,
		const NekMatrix< InnerMatrixType, MatrixTag > &	lhs,
		const DataType *	rhs,
		typename std::enable_if< CanGetRawPtr< NekMatrix< InnerMatrixType, MatrixTag > >::value >::type *	p = 0
	)

Definition at line 503 of file MatrixVectorMultiplication.cpp.

    {
        boost::ignore_unused(p);
 
        const unsigned int* size = lhs.GetSize();
 
        char t = lhs.GetTransposeFlag();
 
        DataType alpha = lhs.Scale();
        const DataType* a = lhs.GetRawPtr();
        int lda = size[0];
        const DataType* x = rhs;
        int incx = 1;
        DataType beta = 0.0;
        DataType* y = result;
        int incy = 1;
        
        Blas::Gemv(t, size[0], size[1], alpha, a, lda, x, incx, beta, y, incy);
    }

References Blas::Gemv(), and CellMLToNektar.cellml_metadata::p.

Referenced by Multiply().

NekMultiplyFullMatrix() [2/2]

template<typename DataType , typename InnerMatrixType , typename MatrixTag >

void Nektar::NekMultiplyFullMatrix	(	DataType *	result,
		const NekMatrix< InnerMatrixType, MatrixTag > &	lhs,
		const DataType *	rhs,
		typename std::enable_if<!CanGetRawPtr< NekMatrix< InnerMatrixType, MatrixTag > >::value >::type *	p = 0
	)

Definition at line 525 of file MatrixVectorMultiplication.cpp.

    {
        boost::ignore_unused(p);
 
        NekMultiplyUnspecializedMatrixType(result, lhs, rhs);
    }

References NekMultiplyUnspecializedMatrixType(), and CellMLToNektar.cellml_metadata::p.

NekMultiplyFullMatrixFullMatrix() [1/2]

template<typename LhsDataType , typename RhsDataType , typename LhsMatrixType , typename RhsMatrixType >

void Nektar::NekMultiplyFullMatrixFullMatrix	(	NekMatrix< LhsDataType, StandardMatrixTag > &	result,
		const NekMatrix< LhsDataType, LhsMatrixType > &	lhs,
		const NekMatrix< RhsDataType, RhsMatrixType > &	rhs,
		typename std::enable_if< CanGetRawPtr< NekMatrix< LhsDataType, LhsMatrixType >>::value &&CanGetRawPtr< NekMatrix< RhsDataType, RhsMatrixType >>::value >::type *	p = 0
	)

Definition at line 144 of file MatrixOperations.hpp.

{
    boost::ignore_unused(p);
 
    ASSERTL1(lhs.GetType() == eFULL && rhs.GetType() == eFULL,
             "Only full matrices are supported.");
 
    unsigned int M = lhs.GetRows();
    unsigned int N = rhs.GetColumns();
    unsigned int K = lhs.GetColumns();
 
    unsigned int LDA = M;
    if (lhs.GetTransposeFlag() == 'T')
    {
        LDA = K;
    }
 
    unsigned int LDB = K;
    if (rhs.GetTransposeFlag() == 'T')
    {
        LDB = N;
    }
 
    Blas::Gemm(lhs.GetTransposeFlag(), rhs.GetTransposeFlag(), M, N, K,
                lhs.Scale() * rhs.Scale(), lhs.GetRawPtr(), LDA,
                rhs.GetRawPtr(), LDB, 0.0, result.GetRawPtr(),
                result.GetRows());
}

References ASSERTL1, eFULL, Blas::Gemm(), and CellMLToNektar.cellml_metadata::p.

NekMultiplyFullMatrixFullMatrix() [2/2]

template<typename ResultType , typename LhsDataType , typename RhsDataType , typename LhsMatrixType , typename RhsMatrixType >

void Nektar::NekMultiplyFullMatrixFullMatrix	(	NekMatrix< ResultType, StandardMatrixTag > &	result,
		const NekMatrix< LhsDataType, LhsMatrixType > &	lhs,
		const NekMatrix< RhsDataType, RhsMatrixType > &	rhs
	)

Definition at line 150 of file MatrixOperations.cpp.

    {
        NekMultiplyDefaultImpl(result, lhs, rhs);
    }

References NekMultiplyDefaultImpl().

Referenced by Multiply().

NekMultiplyLowerTriangularMatrix() [1/3]

template<typename DataType >

void Nektar::NekMultiplyLowerTriangularMatrix	(	DataType *	result,
		const NekMatrix< DataType, StandardMatrixTag > &	lhs,
		const DataType *	rhs
	)

Definition at line 387 of file MatrixVectorMultiplication.cpp.

    {
        int vectorSize = lhs.GetColumns();
        std::copy(rhs, rhs+vectorSize, result);
        int n = lhs.GetRows();
        const DataType* a = lhs.GetRawPtr();
        DataType* x = result;
        int incx = 1;
        
        Blas::Tpmv('L', lhs.GetTransposeFlag(), 'N', n, a, x, incx);
    }

References CellMLToNektar.pycml::copy(), Nektar::ConstMatrix< DataType >::GetColumns(), Nektar::NekMatrix< DataType, StandardMatrixTag >::GetRawPtr(), Nektar::ConstMatrix< DataType >::GetRows(), Nektar::ConstMatrix< DataType >::GetTransposeFlag(), and Blas::Tpmv().

Referenced by Multiply(), and NekMultiplyLowerTriangularMatrix().

NekMultiplyLowerTriangularMatrix() [2/3]

template<typename DataType , typename LhsDataType , typename MatrixType >

void Nektar::NekMultiplyLowerTriangularMatrix	(	DataType *	result,
		const NekMatrix< LhsDataType, MatrixType > &	lhs,
		const DataType *	rhs
	)

Definition at line 415 of file MatrixVectorMultiplication.cpp.

    {
       for(unsigned int i = 0; i < lhs.GetRows(); ++i)
       {
           DataType accum = DataType(0);
           for(unsigned int j = 0; j <= i; ++j)
           {
               accum += lhs(i,j)*rhs[j];
           }
           result[i] = accum;
       }
    }

NekMultiplyLowerTriangularMatrix() [3/3]

template<typename DataType >

void Nektar::NekMultiplyLowerTriangularMatrix	(	DataType *	result,
		const NekMatrix< NekMatrix< DataType, StandardMatrixTag >, ScaledMatrixTag > &	lhs,
		const DataType *	rhs
	)

Definition at line 402 of file MatrixVectorMultiplication.cpp.

    {
        NekMultiplyLowerTriangularMatrix(result, *lhs.GetOwnedMatrix(), rhs);
        
        for(unsigned int i = 0; i < lhs.GetColumns(); ++i)
        {
            result[i] *= lhs.Scale();
        }
    }

References NekMultiplyLowerTriangularMatrix().

NekMultiplySymmetricMatrix() [1/2]

template<typename DataType , typename InnerMatrixType , typename MatrixTag >

void Nektar::NekMultiplySymmetricMatrix	(	DataType *	result,
		const NekMatrix< InnerMatrixType, MatrixTag > &	lhs,
		const DataType *	rhs,
		typename std::enable_if< CanGetRawPtr< NekMatrix< InnerMatrixType, MatrixTag > >::value >::type *	p = 0
	)

Definition at line 475 of file MatrixVectorMultiplication.cpp.

    {
        boost::ignore_unused(p);
 
        const unsigned int* size = lhs.GetSize();
 
        DataType alpha = lhs.Scale();
        const DataType* a = lhs.GetRawPtr();
        const DataType* x = rhs;
        int incx = 1;
        DataType beta = 0.0;
        DataType* y = result;
        int incy = 1;
 
        Blas::Spmv('U', size[0], alpha, a, x, incx, beta, y, incy);
    }

References CellMLToNektar.cellml_metadata::p, and Blas::Spmv().

Referenced by Multiply().

NekMultiplySymmetricMatrix() [2/2]

template<typename DataType , typename InnerMatrixType , typename MatrixTag >

void Nektar::NekMultiplySymmetricMatrix	(	DataType *	result,
		const NekMatrix< InnerMatrixType, MatrixTag > &	lhs,
		const DataType *	rhs,
		typename std::enable_if<!CanGetRawPtr< NekMatrix< InnerMatrixType, MatrixTag > >::value >::type *	p = 0
	)

Definition at line 494 of file MatrixVectorMultiplication.cpp.

    {
        boost::ignore_unused(p);
 
        NekMultiplyUnspecializedMatrixType(result, lhs, rhs);
    }

References NekMultiplyUnspecializedMatrixType(), and CellMLToNektar.cellml_metadata::p.

NekMultiplyUnspecializedMatrixType()

template<typename DataType , typename LhsDataType , typename MatrixType >

void Nektar::NekMultiplyUnspecializedMatrixType	(	DataType *	result,
		const NekMatrix< LhsDataType, MatrixType > &	lhs,
		const DataType *	rhs
	)

Definition at line 58 of file MatrixVectorMultiplication.cpp.

    {
        for(unsigned int i = 0; i < lhs.GetRows(); ++i)
        {
            DataType accum = DataType(0);
            for(unsigned int j = 0; j < lhs.GetColumns(); ++j)
            {
                accum += lhs(i,j)*rhs[j];
            }
            result[i] = accum;
        }
    }

Referenced by Multiply(), NekMultiplyFullMatrix(), and NekMultiplySymmetricMatrix().

NekMultiplyUpperTriangularMatrix() [1/3]

template<typename DataType >

void Nektar::NekMultiplyUpperTriangularMatrix	(	DataType *	result,
		const NekMatrix< DataType, StandardMatrixTag > &	lhs,
		const DataType *	rhs
	)

Definition at line 431 of file MatrixVectorMultiplication.cpp.

    {
        int vectorSize = lhs.GetColumns();
        std::copy(rhs, rhs+vectorSize, result);
        int n = lhs.GetRows();
        const DataType* a = lhs.GetRawPtr();
        DataType* x = result;
        int incx = 1;
        
        Blas::Tpmv('U', lhs.GetTransposeFlag(), 'N', n, a, x, incx);
    }

References CellMLToNektar.pycml::copy(), Nektar::ConstMatrix< DataType >::GetColumns(), Nektar::NekMatrix< DataType, StandardMatrixTag >::GetRawPtr(), Nektar::ConstMatrix< DataType >::GetRows(), Nektar::ConstMatrix< DataType >::GetTransposeFlag(), and Blas::Tpmv().

Referenced by Multiply(), and NekMultiplyUpperTriangularMatrix().

NekMultiplyUpperTriangularMatrix() [2/3]

template<typename DataType , typename LhsDataType , typename MatrixType >

void Nektar::NekMultiplyUpperTriangularMatrix	(	DataType *	result,
		const NekMatrix< LhsDataType, MatrixType > &	lhs,
		const DataType *	rhs
	)

Definition at line 459 of file MatrixVectorMultiplication.cpp.

    {
       for(unsigned int i = 0; i < lhs.GetRows(); ++i)
       {
           DataType accum = DataType(0);
           for(unsigned int j = i; j < lhs.GetColumns(); ++j)
           {
               accum += lhs(i,j)*rhs[j];
           }
           result[i] = accum;
       }
    }

NekMultiplyUpperTriangularMatrix() [3/3]

template<typename DataType >

void Nektar::NekMultiplyUpperTriangularMatrix	(	DataType *	result,
		const NekMatrix< NekMatrix< DataType, StandardMatrixTag >, ScaledMatrixTag > &	lhs,
		const DataType *	rhs
	)

Definition at line 446 of file MatrixVectorMultiplication.cpp.

    {
        NekMultiplyUpperTriangularMatrix(result, *lhs.GetOwnedMatrix(), rhs);
        
        for(unsigned int i = 0; i < lhs.GetColumns(); ++i)
        {
            result[i] *= lhs.Scale();
        }
    }

References NekMultiplyUpperTriangularMatrix().

NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX() [1/11]

Nektar::NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX	(	AddEqual	,
		NEKTAR_ALL_MATRIX_TYPES	,
		(1,(void))	,
		(1,(DNekMat &))	,
		(0,())
	)

NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX() [2/11]

Nektar::NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX	(	Multiply	,
		NEKTAR_ALL_MATRIX_TYPES	,
		(1,(DNekMat))	,
		(0,())	,
		(1,(const NekDouble &))
	)

NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX() [3/11]

Nektar::NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX	(	Multiply	,
		NEKTAR_ALL_MATRIX_TYPES	,
		(1,(DNekMat))	,
		(1,(const NekDouble &))	,
		(0,())
	)

NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX() [4/11]

Nektar::NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX	(	Multiply	,
		NEKTAR_ALL_MATRIX_TYPES	,
		(1,(NekVector< NekDouble >))	,
		(0,())	,
		(1,(const NekVector< NekDouble > &))
	)

NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX() [5/11]

Nektar::NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX	(	Multiply	,
		NEKTAR_ALL_MATRIX_TYPES	,
		(1,(void))	,
		(1,(DNekMat &))	,
		(1,(const NekDouble &))
	)

NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX() [6/11]

Nektar::NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX	(	Multiply	,
		NEKTAR_ALL_MATRIX_TYPES	,
		(1,(void))	,
		(2,(DNekMat &, const NekDouble &))	,
		(0,())
	)

NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX() [7/11]

Nektar::NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX	(	Multiply	,
		NEKTAR_BLOCK_MATRIX_TYPES	,
		(1,(void))	,
		(1,(NekVector< NekDouble > &))	,
		(1,(const NekVector< NekDouble > &))
	)

NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX() [8/11]

Nektar::NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX	(	Multiply	,
		NEKTAR_STANDARD_AND_SCALED_MATRICES	,
		(1,(void))	,
		(1,(NekVector< NekDouble > &))	,
		(1,(const NekVector< NekDouble > &))
	)

NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX() [9/11]

Nektar::NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX	(	MultiplyEqual	,
		(1,(DNekMat &))	,
		(1,(void))	,
		(0,())	,
		(1,(const NekDouble &))
	)

NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX() [10/11]

Nektar::NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX	(	SubtractEqual	,
		NEKTAR_ALL_MATRIX_TYPES	,
		(1,(void))	,
		(1,(DNekMat &))	,
		(0,())
	)

NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX() [11/11]

SNekMat Nektar::NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX	(	SubtractEqualNegatedLhs	,
		NEKTAR_ALL_MATRIX_TYPES	,
		(1,(void))	,
		(1,(DNekMat &))	,
		(0,())
	)

NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES() [1/6]

Nektar::NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES	(	Add	,
		NEKTAR_ALL_MATRIX_TYPES	,
		NEKTAR_ALL_MATRIX_TYPES	,
		(1,(DNekMat))	,
		(0,())	,
		(0,())
	)

NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES() [2/6]

Nektar::NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES	(	Add	,
		NEKTAR_ALL_MATRIX_TYPES	,
		NEKTAR_ALL_MATRIX_TYPES	,
		(1,(void))	,
		(1,(DNekMat &))	,
		(0,())
	)

NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES() [3/6]

Nektar::NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES	(	Multiply	,
		NEKTAR_ALL_MATRIX_TYPES	,
		NEKTAR_ALL_MATRIX_TYPES	,
		(1,(void))	,
		(1,(DNekMat &))	,
		(0,())
	)

NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES() [4/6]

Nektar::NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES	(	Subtract	,
		NEKTAR_ALL_MATRIX_TYPES	,
		NEKTAR_ALL_MATRIX_TYPES	,
		(1,(DNekMat))	,
		(0,())	,
		(0,())
	)

NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES() [5/6]

Nektar::NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES	(	Subtract	,
		NEKTAR_ALL_MATRIX_TYPES	,
		NEKTAR_ALL_MATRIX_TYPES	,
		(1,(void))	,
		(1,(DNekMat &))	,
		(0,())
	)

NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES() [6/6]

SNekMat Nektar::NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES	(	SubtractNegatedLhs	,
		NEKTAR_ALL_MATRIX_TYPES	,
		NEKTAR_ALL_MATRIX_TYPES	,
		(1,(void))	,
		(1,(DNekMat &))	,
		(0,())
	)

Normalize() [1/3]

template<typename DataType >

void Nektar::Normalize

(

NekVector< DataType > &

v

)

Definition at line 1244 of file NekVector.cpp.

    {
        DataType m = v.Magnitude();
        if( m > DataType(0) )
        {
            v /= m;
        }
    }

References Nektar::NekVector< DataType >::Magnitude().

Referenced by Nektar::NekVector< DataType >::Normalize().

Normalize() [2/3]

template void Nektar::Normalize

(

NekVector< NekDouble > &

v

)

Normalize() [3/3]

template void Nektar::Normalize

(

NekVector< NekSingle > &

v

)

operator!=() [1/6]

template<typename T1 , typename T2 >

bool Nektar::operator!=	(	const Array< OneD, T1 > &	lhs,
		const Array< OneD, T2 > &	rhs
	)

Definition at line 776 of file SharedArray.hpp.

    {
        return !(lhs == rhs);
    }

operator!=() [2/6]

template<typename T1 , typename T2 >

bool Nektar::operator!=	(	const Array< TwoD, T1 > &	lhs,
		const Array< TwoD, T2 > &	rhs
	)

Definition at line 902 of file SharedArray.hpp.

    {
        return !(lhs == rhs);
    }

operator!=() [3/6]

template<typename DataType >

bool Nektar::operator!=	(	const MemoryManager< DataType > &	lhs,
		const MemoryManager< DataType > &	rhs
	)

Definition at line 308 of file NekMemoryManager.hpp.

{
    return !(lhs == rhs);
}

operator!=() [4/6]

template<typename DataType >

bool Nektar::operator!=	(	const NekVector< DataType > &	lhs,
		const NekVector< DataType > &	rhs
	)

Definition at line 1065 of file NekVector.cpp.

    {
        return !(lhs == rhs);
    }

operator!=() [5/6]

template bool Nektar::operator!=	(	const NekVector< NekDouble > &	lhs,
		const NekVector< NekDouble > &	rhs
	)

operator!=() [6/6]

template bool Nektar::operator!=	(	const NekVector< NekSingle > &	lhs,
		const NekVector< NekSingle > &	rhs
	)

operator*() [1/9]

template<typename DataType , typename RhsDataType , typename RhsMatrixType >

NekMatrix<typename NekMatrix<RhsDataType, RhsMatrixType>::NumberType, StandardMatrixTag> Nektar::operator*	(	const DataType &	lhs,
		const NekMatrix< RhsDataType, RhsMatrixType > &	rhs
	)

Definition at line 120 of file MatrixOperations.hpp.

{
    return Multiply(lhs, rhs);
}

References Multiply().

operator*() [2/9]

template<typename DataType >

NekVector<DataType> Nektar::operator*	(	const NekDouble &	lhs,
		const NekVector< DataType > &	rhs
	)

Definition at line 306 of file NekVector.hpp.

    {
        return Multiply(lhs, rhs);
    }

References Multiply().

operator*() [3/9]

template<typename LhsDataType , typename RhsDataType , typename LhsMatrixType , typename RhsMatrixType >

NekMatrix<typename std::remove_const< typename NekMatrix<LhsDataType, LhsMatrixType>::NumberType>::type, StandardMatrixTag> Nektar::operator*	(	const NekMatrix< LhsDataType, LhsMatrixType > &	lhs,
		const NekMatrix< RhsDataType, RhsMatrixType > &	rhs
	)

Definition at line 285 of file MatrixOperations.hpp.

{
    return Multiply(lhs, rhs);
}

References Multiply().

operator*() [4/9]

template<typename DataType , typename LhsDataType , typename MatrixType >

NekVector<DataType> Nektar::operator*	(	const NekMatrix< LhsDataType, MatrixType > &	lhs,
		const NekVector< DataType > &	rhs
	)

Definition at line 74 of file MatrixOperations.hpp.

{
    return Multiply(lhs, rhs);
}

References Multiply().

operator*() [5/9]

template<typename DataType , typename RhsDataType , typename RhsMatrixType >

NekMatrix<typename NekMatrix<RhsDataType, RhsMatrixType>::NumberType, StandardMatrixTag> Nektar::operator*	(	const NekMatrix< RhsDataType, RhsMatrixType > &	lhs,
		const DataType &	rhs
	)

Definition at line 128 of file MatrixOperations.hpp.

{
    return Multiply(lhs, rhs);
}

References Multiply().

operator*() [6/9]

template<typename DataType , typename dim , typename space , typename ScalarType >

NekPoint<DataType> Nektar::operator*	(	const NekPoint< DataType > &	lhs,
		const ScalarType &	rhs
	)

Definition at line 437 of file NekPoint.hpp.

    {
        NekPoint<DataType> result(lhs);
        result *= rhs;
        return result;
    }

operator*() [7/9]

template<typename DataType >

NekVector<DataType> Nektar::operator*	(	const NekVector< DataType > &	lhs,
		const NekDouble &	rhs
	)

Definition at line 299 of file NekVector.hpp.

    {
        return Multiply(lhs, rhs);
    }

References Multiply().

operator*() [8/9]

template<typename DataType >

NekVector<DataType> Nektar::operator*	(	const NekVector< DataType > &	lhs,
		const NekVector< DataType > &	rhs
	)

Definition at line 313 of file NekVector.hpp.

    {
        return Multiply(lhs, rhs);
    }

References Multiply().

operator*() [9/9]

template<typename DataType , typename dim , typename space , typename ScalarType >

NekPoint<DataType> Nektar::operator*	(	const ScalarType &	lhs,
		const NekPoint< DataType > &	rhs
	)

Definition at line 428 of file NekPoint.hpp.

    {
        NekPoint<DataType> result(rhs);
        result *= lhs;
        return result;
    }

operator+() [1/7]

template<typename DataType >

Array<OneD, DataType> Nektar::operator+	(	const Array< OneD, DataType > &	lhs,
		typename Array< OneD, DataType >::size_type	offset
	)

Definition at line 783 of file SharedArray.hpp.

    {
        return Array<OneD, const DataType>::CreateWithOffset(lhs, offset);
    }

operator+() [2/7]

template<typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >

NekMatrix<typename NekMatrix<LhsDataType, LhsMatrixType>::NumberType, StandardMatrixTag> Nektar::operator+	(	const NekMatrix< LhsDataType, LhsMatrixType > &	lhs,
		const NekMatrix< RhsDataType, RhsMatrixType > &	rhs
	)

Definition at line 316 of file MatrixOperations.hpp.

{
    return Add(lhs, rhs);
}

References Add().

operator+() [3/7]

template<typename DataType >

NekPoint<DataType> Nektar::operator+	(	const NekPoint< DataType > &	lhs,
		const NekPoint< DataType > &	rhs
	)

Definition at line 374 of file NekPoint.hpp.

    {
        NekPoint<DataType> result(lhs);
        result += rhs;
        return result;
    }

operator+() [4/7]

template<typename DataType >

NekPoint<DataType> Nektar::operator+	(	const NekPoint< DataType > &	lhs,
		typename boost::call_traits< DataType >::const_reference	rhs
	)

Definition at line 392 of file NekPoint.hpp.

    {
        NekPoint<DataType> result(lhs);
        result += rhs;
        return result;
    }

operator+() [5/7]

template<typename DataType >

NekVector<DataType> Nektar::operator+	(	const NekVector< DataType > &	lhs,
		const NekVector< DataType > &	rhs
	)

Definition at line 327 of file NekVector.hpp.

    {
        return Add(lhs, rhs);
    }

References Add().

operator+() [6/7]

template<typename DataType >

Array<OneD, DataType> Nektar::operator+	(	typename Array< OneD, DataType >::size_type	offset,
		const Array< OneD, DataType > &	rhs
	)

Definition at line 790 of file SharedArray.hpp.

    {
        return Array<OneD, const DataType>::CreateWithOffset(rhs, offset);
    }

operator+() [7/7]

template<typename DataType >

NekPoint<DataType> Nektar::operator+	(	typename boost::call_traits< DataType >::const_reference	lhs,
		const NekPoint< DataType > &	rhs
	)

Definition at line 383 of file NekPoint.hpp.

    {
        NekPoint<DataType> result(rhs);
        result += lhs;
        return result;
    }

operator-() [1/5]

template<typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >

NekMatrix<typename NekMatrix<LhsDataType, LhsMatrixType>::NumberType, StandardMatrixTag> Nektar::operator-	(	const NekMatrix< LhsDataType, LhsMatrixType > &	lhs,
		const NekMatrix< RhsDataType, RhsMatrixType > &	rhs
	)

Definition at line 366 of file MatrixOperations.hpp.

{
    return Subtract(lhs, rhs);
}

References Subtract().

operator-() [2/5]

template<typename DataType >

NekPoint<DataType> Nektar::operator-	(	const NekPoint< DataType > &	lhs,
		const NekPoint< DataType > &	rhs
	)

Definition at line 401 of file NekPoint.hpp.

    {
        NekPoint<DataType> result(lhs);
        result -= rhs;
        return result;
    }

operator-() [3/5]

template<typename DataType >

NekPoint<DataType> Nektar::operator-	(	const NekPoint< DataType > &	lhs,
		typename boost::call_traits< DataType >::const_reference	rhs
	)

Definition at line 419 of file NekPoint.hpp.

    {
        NekPoint<DataType> result(lhs);
        result -= rhs;
        return result;
    }

operator-() [4/5]

template<typename DataType >

NekVector<DataType> Nektar::operator-	(	const NekVector< DataType > &	lhs,
		const NekVector< DataType > &	rhs
	)

Definition at line 334 of file NekVector.hpp.

    {
        return Subtract(lhs, rhs);
    }

References Subtract().

operator-() [5/5]

template<typename DataType >

NekPoint<DataType> Nektar::operator-	(	typename boost::call_traits< DataType >::const_reference	lhs,
		const NekPoint< DataType > &	rhs
	)

Definition at line 410 of file NekPoint.hpp.

    {
        NekPoint<DataType> result(-rhs);
        result += lhs;
        return result;
    }

operator/() [1/2]

template<typename DataType >

NekPoint<DataType> Nektar::operator/	(	const NekPoint< DataType > &	lhs,
		typename boost::call_traits< DataType >::param_type	rhs
	)

Definition at line 446 of file NekPoint.hpp.

    {
        NekPoint<DataType> result(lhs);
        result /= rhs;
        return result;
    }

operator/() [2/2]

template<typename DataType >

NekVector<DataType> Nektar::operator/	(	const NekVector< DataType > &	lhs,
		const NekDouble &	rhs
	)

Definition at line 320 of file NekVector.hpp.

    {
        return Divide(lhs, rhs);
    }

References Divide().

operator<<() [1/9]

template<typename DataType , typename FormType >

std::ostream& Nektar::operator<<	(	std::ostream &	os,
		const NekMatrix< DataType, FormType > &	rhs
	)

Definition at line 49 of file NekMatrix.hpp.

    {
        int oswidth = 9;
        int osprecision = 6;
 
        for(unsigned int i = 0; i < rhs.GetRows(); ++i)
        {
            os << "[";
            for(unsigned int j = 0; j < rhs.GetColumns(); ++j)
            {
                os.width(oswidth);
                os.precision(osprecision);
                os << rhs(i,j);
                if( j != rhs.GetColumns() - 1 )
                {
                    os << ", ";
                }
            }
            os << "]";
            if( i != rhs.GetRows()-1 )
            {
                os << std::endl;
            }
        }
        return os;
    }

operator<<() [2/9]

template<typename DataType >

std::ostream& Nektar::operator<<	(	std::ostream &	os,
		const NekPoint< DataType > &	p
	)

Definition at line 490 of file NekPoint.hpp.

    {
        os << p.AsString();
        return os;
    }

References CellMLToNektar.cellml_metadata::p.

operator<<() [3/9]

template<typename SparseStorageType >

std::ostream & Nektar::operator<<	(	std::ostream &	os,
		const NekSparseDiagBlkMatrix< SparseStorageType > &	rhs
	)

Definition at line 114 of file SparseUtils.cpp.

    {
        int oswidth = 9;
        int osprecision = 6;
 
        for(unsigned int i = 0; i < rhs.GetRows(); ++i)
        {
            os << "[";
            for(unsigned int j = 0; j < rhs.GetColumns(); ++j)
            {
                os.width(oswidth);
                os.precision(osprecision);
                os << rhs(i,j);
                if( j != rhs.GetColumns() - 1 )
                {
                    os << ", ";
                }
            }
            os << "]";
            if( i != rhs.GetRows()-1 )
            {
                os << std::endl;
            }
        }
        return os;
    }

References Nektar::NekSparseDiagBlkMatrix< SparseStorageType >::GetColumns(), and Nektar::NekSparseDiagBlkMatrix< SparseStorageType >::GetRows().

operator<<() [4/9]

template std::ostream& Nektar::operator<<	(	std::ostream &	os,
		const NekSparseDiagBlkMatrix< StorageSmvBsr< NekDouble > > &	rhs
	)

operator<<() [5/9]

template<typename SparseStorageType >

std::ostream & Nektar::operator<<	(	std::ostream &	os,
		const NekSparseMatrix< SparseStorageType > &	rhs
	)

Definition at line 86 of file SparseUtils.cpp.

    {
        int oswidth = 9;
        int osprecision = 6;
 
        for(unsigned int i = 0; i < rhs.GetRows(); ++i)
        {
            os << "[";
            for(unsigned int j = 0; j < rhs.GetColumns(); ++j)
            {
                os.width(oswidth);
                os.precision(osprecision);
                os << rhs(i,j);
                if( j != rhs.GetColumns() - 1 )
                {
                    os << ", ";
                }
            }
            os << "]";
            if( i != rhs.GetRows()-1 )
            {
                os << std::endl;
            }
        }
        return os;
    }

References Nektar::NekSparseMatrix< SparseStorageType >::GetColumns(), and Nektar::NekSparseMatrix< SparseStorageType >::GetRows().

operator<<() [6/9]

template std::ostream& Nektar::operator<<	(	std::ostream &	os,
		const NekSparseMatrix< StorageSmvBsr< NekDouble > > &	rhs
	)

operator<<() [7/9]

template<typename DataType >

std::ostream & Nektar::operator<<	(	std::ostream &	os,
		const NekVector< DataType > &	rhs
	)

Definition at line 990 of file NekVector.cpp.

    {
        os << rhs.AsString();
        return os;
    }

References Nektar::NekVector< DataType >::AsString().

operator<<() [8/9]

template std::ostream& Nektar::operator<<	(	std::ostream &	os,
		const NekVector< NekDouble > &	rhs
	)

operator<<() [9/9]

template std::ostream& Nektar::operator<<	(	std::ostream &	os,
		const NekVector< NekSingle > &	rhs
	)

operator==() [1/6]

template<typename T1 , typename T2 >

bool Nektar::operator==	(	const Array< OneD, T1 > &	lhs,
		const Array< OneD, T2 > &	rhs
	)

Definition at line 750 of file SharedArray.hpp.

    {
        if (lhs.size() != rhs.size())
        {
            return false;
        }
 
        if (lhs.data() == rhs.data())
        {
            return true;
        }
 
        typename Array<OneD, T1>::size_type size_value(lhs.size());
        for (typename Array<OneD, T1>::size_type i = 0; i < size_value; ++i)
        {
            if (!IsEqual(lhs[i], rhs[i]))
            {
                return false;
            }
        }
 
        return true;
    }

References IsEqual().

operator==() [2/6]

template<typename T1 , typename T2 >

bool Nektar::operator==	(	const Array< TwoD, T1 > &	lhs,
		const Array< TwoD, T2 > &	rhs
	)

Definition at line 872 of file SharedArray.hpp.

    {
        if ( (lhs.GetRows() != rhs.GetRows()) ||
            (lhs.GetColumns() != rhs.GetColumns()) )
        {
            return false;
        }
 
        if ( lhs.data() == rhs.data() )
        {
            return true;
        }
 
        for (typename Array<OneD, T1>::size_type i = 0; i < lhs.GetRows(); ++i)
        {
            for (typename Array<OneD, T1>::size_type j = 0;
                j < lhs.GetColumns(); ++j)
            {
                if (!IsEqual(lhs[i][j], rhs[i][j]))
                {
                    return false;
                }
            }
        }
 
        return true;
    }

References IsEqual().

operator==() [3/6]

template<typename DataType >

bool Nektar::operator==	(	const MemoryManager< DataType > &	lhs,
		const MemoryManager< DataType > &	rhs
	)

Definition at line 301 of file NekMemoryManager.hpp.

{
    boost::ignore_unused(lhs,rhs);
    return true;
}

operator==() [4/6]

template<typename DataType >

bool Nektar::operator==	(	const NekVector< DataType > &	lhs,
		const NekVector< DataType > &	rhs
	)

Definition at line 1045 of file NekVector.cpp.

    {
        if( lhs.GetDimension() != rhs.GetDimension() )
        {
            return false;
        }
 
        return std::equal(lhs.begin(), lhs.end(), rhs.begin());
    }

References Nektar::NekVector< DataType >::begin(), Nektar::NekVector< DataType >::end(), and Nektar::NekVector< DataType >::GetDimension().

operator==() [5/6]

template bool Nektar::operator==	(	const NekVector< NekDouble > &	lhs,
		const NekVector< NekDouble > &	rhs
	)

operator==() [6/6]

template bool Nektar::operator==	(	const NekVector< NekSingle > &	lhs,
		const NekVector< NekSingle > &	rhs
	)

operator>>()

template<typename DataType , typename FormType >

std::ostream& Nektar::operator>>	(	std::ostream &	os,
		const NekMatrix< DataType, FormType > &	rhs
	)

Definition at line 77 of file NekMatrix.hpp.

    {
        NekDouble tol = 1e-12;
        os <<  "[" << std::endl;
 
        for(unsigned int i = 0; i < rhs.GetRows(); ++i)
        {
            for(unsigned int j = 0; j < rhs.GetColumns(); ++j)
            {
                if((NekDouble)rhs(i,j) > tol)
                {
                    os << '+';
                }
                else if((NekDouble)rhs(i,j) < -tol)
                {
                    os << '*';
                }
                else
                {
                    os << '-';
                }
            }
            if( i != rhs.GetRows()-1 )
            {
                os << std::endl;
            }
        }
        os <<  "]" << std::endl;
        return os;
    }

prefun()

void Nektar::prefun ( NekDouble *  g, NekDouble  p, NekDouble  dk, NekDouble  pk, NekDouble  ck, NekDouble &  f, NekDouble &  fd  )

inline

Evaluate pressure functions fL and fR in Newton iteration of Riemann solver (see equation 4.85 and 4.86 of Toro 2009).

Parameters

g	Array of gamma parameters.
p	Pressure at current iteration.
dk	Density (left or right state)
pk	Pressure (left or right state)
ck	Sound speed (left or right state)
f	Computed pressure (shock).
fd	Computed pressure (rarefaction).

Definition at line 120 of file ExactSolverToro.cpp.

    {
        if (p <= pk)
        {
            // Rarefaction wave
            NekDouble prat = p/pk;
            f = g[4]*ck*(pow(prat, g[1])-1.0);
            fd = pow(prat, -g[2])/(dk*ck);
        }
        else
        {
            // Shock wave
            NekDouble ak  = g[5]/dk;
            NekDouble bk  = g[6]*pk;
            NekDouble qrt = sqrt(ak/(bk+p));
            f             = (p-pk)*qrt;
            fd            = (1.0-0.5*(p-pk)/(bk+p))*qrt;
        }
    }

References CellMLToNektar.cellml_metadata::p, and tinysimd::sqrt().

Referenced by Nektar::ExactSolverToro::v_PointSolve().

RoeKernel()

template<class T , typename = typename std::enable_if < std::is_floating_point<T>::value || tinysimd::is_vector_floating_point<T>::value >::type>

void Nektar::RoeKernel ( T &  rhoL, T &  rhouL, T &  rhovL, T &  rhowL, T &  EL, T &  rhoR, T &  rhouR, T &  rhovR, T &  rhowR, T &  ER, T &  rhof, T &  rhouf, T &  rhovf, T &  rhowf, T &  Ef, NekDouble  gamma  )

inline

Definition at line 79 of file RoeSolver.h.

{
    // Left and right velocities
    T uL = rhouL / rhoL;
    T vL = rhovL / rhoL;
    T wL = rhowL / rhoL;
    T uR = rhouR / rhoR;
    T vR = rhovR / rhoR;
    T wR = rhowR / rhoR;
 
    // Left and right pressures
    T pL = (gamma - 1.0) *
        (EL - 0.5 * (rhouL * uL + rhovL * vL + rhowL * wL));
    T pR = (gamma - 1.0) *
        (ER - 0.5 * (rhouR * uR + rhovR * vR + rhowR * wR));
 
    // Left and right enthalpy
    T hL = (EL + pL) / rhoL;
    T hR = (ER + pR) / rhoR;
 
    // Square root of rhoL and rhoR.
    T srL  = sqrt(rhoL);
    T srR  = sqrt(rhoR);
    T srLR = srL + srR;
 
    // Velocity, enthalpy and sound speed Roe averages (equation 11.60).
    T uRoe   = (srL * uL + srR * uR) / srLR;
    T vRoe   = (srL * vL + srR * vR) / srLR;
    T wRoe   = (srL * wL + srR * wR) / srLR;
    T hRoe   = (srL * hL + srR * hR) / srLR;
    T URoe   = (uRoe * uRoe + vRoe * vRoe + wRoe * wRoe);
    T cRoe   = sqrt((gamma - 1.0)*(hRoe - 0.5 * URoe));
 
    // Compute eigenvectors (equation 11.59).
    T k[5][5] = {
        {1., uRoe - cRoe, vRoe, wRoe, hRoe - uRoe * cRoe},
        {1., uRoe,        vRoe, wRoe, 0.5 * URoe},
        {0., 0.,           1.,    0.,    vRoe},
        {0., 0.,           0.,    1.,    wRoe},
        {1., uRoe+cRoe,  vRoe,  wRoe, hRoe + uRoe*cRoe}
    };
 
    // Calculate jumps \Delta u_i (defined preceding equation 11.67).
    T jump[5] = {
        rhoR  - rhoL,
        rhouR - rhouL,
        rhovR - rhovL,
        rhowR - rhowL,
        ER    - EL
    };
 
    // Define \Delta u_5 (equation 11.70).
    T jumpbar = jump[4] - (jump[2]-vRoe*jump[0])*vRoe -
        (jump[3]-wRoe*jump[0])*wRoe;
 
    // Compute wave amplitudes (equations 11.68, 11.69).
    T alpha[5];
    alpha[1] = (gamma-1.0)*(jump[0]*(hRoe - uRoe*uRoe) + uRoe*jump[1] -
                            jumpbar)/(cRoe*cRoe);
    alpha[0] = (jump[0]*(uRoe + cRoe) - jump[1] - cRoe*alpha[1])/(2.0*cRoe);
    alpha[4] = jump[0] - (alpha[0] + alpha[1]);
    alpha[2] = jump[2] - vRoe * jump[0];
    alpha[3] = jump[3] - wRoe * jump[0];
 
    // Compute average of left and right fluxes needed for equation 11.29.
    rhof  = 0.5*(rhoL*uL + rhoR*uR);
    rhouf = 0.5*(pL + rhoL*uL*uL + pR + rhoR*uR*uR);
    rhovf = 0.5*(rhoL*uL*vL + rhoR*uR*vR);
    rhowf = 0.5*(rhoL*uL*wL + rhoR*uR*wR);
    Ef    = 0.5*(uL*(EL + pL) + uR*(ER + pR));
 
    // Needed to get right overload resolution for std::abs
    using std::abs;
 
    // Compute eigenvalues \lambda_i (equation 11.58).
    T uRoeAbs = abs(uRoe);
    T lambda[5] = {
        abs(uRoe - cRoe),
        uRoeAbs,
        uRoeAbs,
        uRoeAbs,
        abs(uRoe + cRoe)
    };
 
    // Finally perform summation (11.29).
    for (size_t i = 0; i < 5; ++i)
    {
        uRoeAbs = 0.5*alpha[i]*lambda[i];
 
        rhof  -= uRoeAbs*k[i][0];
        rhouf -= uRoeAbs*k[i][1];
        rhovf -= uRoeAbs*k[i][2];
        rhowf -= uRoeAbs*k[i][3];
        Ef    -= uRoeAbs*k[i][4];
    }
 
}

References tinysimd::abs(), and tinysimd::sqrt().

Referenced by main(), Nektar::RoeSolver::v_ArraySolve(), Nektar::RoeSolver::v_PointSolve(), and Nektar::RoeSolverSIMD::v_Solve().

Subtract() [1/9]

template<typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >

SNekMat SNekMat NekMatrix<typename NekMatrix<LhsDataType, LhsMatrixType>::NumberType, StandardMatrixTag> Nektar::Subtract	(	const NekMatrix< LhsDataType, LhsMatrixType > &	lhs,
		const NekMatrix< RhsDataType, RhsMatrixType > &	rhs
	)

Definition at line 405 of file MatrixOperations.cpp.

    {
        typedef typename NekMatrix<LhsDataType, LhsMatrixType>::NumberType NumberType;
        NekMatrix<NumberType, StandardMatrixTag> result(lhs.GetRows(), lhs.GetColumns());
        Subtract(result, lhs, rhs);
        return result;
    }

References Subtract().

Subtract() [2/9]

template<typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >

NekMatrix<typename NekMatrix<LhsDataType, LhsMatrixType>::NumberType, StandardMatrixTag> Nektar::Subtract	(	const NekMatrix< LhsDataType, LhsMatrixType > &	lhs,
		const NekMatrix< RhsDataType, RhsMatrixType > &	rhs
	)

Definition at line 405 of file MatrixOperations.cpp.

    {
        typedef typename NekMatrix<LhsDataType, LhsMatrixType>::NumberType NumberType;
        NekMatrix<NumberType, StandardMatrixTag> result(lhs.GetRows(), lhs.GetColumns());
        Subtract(result, lhs, rhs);
        return result;
    }

References Subtract().

Subtract() [3/9]

template<typename DataType >

NekVector< DataType > Nektar::Subtract	(	const NekVector< DataType > &	lhs,
		const NekVector< DataType > &	rhs
	)

Definition at line 624 of file NekVector.cpp.

    {
        NekVector<DataType> result(lhs.GetDimension());
        Subtract(result, lhs, rhs);
        return result;
    }

References Nektar::NekVector< DataType >::GetDimension(), and Subtract().

Subtract() [4/9]

template NekVector<NekDouble> Nektar::Subtract	(	const NekVector< NekDouble > &	lhs,
		const NekVector< NekDouble > &	rhs
	)

Subtract() [5/9]

template NekVector<NekSingle> Nektar::Subtract	(	const NekVector< NekSingle > &	lhs,
		const NekVector< NekSingle > &	rhs
	)

Subtract() [6/9]

template<typename DataType , typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >

void Nektar::Subtract	(	NekMatrix< DataType, StandardMatrixTag > &	result,
		const NekMatrix< LhsDataType, LhsMatrixType > &	lhs,
		const NekMatrix< RhsDataType, RhsMatrixType > &	rhs
	)

Definition at line 303 of file MatrixOperations.cpp.

    {
        ASSERTL1(lhs.GetRows() == rhs.GetRows(), std::string("Matrices with different row counts  ") + 
            std::to_string(lhs.GetRows()) + std::string(" and ") +
            std::to_string(rhs.GetRows()) + std::string(" can't be subtracted."));
        ASSERTL1(lhs.GetColumns() == rhs.GetColumns(), std::string("Matrices with different column counts  ") + 
            std::to_string(lhs.GetColumns()) + std::string(" and ") +
            std::to_string(rhs.GetColumns()) + std::string(" can't be subtracted."));
 
        for(unsigned int i = 0; i < lhs.GetRows(); ++i)
        {
            for(unsigned int j = 0; j < lhs.GetColumns(); ++j)
            {
                result(i,j) = lhs(i,j) - rhs(i,j);
            }
        }
    }

References ASSERTL1.

Referenced by operator-(), and Subtract().

Subtract() [7/9]

template void Nektar::Subtract	(	NekVector< NekDouble > &	result,
		const NekVector< NekDouble > &	lhs,
		const NekVector< NekDouble > &	rhs
	)

Subtract() [8/9]

template void Nektar::Subtract	(	NekVector< NekSingle > &	result,
		const NekVector< NekSingle > &	lhs,
		const NekVector< NekSingle > &	rhs
	)

Subtract() [9/9]

template<typename ResultDataType , typename InputDataType >

void Nektar::Subtract	(	NekVector< ResultDataType > &	result,
		const NekVector< InputDataType > &	lhs,
		const NekVector< InputDataType > &	rhs
	)

Definition at line 531 of file NekVector.cpp.

    {
        ResultDataType* r_buf = result.GetRawPtr();
        typename std::add_const<InputDataType>::type* lhs_buf = lhs.GetRawPtr();
        typename std::add_const<InputDataType>::type* rhs_buf = rhs.GetRawPtr();
        const unsigned int ldim = lhs.GetDimension();
        for(int i = 0; i < ldim; ++i)
        {
            r_buf[i] = lhs_buf[i] - rhs_buf[i];
        }
    }

References Nektar::NekVector< DataType >::GetDimension(), and Nektar::NekVector< DataType >::GetRawPtr().

SubtractEqual() [1/5]

template<typename DataType , typename RhsDataType , typename RhsMatrixType >

SNekMat SNekMat void Nektar::SubtractEqual	(	NekMatrix< DataType, StandardMatrixTag > &	result,
		const NekMatrix< RhsDataType, RhsMatrixType > &	rhs
	)

Definition at line 356 of file MatrixOperations.cpp.

    {
        ASSERTL1(result.GetRows() == rhs.GetRows(), std::string("Matrices with different row counts  ") + 
            std::to_string(result.GetRows()) + std::string(" and ") +
            std::to_string(rhs.GetRows()) + std::string(" can't be subtracted."));
        ASSERTL1(result.GetColumns() == rhs.GetColumns(), std::string("Matrices with different column counts  ") + 
            std::to_string(result.GetColumns()) + std::string(" and ") +
            std::to_string(rhs.GetColumns()) + std::string(" can't be subtracted."));
 
        for(unsigned int i = 0; i < rhs.GetRows(); ++i)
        {
            for(unsigned int j = 0; j < rhs.GetColumns(); ++j)
            {
                result(i,j) -= rhs(i,j);
            }
        }
    }

References ASSERTL1.

Referenced by Nektar::NekVector< DataType >::operator-=().

SubtractEqual() [2/5]

template<typename DataType , typename RhsDataType , typename RhsMatrixType >

void Nektar::SubtractEqual	(	NekMatrix< DataType, StandardMatrixTag > &	result,
		const NekMatrix< RhsDataType, RhsMatrixType > &	rhs
	)

Definition at line 356 of file MatrixOperations.cpp.

    {
        ASSERTL1(result.GetRows() == rhs.GetRows(), std::string("Matrices with different row counts  ") + 
            std::to_string(result.GetRows()) + std::string(" and ") +
            std::to_string(rhs.GetRows()) + std::string(" can't be subtracted."));
        ASSERTL1(result.GetColumns() == rhs.GetColumns(), std::string("Matrices with different column counts  ") + 
            std::to_string(result.GetColumns()) + std::string(" and ") +
            std::to_string(rhs.GetColumns()) + std::string(" can't be subtracted."));
 
        for(unsigned int i = 0; i < rhs.GetRows(); ++i)
        {
            for(unsigned int j = 0; j < rhs.GetColumns(); ++j)
            {
                result(i,j) -= rhs(i,j);
            }
        }
    }

References ASSERTL1.

Referenced by Nektar::NekVector< DataType >::operator-=().

SubtractEqual() [3/5]

template void Nektar::SubtractEqual	(	NekVector< NekDouble > &	result,
		const NekVector< NekDouble > &	rhs
	)

SubtractEqual() [4/5]

template void Nektar::SubtractEqual	(	NekVector< NekSingle > &	result,
		const NekVector< NekSingle > &	rhs
	)

SubtractEqual() [5/5]

template<typename ResultDataType , typename InputDataType >

void Nektar::SubtractEqual	(	NekVector< ResultDataType > &	result,
		const NekVector< InputDataType > &	rhs
	)

Definition at line 581 of file NekVector.cpp.

    {
        ResultDataType* r_buf = result.GetRawPtr();
        typename std::add_const<InputDataType>::type* rhs_buf = rhs.GetRawPtr();
        const unsigned int rdim = rhs.GetDimension();
        for(int i = 0; i < rdim; ++i)
        {
            r_buf[i] -= rhs_buf[i];
        }
    }

References Nektar::NekVector< DataType >::GetDimension(), and Nektar::NekVector< DataType >::GetRawPtr().

SubtractEqualNegatedLhs() [1/4]

template<typename DataType , typename RhsDataType , typename RhsMatrixType >

void Nektar::SubtractEqualNegatedLhs	(	NekMatrix< DataType, StandardMatrixTag > &	result,
		const NekMatrix< RhsDataType, RhsMatrixType > &	rhs
	)

Definition at line 376 of file MatrixOperations.cpp.

    {
        ASSERTL1(result.GetRows() == rhs.GetRows(), std::string("Matrices with different row counts  ") + 
            std::to_string(result.GetRows()) + std::string(" and ") +
            std::to_string(rhs.GetRows()) + std::string(" can't be subtracted."));
        ASSERTL1(result.GetColumns() == rhs.GetColumns(), std::string("Matrices with different column counts  ") + 
            std::to_string(result.GetColumns()) + std::string(" and ") +
            std::to_string(rhs.GetColumns()) + std::string(" can't be subtracted."));
 
        for(unsigned int i = 0; i < rhs.GetRows(); ++i)
        {
            for(unsigned int j = 0; j < rhs.GetColumns(); ++j)
            {
                result(i,j) = -result(i,j) - rhs(i,j);
            }
        }
    }

References ASSERTL1, Nektar::ConstMatrix< DataType >::GetColumns(), and Nektar::ConstMatrix< DataType >::GetRows().

SubtractEqualNegatedLhs() [2/4]

template void Nektar::SubtractEqualNegatedLhs	(	NekVector< NekDouble > &	result,
		const NekVector< NekDouble > &	rhs
	)

SubtractEqualNegatedLhs() [3/4]

template void Nektar::SubtractEqualNegatedLhs	(	NekVector< NekSingle > &	result,
		const NekVector< NekSingle > &	rhs
	)

SubtractEqualNegatedLhs() [4/4]

template<typename ResultDataType , typename InputDataType >

void Nektar::SubtractEqualNegatedLhs	(	NekVector< ResultDataType > &	result,
		const NekVector< InputDataType > &	rhs
	)

Definition at line 594 of file NekVector.cpp.

    {
                ResultDataType* r_buf = result.GetRawPtr();
        typename std::add_const<InputDataType>::type* rhs_buf = rhs.GetRawPtr();
        const unsigned int rdim = rhs.GetDimension();
        for(int i = 0; i < rdim; ++i)
        {
            r_buf[i] = -r_buf[i] - rhs_buf[i];
        }
    }

References Nektar::NekVector< DataType >::GetDimension(), and Nektar::NekVector< DataType >::GetRawPtr().

SubtractNegatedLhs() [1/4]

template<typename DataType , typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >

void Nektar::SubtractNegatedLhs	(	NekMatrix< DataType, StandardMatrixTag > &	result,
		const NekMatrix< LhsDataType, LhsMatrixType > &	lhs,
		const NekMatrix< RhsDataType, RhsMatrixType > &	rhs
	)

Definition at line 324 of file MatrixOperations.cpp.

    {
        ASSERTL1(lhs.GetRows() == rhs.GetRows(), std::string("Matrices with different row counts  ") + 
            std::to_string(lhs.GetRows()) + std::string(" and ") +
            std::to_string(rhs.GetRows()) + std::string(" can't be subtracted."));
        ASSERTL1(lhs.GetColumns() == rhs.GetColumns(), std::string("Matrices with different column counts  ") + 
            std::to_string(lhs.GetColumns()) + std::string(" and ") +
            std::to_string(rhs.GetColumns()) + std::string(" can't be subtracted."));
 
        for(unsigned int i = 0; i < lhs.GetRows(); ++i)
        {
            for(unsigned int j = 0; j < lhs.GetColumns(); ++j)
            {
                result(i,j) = -lhs(i,j) - rhs(i,j);
            }
        }
    }

References ASSERTL1.

SubtractNegatedLhs() [2/4]

template void Nektar::SubtractNegatedLhs	(	NekVector< NekDouble > &	result,
		const NekVector< NekDouble > &	lhs,
		const NekVector< NekDouble > &	rhs
	)

SubtractNegatedLhs() [3/4]

template void Nektar::SubtractNegatedLhs	(	NekVector< NekSingle > &	result,
		const NekVector< NekSingle > &	lhs,
		const NekVector< NekSingle > &	rhs
	)

SubtractNegatedLhs() [4/4]

template<typename ResultDataType , typename InputDataType >

void Nektar::SubtractNegatedLhs	(	NekVector< ResultDataType > &	result,
		const NekVector< InputDataType > &	lhs,
		const NekVector< InputDataType > &	rhs
	)

Definition at line 546 of file NekVector.cpp.

    {
        ResultDataType* r_buf = result.GetRawPtr();
        typename std::add_const<InputDataType>::type* lhs_buf = lhs.GetRawPtr();
        typename std::add_const<InputDataType>::type* rhs_buf = rhs.GetRawPtr();
        const unsigned int ldim = lhs.GetDimension();
        for(int i = 0; i < ldim; ++i)
        {
            r_buf[i] = -lhs_buf[i] - rhs_buf[i];
        }
    }

References Nektar::NekVector< DataType >::GetDimension(), and Nektar::NekVector< DataType >::GetRawPtr().

Transpose() [1/7]

template<typename DataType >

NekMatrix< DataType, ScaledMatrixTag > Nektar::Transpose

(

NekMatrix< DataType, ScaledMatrixTag > &

rhs

)

Definition at line 178 of file ScaledMatrix.cpp.

    {
        NekMatrix<DataType, ScaledMatrixTag> result(rhs);
        result.Transpose();
        return result;
    }

Transpose() [2/7]

template<typename DataType >

NekMatrix< DataType, StandardMatrixTag > Nektar::Transpose

(

NekMatrix< DataType, StandardMatrixTag > &

rhs

)

Definition at line 816 of file StandardMatrix.cpp.

    {
        NekMatrix<DataType, StandardMatrixTag> result(rhs.GetRows(), rhs.GetColumns(),
            rhs.GetPtr(), eWrapper, rhs.GetType(), rhs.GetNumberOfSubDiagonals(),
            rhs.GetNumberOfSuperDiagonals());
        result.Transpose();
        return result;
    }

References eWrapper, Nektar::ConstMatrix< DataType >::GetColumns(), Nektar::NekMatrix< DataType, StandardMatrixTag >::GetNumberOfSubDiagonals(), Nektar::NekMatrix< DataType, StandardMatrixTag >::GetNumberOfSuperDiagonals(), Nektar::NekMatrix< DataType, StandardMatrixTag >::GetPtr(), Nektar::ConstMatrix< DataType >::GetRows(), Nektar::ConstMatrix< DataType >::GetType(), and Nektar::ConstMatrix< DataType >::Transpose().

Transpose() [3/7]

template<typename InnerMatrixType >

NekMatrix<InnerMatrixType, BlockMatrixTag> Nektar::Transpose

(

NekMatrix< InnerMatrixType, BlockMatrixTag > &

rhs

)

Definition at line 217 of file BlockMatrix.hpp.

    {
        NekMatrix<InnerMatrixType, BlockMatrixTag> result(rhs);
        result.Transpose();
        return result;
    }

Referenced by Nektar::LocalRegions::HexExp::CreateMatrix(), Nektar::LocalRegions::NodalTriExp::CreateMatrix(), Nektar::LocalRegions::PrismExp::CreateMatrix(), Nektar::LocalRegions::PyrExp::CreateMatrix(), Nektar::LocalRegions::QuadExp::CreateMatrix(), Nektar::LocalRegions::TetExp::CreateMatrix(), Nektar::LocalRegions::TriExp::CreateMatrix(), Nektar::StdRegions::StdNodalPrismExp::NodalToModalTranspose(), Nektar::StdRegions::StdNodalTetExp::NodalToModalTranspose(), Nektar::StdRegions::StdNodalTriExp::NodalToModalTranspose(), Nektar::CoupledLinearNS::SetUpCoupledMatrix(), Nektar::CoupledLinearNS::SolveLinearNS(), Nektar::MultiRegions::PreconditionerLowEnergy::v_BuildPreconditioner(), Nektar::LocalRegions::Expansion2D::v_DGDeriv(), Nektar::LocalRegions::Expansion3D::v_DGDeriv(), Nektar::LinearElasticSystem::v_DoSolve(), Nektar::LocalRegions::Expansion1D::v_GenMatrix(), Nektar::LocalRegions::Expansion2D::v_GenMatrix(), Nektar::LocalRegions::Expansion3D::v_GenMatrix(), Nektar::MultiRegions::DisContField::v_HelmSolve(), and Nektar::MultiRegions::PreconditionerLowEnergy::v_TransformedSchurCompl().

Transpose() [4/7]

template NekMatrix<NekDouble, StandardMatrixTag> Nektar::Transpose

(

NekMatrix< NekDouble, StandardMatrixTag > &

rhs

)

Transpose() [5/7]

template NekMatrix< NekMatrix<NekDouble, StandardMatrixTag>, ScaledMatrixTag> Nektar::Transpose

(

NekMatrix< NekMatrix< NekDouble, StandardMatrixTag >, ScaledMatrixTag > &

rhs

)

Transpose() [6/7]

template NekMatrix< NekMatrix<NekSingle, StandardMatrixTag>, ScaledMatrixTag> Nektar::Transpose

(

NekMatrix< NekMatrix< NekSingle, StandardMatrixTag >, ScaledMatrixTag > &

rhs

)

Transpose() [7/7]

template NekMatrix<NekSingle, StandardMatrixTag> Nektar::Transpose

(

NekMatrix< NekSingle, StandardMatrixTag > &

rhs

)

Variable Documentation

EigenvaluesAnaMeshesAB2

NekDouble Nektar::EigenvaluesAnaMeshesAB2[6][14]

static

Initial value:

=
    {{18.849560, 37.699110, 62.254810, 92.114370, 127.199300, 167.209300, 212.189900, 261.852900, 316.311600, 375.280200, 438.911800, 506.922500, 579.489600, 656.332100}, 
    {625.358147, 1196.328877, 1817.986152, 2475.195638, 3162.726621, 3867.689152, 4595.324620, 5340.967597, 6188.286000, 7399.972000, 8708.072000, 10111.160000, 11608.000000, 13197.470000}, 
    {705.738221, 1268.022370, 1883.167893, 2533.621042, 3215.460527, 3915.574276, 4638.993612, 5380.985954, 6153.131100, 6914.337599, 7721.969961, 8529.801758, 9326.138300, 10138.712574}, 
    {733.261678, 1293.053007, 1905.511959, 2553.681869, 3233.562783, 3932.056639, 4654.037626, 5394.854534, 6165.912400, 6926.174929, 7732.912435, 8509.531270, 9335.504451, 10147.409120}, 
    {747.053764, 1305.602041, 1916.689465, 2563.704820, 3242.557000, 3940.217950, 4661.410438, 5401.601883, 6172.029656, 6931.769221, 7737.958233, 8514.117977, 9339.576627, 10151.066350},
    {755.354971, 1313.162315, 1923.399136, 2569.711788, 3247.904628, 3945.042610, 4665.705043, 5405.487354, 6175.462753, 6934.840253, 7740.605266, 8518.215978, 9343.872193, 10156.126788}}

Definition at line 57 of file CFLtester.h.

Referenced by Nektar::CFLtester::v_GetTimeStep().

EigenvaluesAnaMeshesRK2

NekDouble Nektar::EigenvaluesAnaMeshesRK2[6][14]

static

Initial value:

=
    {{18.849560, 37.699110, 62.254810, 92.114370, 127.199300, 167.209300, 212.189900, 261.852900, 316.311600, 375.280200, 438.911800, 506.922500, 579.489600, 656.332100}, 
    {557.050244, 1050.871071, 1626.248117, 2260.761693, 2948.760275, 3677.949231, 4461.704082, 5269.668301, 6188.286000, 7399.972000, 8708.072000, 10111.160000, 11608.000000, 13197.470000}, 
    {628.920938, 1115.037602, 1684.555318, 2314.125522, 2997.926601, 3723.485221, 4504.103288, 5309.152432, 6144.425035, 6997.224333, 7899.393530, 8799.536577, 9741.728144, 10730.151339}, 
    {653.448558, 1137.048335, 1704.542817, 2332.448417, 3014.804194, 3739.158997, 4518.709861, 5322.835874, 6157.188251, 7009.203565, 7910.587422, 8810.047856, 9751.511668, 10739.355196}, 
    {665.739421, 1148.083349, 1714.541462, 2341.603048, 3023.189930, 3746.919933, 4525.868290, 5329.493149, 6163.296851, 7014.864920, 7915.749155, 8814.796544, 9755.765307, 10668.230508}, 
    {673.137069, 1154.731489, 1720.543482, 2347.089614, 3028.175778, 3751.507906, 4508.994826, 5306.299694, 6166.725091, 7017.972766, 7918.457008, 8818.796544, 9759.765307, 10672.230508}}

Definition at line 65 of file CFLtester.h.

Referenced by Nektar::CFLtester::v_GetTimeStep().

EigenvaluesAnaMeshesRK4

NekDouble Nektar::EigenvaluesAnaMeshesRK4[6][14]

static

Initial value:

=
    {{18.849560, 37.699110, 62.254810, 92.114370, 127.199300, 167.209300, 212.189900, 261.852900, 316.311600, 375.280200, 438.911800, 506.922500, 579.489600, 656.332100}, 
    {606.168101, 1187.787270, 1793.615712, 2391.865039, 2950.786843, 3487.596192, 4060.011000, 5074.723000, 6188.286000, 7399.972000, 8708.072000, 10111.160000, 11608.000000, 13197.470000}, 
    {684.081594, 1260.315774, 1857.923680, 2448.327633, 2999.987783, 3530.775456, 4073.368829, 4591.645387, 5121.018725, 5647.554500, 6330.380000, 7341.464000, 8418.710000, 9561.240000}, 
    {710.760453, 1285.192482, 1879.968339, 2467.708932, 3016.876152, 3545.638033, 4086.578922, 4603.479913, 5131.656118, 5657.223101, 6197.802683, 7022.172000, 8034.773000, 9107.511000}, 
    {724.129308, 1297.665239, 1890.995890, 2477.394447, 3025.267650, 3552.997300, 4093.052410, 4609.237151, 5136.747279, 5661.792457, 6397.687000, 7383.760000, 8431.678000, 9540.598000}, 
    {732.175780, 1305.179484, 1897.615616, 2483.199183, 3030.256925, 3557.347822, 4096.823380, 4612.552660, 5139.604517, 5664.300842, 6771.812000, 7388.760000, 8436.678000, 9546.598000}}

Definition at line 73 of file CFLtester.h.

Referenced by Nektar::CFLtester::v_GetTimeStep().

EigenvaluesRegMeshes

NekDouble Nektar::EigenvaluesRegMeshes[10][14]

static

Initial value:

=
    {{18.849560, 37.699110, 62.254810, 92.114370, 127.199300, 167.209300, 212.189900, 261.852900, 316.311600, 375.280200, 438.911800, 506.922500, 579.489600, 656.332100},
    {32.277580, 67.919290, 113.860500, 169.431300, 234.151800, 307.678500, 389.746800, 480.143200, 578.689500, 685.233500, 799.642600, 921.799700, 1051.600000, 1188.949000},
    {56.418920, 115.463200, 191.215900, 282.444600, 388.469600, 508.597500, 642.523200, 789.745400, 950.116100, 1123.225000, 1309.009000, 1507.109000, 1717.513000, 1939.900000},
    {77.988010, 158.974000, 262.115100, 385.943600, 529.415800, 691.770100, 872.414200, 1070.867000, 1286.725000, 1519.644000, 1769.323000, 2035.496000, 2317.925000, 2616.397000},
    {102.518800, 207.512500, 340.960200, 500.891100, 686.042600, 895.336300, 1128.107000, 1383.623000, 1661.474000, 1961.100000, 2282.224000, 2624.386000, 2987.395000, 3370.856000},
    {125.653700, 253.549800, 415.661800, 609.711500, 834.071300, 1087.549000, 1369.216000, 1678.315000, 2014.214000, 2376.369000, 2764.308000, 3177.613000, 3615.910000, 4078.863000},
    {150.392200, 302.534600, 495.170300, 725.542200, 991.784100, 1292.405000, 1626.378000, 1992.722000, 2390.769000, 2819.785000, 3279.297000, 3768.717000, 4287.691000, 4835.729000},
    {174.106400, 349.636100, 571.545300, 836.751500, 1143.031000, 1488.755000, 1872.650000, 2293.681000, 2750.981000, 3243.808000, 3771.512000, 4333.522000, 4929.325000, 5558.461000},
    {198.947800, 398.852300, 651.400800, 953.050400, 1301.327000, 1694.312000, 2130.624000, 2609.014000, 3128.566000, 3688.361000, 4287.733000, 4925.959000, 5602.527000, 6316.841000},
    {222.978700, 446.558300, 728.737000, 1065.639000, 1454.438000, 1893.064000, 2379.896000, 2913.620000, 3493.132000, 4117.485000, 4785.857000, 5497.519000, 6251.820000, 7079.855200}}

Definition at line 45 of file CFLtester.h.

FlagTypeMap

const char* const Nektar::FlagTypeMap[]

Initial value:

= {
        "UseGlobal"
    }

String map for FlagType enumeration.

Definition at line 94 of file NektarUnivTypeDefs.hpp.

InitWaveTypeMap

const char* const Nektar::InitWaveTypeMap[]

Initial value:

=
    {
      "Left",
      "BothEnd",
      "Center",
      "LeftBottomCorner",
      "Point",
      "SpiralDock",
    }

Definition at line 80 of file MMFDiffusion.h.

Referenced by Nektar::MMFDiffusion::v_InitObject().

kAdvectionFormStr

const std::string Nektar::kAdvectionFormStr[]

Initial value:

=
    {
        "NoType",
        "Convective",
        "NonConservative",
        "Linearised",
        "Adjoint",
        "SkewSymmetric"
        "NoAdvection"
    }

Definition at line 88 of file IncNavierStokes.h.

kEquationTypeStr

const std::string Nektar::kEquationTypeStr[]

Initial value:

=
    {
        "NoType",
        "SteadyStokes",
        "SteadyOseen",
        "SteadyLinearisedNS",
        "UnsteadyStokes",
        "UnsteadyLinearisedNS",
        "UnsteadyNavierStokes",
        "SteadyNavierStokes",
    }

Definition at line 62 of file IncNavierStokes.h.

Referenced by Nektar::IncNavierStokes::v_InitObject().

NEKTAR_ALL_MATRIX_TYPES_SINGLE

SNekMat Nektar::NEKTAR_ALL_MATRIX_TYPES_SINGLE

Definition at line 59 of file MatrixOperations.cpp.

NEKTAR_BLOCK_MATRIX_TYPES_SINGLE

Nektar::NEKTAR_BLOCK_MATRIX_TYPES_SINGLE

Definition at line 598 of file MatrixVectorMultiplication.cpp.

NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX

SNekMat Nektar::NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX(SubtractEqualNegatedLhs, NEKTAR_ALL_MATRIX_TYPES,(1,(void)),(1,(DNekMat &)),(0,())) NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX(SubtractEqualNegatedLhs	(	AddEqualNegatedLhs	,
		NEKTAR_ALL_MATRIX_TYPES	,
		(1,(void))	,
		(1,(DNekMat &))	,
		(0,())
	)

NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES

SNekMat Nektar::NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES(SubtractNegatedLhs, NEKTAR_ALL_MATRIX_TYPES, NEKTAR_ALL_MATRIX_TYPES,(1,(void)),(1,(DNekMat &)),(0,())) NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES(SubtractNegatedLhs	(	AddNegatedLhs	,
		NEKTAR_ALL_MATRIX_TYPES	,
		NEKTAR_ALL_MATRIX_TYPES	,
		(1,(void))	,
		(1,(DNekMat &))	,
		(0,())
	)

NEKTAR_STANDARD_AND_SCALED_MATRICES_SINGLE

Nektar::NEKTAR_STANDARD_AND_SCALED_MATRICES_SINGLE

Definition at line 580 of file MatrixVectorMultiplication.cpp.

NekVector< NekSingle >

Nektar::NekVector< NekSingle >

Definition at line 611 of file MatrixVectorMultiplication.cpp.

NistSpBlasDescra

const int Nektar::NistSpBlasDescra[5][9]

static

Definition at line 44 of file NistSparseDescriptors.hpp.

NullArrayDNekBlkMatSharedPtr

Array<OneD, DNekBlkMatSharedPtr> Nektar::NullArrayDNekBlkMatSharedPtr

static

Definition at line 88 of file NekTypeDefs.hpp.

NullArraySNekBlkMatSharedPtr

Array<OneD, SNekBlkMatSharedPtr> Nektar::NullArraySNekBlkMatSharedPtr

static

Definition at line 130 of file NekTypeDefs.hpp.

NullDNekMatSharedPtr

DNekMatSharedPtr Nektar::NullDNekMatSharedPtr

static

Definition at line 78 of file NekTypeDefs.hpp.

Referenced by Nektar::StdRegions::StdExpansion::v_BuildInverseTransformationMatrix(), Nektar::LocalRegions::Expansion::v_BuildTransformationMatrix(), Nektar::LocalRegions::Expansion3D::v_BuildTransformationMatrix(), and Nektar::LocalRegions::Expansion::v_BuildVertexMatrix().

NullDNekScalBlkMatSharedPtr

DNekScalBlkMatSharedPtr Nektar::NullDNekScalBlkMatSharedPtr

static

Definition at line 80 of file NekTypeDefs.hpp.

Referenced by Nektar::StdRegions::StdExpansion::v_GetLocStaticCondMatrix().

NullDNekScalMatSharedPtr

DNekScalMatSharedPtr Nektar::NullDNekScalMatSharedPtr

static

Definition at line 79 of file NekTypeDefs.hpp.

Referenced by Nektar::LocalRegions::Expansion::v_GetLocMatrix().

NullInt1DArray

Array<OneD, int> Nektar::NullInt1DArray

static

Definition at line 819 of file SharedArray.hpp.

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

NullNekDouble1DArray

Array<OneD, NekDouble> Nektar::NullNekDouble1DArray

static

Definition at line 820 of file SharedArray.hpp.

Referenced by Nektar::SolverUtils::DiffusionIP::AddSecondDerivToTrace(), Nektar::MultiRegions::ExpList::AddTraceJacToElmtJac(), Nektar::VelocityCorrectionScheme::AppendSVVFactors(), Nektar::Collections::Collection::ApplyOperator(), Nektar::CoupledAssemblyMap::CoupledAssemblyMap(), Nektar::StdRegions::StdExpansion::H1(), Nektar::SolverUtils::EquationSystem::L2Error(), Nektar::MultiRegions::ExpList::Linf(), Nektar::StdRegions::StdExpansion::Linf(), Nektar::CFSImplicit::NumCalcRiemFluxJac(), Nektar::CFSImplicit::PreconCoeff(), Nektar::FieldUtils::ProcessEquiSpacedOutput::Process(), Nektar::FieldUtils::ProcessInterpField::Process(), Nektar::VelocityCorrectionScheme::SetUpSVV(), Nektar::CFSImplicit::UpdateTimeStepCheck(), Nektar::SolverUtils::DiffusionIP::v_DiffuseCalcDerivative(), Nektar::SolverUtils::DiffusionIP::v_DiffuseVolumeFlux(), Nektar::MultiRegions::PreconditionerLinear::v_DoPreconditioner(), Nektar::MultiRegions::PreconditionerLinear::v_DoPreconditionerWithNonVertOutput(), Nektar::VelocityCorrectionScheme::v_GenerateSummary(), Nektar::SolverUtils::Driver::v_GetImagEvl(), Nektar::MultiRegions::DisContField::v_GetLocTraceFromTracePts(), Nektar::LocalRegions::Expansion::v_GetPhysNormals(), Nektar::LocalRegions::SegExp::v_GetPhysNormals(), Nektar::SolverUtils::Driver::v_GetRealEvl(), Nektar::SolverUtils::ForcingMovingReferenceFrame::v_InitObject(), Nektar::SolverUtils::DiffusionIP::v_InitObject(), Nektar::MultiRegions::ExpList3DHomogeneous1D::v_L2(), Nektar::MultiRegions::ExpList::v_L2(), Nektar::MultiRegions::ExpListHomogeneous1D::v_PhysDeriv(), Nektar::StdRegions::StdPrismExp::v_PhysDeriv(), Nektar::StdRegions::StdTetExp::v_PhysDeriv(), Nektar::LocalRegions::HexExp::v_PhysDeriv(), Nektar::LocalRegions::QuadExp::v_PhysDeriv(), Nektar::LocalRegions::TriExp::v_PhysDeriv(), Nektar::StdRegions::StdHexExp::v_PhysDeriv(), Nektar::StdRegions::StdPyrExp::v_PhysDeriv(), Nektar::StdRegions::StdQuadExp::v_PhysDeriv(), Nektar::StdRegions::StdTriExp::v_PhysDeriv(), Nektar::LocalRegions::SegExp::v_PhysDeriv(), and Nektar::VCSWeakPressure::v_SolvePressure().

NullNekDoubleArrayOfArray

Array<OneD, Array<OneD, NekDouble> > Nektar::NullNekDoubleArrayOfArray

static

Definition at line 821 of file SharedArray.hpp.

Referenced by Nektar::CompressibleFlowSystem::DoOdeRhs(), Nektar::CFSImplicit::DoOdeRhsCoeff(), Nektar::CFSImplicit::GetTraceJac(), Nektar::CFSImplicit::NonlinSysEvaluatorCoeff(), Nektar::SolverUtils::DiffusionLDG::NumFluxforScalar(), Nektar::CoupledLinearNS::SetUpCoupledMatrix(), Nektar::VelocityCorrectionScheme::SetUpSVV(), Nektar::VelocityCorrectionScheme::SVVVarDiffCoeff(), Nektar::SolverUtils::AdvectionWeakDG::v_AdvectTraceFlux(), Nektar::SolverUtils::DiffusionIP::v_DiffuseCoeffs(), Nektar::SolverUtils::DiffusionIP::v_DiffuseVolumeFlux(), Nektar::NavierStokesCFE::v_DoDiffusion(), Nektar::NavierStokesImplicitCFE::v_DoDiffusionCoeff(), Nektar::SolverUtils::Diffusion::v_GetTraceNormal(), and Nektar::LocalRegions::SegExp::v_PhysDeriv_n().

NullNekDoubleTensorOfArray3D

Array<OneD, Array<OneD, Array<OneD, NekDouble> > > Nektar::NullNekDoubleTensorOfArray3D

static

Definition at line 828 of file SharedArray.hpp.

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

NullPulseWaveBoundarySharedPtr

PulseWaveBoundarySharedPtr Nektar::NullPulseWaveBoundarySharedPtr

static

Definition at line 52 of file PulseWaveBoundary.h.

NullPulseWavePressureAreaSharedPtr

PulseWavePressureAreaSharedPtr Nektar::NullPulseWavePressureAreaSharedPtr

static

Definition at line 51 of file PulseWavePressureArea.h.

NullSNekMatSharedPtr

SNekMatSharedPtr Nektar::NullSNekMatSharedPtr

static

Definition at line 123 of file NekTypeDefs.hpp.

NullSNekScalBlkMatSharedPtr

SNekScalBlkMatSharedPtr Nektar::NullSNekScalBlkMatSharedPtr

static

Definition at line 125 of file NekTypeDefs.hpp.

NullSNekScalMatSharedPtr

SNekScalMatSharedPtr Nektar::NullSNekScalMatSharedPtr

static

Definition at line 124 of file NekTypeDefs.hpp.

ProblemTypeMap

const char* const Nektar::ProblemTypeMap[] = { "General", "SolitaryWave" }

Definition at line 51 of file NonlinearPeregrine.h.

Referenced by Nektar::NonlinearPeregrine::v_InitObject().

TestTypeMap

const char *const Nektar::TestTypeMap

Initial value:

=
    {
      "TestPlane",
      "TestCube",
      "TestLinearSphere",
      "TestNonlinearSphere",
      "FHNStandard",
      "FHNRogers",
      "FHNAlievPanf",
    }

Definition at line 58 of file MMFDiffusion.h.

Referenced by Nektar::MMFAdvection::v_GenerateSummary(), Nektar::MMFDiffusion::v_GenerateSummary(), Nektar::MMFSWE::v_GenerateSummary(), Nektar::MMFAdvection::v_InitObject(), Nektar::MMFDiffusion::v_InitObject(), and Nektar::MMFSWE::v_InitObject().

UpwindTypeMapPulse

const char* const Nektar::UpwindTypeMapPulse[]

Initial value:

=
        {
            "NoSetPulse",
            "UpwindPulse",
        }

Definition at line 54 of file PulseWaveSystem.h.

Referenced by Nektar::PulseWaveSystem::v_InitObject().

void

SNekMat Nektar::void

Definition at line 59 of file MatrixOperations.cpp.

Referenced by Nektar::LibUtilities::CompressData::ZlibDecode(), and Nektar::LibUtilities::CompressData::ZlibEncode().

VWIIterationTypeMap

const std::string Nektar::VWIIterationTypeMap[]

Initial value:

= 
    {
        "FixedAlpha",
        "FixedWaveForcing",
        "FixedAlphaWaveForcing",
        "FixedWaveForcingWithSubIterationOnAlpha"
    }

Definition at line 63 of file VortexWaveInteraction.h.

Referenced by Nektar::VortexWaveInteraction::VortexWaveInteraction().