Nektar++
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Public Member Functions | Static Public Member Functions | Static Public Attributes | Protected Member Functions | Protected Attributes | Private Member Functions | Friends | List of all members
Nektar::CFLtester Class Reference

#include <CFLtester.h>

Inheritance diagram for Nektar::CFLtester:
Inheritance graph
[legend]
Collaboration diagram for Nektar::CFLtester:
Collaboration graph
[legend]

Public Member Functions

virtual ~CFLtester ()
 
- Public Member Functions inherited from Nektar::SolverUtils::UnsteadySystem
virtual SOLVER_UTILS_EXPORT ~UnsteadySystem ()
 Destructor. More...
 
SOLVER_UTILS_EXPORT NekDouble GetTimeStep (const Array< OneD, const Array< OneD, NekDouble > > &inarray)
 Calculate the larger time-step mantaining the problem stable. More...
 
- Public Member Functions inherited from Nektar::SolverUtils::EquationSystem
virtual SOLVER_UTILS_EXPORT ~EquationSystem ()
 Destructor. More...
 
SOLVER_UTILS_EXPORT void SetUpTraceNormals (void)
 
SOLVER_UTILS_EXPORT void InitObject ()
 Initialises the members of this object. More...
 
SOLVER_UTILS_EXPORT void DoInitialise ()
 Perform any initialisation necessary before solving the problem. More...
 
SOLVER_UTILS_EXPORT void DoSolve ()
 Solve the problem. More...
 
SOLVER_UTILS_EXPORT void TransCoeffToPhys ()
 Transform from coefficient to physical space. More...
 
SOLVER_UTILS_EXPORT void TransPhysToCoeff ()
 Transform from physical to coefficient space. More...
 
SOLVER_UTILS_EXPORT void Output ()
 Perform output operations after solve. More...
 
SOLVER_UTILS_EXPORT NekDouble LinfError (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray)
 Linf error computation. More...
 
SOLVER_UTILS_EXPORT std::string GetSessionName ()
 Get Session name. More...
 
template<class T >
boost::shared_ptr< T > as ()
 
SOLVER_UTILS_EXPORT void ResetSessionName (std::string newname)
 Reset Session name. More...
 
SOLVER_UTILS_EXPORT
LibUtilities::SessionReaderSharedPtr 
GetSession ()
 Get Session name. More...
 
SOLVER_UTILS_EXPORT
MultiRegions::ExpListSharedPtr 
GetPressure ()
 Get pressure field if available. More...
 
SOLVER_UTILS_EXPORT void PrintSummary (std::ostream &out)
 Print a summary of parameters and solver characteristics. More...
 
SOLVER_UTILS_EXPORT void SetLambda (NekDouble lambda)
 Set parameter m_lambda. More...
 
SOLVER_UTILS_EXPORT void EvaluateFunction (Array< OneD, Array< OneD, NekDouble > > &pArray, std::string pFunctionName, const NekDouble pTime=0.0, const int domain=0)
 Evaluates a function as specified in the session file. More...
 
SOLVER_UTILS_EXPORT void EvaluateFunction (std::vector< std::string > pFieldNames, Array< OneD, Array< OneD, NekDouble > > &pFields, const std::string &pName, const NekDouble &pTime=0.0, const int domain=0)
 Populate given fields with the function from session. More...
 
SOLVER_UTILS_EXPORT void EvaluateFunction (std::vector< std::string > pFieldNames, Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const std::string &pName, const NekDouble &pTime=0.0, const int domain=0)
 Populate given fields with the function from session. More...
 
SOLVER_UTILS_EXPORT void EvaluateFunction (std::string pFieldName, Array< OneD, NekDouble > &pArray, const std::string &pFunctionName, const NekDouble &pTime=0.0, const int domain=0)
 
SOLVER_UTILS_EXPORT std::string DescribeFunction (std::string pFieldName, const std::string &pFunctionName, const int domain)
 Provide a description of a function for a given field name. More...
 
SOLVER_UTILS_EXPORT void InitialiseBaseFlow (Array< OneD, Array< OneD, NekDouble > > &base)
 Perform initialisation of the base flow. More...
 
SOLVER_UTILS_EXPORT void SetInitialConditions (NekDouble initialtime=0.0, bool dumpInitialConditions=true, const int domain=0)
 Initialise the data in the dependent fields. More...
 
SOLVER_UTILS_EXPORT void EvaluateExactSolution (int field, Array< OneD, NekDouble > &outfield, const NekDouble time)
 Evaluates an exact solution. More...
 
SOLVER_UTILS_EXPORT NekDouble L2Error (unsigned int field, const Array< OneD, NekDouble > &exactsoln, bool Normalised=false)
 Compute the L2 error between fields and a given exact solution. More...
 
SOLVER_UTILS_EXPORT NekDouble L2Error (unsigned int field, bool Normalised=false)
 Compute the L2 error of the fields. More...
 
SOLVER_UTILS_EXPORT Array
< OneD, NekDouble
ErrorExtraPoints (unsigned int field)
 Compute error (L2 and L_inf) over an larger set of quadrature points return [L2 Linf]. More...
 
SOLVER_UTILS_EXPORT void WeakAdvectionGreensDivergenceForm (const Array< OneD, Array< OneD, NekDouble > > &F, Array< OneD, NekDouble > &outarray)
 Compute the inner product $ (\nabla \phi \cdot F) $. More...
 
SOLVER_UTILS_EXPORT void WeakAdvectionDivergenceForm (const Array< OneD, Array< OneD, NekDouble > > &F, Array< OneD, NekDouble > &outarray)
 Compute the inner product $ (\phi, \nabla \cdot F) $. More...
 
SOLVER_UTILS_EXPORT void WeakAdvectionNonConservativeForm (const Array< OneD, Array< OneD, NekDouble > > &V, const Array< OneD, const NekDouble > &u, Array< OneD, NekDouble > &outarray, bool UseContCoeffs=false)
 Compute the inner product $ (\phi, V\cdot \nabla u) $. More...
 
f SOLVER_UTILS_EXPORT void AdvectionNonConservativeForm (const Array< OneD, Array< OneD, NekDouble > > &V, const Array< OneD, const NekDouble > &u, Array< OneD, NekDouble > &outarray, Array< OneD, NekDouble > &wk=NullNekDouble1DArray)
 Compute the non-conservative advection. More...
 
