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

Namespaces

 CompressData
 
 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  CommMpi
 A global linear system. More...
 
class  CommSerial
 A global linear system. More...
 
struct  defOpLessCreator
 
class  Equation
 
struct  FieldDefinitions
 
class  FieldIO
 Class for operating on FLD files. More...
 
class  FourierPoints
 
class  FourierSingleModePoints
 
struct  func
 
struct  functions
 
struct  FunctionVariableDefinition
 
class  GaussPoints
 
class  Graph
 
class  GraphEdgeObject
 
class  GraphVertexObject
 
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  NodalPrismEvenlySpaced
 
class  NodalTetElec
 
class  NodalTetEvenlySpaced
 
class  NodalTriElec
 
class  NodalTriEvenlySpaced
 
class  NodalTriFekete
 
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  PtsPoint
 
class  SessionReader
 Reads and parses information from a Nektar++ XML session file. 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
 

Typedefs

typedef std::map< std::string,
std::string > 
FieldMetaDataMap
 
typedef boost::shared_ptr
< FieldDefinitions
FieldDefinitionsSharedPtr
 
typedef boost::shared_ptr
< FieldIO
FieldIOSharedPtr
 
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 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  PtsType {
  ePtsFile, ePtsLine, ePtsPlane, ePtsBox,
  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  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,
  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)
 
void Write (const std::string &outFile, std::vector< FieldDefinitionsSharedPtr > &fielddefs, std::vector< std::vector< NekDouble > > &fielddata, const FieldMetaDataMap &fieldinfomap=NullFieldMetaDataMap)
 Write a field file in serial only. More...
 
void Import (const std::string &infilename, std::vector< FieldDefinitionsSharedPtr > &fielddefs, std::vector< std::vector< NekDouble > > &fielddata=NullVectorNekDoubleVector, FieldMetaDataMap &fieldinfomap=NullFieldMetaDataMap, const Array< OneD, int > ElementiDs=NullInt1DArray)
 Imports an FLD file. More...
 
std::string PortablePath (const boost::filesystem::path &path)
 create portable path on different platforms for boost::filesystem path More...
 
MeshPartitionFactoryGetMeshPartitionFactory ()
 
void PrintProgressbar (const int position, const int goal, const string message)
 Prints a progressbar. More...
 
void Import (const string &inFile, PtsFieldSharedPtr &ptsField)
 
void Write (const string &outFile, const PtsFieldSharedPtr &ptsField)
 
int GetNumberOfCoefficients (ShapeType shape, std::vector< unsigned int > &modes, int offset)
 
int GetNumberOfCoefficients (ShapeType shape, int na, int nb, int nc)
 
CommFactoryGetCommFactory ()
 
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)
 
template<typename T >
NekVector< T > GetColumn (const NekMatrix< T > &matA, int n)
 
NekMatrix< NekDouble > & SetColumn (NekMatrix< NekDouble > &matA, int n, const NekVector< NekDouble > &x)
 
NekVector< NekDoubleGetE (int rows, int n)
 
NekMatrix< NekDoubleInvert (const NekMatrix< NekDouble > &matA)
 
NekMatrix< NekDoubleGetTranspose (const NekMatrix< NekDouble > &matA)
 
int GetSize (const Array< OneD, const NekDouble > &x)
 
int GetSize (const NekVector< NekDouble > &x)
 
NekVector< NekDoubleToVector (const Array< OneD, const NekDouble > &x)
 
Array< OneD, NekDoubleToArray (const NekVector< NekDouble > &x)
 
NekVector< NekDoubleHadamard (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y)
 
NekVector< NekDoubleVectorPower (const NekVector< NekDouble > &x, NekDouble p)
 
std::string MatrixToString (const NekMatrix< NekDouble > &A, int precision, NekDouble expSigFigs)
 
std::string VectorToString (const NekVector< NekDouble > &v, int precision, NekDouble expSigFigs)
 
int GetTriNumPoints (int degree)
 
int GetDegree (int nBasisFunctions)
 
int GetTetNumPoints (int degree)
 
int GetTetDegree (int nBasisFunc)
 
NekDouble MakeRound (NekDouble x)
 
NekVector< NekDoubleMakeDubinerQuadratureSystem (int nBasisFunctions)
 
NekVector< NekDoubleMakeTetQuadratureSystem (int nBasisFunctions)
 
NekVector< NekDoubleJacobiPoly (int degree, const NekVector< NekDouble > &x, NekDouble alpha, NekDouble beta)
 
NekDouble JacobiPoly (int degree, NekDouble x, NekDouble alpha, NekDouble beta)
 
NekVector< NekDoubleLegendrePoly (int degree, const NekVector< NekDouble > &x)
 
NekVector< NekDoubleDubinerPoly (int p, int q, const NekVector< NekDouble > &x, const NekVector< NekDouble > &y)
 
NekVector< NekDoubleTetrahedralBasis (int p, int q, int r, const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z)
 
NekMatrix< NekDoubleGetTetVandermonde (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z, int degree)
 
NekMatrix< NekDoubleGetTetVandermonde (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z)
 
NekMatrix< NekDoubleGetVandermonde (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, int degree)
 
NekMatrix< NekDoubleGetVandermonde (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y)
 
SharedNekMatrixPtr MakeVmatrixOfTet (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z)
 
SharedNekMatrixPtr MakeVmatrixOfDubinerPolynomial (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y)
 
NekVector< NekDoubleMakeTetWeights (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z)
 
NekVector< NekDoubleMakeQuadratureWeights (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y)
 
NekMatrix< NekDoubleGetTetInterpolationMatrix (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z, const NekVector< NekDouble > &xi, const NekVector< NekDouble > &yi, const NekVector< NekDouble > &zi)
 
NekMatrix< NekDoubleGetInterpolationMatrix (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &xi, const NekVector< NekDouble > &yi)
 
NekVector< NekDoubleLegendrePolyDerivative (int degree, const NekVector< NekDouble > &x)
 
NekVector< NekDoubleDubinerPolyXDerivative (int p, int q, const NekVector< NekDouble > &x, const NekVector< NekDouble > &y)
 
NekVector< NekDoubleTetXDerivative (int p, int q, int r, const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z)
 
NekMatrix< NekDoubleGetVandermondeForTetXDerivative (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z, int degree)
 
NekMatrix< NekDoubleGetVandermondeForTetXDerivative (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z)
 
Points< NekDouble >
::MatrixSharedPtrType 
GetTetXDerivativeMatrix (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z, const NekVector< NekDouble > &xi, const NekVector< NekDouble > &yi, const NekVector< NekDouble > &zi)
 
NekMatrix< NekDoubleGetVandermondeForXDerivative (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, int degree)
 
NekMatrix< NekDoubleGetVandermondeForXDerivative (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y)
 
Points< NekDouble >
::MatrixSharedPtrType 
GetXDerivativeMatrix (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &xi, const NekVector< NekDouble > &yi)
 
NekVector< NekDoubleJacobiPolyDerivative (int degree, const NekVector< NekDouble > &x, int alpha, int beta)
 
NekVector< NekDoubleTetYDerivative (int p, int q, int r, const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z)
 
NekMatrix< NekDoubleGetVandermondeForTetYDerivative (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z, int degree)
 
NekMatrix< NekDoubleGetVandermondeForTetYDerivative (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z)
 
Points< NekDouble >
::MatrixSharedPtrType 
GetTetYDerivativeMatrix (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z, const NekVector< NekDouble > &xi, const NekVector< NekDouble > &yi, const NekVector< NekDouble > &zi)
 
NekVector< NekDoubleTetZDerivative (int p, int q, int r, const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z)
 
NekMatrix< NekDoubleGetVandermondeForTetZDerivative (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z, int degree)
 
NekMatrix< NekDoubleGetVandermondeForTetZDerivative (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z)
 
Points< NekDouble >
::MatrixSharedPtrType 
GetTetZDerivativeMatrix (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z, const NekVector< NekDouble > &xi, const NekVector< NekDouble > &yi, const NekVector< NekDouble > &zi)
 
NekVector< NekDoubleDubinerPolyYDerivative (int p, int q, const NekVector< NekDouble > &x, const NekVector< NekDouble > &y)
 
NekMatrix< NekDoubleGetVandermondeForYDerivative (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, int degree)
 
Points< NekDouble >
::MatrixSharedPtrType 
GetYDerivativeMatrix (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &xi, const NekVector< NekDouble > &yi)
 
NekMatrix< NekDoubleGetVandermondeForYDerivative (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y)
 
NekMatrix< NekDoubleGetMonomialVandermonde (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, int degree)
 
NekMatrix< NekDoubleGetMonomialVandermonde (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z, int degree)
 
NekMatrix< NekDoubleGetMonomialVandermonde (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z)
 
NekMatrix< NekDoubleGetMonomialVandermonde (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y)
 
NekMatrix< NekDoubleGetXDerivativeOfMonomialVandermonde (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, int degree)
 
NekMatrix< NekDoubleGetXDerivativeOfMonomialVandermonde (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y)
 
NekMatrix< NekDoubleGetTetXDerivativeOfMonomialVandermonde (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z, int degree)
 
NekMatrix< NekDoubleGetTetXDerivativeOfMonomialVandermonde (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z)
 
NekMatrix< NekDoubleGetTetYDerivativeOfMonomialVandermonde (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z, int degree)
 
NekMatrix< NekDoubleGetTetYDerivativeOfMonomialVandermonde (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z)
 
NekMatrix< NekDoubleGetTetZDerivativeOfMonomialVandermonde (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z, int degree)
 
NekMatrix< NekDoubleGetTetZDerivativeOfMonomialVandermonde (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z)
 
NekMatrix< NekDoubleGetYDerivativeOfMonomialVandermonde (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, int degree)
 
NekMatrix< NekDoubleGetYDerivativeOfMonomialVandermonde (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y)
 
NekVector< NekDoubleGetIntegralOfMonomialVandermonde (int degree)
 
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 []
 
static std::vector< NekDoubleNullNekDoubleVector
 
static std::vector
< LibUtilities::PointsType
NullPointsTypeVector
 
static std::vector< unsigned int > NullUnsignedIntVector
 
static FieldMetaDataMap NullFieldMetaDataMap
 
static std::vector
< std::vector< NekDouble > > 
NullVectorNekDoubleVector
 
static 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 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]
 
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]
 
Nektar::LibUtilities::functions functions_p
 
const char *const TimeIntegrationMethodMap []
 
const char *const TimeIntegrationSchemeTypeMap []
 

Typedef Documentation

Name for a vector of BasisKeys.

Definition at line 69 of file FoundationsFwd.hpp.

Name for an iterator over a BasisKeyVector.

Definition at line 76 of file FoundationsFwd.hpp.

Definition at line 51 of file ManagerAccess.h.

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

Definition at line 79 of file FoundationsFwd.hpp.

Definition at line 80 of file FoundationsFwd.hpp.

Definition at line 81 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.

typedef LibUtilities::NekFactory< std::string, Comm, int, char** > Nektar::LibUtilities::CommFactory

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

Definition at line 60 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 53 of file Comm.h.

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

Definition at line 53 of file MeshPartition.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 118 of file FieldIO.h.

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

Definition at line 225 of file FieldIO.h.

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

Definition at line 53 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 85 of file FoundationsFwd.hpp.

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 235 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 83 of file FoundationsFwd.hpp.

Definition at line 220 of file Points.h.

Definition at line 50 of file ManagerAccess.h.

Definition at line 84 of file FoundationsFwd.hpp.

Definition at line 262 of file PtsField.h.

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

