Nektar Namespace Reference

< More...

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

Classes
class	AdjointAdvection
	Advection for the adjoint form of the linearised Navier-Stokes equations. More...
class	AlternateSkewAdvection
class	APE
class	APESolver
singleton	Array
class	Array< OneD, const DataType >
	1D Array of constant elements with garbage collection and bounds checking. More...
class	Array< OneD, DataType >
	1D Array More...
class	Array< ThreeD, const DataType >
	3D array with garbage collection and bounds checking. More...
class	Array< ThreeD, DataType >
	A 3D array. More...
class	Array< TwoD, const DataType >
	2D array with garbage collection and bounds checking. More...
class	Array< TwoD, DataType >
	A 2D array. More...
singleton	ArrayDestructionPolicy
class	ArrayDestructionPolicy< ObjectType, typename boost::disable_if< boost::is_fundamental< ObjectType > >::type >
class	ArrayDestructionPolicy< ObjectType, typename boost::enable_if< boost::is_fundamental< ObjectType > >::type >
singleton	ArrayInitializationPolicy
class	ArrayInitializationPolicy< ObjectType, typename boost::disable_if< boost::is_fundamental< ObjectType > >::type >
class	ArrayInitializationPolicy< ObjectType, typename boost::enable_if< boost::is_fundamental< ObjectType > >::type >
class	ArterialPressureArea
	A global linear system. More...
class	ArtificialDiffusion
	Encapsulates the artificial diffusion used in shock capture. More...
class	AssignableConcept
class	AUSM0Solver
class	AUSM1Solver
class	AUSM2Solver
class	AUSM3Solver
class	AverageSolver
struct	BandedMatrixFuncs
class	Bidomain
	A model for cardiac conduction. More...
class	BidomainRoth
	A model for cardiac conduction. More...
struct	CanGetRawPtr
struct	CanGetRawPtr< NekMatrix< NekMatrix< T, R >, ScaledMatrixTag > >
struct	CanGetRawPtr< NekMatrix< T, M > >
struct	CanGetRawPtr< NekMatrix< T, StandardMatrixTag > >
class	CellModel
	Cell model base class. More...
class	CellModelAlievPanfilov
	Aliev Panfilov model. More...
class	CellModelFitzHughNagumo
	FitzHugh-Nagumo model. More...
class	CFLtester
class	CFSBndCond
	Encapsulates the user-defined boundary conditions for compressible flow solver. More...
class	CompressibleFlowSystem
class	CompressibleSolver
struct	ConsistentObjectAccess
struct	ConsistentObjectAccess< boost::shared_ptr< DataType > >
struct	ConsistentObjectAccess< DataType * >
singleton	ConstMatrix
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	CoupledLinearNS
class	CoupledLocalToGlobalC0ContMap
struct	coupledSolverMatrices
class	CourtemancheRamirezNattel98
struct	DiagonalMatrixFuncs
class	EigenValuesAdvection
class	EulerCFE
class	ExactSolverToro
class	Extrapolate
class	ExtrapOrder0BC
	Extrapolation of order 0 for all the variables such that, at the boundaries, a trivial Riemann problem is solved. More...
class	FentonKarma
class	FilterBenchmark
	Records activation and repolarisation times. More...
class	FilterCellHistoryPoints
class	FilterCheckpointCellModel
class	FilterElectrogram
class	FilterEnergy
class	FilterMovingBody
class	FlagList
	Defines a list of flags. More...
class	ForcingMovingBody
class	ForcingStabilityCoupledLNS
struct	FourD
class	Fox02
struct	FullMatrixFuncs
class	Helmholtz
struct	HighOrderOutflow
class	HLLCSolver
class	HLLSolver
class	ImageWarpingSystem
class	IncNavierStokes
	This class is the base class for Navier Stokes problems. More...
struct	InterfacePoint
class	IsentropicVortex
class	IsentropicVortexBC
	Wall boundary conditions for compressible flow problems. More...
struct	IsSharedPointer
struct	IsSharedPointer< boost::shared_ptr< DataType > >
struct	IsVector
struct	IsVector< NekVector< DataType > >
class	IterativeElasticSystem
	Class for iterative elastic system, in which linear elasticity is applied in substeps to attain a large deformation. More...
class	Laplace
class	LaxFriedrichsSolver
class	LinearAverageSolver
class	LinearElasticSystem
	Base class for linear elastic system. More...
class	LinearHLLSolver
class	LinearisedAdvection
class	LinearSWE
class	LinearSWESolver
class	LinearSystem
struct	LinearSystemSolver
struct	LowerTriangularBandedMatrixFuncs
struct	LowerTriangularMatrixFuncs
class	LuoRudy91
class	LymphaticPressureArea
	A global linear system. More...
class	MappingExtrapolate
singleton	Matrix
class	MemoryManager
	General purpose memory allocation routines with the ability to allocate from thread specific memory pools. More...
class	MemPool
class	Monodomain
	A model for cardiac conduction. More...
class	NavierStokesAdvection
class	NavierStokesCFE
singleton	NekMatrix
class	NekMatrix< DataType, StandardMatrixTag >
	Standard Matrix. More...
class	NekMatrix< NekMatrix< DataType, InnerMatrixType >, BlockMatrixTag >
class	NekMatrix< NekMatrix< DataType, InnerMatrixType >, ScaledMatrixTag >
class	NekPoint
class	NekPtr
singleton	NekSparseDiagBlkMatrix
singleton	NekSparseMatrix
singleton	NekVector
class	NoAdvection
class	NonlinearPeregrine
class	NonlinearSWE
class	NonlinearSWESolver
class	NonSmoothShockCapture
	Non Smooth artificial diffusion for shock capture for compressible flow problems. More...
class	NoSolver
struct	OneD
class	PanditGilesDemir03
class	ParseUtils
class	Poisson
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	PressureOutflowBC
	Pressure outflow boundary conditions for compressible flow problems. More...
class	PressureOutflowFileBC
	Pressure outflow boundary conditions for compressible flow problems. More...
class	PressureOutflowNonReflectiveBC
	Pressure outflow non-reflective boundary conditions for compressible flow problems. More...
class	Projection
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	PulseWaveBoundary
class	PulseWavePressureArea
class	PulseWavePropagation
class	PulseWaveSystem
	Base class for unsteady solvers. More...
class	PulseWaveSystemOutput
	Base class for unsteady solvers. More...
class	QInflow
	A global linear system. More...
struct	RawType
struct	RawType< boost::shared_ptr< const T > >
struct	RawType< boost::shared_ptr< const volatile T > >
struct	RawType< boost::shared_ptr< T > >
struct	RawType< boost::shared_ptr< volatile T > >
struct	RawType< const boost::shared_ptr< const T > >
struct	RawType< const boost::shared_ptr< const volatile T > >
struct	RawType< const boost::shared_ptr< T > >
struct	RawType< const boost::shared_ptr< volatile T > >
struct	RawType< const T * >
struct	RawType< const T *const >
struct	RawType< const T *const volatile >
struct	RawType< const T *volatile >
struct	RawType< const T >
struct	RawType< const volatile boost::shared_ptr< const T > >
struct	RawType< const volatile boost::shared_ptr< const volatile T > >
struct	RawType< const volatile boost::shared_ptr< T > >
struct	RawType< const volatile boost::shared_ptr< volatile T > >
struct	RawType< const volatile T * >
struct	RawType< const volatile T *const >
struct	RawType< const volatile T *const volatile >
struct	RawType< const volatile T *volatile >
struct	RawType< const volatile T >
struct	RawType< T * >
struct	RawType< T *const >
struct	RawType< T *const volatile >
struct	RawType< T *volatile >
struct	RawType< volatile boost::shared_ptr< const T > >
struct	RawType< volatile boost::shared_ptr< const volatile T > >
struct	RawType< volatile boost::shared_ptr< T > >
struct	RawType< volatile boost::shared_ptr< volatile T > >
struct	RawType< volatile T * >
struct	RawType< volatile T *const >
struct	RawType< volatile T *const volatile >
struct	RawType< volatile T *volatile >
struct	RawType< volatile T >
class	RCROutflow
	A global linear system. More...
class	RiemannInvariantBC
	Outflow characteristic boundary conditions for compressible flow problems. More...
class	RinglebFlow
class	RinglebFlowBC
	Wall boundary conditions for compressible flow problems. More...
class	RoeSolver
class	ROutflow
	A global linear system. More...
class	ShallowWaterSystem
	Base class for unsteady solvers. More...
class	SkewSymmetricAdvection
class	SmoothShockCapture
	Smooth artificial diffusion for shock capture for compressible flow problems. More...
class	StandardExtrapolate
class	SteadyAdvectionDiffusion
class	SteadyAdvectionDiffusionReaction
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	StorageSmvBsr
class	SubSteppingExtrapolate
class	SubSteppingExtrapolateWeakPressure
struct	SymmetricBandedMatrixFuncs
struct	SymmetricMatrixFuncs
class	SymmetryBC
	Symmetry boundary conditions for compressible flow problems. More...
class	TenTusscher06
class	TerminalOutflow
	A global linear system. More...
struct	ThreeD
class	TimeDependentBC
	Time dependent boundary condition. More...
class	TimeDependentInflow
	A global linear system. More...
class	Timer
struct	TriangularBandedMatrixFuncs
struct	TriangularMatrixFuncs
struct	TwoD
class	UndefinedInOutflow
	A global linear system. More...
class	UnsteadyAdvection
class	UnsteadyAdvectionDiffusion
class	UnsteadyDiffusion
class	UnsteadyInviscidBurger
class	UnsteadyViscousBurgers
struct	UpperTriangularBandedMatrixFuncs
struct	UpperTriangularMatrixFuncs
class	UpwindSolver
class	VariableConverter
class	VCSMapping
class	VCSWeakPressure
class	VelocityCorrectionScheme
class	VortexWaveInteraction
class	WallBC
	Wall boundary conditions for compressible flow problems. More...
class	WallViscousBC
	Wall boundary conditions for viscous compressible flow problems. More...
class	WeakPressureExtrapolate
class	Winslow99
struct	WomersleyParams
class	XmlUtil

Typedefs
typedef double	NekDouble
typedef boost::int32_t	NekInt
typedef boost::int32_t	NekInt32
typedef boost::int64_t	NekInt64
typedef boost::uint32_t	NekUInt
typedef boost::uint32_t	NekUInt32
typedef boost::uint64_t	NekUInt64
typedef boost::shared_ptr < NekMatrix< NekDouble, StandardMatrixTag > >	SharedNekMatrixPtr
typedef NekMatrix< NekMatrix < NekDouble, StandardMatrixTag > , ScaledMatrixTag >	DNekScalMat
typedef boost::shared_ptr < DNekScalMat >	DNekScalMatSharedPtr
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 boost::shared_ptr < DNekMat >	DNekMatSharedPtr
typedef boost::shared_ptr < DNekBlkMat >	DNekBlkMatSharedPtr
typedef boost::shared_ptr < BlkMatDNekBlkMat >	BlkMatDNekBlkMatSharedPtr
typedef boost::shared_ptr < DNekScalBlkMat >	DNekScalBlkMatSharedPtr
typedef boost::shared_ptr < BlkMatDNekScalBlkMat >	BlkMatDNekScalBlkMatSharedPtr
typedef LinearSystem	DNekLinSys
typedef boost::shared_ptr < DNekLinSys >	DNekLinSysSharedPtr
typedef LinearSystem	DNekScalLinSys
typedef boost::shared_ptr < DNekScalLinSys >	DNekScalLinSysSharedPtr
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 boost::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 boost::shared_ptr < BCOMatType >	BCOMatTypeSharedPtr
typedef Array< OneD, BCOMatType >	BCOMatVector
typedef std::vector< std::pair < std::string, std::string > >	SummaryList
typedef boost::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 boost::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 boost::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 boost::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 boost::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 boost::shared_ptr < VariableConverter >	VariableConverterSharedPtr
typedef struct Nektar::coupledSolverMatrices	CoupledSolverMatrices
typedef boost::shared_ptr < CoupledLocalToGlobalC0ContMap >	CoupledLocalToGlobalC0ContMapSharedPtr
typedef boost::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 boost::shared_ptr < HighOrderOutflow >	HighOrderOutflowSharedPtr
typedef boost::shared_ptr < WomersleyParams >	WomersleyParamsSharedPtr
typedef boost::shared_ptr < IncNavierStokes >	IncNavierStokesSharedPtr
typedef boost::shared_ptr < MappingExtrapolate >	MappingExtrapolateSharedPtr
typedef boost::shared_ptr < StandardExtrapolate >	StandardExtrapolateSharedPtr
typedef boost::shared_ptr < SubSteppingExtrapolate >	SubSteppingExtrapolateSharedPtr
typedef boost::shared_ptr < SubSteppingExtrapolateWeakPressure >	SubSteppingExtrapolateWeakPressureSharedPtr
typedef boost::shared_ptr < VCSMapping >	VCSMappingSharedPtr
typedef boost::shared_ptr < VelocityCorrectionScheme >	VelocityCorrectionSchemeSharedPtr
typedef boost::shared_ptr < VCSWeakPressure >	VCSWeakPressureSharedPtr
typedef boost::shared_ptr < WeakPressureExtrapolate >	WeakPressureExtrapolateSharedPtr
typedef boost::shared_ptr < FilterMovingBody >	FilterMovingBodySharedPtr
typedef std::map< std::string, std::string >	FilterParams
typedef std::pair< std::string, FilterParams >	FilterMap
typedef boost::shared_ptr < CoupledAssemblyMap >	CoupledAssemblyMapSharedPtr
typedef boost::shared_ptr < ArterialPressureArea >	ArterialPressureAreaSharedPtr
	Pointer to a PulseWaveOutflow object. More...