SOLVER_UTILS_EXPORT void WeakDGAdvection (const Array< OneD, Array< OneD, NekDouble > > &InField, Array< OneD, Array< OneD, NekDouble > > &OutField, bool NumericalFluxIncludesNormal=true, bool InFieldIsInPhysSpace=false, int nvariables=0)
 Calculate the weak discontinuous Galerkin advection. More...
 
SOLVER_UTILS_EXPORT void WeakDGDiffusion (const Array< OneD, Array< OneD, NekDouble > > &InField, Array< OneD, Array< OneD, NekDouble > > &OutField, bool NumericalFluxIncludesNormal=true, bool InFieldIsInPhysSpace=false)
 Calculate weak DG Diffusion in the LDG form. More...
 
SOLVER_UTILS_EXPORT void Checkpoint_Output (const int n)
 Write checkpoint file of m_fields. More...
 
SOLVER_UTILS_EXPORT void Checkpoint_Output (const int n, MultiRegions::ExpListSharedPtr &field, std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables)
 Write checkpoint file of custom data fields. More...
 
SOLVER_UTILS_EXPORT void Checkpoint_BaseFlow (const int n)
 Write base flow file of m_fields. More...
 
SOLVER_UTILS_EXPORT void WriteFld (const std::string &outname)
 Write field data to the given filename. More...
 
SOLVER_UTILS_EXPORT void WriteFld (const std::string &outname, MultiRegions::ExpListSharedPtr &field, std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables)
 Write input fields to the given filename. More...
 
SOLVER_UTILS_EXPORT void ImportFld (const std::string &infile, Array< OneD, MultiRegions::ExpListSharedPtr > &pFields)
 Input field data from the given file. More...
 
SOLVER_UTILS_EXPORT void ImportFldToMultiDomains (const std::string &infile, Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const int ndomains)
 Input field data from the given file to multiple domains. More...
 
SOLVER_UTILS_EXPORT void ImportFld (const std::string &infile, std::vector< std::string > &fieldStr, Array< OneD, Array< OneD, NekDouble > > &coeffs)
 Output a field. Input field data into array from the given file. More...
 
SOLVER_UTILS_EXPORT void ImportFld (const std::string &infile, MultiRegions::ExpListSharedPtr &pField, std::string &pFieldName)
 Output a field. Input field data into ExpList from the given file. More...
 
SOLVER_UTILS_EXPORT void ScanForHistoryPoints ()
 Builds map of which element holds each history point. More...
 
SOLVER_UTILS_EXPORT void WriteHistoryData (std::ostream &out)
 Probe each history point and write to file. More...
 
SOLVER_UTILS_EXPORT void SessionSummary (SummaryList &vSummary)
 Write out a session summary. More...
 
SOLVER_UTILS_EXPORT Array
< OneD,
MultiRegions::ExpListSharedPtr > & 
UpdateFields ()
 
SOLVER_UTILS_EXPORT
LibUtilities::FieldMetaDataMap
UpdateFieldMetaDataMap ()
 Get hold of FieldInfoMap so it can be updated. More...
 
SOLVER_UTILS_EXPORT NekDouble GetFinalTime ()
 Return final time. More...
 
SOLVER_UTILS_EXPORT int GetNcoeffs ()
 
SOLVER_UTILS_EXPORT int GetNcoeffs (const int eid)
 
SOLVER_UTILS_EXPORT int GetNumExpModes ()
 
SOLVER_UTILS_EXPORT const
Array< OneD, int > 
GetNumExpModesPerExp ()
 
SOLVER_UTILS_EXPORT int GetNvariables ()
 
SOLVER_UTILS_EXPORT const
std::string 
GetVariable (unsigned int i)
 
SOLVER_UTILS_EXPORT int GetTraceTotPoints ()
 
SOLVER_UTILS_EXPORT int GetTraceNpoints ()
 
SOLVER_UTILS_EXPORT int GetExpSize ()
 
SOLVER_UTILS_EXPORT int GetPhys_Offset (int n)
 
SOLVER_UTILS_EXPORT int GetCoeff_Offset (int n)
 
SOLVER_UTILS_EXPORT int GetTotPoints ()
 
SOLVER_UTILS_EXPORT int GetTotPoints (int n)
 
SOLVER_UTILS_EXPORT int GetNpoints ()
 
SOLVER_UTILS_EXPORT int GetNumElmVelocity ()
 
SOLVER_UTILS_EXPORT int GetSteps ()
 
SOLVER_UTILS_EXPORT NekDouble GetTimeStep ()
 
SOLVER_UTILS_EXPORT void CopyFromPhysField (const int i, Array< OneD, NekDouble > &output)
 
SOLVER_UTILS_EXPORT void CopyToPhysField (const int i, Array< OneD, NekDouble > &output)
 
SOLVER_UTILS_EXPORT void SetSteps (const int steps)
 
SOLVER_UTILS_EXPORT void ZeroPhysFields ()
 
SOLVER_UTILS_EXPORT void FwdTransFields ()
 
SOLVER_UTILS_EXPORT void GetFluxVector (const int i, Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &flux)
 
SOLVER_UTILS_EXPORT void GetFluxVector (const int i, Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &fluxX, Array< OneD, Array< OneD, NekDouble > > &fluxY)
 
SOLVER_UTILS_EXPORT void GetFluxVector (const int i, const int j, Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &flux)
 
SOLVER_UTILS_EXPORT void NumericalFlux (Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &numflux)
 
SOLVER_UTILS_EXPORT void NumericalFlux (Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &numfluxX, Array< OneD, Array< OneD, NekDouble > > &numfluxY)
 
SOLVER_UTILS_EXPORT void NumFluxforScalar (const Array< OneD, Array< OneD, NekDouble > > &ufield, Array< OneD, Array< OneD, Array< OneD, NekDouble > > > &uflux)
 
SOLVER_UTILS_EXPORT void NumFluxforVector (const Array< OneD, Array< OneD, NekDouble > > &ufield, Array< OneD, Array< OneD, Array< OneD, NekDouble > > > &qfield, Array< OneD, Array< OneD, NekDouble > > &qflux)
 