Definition at line 96 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.

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 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 171 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.

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

SIZE_PointsType 

Length of enum list.

Definition at line 44 of file PointsType.h.

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

Definition at line 65 of file PtsField.h.

Enumerator
ePtsFile 
ePtsLine 
ePtsPlane 
ePtsBox 
ePtsTriBlock 
ePtsTetBlock 

Definition at line 55 of file PtsField.h.

Type of operation to perform in AllReduce.

Enumerator
ReduceSum 
ReduceMax 
ReduceMin 

Definition at line 65 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  )
NekVector< NekDouble > Nektar::LibUtilities::DubinerPoly ( int  p,
int  q,
const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y 
)

Definition at line 375 of file NodalUtil.cpp.

References GetSize(), JacobiPoly(), and LegendrePoly().

Referenced by GetVandermonde().

376  {
377  // Get the coordinate transform
378  int size = GetSize(x);
379  NekVector<NekDouble> eta_1(size);
380 
381  // Initialize the horizontal coordinate of the triangle (beta in Barycentric coordinates)
382  for(int el=0; el<size; ++el)
383  {
384  if( y[el] < 1.0 - 1e-16 )
385  {
386  eta_1[el] = 2.0*(1.0 + x[el]) / (1.0 - y[el]) - 1.0;
387  }
388  else
389  {
390  eta_1[el] = -1.0; // When y is close to 1, then we have a removeable singularity
391  }
392  }
393 
394  // Initialize the vertical coordinate of the triangle (gamma in Barycentric coordinates)
395  NekVector<NekDouble> eta_2 = y;
396 
397  // Orthogonal Dubiner polynomial
398  int alpha = 2*p + 1; int beta = 0;
399  NekVector<NekDouble> phi(size);
400  NekVector<NekDouble> psi_a = LegendrePoly(p, eta_1);
401  NekVector<NekDouble> upsilon = JacobiPoly(q, eta_2, alpha, beta);
402  NekDouble w = sqrt((2.0 * p + 1.0) * (p + q + 1.0) / 2.0); // Normalizing Orthonormal weight
403 
404  for(int el=0; el<size; ++el)
405  {
406  NekDouble zeta = pow((1.0 - eta_2[el])/2.0, p);
407  NekDouble psi_b = zeta * upsilon[el];
408  phi[el] = w * psi_a[el] * psi_b;
409  }
410  return phi;
411  }
int GetSize(const NekVector< NekDouble > &x)
Definition: NodalUtil.cpp:116
NekVector< NekDouble > LegendrePoly(int degree, const NekVector< NekDouble > &x)
Definition: NodalUtil.cpp:340
double NekDouble
NekDouble JacobiPoly(int degree, NekDouble x, NekDouble alpha, NekDouble beta)
Definition: NodalUtil.cpp:300
NekVector< NekDouble > Nektar::LibUtilities::DubinerPolyXDerivative ( int  p,
int  q,
const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y 
)

Definition at line 664 of file NodalUtil.cpp.

References Nektar::NekVector< DataType >::GetRows(), GetSize(), JacobiPoly(), and LegendrePolyDerivative().

Referenced by GetVandermondeForXDerivative().

665  {
666  // Get the coordinate transform
667  int size = GetSize(y);
668  NekVector<NekDouble> eta_1(size);
669  NekVector<NekDouble> psi_x(x.GetRows());
670  if(p>0)
671  {
672  // Initialize the horizontal coordinate of the triangle (beta in Barycentric coordinates)
673  for(int el=0; el<size; ++el)
674  {
675  if(y[el] < 1.0 - 1e-16)
676  {
677  eta_1[el] = 2.0*(1.0 + x[el]) / (1.0 - y[el]) - 1.0;
678  }
679  else
680  {
681  eta_1[el] = -1.0; // When y is close to 1, then we have a removeable singularity
682  }
683  }
684  // Initialize the vertical coordinate of the triangle (gamma in Barycentric coordinates)
685  NekVector<NekDouble> eta_2 = y;
686 
687  // Orthogonal Dubiner polynomial x-derivative
688  int alpha = 2*p + 1; int beta = 0;
689  NekVector<NekDouble> psi_a_x = LegendrePolyDerivative(p, eta_1);
690  NekVector<NekDouble> upsilon = JacobiPoly(q, eta_2, alpha, beta);
691  NekDouble w = sqrt((2.0*p + 1.0) * (p + q + 1.0) / 2.0); // Normalizing Orthonormal weight
692 
693  for(int i=0; i<size; ++i)
694  {
695  NekDouble zeta = pow((1.0 - eta_2[i])/2.0, (p-1.0));
696  NekDouble psi_b = zeta*upsilon[i];
697  psi_x[i] = w * psi_a_x[i] * psi_b;
698  }
699  }
700  else
701  {
702  for(int i=0; i<int(x.GetRows()); ++i)
703  {
704  psi_x[i] = 0.0;
705  }
706  }
707 
708  return psi_x;
709  }
int GetSize(const NekVector< NekDouble > &x)
Definition: NodalUtil.cpp:116
NekVector< NekDouble > LegendrePolyDerivative(int degree, const NekVector< NekDouble > &x)
Definition: NodalUtil.cpp:624
double NekDouble
NekDouble JacobiPoly(int degree, NekDouble x, NekDouble alpha, NekDouble beta)
Definition: NodalUtil.cpp:300
NekVector< NekDouble > Nektar::LibUtilities::DubinerPolyYDerivative ( int  p,
int  q,
const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y 
)

Definition at line 1217 of file NodalUtil.cpp.

References GetSize(), JacobiPoly(), JacobiPolyDerivative(), LegendrePoly(), and LegendrePolyDerivative().

Referenced by GetVandermondeForYDerivative().

1218  {
1219  // Get the coordinate transform
1220  int size = GetSize(y);
1221  NekVector<NekDouble> eta_1(size);
1222 
1223  // Initialize the horizontal coordinate of the triangle (beta in Barycentric coordinates)
1224  for(int el=0; el<size; ++el)
1225  {
1226  if(y[el] < 1.0 - 1e-16)
1227  {
1228  eta_1[el] = 2.0*(1.0 + x[el]) / (1.0 - y[el]) - 1.0;
1229  }
1230  else
1231  {
1232  eta_1[el] = -1.0; // When y is close to 1, then we have a removeable singularity
1233  }
1234  }
1235  // Initialize the vertical coordinate of the triangle (gamma in Barycentric coordinates)
1236  NekVector<NekDouble> eta_2 = y;
1237 
1238  // Orthogonal Dubiner y-polynomial
1239  int alpha = 2*p + 1; int beta = 0;
1240 
1241  NekVector<NekDouble> psi_a = LegendrePoly(p, eta_1);
1242  NekVector<NekDouble> psi_a_y = LegendrePolyDerivative(p, eta_1);
1243  NekVector<NekDouble> psi_b = JacobiPoly(q, eta_2, alpha, beta);
1244  NekVector<NekDouble> psi_b_y = JacobiPolyDerivative(q, eta_2, alpha, beta);
1245  NekVector<NekDouble> secondComponentOf_psi_b(size);
1246  NekVector<NekDouble> psi_y(size);
1247 
1248  NekVector<NekDouble> first_part_derivative(size);
1249 
1250  if(p > 0)
1251  {
1252  for(int i=0; i<size; ++i)
1253  {
1254 
1255  first_part_derivative[i] = (1.0 + eta_1[i])/2.0 * psi_a_y[i] * pow((1.0 - eta_2[i])/2.0, p-1.0) * psi_b[i];
1256  secondComponentOf_psi_b[i] = -p/2.0 * pow(((1.0 - eta_2[i]) / 2.0), p - 1.0) * psi_b[i];
1257 
1258  }
1259  }
1260  else
1261  {
1262  for(int i=0; i<size; ++i)
1263  {
1264  secondComponentOf_psi_b[i] = 0.0;
1265  first_part_derivative[i] = 0.0;
1266  }
1267  }
1268  for(int k=0; k<size; ++k)
1269  {
1270  psi_y[k] = first_part_derivative[k] + psi_a[k] * ( pow((1.0 - eta_2[k])/2.0, p) * psi_b_y[k] + secondComponentOf_psi_b[k] );
1271 
1272  }
1273  NekDouble w = sqrt((2.0*p + 1.0)*(p + q + 1.0)/2.0); // Normalizing Orthonormal weight
1274 
1275  return w * psi_y;
1276  }
int GetSize(const NekVector< NekDouble > &x)
Definition: NodalUtil.cpp:116
NekVector< NekDouble > LegendrePolyDerivative(int degree, const NekVector< NekDouble > &x)
Definition: NodalUtil.cpp:624
NekVector< NekDouble > LegendrePoly(int degree, const NekVector< NekDouble > &x)
Definition: NodalUtil.cpp:340
double NekDouble
NekDouble JacobiPoly(int degree, NekDouble x, NekDouble alpha, NekDouble beta)
Definition: NodalUtil.cpp:300
NekVector< NekDouble > JacobiPolyDerivative(int degree, const NekVector< NekDouble > &x, int alpha, int beta)
Definition: NodalUtil.cpp:867
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  }
template<typename T >
NekVector< T > Nektar::LibUtilities::GetColumn ( const NekMatrix< T > &  matA,
int  n 
)

Definition at line 52 of file NodalUtil.cpp.

53  {
54  NekVector<T> v(matA.GetRows());
55  for( int i=0; i<matA.GetRows(); ++i )
56  {
57  v[i] = matA(i,n);
58  }
59  return v;
60  }
CommFactory & Nektar::LibUtilities::GetCommFactory ( )

Definition at line 64 of file Comm.cpp.

Referenced by Nektar::LibUtilities::SessionReader::CreateComm(), Import(), main(), Nektar::Utilities::InputFld::Process(), Nektar::Utilities::InputPts::Process(), and Write().

65  {
66  typedef Loki::SingletonHolder<CommFactory,
67  Loki::CreateUsingNew,
68  Loki::NoDestroy,
69  Loki::SingleThreaded> Type;
70  return Type::Instance();
71  }
LibUtilities::NekFactory< std::string, Comm, int, char ** > CommFactory
Datatype of the NekFactory used to instantiate classes derived from the EquationSystem class...
Definition: Comm.h:60
int Nektar::LibUtilities::GetDegree ( int  nBasisFunctions)

Definition at line 207 of file NodalUtil.cpp.

References ASSERTL1, GetTriNumPoints(), and MakeRound().

Referenced by GetInterpolationMatrix(), GetMonomialVandermonde(), GetVandermonde(), GetVandermondeForXDerivative(), GetVandermondeForYDerivative(), GetXDerivativeMatrix(), GetXDerivativeOfMonomialVandermonde(), GetYDerivativeMatrix(), and GetYDerivativeOfMonomialVandermonde().

208  {
209  int degree = int(MakeRound((-3.0 + sqrt(1.0 + 8.0*nBasisFunctions))/2.0));
210 
211  // TODO: Find out why ASSERTL0 and ASSERTL1 don't work
212  ASSERTL1( GetTriNumPoints(degree) == nBasisFunctions, "The number of points defines an expansion of fractional degree, which is not supported." );
213  return degree;
214  }
NekDouble MakeRound(NekDouble x)
Definition: NodalUtil.cpp:231
int GetTriNumPoints(int degree)
Definition: NodalUtil.cpp:202
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:218
NekVector< NekDouble > Nektar::LibUtilities::GetE ( int  rows,
int  n 
)

Definition at line 72 of file NodalUtil.cpp.

Referenced by Invert().