typedef boost::shared_ptr < LymphaticPressureArea >	LymphaticPressureAreaSharedPtr
	Pointer to a PulseWaveOutflow object. More...
typedef boost::shared_ptr < PulseWaveBoundary >	PulseWaveBoundarySharedPtr
typedef LibUtilities::NekFactory < std::string, PulseWaveBoundary, Array< OneD, MultiRegions::ExpListSharedPtr > &, const LibUtilities::SessionReaderSharedPtr &, PulseWavePressureAreaSharedPtr & >	BoundaryFactory
typedef boost::shared_ptr < PulseWavePressureArea >	PulseWavePressureAreaSharedPtr
typedef LibUtilities::NekFactory < std::string, PulseWavePressureArea, Array < OneD, MultiRegions::ExpListSharedPtr > &, const LibUtilities::SessionReaderSharedPtr & >	PressureAreaFactory
typedef boost::shared_ptr < InterfacePoint >	InterfacePointShPtr
typedef boost::shared_ptr < PulseWaveSystem >	PulseWaveSystemSharedPtr
typedef boost::shared_ptr < QInflow >	QInflowSharedPtr
	Pointer to a PulseWaveOutflow object. More...
typedef boost::shared_ptr < RCROutflow >	RCROutflowSharedPtr
	Pointer to a PulseWaveOutflow object. More...
typedef boost::shared_ptr < ROutflow >	ROutflowSharedPtr
	Pointer to a PulseWaveOutflow object. More...
typedef boost::shared_ptr < TerminalOutflow >	TerminalOutflowSharedPtr
	Pointer to a PulseWaveOutflow object. More...
typedef boost::shared_ptr < TimeDependentInflow >	TimeDependentInflowSharedPtr
	Pointer to a PulseWaveOutflow object. More...
typedef boost::shared_ptr < UndefinedInOutflow >	UndefinedInOutflowSharedPtr
	Pointer to a PulseWaveOutflow object. More...
typedef boost::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	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	ProblemType { eGeneral, eSolitaryWave, SIZE_ProblemType }
enum	VWIIterationType {   eFixedAlpha, eFixedWaveForcing, eFixedAlphaWaveForcing, eFixedWaveForcingWithSubIterationOnAlpha,   eVWIIterationTypeSize }