SOLVER_UTILS_EXPORT void SetModifiedBasis (const bool modbasis)
 
SOLVER_UTILS_EXPORT int NoCaseStringCompare (const std::string &s1, const std::string &s2)
 Perform a case-insensitive string comparison. More...
 
SOLVER_UTILS_EXPORT int GetCheckpointNumber ()
 
SOLVER_UTILS_EXPORT void SetCheckpointNumber (int num)
 
SOLVER_UTILS_EXPORT int GetCheckpointSteps ()
 
SOLVER_UTILS_EXPORT void SetCheckpointSteps (int num)
 
SOLVER_UTILS_EXPORT void SetTime (const NekDouble time)
 
SOLVER_UTILS_EXPORT void SetInitialStep (const int step)
 
SOLVER_UTILS_EXPORT void SetBoundaryConditions (NekDouble time)
 Evaluates the boundary conditions at the given time. More...
 
virtual SOLVER_UTILS_EXPORT bool v_NegatedOp ()
 Virtual function to identify if operator is negated in DoSolve. More...
 

Static Public Member Functions

static EquationSystemSharedPtr create (const LibUtilities::SessionReaderSharedPtr &pSession)
 

Static Public Attributes

static std::string className = GetEquationSystemFactory().RegisterCreatorFunction("CFLtester", CFLtester::create, "Testing CFL restriction")
 

Protected Member Functions

 CFLtester (const LibUtilities::SessionReaderSharedPtr &pSession)
 