73  {
74  NekVector<NekDouble> e(rows, 0.0);
75  e(n) = 1;
76  return e;
77  }
NekVector< NekDouble > Nektar::LibUtilities::GetIntegralOfMonomialVandermonde ( int  degree)

Definition at line 1588 of file NodalUtil.cpp.

1589  {
1590  int cols = (degree + 1) * (degree + 2) / 2;
1591  NekVector<NekDouble>integralMVandermonde(cols, 0.0);
1592 
1593  for(int d=0, n=0; d <= degree; ++d)
1594  {
1595  for(int p=0; p <= d; ++p, ++n)
1596  {
1597  int q = d - p;
1598  int sp = 1 - 2 * (p % 2);
1599  int sq = 1 - 2 * (q % 2);
1600 
1601  integralMVandermonde(n) = NekDouble(sp * (p+1) + sq * (q+1) + sp * sq * (p+q+2)) / ((p+1) * (q+1) * (p+q+2));
1602  }
1603  }
1604  return integralMVandermonde;
1605  }
double NekDouble
NekMatrix< NekDouble > Nektar::LibUtilities::GetInterpolationMatrix ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y,
const NekVector< NekDouble > &  xi,
const NekVector< NekDouble > &  yi 
)

Definition at line 609 of file NodalUtil.cpp.

References GetDegree(), GetSize(), GetVandermonde(), and Invert().

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

611  {
612  int nNodes = GetSize(x);
613  int degree = GetDegree(nNodes);
614 
615  NekMatrix<NekDouble> matS = GetVandermonde(x, y); // Square 'short' matrix
616  NekMatrix<NekDouble> matT = GetVandermonde(xi, yi, degree); // Coefficient interpolation matrix (tall)
617 
618  NekMatrix<NekDouble> invertMatrix = Invert(matS);
619 
620  // Get the interpolation matrix
621  return matT*invertMatrix;
622  }
int GetDegree(int nBasisFunctions)
Definition: NodalUtil.cpp:207
int GetSize(const NekVector< NekDouble > &x)
Definition: NodalUtil.cpp:116
NekMatrix< NekDouble > Invert(const NekMatrix< NekDouble > &matA)
Definition: NodalUtil.cpp:79
NekMatrix< NekDouble > GetVandermonde(const NekVector< NekDouble > &x, const NekVector< NekDouble > &y)
Definition: NodalUtil.cpp:540
MeshPartitionFactory & Nektar::LibUtilities::GetMeshPartitionFactory ( )

Definition at line 69 of file MeshPartition.cpp.

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

70  {
71  typedef Loki::SingletonHolder<MeshPartitionFactory,
72  Loki::CreateUsingNew,
73  Loki::NoDestroy,
74  Loki::SingleThreaded> Type;
75  return Type::Instance();
76  }
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
NekMatrix< NekDouble > Nektar::LibUtilities::GetMonomialVandermonde ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y,
int  degree 
)

Definition at line 1327 of file NodalUtil.cpp.

References GetSize().

Referenced by GetMonomialVandermonde().

1328  {
1329  int rows = GetSize(x);
1330  int cols = (degree + 1)*(degree + 2)/2;
1331  NekMatrix<NekDouble>matV(rows,cols, 0.0);
1332 
1333  for(int d=0, n=0; d <= degree; ++d)
1334  {
1335  for(int p=0; p <= d; ++p, ++n)
1336  {
1337  int q = d - p;
1338 
1339  for(int i=0; i<rows; ++i)
1340  {
1341  matV(i, n) = pow(x[i], p) * pow(y[i], q);
1342  }
1343  }
1344  }
1345  return matV;
1346  }
int GetSize(const NekVector< NekDouble > &x)
Definition: NodalUtil.cpp:116
NekMatrix< NekDouble > Nektar::LibUtilities::GetMonomialVandermonde ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y,
const NekVector< NekDouble > &  z,
int  degree 
)

Definition at line 1348 of file NodalUtil.cpp.

References GetSize().

1350  {
1351  int rows = GetSize(x);
1352  int cols = (degree + 1) * (degree + 2) * (degree + 3)/6;
1353 
1354  NekMatrix<NekDouble> matV(rows, cols, 0.0);
1355 
1356  for(int d=0, n=0; d<=degree; ++d)
1357  {
1358  for(int p=0; p <= d; ++p)
1359  {
1360  for(int q=0; q <= d - p; ++q, ++n)
1361  {
1362  int r = d - p - q;
1363 
1364  // Set n-th column of V to the monomial vector
1365  for(int i=0; i<rows; ++i)
1366  {
1367  matV(i,n) = pow(x[i],p) * pow(y[i],q) * pow(z[i],r);
1368  }
1369  }
1370  }
1371  }
1372  return matV;
1373  }
int GetSize(const NekVector< NekDouble > &x)
Definition: NodalUtil.cpp:116
NekMatrix< NekDouble > Nektar::LibUtilities::GetMonomialVandermonde ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y,
const NekVector< NekDouble > &  z 
)

Definition at line 1375 of file NodalUtil.cpp.

References GetMonomialVandermonde(), GetSize(), and GetTetDegree().

1376  {
1377  int rows = GetSize(x);
1378  int degree = GetTetDegree(rows);
1379  return GetMonomialVandermonde(x, y, z, degree);
1380  }
int GetTetDegree(int nBasisFunc)
Definition: NodalUtil.cpp:222
int GetSize(const NekVector< NekDouble > &x)
Definition: NodalUtil.cpp:116
NekMatrix< NekDouble > GetMonomialVandermonde(const NekVector< NekDouble > &x, const NekVector< NekDouble > &y)
Definition: NodalUtil.cpp:1382
NekMatrix< NekDouble > Nektar::LibUtilities::GetMonomialVandermonde ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y 
)

Definition at line 1382 of file NodalUtil.cpp.

References GetDegree(), GetMonomialVandermonde(), and GetSize().

1383  {
1384  int rows = GetSize(x);
1385  int degree = GetDegree(rows);
1386  return GetMonomialVandermonde(x, y, degree);
1387  }
int GetDegree(int nBasisFunctions)
Definition: NodalUtil.cpp:207
int GetSize(const NekVector< NekDouble > &x)
Definition: NodalUtil.cpp:116
NekMatrix< NekDouble > GetMonomialVandermonde(const NekVector< NekDouble > &x, const NekVector< NekDouble > &y)
Definition: NodalUtil.cpp:1382
NektarFFTFactory & Nektar::LibUtilities::GetNektarFFTFactory ( )

Definition at line 69 of file NektarFFT.cpp.

Referenced by Nektar::LinearisedAdvection::DFT(), Nektar::AdjointAdvection::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:188
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:188
int getNumberOfCoefficients(int Na, int Nb, int Nc)
Definition: ShapeType.hpp:286
int Nektar::LibUtilities::GetSize ( const Array< OneD, const NekDouble > &  x)
int Nektar::LibUtilities::GetSize ( const NekVector< NekDouble > &  x)

Definition at line 116 of file NodalUtil.cpp.

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

117  {
118  return x.GetRows();
119  }
int Nektar::LibUtilities::GetTetDegree ( int  nBasisFunc)

Definition at line 222 of file NodalUtil.cpp.

References ASSERTL1, GetTetNumPoints(), and MakeRound().

Referenced by GetMonomialVandermonde(), GetTetInterpolationMatrix(), GetTetVandermonde(), GetTetXDerivativeMatrix(), GetTetXDerivativeOfMonomialVandermonde(), GetTetYDerivativeOfMonomialVandermonde(), GetTetZDerivativeMatrix(), GetTetZDerivativeOfMonomialVandermonde(), GetVandermondeForTetXDerivative(), GetVandermondeForTetYDerivative(), and GetVandermondeForTetZDerivative().

223  {
224  NekDouble eq = pow( 81.0 * nBasisFunc + 3.0 * sqrt(-3.0 + 729.0 * nBasisFunc * nBasisFunc), 1.0/3.0);
225  int degree = int(MakeRound(eq/3.0 + 1.0/eq - 1.0)) - 1;
226 
227  ASSERTL1( GetTetNumPoints(degree) == nBasisFunc, "The number of points defines an expansion of fractional degree, which is not supported." );
228  return degree;
229  }
int GetTetNumPoints(int degree)
Definition: NodalUtil.cpp:216
NekDouble MakeRound(NekDouble x)
Definition: NodalUtil.cpp:231
double NekDouble
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:218
NekMatrix< NekDouble > Nektar::LibUtilities::GetTetInterpolationMatrix ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y,
const NekVector< NekDouble > &  z,
const NekVector< NekDouble > &  xi,
const NekVector< NekDouble > &  yi,
const NekVector< NekDouble > &  zi 
)

Definition at line 594 of file NodalUtil.cpp.

References GetSize(), GetTetDegree(), GetTetVandermonde(), and Invert().

Referenced by Nektar::LibUtilities::NodalTetElec::CalculateInterpMatrix(), and Nektar::LibUtilities::NodalTetEvenlySpaced::CalculateInterpMatrix().

596  {
597  int nNodes = GetSize(x);
598  int degree = GetTetDegree(nNodes);
599 
600  NekMatrix<NekDouble> matS = GetTetVandermonde(x, y, z); // Square 'short' matrix
601  NekMatrix<NekDouble> matT = GetTetVandermonde(xi, yi, zi, degree); // Coefficient interpolation matrix (tall)
602 
603  NekMatrix<NekDouble> invertMatrix = Invert(matS);
604 
605  // Get the interpolation matrix
606  return matT*invertMatrix;
607  }
int GetTetDegree(int nBasisFunc)
Definition: NodalUtil.cpp:222
int GetSize(const NekVector< NekDouble > &x)
Definition: NodalUtil.cpp:116
NekMatrix< NekDouble > GetTetVandermonde(const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z)
Definition: NodalUtil.cpp:507
NekMatrix< NekDouble > Invert(const NekMatrix< NekDouble > &matA)
Definition: NodalUtil.cpp:79
int Nektar::LibUtilities::GetTetNumPoints ( int  degree)

Definition at line 216 of file NodalUtil.cpp.

Referenced by GetTetDegree().

217  {
218  return (degree+1) * (degree+2) * (degree+3) / 6;
219  }
NekMatrix< NekDouble > Nektar::LibUtilities::GetTetVandermonde ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y,
const NekVector< NekDouble > &  z,
int  degree 
)

Definition at line 477 of file NodalUtil.cpp.

References GetSize(), and TetrahedralBasis().

Referenced by GetTetInterpolationMatrix(), GetTetVandermonde(), GetTetXDerivativeMatrix(), GetTetYDerivativeMatrix(), GetTetZDerivativeMatrix(), and MakeVmatrixOfTet().

478  {
479  //cout << "Begin GetTetVandermonde" << endl;
480  int rows = GetSize(x);
481  int cols = (degree + 1) * (degree + 2) * (degree + 3)/6;
482 
483  NekMatrix<NekDouble> matV(rows, cols, 0.0);
484 
485  for(int d=0, n=0; d<=degree; ++d)
486  {
487  for(int p=0; p <= d; ++p)
488  {
489  for(int q=0; q <= d - p; ++q, ++n)
490  {
491  int r = d - p - q;
492  NekVector<NekDouble> columnVector = TetrahedralBasis(p, q, r, x, y, z);
493 
494  // cout << "degree = " << degree << ", (d,p,q,r) = (" << d << ", " << p << ", " << q << ", " << r << ")" << endl;
495  // Set n-th column of V to the TetrahedralBasis vector
496  for(int i=0; i<rows; ++i)
497  {
498  matV(i,n) = columnVector[i];
499  }
500  }
501  }
502  }
503  return matV;
504  }
int GetSize(const NekVector< NekDouble > &x)
Definition: NodalUtil.cpp:116
NekVector< NekDouble > TetrahedralBasis(int p, int q, int r, const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z)
Definition: NodalUtil.cpp:415
NekMatrix< NekDouble > Nektar::LibUtilities::GetTetVandermonde ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y,
const NekVector< NekDouble > &  z 
)

