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

Namespaces

 CompressData
 
 H5
 
 StdHexData
 
 StdPrismData
 
 StdPyrData
 
 StdQuadData
 
 StdSegData
 
 StdTetData
 
 StdTriData
 

Classes

class  AnalyticExpressionEvaluator
 This class defines evaluator of analytic (symbolic) mathematical expressions. Expressions are allowed to depend on a number of spatial-time variables and parameters. Pre-processing and evaluation stages are split. At evaluation stage one specifies values for each variable, resulting expression value is returned. Vectorized evaluator (evaluate expression at a set of points) is available. More...
 
class  Basis
 Represents a basis of a given type. More...
 
class  BasisKey
 Describes the specification for a Basis. More...
 
class  BLPoints
 
struct  CmdLineArg
 
class  Comm
 Base communications class. More...
 
class  CommDataTypeTraits
 
class  CommDataTypeTraits< Array< OneD, elemT > >
 
class  CommDataTypeTraits< std::vector< elemT > >
 
class  CommMpi
 A global linear system. More...
 
class  CommSerial
 A global linear system. More...
 
class  DataSource
 
struct  defOpLessCreator
 
class  Equation
 
struct  FieldDefinitions
 Metadata that describes the storage properties of field output. More...
 
class  FieldIO
 Class for operating on Nektar++ input/output files. More...
 
class  FieldIOHdf5
 
class  FieldIOXml
 
class  FourierPoints
 
class  FourierSingleModePoints
 
struct  func
 
struct  functions
 
struct  FunctionVariableDefinition
 
class  GaussPoints
 
class  Graph
 
class  GraphEdgeObject
 
class  GraphVertexObject
 
class  H5DataSource
 
class  H5TagWriter
 
class  Kernel
 
struct  MeshCurvedInfo
 
struct  MeshCurvedPts
 
struct  MeshEdge
 
struct  MeshHex
 
class  MeshPartition
 
class  MeshPartitionMetis
 
class  MeshPartitionScotch
 
struct  MeshPrism
 
struct  MeshPyr
 
struct  MeshQuad
 
struct  MeshTet
 
struct  MeshTri
 
struct  MeshVertex
 
class  NekFactory
 Provides a generic Factory class. More...
 
class  NekFFTW
 
class  NekManager
 
class  NektarFFT
 
class  NodalHexElec
 
class  NodalPrismElec
 
class  NodalPrismEvenlySpaced
 
class  NodalPrismSPI
 
class  NodalQuadElec
 
class  NodalTetElec
 
class  NodalTetEvenlySpaced
 
class  NodalTetSPI
 
class  NodalTriElec
 
class  NodalTriEvenlySpaced
 
class  NodalTriFekete
 
class  NodalTriSPI
 
class  NodalUtil
 A class to assist in the construction of nodal simplex and hybrid elements in two and three dimensions. More...
 
class  NodalUtilHex
 Specialisation of the NodalUtil class to support nodal hex elements. More...
 
class  NodalUtilPrism
 Specialisation of the NodalUtil class to support nodal prismatic elements. More...
 
class  NodalUtilQuad
 Specialisation of the NodalUtil class to support nodal quad elements. More...
 
class  NodalUtilTetrahedron
 Specialisation of the NodalUtil class to support nodal tetrahedral elements. More...
 
class  NodalUtilTriangle
 Specialisation of the NodalUtil class to support nodal triangular elements. More...
 
struct  none
 
class  Points
 Stores a set of points of datatype DataT, defined by a PointKey. More...
 
class  PointsKey
 Defines a specification for a set of points. More...
 
class  PolyEPoints
 
class  PtsField
 
class  PtsIO
 
class  SessionReader
 Reads and parses information from a Nektar++ XML session file. More...
 
class  TagWriter
 Base class for writing hierarchical data (XML or HDF5). More...
 
class  TimeIntegrationAdamsBashforthOrder2
 
class  TimeIntegrationAdamsBashforthOrder3
 
class  TimeIntegrationAdamsMoultonOrder2
 
class  TimeIntegrationBackwardEuler
 
class  TimeIntegrationBDFImplicitOrder1
 
class  TimeIntegrationBDFImplicitOrder2
 
class  TimeIntegrationClassicalRungeKutta4
 
class  TimeIntegrationCNAB
 
class  TimeIntegrationDIRKOrder2
 
class  TimeIntegrationDIRKOrder3
 
class  TimeIntegrationForwardEuler
 
class  TimeIntegrationIMEXdirk_1_1_1
 
class  TimeIntegrationIMEXdirk_1_2_1
 
class  TimeIntegrationIMEXdirk_1_2_2
 
class  TimeIntegrationIMEXdirk_2_2_2
 
class  TimeIntegrationIMEXdirk_2_3_2
 
class  TimeIntegrationIMEXdirk_2_3_3
 
class  TimeIntegrationIMEXdirk_3_4_3
 
class  TimeIntegrationIMEXdirk_4_4_3
 
class  TimeIntegrationIMEXGear
 
class  TimeIntegrationIMEXOrder1
 
class  TimeIntegrationIMEXOrder2
 
class  TimeIntegrationIMEXOrder3
 
class  TimeIntegrationMCNAB
 
class  TimeIntegrationMidpoint
 
class  TimeIntegrationRungeKutta2
 
class  TimeIntegrationRungeKutta2_ImprovedEuler
 
class  TimeIntegrationRungeKutta2_SSP
 
class  TimeIntegrationRungeKutta3_SSP
 
class  TimeIntegrationRungeKutta4
 
class  TimeIntegrationScheme
 
class  TimeIntegrationSchemeKey
 
class  TimeIntegrationSchemeOperators
 
class  TimeIntegrationSolution
 
class  TimeIntegrationWrapper
 
class  Transposition
 
class  XmlDataSource
 
class  XmlTagWriter
 

Typedefs

typedef std::map< std::string,
std::string > 
FieldMetaDataMap
 
typedef boost::shared_ptr
< TagWriter
TagWriterSharedPtr
 
typedef boost::shared_ptr
< DataSource
DataSourceSharedPtr
 
typedef boost::shared_ptr
< FieldDefinitions
FieldDefinitionsSharedPtr
 
typedef
LibUtilities::NekFactory
< std::string, FieldIO,
LibUtilities::CommSharedPtr,
bool > 
FieldIOFactory
 Datatype of the NekFactory used to instantiate classes. More...
 
typedef boost::shared_ptr
< FieldIO
FieldIOSharedPtr
 
typedef boost::shared_ptr
< H5DataSource
H5DataSourceSharedPtr
 
typedef boost::shared_ptr
< H5TagWriter
H5TagWriterSharedPtr
 
typedef boost::shared_ptr
< XmlDataSource
XmlDataSourceSharedPtr
 
typedef boost::shared_ptr
< XmlTagWriter
XmlTagWriterSharedPtr
 
typedef boost::shared_ptr
< SessionReader
SessionReaderSharedPtr
 
typedef std::map< int,
std::vector< unsigned int > > 
CompositeOrdering
 
typedef std::map< int,
std::vector< unsigned int > > 
BndRegionOrdering
 
typedef
LibUtilities::NekFactory
< std::string, MeshPartition,
const SessionReaderSharedPtr & > 
MeshPartitionFactory
 Datatype of the NekFactory used to instantiate classes derived from the EquationSystem class. More...
 
typedef boost::shared_ptr
< MeshPartition
MeshPartitionSharedPtr
 
typedef boost::unique_lock
< boost::shared_mutex > 
WriteLock
 
typedef boost::shared_lock
< boost::shared_mutex > 
ReadLock
 
typedef boost::shared_ptr
< PtsField
PtsFieldSharedPtr
 
typedef std::map< std::string,
std::string > 
PtsMetaDataMap
 
typedef boost::shared_ptr< PtsIOPtsIOSharedPtr
 
typedef std::map< std::string,
std::string > 
SolverInfoMap
 
typedef std::map< std::string,
NekDouble
ParameterMap
 
typedef std::map< std::string,
std::string > 
GeometricInfoMap
 
typedef std::map< std::string,
std::string > 
ExpressionMap
 
typedef std::vector< std::string > VariableList
 
typedef std::map< std::string,
std::string > 
TagMap
 
typedef std::map< std::string,
std::string > 
FilterParams
 
typedef std::vector< std::pair
< std::string, FilterParams > > 
FilterMap
 
typedef std::map< std::string,
CmdLineArg
CmdLineArgMap
 
typedef std::map< std::string,
int > 
EnumMap
 
typedef std::map< std::string,
EnumMap
EnumMapList
 
typedef std::map< std::string,
std::string > 
GloSysInfoMap
 
typedef std::map< std::string,
GloSysInfoMap
GloSysSolnInfoList
 
typedef boost::shared_ptr
< Equation
EquationSharedPtr
 
typedef std::map< std::pair
< std::string, int >
, FunctionVariableDefinition
FunctionVariableMap
 
typedef std::map< std::string,
FunctionVariableMap
FunctionMap
 
typedef boost::shared_ptr< CommCommSharedPtr
 Pointer to a Communicator object. More...
 
typedef
LibUtilities::NekFactory
< std::string, Comm, int, char ** > 
CommFactory
 Datatype of the NekFactory used to instantiate classes derived from the EquationSystem class. More...
 
typedef boost::shared_ptr
< CommMpi
CommMpiSharedPtr
 Pointer to a Communicator object. More...
 
typedef boost::shared_ptr
< CommSerial
CommSerialSharedPtr
 Pointer to a Communicator object. More...
 
typedef boost::shared_ptr
< Transposition
TranspositionSharedPtr
 
typedef boost::shared_ptr
< NekFFTW
NekFFTWSharedPtr
 
typedef boost::shared_ptr
< NektarFFT
NektarFFTSharedPtr
 
typedef
LibUtilities::NekFactory
< std::string, NektarFFT, int > 
NektarFFTFactory
 Datatype of the NekFactory used to instantiate classes derived from the NektarFFT class. More...
 
typedef std::vector< BasisKeyBasisKeyVector
 Name for a vector of BasisKeys. More...
 
typedef std::vector< BasisKey >
::iterator 
BasisKeyVectorIter
 Name for an iterator over a BasisKeyVector. More...
 
typedef boost::shared_ptr< BasisBasisSharedPtr
 
typedef std::vector
< BasisSharedPtr
BasisVector
 
typedef std::vector
< BasisSharedPtr >::iterator 
BasisVectorIter
 
typedef Points< NekDoublePointsBaseType
 
typedef boost::shared_ptr
< Points< NekDouble > > 
PointsSharedPtr
 
typedef int GraphVertexID
 
typedef NekManager< PointsKey,
Points< NekDouble >
, PointsKey::opLess
PointsManagerT
 
typedef NekManager< BasisKey,
Basis, BasisKey::opLess
BasisManagerT
 
typedef boost::shared_ptr
< NekMatrix< NekDouble > > 
SharedMatrix
 
typedef std::vector< PointsKeyPointsKeyVector
 
typedef NekDouble(* PFD )()
 
typedef NekDouble(* PFD1 )(NekDouble)
 
typedef NekDouble(* PFD2 )(NekDouble, NekDouble)
 
typedef NekDouble(* PFD3 )(NekDouble, NekDouble, NekDouble)
 
typedef NekDouble(* PFD4 )(NekDouble, NekDouble, NekDouble, NekDouble)
 
typedef boost::shared_ptr< KernelKernelSharedPtr
 
typedef boost::shared_ptr
< TimeIntegrationScheme
TimeIntegrationSchemeSharedPtr
 
typedef std::vector
< TimeIntegrationSchemeSharedPtr
TimeIntegrationSchemeVector
 
typedef std::vector
< TimeIntegrationSchemeSharedPtr >
::iterator 
TimeIntegrationSchemeVectorIter
 
typedef boost::shared_ptr
< TimeIntegrationSolution
TimeIntegrationSolutionSharedPtr
 
typedef std::vector
< TimeIntegrationSolutionSharedPtr
TimeIntegrationSolutionVector
 
typedef std::vector
< TimeIntegrationSolutionSharedPtr >
::iterator 
TimeIntegrationSolutionVectorIter
 
typedef NekManager
< TimeIntegrationSchemeKey,
TimeIntegrationScheme,
TimeIntegrationSchemeKey::opLess
TimeIntegrationSchemeManagerT
 
typedef NekFactory
< std::string,
TimeIntegrationWrapper
TimeIntegrationWrapperFactory
 Datatype of the NekFactory used to instantiate classes derived from the EquationSystem class. More...
 
typedef boost::shared_ptr
< TimeIntegrationWrapper
TimeIntegrationWrapperSharedPtr
 
typedef boost::shared_ptr
< TimeIntegrationIMEXOrder1
TimeIntegrationIMEXOrder1SharedPtr
 

Enumerations

enum  EndianType {
  eEndianUnknown, eEndianBig, eEndianLittle, eEndianBigWord,
  eEndianLittleWord
}
 
enum  FieldIOType { eXML, eHDF5 }
 Enumerator for auto-detection of FieldIO types. More...
 
enum  PtsType {
  ePtsFile, ePtsLine, ePtsPlane, ePtsBox,
  ePtsSegBlock, ePtsTriBlock, ePtsTetBlock
}
 
enum  PtsInfo { eIsEquiSpacedData, ePtsPerElmtEdge }
 
enum  FunctionType { eFunctionTypeExpression, eFunctionTypeFile, eFunctionTypeTransientFile, eSIZE_FunctionType }
 
enum  ShapeType {
  eNoShapeType, ePoint, eSegment, eTriangle,
  eQuadrilateral, eTetrahedron, ePyramid, ePrism,
  eHexahedron, SIZE_ShapeType
}
 
enum  ReduceOperator { ReduceSum, ReduceMax, ReduceMin }
 Type of operation to perform in AllReduce. More...
 
enum  CommDataType {
  MPI_INT, MPI_UNSIGNED, MPI_LONG, MPI_UNSIGNED_LONG,
  MPI_LONG_LONG, MPI_UNSIGNED_LONG_LONG, MPI_FLOAT, MPI_DOUBLE,
  MPI_LONG_DOUBLE
}
 
enum  TranspositionDir {
  eXYtoZ, eZtoXY, eXtoYZ, eYZtoX,
  eYZtoZY, eZYtoYZ, eXtoY, eYtoZ,
  eZtoX, eNoTrans
}
 
enum  BasisType {
  eNoBasisType, eOrtho_A, eOrtho_B, eOrtho_C,
  eModified_A, eModified_B, eModified_C, eFourier,
  eGLL_Lagrange, eGauss_Lagrange, eLegendre, eChebyshev,
  eMonomial, eFourierSingleMode, eFourierHalfModeRe, eFourierHalfModeIm,
  SIZE_BasisType
}
 
enum  PointsType {
  eNoPointsType, eGaussGaussLegendre, eGaussRadauMLegendre, eGaussRadauPLegendre,
  eGaussLobattoLegendre, eGaussGaussChebyshev, eGaussRadauMChebyshev, eGaussRadauPChebyshev,
  eGaussLobattoChebyshev, eGaussRadauMAlpha0Beta1, eGaussRadauMAlpha0Beta2, eGaussRadauMAlpha1Beta0,
  eGaussRadauMAlpha2Beta0, eGaussKronrodLegendre, eGaussRadauKronrodMLegendre, eGaussRadauKronrodMAlpha1Beta0,
  eGaussLobattoKronrodLegendre, ePolyEvenlySpaced, eFourierEvenlySpaced, eFourierSingleModeSpaced,
  eBoundaryLayerPoints, eBoundaryLayerPointsRev, eNodalTriElec, eNodalTriFekete,
  eNodalTriEvenlySpaced, eNodalTetEvenlySpaced, eNodalTetElec, eNodalPrismEvenlySpaced,
  eNodalPrismElec, eNodalTriSPI, eNodalTetSPI, eNodalPrismSPI,
  eNodalQuadElec, eNodalHexElec, SIZE_PointsType
}
 
enum  TimeIntegrationMethod {
  eNoTimeIntegrationMethod, eAdamsBashforthOrder1, eAdamsBashforthOrder2, eAdamsBashforthOrder3,
  eAdamsMoultonOrder1, eAdamsMoultonOrder2, eBDFImplicitOrder1, eBDFImplicitOrder2,
  eClassicalRungeKutta4, eRungeKutta4, eRungeKutta3_SSP, eRungeKutta2_ImprovedEuler,
  eRungeKutta2_SSP, eForwardEuler, eBackwardEuler, eIMEXOrder1,
  eIMEXOrder2, eIMEXOrder3, eMidpoint, eRungeKutta2,
  eDIRKOrder2, eDIRKOrder3, eCNAB, eIMEXGear,
  eMCNAB, eIMEXdirk_1_1_1, eIMEXdirk_1_2_1, eIMEXdirk_1_2_2,
  eIMEXdirk_2_2_2, eIMEXdirk_2_3_2, eIMEXdirk_2_3_3, eIMEXdirk_3_4_3,
  eIMEXdirk_4_4_3, SIZE_TimeIntegrationMethod
}
 