Functions
bool	operator== (const Array< OneD, NekDouble > &lhs, const Array< OneD, NekDouble > &rhs)
bool	IsEqual (const Array< OneD, const NekDouble > &lhs, const Array< OneD, const NekDouble > &rhs, NekDouble tol)
bool	operator== (const Array< TwoD, NekDouble > &lhs, const Array< TwoD, NekDouble > &rhs)
bool	IsEqual (const Array< TwoD, const NekDouble > &lhs, const Array< TwoD, const NekDouble > &rhs, NekDouble tol)
template<typename DataType >
void	DeleteStorage (DataType *data, unsigned int num)
template<typename Dim , typename DataType , typename ExtentListType >
boost::shared_ptr < boost::multi_array_ref < DataType, Dim::Value > >	CreateStorage (const ExtentListType &extent)
template<typename DataType >
boost::shared_ptr < boost::multi_array_ref < DataType, 1 > >	CreateStorage (unsigned int d1)
template<typename DataType >
boost::shared_ptr < boost::multi_array_ref < DataType, 2 > >	CreateStorage (unsigned int d1, unsigned int d2)
template<typename DataType >
boost::shared_ptr < boost::multi_array_ref < DataType, 3 > >	CreateStorage (unsigned int d1, unsigned int d2, unsigned int d3)
template<typename DataType >
boost::shared_ptr< DataType >	MakePtr (DataType *d)
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, unsigned int offset)
template<typename DataType >
Array< OneD, DataType >	operator+ (unsigned int 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, unsigned int n)
template<typename DataType >
bool	operator== (const Array< TwoD, DataType > &lhs, const Array< TwoD, DataType > &rhs)
template<typename DataType >
bool	operator!= (const Array< TwoD, DataType > &lhs, const Array< TwoD, DataType > &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 &))) template< typename DataType
LhsMatrixType 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 &))) template< typename RhsDataType
ResultDataType 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,())) template< typename DataType
RhsMatrixType 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,())) template< typename LhsDataType > void MultiplyEqual(NekMatrix< LhsDataType
	for (iterator iter=lhs.begin();iter!=lhs.end();++iter)
	NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX (MultiplyEqual,(1,(DNekMat &)),(1,(void)),(0,()),(1,(const NekDouble &))) template< typename ResultType
RhsMatrixType 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,())) template< typename DataType
RhsMatrixType 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(AddEqualNegatedLhs
template<typename DataType , typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >
DNekMat 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(AddNegatedLhs
template<typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >
DNekMat 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,())) template< typename DataType
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(SubtractNegatedLhs
template<typename DataType , typename RhsDataType , typename RhsMatrixType >
DNekMat 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(SubtractEqualNegatedLhs
template<typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >
DNekMat NekMatrix< typename NekMatrix< LhsDataType, LhsMatrixType >::NumberType, StandardMatrixTag >	Subtract (const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
	GENERATE_MULTIPLICATION_OPERATOR (NekMatrix, 2, NekMatrix, 2)
	GENERATE_MULTIPLICATION_OPERATOR (NekMatrix, 2, NekDouble, 0)
	GENERATE_MULTIPLICATION_OPERATOR (NekDouble, 0, NekMatrix, 2)
	GENERATE_MULTIPLICATION_OPERATOR (NekMatrix, 2, NekVector, 1)
	GENERATE_DIVISION_OPERATOR (NekMatrix, 2, NekMatrix, 2)
	GENERATE_ADDITION_OPERATOR (NekMatrix, 2, NekMatrix, 2)
	GENERATE_SUBTRACTION_OPERATOR (NekMatrix, 2, NekMatrix, 2)
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)
void	DiagonalBlockFullScalMatrixMultiply (NekVector< double > &result, const NekMatrix< NekMatrix< NekMatrix< NekDouble, StandardMatrixTag >, ScaledMatrixTag >, BlockMatrixTag > &lhs, const NekVector< double > &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< NekDouble, StandardMatrixTag > &result, const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs, typename boost::enable_if< boost::mpl::and_< CanGetRawPtr< NekMatrix< LhsDataType, LhsMatrixType > >, CanGetRawPtr< NekMatrix< RhsDataType, RhsMatrixType > > > >::type *p=0)
template<typename RhsInnerType , typename RhsMatrixType >
void	MultiplyEqual (NekMatrix< double, StandardMatrixTag > &result, const NekMatrix< RhsInnerType, RhsMatrixType > &rhs, typename boost::enable_if< boost::mpl::and_< boost::is_same< typename RawType< typename NekMatrix< RhsInnerType, RhsMatrixType >::NumberType >::type, double >, CanGetRawPtr< NekMatrix< RhsInnerType, RhsMatrixType > > > >::type *t=0)
template<typename DataType , typename RhsInnerType , typename RhsMatrixType >
void	MultiplyEqual (NekMatrix< DataType, StandardMatrixTag > &result, const NekMatrix< RhsInnerType, RhsMatrixType > &rhs, typename boost::enable_if< boost::mpl::or_< boost::mpl::not_< boost::is_same< typename RawType< typename NekMatrix< RhsInnerType, RhsMatrixType >::NumberType >::type, double > >, boost::mpl::not_< CanGetRawPtr< NekMatrix< RhsInnerType, RhsMatrixType > > > > >::type *t=0)
template<typename LhsDataType , typename RhsDataType , typename LhsMatrixType , typename RhsMatrixType >
NekMatrix< typename boost::remove_const< typename NekMatrix< LhsDataType, LhsMatrixType >::NumberType > ::type, StandardMatrixTag >	Multiply (const NekMatrix< LhsDataType, LhsMatrixType > &lhs, 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 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 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 LhsDataType , typename MatrixType >
void	NekMultiplyBandedMatrix (NekDouble *result, const NekMatrix< LhsDataType, MatrixType > &lhs, const NekDouble *rhs, typename boost::enable_if< CanGetRawPtr< NekMatrix< LhsDataType, MatrixType > > >::type *p=0)
template<typename DataType , typename LhsDataType >
void	NekMultiplyBandedMatrix (DataType *result, const NekMatrix< LhsDataType, BlockMatrixTag > &lhs, const DataType *rhs, typename boost::enable_if< boost::mpl::not_< CanGetRawPtr< NekMatrix< LhsDataType, BlockMatrixTag > > > >::type *p=0)
template<typename DataType , typename LhsInnerMatrixType >
void	FullBlockMatrixMultiply (NekVector< DataType > &result, const NekMatrix< LhsInnerMatrixType, BlockMatrixTag > &lhs, const NekVector< DataType > &rhs)
template<typename LhsInnerMatrixType >
void	DiagonalBlockMatrixMultiply (NekVector< double > &result, const NekMatrix< LhsInnerMatrixType, BlockMatrixTag > &lhs, const NekVector< double > &rhs)
void	NekMultiplyLowerTriangularMatrix (NekDouble *result, const NekMatrix< NekDouble, StandardMatrixTag > &lhs, const NekDouble *rhs)
void	NekMultiplyLowerTriangularMatrix (NekDouble *result, const NekMatrix< NekMatrix< NekDouble, StandardMatrixTag >, ScaledMatrixTag > &lhs, const NekDouble *rhs)
template<typename DataType , typename LhsDataType , typename MatrixType >
void	NekMultiplyLowerTriangularMatrix (DataType *result, const NekMatrix< LhsDataType, MatrixType > &lhs, const DataType *rhs)
void	NekMultiplyUpperTriangularMatrix (NekDouble *result, const NekMatrix< NekDouble, StandardMatrixTag > &lhs, const NekDouble *rhs)
void	NekMultiplyUpperTriangularMatrix (NekDouble *result, const NekMatrix< NekMatrix< NekDouble, StandardMatrixTag >, ScaledMatrixTag > &lhs, const NekDouble *rhs)
template<typename DataType , typename LhsDataType , typename MatrixType >
void	NekMultiplyUpperTriangularMatrix (DataType *result, const NekMatrix< LhsDataType, MatrixType > &lhs, const DataType *rhs)
template<typename InnerMatrixType , typename MatrixTag >
void	NekMultiplySymmetricMatrix (NekDouble *result, const NekMatrix< InnerMatrixType, MatrixTag > &lhs, const NekDouble *rhs, typename boost::enable_if< CanGetRawPtr< NekMatrix< InnerMatrixType, MatrixTag > > >::type *p=0)
template<typename InnerMatrixType , typename MatrixTag >
void	NekMultiplySymmetricMatrix (NekDouble *result, const NekMatrix< InnerMatrixType, MatrixTag > &lhs, const NekDouble *rhs, typename boost::enable_if< boost::mpl::not_< CanGetRawPtr< NekMatrix< InnerMatrixType, MatrixTag > > > >::type *p=0)
template<typename InnerMatrixType , typename MatrixTag >
void	NekMultiplyFullMatrix (NekDouble *result, const NekMatrix< InnerMatrixType, MatrixTag > &lhs, const NekDouble *rhs, typename boost::enable_if< CanGetRawPtr< NekMatrix< InnerMatrixType, MatrixTag > > >::type *p=0)
template<typename InnerMatrixType , typename MatrixTag >
void	NekMultiplyFullMatrix (NekDouble *result, const NekMatrix< InnerMatrixType, MatrixTag > &lhs, const NekDouble *rhs, typename boost::enable_if< boost::mpl::not_< CanGetRawPtr< NekMatrix< InnerMatrixType, MatrixTag > > > >::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, NEKTAR_BLOCK_MATRIX_TYPES,(1,(void)),(1,(NekVector< NekDouble > &)),(1,(const NekVector< NekDouble > &)))
	NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX (Multiply, NEKTAR_ALL_MATRIX_TYPES,(1,(NekVector< NekDouble >)),(0,()),(1,(const NekVector< NekDouble > &)))
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)
	BOOST_TYPEOF_REGISTER_TEMPLATE (NekMatrix, 2)
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<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<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<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<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<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<typename ResultDataType , typename InputDataType >
void	Divide (NekVector< ResultDataType > &result, const NekVector< InputDataType > &lhs, const NekDouble &rhs)
template void	Divide (NekVector< NekDouble > &result, const NekVector< NekDouble > &lhs, const NekDouble &rhs)
template<typename ResultDataType >
void	DivideEqual (NekVector< ResultDataType > &result, const NekDouble &rhs)
template void	DivideEqual (NekVector< NekDouble > &result, const NekDouble &rhs)
template<typename DataType >
NekVector< DataType >	Divide (const NekVector< DataType > &lhs, const NekDouble &rhs)
template NekVector< NekDouble >	Divide (const NekVector< NekDouble > &lhs, const NekDouble &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<typename ResultDataType , typename InputDataType >
void	MultiplyEqual (NekVector< ResultDataType > &result, const NekVector< InputDataType > &rhs)
template void	MultiplyEqual (NekVector< NekDouble > &result, const NekVector< NekDouble > &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<typename ResultDataType , typename InputDataType >
void	Multiply (NekVector< ResultDataType > &result, const NekVector< InputDataType > &lhs, const NekDouble &rhs)
template void	Multiply (NekVector< NekDouble > &result, const NekVector< NekDouble > &lhs, const NekDouble &rhs)
template<typename ResultDataType >
void	MultiplyEqual (NekVector< ResultDataType > &result, const NekDouble &rhs)
template void	MultiplyEqual (NekVector< NekDouble > &result, const NekDouble &rhs)
template<typename DataType >
NekVector< DataType >	Multiply (const NekVector< DataType > &lhs, const NekDouble &rhs)
template NekVector< NekDouble >	Multiply (const NekVector< NekDouble > &lhs, const NekDouble &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 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<typename DataType >
NekVector< DataType >	Multiply (const DataType &lhs, const NekVector< DataType > &rhs)
template NekVector< NekDouble >	Multiply (const NekDouble &lhs, const NekVector< NekDouble > &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<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<typename DataType >
NekPoint< DataType >	findPointAlongVector (const NekVector< DataType > &lhs, const DataType &t)
template NekPoint< NekDouble >	findPointAlongVector (const NekVector< NekDouble > &lhs, const NekDouble &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<typename DataType >
bool	operator!= (const NekVector< DataType > &lhs, const NekVector< DataType > &rhs)
template bool	operator!= (const NekVector< NekDouble > &lhs, const NekVector< NekDouble > &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<typename DataType >
DataType	L2Norm (const NekVector< DataType > &v)
template NekDouble	L2Norm (const NekVector< NekDouble > &v)
template<typename DataType >
DataType	InfinityNorm (const NekVector< DataType > &v)
template NekDouble	InfinityNorm (const NekVector< NekDouble > &v)
template<typename DataType >
NekVector< DataType >	Negate (const NekVector< DataType > &v)
template NekVector< NekDouble >	Negate (const NekVector< NekDouble > &v)
template<typename DataType >
void	NegateInPlace (NekVector< DataType > &v)
template void	NegateInPlace (NekVector< NekDouble > &v)
template<typename DataType >
DataType	Magnitude (const NekVector< DataType > &v)
template NekDouble	Magnitude (const NekVector< NekDouble > &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<typename DataType >
void	Normalize (NekVector< DataType > &v)
template void	Normalize (NekVector< NekDouble > &v)
void	NegateInPlace (NekDouble &v)
void	InvertInPlace (NekDouble &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<typename DataType >
std::string	AsString (const NekVector< DataType > &v)
template std::string	AsString (const NekVector< NekDouble > &v)
	BOOST_TYPEOF_REGISTER_TEMPLATE (NekVector, 1)
	GENERATE_MULTIPLICATION_OPERATOR (NekVector, 1, NekDouble, 0)
	GENERATE_MULTIPLICATION_OPERATOR (NekDouble, 0, NekVector, 1)
	GENERATE_MULTIPLICATION_OPERATOR (NekVector, 1, NekVector, 1)
	GENERATE_DIVISION_OPERATOR (NekVector, 1, NekDouble, 0)
	GENERATE_ADDITION_OPERATOR (NekVector, 1, NekVector, 1)
	GENERATE_SUBTRACTION_OPERATOR (NekVector, 1, NekVector, 1)
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)
void	convertCooToBco (const unsigned int blkRows, const unsigned int blkColumns, 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<typename DataType >
void	NegateInPlace (NekMatrix< DataType, StandardMatrixTag > &m)
template void	NegateInPlace (NekMatrix< double, 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...
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...
ExtrapolateFactory &	GetExtrapolateFactory ()
DNekMat	MappingIdealToRef (SpatialDomains::GeometrySharedPtr geom)
BoundaryFactory &	GetBoundaryFactory ()
PressureAreaFactory &	GetPressureAreaFactory ()

Variables
StandardMatrixTag boost::call_traits < LhsDataType > ::const_reference rhs typedef NekMatrix< LhsDataType, StandardMatrixTag >::iterator	iterator
const char *const	FlagTypeMap []
	String map for FlagType enumeration. More...
static FlagList	NullFlagList
	An empty flag list. More...
static Array< OneD, int >	NullInt1DArray
static Array< OneD, NekDouble >	NullNekDouble1DArray
static Array< OneD, Array < OneD, NekDouble > >	NullNekDoubleArrayofArray
	LhsDataType
	RhsMatrixType
	RhsDataType
StandardMatrixTag &	lhs
	LhsMatrixType
	NEKTAR_ALL_MATRIX_TYPES
	void
static DNekMatSharedPtr	NullDNekMatSharedPtr
static DNekScalMatSharedPtr	NullDNekScalMatSharedPtr
static DNekScalBlkMatSharedPtr	NullDNekScalBlkMatSharedPtr
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 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 []
static char const	kDefaultState [] = "default"

Detailed Description

<

class for meshing individual curves (1d meshing)

Todo:

: forward declare

Todo:

: forward declare

Todo:

: forward declare

Typedef Documentation

typedef boost::shared_ptr<ArterialPressureArea> Nektar::ArterialPressureAreaSharedPtr

Pointer to a PulseWaveOutflow object.

Definition at line 45 of file ArterialPressureArea.h.

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 60 of file ArtificialDiffusion.h.

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

A shared pointer to a artificial diffusion object.

Definition at line 51 of file ArtificialDiffusion.h.

typedef Array<OneD, NekDouble> Nektar::BCOEntryType

Definition at line 64 of file SparseMatrixFwd.hpp.

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

Definition at line 65 of file SparseMatrixFwd.hpp.

typedef BCOMatType::const_iterator Nektar::BCOMatTypeConstIt

Definition at line 66 of file SparseMatrixFwd.hpp.

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

Definition at line 67 of file SparseMatrixFwd.hpp.

typedef Array<OneD, BCOMatType> Nektar::BCOMatVector

Definition at line 68 of file SparseMatrixFwd.hpp.

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

Definition at line 64 of file NekTypeDefs.hpp.

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

Definition at line 73 of file NekTypeDefs.hpp.

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

Definition at line 68 of file NekTypeDefs.hpp.

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

Definition at line 75 of file NekTypeDefs.hpp.

typedef NekMatrix<DenseMatrix, BlockMatrixTag> Nektar::BlockMatrix

Definition at line 61 of file NekTypeDefs.hpp.

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

Definition at line 56 of file PulseWaveBoundary.h.

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 61 of file CellModel.h.

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

A shared pointer to an EquationSystem object.

Definition at line 56 of file CellModel.h.

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 61 of file CFSBndCond.h.

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

A shared pointer to a boundary condition object.

Definition at line 49 of file CFSBndCond.h.

typedef NekDouble Nektar::COOEntryType

Definition at line 57 of file SparseMatrixFwd.hpp.

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

Definition at line 58 of file SparseMatrixFwd.hpp.

typedef COOMatType::const_iterator Nektar::COOMatTypeConstIt

Definition at line 59 of file SparseMatrixFwd.hpp.

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

Definition at line 60 of file SparseMatrixFwd.hpp.

typedef Array<OneD, COOMatType> Nektar::COOMatVector

Definition at line 61 of file SparseMatrixFwd.hpp.

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

Definition at line 56 of file SparseMatrixFwd.hpp.

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

Definition at line 63 of file CoupledAssemblyMap.h.

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

Definition at line 65 of file CoupledLocalToGlobalC0ContMap.h.

typedef struct Nektar::coupledSolverMatrices Nektar::CoupledSolverMatrices

typedef NekMatrix<NekDouble, StandardMatrixTag> Nektar::DenseMatrix

Definition at line 53 of file NekTypeDefs.hpp.

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

Definition at line 60 of file NekTypeDefs.hpp.

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

Definition at line 72 of file NekTypeDefs.hpp.

typedef LinearSystem Nektar::DNekLinSys

Definition at line 83 of file NekTypeDefs.hpp.

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

Definition at line 84 of file NekTypeDefs.hpp.

typedef NekMatrix<NekDouble, StandardMatrixTag> Nektar::DNekMat

Definition at line 52 of file NekTypeDefs.hpp.

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

Definition at line 70 of file NekTypeDefs.hpp.

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

Definition at line 66 of file NekTypeDefs.hpp.

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

Definition at line 74 of file NekTypeDefs.hpp.

typedef LinearSystem Nektar::DNekScalLinSys

Definition at line 86 of file NekTypeDefs.hpp.

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

Definition at line 87 of file NekTypeDefs.hpp.

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

Definition at line 72 of file NekMatrixFwd.hpp.

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

Definition at line 73 of file NekMatrixFwd.hpp.

typedef NekVector<NekDouble> Nektar::DNekVec

Definition at line 49 of file NekTypeDefs.hpp.

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.

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

Definition at line 60 of file Extrapolate.h.

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

Definition at line 49 of file FilterMovingBody.h.

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

Definition at line 45 of file FilterMovingBody.h.

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

Definition at line 48 of file FilterMovingBody.h.

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

Definition at line 69 of file Extrapolate.h.

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

Definition at line 272 of file IncNavierStokes.h.

typedef unsigned int Nektar::IndexType

Definition at line 51 of file SparseMatrixFwd.hpp.

typedef Array<OneD, IndexType> Nektar::IndexVector

Definition at line 53 of file SparseMatrixFwd.hpp.

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

Definition at line 83 of file PulseWaveSystem.h.

typedef boost::shared_ptr<LymphaticPressureArea> Nektar::LymphaticPressureAreaSharedPtr

Pointer to a PulseWaveOutflow object.

Definition at line 45 of file LymphaticPressureArea.h.

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

Definition at line 48 of file MappingExtrapolate.h.

typedef double Nektar::NekDouble

Definition at line 44 of file NektarUnivTypeDefs.hpp.

typedef boost::int32_t Nektar::NekInt

Definition at line 46 of file NektarUnivTypeDefs.hpp.

typedef boost::int32_t Nektar::NekInt32

Definition at line 47 of file NektarUnivTypeDefs.hpp.

typedef boost::int64_t Nektar::NekInt64

Definition at line 48 of file NektarUnivTypeDefs.hpp.

typedef boost::uint32_t Nektar::NekUInt

Definition at line 49 of file NektarUnivTypeDefs.hpp.

typedef boost::uint32_t Nektar::NekUInt32

Definition at line 50 of file NektarUnivTypeDefs.hpp.

typedef boost::uint64_t Nektar::NekUInt64

Definition at line 51 of file NektarUnivTypeDefs.hpp.

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

Definition at line 54 of file PulseWavePressureArea.h.

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 54 of file Protocol.h.

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

A shared pointer to an EquationSystem object.

Definition at line 45 of file Protocol.h.

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

Definition at line 47 of file PulseWaveBoundary.h.

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

Definition at line 46 of file PulseWavePressureArea.h.

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

Definition at line 77 of file PulseWaveSystemOutput.h.

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

Definition at line 186 of file PulseWaveSystem.h.

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

Pointer to a PulseWaveOutflow object.

Definition at line 45 of file QInflow.h.

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

Pointer to a PulseWaveOutflow object.

Definition at line 45 of file RCROutflow.h.

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

Pointer to a PulseWaveOutflow object.

Definition at line 45 of file ROutflow.h.

typedef NekMatrix<DenseMatrix, ScaledMatrixTag> Nektar::ScaledMatrix

Definition at line 57 of file NekTypeDefs.hpp.

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

Definition at line 71 of file NekMatrixFwd.hpp.

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

Definition at line 54 of file StandardExtrapolate.h.

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 60 of file Stimulus.h.

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

A shared pointer to an EquationSystem object.

Definition at line 50 of file Stimulus.h.

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

Definition at line 54 of file SubSteppingExtrapolate.h.

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

Definition at line 47 of file SubSteppingExtrapolateWeakPressure.h.

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

Definition at line 51 of file CellModel.h.

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

Pointer to a PulseWaveOutflow object.

Definition at line 45 of file TerminalOutflow.h.

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

Pointer to a PulseWaveOutflow object.

Definition at line 45 of file TimeDependentInflow.h.

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

Pointer to a PulseWaveOutflow object.

Definition at line 45 of file UndefinedInOutflow.h.

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

Definition at line 45 of file VariableConverter.h.

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

Definition at line 156 of file VCSMapping.h.

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

Definition at line 99 of file VelocityCorrectionSchemeWeakPressure.h.

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

Definition at line 183 of file VelocityCorrectionScheme.h.

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

Definition at line 54 of file WeakPressureExtrapolate.h.

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

Definition at line 124 of file IncNavierStokes.h.

Enumeration Type Documentation

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

enum Nektar::AllowWrappingOfConstArrays

Enumerator
eVECTOR_WRAPPER

Definition at line 461 of file SharedArray.hpp.

    {
        eVECTOR_WRAPPER
    };

enum Nektar::Direction

Enumerator
xDir
yDir
zDir

Definition at line 71 of file NektarUnivTypeDefs.hpp.

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

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

enum Nektar::FlagType

Enumeration of flags for passing a list of options.

Enumerator
eUseGlobal

Definition at line 88 of file NektarUnivTypeDefs.hpp.

    {
        eUseGlobal
    };

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

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

enum Nektar::OutputFormat

Enumerator
eTecplot
eTecplotZones
eTecplotSingleBlock
eGmsh
eGnuplot

Definition at line 78 of file NektarUnivTypeDefs.hpp.

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

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 43 of file PointerWrapper.h.

    { 
        eWrapper, 
        eCopy 
    };

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 45 of file NonlinearPeregrine.h.

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

enum Nektar::UpwindTypePulse

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

Definition at line 46 of file PulseWaveSystem.h.

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

enum Nektar::VWIIterationType

Enumerator
eFixedAlpha
eFixedWaveForcing
eFixedAlphaWaveForcing
eFixedWaveForcingWithSubIterationOnAlpha
eVWIIterationTypeSize

Definition at line 55 of file VortexWaveInteraction.h.

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

Function Documentation

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

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

Definition at line 214 of file MatrixOperations.cpp.

References ASSERTL1, and lhs.

Referenced by Add().

    {
        ASSERTL1(lhs.GetRows() == rhs.GetRows(), std::string("Matrices with different row counts  ") + 
            boost::lexical_cast<std::string>(lhs.GetRows()) + std::string(" and ") +
            boost::lexical_cast<std::string>(rhs.GetRows()) + std::string(" can't be added."));
        ASSERTL1(lhs.GetColumns() == rhs.GetColumns(), std::string("Matrices with different column counts  ") + 
            boost::lexical_cast<std::string>(lhs.GetColumns()) + std::string(" and ") +
            boost::lexical_cast<std::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);
            }
        }
    }

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

References ASSERTL1, and lhs.

Referenced by Add().

    {
        ASSERTL1(lhs.GetRows() == rhs.GetRows(), std::string("Matrices with different row counts  ") + 
            boost::lexical_cast<std::string>(lhs.GetRows()) + std::string(" and ") +
            boost::lexical_cast<std::string>(rhs.GetRows()) + std::string(" can't be added."));
        ASSERTL1(lhs.GetColumns() == rhs.GetColumns(), std::string("Matrices with different column counts  ") + 
            boost::lexical_cast<std::string>(lhs.GetColumns()) + std::string(" and ") +
            boost::lexical_cast<std::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);
            }
        }
    }

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

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

Definition at line 261 of file MatrixOperations.cpp.

References Add().

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

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 261 of file MatrixOperations.cpp.

References Add().

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

template<typename DataType >

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

Definition at line 431 of file NekVector.cpp.

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

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

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

template<typename LhsDataType , typename RhsDataType >

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

Definition at line 502 of file NekVector.cpp.

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

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

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

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

Definition at line 169 of file MatrixOperations.cpp.

References ASSERTL1.

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

    {
        ASSERTL1(result.GetRows() == rhs.GetRows(), std::string("Matrices with different row counts  ") + 
            boost::lexical_cast<std::string>(result.GetRows()) + std::string(" and ") +
            boost::lexical_cast<std::string>(rhs.GetRows()) + std::string(" can't be added."));
        ASSERTL1(result.GetColumns() == rhs.GetColumns(), std::string("Matrices with different column counts  ") + 
            boost::lexical_cast<std::string>(result.GetColumns()) + std::string(" and ") +
            boost::lexical_cast<std::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);
            }
        }
    }

template<typename DataType >

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

Definition at line 468 of file NekVector.cpp.

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

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

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

template<typename DataType , typename RhsDataType , typename RhsMatrixType >

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

Definition at line 190 of file MatrixOperations.cpp.

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

    {
        ASSERTL1(result.GetRows() == rhs.GetRows(), std::string("Matrices with different row counts  ") + 
            boost::lexical_cast<std::string>(result.GetRows()) + std::string(" and ") +
            boost::lexical_cast<std::string>(rhs.GetRows()) + std::string(" can't be added."));
        ASSERTL1(result.GetColumns() == rhs.GetColumns(), std::string("Matrices with different column counts  ") + 
            boost::lexical_cast<std::string>(result.GetColumns()) + std::string(" and ") +
            boost::lexical_cast<std::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);
            }
        }
    }

template<typename DataType >

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

Definition at line 481 of file NekVector.cpp.

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

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

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

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 235 of file MatrixOperations.cpp.

References ASSERTL1, and lhs.

    {
        ASSERTL1(lhs.GetRows() == rhs.GetRows(), std::string("Matrices with different row counts  ") + 
            boost::lexical_cast<std::string>(lhs.GetRows()) + std::string(" and ") +
            boost::lexical_cast<std::string>(rhs.GetRows()) + std::string(" can't be added."));
        ASSERTL1(lhs.GetColumns() == rhs.GetColumns(), std::string("Matrices with different column counts  ") + 
            boost::lexical_cast<std::string>(lhs.GetColumns()) + std::string(" and ") +
            boost::lexical_cast<std::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);
            }
        }
    }

template<typename DataType >

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

Definition at line 446 of file NekVector.cpp.

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

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

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

template<typename DataType >

std::string Nektar::AsString

(

const NekVector< DataType > &

v

)

Definition at line 1045 of file NekVector.cpp.

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

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

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

template std::string Nektar::AsString

(

const NekVector< NekDouble > &

v

)

Nektar::BOOST_TYPEOF_REGISTER_TEMPLATE	(	NekMatrix	,
		2
	)

Nektar::BOOST_TYPEOF_REGISTER_TEMPLATE	(	NekVector	,
		1
	)

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

Definition at line 48 of file SparseUtils.cpp.

Referenced by Nektar::MultiRegions::GlobalMatrix::GlobalMatrix(), and Nektar::MultiRegions::GlobalLinSysIterativeStaticCond::v_AssembleSchurComplement().

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

template<typename ConstDataType , typename DataType >

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

Definition at line 763 of file SharedArray.hpp.

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

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

    {
        if( dest.num_elements() != source.num_elements() )
        {
            dest = Array<OneD, DataType>(source.num_elements());
        }

        std::copy(source.data(), source.data() + source.num_elements(), dest.data());
    }

template<typename ConstDataType , typename DataType >

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

Definition at line 774 of file SharedArray.hpp.

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

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

    {
        if( dest.num_elements() != n )
        {
            dest = Array<OneD, DataType>(n);
        }

        std::copy(source.data(), source.data() + n, dest.data());
    }

template<typename Dim , typename DataType , typename ExtentListType >

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

(

const ExtentListType &

extent

)

Definition at line 193 of file ArrayPolicies.hpp.

References Nektar::MemoryManager< DataType >::RawAllocate().

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

    {
        typedef boost::multi_array_ref<DataType, Dim::Value> ArrayType;
        unsigned int size = std::accumulate(extent.begin(), extent.end(), 1, 
            std::multiplies<unsigned int>());
        DataType* storage = MemoryManager<DataType>::RawAllocate(size);
        return MemoryManager<ArrayType>::AllocateSharedPtrD(
                boost::bind(DeleteStorage<DataType>, storage, size),
                storage, extent);
    }

template<typename DataType >

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

(

unsigned int

d1

)

Definition at line 206 of file ArrayPolicies.hpp.

    {
        std::vector<unsigned int> extents(1, d1);
        return CreateStorage<OneD, DataType>(extents);
    } 

template<typename DataType >

boost::shared_ptr<boost::multi_array_ref<DataType, 2> > Nektar::CreateStorage	(	unsigned int	d1,
		unsigned int	d2
	)

Definition at line 214 of file ArrayPolicies.hpp.

    {
        unsigned int vals[]  = {d1, d2};
        std::vector<unsigned int> extents(vals, vals+2);
        return CreateStorage<TwoD, DataType>(extents);
    }

template<typename DataType >

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

Definition at line 223 of file ArrayPolicies.hpp.

    {
        unsigned int vals[]  = {d1, d2, d3};
        std::vector<unsigned int> extents(vals, vals+3);
        return CreateStorage<ThreeD, DataType>(extents);
    }

template<typename DataType >

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

Definition at line 812 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;
    }

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