Definition at line 507 of file NodalUtil.cpp.

References GetSize(), GetTetDegree(), and GetTetVandermonde().

508  {
509  int rows = GetSize(x);
510  int degree = GetTetDegree(rows);
511  return GetTetVandermonde(x, y, z, degree);
512  }
int GetTetDegree(int nBasisFunc)
Definition: NodalUtil.cpp:222
int GetSize(const NekVector< NekDouble > &x)
Definition: NodalUtil.cpp:116
NekMatrix< NekDouble > GetTetVandermonde(const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z)
Definition: NodalUtil.cpp:507
Points< NekDouble >::MatrixSharedPtrType Nektar::LibUtilities::GetTetXDerivativeMatrix ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y,
const NekVector< NekDouble > &  z,
const NekVector< NekDouble > &  xi,
const NekVector< NekDouble > &  yi,
const NekVector< NekDouble > &  zi 
)

Definition at line 806 of file NodalUtil.cpp.

References GetSize(), GetTetDegree(), GetTetVandermonde(), GetVandermondeForTetXDerivative(), and Invert().

Referenced by Nektar::LibUtilities::NodalTetElec::CalculateDerivMatrix(), and Nektar::LibUtilities::NodalTetEvenlySpaced::CalculateDerivMatrix().

808  {
809  int nNodes = GetSize(x);
810  int degree = GetTetDegree(nNodes);
811  NekMatrix<NekDouble> matS = GetTetVandermonde(x, y, z); // Square 'short' matrix
812  NekMatrix<NekDouble> matTx = GetVandermondeForTetXDerivative(xi, yi, zi, degree); // Tall matrix
813 
814  NekMatrix<NekDouble> invertMatrix = Invert(matS);
815 
816  // Get the Derivation matrix
817  return Points<NekDouble>::MatrixSharedPtrType( new NekMatrix<NekDouble>(matTx*invertMatrix) );
818  }
NekMatrix< NekDouble > GetVandermondeForTetXDerivative(const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z)
Definition: NodalUtil.cpp:799
int GetTetDegree(int nBasisFunc)
Definition: NodalUtil.cpp:222
int GetSize(const NekVector< NekDouble > &x)
Definition: NodalUtil.cpp:116
NekMatrix< NekDouble > GetTetVandermonde(const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z)
Definition: NodalUtil.cpp:507
boost::shared_ptr< NekMatrix< DataType > > MatrixSharedPtrType
Definition: Points.h:228
NekMatrix< NekDouble > Invert(const NekMatrix< NekDouble > &matA)
Definition: NodalUtil.cpp:79
NekMatrix< NekDouble > Nektar::LibUtilities::GetTetXDerivativeOfMonomialVandermonde ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y,
const NekVector< NekDouble > &  z,
int  degree 
)

Definition at line 1427 of file NodalUtil.cpp.

References GetSize().

Referenced by GetTetXDerivativeOfMonomialVandermonde().

1429  {
1430  int rows = GetSize(x);
1431  int cols = (degree + 1) * (degree + 2) * (degree + 3) / 6;
1432  NekMatrix<NekDouble> matVx(rows, cols, 0.0);
1433  for(int d=0, n=0; d<=degree; ++d)
1434  {
1435  for(int p=0; p <= d; ++p)
1436  {
1437  for(int q=0; q <= d - p; ++q, ++n)
1438  {
1439  int r = d - p - q;
1440  if(p > 0)
1441  {
1442  // Set n-th column of V to the monomial vector
1443  for(int i=0; i<rows; ++i)
1444  {
1445  matVx(i,n) = p * pow(x[i],p-1.0) * pow(y[i],q) * pow(z[i],r);
1446  }
1447  }
1448  else{
1449  for(int j=0; j<rows; ++j)
1450  {
1451  matVx(j, n) = 0.0;
1452  }
1453  }
1454  }
1455  }
1456  }
1457  return matVx;
1458  }
int GetSize(const NekVector< NekDouble > &x)
Definition: NodalUtil.cpp:116
NekMatrix< NekDouble > Nektar::LibUtilities::GetTetXDerivativeOfMonomialVandermonde ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y,
const NekVector< NekDouble > &  z 
)

Definition at line 1460 of file NodalUtil.cpp.

References GetSize(), GetTetDegree(), and GetTetXDerivativeOfMonomialVandermonde().

1462  {
1463  int rows = GetSize(x);
1464  int degree = GetTetDegree(rows);
1465  return GetTetXDerivativeOfMonomialVandermonde(x, y, z, degree);
1466  }
int GetTetDegree(int nBasisFunc)
Definition: NodalUtil.cpp:222
int GetSize(const NekVector< NekDouble > &x)
Definition: NodalUtil.cpp:116
NekMatrix< NekDouble > GetTetXDerivativeOfMonomialVandermonde(const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z)
Definition: NodalUtil.cpp:1460
Points< NekDouble >::MatrixSharedPtrType Nektar::LibUtilities::GetTetYDerivativeMatrix ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y,
const NekVector< NekDouble > &  z,
const NekVector< NekDouble > &  xi,
const NekVector< NekDouble > &  yi,
const NekVector< NekDouble > &  zi 
)

Definition at line 1047 of file NodalUtil.cpp.

References GetTetVandermonde(), GetVandermondeForTetYDerivative(), and Invert().

Referenced by Nektar::LibUtilities::NodalTetElec::CalculateDerivMatrix(), and Nektar::LibUtilities::NodalTetEvenlySpaced::CalculateDerivMatrix().

1049  {
1050  // int nNodes = GetSize(y);
1051 
1052  NekMatrix<NekDouble> matS = GetTetVandermonde(x, y, z); // Square 'short' matrix
1053 
1054  NekMatrix<NekDouble> matTy = GetVandermondeForTetYDerivative(xi, yi, zi); // Tall matrix
1055 
1056  NekMatrix<NekDouble> invertMatrix = Invert(matS);
1057 
1058  NekMatrix<NekDouble> makeDerivativeMatrix = matTy*invertMatrix;
1059 
1060  return Points<NekDouble>::MatrixSharedPtrType(new NekMatrix<NekDouble>(makeDerivativeMatrix));
1061 
1062  }
NekMatrix< NekDouble > GetVandermondeForTetYDerivative(const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z)
Definition: NodalUtil.cpp:1039
NekMatrix< NekDouble > GetTetVandermonde(const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z)
Definition: NodalUtil.cpp:507
boost::shared_ptr< NekMatrix< DataType > > MatrixSharedPtrType
Definition: Points.h:228
NekMatrix< NekDouble > Invert(const NekMatrix< NekDouble > &matA)
Definition: NodalUtil.cpp:79
NekMatrix< NekDouble > Nektar::LibUtilities::GetTetYDerivativeOfMonomialVandermonde ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y,
const NekVector< NekDouble > &  z,
int  degree 
)

Definition at line 1468 of file NodalUtil.cpp.

References GetSize().

Referenced by GetTetYDerivativeOfMonomialVandermonde().

1470  {
1471  int rows = GetSize(x);
1472  int cols = (degree + 1) * (degree + 2) * (degree + 3) / 6;
1473  NekMatrix<NekDouble> matVy(rows, cols, 0.0);
1474  for(int d=0, n=0; d<=degree; ++d)
1475  {
1476  for(int p=0; p <= d; ++p)
1477  {
1478  for(int q=0; q <= d - p; ++q, ++n)
1479  {
1480  int r = d - p - q;
1481  if(q > 0)
1482  {
1483  // Set n-th column of V to the monomial vector
1484  for(int i=0; i<rows; ++i)
1485  {
1486  matVy(i,n) = q * pow(x[i],p) * pow(y[i],q-1.0) * pow(z[i],r);
1487  }
1488  }
1489  else
1490  {
1491  for(int j=0; j<rows; ++j)
1492  {
1493  matVy(j, n) = 0.0;
1494  }
1495  }
1496  }
1497  }
1498  }
1499  return matVy;
1500  }
int GetSize(const NekVector< NekDouble > &x)
Definition: NodalUtil.cpp:116
NekMatrix< NekDouble > Nektar::LibUtilities::GetTetYDerivativeOfMonomialVandermonde ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y,
const NekVector< NekDouble > &  z 
)

Definition at line 1502 of file NodalUtil.cpp.

References GetSize(), GetTetDegree(), and GetTetYDerivativeOfMonomialVandermonde().

1504  {
1505  int rows = GetSize(x);
1506  int degree = GetTetDegree(rows);
1507  return GetTetYDerivativeOfMonomialVandermonde(x, y, z, degree);
1508  }
int GetTetDegree(int nBasisFunc)
Definition: NodalUtil.cpp:222
int GetSize(const NekVector< NekDouble > &x)
Definition: NodalUtil.cpp:116
NekMatrix< NekDouble > GetTetYDerivativeOfMonomialVandermonde(const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z)
Definition: NodalUtil.cpp:1502
Points< NekDouble >::MatrixSharedPtrType Nektar::LibUtilities::GetTetZDerivativeMatrix ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y,
const NekVector< NekDouble > &  z,
const NekVector< NekDouble > &  xi,
const NekVector< NekDouble > &  yi,
const NekVector< NekDouble > &  zi 
)

Definition at line 1195 of file NodalUtil.cpp.

References GetSize(), GetTetDegree(), GetTetVandermonde(), GetVandermondeForTetZDerivative(), Invert(), and TetZDerivative().

Referenced by Nektar::LibUtilities::NodalTetElec::CalculateDerivMatrix(), and Nektar::LibUtilities::NodalTetEvenlySpaced::CalculateDerivMatrix().

1197  {
1198  int nNodes = GetSize(z);
1199  int degree = GetTetDegree(nNodes);
1200 
1201 
1202  NekMatrix<NekDouble> matS = GetTetVandermonde(x, y, z); // Square 'short' matrix
1203 
1204  NekMatrix<NekDouble> matTz = GetVandermondeForTetZDerivative(xi, yi, zi, degree); // Tall matrix
1205 
1206  NekMatrix<NekDouble> invertMatrix = Invert(matS);
1207 
1208  NekMatrix<NekDouble> makeDerivativeMatrix = matTz*invertMatrix;
1209 
1211  TetZDerivative = Points<NekDouble>::MatrixSharedPtrType(new NekMatrix<NekDouble>(makeDerivativeMatrix));
1212 
1213  return TetZDerivative;
1214 
1215  }
int GetTetDegree(int nBasisFunc)
Definition: NodalUtil.cpp:222
int GetSize(const NekVector< NekDouble > &x)
Definition: NodalUtil.cpp:116
NekMatrix< NekDouble > GetVandermondeForTetZDerivative(const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z)
Definition: NodalUtil.cpp:1187
NekMatrix< NekDouble > GetTetVandermonde(const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z)
Definition: NodalUtil.cpp:507
NekVector< NekDouble > TetZDerivative(int p, int q, int r, const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z)
Definition: NodalUtil.cpp:1064
boost::shared_ptr< NekMatrix< DataType > > MatrixSharedPtrType
Definition: Points.h:228
NekMatrix< NekDouble > Invert(const NekMatrix< NekDouble > &matA)
Definition: NodalUtil.cpp:79
NekMatrix< NekDouble > Nektar::LibUtilities::GetTetZDerivativeOfMonomialVandermonde ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y,
const NekVector< NekDouble > &  z,
int  degree 
)

