Nektar++
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
Nektar Namespace Reference

Namespaces

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

Classes

class  AcousticSolver
 
class  AcousticSystem
 
class  AdjointAdvection
 Advection for the adjoint form of the linearised Navier-Stokes equations. More...
 
class  AInflow
 
class  AlternateSkewAdvection
 
class  APE
 
class  APELaxFriedrichsSolver
 
class  APEUpwindSolver
 
class  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< TwoD, const DataType >
 2D array with garbage collection and bounds checking. More...
 
class  Array< TwoD, DataType >
 A 2D array. More...
 
class  ArrayDestructionPolicy
 
class  ArrayDestructionPolicy< ObjectType, typename std::enable_if< std::is_fundamental< ObjectType >::value >::type >
 
class  ArrayDestructionPolicy< ObjectType, typename std::enable_if<!std::is_fundamental< ObjectType >::value >::type >
 
class  ArrayInitializationPolicy
 
class  ArrayInitializationPolicy< ObjectType, typename std::enable_if< std::is_fundamental< ObjectType >::value >::type >
 
class  ArrayInitializationPolicy< ObjectType, typename std::enable_if<!std::is_fundamental< ObjectType >::value >::type >
 
class  ArterialPressureArea
 A global linear system. More...
 
class  ArtificialDiffusion
 Encapsulates the artificial diffusion used in shock capture. More...
 
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< DataType * >
 
struct  ConsistentObjectAccess< std::shared_ptr< DataType > >
 
class  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  DiffusionLDGNS
 
class  Dummy
 
class  EigenValuesAdvection
 
struct  EnumHash
 
class  EquationOfState
 Encapsulates equations of state allowing us to obtain thermodynamic properties: most relations are in the form X(rho,e) More...
 
class  ErrorUtil
 
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  FilterMovingBody
 
class  FlagList
 Defines a list of flags. More...
 
class  ForcingAxiSymmetric
 
class  ForcingMovingBody
 
class  ForcingQuasi1D
 
class  ForcingStabilityCoupledLNS
 
struct  FourD
 
class  Fox02
 
struct  FullMatrixFuncs
 
class  Helmholtz
 
struct  HighOrderOutflow
 
class  HLLCSolver
 
class  HLLSolver
 
class  IdealGasEoS
 Ideal gas equation of state: p = rho * R * T. More...
 
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< std::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  LEE
 
class  LEELaxFriedrichsSolver
 
class  LEESolver
 
class  LEEUpwindSolver
 
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
 
class  Matrix
 
class  MemoryManager
 General purpose memory allocation routines with the ability to allocate from thread specific memory pools. More...
 
class  MemPool
 
class  MMFAdvection
 
class  MMFDiffusion
 A model for cardiac conduction. More...
 
class  MMFMaxwell
 
class  MMFSWE
 
class  Monodomain
 A model for cardiac conduction. More...
 
class  NavierStokesAdvection
 
class  NavierStokesCFE
 
class  NavierStokesCFEAxisym
 
class  NekMatrix
 
class  NekMatrix< DataType, StandardMatrixTag >
 Standard Matrix. More...
 
class  NekMatrix< NekMatrix< DataType, InnerMatrixType >, BlockMatrixTag >
 
class  NekMatrix< NekMatrix< DataType, InnerMatrixType >, ScaledMatrixTag >
 
class  NekPoint
 
class  NekSparseDiagBlkMatrix
 
class  NekSparseMatrix
 
class  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
 
struct  PairHash
 
class  PanditGilesDemir03
 
class  ParseUtils
 
class  PengRobinsonEoS
 Peng-Robinson equation of state: p = RT/(1/rho - b) - a*Alpha(T/Tc) / (1/rho^2 + 2*b/rho - b^2) with a = 0.45724 * (R*Tc)^2 / Pc b = 0.0778 * (R*Tc) / Pc Alpha(T/Tc) = [1 + fw * (1 - sqrt(T/ Tc))]^2 fw = 0.37464 + 1.54226*omega - 0.2699*omega*omega. More...
 
class  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  PressureMachTemperatureBC
 Boundary condition in terms of pressure, Mach number and temperature. P should be defined in the "rho" entry, T in the "E" entry and the Mach number in each direction in the corresponding momentum variable. This state is converted to conserved variables and a Dirichlet condition is applied. More...
 
class  PressureOutflowBC
 Pressure outflow boundary conditions for compressible flow problems. More...
 
class  PressureOutflowNonReflectiveBC
 Pressure outflow non-reflective boundary conditions for compressible flow problems. More...
 
class  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...
 
struct  PushBackFunctor
 Helper functors for holding a vector of numbers to be parsed by boost::spirit. More...
 
class  QInflow
 A global linear system. More...
 
struct  RawType
 
struct  RawType< const std::shared_ptr< T > >
 
struct  RawType< const volatile std::shared_ptr< T > >
 
struct  RawType< std::shared_ptr< T > >
 
struct  RawType< volatile std::shared_ptr< T > >
 
class  RCROutflow
 A global linear system. More...
 