template<typename DataType >

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

Definition at line 1028 of file NekVector.cpp.

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

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

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

template<typename DataType >

void Nektar::DeleteStorage	(	DataType *	data,
		unsigned int	num
	)

Definition at line 185 of file ArrayPolicies.hpp.

References Nektar::MemoryManager< DataType >::RawDeallocate().

    {
        ArrayDestructionPolicy<DataType>::Destroy(data, num);
        MemoryManager<DataType>::RawDeallocate(data, num);
    }

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

Definition at line 263 of file MatrixVectorMultiplication.cpp.

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

Referenced by Nektar::MultiRegions::GlobalLinSysStaticCond::v_Solve().

    {
        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::Dgemv('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);
        }
    }

template<typename LhsInnerMatrixType >

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

Definition at line 203 of file MatrixVectorMultiplication.cpp.

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

Referenced by Multiply().

    {
        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 LhsInnerMatrixType* block = lhs.GetBlockPtr(blockRow, blockRow);
            if( !block )
            {
                continue;
            }

            double* resultWrapper = result_ptr + curResultRow;            
            const double* 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);
        }
    }

template<typename DataType >

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

Definition at line 460 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);
    }

template<typename ResultDataType , typename InputDataType >

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

Definition at line 604 of file NekVector.cpp.

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

Referenced by Divide().

    {
        ResultDataType* r_buf = result.GetRawPtr();
        typename boost::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;
        }
    }

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

template<typename DataType >

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

Definition at line 642 of file NekVector.cpp.

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

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

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

template<typename ResultDataType >

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

Definition at line 624 of file NekVector.cpp.

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

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

    {
        ResultDataType* r_buf = result.GetRawPtr();

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

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

template<typename DataType >

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

Definition at line 992 of file NekVector.cpp.

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

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

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

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

template<typename DataType >

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

Definition at line 829 of file NekVector.cpp.

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

        return result;
    }

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

Nektar::for

(

iterator

iter = lhs.begin(); iter != lhs.end(); ++iter

)

Definition at line 100 of file MatrixOperations.cpp.

Referenced by ProjectMeshEllipsoidAndRefine(), and ProjectMeshSphereAndRefine().

        {
            *iter *= rhs;
        }

template<typename DataType >

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

Definition at line 473 of file NekPoint.hpp.

References iterator.

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

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

template<typename DataType >

std::vector< DataType > Nektar::FromString

(

const std::string &

str

)

Definition at line 873 of file NekVector.cpp.

References iterator.

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

template<typename DataType , typename LhsInnerMatrixType >

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

Definition at line 138 of file MatrixVectorMultiplication.cpp.

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

Referenced by Multiply().

    {
        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 boost::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];
                }
            }
        }
    }

Nektar::GENERATE_ADDITION_OPERATOR	(	NekMatrix	,
		2	,
		NekMatrix	,
		2
	)

Nektar::GENERATE_ADDITION_OPERATOR	(	NekVector	,
		1	,
		NekVector	,
		1
	)

Nektar::GENERATE_DIVISION_OPERATOR	(	NekMatrix	,
		2	,
		NekMatrix	,
		2
	)

Nektar::GENERATE_DIVISION_OPERATOR	(	NekVector	,
		1	,
		NekDouble	,
		0
	)

Nektar::GENERATE_MULTIPLICATION_OPERATOR	(	NekMatrix	,
		2	,
		NekMatrix	,
		2
	)

Nektar::GENERATE_MULTIPLICATION_OPERATOR	(	NekMatrix	,
		2	,
		NekDouble	,
		0
	)

Nektar::GENERATE_MULTIPLICATION_OPERATOR	(	NekDouble	,
		0	,
		NekMatrix	,
		2
	)

Nektar::GENERATE_MULTIPLICATION_OPERATOR	(	NekMatrix	,
		2	,
		NekVector	,
		1
	)

Nektar::GENERATE_MULTIPLICATION_OPERATOR	(	NekVector	,
		1	,
		NekDouble	,
		0
	)

Nektar::GENERATE_MULTIPLICATION_OPERATOR	(	NekDouble	,
		0	,
		NekVector	,
		1
	)

Nektar::GENERATE_MULTIPLICATION_OPERATOR	(	NekVector	,
		1	,
		NekVector	,
		1
	)

Nektar::GENERATE_SUBTRACTION_OPERATOR	(	NekMatrix	,
		2	,
		NekMatrix	,
		2
	)