Definition at line 1510 of file NodalUtil.cpp.

References GetSize().

Referenced by GetTetZDerivativeOfMonomialVandermonde().

1512  {
1513  int rows = GetSize(x);
1514  int cols = (degree + 1) * (degree + 2) * (degree + 3) / 6;
1515  NekMatrix<NekDouble> matVz(rows, cols, 0.0);
1516  for(int d=0, n=0; d<=degree; ++d)
1517  {
1518  for(int p=0; p <= d; ++p)
1519  {
1520  for(int q=0; q <= d - p; ++q, ++n)
1521  {
1522  int r = d - p - q;
1523  if(r > 0)
1524  {
1525  // Set n-th column of V to the monomial vector
1526  for(int i=0; i<rows; ++i)
1527  {
1528  matVz(i,n) = r * pow(x[i],p) * pow(y[i],q) * pow(z[i],r-1.0);
1529  }
1530  }
1531  else{
1532  for(int j=0; j<rows; ++j)
1533  {
1534  matVz(j, n) = 0.0;
1535  }
1536  }
1537  }
1538  }
1539  }
1540  return matVz;
1541  }
int GetSize(const NekVector< NekDouble > &x)
Definition: NodalUtil.cpp:116
NekMatrix< NekDouble > Nektar::LibUtilities::GetTetZDerivativeOfMonomialVandermonde ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y,
const NekVector< NekDouble > &  z 
)

Definition at line 1543 of file NodalUtil.cpp.

References GetSize(), GetTetDegree(), and GetTetZDerivativeOfMonomialVandermonde().

1545  {
1546  int rows = GetSize(x);
1547  int degree = GetTetDegree(rows);
1548  return GetTetZDerivativeOfMonomialVandermonde(x, y, z, degree);
1549  }
int GetTetDegree(int nBasisFunc)
Definition: NodalUtil.cpp:222
int GetSize(const NekVector< NekDouble > &x)
Definition: NodalUtil.cpp:116
NekMatrix< NekDouble > GetTetZDerivativeOfMonomialVandermonde(const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z)
Definition: NodalUtil.cpp:1543
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...
NekMatrix< NekDouble > Nektar::LibUtilities::GetTranspose ( const NekMatrix< NekDouble > &  matA)

Definition at line 96 of file NodalUtil.cpp.

97  {
98  int rows = matA.GetRows(), columns = matA.GetColumns();
99  NekMatrix<NekDouble> matX(rows,columns);
100 
101  for( int i=0; i<rows; ++i )
102  {
103  for( int j=0; j<columns; ++j )
104  {
105  matX(j,i) = matA(i,j);
106  }
107  }
108  return matX;
109  }
int Nektar::LibUtilities::GetTriNumPoints ( int  degree)

Definition at line 202 of file NodalUtil.cpp.

Referenced by GetDegree().

203  {
204  return (degree+1) * (degree+2) / 2;
205  }
NekMatrix< NekDouble > Nektar::LibUtilities::GetVandermonde ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y,
int  degree 
)

Definition at line 515 of file NodalUtil.cpp.

References DubinerPoly(), and GetSize().

Referenced by GetInterpolationMatrix(), GetVandermonde(), GetXDerivativeMatrix(), GetYDerivativeMatrix(), and MakeVmatrixOfDubinerPolynomial().

516  {
517  int rows = GetSize(x);
518  int cols = (degree + 1) * (degree + 2) / 2;
519 
520  NekMatrix<NekDouble> matV(rows, cols, 0.0);
521 
522  for(int d=0, n=0; d<=degree; ++d)
523  {
524  for(int p=0; p<=d; ++p, ++n)
525  {
526  int q = d - p;
527  NekVector<NekDouble> columnVector = DubinerPoly(p, q, x, y);
528 
529  // Set n-th column of V to the DubinerPoly vector
530  for(int i=0; i<rows; ++i)
531  {
532  matV(i,n) = columnVector[i];
533  }
534  }
535  }
536 
537  return matV;
538  }
int GetSize(const NekVector< NekDouble > &x)
Definition: NodalUtil.cpp:116
NekVector< NekDouble > DubinerPoly(int p, int q, const NekVector< NekDouble > &x, const NekVector< NekDouble > &y)
Definition: NodalUtil.cpp:375
NekMatrix< NekDouble > Nektar::LibUtilities::GetVandermonde ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y 
)

Definition at line 540 of file NodalUtil.cpp.

References GetDegree(), GetSize(), and GetVandermonde().

541  {
542  int rows = GetSize(x);
543  int degree = GetDegree(rows);
544  return GetVandermonde( x, y, degree );
545  }
int GetDegree(int nBasisFunctions)
Definition: NodalUtil.cpp:207
int GetSize(const NekVector< NekDouble > &x)
Definition: NodalUtil.cpp:116
NekMatrix< NekDouble > GetVandermonde(const NekVector< NekDouble > &x, const NekVector< NekDouble > &y)
Definition: NodalUtil.cpp:540
NekMatrix< NekDouble > Nektar::LibUtilities::GetVandermondeForTetXDerivative ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y,
const NekVector< NekDouble > &  z,
int  degree 
)

Definition at line 772 of file NodalUtil.cpp.

References GetSize(), and TetXDerivative().

Referenced by GetTetXDerivativeMatrix(), and GetVandermondeForTetXDerivative().

774  {
775  int rows = GetSize(x);
776  int cols = (degree + 1) * (degree + 2) * (degree + 3)/6;
777  NekMatrix<NekDouble> matVx(rows, cols, 0.0);
778 
779  for(int d=0, n=0; d<=degree; ++d)
780  {
781  for(int p=0; p <= d; ++p)
782  {
783  for(int q=0; q <= d - p; ++q, ++n)
784  {
785  int r = d - p - q;
786  NekVector<NekDouble> columnVector = TetXDerivative(p, q, r, x, y, z);
787 
788  // Set n-th column of V to the TetrahedralBasis vector
789  for(int i=0; i<rows; ++i)
790  {
791  matVx(i,n) = columnVector[i];
792  }
793  }
794  }
795  }
796  return matVx;
797  }
int GetSize(const NekVector< NekDouble > &x)
Definition: NodalUtil.cpp:116
NekVector< NekDouble > TetXDerivative(int p, int q, int r, const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z)
Definition: NodalUtil.cpp:711
NekMatrix< NekDouble > Nektar::LibUtilities::GetVandermondeForTetXDerivative ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y,
const NekVector< NekDouble > &  z 
)

Definition at line 799 of file NodalUtil.cpp.

References GetSize(), GetTetDegree(), and GetVandermondeForTetXDerivative().

800  {
801  int rows = GetSize(x);
802  int degree = GetTetDegree(rows);
803  return GetVandermondeForTetXDerivative(x, y, z, degree);
804  }
NekMatrix< NekDouble > GetVandermondeForTetXDerivative(const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z)
Definition: NodalUtil.cpp:799
int GetTetDegree(int nBasisFunc)
Definition: NodalUtil.cpp:222
int GetSize(const NekVector< NekDouble > &x)
Definition: NodalUtil.cpp:116
NekMatrix< NekDouble > Nektar::LibUtilities::GetVandermondeForTetYDerivative ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y,
const NekVector< NekDouble > &  z,
int  degree 
)

Definition at line 1013 of file NodalUtil.cpp.

References GetSize(), and TetYDerivative().

Referenced by GetTetYDerivativeMatrix(), and GetVandermondeForTetYDerivative().

1014  {
1015  int rows = GetSize(y);
1016  int cols = (degree + 1) * (degree + 2) * (degree + 3)/6;
1017  NekMatrix<NekDouble> matVy(rows, cols, 0.0);
1018 
1019  for(int d=0, n=0; d<=degree; ++d)
1020  {
1021  for(int p=0; p <= d; ++p)
1022  {
1023  for(int q=0; q <= d - p; ++q, ++n)
1024  {
1025  int r = d - p - q;
1026  NekVector<NekDouble> columnVector = TetYDerivative(p, q, r, x, y, z);
1027 
1028  // Set n-th column of V to the TetrahedralBasis vector
1029  for(int i=0; i<rows; ++i)
1030  {
1031  matVy(i,n) = columnVector[i];
1032  }
1033  }
1034  }
1035  }
1036  return matVy;
1037  }
NekVector< NekDouble > TetYDerivative(int p, int q, int r, const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z)
Definition: NodalUtil.cpp:886
int GetSize(const NekVector< NekDouble > &x)
Definition: NodalUtil.cpp:116
NekMatrix< NekDouble > Nektar::LibUtilities::GetVandermondeForTetYDerivative ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y,
const NekVector< NekDouble > &  z 
)

Definition at line 1039 of file NodalUtil.cpp.

References GetSize(), GetTetDegree(), and GetVandermondeForTetYDerivative().

1041  {
1042  int rows = GetSize(y);
1043  int degree = GetTetDegree(rows);
1044  return GetVandermondeForTetYDerivative(x, y, z, degree);
1045  }
NekMatrix< NekDouble > GetVandermondeForTetYDerivative(const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z)
Definition: NodalUtil.cpp:1039
int GetTetDegree(int nBasisFunc)
Definition: NodalUtil.cpp:222
int GetSize(const NekVector< NekDouble > &x)
Definition: NodalUtil.cpp:116
NekMatrix< NekDouble > Nektar::LibUtilities::GetVandermondeForTetZDerivative ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y,
const NekVector< NekDouble > &  z,
int  degree 
)

Definition at line 1161 of file NodalUtil.cpp.

References GetSize(), and TetZDerivative().

Referenced by GetTetZDerivativeMatrix(), and GetVandermondeForTetZDerivative().

1162  {
1163  int rows = GetSize(z);
1164  int cols = (degree + 1) * (degree + 2) * (degree + 3)/6;
1165  NekMatrix<NekDouble> matVz(rows, cols, 0.0);
1166 
1167  for(int d=0, n=0; d<=degree; ++d)
1168  {
1169  for(int p=0; p <= d; ++p)
1170  {
1171  for(int q=0; q <= d - p; ++q, ++n)
1172  {
1173  int r = d - p - q;
1174  NekVector<NekDouble> columnVector = TetZDerivative(p, q, r, x, y, z);
1175 
1176  // Set n-th column of V to the TetrahedralBasis vector
1177  for(int i=0; i<rows; ++i)
1178  {
1179  matVz(i,n) = columnVector[i];
1180  }
1181  }
1182  }
1183  }
1184  return matVz;
1185  }
int GetSize(const NekVector< NekDouble > &x)
Definition: NodalUtil.cpp:116
NekVector< NekDouble > TetZDerivative(int p, int q, int r, const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z)
Definition: NodalUtil.cpp:1064
NekMatrix< NekDouble > Nektar::LibUtilities::GetVandermondeForTetZDerivative ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y,
const NekVector< NekDouble > &  z 
)

Definition at line 1187 of file NodalUtil.cpp.

References GetSize(), GetTetDegree(), and GetVandermondeForTetZDerivative().

1189  {
1190  int rows = GetSize(z);
1191  int degree = GetTetDegree(rows);
1192  return GetVandermondeForTetZDerivative(x, y, z, degree);
1193  }
int GetTetDegree(int nBasisFunc)
Definition: NodalUtil.cpp:222
int GetSize(const NekVector< NekDouble > &x)
Definition: NodalUtil.cpp:116
NekMatrix< NekDouble > GetVandermondeForTetZDerivative(const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z)
Definition: NodalUtil.cpp:1187
NekMatrix< NekDouble > Nektar::LibUtilities::GetVandermondeForXDerivative ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y,
int  degree 
)