enum  TimeIntegrationSchemeType {
  eNoTimeIntegrationSchemeType, eExplicit, eDiagonallyImplicit, eIMEX,
  eImplicit
}
 

Functions

EndianType Endianness (void)
 
FieldIOFactoryGetFieldIOFactory ()
 Returns the FieldIO factory. More...
 
void Write (const std::string &outFile, std::vector< FieldDefinitionsSharedPtr > &fielddefs, std::vector< std::vector< NekDouble > > &fielddata, const FieldMetaDataMap &fieldinfomap, const bool backup)
 This function allows for data to be written to an FLD file when a session and/or communicator is not instantiated. Typically used in utilities which do not take XML input and operate in serial only. More...
 
void Import (const std::string &infilename, std::vector< FieldDefinitionsSharedPtr > &fielddefs, std::vector< std::vector< NekDouble > > &fielddata, FieldMetaDataMap &fieldinfomap, const Array< OneD, int > &ElementIDs)
 This function allows for data to be imported from an FLD file when a session and/or communicator is not instantiated. Typically used in utilities which only operate in serial. More...
 
std::string PortablePath (const boost::filesystem::path &path)
 create portable path on different platforms for boost::filesystem path More...
 
MeshPartitionFactoryGetMeshPartitionFactory ()
 
int PrintProgressbar (const int position, const int goal, const string message, int lastprogress=-1)
 Prints a progressbar. More...
 
int GetNumberOfCoefficients (ShapeType shape, std::vector< unsigned int > &modes, int offset)
 
int GetNumberOfCoefficients (ShapeType shape, int na, int nb, int nc)
 
CommFactoryGetCommFactory ()
 
int CommDataTypeGetSize (CommDataType dt)
 Return the size in bytes of a data type dt. More...
 
NektarFFTFactoryGetNektarFFTFactory ()
 
bool operator< (const BasisKey &lhs, const BasisKey &rhs)
 
bool operator> (const BasisKey &lhs, const BasisKey &rhs)
 
std::ostream & operator<< (std::ostream &os, const BasisKey &rhs)
 
bool operator== (const BasisKey &x, const BasisKey &y)
 
bool operator== (const BasisKey *x, const BasisKey &y)
 
bool operator== (const BasisKey &x, const BasisKey *y)
 
bool operator!= (const BasisKey &x, const BasisKey &y)
 
bool operator!= (const BasisKey *x, const BasisKey &y)
 
bool operator!= (const BasisKey &x, const BasisKey *y)
 
static const BasisKey NullBasisKey (eNoBasisType, 0, NullPointsKey)
 Defines a null basis with no type or points. More...
 
bool operator== (const GraphVertexObject &x, const GraphVertexObject &y)
 
bool operator!= (const GraphVertexObject &x, const GraphVertexObject &y)
 
void Interp1D (const BasisKey &fbasis0, const Array< OneD, const NekDouble > &from, const BasisKey &tbasis0, Array< OneD, NekDouble > &to)
 this function interpolates a 1D function $f$ evaluated at the quadrature points of the basis fbasis0 to the function values at the quadrature points of the basis tbasis0 More...
 
void Interp1D (const PointsKey &fpoints0, const Array< OneD, const NekDouble > &from, const PointsKey &tpoints0, Array< OneD, NekDouble > &to)
 
void Interp1D (const BasisKey &fbasis0, const NekDouble *from, const BasisKey &tbasis0, NekDouble *to)
 
void Interp1D (const PointsKey &fpoints0, const NekDouble *from, const PointsKey &tpoints0, NekDouble *to)
 
void Interp2D (const BasisKey &fbasis0, const BasisKey &fbasis1, const Array< OneD, const NekDouble > &from, const BasisKey &tbasis0, const BasisKey &tbasis1, Array< OneD, NekDouble > &to)
 this function interpolates a 2D function $f$ evaluated at the quadrature points of the 2D basis, constructed by fbasis0 and fbasis1, to the function values at the quadrature points of the 2D basis, constructed by tbasis0 and tbasis1 More...
 
void Interp2D (const PointsKey &fpoints0, const PointsKey &fpoints1, const Array< OneD, const NekDouble > &from, const PointsKey &tpoints0, const PointsKey &tpoints1, Array< OneD, NekDouble > &to)
 
void Interp2D (const PointsKey &fpoints0, const PointsKey &fpoints1, const NekDouble *from, const PointsKey &tpoints0, const PointsKey &tpoints1, NekDouble *to)
 
void Interp3D (const BasisKey &fbasis0, const BasisKey &fbasis1, const BasisKey &fbasis2, const Array< OneD, const NekDouble > &from, const BasisKey &tbasis0, const BasisKey &tbasis1, const BasisKey &tbasis2, Array< OneD, NekDouble > &to)
 this function interpolates a 3D function $f$ evaluated at the quadrature points of the 3D basis, constructed by fbasis0, fbasis1, and fbasis2 to the function values at the quadrature points of the 3D basis, constructed by tbasis0, tbasis1, and tbasis2. More...
 
void Interp3D (const PointsKey &fpoints0, const PointsKey &fpoints1, const PointsKey &fpoints2, const Array< OneD, const NekDouble > &from, const PointsKey &tpoints0, const PointsKey &tpoints1, const PointsKey &tpoints2, Array< OneD, NekDouble > &to)
 
void Interp3D (const PointsKey &fpoints0, const PointsKey &fpoints1, const PointsKey &fpoints2, const NekDouble *from, const PointsKey &tpoints0, const PointsKey &tpoints1, const PointsKey &tpoints2, NekDouble *to)
 
void InterpCoeff1D (const BasisKey &fbasis0, const Array< OneD, const NekDouble > &from, const BasisKey &tbasis0, Array< OneD, NekDouble > &to)
 
void InterpCoeff2D (const BasisKey &fbasis0, const BasisKey &fbasis1, const Array< OneD, const NekDouble > &from, const BasisKey &tbasis0, const BasisKey &tbasis1, Array< OneD, NekDouble > &to)
 
void InterpCoeff2D (const BasisKey &fbasis0, const BasisKey &fbasis1, const NekDouble *from, const BasisKey &tbasis0, const BasisKey &tbasis1, NekDouble *to)
 
void InterpCoeff3D (const BasisKey &fbasis0, const BasisKey &fbasis1, const BasisKey &fbasis2, const Array< OneD, const NekDouble > &from, const BasisKey &tbasis0, const BasisKey &tbasis1, const BasisKey &tbasis2, Array< OneD, NekDouble > &to)
 
void InterpCoeff3D (const BasisKey &fbasis0, const BasisKey &fbasis1, const BasisKey &fbasis2, const NekDouble *from, const BasisKey &tbasis0, const BasisKey &tbasis1, const BasisKey &tbasis2, NekDouble *to)
 
PointsManagerTPointsManager (void)
 
BasisManagerTBasisManager (void)
 
void PhysGalerkinProject1D (const BasisKey &fbasis0, const Array< OneD, const NekDouble > &from, const BasisKey &tbasis0, Array< OneD, NekDouble > &to)
 
void PhysGalerkinProject1D (const PointsKey &fpoints0, const Array< OneD, const NekDouble > &from, const PointsKey &tpoints0, Array< OneD, NekDouble > &to)
 
void PhysGalerkinProject1D (const BasisKey &fbasis0, const NekDouble *from, const BasisKey &tbasis0, NekDouble *to)
 
void PhysGalerkinProject1D (const PointsKey &fpoints0, const NekDouble *from, const PointsKey &tpoints0, NekDouble *to)
 
void PhysGalerkinProject2D (const BasisKey &fbasis0, const BasisKey &fbasis1, const Array< OneD, const NekDouble > &from, const BasisKey &tbasis0, const BasisKey &tbasis1, Array< OneD, NekDouble > &to)
 
void PhysGalerkinProject2D (const PointsKey &fpoints0, const PointsKey &fpoints1, const Array< OneD, const NekDouble > &from, const PointsKey &tpoints0, const PointsKey &tpoints1, Array< OneD, NekDouble > &to)
 
void PhysGalerkinProject2D (const PointsKey &fpoints0, const PointsKey &fpoints1, const NekDouble *from, const PointsKey &tpoints0, const PointsKey &tpoints1, NekDouble *to)
 
void PhysGalerkinProject3D (const BasisKey &fbasis0, const BasisKey &fbasis1, const BasisKey &fbasis2, const Array< OneD, const NekDouble > &from, const BasisKey &tbasis0, const BasisKey &tbasis1, const BasisKey &tbasis2, Array< OneD, NekDouble > &to)
 
void PhysGalerkinProject3D (const PointsKey &fpoints0, const PointsKey &fpoints1, const PointsKey &fpoints2, const Array< OneD, const NekDouble > &from, const PointsKey &tpoints0, const PointsKey &tpoints1, const PointsKey &tpoints2, Array< OneD, NekDouble > &to)
 
void PhysGalerkinProject3D (const PointsKey &fpoints0, const PointsKey &fpoints1, const PointsKey &fpoints2, const NekDouble *from, const PointsKey &tpoints0, const PointsKey &tpoints1, const PointsKey &tpoints2, NekDouble *to)
 
bool operator== (const PointsKey &lhs, const PointsKey &rhs)
 
bool operator< (const PointsKey &lhs, const PointsKey &rhs)
 
std::ostream & operator<< (std::ostream &os, const PointsKey &rhs)
 
static const PointsKey NullPointsKey (0, eNoPointsType)
 
NekDouble sign (NekDouble arg)
 
NekDouble awgn (NekDouble sigma)
 
static NekDouble rad (NekDouble x, NekDouble y)
 
static NekDouble ang (NekDouble x, NekDouble y)
 
TimeIntegrationSchemeManagerTTimeIntegrationSchemeManager (void)
 
bool operator== (const TimeIntegrationSchemeKey &lhs, const TimeIntegrationSchemeKey &rhs)
 
bool operator< (const TimeIntegrationSchemeKey &lhs, const TimeIntegrationSchemeKey &rhs)
 
std::ostream & operator<< (std::ostream &os, const TimeIntegrationSchemeKey &rhs)
 
std::ostream & operator<< (std::ostream &os, const TimeIntegrationSchemeSharedPtr &rhs)
 
std::ostream & operator<< (std::ostream &os, const TimeIntegrationScheme &rhs)
 
static const
TimeIntegrationSchemeKey 
NullTimeIntegrationSchemeKey (eNoTimeIntegrationMethod)
 
TimeIntegrationWrapperFactoryGetTimeIntegrationWrapperFactory ()
 

Variables

const std::string EndianTypeMap []
 
std::string fldCmdFormat
 
static FieldMetaDataMap NullFieldMetaDataMap
 
static std::map< PtsInfo, int > NullPtsInfoMap
 
static PtsFieldSharedPtr NullPtsField
 
static PtsMetaDataMap NullPtsMetaDataMap
 
const char *const FunctionTypeMap []
 
const char *const ShapeTypeMap []
 
const unsigned int ShapeTypeDimMap [SIZE_ShapeType]
 
static std::vector< NekDoubleNullNekDoubleVector
 
static std::vector< unsigned int > NullUnsignedIntVector
 
static std::vector
< std::vector< NekDouble > > 
NullVectorNekDoubleVector
 
static BasisSharedPtr NullBasisSharedPtr
 
static Array< OneD,
BasisSharedPtr
NullBasisSharedPtr1DArray
 
const char *const BasisTypeMap []
 
const std::string kPointsTypeStr []
 
static const unsigned int perm4_3d [4][4] = {{0,1,2,3},{3,0,1,2},{2,3,0,1},{1,2,3,0}}
 
static const unsigned int perm6_3d [6][4] = {{0,1,2,3},{0,2,1,3},{0,2,3,1},{2,0,1,3},{2,0,3,1},{2,3,0,1}}
 
static const unsigned int perm12A_3d [12][4]
 
static const unsigned int perm12B_3d [12][4]
 
static const unsigned int perm12C_3d [12][4]
 
static const unsigned int perm24_3d [24][4]
 
const unsigned int NodalTetElecAvailable = 10
 
static const unsigned int NodalTetElecNPTS [NodalTetElecAvailable] = {1,2,3,5,6,9,11,15,18,23}
 
static const NekDouble NodalTetElecData [][9]
 
const unsigned int NodalTetSPIAvailable = 10
 
static const unsigned int NodalTetSPINPTS [NodalTetSPIAvailable]
 
static const NekDouble NodalTetSPIData [][4]
 
static const unsigned int perm3A_2d [3][3] = {{0,1,2},{2,0,1},{0,2,1}}
 
static const unsigned int perm3B_2d [3][3] = {{0,1,2},{1,0,2},{1,2,0}}
 
static const unsigned int perm6_2d [6][3]
 
const unsigned int NodalTriElecAvailable = 16
 
static const unsigned int NodalTriElecNPTS [NodalTriElecAvailable] = {1,2,3,4,5,7,8,10,12,14,16,19,21,24,27,30}
 
static const NekDouble NodalTriElecData [][6]
 
static const unsigned int perm3A_2d [3][3] = {{0,1,2},{2,0,1},{0,2,1}}
 
static const unsigned int perm3B_2d [3][3] = {{0,1,2},{1,0,2},{1,2,0}}
 
static const unsigned int perm3C_2d [3][3] = {{0,1,2},{2,0,1},{1,2,0}}
 
static const unsigned int perm6_2d [6][3]
 
const unsigned int NodalTriFeketeAvailable = 16
 
static const unsigned int NodalTriFeketeNPTS [NodalTriFeketeAvailable] = {1,2,3,4,5,7,8,10,12,14,16,19,21,24,27,30}
 
static const NekDouble NodalTriFeketeData [][6]
 
const unsigned int NodalTriSPIAvailable = 10
 
static const unsigned int NodalTriSPINPTS [NodalTriSPIAvailable]
 
static const NekDouble NodalTriSPIData [][3]
 
static std::vector
< LibUtilities::PointsType
NullPointsTypeVector
 
Nektar::LibUtilities::functions functions_p
 
const char *const TimeIntegrationMethodMap []
 
const char *const TimeIntegrationSchemeTypeMap []
 

Typedef Documentation

Name for a vector of BasisKeys.

Definition at line 70 of file FoundationsFwd.hpp.

Name for an iterator over a BasisKeyVector.

Definition at line 77 of file FoundationsFwd.hpp.

Definition at line 51 of file ManagerAccess.h.

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

Definition at line 80 of file FoundationsFwd.hpp.

Definition at line 81 of file FoundationsFwd.hpp.

Definition at line 82 of file FoundationsFwd.hpp.

typedef std::map< int, std::vector< unsigned int > > Nektar::LibUtilities::BndRegionOrdering

Definition at line 54 of file MeshPartition.h.

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

Definition at line 75 of file SessionReader.h.

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

Definition at line 62 of file Comm.h.

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

Pointer to a Communicator object.

Definition at line 55 of file CommMpi.h.

Pointer to a Communicator object.

Definition at line 49 of file CommSerial.h.

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

Pointer to a Communicator object.

Definition at line 55 of file Comm.h.

typedef std::map< int, std::vector< unsigned int > > Nektar::LibUtilities::CompositeOrdering

Definition at line 53 of file MeshPartition.h.

Definition at line 81 of file FieldIO.h.

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

Definition at line 77 of file SessionReader.h.

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

Definition at line 78 of file SessionReader.h.

Definition at line 100 of file SessionReader.h.

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

Definition at line 61 of file SessionReader.h.

Definition at line 181 of file FieldIO.h.

Datatype of the NekFactory used to instantiate classes.

Definition at line 197 of file FieldIO.h.

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

Definition at line 309 of file FieldIO.h.

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

Definition at line 54 of file FieldIO.h.

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

Definition at line 66 of file SessionReader.h.

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

Definition at line 64 of file SessionReader.h.

typedef std::map<std::string, FunctionVariableMap > Nektar::LibUtilities::FunctionMap

Definition at line 117 of file SessionReader.h.

typedef std::map<std::pair<std::string,int>, FunctionVariableDefinition> Nektar::LibUtilities::FunctionVariableMap

Definition at line 115 of file SessionReader.h.

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

Definition at line 60 of file SessionReader.h.

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

Definition at line 80 of file SessionReader.h.

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

Definition at line 81 of file SessionReader.h.

Definition at line 86 of file FoundationsFwd.hpp.

Definition at line 89 of file FieldIOHdf5.h.

Definition at line 117 of file FieldIOHdf5.h.

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

Definition at line 215 of file kernel.h.

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

Definition at line 58 of file MeshPartition.h.

Definition at line 246 of file MeshPartition.h.

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

Definition at line 56 of file NekFFTW.h.

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

Definition at line 63 of file NektarFFT.h.

Definition at line 56 of file NektarFFT.h.

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

Definition at line 59 of file SessionReader.h.

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

Definition at line 74 of file AnalyticExpressionEvaluator.cpp.

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

Definition at line 75 of file AnalyticExpressionEvaluator.cpp.

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

Definition at line 76 of file AnalyticExpressionEvaluator.cpp.

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