class  RedlichKwongEoS
 Redlich-Kwong equation of state: p = RT/(1/rho - b) - a/( sqrt(T / Tc) * (1/rho^2 + b/rho) with a = 0.42748 * (R*Tc)^2 / Pc b = 0.08664 * (R*Tc) / Pc. More...
 
class  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  StagnationInflowBC
 Stagnation conditions inflow boundary conditions for compressible flow problems where the energy and density are prescribed. 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...
 
struct  TriangularBandedMatrixFuncs
 
struct  TriangularMatrixFuncs
 
struct  TwoD
 
class  UInflow
 A global linear system. More...
 
class  UndefinedInOutflow
 A global linear system. More...
 
class  UnsteadyAdvection
 
class  UnsteadyAdvectionDiffusion
 
class  UnsteadyDiffusion
 
class  UnsteadyInviscidBurger
 
class  UnsteadyReactionDiffusion
 
class  UnsteadyViscousBurgers
 
struct  UpperTriangularBandedMatrixFuncs
 
struct  UpperTriangularMatrixFuncs
 
class  UpwindPulseSolver
 
class  VanDerWaalsEoS
 van der Waals equation of state: p = RT/(1/rho - b) - a * rho^2 with a = 27/64 * (R*Tc)^2 / Pc b = 1/8 * (R*Tc) / Pc More...
 
class  VariableConverter
 
class  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
 

Typedefs

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

Enumerations

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

Functions

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

Variables

const char *const FlagTypeMap []
 String map for FlagType enumeration. More...
 
static FlagList NullFlagList
 An empty flag list. More...
 
static Array< OneD, int > NullInt1DArray
 
static Array< OneD, NekDouble > NullNekDouble1DArray
 
static Array< OneD, Array< OneD, NekDouble > > NullNekDoubleArrayofArray
 
 LhsDataType
 
 RhsMatrixType
 
 RhsDataType
 
StandardMatrixTag & lhs
 
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
 
 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 char *const TestTypeMap []
 
const char *const InitWaveTypeMap []
 
const std::string kEquationTypeStr []
 
const std::string kAdvectionFormStr []
 
static PulseWaveBoundarySharedPtr NullPulseWaveBoundarySharedPtr
 
static PulseWavePressureAreaSharedPtr NullPulseWavePressureAreaSharedPtr
 
const char *const UpwindTypeMapPulse []
 
const char *const ProblemTypeMap [] = { "General", "SolitaryWave" }
 
const std::string VWIIterationTypeMap []
 
static char const kDefaultState [] = "default"
 

Typedef Documentation

◆ AInflowSharedPtr

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

Definition at line 44 of file AInflow.h.

◆ ArterialPressureAreaSharedPtr

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

Pointer to a PulseWaveOutflow object.

Definition at line 44 of file ArterialPressureArea.h.

◆ ArtificialDiffusionFactory

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

Declaration of the artificial diffusion factory.

Definition at line 59 of file ArtificialDiffusion.h.

◆ ArtificialDiffusionSharedPtr

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

A shared pointer to a artificial diffusion object.

Definition at line 50 of file ArtificialDiffusion.h.

◆ BCOEntryType

typedef Array<OneD, NekDouble> Nektar::BCOEntryType

Definition at line 63 of file SparseMatrixFwd.hpp.

◆ BCOMatType

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

Definition at line 64 of file SparseMatrixFwd.hpp.

◆ BCOMatTypeConstIt

typedef BCOMatType::const_iterator Nektar::BCOMatTypeConstIt

Definition at line 65 of file SparseMatrixFwd.hpp.

◆ BCOMatTypeSharedPtr

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

Definition at line 66 of file SparseMatrixFwd.hpp.

◆ BCOMatVector

typedef Array<OneD, BCOMatType> Nektar::BCOMatVector

Definition at line 67 of file SparseMatrixFwd.hpp.

◆ BlkMatDNekBlkMat

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

Definition at line 63 of file NekTypeDefs.hpp.

◆ BlkMatDNekBlkMatSharedPtr

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

Definition at line 72 of file NekTypeDefs.hpp.

◆ BlkMatDNekScalBlkMat

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

Definition at line 67 of file NekTypeDefs.hpp.

◆ BlkMatDNekScalBlkMatSharedPtr

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

Definition at line 74 of file NekTypeDefs.hpp.

◆ BlockMatrix

typedef NekMatrix<DenseMatrix, BlockMatrixTag> Nektar::BlockMatrix

Definition at line 60 of file NekTypeDefs.hpp.

◆ BoundaryFactory

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

Definition at line 55 of file PulseWaveBoundary.h.

◆ CellModelFactory

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

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

Definition at line 60 of file CellModel.h.

◆ CellModelSharedPtr

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

A shared pointer to an EquationSystem object.

Definition at line 55 of file CellModel.h.

◆ CFSBndCondFactory

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

Declaration of the boundary condition factory.

Definition at line 60 of file CFSBndCond.h.

◆ CFSBndCondSharedPtr

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

A shared pointer to a boundary condition object.

Definition at line 48 of file CFSBndCond.h.

◆ COOEntryType

typedef NekDouble Nektar::COOEntryType

Definition at line 56 of file SparseMatrixFwd.hpp.

◆ COOMatType

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

Definition at line 57 of file SparseMatrixFwd.hpp.

◆ COOMatTypeConstIt

typedef COOMatType::const_iterator Nektar::COOMatTypeConstIt

Definition at line 58 of file SparseMatrixFwd.hpp.

◆ COOMatTypeSharedPtr

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

Definition at line 59 of file SparseMatrixFwd.hpp.

◆ COOMatVector

typedef Array<OneD, COOMatType> Nektar::COOMatVector

Definition at line 60 of file SparseMatrixFwd.hpp.

◆ CoordType

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

Definition at line 55 of file SparseMatrixFwd.hpp.

◆ CoupledAssemblyMapSharedPtr

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

Definition at line 62 of file CoupledAssemblyMap.h.

◆ CoupledLocalToGlobalC0ContMapSharedPtr

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

Definition at line 64 of file CoupledLocalToGlobalC0ContMap.h.

◆ CoupledSolverMatrices

typedef struct Nektar::coupledSolverMatrices Nektar::CoupledSolverMatrices

◆ DenseMatrix

typedef NekMatrix<NekDouble, StandardMatrixTag> Nektar::DenseMatrix

Definition at line 52 of file NekTypeDefs.hpp.

◆ DiffusionLDGNSSharedPtr

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

Definition at line 139 of file DiffusionLDGNS.h.

◆ DNekBlkMat

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

Definition at line 59 of file NekTypeDefs.hpp.

◆ DNekBlkMatSharedPtr

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

Definition at line 71 of file NekTypeDefs.hpp.

◆ DNekLinSys

typedef LinearSystem Nektar::DNekLinSys

Definition at line 82 of file NekTypeDefs.hpp.

◆ DNekLinSysSharedPtr

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

Definition at line 83 of file NekTypeDefs.hpp.

◆ DNekMat

typedef NekMatrix<NekDouble, StandardMatrixTag> Nektar::DNekMat

Definition at line 51 of file NekTypeDefs.hpp.

◆ DNekMatSharedPtr

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

Definition at line 69 of file NekTypeDefs.hpp.

◆ DNekScalBlkMat

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

Definition at line 65 of file NekTypeDefs.hpp.

◆ DNekScalBlkMatSharedPtr

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

Definition at line 73 of file NekTypeDefs.hpp.

◆ DNekScalLinSys

typedef LinearSystem Nektar::DNekScalLinSys

Definition at line 85 of file NekTypeDefs.hpp.

◆ DNekScalLinSysSharedPtr

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

Definition at line 86 of file NekTypeDefs.hpp.

◆ DNekScalMat

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

Definition at line 68 of file NekMatrixFwd.hpp.

◆ DNekScalMatSharedPtr

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

Definition at line 69 of file NekMatrixFwd.hpp.

◆ DNekVec

typedef NekVector<NekDouble> Nektar::DNekVec

Definition at line 48 of file NekTypeDefs.hpp.

◆ EquationOfStateFactory

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

Declaration of the equation of state factory.

Definition at line 52 of file EquationOfState.h.

◆ EquationOfStateSharedPtr

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

A shared pointer to an equation of state object.

Definition at line 44 of file EquationOfState.h.

◆ ExtrapolateFactory

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

Definition at line 66 of file Extrapolate.h.

◆ ExtrapolateSharedPtr

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

Definition at line 59 of file Extrapolate.h.

◆ FilterMap

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

Definition at line 48 of file FilterMovingBody.h.

◆ FilterMovingBodySharedPtr

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

Definition at line 44 of file FilterMovingBody.h.

◆ FilterParams

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

Definition at line 47 of file FilterMovingBody.h.

◆ HighOrderOutflowSharedPtr

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

Definition at line 68 of file Extrapolate.h.

◆ IncNavierStokesSharedPtr

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

Definition at line 274 of file IncNavierStokes.h.

◆ IndexType

typedef unsigned int Nektar::IndexType

Definition at line 50 of file SparseMatrixFwd.hpp.

◆ IndexVector

typedef Array<OneD, IndexType> Nektar::IndexVector

Definition at line 52 of file SparseMatrixFwd.hpp.

◆ InterfacePointShPtr

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

Definition at line 82 of file PulseWaveSystem.h.

◆ LymphaticPressureAreaSharedPtr

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

Pointer to a PulseWaveOutflow object.

Definition at line 44 of file LymphaticPressureArea.h.

◆ MappingExtrapolateSharedPtr

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

Definition at line 47 of file MappingExtrapolate.h.

◆ NekComplexDouble

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

Definition at line 101 of file IncNavierStokes.h.

◆ NekDouble

typedef double Nektar::NekDouble

Definition at line 43 of file NektarUnivTypeDefs.hpp.

◆ NekInt

typedef std::int32_t Nektar::NekInt

Definition at line 45 of file NektarUnivTypeDefs.hpp.

◆ NekInt32

typedef std::int32_t Nektar::NekInt32

Definition at line 46 of file NektarUnivTypeDefs.hpp.

◆ NekInt64

typedef std::int64_t Nektar::NekInt64

Definition at line 47 of file NektarUnivTypeDefs.hpp.

◆ NekUInt

typedef std::uint32_t Nektar::NekUInt

Definition at line 48 of file NektarUnivTypeDefs.hpp.

◆ NekUInt32

typedef std::uint32_t Nektar::NekUInt32

Definition at line 49 of file NektarUnivTypeDefs.hpp.

◆ NekUInt64

typedef std::uint64_t Nektar::NekUInt64

Definition at line 50 of file NektarUnivTypeDefs.hpp.

◆ PressureAreaFactory

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

Definition at line 53 of file PulseWavePressureArea.h.

◆ ProtocolFactory

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

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

Definition at line 53 of file Protocol.h.

◆ ProtocolSharedPtr

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

A shared pointer to an EquationSystem object.

Definition at line 44 of file Protocol.h.

◆ PulseWaveBoundarySharedPtr

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

Definition at line 46 of file PulseWaveBoundary.h.

◆ PulseWavePressureAreaSharedPtr

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

Definition at line 45 of file PulseWavePressureArea.h.

◆ PulseWaveSystemOutputSharedPtr

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

Definition at line 76 of file PulseWaveSystemOutput.h.

◆ PulseWaveSystemSharedPtr

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

Definition at line 186 of file PulseWaveSystem.h.

◆ QInflowSharedPtr

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

Pointer to a PulseWaveOutflow object.

Definition at line 44 of file QInflow.h.

◆ RawType_t

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

Definition at line 76 of file RawType.hpp.

◆ RCROutflowSharedPtr

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

Pointer to a PulseWaveOutflow object.

Definition at line 44 of file RCROutflow.h.

◆ ROutflowSharedPtr

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

Pointer to a PulseWaveOutflow object.

Definition at line 44 of file ROutflow.h.

◆ ScaledMatrix

typedef NekMatrix<DenseMatrix, ScaledMatrixTag> Nektar::ScaledMatrix

Definition at line 56 of file NekTypeDefs.hpp.

◆ SharedNekMatrixPtr

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

Definition at line 67 of file NekMatrixFwd.hpp.

◆ StandardExtrapolateSharedPtr

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

Definition at line 53 of file StandardExtrapolate.h.

◆ StimulusFactory

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

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

Definition at line 59 of file Stimulus.h.

◆ StimulusSharedPtr

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

A shared pointer to an EquationSystem object.

Definition at line 49 of file Stimulus.h.

◆ SubSteppingExtrapolateSharedPtr

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

Definition at line 53 of file SubSteppingExtrapolate.h.

◆ SubSteppingExtrapolateWeakPressureSharedPtr

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

Definition at line 46 of file SubSteppingExtrapolateWeakPressure.h.

◆ SummaryList

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

Definition at line 50 of file CellModel.h.

◆ TerminalOutflowSharedPtr

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

Pointer to a PulseWaveOutflow object.

Definition at line 44 of file TerminalOutflow.h.

◆ TimeDependentInflowSharedPtr

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

Pointer to a PulseWaveOutflow object.

Definition at line 44 of file TimeDependentInflow.h.

◆ UInflowSharedPtr

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

Pointer to a PulseWaveOutflow object.

Definition at line 44 of file UInflow.h.

◆ UndefinedInOutflowSharedPtr

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

Pointer to a PulseWaveOutflow object.

Definition at line 44 of file UndefinedInOutflow.h.

◆ VariableConverterSharedPtr

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

Definition at line 45 of file VariableConverter.h.

◆ VCSMappingSharedPtr

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

Definition at line 157 of file VCSMapping.h.

◆ VCSWeakPressureSharedPtr

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

Definition at line 101 of file VelocityCorrectionSchemeWeakPressure.h.

◆ VelocityCorrectionSchemeSharedPtr

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

Definition at line 234 of file VelocityCorrectionScheme.h.

◆ WeakPressureExtrapolateSharedPtr

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

Definition at line 53 of file WeakPressureExtrapolate.h.

◆ WomersleyParamsSharedPtr

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

Definition at line 130 of file IncNavierStokes.h.

Enumeration Type Documentation

◆ AdvectionForm

enum Nektar::AdvectionForm
Enumerator
eNoAdvectionForm 
eConvective 
eNonConservative 
eLinearised 
eAdjoint 
eSkewSymmetric 
eNoAdvection 
eAdvectionFormSize 

Definition at line 76 of file IncNavierStokes.h.

77  {
78  eNoAdvectionForm,
79  eConvective,
80  eNonConservative,
81  eLinearised,
82  eAdjoint,
83  eSkewSymmetric,
84  eNoAdvection,
85  eAdvectionFormSize
86  };

◆ AllowWrappingOfConstArrays

enum Nektar::AllowWrappingOfConstArrays
Enumerator
eVECTOR_WRAPPER 

Definition at line 506 of file SharedArray.hpp.

507  {
508  eVECTOR_WRAPPER
509  };

◆ Direction

enum Nektar::Direction
Enumerator
xDir 
yDir 
zDir 

Definition at line 70 of file NektarUnivTypeDefs.hpp.

71  {
72  xDir = 0,
73  yDir = 1,
74  zDir = 2
75  };

◆ EquationType

enum Nektar::EquationType
Enumerator
eNoEquationType 
eSteadyStokes 
eSteadyOseen 
eSteadyLinearisedNS 
eUnsteadyStokes 
eUnsteadyLinearisedNS 
eUnsteadyNavierStokes 
eSteadyNavierStokes 
eEquationTypeSize 

Definition at line 49 of file IncNavierStokes.h.

50  {
51  eNoEquationType,
52  eSteadyStokes,
53  eSteadyOseen,
54  eSteadyLinearisedNS,
55  eUnsteadyStokes,
56  eUnsteadyLinearisedNS,
57  eUnsteadyNavierStokes,
58  eSteadyNavierStokes,
59  eEquationTypeSize
60  };

◆ FlagType

enum Nektar::FlagType

Enumeration of flags for passing a list of options.

Enumerator
eUseGlobal 

Definition at line 87 of file NektarUnivTypeDefs.hpp.

88  {
89  eUseGlobal
90  };

◆ HBCType

enum Nektar::HBCType
Enumerator
eNOHBC 
eHBCNeumann 
eOBC 
eConvectiveOBC 

Definition at line 50 of file Extrapolate.h.

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

◆ InitWaveType

enum Nektar::InitWaveType
Enumerator
eLeft 
eBothEnds 
eCenter 
eLeftBottomCorner 
ePoint 
eSpiralDock 
SIZE_InitWaveType 

Length of enum list.

Definition at line 69 of file MMFDiffusion.h.

70  {
71  eLeft,
72  eBothEnds,
73  eCenter,
74  eLeftBottomCorner,
75  ePoint,
76  eSpiralDock,
77  SIZE_InitWaveType ///< Length of enum list
78  };
Nektar::SIZE_InitWaveType
Length of enum list.
Definition: MMFDiffusion.h:77

◆ MatrixStorage

enum Nektar::MatrixStorage
Enumerator
eFULL 
eDIAGONAL 
eUPPER_TRIANGULAR 
eLOWER_TRIANGULAR 
eSYMMETRIC 
ePOSITIVE_DEFINITE_SYMMETRIC 
eBANDED 
eSYMMETRIC_BANDED 
ePOSITIVE_DEFINITE_SYMMETRIC_BANDED 
eUPPER_TRIANGULAR_BANDED 
eLOWER_TRIANGULAR_BANDED 

Definition at line 41 of file MatrixStorageType.h.

42  {
43  eFULL,
44  eDIAGONAL,
45  eUPPER_TRIANGULAR,
46  eLOWER_TRIANGULAR,
47  eSYMMETRIC,
48  ePOSITIVE_DEFINITE_SYMMETRIC,
49  eBANDED,
50  eSYMMETRIC_BANDED,
51  ePOSITIVE_DEFINITE_SYMMETRIC_BANDED,
52  eUPPER_TRIANGULAR_BANDED,
53  eLOWER_TRIANGULAR_BANDED
54  };

◆ OutputFormat

enum Nektar::OutputFormat
Enumerator
eTecplot 
eTecplotZones 
eTecplotSingleBlock 
eGmsh 
eGnuplot 

Definition at line 77 of file NektarUnivTypeDefs.hpp.

78  {
79  eTecplot,
80  eTecplotZones,
81  eTecplotSingleBlock,
82  eGmsh,
83  eGnuplot
84  };

◆ PointerWrapper

enum Nektar::PointerWrapper

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

Enumerator
eWrapper 
eCopy 

Definition at line 42 of file PointerWrapper.h.

43  {
44  eWrapper,
45  eCopy
46  };

◆ ProblemType

enum Nektar::ProblemType
Enumerator
eGeneral 

No problem defined - Default Inital data.

eSolitaryWave 

First order Laitone solitary wave.

SIZE_ProblemType 

Length of enum list.

Definition at line 44 of file NonlinearPeregrine.h.

45 {
46  eGeneral, ///< No problem defined - Default Inital data
47  eSolitaryWave, ///< First order Laitone solitary wave
48  SIZE_ProblemType ///< Length of enum list
49 };
Nektar::SIZE_ProblemType
Length of enum list.
Definition: NonlinearPeregrine.h:48
Nektar::eGeneral
No problem defined - Default Inital data.
Definition: NonlinearPeregrine.h:46
Nektar::eSolitaryWave
First order Laitone solitary wave.
Definition: NonlinearPeregrine.h:47

◆ TestType [1/2]

enum Nektar::TestType
Enumerator
eTestPlane 
eTestCube 
eTestLinearSphere 
eTestNonlinearSphere 
eFHNStandard 
eFHNRogers 
eFHNAlievPanf 
SIZE_TestType 

Length of enum list.

eTestPlane 
eTestSteadyZonal 
eTestUnsteadyZonal 
eTestIsolatedMountain 
eTestUnstableJet 
eTestRossbyWave 
SIZE_TestType 

Length of enum list.

Definition at line 44 of file MMFSWE.h.

45 {
46  eTestPlane,
47  eTestSteadyZonal,
48  eTestUnsteadyZonal,
49  eTestIsolatedMountain,
50  eTestUnstableJet,
51  eTestRossbyWave,
52  SIZE_TestType ///< Length of enum list
53 };
SIZE_TestType
Length of enum list.
Definition: MMFAdvection.h:49
eTestPlane
Definition: MMFAdvection.h:45

◆ TestType [2/2]

enum Nektar::TestType
Enumerator
eTestPlane 
eTestCube 
eTestLinearSphere 
eTestNonlinearSphere 
eFHNStandard 
eFHNRogers 
eFHNAlievPanf 
SIZE_TestType 

Length of enum list.

eTestPlane 
eTestSteadyZonal 
eTestUnsteadyZonal 
eTestIsolatedMountain 
eTestUnstableJet 
eTestRossbyWave 
SIZE_TestType 

Length of enum list.

Definition at line 46 of file MMFDiffusion.h.

47  {
48  eTestPlane,
49  eTestCube,
50  eTestLinearSphere,
51  eTestNonlinearSphere,
52  eFHNStandard,
53  eFHNRogers,
54  eFHNAlievPanf,
55  SIZE_TestType ///< Length of enum list
56  };
SIZE_TestType
Length of enum list.
Definition: MMFAdvection.h:49
eTestCube
Definition: MMFAdvection.h:47
eTestPlane
Definition: MMFAdvection.h:45

◆ UpwindTypePulse

enum Nektar::UpwindTypePulse
Enumerator
eNotSetPulse 

flux not defined

eUpwindPulse 

simple upwinding scheme

SIZE_UpwindTypePulse 

Length of enum list.

Definition at line 45 of file PulseWaveSystem.h.

46  {
47  eNotSetPulse, ///< flux not defined
48  eUpwindPulse, ///< simple upwinding scheme
49  SIZE_UpwindTypePulse ///< Length of enum list
50  };
Nektar::SIZE_UpwindTypePulse
Length of enum list.
Definition: PulseWaveSystem.h:49
Nektar::eNotSetPulse
flux not defined
Definition: PulseWaveSystem.h:47
Nektar::eUpwindPulse
simple upwinding scheme
Definition: PulseWaveSystem.h:48

◆ VWIIterationType

enum Nektar::VWIIterationType
Enumerator
eFixedAlpha 
eFixedWaveForcing 
eFixedAlphaWaveForcing 
eFixedWaveForcingWithSubIterationOnAlpha 
eVWIIterationTypeSize 

Definition at line 54 of file VortexWaveInteraction.h.

55  {
56  eFixedAlpha,
57  eFixedWaveForcing,
58  eFixedAlphaWaveForcing,
59  eFixedWaveForcingWithSubIterationOnAlpha,
60  eVWIIterationTypeSize
61  };

Function Documentation

◆ Add() [1/8]

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

References ASSERTL1, lhs, and rhs.

Referenced by Add(), AddNegatedLhs(), Nektar::NekMeshUtils::CADSurfOCE::BoundingBox(), operator*(), and operator+().

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

◆ Add() [2/8]

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

References Add(), NEKTAR_ALL_MATRIX_TYPES, and NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES().

262  {
263  typedef typename NekMatrix<LhsDataType, LhsMatrixType>::NumberType NumberType;
264  NekMatrix<NumberType, StandardMatrixTag> result(lhs.GetRows(), lhs.GetColumns());
265  Add(result, lhs, rhs);
266  return result;
267  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::Add
DNekMat NekMatrix< typename NekMatrix< LhsDataType, LhsMatrixType >::NumberType, StandardMatrixTag > Add(const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
Definition: MatrixOperations.cpp:260
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ Add() [3/8]

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

References ASSERTL1, lhs, and rhs.

Referenced by Add(), AddNegatedLhs(), Nektar::NekMeshUtils::CADSurfOCE::BoundingBox(), operator*(), and operator+().

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

◆ Add() [4/8]

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

References Add(), NEKTAR_ALL_MATRIX_TYPES, and NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES().

262  {
263  typedef typename NekMatrix<LhsDataType, LhsMatrixType>::NumberType NumberType;
264  NekMatrix<NumberType, StandardMatrixTag> result(lhs.GetRows(), lhs.GetColumns());
265  Add(result, lhs, rhs);
266  return result;
267  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::Add
DNekMat NekMatrix< typename NekMatrix< LhsDataType, LhsMatrixType >::NumberType, StandardMatrixTag > Add(const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
Definition: MatrixOperations.cpp:260
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ Add() [5/8]

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

Definition at line 428 of file NekVector.cpp.

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

431  {
432  DataType* r_buf = result.GetRawPtr();
433  const DataType* lhs_buf = lhs.GetRawPtr();
434  const DataType* rhs_buf = rhs.GetRawPtr();
435  const unsigned int ldim = lhs.GetDimension();
436  for(int i = 0; i < ldim; ++i)
437  {
438  r_buf[i] = lhs_buf[i] + rhs_buf[i];
439  }
440  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ Add() [6/8]

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

◆ Add() [7/8]

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

Definition at line 499 of file NekVector.cpp.

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

501  {
502  NekVector<LhsDataType> result(lhs.GetDimension());
503  Add(result, lhs, rhs);
504  return result;
505  }
Nektar::Add
template NekVector< NekDouble > Add(const NekVector< NekDouble > &lhs, const NekVector< NekDouble > &rhs)
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ Add() [8/8]

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

Referenced by Add(), and AddNegatedLhs().

◆ AddEqual() [1/3]

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

Definition at line 168 of file MatrixOperations.cpp.

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

Referenced by AddEqualNegatedLhs(), and operator*().

170  {
171  ASSERTL1(result.GetRows() == rhs.GetRows(), std::string("Matrices with different row counts ") +
172  std::to_string(result.GetRows()) + std::string(" and ") +
173  std::to_string(rhs.GetRows()) + std::string(" can't be added."));
174  ASSERTL1(result.GetColumns() == rhs.GetColumns(), std::string("Matrices with different column counts ") +
175  std::to_string(result.GetColumns()) + std::string(" and ") +
176  std::to_string(rhs.GetColumns()) + std::string(" can't be added."));
177 
178  for(unsigned int i = 0; i < rhs.GetRows(); ++i)
179  {
180  for(unsigned int j = 0; j < rhs.GetColumns(); ++j)
181  {
182  result(i,j) += rhs(i,j);
183  }
184  }
185  }
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97
ASSERTL1
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:250

◆ AddEqual() [2/3]

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

Definition at line 465 of file NekVector.cpp.

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

467  {
468  DataType* r_buf = result.GetRawPtr();
469  const DataType* rhs_buf = rhs.GetRawPtr();
470  const unsigned int rdim = rhs.GetDimension();
471  for(int i = 0; i < rdim; ++i)
472  {
473  r_buf[i] += rhs_buf[i];
474  }
475  }
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ AddEqual() [3/3]

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

Referenced by AddEqualNegatedLhs(), and Nektar::NekVector< NekDouble >::operator+=().

◆ AddEqualNegatedLhs() [1/3]

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

Definition at line 189 of file MatrixOperations.cpp.

References AddEqual(), ASSERTL1, Nektar::ConstMatrix< DataType >::GetColumns(), Nektar::ConstMatrix< DataType >::GetRows(), NEKTAR_ALL_MATRIX_TYPES, NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX(), and rhs.

Referenced by operator+().

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

◆ AddEqualNegatedLhs() [2/3]

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

Definition at line 478 of file NekVector.cpp.

References AddEqual(), AddEqualNegatedLhs(), Nektar::NekVector< DataType >::GetDimension(), Nektar::NekVector< DataType >::GetRawPtr(), LhsDataType, LIB_UTILITIES_EXPORT, and RhsDataType.

480  {
481  DataType* r_buf = result.GetRawPtr();
482  const DataType* rhs_buf = rhs.GetRawPtr();
483  const unsigned int rdim = rhs.GetDimension();
484  for(int i = 0; i < rdim; ++i)
485  {
486  r_buf[i] = -r_buf[i] + rhs_buf[i];
487  }
488  }
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ AddEqualNegatedLhs() [3/3]

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

Referenced by AddEqualNegatedLhs().

◆ AddNegatedLhs() [1/3]

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

References Add(), ASSERTL1, lhs, NEKTAR_ALL_MATRIX_TYPES, NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES(), and rhs.

Referenced by operator+().

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

◆ AddNegatedLhs() [2/3]

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

Definition at line 443 of file NekVector.cpp.

References Add(), AddNegatedLhs(), Nektar::NekVector< DataType >::GetDimension(), Nektar::NekVector< DataType >::GetRawPtr(), lhs, LIB_UTILITIES_EXPORT, and rhs.

446  {
447  DataType* r_buf = result.GetRawPtr();
448  const DataType* lhs_buf = lhs.GetRawPtr();
449  const DataType* rhs_buf = rhs.GetRawPtr();
450  const unsigned int ldim = lhs.GetDimension();
451  for(int i = 0; i < ldim; ++i)
452  {
453  r_buf[i] = -lhs_buf[i] + rhs_buf[i];
454  }
455  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ AddNegatedLhs() [3/3]

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

Referenced by AddNegatedLhs().

◆ AsString() [1/2]

template<typename DataType >
std::string Nektar::AsString ( const NekVector< DataType > &  v)

Definition at line 1042 of file NekVector.cpp.

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

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

1043  {
1044  unsigned int d = v.GetRows();
1045  std::string result = "(";
1046  for(unsigned int i = 0; i < d; ++i)
1047  {
1048  result += boost::lexical_cast<std::string>(v[i]);
1049  if( i < v.GetDimension()-1 )
1050  {
1051  result += ", ";
1052  }
1053  }
1054  result += ")";
1055  return result;
1056  }

◆ AsString() [2/2]

template std::string Nektar::AsString ( const NekVector< NekDouble > &  v)

Referenced by AsString().

◆ convertCooToBco()

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

Definition at line 49 of file SparseUtils.cpp.

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

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

◆ CopyArray()

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

Definition at line 765 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< NekDouble >::NekVector(), Nektar::StdRegions::StdExpansion0D::PhysTensorDeriv(), and Nektar::StdRegions::StdExpansion1D::PhysTensorDeriv().

766  {
767  if( dest.num_elements() != source.num_elements() )
768  {
769  dest = Array<OneD, DataType>(source.num_elements());
770  }
771 
772  std::copy(source.data(), source.data() + source.num_elements(), dest.data());
773  }
CellMLToNektar.pycml.copy
def copy(self)
Definition: pycml.py:2663

◆ CopyArrayN()

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

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

777  {
778  if( dest.num_elements() != n )
779  {
780  dest = Array<OneD, DataType>(n);
781  }
782 
783  std::copy(source.data(), source.data() + n, dest.data());
784  }
CellMLToNektar.pycml.copy
def copy(self)
Definition: pycml.py:2663

◆ CreateStorage() [1/4]

template<typename Dim , typename DataType , typename ExtentListType >
std::shared_ptr<boost::multi_array_ref<DataType, Dim::Value> > Nektar::CreateStorage ( const ExtentListType &  extent)

Definition at line 177 of file ArrayPolicies.hpp.

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

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

178  {
179  typedef boost::multi_array_ref<DataType, Dim::Value> ArrayType;
180  size_t size = std::accumulate(extent.begin(), extent.end(), 1,
181  std::multiplies<size_t>());
182  DataType* storage = MemoryManager<DataType>::RawAllocate(size);
183  return MemoryManager<ArrayType>::AllocateSharedPtrD(
184  [=](boost::multi_array_ref<DataType, Dim::Value> *ptr) {
185  boost::ignore_unused(ptr);
186  ArrayDestructionPolicy<DataType>::Destroy(storage, size);
187  MemoryManager<DataType>::RawDeallocate(storage, size);
188  },
189  storage, extent);
190  }

◆ CreateStorage() [2/4]

template<typename DataType >
std::shared_ptr<boost::multi_array_ref<DataType, 1> > Nektar::CreateStorage ( size_t  d1)

Definition at line 194 of file ArrayPolicies.hpp.

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

◆ CreateStorage() [3/4]

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

Definition at line 202 of file ArrayPolicies.hpp.

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

◆ CreateStorage() [4/4]

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

Definition at line 210 of file ArrayPolicies.hpp.

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

◆ createVectorFromPoints() [1/2]

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

Definition at line 809 of file NekVector.cpp.

References createVectorFromPoints(), and LIB_UTILITIES_EXPORT.

Referenced by operator-().

811  {
812  NekVector<DataType> result(3, 0.0);
813  for(unsigned int i = 0; i < 3; ++i)
814  {
815  result[i] = dest[i]-source[i];
816  }
817  return result;
818  }

◆ createVectorFromPoints() [2/2]

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

Referenced by createVectorFromPoints().

◆ Cross() [1/2]

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

Definition at line 1025 of file NekVector.cpp.

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

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

1027  {
1028  ASSERTL1(lhs.GetDimension() == 3 && rhs.GetDimension() == 3, "Cross is only valid for 3D vectors.");
1029 
1030  DataType first = lhs.y()*rhs.z() - lhs.z()*rhs.y();
1031  DataType second = lhs.z()*rhs.x() - lhs.x()*rhs.z();
1032  DataType third = lhs.x()*rhs.y() - lhs.y()*rhs.x();
1033 
1034  NekVector<DataType> result(first, second, third);
1035  return result;
1036  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97
ASSERTL1
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:250

◆ Cross() [2/2]

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

Referenced by Cross().

◆ DiagonalBlockFullScalMatrixMultiply()

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

Definition at line 258 of file MatrixVectorMultiplication.cpp.

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

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

261  {
262  unsigned int numberOfBlockRows = lhs.GetNumberOfBlockRows();
263  double* result_ptr = result.GetRawPtr();
264  const double* rhs_ptr = rhs.GetRawPtr();
265 
266  Array<OneD, unsigned int> rowSizes;
267  Array<OneD, unsigned int> colSizes;
268  lhs.GetBlockSizes(rowSizes, colSizes);
269 
270  unsigned int curResultRow = 0;
271  unsigned int curWrapperRow = 0;
272  unsigned int rowsInBlock = 0;
273  unsigned int columnsInBlock = 0;
274  for(unsigned int blockRow = 0; blockRow < numberOfBlockRows; ++blockRow)
275  {
276  curResultRow += rowsInBlock;
277  curWrapperRow += columnsInBlock;
278  if ( blockRow == 0)
279  {
280  rowsInBlock = rowSizes[blockRow] + 1;
281  columnsInBlock = colSizes[blockRow] + 1;
282  }
283  else
284  {
285  rowsInBlock = rowSizes[blockRow] - rowSizes[blockRow-1];
286  columnsInBlock = colSizes[blockRow] - colSizes[blockRow-1];
287  }
288 
289  if( rowsInBlock == 0)
290  {
291  continue;
292  }
293  if( columnsInBlock == 0)
294  {
295  std::fill(result.begin()+curResultRow,
296  result.begin()+curResultRow + rowsInBlock, 0.0);
297  continue;
298  }
299 
300  const DNekScalMat* block = lhs.GetBlockPtr(blockRow, blockRow);
301  if( !block )
302  {
303  continue;
304  }
305 
306  double* resultWrapper = result_ptr + curResultRow;
307  const double* rhsWrapper = rhs_ptr + curWrapperRow;
308 
309  // Multiply
310  const unsigned int* size = block->GetSize();
311  Blas::Dgemv('N', size[0], size[1], block->Scale(),
312  block->GetRawPtr(), size[0], rhsWrapper, 1,
313  0.0, resultWrapper, 1);
314  }
315  curResultRow += rowsInBlock;
316  if (curResultRow < result.GetRows())
317  {
318  std::fill(result.begin()+curResultRow, result.end(), 0.0);
319  }
320  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Blas::Dgemv
static void Dgemv(const char &trans, const int &m, const int &n, const double &alpha, const double *a, const int &lda, const double *x, const int &incx, const double &beta, double *y, const int &incy)
BLAS level 2: Matrix vector multiply y = A x where A[m x n].
Definition: Blas.hpp:168
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97
Nektar::DNekScalMat
NekMatrix< NekMatrix< NekDouble, StandardMatrixTag >, ScaledMatrixTag > DNekScalMat
Definition: NekMatrixFwd.hpp:68

◆ DiagonalBlockMatrixMultiply()

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

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

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

◆ distanceBetween()

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

Definition at line 454 of file NekPoint.hpp.

456  {
457  DataType result = 0.0;
458  for(unsigned int i = 0; i < 3; ++i)
459  {
460  DataType temp = lhs[i] - rhs[i];
461  result += temp*temp;
462  }
463  return sqrt(result);
464  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ Divide() [1/4]

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

Definition at line 601 of file NekVector.cpp.

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

Referenced by operator/().

604  {
605  ResultDataType* r_buf = result.GetRawPtr();
606  typename std::add_const<InputDataType>::type* lhs_buf = lhs.GetRawPtr();
607 
608  const unsigned int ldim = lhs.GetDimension();
609  for(int i = 0; i < ldim; ++i)
610  {
611  r_buf[i] = lhs_buf[i] / rhs;
612  }
613  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ Divide() [2/4]

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

◆ Divide() [3/4]

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

Definition at line 639 of file NekVector.cpp.

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

641  {
642  NekVector<DataType> result(lhs.GetDimension());
643  Divide(result, lhs, rhs);
644  return result;
645  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::Divide
template NekVector< NekDouble > Divide(const NekVector< NekDouble > &lhs, const NekDouble &rhs)
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ Divide() [4/4]

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

Referenced by Divide().

◆ DivideEqual() [1/2]

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

Definition at line 621 of file NekVector.cpp.

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

623  {
624  ResultDataType* r_buf = result.GetRawPtr();
625 
626  const unsigned int resdim = result.GetDimension();
627  for(int i = 0; i < resdim; ++i)
628  {
629  r_buf[i] /= rhs;
630  }
631  }
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ DivideEqual() [2/2]

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

Referenced by DivideEqual(), and Nektar::NekVector< NekDouble >::operator/=().

◆ Dot() [1/2]

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

Definition at line 989 of file NekVector.cpp.

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

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

991  {
992  ASSERTL1( lhs.GetDimension() == rhs.GetDimension(), "Dot, dimension of the two operands must be identical.");
993 
994  DataType result = DataType(0);
995  const unsigned int ldim = lhs.GetDimension();
996  for(unsigned int i = 0; i < ldim; ++i)
997  {
998  result += lhs[i]*rhs[i];
999  }
1000 
1001  return result;
1002  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97
ASSERTL1
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:250

◆ Dot() [2/2]

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

Referenced by Dot().

◆ findPointAlongVector() [1/2]

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

Definition at line 826 of file NekVector.cpp.

References findPointAlongVector(), and LIB_UTILITIES_EXPORT.

Referenced by operator-().

828  {
829  NekPoint<DataType> result;
830  for(unsigned int i = 0; i < 3; ++i)
831  {
832  result[i] = lhs[i]*t;
833  }
834 
835  return result;
836  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95

◆ findPointAlongVector() [2/2]

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

Referenced by findPointAlongVector().

◆ for()

Nektar::for ( iterator  iter = lhs.begin(); iter != lhs.end(); ++iter)

Definition at line 99 of file MatrixOperations.cpp.

References MultiplyEqual(), NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX(), and rhs.

100  {
101  *iter *= rhs;
102  }
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ fromString()

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

Definition at line 467 of file NekPoint.hpp.

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

468  {
469  try
470  {
471  typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
472  boost::char_separator<char> sep("(<,>) ");
473  tokenizer tokens(str, sep);
474  unsigned int i = 0;
475  for(tokenizer::iterator iter = tokens.begin(); iter != tokens.end(); ++iter)
476  {
477  result[i] = boost::lexical_cast<DataType>(*iter);
478  ++i;
479  }
480 
481  return i == 3;
482  }
483  catch(boost::bad_lexical_cast&)
484  {
485  return false;
486  }
487  }

◆ FromString()

template<typename DataType >
std::vector< DataType > Nektar::FromString ( const std::string &  str)

Definition at line 870 of file NekVector.cpp.

References LIB_UTILITIES_EXPORT.

Referenced by operator-().

871  {
872  std::vector<DataType> result;
873 
874  try
875  {
876  typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
877  boost::char_separator<char> sep("(<,>) ");
878  tokenizer tokens(str, sep);
879  for( tokenizer::iterator strIter = tokens.begin(); strIter != tokens.end(); ++strIter)
880  {
881  result.push_back(boost::lexical_cast<DataType>(*strIter));
882  }
883  }
884  catch(boost::bad_lexical_cast&)
885  {
886  }
887 
888  return result;
889  }

◆ FullBlockMatrixMultiply()

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

Definition at line 133 of file MatrixVectorMultiplication.cpp.

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

Referenced by Multiply().

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

◆ GetArtificialDiffusionFactory()

ArtificialDiffusionFactory & Nektar::GetArtificialDiffusionFactory ( )

Declaration of the artificial diffusion factory singleton.

Definition at line 42 of file ArtificialDiffusion.cpp.

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

43 {
44  static ArtificialDiffusionFactory instance;
45  return instance;
46 }
Nektar::ArtificialDiffusionFactory
LibUtilities::NekFactory< std::string, ArtificialDiffusion, const LibUtilities::SessionReaderSharedPtr &, const Array< OneD, MultiRegions::ExpListSharedPtr > &, const int > ArtificialDiffusionFactory
Declaration of the artificial diffusion factory.
Definition: ArtificialDiffusion.h:59

◆ GetBoundaryFactory()

BoundaryFactory & Nektar::GetBoundaryFactory ( )

Definition at line 67 of file PulseWaveBoundary.cpp.

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

68  {
69  static BoundaryFactory instance;
70  return instance;
71  }
Nektar::BoundaryFactory
LibUtilities::NekFactory< std::string, PulseWaveBoundary, Array< OneD, MultiRegions::ExpListSharedPtr > &, const LibUtilities::SessionReaderSharedPtr &, PulseWavePressureAreaSharedPtr &> BoundaryFactory
Definition: PulseWaveBoundary.h:55

◆ GetCellModelFactory()

CellModelFactory & Nektar::GetCellModelFactory ( )

Definition at line 46 of file CellModel.cpp.

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

47  {
48  static CellModelFactory instance;
49  return instance;
50  }
Nektar::CellModelFactory
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:60

◆ GetCFSBndCondFactory()

CFSBndCondFactory & Nektar::GetCFSBndCondFactory ( )

Declaration of the boundary condition factory singleton.

Definition at line 41 of file CFSBndCond.cpp.

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

42 {
43  static CFSBndCondFactory instance;
44  return instance;
45 }
Nektar::CFSBndCondFactory
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:60

◆ GetEquationOfStateFactory()

EquationOfStateFactory & Nektar::GetEquationOfStateFactory ( )

Declaration of the equation of state factory singleton.

Definition at line 41 of file EquationOfState.cpp.

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

42 {
43  static EquationOfStateFactory instance;
44  return instance;
45 }
Nektar::EquationOfStateFactory
LibUtilities::NekFactory< std::string, EquationOfState, const LibUtilities::SessionReaderSharedPtr & > EquationOfStateFactory
Declaration of the equation of state factory.
Definition: EquationOfState.h:52

◆ GetExtrapolateFactory()

ExtrapolateFactory & Nektar::GetExtrapolateFactory ( )

Definition at line 49 of file Extrapolate.cpp.

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

50  {
51  static ExtrapolateFactory instance;
52  return instance;
53  }
Nektar::ExtrapolateFactory
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:66

◆ GetMemoryPool()

MemPool & Nektar::GetMemoryPool ( )

Definition at line 36 of file ThreadSpecificPool.cpp.

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

37  {
38  static MemPool instance;
39  return instance;
40  }

◆ GetPressureAreaFactory()

PressureAreaFactory & Nektar::GetPressureAreaFactory ( )

Definition at line 62 of file PulseWavePressureArea.cpp.

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

63  {
64  static PressureAreaFactory instance;
65  return instance;
66  }
Nektar::PressureAreaFactory
LibUtilities::NekFactory< std::string, PulseWavePressureArea, Array< OneD, MultiRegions::ExpListSharedPtr > &, const LibUtilities::SessionReaderSharedPtr &> PressureAreaFactory
Definition: PulseWavePressureArea.h:53

◆ GetProtocolFactory()

ProtocolFactory & Nektar::GetProtocolFactory ( )

Definition at line 39 of file Protocol.cpp.

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

40  {
41  static ProtocolFactory instance;
42  return instance;
43  }
Nektar::ProtocolFactory
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:53

◆ GetStimulusFactory()

StimulusFactory & Nektar::GetStimulusFactory ( )

Definition at line 44 of file Stimulus.cpp.

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

45  {
46  static StimulusFactory instance;
47  return instance;
48  }
Nektar::StimulusFactory
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:59

◆ GramSchmidtOrthogonalization()

template<typename DataType >
std::vector<NekVector<DataType> > Nektar::GramSchmidtOrthogonalization ( const std::vector< NekVector< DataType > > &  x)

Calculates the orthogonal, normalized vectors from linearly independent input.

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

Definition at line 53 of file NekLinAlgAlgorithms.hpp.

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

◆ guessp()

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

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

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

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

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

◆ hash_combine() [1/3]

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

Definition at line 46 of file HashUtils.hpp.

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

47 {
48  boost::ignore_unused(seed);
49 }

◆ hash_combine() [2/3]

template<typename T , typename... Args>
void Nektar::hash_combine ( std::size_t &  seed,
const T &  v,
Args...  args 
)
inline

Definition at line 52 of file HashUtils.hpp.

References hash_combine().

53 {
54  std::hash<T> hasher;
55  seed ^= hasher(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
56  hash_combine(seed, args...);
57 }
Nektar::hash_combine
std::size_t hash_combine(const T &v, Args... args)
Definition: HashUtils.hpp:60

◆ hash_combine() [3/3]

template<typename T , typename... Args>
std::size_t Nektar::hash_combine ( const T &  v,
Args...  args 
)
inline

Definition at line 60 of file HashUtils.hpp.

References hash_combine().

61 {
62  boost::ignore_unused(v);
63  std::size_t seed = 0;
64  hash_combine(seed, args...);
65  return seed;
66 }
Nektar::hash_combine
std::size_t hash_combine(const T &v, Args... args)
Definition: HashUtils.hpp:60

◆ hash_range() [1/2]

template<typename Iter >
std::size_t Nektar::hash_range ( Iter  first,
Iter  last 
)

Definition at line 69 of file HashUtils.hpp.

References hash_combine().

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

70 {
71  std::size_t seed = 0;
72  for(; first != last; ++first)
73  {
74  hash_combine(seed, *first);
75  }
76  return seed;
77 }
Nektar::hash_combine
std::size_t hash_combine(const T &v, Args... args)
Definition: HashUtils.hpp:60

◆ hash_range() [2/2]

template<typename Iter >
void Nektar::hash_range ( std::size_t &  seed,
Iter  first,
Iter  last 
)

Definition at line 80 of file HashUtils.hpp.

References hash_combine(), and hash_range().

81 {
82  hash_combine(seed, hash_range(first, last));
83 }
Nektar::hash_combine
std::size_t hash_combine(const T &v, Args... args)
Definition: HashUtils.hpp:60
Nektar::hash_range
void hash_range(std::size_t &seed, Iter first, Iter last)
Definition: HashUtils.hpp:80

◆ InfinityNorm() [1/2]

template<typename DataType >
DataType Nektar::InfinityNorm ( const NekVector< DataType > &  v)

Definition at line 929 of file NekVector.cpp.

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

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

930  {
931  DataType result = fabs(v[0]);
932  const unsigned int vdim = v.GetDimension();
933  for(unsigned int i = 0; i < vdim; ++i)
934  {
935  result = std::max(fabs(v[i]), result);
936  }
937  return result;
938  }

◆ InfinityNorm() [2/2]

template NekDouble Nektar::InfinityNorm ( const NekVector< NekDouble > &  v)

Referenced by InfinityNorm().

◆ InvertInPlace()

void Nektar::InvertInPlace ( NekDouble &  v)

Definition at line 1022 of file NekVector.cpp.

Referenced by operator-().

1022 { v = 1.0/v; }

◆ IsEqual() [1/2]

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 Nektar::Array< TwoD, DataType >::data(), Nektar::Array< TwoD, const DataType >::operator=(), operator==(), and Nektar::Array< OneD, const DataType >::Overlaps().

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  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ IsEqual() [2/2]

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  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ L1Norm() [1/2]

template<typename DataType >
DataType Nektar::L1Norm ( const NekVector< DataType > &  v)
Todo:
Do the Norms with Blas where applicable.

Definition at line 895 of file NekVector.cpp.

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

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

896  {
897  typedef NekVector<DataType> VectorType;
898 
899  DataType result(0);
900  for(typename VectorType::const_iterator iter = v.begin(); iter != v.end(); ++iter)
901  {
902  result += fabs(*iter);
903  }
904 
905  return result;
906  }

◆ L1Norm() [2/2]

template NekDouble Nektar::L1Norm ( const NekVector< NekDouble > &  v)

Referenced by L1Norm().

◆ L2Norm() [1/2]

template<typename DataType >
DataType Nektar::L2Norm ( const NekVector< DataType > &  v)

Definition at line 912 of file NekVector.cpp.

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

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

913  {
914  typedef NekVector<DataType> VectorType;
915 
916  DataType result(0);
917  for(typename VectorType::const_iterator iter = v.begin(); iter != v.end(); ++iter)
918  {
919  DataType v = fabs(*iter);
920  result += v*v;
921  }
922  return sqrt(result);
923  }

◆ L2Norm() [2/2]

template NekDouble Nektar::L2Norm ( const NekVector< NekDouble > &  v)

Referenced by L2Norm().

◆ Magnitude() [1/2]

template<typename DataType >
DataType Nektar::Magnitude ( const NekVector< DataType > &  v)

Definition at line 973 of file NekVector.cpp.

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

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

974  {
975  DataType result = DataType(0);
976 
977  const unsigned int vdim = v.GetDimension();
978  for(unsigned int i = 0; i < vdim; ++i)
979  {
980  result += v[i]*v[i];
981  }
982  return sqrt(result);
983  }

◆ Magnitude() [2/2]

template NekDouble Nektar::Magnitude ( const NekVector< NekDouble > &  v)

Referenced by Magnitude().

◆ MappingIdealToRef()

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

Definition at line 77 of file LinearElasticSystem.cpp.

References eFULL.

Referenced by Nektar::Utilities::ElUtil::GetMinJac(), and Nektar::LinearElasticSystem::v_DoSolve().

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

◆ Multiply() [1/22]

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

Definition at line 41 of file MatrixOperations.cpp.

References lhs, NEKTAR_ALL_MATRIX_TYPES, NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX(), and rhs.

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

44  {
45  // TODO - optimize for the different matrix types.
46  int n = lhs.GetRows();
47  int m = lhs.GetColumns();
48  for(unsigned int i = 0; i < n; ++i)
49  {
50  for(unsigned int j = 0; j < m; ++j)
51  {
52  result(i,j) = lhs(i,j)*rhs;
53  }
54  }
55  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ Multiply() [2/22]

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

Definition at line 532 of file MatrixVectorMultiplication.cpp.

References Multiply(), NEKTAR_ALL_MATRIX_TYPES, and NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX().

534  {
535  NekVector<DataType> result(lhs.GetRows(), DataType(0));
536  Multiply(result, lhs, rhs);
537  return result;
538  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::Multiply
void Multiply(DataType *result, const NekMatrix< LhsDataType, MatrixType > &lhs, const DataType *rhs)
Definition: MatrixVectorMultiplication.cpp:466
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ Multiply() [3/22]

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

Definition at line 61 of file MatrixOperations.cpp.

References Multiply(), NEKTAR_ALL_MATRIX_TYPES, and NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX().

63  {
64  typedef typename NekMatrix<LhsDataType, LhsMatrixType>::NumberType ResultDataType;
65  NekMatrix<ResultDataType, StandardMatrixTag> result(lhs.GetRows(), lhs.GetColumns());
66  Multiply(result, lhs, rhs);
67  return result;
68  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97
Nektar::Multiply
void Multiply(NekMatrix< DataType, StandardMatrixTag > &result, const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
Definition: MatrixOperations.cpp:145

◆ Multiply() [4/22]

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

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

502  {
503 
504  ASSERTL1(lhs.GetColumns() == rhs.GetRows(), std::string("A left side matrix with column count ") +
505  std::to_string(lhs.GetColumns()) +
506  std::string(" and a right side vector with row count ") +
507  std::to_string(rhs.GetRows()) + std::string(" can't be multiplied."));
508  Multiply(result.GetRawPtr(), lhs, rhs.GetRawPtr());
509  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::Multiply
void Multiply(DataType *result, const NekMatrix< LhsDataType, MatrixType > &lhs, const DataType *rhs)
Definition: MatrixVectorMultiplication.cpp:466
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97
ASSERTL1
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:250

◆ Multiply() [5/22]

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

Definition at line 514 of file MatrixVectorMultiplication.cpp.

References DiagonalBlockMatrixMultiply(), eDIAGONAL, FullBlockMatrixMultiply(), Multiply(), NEKTAR_BLOCK_MATRIX_TYPES, and NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX().

517  {
518  if( lhs.GetStorageType() == eDIAGONAL )
519  {
520  DiagonalBlockMatrixMultiply(result, lhs, rhs);
521  }
522  else
523  {
524  FullBlockMatrixMultiply(result, lhs, rhs);
525  }
526  }
Nektar::FullBlockMatrixMultiply
void FullBlockMatrixMultiply(NekVector< DataType > &result, const NekMatrix< LhsInnerMatrixType, BlockMatrixTag > &lhs, const NekVector< DataType > &rhs)
Definition: MatrixVectorMultiplication.cpp:133
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97
Nektar::DiagonalBlockMatrixMultiply
void DiagonalBlockMatrixMultiply(NekVector< double > &result, const NekMatrix< LhsInnerMatrixType, BlockMatrixTag > &lhs, const NekVector< double > &rhs)
Definition: MatrixVectorMultiplication.cpp:198

◆ Multiply() [6/22]

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

Definition at line 73 of file MatrixOperations.cpp.

References lhs, Multiply(), NEKTAR_ALL_MATRIX_TYPES, NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX(), and rhs.

77  {
78  Multiply(result, rhs, lhs);
79  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97
Nektar::Multiply
void Multiply(NekMatrix< DataType, StandardMatrixTag > &result, const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
Definition: MatrixOperations.cpp:145

◆ Multiply() [7/22]

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

Definition at line 85 of file MatrixOperations.cpp.

References lhs, Multiply(), NEKTAR_ALL_MATRIX_TYPES, NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX(), and rhs.

88  {
89  return Multiply(rhs, lhs);
90  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97
Nektar::Multiply
void Multiply(NekMatrix< DataType, StandardMatrixTag > &result, const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
Definition: MatrixOperations.cpp:145

◆ Multiply() [8/22]

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

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

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

◆ Multiply() [9/22]

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

Definition at line 261 of file MatrixOperations.hpp.

References LhsDataType, LhsMatrixType, Multiply(), RhsDataType, and RhsMatrixType.

263 {
264  typedef typename std::remove_const<
265  typename NekMatrix<LhsDataType, LhsMatrixType>::NumberType>::type
266  NumberType;
267  NekMatrix<NumberType, StandardMatrixTag> result(lhs.GetRows(),
268  rhs.GetColumns());
269  Multiply(result, lhs, rhs);
270  return result;
271 }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97
Nektar::Multiply
NekMatrix< typename std::remove_const< typename NekMatrix< LhsDataType, LhsMatrixType >::NumberType >::type, StandardMatrixTag > Multiply(const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
Definition: MatrixOperations.hpp:261

◆ Multiply() [10/22]

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

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

469  {
470  switch(lhs.GetType())
471  {
472  case eFULL:
473  NekMultiplyFullMatrix(result, lhs, rhs);
474  break;
475  case eDIAGONAL:
476  NekMultiplyDiagonalMatrix(result, lhs, rhs);
477  break;
478  case eUPPER_TRIANGULAR:
479  NekMultiplyUpperTriangularMatrix(result, lhs, rhs);
480  break;
481  case eLOWER_TRIANGULAR:
482  NekMultiplyLowerTriangularMatrix(result, lhs, rhs);
483  break;
484  case eSYMMETRIC:
485  NekMultiplySymmetricMatrix(result, lhs, rhs);
486  break;
487  case eBANDED:
488  NekMultiplyBandedMatrix(result, lhs, rhs);
489  break;
490  case eSYMMETRIC_BANDED:
491  case eUPPER_TRIANGULAR_BANDED:
492  case eLOWER_TRIANGULAR_BANDED:
493  default:
494  NekMultiplyUnspecializedMatrixType(result, lhs, rhs);
495  }
496  }
Nektar::NekMultiplyUnspecializedMatrixType
void NekMultiplyUnspecializedMatrixType(DataType *result, const NekMatrix< LhsDataType, MatrixType > &lhs, const DataType *rhs)
Definition: MatrixVectorMultiplication.cpp:58
Nektar::NekMultiplyLowerTriangularMatrix
void NekMultiplyLowerTriangularMatrix(DataType *result, const NekMatrix< LhsDataType, MatrixType > &lhs, const DataType *rhs)
Definition: MatrixVectorMultiplication.cpp:349
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::NekMultiplyFullMatrix
void NekMultiplyFullMatrix(NekDouble *result, const NekMatrix< InnerMatrixType, MatrixTag > &lhs, const NekDouble *rhs, typename std::enable_if<!CanGetRawPtr< NekMatrix< InnerMatrixType, MatrixTag > >::value >::type *p=0)
Definition: MatrixVectorMultiplication.cpp:457
Nektar::NekMultiplyBandedMatrix
void NekMultiplyBandedMatrix(DataType *result, const NekMatrix< LhsDataType, BlockMatrixTag > &lhs, const DataType *rhs, typename std::enable_if< !CanGetRawPtr< NekMatrix< LhsDataType, BlockMatrixTag > >::value >::type *p=0)
Definition: MatrixVectorMultiplication.cpp:121
Nektar::NekMultiplyDiagonalMatrix
void NekMultiplyDiagonalMatrix(DataType *result, const NekMatrix< LhsDataType, StandardMatrixTag > &lhs, const DataType *rhs)
Definition: MatrixVectorMultiplication.cpp:86
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97
Nektar::NekMultiplySymmetricMatrix
void NekMultiplySymmetricMatrix(NekDouble *result, const NekMatrix< InnerMatrixType, MatrixTag > &lhs, const NekDouble *rhs, typename std::enable_if<!CanGetRawPtr< NekMatrix< InnerMatrixType, MatrixTag > >::value >::type *p=0)
Definition: MatrixVectorMultiplication.cpp:426
Nektar::NekMultiplyUpperTriangularMatrix
void NekMultiplyUpperTriangularMatrix(DataType *result, const NekMatrix< LhsDataType, MatrixType > &lhs, const DataType *rhs)
Definition: MatrixVectorMultiplication.cpp:391

◆ Multiply() [11/22]

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

Definition at line 654 of file NekVector.cpp.

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

657  {
658  ResultDataType* result_buf = result.GetRawPtr();
659  const InputDataType* rhs_buf = rhs.GetRawPtr();
660  const InputDataType* lhs_buf = lhs.GetRawPtr();
661  const unsigned int resdim = result.GetDimension();
662  for(int i = 0; i < resdim; ++i)
663  {
664  result_buf[i] = lhs_buf[i] * rhs_buf[i];
665  }
666  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ Multiply() [12/22]

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

◆ Multiply() [13/22]

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

Definition at line 689 of file NekVector.cpp.

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

691  {
692  NekVector<DataType> result(lhs.GetDimension());
693  Multiply(result, lhs, rhs);
694  return result;
695  }
Nektar::Multiply
template NekVector< NekDouble > Multiply(const NekDouble &lhs, const NekVector< NekDouble > &rhs)
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ Multiply() [14/22]

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

◆ Multiply() [15/22]

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

Definition at line 703 of file NekVector.cpp.

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

706  {
707  ResultDataType* r_buf = result.GetRawPtr();
708  const InputDataType* lhs_buf = lhs.GetRawPtr();
709 
710  const unsigned int ldim = lhs.GetDimension();
711  for(int i = 0; i < ldim; ++i)
712  {
713  r_buf[i] = lhs_buf[i] * rhs;
714  }
715  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ Multiply() [16/22]

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

◆ Multiply() [17/22]

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

Definition at line 739 of file NekVector.cpp.

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

741  {
742  NekVector<DataType> result(lhs.GetDimension());
743  Multiply(result, lhs, rhs);
744  return result;
745  }
Nektar::Multiply
template NekVector< NekDouble > Multiply(const NekDouble &lhs, const NekVector< NekDouble > &rhs)
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ Multiply() [18/22]

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

◆ Multiply() [19/22]

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

Definition at line 753 of file NekVector.cpp.

References Multiply().

756  {
757  Multiply(result, rhs, lhs);
758  }
Nektar::Multiply
template NekVector< NekDouble > Multiply(const NekDouble &lhs, const NekVector< NekDouble > &rhs)
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ Multiply() [20/22]

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

◆ Multiply() [21/22]

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

Definition at line 787 of file NekVector.cpp.

References LIB_UTILITIES_EXPORT, and Multiply().

789  {
790  return Multiply(rhs, lhs);
791  }
Nektar::Multiply
template NekVector< NekDouble > Multiply(const NekDouble &lhs, const NekVector< NekDouble > &rhs)
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ Multiply() [22/22]

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

Referenced by Multiply(), and MultiplyInvertedLhs().

◆ MultiplyEqual() [1/7]

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

Referenced by for(), and operator*().

◆ MultiplyEqual() [2/7]

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

Definition at line 180 of file MatrixOperations.hpp.

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

189 {
190  boost::ignore_unused(t);
191  ASSERTL0(result.GetType() == eFULL && rhs.GetType() == eFULL,
192  "Only full matrices supported.");
193  unsigned int M = result.GetRows();
194  unsigned int N = rhs.GetColumns();
195  unsigned int K = result.GetColumns();
196 
197  unsigned int LDA = M;
198  if (result.GetTransposeFlag() == 'T')
199  {
200  LDA = K;
201  }
202 
203  unsigned int LDB = K;
204  if (rhs.GetTransposeFlag() == 'T')
205  {
206  LDB = N;
207  }
208  double scale = rhs.Scale();
209  Array<OneD, double> &buf = result.GetTempSpace();
210  Blas::Dgemm(result.GetTransposeFlag(), rhs.GetTransposeFlag(), M, N, K,
211  scale, result.GetRawPtr(), LDA, rhs.GetRawPtr(), LDB, 0.0,
212  buf.data(), result.GetRows());
213  result.SetSize(result.GetRows(), rhs.GetColumns());
214  result.SwapTempAndDataBuffers();
215 }
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:216
Blas::Dgemm
static void Dgemm(const char &transa, const char &transb, const int &m, const int &n, const int &k, const double &alpha, const double *a, const int &lda, const double *b, const int &ldb, const double &beta, double *c, const int &ldc)
BLAS level 3: Matrix-matrix multiply C = A x B where A[m x n], B[n x k], C[m x k].
Definition: Blas.hpp:213
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ MultiplyEqual() [3/7]

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

Definition at line 218 of file MatrixOperations.hpp.

References ASSERTL1, Nektar::ConstMatrix< DataType >::GetColumns(), Nektar::ConstMatrix< DataType >::GetRows(), LhsDataType, LhsMatrixType, rhs, RhsDataType, and RhsMatrixType.

227 {
228  boost::ignore_unused(t);
229  ASSERTL1(result.GetColumns() == rhs.GetRows(),
230  std::string("A left side matrix with column count ") +
231  std::to_string(result.GetColumns()) +
232  std::string(" and a right side matrix with row count ") +
233  std::to_string(rhs.GetRows()) +
234  std::string(" can't be multiplied."));
235  NekMatrix<DataType, StandardMatrixTag> temp(result.GetRows(),
236  result.GetColumns());
237 
238  for (unsigned int i = 0; i < result.GetRows(); ++i)
239  {
240  for (unsigned int j = 0; j < result.GetColumns(); ++j)
241  {
242  DataType t = DataType(0);
243 
244  // Set the result(i,j) element.
245  for (unsigned int k = 0; k < result.GetColumns(); ++k)
246  {
247  t += result(i, k) * rhs(k, j);
248  }
249  temp(i, j) = t;
250  }
251  }
252 
253  result = temp;
254 }
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97
ASSERTL1
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:250

◆ MultiplyEqual() [4/7]

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

Definition at line 672 of file NekVector.cpp.

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

674  {
675  ResultDataType* result_buf = result.GetRawPtr();
676  const InputDataType* rhs_buf = rhs.GetRawPtr();
677  const unsigned int resdim = result.GetDimension();
678  for(int i = 0; i < resdim; ++i)
679  {
680  result_buf[i] *= rhs_buf[i];
681  }
682  }
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ MultiplyEqual() [5/7]

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

◆ MultiplyEqual() [6/7]

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

Definition at line 723 of file NekVector.cpp.

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

725  {
726  ResultDataType* r_buf = result.GetRawPtr();
727  const unsigned int rdim = result.GetDimension();
728  for(unsigned int i = 0; i < rdim; ++i)
729  {
730  r_buf[i] *= rhs;
731  }
732  }
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ MultiplyEqual() [7/7]

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

Referenced by MultiplyEqual(), and Nektar::NekVector< NekDouble >::operator*=().

◆ MultiplyInvertedLhs() [1/2]

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

Definition at line 761 of file NekVector.cpp.

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

764  {
765  ResultDataType* r_buf = result.GetRawPtr();
766  const InputDataType* rhs_buf = rhs.GetRawPtr();
767  NekDouble inverse = 1.0/lhs;
768 
769  const unsigned int rdim = rhs.GetDimension();
770  for(int i = 0; i < rdim; ++i)
771  {
772  r_buf[i] = inverse * rhs_buf[i];
773  }
774  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::NekDouble
double NekDouble
Definition: NektarUnivTypeDefs.hpp:43
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ MultiplyInvertedLhs() [2/2]

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

Referenced by MultiplyInvertedLhs().

◆ negate()

template<typename DataType >
void Nektar::negate ( NekPoint< DataType > &  rhs)

Definition at line 367 of file NekPoint.hpp.

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

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

368  {
369  rhs.negate();
370  }
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ Negate() [1/2]

template<typename DataType >
NekVector< DataType > Nektar::Negate ( const NekVector< DataType > &  v)

Definition at line 944 of file NekVector.cpp.

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

Referenced by operator-().

945  {
946  NekVector<DataType> temp(v);
947  const unsigned int tdim = temp.GetDimension();
948  for(unsigned int i = 0; i < tdim; ++i)
949  {
950  temp(i) = -temp(i);
951  }
952  return temp;
953  }

◆ Negate() [2/2]

template NekVector<NekDouble> Nektar::Negate ( const NekVector< NekDouble > &  v)

Referenced by Negate(), and Nektar::NekVector< NekDouble >::operator-().

◆ NegateInPlace() [1/7]

template<typename DataType >
void Nektar::NegateInPlace ( NekMatrix< DataType, ScaledMatrixTag > &  v)

Definition at line 238 of file ScaledMatrix.cpp.

References LIB_UTILITIES_EXPORT, and NegateInPlace().

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

◆ NegateInPlace() [2/7]

template void Nektar::NegateInPlace ( NekMatrix< NekMatrix< NekDouble, StandardMatrixTag >, ScaledMatrixTag > &  v)

◆ NegateInPlace() [3/7]

template<typename DataType >
void Nektar::NegateInPlace ( NekMatrix< DataType, StandardMatrixTag > &  m)

Definition at line 816 of file StandardMatrix.cpp.

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

817  {
818  for(unsigned int i = 0; i < m.GetRows(); ++i)
819  {
820  for(unsigned int j = 0; j < m.GetColumns(); ++j)
821  {
822  m(i,j) *= -1.0;
823  }
824  }
825  }

◆ NegateInPlace() [4/7]

template void Nektar::NegateInPlace ( NekMatrix< double, StandardMatrixTag > &  v)

◆ NegateInPlace() [5/7]

template<typename DataType >
void Nektar::NegateInPlace ( NekVector< DataType > &  v)

Definition at line 959 of file NekVector.cpp.

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

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

960  {
961  DataType* data = v.GetRawPtr();
962  const unsigned int vdim = v.GetDimension();
963  for(unsigned int i = 0; i < vdim; ++i)
964  {
965  data[i] = -data[i];
966  }
967  }

◆ NegateInPlace() [6/7]

template void Nektar::NegateInPlace ( NekVector< NekDouble > &  v)

◆ NegateInPlace() [7/7]

void Nektar::NegateInPlace ( NekDouble &  v)

Definition at line 1021 of file NekVector.cpp.

Referenced by NegateInPlace().

1021 { v = -v; }

◆ NekMultiplyBandedMatrix() [1/2]

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

Definition at line 96 of file MatrixVectorMultiplication.cpp.

References Blas::Dgbmv(), CellMLToNektar.cellml_metadata::p, and rhs.

Referenced by Multiply().

101  {
102  boost::ignore_unused(p);
103 
104  int m = lhs.GetRows();
105  int n = lhs.GetColumns();
106  int kl = lhs.GetNumberOfSubDiagonals();
107  int ku = lhs.GetNumberOfSuperDiagonals();
108  double alpha = lhs.Scale();
109  const double* a = lhs.GetRawPtr();
110  int lda = kl + ku + 1;
111  const double* x = rhs;
112  int incx = 1;
113  double beta = 0.0;
114  double* y = result;
115  int incy = 1;
116  Blas::Dgbmv('N', m, n, kl, ku, alpha, a, lda, x, incx, beta, y, incy);
117 
118  }
CellMLToNektar.cellml_metadata.p
p
Definition: cellml_metadata.py:350
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Blas::Dgbmv
static void Dgbmv(const char &trans, const int &m, const int &n, const int &kl, const int &ku, const double &alpha, const double *a, const int &lda, const double *x, const int &incx, const double &beta, double *y, const int &incy)
Definition: Blas.hpp:176
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ NekMultiplyBandedMatrix() [2/2]

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

Definition at line 121 of file MatrixVectorMultiplication.cpp.

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

126  {
127  boost::ignore_unused(result, lhs, rhs, p);
128 
129  NEKERROR(ErrorUtil::efatal, "Banded block matrix multiplication not yet implemented");
130  }
NEKERROR
#define NEKERROR(type, msg)
Assert Level 0 – Fundamental assert which is used whether in FULLDEBUG, DEBUG or OPT compilation mod...
Definition: ErrorUtil.hpp:209
CellMLToNektar.cellml_metadata.p
p
Definition: cellml_metadata.py:350
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ NekMultiplyDefaultImpl()

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

Definition at line 109 of file MatrixOperations.cpp.

References ASSERTL1, lhs, LhsDataType, LhsMatrixType, rhs, RhsDataType, and RhsMatrixType.

Referenced by Multiply(), and NekMultiplyFullMatrixFullMatrix().

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

◆ NekMultiplyDiagonalMatrix() [1/2]

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

Definition at line 74 of file MatrixVectorMultiplication.cpp.

References lhs.

Referenced by Multiply().

77  {
78  int n = lhs.GetRows();
79  for(unsigned int i = 0; i < n; ++i)
80  {
81  result[i] = lhs(i,i)*rhs[i];
82  }
83  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ NekMultiplyDiagonalMatrix() [2/2]

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

Definition at line 86 of file MatrixVectorMultiplication.cpp.

References Vmath::Vmul().

89  {
90  int n = lhs.GetRows();
91  const DataType* mat_ptr = lhs.GetRawPtr();
92  Vmath::Vmul(n, mat_ptr, 1, rhs, 1, result, 1);
93  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97
Vmath::Vmul
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:186

◆ NekMultiplyFullMatrix() [1/2]

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

Definition at line 435 of file MatrixVectorMultiplication.cpp.

References Blas::Dgemv(), CellMLToNektar.cellml_metadata::p, and rhs.

Referenced by Multiply().

437  {
438  boost::ignore_unused(p);
439 
440  const unsigned int* size = lhs.GetSize();
441 
442  char t = lhs.GetTransposeFlag();
443 
444  double alpha = lhs.Scale();
445  const double* a = lhs.GetRawPtr();
446  int lda = size[0];
447  const double* x = rhs;
448  int incx = 1;
449  double beta = 0.0;
450  double* y = result;
451  int incy = 1;
452 
453  Blas::Dgemv(t, size[0], size[1], alpha, a, lda, x, incx, beta, y, incy);
454  }
CellMLToNektar.cellml_metadata.p
p
Definition: cellml_metadata.py:350
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Blas::Dgemv
static void Dgemv(const char &trans, const int &m, const int &n, const double &alpha, const double *a, const int &lda, const double *x, const int &incx, const double &beta, double *y, const int &incy)
BLAS level 2: Matrix vector multiply y = A x where A[m x n].
Definition: Blas.hpp:168
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ NekMultiplyFullMatrix() [2/2]

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

Definition at line 457 of file MatrixVectorMultiplication.cpp.

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

459  {
460  boost::ignore_unused(p);
461 
462  NekMultiplyUnspecializedMatrixType(result, lhs, rhs);
463  }
Nektar::NekMultiplyUnspecializedMatrixType
void NekMultiplyUnspecializedMatrixType(DataType *result, const NekMatrix< LhsDataType, MatrixType > &lhs, const DataType *rhs)
Definition: MatrixVectorMultiplication.cpp:58
CellMLToNektar.cellml_metadata.p
p
Definition: cellml_metadata.py:350
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ NekMultiplyFullMatrixFullMatrix() [1/2]

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

Definition at line 136 of file MatrixOperations.cpp.

References LhsDataType, LhsMatrixType, NekMultiplyDefaultImpl(), RhsDataType, and RhsMatrixType.

Referenced by Multiply().

139  {
140  NekMultiplyDefaultImpl(result, lhs, rhs);
141  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::NekMultiplyDefaultImpl
RhsMatrixType void NekMultiplyDefaultImpl(NekMatrix< ResultType, StandardMatrixTag > &result, const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
Definition: MatrixOperations.cpp:109
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ NekMultiplyFullMatrixFullMatrix() [2/2]

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 std::enable_if< CanGetRawPtr< NekMatrix< LhsDataType, LhsMatrixType >>::value &&CanGetRawPtr< NekMatrix< RhsDataType, RhsMatrixType >>::value >::type *  p = 0 
)

Definition at line 137 of file MatrixOperations.hpp.

References ASSERTL1, Blas::Dgemm(), eFULL, LhsDataType, LhsMatrixType, Multiply(), CellMLToNektar.cellml_metadata::p, RhsDataType, and RhsMatrixType.

145 {
146  boost::ignore_unused(p);
147 
148  ASSERTL1(lhs.GetType() == eFULL && rhs.GetType() == eFULL,
149  "Only full matrices are supported.");
150 
151  unsigned int M = lhs.GetRows();
152  unsigned int N = rhs.GetColumns();
153  unsigned int K = lhs.GetColumns();
154 
155  unsigned int LDA = M;
156  if (lhs.GetTransposeFlag() == 'T')
157  {
158  LDA = K;
159  }
160 
161  unsigned int LDB = K;
162  if (rhs.GetTransposeFlag() == 'T')
163  {
164  LDB = N;
165  }
166 
167  Blas::Dgemm(lhs.GetTransposeFlag(), rhs.GetTransposeFlag(), M, N, K,
168  lhs.Scale() * rhs.Scale(), lhs.GetRawPtr(), LDA,
169  rhs.GetRawPtr(), LDB, 0.0, result.GetRawPtr(),
170  result.GetRows());
171 }
Blas::Dgemm
static void Dgemm(const char &transa, const char &transb, const int &m, const int &n, const int &k, const double &alpha, const double *a, const int &lda, const double *b, const int &ldb, const double &beta, double *c, const int &ldc)
BLAS level 3: Matrix-matrix multiply C = A x B where A[m x n], B[n x k], C[m x k].
Definition: Blas.hpp:213
CellMLToNektar.cellml_metadata.p
p
Definition: cellml_metadata.py:350
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97
ASSERTL1
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:250

◆ NekMultiplyLowerTriangularMatrix() [1/3]

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

Definition at line 322 of file MatrixVectorMultiplication.cpp.

References CellMLToNektar.pycml::copy(), and Blas::Dtpmv().

Referenced by Multiply(), and NekMultiplyLowerTriangularMatrix().

325  {
326  int vectorSize = lhs.GetColumns();
327  std::copy(rhs, rhs+vectorSize, result);
328  int n = lhs.GetRows();
329  const double* a = lhs.GetRawPtr();
330  double* x = result;
331  int incx = 1;
332 
333  Blas::Dtpmv('L', lhs.GetTransposeFlag(), 'N', n, a, x, incx);
334  }
CellMLToNektar.pycml.copy
def copy(self)
Definition: pycml.py:2663
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Blas::Dtpmv
static void Dtpmv(const char &uplo, const char &trans, const char &diag, const int &n, const double *ap, double *x, const int &incx)
Definition: Blas.hpp:187
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ NekMultiplyLowerTriangularMatrix() [2/3]

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

Definition at line 336 of file MatrixVectorMultiplication.cpp.

References lhs, NekMultiplyLowerTriangularMatrix(), and rhs.

339  {
340  NekMultiplyLowerTriangularMatrix(result, *lhs.GetOwnedMatrix(), rhs);
341 
342  for(unsigned int i = 0; i < lhs.GetColumns(); ++i)
343  {
344  result[i] *= lhs.Scale();
345  }
346  }
Nektar::NekMultiplyLowerTriangularMatrix
void NekMultiplyLowerTriangularMatrix(DataType *result, const NekMatrix< LhsDataType, MatrixType > &lhs, const DataType *rhs)
Definition: MatrixVectorMultiplication.cpp:349
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ NekMultiplyLowerTriangularMatrix() [3/3]

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

Definition at line 349 of file MatrixVectorMultiplication.cpp.

References lhs.

352  {
353  for(unsigned int i = 0; i < lhs.GetRows(); ++i)
354  {
355  DataType accum = DataType(0);
356  for(unsigned int j = 0; j <= i; ++j)
357  {
358  accum += lhs(i,j)*rhs[j];
359  }
360  result[i] = accum;
361  }
362  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ NekMultiplySymmetricMatrix() [1/2]

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

Definition at line 407 of file MatrixVectorMultiplication.cpp.

References Blas::Dspmv(), CellMLToNektar.cellml_metadata::p, and rhs.

Referenced by Multiply().

409  {
410  boost::ignore_unused(p);
411 
412  const unsigned int* size = lhs.GetSize();
413 
414  double alpha = lhs.Scale();
415  const double* a = lhs.GetRawPtr();
416  const double* x = rhs;
417  int incx = 1;
418  double beta = 0.0;
419  double* y = result;
420  int incy = 1;
421 
422  Blas::Dspmv('U', size[0], alpha, a, x, incx, beta, y, incy);
423  }
CellMLToNektar.cellml_metadata.p
p
Definition: cellml_metadata.py:350
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Blas::Dspmv
static void Dspmv(const char &uplo, const int &n, const double &alpha, const double *a, const double *x, const int &incx, const double &beta, double *y, const int &incy)
BLAS level 2: Matrix vector multiply y = A x where A is symmetric packed.
Definition: Blas.hpp:195
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ NekMultiplySymmetricMatrix() [2/2]

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

Definition at line 426 of file MatrixVectorMultiplication.cpp.

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

428  {
429  boost::ignore_unused(p);
430 
431  NekMultiplyUnspecializedMatrixType(result, lhs, rhs);
432  }
Nektar::NekMultiplyUnspecializedMatrixType
void NekMultiplyUnspecializedMatrixType(DataType *result, const NekMatrix< LhsDataType, MatrixType > &lhs, const DataType *rhs)
Definition: MatrixVectorMultiplication.cpp:58
CellMLToNektar.cellml_metadata.p
p
Definition: cellml_metadata.py:350
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ NekMultiplyUnspecializedMatrixType()

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

Definition at line 58 of file MatrixVectorMultiplication.cpp.

References lhs.

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

61  {
62  for(unsigned int i = 0; i < lhs.GetRows(); ++i)
63  {
64  DataType accum = DataType(0);
65  for(unsigned int j = 0; j < lhs.GetColumns(); ++j)
66  {
67  accum += lhs(i,j)*rhs[j];
68  }
69  result[i] = accum;
70  }
71  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ NekMultiplyUpperTriangularMatrix() [1/3]

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

Definition at line 364 of file MatrixVectorMultiplication.cpp.

References CellMLToNektar.pycml::copy(), and Blas::Dtpmv().

Referenced by Multiply(), and NekMultiplyUpperTriangularMatrix().

367  {
368  int vectorSize = lhs.GetColumns();
369  std::copy(rhs, rhs+vectorSize, result);
370  int n = lhs.GetRows();
371  const double* a = lhs.GetRawPtr();
372  double* x = result;
373  int incx = 1;
374 
375  Blas::Dtpmv('U', lhs.GetTransposeFlag(), 'N', n, a, x, incx);
376  }
CellMLToNektar.pycml.copy
def copy(self)
Definition: pycml.py:2663
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Blas::Dtpmv
static void Dtpmv(const char &uplo, const char &trans, const char &diag, const int &n, const double *ap, double *x, const int &incx)
Definition: Blas.hpp:187
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ NekMultiplyUpperTriangularMatrix() [2/3]

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

Definition at line 378 of file MatrixVectorMultiplication.cpp.

References lhs, NekMultiplyUpperTriangularMatrix(), and rhs.

381  {
382  NekMultiplyUpperTriangularMatrix(result, *lhs.GetOwnedMatrix(), rhs);
383 
384  for(unsigned int i = 0; i < lhs.GetColumns(); ++i)
385  {
386  result[i] *= lhs.Scale();
387  }
388  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97
Nektar::NekMultiplyUpperTriangularMatrix
void NekMultiplyUpperTriangularMatrix(DataType *result, const NekMatrix< LhsDataType, MatrixType > &lhs, const DataType *rhs)
Definition: MatrixVectorMultiplication.cpp:391

◆ NekMultiplyUpperTriangularMatrix() [3/3]

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

Definition at line 391 of file MatrixVectorMultiplication.cpp.

References lhs.

394  {
395  for(unsigned int i = 0; i < lhs.GetRows(); ++i)
396  {
397  DataType accum = DataType(0);
398  for(unsigned int j = i; j < lhs.GetColumns(); ++j)
399  {
400  accum += lhs(i,j)*rhs[j];
401  }
402  result[i] = accum;
403  }
404  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX() [1/9]

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

Referenced by AddEqualNegatedLhs(), for(), Multiply(), and SubtractEqualNegatedLhs().

◆ NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX() [2/9]

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

◆ NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX() [3/9]

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

◆ NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX() [4/9]

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

◆ NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX() [5/9]

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

◆ NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX() [6/9]

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

◆ NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX() [7/9]

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

◆ NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX() [8/9]

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

◆ NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX() [9/9]

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

◆ NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES() [1/4]

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

Referenced by Add(), AddNegatedLhs(), Multiply(), Subtract(), and SubtractNegatedLhs().

◆ NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES() [2/4]

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

◆ NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES() [3/4]

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

◆ NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES() [4/4]

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

◆ Normalize() [1/2]

template<typename DataType >
void Nektar::Normalize ( NekVector< DataType > &  v)

Definition at line 1009 of file NekVector.cpp.

References LIB_UTILITIES_EXPORT, Nektar::NekVector< DataType >::Magnitude(), and Normalize().

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

1010  {
1011  DataType m = v.Magnitude();
1012  if( m > DataType(0) )
1013  {
1014  v /= m;
1015  }
1016  }

◆ Normalize() [2/2]

template void Nektar::Normalize ( NekVector< NekDouble > &  v)

Referenced by Normalize().

◆ operator!=() [1/5]

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

Definition at line 286 of file NekMemoryManager.hpp.

References rhs.

287 {
288  return !(lhs == rhs);
289 }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ operator!=() [2/5]

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

Definition at line 741 of file SharedArray.hpp.

References rhs.

Referenced by operator-().

742  {
743  return !(lhs == rhs);
744  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ operator!=() [3/5]

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

Definition at line 802 of file SharedArray.hpp.

References rhs.

803  {
804  return !(lhs == rhs);
805  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ operator!=() [4/5]

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

Definition at line 859 of file NekVector.cpp.

References LIB_UTILITIES_EXPORT, operator!=(), and rhs.

861  {
862  return !(lhs == rhs);
863  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ operator!=() [5/5]

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

Referenced by operator!=().

◆ operator*() [1/9]

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

Definition at line 74 of file MatrixOperations.hpp.

References DiagonalBlockFullScalMatrixMultiply(), lhs, LIB_UTILITIES_EXPORT, Multiply(), and rhs.

76 {
77  return Multiply(lhs, rhs);
78 }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97
Nektar::Multiply
NekMatrix< typename std::remove_const< typename NekMatrix< LhsDataType, LhsMatrixType >::NumberType >::type, StandardMatrixTag > Multiply(const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
Definition: MatrixOperations.hpp:261

◆ operator*() [2/9]

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

Definition at line 113 of file MatrixOperations.hpp.

References Multiply().

114 {
115  return Multiply(lhs, rhs);
116 }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97
Nektar::Multiply
NekMatrix< typename std::remove_const< typename NekMatrix< LhsDataType, LhsMatrixType >::NumberType >::type, StandardMatrixTag > Multiply(const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
Definition: MatrixOperations.hpp:261

◆ operator*() [3/9]

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

Definition at line 121 of file MatrixOperations.hpp.

References LhsDataType, LhsMatrixType, Multiply(), MultiplyEqual(), RhsDataType, and RhsMatrixType.

122 {
123  return Multiply(lhs, rhs);
124 }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97
Nektar::Multiply
NekMatrix< typename std::remove_const< typename NekMatrix< LhsDataType, LhsMatrixType >::NumberType >::type, StandardMatrixTag > Multiply(const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
Definition: MatrixOperations.hpp:261

◆ operator*() [4/9]

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

Definition at line 278 of file MatrixOperations.hpp.

References Add(), AddEqual(), LhsDataType, LhsMatrixType, Multiply(), RhsDataType, and RhsMatrixType.

280 {
281  return Multiply(lhs, rhs);
282 }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97
Nektar::Multiply
NekMatrix< typename std::remove_const< typename NekMatrix< LhsDataType, LhsMatrixType >::NumberType >::type, StandardMatrixTag > Multiply(const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
Definition: MatrixOperations.hpp:261

◆ operator*() [5/9]

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

Definition at line 299 of file NekVector.hpp.

References Multiply().

301  {
302  return Multiply(lhs, rhs);
303  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::Multiply
void Multiply(NekMatrix< ResultDataType, StandardMatrixTag > &result, const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const ResultDataType &rhs)
Definition: MatrixOperations.cpp:41
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ operator*() [6/9]

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

Definition at line 306 of file NekVector.hpp.

References Multiply().

308  {
309  return Multiply(lhs, rhs);
310  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::Multiply
void Multiply(NekMatrix< ResultDataType, StandardMatrixTag > &result, const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const ResultDataType &rhs)
Definition: MatrixOperations.cpp:41
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ operator*() [7/9]

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

Definition at line 313 of file NekVector.hpp.

References Multiply().

315  {
316  return Multiply(lhs, rhs);
317  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::Multiply
void Multiply(NekMatrix< ResultDataType, StandardMatrixTag > &result, const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const ResultDataType &rhs)
Definition: MatrixOperations.cpp:41
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ operator*() [8/9]

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

Definition at line 428 of file NekPoint.hpp.

References lhs.

429  {
430  NekPoint<DataType> result(rhs);
431  result *= lhs;
432  return result;
433  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ operator*() [9/9]

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

Definition at line 437 of file NekPoint.hpp.

References rhs.

438  {
439  NekPoint<DataType> result(lhs);
440  result *= rhs;
441  return result;
442  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ operator+() [1/7]

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

Definition at line 309 of file MatrixOperations.hpp.

References Add(), AddEqualNegatedLhs(), AddNegatedLhs(), LhsDataType, LhsMatrixType, RhsDataType, RhsMatrixType, Subtract(), SubtractEqual(), SubtractEqualNegatedLhs(), and SubtractNegatedLhs().

311 {
312  return Add(lhs, rhs);
313 }
Nektar::Add
NekMatrix< typename NekMatrix< LhsDataType, LhsMatrixType >::NumberType, StandardMatrixTag > Add(const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
Definition: MatrixOperations.cpp:260
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ operator+() [2/7]

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

Definition at line 327 of file NekVector.hpp.

References Add().

329  {
330  return Add(lhs, rhs);
331  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::Add
DNekMat void Add(NekMatrix< DataType, StandardMatrixTag > &result, const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
Definition: MatrixOperations.cpp:213
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ operator+() [3/7]

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

Definition at line 374 of file NekPoint.hpp.

References rhs.

375  {
376  NekPoint<DataType> result(lhs);
377  result += rhs;
378  return result;
379  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ operator+() [4/7]

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

Definition at line 383 of file NekPoint.hpp.

References lhs.

384  {
385  NekPoint<DataType> result(rhs);
386  result += lhs;
387  return result;
388  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ operator+() [5/7]

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

Definition at line 392 of file NekPoint.hpp.

References rhs.

393  {
394  NekPoint<DataType> result(lhs);
395  result += rhs;
396  return result;
397  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ operator+() [6/7]

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

Definition at line 747 of file SharedArray.hpp.

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

748  {
749  return Array<OneD, const DataType>::CreateWithOffset(lhs, offset);
750  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95

◆ operator+() [7/7]

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

Definition at line 753 of file SharedArray.hpp.

754  {
755  return Array<OneD, const DataType>::CreateWithOffset(rhs, offset);
756  }
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ operator-() [1/5]

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

Definition at line 334 of file NekVector.hpp.

References Nektar::NekVector< DataType >::AsString(), createVectorFromPoints(), Nektar::NekVector< DataType >::Cross(), Nektar::NekVector< DataType >::Dot(), findPointAlongVector(), FromString(), Nektar::NekVector< DataType >::InfinityNorm(), InvertInPlace(), Nektar::NekVector< DataType >::L1Norm(), Nektar::NekVector< DataType >::L2Norm(), lhs, LIB_UTILITIES_EXPORT, Nektar::NekVector< DataType >::Magnitude(), Negate(), NegateInPlace(), Nektar::NekVector< DataType >::Normalize(), operator!=(), operator==(), rhs, and Subtract().

336  {
337  return Subtract(lhs, rhs);
338  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97
Nektar::Subtract
RhsMatrixType void Subtract(NekMatrix< DataType, StandardMatrixTag > &result, const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
Definition: MatrixOperations.cpp:272

◆ operator-() [2/5]

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

Definition at line 359 of file MatrixOperations.hpp.

References Subtract().

361 {
362  return Subtract(lhs, rhs);
363 }
Nektar::Subtract
NekMatrix< typename NekMatrix< LhsDataType, LhsMatrixType >::NumberType, StandardMatrixTag > Subtract(const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
Definition: MatrixOperations.cpp:363
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ operator-() [3/5]

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

Definition at line 401 of file NekPoint.hpp.

References rhs.

402  {
403  NekPoint<DataType> result(lhs);
404  result -= rhs;
405  return result;
406  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ operator-() [4/5]

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

Definition at line 410 of file NekPoint.hpp.

References lhs.

411  {
412  NekPoint<DataType> result(-rhs);
413  result += lhs;
414  return result;
415  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ operator-() [5/5]

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

Definition at line 419 of file NekPoint.hpp.

References rhs.

420  {
421  NekPoint<DataType> result(lhs);
422  result -= rhs;
423  return result;
424  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ operator/() [1/2]

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

Definition at line 320 of file NekVector.hpp.

References Divide().

322  {
323  return Divide(lhs, rhs);
324  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::Divide
void Divide(NekVector< ResultDataType > &result, const NekVector< InputDataType > &lhs, const NekDouble &rhs)
Definition: NekVector.cpp:601
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ operator/() [2/2]

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

Definition at line 446 of file NekPoint.hpp.

References rhs.

447  {
448  NekPoint<DataType> result(lhs);
449  result /= rhs;
450  return result;
451  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ operator<<() [1/8]

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

Definition at line 49 of file NekMatrix.hpp.

References rhs.

50  {
51  int oswidth = 9;
52  int osprecision = 6;
53 
54  for(unsigned int i = 0; i < rhs.GetRows(); ++i)
55  {
56  os << "[";
57  for(unsigned int j = 0; j < rhs.GetColumns(); ++j)
58  {
59  os.width(oswidth);
60  os.precision(osprecision);
61  os << rhs(i,j);
62  if( j != rhs.GetColumns() - 1 )
63  {
64  os << ", ";
65  }
66  }
67  os << "]";
68  if( i != rhs.GetRows()-1 )
69  {
70  os << std::endl;
71  }
72  }
73  return os;
74  }
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ operator<<() [2/8]

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

Definition at line 86 of file SparseUtils.cpp.

References rhs.

87  {
88  int oswidth = 9;
89  int osprecision = 6;
90 
91  for(unsigned int i = 0; i < rhs.GetRows(); ++i)
92  {
93  os << "[";
94  for(unsigned int j = 0; j < rhs.GetColumns(); ++j)
95  {
96  os.width(oswidth);
97  os.precision(osprecision);
98  os << rhs(i,j);
99  if( j != rhs.GetColumns() - 1 )
100  {
101  os << ", ";
102  }
103  }
104  os << "]";
105  if( i != rhs.GetRows()-1 )
106  {
107  os << std::endl;
108  }
109  }
110  return os;
111  }
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ operator<<() [3/8]

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

Definition at line 114 of file SparseUtils.cpp.

References rhs.

115  {
116  int oswidth = 9;
117  int osprecision = 6;
118 
119  for(unsigned int i = 0; i < rhs.GetRows(); ++i)
120  {
121  os << "[";
122  for(unsigned int j = 0; j < rhs.GetColumns(); ++j)
123  {
124  os.width(oswidth);
125  os.precision(osprecision);
126  os << rhs(i,j);
127  if( j != rhs.GetColumns() - 1 )
128  {
129  os << ", ";
130  }
131  }
132  os << "]";
133  if( i != rhs.GetRows()-1 )
134  {
135  os << std::endl;
136  }
137  }
138  return os;
139  }
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ operator<<() [4/8]

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

◆ operator<<() [5/8]

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

◆ operator<<() [6/8]

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

Definition at line 490 of file NekPoint.hpp.

References CellMLToNektar.cellml_metadata::p.

491  {
492  os << p.AsString();
493  return os;
494  }
CellMLToNektar.cellml_metadata.p
p
Definition: cellml_metadata.py:350

◆ operator<<() [7/8]

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

Definition at line 799 of file NekVector.cpp.

References Nektar::NekVector< DataType >::AsString(), LIB_UTILITIES_EXPORT, and rhs.

800  {
801  os << rhs.AsString();
802  return os;
803  }
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ operator<<() [8/8]

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

◆ operator==() [1/7]

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

Definition at line 39 of file ArrayEqualityComparison.cpp.

References IsEqual().

Referenced by Nektar::Array< TwoD, DataType >::data(), operator-(), Nektar::Array< TwoD, const DataType >::operator=(), and Nektar::Array< OneD, const DataType >::Overlaps().

40  {
41  return IsEqual(lhs,rhs);
42  }
Nektar::IsEqual
bool IsEqual(const Array< TwoD, const NekDouble > &lhs, const Array< TwoD, const NekDouble > &rhs, NekDouble tol)
Definition: ArrayEqualityComparison.cpp:76

◆ operator==() [2/7]

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  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::IsEqual
bool IsEqual(const Array< TwoD, const NekDouble > &lhs, const Array< TwoD, const NekDouble > &rhs, NekDouble tol)
Definition: ArrayEqualityComparison.cpp:76
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ operator==() [3/7]

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

Definition at line 279 of file NekMemoryManager.hpp.

280 {
281  boost::ignore_unused(lhs,rhs);
282  return true;
283 }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ operator==() [4/7]

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

Definition at line 717 of file SharedArray.hpp.

718  {
719  if( lhs.num_elements() != rhs.num_elements() )
720  {
721  return false;
722  }
723 
724  if( lhs.data() == rhs.data() )
725  {
726  return true;
727  }
728 
729  for(unsigned int i = 0; i < lhs.num_elements(); ++i)
730  {
731  if( lhs[i] != rhs[i] )
732  {
733  return false;
734  }
735  }
736 
737  return true;
738  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ operator==() [5/7]

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

Definition at line 796 of file SharedArray.hpp.

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

797  {
798  return *lhs.m_data == *rhs.m_data;
799  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ operator==() [6/7]

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

Definition at line 843 of file NekVector.cpp.

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

845  {
846  if( lhs.GetDimension() != rhs.GetDimension() )
847  {
848  return false;
849  }
850 
851  return std::equal(lhs.begin(), lhs.end(), rhs.begin());
852  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ operator==() [7/7]

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

◆ operator>>()

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

Definition at line 77 of file NekMatrix.hpp.

References rhs.

78  {
79  NekDouble tol = 1e-12;
80  os << "[" << std::endl;
81 
82  for(unsigned int i = 0; i < rhs.GetRows(); ++i)
83  {
84  for(unsigned int j = 0; j < rhs.GetColumns(); ++j)
85  {
86  if((NekDouble)rhs(i,j) > tol)
87  {
88  os << '+';
89  }
90  else if((NekDouble)rhs(i,j) < -tol)
91  {
92  os << '*';
93  }
94  else
95  {
96  os << '-';
97  }
98  }
99  if( i != rhs.GetRows()-1 )
100  {
101  os << std::endl;
102  }
103  }
104  os << "]" << std::endl;
105  return os;
106  }
Nektar::NekDouble
double NekDouble
Definition: NektarUnivTypeDefs.hpp:43
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ prefun()

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

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

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

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

122  {
123  if (p <= pk)
124  {
125  // Rarefaction wave
126  NekDouble prat = p/pk;
127  f = g[4]*ck*(pow(prat, g[1])-1.0);
128  fd = pow(prat, -g[2])/(dk*ck);
129  }
130  else
131  {
132  // Shock wave
133  NekDouble ak = g[5]/dk;
134  NekDouble bk = g[6]*pk;
135  NekDouble qrt = sqrt(ak/(bk+p));
136  f = (p-pk)*qrt;
137  fd = (1.0-0.5*(p-pk)/(bk+p))*qrt;
138  }
139  }
CellMLToNektar.cellml_metadata.p
p
Definition: cellml_metadata.py:350
Nektar::NekDouble
double NekDouble
Definition: NektarUnivTypeDefs.hpp:43

◆ Subtract() [1/7]

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

Definition at line 272 of file MatrixOperations.cpp.

References ASSERTL1, lhs, and rhs.

Referenced by operator+(), operator-(), Subtract(), SubtractNegatedLhs(), and Nektar::MultiRegions::GlobalLinSysStaticCond::v_Solve().

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

◆ Subtract() [2/7]

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

References NEKTAR_ALL_MATRIX_TYPES, NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES(), and Subtract().

365  {
366  typedef typename NekMatrix<LhsDataType, LhsMatrixType>::NumberType NumberType;
367  NekMatrix<NumberType, StandardMatrixTag> result(lhs.GetRows(), lhs.GetColumns());
368  Subtract(result, lhs, rhs);
369  return result;
370  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::Subtract
DNekMat NekMatrix< typename NekMatrix< LhsDataType, LhsMatrixType >::NumberType, StandardMatrixTag > Subtract(const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
Definition: MatrixOperations.cpp:363
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ Subtract() [3/7]

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

References NEKTAR_ALL_MATRIX_TYPES, NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES(), and Subtract().

365  {
366  typedef typename NekMatrix<LhsDataType, LhsMatrixType>::NumberType NumberType;
367  NekMatrix<NumberType, StandardMatrixTag> result(lhs.GetRows(), lhs.GetColumns());
368  Subtract(result, lhs, rhs);
369  return result;
370  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::Subtract
DNekMat NekMatrix< typename NekMatrix< LhsDataType, LhsMatrixType >::NumberType, StandardMatrixTag > Subtract(const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
Definition: MatrixOperations.cpp:363
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ Subtract() [4/7]

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

Definition at line 512 of file NekVector.cpp.

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

515  {
516  ResultDataType* r_buf = result.GetRawPtr();
517  typename std::add_const<InputDataType>::type* lhs_buf = lhs.GetRawPtr();
518  typename std::add_const<InputDataType>::type* rhs_buf = rhs.GetRawPtr();
519  const unsigned int ldim = lhs.GetDimension();
520  for(int i = 0; i < ldim; ++i)
521  {
522  r_buf[i] = lhs_buf[i] - rhs_buf[i];
523  }
524  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ Subtract() [5/7]

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

◆ Subtract() [6/7]

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

Definition at line 587 of file NekVector.cpp.

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

589  {
590  NekVector<DataType> result(lhs.GetDimension());
591  Subtract(result, lhs, rhs);
592  return result;
593  }
Nektar::Subtract
template NekVector< NekDouble > Subtract(const NekVector< NekDouble > &lhs, const NekVector< NekDouble > &rhs)
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ Subtract() [7/7]

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

Referenced by Subtract(), and SubtractNegatedLhs().

◆ SubtractEqual() [1/4]

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

Definition at line 319 of file MatrixOperations.cpp.

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

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

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

◆ SubtractEqual() [2/4]

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

Definition at line 319 of file MatrixOperations.cpp.

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

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

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

◆ SubtractEqual() [3/4]

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

Definition at line 552 of file NekVector.cpp.

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

554  {
555  ResultDataType* r_buf = result.GetRawPtr();
556  typename std::add_const<InputDataType>::type* rhs_buf = rhs.GetRawPtr();
557  const unsigned int rdim = rhs.GetDimension();
558  for(int i = 0; i < rdim; ++i)
559  {
560  r_buf[i] -= rhs_buf[i];
561  }
562  }
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ SubtractEqual() [4/4]

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

Referenced by Nektar::NekVector< NekDouble >::operator-=(), and SubtractEqualNegatedLhs().

◆ SubtractEqualNegatedLhs() [1/3]

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

Definition at line 339 of file MatrixOperations.cpp.

References ASSERTL1, Nektar::ConstMatrix< DataType >::GetColumns(), Nektar::ConstMatrix< DataType >::GetRows(), NEKTAR_ALL_MATRIX_TYPES, NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX(), rhs, and SubtractEqual().

Referenced by operator+().

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

◆ SubtractEqualNegatedLhs() [2/3]

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

Definition at line 565 of file NekVector.cpp.

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

567  {
568  ResultDataType* r_buf = result.GetRawPtr();
569  typename std::add_const<InputDataType>::type* rhs_buf = rhs.GetRawPtr();
570  const unsigned int rdim = rhs.GetDimension();
571  for(int i = 0; i < rdim; ++i)
572  {
573  r_buf[i] = -r_buf[i] - rhs_buf[i];
574  }
575  }
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ SubtractEqualNegatedLhs() [3/3]

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

Referenced by SubtractEqualNegatedLhs().

◆ SubtractNegatedLhs() [1/3]

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

References ASSERTL1, lhs, NEKTAR_ALL_MATRIX_TYPES, NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES(), rhs, and Subtract().

Referenced by operator+().

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

◆ SubtractNegatedLhs() [2/3]

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

Definition at line 527 of file NekVector.cpp.

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

530  {
531  ResultDataType* r_buf = result.GetRawPtr();
532  typename std::add_const<InputDataType>::type* lhs_buf = lhs.GetRawPtr();
533  typename std::add_const<InputDataType>::type* rhs_buf = rhs.GetRawPtr();
534  const unsigned int ldim = lhs.GetDimension();
535  for(int i = 0; i < ldim; ++i)
536  {
537  r_buf[i] = -lhs_buf[i] - rhs_buf[i];
538  }
539  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ SubtractNegatedLhs() [3/3]

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

Referenced by SubtractNegatedLhs().

◆ Transpose() [1/5]

template<typename DataType >
NekMatrix< DataType, ScaledMatrixTag > Nektar::Transpose ( NekMatrix< DataType, ScaledMatrixTag > &  rhs)

Definition at line 178 of file ScaledMatrix.cpp.

References LIB_UTILITIES_EXPORT, and Transpose().

179  {
180  NekMatrix<DataType, ScaledMatrixTag> result(rhs);
181  result.Transpose();
182  return result;
183  }
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ Transpose() [2/5]

template<typename InnerMatrixType >
NekMatrix<InnerMatrixType, BlockMatrixTag> Nektar::Transpose ( NekMatrix< InnerMatrixType, BlockMatrixTag > &  rhs)

Definition at line 217 of file BlockMatrix.hpp.

Referenced by Nektar::NekMeshUtils::HOQuadrilateral< T >::Align(), Nektar::LocalRegions::NodalTriExp::CreateMatrix(), Nektar::LocalRegions::PyrExp::CreateMatrix(), Nektar::LocalRegions::TetExp::CreateMatrix(), Nektar::LocalRegions::PrismExp::CreateMatrix(), Nektar::LocalRegions::QuadExp::CreateMatrix(), Nektar::LocalRegions::TriExp::CreateMatrix(), Nektar::LocalRegions::HexExp::CreateMatrix(), Nektar::StdRegions::StdNodalPrismExp::NodalToModalTranspose(), Nektar::StdRegions::StdNodalTetExp::NodalToModalTranspose(), Nektar::StdRegions::StdNodalTriExp::NodalToModalTranspose(), Nektar::CoupledLinearNS::SetUpCoupledMatrix(), Nektar::CoupledLinearNS::SolveLinearNS(), Transpose(), Nektar::MultiRegions::PreconditionerLowEnergy::v_BuildPreconditioner(), Nektar::LocalRegions::Expansion3D::v_DGDeriv(), Nektar::LocalRegions::Expansion2D::v_DGDeriv(), Nektar::LinearElasticSystem::v_DoSolve(), Nektar::LocalRegions::Expansion1D::v_GenMatrix(), Nektar::LocalRegions::Expansion3D::v_GenMatrix(), Nektar::LocalRegions::Expansion2D::v_GenMatrix(), Nektar::MultiRegions::DisContField3D::v_HelmSolve(), Nektar::MultiRegions::DisContField2D::v_HelmSolve(), Nektar::MultiRegions::DisContField1D::v_HelmSolve(), and Nektar::MultiRegions::PreconditionerLowEnergy::v_TransformedSchurCompl().

218  {
219  NekMatrix<InnerMatrixType, BlockMatrixTag> result(rhs);
220  result.Transpose();
221  return result;
222  }
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ Transpose() [3/5]

template NekMatrix< NekMatrix<NekDouble, StandardMatrixTag>, ScaledMatrixTag> Nektar::Transpose ( NekMatrix< NekMatrix< NekDouble, StandardMatrixTag >, ScaledMatrixTag > &  rhs)

◆ Transpose() [4/5]

template<typename DataType >
NekMatrix< DataType, StandardMatrixTag > Nektar::Transpose ( NekMatrix< DataType, StandardMatrixTag > &  rhs)

Definition at line 802 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(), LIB_UTILITIES_EXPORT, rhs, Nektar::ConstMatrix< DataType >::Transpose(), and Transpose().

803  {
804  NekMatrix<DataType, StandardMatrixTag> result(rhs.GetRows(), rhs.GetColumns(),
805  rhs.GetPtr(), eWrapper, rhs.GetType(), rhs.GetNumberOfSubDiagonals(),
806  rhs.GetNumberOfSuperDiagonals());
807  result.Transpose();
808  return result;
809  }
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ Transpose() [5/5]

template NekMatrix<NekDouble, StandardMatrixTag> Nektar::Transpose ( NekMatrix< NekDouble, StandardMatrixTag > &  rhs)

Variable Documentation

◆ EigenvaluesAnaMeshesAB2

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

Definition at line 57 of file CFLtester.h.

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

◆ EigenvaluesAnaMeshesRK2

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

Definition at line 65 of file CFLtester.h.

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

◆ EigenvaluesAnaMeshesRK4

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

Definition at line 73 of file CFLtester.h.

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

◆ EigenvaluesRegMeshes

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

Definition at line 45 of file CFLtester.h.

◆ FlagTypeMap

const char* const Nektar::FlagTypeMap[]
Initial value:
= {
"UseGlobal"
}

String map for FlagType enumeration.

Definition at line 93 of file NektarUnivTypeDefs.hpp.

◆ InitWaveTypeMap

const char* const Nektar::InitWaveTypeMap[]
Initial value:
=
{
"Left",
"BothEnd",
"Center",
"LeftBottomCorner",
"Point",
"SpiralDock",
}

Definition at line 80 of file MMFDiffusion.h.

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

◆ kAdvectionFormStr

const std::string Nektar::kAdvectionFormStr[]
Initial value:
=
{
"NoType",
"Convective",
"NonConservative",
"Linearised",
"Adjoint",
"SkewSymmetric"
"NoAdvection"
}

Definition at line 89 of file IncNavierStokes.h.

◆ kDefaultState

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

Definition at line 47 of file InputStar.cpp.

◆ kEquationTypeStr

const std::string Nektar::kEquationTypeStr[]
Initial value:
=
{
"NoType",
"SteadyStokes",
"SteadyOseen",
"SteadyLinearisedNS",
"UnsteadyStokes",
"UnsteadyLinearisedNS",
"UnsteadyNavierStokes",
"SteadyNavierStokes",
}

Definition at line 63 of file IncNavierStokes.h.

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

◆ lhs

StandardMatrixTag& Nektar::lhs

Definition at line 95 of file MatrixOperations.cpp.

Referenced by Add(), AddNegatedLhs(), Nektar::LibUtilities::Basis::Basis(), Nektar::LibUtilities::SessionReader::CmdLineOverride(), Nektar::Array< TwoD, DataType >::data(), DiagonalBlockFullScalMatrixMultiply(), Nektar::LibUtilities::PointsKey::GetTotNumPoints(), Multiply(), MultiplyInvertedLhs(), NekMultiplyDefaultImpl(), NekMultiplyDiagonalMatrix(), NekMultiplyLowerTriangularMatrix(), NekMultiplyUnspecializedMatrixType(), NekMultiplyUpperTriangularMatrix(), Nektar::LibUtilities::TimeIntegrationSchemeKey::operator!=(), operator*(), operator+(), operator-(), Nektar::Array< OneD, const DataType >::Overlaps(), Nektar::LibUtilities::SessionReader::ReadParameters(), Nektar::LibUtilities::BasisKey::SameExp(), Subtract(), SubtractNegatedLhs(), and Nektar::LibUtilities::TimeIntegrationSchemeKey::TimeIntegrationSchemeKey().

◆ LhsDataType

Nektar::LhsDataType

Definition at line 59 of file MatrixOperations.cpp.

Referenced by AddEqualNegatedLhs(), Multiply(), MultiplyEqual(), NekMultiplyDefaultImpl(), NekMultiplyFullMatrixFullMatrix(), operator*(), and operator+().

◆ LhsMatrixType

Nektar::LhsMatrixType

Definition at line 107 of file MatrixOperations.cpp.

Referenced by Multiply(), MultiplyEqual(), NekMultiplyDefaultImpl(), NekMultiplyFullMatrixFullMatrix(), operator*(), and operator+().

◆ NEKTAR_ALL_MATRIX_TYPES

Nektar::NEKTAR_ALL_MATRIX_TYPES

Definition at line 209 of file MatrixOperations.cpp.

Referenced by Add(), AddEqualNegatedLhs(), AddNegatedLhs(), Multiply(), Subtract(), SubtractEqualNegatedLhs(), and SubtractNegatedLhs().

◆ NistSpBlasDescra

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

Definition at line 44 of file NistSparseDescriptors.hpp.

◆ NullDNekMatSharedPtr

DNekMatSharedPtr Nektar::NullDNekMatSharedPtr
static

Definition at line 78 of file NekTypeDefs.hpp.

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

◆ NullDNekScalBlkMatSharedPtr

DNekScalBlkMatSharedPtr Nektar::NullDNekScalBlkMatSharedPtr
static

Definition at line 80 of file NekTypeDefs.hpp.

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

◆ NullDNekScalMatSharedPtr

DNekScalMatSharedPtr Nektar::NullDNekScalMatSharedPtr
static

Definition at line 79 of file NekTypeDefs.hpp.

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

◆ NullFlagList

FlagList Nektar::NullFlagList
static

An empty flag list.

Definition at line 115 of file NektarUnivTypeDefs.hpp.

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

◆ NullInt1DArray

Array<OneD, int> Nektar::NullInt1DArray
static

Definition at line 786 of file SharedArray.hpp.

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

◆ NullNekDouble1DArray

Array<OneD, NekDouble> Nektar::NullNekDouble1DArray
static

Definition at line 787 of file SharedArray.hpp.

Referenced by Nektar::VelocityCorrectionScheme::AppendSVVFactors(), Nektar::Collections::Collection::ApplyOperator(), Nektar::CoupledAssemblyMap::CoupledAssemblyMap(), Nektar::FullMatrixFuncs::EigenSolve(), Nektar::MultiRegions::ExpList::GetNumElmts(), Nektar::StdRegions::StdExpansion::H1(), Nektar::LocalRegions::NodalTriExp::IProductWRTDerivBase(), Nektar::MultiRegions::ExpList::L2(), Nektar::SolverUtils::EquationSystem::L2Error(), Nektar::MultiRegions::ExpList::Linf(), Nektar::StdRegions::StdExpansion::Linf(), Nektar::StdRegions::StdExpansion::LocCoordToLocCollapsed(), Nektar::Collections::Operator::Operator(), Nektar::FieldUtils::ProcessEquiSpacedOutput::Process(), Nektar::FieldUtils::ProcessInterpField::Process(), Nektar::VelocityCorrectionScheme::SetUpSVV(), Nektar::MultiRegions::PreconditionerLinear::v_DoPreconditioner(), Nektar::MultiRegions::PreconditionerLinear::v_DoPreconditionerWithNonVertOutput(), Nektar::VelocityCorrectionScheme::v_GenerateSummary(), Nektar::SolverUtils::Driver::v_GetImagEvl(), Nektar::MultiRegions::ExpList::v_GetNumElmts(), Nektar::LocalRegions::SegExp::v_GetPhysNormals(), Nektar::StdRegions::StdExpansion::v_GetPhysNormals(), Nektar::SolverUtils::Driver::v_GetRealEvl(), Nektar::MultiRegions::ExpList3DHomogeneous1D::v_L2(), Nektar::MultiRegions::ExpList::v_L2(), Nektar::StdRegions::StdHexExp::v_PhysDeriv(), Nektar::StdRegions::StdPrismExp::v_PhysDeriv(), Nektar::StdRegions::StdTriExp::v_PhysDeriv(), Nektar::StdRegions::StdQuadExp::v_PhysDeriv(), Nektar::LocalRegions::SegExp::v_PhysDeriv(), Nektar::StdRegions::StdTetExp::v_PhysDeriv(), Nektar::LocalRegions::TriExp::v_PhysDeriv(), Nektar::LocalRegions::QuadExp::v_PhysDeriv(), Nektar::LocalRegions::HexExp::v_PhysDeriv(), Nektar::StdRegions::StdPyrExp::v_PhysDeriv(), Nektar::MultiRegions::ExpListHomogeneous1D::v_PhysDeriv(), Nektar::VCSWeakPressure::v_SolvePressure(), Nektar::MultiRegions::ExpList::WriteVtkPieceData(), Nektar::MultiRegions::GlobalLinSys::~GlobalLinSys(), and Nektar::MultiRegions::Preconditioner::~Preconditioner().

◆ NullNekDoubleArrayofArray

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

Definition at line 788 of file SharedArray.hpp.

Referenced by Nektar::CompressibleFlowSystem::DoOdeRhs(), Nektar::SolverUtils::DiffusionLDG::NumFluxforScalar(), Nektar::NavierStokesAdvection::SetSpecHPDealiasing(), Nektar::CoupledLinearNS::SetUpCoupledMatrix(), Nektar::VelocityCorrectionScheme::SetUpSVV(), Nektar::VelocityCorrectionScheme::SVVVarDiffCoeff(), Nektar::SolverUtils::AdvectionWeakDG::v_Advect(), Nektar::NavierStokesCFE::v_DoDiffusion(), Nektar::SolverUtils::Diffusion::v_InitObject(), Nektar::LocalRegions::SegExp::v_PhysDeriv_n(), Nektar::SolverUtils::Advection::~Advection(), and Nektar::SolverUtils::Diffusion::~Diffusion().

◆ NullPulseWaveBoundarySharedPtr

PulseWaveBoundarySharedPtr Nektar::NullPulseWaveBoundarySharedPtr
static

Definition at line 49 of file PulseWaveBoundary.h.

◆ NullPulseWavePressureAreaSharedPtr

PulseWavePressureAreaSharedPtr Nektar::NullPulseWavePressureAreaSharedPtr
static

Definition at line 48 of file PulseWavePressureArea.h.

◆ ProblemTypeMap

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

Definition at line 51 of file NonlinearPeregrine.h.

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

◆ rhs

StandardMatrixTag boost::call_traits<LhsDataType>::const_reference Nektar::rhs
Initial value:
{
typedef typename NekMatrix<LhsDataType, StandardMatrixTag>::iterator iterator

Definition at line 97 of file MatrixOperations.cpp.

Referenced by Add(), AddEqual(), AddEqualNegatedLhs(), AddNegatedLhs(), Nektar::LibUtilities::Basis::Basis(), Nektar::LibUtilities::SessionReader::CmdLineOverride(), Nektar::NekMatrix< DataType, StandardMatrixTag >::CreateWrapper(), Nektar::Array< TwoD, DataType >::data(), Nektar::LibUtilities::NekManager< Nektar::MultiRegions::GlobalLinSysKey, Nektar::MultiRegions::GlobalLinSys >::DisableManagement(), Divide(), DivideEqual(), Nektar::NekMatrix< NekMatrix< DataType, InnerMatrixType >, ScaledMatrixTag >::end(), Nektar::NekMatrix< NekMatrix< DataType, InnerMatrixType >, BlockMatrixTag >::end(), for(), Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::getMapFactory(), Nektar::ConstMatrix< NekMatrix< DataType, InnerMatrixType >::NumberType >::GetStorageType(), Nektar::LibUtilities::PointsKey::GetTotNumPoints(), Nektar::NekMeshUtils::CurveMesh::Mesh(), Multiply(), MultiplyEqual(), Nektar::NekMatrix< NekMatrix< DataType, InnerMatrixType >, ScaledMatrixTag >::NekMatrix(), Nektar::NekMatrix< NekMatrix< DataType, InnerMatrixType >, BlockMatrixTag >::NekMatrix(), NekMultiplyBandedMatrix(), NekMultiplyDefaultImpl(), NekMultiplyFullMatrix(), NekMultiplyLowerTriangularMatrix(), NekMultiplySymmetricMatrix(), NekMultiplyUpperTriangularMatrix(), Nektar::NekMatrix< NekMatrix< DataType, InnerMatrixType >, ScaledMatrixTag >::const_iterator::operator!=(), Nektar::NekMatrix< NekMatrix< DataType, InnerMatrixType >, BlockMatrixTag >::iterator_base< MatrixType >::operator!=(), Nektar::NekMatrix< DataType, StandardMatrixTag >::iterator_impl< T, MatrixType >::operator!=(), Nektar::NekPoint< NekDouble >::operator!=(), operator!=(), Nektar::LibUtilities::TimeIntegrationSchemeKey::operator!=(), Nektar::LibUtilities::defOpLessCreator< KeyType >::operator()(), operator*(), Nektar::NekPoint< NekDouble >::operator*=(), operator+(), Nektar::NekPoint< NekDouble >::operator+=(), operator-(), Nektar::NekPoint< NekDouble >::operator-=(), operator/(), Nektar::NekPoint< NekDouble >::operator/=(), Nektar::LocalRegions::operator<(), Nektar::MultiRegions::operator<(), operator<<(), Nektar::NekMatrix< DataType, StandardMatrixTag >::operator==(), operator>>(), Nektar::Array< OneD, const DataType >::Overlaps(), Nektar::LibUtilities::SessionReader::ReadParameters(), Nektar::LibUtilities::BasisKey::SameExp(), Subtract(), SubtractEqual(), SubtractEqualNegatedLhs(), SubtractNegatedLhs(), Nektar::LibUtilities::TimeIntegrationSchemeKey::TimeIntegrationSchemeKey(), Transpose(), Nektar::LinearElasticSystem::v_DoSolve(), Nektar::StdRegions::StdQuadExp::v_FwdTrans_BndConstrained(), Nektar::LocalRegions::TriExp::v_FwdTrans_BndConstrained(), Nektar::LocalRegions::QuadExp::v_FwdTrans_BndConstrained(), and Nektar::StdRegions::StdTriExp::v_FwdTrans_BndConstrained().

◆ RhsDataType

Nektar::RhsDataType

Definition at line 83 of file MatrixOperations.cpp.

Referenced by AddEqualNegatedLhs(), Multiply(), MultiplyEqual(), NekMultiplyDefaultImpl(), NekMultiplyFullMatrixFullMatrix(), operator*(), and operator+().

◆ RhsMatrixType

Nektar::RhsMatrixType

Definition at line 72 of file MatrixOperations.cpp.

Referenced by Multiply(), MultiplyEqual(), NekMultiplyDefaultImpl(), NekMultiplyFullMatrixFullMatrix(), operator*(), and operator+().

◆ TestTypeMap

const char *const Nektar::TestTypeMap
Initial value:
=
{
"TestPlane",
"TestCube",
"TestLinearSphere",
"TestNonlinearSphere",
"FHNStandard",
"FHNRogers",
"FHNAlievPanf",
}

Definition at line 58 of file MMFDiffusion.h.

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

◆ UpwindTypeMapPulse

const char* const Nektar::UpwindTypeMapPulse[]
Initial value:
=
{
"NoSetPulse",
"UpwindPulse",
}

Definition at line 52 of file PulseWaveSystem.h.

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

◆ void

Nektar::void

Definition at line 209 of file MatrixOperations.cpp.

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

◆ VWIIterationTypeMap

const std::string Nektar::VWIIterationTypeMap[]
Initial value:
=
{
"FixedAlpha",
"FixedWaveForcing",
"FixedAlphaWaveForcing",
"FixedWaveForcingWithSubIterationOnAlpha"
}

Definition at line 63 of file VortexWaveInteraction.h.

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

Generated on Wed Jan 20 2021 03:33:50 for Nektar++ by   doxygen 1.8.13