Definition at line 821 of file NodalUtil.cpp.

References DubinerPolyXDerivative(), and GetSize().

Referenced by GetVandermondeForXDerivative(), and GetXDerivativeMatrix().

822  {
823  int rows = GetSize(x);
824  int cols = (degree + 1) * (degree + 2)/2;
825  NekMatrix<NekDouble> matVx(rows, cols, 0.0);
826  for(int d=0, n=0; d<=degree; ++d)
827  {
828  for(int p=0; p<=d; ++p, ++n)
829  {
830  int q = d - p;
831  NekVector<NekDouble> columnVector = DubinerPolyXDerivative(p, q, x, y);
832 
833  // Set n-th column of Vx to the DubinerPolyXDerivative vector
834  for(int i=0; i<rows; ++i)
835  {
836  matVx(i, n) = columnVector[i];
837  }
838  }
839  }
840 
841  return matVx;
842  }
int GetSize(const NekVector< NekDouble > &x)
Definition: NodalUtil.cpp:116
NekVector< NekDouble > DubinerPolyXDerivative(int p, int q, const NekVector< NekDouble > &x, const NekVector< NekDouble > &y)
Definition: NodalUtil.cpp:664
NekMatrix< NekDouble > Nektar::LibUtilities::GetVandermondeForXDerivative ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y 
)

Definition at line 845 of file NodalUtil.cpp.

References GetDegree(), GetSize(), and GetVandermondeForXDerivative().

846  {
847  int rows = GetSize(x);
848  int degree = GetDegree(rows);
849  return GetVandermondeForXDerivative(x, y, degree);
850  }
int GetDegree(int nBasisFunctions)
Definition: NodalUtil.cpp:207
int GetSize(const NekVector< NekDouble > &x)
Definition: NodalUtil.cpp:116
NekMatrix< NekDouble > GetVandermondeForXDerivative(const NekVector< NekDouble > &x, const NekVector< NekDouble > &y)
Definition: NodalUtil.cpp:845
NekMatrix< NekDouble > Nektar::LibUtilities::GetVandermondeForYDerivative ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y,
int  degree 
)

Definition at line 1280 of file NodalUtil.cpp.

References DubinerPolyYDerivative(), and GetSize().

Referenced by GetVandermondeForYDerivative(), and GetYDerivativeMatrix().

1281  {
1282  int rows = GetSize(y);
1283  int cols = (degree + 1) * (degree + 2)/2;
1284  NekMatrix<NekDouble> matVy(rows, cols, 0.0);
1285 
1286  for(int d=0, n=0; d<=degree; ++d)
1287  {
1288  for(int p=0; p<=d; ++p, ++n)
1289  {
1290  int q = d - p;
1291  NekVector<NekDouble> columnVector = DubinerPolyYDerivative(p, q, x, y);
1292 
1293  for(int i=0; i<rows; ++i)
1294  {
1295  matVy(i, n) = columnVector[i];
1296  }
1297  }
1298  }
1299  return matVy;
1300  }
int GetSize(const NekVector< NekDouble > &x)
Definition: NodalUtil.cpp:116
NekVector< NekDouble > DubinerPolyYDerivative(int p, int q, const NekVector< NekDouble > &x, const NekVector< NekDouble > &y)
Definition: NodalUtil.cpp:1217
NekMatrix< NekDouble > Nektar::LibUtilities::GetVandermondeForYDerivative ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y 
)

Definition at line 1320 of file NodalUtil.cpp.

References GetDegree(), GetSize(), and GetVandermondeForYDerivative().

1321  {
1322  int rows = GetSize(y);
1323  int degree = GetDegree(rows);
1324  return GetVandermondeForYDerivative(x, y, degree);
1325  }
int GetDegree(int nBasisFunctions)
Definition: NodalUtil.cpp:207
int GetSize(const NekVector< NekDouble > &x)
Definition: NodalUtil.cpp:116
NekMatrix< NekDouble > GetVandermondeForYDerivative(const NekVector< NekDouble > &x, const NekVector< NekDouble > &y)
Definition: NodalUtil.cpp:1320
Points< NekDouble >::MatrixSharedPtrType Nektar::LibUtilities::GetXDerivativeMatrix ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y,
const NekVector< NekDouble > &  xi,
const NekVector< NekDouble > &  yi 
)

Definition at line 852 of file NodalUtil.cpp.

References GetDegree(), GetSize(), GetVandermonde(), GetVandermondeForXDerivative(), and Invert().

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

854  {
855  int nNodes = GetSize(x);
856  int degree = GetDegree(nNodes);
857  NekMatrix<NekDouble> matS = GetVandermonde(x, y); // Square 'short' matrix
858  NekMatrix<NekDouble> matTx = GetVandermondeForXDerivative(xi, yi, degree); // Tall matrix
859 
860  NekMatrix<NekDouble> invertMatrix = Invert(matS);
861 
862  // Get the Derivation matrix
863  return Points<NekDouble>::MatrixSharedPtrType( new NekMatrix<NekDouble>(matTx*invertMatrix) );
864  }
int GetDegree(int nBasisFunctions)
Definition: NodalUtil.cpp:207
int GetSize(const NekVector< NekDouble > &x)
Definition: NodalUtil.cpp:116
boost::shared_ptr< NekMatrix< DataType > > MatrixSharedPtrType
Definition: Points.h:228
NekMatrix< NekDouble > Invert(const NekMatrix< NekDouble > &matA)
Definition: NodalUtil.cpp:79
NekMatrix< NekDouble > GetVandermonde(const NekVector< NekDouble > &x, const NekVector< NekDouble > &y)
Definition: NodalUtil.cpp:540
NekMatrix< NekDouble > GetVandermondeForXDerivative(const NekVector< NekDouble > &x, const NekVector< NekDouble > &y)
Definition: NodalUtil.cpp:845
NekMatrix< NekDouble > Nektar::LibUtilities::GetXDerivativeOfMonomialVandermonde ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y,
int  degree 
)

Definition at line 1389 of file NodalUtil.cpp.

References GetSize().

Referenced by GetXDerivativeOfMonomialVandermonde().

1390  {
1391  int rows = GetSize(x);
1392  int cols = (degree + 1) * (degree + 2) / 2;
1393  NekMatrix<NekDouble> matVx(rows, cols, 0.0);
1394 
1395  for(int d=0, n=0; d <= degree; ++d)
1396  {
1397  for(int p=0; p <= d; ++p, ++n)
1398  {
1399  int q = d - p;
1400 
1401  if(p > 0)
1402  {
1403  for(int i=0; i<rows; ++i)
1404  {
1405  matVx(i, n) = p * pow(x[i], p-1.0) * pow(y[i],q);
1406  }
1407  }
1408  else
1409  {
1410  for(int j=0; j<rows; ++j)
1411  {
1412  matVx(j, n) = 0.0;
1413  }
1414  }
1415  }
1416  }
1417  return matVx;
1418  }
int GetSize(const NekVector< NekDouble > &x)
Definition: NodalUtil.cpp:116
NekMatrix< NekDouble > Nektar::LibUtilities::GetXDerivativeOfMonomialVandermonde ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y 
)

Definition at line 1420 of file NodalUtil.cpp.

References GetDegree(), GetSize(), and GetXDerivativeOfMonomialVandermonde().

1421  {
1422  int rows = GetSize(x);
1423  int degree = GetDegree(rows);
1424  return GetXDerivativeOfMonomialVandermonde(x, y, degree);
1425  }
NekMatrix< NekDouble > GetXDerivativeOfMonomialVandermonde(const NekVector< NekDouble > &x, const NekVector< NekDouble > &y)
Definition: NodalUtil.cpp:1420
int GetDegree(int nBasisFunctions)
Definition: NodalUtil.cpp:207
int GetSize(const NekVector< NekDouble > &x)
Definition: NodalUtil.cpp:116
Points< NekDouble >::MatrixSharedPtrType Nektar::LibUtilities::GetYDerivativeMatrix ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y,
const NekVector< NekDouble > &  xi,
const NekVector< NekDouble > &  yi 
)

Definition at line 1303 of file NodalUtil.cpp.

References GetDegree(), GetSize(), GetVandermonde(), GetVandermondeForYDerivative(), and Invert().

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

1305  {
1306  int nNodes = GetSize(y);
1307  int degree = GetDegree(nNodes);
1308 
1309  NekMatrix<NekDouble> matS = GetVandermonde(x, y); // Square 'short' matrix
1310  NekMatrix<NekDouble> matTy = GetVandermondeForYDerivative(xi, yi, degree); // Tall matrix
1311 
1312  NekMatrix<NekDouble> invertMatrix = Invert(matS);
1313 
1314 
1315  // Get the Derivation matrix
1316  return Points<NekDouble>::MatrixSharedPtrType( new NekMatrix<NekDouble>(matTy*invertMatrix) );
1317  }
int GetDegree(int nBasisFunctions)
Definition: NodalUtil.cpp:207
int GetSize(const NekVector< NekDouble > &x)
Definition: NodalUtil.cpp:116
boost::shared_ptr< NekMatrix< DataType > > MatrixSharedPtrType
Definition: Points.h:228
NekMatrix< NekDouble > GetVandermondeForYDerivative(const NekVector< NekDouble > &x, const NekVector< NekDouble > &y)
Definition: NodalUtil.cpp:1320
NekMatrix< NekDouble > Invert(const NekMatrix< NekDouble > &matA)
Definition: NodalUtil.cpp:79
NekMatrix< NekDouble > GetVandermonde(const NekVector< NekDouble > &x, const NekVector< NekDouble > &y)
Definition: NodalUtil.cpp:540
NekMatrix< NekDouble > Nektar::LibUtilities::GetYDerivativeOfMonomialVandermonde ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y,
int  degree 
)

Definition at line 1551 of file NodalUtil.cpp.

References GetSize().

Referenced by GetYDerivativeOfMonomialVandermonde().

1552  {
1553  int rows = GetSize(x);
1554  int cols = (degree + 1) * (degree + 2) / 2;
1555  NekMatrix<NekDouble> matVy(rows, cols, 0.0);
1556 
1557  for(int d=0, n=0; d <= degree; ++d)
1558  {
1559  for(int p=0; p <= d; ++p, ++n)
1560  {
1561  int q = d - p;
1562  if(q > 0)
1563  {
1564  for(int i=0; i<rows; ++i)
1565  {
1566  matVy(i, n) = q * pow(x[i], p) * pow(y[i], q-1.0);
1567  }
1568  }
1569  else
1570  {
1571  for(int j=0; j<rows; ++j)
1572  {
1573  matVy(j, n) = 0.0;
1574  }
1575  }
1576  }
1577  }
1578  return matVy;
1579  }
int GetSize(const NekVector< NekDouble > &x)
Definition: NodalUtil.cpp:116
NekMatrix< NekDouble > Nektar::LibUtilities::GetYDerivativeOfMonomialVandermonde ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y 
)

Definition at line 1581 of file NodalUtil.cpp.

References GetDegree(), GetSize(), and GetYDerivativeOfMonomialVandermonde().