Definition at line 77 of file AnalyticExpressionEvaluator.cpp.

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

Definition at line 78 of file AnalyticExpressionEvaluator.cpp.

Definition at line 84 of file FoundationsFwd.hpp.

Definition at line 242 of file Points.h.

Definition at line 50 of file ManagerAccess.h.

Definition at line 85 of file FoundationsFwd.hpp.

Definition at line 178 of file PtsField.h.

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

Definition at line 95 of file PtsIO.h.

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

Definition at line 61 of file PtsIO.h.

typedef boost::shared_lock< boost::shared_mutex > Nektar::LibUtilities::ReadLock

Definition at line 71 of file NekFactory.hpp.

Definition at line 51 of file MeshPartition.h.

Definition at line 56 of file NodalUtil.h.

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

Definition at line 58 of file SessionReader.h.

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

Definition at line 63 of file SessionReader.h.

Definition at line 71 of file FieldIO.h.

Definition at line 115 of file TimeIntegrationWrapper.h.

Definition at line 354 of file TimeIntegrationScheme.h.

Definition at line 51 of file TimeIntegrationScheme.h.

Definition at line 55 of file TimeIntegrationScheme.h.

Definition at line 56 of file TimeIntegrationScheme.h.

Definition at line 57 of file TimeIntegrationScheme.h.

Definition at line 58 of file TimeIntegrationScheme.h.

Definition at line 59 of file TimeIntegrationScheme.h.

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

Definition at line 46 of file TimeIntegrationWrapper.h.

Definition at line 57 of file TimeIntegrationWrapper.h.

Definition at line 166 of file Transposition.h.

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

Definition at line 62 of file SessionReader.h.

typedef boost::unique_lock< boost::shared_mutex > Nektar::LibUtilities::WriteLock

Definition at line 70 of file NekFactory.hpp.

Definition at line 108 of file FieldIOXml.h.

Definition at line 139 of file FieldIOXml.h.

Enumeration Type Documentation

Enumerator
eNoBasisType 
eOrtho_A 

Principle Orthogonal Functions $\widetilde{\psi}^a_p(z_i)$.

eOrtho_B 

Principle Orthogonal Functions $\widetilde{\psi}^b_{pq}(z_i)$.

eOrtho_C 

Principle Orthogonal Functions $\widetilde{\psi}^c_{pqr}(z_i)$.

eModified_A 

Principle Modified Functions $ \phi^a_p(z_i) $.

eModified_B 

Principle Modified Functions $ \phi^b_{pq}(z_i) $.

eModified_C 

Principle Modified Functions $ \phi^c_{pqr}(z_i) $.

eFourier 

Fourier Expansion $ \exp(i p\pi z_i)$.

eGLL_Lagrange 

Lagrange for SEM basis $ h_p(z_i) $.

eGauss_Lagrange 

Lagrange Polynomials using the Gauss points $ h_p(z_i) $.

eLegendre 

Legendre Polynomials $ L_p(z_i) = P^{0,0}_p(z_i)$. Same as Ortho_A.

eChebyshev 

Chebyshev Polynomials $ T_p(z_i) = P^{-1/2,-1/2}_p(z_i)$.

eMonomial 

Monomial polynomials $ L_p(z_i) = z_i^{p}$.

eFourierSingleMode 

Fourier ModifiedExpansion with just the first mode $ \exp(i \pi z_i)$.

eFourierHalfModeRe 

Fourier Modified expansions with just the real part of the first mode $ Re[\exp(i \pi z_i)]$.

eFourierHalfModeIm 

Fourier Modified expansions with just the imaginary part of the first mode $ Im[\exp(i \pi z_i)]$.

SIZE_BasisType 

Length of enum list.

Definition at line 43 of file BasisType.h.

44  {
46  eOrtho_A, //!< Principle Orthogonal Functions \f$\widetilde{\psi}^a_p(z_i)\f$
47  eOrtho_B, //!< Principle Orthogonal Functions \f$\widetilde{\psi}^b_{pq}(z_i)\f$
48  eOrtho_C, //!< Principle Orthogonal Functions \f$\widetilde{\psi}^c_{pqr}(z_i)\f$
49  eModified_A, //!< Principle Modified Functions \f$ \phi^a_p(z_i) \f$
50  eModified_B, //!< Principle Modified Functions \f$ \phi^b_{pq}(z_i) \f$
51  eModified_C, //!< Principle Modified Functions \f$ \phi^c_{pqr}(z_i) \f$
52  eFourier, //!< Fourier Expansion \f$ \exp(i p\pi z_i)\f$
53  eGLL_Lagrange, //!< Lagrange for SEM basis \f$ h_p(z_i) \f$
54  eGauss_Lagrange, //!< Lagrange Polynomials using the Gauss points \f$ h_p(z_i) \f$
55  eLegendre, //!< Legendre Polynomials \f$ L_p(z_i) = P^{0,0}_p(z_i)\f$. Same as Ortho_A
56  eChebyshev, //!< Chebyshev Polynomials \f$ T_p(z_i) = P^{-1/2,-1/2}_p(z_i)\f$
57  eMonomial, //!< Monomial polynomials \f$ L_p(z_i) = z_i^{p}\f$
58  eFourierSingleMode, //!< Fourier ModifiedExpansion with just the first mode \f$ \exp(i \pi z_i)\f$
59  eFourierHalfModeRe, //!< Fourier Modified expansions with just the real part of the first mode \f$ Re[\exp(i \pi z_i)]\f$
60  eFourierHalfModeIm, //!< Fourier Modified expansions with just the imaginary part of the first mode \f$ Im[\exp(i \pi z_i)]\f$
61  SIZE_BasisType //!< Length of enum list
62  };
Principle Modified Functions .
Definition: BasisType.h:51
Principle Modified Functions .
Definition: BasisType.h:49
Lagrange Polynomials using the Gauss points .
Definition: BasisType.h:54
Fourier Expansion .
Definition: BasisType.h:52
Chebyshev Polynomials .
Definition: BasisType.h:56
Principle Orthogonal Functions .
Definition: BasisType.h:47
Fourier Modified expansions with just the real part of the first mode .
Definition: BasisType.h:59
Principle Modified Functions .
Definition: BasisType.h:50
Principle Orthogonal Functions .
Definition: BasisType.h:48
Principle Orthogonal Functions .
Definition: BasisType.h:46
Fourier Modified expansions with just the imaginary part of the first mode .
Definition: BasisType.h:60
Fourier ModifiedExpansion with just the first mode .
Definition: BasisType.h:58
Legendre Polynomials . Same as Ortho_A.
Definition: BasisType.h:55
Lagrange for SEM basis .
Definition: BasisType.h:53
Monomial polynomials .
Definition: BasisType.h:57
Enumerator
eEndianUnknown 
eEndianBig 
eEndianLittle 
eEndianBigWord 
eEndianLittleWord 

Definition at line 60 of file CompressData.h.

Enumerator for auto-detection of FieldIO types.

Enumerator
eXML 
eHDF5 

Definition at line 83 of file FieldIO.cpp.

Enumerator
eFunctionTypeExpression 
eFunctionTypeFile 
eFunctionTypeTransientFile 
eSIZE_FunctionType 

Definition at line 86 of file SessionReader.h.

Enumerator
eNoPointsType 
eGaussGaussLegendre 

1D Gauss-Gauss-Legendre quadrature points

eGaussRadauMLegendre 

1D Gauss-Radau-Legendre quadrature points, pinned at x=-1

eGaussRadauPLegendre 

1D Gauss-Radau-Legendre quadrature points, pinned at x=1

eGaussLobattoLegendre 

1D Gauss-Lobatto-Legendre quadrature points

eGaussGaussChebyshev 

1D Gauss-Gauss-Chebyshev quadrature points

eGaussRadauMChebyshev 

1D Gauss-Radau-Chebyshev quadrature points, pinned at x=-1

eGaussRadauPChebyshev 

1D Gauss-Radau-Chebyshev quadrature points, pinned at x=1

eGaussLobattoChebyshev 

1D Gauss-Lobatto-Legendre quadrature points

eGaussRadauMAlpha0Beta1 

Gauss Radau pinned at x=-1, $ \alpha = 0, \beta = 1 $.

eGaussRadauMAlpha0Beta2 

Gauss Radau pinned at x=-1, $ \alpha = 0, \beta = 2 $.

eGaussRadauMAlpha1Beta0 

Gauss Radau pinned at x=-1, $ \alpha = 1, \beta = 0 $.

eGaussRadauMAlpha2Beta0 

Gauss Radau pinned at x=-1, $ \alpha = 2, \beta = 0 $.

eGaussKronrodLegendre 

1D Gauss-Kronrod-Legendre quadrature points

eGaussRadauKronrodMLegendre 

1D Gauss-Radau-Kronrod-Legendre quadrature points, pinned at x=-1

eGaussRadauKronrodMAlpha1Beta0 

1D Gauss-Radau-Kronrod-Legendre pinned at x=-1, $ \alpha = 1, \beta = 0 $

eGaussLobattoKronrodLegendre 

1D Lobatto Kronrod quadrature points

ePolyEvenlySpaced 

1D Evenly-spaced points using Lagrange polynomial

eFourierEvenlySpaced 

1D Evenly-spaced points using Fourier Fit

eFourierSingleModeSpaced 

1D Non Evenly-spaced points for Single Mode analysis

eBoundaryLayerPoints 

1D power law distribution for boundary layer points

eBoundaryLayerPointsRev 

1D power law distribution for boundary layer points

eNodalTriElec 

2D Nodal Electrostatic Points on a Triangle

eNodalTriFekete 

2D Nodal Fekete Points on a Triangle

eNodalTriEvenlySpaced 

2D Evenly-spaced points on a Triangle

eNodalTetEvenlySpaced 

3D Evenly-spaced points on a Tetrahedron

eNodalTetElec 

3D Nodal Electrostatic Points on a Tetrahedron

eNodalPrismEvenlySpaced 

3D Evenly-spaced points on a Prism

eNodalPrismElec 

3D electrostatically spaced points on a Prism

eNodalTriSPI 

2D Nodal Symmetric positive internal triangle (Whitherden, Vincent)

eNodalTetSPI 

3D Nodal Symmetric positive internal tet (Whitherden, Vincent)

eNodalPrismSPI 

3D prism SPI

eNodalQuadElec 

2D GLL for quad

eNodalHexElec 

3D GLL for hex

SIZE_PointsType 

Length of enum list.

Definition at line 46 of file PointsType.h.

47  {
49  eGaussGaussLegendre, //!< 1D Gauss-Gauss-Legendre quadrature points
50  eGaussRadauMLegendre, //!< 1D Gauss-Radau-Legendre quadrature points, pinned at x=-1
51  eGaussRadauPLegendre, //!< 1D Gauss-Radau-Legendre quadrature points, pinned at x=1
52  eGaussLobattoLegendre, //!< 1D Gauss-Lobatto-Legendre quadrature points
53  eGaussGaussChebyshev, //!< 1D Gauss-Gauss-Chebyshev quadrature points
54  eGaussRadauMChebyshev, //!< 1D Gauss-Radau-Chebyshev quadrature points, pinned at x=-1
55  eGaussRadauPChebyshev, //!< 1D Gauss-Radau-Chebyshev quadrature points, pinned at x=1
56  eGaussLobattoChebyshev, //!< 1D Gauss-Lobatto-Legendre quadrature points
57  eGaussRadauMAlpha0Beta1, //!< Gauss Radau pinned at x=-1, \f$ \alpha = 0, \beta = 1 \f$
58  eGaussRadauMAlpha0Beta2, //!< Gauss Radau pinned at x=-1, \f$ \alpha = 0, \beta = 2 \f$
59  eGaussRadauMAlpha1Beta0, //!< Gauss Radau pinned at x=-1, \f$ \alpha = 1, \beta = 0 \f$
60  eGaussRadauMAlpha2Beta0, //!< Gauss Radau pinned at x=-1, \f$ \alpha = 2, \beta = 0 \f$
61  eGaussKronrodLegendre, //!< 1D Gauss-Kronrod-Legendre quadrature points
62  eGaussRadauKronrodMLegendre, //!< 1D Gauss-Radau-Kronrod-Legendre quadrature points, pinned at x=-1
63  eGaussRadauKronrodMAlpha1Beta0, //!< 1D Gauss-Radau-Kronrod-Legendre pinned at x=-1, \f$ \alpha = 1, \beta = 0 \f$
64  eGaussLobattoKronrodLegendre, //!< 1D Lobatto Kronrod quadrature points
65  ePolyEvenlySpaced, //!< 1D Evenly-spaced points using Lagrange polynomial
66  eFourierEvenlySpaced, //!< 1D Evenly-spaced points using Fourier Fit
67  eFourierSingleModeSpaced, //!< 1D Non Evenly-spaced points for Single Mode analysis
68  eBoundaryLayerPoints, //!< 1D power law distribution for boundary layer points
69  eBoundaryLayerPointsRev, //!< 1D power law distribution for boundary layer points
70  eNodalTriElec, //!< 2D Nodal Electrostatic Points on a Triangle
71  eNodalTriFekete, //!< 2D Nodal Fekete Points on a Triangle
72  eNodalTriEvenlySpaced, //!< 2D Evenly-spaced points on a Triangle
73  eNodalTetEvenlySpaced, //!< 3D Evenly-spaced points on a Tetrahedron
74  eNodalTetElec, //!< 3D Nodal Electrostatic Points on a Tetrahedron
75  eNodalPrismEvenlySpaced, //!< 3D Evenly-spaced points on a Prism
76  eNodalPrismElec, //!< 3D electrostatically spaced points on a Prism
77  eNodalTriSPI, //!< 2D Nodal Symmetric positive internal triangle (Whitherden, Vincent)
78  eNodalTetSPI, //!< 3D Nodal Symmetric positive internal tet (Whitherden, Vincent)
79  eNodalPrismSPI, //!< 3D prism SPI
80  eNodalQuadElec, //!< 2D GLL for quad
81  eNodalHexElec, //!< 3D GLL for hex
82  SIZE_PointsType //!< Length of enum list
83  };
1D Gauss-Radau-Kronrod-Legendre quadrature points, pinned at x=-1
Definition: PointsType.h:62
1D Gauss-Radau-Chebyshev quadrature points, pinned at x=-1
Definition: PointsType.h:54
1D Gauss-Radau-Legendre quadrature points, pinned at x=1
Definition: PointsType.h:51
1D Gauss-Kronrod-Legendre quadrature points
Definition: PointsType.h:61
3D Nodal Symmetric positive internal tet (Whitherden, Vincent)
Definition: PointsType.h:78
1D Gauss-Gauss-Legendre quadrature points
Definition: PointsType.h:49
Gauss Radau pinned at x=-1, .
Definition: PointsType.h:59
1D Gauss-Radau-Kronrod-Legendre pinned at x=-1,
Definition: PointsType.h:63
1D Evenly-spaced points using Lagrange polynomial
Definition: PointsType.h:65
1D Lobatto Kronrod quadrature points
Definition: PointsType.h:64
1D Evenly-spaced points using Fourier Fit
Definition: PointsType.h:66
3D Nodal Electrostatic Points on a Tetrahedron
Definition: PointsType.h:74
1D Gauss-Radau-Chebyshev quadrature points, pinned at x=1
Definition: PointsType.h:55
1D Gauss-Gauss-Chebyshev quadrature points
Definition: PointsType.h:53
3D Evenly-spaced points on a Tetrahedron
Definition: PointsType.h:73
2D Nodal Fekete Points on a Triangle
Definition: PointsType.h:71
1D power law distribution for boundary layer points
Definition: PointsType.h:69
1D Non Evenly-spaced points for Single Mode analysis
Definition: PointsType.h:67
Gauss Radau pinned at x=-1, .
Definition: PointsType.h:60
1D power law distribution for boundary layer points
Definition: PointsType.h:68
3D Evenly-spaced points on a Prism
Definition: PointsType.h:75
2D Evenly-spaced points on a Triangle
Definition: PointsType.h:72
Gauss Radau pinned at x=-1, .
Definition: PointsType.h:58
Gauss Radau pinned at x=-1, .
Definition: PointsType.h:57
1D Gauss-Lobatto-Legendre quadrature points
Definition: PointsType.h:52
2D Nodal Electrostatic Points on a Triangle
Definition: PointsType.h:70
3D electrostatically spaced points on a Prism
Definition: PointsType.h:76
1D Gauss-Radau-Legendre quadrature points, pinned at x=-1
Definition: PointsType.h:50
2D Nodal Symmetric positive internal triangle (Whitherden, Vincent)
Definition: PointsType.h:77
1D Gauss-Lobatto-Legendre quadrature points
Definition: PointsType.h:56
Enumerator
eIsEquiSpacedData 
ePtsPerElmtEdge 

Definition at line 65 of file PtsField.h.

Enumerator
ePtsFile 
ePtsLine 
ePtsPlane 
ePtsBox 
ePtsSegBlock 
ePtsTriBlock 
ePtsTetBlock 