void DoOdeRhs (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
 
void DoOdeProjection (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
 
virtual void v_InitObject ()
 Init object for UnsteadySystem class. More...
 
virtual void v_GetFluxVector (const int i, Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &flux)
 
virtual void v_NumericalFlux (Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &numflux)
 
virtual void v_GenerateSummary (SummaryList &s)
 Print a summary of time stepping parameters. More...
 
- Protected Member Functions inherited from Nektar::SolverUtils::UnsteadySystem
SOLVER_UTILS_EXPORT UnsteadySystem (const LibUtilities::SessionReaderSharedPtr &pSession)
 Initialises UnsteadySystem class members. More...
 
SOLVER_UTILS_EXPORT NekDouble MaxTimeStepEstimator ()
 Get the maximum timestep estimator for cfl control. More...
 
virtual SOLVER_UTILS_EXPORT void v_DoSolve ()
 Solves an unsteady problem. More...
 
virtual SOLVER_UTILS_EXPORT void v_DoInitialise ()
 Sets up initial conditions. More...
 
virtual SOLVER_UTILS_EXPORT void v_AppendOutput1D (Array< OneD, Array< OneD, NekDouble > > &solution1D)
 Print the solution at each solution point in a txt file. More...
 
virtual SOLVER_UTILS_EXPORT void v_NumericalFlux (Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &numfluxX, Array< OneD, Array< OneD, NekDouble > > &numfluxY)
 
virtual SOLVER_UTILS_EXPORT void v_NumFluxforScalar (const Array< OneD, Array< OneD, NekDouble > > &ufield, Array< OneD, Array< OneD, Array< OneD, NekDouble > > > &uflux)
 
virtual SOLVER_UTILS_EXPORT void v_NumFluxforVector (const Array< OneD, Array< OneD, NekDouble > > &ufield, Array< OneD, Array< OneD, Array< OneD, NekDouble > > > &qfield, Array< OneD, Array< OneD, NekDouble > > &qflux)
 
virtual SOLVER_UTILS_EXPORT
NekDouble 
v_GetTimeStep (const Array< OneD, const Array< OneD, NekDouble > > &inarray)
 Return the timestep to be used for the next step in the time-marching loop. More...
 
virtual SOLVER_UTILS_EXPORT bool v_PreIntegrate (int step)
 
virtual SOLVER_UTILS_EXPORT bool v_PostIntegrate (int step)
 
virtual SOLVER_UTILS_EXPORT bool v_SteadyStateCheck (int step)
 
SOLVER_UTILS_EXPORT void CheckForRestartTime (NekDouble &time)
 
SOLVER_UTILS_EXPORT void SVVVarDiffCoeff (const Array< OneD, Array< OneD, NekDouble > > vel, StdRegions::VarCoeffMap &varCoeffMap)
 Evaluate the SVV diffusion coefficient according to Moura's paper where it should proportional to h time velocity. More...
 
- Protected Member Functions inherited from Nektar::SolverUtils::EquationSystem
SOLVER_UTILS_EXPORT EquationSystem (const LibUtilities::SessionReaderSharedPtr &pSession)
 Initialises EquationSystem class members. More...
 
int nocase_cmp (const std::string &s1, const std::string &s2)
 
virtual SOLVER_UTILS_EXPORT
NekDouble 
v_LinfError (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray)
 Virtual function for the L_inf error computation between fields and a given exact solution. More...
 
virtual SOLVER_UTILS_EXPORT
NekDouble 
v_L2Error (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray, bool Normalised=false)
 Virtual function for the L_2 error computation between fields and a given exact solution. More...
 
virtual SOLVER_UTILS_EXPORT void v_TransCoeffToPhys ()
 Virtual function for transformation to physical space. More...
 
virtual SOLVER_UTILS_EXPORT void v_TransPhysToCoeff ()
 Virtual function for transformation to coefficient space. More...
 
virtual SOLVER_UTILS_EXPORT void v_SetInitialConditions (NekDouble initialtime=0.0, bool dumpInitialConditions=true, const int domain=0)
 
virtual SOLVER_UTILS_EXPORT void v_EvaluateExactSolution (unsigned int field, Array< OneD, NekDouble > &outfield, const NekDouble time)
 
SOLVER_UTILS_EXPORT void SetUpBaseFields (SpatialDomains::MeshGraphSharedPtr &mesh)
 
SOLVER_UTILS_EXPORT void ImportFldBase (std::string pInfile, SpatialDomains::MeshGraphSharedPtr pGraph)
 
virtual SOLVER_UTILS_EXPORT void v_Output (void)
 
virtual SOLVER_UTILS_EXPORT
MultiRegions::ExpListSharedPtr 
v_GetPressure (void)
 
virtual SOLVER_UTILS_EXPORT void v_ExtraFldOutput (std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables)
 

Protected Attributes

Array< OneD, Array< OneD,
NekDouble > > 
m_velocity
 
- Protected Attributes inherited from Nektar::SolverUtils::UnsteadySystem
int m_infosteps
 Number of time steps between outputting status information. More...
 
LibUtilities::TimeIntegrationWrapperSharedPtr m_intScheme
 Wrapper to the time integration scheme. More...
 
LibUtilities::TimeIntegrationSchemeOperators m_ode
 The time integration scheme operators to use. More...
 
LibUtilities::TimeIntegrationSolutionSharedPtr m_intSoln
 
NekDouble m_epsilon
 
bool m_explicitDiffusion
 Indicates if explicit or implicit treatment of diffusion is used. More...
 
bool m_explicitAdvection
 Indicates if explicit or implicit treatment of advection is used. More...
 
bool m_explicitReaction
 Indicates if explicit or implicit treatment of reaction is used. More...
 
bool m_homoInitialFwd
 Flag to determine if simulation should start in homogeneous forward transformed state. More...
 
std::vector< int > m_intVariables
 
std::vector< FilterSharedPtrm_filters
 
- Protected Attributes inherited from Nektar::SolverUtils::EquationSystem
LibUtilities::CommSharedPtr m_comm
 Communicator. More...
 
LibUtilities::SessionReaderSharedPtr m_session
 The session reader. More...
 
LibUtilities::FieldIOSharedPtr m_fld
 Field input/output. More...
 
std::map< std::string, Array
< OneD, Array< OneD, float > > > 
m_interpWeights
 Map of the interpolation weights for a specific filename. More...
 
std::map< std::string, Array
< OneD, Array< OneD, unsigned
int > > > 
m_interpInds
 Map of the interpolation indices for a specific filename. More...
 
Array< OneD,
MultiRegions::ExpListSharedPtr
m_fields
 Array holding all dependent variables. More...
 
Array< OneD,
MultiRegions::ExpListSharedPtr
m_base
 Base fields. More...
 
Array< OneD,
MultiRegions::ExpListSharedPtr
m_derivedfields
 Array holding all dependent variables. More...
 
SpatialDomains::BoundaryConditionsSharedPtr m_boundaryConditions
 Pointer to boundary conditions object. More...
 
SpatialDomains::MeshGraphSharedPtr m_graph
 Pointer to graph defining mesh. More...
 
std::string m_sessionName
 Name of the session. More...
 
NekDouble m_time
 Current time of simulation. More...
 
int m_initialStep
 Number of the step where the simulation should begin. More...
 
NekDouble m_fintime
 Finish time of the simulation. More...
 
NekDouble m_timestep
 Time step size. More...
 
NekDouble m_lambda
 Lambda constant in real system if one required. More...
 
std::set< std::string > m_loadedFields
 
NekDouble m_checktime
 Time between checkpoints. More...
 
int m_nchk
 Number of checkpoints written so far. More...
 
int m_steps
 Number of steps to take. More...
 
int m_checksteps
 Number of steps between checkpoints. More...
 
int m_spacedim
 Spatial dimension (>= expansion dim). More...
 
int m_expdim
 Expansion dimension. More...
 
bool m_singleMode
 Flag to determine if single homogeneous mode is used. More...
 
bool m_halfMode
 Flag to determine if half homogeneous mode is used. More...
 
bool m_multipleModes
 Flag to determine if use multiple homogenenous modes are used. More...
 
bool m_useFFT
 Flag to determine if FFT is used for homogeneous transform. More...
 
bool m_homogen_dealiasing
 Flag to determine if dealiasing is used for homogeneous simulations. More...
 
bool m_specHP_dealiasing
 Flag to determine if dealisising is usde for the Spectral/hp element discretisation. More...
 
enum MultiRegions::ProjectionType m_projectionType
 Type of projection; e.g continuous or discontinuous. More...
 
Array< OneD, Array< OneD,
NekDouble > > 
m_traceNormals
 Array holding trace normals for DG simulations in the forwards direction. More...
 
Array< OneD, Array< OneD,
Array< OneD, NekDouble > > > 
m_gradtan
 1 x nvariable x nq More...
 
Array< OneD, Array< OneD,
Array< OneD, NekDouble > > > 
m_tanbasis
 2 x m_spacedim x nq More...
 
Array< OneD, bool > m_checkIfSystemSingular
 Flag to indicate if the fields should be checked for singularity. More...
 
LibUtilities::FieldMetaDataMap m_fieldMetaDataMap
 Map to identify relevant solver info to dump in output fields. More...
 
int m_NumQuadPointsError
 Number of Quadrature points used to work out the error. More...
 
enum HomogeneousType m_HomogeneousType
 
NekDouble m_LhomX
 physical length in X direction (if homogeneous) More...
 
NekDouble m_LhomY
 physical length in Y direction (if homogeneous) More...
 
NekDouble m_LhomZ
 physical length in Z direction (if homogeneous) More...
 
int m_npointsX
 number of points in X direction (if homogeneous) More...
 
int m_npointsY
 number of points in Y direction (if homogeneous) More...
 
int m_npointsZ
 number of points in Z direction (if homogeneous) More...
 
int m_HomoDirec
 number of homogenous directions More...
 

Private Member Functions

virtual NekDouble v_GetTimeStep (const Array< OneD, int > ExpOrder, const Array< OneD, NekDouble > CFL, NekDouble timeCFL)
 
virtual NekDouble v_GetTimeStep (int ExpOrder, NekDouble CFL, NekDouble TimeStability)
 
Array< OneD, NekDoubleGetStdVelocity (const Array< OneD, Array< OneD, NekDouble > > inarray)
 

Friends

class MemoryManager< CFLtester >
 

Additional Inherited Members

- Public Attributes inherited from Nektar::SolverUtils::UnsteadySystem
NekDouble m_cflSafetyFactor
 CFL safety factor (comprise between 0 to 1). More...
 
- Protected Types inherited from Nektar::SolverUtils::EquationSystem
enum  HomogeneousType { eHomogeneous1D, eHomogeneous2D, eHomogeneous3D, eNotHomogeneous }
 Parameter for homogeneous expansions. More...
 

Detailed Description

Definition at line 81 of file CFLtester.h.

Constructor & Destructor Documentation

Nektar::CFLtester::~CFLtester ( )
virtual

Definition at line 78 of file CFLtester.cpp.

79  {
80  }
Nektar::CFLtester::CFLtester ( const LibUtilities::SessionReaderSharedPtr pSession)
protected

Definition at line 48 of file CFLtester.cpp.

50  : UnsteadySystem(pSession)
51  {
52  }
SOLVER_UTILS_EXPORT UnsteadySystem(const LibUtilities::SessionReaderSharedPtr &pSession)
Initialises UnsteadySystem class members.

Member Function Documentation

static EquationSystemSharedPtr Nektar::CFLtester::create ( const LibUtilities::SessionReaderSharedPtr pSession)
inlinestatic

Definition at line 86 of file CFLtester.h.

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

86  {
88  p->InitObject();
89  return p;}
static boost::shared_ptr< DataType > AllocateSharedPtr()
Allocate a shared pointer from the memory pool.
boost::shared_ptr< EquationSystem > EquationSystemSharedPtr
A shared pointer to an EquationSystem object.
void Nektar::CFLtester::DoOdeProjection ( const Array< OneD, const Array< OneD, NekDouble > > &  inarray,
Array< OneD, Array< OneD, NekDouble > > &  outarray,
const NekDouble  time 
)
protected

Definition at line 131 of file CFLtester.cpp.

References ASSERTL0, Nektar::MultiRegions::eDiscontinuous, Nektar::MultiRegions::eGalerkin, Nektar::MultiRegions::eMixed_CG_Discontinuous, Nektar::SolverUtils::EquationSystem::GetNcoeffs(), Nektar::SolverUtils::EquationSystem::GetNpoints(), Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::EquationSystem::m_projectionType, Nektar::SolverUtils::EquationSystem::SetBoundaryConditions(), and Vmath::Vcopy().

Referenced by v_InitObject().

135  {
136  int j;
137  int nvariables = inarray.num_elements();
138  SetBoundaryConditions(time);
139 
140  switch(m_projectionType)
141  {
143  {
144  // Just copy over array
145  int npoints = GetNpoints();
146 
147  for(j = 0; j < nvariables; ++j)
148  {
149  Vmath::Vcopy(npoints,inarray[j],1,outarray[j],1);
150  }
151  }
152  break;
155  {
156  Array<OneD, NekDouble> coeffs(m_fields[0]->GetNcoeffs());
157 
158  for(j = 0; j < nvariables; ++j)
159  {
160  m_fields[j]->FwdTrans(inarray[j],coeffs);
161  m_fields[j]->BwdTrans_IterPerExp(coeffs,outarray[j]);
162  }
163  break;
164  }
165  default:
166  ASSERTL0(false,"Unknown projection scheme");
167  break;
168  }
169  }
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:161
enum MultiRegions::ProjectionType m_projectionType
Type of projection; e.g continuous or discontinuous.
SOLVER_UTILS_EXPORT void SetBoundaryConditions(NekDouble time)
Evaluates the boundary conditions at the given time.
SOLVER_UTILS_EXPORT int GetNpoints()
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
SOLVER_UTILS_EXPORT int GetNcoeffs()
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1047
void Nektar::CFLtester::DoOdeRhs ( const Array< OneD, const Array< OneD, NekDouble > > &  inarray,
Array< OneD, Array< OneD, NekDouble > > &  outarray,
const NekDouble  time 
)
protected

Definition at line 82 of file CFLtester.cpp.

References Nektar::SolverUtils::EquationSystem::AdvectionNonConservativeForm(), Nektar::MultiRegions::eDiscontinuous, Nektar::MultiRegions::eGalerkin, Nektar::MultiRegions::eMixed_CG_Discontinuous, Nektar::SolverUtils::EquationSystem::GetNpoints(), Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::EquationSystem::m_projectionType, m_velocity, Vmath::Neg(), and Nektar::SolverUtils::EquationSystem::WeakDGAdvection().

Referenced by v_InitObject().

86  {
87  int j;
88  int nvariables = inarray.num_elements();
89  int npoints = GetNpoints();
90 
91  switch (m_projectionType)
92  {
94  {
95  int ncoeffs = inarray[0].num_elements();
96  Array<OneD, Array<OneD, NekDouble> > WeakAdv(nvariables);
97 
98  WeakAdv[0] = Array<OneD, NekDouble>(ncoeffs*nvariables);
99  for(j = 1; j < nvariables; ++j)
100  {
101  WeakAdv[j] = WeakAdv[j-1] + ncoeffs;
102  }
103 
104  WeakDGAdvection(inarray, WeakAdv, true, true);
105 
106  for(j = 0; j < nvariables; ++j)
107  {
108  m_fields[j]->MultiplyByElmtInvMass(WeakAdv[j], WeakAdv[j]);
109  m_fields[j]->BwdTrans(WeakAdv[j],outarray[j]);
110  Vmath::Neg(npoints,outarray[j],1);
111  }
112  break;
113  }
116  {
117  // Calculate -V\cdot Grad(u);
118  for(j = 0; j < nvariables; ++j)
119  {
121  inarray[j],
122  outarray[j]);
123 
124  Vmath::Neg(npoints, outarray[j], 1);
125  }
126  break;
127  }
128  }
129  }
f SOLVER_UTILS_EXPORT void AdvectionNonConservativeForm(const Array< OneD, Array< OneD, NekDouble > > &V, const Array< OneD, const NekDouble > &u, Array< OneD, NekDouble > &outarray, Array< OneD, NekDouble > &wk=NullNekDouble1DArray)
Compute the non-conservative advection.
enum MultiRegions::ProjectionType m_projectionType
Type of projection; e.g continuous or discontinuous.
void Neg(int n, T *x, const int incx)
Negate x = -x.
Definition: Vmath.cpp:382
SOLVER_UTILS_EXPORT int GetNpoints()
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
Array< OneD, Array< OneD, NekDouble > > m_velocity
Definition: CFLtester.h:97
SOLVER_UTILS_EXPORT void WeakDGAdvection(const Array< OneD, Array< OneD, NekDouble > > &InField, Array< OneD, Array< OneD, NekDouble > > &OutField, bool NumericalFluxIncludesNormal=true, bool InFieldIsInPhysSpace=false, int nvariables=0)
Calculate the weak discontinuous Galerkin advection.
Array< OneD, NekDouble > Nektar::CFLtester::GetStdVelocity ( const Array< OneD, Array< OneD, NekDouble > >  inarray)
private

Definition at line 329 of file CFLtester.cpp.

References ASSERTL0, Nektar::SpatialDomains::eDeformed, Nektar::StdRegions::StdExpansion::GetTotPoints(), Nektar::SolverUtils::EquationSystem::GetTotPoints(), Nektar::SolverUtils::EquationSystem::m_expdim, and Nektar::SolverUtils::EquationSystem::m_fields.

Referenced by v_GetTimeStep().

331  {
332  // Checking if the problem is 2D
333  ASSERTL0(m_expdim >= 2, "Method not implemented for 1D");
334 
335  int nTotQuadPoints = GetTotPoints();
336  int n_element = m_fields[0]->GetExpSize();
337  int nvel = inarray.num_elements();
338 
339  NekDouble pntVelocity;
340 
341  // Getting the standard velocity vector on the 2D normal space
342  Array<OneD, Array<OneD, NekDouble> > stdVelocity(nvel);
343  Array<OneD, NekDouble> stdV(n_element, 0.0);
344 
345  for (int i = 0; i < nvel; ++i)
346  {
347  stdVelocity[i] = Array<OneD, NekDouble>(nTotQuadPoints);
348  }
349 
350  if (nvel == 2)
351  {
352  for (int el = 0; el < n_element; ++el)
353  {
355  m_fields[0]->GetExp(el)->as<LocalRegions::Expansion2D>();
356  int n_points = el2D->GetTotPoints();
357 
358  Array<OneD, const NekDouble> jac =
359  el2D->GetGeom2D()->GetMetricInfo()->GetJac();
360  Array<TwoD, const NekDouble> gmat =
361  el2D->GetGeom2D()->GetMetricInfo()->GetDerivFactors();
362 
363  if (el2D->GetGeom2D()->GetMetricInfo()->GetGtype()
365  {
366  for (int i = 0; i < n_points; i++)
367  {
368  stdVelocity[0][i] = gmat[0][i]*inarray[0][i]
369  + gmat[2][i]*inarray[1][i];
370 
371  stdVelocity[1][i] = gmat[1][i]*inarray[0][i]
372  + gmat[3][i]*inarray[1][i];
373  }
374  }
375  else
376  {
377  for (int i = 0; i < n_points; i++)
378  {
379  stdVelocity[0][i] = gmat[0][0]*inarray[0][i]
380  + gmat[2][0]*inarray[1][i];
381 
382  stdVelocity[1][i] = gmat[1][0]*inarray[0][i]
383  + gmat[3][0]*inarray[1][i];
384  }
385  }
386 
387 
388  for (int i = 0; i < n_points; i++)
389  {
390  pntVelocity = sqrt(stdVelocity[0][i]*stdVelocity[0][i]
391  + stdVelocity[1][i]*stdVelocity[1][i]);
392 
393  if (pntVelocity>stdV[el])
394  {
395  stdV[el] = pntVelocity;
396  }
397  }
398  }
399  }
400  else
401  {
402  for (int el = 0; el < n_element; ++el)
403  {
405  m_fields[0]->GetExp(el)->as<LocalRegions::Expansion3D>();
406 
407  int n_points = el3D->GetTotPoints();
408 
409  Array<OneD, const NekDouble> jac =
410  el3D->GetGeom3D()->GetMetricInfo()->GetJac();
411  Array<TwoD, const NekDouble> gmat =
412  el3D->GetGeom3D()->GetMetricInfo()->GetDerivFactors();
413 
414  if (el3D->GetGeom3D()->GetMetricInfo()->GetGtype()
416  {
417  for (int i = 0; i < n_points; i++)
418  {
419  stdVelocity[0][i] = gmat[0][i]*inarray[0][i]
420  + gmat[3][i]*inarray[1][i]
421  + gmat[6][i]*inarray[2][i];
422 
423  stdVelocity[1][i] = gmat[1][i]*inarray[0][i]
424  + gmat[4][i]*inarray[1][i]
425  + gmat[7][i]*inarray[2][i];
426 
427  stdVelocity[2][i] = gmat[2][i]*inarray[0][i]
428  + gmat[5][i]*inarray[1][i]
429  + gmat[8][i]*inarray[2][i];
430  }
431  }
432  else
433  {
434  Array<OneD, const NekDouble> jac =
435  el3D->GetGeom3D()->GetMetricInfo()->GetJac();
436  Array<TwoD, const NekDouble> gmat =
437  el3D->GetGeom3D()->GetMetricInfo()->GetDerivFactors();
438 
439  for (int i = 0; i < n_points; i++)
440  {
441  stdVelocity[0][i] = gmat[0][0]*inarray[0][i]
442  + gmat[3][0]*inarray[1][i]
443  + gmat[6][0]*inarray[2][i];
444 
445  stdVelocity[1][i] = gmat[1][0]*inarray[0][i]
446  + gmat[4][0]*inarray[1][i]
447  + gmat[7][0]*inarray[2][i];
448 
449  stdVelocity[2][i] = gmat[2][0]*inarray[0][i]
450  + gmat[5][0]*inarray[1][i]
451  + gmat[8][0]*inarray[2][i];
452  }
453  }
454 
455  for (int i = 0; i < n_points; i++)
456  {
457  pntVelocity = sqrt(stdVelocity[0][i]*stdVelocity[0][i]
458  + stdVelocity[1][i]*stdVelocity[1][i]
459  + stdVelocity[2][i]*stdVelocity[2][i]);
460 
461  if (pntVelocity > stdV[el])
462  {
463  stdV[el] = pntVelocity;
464  }
465  }
466  }
467  }
468 
469  return stdV;
470  }
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:161
int m_expdim
Expansion dimension.
SOLVER_UTILS_EXPORT int GetTotPoints()
boost::shared_ptr< Expansion3D > Expansion3DSharedPtr
Definition: Expansion2D.h:48
double NekDouble
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
Geometry is curved or has non-constant factors.
boost::shared_ptr< Expansion2D > Expansion2DSharedPtr
Definition: Expansion1D.h:49
void Nektar::CFLtester::v_GenerateSummary ( SummaryList s)
protectedvirtual

Print a summary of time stepping parameters.

Prints a summary with some information regards the time-stepping.

Reimplemented from Nektar::SolverUtils::UnsteadySystem.

Definition at line 222 of file CFLtester.cpp.

References Nektar::SolverUtils::UnsteadySystem::v_GenerateSummary().

223  {
225  }
virtual SOLVER_UTILS_EXPORT void v_GenerateSummary(SummaryList &s)
Print a summary of time stepping parameters.
void Nektar::CFLtester::v_GetFluxVector ( const int  i,
Array< OneD, Array< OneD, NekDouble > > &  physfield,
Array< OneD, Array< OneD, NekDouble > > &  flux 
)
protectedvirtual

Reimplemented from Nektar::SolverUtils::EquationSystem.

Definition at line 172 of file CFLtester.cpp.

References ASSERTL1, Nektar::SolverUtils::EquationSystem::GetNpoints(), m_velocity, and Vmath::Vmul().

176  {
177  ASSERTL1(flux.num_elements() == m_velocity.num_elements(),
178  "Dimension of flux array and velocity array do not match");
179 
180  for (int j = 0; j < flux.num_elements(); ++j)
181  {
183  physfield[i], 1,
184  m_velocity[j], 1,
185  flux[j], 1);
186  }
187  }
SOLVER_UTILS_EXPORT int GetNpoints()
Array< OneD, Array< OneD, NekDouble > > m_velocity
Definition: CFLtester.h:97
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:191
void Vmul(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Multiply vector z = x*y.
Definition: Vmath.cpp:169
NekDouble Nektar::CFLtester::v_GetTimeStep ( const Array< OneD, int >  ExpOrder,
const Array< OneD, NekDouble CFL,
NekDouble  timeCFL 
)
privatevirtual

Definition at line 229 of file CFLtester.cpp.

References GetStdVelocity(), Nektar::SolverUtils::EquationSystem::m_fields, m_velocity, and Vmath::Vmin().

233  {
234 
235  int n_element = m_fields[0]->GetExpSize();
236 
237  //const NekDouble minLengthStdTri = 1.414213;
238  //const NekDouble minLengthStdQuad = 2.0;
239  //const NekDouble cLambda = 0.2; // Spencer book pag. 317
240 
241  Array<OneD, NekDouble> tstep (n_element, 0.0);
242  Array<OneD, NekDouble> stdVelocity(n_element, 0.0);
243  stdVelocity = GetStdVelocity(m_velocity);
244 
245  for (int el = 0; el < n_element; ++el)
246  {
247  int npoints = m_fields[0]->GetExp(el)->GetTotPoints();
248  Array<OneD, NekDouble> one2D(npoints, 1.0);
249  //NekDouble Area = m_fields[0]->GetExp(el)->Integral(one2D);
250  if(boost::dynamic_pointer_cast<LocalRegions::TriExp>(m_fields[0]->GetExp(el)))
251  {
252  //tstep[el] = timeCFL/(stdVelocity[el]*cLambda*(ExpOrder[el]-1)*(ExpOrder[el]-1));
253  //tstep[el] = timeCFL*minLengthStdTri/(stdVelocity[el]*cLambda*(ExpOrder[el]-1)*(ExpOrder[el]-1));
254  tstep[el] = CFL[el]/(stdVelocity[el]);
255  }
256  else if(boost::dynamic_pointer_cast<LocalRegions::QuadExp>(m_fields[0]->GetExp(el)))
257  {
258  //tstep[el] = timeCFL/(stdVelocity[el]*cLambda*(ExpOrder[el]-1)*(ExpOrder[el]-1));
259  //tstep[el] = timeCFL*minLengthStdQuad/(stdVelocity[el]*cLambda*(ExpOrder[el]-1)*(ExpOrder[el]-1));
260  tstep[el] = CFL[el]/(stdVelocity[el]);
261  }
262  }
263 
264  NekDouble TimeStep = Vmath::Vmin(n_element, tstep, 1);
265 
266  return TimeStep;
267  }
T Vmin(int n, const T *x, const int incx)
Return the minimum element in x - called vmin to avoid conflict with min.
Definition: Vmath.cpp:857
Array< OneD, NekDouble > GetStdVelocity(const Array< OneD, Array< OneD, NekDouble > > inarray)
Definition: CFLtester.cpp:329
double NekDouble
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
Array< OneD, Array< OneD, NekDouble > > m_velocity
Definition: CFLtester.h:97
NekDouble Nektar::CFLtester::v_GetTimeStep ( int  ExpOrder,
NekDouble  CFL,
NekDouble  TimeStability 
)
privatevirtual

Definition at line 271 of file CFLtester.cpp.

References ASSERTL0, Nektar::EigenvaluesAnaMeshesAB2, Nektar::EigenvaluesAnaMeshesRK2, Nektar::EigenvaluesAnaMeshesRK4, and Nektar::SolverUtils::EquationSystem::m_fields.

275  {
276  //================================================================
277  // This function has been created just to test specific problems, hence is not general
278  // and it has been implemented in a rude fashion, as the full CFLtester class.
279  // For real CFL calculations refer to the general implementation above. (A.Bolis)
280  //================================================================
281 
282  NekDouble TimeStep;
283  NekDouble SpatialStability;
284  int n_elements = m_fields[0]->GetExpSize();
285 
286  //solve ambiguity in windows
287  NekDouble n_elem = n_elements;
288  NekDouble DH = sqrt(n_elem);
289 
290  int H = (int)DH;
291  int P = ExpOrder-1;
292 
293  //================================================================
294  // Regular meshes
295 
296  //SpatialStability = EigenvaluesRegMeshes[H-1][P-1];
297 
298  //================================================================
299  // Anisotropic meshes
300 
301  if (TimeStability == 1.0)
302  {
303  SpatialStability = EigenvaluesAnaMeshesAB2[H/2][P-1];
304  }
305  else if (TimeStability == 2.0)
306  {
307  SpatialStability = EigenvaluesAnaMeshesRK2[H/2][P-1];
308  }
309  else if (TimeStability == 2.784)
310  {
311  SpatialStability = EigenvaluesAnaMeshesRK4[H/2][P-1];
312  }
313  else
314  {
315  ASSERTL0(false,"Dominant eigenvalues database not present for this time-stepping scheme")
316  }
317 
318  //================================================================
319 
320  TimeStep = (TimeStability/SpatialStability)*CFL;
321 
322  //================================================================
323 
324  return TimeStep;
325  }
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:161
static NekDouble EigenvaluesAnaMeshesRK2[6][14]
Definition: CFLtester.h:65
static NekDouble EigenvaluesAnaMeshesRK4[6][14]
Definition: CFLtester.h:73
double NekDouble
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
static NekDouble EigenvaluesAnaMeshesAB2[6][14]
Definition: CFLtester.h:57
void Nektar::CFLtester::v_InitObject ( )
protectedvirtual

Init object for UnsteadySystem class.

Initialization object for UnsteadySystem class.

Reimplemented from Nektar::SolverUtils::UnsteadySystem.

Definition at line 54 of file CFLtester.cpp.

References ASSERTL0, Nektar::LibUtilities::TimeIntegrationSchemeOperators::DefineOdeRhs(), Nektar::LibUtilities::TimeIntegrationSchemeOperators::DefineProjection(), DoOdeProjection(), DoOdeRhs(), Nektar::SolverUtils::EquationSystem::EvaluateFunction(), Nektar::SolverUtils::UnsteadySystem::m_explicitAdvection, Nektar::SolverUtils::UnsteadySystem::m_ode, Nektar::SolverUtils::EquationSystem::m_spacedim, m_velocity, and Nektar::SolverUtils::UnsteadySystem::v_InitObject().

55  {
57 
58  m_velocity = Array<OneD, Array<OneD, NekDouble> >(m_spacedim);
59  std::vector<std::string> vel;
60  vel.push_back("Vx");
61  vel.push_back("Vy");
62  vel.push_back("Vz");
63  vel.resize(m_spacedim);
64 
65  EvaluateFunction(vel, m_velocity, "AdvectionVelocity");
66 
68  {
71  }
72  else
73  {
74  ASSERTL0(false, "Implicit unsteady Advection not set up.");
75  }
76  }
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:161
LibUtilities::TimeIntegrationSchemeOperators m_ode
The time integration scheme operators to use.
void DefineProjection(FuncPointerT func, ObjectPointerT obj)
bool m_explicitAdvection
Indicates if explicit or implicit treatment of advection is used.
void DoOdeRhs(const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
Definition: CFLtester.cpp:82
void DefineOdeRhs(FuncPointerT func, ObjectPointerT obj)
int m_spacedim
Spatial dimension (>= expansion dim).
virtual SOLVER_UTILS_EXPORT void v_InitObject()
Init object for UnsteadySystem class.
SOLVER_UTILS_EXPORT void EvaluateFunction(Array< OneD, Array< OneD, NekDouble > > &pArray, std::string pFunctionName, const NekDouble pTime=0.0, const int domain=0)
Evaluates a function as specified in the session file.
void DoOdeProjection(const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
Definition: CFLtester.cpp:131
Array< OneD, Array< OneD, NekDouble > > m_velocity
Definition: CFLtester.h:97
void Nektar::CFLtester::v_NumericalFlux ( Array< OneD, Array< OneD, NekDouble > > &  physfield,
Array< OneD, Array< OneD, NekDouble > > &  numflux 
)
protectedvirtual

Reimplemented from Nektar::SolverUtils::UnsteadySystem.

Definition at line 189 of file CFLtester.cpp.

References Nektar::SolverUtils::EquationSystem::GetTraceNpoints(), Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::EquationSystem::m_spacedim, Nektar::SolverUtils::EquationSystem::m_traceNormals, m_velocity, Vmath::Vmul(), and Vmath::Vvtvp().

192  {
193  int i;
194  int nTraceNumPoints = GetTraceNpoints();
195  int nvel = m_spacedim;
196 
197  Array<OneD, NekDouble > Fwd(nTraceNumPoints);
198  Array<OneD, NekDouble > Bwd(nTraceNumPoints);
199  Array<OneD, NekDouble > Vn (nTraceNumPoints,0.0);
200 
201  // Get Edge Velocity - Could be stored if time independent
202  for (i = 0; i < nvel; ++i)
203  {
204  m_fields[0]->ExtractTracePhys(m_velocity[i], Fwd);
205  Vmath::Vvtvp(nTraceNumPoints,
206  m_traceNormals[i], 1,
207  Fwd, 1, Vn, 1, Vn, 1);
208  }
209 
210  for (i = 0; i < numflux.num_elements(); ++i)
211  {
212  m_fields[i]->GetFwdBwdTracePhys(physfield[i], Fwd, Bwd);
213  //evaulate upwinded m_fields[i]
214  m_fields[i]->GetTrace()->Upwind(Vn, Fwd, Bwd, numflux[i]);
215  // calculate m_fields[i]*Vn
216  Vmath::Vmul(nTraceNumPoints, numflux[i], 1, Vn, 1, numflux[i], 1);
217  }
218  }
void Vvtvp(int n, const T *w, const int incw, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
vvtvp (vector times vector plus vector): z = w*x + y
Definition: Vmath.cpp:428
Array< OneD, Array< OneD, NekDouble > > m_traceNormals
Array holding trace normals for DG simulations in the forwards direction.
int m_spacedim
Spatial dimension (>= expansion dim).
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
SOLVER_UTILS_EXPORT int GetTraceNpoints()
Array< OneD, Array< OneD, NekDouble > > m_velocity
Definition: CFLtester.h:97
void Vmul(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Multiply vector z = x*y.
Definition: Vmath.cpp:169

Friends And Related Function Documentation

friend class MemoryManager< CFLtester >
friend

Definition at line 84 of file CFLtester.h.

Member Data Documentation

string Nektar::CFLtester::className = GetEquationSystemFactory().RegisterCreatorFunction("CFLtester", CFLtester::create, "Testing CFL restriction")
static

Definition at line 91 of file CFLtester.h.

Array<OneD, Array<OneD, NekDouble> > Nektar::CFLtester::m_velocity
protected

Definition at line 97 of file CFLtester.h.

Referenced by DoOdeRhs(), v_GetFluxVector(), v_GetTimeStep(), v_InitObject(), and v_NumericalFlux().