1582  {
1583  int rows = GetSize(x);
1584  int degree = GetDegree(rows);
1585  return GetYDerivativeOfMonomialVandermonde(x, y, degree);
1586  }
int GetDegree(int nBasisFunctions)
Definition: NodalUtil.cpp:207
int GetSize(const NekVector< NekDouble > &x)
Definition: NodalUtil.cpp:116
NekMatrix< NekDouble > GetYDerivativeOfMonomialVandermonde(const NekVector< NekDouble > &x, const NekVector< NekDouble > &y)
Definition: NodalUtil.cpp:1581
NekVector< NekDouble > Nektar::LibUtilities::Hadamard ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y 
)

Definition at line 131 of file NodalUtil.cpp.

References GetSize().

Referenced by LegendrePoly(), LegendrePolyDerivative(), TetYDerivative(), and TetZDerivative().

132  {
133  int size = GetSize(x);
134  NekVector<NekDouble> z(size);
135 
136  for( int i=0; i<size; ++i )
137  {
138  z[i] = x[i] * y[i];
139  }
140  return z;
141  }
int GetSize(const NekVector< NekDouble > &x)
Definition: NodalUtil.cpp:116
void Nektar::LibUtilities::Import ( const string &  inFile,
PtsFieldSharedPtr &  ptsField 
)

Definition at line 56 of file PtsIO.cpp.

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

57 {
58 #ifdef NEKTAR_USE_MPI
59  int size;
60  int init;
61  MPI_Initialized(&init);
62 
63  // If MPI has been initialised we can check the number of processes
64  // and, if > 1, tell the user he should not be running this
65  // function in parallel. If it is not initialised, we do not
66  // initialise it here, and assume the user knows what they are
67  // doing.
68  if (init)
69  {
70  MPI_Comm_size(MPI_COMM_WORLD, &size);
71  ASSERTL0(size == 1,
72  "This static function is not available in parallel. Please "
73  "instantiate a FieldIO object for parallel use.");
74  }
75 #endif
76  CommSharedPtr c = GetCommFactory().CreateInstance("Serial", 0, 0);
77  PtsIO p(c);
78  p.Import(inFile, ptsField);
79 }
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:188
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
CommFactory & GetCommFactory()
Definition: Comm.cpp:64
boost::shared_ptr< Comm > CommSharedPtr
Pointer to a Communicator object.
Definition: Comm.h:53
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 
)

Imports an FLD file.

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.

Definition at line 115 of file FieldIO.cpp.

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

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

121  {
122 #ifdef NEKTAR_USE_MPI
123  int size;
124  int init;
125  MPI_Initialized(&init);
126 
127  // If MPI has been initialised we can check the number of processes
128  // and, if > 1, tell the user he should not be running this
129  // function in parallel. If it is not initialised, we do not
130  // initialise it here, and assume the user knows what they are
131  // doing.
132  if (init)
133  {
134  MPI_Comm_size( MPI_COMM_WORLD, &size );
135  ASSERTL0(size == 1,
136  "This static function is not available in parallel. Please"
137  "instantiate a FieldIO object for parallel use.");
138  }
139 #endif
140  CommSharedPtr c = GetCommFactory().CreateInstance("Serial", 0, 0);
141  FieldIO f(c);
142  f.Import(infilename, fielddefs, fielddata, fieldinfomap, ElementiDs);
143  }
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:188
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
CommFactory & GetCommFactory()
Definition: Comm.cpp:64
boost::shared_ptr< Comm > CommSharedPtr
Pointer to a Communicator object.
Definition: Comm.h:53
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:1047
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:1047
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::Utilities::ProcessEquiSpacedOutput::GenOrthoModes(), Nektar::Utilities::ProcessQualityMetric::GetQ(), Nektar::SpatialDomains::GeomFactors::Interp(), Interp2D(), Nektar::SolverUtils::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:1047
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::Utilities::ProcessQualityMetric::GetQ(), Nektar::SpatialDomains::GeomFactors::Interp(), Interp3D(), 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(), 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:188
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:1047
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:1047
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)
NekMatrix< NekDouble > Nektar::LibUtilities::Invert ( const NekMatrix< NekDouble > &  matA)

Definition at line 79 of file NodalUtil.cpp.

References GetE(), SetColumn(), and Nektar::LinearSystem::Solve().

Referenced by GetInterpolationMatrix(), GetTetInterpolationMatrix(), GetTetXDerivativeMatrix(), GetTetYDerivativeMatrix(), GetTetZDerivativeMatrix(), GetXDerivativeMatrix(), and GetYDerivativeMatrix().

80  {
81  int rows = matA.GetRows(), columns = matA.GetColumns();
82  NekMatrix<NekDouble> matX(rows,columns);
83 
84  // The linear system solver
85  LinearSystem matL( SharedNekMatrixPtr(new NekMatrix<NekDouble>(matA)) );
86 
87  // Solve each column for the identity matrix
88  for( int j=0; j<columns; ++j )
89  {
90  SetColumn( matX, j, matL.Solve( GetE(rows,j) ) );
91  }
92 
93  return matX;
94  }
NekVector< NekDouble > GetE(int rows, int n)
Definition: NodalUtil.cpp:72
NekMatrix< NekDouble > & SetColumn(NekMatrix< NekDouble > &matA, int n, const NekVector< NekDouble > &x)
Definition: NodalUtil.cpp:62
boost::shared_ptr< NekMatrix< NekDouble, StandardMatrixTag > > SharedNekMatrixPtr
NekVector< NekDouble > Nektar::LibUtilities::JacobiPoly ( int  degree,
const NekVector< NekDouble > &  x,
NekDouble  alpha,
NekDouble  beta 
)

Definition at line 253 of file NodalUtil.cpp.

References GetSize().

Referenced by DubinerPoly(), DubinerPolyXDerivative(), DubinerPolyYDerivative(), JacobiPoly(), JacobiPolyDerivative(), TetrahedralBasis(), TetXDerivative(), TetYDerivative(), and TetZDerivative().

254  {
255  int size = GetSize(x);
256  NekVector<NekDouble> y(size);
257 
258  if(degree == 0)
259  {
260  // Set y to ones
261  y = NekVector<NekDouble>(size, 1.0);
262 
263  }
264  else if (degree == 1)
265  {
266  for(int el=0; el<size; ++el)
267  {
268  y[el] = 0.5*(alpha - beta + (alpha + beta + 2.0) * x[el]);
269  }
270 
271  }
272  else if (degree > 1)
273  {
274  NekDouble degm1 = degree - 1.0;
275  NekDouble tmp = 2.0 * degm1 + alpha + beta;
276  NekDouble a1 = 2.0 * (degm1 + 1.0) * (degm1 + alpha + beta + 1.0) * tmp;
277  NekDouble a2 = (tmp + 1.0) * (alpha * alpha - beta * beta);
278  NekDouble a3 = tmp * (tmp + 1.0) * (tmp + 2.0);
279  NekDouble a4 = 2.0 * (degm1 + alpha) * (degm1 + beta) * (tmp + 2.0);
280 
281  // TODO: Make this efficient: Reuse the degree-2 for the degree-1 call.
282  // This can be done in linear time, but it is currently implemented to run in exponential time.
283  NekVector<NekDouble> z2 = JacobiPoly(degree-2, x, alpha, beta);
284  NekVector<NekDouble> z1 = JacobiPoly(degree-1, x, alpha, beta);
285 
286  for (int el=0; el<size; ++el)
287  {
288  y[el] = ((a2 + a3 * x[el]) * z1[el] - a4 * z2[el])/a1;
289  }
290 
291  }
292  else
293  {
294  cerr << "Bad degree" << endl;
295  }
296 
297  return y;
298  }
int GetSize(const NekVector< NekDouble > &x)
Definition: NodalUtil.cpp:116
double NekDouble
NekDouble JacobiPoly(int degree, NekDouble x, NekDouble alpha, NekDouble beta)
Definition: NodalUtil.cpp:300
NekDouble Nektar::LibUtilities::JacobiPoly ( int  degree,
NekDouble  x,
NekDouble  alpha,
NekDouble  beta 
)

Definition at line 300 of file NodalUtil.cpp.

References JacobiPoly().

301  {
302  NekDouble y = 0.0;
303 
304  if(degree == 0)
305  {
306  y = 1.0;
307  }
308 
309  else if (degree == 1)
310  {
311  y = 0.5*(alpha - beta + (alpha + beta + 2.0) * x);
312  }
313 
314  else if (degree > 1)
315  {
316  NekDouble degm1 = degree - 1.0;
317  NekDouble tmp = 2.0 * degm1 + alpha + beta;
318  NekDouble a1 = 2.0 * (degm1 + 1.0) * (degm1 + alpha + beta + 1.0) * tmp;
319  NekDouble a2 = (tmp + 1.0) * (alpha * alpha - beta * beta);
320  NekDouble a3 = tmp * (tmp + 1.0) * (tmp + 2.0);
321  NekDouble a4 = 2.0 * (degm1 + alpha) * (degm1 + beta) * (tmp + 2.0);
322 
323  // TODO: Make this efficient: Reuse the degree-2 for the degree-1 call.
324  // This can be done in linear time, but it is currently implemented to run in exponential time.
325  NekDouble z2 = JacobiPoly(degree-2, x, alpha, beta);
326  NekDouble z1 = JacobiPoly(degree-1, x, alpha, beta);
327 
328  y = ((a2 + a3 * x) * z1 - a4 * z2)/a1;
329  }
330 
331  else
332  {
333  cerr << "Bad degree" << endl;
334  }
335 
336  return y;
337  }
double NekDouble
NekDouble JacobiPoly(int degree, NekDouble x, NekDouble alpha, NekDouble beta)
Definition: NodalUtil.cpp:300
NekVector< NekDouble > Nektar::LibUtilities::JacobiPolyDerivative ( int  degree,
const NekVector< NekDouble > &  x,
int  alpha,
int  beta 
)

Definition at line 867 of file NodalUtil.cpp.

References GetSize(), and JacobiPoly().

Referenced by DubinerPolyYDerivative(), TetYDerivative(), and TetZDerivative().

868  {
869  int size = GetSize(x);
870  NekVector<NekDouble> y(size);
871 
872  if(degree == 0)
873  {
874  y = NekVector<NekDouble>(size, 0.0);
875 
876  }
877  else
878  {
879  y = 0.5 * (alpha + beta + degree + 1) * JacobiPoly(degree - 1, x, alpha + 1, beta + 1);
880  }
881  return y;
882  }
int GetSize(const NekVector< NekDouble > &x)
Definition: NodalUtil.cpp:116
NekDouble JacobiPoly(int degree, NekDouble x, NekDouble alpha, NekDouble beta)
Definition: NodalUtil.cpp:300
NekVector< NekDouble > Nektar::LibUtilities::LegendrePoly ( int  degree,
const NekVector< NekDouble > &  x 
)

Definition at line 340 of file NodalUtil.cpp.

References GetSize(), and Hadamard().

Referenced by DubinerPoly(), DubinerPolyYDerivative(), TetrahedralBasis(), TetYDerivative(), and TetZDerivative().

341  {
342  int size = GetSize(x);
343  NekVector<NekDouble> y(size);
344 
345  if(degree > 1)
346  {
347  NekVector<NekDouble> a0(size, 1.0);
348  NekVector<NekDouble> a1 = x;
349  NekVector<NekDouble> a2(size);
350 
351  for(int i=2; i<=degree; ++i)
352  {
353  NekDouble b = NekDouble(2.0*i-1.0)/i;
354  NekDouble c = NekDouble(i-1.0)/i;
355 
356  // multiply each elements in matrix
357  a2 = b * Hadamard(a1, x) - c * a0;
358  a0 = a1;
359  a1 = a2;
360  }
361  y = a2;
362  }
363  else if( degree == 1 )
364  {
365  y = x;
366  }
367  else
368  {
369  y = NekVector<NekDouble>(size, 1.0);
370  }
371  return y;
372  }
int GetSize(const NekVector< NekDouble > &x)
Definition: NodalUtil.cpp:116
NekVector< NekDouble > Hadamard(const NekVector< NekDouble > &x, const NekVector< NekDouble > &y)
Definition: NodalUtil.cpp:131
double NekDouble
NekVector< NekDouble > Nektar::LibUtilities::LegendrePolyDerivative ( int  degree,
const NekVector< NekDouble > &  x 
)