Nektar::GENERATE_SUBTRACTION_OPERATOR	(	NekVector	,
		1	,
		NekVector	,
		1
	)

ArtificialDiffusionFactory & Nektar::GetArtificialDiffusionFactory

(

)

Declaration of the artificial diffusion factory singleton.

Definition at line 43 of file ArtificialDiffusion.cpp.

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

{
    typedef Loki::SingletonHolder<ArtificialDiffusionFactory,
                                  Loki::CreateUsingNew,
                                  Loki::NoDestroy,
                                  Loki::SingleThreaded> Type;
    return Type::Instance();
}

BoundaryFactory & Nektar::GetBoundaryFactory

(

)

Definition at line 69 of file PulseWaveBoundary.cpp.

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

    {
        typedef Loki::SingletonHolder<BoundaryFactory,
                                      Loki::CreateUsingNew,
                                      Loki::NoDestroy > Type;
        return Type::Instance();
    }

CellModelFactory & Nektar::GetCellModelFactory

(

)

Definition at line 47 of file CellModel.cpp.

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

    {
        typedef Loki::SingletonHolder<CellModelFactory,
            Loki::CreateUsingNew,
            Loki::NoDestroy > Type;
        return Type::Instance();
    }

CFSBndCondFactory & Nektar::GetCFSBndCondFactory

(

)

Declaration of the boundary condition factory singleton.

Definition at line 42 of file CFSBndCond.cpp.

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

{
    typedef Loki::SingletonHolder<CFSBndCondFactory,
                                  Loki::CreateUsingNew,
                                  Loki::NoDestroy,
                                  Loki::SingleThreaded> Type;
    return Type::Instance();
}

ExtrapolateFactory & Nektar::GetExtrapolateFactory

(

)

Definition at line 50 of file Extrapolate.cpp.

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

    {
        typedef Loki::SingletonHolder<ExtrapolateFactory,
                                      Loki::CreateUsingNew,
                                      Loki::NoDestroy,
                                      Loki::SingleThreaded > Type;
        return Type::Instance();
    }

MemPool & Nektar::GetMemoryPool

(

)

Definition at line 37 of file ThreadSpecificPool.cpp.

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

    {
        typedef Loki::SingletonHolder<MemPool ,
                Loki::CreateUsingNew,
                Loki::NoDestroy,
                Loki::SingleThreaded> Type;
        return Type::Instance();
    }

PressureAreaFactory & Nektar::GetPressureAreaFactory

(

)

Definition at line 64 of file PulseWavePressureArea.cpp.

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

    {
        typedef Loki::SingletonHolder<PressureAreaFactory,
                                      Loki::CreateUsingNew,
                                      Loki::NoDestroy > Type;
        return Type::Instance();
    }

ProtocolFactory & Nektar::GetProtocolFactory

(

)

Definition at line 40 of file Protocol.cpp.

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

    {
        typedef Loki::SingletonHolder<ProtocolFactory,
        Loki::CreateUsingNew,
        Loki::NoDestroy > Type;
        return Type::Instance();
    }

StimulusFactory & Nektar::GetStimulusFactory

(

)

Definition at line 45 of file Stimulus.cpp.

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

    {
        typedef Loki::SingletonHolder<StimulusFactory,
        Loki::CreateUsingNew,
        Loki::NoDestroy > Type;
        return Type::Instance();
    }

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

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 69 of file ExactSolverToro.cpp.

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

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

template<typename DataType >

DataType Nektar::InfinityNorm

(

const NekVector< DataType > &

v

)

Definition at line 932 of file NekVector.cpp.

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

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

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

template NekDouble Nektar::InfinityNorm

(

const NekVector< NekDouble > &

v

)

void Nektar::InvertInPlace

(

NekDouble &

v

)

Definition at line 1025 of file NekVector.cpp.

{ v = 1.0/v; }

bool Nektar::IsEqual	(	const Array< OneD, const NekDouble > &	lhs,
		const Array< OneD, const NekDouble > &	rhs,
		NekDouble	tol
	)

Definition at line 45 of file ArrayEqualityComparison.cpp.

Referenced by operator==().

    {
        if( lhs.num_elements() != rhs.num_elements() )
        {
            return false;
        }
        
        if( lhs.data() == rhs.data() )
        {
            return true;
        }
        
        for(unsigned int i = 0; i < lhs.num_elements(); ++i)
        {
            if( fabs(lhs[i]-rhs[i]) > tol )
            {
                return false;
            }
        }
        
        return true;
    }

bool Nektar::IsEqual	(	const Array< TwoD, const NekDouble > &	lhs,
		const Array< TwoD, const NekDouble > &	rhs,
		NekDouble	tol
	)

Definition at line 76 of file ArrayEqualityComparison.cpp.

    {
        if( (lhs.GetRows() != rhs.GetRows()) || 
            (lhs.GetColumns() != rhs.GetColumns()) )
        {
            return false;
        }
        
        if( lhs.data() == rhs.data() )
        {
            return true;
        }

        for(unsigned int i = 0; i < lhs.GetRows(); ++i)
        {
            for(unsigned int j = 0; j < lhs.GetColumns(); ++j)
            {
                if( fabs(lhs[i][j]-rhs[i][j]) > tol )
                {
                    return false;
                }
            }
        }
        
        return true;
    }

template<typename DataType >

DataType Nektar::L1Norm

(

const NekVector< DataType > &

v

)

Todo:

Do the Norms with Blas where applicable.

Definition at line 898 of file NekVector.cpp.

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

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

    {
        typedef NekVector<DataType> VectorType;

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

        return result;
    }

template NekDouble Nektar::L1Norm

(

const NekVector< NekDouble > &

v

)

template<typename DataType >

DataType Nektar::L2Norm

(

const NekVector< DataType > &

v

)

Definition at line 915 of file NekVector.cpp.

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

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

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

template NekDouble Nektar::L2Norm

(

const NekVector< NekDouble > &

v

)

template<typename DataType >

DataType Nektar::Magnitude

(

const NekVector< DataType > &

v

)

Definition at line 976 of file NekVector.cpp.

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

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

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

template NekDouble Nektar::Magnitude

(

const NekVector< NekDouble > &

v

)

template<typename DataType >

boost::shared_ptr<DataType> Nektar::MakePtr

(

DataType *

d

)

Definition at line 45 of file BoostUtil.hpp.

    {
        return boost::shared_ptr<DataType>(d);
    }

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

inline

Definition at line 78 of file LinearElasticSystem.cpp.

References eFULL.

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

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

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 42 of file MatrixOperations.cpp.

References lhs.

Referenced by DiagonalBlockMatrixMultiply(), FullBlockMatrixMultiply(), Multiply(), and Nektar::MultiRegions::GlobalLinSysStaticCond::v_Solve().

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

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

Definition at line 62 of file MatrixOperations.cpp.

References Multiply().

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

template<typename DataType , typename LhsDataType , typename MatrixType >

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

Definition at line 541 of file MatrixVectorMultiplication.cpp.

References Multiply().

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

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 508 of file MatrixVectorMultiplication.cpp.

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

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

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

Definition at line 74 of file MatrixOperations.cpp.

References Multiply().

    {
        Multiply(result, rhs, lhs);
    }

template<typename DataType , typename LhsInnerMatrixType >

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

Definition at line 523 of file MatrixVectorMultiplication.cpp.

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

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

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

Definition at line 86 of file MatrixOperations.cpp.

References Multiply().

    {
        return Multiply(rhs, lhs);
    }

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 146 of file MatrixOperations.cpp.

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

    {
        ASSERTL1(lhs.GetColumns() == rhs.GetRows(), std::string("A left side matrix with column count ") + 
            boost::lexical_cast<std::string>(lhs.GetColumns()) + 
            std::string(" and a right side matrix with row count ") + 
            boost::lexical_cast<std::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);
        }
    }

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

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

Definition at line 236 of file MatrixOperationsDeclarations.hpp.

References Multiply().

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

template<typename DataType , typename LhsDataType , typename MatrixType >

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

Definition at line 475 of file MatrixVectorMultiplication.cpp.

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

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

template<typename ResultDataType , typename InputDataType >

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

Definition at line 657 of file NekVector.cpp.

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

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

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

template<typename DataType , typename InputDataType >

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

Definition at line 692 of file NekVector.cpp.

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

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

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

template<typename ResultDataType , typename InputDataType >

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

Definition at line 706 of file NekVector.cpp.

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

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

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

template<typename DataType >

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

Definition at line 742 of file NekVector.cpp.

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

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

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

template<typename ResultDataType , typename InputDataType >

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

Definition at line 756 of file NekVector.cpp.

References Multiply().

    {
                Multiply(result, rhs, lhs);
    }

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

template<typename DataType >

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

Definition at line 790 of file NekVector.cpp.

References Multiply().

    {
                return Multiply(rhs, lhs);
    }

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

template<typename LhsDataType >

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

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

template<typename RhsInnerType , typename RhsMatrixType >

void Nektar::MultiplyEqual	(	NekMatrix< double, StandardMatrixTag > &	result,
		const NekMatrix< RhsInnerType, RhsMatrixType > &	rhs,
		typename boost::enable_if< boost::mpl::and_< boost::is_same< typename RawType< typename NekMatrix< RhsInnerType, RhsMatrixType >::NumberType >::type, double >, CanGetRawPtr< NekMatrix< RhsInnerType, RhsMatrixType > > > >::type *	t = 0
	)

Definition at line 161 of file MatrixOperationsDeclarations.hpp.

References ASSERTL0, and eFULL.

    {
        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;
        }
        double scale = rhs.Scale();
        Array<OneD, double>& buf = result.GetTempSpace();
        Blas::Dgemm(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();
    }

template<typename DataType , typename RhsInnerType , typename RhsMatrixType >

void Nektar::MultiplyEqual	(	NekMatrix< DataType, StandardMatrixTag > &	result,
		const NekMatrix< RhsInnerType, RhsMatrixType > &	rhs,
		typename boost::enable_if< boost::mpl::or_< boost::mpl::not_< boost::is_same< typename RawType< typename NekMatrix< RhsInnerType, RhsMatrixType >::NumberType >::type, double > >, boost::mpl::not_< CanGetRawPtr< NekMatrix< RhsInnerType, RhsMatrixType > > > > >::type *	t = 0
	)

Definition at line 198 of file MatrixOperationsDeclarations.hpp.

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

    {
        ASSERTL1(result.GetColumns() == rhs.GetRows(), std::string("A left side matrix with column count ") + 
            boost::lexical_cast<std::string>(result.GetColumns()) + 
            std::string(" and a right side matrix with row count ") + 
            boost::lexical_cast<std::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;
    }

template<typename ResultDataType , typename InputDataType >

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

Definition at line 675 of file NekVector.cpp.

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

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

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

template<typename ResultDataType >

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

Definition at line 726 of file NekVector.cpp.

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

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

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

template<typename ResultDataType , typename InputDataType >

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

Definition at line 764 of file NekVector.cpp.

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

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

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

template<typename DataType >

void Nektar::negate

(

NekPoint< DataType > &

rhs

)

Definition at line 373 of file NekPoint.hpp.

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

Referenced by Nektar::NekMeshUtils::DelaunayTriangle::incircleadaptTRI(), and Nektar::NekMeshUtils::DelaunayTriangle::orient3dadapt().

    {
        rhs.negate();
    }

template<typename DataType >

NekVector< DataType > Nektar::Negate

(

const NekVector< DataType > &

v

)

Definition at line 947 of file NekVector.cpp.

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

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

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

template NekVector<NekDouble> Nektar::Negate

(

const NekVector< NekDouble > &

v

)

template<typename DataType >

void Nektar::NegateInPlace

(

NekMatrix< DataType, ScaledMatrixTag > &

v

)

Definition at line 239 of file ScaledMatrix.cpp.

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

template void Nektar::NegateInPlace

(

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

v

)

template<typename DataType >

void Nektar::NegateInPlace

(

NekMatrix< DataType, StandardMatrixTag > &

m

)

Definition at line 819 of file StandardMatrix.cpp.

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

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

template void Nektar::NegateInPlace

(

NekMatrix< double, StandardMatrixTag > &

v

)

template<typename DataType >

void Nektar::NegateInPlace

(

NekVector< DataType > &

v

)

Definition at line 962 of file NekVector.cpp.

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

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

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

template void Nektar::NegateInPlace

(

NekVector< NekDouble > &

v

)

void Nektar::NegateInPlace

(

NekDouble &

v

)

Definition at line 1024 of file NekVector.cpp.

{ v = -v; }

template<typename LhsDataType , typename MatrixType >

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

Definition at line 101 of file MatrixVectorMultiplication.cpp.

Referenced by Multiply().

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

    }

template<typename DataType , typename LhsDataType >

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

Definition at line 126 of file MatrixVectorMultiplication.cpp.

References ErrorUtil::efatal, and NEKERROR.

    {
        NEKERROR(ErrorUtil::efatal, "Banded block matrix multiplication not yet implemented");
    }

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

Definition at line 110 of file MatrixOperations.cpp.

References ASSERTL1, and lhs.

