Nektar++
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
Nektar Namespace Reference

< More...

Namespaces

 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< NekDoubleDNekVec
 
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, IndexTypeIndexVector
 
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, COOMatTypeCOOMatVector
 
typedef Array< OneD, NekDoubleBCOEntryType
 
typedef std::map< CoordType,
BCOEntryType
BCOMatType
 
typedef BCOMatType::const_iterator BCOMatTypeConstIt
 
typedef boost::shared_ptr
< BCOMatType
BCOMatTypeSharedPtr
 
typedef Array< OneD, BCOMatTypeBCOMatVector
 
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< LhsDataTypeAdd (const NekVector< LhsDataType > &lhs, const NekVector< RhsDataType > &rhs)
 
template NekVector< NekDoubleAdd (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< NekDoubleSubtract (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< NekDoubleDivide (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< NekDoubleMultiply (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< NekDoubleMultiply (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< NekDoubleMultiply (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< NekDoublecreateVectorFromPoints (const NekPoint< NekDouble > &source, const NekPoint< NekDouble > &dest)
 
template<typename DataType >
NekPoint< DataType > findPointAlongVector (const NekVector< DataType > &lhs, const DataType &t)
 
template NekPoint< NekDoublefindPointAlongVector (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< NekDoubleNegate (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< NekDoubleCross (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)
 
MemPoolGetMemoryPool ()
 
CellModelFactoryGetCellModelFactory ()
 
ProtocolFactoryGetProtocolFactory ()
 
StimulusFactoryGetStimulusFactory ()
 
ArtificialDiffusionFactoryGetArtificialDiffusionFactory ()
 Declaration of the artificial diffusion factory singleton. More...
 
CFSBndCondFactoryGetCFSBndCondFactory ()
 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...
 
ExtrapolateFactoryGetExtrapolateFactory ()
 
DNekMat MappingIdealToRef (SpatialDomains::GeometrySharedPtr geom)
 
BoundaryFactoryGetBoundaryFactory ()
 
PressureAreaFactoryGetPressureAreaFactory ()
 

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, NekDoubleNullNekDouble1DArray
 
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

Pointer to a PulseWaveOutflow object.

Definition at line 45 of file ArterialPressureArea.h.

Declaration of the artificial diffusion factory.

Definition at line 60 of file ArtificialDiffusion.h.

A shared pointer to a artificial diffusion object.

Definition at line 51 of file ArtificialDiffusion.h.

Definition at line 64 of file SparseMatrixFwd.hpp.

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.

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.

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.

Definition at line 75 of file NekTypeDefs.hpp.

typedef NekMatrix<DenseMatrix, BlockMatrixTag> Nektar::BlockMatrix

Definition at line 61 of file NekTypeDefs.hpp.

Definition at line 56 of file PulseWaveBoundary.h.

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.

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.

Definition at line 57 of file SparseMatrixFwd.hpp.

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.

Definition at line 61 of file SparseMatrixFwd.hpp.

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

Definition at line 56 of file SparseMatrixFwd.hpp.

Definition at line 63 of file CoupledAssemblyMap.h.

Definition at line 65 of file CoupledLocalToGlobalC0ContMap.h.

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.

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.

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.

Definition at line 49 of file NekTypeDefs.hpp.

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.

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.

Definition at line 69 of file Extrapolate.h.

Definition at line 272 of file IncNavierStokes.h.

typedef unsigned int Nektar::IndexType

Definition at line 51 of file SparseMatrixFwd.hpp.

Definition at line 53 of file SparseMatrixFwd.hpp.

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

Definition at line 83 of file PulseWaveSystem.h.

Pointer to a PulseWaveOutflow object.

Definition at line 45 of file LymphaticPressureArea.h.

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.

Definition at line 54 of file PulseWavePressureArea.h.

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.

Definition at line 47 of file PulseWaveBoundary.h.

Definition at line 46 of file PulseWavePressureArea.h.

Definition at line 77 of file PulseWaveSystemOutput.h.

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.

Definition at line 54 of file StandardExtrapolate.h.

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.

Definition at line 54 of file SubSteppingExtrapolate.h.

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.

Pointer to a PulseWaveOutflow object.

Definition at line 45 of file TerminalOutflow.h.

Pointer to a PulseWaveOutflow object.

Definition at line 45 of file TimeDependentInflow.h.

Pointer to a PulseWaveOutflow object.

Definition at line 45 of file UndefinedInOutflow.h.

Definition at line 45 of file VariableConverter.h.

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

Definition at line 156 of file VCSMapping.h.

Definition at line 99 of file VelocityCorrectionSchemeWeakPressure.h.

Definition at line 183 of file VelocityCorrectionScheme.h.

Definition at line 54 of file WeakPressureExtrapolate.h.

Definition at line 124 of file IncNavierStokes.h.

Enumeration Type Documentation

Enumerator
eNoAdvectionForm 
eConvective 
eNonConservative 
eLinearised 
eAdjoint 
eSkewSymmetric 
eNoAdvection 
eAdvectionFormSize 

Definition at line 75 of file IncNavierStokes.h.

Enumerator
eVECTOR_WRAPPER 

Definition at line 461 of file SharedArray.hpp.

462  {
464  };
Enumerator
xDir 
yDir 
zDir 

Definition at line 71 of file NektarUnivTypeDefs.hpp.

72  {
73  xDir = 0,
74  yDir = 1,
75  zDir = 2
76  };
Enumerator
eNoEquationType 
eSteadyStokes 
eSteadyOseen 
eSteadyLinearisedNS 
eUnsteadyStokes 
eUnsteadyLinearisedNS 
eUnsteadyNavierStokes 
eSteadyNavierStokes 
eEquationTypeSize 

Definition at line 48 of file IncNavierStokes.h.

Enumeration of flags for passing a list of options.

Enumerator
eUseGlobal 

Definition at line 88 of file NektarUnivTypeDefs.hpp.

Enumerator
eNOHBC 
eHBCNeumann 
eOBC 
eConvectiveOBC 

Definition at line 51 of file Extrapolate.h.

52  {
53  eNOHBC,
54  eHBCNeumann, // Standard High Order BC
55  eOBC, // High Order outflow BC (Neumann-Dirichlet) from Dong et al JCP 2014
56  eConvectiveOBC // Convective High Order (Robin type) BC from Dong JCP 2015
57  };
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.

Enumerator
eTecplot 
eTecplotZones 
eTecplotSingleBlock 
eGmsh 
eGnuplot 

Definition at line 78 of file NektarUnivTypeDefs.hpp.

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.

44  {
45  eWrapper,
46  eCopy
47  };
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.

46 {
47  eGeneral, ///< No problem defined - Default Inital data
48  eSolitaryWave, ///< First order Laitone solitary wave
49  SIZE_ProblemType ///< Length of enum list
50 };
Length of enum list.
No problem defined - Default Inital data.
First order Laitone solitary wave.
Enumerator
eNotSetPulse 

flux not defined

eUpwindPulse 

simple upwinding scheme

SIZE_UpwindTypePulse 

Length of enum list.

Definition at line 46 of file PulseWaveSystem.h.

47  {
48  eNotSetPulse, ///< flux not defined
49  eUpwindPulse, ///< simple upwinding scheme
50  SIZE_UpwindTypePulse ///< Length of enum list
51  };
Length of enum list.
flux not defined
simple upwinding scheme
Enumerator
eFixedAlpha 
eFixedWaveForcing 
eFixedAlphaWaveForcing 
eFixedWaveForcingWithSubIterationOnAlpha 
eVWIIterationTypeSize 

Definition at line 55 of file VortexWaveInteraction.h.

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

217  {
218  ASSERTL1(lhs.GetRows() == rhs.GetRows(), std::string("Matrices with different row counts ") +
219  boost::lexical_cast<std::string>(lhs.GetRows()) + std::string(" and ") +
220  boost::lexical_cast<std::string>(rhs.GetRows()) + std::string(" can't be added."));
221  ASSERTL1(lhs.GetColumns() == rhs.GetColumns(), std::string("Matrices with different column counts ") +
222  boost::lexical_cast<std::string>(lhs.GetColumns()) + std::string(" and ") +
223  boost::lexical_cast<std::string>(rhs.GetColumns()) + std::string(" can't be added."));
224 
225  for(unsigned int i = 0; i < lhs.GetRows(); ++i)
226  {
227  for(unsigned int j = 0; j < lhs.GetColumns(); ++j)
228  {
229  result(i,j) = lhs(i,j) + rhs(i,j);
230  }
231  }
232  }
StandardMatrixTag & lhs
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:228
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().

217  {
218  ASSERTL1(lhs.GetRows() == rhs.GetRows(), std::string("Matrices with different row counts ") +
219  boost::lexical_cast<std::string>(lhs.GetRows()) + std::string(" and ") +
220  boost::lexical_cast<std::string>(rhs.GetRows()) + std::string(" can't be added."));
221  ASSERTL1(lhs.GetColumns() == rhs.GetColumns(), std::string("Matrices with different column counts ") +
222  boost::lexical_cast<std::string>(lhs.GetColumns()) + std::string(" and ") +
223  boost::lexical_cast<std::string>(rhs.GetColumns()) + std::string(" can't be added."));
224 
225  for(unsigned int i = 0; i < lhs.GetRows(); ++i)
226  {
227  for(unsigned int j = 0; j < lhs.GetColumns(); ++j)
228  {
229  result(i,j) = lhs(i,j) + rhs(i,j);
230  }
231  }
232  }
StandardMatrixTag & lhs
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:228
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().

263  {
264  typedef typename NekMatrix<LhsDataType, LhsMatrixType>::NumberType NumberType;
265  NekMatrix<NumberType, StandardMatrixTag> result(lhs.GetRows(), lhs.GetColumns());
266  Add(result, lhs, rhs);
267  return result;
268  }
StandardMatrixTag & lhs
DNekMat NekMatrix< typename NekMatrix< LhsDataType, LhsMatrixType >::NumberType, StandardMatrixTag > Add(const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
template<typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >
NekMatrix<typename NekMatrix<LhsDataType, LhsMatrixType>::NumberType, StandardMatrixTag> Nektar::Add ( const NekMatrix< LhsDataType, LhsMatrixType > &  lhs,
const NekMatrix< RhsDataType, RhsMatrixType > &  rhs 
)

Definition at line 261 of file MatrixOperations.cpp.

References Add().

263  {
264  typedef typename NekMatrix<LhsDataType, LhsMatrixType>::NumberType NumberType;
265  NekMatrix<NumberType, StandardMatrixTag> result(lhs.GetRows(), lhs.GetColumns());
266  Add(result, lhs, rhs);
267  return result;
268  }
StandardMatrixTag & lhs
DNekMat NekMatrix< typename NekMatrix< LhsDataType, LhsMatrixType >::NumberType, StandardMatrixTag > Add(const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
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().

434  {
435  DataType* r_buf = result.GetRawPtr();
436  const DataType* lhs_buf = lhs.GetRawPtr();
437  const DataType* rhs_buf = rhs.GetRawPtr();
438  const unsigned int ldim = lhs.GetDimension();
439  for(int i = 0; i < ldim; ++i)
440  {
441  r_buf[i] = lhs_buf[i] + rhs_buf[i];
442  }
443  }
StandardMatrixTag & lhs
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().

504  {
505  NekVector<LhsDataType> result(lhs.GetDimension());
506  Add(result, lhs, rhs);
507  return result;
508  }
template NekVector< NekDouble > Add(const NekVector< NekDouble > &lhs, const NekVector< NekDouble > &rhs)
StandardMatrixTag & lhs
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+=().

171  {
172  ASSERTL1(result.GetRows() == rhs.GetRows(), std::string("Matrices with different row counts ") +
173  boost::lexical_cast<std::string>(result.GetRows()) + std::string(" and ") +
174  boost::lexical_cast<std::string>(rhs.GetRows()) + std::string(" can't be added."));
175  ASSERTL1(result.GetColumns() == rhs.GetColumns(), std::string("Matrices with different column counts ") +
176  boost::lexical_cast<std::string>(result.GetColumns()) + std::string(" and ") +
177  boost::lexical_cast<std::string>(rhs.GetColumns()) + std::string(" can't be added."));
178 
179  for(unsigned int i = 0; i < rhs.GetRows(); ++i)
180  {
181  for(unsigned int j = 0; j < rhs.GetColumns(); ++j)
182  {
183  result(i,j) += rhs(i,j);
184  }
185  }
186  }
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:228
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().

470  {
471  DataType* r_buf = result.GetRawPtr();
472  const DataType* rhs_buf = rhs.GetRawPtr();
473  const unsigned int rdim = rhs.GetDimension();
474  for(int i = 0; i < rdim; ++i)
475  {
476  r_buf[i] += rhs_buf[i];
477  }
478  }
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().

192  {
193  ASSERTL1(result.GetRows() == rhs.GetRows(), std::string("Matrices with different row counts ") +
194  boost::lexical_cast<std::string>(result.GetRows()) + std::string(" and ") +
195  boost::lexical_cast<std::string>(rhs.GetRows()) + std::string(" can't be added."));
196  ASSERTL1(result.GetColumns() == rhs.GetColumns(), std::string("Matrices with different column counts ") +
197  boost::lexical_cast<std::string>(result.GetColumns()) + std::string(" and ") +
198  boost::lexical_cast<std::string>(rhs.GetColumns()) + std::string(" can't be added."));
199 
200  for(unsigned int i = 0; i < rhs.GetRows(); ++i)
201  {
202  for(unsigned int j = 0; j < rhs.GetColumns(); ++j)
203  {
204  result(i,j) = -result(i,j) + rhs(i,j);
205  }
206  }
207  }
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:228
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().

483  {
484  DataType* r_buf = result.GetRawPtr();
485  const DataType* rhs_buf = rhs.GetRawPtr();
486  const unsigned int rdim = rhs.GetDimension();
487  for(int i = 0; i < rdim; ++i)
488  {
489  r_buf[i] = -r_buf[i] + rhs_buf[i];
490  }
491  }
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.

238  {
239  ASSERTL1(lhs.GetRows() == rhs.GetRows(), std::string("Matrices with different row counts ") +
240  boost::lexical_cast<std::string>(lhs.GetRows()) + std::string(" and ") +
241  boost::lexical_cast<std::string>(rhs.GetRows()) + std::string(" can't be added."));
242  ASSERTL1(lhs.GetColumns() == rhs.GetColumns(), std::string("Matrices with different column counts ") +
243  boost::lexical_cast<std::string>(lhs.GetColumns()) + std::string(" and ") +
244  boost::lexical_cast<std::string>(rhs.GetColumns()) + std::string(" can't be added."));
245 
246  for(unsigned int i = 0; i < lhs.GetRows(); ++i)
247  {
248  for(unsigned int j = 0; j < lhs.GetColumns(); ++j)
249  {
250  result(i,j) = -lhs(i,j) + rhs(i,j);
251  }
252  }
253  }
StandardMatrixTag & lhs
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:228
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().

449  {
450  DataType* r_buf = result.GetRawPtr();
451  const DataType* lhs_buf = lhs.GetRawPtr();
452  const DataType* rhs_buf = rhs.GetRawPtr();
453  const unsigned int ldim = lhs.GetDimension();
454  for(int i = 0; i < ldim; ++i)
455  {
456  r_buf[i] = -lhs_buf[i] + rhs_buf[i];
457  }
458  }
StandardMatrixTag & lhs
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().

1046  {
1047  unsigned int d = v.GetRows();
1048  std::string result = "(";
1049  for(unsigned int i = 0; i < d; ++i)
1050  {
1051  result += boost::lexical_cast<std::string>(v[i]);
1052  if( i < v.GetDimension()-1 )
1053  {
1054  result += ", ";
1055  }
1056  }
1057  result += ")";
1058  return result;
1059  }
template std::string Nektar::AsString ( const NekVector< NekDouble > &  v)
Nektar::BOOST_TYPEOF_REGISTER_TEMPLATE ( NekMatrix  ,
 
)
Nektar::BOOST_TYPEOF_REGISTER_TEMPLATE ( NekVector  ,
 
)
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().

54  {
55  COOMatTypeConstIt entry;
57  int rowcoord, localRow, blkRowCoord;
58  int colcoord, localCol, blkColCoord;
59 
60  for(entry = cooMat.begin(); entry != cooMat.end(); entry++)
61  {
62  rowcoord = (entry->first).first;
63  colcoord = (entry->first).second;
64 
65  blkRowCoord = rowcoord / blkDim;
66  blkColCoord = colcoord / blkDim;
67 
68  CoordType blkCoords = std::make_pair(blkRowCoord,blkColCoord);
69  blk = bcoMat.find(blkCoords);
70  if (blk == bcoMat.end())
71  {
72  BCOEntryType b(blkDim*blkDim, 0.0);
73  bcoMat[blkCoords] = b;
74  }
75 
76  localRow = rowcoord % blkDim;
77  localCol = colcoord % blkDim;
78 
79  // transpose it: NIST SpBLAS expects Fortran ordering
80  // of dense subblocks
81  const unsigned int localoffset = localRow + localCol*blkDim;
82  (bcoMat[blkCoords])[localoffset] = entry->second;
83  }
84  }
COOMatType::const_iterator COOMatTypeConstIt
BCOMatType::const_iterator BCOMatTypeConstIt
Array< OneD, NekDouble > BCOEntryType
std::pair< IndexType, IndexType > CoordType
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().

764  {
765  if( dest.num_elements() != source.num_elements() )
766  {
767  dest = Array<OneD, DataType>(source.num_elements());
768  }
769 
770  std::copy(source.data(), source.data() + source.num_elements(), dest.data());
771  }
#define dest(otri, vertexptr)
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().

775  {
776  if( dest.num_elements() != n )
777  {
778  dest = Array<OneD, DataType>(n);
779  }
780 
781  std::copy(source.data(), source.data() + n, dest.data());
782  }
#define dest(otri, vertexptr)
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().

194  {
195  typedef boost::multi_array_ref<DataType, Dim::Value> ArrayType;
196  unsigned int size = std::accumulate(extent.begin(), extent.end(), 1,
197  std::multiplies<unsigned int>());
198  DataType* storage = MemoryManager<DataType>::RawAllocate(size);
199  return MemoryManager<ArrayType>::AllocateSharedPtrD(
200  boost::bind(DeleteStorage<DataType>, storage, size),
201  storage, extent);
202  }
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.

207  {
208  std::vector<unsigned int> extents(1, d1);
209  return CreateStorage<OneD, DataType>(extents);
210  }
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.

215  {
216  unsigned int vals[] = {d1, d2};
217  std::vector<unsigned int> extents(vals, vals+2);
218  return CreateStorage<TwoD, DataType>(extents);
219  }
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.

224  {
225  unsigned int vals[] = {d1, d2, d3};
226  std::vector<unsigned int> extents(vals, vals+3);
227  return CreateStorage<ThreeD, DataType>(extents);
228  }
template<typename DataType >
NekVector< DataType > Nektar::createVectorFromPoints ( const NekPoint< DataType > &  source,
const NekPoint< DataType > &  dest 
)

Definition at line 812 of file NekVector.cpp.

814  {
815  NekVector<DataType> result(3, 0.0);
816  for(unsigned int i = 0; i < 3; ++i)
817  {
818  result[i] = dest[i]-source[i];
819  }
820  return result;
821  }
#define dest(otri, vertexptr)
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().

1030  {
1031  ASSERTL1(lhs.GetDimension() == 3 && rhs.GetDimension() == 3, "Cross is only valid for 3D vectors.");
1032 
1033  DataType first = lhs.y()*rhs.z() - lhs.z()*rhs.y();
1034  DataType second = lhs.z()*rhs.x() - lhs.x()*rhs.z();
1035  DataType third = lhs.x()*rhs.y() - lhs.y()*rhs.x();
1036 
1037  NekVector<DataType> result(first, second, third);
1038  return result;
1039  }
StandardMatrixTag & lhs
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:228
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().

186  {
187  ArrayDestructionPolicy<DataType>::Destroy(data, num);
188  MemoryManager<DataType>::RawDeallocate(data, num);
189  }
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().

266  {
267  unsigned int numberOfBlockRows = lhs.GetNumberOfBlockRows();
268  double* result_ptr = result.GetRawPtr();
269  const double* rhs_ptr = rhs.GetRawPtr();
270 
271  Array<OneD, unsigned int> rowSizes;
272  Array<OneD, unsigned int> colSizes;
273  lhs.GetBlockSizes(rowSizes, colSizes);
274 
275  unsigned int curResultRow = 0;
276  unsigned int curWrapperRow = 0;
277  unsigned int rowsInBlock = 0;
278  unsigned int columnsInBlock = 0;
279  for(unsigned int blockRow = 0; blockRow < numberOfBlockRows; ++blockRow)
280  {
281  curResultRow += rowsInBlock;
282  curWrapperRow += columnsInBlock;
283  if ( blockRow == 0)
284  {
285  rowsInBlock = rowSizes[blockRow] + 1;
286  columnsInBlock = colSizes[blockRow] + 1;
287  }
288  else
289  {
290  rowsInBlock = rowSizes[blockRow] - rowSizes[blockRow-1];
291  columnsInBlock = colSizes[blockRow] - colSizes[blockRow-1];
292  }
293 
294  if( rowsInBlock == 0)
295  {
296  continue;
297  }
298  if( columnsInBlock == 0)
299  {
300  std::fill(result.begin()+curResultRow,
301  result.begin()+curResultRow + rowsInBlock, 0.0);
302  continue;
303  }
304 
305  const DNekScalMat* block = lhs.GetBlockPtr(blockRow, blockRow);
306  if( !block )
307  {
308  continue;
309  }
310 
311  double* resultWrapper = result_ptr + curResultRow;
312  const double* rhsWrapper = rhs_ptr + curWrapperRow;
313 
314  // Multiply
315  const unsigned int* size = block->GetSize();
316  Blas::Dgemv('N', size[0], size[1], block->Scale(),
317  block->GetRawPtr(), size[0], rhsWrapper, 1,
318  0.0, resultWrapper, 1);
319  }
320  curResultRow += rowsInBlock;
321  if (curResultRow < result.GetRows())
322  {
323  std::fill(result.begin()+curResultRow, result.end(), 0.0);
324  }
325  }
StandardMatrixTag & lhs
NekMatrix< NekMatrix< NekDouble, StandardMatrixTag >, ScaledMatrixTag > DNekScalMat
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().

206  {
207  unsigned int numberOfBlockRows = lhs.GetNumberOfBlockRows();
208  double* result_ptr = result.GetRawPtr();
209  const double* rhs_ptr = rhs.GetRawPtr();
210 
211  Array<OneD, unsigned int> rowSizes;
212  Array<OneD, unsigned int> colSizes;
213  lhs.GetBlockSizes(rowSizes, colSizes);
214 
215  unsigned int curResultRow = 0;
216  unsigned int curWrapperRow = 0;
217  unsigned int rowsInBlock = 0;
218  unsigned int columnsInBlock = 0;
219  for(unsigned int blockRow = 0; blockRow < numberOfBlockRows; ++blockRow)
220  {
221  curResultRow += rowsInBlock;
222  curWrapperRow += columnsInBlock;
223  if ( blockRow == 0)
224  {
225  rowsInBlock = rowSizes[blockRow] + 1;
226  columnsInBlock = colSizes[blockRow] + 1;
227  }
228  else
229  {
230  rowsInBlock = rowSizes[blockRow] - rowSizes[blockRow-1];
231  columnsInBlock = colSizes[blockRow] - colSizes[blockRow-1];
232  }
233 
234  if( rowsInBlock == 0)
235  {
236  continue;
237  }
238  if( columnsInBlock == 0)
239  {
240  std::fill(result.begin()+curResultRow,
241  result.begin()+curResultRow + rowsInBlock, 0.0);
242  continue;
243  }
244 
245  const LhsInnerMatrixType* block = lhs.GetBlockPtr(blockRow, blockRow);
246  if( !block )
247  {
248  continue;
249  }
250 
251  double* resultWrapper = result_ptr + curResultRow;
252  const double* rhsWrapper = rhs_ptr + curWrapperRow;
253  Multiply(resultWrapper, *block, rhsWrapper);
254  //resultWrapper = (*block)*rhsWrapper;
255  }
256  curResultRow += rowsInBlock;
257  if (curResultRow < result.GetRows())
258  {
259  std::fill(result.begin()+curResultRow, result.end(), 0.0);
260  }
261  }
StandardMatrixTag & lhs
void Multiply(DataType *result, const NekMatrix< LhsDataType, MatrixType > &lhs, const DataType *rhs)
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.

462  {
463  DataType result = 0.0;
464  for(unsigned int i = 0; i < 3; ++i)
465  {
466  DataType temp = lhs[i] - rhs[i];
467  result += temp*temp;
468  }
469  return sqrt(result);
470  }
StandardMatrixTag & lhs
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().

607  {
608  ResultDataType* r_buf = result.GetRawPtr();
609  typename boost::add_const<InputDataType>::type* lhs_buf = lhs.GetRawPtr();
610 
611  const unsigned int ldim = lhs.GetDimension();
612  for(int i = 0; i < ldim; ++i)
613  {
614  r_buf[i] = lhs_buf[i] / rhs;
615  }
616  }
StandardMatrixTag & lhs
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().

644  {
645  NekVector<DataType> result(lhs.GetDimension());
646  Divide(result, lhs, rhs);
647  return result;
648  }
StandardMatrixTag & lhs
template NekVector< NekDouble > Divide(const NekVector< NekDouble > &lhs, const NekDouble &rhs)
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/=().

626  {
627  ResultDataType* r_buf = result.GetRawPtr();
628 
629  const unsigned int resdim = result.GetDimension();
630  for(int i = 0; i < resdim; ++i)
631  {
632  r_buf[i] /= rhs;
633  }
634  }
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().

994  {
995  ASSERTL1( lhs.GetDimension() == rhs.GetDimension(), "Dot, dimension of the two operands must be identical.");
996 
997  DataType result = DataType(0);
998  const unsigned int ldim = lhs.GetDimension();
999  for(unsigned int i = 0; i < ldim; ++i)
1000  {
1001  result += lhs[i]*rhs[i];
1002  }
1003 
1004  return result;
1005  }
StandardMatrixTag & lhs
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:228
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.

831  {
832  NekPoint<DataType> result;
833  for(unsigned int i = 0; i < 3; ++i)
834  {
835  result[i] = lhs[i]*t;
836  }
837 
838  return result;
839  }
StandardMatrixTag & lhs
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().

101  {
102  *iter *= rhs;
103  }
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().

474  {
475  try
476  {
477  typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
478  boost::char_separator<char> sep("(<,>) ");
479  tokenizer tokens(str, sep);
480  unsigned int i = 0;
481  for(tokenizer::iterator iter = tokens.begin(); iter != tokens.end(); ++iter)
482  {
483  result[i] = boost::lexical_cast<DataType>(*iter);
484  ++i;
485  }
486 
487  return i == 3;
488  }
489  catch(boost::bad_lexical_cast&)
490  {
491  return false;
492  }
493  }
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs typedef NekMatrix< LhsDataType, StandardMatrixTag >::iterator iterator
template<typename DataType >
std::vector< DataType > Nektar::FromString ( const std::string &  str)

Definition at line 873 of file NekVector.cpp.

References iterator.

874  {
875  std::vector<DataType> result;
876 
877  try
878  {
879  typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
880  boost::char_separator<char> sep("(<,>) ");
881  tokenizer tokens(str, sep);
882  for( tokenizer::iterator strIter = tokens.begin(); strIter != tokens.end(); ++strIter)
883  {
884  result.push_back(boost::lexical_cast<DataType>(*strIter));
885  }
886  }
887  catch(boost::bad_lexical_cast&)
888  {
889  }
890 
891  return result;
892  }
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs typedef NekMatrix< LhsDataType, StandardMatrixTag >::iterator iterator
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().

141  {
142  unsigned int numberOfBlockRows = lhs.GetNumberOfBlockRows();
143  unsigned int numberOfBlockColumns = lhs.GetNumberOfBlockColumns();
144  DataType* result_ptr = result.GetRawPtr();
145  const DataType* rhs_ptr = rhs.GetRawPtr();
146 
147  for(unsigned int i = 0; i < result.GetDimension(); ++i)
148  {
149  result_ptr[i] = DataType(0);
150  }
151  Array<OneD, DataType> temp(result.GetDimension());
152  DataType* temp_ptr = temp.get();
153 
154  unsigned int curResultRow = 0;
155  for(unsigned int blockRow = 0; blockRow < numberOfBlockRows; ++blockRow)
156  {
157  unsigned int rowsInBlock = lhs.GetNumberOfRowsInBlockRow(blockRow);
158 
159  if( blockRow != 0 )
160  {
161  curResultRow += lhs.GetNumberOfRowsInBlockRow(blockRow-1);
162  }
163 
164  if( rowsInBlock == 0 )
165  {
166  continue;
167  }
168 
169  DataType* resultWrapper = result_ptr + curResultRow;
170 
171  unsigned int curWrapperRow = 0;
172  for(unsigned int blockColumn = 0; blockColumn < numberOfBlockColumns; ++blockColumn)
173  {
174  if( blockColumn != 0 )
175  {
176  curWrapperRow += lhs.GetNumberOfColumnsInBlockColumn(blockColumn-1);
177  }
178 
179  //const boost::shared_ptr<const LhsInnerMatrixType>& block = lhs.GetBlock(blockRow, blockColumn);
180  const LhsInnerMatrixType* block = lhs.GetBlockPtr(blockRow, blockColumn);
181  if( !block )
182  {
183  continue;
184  }
185 
186  unsigned int columnsInBlock = lhs.GetNumberOfColumnsInBlockColumn(blockColumn);
187  if( columnsInBlock == 0 )
188  {
189  continue;
190  }
191 
192  const DataType* rhsWrapper = rhs_ptr + curWrapperRow;
193  Multiply(temp_ptr, *block, rhsWrapper);
194  for(unsigned int i = 0; i < rowsInBlock; ++i)
195  {
196  resultWrapper[i] += temp_ptr[i];
197  }
198  }
199  }
200  }
StandardMatrixTag & lhs
void Multiply(DataType *result, const NekMatrix< LhsDataType, MatrixType > &lhs, const DataType *rhs)
Nektar::GENERATE_ADDITION_OPERATOR ( NekMatrix  ,
,
NekMatrix  ,
 
)
Nektar::GENERATE_ADDITION_OPERATOR ( NekVector  ,
,
NekVector  ,
 
)
Nektar::GENERATE_DIVISION_OPERATOR ( NekMatrix  ,
,
NekMatrix  ,
 
)
Nektar::GENERATE_DIVISION_OPERATOR ( NekVector  ,
,
NekDouble  ,
 
)
Nektar::GENERATE_MULTIPLICATION_OPERATOR ( NekMatrix  ,
,
NekMatrix  ,
 
)
Nektar::GENERATE_MULTIPLICATION_OPERATOR ( NekMatrix  ,
,
NekDouble  ,
 
)
Nektar::GENERATE_MULTIPLICATION_OPERATOR ( NekDouble  ,
,
NekMatrix  ,
 
)
Nektar::GENERATE_MULTIPLICATION_OPERATOR ( NekMatrix  ,
,
NekVector  ,
 
)
Nektar::GENERATE_MULTIPLICATION_OPERATOR ( NekVector  ,
,
NekDouble  ,
 
)
Nektar::GENERATE_MULTIPLICATION_OPERATOR ( NekDouble  ,
,
NekVector  ,
 
)
Nektar::GENERATE_MULTIPLICATION_OPERATOR ( NekVector  ,
,
NekVector  ,
 
)
Nektar::GENERATE_SUBTRACTION_OPERATOR ( NekMatrix  ,
,
NekMatrix  ,
 
)
Nektar::GENERATE_SUBTRACTION_OPERATOR ( NekVector  ,
,
NekVector  ,
 
)
ArtificialDiffusionFactory & Nektar::GetArtificialDiffusionFactory ( )

Declaration of the artificial diffusion factory singleton.

Definition at line 43 of file ArtificialDiffusion.cpp.

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

44 {
45  typedef Loki::SingletonHolder<ArtificialDiffusionFactory,
46  Loki::CreateUsingNew,
47  Loki::NoDestroy,
48  Loki::SingleThreaded> Type;
49  return Type::Instance();
50 }
LibUtilities::NekFactory< std::string, ArtificialDiffusion, const LibUtilities::SessionReaderSharedPtr &, const Array< OneD, MultiRegions::ExpListSharedPtr > &, const int > ArtificialDiffusionFactory
Declaration of the artificial diffusion factory.
BoundaryFactory & Nektar::GetBoundaryFactory ( )

Definition at line 69 of file PulseWaveBoundary.cpp.

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

70  {
71  typedef Loki::SingletonHolder<BoundaryFactory,
72  Loki::CreateUsingNew,
73  Loki::NoDestroy > Type;
74  return Type::Instance();
75  }
LibUtilities::NekFactory< std::string, PulseWaveBoundary, Array< OneD, MultiRegions::ExpListSharedPtr > &, const LibUtilities::SessionReaderSharedPtr &, PulseWavePressureAreaSharedPtr & > BoundaryFactory
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().

48  {
49  typedef Loki::SingletonHolder<CellModelFactory,
50  Loki::CreateUsingNew,
51  Loki::NoDestroy > Type;
52  return Type::Instance();
53  }
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...
Definition: CellModel.h:61
CFSBndCondFactory & Nektar::GetCFSBndCondFactory ( )

Declaration of the boundary condition factory singleton.

Definition at line 42 of file CFSBndCond.cpp.

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

43 {
44  typedef Loki::SingletonHolder<CFSBndCondFactory,
45  Loki::CreateUsingNew,
46  Loki::NoDestroy,
47  Loki::SingleThreaded> Type;
48  return Type::Instance();
49 }
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.
Definition: CFSBndCond.h:61
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().

51  {
52  typedef Loki::SingletonHolder<ExtrapolateFactory,
53  Loki::CreateUsingNew,
54  Loki::NoDestroy,
55  Loki::SingleThreaded > Type;
56  return Type::Instance();
57  }
LibUtilities::NekFactory< std::string, Extrapolate, const LibUtilities::SessionReaderSharedPtr &, Array< OneD, MultiRegions::ExpListSharedPtr > &, MultiRegions::ExpListSharedPtr &, const Array< OneD, int > &, const SolverUtils::AdvectionSharedPtr & > ExtrapolateFactory
Definition: Extrapolate.h:67
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().

38  {
39  typedef Loki::SingletonHolder<MemPool ,
40  Loki::CreateUsingNew,
41  Loki::NoDestroy,
42  Loki::SingleThreaded> Type;
43  return Type::Instance();
44  }
PressureAreaFactory & Nektar::GetPressureAreaFactory ( )

Definition at line 64 of file PulseWavePressureArea.cpp.

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

65  {
66  typedef Loki::SingletonHolder<PressureAreaFactory,
67  Loki::CreateUsingNew,
68  Loki::NoDestroy > Type;
69  return Type::Instance();
70  }
LibUtilities::NekFactory< std::string, PulseWavePressureArea, Array< OneD, MultiRegions::ExpListSharedPtr > &, const LibUtilities::SessionReaderSharedPtr & > PressureAreaFactory
ProtocolFactory & Nektar::GetProtocolFactory ( )

Definition at line 40 of file Protocol.cpp.

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

41  {
42  typedef Loki::SingletonHolder<ProtocolFactory,
43  Loki::CreateUsingNew,
44  Loki::NoDestroy > Type;
45  return Type::Instance();
46  }
LibUtilities::NekFactory< std::string, Protocol, const LibUtilities::SessionReaderSharedPtr &, const TiXmlElement * > ProtocolFactory
Datatype of the NekFactory used to instantiate classes derived from the EquationSystem class...
Definition: Protocol.h:54
StimulusFactory & Nektar::GetStimulusFactory ( )

Definition at line 45 of file Stimulus.cpp.

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

46  {
47  typedef Loki::SingletonHolder<StimulusFactory,
48  Loki::CreateUsingNew,
49  Loki::NoDestroy > Type;
50  return Type::Instance();
51  }
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...
Definition: Stimulus.h:60
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.

55  {
56  typedef NekVector<DataType> VectorType;
57  typedef NekMatrix<DataType> MatrixType;
58 
59  //typename dim = x[0].GetDimension();
60  unsigned int dim = x[0].GetDimension();
61  std::vector<VectorType> q(x.size(), VectorType());
62 
63  // This matrix holds the r_ij values. Using the matrix object
64  // is a convenience since it provides a 2D access to a table
65  // of values.
66  MatrixType r(dim, dim);
67  r(0,0) = x[0].L2Norm();
68 
69  if( r(0,0) == DataType(0) )
70  {
71  return q;
72  }
73 
74  q[0] = x[0]/r(0,0);
75 
76  for(unsigned int j = 1; j < x.size(); ++j)
77  {
78  for(unsigned int i = 0; i <= j-1; ++i)
79  {
80  r(i,j) = q[i].Dot(x[j]);
81  }
82 
83  VectorType y = x[j];
84  for(unsigned int i = 0; i <= j-1; ++i)
85  {
86  y = y - r(i,j)*q[i];
87  }
88 
89  r(j,j) = y.L2Norm();
90  if( r(j,j) == DataType(0) )
91  {
92  return q;
93  }
94 
95  q[j] = y/r(j,j);
96  }
97 
98  return q;
99  }
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
gArray of calculated gamma values.
rhoLDensity left state.
rhoRDensity right state.
uLx-velocity component left state.
uRx-velocity component right state.
pLPressure component left state.
pRPressure component right state.
cLSound speed component left state.
cRSound 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().

73  {
74  const NekDouble quser = 2.0;
75  NekDouble cup, ppv, pmin, pmax, qmax;
76 
77  cup = 0.25*(rhoL + rhoR)*(cL + cR);
78  ppv = 0.5 *(pL + pR) + 0.5*(uL - uR)*cup;
79  ppv = std::max(0.0, ppv);
80  pmin = std::min(pL, pR);
81  pmax = std::max(pL, pR);
82  qmax = pmax/pmin;
83 
84  if (qmax <= quser && pmin <= ppv && ppv <= pmax)
85  {
86  // Select PVRS Riemann solver.
87  return ppv;
88  }
89  else if (ppv < pmin)
90  {
91  // Select two-rarefaction Riemann solver.
92  NekDouble pq = pow(pL/pR, g[1]);
93  NekDouble um = (pq*uL/cL + uR/cR + g[4]*(pq - 1.0))/(pq/cL + 1.0/cR);
94  NekDouble ptL = 1.0 + g[7]*(uL - um)/cL;
95  NekDouble ptR = 1.0 + g[7]*(um - uR)/cR;
96  return 0.5*(pL*pow(ptL, g[3]) + pR*pow(ptR, g[3]));
97  }
98  else
99  {
100  // Select two-shock Riemann solver with PVRS as estimate.
101  NekDouble geL = sqrt((g[5]/rhoL)/(g[6]*pL + ppv));
102  NekDouble geR = sqrt((g[5]/rhoR)/(g[6]*pR + ppv));
103  return (geL*pL + geR*pR - (uR - uL))/(geL + geR);
104  }
105  }
double NekDouble
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().

933  {
934  DataType result = fabs(v[0]);
935  const unsigned int vdim = v.GetDimension();
936  for(unsigned int i = 0; i < vdim; ++i)
937  {
938  result = std::max(fabs(v[i]), result);
939  }
940  return result;
941  }
template NekDouble Nektar::InfinityNorm ( const NekVector< NekDouble > &  v)
void Nektar::InvertInPlace ( NekDouble &  v)

Definition at line 1025 of file NekVector.cpp.

1025 { 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==().

48  {
49  if( lhs.num_elements() != rhs.num_elements() )
50  {
51  return false;
52  }
53 
54  if( lhs.data() == rhs.data() )
55  {
56  return true;
57  }
58 
59  for(unsigned int i = 0; i < lhs.num_elements(); ++i)
60  {
61  if( fabs(lhs[i]-rhs[i]) > tol )
62  {
63  return false;
64  }
65  }
66 
67  return true;
68  }
StandardMatrixTag & lhs
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.

79  {
80  if( (lhs.GetRows() != rhs.GetRows()) ||
81  (lhs.GetColumns() != rhs.GetColumns()) )
82  {
83  return false;
84  }
85 
86  if( lhs.data() == rhs.data() )
87  {
88  return true;
89  }
90 
91  for(unsigned int i = 0; i < lhs.GetRows(); ++i)
92  {
93  for(unsigned int j = 0; j < lhs.GetColumns(); ++j)
94  {
95  if( fabs(lhs[i][j]-rhs[i][j]) > tol )
96  {
97  return false;
98  }
99  }
100  }
101 
102  return true;
103  }
StandardMatrixTag & lhs
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().

899  {
900  typedef NekVector<DataType> VectorType;
901 
902  DataType result(0);
903  for(typename VectorType::const_iterator iter = v.begin(); iter != v.end(); ++iter)
904  {
905  result += fabs(*iter);
906  }
907 
908  return result;
909  }
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().

916  {
917  typedef NekVector<DataType> VectorType;
918 
919  DataType result(0);
920  for(typename VectorType::const_iterator iter = v.begin(); iter != v.end(); ++iter)
921  {
922  DataType v = fabs(*iter);
923  result += v*v;
924  }
925  return sqrt(result);
926  }
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().

977  {
978  DataType result = DataType(0);
979 
980  const unsigned int vdim = v.GetDimension();
981  for(unsigned int i = 0; i < vdim; ++i)
982  {
983  result += v[i]*v[i];
984  }
985  return sqrt(result);
986  }
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.

46  {
47  return boost::shared_ptr<DataType>(d);
48  }
DNekMat Nektar::MappingIdealToRef ( SpatialDomains::GeometrySharedPtr  geom)
inline

Definition at line 78 of file LinearElasticSystem.cpp.

References eFULL.

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

79 {
80  int n = geom->GetNumVerts(), i, j;
81 
82  DNekMat map (n, n, 1.0, eFULL);
83  DNekMat mapref(n, n, 1.0, eFULL);
84 
85  // Extract coordinate information.
86  for (i = 0; i < n; ++i)
87  {
88  for (j = 0; j < n-1; ++j)
89  {
90  map(j,i) = (*geom->GetVertex(i))[j];
91  }
92  }
93 
94  // Set up reference triangle or tetrahedron mapping.
95  if (n == 3)
96  {
97  mapref(0,0) = -1.0; mapref(1,0) = -1.0;
98  mapref(0,1) = 1.0; mapref(1,1) = -1.0;
99  mapref(0,2) = -1.0; mapref(1,2) = 1.0;
100  }
101  else if (n == 4)
102  {
103  mapref(0,0) = -1.0; mapref(1,0) = -1.0; mapref(2,0) = -1.0;
104  mapref(0,1) = 1.0; mapref(1,1) = -1.0; mapref(2,1) = -1.0;
105  mapref(0,2) = -1.0; mapref(1,2) = 1.0; mapref(2,2) = -1.0;
106  mapref(0,3) = -1.0; mapref(1,3) = -1.0; mapref(2,3) = 1.0;
107  }
108 
109  map.Invert();
110 
111  DNekMat newmap = mapref * map;
112  DNekMat mapred(n-1, n-1, 1.0, eFULL);
113 
114  for (i = 0; i < n-1; ++i)
115  {
116  for (j = 0; j < n-1; ++j)
117  {
118  mapred(i,j) = newmap(i,j);
119  }
120  }
121 
122  return mapred;
123 }
NekMatrix< NekDouble, StandardMatrixTag > DNekMat
Definition: NekTypeDefs.hpp:52
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().

45  {
46  // TODO - optimize for the different matrix types.
47  int n = lhs.GetRows();
48  int m = lhs.GetColumns();
49  for(unsigned int i = 0; i < n; ++i)
50  {
51  for(unsigned int j = 0; j < m; ++j)
52  {
53  result(i,j) = lhs(i,j)*rhs;
54  }
55  }
56  }
StandardMatrixTag & lhs
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().

64  {
65  typedef typename NekMatrix<LhsDataType, LhsMatrixType>::NumberType ResultDataType;
66  NekMatrix<ResultDataType, StandardMatrixTag> result(lhs.GetRows(), lhs.GetColumns());
67  Multiply(result, lhs, rhs);
68  return result;
69  }
StandardMatrixTag & lhs
void Multiply(NekMatrix< DataType, StandardMatrixTag > &result, const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
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().

543  {
544  NekVector<DataType> result(lhs.GetRows(), DataType(0));
545  Multiply(result, lhs, rhs);
546  return result;
547  }
StandardMatrixTag & lhs
void Multiply(DataType *result, const NekMatrix< LhsDataType, MatrixType > &lhs, const DataType *rhs)
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().

511  {
512 
513  ASSERTL1(lhs.GetColumns() == rhs.GetRows(), std::string("A left side matrix with column count ") +
514  boost::lexical_cast<std::string>(lhs.GetColumns()) +
515  std::string(" and a right side vector with row count ") +
516  boost::lexical_cast<std::string>(rhs.GetRows()) + std::string(" can't be multiplied."));
517  Multiply(result.GetRawPtr(), lhs, rhs.GetRawPtr());
518  }
StandardMatrixTag & lhs
void Multiply(DataType *result, const NekMatrix< LhsDataType, MatrixType > &lhs, const DataType *rhs)
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:228
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().

78  {
79  Multiply(result, rhs, lhs);
80  }
StandardMatrixTag & lhs
void Multiply(NekMatrix< DataType, StandardMatrixTag > &result, const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
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().

526  {
527  if( lhs.GetStorageType() == eDIAGONAL )
528  {
529  DiagonalBlockMatrixMultiply(result, lhs, rhs);
530  }
531  else
532  {
533  FullBlockMatrixMultiply(result, lhs, rhs);
534  }
535  }
void FullBlockMatrixMultiply(NekVector< DataType > &result, const NekMatrix< LhsInnerMatrixType, BlockMatrixTag > &lhs, const NekVector< DataType > &rhs)
StandardMatrixTag & lhs
void DiagonalBlockMatrixMultiply(NekVector< double > &result, const NekMatrix< LhsInnerMatrixType, BlockMatrixTag > &lhs, const NekVector< double > &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().

89  {
90  return Multiply(rhs, lhs);
91  }
StandardMatrixTag & lhs
void Multiply(NekMatrix< DataType, StandardMatrixTag > &result, const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
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().

149  {
150  ASSERTL1(lhs.GetColumns() == rhs.GetRows(), std::string("A left side matrix with column count ") +
151  boost::lexical_cast<std::string>(lhs.GetColumns()) +
152  std::string(" and a right side matrix with row count ") +
153  boost::lexical_cast<std::string>(rhs.GetRows()) + std::string(" can't be multiplied."));
154 
155  result.SetSize(lhs.GetRows(), rhs.GetColumns());
156  if( lhs.GetType() == eFULL && rhs.GetType() == eFULL)
157  {
158  NekMultiplyFullMatrixFullMatrix(result, lhs, rhs);
159  }
160  else
161  {
162  NekMultiplyDefaultImpl(result, lhs, rhs);
163  }
164  }
void NekMultiplyFullMatrixFullMatrix(NekMatrix< ResultType, StandardMatrixTag > &result, const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
StandardMatrixTag & lhs
RhsMatrixType void NekMultiplyDefaultImpl(NekMatrix< ResultType, StandardMatrixTag > &result, const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:228
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().

238  {
239  typedef typename boost::remove_const<typename NekMatrix<LhsDataType, LhsMatrixType>::NumberType>::type NumberType;
240  NekMatrix<NumberType, StandardMatrixTag> result(lhs.GetRows(), rhs.GetColumns());
241  Multiply(result, lhs, rhs);
242  return result;
243  }
StandardMatrixTag & lhs
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 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().

478  {
479  switch(lhs.GetType())
480  {
481  case eFULL:
482  NekMultiplyFullMatrix(result, lhs, rhs);
483  break;
484  case eDIAGONAL:
485  NekMultiplyDiagonalMatrix(result, lhs, rhs);
486  break;
487  case eUPPER_TRIANGULAR:
489  break;
490  case eLOWER_TRIANGULAR:
492  break;
493  case eSYMMETRIC:
494  NekMultiplySymmetricMatrix(result, lhs, rhs);
495  break;
496  case eBANDED:
497  NekMultiplyBandedMatrix(result, lhs, rhs);
498  break;
499  case eSYMMETRIC_BANDED:
502  default:
504  }
505  }
void NekMultiplyUnspecializedMatrixType(DataType *result, const NekMatrix< LhsDataType, MatrixType > &lhs, const DataType *rhs)
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)
void NekMultiplyLowerTriangularMatrix(DataType *result, const NekMatrix< LhsDataType, MatrixType > &lhs, const DataType *rhs)
StandardMatrixTag & lhs
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)
void NekMultiplyDiagonalMatrix(DataType *result, const NekMatrix< LhsDataType, StandardMatrixTag > &lhs, const DataType *rhs)
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)
void NekMultiplyUpperTriangularMatrix(DataType *result, const NekMatrix< LhsDataType, MatrixType > &lhs, const DataType *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().

660  {
661  ResultDataType* result_buf = result.GetRawPtr();
662  const InputDataType* rhs_buf = rhs.GetRawPtr();
663  const InputDataType* lhs_buf = lhs.GetRawPtr();
664  const unsigned int resdim = result.GetDimension();
665  for(int i = 0; i < resdim; ++i)
666  {
667  result_buf[i] = lhs_buf[i] * rhs_buf[i];
668  }
669  }
StandardMatrixTag & lhs
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().

694  {
695  NekVector<DataType> result(lhs.GetDimension());
696  Multiply(result, lhs, rhs);
697  return result;
698  }
template NekVector< NekDouble > Multiply(const NekDouble &lhs, const NekVector< NekDouble > &rhs)
StandardMatrixTag & lhs
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().

709  {
710  ResultDataType* r_buf = result.GetRawPtr();
711  const InputDataType* lhs_buf = lhs.GetRawPtr();
712 
713  const unsigned int ldim = lhs.GetDimension();
714  for(int i = 0; i < ldim; ++i)
715  {
716  r_buf[i] = lhs_buf[i] * rhs;
717  }
718  }
StandardMatrixTag & lhs
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().

744  {
745  NekVector<DataType> result(lhs.GetDimension());
746  Multiply(result, lhs, rhs);
747  return result;
748  }
template NekVector< NekDouble > Multiply(const NekDouble &lhs, const NekVector< NekDouble > &rhs)
StandardMatrixTag & lhs
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().

759  {
760  Multiply(result, rhs, lhs);
761  }
template NekVector< NekDouble > Multiply(const NekDouble &lhs, const NekVector< NekDouble > &rhs)
StandardMatrixTag & 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().

792  {
793  return Multiply(rhs, lhs);
794  }
template NekVector< NekDouble > Multiply(const NekDouble &lhs, const NekVector< NekDouble > &rhs)
StandardMatrixTag & 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 
)
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.

171  {
172  ASSERTL0(result.GetType() == eFULL && rhs.GetType() == eFULL, "Only full matrices supported.");
173  unsigned int M = result.GetRows();
174  unsigned int N = rhs.GetColumns();
175  unsigned int K = result.GetColumns();
176 
177  unsigned int LDA = M;
178  if( result.GetTransposeFlag() == 'T' )
179  {
180  LDA = K;
181  }
182 
183  unsigned int LDB = K;
184  if( rhs.GetTransposeFlag() == 'T' )
185  {
186  LDB = N;
187  }
188  double scale = rhs.Scale();
189  Array<OneD, double>& buf = result.GetTempSpace();
190  Blas::Dgemm(result.GetTransposeFlag(), rhs.GetTransposeFlag(), M, N, K,
191  scale, result.GetRawPtr(), LDA, rhs.GetRawPtr(), LDB, 0.0,
192  buf.data(), result.GetRows());
193  result.SetSize(result.GetRows(), rhs.GetColumns());
194  result.SwapTempAndDataBuffers();
195  }
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:198
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().

208  {
209  ASSERTL1(result.GetColumns() == rhs.GetRows(), std::string("A left side matrix with column count ") +
210  boost::lexical_cast<std::string>(result.GetColumns()) +
211  std::string(" and a right side matrix with row count ") +
212  boost::lexical_cast<std::string>(rhs.GetRows()) + std::string(" can't be multiplied."));
213  NekMatrix<DataType, StandardMatrixTag> temp(result.GetRows(), result.GetColumns());
214 
215  for(unsigned int i = 0; i < result.GetRows(); ++i)
216  {
217  for(unsigned int j = 0; j < result.GetColumns(); ++j)
218  {
219  DataType t = DataType(0);
220 
221  // Set the result(i,j) element.
222  for(unsigned int k = 0; k < result.GetColumns(); ++k)
223  {
224  t += result(i,k)*rhs(k,j);
225  }
226  temp(i,j) = t;
227  }
228  }
229 
230  result = temp;
231  }
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:228
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().

677  {
678  ResultDataType* result_buf = result.GetRawPtr();
679  const InputDataType* rhs_buf = rhs.GetRawPtr();
680  const unsigned int resdim = result.GetDimension();
681  for(int i = 0; i < resdim; ++i)
682  {
683  result_buf[i] *= rhs_buf[i];
684  }
685  }
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().

728  {
729  ResultDataType* r_buf = result.GetRawPtr();
730  const unsigned int rdim = result.GetDimension();
731  for(unsigned int i = 0; i < rdim; ++i)
732  {
733  r_buf[i] *= rhs;
734  }
735  }
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.

767  {
768  ResultDataType* r_buf = result.GetRawPtr();
769  const InputDataType* rhs_buf = rhs.GetRawPtr();
770  NekDouble inverse = 1.0/lhs;
771 
772  const unsigned int rdim = rhs.GetDimension();
773  for(int i = 0; i < rdim; ++i)
774  {
775  r_buf[i] = inverse * rhs_buf[i];
776  }
777  }
StandardMatrixTag & lhs
double NekDouble
template void Nektar::MultiplyInvertedLhs ( NekVector< NekDouble > &  result,
const NekDouble &  lhs,
const NekVector< NekDouble > &  rhs 
)
template<typename DataType >
void Nektar::negate ( NekPoint< DataType > &  rhs)
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-().

948  {
949  NekVector<DataType> temp(v);
950  const unsigned int tdim = temp.GetDimension();
951  for(unsigned int i = 0; i < tdim; ++i)
952  {
953  temp(i) = -temp(i);
954  }
955  return temp;
956  }
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.

240  {
241  v.SetScale(-1.0*v.Scale());
242  }
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().

820  {
821  for(unsigned int i = 0; i < m.GetRows(); ++i)
822  {
823  for(unsigned int j = 0; j < m.GetColumns(); ++j)
824  {
825  m(i,j) *= -1.0;
826  }
827  }
828  }
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-().

963  {
964  DataType* data = v.GetRawPtr();
965  const unsigned int vdim = v.GetDimension();
966  for(unsigned int i = 0; i < vdim; ++i)
967  {
968  data[i] = -data[i];
969  }
970  }
template void Nektar::NegateInPlace ( NekVector< NekDouble > &  v)
void Nektar::NegateInPlace ( NekDouble &  v)

Definition at line 1024 of file NekVector.cpp.

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

108  {
109  int m = lhs.GetRows();
110  int n = lhs.GetColumns();
111  int kl = lhs.GetNumberOfSubDiagonals();
112  int ku = lhs.GetNumberOfSuperDiagonals();
113  double alpha = lhs.Scale();
114  const double* a = lhs.GetRawPtr();
115  int lda = kl + ku + 1;
116  const double* x = rhs;
117  int incx = 1;
118  double beta = 0.0;
119  double* y = result;
120  int incy = 1;
121  Blas::Dgbmv('N', m, n, kl, ku, alpha, a, lda, x, incx, beta, y, incy);
122 
123  }
StandardMatrixTag & lhs
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.

133  {
134  NEKERROR(ErrorUtil::efatal, "Banded block matrix multiplication not yet implemented");
135  }
#define NEKERROR(type, msg)
Assert Level 0 – Fundamental assert which is used whether in FULLDEBUG, DEBUG or OPT compilation mod...
Definition: ErrorUtil.hpp:191
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().

113  {
114  ASSERTL1(lhs.GetColumns() == rhs.GetRows(), std::string("A left side matrix with column count ") +
115  boost::lexical_cast<std::string>(lhs.GetColumns()) +
116  std::string(" and a right side matrix with row count ") +
117  boost::lexical_cast<std::string>(rhs.GetRows()) + std::string(" can't be multiplied."));
118 
119  for(unsigned int i = 0; i < result.GetRows(); ++i)
120  {
121  for(unsigned int j = 0; j < result.GetColumns(); ++j)
122  {
123  ResultType t = ResultType(0);
124 
125  // Set the result(i,j) element.
126  for(unsigned int k = 0; k < lhs.GetColumns(); ++k)
127  {
128  t += lhs(i,k)*rhs(k,j);
129  }
130  result(i,j) = t;
131  }
132  }
133  }
StandardMatrixTag & lhs
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:228
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().

82  {
83  int n = lhs.GetRows();
84  for(unsigned int i = 0; i < n; ++i)
85  {
86  result[i] = lhs(i,i)*rhs[i];
87  }
88  }
StandardMatrixTag & lhs
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().

94  {
95  int n = lhs.GetRows();
96  const DataType* mat_ptr = lhs.GetRawPtr();
97  Vmath::Vmul(n, mat_ptr, 1, rhs, 1, result, 1);
98  }
StandardMatrixTag & lhs
void Vmul(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Multiply vector z = x*y.
Definition: Vmath.cpp:183
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().

447  {
448  const unsigned int* size = lhs.GetSize();
449 
450  char t = lhs.GetTransposeFlag();
451 
452  double alpha = lhs.Scale();
453  const double* a = lhs.GetRawPtr();
454  int lda = size[0];
455  const double* x = rhs;
456  int incx = 1;
457  double beta = 0.0;
458  double* y = result;
459  int incy = 1;
460 
461  Blas::Dgemv(t, size[0], size[1], alpha, a, lda, x, incx, beta, y, incy);
462  }
StandardMatrixTag & lhs
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().

470  {
472  }
void NekMultiplyUnspecializedMatrixType(DataType *result, const NekMatrix< LhsDataType, MatrixType > &lhs, const DataType *rhs)
StandardMatrixTag & lhs
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.

127  {
128  ASSERTL1(lhs.GetType() == eFULL && rhs.GetType() == eFULL, "Only full matrices are supported.");
129 
130  unsigned int M = lhs.GetRows();
131  unsigned int N = rhs.GetColumns();
132  unsigned int K = lhs.GetColumns();
133 
134  unsigned int LDA = M;
135  if( lhs.GetTransposeFlag() == 'T' )
136  {
137  LDA = K;
138  }
139 
140  unsigned int LDB = K;
141  if( rhs.GetTransposeFlag() == 'T' )
142  {
143  LDB = N;
144  }
145 
146  Blas::Dgemm(lhs.GetTransposeFlag(), rhs.GetTransposeFlag(), M, N, K,
147  lhs.Scale()*rhs.Scale(), lhs.GetRawPtr(), LDA,
148  rhs.GetRawPtr(), LDB, 0.0,
149  result.GetRawPtr(), result.GetRows());
150  }
StandardMatrixTag & lhs
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:228
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().

140  {
141  NekMultiplyDefaultImpl(result, lhs, rhs);
142  }
StandardMatrixTag & lhs
RhsMatrixType void NekMultiplyDefaultImpl(NekMatrix< ResultType, StandardMatrixTag > &result, const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &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().

330  {
331  int vectorSize = lhs.GetColumns();
332  std::copy(rhs, rhs+vectorSize, result);
333  int n = lhs.GetRows();
334  const double* a = lhs.GetRawPtr();
335  double* x = result;
336  int incx = 1;
337 
338  Blas::Dtpmv('L', lhs.GetTransposeFlag(), 'N', n, a, x, incx);
339  }
StandardMatrixTag & lhs
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().

344  {
345  NekMultiplyLowerTriangularMatrix(result, *lhs.GetOwnedMatrix(), rhs);
346 
347  for(unsigned int i = 0; i < lhs.GetColumns(); ++i)
348  {
349  result[i] *= lhs.Scale();
350  }
351  }
void NekMultiplyLowerTriangularMatrix(DataType *result, const NekMatrix< LhsDataType, MatrixType > &lhs, const DataType *rhs)
StandardMatrixTag & lhs
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.

357  {
358  for(unsigned int i = 0; i < lhs.GetRows(); ++i)
359  {
360  DataType accum = DataType(0);
361  for(unsigned int j = 0; j <= i; ++j)
362  {
363  accum += lhs(i,j)*rhs[j];
364  }
365  result[i] = accum;
366  }
367  }
StandardMatrixTag & lhs
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().

417  {
418  const unsigned int* size = lhs.GetSize();
419 
420  double alpha = lhs.Scale();
421  const double* a = lhs.GetRawPtr();
422  const double* x = rhs;
423  int incx = 1;
424  double beta = 0.0;
425  double* y = result;
426  int incy = 1;
427 
428  Blas::Dspmv('U', size[0], alpha, a, x, incx, beta, y, incy);
429  }
StandardMatrixTag & lhs
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().

437  {
439  }
void NekMultiplyUnspecializedMatrixType(DataType *result, const NekMatrix< LhsDataType, MatrixType > &lhs, const DataType *rhs)
StandardMatrixTag & lhs
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().

66  {
67  for(unsigned int i = 0; i < lhs.GetRows(); ++i)
68  {
69  DataType accum = DataType(0);
70  for(unsigned int j = 0; j < lhs.GetColumns(); ++j)
71  {
72  accum += lhs(i,j)*rhs[j];
73  }
74  result[i] = accum;
75  }
76  }
StandardMatrixTag & lhs
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().

372  {
373  int vectorSize = lhs.GetColumns();
374  std::copy(rhs, rhs+vectorSize, result);
375  int n = lhs.GetRows();
376  const double* a = lhs.GetRawPtr();
377  double* x = result;
378  int incx = 1;
379 
380  Blas::Dtpmv('U', lhs.GetTransposeFlag(), 'N', n, a, x, incx);
381  }
StandardMatrixTag & lhs
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().

386  {
387  NekMultiplyUpperTriangularMatrix(result, *lhs.GetOwnedMatrix(), rhs);
388 
389  for(unsigned int i = 0; i < lhs.GetColumns(); ++i)
390  {
391  result[i] *= lhs.Scale();
392  }
393  }
StandardMatrixTag & lhs
void NekMultiplyUpperTriangularMatrix(DataType *result, const NekMatrix< LhsDataType, MatrixType > &lhs, const DataType *rhs)
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.

399  {
400  for(unsigned int i = 0; i < lhs.GetRows(); ++i)
401  {
402  DataType accum = DataType(0);
403  for(unsigned int j = i; j < lhs.GetColumns(); ++j)
404  {
405  accum += lhs(i,j)*rhs[j];
406  }
407  result[i] = accum;
408  }
409  }
StandardMatrixTag & lhs
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().

1013  {
1014  DataType m = v.Magnitude();
1015  if( m > DataType(0) )
1016  {
1017  v /= m;
1018  }
1019  }
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.

385  {
386  return !(lhs == rhs);
387  }
StandardMatrixTag & lhs
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.

740  {
741  return !(lhs == rhs);
742  }
StandardMatrixTag & lhs
template<typename DataType >
bool Nektar::operator!= ( const Array< TwoD, DataType > &  lhs,
const Array< TwoD, DataType > &  rhs 
)

Definition at line 800 of file SharedArray.hpp.

801  {
802  return !(lhs == rhs);
803  }
StandardMatrixTag & lhs
template<typename DataType >
bool Nektar::operator!= ( const NekVector< DataType > &  lhs,
const NekVector< DataType > &  rhs 
)

Definition at line 862 of file NekVector.cpp.

864  {
865  return !(lhs == rhs);
866  }
StandardMatrixTag & lhs
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.

435  {
436  NekPoint<DataType> result(rhs);
437  result *= lhs;
438  return result;
439  }
StandardMatrixTag & lhs
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.

444  {
445  NekPoint<DataType> result(lhs);
446  result *= rhs;
447  return result;
448  }
StandardMatrixTag & lhs
template<typename DataType >
NekPoint<DataType> Nektar::operator+ ( const NekPoint< DataType > &  lhs,
const NekPoint< DataType > &  rhs 
)

Definition at line 380 of file NekPoint.hpp.

381  {
382  NekPoint<DataType> result(lhs);
383  result += rhs;
384  return result;
385  }
StandardMatrixTag & lhs
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.

390  {
391  NekPoint<DataType> result(rhs);
392  result += lhs;
393  return result;
394  }
StandardMatrixTag & lhs
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.

399  {
400  NekPoint<DataType> result(lhs);
401  result += rhs;
402  return result;
403  }
StandardMatrixTag & lhs
template<typename DataType >
Array<OneD, DataType> Nektar::operator+ ( const Array< OneD, DataType > &  lhs,
unsigned int  offset 
)

Definition at line 745 of file SharedArray.hpp.

746  {
747  return Array<OneD, const DataType>::CreateWithOffset(lhs, offset);
748  }
StandardMatrixTag & lhs
template<typename DataType >
Array<OneD, DataType> Nektar::operator+ ( unsigned int  offset,
const Array< OneD, DataType > &  rhs 
)

Definition at line 751 of file SharedArray.hpp.

752  {
753  return Array<OneD, const DataType>::CreateWithOffset(rhs, offset);
754  }
template<typename DataType >
NekPoint<DataType> Nektar::operator- ( const NekPoint< DataType > &  lhs,
const NekPoint< DataType > &  rhs 
)

Definition at line 407 of file NekPoint.hpp.

408  {
409  NekPoint<DataType> result(lhs);
410  result -= rhs;
411  return result;
412  }
StandardMatrixTag & lhs
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.

417  {
418  NekPoint<DataType> result(-rhs);
419  result += lhs;
420  return result;
421  }
StandardMatrixTag & lhs
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.

426  {
427  NekPoint<DataType> result(lhs);
428  result -= rhs;
429  return result;
430  }
StandardMatrixTag & lhs
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.

453  {
454  NekPoint<DataType> result(lhs);
455  result /= rhs;
456  return result;
457  }
StandardMatrixTag & lhs
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.

57  {
58  int oswidth = 9;
59  int osprecision = 6;
60 
61  for(unsigned int i = 0; i < rhs.GetRows(); ++i)
62  {
63  os << "[";
64  for(unsigned int j = 0; j < rhs.GetColumns(); ++j)
65  {
66  os.width(oswidth);
67  os.precision(osprecision);
68  os << rhs(i,j);
69  if( j != rhs.GetColumns() - 1 )
70  {
71  os << ", ";
72  }
73  }
74  os << "]";
75  if( i != rhs.GetRows()-1 )
76  {
77  os << std::endl;
78  }
79  }
80  return os;
81  }
template<typename SparseStorageType >
std::ostream & Nektar::operator<< ( std::ostream &  os,
const NekSparseMatrix< SparseStorageType > &  rhs 
)

Definition at line 87 of file SparseUtils.cpp.

88  {
89  int oswidth = 9;
90  int osprecision = 6;
91 
92  for(unsigned int i = 0; i < rhs.GetRows(); ++i)
93  {
94  os << "[";
95  for(unsigned int j = 0; j < rhs.GetColumns(); ++j)
96  {
97  os.width(oswidth);
98  os.precision(osprecision);
99  os << rhs(i,j);
100  if( j != rhs.GetColumns() - 1 )
101  {
102  os << ", ";
103  }
104  }
105  os << "]";
106  if( i != rhs.GetRows()-1 )
107  {
108  os << std::endl;
109  }
110  }
111  return os;
112  }
template<typename SparseStorageType >
std::ostream & Nektar::operator<< ( std::ostream &  os,
const NekSparseDiagBlkMatrix< SparseStorageType > &  rhs 
)

Definition at line 115 of file SparseUtils.cpp.

116  {
117  int oswidth = 9;
118  int osprecision = 6;
119 
120  for(unsigned int i = 0; i < rhs.GetRows(); ++i)
121  {
122  os << "[";
123  for(unsigned int j = 0; j < rhs.GetColumns(); ++j)
124  {
125  os.width(oswidth);
126  os.precision(osprecision);
127  os << rhs(i,j);
128  if( j != rhs.GetColumns() - 1 )
129  {
130  os << ", ";
131  }
132  }
133  os << "]";
134  if( i != rhs.GetRows()-1 )
135  {
136  os << std::endl;
137  }
138  }
139  return os;
140  }
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.

497  {
498  os << p.AsString();
499  return os;
500  }
template<typename DataType >
std::ostream & Nektar::operator<< ( std::ostream &  os,
const NekVector< DataType > &  rhs 
)

Definition at line 802 of file NekVector.cpp.

803  {
804  os << rhs.AsString();
805  return os;
806  }
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().

40  {
41  return IsEqual(lhs,rhs);
42  }
bool IsEqual(const Array< TwoD, const NekDouble > &lhs, const Array< TwoD, const NekDouble > &rhs, NekDouble tol)
bool Nektar::operator== ( const Array< TwoD, NekDouble > &  lhs,
const Array< TwoD, NekDouble > &  rhs 
)

Definition at line 71 of file ArrayEqualityComparison.cpp.

References IsEqual().

72  {
73  return IsEqual(lhs,rhs);
74  }
StandardMatrixTag & lhs
bool IsEqual(const Array< TwoD, const NekDouble > &lhs, const Array< TwoD, const NekDouble > &rhs, NekDouble tol)
template<typename DataType >
bool Nektar::operator== ( const MemoryManager< DataType > &  lhs,
const MemoryManager< DataType > &  rhs 
)

Definition at line 378 of file NekMemoryManager.hpp.

379  {
380  return true;
381  }
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.

716  {
717  if( lhs.num_elements() != rhs.num_elements() )
718  {
719  return false;
720  }
721 
722  if( lhs.data() == rhs.data() )
723  {
724  return true;
725  }
726 
727  for(unsigned int i = 0; i < lhs.num_elements(); ++i)
728  {
729  if( lhs[i] != rhs[i] )
730  {
731  return false;
732  }
733  }
734 
735  return true;
736  }
StandardMatrixTag & lhs
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.

795  {
796  return *lhs.m_data == *rhs.m_data;
797  }
StandardMatrixTag & lhs
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().

848  {
849  if( lhs.GetDimension() != rhs.GetDimension() )
850  {
851  return false;
852  }
853 
854  return std::equal(lhs.begin(), lhs.end(), rhs.begin());
855  }
StandardMatrixTag & lhs
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.

85  {
86  NekDouble tol = 1e-12;
87  os << "[" << std::endl;
88 
89  for(unsigned int i = 0; i < rhs.GetRows(); ++i)
90  {
91  for(unsigned int j = 0; j < rhs.GetColumns(); ++j)
92  {
93  if((NekDouble)rhs(i,j) > tol)
94  {
95  os << '+';
96  }
97  else if((NekDouble)rhs(i,j) < -tol)
98  {
99  os << '*';
100  }
101  else
102  {
103  os << '-';
104  }
105  }
106  if( i != rhs.GetRows()-1 )
107  {
108  os << std::endl;
109  }
110  }
111  os << "]" << std::endl;
112  return os;
113  }
double NekDouble
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
gArray of gamma parameters.
pPressure at current iteration.
dkDensity (left or right state)
pkPressure (left or right state)
ckSound speed (left or right state)
fComputed pressure (shock).
fdComputed pressure (rarefaction).

Definition at line 119 of file ExactSolverToro.cpp.

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

121  {
122  if (p <= pk)
123  {
124  // Rarefaction wave
125  NekDouble prat = p/pk;
126  f = g[4]*ck*(pow(prat, g[1])-1.0);
127  fd = pow(prat, -g[2])/(dk*ck);
128  }
129  else
130  {
131  // Shock wave
132  NekDouble ak = g[5]/dk;
133  NekDouble bk = g[6]*pk;
134  NekDouble qrt = sqrt(ak/(bk+p));
135  f = (p-pk)*qrt;
136  fd = (1.0-0.5*(p-pk)/(bk+p))*qrt;
137  }
138  }
double NekDouble
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().

276  {
277  ASSERTL1(lhs.GetRows() == rhs.GetRows(), std::string("Matrices with different row counts ") +
278  boost::lexical_cast<std::string>(lhs.GetRows()) + std::string(" and ") +
279  boost::lexical_cast<std::string>(rhs.GetRows()) + std::string(" can't be subtracted."));
280  ASSERTL1(lhs.GetColumns() == rhs.GetColumns(), std::string("Matrices with different column counts ") +
281  boost::lexical_cast<std::string>(lhs.GetColumns()) + std::string(" and ") +
282  boost::lexical_cast<std::string>(rhs.GetColumns()) + std::string(" can't be subtracted."));
283 
284  for(unsigned int i = 0; i < lhs.GetRows(); ++i)
285  {
286  for(unsigned int j = 0; j < lhs.GetColumns(); ++j)
287  {
288  result(i,j) = lhs(i,j) - rhs(i,j);
289  }
290  }
291  }
StandardMatrixTag & lhs
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:228
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().

366  {
367  typedef typename NekMatrix<LhsDataType, LhsMatrixType>::NumberType NumberType;
368  NekMatrix<NumberType, StandardMatrixTag> result(lhs.GetRows(), lhs.GetColumns());
369  Subtract(result, lhs, rhs);
370  return result;
371  }
StandardMatrixTag & lhs
DNekMat NekMatrix< typename NekMatrix< LhsDataType, LhsMatrixType >::NumberType, StandardMatrixTag > Subtract(const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
template<typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >
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().

366  {
367  typedef typename NekMatrix<LhsDataType, LhsMatrixType>::NumberType NumberType;
368  NekMatrix<NumberType, StandardMatrixTag> result(lhs.GetRows(), lhs.GetColumns());
369  Subtract(result, lhs, rhs);
370  return result;
371  }
StandardMatrixTag & lhs
DNekMat NekMatrix< typename NekMatrix< LhsDataType, LhsMatrixType >::NumberType, StandardMatrixTag > Subtract(const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
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().

518  {
519  ResultDataType* r_buf = result.GetRawPtr();
520  typename boost::add_const<InputDataType>::type* lhs_buf = lhs.GetRawPtr();
521  typename boost::add_const<InputDataType>::type* rhs_buf = rhs.GetRawPtr();
522  const unsigned int ldim = lhs.GetDimension();
523  for(int i = 0; i < ldim; ++i)
524  {
525  r_buf[i] = lhs_buf[i] - rhs_buf[i];
526  }
527  }
StandardMatrixTag & lhs
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().

592  {
593  NekVector<DataType> result(lhs.GetDimension());
594  Subtract(result, lhs, rhs);
595  return result;
596  }
template NekVector< NekDouble > Subtract(const NekVector< NekDouble > &lhs, const NekVector< NekDouble > &rhs)
StandardMatrixTag & lhs
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-=().

322  {
323  ASSERTL1(result.GetRows() == rhs.GetRows(), std::string("Matrices with different row counts ") +
324  boost::lexical_cast<std::string>(result.GetRows()) + std::string(" and ") +
325  boost::lexical_cast<std::string>(rhs.GetRows()) + std::string(" can't be subtracted."));
326  ASSERTL1(result.GetColumns() == rhs.GetColumns(), std::string("Matrices with different column counts ") +
327  boost::lexical_cast<std::string>(result.GetColumns()) + std::string(" and ") +
328  boost::lexical_cast<std::string>(rhs.GetColumns()) + std::string(" can't be subtracted."));
329 
330  for(unsigned int i = 0; i < rhs.GetRows(); ++i)
331  {
332  for(unsigned int j = 0; j < rhs.GetColumns(); ++j)
333  {
334  result(i,j) -= rhs(i,j);
335  }
336  }
337  }
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:228
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-=().

322  {
323  ASSERTL1(result.GetRows() == rhs.GetRows(), std::string("Matrices with different row counts ") +
324  boost::lexical_cast<std::string>(result.GetRows()) + std::string(" and ") +
325  boost::lexical_cast<std::string>(rhs.GetRows()) + std::string(" can't be subtracted."));
326  ASSERTL1(result.GetColumns() == rhs.GetColumns(), std::string("Matrices with different column counts ") +
327  boost::lexical_cast<std::string>(result.GetColumns()) + std::string(" and ") +
328  boost::lexical_cast<std::string>(rhs.GetColumns()) + std::string(" can't be subtracted."));
329 
330  for(unsigned int i = 0; i < rhs.GetRows(); ++i)
331  {
332  for(unsigned int j = 0; j < rhs.GetColumns(); ++j)
333  {
334  result(i,j) -= rhs(i,j);
335  }
336  }
337  }
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:228
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().

557  {
558  ResultDataType* r_buf = result.GetRawPtr();
559  typename boost::add_const<InputDataType>::type* rhs_buf = rhs.GetRawPtr();
560  const unsigned int rdim = rhs.GetDimension();
561  for(int i = 0; i < rdim; ++i)
562  {
563  r_buf[i] -= rhs_buf[i];
564  }
565  }
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().

342  {
343  ASSERTL1(result.GetRows() == rhs.GetRows(), std::string("Matrices with different row counts ") +
344  boost::lexical_cast<std::string>(result.GetRows()) + std::string(" and ") +
345  boost::lexical_cast<std::string>(rhs.GetRows()) + std::string(" can't be subtracted."));
346  ASSERTL1(result.GetColumns() == rhs.GetColumns(), std::string("Matrices with different column counts ") +
347  boost::lexical_cast<std::string>(result.GetColumns()) + std::string(" and ") +
348  boost::lexical_cast<std::string>(rhs.GetColumns()) + std::string(" can't be subtracted."));
349 
350  for(unsigned int i = 0; i < rhs.GetRows(); ++i)
351  {
352  for(unsigned int j = 0; j < rhs.GetColumns(); ++j)
353  {
354  result(i,j) = -result(i,j) - rhs(i,j);
355  }
356  }
357  }
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:228
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().

570  {
571  ResultDataType* r_buf = result.GetRawPtr();
572  typename boost::add_const<InputDataType>::type* rhs_buf = rhs.GetRawPtr();
573  const unsigned int rdim = rhs.GetDimension();
574  for(int i = 0; i < rdim; ++i)
575  {
576  r_buf[i] = -r_buf[i] - rhs_buf[i];
577  }
578  }
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.

297  {
298  ASSERTL1(lhs.GetRows() == rhs.GetRows(), std::string("Matrices with different row counts ") +
299  boost::lexical_cast<std::string>(lhs.GetRows()) + std::string(" and ") +
300  boost::lexical_cast<std::string>(rhs.GetRows()) + std::string(" can't be subtracted."));
301  ASSERTL1(lhs.GetColumns() == rhs.GetColumns(), std::string("Matrices with different column counts ") +
302  boost::lexical_cast<std::string>(lhs.GetColumns()) + std::string(" and ") +
303  boost::lexical_cast<std::string>(rhs.GetColumns()) + std::string(" can't be subtracted."));
304 
305  for(unsigned int i = 0; i < lhs.GetRows(); ++i)
306  {
307  for(unsigned int j = 0; j < lhs.GetColumns(); ++j)
308  {
309  result(i,j) = -lhs(i,j) - rhs(i,j);
310  }
311  }
312  }
StandardMatrixTag & lhs
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:228
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().

533  {
534  ResultDataType* r_buf = result.GetRawPtr();
535  typename boost::add_const<InputDataType>::type* lhs_buf = lhs.GetRawPtr();
536  typename boost::add_const<InputDataType>::type* rhs_buf = rhs.GetRawPtr();
537  const unsigned int ldim = lhs.GetDimension();
538  for(int i = 0; i < ldim; ++i)
539  {
540  r_buf[i] = -lhs_buf[i] - rhs_buf[i];
541  }
542  }
StandardMatrixTag & lhs
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.

180  {
181  NekMatrix<DataType, ScaledMatrixTag> result(rhs);
182  result.Transpose();
183  return result;
184  }
template<typename InnerMatrixType >
NekMatrix<InnerMatrixType, BlockMatrixTag> Nektar::Transpose ( NekMatrix< InnerMatrixType, BlockMatrixTag > &  rhs)
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().

806  {
807  NekMatrix<DataType, StandardMatrixTag> result(rhs.GetRows(), rhs.GetColumns(),
808  rhs.GetPtr(), eWrapper, rhs.GetType(), rhs.GetNumberOfSubDiagonals(),
809  rhs.GetNumberOfSuperDiagonals());
810  result.Transpose();
811  return result;
812  }
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::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::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::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::FieldUtils::ProcessNumModes::Process(), Nektar::Utilities::ProcessLinear::Process(), Nektar::FieldUtils::ProcessVorticity::Process(), Nektar::FieldUtils::ProcessQCriterion::Process(), Nektar::Utilities::InputNek::Process(), Nektar::NekMeshUtils::SurfaceMesh::Process(), Nektar::NekMeshUtils::Generator2D::Process(), Nektar::Utilities::ProcessInsertSurface::Process(), Nektar::Utilities::ProcessExtractSurf::Process(), Nektar::Utilities::ProcessLinkCheck::Process(), Nektar::Utilities::ProcessExtractTetPrismInterface::Process(), Nektar::Utilities::ProcessTetSplit::Process(), Nektar::Utilities::ProcessDetectSurf::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
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
DNekScalBlkMatSharedPtr Nektar::NullDNekScalBlkMatSharedPtr
static
DNekScalMatSharedPtr Nektar::NullDNekScalMatSharedPtr
static

Definition at line 80 of file NekTypeDefs.hpp.

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

FlagList Nektar::NullFlagList
static
Array<OneD, int> Nektar::NullInt1DArray
static
Array<OneD, NekDouble> Nektar::NullNekDouble1DArray
static
Array<OneD, Array<OneD, NekDouble> > Nektar::NullNekDoubleArrayofArray
static
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
const std::string Nektar::VWIIterationTypeMap[]
Initial value:
=
{
"FixedAlpha",
"FixedWaveForcing",
"FixedAlphaWaveForcing",
"FixedWaveForcingWithSubIterationOnAlpha"
}

Definition at line 64 of file VortexWaveInteraction.h.

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