Definition at line 624 of file NodalUtil.cpp.

References GetSize(), and Hadamard().

Referenced by DubinerPolyXDerivative(), DubinerPolyYDerivative(), TetXDerivative(), TetYDerivative(), and TetZDerivative().

625  {
626  int size = GetSize(x);
627  NekVector<NekDouble> y(size), b3(size), a2(size);
628 
629  if(degree >= 3)
630  {
631  NekVector<NekDouble> b0(size, 0.0), b1(size, 1.0), b2 = 3.0 * x;
632  NekVector<NekDouble> a0(size, 1.0), a1 = x;
633 
634  for(int n=3; n<=degree; ++n)
635  {
636  a2 = ((2.0*n - 3.0)/(n - 1.0)) * Hadamard(x, a1) - (n - 2.0)/(n - 1.0) * a0;
637  a0 = a1;
638  a1 = a2;
639 
640  b3 = (2.0*n - 1.0)/n * (Hadamard(b2, x) + a2) - (n - 1.0)/n * b1;
641  b1 = b2;
642  b2 = b3;
643  }
644  y = b3;
645 
646  }
647  else if(degree == 2)
648  {
649  y = 3.0 * x;
650  }
651  else if(degree == 1)
652  {
653  y = NekVector<NekDouble>(size, 1.0);
654 
655  }
656  else
657  {
658  y = NekVector<NekDouble>(size, 0.0);
659  }
660  return y;
661  }
int GetSize(const NekVector< NekDouble > &x)
Definition: NodalUtil.cpp:116
NekVector< NekDouble > Hadamard(const NekVector< NekDouble > &x, const NekVector< NekDouble > &y)
Definition: NodalUtil.cpp:131
NekVector< NekDouble > Nektar::LibUtilities::MakeDubinerQuadratureSystem ( int  nBasisFunctions)

Definition at line 236 of file NodalUtil.cpp.

Referenced by MakeQuadratureWeights().

237  {
238  // Make the vector of integrals: note that each modal basis function integrates to zero except for the 0th degree
239  NekVector<NekDouble> g(nBasisFunctions, 0.0);
240  g(0) = sqrt(2.0);
241 
242  return g;
243  }
NekVector< NekDouble > Nektar::LibUtilities::MakeQuadratureWeights ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y 
)

Definition at line 579 of file NodalUtil.cpp.

References Nektar::NekVector< DataType >::GetRows(), MakeDubinerQuadratureSystem(), MakeVmatrixOfDubinerPolynomial(), and Nektar::LinearSystem::SolveTranspose().

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

580  {
581 
582  NekVector<NekDouble> g = MakeDubinerQuadratureSystem(x.GetRows());
583 
585 
586  // Initialize the linear system solver
587  LinearSystem matL(matV);
588 
589  // Deduce the quadrature weights
590  return matL.SolveTranspose(g);
591 
592  }
NekVector< NekDouble > MakeDubinerQuadratureSystem(int nBasisFunctions)
Definition: NodalUtil.cpp:236
SharedNekMatrixPtr MakeVmatrixOfDubinerPolynomial(const NekVector< NekDouble > &x, const NekVector< NekDouble > &y)
Definition: NodalUtil.cpp:554
boost::shared_ptr< NekMatrix< NekDouble, StandardMatrixTag > > SharedNekMatrixPtr
NekDouble Nektar::LibUtilities::MakeRound ( NekDouble  x)

Definition at line 231 of file NodalUtil.cpp.

Referenced by GetDegree(), GetTetDegree(), MatrixToString(), and VectorToString().

232  {
233  return floor(x + 0.5);
234  }
NekVector< NekDouble > Nektar::LibUtilities::MakeTetQuadratureSystem ( int  nBasisFunctions)

Definition at line 245 of file NodalUtil.cpp.

Referenced by MakeTetWeights().

246  {
247  NekVector<NekDouble> g(nBasisFunctions, 0.0);
248  g(0) = 1.0;
249  return g;
250  }
NekVector< NekDouble > Nektar::LibUtilities::MakeTetWeights ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y,
const NekVector< NekDouble > &  z 
)

Definition at line 562 of file NodalUtil.cpp.

References Nektar::NekVector< DataType >::GetRows(), MakeTetQuadratureSystem(), MakeVmatrixOfTet(), and Nektar::LinearSystem::SolveTranspose().

Referenced by Nektar::LibUtilities::NodalTetElec::CalculateWeights(), and Nektar::LibUtilities::NodalTetEvenlySpaced::CalculateWeights().

563  {
564 
565  NekVector<NekDouble> g = MakeTetQuadratureSystem(x.GetRows());
566 
567  SharedNekMatrixPtr matV = MakeVmatrixOfTet(x, y, z);
568 
569  // Initialize the linear system solver
570  LinearSystem matL(matV);
571 
572 
573  // Deduce the quadrature weights
574  NekVector<NekDouble> w = matL.SolveTranspose(g);
575 
576  return w;
577  }
NekVector< NekDouble > MakeTetQuadratureSystem(int nBasisFunctions)
Definition: NodalUtil.cpp:245
SharedNekMatrixPtr MakeVmatrixOfTet(const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z)
Definition: NodalUtil.cpp:547
boost::shared_ptr< NekMatrix< NekDouble, StandardMatrixTag > > SharedNekMatrixPtr
SharedNekMatrixPtr Nektar::LibUtilities::MakeVmatrixOfDubinerPolynomial ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y 
)

Definition at line 554 of file NodalUtil.cpp.

References GetVandermonde().

Referenced by MakeQuadratureWeights().

555  {
556  // Construct the Vandermonde matrix of DubinerPolynomials
557  SharedNekMatrixPtr vandermonde(new NekMatrix<NekDouble>( GetVandermonde(x, y) ));
558 
559  return vandermonde;
560  }
NekMatrix< NekDouble > GetVandermonde(const NekVector< NekDouble > &x, const NekVector< NekDouble > &y)
Definition: NodalUtil.cpp:540
boost::shared_ptr< NekMatrix< NekDouble, StandardMatrixTag > > SharedNekMatrixPtr
SharedNekMatrixPtr Nektar::LibUtilities::MakeVmatrixOfTet ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y,
const NekVector< NekDouble > &  z 
)

Definition at line 547 of file NodalUtil.cpp.

References GetTetVandermonde().

Referenced by MakeTetWeights().

548  {
549  // Construct the Vandermonde matrix of Tetrahedron
550  SharedNekMatrixPtr vMat(new NekMatrix<NekDouble>( GetTetVandermonde(x, y, z)));
551  return vMat;
552  }
NekMatrix< NekDouble > GetTetVandermonde(const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z)
Definition: NodalUtil.cpp:507
boost::shared_ptr< NekMatrix< NekDouble, StandardMatrixTag > > SharedNekMatrixPtr
std::string Nektar::LibUtilities::MatrixToString ( const NekMatrix< NekDouble > &  A,
int  precision,
NekDouble  expSigFigs 
)

Definition at line 157 of file NodalUtil.cpp.

References MakeRound().

158  {
159  stringstream s;
160  s << setprecision(precision);
161  int M = int(A.GetRows()), N = int(A.GetColumns());
162 
163  for(int i=0; i<M; ++i )
164  {
165  for(int j=0; j<N; ++j)
166  {
167  NekDouble a = MakeRound(expSigFigs * A(i, j)) / expSigFigs;
168  s << setw(7) << right << a;
169  if( j < N-1 )
170  {
171  s << ", ";
172  }
173  }
174  if( i < M-1 )
175  {
176  s << "\n";
177  }
178  }
179  return s.str();
180  }
NekDouble MakeRound(NekDouble x)
Definition: NodalUtil.cpp:231
double NekDouble
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:1047
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:1047
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:1047
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 92 of file ManagerAccess.cpp.

Referenced by Nektar::LibUtilities::GaussPoints::CalculateGalerkinProjectionMatrix(), Nektar::LibUtilities::PolyEPoints::CalculateWeights(), Nektar::LibUtilities::BLPoints::CreateMatrix(), Nektar::LibUtilities::FourierPoints::CreateMatrix(), Nektar::LibUtilities::FourierSingleModePoints::CreateMatrix(), Nektar::LibUtilities::GaussPoints::CreateMatrix(), Nektar::LibUtilities::Basis::GenBasis(), Nektar::LibUtilities::NodalTriElec::GetI(), Nektar::LibUtilities::NodalTetElec::GetI(), Nektar::LibUtilities::NodalTriEvenlySpaced::GetI(), Nektar::LibUtilities::PolyEPoints::GetI(), Nektar::LibUtilities::NodalTriFekete::GetI(), Nektar::LibUtilities::NodalTetEvenlySpaced::GetI(), Nektar::LibUtilities::NodalPrismEvenlySpaced::GetI(), Nektar::StdRegions::StdNodalTetExp::GetNodalPoints(), Nektar::StdRegions::StdNodalPrismExp::GetNodalPoints(), Nektar::StdRegions::StdNodalTriExp::GetNodalPoints(), Nektar::NekMeshUtils::SurfaceMesh::HOSurf(), Interp1D(), Interp2D(), Interp3D(), Nektar::Utilities::InputNek::LoadHOSurfaces(), PhysGalerkinProject1D(), PhysGalerkinProject2D(), PhysGalerkinProject3D(), Nektar::MultiRegions::ExpList1D::PostProcess(), Nektar::Utilities::ProcessTetSplit::Process(), Nektar::Utilities::ProcessBL::Process(), Nektar::MultiRegions::LocTraceToTraceMap::Setup2D(), Nektar::MultiRegions::LocTraceToTraceMap::Setup3D(), Nektar::SpatialDomains::SegGeom::v_FillGeom(), and Nektar::SpatialDomains::TriGeom::v_FillGeom().

93  {
94  return Loki::SingletonHolder<PointsManagerT>::Instance();
95  }
std::string Nektar::LibUtilities::PortablePath ( const boost::filesystem::path &  path)
void Nektar::LibUtilities::PrintProgressbar ( const int  position,
const int  goal,
const string  message 
)
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::Utilities::Iso::globalcondense(), Nektar::NekMeshUtils::SurfaceMesh::HOSurf(), Nektar::NekMeshUtils::SurfaceMesh::Mesh(), Nektar::Utilities::ProcessInterpPointDataToFld::PrintProgressbar(), Nektar::SolverUtils::EquationSystem::PrintProgressbar(), and Nektar::Utilities::Iso::separate_regions().

70 {
71  std::cout.unsetf ( std::ios::floatfield );
72  if (ISTTY)
73  {
74  // carriage return
75  cout << "\r";
76 
77  cout << message << ": ";
78  float progress = position / float(goal);
79  cout << setw(3) << ceil(100 * progress) << "% [";
80  for (int j = 0; j < ceil(progress * 49); j++)
81  {
82  cout << "=";
83  }
84  for (int j = ceil(progress * 49); j < 49; j++)
85  {
86  cout << " ";
87  }
88  cout << "]" << flush;
89  }
90  else
91  {