Referenced by Multiply(), and NekMultiplyFullMatrixFullMatrix().

    {
        ASSERTL1(lhs.GetColumns() == rhs.GetRows(), std::string("A left side matrix with column count ") + 
            boost::lexical_cast<std::string>(lhs.GetColumns()) + 
            std::string(" and a right side matrix with row count ") + 
            boost::lexical_cast<std::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;
            }
        }
    }

template<typename DataType , typename LhsDataType , typename MatrixType >

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

Definition at line 79 of file MatrixVectorMultiplication.cpp.

References lhs.

Referenced by Multiply().

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

template<typename DataType , typename LhsDataType >

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

Definition at line 91 of file MatrixVectorMultiplication.cpp.

References Vmath::Vmul().

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

template<typename InnerMatrixType , typename MatrixTag >

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

Definition at line 442 of file MatrixVectorMultiplication.cpp.

Referenced by Multiply().

    {
        const unsigned int* size = lhs.GetSize();

        char t = lhs.GetTransposeFlag();

        double alpha = lhs.Scale();
        const double* a = lhs.GetRawPtr();
        int lda = size[0];
        const double* x = rhs;
        int incx = 1;
        double beta = 0.0;
        double* y = result;
        int incy = 1;
        
        Blas::Dgemv(t, size[0], size[1], alpha, a, lda, x, incx, beta, y, incy);
    }

template<typename InnerMatrixType , typename MatrixTag >

void Nektar::NekMultiplyFullMatrix	(	NekDouble *	result,
		const NekMatrix< InnerMatrixType, MatrixTag > &	lhs,
		const NekDouble *	rhs,
		typename boost::enable_if< boost::mpl::not_< CanGetRawPtr< NekMatrix< InnerMatrixType, MatrixTag > > > >::type *	p = 0
	)

Definition at line 465 of file MatrixVectorMultiplication.cpp.

References NekMultiplyUnspecializedMatrixType().

    {
        NekMultiplyUnspecializedMatrixType(result, lhs, rhs);
    }

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

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

Definition at line 116 of file MatrixOperationsDeclarations.hpp.

References ASSERTL1, and eFULL.

    {
        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::Dgemm(lhs.GetTransposeFlag(), rhs.GetTransposeFlag(), M, N, K,
                    lhs.Scale()*rhs.Scale(), lhs.GetRawPtr(), LDA,
                    rhs.GetRawPtr(), LDB, 0.0,
                    result.GetRawPtr(), result.GetRows());
    }

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

References NekMultiplyDefaultImpl().

Referenced by Multiply().

    {
        NekMultiplyDefaultImpl(result, lhs, rhs);
    }

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

Definition at line 327 of file MatrixVectorMultiplication.cpp.

References CellMLToNektar.pycml::copy().

Referenced by Multiply(), and NekMultiplyLowerTriangularMatrix().

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

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

Definition at line 341 of file MatrixVectorMultiplication.cpp.

References lhs, and NekMultiplyLowerTriangularMatrix().

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

template<typename DataType , typename LhsDataType , typename MatrixType >

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

Definition at line 354 of file MatrixVectorMultiplication.cpp.

References lhs.

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

template<typename InnerMatrixType , typename MatrixTag >

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

Definition at line 412 of file MatrixVectorMultiplication.cpp.

Referenced by Multiply().

    {
        const unsigned int* size = lhs.GetSize();

        double alpha = lhs.Scale();
        const double* a = lhs.GetRawPtr();
        const double* x = rhs;
        int incx = 1;
        double beta = 0.0;
        double* y = result;
        int incy = 1;

        Blas::Dspmv('U', size[0], alpha, a, x, incx, beta, y, incy);
    }

template<typename InnerMatrixType , typename MatrixTag >

void Nektar::NekMultiplySymmetricMatrix	(	NekDouble *	result,
		const NekMatrix< InnerMatrixType, MatrixTag > &	lhs,
		const NekDouble *	rhs,
		typename boost::enable_if< boost::mpl::not_< CanGetRawPtr< NekMatrix< InnerMatrixType, MatrixTag > > > >::type *	p = 0
	)

Definition at line 432 of file MatrixVectorMultiplication.cpp.

References NekMultiplyUnspecializedMatrixType().

    {
        NekMultiplyUnspecializedMatrixType(result, lhs, rhs);
    }

template<typename DataType , typename LhsDataType , typename MatrixType >

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

Definition at line 63 of file MatrixVectorMultiplication.cpp.

References lhs.

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

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

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

Definition at line 369 of file MatrixVectorMultiplication.cpp.

References CellMLToNektar.pycml::copy().

Referenced by Multiply(), and NekMultiplyUpperTriangularMatrix().

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

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

Definition at line 383 of file MatrixVectorMultiplication.cpp.

References lhs, and NekMultiplyUpperTriangularMatrix().

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

template<typename DataType , typename LhsDataType , typename MatrixType >

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

Definition at line 396 of file MatrixVectorMultiplication.cpp.

References lhs.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template<typename DataType >

void Nektar::Normalize

(

NekVector< DataType > &

v

)

Definition at line 1012 of file NekVector.cpp.

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

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

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

template void Nektar::Normalize

(

NekVector< NekDouble > &

v

)

template<typename DataType >

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

Definition at line 384 of file NekMemoryManager.hpp.

    {
        return !(lhs == rhs);
    }

template<typename T1 , typename T2 >

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

Definition at line 739 of file SharedArray.hpp.

    {
        return !(lhs == rhs);
    }

template<typename DataType >

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

Definition at line 800 of file SharedArray.hpp.

    {
        return !(lhs == rhs);
    }

template<typename DataType >

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

Definition at line 862 of file NekVector.cpp.

    {
        return !(lhs == rhs);
    }

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

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

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

Definition at line 434 of file NekPoint.hpp.

References lhs.

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

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

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

Definition at line 443 of file NekPoint.hpp.

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

template<typename DataType >

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

Definition at line 380 of file NekPoint.hpp.

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

template<typename DataType >

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

Definition at line 389 of file NekPoint.hpp.

References lhs.

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

template<typename DataType >

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

Definition at line 398 of file NekPoint.hpp.

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

template<typename DataType >

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

Definition at line 745 of file SharedArray.hpp.

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

template<typename DataType >

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

Definition at line 751 of file SharedArray.hpp.

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

template<typename DataType >

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

Definition at line 407 of file NekPoint.hpp.

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

template<typename DataType >

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

Definition at line 416 of file NekPoint.hpp.

References lhs.

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

template<typename DataType >

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

Definition at line 425 of file NekPoint.hpp.

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

template<typename DataType >

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

Definition at line 452 of file NekPoint.hpp.

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

template<typename DataType , typename FormType >

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

Definition at line 56 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;
    }

template<typename SparseStorageType >

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

Definition at line 87 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;
    }

template<typename SparseStorageType >

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

Definition at line 115 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;
    }

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

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

template<typename DataType >

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

Definition at line 496 of file NekPoint.hpp.

References CellMLToNektar.cellml_metadata::p.

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

template<typename DataType >

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

Definition at line 802 of file NekVector.cpp.

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

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

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

Definition at line 39 of file ArrayEqualityComparison.cpp.

References IsEqual().

    {     
        return IsEqual(lhs,rhs);
    }

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

Definition at line 71 of file ArrayEqualityComparison.cpp.

References IsEqual().

    {
        return IsEqual(lhs,rhs);
    }

template<typename DataType >

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

Definition at line 378 of file NekMemoryManager.hpp.

    {
        return true;
    }

template<typename T1 , typename T2 >

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

Definition at line 715 of file SharedArray.hpp.

    {
        if( lhs.num_elements() != rhs.num_elements() )
        {
            return false;
        }

        if( lhs.data() == rhs.data() )
        {
            return true;
        }

        for(unsigned int i = 0; i < lhs.num_elements(); ++i)
        {
            if( lhs[i] != rhs[i] )
            {
                return false;
            }
        }

        return true;
    }

template<typename DataType >

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

Definition at line 794 of file SharedArray.hpp.

References Nektar::Array< TwoD, const DataType >::m_data.

    {
        return *lhs.m_data == *rhs.m_data;
    }

template<typename DataType >

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

Definition at line 846 of file NekVector.cpp.

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

    {
        if( lhs.GetDimension() != rhs.GetDimension() )
        {
            return false;
        }

        return std::equal(lhs.begin(), lhs.end(), rhs.begin());
    }

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

template<typename DataType , typename FormType >

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

Definition at line 84 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;
    }

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 119 of file ExactSolverToro.cpp.

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

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

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

Definition at line 273 of file MatrixOperations.cpp.

References ASSERTL1, and lhs.

Referenced by Subtract(), and Nektar::MultiRegions::GlobalLinSysStaticCond::v_Solve().

    {
        ASSERTL1(lhs.GetRows() == rhs.GetRows(), std::string("Matrices with different row counts  ") + 
            boost::lexical_cast<std::string>(lhs.GetRows()) + std::string(" and ") +
            boost::lexical_cast<std::string>(rhs.GetRows()) + std::string(" can't be subtracted."));
        ASSERTL1(lhs.GetColumns() == rhs.GetColumns(), std::string("Matrices with different column counts  ") + 
            boost::lexical_cast<std::string>(lhs.GetColumns()) + std::string(" and ") +
            boost::lexical_cast<std::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);
            }
        }
    }

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 364 of file MatrixOperations.cpp.

References Subtract().

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

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

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

Definition at line 364 of file MatrixOperations.cpp.

References Subtract().

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

template<typename ResultDataType , typename InputDataType >

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

Definition at line 515 of file NekVector.cpp.

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

    {
        ResultDataType* r_buf = result.GetRawPtr();
        typename boost::add_const<InputDataType>::type* lhs_buf = lhs.GetRawPtr();
        typename boost::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];
        }
    }

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

template<typename DataType >

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

Definition at line 590 of file NekVector.cpp.

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

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

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

template<typename DataType , typename RhsDataType , typename RhsMatrixType >

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

Definition at line 320 of file MatrixOperations.cpp.

References ASSERTL1.

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

    {
        ASSERTL1(result.GetRows() == rhs.GetRows(), std::string("Matrices with different row counts  ") + 
            boost::lexical_cast<std::string>(result.GetRows()) + std::string(" and ") +
            boost::lexical_cast<std::string>(rhs.GetRows()) + std::string(" can't be subtracted."));
        ASSERTL1(result.GetColumns() == rhs.GetColumns(), std::string("Matrices with different column counts  ") + 
            boost::lexical_cast<std::string>(result.GetColumns()) + std::string(" and ") +
            boost::lexical_cast<std::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);
            }
        }
    }

template<typename DataType , typename RhsDataType , typename RhsMatrixType >

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

Definition at line 320 of file MatrixOperations.cpp.

References ASSERTL1.

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

    {
        ASSERTL1(result.GetRows() == rhs.GetRows(), std::string("Matrices with different row counts  ") + 
            boost::lexical_cast<std::string>(result.GetRows()) + std::string(" and ") +
            boost::lexical_cast<std::string>(rhs.GetRows()) + std::string(" can't be subtracted."));
        ASSERTL1(result.GetColumns() == rhs.GetColumns(), std::string("Matrices with different column counts  ") + 
            boost::lexical_cast<std::string>(result.GetColumns()) + std::string(" and ") +
            boost::lexical_cast<std::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);
            }
        }
    }

template<typename ResultDataType , typename InputDataType >

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

Definition at line 555 of file NekVector.cpp.

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

    {
        ResultDataType* r_buf = result.GetRawPtr();
        typename boost::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];
        }
    }

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

template<typename DataType , typename RhsDataType , typename RhsMatrixType >

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

Definition at line 340 of file MatrixOperations.cpp.

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

    {
        ASSERTL1(result.GetRows() == rhs.GetRows(), std::string("Matrices with different row counts  ") + 
            boost::lexical_cast<std::string>(result.GetRows()) + std::string(" and ") +
            boost::lexical_cast<std::string>(rhs.GetRows()) + std::string(" can't be subtracted."));
        ASSERTL1(result.GetColumns() == rhs.GetColumns(), std::string("Matrices with different column counts  ") + 
            boost::lexical_cast<std::string>(result.GetColumns()) + std::string(" and ") +
            boost::lexical_cast<std::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);
            }
        }
    }

template<typename ResultDataType , typename InputDataType >

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

Definition at line 568 of file NekVector.cpp.

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

    {
                ResultDataType* r_buf = result.GetRawPtr();
        typename boost::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];
        }
    }

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

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 294 of file MatrixOperations.cpp.

References ASSERTL1, and lhs.

    {
        ASSERTL1(lhs.GetRows() == rhs.GetRows(), std::string("Matrices with different row counts  ") + 
            boost::lexical_cast<std::string>(lhs.GetRows()) + std::string(" and ") +
            boost::lexical_cast<std::string>(rhs.GetRows()) + std::string(" can't be subtracted."));
        ASSERTL1(lhs.GetColumns() == rhs.GetColumns(), std::string("Matrices with different column counts  ") + 
            boost::lexical_cast<std::string>(lhs.GetColumns()) + std::string(" and ") +
            boost::lexical_cast<std::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);
            }
        }
    }