Definition at line 54 of file PtsField.h.

Type of operation to perform in AllReduce.

Enumerator
ReduceSum 
ReduceMax 
ReduceMin 

Definition at line 67 of file Comm.h.

Enumerator
eNoTimeIntegrationMethod 
eAdamsBashforthOrder1 

Adams-Bashforth Forward multi-step scheme of order 1.

eAdamsBashforthOrder2 

Adams-Bashforth Forward multi-step scheme of order 2.

eAdamsBashforthOrder3 

Adams-Bashforth Forward multi-step scheme of order 3.

eAdamsMoultonOrder1 

Adams-Moulton Forward multi-step scheme of order 1.

eAdamsMoultonOrder2 

Adams-Moulton Forward multi-step scheme of order 2.

eBDFImplicitOrder1 

BDF multi-step scheme of order 1 (implicit)

eBDFImplicitOrder2 

BDF multi-step scheme of order 2 (implicit)

eClassicalRungeKutta4 

Runge-Kutta multi-stage scheme 4th order explicit (old name)

eRungeKutta4 

Classical RungeKutta4 method (new name for eClassicalRungeKutta4)

eRungeKutta3_SSP 

Nonlinear SSP RungeKutta3 explicit.

eRungeKutta2_ImprovedEuler 

Improved RungeKutta2 explicit (old name meaning Heun's method)

eRungeKutta2_SSP 

Nonlinear SSP RungeKutta2 explicit (surrogate for eRungeKutta2_ImprovedEuler)

eForwardEuler 

Forward Euler scheme.

eBackwardEuler 

Backward Euler scheme.

eIMEXOrder1 

IMEX 1st order scheme using Euler Backwards/Euler Forwards.

eIMEXOrder2 

IMEX 2nd order scheme using Backward Different Formula & Extrapolation.

eIMEXOrder3 

IMEX 3rd order scheme using Backward Different Formula & Extrapolation.

eMidpoint 

midpoint method (old name)

eRungeKutta2 

Classical RungeKutta2 method (new name for eMidpoint)

eDIRKOrder2 

Diagonally Implicit Runge Kutta scheme of order 3.

eDIRKOrder3 

Diagonally Implicit Runge Kutta scheme of order 3.

eCNAB 

Crank-Nicolson/Adams-Bashforth Order 2 (CNAB)

eIMEXGear 

IMEX Gear Order 2.

eMCNAB 

Modified Crank-Nicolson/Adams-Bashforth Order 2 (MCNAB)

eIMEXdirk_1_1_1 

Forward-Backward Euler IMEX DIRK(1,1,1)

eIMEXdirk_1_2_1 

Forward-Backward Euler IMEX DIRK(1,2,1)

eIMEXdirk_1_2_2 

Implicit-Explicit Midpoint IMEX DIRK(1,2,2)

eIMEXdirk_2_2_2 

L-stable, two stage, second order IMEX DIRK(2,2,2)

eIMEXdirk_2_3_2 

L-stable, three stage, third order IMEX DIRK(3,4,3)

eIMEXdirk_2_3_3 

L-stable, two stage, third order IMEX DIRK(2,3,3)

eIMEXdirk_3_4_3 

L-stable, three stage, third order IMEX DIRK(3,4,3)

eIMEXdirk_4_4_3 

L-stable, four stage, third order IMEX DIRK(4,4,3)

SIZE_TimeIntegrationMethod 

Length of enum list.

Definition at line 64 of file TimeIntegrationScheme.h.

65  {
67  eAdamsBashforthOrder1, //!< Adams-Bashforth Forward multi-step scheme of order 1
68  eAdamsBashforthOrder2, //!< Adams-Bashforth Forward multi-step scheme of order 2
69  eAdamsBashforthOrder3, //!< Adams-Bashforth Forward multi-step scheme of order 3
70  eAdamsMoultonOrder1, //!< Adams-Moulton Forward multi-step scheme of order 1
71  eAdamsMoultonOrder2, //!< Adams-Moulton Forward multi-step scheme of order 2
72  eBDFImplicitOrder1, //!< BDF multi-step scheme of order 1 (implicit)
73  eBDFImplicitOrder2, //!< BDF multi-step scheme of order 2 (implicit)
74  eClassicalRungeKutta4, //!< Runge-Kutta multi-stage scheme 4th order explicit (old name)
75  eRungeKutta4, //!< Classical RungeKutta4 method (new name for eClassicalRungeKutta4)
76  eRungeKutta3_SSP, //!< Nonlinear SSP RungeKutta3 explicit
77  eRungeKutta2_ImprovedEuler, //!< Improved RungeKutta2 explicit (old name meaning Heun's method)
78  eRungeKutta2_SSP, //!< Nonlinear SSP RungeKutta2 explicit (surrogate for eRungeKutta2_ImprovedEuler)
79  eForwardEuler, //!< Forward Euler scheme
80  eBackwardEuler, //!< Backward Euler scheme
81  eIMEXOrder1, //!< IMEX 1st order scheme using Euler Backwards/Euler Forwards
82  eIMEXOrder2, //!< IMEX 2nd order scheme using Backward Different Formula & Extrapolation
83  eIMEXOrder3, //!< IMEX 3rd order scheme using Backward Different Formula & Extrapolation
84  eMidpoint, //!< midpoint method (old name)
85  eRungeKutta2, //!< Classical RungeKutta2 method (new name for eMidpoint)
86  eDIRKOrder2, //!< Diagonally Implicit Runge Kutta scheme of order 3
87  eDIRKOrder3, //!< Diagonally Implicit Runge Kutta scheme of order 3
88  eCNAB, //!< Crank-Nicolson/Adams-Bashforth Order 2 (CNAB)
89  eIMEXGear, //!< IMEX Gear Order 2
90  eMCNAB, //!< Modified Crank-Nicolson/Adams-Bashforth Order 2 (MCNAB)
91  eIMEXdirk_1_1_1, //!< Forward-Backward Euler IMEX DIRK(1,1,1)
92  eIMEXdirk_1_2_1, //!< Forward-Backward Euler IMEX DIRK(1,2,1)
93  eIMEXdirk_1_2_2, //!< Implicit-Explicit Midpoint IMEX DIRK(1,2,2)
94  eIMEXdirk_2_2_2, //!< L-stable, two stage, second order IMEX DIRK(2,2,2)
95  eIMEXdirk_2_3_2, //!< L-stable, three stage, third order IMEX DIRK(3,4,3)
96  eIMEXdirk_2_3_3, //!< L-stable, two stage, third order IMEX DIRK(2,3,3)
97  eIMEXdirk_3_4_3, //!< L-stable, three stage, third order IMEX DIRK(3,4,3)
98  eIMEXdirk_4_4_3, //!< L-stable, four stage, third order IMEX DIRK(4,4,3)
99  SIZE_TimeIntegrationMethod //!< Length of enum list
100  };
BDF multi-step scheme of order 1 (implicit)
Adams-Bashforth Forward multi-step scheme of order 2.
Runge-Kutta multi-stage scheme 4th order explicit (old name)
Implicit-Explicit Midpoint IMEX DIRK(1,2,2)
Classical RungeKutta4 method (new name for eClassicalRungeKutta4)
L-stable, four stage, third order IMEX DIRK(4,4,3)
Forward-Backward Euler IMEX DIRK(1,2,1)
Nonlinear SSP RungeKutta3 explicit.
Adams-Moulton Forward multi-step scheme of order 2.
Adams-Bashforth Forward multi-step scheme of order 3.
Crank-Nicolson/Adams-Bashforth Order 2 (CNAB)
IMEX 2nd order scheme using Backward Different Formula & Extrapolation.
Classical RungeKutta2 method (new name for eMidpoint)
Adams-Moulton Forward multi-step scheme of order 1.
Adams-Bashforth Forward multi-step scheme of order 1.
L-stable, three stage, third order IMEX DIRK(3,4,3)
Nonlinear SSP RungeKutta2 explicit (surrogate for eRungeKutta2_ImprovedEuler)
Improved RungeKutta2 explicit (old name meaning Heun's method)
Forward-Backward Euler IMEX DIRK(1,1,1)
BDF multi-step scheme of order 2 (implicit)
L-stable, two stage, second order IMEX DIRK(2,2,2)
Diagonally Implicit Runge Kutta scheme of order 3.
IMEX 3rd order scheme using Backward Different Formula & Extrapolation.
L-stable, three stage, third order IMEX DIRK(3,4,3)
Diagonally Implicit Runge Kutta scheme of order 3.
L-stable, two stage, third order IMEX DIRK(2,3,3)
Modified Crank-Nicolson/Adams-Bashforth Order 2 (MCNAB)
IMEX 1st order scheme using Euler Backwards/Euler Forwards.
midpoint method (old name)
Enumerator
eNoTimeIntegrationSchemeType 
eExplicit 

Formally explicit scheme.

eDiagonallyImplicit 

Diagonally implicit scheme (e.g. the DIRK schemes)

eIMEX 

Implicit Explicit General Linear Method.

eImplicit 

Fully implicit scheme.

Definition at line 139 of file TimeIntegrationScheme.h.

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

Function Documentation

static NekDouble Nektar::LibUtilities::ang ( NekDouble  x,
NekDouble  y 
)
static
NekDouble Nektar::LibUtilities::awgn ( NekDouble  sigma)

Definition at line 106 of file AnalyticExpressionEvaluator.cpp.

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

107  {
108  AnalyticExpressionEvaluator::RandomGeneratorType rng;
109  boost::variate_generator<
110  AnalyticExpressionEvaluator::RandomGeneratorType&,
111  boost::normal_distribution<>
112  > _normal(rng, boost::normal_distribution<>(0, sigma) );
113  return _normal();
114  }
BasisManagerT & Nektar::LibUtilities::BasisManager ( void  )
int Nektar::LibUtilities::CommDataTypeGetSize ( CommDataType  dt)

Return the size in bytes of a data type dt.

Parameters
dtData type
Returns
Size of dt in bytes.

Definition at line 51 of file CommDataType.cpp.

References ASSERTL0, MPI_DOUBLE, MPI_FLOAT, MPI_INT, MPI_LONG, MPI_LONG_DOUBLE, MPI_LONG_LONG, MPI_UNSIGNED, MPI_UNSIGNED_LONG, and MPI_UNSIGNED_LONG_LONG.

Referenced by Nektar::LibUtilities::CommSerial::v_Gather(), and Nektar::LibUtilities::CommSerial::v_Scatter().

52 {
53 #ifdef NEKTAR_USE_MPI
54  int size;
55  MPI_Type_size(dt, &size);
56  return size;
57 #else
58  switch (dt)
59  {
60  case MPI_INT:
61  return sizeof(int);
62  case MPI_UNSIGNED:
63  return sizeof(unsigned);
64  case MPI_LONG:
65  return sizeof(long);
66  case MPI_UNSIGNED_LONG:
67  return sizeof(unsigned long);
68  case MPI_LONG_LONG:
69  return sizeof(long long);
71  return sizeof(unsigned long long);
72  case MPI_FLOAT:
73  return sizeof(float);
74  case MPI_DOUBLE:
75  return sizeof(double);
76  case MPI_LONG_DOUBLE:
77  return sizeof(long double);
78  default:
79  ASSERTL0(false, "Unrecognised datatype!");
80  }
81  return sizeof(int);
82 #endif
83 }
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:198
EndianType Nektar::LibUtilities::Endianness ( void  )

run time determination of endianness, returning an EndianType

Definition at line 60 of file CompressData.cpp.

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

Referenced by Nektar::LibUtilities::CompressData::GetCompressString().

61  {
62  union
63  {
64  boost::uint32_t value;
65  boost::uint8_t data[sizeof(boost::uint32_t)];
66  } number;
67 
68  number.data[0] = 0x00;
69  number.data[1] = 0x01;
70  number.data[2] = 0x02;
71  number.data[3] = 0x03;
72 
73  switch (number.value)
74  {
75  case UINT32_C(0x00010203): return eEndianBig;
76  case UINT32_C(0x03020100): return eEndianLittle;
77  case UINT32_C(0x02030001): return eEndianBigWord;
78  case UINT32_C(0x01000302): return eEndianLittleWord;
79  default: return eEndianUnknown;
80  }
81  }
CommFactory & Nektar::LibUtilities::GetCommFactory ( )

Definition at line 61 of file Comm.cpp.

Referenced by Nektar::LibUtilities::SessionReader::CreateComm(), Nektar::FieldUtils::Field::FieldIOForFile(), Import(), main(), Nektar::FieldUtils::InputPts::Process(), Nektar::FieldUtils::OutputInfo::Process(), Nektar::FieldUtils::OutputFld::Process(), Nektar::LibUtilities::MeshPartition::ReadExpansions(), Nektar::Utilities::ProcessCurve::v_GenerateEdgeNodes(), and Write().

62 {
63  typedef Loki::SingletonHolder<CommFactory, Loki::CreateUsingNew,
64  Loki::NoDestroy, Loki::SingleThreaded>
65  Type;
66  return Type::Instance();
67 }
LibUtilities::NekFactory< std::string, Comm, int, char ** > CommFactory
Datatype of the NekFactory used to instantiate classes derived from the EquationSystem class...
Definition: Comm.h:62
FieldIOFactory & Nektar::LibUtilities::GetFieldIOFactory ( )

Returns the FieldIO factory.

Definition at line 74 of file FieldIO.cpp.

Referenced by Nektar::LibUtilities::FieldIO::CreateDefault(), Nektar::LibUtilities::FieldIO::CreateForFile(), Nektar::MultiRegions::ExpList::ExtractFileBCs(), Nektar::FieldUtils::Field::FieldIOForFile(), Import(), Nektar::FieldUtils::OutputInfo::Process(), Nektar::FieldUtils::OutputFld::Process(), Nektar::LibUtilities::MeshPartition::ReadExpansions(), and Write().

75 {
76  typedef Loki::
77  SingletonHolder<FieldIOFactory, Loki::CreateUsingNew, Loki::NoDestroy,
78  Loki::ClassLevelLockable> Type;
79  return Type::Instance();
80 }
LibUtilities::NekFactory< std::string, FieldIO, LibUtilities::CommSharedPtr, bool > FieldIOFactory
Datatype of the NekFactory used to instantiate classes.
Definition: FieldIO.h:197
MeshPartitionFactory & Nektar::LibUtilities::GetMeshPartitionFactory ( )

Definition at line 70 of file MeshPartition.cpp.

Referenced by Nektar::LibUtilities::SessionReader::PartitionMesh(), and Nektar::FieldUtils::OutputInfo::Process().

71  {
72  typedef Loki::SingletonHolder<MeshPartitionFactory,
73  Loki::CreateUsingNew,
74  Loki::NoDestroy,
75  Loki::SingleThreaded> Type;
76  return Type::Instance();
77  }
LibUtilities::NekFactory< std::string, MeshPartition, const SessionReaderSharedPtr & > MeshPartitionFactory
Datatype of the NekFactory used to instantiate classes derived from the EquationSystem class...
Definition: MeshPartition.h:58
NektarFFTFactory & Nektar::LibUtilities::GetNektarFFTFactory ( )

Definition at line 69 of file NektarFFT.cpp.

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

70  {
71  typedef Loki::SingletonHolder<NektarFFTFactory,
72  Loki::CreateUsingNew,
73  Loki::NoDestroy,
74  Loki::ClassLevelLockable> Type;
75  return Type::Instance();
76  }
LibUtilities::NekFactory< std::string, NektarFFT, int > NektarFFTFactory
Datatype of the NekFactory used to instantiate classes derived from the NektarFFT class...
Definition: NektarFFT.h:63
int Nektar::LibUtilities::GetNumberOfCoefficients ( ShapeType  shape,
std::vector< unsigned int > &  modes,
int  offset 
)
inline

Definition at line 312 of file ShapeType.hpp.

References ASSERTL0, eHexahedron, ePrism, ePyramid, eQuadrilateral, eSegment, eTetrahedron, eTriangle, Nektar::LibUtilities::StdTriData::getNumberOfCoefficients(), Nektar::LibUtilities::StdTetData::getNumberOfCoefficients(), Nektar::LibUtilities::StdPyrData::getNumberOfCoefficients(), and Nektar::LibUtilities::StdPrismData::getNumberOfCoefficients().

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

313  {
314  int returnval = 0;
315  switch(shape)
316  {
317  case eSegment:
318  returnval = modes[offset];
319  break;
320  case eTriangle:
321  returnval = StdTriData::getNumberOfCoefficients(modes[offset],modes[offset+1]);
322  break;
323  case eQuadrilateral:
324  returnval = modes[offset]*modes[offset+1];
325  break;
326  case eTetrahedron:
327  returnval = StdTetData::getNumberOfCoefficients(modes[offset],modes[offset+1],modes[offset+2]);
328  break;
329  case ePyramid:
330  returnval = StdPyrData::getNumberOfCoefficients(modes[offset],modes[offset+1],modes[offset+2]);
331  break;
332  case ePrism:
333  returnval = StdPrismData::getNumberOfCoefficients(modes[offset],modes[offset+1],modes[offset+2]);
334  break;
335  case eHexahedron:
336  returnval = modes[offset]*modes[offset+1]*modes[offset+2];
337  break;
338  default:
339  ASSERTL0(false,"Unknown Shape Type");
340  break;
341  }
342 
343  return returnval;
344  }
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:198
int getNumberOfCoefficients(int Na, int Nb, int Nc)
Definition: ShapeType.hpp:286
int Nektar::LibUtilities::GetNumberOfCoefficients ( ShapeType  shape,
int  na,
int  nb,
int  nc 
)
inline

Definition at line 347 of file ShapeType.hpp.

References ASSERTL0, eHexahedron, ePrism, ePyramid, eQuadrilateral, eSegment, eTetrahedron, eTriangle, Nektar::LibUtilities::StdTriData::getNumberOfCoefficients(), Nektar::LibUtilities::StdTetData::getNumberOfCoefficients(), Nektar::LibUtilities::StdPyrData::getNumberOfCoefficients(), and Nektar::LibUtilities::StdPrismData::getNumberOfCoefficients().

348  {
349  int returnval = 0;
350  switch(shape)
351  {
352  case eSegment:
353  returnval = na;
354  break;
355  case eTriangle:
356  returnval = StdTriData::getNumberOfCoefficients(na,nb);
357  break;
358  case eQuadrilateral:
359  returnval = na*nb;
360  break;
361  case eTetrahedron:
362  returnval = StdTetData::getNumberOfCoefficients(na,nb,nc);
363  break;
364  case ePyramid:
365  returnval = StdPyrData::getNumberOfCoefficients(na,nb,nc);
366  break;
367  case ePrism:
368  returnval = StdPrismData::getNumberOfCoefficients(na,nb,nc);
369  break;
370  case eHexahedron:
371  returnval = na*nb*nc;
372  break;
373  default:
374  ASSERTL0(false,"Unknown Shape Type");
375  break;
376  }
377 
378  return returnval;
379  }
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:198
int getNumberOfCoefficients(int Na, int Nb, int Nc)
Definition: ShapeType.hpp:286
TimeIntegrationWrapperFactory & Nektar::LibUtilities::GetTimeIntegrationWrapperFactory ( )

Definition at line 42 of file TimeIntegrationWrapper.cpp.

Referenced by Nektar::UnsteadyAdvectionDiffusion::SetUpSubSteppingTimeIntegration(), Diffusion::TimeIntegrate(), Nektar::SolverUtils::UnsteadySystem::v_InitObject(), and Nektar::SubSteppingExtrapolate::v_SubSteppingTimeIntegration().

43  {
44  typedef Loki::SingletonHolder<TimeIntegrationWrapperFactory,
45  Loki::CreateUsingNew,
46  Loki::NoDestroy,
47  Loki::SingleThreaded> Type;
48  return Type::Instance();
49  }
NekFactory< std::string, TimeIntegrationWrapper > TimeIntegrationWrapperFactory
Datatype of the NekFactory used to instantiate classes derived from the EquationSystem class...
void Nektar::LibUtilities::Import ( const std::string &  infilename,
std::vector< FieldDefinitionsSharedPtr > &  fielddefs,
std::vector< std::vector< NekDouble > > &  fielddata,
FieldMetaDataMap &  fieldinfomap,
const Array< OneD, int > &  ElementIDs 
)

This function allows for data to be imported from an FLD file when a session and/or communicator is not instantiated. Typically used in utilities which only operate in serial.

Parameters
infilenameInput filename (or directory if parallel format)
fielddefsOn return contains field definitions as read from the input.
fielddataOn return, contains binary field data that stores the input corresponding to fielddefs.
fieldinfoOn returnm, contains the associated field metadata map.
ElementIDsElement IDs that lie on this processor, which can be optionally supplied to avoid reading the entire file on each processor.

Definition at line 279 of file FieldIO.cpp.

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

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

285 {
286 #ifdef NEKTAR_USE_MPI
287  int size;
288  int init;
289  MPI_Initialized(&init);
290 
291  // If MPI has been initialised we can check the number of processes
292  // and, if > 1, tell the user he should not be running this
293  // function in parallel. If it is not initialised, we do not
294  // initialise it here, and assume the user knows what they are
295  // doing.
296  if (init)
297  {
298  MPI_Comm_size(MPI_COMM_WORLD, &size);
299  ASSERTL0(size == 1,
300  "This static function is not available in parallel. Please"
301  "instantiate a FieldIO object for parallel use.");
302  }
303 #endif
304  CommSharedPtr c = GetCommFactory().CreateInstance("Serial", 0, 0);
305  const std::string iofmt = FieldIO::GetFileType(infilename, c);
306  FieldIOSharedPtr f = GetFieldIOFactory().CreateInstance(iofmt, c, false);
307  f->Import(infilename, fielddefs, fielddata, fieldinfomap, ElementIDs);
308 }
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:198
tBaseSharedPtr CreateInstance(tKey idKey BOOST_PP_COMMA_IF(MAX_PARAM) BOOST_PP_ENUM_BINARY_PARAMS(MAX_PARAM, tParam, x))
Create an instance of the class referred to by idKey.
Definition: NekFactory.hpp:162
FieldIOFactory & GetFieldIOFactory()
Returns the FieldIO factory.
Definition: FieldIO.cpp:74
CommFactory & GetCommFactory()
Definition: Comm.cpp:61
boost::shared_ptr< Comm > CommSharedPtr
Pointer to a Communicator object.
Definition: Comm.h:55
boost::shared_ptr< FieldIO > FieldIOSharedPtr
Definition: FieldIO.h:309
void Nektar::LibUtilities::Interp1D ( const BasisKey &  fbasis0,
const Array< OneD, const NekDouble > &  from,
const BasisKey &  tbasis0,
Array< OneD, NekDouble > &  to 
)

this function interpolates a 1D function $f$ evaluated at the quadrature points of the basis fbasis0 to the function values at the quadrature points of the basis tbasis0

Given a function $ f$ evaluated at the Q quadrature points of the basis fbasis0, this routine calculates, using (Q-1)th order polynomial interpolation, the function values at the Q2 quadrature points of the basis tbasis0.

Parameters
fbasis0the basis at which's quadrature points the function is given
fromthe array containg the function $ f$ evaluated at the quadrature points of fbasis0
tbasis0the basis to which's quadrature points the function should be interpolated
tothe array containg the function $ f$ evaluated at the quadrature points of tbasis0 (output of the function)

Definition at line 54 of file Interp.cpp.

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

Referenced by Nektar::SpatialDomains::GeomFactors::Interp(), Interp1D(), Nektar::LocalRegions::QuadExp::v_ComputeEdgeNormal(), Nektar::LocalRegions::TriExp::v_ComputeEdgeNormal(), Nektar::LocalRegions::NodalTriExp::v_ComputeEdgeNormal(), Nektar::LocalRegions::SegExp::v_ExtractDataToCoeffs(), Nektar::LocalRegions::TriExp::v_FwdTrans_BndConstrained(), Nektar::LocalRegions::Expansion::v_GetCoords(), Nektar::LocalRegions::QuadExp::v_GetEdgePhysVals(), Nektar::LocalRegions::TriExp::v_GetEdgePhysVals(), and Nektar::MultiRegions::ExpList1D::v_GetNormals().

58  {
59  Interp1D(fbasis0.GetPointsKey(),from,tbasis0.GetPointsKey(),to);
60  }
void Interp1D(const PointsKey &fpoints0, const NekDouble *from, const PointsKey &tpoints0, NekDouble *to)
Definition: Interp.cpp:92
void Nektar::LibUtilities::Interp1D ( const PointsKey &  fpoints0,
const Array< OneD, const NekDouble > &  from,
const PointsKey &  tpoints0,
Array< OneD, NekDouble > &  to 
)

Definition at line 62 of file Interp.cpp.

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

66  {
67  if(fpoints0 == tpoints0) //check to see if the same
68  {
69  Vmath::Vcopy(fpoints0.GetNumPoints(),from,1,to,1);
70  }
71  else // interpolate
72  {
74 
75  I0 = PointsManager()[fpoints0]->GetI(tpoints0);
76 
77  NekVector<NekDouble> in(fpoints0.GetNumPoints(),from,eWrapper);
78  NekVector<NekDouble> out(tpoints0.GetNumPoints(),to,eWrapper);
79 
80  out = (*I0)*in;
81  }
82  }
boost::shared_ptr< DNekMat > DNekMatSharedPtr
Definition: NekTypeDefs.hpp:70
PointsManagerT & PointsManager(void)
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1061
void Nektar::LibUtilities::Interp1D ( const BasisKey &  fbasis0,
const NekDouble *  from,
const BasisKey &  tbasis0,
NekDouble *  to 
)

Definition at line 84 of file Interp.cpp.

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

88  {
89  Interp1D(fbasis0.GetPointsKey(),from,tbasis0.GetPointsKey(),to);
90  }
void Interp1D(const PointsKey &fpoints0, const NekDouble *from, const PointsKey &tpoints0, NekDouble *to)
Definition: Interp.cpp:92
void Nektar::LibUtilities::Interp1D ( const PointsKey &  fpoints0,
const NekDouble *  from,
const PointsKey &  tpoints0,
NekDouble *  to 
)

Definition at line 92 of file Interp.cpp.

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

96  {
97  if(fpoints0 == tpoints0) //check to see if the same
98  {
99  Vmath::Vcopy(fpoints0.GetNumPoints(),from,1,to,1);
100  }
101  else // interpolate
102  {
103 
104  DNekMatSharedPtr I0;
105 
106  I0 = PointsManager()[fpoints0]
107  ->GetI(tpoints0);
108 
109  Blas::Dgemv('N', tpoints0.GetNumPoints(), fpoints0.GetNumPoints(),
110  1.0, I0->GetPtr().get(), tpoints0.GetNumPoints(),
111  from, 1, 0.0, to, 1);
112  }
113  }
boost::shared_ptr< DNekMat > DNekMatSharedPtr
Definition: NekTypeDefs.hpp:70
PointsManagerT & PointsManager(void)
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1061
void Nektar::LibUtilities::Interp2D ( const BasisKey &  fbasis0,
const BasisKey &  fbasis1,
const Array< OneD, const NekDouble > &  from,
const BasisKey &  tbasis0,
const BasisKey &  tbasis1,
Array< OneD, NekDouble > &  to 
)

this function interpolates a 2D function $f$ evaluated at the quadrature points of the 2D basis, constructed by fbasis0 and fbasis1, to the function values at the quadrature points of the 2D basis, constructed by tbasis0 and tbasis1

Given a function $ f$ evaluated at the Q quadrature points of the first expansion basis, this routine calculates, using (Q-1)th order polynomial interpolation, the function values at the Q2 quadrature points of the second basis.

Parameters
fbasis0the basis at which's quadrature points the function is given
fromthe array containg the function $ f$ evaluated at the quadrature points of fbasis0
tbasis0the basis to which's quadrature points the function should be interpolated
tothe array containg the function $ f$ evaluated at the quadrature points of tbasis0 (output of the function)

Definition at line 116 of file Interp.cpp.

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

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

122  {
123  Interp2D(fbasis0.GetPointsKey(),fbasis1.GetPointsKey(),from.data(),
124  tbasis0.GetPointsKey(),tbasis1.GetPointsKey(),to.data());
125  }
void Interp2D(const PointsKey &fpoints0, const PointsKey &fpoints1, const NekDouble *from, const PointsKey &tpoints0, const PointsKey &tpoints1, NekDouble *to)
Definition: Interp.cpp:137
void Nektar::LibUtilities::Interp2D ( const PointsKey &  fpoints0,
const PointsKey &  fpoints1,
const Array< OneD, const NekDouble > &  from,
const PointsKey &  tpoints0,
const PointsKey &  tpoints1,
Array< OneD, NekDouble > &  to 
)

Definition at line 127 of file Interp.cpp.

References Interp2D().

133  {
134  Interp2D(fpoints0,fpoints1,from.data(),tpoints0,tpoints1,to.data());
135  }
void Interp2D(const PointsKey &fpoints0, const PointsKey &fpoints1, const NekDouble *from, const PointsKey &tpoints0, const PointsKey &tpoints1, NekDouble *to)
Definition: Interp.cpp:137
void Nektar::LibUtilities::Interp2D ( const PointsKey &  fpoints0,
const PointsKey &  fpoints1,
const NekDouble *  from,
const PointsKey &  tpoints0,
const PointsKey &  tpoints1,
NekDouble *  to 
)

Definition at line 137 of file Interp.cpp.

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

143  {
144  // default interpolation
145  if((fpoints0 == tpoints0)&&(fpoints1 == tpoints1))
146  {
147  Vmath::Vcopy(tpoints0.GetNumPoints()*tpoints1.GetNumPoints(),
148  from,1,to,1);
149  return;
150  }
151 
152  DNekMatSharedPtr I0,I1;
153  Array<OneD, NekDouble> wsp(tpoints1.GetNumPoints()*fpoints0.GetNumPoints()); // fnp0*tnp1
154 
155  int fnp0 = fpoints0.GetNumPoints();
156  int fnp1 = fpoints1.GetNumPoints();
157  int tnp0 = tpoints0.GetNumPoints();
158  int tnp1 = tpoints1.GetNumPoints();
159 
160  if(fpoints1 == tpoints1)
161  {
162  Vmath::Vcopy(fnp0*tnp1,from,1,wsp.get(),1);
163  }
164  else
165  {
166  I1 = PointsManager()[fpoints1]->GetI(tpoints1);
167  Blas::Dgemm('N', 'T', fnp0, tnp1, fnp1, 1.0, from, fnp0,
168  I1->GetPtr().get(), tnp1, 0.0, wsp.get(), fnp0);
169  }
170 
171  if(fpoints0 == tpoints0)
172  {
173  Vmath::Vcopy(tnp0*tnp1,wsp.get(),1,to,1);
174  }
175  else
176  {
177  I0 = PointsManager()[fpoints0]->GetI(tpoints0);
178  Blas::Dgemm('N', 'N', tnp0, tnp1, fnp0, 1.0, I0->GetPtr().get(),
179  tnp0, wsp.get(), fnp0, 0.0, to, tnp0);
180  }
181  }
boost::shared_ptr< DNekMat > DNekMatSharedPtr
Definition: NekTypeDefs.hpp:70
PointsManagerT & PointsManager(void)
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1061
void Nektar::LibUtilities::Interp3D ( const BasisKey &  fbasis0,
const BasisKey &  fbasis1,
const BasisKey &  fbasis2,
const Array< OneD, const NekDouble > &  from,
const BasisKey &  tbasis0,
const BasisKey &  tbasis1,
const BasisKey &  tbasis2,
Array< OneD, NekDouble > &  to 
)

this function interpolates a 3D function $f$ evaluated at the quadrature points of the 3D basis, constructed by fbasis0, fbasis1, and fbasis2 to the function values at the quadrature points of the 3D basis, constructed by tbasis0, tbasis1, and tbasis2.

Given a function $ f$ evaluated at the Q quadrature points of the first expansion basis, this routine calculates, using (Q-1)th order polynomial interpolation, the function values at the Q2 quadrature points of the second basis, and the function values at the Q3 quadrature points of the third basis.

Parameters
fbasis0the basis at which's quadrature points the function is given
fromthe array containg the function $ f$ evaluated at the quadrature points of fbasis0
tbasis0the basis to which's quadrature points the function should be interpolated
tothe array containg the function $ f$ evaluated at the quadrature points of tbasis0 (output of the function)

Definition at line 186 of file Interp.cpp.

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

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

194  {
195  Interp3D(fbasis0.GetPointsKey(),fbasis1.GetPointsKey(),
196  fbasis2.GetPointsKey(),from.data(),
197  tbasis0.GetPointsKey(),tbasis1.GetPointsKey(),
198  tbasis2.GetPointsKey(),to.data());
199  }
void Interp3D(const PointsKey &fpoints0, const PointsKey &fpoints1, const PointsKey &fpoints2, const NekDouble *from, const PointsKey &tpoints0, const PointsKey &tpoints1, const PointsKey &tpoints2, NekDouble *to)
Definition: Interp.cpp:215
void Nektar::LibUtilities::Interp3D ( const PointsKey &  fpoints0,
const PointsKey &  fpoints1,
const PointsKey &  fpoints2,
const Array< OneD, const NekDouble > &  from,
const PointsKey &  tpoints0,
const PointsKey &  tpoints1,
const PointsKey &  tpoints2,
Array< OneD, NekDouble > &  to 
)

Definition at line 202 of file Interp.cpp.

References Interp3D().

210  {
211  Interp3D(fpoints0,fpoints1,fpoints2,from.data(),
212  tpoints0,tpoints1,tpoints2,to.data());
213  }
void Interp3D(const PointsKey &fpoints0, const PointsKey &fpoints1, const PointsKey &fpoints2, const NekDouble *from, const PointsKey &tpoints0, const PointsKey &tpoints1, const PointsKey &tpoints2, NekDouble *to)
Definition: Interp.cpp:215
void Nektar::LibUtilities::Interp3D ( const PointsKey &  fpoints0,
const PointsKey &  fpoints1,
const PointsKey &  fpoints2,
const NekDouble *  from,
const PointsKey &  tpoints0,
const PointsKey &  tpoints1,
const PointsKey &  tpoints2,
NekDouble *  to 
)

Definition at line 215 of file Interp.cpp.

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

223  {
224  int i;
225  DNekMatSharedPtr I0, I1, I2;
226 
227  int fnp0 = fpoints0.GetNumPoints();
228  int fnp1 = fpoints1.GetNumPoints();
229  int fnp2 = fpoints2.GetNumPoints();
230  int tnp0 = tpoints0.GetNumPoints();
231  int tnp1 = tpoints1.GetNumPoints();
232  int tnp2 = tpoints2.GetNumPoints();
233 
234  Array<OneD, NekDouble> wsp1(tnp0*tnp1*fnp2);
235  Array<OneD, NekDouble> wsp2(tnp0*fnp1*fnp2);
236 
237  I0 = PointsManager()[fpoints0]->GetI(tpoints0);
238  I1 = PointsManager()[fpoints1]->GetI(tpoints1);
239  I2 = PointsManager()[fpoints2]->GetI(tpoints2);
240 
241  Blas::Dgemm('N', 'N', tnp0, fnp1*fnp2, fnp0, 1.0, I0->GetPtr().get(),
242  tnp0, from, fnp0, 0.0, wsp2.get(), tnp0);
243 
244  for(i = 0; i < fnp2; i++)
245  {
246  Blas::Dgemm('N', 'T', tnp0, tnp1, fnp1, 1.0, wsp2.get()+i*tnp0*fnp1,
247  tnp0, I1->GetPtr().get(), tnp1, 0.0, wsp1.get()+i*tnp0*tnp1, tnp0);
248  }
249 
250  Blas::Dgemm('N', 'T', tnp0*tnp1, tnp2, fnp2, 1.0, wsp1.get(),
251  tnp0*tnp1, I2->GetPtr().get(), tnp2, 0.0, to, tnp0*tnp1);
252  }
boost::shared_ptr< DNekMat > DNekMatSharedPtr
Definition: NekTypeDefs.hpp:70
PointsManagerT & PointsManager(void)
void Nektar::LibUtilities::InterpCoeff1D ( const BasisKey &  fbasis0,
const Array< OneD, const NekDouble > &  from,
const BasisKey &  tbasis0,
Array< OneD, NekDouble > &  to 
)

Definition at line 47 of file InterpCoeff.cpp.

References ASSERTL0, BasisManager(), Nektar::eWrapper, Nektar::LibUtilities::BasisKey::GetBasisType(), Nektar::LibUtilities::BasisKey::GetNumModes(), and Vmath::Vcopy().

Referenced by Nektar::LocalRegions::Expansion2D::v_AddEdgeNormBoundaryInt(), Nektar::StdRegions::StdSegExp::v_ReduceOrderCoeffs(), and Nektar::SolverUtils::FilterEnergy1D::v_Update().

51  {
52  ASSERTL0(fbasis0.GetNumModes() == tbasis0.GetNumModes(),
53  "Number of modes must be the same for "
54  "interpolating coefficients");
55 
56  // Check to see if the same basis
57  if (fbasis0.GetBasisType() == tbasis0.GetBasisType())
58  {
59  Vmath::Vcopy(fbasis0.GetNumModes(), from, 1, to, 1);
60  }
61  else
62  {
63  // interpolate
64  DNekMatSharedPtr ftB = BasisManager()[fbasis0]->GetI(tbasis0);
65 
66  NekVector<NekDouble> in (fbasis0.GetNumModes(), from, eWrapper);
67  NekVector<NekDouble> out(tbasis0.GetNumModes(), to, eWrapper);
68 
69  out = (*ftB)*in;
70  }
71  }
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:198
boost::shared_ptr< DNekMat > DNekMatSharedPtr
Definition: NekTypeDefs.hpp:70
BasisManagerT & BasisManager(void)
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1061
void Nektar::LibUtilities::InterpCoeff2D ( const BasisKey &  fbasis0,
const BasisKey &  fbasis1,
const Array< OneD, const NekDouble > &  from,
const BasisKey &  tbasis0,
const BasisKey &  tbasis1,
Array< OneD, NekDouble > &  to 
)

Definition at line 73 of file InterpCoeff.cpp.

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

79  {
80  InterpCoeff2D(fbasis0, fbasis1, from.data(),
81  tbasis0, tbasis1, to. data());
82  }
void InterpCoeff2D(const BasisKey &fbasis0, const BasisKey &fbasis1, const NekDouble *from, const BasisKey &tbasis0, const BasisKey &tbasis1, NekDouble *to)
Definition: InterpCoeff.cpp:84
void Nektar::LibUtilities::InterpCoeff2D ( const BasisKey &  fbasis0,
const BasisKey &  fbasis1,
const NekDouble *  from,
const BasisKey &  tbasis0,
const BasisKey &  tbasis1,
NekDouble *  to 
)

Definition at line 84 of file InterpCoeff.cpp.

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

90  {
91  const int fnm0 = fbasis0.GetNumModes();
92  const int fnm1 = fbasis1.GetNumModes();
93  const int tnm0 = tbasis0.GetNumModes();
94  const int tnm1 = tbasis1.GetNumModes();
95 
96  Array<OneD, NekDouble> wsp(tnm1 * fnm0);
97 
98  if (fbasis1.GetBasisType() == tbasis1.GetBasisType())
99  {
100  Vmath::Vcopy(fnm0*tnm1, from, 1, wsp.get(), 1);
101  }
102  else
103  {
104  // interpolate
105  DNekMatSharedPtr ft1 = BasisManager()[fbasis1]->GetI(tbasis1);
106 
107  Blas::Dgemm('N', 'T', fnm0, tnm1, fnm1, 1.0, from, fnm0,
108  ft1->GetPtr().get(), tnm1, 0.0, wsp.get(), fnm0);
109  }
110 
111  if (fbasis0.GetBasisType() == tbasis0.GetBasisType())
112  {
113  Vmath::Vcopy(tnm0*tnm1, wsp.get(), 1, to, 1);
114  }
115  else
116  {
117  // interpolate
118  DNekMatSharedPtr ft0 = BasisManager()[fbasis0]->GetI(tbasis0);
119 
120  Blas::Dgemm('N', 'N', tnm0, tnm1, fnm0, 1.0, ft0->GetPtr().get(),
121  tnm0, wsp.get(), fnm0, 0.0, to, tnm0);
122  }
123  }
boost::shared_ptr< DNekMat > DNekMatSharedPtr
Definition: NekTypeDefs.hpp:70
BasisManagerT & BasisManager(void)
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1061
void Nektar::LibUtilities::InterpCoeff3D ( const BasisKey &  fbasis0,
const BasisKey &  fbasis1,
const BasisKey &  fbasis2,
const Array< OneD, const NekDouble > &  from,
const BasisKey &  tbasis0,
const BasisKey &  tbasis1,
const BasisKey &  tbasis2,
Array< OneD, NekDouble > &  to 
)

Definition at line 125 of file InterpCoeff.cpp.

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

133  {
134  InterpCoeff3D(fbasis0, fbasis1, fbasis2, from.data(),
135  tbasis0, tbasis1, tbasis2, to. data());
136  }
void InterpCoeff3D(const BasisKey &fbasis0, const BasisKey &fbasis1, const BasisKey &fbasis2, const NekDouble *from, const BasisKey &tbasis0, const BasisKey &tbasis1, const BasisKey &tbasis2, NekDouble *to)
void Nektar::LibUtilities::InterpCoeff3D ( const BasisKey &  fbasis0,
const BasisKey &  fbasis1,
const BasisKey &  fbasis2,
const NekDouble *  from,
const BasisKey &  tbasis0,
const BasisKey &  tbasis1,
const BasisKey &  tbasis2,
NekDouble *  to 
)

Definition at line 138 of file InterpCoeff.cpp.

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

146  {
147  const int fnm0 = fbasis0.GetNumModes();
148  const int fnm1 = fbasis1.GetNumModes();
149  const int fnm2 = fbasis2.GetNumModes();
150  const int tnm0 = tbasis0.GetNumModes();
151  const int tnm1 = tbasis1.GetNumModes();
152  const int tnm2 = tbasis2.GetNumModes();
153 
154  Array<OneD, NekDouble> wsp1(tnm0 * tnm1 * fnm2);
155  Array<OneD, NekDouble> wsp2(tnm0 * fnm1 * fnm2);
156 
157  DNekMatSharedPtr ft0 = BasisManager()[fbasis0]->GetI(tbasis0);
158  DNekMatSharedPtr ft1 = BasisManager()[fbasis1]->GetI(tbasis1);
159  DNekMatSharedPtr ft2 = BasisManager()[fbasis2]->GetI(tbasis2);
160 
161  Blas::Dgemm('N', 'N', tnm0, fnm1*fnm2, fnm0, 1.0,
162  ft0->GetPtr().get(), tnm0, from, fnm0, 0.0,
163  wsp2.get(), tnm0);
164 
165  for (int i = 0; i < fnm2; i++)
166  {
167  Blas::Dgemm('N', 'T', tnm0, tnm1, fnm1, 1.0,
168  wsp2.get()+i*tnm0*fnm1, tnm0, ft1->GetPtr().get(),
169  tnm1, 0.0, wsp1.get()+i*tnm0*tnm1, tnm0);
170  }
171 
172  Blas::Dgemm('N', 'T', tnm0*tnm1, tnm2, fnm2, 1.0, wsp1.get(),
173  tnm0*tnm1, ft2->GetPtr().get(), tnm2,
174  0.0, to, tnm0*tnm1);
175  }
boost::shared_ptr< DNekMat > DNekMatSharedPtr
Definition: NekTypeDefs.hpp:70
BasisManagerT & BasisManager(void)
static const BasisKey Nektar::LibUtilities::NullBasisKey ( eNoBasisType  ,
,
NullPointsKey   
)
static
static const PointsKey Nektar::LibUtilities::NullPointsKey ( ,
eNoPointsType   
)
static
static const TimeIntegrationSchemeKey Nektar::LibUtilities::NullTimeIntegrationSchemeKey ( eNoTimeIntegrationMethod  )
static
bool Nektar::LibUtilities::operator!= ( const GraphVertexObject &  x,
const GraphVertexObject &  y 
)

Definition at line 76 of file Graph.cpp.

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

77  {
78  return (x.m_id != y.m_id);
79  }
bool Nektar::LibUtilities::operator!= ( const BasisKey &  x,
const BasisKey &  y 
)

Definition at line 723 of file Basis.cpp.

724  {
725  return (!(x == y));
726  }
bool Nektar::LibUtilities::operator!= ( const BasisKey *  x,
const BasisKey &  y 
)

Definition at line 729 of file Basis.cpp.

730  {
731  return (!(*x == y));
732  }
bool Nektar::LibUtilities::operator!= ( const BasisKey &  x,
const BasisKey *  y 
)

Definition at line 735 of file Basis.cpp.

736  {
737  return (!(x == *y));
738  }
bool Nektar::LibUtilities::operator< ( const BasisKey &  lhs,
const BasisKey &  rhs 
)

Definition at line 49 of file Basis.cpp.

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

50  {
51  PointsKey lhsPointsKey = lhs.GetPointsKey();
52  PointsKey rhsPointsKey = rhs.GetPointsKey();
53 
54  if (lhsPointsKey < rhsPointsKey)
55  {
56  return true;
57  }
58  if (lhsPointsKey != rhsPointsKey)
59  {
60  return false;
61  }
62 
63  if (lhs.m_nummodes < rhs.m_nummodes)
64  {
65  return true;
66  }
67  if (lhs.m_nummodes > rhs.m_nummodes)
68  {
69  return false;
70  }
71 
72  return (lhs.m_basistype < rhs.m_basistype);
73  }
StandardMatrixTag & lhs
bool Nektar::LibUtilities::operator< ( const PointsKey &  lhs,
const PointsKey &  rhs 
)

Definition at line 55 of file Points.cpp.

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

56  {
57  if (lhs.m_pointstype < rhs.m_pointstype)
58  {
59  return true;
60  }
61 
62  if (lhs.m_pointstype > rhs.m_pointstype)
63  {
64  return false;
65  }
66 
67  if (lhs.m_numpoints < rhs.m_numpoints)
68  {
69  return true;
70  }
71 
72  if (lhs.m_numpoints > rhs.m_numpoints)
73  {
74  return false;
75  }
76 
77  if(lhs.m_factor < rhs.m_factor)
78  {
79  return true;
80  }
81 
82  if(lhs.m_factor > rhs.m_factor)
83  {
84  return true;
85  }
86 
87  return false;
88  }
StandardMatrixTag & lhs
bool Nektar::LibUtilities::operator< ( const TimeIntegrationSchemeKey &  lhs,
const TimeIntegrationSchemeKey &  rhs 
)

Definition at line 58 of file TimeIntegrationScheme.cpp.

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

59  {
60  return (lhs.m_method < rhs.m_method);
61  }
StandardMatrixTag & lhs
std::ostream & Nektar::LibUtilities::operator<< ( std::ostream &  os,
const TimeIntegrationSchemeKey &  rhs 
)

Definition at line 68 of file TimeIntegrationScheme.cpp.

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

69  {
70  os << "Time Integration Scheme: " << TimeIntegrationMethodMap[rhs.GetIntegrationMethod()] << endl;
71 
72  return os;
73  }
const char *const TimeIntegrationMethodMap[]
std::ostream & Nektar::LibUtilities::operator<< ( std::ostream &  os,
const BasisKey &  rhs 
)

Definition at line 85 of file Basis.cpp.

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

Referenced by operator<<().

86  {
87  os << "NumModes: " << rhs.GetNumModes() << " BasisType: " << BasisTypeMap[rhs.GetBasisType()];
88  os << " " << rhs.GetPointsKey() << std::endl;
89 
90  return os;
91  }
const char *const BasisTypeMap[]
Definition: Foundations.hpp:47
std::ostream & Nektar::LibUtilities::operator<< ( std::ostream &  os,
const PointsKey &  rhs 
)

Definition at line 95 of file Points.cpp.

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

96  {
97  os << "NumPoints: " << rhs.GetNumPoints() << " PointsType: " << kPointsTypeStr[rhs.GetPointsType()] << std::endl;
98 
99  return os;
100  }
const std::string kPointsTypeStr[]
Definition: Foundations.hpp:69
std::ostream & Nektar::LibUtilities::operator<< ( std::ostream &  os,
const TimeIntegrationSchemeSharedPtr &  rhs 
)

Definition at line 1779 of file TimeIntegrationScheme.cpp.

References operator<<().

1780  {
1781  return operator<<(os,*rhs);
1782  }
std::ostream & operator<<(std::ostream &os, const TimeIntegrationScheme &rhs)
std::ostream & Nektar::LibUtilities::operator<< ( std::ostream &  os,
const TimeIntegrationScheme &  rhs 
)

Definition at line 1784 of file TimeIntegrationScheme.cpp.

References Nektar::LibUtilities::TimeIntegrationScheme::A(), Nektar::LibUtilities::TimeIntegrationScheme::A_IMEX(), Nektar::LibUtilities::TimeIntegrationScheme::B(), Nektar::LibUtilities::TimeIntegrationScheme::B_IMEX(), eIMEX, Nektar::LibUtilities::TimeIntegrationScheme::GetIntegrationMethod(), Nektar::LibUtilities::TimeIntegrationScheme::GetIntegrationSchemeType(), Nektar::LibUtilities::TimeIntegrationScheme::GetNstages(), Nektar::LibUtilities::TimeIntegrationScheme::GetNsteps(), TimeIntegrationMethodMap, TimeIntegrationSchemeTypeMap, Nektar::LibUtilities::TimeIntegrationScheme::U(), and Nektar::LibUtilities::TimeIntegrationScheme::V().

1785  {
1786  int i,j;
1787  int r = rhs.GetNsteps();
1788  int s = rhs.GetNstages();
1789  TimeIntegrationSchemeType type = rhs.GetIntegrationSchemeType();
1790 
1791  int oswidth = 9;
1792  int osprecision = 6;
1793 
1794  os << "Time Integration Scheme: " << TimeIntegrationMethodMap[rhs.GetIntegrationMethod()] << endl;
1795  os << "- number of steps: " << r << endl;
1796  os << "- number of stages: " << s << endl;
1797  os << "- type of scheme: " << TimeIntegrationSchemeTypeMap[rhs.GetIntegrationSchemeType()] << endl;
1798  os << "General linear method tableau: " << endl;
1799 
1800  for(i = 0; i < s; i++)
1801  {
1802  for(j = 0; j < s; j++)
1803  {
1804  os.width(oswidth);
1805  os.precision(osprecision);
1806  os << right << rhs.A(i,j) << " ";
1807  }
1808  if(type == eIMEX)
1809  {
1810  os << " '";
1811  for(j = 0; j < s; j++)
1812  {
1813  os.width(oswidth);
1814  os.precision(osprecision);
1815  os << right << rhs.A_IMEX(i,j) << " ";
1816  }
1817  }
1818  os << " |";
1819 
1820  for(j = 0; j < r; j++)
1821  {
1822  os.width(oswidth);
1823  os.precision(osprecision);
1824  os << right << rhs.U(i,j);
1825  }
1826  os << endl;
1827  }
1828  int imexflag = (type == eIMEX)?2:1;
1829  for(int i = 0; i < (r+imexflag*s)*(oswidth+1)+imexflag*2-1; i++)
1830  {
1831  os << "-";
1832  }
1833  os << endl;
1834  for(i = 0; i < r; i++)
1835  {
1836  for(j = 0; j < s; j++)
1837  {
1838  os.width(oswidth);
1839  os.precision(osprecision);
1840  os << right << rhs.B(i,j) << " ";
1841  }
1842  if(type == eIMEX)
1843  {
1844  os << " '";
1845  for(j = 0; j < s; j++)
1846  {
1847  os.width(oswidth);
1848  os.precision(osprecision);
1849  os << right << rhs.B_IMEX(i,j) << " ";
1850  }
1851  }
1852  os << " |";
1853 
1854  for(j = 0; j < r; j++)
1855  {
1856  os.width(oswidth);
1857  os.precision(osprecision);
1858  os << right << rhs.V(i,j);
1859  }
1860  os << endl;
1861  }
1862  return os;
1863  }
const char *const TimeIntegrationSchemeTypeMap[]
Implicit Explicit General Linear Method.
const char *const TimeIntegrationMethodMap[]
bool Nektar::LibUtilities::operator== ( const PointsKey &  lhs,
const PointsKey &  rhs 
)

Definition at line 49 of file Points.cpp.

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

50  {
51  return (lhs.m_numpoints == rhs.m_numpoints &&
52  lhs.m_pointstype == rhs.m_pointstype);
53  }
StandardMatrixTag & lhs
bool Nektar::LibUtilities::operator== ( const TimeIntegrationSchemeKey &  lhs,
const TimeIntegrationSchemeKey &  rhs 
)

Definition at line 53 of file TimeIntegrationScheme.cpp.

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

54  {
55  return (lhs.m_method == rhs.m_method);
56  }
StandardMatrixTag & lhs
bool Nektar::LibUtilities::operator== ( const GraphVertexObject &  x,
const GraphVertexObject &  y 
)

Definition at line 71 of file Graph.cpp.

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

72  {
73  return (x.m_id == y.m_id);
74  }
bool Nektar::LibUtilities::operator== ( const BasisKey &  x,
const BasisKey &  y 
)

Definition at line 703 of file Basis.cpp.

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

704  {
705  return (x.GetPointsKey() == y.GetPointsKey() &&
706  x.m_basistype == y.m_basistype &&
707  x.GetNumModes() == y.GetNumModes());
708  }
bool Nektar::LibUtilities::operator== ( const BasisKey *  x,
const BasisKey &  y 
)

Definition at line 711 of file Basis.cpp.

712  {
713  return (*x == y);
714  }
bool Nektar::LibUtilities::operator== ( const BasisKey &  x,
const BasisKey *  y 
)

Definition at line 717 of file Basis.cpp.

718  {
719  return (x == *y);
720  }
bool Nektar::LibUtilities::operator> ( const BasisKey &  lhs,
const BasisKey &  rhs 
)

Definition at line 75 of file Basis.cpp.

76  {
77  return (rhs < lhs);
78  }
StandardMatrixTag & lhs
void Nektar::LibUtilities::PhysGalerkinProject1D ( const BasisKey &  fbasis0,
const Array< OneD, const NekDouble > &  from,
const BasisKey &  tbasis0,
Array< OneD, NekDouble > &  to 
)

Definition at line 53 of file PhysGalerkinProject.cpp.

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

Referenced by PhysGalerkinProject1D().

57  {
58  PhysGalerkinProject1D(fbasis0.GetPointsKey(),from,tbasis0.GetPointsKey(),to);
59  }
void PhysGalerkinProject1D(const PointsKey &fpoints0, const NekDouble *from, const PointsKey &tpoints0, NekDouble *to)
void Nektar::LibUtilities::PhysGalerkinProject1D ( const PointsKey &  fpoints0,
const Array< OneD, const NekDouble > &  from,
const PointsKey &  tpoints0,
Array< OneD, NekDouble > &  to 
)

Definition at line 61 of file PhysGalerkinProject.cpp.

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

65  {
66  if(fpoints0 == tpoints0) //check to see if the same
67  {
68  Vmath::Vcopy(fpoints0.GetNumPoints(),from,1,to,1);
69  }
70  else // interpolate
71  {
72  DNekMatSharedPtr GP0;
73 
74  GP0 = PointsManager()[tpoints0]->GetGalerkinProjection(fpoints0);
75 
76  NekVector<NekDouble> in(fpoints0.GetNumPoints(),from,eWrapper);
77  NekVector<NekDouble> out(tpoints0.GetNumPoints(),to,eWrapper);
78 
79  GP0->Transpose();
80  out = (*GP0)*in;
81  }
82  }
boost::shared_ptr< DNekMat > DNekMatSharedPtr
Definition: NekTypeDefs.hpp:70
PointsManagerT & PointsManager(void)
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1061
void Nektar::LibUtilities::PhysGalerkinProject1D ( const BasisKey &  fbasis0,
const NekDouble *  from,
const BasisKey &  tbasis0,
NekDouble *  to 
)

Definition at line 84 of file PhysGalerkinProject.cpp.

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

88  {
89  PhysGalerkinProject1D(fbasis0.GetPointsKey(),from,tbasis0.GetPointsKey(),to);
90  }
void PhysGalerkinProject1D(const PointsKey &fpoints0, const NekDouble *from, const PointsKey &tpoints0, NekDouble *to)
void Nektar::LibUtilities::PhysGalerkinProject1D ( const PointsKey &  fpoints0,
const NekDouble *  from,
const PointsKey &  tpoints0,
NekDouble *  to 
)

Definition at line 92 of file PhysGalerkinProject.cpp.

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

96  {
97  if(fpoints0 == tpoints0) //check to see if the same
98  {
99  Vmath::Vcopy(fpoints0.GetNumPoints(),from,1,to,1);
100  }
101  else // interpolate
102  {
103 
104  DNekMatSharedPtr GP0;
105 
106  GP0 = PointsManager()[tpoints0]
107  ->GetGalerkinProjection(fpoints0);
108 
109  Blas::Dgemv('T', tpoints0.GetNumPoints(), fpoints0.GetNumPoints(),
110  1.0, GP0->GetPtr().get(), tpoints0.GetNumPoints(),
111  from, 1, 0.0, to, 1);
112  }
113  }
boost::shared_ptr< DNekMat > DNekMatSharedPtr
Definition: NekTypeDefs.hpp:70
PointsManagerT & PointsManager(void)
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1061
void Nektar::LibUtilities::PhysGalerkinProject2D ( const BasisKey &  fbasis0,
const BasisKey &  fbasis1,
const Array< OneD, const NekDouble > &  from,
const BasisKey &  tbasis0,
const BasisKey &  tbasis1,
Array< OneD, NekDouble > &  to 
)

Definition at line 116 of file PhysGalerkinProject.cpp.

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

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

122  {
123  PhysGalerkinProject2D(fbasis0.GetPointsKey(),fbasis1.GetPointsKey(),from.data(),
124  tbasis0.GetPointsKey(),tbasis1.GetPointsKey(),to.data());
125  }
void PhysGalerkinProject2D(const PointsKey &fpoints0, const PointsKey &fpoints1, const NekDouble *from, const PointsKey &tpoints0, const PointsKey &tpoints1, NekDouble *to)
void Nektar::LibUtilities::PhysGalerkinProject2D ( const PointsKey &  fpoints0,
const PointsKey &  fpoints1,
const Array< OneD, const NekDouble > &  from,
const PointsKey &  tpoints0,
const PointsKey &  tpoints1,
Array< OneD, NekDouble > &  to 
)

Definition at line 127 of file PhysGalerkinProject.cpp.

References PhysGalerkinProject2D().

133  {
134  PhysGalerkinProject2D(fpoints0,fpoints1,from.data(),tpoints0,tpoints1,to.data());
135  }
void PhysGalerkinProject2D(const PointsKey &fpoints0, const PointsKey &fpoints1, const NekDouble *from, const PointsKey &tpoints0, const PointsKey &tpoints1, NekDouble *to)
void Nektar::LibUtilities::PhysGalerkinProject2D ( const PointsKey &  fpoints0,
const PointsKey &  fpoints1,
const NekDouble *  from,
const PointsKey &  tpoints0,
const PointsKey &  tpoints1,
NekDouble *  to 
)

Definition at line 137 of file PhysGalerkinProject.cpp.

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

143  {
144  DNekMatSharedPtr GP0,GP1;
145  Array<OneD, NekDouble> wsp(tpoints1.GetNumPoints()*fpoints0.GetNumPoints()); // fnp0*tnp1
146 
147  int fnp0 = fpoints0.GetNumPoints();
148  int fnp1 = fpoints1.GetNumPoints();
149  int tnp0 = tpoints0.GetNumPoints();
150  int tnp1 = tpoints1.GetNumPoints();
151 
152  if(fpoints1 == tpoints1)
153  {
154  Vmath::Vcopy(fnp0*tnp1,from,1,wsp.get(),1);
155  }
156  else
157  {
158  GP1 = PointsManager()[tpoints1]->GetGalerkinProjection(fpoints1);
159  Blas::Dgemm('N', 'T', fnp0, tnp1, fnp1, 1.0, from, fnp0,
160  GP1->GetPtr().get(), tnp1, 0.0, wsp.get(), fnp0);
161  }
162 
163  if(fpoints0 == tpoints0)
164  {
165  Vmath::Vcopy(tnp0*tnp1,wsp.get(),1,to,1);
166  }
167  else
168  {
169  GP0 = PointsManager()[tpoints0]->GetGalerkinProjection(fpoints0);
170  Blas::Dgemm('N', 'N', tnp0, tnp1, fnp0, 1.0,
171  GP0->GetPtr().get(),
172  tnp0, wsp.get(), fnp0, 0.0, to, tnp0);
173  }
174  }
boost::shared_ptr< DNekMat > DNekMatSharedPtr
Definition: NekTypeDefs.hpp:70
PointsManagerT & PointsManager(void)
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1061
void Nektar::LibUtilities::PhysGalerkinProject3D ( const BasisKey &  fbasis0,
const BasisKey &  fbasis1,
const BasisKey &  fbasis2,
const Array< OneD, const NekDouble > &  from,
const BasisKey &  tbasis0,
const BasisKey &  tbasis1,
const BasisKey &  tbasis2,
Array< OneD, NekDouble > &  to 
)

Definition at line 178 of file PhysGalerkinProject.cpp.

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

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

186  {
187  PhysGalerkinProject3D(fbasis0.GetPointsKey(),
188  fbasis1.GetPointsKey(),
189  fbasis2.GetPointsKey(),
190  from.data(),
191  tbasis0.GetPointsKey(),
192  tbasis1.GetPointsKey(),
193  tbasis2.GetPointsKey(),
194  to.data());
195  }
void PhysGalerkinProject3D(const PointsKey &fpoints0, const PointsKey &fpoints1, const PointsKey &fpoints2, const NekDouble *from, const PointsKey &tpoints0, const PointsKey &tpoints1, const PointsKey &tpoints2, NekDouble *to)
void Nektar::LibUtilities::PhysGalerkinProject3D ( const PointsKey &  fpoints0,
const PointsKey &  fpoints1,
const PointsKey &  fpoints2,
const Array< OneD, const NekDouble > &  from,
const PointsKey &  tpoints0,
const PointsKey &  tpoints1,
const PointsKey &  tpoints2,
Array< OneD, NekDouble > &  to 
)

Definition at line 197 of file PhysGalerkinProject.cpp.

References PhysGalerkinProject3D().

205  {
206  PhysGalerkinProject3D(fpoints0,fpoints1,fpoints2,from.data(),
207  tpoints0,tpoints1,tpoints2,to.data());
208  }
void PhysGalerkinProject3D(const PointsKey &fpoints0, const PointsKey &fpoints1, const PointsKey &fpoints2, const NekDouble *from, const PointsKey &tpoints0, const PointsKey &tpoints1, const PointsKey &tpoints2, NekDouble *to)
void Nektar::LibUtilities::PhysGalerkinProject3D ( const PointsKey &  fpoints0,
const PointsKey &  fpoints1,
const PointsKey &  fpoints2,
const NekDouble *  from,
const PointsKey &  tpoints0,
const PointsKey &  tpoints1,
const PointsKey &  tpoints2,
NekDouble *  to 
)

Definition at line 210 of file PhysGalerkinProject.cpp.

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

218  {
219  DNekMatSharedPtr GP0,GP1,GP2;
220 
221  int fnp0 = fpoints0.GetNumPoints();
222  int fnp1 = fpoints1.GetNumPoints();
223  int fnp2 = fpoints2.GetNumPoints();
224  int tnp0 = tpoints0.GetNumPoints();
225  int tnp1 = tpoints1.GetNumPoints();
226  int tnp2 = tpoints2.GetNumPoints();
227 
228  Array<OneD, NekDouble> wsp1(fnp0*tnp1*tnp2);
229  Array<OneD, NekDouble> wsp2(fnp0*fnp1*tnp2);
230 
231  GP2 = PointsManager()[tpoints2]->GetGalerkinProjection(fpoints2);
232  Blas::Dgemm('N', 'T', fnp0*fnp1, tnp2, fnp2, 1.0, from, fnp0*fnp1,
233  GP2->GetPtr().get(), tnp2, 0.0, wsp2.get(), fnp0*fnp1);
234 
235  GP1 = PointsManager()[tpoints1]->GetGalerkinProjection(fpoints1);
236  for(int i = 0; i < tnp2; i++)
237  {
238  Blas::Dgemm('N', 'T', fnp0, tnp1, fnp1, 1.0,
239  wsp2.get()+i*fnp0*fnp1,
240  fnp0, GP1->GetPtr().get(),tnp1, 0.0,
241  wsp1.get()+i*fnp0*tnp1,
242  fnp0);
243  }
244 
245  GP0 = PointsManager()[tpoints0]->GetGalerkinProjection(fpoints0);
246  Blas::Dgemm('N', 'N', tnp0, tnp1*tnp2, fnp0, 1.0,
247  GP0->GetPtr().get(), tnp0, wsp1.get(), fnp0, 0.0,
248  to, tnp0);
249  }
boost::shared_ptr< DNekMat > DNekMatSharedPtr
Definition: NekTypeDefs.hpp:70
PointsManagerT & PointsManager(void)
PointsManagerT & Nektar::LibUtilities::PointsManager ( void  )

Definition at line 110 of file ManagerAccess.cpp.

Referenced by Nektar::Utilities::ProcessBL::BoundaryLayer2D(), Nektar::Utilities::ProcessBL::BoundaryLayer3D(), Nektar::Utilities::ProcessVarOpti::BuildDerivUtil(), Nektar::LibUtilities::GaussPoints::CalculateGalerkinProjectionMatrix(), Nektar::LibUtilities::NodalPrismSPI::CalculatePoints(), Nektar::LibUtilities::NodalHexElec::CalculatePoints(), Nektar::LibUtilities::NodalQuadElec::CalculatePoints(), Nektar::LibUtilities::NodalPrismElec::CalculatePoints(), Nektar::LibUtilities::PolyEPoints::CalculateWeights(), Nektar::LibUtilities::BLPoints::CreateMatrix(), Nektar::LibUtilities::FourierSingleModePoints::CreateMatrix(), Nektar::LibUtilities::GaussPoints::CreateMatrix(), Nektar::LibUtilities::FourierPoints::CreateMatrix(), Nektar::LibUtilities::Basis::GenBasis(), Nektar::LibUtilities::NodalTetElec::GetI(), Nektar::LibUtilities::NodalTriElec::GetI(), Nektar::LibUtilities::PolyEPoints::GetI(), Nektar::LibUtilities::NodalPrismElec::GetI(), Nektar::LibUtilities::NodalTriEvenlySpaced::GetI(), Nektar::LibUtilities::NodalTriFekete::GetI(), Nektar::LibUtilities::NodalPrismEvenlySpaced::GetI(), Nektar::LibUtilities::NodalTetEvenlySpaced::GetI(), Nektar::StdRegions::StdNodalTetExp::GetNodalPoints(), Nektar::StdRegions::StdNodalPrismExp::GetNodalPoints(), Nektar::StdRegions::StdNodalTriExp::GetNodalPoints(), Interp1D(), Interp2D(), Interp3D(), Nektar::Utilities::InputNek::LoadHOSurfaces(), Nektar::NekMeshUtils::Line::MakeOrder(), Nektar::NekMeshUtils::Prism::MakeOrder(), Nektar::NekMeshUtils::Quadrilateral::MakeOrder(), Nektar::NekMeshUtils::Tetrahedron::MakeOrder(), Nektar::NekMeshUtils::Triangle::MakeOrder(), Nektar::NekMeshUtils::Hexahedron::MakeOrder(), Nektar::NekMeshUtils::Edge::MakeOrder(), Nektar::NekMeshUtils::Face::MakeOrder(), Nektar::Utilities::ElUtil::MappingIdealToRef(), PhysGalerkinProject1D(), PhysGalerkinProject2D(), PhysGalerkinProject3D(), Nektar::MultiRegions::ExpList1D::PostProcess(), Nektar::Utilities::InputNek5000::Process(), Nektar::NekMeshUtils::HOSurfaceMesh::Process(), Nektar::Utilities::ProcessTetSplit::Process(), Nektar::NekMeshUtils::BLMesh::Setup(), Nektar::MultiRegions::LocTraceToTraceMap::Setup2D(), Nektar::MultiRegions::LocTraceToTraceMap::Setup3D(), Nektar::SpatialDomains::SegGeom::v_FillGeom(), and Nektar::SpatialDomains::TriGeom::v_FillGeom().

111  {
112  return Loki::SingletonHolder<PointsManagerT>::Instance();
113  }
std::string Nektar::LibUtilities::PortablePath ( const boost::filesystem::path &  path)
int Nektar::LibUtilities::PrintProgressbar ( const int  position,
const int  goal,
const string  message,
int  lastprogress = -1 
)
inline

Prints a progressbar.

Parameters
positionState of the current process
goalGoal of the current process
messageShort Description of the current process

This function plots a simple progressbar to the console or log file to visualize the current state of an ongoing process. Make sure you minimize calling this routine. Ideally, this should be called only when the percentage is increased by an integer.

Definition at line 69 of file Progressbar.hpp.

References ISTTY.

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

71 {
72  std::cout.unsetf ( std::ios::floatfield );
73  if (ISTTY)
74  {
75  float progress = position / float(goal);
76  int numeq = ceil(progress *49);
77  if(lastprogress == numeq)
78  {
79  return numeq;
80  }
81  else
82  {
83  // carriage return
84  cout << "\r";
85 
86  cout << message << ": ";
87 
88  cout << setw(3) << ceil(100 * progress) << "% [";
89  for (int j = 0; j < numeq; j++)
90  {
91  cout << "=";
92  }
93  for (int j = numeq; j < 49; j++)
94  {
95  cout << " ";
96  }
97  cout << "]" << flush;
98  return numeq;
99  }
100  }
101  else
102  {
103  // print only every 2 percent
104  if (int(ceil(double(100 * position / goal))) % 2 == 0)
105  {
106  cout << "." << flush;
107  }
108  return -1;
109  }
110 }
#define ISTTY
Definition: Progressbar.hpp:48
static NekDouble Nektar::LibUtilities::rad ( NekDouble  x,
NekDouble  y 
)
static
NekDouble Nektar::LibUtilities::sign ( NekDouble  arg)

Definition at line 97 of file AnalyticExpressionEvaluator.cpp.

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

98  {
99  return (arg > 0.0) - (arg < 0.0);
100  }
TimeIntegrationSchemeManagerT & Nektar::LibUtilities::TimeIntegrationSchemeManager ( void  )

Definition at line 45 of file TimeIntegrationScheme.cpp.

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

Referenced by Nektar::LibUtilities::TimeIntegrationIMEXOrder1::v_InitObject(), Nektar::LibUtilities::TimeIntegrationIMEXOrder2::v_InitObject(), Nektar::LibUtilities::TimeIntegrationIMEXOrder3::v_InitObject(), Nektar::LibUtilities::TimeIntegrationIMEXdirk_1_1_1::v_InitObject(), Nektar::LibUtilities::TimeIntegrationIMEXdirk_1_2_1::v_InitObject(), Nektar::LibUtilities::TimeIntegrationIMEXdirk_1_2_2::v_InitObject(), Nektar::LibUtilities::TimeIntegrationIMEXdirk_4_4_3::v_InitObject(), Nektar::LibUtilities::TimeIntegrationIMEXdirk_2_2_2::v_InitObject(), Nektar::LibUtilities::TimeIntegrationIMEXdirk_2_3_3::v_InitObject(), Nektar::LibUtilities::TimeIntegrationIMEXdirk_2_3_2::v_InitObject(), Nektar::LibUtilities::TimeIntegrationIMEXdirk_3_4_3::v_InitObject(), Nektar::LibUtilities::TimeIntegrationForwardEuler::v_InitObject(), Nektar::LibUtilities::TimeIntegrationBackwardEuler::v_InitObject(), Nektar::LibUtilities::TimeIntegrationBDFImplicitOrder1::v_InitObject(), Nektar::LibUtilities::TimeIntegrationBDFImplicitOrder2::v_InitObject(), Nektar::LibUtilities::TimeIntegrationMidpoint::v_InitObject(), Nektar::LibUtilities::TimeIntegrationRungeKutta2::v_InitObject(), Nektar::LibUtilities::TimeIntegrationRungeKutta2_ImprovedEuler::v_InitObject(), Nektar::LibUtilities::TimeIntegrationRungeKutta2_SSP::v_InitObject(), Nektar::LibUtilities::TimeIntegrationRungeKutta3_SSP::v_InitObject(), Nektar::LibUtilities::TimeIntegrationClassicalRungeKutta4::v_InitObject(), Nektar::LibUtilities::TimeIntegrationRungeKutta4::v_InitObject(), Nektar::LibUtilities::TimeIntegrationDIRKOrder2::v_InitObject(), Nektar::LibUtilities::TimeIntegrationDIRKOrder3::v_InitObject(), Nektar::LibUtilities::TimeIntegrationAdamsBashforthOrder2::v_InitObject(), Nektar::LibUtilities::TimeIntegrationAdamsBashforthOrder3::v_InitObject(), Nektar::LibUtilities::TimeIntegrationAdamsMoultonOrder2::v_InitObject(), Nektar::LibUtilities::TimeIntegrationIMEXGear::v_InitObject(), Nektar::LibUtilities::TimeIntegrationCNAB::v_InitObject(), and Nektar::LibUtilities::TimeIntegrationMCNAB::v_InitObject().

46  {
47  TimeIntegrationSchemeManagerT& m = Loki::SingletonHolder<TimeIntegrationSchemeManagerT>::Instance();
48  m.RegisterGlobalCreator(TimeIntegrationScheme::Create);
49  return m;
50  }
NekManager< TimeIntegrationSchemeKey, TimeIntegrationScheme, TimeIntegrationSchemeKey::opLess > TimeIntegrationSchemeManagerT
void Nektar::LibUtilities::Write ( const std::string &  outFile,
std::vector< FieldDefinitionsSharedPtr > &  fielddefs,
std::vector< std::vector< NekDouble > > &  fielddata,
const FieldMetaDataMap &  fieldinfomap,
const bool  backup 
)

This function allows for data to be written to an FLD file when a session and/or communicator is not instantiated. Typically used in utilities which do not take XML input and operate in serial only.

Parameters
outFileOutput filename
fielddefsField definitions that define the output
fielddataBinary field data that stores the output corresponding to fielddefs.
fieldinfomapAssociated field metadata map.

Definition at line 235 of file FieldIO.cpp.

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

Referenced by CalcNonLinearForcing(), main(), WriteBcs(), WriteFld(), and Nektar::PulseWaveSystem::WriteVessels().

240 {
241 #ifdef NEKTAR_USE_MPI
242  int size;
243  int init;
244  MPI_Initialized(&init);
245 
246  // If MPI has been initialised we can check the number of processes
247  // and, if > 1, tell the user he should not be running this
248  // function in parallel. If it is not initialised, we do not
249  // initialise it here, and assume the user knows what they are
250  // doing.
251  if (init)
252  {
253  MPI_Comm_size(MPI_COMM_WORLD, &size);
254  ASSERTL0(size == 1,
255  "This static function is not available in parallel. Please"
256  "instantiate a FieldIO object for parallel use.");
257  }
258 #endif
259  CommSharedPtr c = GetCommFactory().CreateInstance("Serial", 0, 0);
260  FieldIOSharedPtr f = GetFieldIOFactory().CreateInstance("Xml", c, false);
261  f->Write(outFile, fielddefs, fielddata, fieldinfomap, backup);
262 }
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:198
tBaseSharedPtr CreateInstance(tKey idKey BOOST_PP_COMMA_IF(MAX_PARAM) BOOST_PP_ENUM_BINARY_PARAMS(MAX_PARAM, tParam, x))
Create an instance of the class referred to by idKey.
Definition: NekFactory.hpp:162
FieldIOFactory & GetFieldIOFactory()
Returns the FieldIO factory.
Definition: FieldIO.cpp:74
CommFactory & GetCommFactory()
Definition: Comm.cpp:61
boost::shared_ptr< Comm > CommSharedPtr
Pointer to a Communicator object.
Definition: Comm.h:55
boost::shared_ptr< FieldIO > FieldIOSharedPtr
Definition: FieldIO.h:309

Variable Documentation

const char* const Nektar::LibUtilities::BasisTypeMap[]
Initial value:
=
{
"NoBasisType",
"Ortho_A",
"Ortho_B",
"Ortho_C",
"Modified_A",
"Modified_B",
"Modified_C",
"Fourier",
"GLL_Lagrange",
"Gauss_Lagrange",
"Legendre",
"Chebyshev",
"Monomial",
"FourierSingleMode",
"FourierHalfModeRe",
"FourierHalfModeIm"
}

Definition at line 47 of file Foundations.hpp.

Referenced by Nektar::LibUtilities::FieldIOXml::ImportFieldDefs(), operator<<(), Nektar::SpatialDomains::MeshGraph::ReadExpansions(), Nektar::SolverUtils::DriverAdaptive::ReplaceExpansion(), and Nektar::LibUtilities::FieldIOXml::v_Write().

const std::string Nektar::LibUtilities::EndianTypeMap[]
Initial value:
=
{
"UnknownEndian",
"BigEndian",
"LittleEndian",
"BigWordEndian",
"LittleWordEndian"
}

Definition at line 69 of file CompressData.h.

Referenced by Nektar::LibUtilities::CompressData::GetCompressString().

std::string Nektar::LibUtilities::fldCmdFormat
Initial value:
= SessionReader::RegisterCmdLineArgument(
"io-format", "i", "Default input/output format (e.g. Xml, Hdf5)")

Definition at line 68 of file FieldIO.cpp.

Nektar::LibUtilities::functions Nektar::LibUtilities::functions_p
static
const char* const Nektar::LibUtilities::FunctionTypeMap[]
Initial value:
=
{
"No Function type",
"Expression",
"File"
}

Definition at line 93 of file SessionReader.h.

const std::string Nektar::LibUtilities::kPointsTypeStr[]
const unsigned int Nektar::LibUtilities::NodalTetElecAvailable = 10

Definition at line 23 of file NodalTetElecData.h.

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

Definition at line 43 of file NodalTetSPIData.h.

const NekDouble Nektar::LibUtilities::NodalTetSPIData[][4]
static
const unsigned int Nektar::LibUtilities::NodalTetSPINPTS[NodalTetSPIAvailable]
static
Initial value:
= {
1, 4, 8, 14, 14, 28, 36, 81, 121, 180
}

Definition at line 44 of file NodalTetSPIData.h.

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

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

Definition at line 10 of file NodalTriElecData.h.

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

Definition at line 10 of file NodalTriFeketeData.h.

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

Definition at line 43 of file NodalTriSPIData.h.

const NekDouble Nektar::LibUtilities::NodalTriSPIData[][3]
static
const unsigned int Nektar::LibUtilities::NodalTriSPINPTS[NodalTriSPIAvailable]
static
Initial value:
= {
1, 3, 6, 6, 7, 13, 16, 18, 22, 25
}

Definition at line 44 of file NodalTriSPIData.h.

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

BasisSharedPtr Nektar::LibUtilities::NullBasisSharedPtr
static

Definition at line 358 of file Basis.h.

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

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

Definition at line 359 of file Basis.h.

FieldMetaDataMap Nektar::LibUtilities::NullFieldMetaDataMap
static
std::vector<NekDouble> Nektar::LibUtilities::NullNekDoubleVector
static

Definition at line 807 of file SharedArray.hpp.

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

Definition at line 85 of file PointsType.h.

PtsFieldSharedPtr Nektar::LibUtilities::NullPtsField
static
std::map<PtsInfo, int> Nektar::LibUtilities::NullPtsInfoMap
static

Definition at line 71 of file PtsField.h.

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

PtsMetaDataMap Nektar::LibUtilities::NullPtsMetaDataMap
static

Definition at line 62 of file PtsIO.h.

std::vector<unsigned int> Nektar::LibUtilities::NullUnsignedIntVector
static
std::vector<std::vector<NekDouble> > Nektar::LibUtilities::NullVectorNekDoubleVector
static
Initial value:
=
boost::assign::list_of(NullNekDoubleVector)
static std::vector< NekDouble > NullNekDoubleVector

Definition at line 809 of file SharedArray.hpp.

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

const unsigned int Nektar::LibUtilities::perm12A_3d[12][4]
static
Initial value:
= {{0,1,2,3},{0,1,3,2},{0,2,1,3},{0,2,3,1},{0,3,1,2},{0,3,2,1},
{2,0,1,3},{2,0,3,1},{2,3,0,1},{3,0,1,2},{3,0,2,1},{3,2,0,1}}

Definition at line 9 of file NodalTetElecData.h.

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

const unsigned int Nektar::LibUtilities::perm12B_3d[12][4]
static
Initial value:
= {{0,1,2,3},{0,2,1,3},{0,2,3,1},{1,0,2,3},{1,2,0,3},{1,2,3,0},
{2,0,1,3},{2,0,3,1},{2,1,0,3},{2,1,3,0},{2,3,0,1},{2,3,1,0}}

Definition at line 11 of file NodalTetElecData.h.

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

const unsigned int Nektar::LibUtilities::perm12C_3d[12][4]
static
Initial value:
= {{0,1,2,3},{0,1,3,2},{0,3,1,2},{1,0,2,3},{1,0,3,2},{1,2,0,3},
{1,2,3,0},{1,3,0,2},{1,3,2,0},{3,0,1,2},{3,1,0,2},{3,1,2,0}}

Definition at line 13 of file NodalTetElecData.h.

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

const unsigned int Nektar::LibUtilities::perm24_3d[24][4]
static
Initial value:
= {
{0,1,2,3},{0,1,3,2},{0,2,1,3},{0,2,3,1},{0,3,1,2},{0,3,2,1},
{1,0,2,3},{1,0,3,2},{1,2,0,3},{1,2,3,0},{1,3,0,2},{1,3,2,0},
{2,0,1,3},{2,0,3,1},{2,1,0,3},{2,1,3,0},{2,3,0,1},{2,3,1,0},
{3,0,1,2},{3,0,2,1},{3,1,0,2},{3,1,2,0},{3,2,0,1},{3,2,1,0}
}

Definition at line 16 of file NodalTetElecData.h.

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

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

Definition at line 5 of file NodalTriFeketeData.h.

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

Definition at line 6 of file NodalTriFeketeData.h.

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

Definition at line 7 of file NodalTriFeketeData.h.

const unsigned int Nektar::LibUtilities::perm4_3d[4][4] = {{0,1,2,3},{3,0,1,2},{2,3,0,1},{1,2,3,0}}
static
const unsigned int Nektar::LibUtilities::perm6_2d[6][3]
static
Initial value:
= {{0,1,2},{1,0,2},{2,0,1},
{2,1,0},{0,2,1},{1,2,0}}

Definition at line 8 of file NodalTriElecData.h.

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

const unsigned int Nektar::LibUtilities::perm6_2d[6][3]
static
Initial value:
= {{0,1,2},{1,0,2},{2,0,1},
{2,1,0},{0,2,1},{1,2,0}}

Definition at line 8 of file NodalTriFeketeData.h.

const unsigned int Nektar::LibUtilities::perm6_3d[6][4] = {{0,1,2,3},{0,2,1,3},{0,2,3,1},{2,0,1,3},{2,0,3,1},{2,3,0,1}}
static
const unsigned int Nektar::LibUtilities::ShapeTypeDimMap[SIZE_ShapeType]
Initial value:
=
{
0,
0,
1,
2,
2,
3,
3,
3,
3,
}

Definition at line 81 of file ShapeType.hpp.

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

const char* const Nektar::LibUtilities::ShapeTypeMap[]
const char* const Nektar::LibUtilities::TimeIntegrationMethodMap[]
const char* const Nektar::LibUtilities::TimeIntegrationSchemeTypeMap[]
Initial value:
=
{
"NoTimeIntegrationSchemeType",
"Explicit",
"DiagonallyImplicit",
"IMEX",
"Implicit"
}

Definition at line 148 of file TimeIntegrationScheme.h.

Referenced by operator<<().