template<typename ResultDataType , typename InputDataType >

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

Definition at line 530 of file NekVector.cpp.

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

    {
        ResultDataType* r_buf = result.GetRawPtr();
        typename boost::add_const<InputDataType>::type* lhs_buf = lhs.GetRawPtr();
        typename boost::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];
        }
    }

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

template<typename DataType >

NekMatrix< DataType, ScaledMatrixTag > Nektar::Transpose

(

NekMatrix< DataType, ScaledMatrixTag > &

rhs

)

Definition at line 179 of file ScaledMatrix.cpp.

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

template<typename InnerMatrixType >

NekMatrix<InnerMatrixType, BlockMatrixTag> Nektar::Transpose

(

NekMatrix< InnerMatrixType, BlockMatrixTag > &

rhs

)

Definition at line 219 of file BlockMatrix.hpp.

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

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

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

(

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

rhs

)

template<typename DataType >

NekMatrix< DataType, StandardMatrixTag > Nektar::Transpose

(

NekMatrix< DataType, StandardMatrixTag > &

rhs

)

Definition at line 805 of file StandardMatrix.cpp.

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

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

template NekMatrix<NekDouble, StandardMatrixTag> Nektar::Transpose

(

NekMatrix< NekDouble, StandardMatrixTag > &

rhs

)

Variable Documentation

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

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

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

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.

const char* const Nektar::FlagTypeMap[]

Initial value:

= {
        "UseGlobal"
    }

String map for FlagType enumeration.

Definition at line 94 of file NektarUnivTypeDefs.hpp.

StandardMatrixTag boost::call_traits<LhsDataType>::const_reference rhs typedef NekMatrix<LhsDataType, StandardMatrixTag>::iterator Nektar::iterator

Definition at line 96 of file MatrixOperations.cpp.

Referenced by Nektar::MemPool::Allocate(), Nektar::LibUtilities::NekManager< Nektar::MultiRegions::GlobalLinSysKey, Nektar::MultiRegions::GlobalLinSys >::AlreadyCreated(), Nektar::MultiRegions::AssemblyMapCG::AssemblyMapCG(), Nektar::NekMatrix< NekMatrix< DataType, InnerMatrixType >, BlockMatrixTag >::begin(), Nektar::NekMatrix< DataType, StandardMatrixTag >::begin(), Nektar::NekMeshUtils::BGFSUpdate(), Nektar::MultiRegions::PreconditionerBlock::BlockPreconditionerCG(), Nektar::Utilities::ProcessBL::BoundaryLayer2D(), Nektar::Utilities::ProcessBL::BoundaryLayer3D(), Nektar::Utilities::ProcessVarOpti::BuildDerivUtil(), Nektar::NekMeshUtils::BLMesh::BuildElements(), Nektar::NekMeshUtils::FaceMesh::BuildLocalMesh(), Nektar::Utilities::NodeOpti::CalcMinJac(), Nektar::SolverUtils::RiemannSolver::CheckAuxScal(), Nektar::SolverUtils::RiemannSolver::CheckAuxVec(), Nektar::SolverUtils::UnsteadySystem::CheckForRestartTime(), Nektar::SolverUtils::RiemannSolver::CheckParams(), Nektar::SolverUtils::RiemannSolver::CheckScalars(), Nektar::SolverUtils::RiemannSolver::CheckVectors(), Nektar::NekMeshUtils::Module::ClearElementLinks(), Nektar::LibUtilities::NekManager< Nektar::MultiRegions::GlobalLinSysKey, Nektar::MultiRegions::GlobalLinSys >::ClearManager(), Nektar::Collections::Collection::Collection(), Nektar::Collections::CollectionOptimisation::CollectionOptimisation(), Nektar::FieldUtils::Iso::Condense(), Nektar::CoupledLocalToGlobalC0ContMap::CoupledLocalToGlobalC0ContMap(), Nektar::SpatialDomains::BoundaryConditions::CreateBoundaryComms(), Nektar::MultiRegions::ExpList::CreateCollections(), Nektar::Utilities::ProcessVarOpti::CreateColoursets(), Nektar::MultiRegions::AssemblyMapCG::CreateGraph(), Nektar::LibUtilities::MeshPartition::CreateGraph(), Nektar::Utilities::InputGmsh::CreateReordering(), Nektar::MemPool::Deallocate(), Nektar::LibUtilities::NekManager< Nektar::MultiRegions::GlobalLinSysKey, Nektar::MultiRegions::GlobalLinSys >::DeleteObject(), Nektar::NekMeshUtils::FaceMesh::DiagonalSwap(), Nektar::LibUtilities::NekManager< Nektar::MultiRegions::GlobalLinSysKey, Nektar::MultiRegions::GlobalLinSys >::DisableManagement(), Nektar::LibUtilities::NekManager< Nektar::MultiRegions::GlobalLinSysKey, Nektar::MultiRegions::GlobalLinSys >::EnableManagement(), Nektar::NekMatrix< NekMatrix< DataType, InnerMatrixType >, BlockMatrixTag >::end(), Nektar::NekMatrix< DataType, StandardMatrixTag >::end(), ExpandComposites(), Nektar::MultiRegions::ExpList1D::ExpList1D(), Nektar::MultiRegions::ExpList2D::ExpList2D(), Nektar::NekMeshUtils::TriangleInterface::Extract(), Extractlayerdata(), Nektar::FieldUtils::Field::FieldIOForFile(), Nektar::CoupledLocalToGlobalC0ContMap::FindEdgeIdToAddMeanPressure(), Nektar::Utilities::ProcessSpherigon::FindNormalFromPlyFile(), Nektar::MultiRegions::DisContField2D::FindPeriodicEdges(), Nektar::MultiRegions::DisContField3D::FindPeriodicFaces(), Nektar::MultiRegions::DisContField1D::FindPeriodicVertices(), fromString(), FromString(), Nektar::MultiRegions::DisContField1D::GenerateBoundaryConditionExpansion(), Nektar::Utilities::ProcessSpherigon::GenerateNormals(), Nektar::LibUtilities::H5::CanHaveAttributes::GetAttribute(), Nektar::MultiRegions::ExpList::GetBlockMatrix(), Nektar::NekMeshUtils::Element::GetBoundaryLink(), Nektar::NekMeshUtils::Node::GetCADCurve(), Nektar::NekMeshUtils::Node::GetCADCurveInfo(), Nektar::NekMeshUtils::Node::GetCADCurveInfoVector(), Nektar::NekMeshUtils::Node::GetCADCurves(), Nektar::NekMeshUtils::Node::GetCADSurf(), Nektar::NekMeshUtils::Node::GetCADSurfInfo(), Nektar::NekMeshUtils::Node::GetCADSurfInfoVector(), Nektar::NekMeshUtils::Node::GetCADSurfs(), Nektar::Utilities::ProcessVarOpti::GetColouredNodes(), Nektar::SpatialDomains::MeshGraph::GetCompositeList(), Nektar::LibUtilities::MeshPartition::GetCompositeOrdering(), Nektar::NekMeshUtils::CADSystem::GetCurve(), Nektar::MultiRegions::DisContField1D::GetDomainBCs(), Nektar::SpatialDomains::MeshGraph3D::GetElementsFromFace(), Nektar::Utilities::NodeOpti::GetFunctional(), Nektar::MultiRegions::DisContField2D::GetGlobalBndLinSys(), Nektar::MultiRegions::DisContField3D::GetGlobalBndLinSys(), Nektar::MultiRegions::DisContField1D::GetGlobalBndLinSys(), Nektar::MultiRegions::ContField3D::GetGlobalMatrix(), Nektar::MultiRegions::ContField2D::GetGlobalMatrix(), Nektar::MultiRegions::ContField3D::GetGlobalMatrixNnz(), Nektar::MultiRegions::ContField2D::GetGlobalMatrixNnz(), Nektar::MultiRegions::ExpListHomogeneous1D::GetHomogeneous1DBlockMatrix(), Nektar::MultiRegions::ExpListHomogeneous2D::GetHomogeneous2DBlockMatrix(), Nektar::Utilities::ProcessVarOpti::GetLockedElements(), GetNewVertexLocation(), Nektar::Utilities::InputGmsh::GetNnodes(), Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), Nektar::SpatialDomains::MeshGraph3D::GetSegGeom(), Nektar::SpatialDomains::MeshGraph2D::GetSegGeom(), Nektar::LibUtilities::SessionReader::GetSolverInfoAsEnum(), Nektar::NekMeshUtils::CADSystem::GetSurf(), Nektar::NekMeshUtils::BLMesh::GetSymNodes(), Nektar::LibUtilities::SessionReader::GetValueAsEnum(), Nektar::SpatialDomains::MeshGraph::GetVertex(), Nektar::NekMeshUtils::Composite::GetXmlString(), GetXmlString(), Nektar::FieldUtils::Iso::GlobalCondense(), Nektar::NekMeshUtils::BLMesh::GrowLayers(), Nektar::NekMeshUtils::Hexahedron::Hexahedron(), Nektar::NekMeshUtils::TetGenInterface::InitialMesh(), Nektar::LibUtilities::SessionReader::InitSession(), Nektar::MultiRegions::DisContField2D::IsLeftAdjacentEdge(), Nektar::MultiRegions::DisContField3D::IsLeftAdjacentFace(), Nektar::MultiRegions::DisContField1D::IsLeftAdjacentVertex(), Nektar::NekMeshUtils::CADSystemOCE::LoadCAD(), Nektar::CellModel::LoadCellModel(), Nektar::Utilities::InputNek::LoadHOSurfaces(), main(), Nektar::NekMeshUtils::Generator2D::MakeBL(), Nektar::NekMeshUtils::Generator2D::MakeBLPrep(), Nektar::NekMeshUtils::Mesh::MakeOrder(), Nektar::NekMeshUtils::BLMesh::Mesh(), Nektar::MultiRegions::MultiLevelBisectionReordering(), Nektar::LibUtilities::NekManager< Nektar::MultiRegions::GlobalLinSysKey, Nektar::MultiRegions::GlobalLinSys >::NekManager(), Nektar::Utilities::NodeOpti::NodeOpti(), Nektar::NekMeshUtils::Face::operator==(), Nektar::NekMeshUtils::operator==(), Nektar::LibUtilities::NekManager< Nektar::MultiRegions::GlobalLinSysKey, Nektar::MultiRegions::GlobalLinSys >::operator[](), Nektar::NekMeshUtils::Tetrahedron::OrientTet(), Nektar::Utilities::OutputGmsh::OutputGmsh(), Nektar::LibUtilities::MeshPartition::OutputPartition(), Nektar::LibUtilities::SessionReader::ParseCommandLineArguments(), Nektar::Utilities::InputMCF::ParseFile(), Nektar::LibUtilities::SessionReader::PartitionMesh(), Nektar::LibUtilities::NekManager< Nektar::MultiRegions::GlobalLinSysKey, Nektar::MultiRegions::GlobalLinSys >::PoolCreated(), Nektar::SpatialDomains::MeshGraph3D::PopulateFaceToElMap(), Nektar::FieldUtils::Module::PrintConfig(), Nektar::NekMeshUtils::Module::PrintConfig(), Nektar::LibUtilities::MeshPartition::PrintPartInfo(), Nektar::NekMeshUtils::Prism::Prism(), Nektar::NekMeshUtils::Module::PrismLines(), Nektar::Utilities::InputGmsh::Process(), Nektar::Utilities::InputNekpp::Process(), Nektar::Utilities::InputSem::Process(), Nektar::NekMeshUtils::HOSurfaceMesh::Process(), Nektar::Utilities::InputNek5000::Process(), Nektar::NekMeshUtils::VolumeMesh::Process(), Nektar::Utilities::OutputSTL::Process(), Nektar::FieldUtils::ProcessDisplacement::Process(), Nektar::Utilities::ProcessOptiExtract::Process(), Nektar::Utilities::ProcessPerAlign::Process(), Nektar::Utilities::OutputVtk::Process(), Nektar::Utilities::ProcessExtrude::Process(), Nektar::Utilities::ProcessSpherigon::Process(), Nektar::Utilities::ProcessLinear::Process(), Nektar::FieldUtils::ProcessNumModes::Process(), Nektar::FieldUtils::ProcessVorticity::Process(), Nektar::FieldUtils::ProcessQCriterion::Process(), Nektar::Utilities::InputNek::Process(), Nektar::NekMeshUtils::SurfaceMesh::Process(), Nektar::NekMeshUtils::Generator2D::Process(), Nektar::Utilities::ProcessDetectSurf::Process(), Nektar::Utilities::ProcessExtractTetPrismInterface::Process(), Nektar::Utilities::ProcessLinkCheck::Process(), Nektar::Utilities::ProcessExtractSurf::Process(), Nektar::Utilities::ProcessInsertSurface::Process(), Nektar::Utilities::ProcessTetSplit::Process(), Nektar::Utilities::OutputGmsh::Process(), Nektar::Utilities::ProcessVarOpti::Process(), Nektar::NekMeshUtils::Module::ProcessComposites(), Nektar::NekMeshUtils::Module::ProcessEdges(), Nektar::NekMeshUtils::Module::ProcessFaces(), Nektar::NekMeshUtils::Octree::PropagateDomain(), Nektar::NekMeshUtils::Pyramid::Pyramid(), Nektar::NekMeshUtils::Quadrilateral::Quadrilateral(), Nektar::Thread::ThreadManagerBoost::QueueJobs(), Nektar::SpatialDomains::BoundaryConditions::ReadBoundaryConditions(), Nektar::SpatialDomains::MeshGraph3D::ReadEdges(), Nektar::SpatialDomains::MeshGraph2D::ReadEdges(), Nektar::SpatialDomains::MeshGraph1D::ReadElements(), Nektar::SpatialDomains::MeshGraph2D::ReadElements(), Nektar::LibUtilities::SessionReader::ReadExpressions(), Nektar::SpatialDomains::MeshGraph3D::ReadFaces(), Nektar::LibUtilities::SessionReader::ReadFunctions(), Nektar::SpatialDomains::MeshGraph::ReadGeometryInfo(), Nektar::LibUtilities::SessionReader::ReadGlobalSysSolnInfo(), Nektar::Utilities::InputTec::ReadZone(), Nektar::FieldUtils::Module::RegisterConfig(), Nektar::NekMeshUtils::Module::RegisterConfig(), Nektar::LibUtilities::SessionReader::RegisterEnumValue(), Nektar::Utilities::ProcessVarOpti::RemoveLinearCurvature(), Nektar::NekMeshUtils::Module::ReorderPrisms(), Nektar::Utilities::InputTec::ResetNodes(), Nektar::Utilities::InputStar::ResetNodes(), Nektar::SpatialDomains::MeshGraph1D::ResolveGeomRef(), Nektar::SpatialDomains::MeshGraph3D::ResolveGeomRef(), Nektar::SpatialDomains::MeshGraph2D::ResolveGeomRef(), Nektar::FieldUtils::Iso::SeparateRegions(), Nektar::MultiRegions::DisContField1D::SetBoundaryConditionExpansion(), Nektar::CompressibleFlowSystem::SetBoundaryConditions(), Nektar::FieldUtils::Module::SetDefaults(), Nektar::NekMeshUtils::Module::SetDefaults(), Nektar::LibUtilities::SessionReader::SetSolverInfo(), Nektar::NekMeshUtils::BLMesh::Setup(), Nektar::MultiRegions::LocTraceToTraceMap::Setup2D(), Nektar::MultiRegions::LocTraceToTraceMap::Setup3D(), Nektar::MultiRegions::DisContField3D::SetUpDG(), Nektar::MultiRegions::DisContField2D::SetUpDG(), Nektar::MultiRegions::DisContField1D::SetUpDG(), Nektar::PulseWaveSystem::SetUpDomainInterfaces(), Nektar::FieldUtils::Interpolator::SetupTree(), Nektar::NekMeshUtils::BLMesh::Shrink(), Nektar::FieldUtils::Iso::Smooth(), Nektar::NekMeshUtils::Octree::SmoothAllOctants(), Nektar::NekMeshUtils::FaceMesh::Smoothing(), Nektar::NekMeshUtils::Octree::SmoothSurfaceOctants(), Nektar::StdRegions::StdPyrExp::StdPyrExp(), Nektar::NekMeshUtils::Octree::SubDivide(), Nektar::LibUtilities::SessionReader::SubstituteExpressions(), Nektar::NekMeshUtils::Tetrahedron::Tetrahedron(), Nektar::NekMeshUtils::Triangle::Triangle(), TurnOffEdges(), Nektar::StdRegions::StdPyrExp::v_BwdTrans_SumFacKernel(), Nektar::SolverUtils::UnsteadySystem::v_DoSolve(), Nektar::LinearElasticSystem::v_DoSolve(), Nektar::MultiRegions::ExpListHomogeneous1D::v_ExtractDataToCoeffs(), Nektar::MultiRegions::ExpList::v_ExtractDataToCoeffs(), Nektar::MultiRegions::DisContField2D::v_GetFwdBwdTracePhys(), Nektar::LibUtilities::FieldIOXml::v_Import(), Nektar::LibUtilities::FieldIOHdf5::v_Import(), Nektar::MultiRegions::ContField3D::v_ImposeDirichletConditions(), Nektar::MultiRegions::ContField2D::v_ImposeDirichletConditions(), Nektar::SolverUtils::Advection3DHomogeneous1D::v_InitObject(), Nektar::StdRegions::StdPyrExp::v_IProductWRTBase_SumFacKernel(), Nektar::SpatialDomains::SegGeom::v_Reset(), Nektar::SpatialDomains::QuadGeom::v_Reset(), Nektar::SpatialDomains::TriGeom::v_Reset(), Nektar::SolverUtils::FilterHistoryPoints::v_Update(), Nektar::FilterCellHistoryPoints::v_Update(), Nektar::SpatialDomains::Geometry3D::v_WhichEdge(), Nektar::SpatialDomains::QuadGeom::v_WhichEdge(), Nektar::SpatialDomains::TriGeom::v_WhichEdge(), Nektar::SpatialDomains::Geometry3D::v_WhichFace(), Nektar::LibUtilities::FieldIOHdf5::v_Write(), Nektar::NekMeshUtils::Octree::VerifyNeigbours(), Nektar::LibUtilities::MeshPartition::WeightElements(), Nektar::SpatialDomains::MeshGraph::WriteGeometry(), Nektar::Utilities::OutputNekpp::WriteXmlComposites(), Nektar::Utilities::OutputNekpp::WriteXmlConditions(), Nektar::Utilities::OutputNekpp::WriteXmlCurves(), Nektar::Utilities::OutputNekpp::WriteXmlDomain(), Nektar::Utilities::OutputNekpp::WriteXmlEdges(), Nektar::Utilities::OutputNekpp::WriteXmlExpansions(), Nektar::Utilities::OutputNekpp::WriteXmlFaces(), Nektar::Utilities::OutputNekpp::WriteXmlNodes(), and Nektar::LibUtilities::AnalyticExpressionEvaluator::~AnalyticExpressionEvaluator().

const std::string Nektar::kAdvectionFormStr[]

Initial value:

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

Definition at line 88 of file IncNavierStokes.h.

char const Nektar::kDefaultState[] = "default"

static

Definition at line 47 of file InputStar.cpp.

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

StandardMatrixTag& Nektar::lhs

Definition at line 96 of file MatrixOperations.cpp.

Referenced by Add(), AddNegatedLhs(), Nektar::LibUtilities::SessionReader::CmdLineOverride(), Nektar::AssignableConcept< DataType >::const_constraints(), Nektar::AssignableConcept< DataType >::constraints(), DiagonalBlockFullScalMatrixMultiply(), Multiply(), MultiplyInvertedLhs(), NekMultiplyDefaultImpl(), NekMultiplyDiagonalMatrix(), NekMultiplyLowerTriangularMatrix(), NekMultiplyUnspecializedMatrixType(), NekMultiplyUpperTriangularMatrix(), operator*(), operator+(), operator-(), Nektar::LibUtilities::SessionReader::ReadParameters(), Subtract(), and SubtractNegatedLhs().

Nektar::LhsDataType

Definition at line 60 of file MatrixOperations.cpp.

Nektar::LhsMatrixType

Definition at line 108 of file MatrixOperations.cpp.

Nektar::NEKTAR_ALL_MATRIX_TYPES

Definition at line 210 of file MatrixOperations.cpp.

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

static

Definition at line 45 of file NistSparseDescriptors.hpp.

DNekMatSharedPtr Nektar::NullDNekMatSharedPtr

static

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

DNekScalBlkMatSharedPtr Nektar::NullDNekScalBlkMatSharedPtr

static

Definition at line 81 of file NekTypeDefs.hpp.

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

DNekScalMatSharedPtr Nektar::NullDNekScalMatSharedPtr

static

Definition at line 80 of file NekTypeDefs.hpp.

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

FlagList Nektar::NullFlagList

static

An empty flag list.

Definition at line 116 of file NektarUnivTypeDefs.hpp.

Referenced by Diffusion::DoImplicitSolve(), Nektar::Bidomain::DoImplicitSolve(), Nektar::BidomainRoth::DoImplicitSolve(), Nektar::Monodomain::DoImplicitSolve(), Nektar::UnsteadyDiffusion::DoImplicitSolve(), Nektar::UnsteadyAdvectionDiffusion::DoImplicitSolve(), Nektar::UnsteadyViscousBurgers::DoImplicitSolve(), Nektar::ImageWarpingSystem::DoOdeRhs(), Nektar::BidomainRoth::DoOdeRhs(), main(), Nektar::Laplace::v_DoSolve(), Nektar::VCSWeakPressure::v_SolvePressure(), Nektar::VCSMapping::v_SolvePressure(), Nektar::VelocityCorrectionScheme::v_SolvePressure(), Nektar::VCSMapping::v_SolveViscous(), Nektar::VelocityCorrectionScheme::v_SolveViscous(), and Nektar::NonlinearPeregrine::WCESolve().

Array<OneD, int> Nektar::NullInt1DArray

static

Definition at line 784 of file SharedArray.hpp.

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

Array<OneD, NekDouble> Nektar::NullNekDouble1DArray

static

Definition at line 785 of file SharedArray.hpp.

Referenced by Nektar::Collections::Collection::ApplyOperator(), Nektar::CoupledAssemblyMap::CoupledAssemblyMap(), Nektar::FullMatrixFuncs::EigenSolve(), Nektar::StdRegions::StdExpansion::H1(), Nektar::SolverUtils::EquationSystem::L2Error(), Nektar::MultiRegions::ExpList::Linf(), Nektar::StdRegions::StdExpansion::Linf(), Nektar::FieldUtils::ProcessInterpField::Process(), Nektar::FieldUtils::ProcessEquiSpacedOutput::SetupEquiSpacedField(), Nektar::MultiRegions::PreconditionerLinear::v_DoPreconditioner(), Nektar::MultiRegions::PreconditionerLinear::v_DoPreconditionerWithNonVertOutput(), Nektar::SolverUtils::Driver::v_GetImagEvl(), Nektar::LocalRegions::SegExp::v_GetPhysNormals(), Nektar::StdRegions::StdExpansion::v_GetPhysNormals(), Nektar::SolverUtils::Driver::v_GetRealEvl(), Nektar::MultiRegions::ExpList3DHomogeneous1D::v_L2(), Nektar::MultiRegions::ExpList::v_L2(), Nektar::StdRegions::StdPrismExp::v_PhysDeriv(), Nektar::StdRegions::StdTriExp::v_PhysDeriv(), Nektar::StdRegions::StdHexExp::v_PhysDeriv(), Nektar::StdRegions::StdQuadExp::v_PhysDeriv(), Nektar::LocalRegions::SegExp::v_PhysDeriv(), Nektar::StdRegions::StdTetExp::v_PhysDeriv(), Nektar::LocalRegions::TriExp::v_PhysDeriv(), Nektar::LocalRegions::QuadExp::v_PhysDeriv(), Nektar::LocalRegions::HexExp::v_PhysDeriv(), Nektar::StdRegions::StdPyrExp::v_PhysDeriv(), Nektar::MultiRegions::ExpListHomogeneous1D::v_PhysDeriv(), and Nektar::VCSWeakPressure::v_SolvePressure().

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

static

Definition at line 786 of file SharedArray.hpp.

Referenced by Nektar::CompressibleFlowSystem::DoOdeRhs(), Nektar::CoupledLinearNS::SetUpCoupledMatrix(), Nektar::SolverUtils::AdvectionWeakDG::v_Advect(), Nektar::NavierStokesCFE::v_DoDiffusion(), Nektar::SolverUtils::DiffusionLDGNS::v_NumericalFluxO1(), Nektar::SolverUtils::DiffusionLDG::v_NumFluxforScalar(), and Nektar::LocalRegions::SegExp::v_PhysDeriv_n().

PulseWaveBoundarySharedPtr Nektar::NullPulseWaveBoundarySharedPtr

static

Definition at line 50 of file PulseWaveBoundary.h.

PulseWavePressureAreaSharedPtr Nektar::NullPulseWavePressureAreaSharedPtr

static

Definition at line 49 of file PulseWavePressureArea.h.

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

Definition at line 52 of file NonlinearPeregrine.h.

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

Nektar::RhsDataType

Definition at line 84 of file MatrixOperations.cpp.

Nektar::RhsMatrixType

Definition at line 73 of file MatrixOperations.cpp.

const char* const Nektar::UpwindTypeMapPulse[]

Initial value:

=
        {
            "NoSetPulse",
            "UpwindPulse",
        }

Definition at line 53 of file PulseWaveSystem.h.

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

Nektar::void

Definition at line 210 of file MatrixOperations.cpp.

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

const std::string Nektar::VWIIterationTypeMap[]

Initial value:

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

Definition at line 64 of file VortexWaveInteraction.h.

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