Nektar++
Static Public Member Functions | Static Public Attributes | Protected Member Functions | Protected Attributes | Private Attributes | Friends | List of all members
Nektar::UnsteadyAdvection Class Reference

#include <UnsteadyAdvection.h>

Inheritance diagram for Nektar::UnsteadyAdvection:
[legend]

Static Public Member Functions

static SolverUtils::EquationSystemSharedPtr create (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
 Creates an instance of this class. More...
 

Static Public Attributes

static std::string className
 Name of class. More...
 
- Static Public Attributes inherited from Nektar::SolverUtils::UnsteadySystem
static std::string cmdSetStartTime
 
static std::string cmdSetStartChkNum
 

Protected Member Functions

 UnsteadyAdvection (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
 
 ~UnsteadyAdvection () override=default
 
void v_InitObject (bool DeclareFields=true) override
 Initialise the object. More...
 
void DoOdeRhs (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
 Compute the RHS. More...
 
void DoOdeProjection (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
 Compute the projection. More...
 
Array< OneD, NekDouble > & GetNormalVelocity ()
 Get the normal velocity. More...
 
Array< OneD, NekDouble > & GetNormalVel (const Array< OneD, const Array< OneD, NekDouble > > &velfield)
 Get the normal velocity based on input velfield. More...
 
void GetFluxVector (const Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, Array< OneD, NekDouble > > > &flux)
 Evaluate the flux at each solution point. More...
 
void GetFluxVectorDeAlias (const Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, Array< OneD, NekDouble > > > &flux)
 Evaluate the flux at each solution point using dealiasing. More...
 
void v_GenerateSummary (SolverUtils::SummaryList &s) override
 Print Summary. More...
 
bool v_PreIntegrate (int step) override
 
void v_ExtraFldOutput (std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables) override
 
void v_ALEInitObject (int spaceDim, Array< OneD, MultiRegions::ExpListSharedPtr > &fields) override
 
- Protected Member Functions inherited from Nektar::SolverUtils::AdvectionSystem
SOLVER_UTILS_EXPORT void v_InitObject (bool DeclareField=true) override
 Initialisation object for EquationSystem. More...
 
SOLVER_UTILS_EXPORT bool v_PostIntegrate (int step) override
 
virtual SOLVER_UTILS_EXPORT Array< OneD, NekDoublev_GetMaxStdVelocity (const NekDouble SpeedSoundFactor=1.0)
 
- Protected Member Functions inherited from Nektar::SolverUtils::UnsteadySystem
SOLVER_UTILS_EXPORT UnsteadySystem (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
 Initialises UnsteadySystem class members. More...
 
SOLVER_UTILS_EXPORT void v_InitObject (bool DeclareField=true) override
 Init object for UnsteadySystem class. More...
 
SOLVER_UTILS_EXPORT void v_DoSolve () override
 Solves an unsteady problem. More...
 
virtual SOLVER_UTILS_EXPORT void v_PrintStatusInformation (const int step, const NekDouble cpuTime)
 Print Status Information. More...
 
virtual SOLVER_UTILS_EXPORT void v_PrintSummaryStatistics (const NekDouble intTime)
 Print Summary Statistics. More...
 
SOLVER_UTILS_EXPORT void v_DoInitialise (bool dumpInitialConditions=true) override
 Sets up initial conditions. More...
 
SOLVER_UTILS_EXPORT void v_GenerateSummary (SummaryList &s) override
 Print a summary of time stepping parameters. More...
 
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_RequireFwdTrans ()
 
virtual SOLVER_UTILS_EXPORT void v_SteadyStateResidual (int step, Array< OneD, NekDouble > &L2)
 
virtual SOLVER_UTILS_EXPORT bool v_UpdateTimeStepCheck ()
 
SOLVER_UTILS_EXPORT NekDouble MaxTimeStepEstimator ()
 Get the maximum timestep estimator for cfl control. More...
 
SOLVER_UTILS_EXPORT void CheckForRestartTime (NekDouble &time, int &nchk)
 
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...
 
SOLVER_UTILS_EXPORT void DoDummyProjection (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
 Perform dummy projection. More...
 
- Protected Member Functions inherited from Nektar::SolverUtils::EquationSystem
SOLVER_UTILS_EXPORT EquationSystem (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
 Initialises EquationSystem class members. More...
 
virtual SOLVER_UTILS_EXPORT void v_InitObject (bool DeclareFeld=true)
 Initialisation object for EquationSystem. More...
 
virtual SOLVER_UTILS_EXPORT void v_DoInitialise (bool dumpInitialConditions=true)
 Virtual function for initialisation implementation. More...
 
virtual SOLVER_UTILS_EXPORT void v_DoSolve ()
 Virtual function for solve implementation. More...
 
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 NekDouble v_H1Error (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray, bool Normalised=false)
 Virtual function for the H_1 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_GenerateSummary (SummaryList &l)
 Virtual function for generating summary information. 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)
 
virtual SOLVER_UTILS_EXPORT void v_Output (void)
 
virtual SOLVER_UTILS_EXPORT MultiRegions::ExpListSharedPtr v_GetPressure (void)
 
virtual SOLVER_UTILS_EXPORT bool v_NegatedOp (void)
 Virtual function to identify if operator is negated in DoSolve. More...
 
virtual SOLVER_UTILS_EXPORT void v_ExtraFldOutput (std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables)
 

Protected Attributes

bool m_useGJPStabilisation
 
NekDouble m_GJPJumpScale
 
SolverUtils::RiemannSolverSharedPtr m_riemannSolver
 
Array< OneD, Array< OneD, NekDouble > > m_velocity
 Advection velocity. More...
 
Array< OneD, NekDoublem_traceVn
 
std::vector< SolverUtils::ForcingSharedPtrm_forcing
 Forcing terms. More...
 
- Protected Attributes inherited from Nektar::SolverUtils::AdvectionSystem
SolverUtils::AdvectionSharedPtr m_advObject
 Advection term. More...
 
- Protected Attributes inherited from Nektar::SolverUtils::UnsteadySystem
LibUtilities::TimeIntegrationSchemeSharedPtr m_intScheme
 Wrapper to the time integration scheme. More...
 
LibUtilities::TimeIntegrationSchemeOperators m_ode
 The time integration scheme operators to use. More...
 
Array< OneD, Array< OneD, NekDouble > > m_previousSolution
 Storage for previous solution for steady-state check. More...
 
std::vector< int > m_intVariables
 
NekDouble m_cflSafetyFactor
 CFL safety factor (comprise between 0 to 1). More...
 
NekDouble m_CFLGrowth
 CFL growth rate. More...
 
NekDouble m_CFLEnd
 Maximun cfl in cfl growth. More...
 
int m_abortSteps
 Number of steps between checks for abort conditions. More...
 
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...
 
int m_steadyStateSteps
 Check for steady state at step interval. More...
 
NekDouble m_steadyStateTol
 Tolerance to which steady state should be evaluated at. More...
 
int m_filtersInfosteps
 Number of time steps between outputting filters information. More...
 
std::vector< std::pair< std::string, FilterSharedPtr > > m_filters
 
bool m_homoInitialFwd
 Flag to determine if simulation should start in homogeneous forward transformed state. More...
 
std::ofstream m_errFile
 
NekDouble m_epsilon
 Diffusion coefficient. More...
 
- Protected Attributes inherited from Nektar::SolverUtils::EquationSystem
LibUtilities::CommSharedPtr m_comm
 Communicator. More...
 
bool m_verbose
 
LibUtilities::SessionReaderSharedPtr m_session
 The session reader. More...
 
std::map< std::string, SolverUtils::SessionFunctionSharedPtrm_sessionFunctions
 Map of known SessionFunctions. More...
 
LibUtilities::FieldIOSharedPtr m_fld
 Field input/output. More...
 
Array< OneD, MultiRegions::ExpListSharedPtrm_fields
 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...
 
NekDouble m_checktime
 Time between checkpoints. More...
 
NekDouble m_lastCheckTime
 
NekDouble m_TimeIncrementFactor
 
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_infosteps
 Number of time steps between outputting status information. More...
 
int m_iterPIT = 0
 Number of parallel-in-time time iteration. More...
 
int m_windowPIT = 0
 Index of windows for parallel-in-time time iteration. 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, 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...
 
Array< OneD, NekDoublem_movingFrameData
 Moving reference frame status in the inertial frame X, Y, Z, Theta_x, Theta_y, Theta_z, U, V, W, Omega_x, Omega_y, Omega_z, A_x, A_y, A_z, DOmega_x, DOmega_y, DOmega_z, pivot_x, pivot_y, pivot_z. More...
 
std::vector< std::string > m_strFrameData
 variable name in m_movingFrameData 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...
 
- Protected Attributes inherited from Nektar::SolverUtils::ALEHelper
Array< OneD, MultiRegions::ExpListSharedPtrm_fieldsALE
 
Array< OneD, Array< OneD, NekDouble > > m_gridVelocity
 
Array< OneD, Array< OneD, NekDouble > > m_gridVelocityTrace
 
std::vector< ALEBaseShPtrm_ALEs
 
bool m_ALESolver = false
 
bool m_ImplicitALESolver = false
 
NekDouble m_prevStageTime = 0.0
 
int m_spaceDim
 

Private Attributes

NekDouble m_waveFreq
 

Friends

class MemoryManager< UnsteadyAdvection >
 

Additional Inherited Members

- Public Member Functions inherited from Nektar::SolverUtils::AdvectionSystem
SOLVER_UTILS_EXPORT AdvectionSystem (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
 
SOLVER_UTILS_EXPORT ~AdvectionSystem () override=default
 
SOLVER_UTILS_EXPORT AdvectionSharedPtr GetAdvObject ()
 Returns the advection object held by this instance. More...
 
SOLVER_UTILS_EXPORT Array< OneD, NekDoubleGetElmtCFLVals (const bool FlagAcousticCFL=true)
 
SOLVER_UTILS_EXPORT NekDouble GetCFLEstimate (int &elmtid)
 
- Public Member Functions inherited from Nektar::SolverUtils::UnsteadySystem
SOLVER_UTILS_EXPORT ~UnsteadySystem () override=default
 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...
 
SOLVER_UTILS_EXPORT NekDouble GetTimeStep ()
 
SOLVER_UTILS_EXPORT void SetTimeStep (const NekDouble timestep)
 
SOLVER_UTILS_EXPORT void SteadyStateResidual (int step, Array< OneD, NekDouble > &L2)
 
SOLVER_UTILS_EXPORT LibUtilities::TimeIntegrationSchemeSharedPtrGetTimeIntegrationScheme ()
 Returns the time integration scheme. More...
 
SOLVER_UTILS_EXPORT LibUtilities::TimeIntegrationSchemeOperatorsGetTimeIntegrationSchemeOperators ()
 Returns the time integration scheme operators. More...
 
- Public Member Functions inherited from Nektar::SolverUtils::EquationSystem
virtual SOLVER_UTILS_EXPORT ~EquationSystem ()
 Destructor. More...
 
SOLVER_UTILS_EXPORT void InitObject (bool DeclareField=true)
 Initialises the members of this object. More...
 
SOLVER_UTILS_EXPORT void DoInitialise (bool dumpInitialConditions=true)
 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 std::string GetSessionName ()
 Get Session name. More...
 
template<class T >
std::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 ExtraFldOutput (std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables)
 
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 SessionFunctionSharedPtr GetFunction (std::string name, const MultiRegions::ExpListSharedPtr &field=MultiRegions::NullExpListSharedPtr, bool cache=false)
 Get a SessionFunction by name. 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 NekDouble LinfError (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray)
 Linf error computation. More...
 
SOLVER_UTILS_EXPORT NekDouble H1Error (unsigned int field, const Array< OneD, NekDouble > &exactsoln, bool Normalised=false)
 Compute the H1 error between fields and a given exact solution. More...
 
SOLVER_UTILS_EXPORT Array< OneD, NekDoubleErrorExtraPoints (unsigned int field)
 Compute error (L2 and L_inf) over an larger set of quadrature points return [L2 Linf]. 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 SessionSummary (SummaryList &vSummary)
 Write out a session summary. More...
 
SOLVER_UTILS_EXPORT Array< OneD, MultiRegions::ExpListSharedPtr > & UpdateFields ()
 
SOLVER_UTILS_EXPORT LibUtilities::FieldMetaDataMapUpdateFieldMetaDataMap ()
 Get hold of FieldInfoMap so it can be updated. More...
 
SOLVER_UTILS_EXPORT NekDouble GetTime ()
 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 GetSteps ()
 
SOLVER_UTILS_EXPORT void SetSteps (const int steps)
 
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, const Array< OneD, const NekDouble > &input)
 
SOLVER_UTILS_EXPORT Array< OneD, NekDouble > & UpdatePhysField (const int i)
 
SOLVER_UTILS_EXPORT void ZeroPhysFields ()
 
SOLVER_UTILS_EXPORT void FwdTransFields ()
 
SOLVER_UTILS_EXPORT void SetModifiedBasis (const bool modbasis)
 
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 int GetInfoSteps ()
 
SOLVER_UTILS_EXPORT void SetInfoSteps (int num)
 
SOLVER_UTILS_EXPORT void SetIterationNumberPIT (int num)
 
SOLVER_UTILS_EXPORT void SetWindowNumberPIT (int num)
 
SOLVER_UTILS_EXPORT Array< OneD, const Array< OneD, NekDouble > > GetTraceNormals ()
 
SOLVER_UTILS_EXPORT void SetTime (const NekDouble time)
 
SOLVER_UTILS_EXPORT void SetTimeStep (const NekDouble timestep)
 
SOLVER_UTILS_EXPORT void SetInitialStep (const int step)
 
SOLVER_UTILS_EXPORT void SetBoundaryConditions (NekDouble time)
 Evaluates the boundary conditions at the given time. More...
 
SOLVER_UTILS_EXPORT bool NegatedOp ()
 Identify if operator is negated in DoSolve. More...
 
- Public Member Functions inherited from Nektar::SolverUtils::ALEHelper
virtual ~ALEHelper ()=default
 
virtual SOLVER_UTILS_EXPORT void v_ALEInitObject (int spaceDim, Array< OneD, MultiRegions::ExpListSharedPtr > &fields)
 
SOLVER_UTILS_EXPORT void InitObject (int spaceDim, Array< OneD, MultiRegions::ExpListSharedPtr > &fields)
 
virtual SOLVER_UTILS_EXPORT void v_UpdateGridVelocity (const NekDouble &time)
 
virtual SOLVER_UTILS_EXPORT void v_ALEPreMultiplyMass (Array< OneD, Array< OneD, NekDouble > > &fields)
 
SOLVER_UTILS_EXPORT void ALEDoElmtInvMass (Array< OneD, Array< OneD, NekDouble > > &traceNormals, Array< OneD, Array< OneD, NekDouble > > &fields, NekDouble time)
 Update m_fields with u^n by multiplying by inverse mass matrix. That's then used in e.g. checkpoint output and L^2 error calculation. More...
 
SOLVER_UTILS_EXPORT void ALEDoElmtInvMassBwdTrans (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray)
 
SOLVER_UTILS_EXPORT void MoveMesh (const NekDouble &time, Array< OneD, Array< OneD, NekDouble > > &traceNormals)
 
const Array< OneD, const Array< OneD, NekDouble > > & GetGridVelocity ()
 
SOLVER_UTILS_EXPORT const Array< OneD, const Array< OneD, NekDouble > > & GetGridVelocityTrace ()
 
SOLVER_UTILS_EXPORT void ExtraFldOutputGridVelocity (std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables)
 
- Protected Types inherited from Nektar::SolverUtils::EquationSystem
enum  HomogeneousType { eHomogeneous1D , eHomogeneous2D , eHomogeneous3D , eNotHomogeneous }
 Parameter for homogeneous expansions. More...
 
- Static Protected Attributes inherited from Nektar::SolverUtils::EquationSystem
static std::string equationSystemTypeLookupIds []
 
static std::string projectionTypeLookupIds []
 

Detailed Description

Definition at line 44 of file UnsteadyAdvection.h.

Constructor & Destructor Documentation

◆ UnsteadyAdvection()

Nektar::UnsteadyAdvection::UnsteadyAdvection ( const LibUtilities::SessionReaderSharedPtr pSession,
const SpatialDomains::MeshGraphSharedPtr pGraph 
)
protected

Definition at line 49 of file UnsteadyAdvection.cpp.

52 : UnsteadySystem(pSession, pGraph), AdvectionSystem(pSession, pGraph)
53{
54}
SOLVER_UTILS_EXPORT AdvectionSystem(const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
SOLVER_UTILS_EXPORT UnsteadySystem(const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
Initialises UnsteadySystem class members.

◆ ~UnsteadyAdvection()

Nektar::UnsteadyAdvection::~UnsteadyAdvection ( )
overrideprotecteddefault

Member Function Documentation

◆ create()

static SolverUtils::EquationSystemSharedPtr Nektar::UnsteadyAdvection::create ( const LibUtilities::SessionReaderSharedPtr pSession,
const SpatialDomains::MeshGraphSharedPtr pGraph 
)
inlinestatic

Creates an instance of this class.

Definition at line 50 of file UnsteadyAdvection.h.

53 {
56 pGraph);
57 p->InitObject();
58 return p;
59 }
static std::shared_ptr< DataType > AllocateSharedPtr(const Args &...args)
Allocate a shared pointer from the memory pool.
std::shared_ptr< EquationSystem > EquationSystemSharedPtr
A shared pointer to an EquationSystem object.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), and CellMLToNektar.cellml_metadata::p.

◆ DoOdeProjection()

void Nektar::UnsteadyAdvection::DoOdeProjection ( const Array< OneD, const Array< OneD, NekDouble > > &  inarray,
Array< OneD, Array< OneD, NekDouble > > &  outarray,
const NekDouble  time 
)
protected

Compute the projection.

Compute the projection for the linear advection equation.

Parameters
inarrayGiven fields.
outarrayCalculated solution.
timeTime.

Definition at line 235 of file UnsteadyAdvection.cpp.

238{
239 // Number of fields (variables of the problem)
240 int nVariables = inarray.size();
241
242 // Perform ALE movement
243 if (m_ALESolver)
244 {
246 }
247
248 // Set the boundary conditions
250
251 // Switch on the projection type (Discontinuous or Continuous)
252 switch (m_projectionType)
253 {
254 // Discontinuous projection
256 {
257 // Just copy over array
258 if (inarray != outarray)
259 {
260 int npoints = GetNpoints();
261
262 for (int i = 0; i < nVariables; ++i)
263 {
264 Vmath::Vcopy(npoints, inarray[i], 1, outarray[i], 1);
265 }
266 }
267 break;
268 }
269 // Continuous projection
272 {
273 int ncoeffs = m_fields[0]->GetNcoeffs();
274 Array<OneD, NekDouble> coeffs(ncoeffs, 0.0);
276 {
279
280 Array<OneD, NekDouble> wsp(ncoeffs);
281
282 for (int i = 0; i < nVariables; ++i)
283 {
285 std::dynamic_pointer_cast<MultiRegions::ContField>(
286 m_fields[i]);
287
288 m_fields[i]->IProductWRTBase(inarray[i], wsp);
289
291 cfield->GetGJPForcing();
292
295
296 if (GJPData->IsSemiImplicit())
297 {
298 mtype = StdRegions::eMassGJP;
299 }
300
301 // to set up forcing need initial guess in
302 // physical space
304
305 GJPData->Apply(inarray[i], wsp, NullNekDouble1DArray,
306 scale);
307
308 // Solve the system
309 MultiRegions::GlobalLinSysKey key(
310 mtype, cfield->GetLocalToGlobalMap(), factors);
311
312 cfield->GlobalSolve(key, wsp, coeffs, NullNekDouble1DArray);
313
314 m_fields[i]->BwdTrans(coeffs, outarray[i]);
315 }
316 }
317 else
318 {
319 for (int i = 0; i < nVariables; ++i)
320 {
321 m_fields[i]->FwdTrans(inarray[i], coeffs);
322 m_fields[i]->BwdTrans(coeffs, outarray[i]);
323 }
324 }
325 break;
326 }
327 default:
328 ASSERTL0(false, "Unknown projection scheme");
329 break;
330 }
331}
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:208
SOLVER_UTILS_EXPORT void MoveMesh(const NekDouble &time, Array< OneD, Array< OneD, NekDouble > > &traceNormals)
Definition: ALEHelper.cpp:168
NekDouble m_timestep
Time step size.
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
SOLVER_UTILS_EXPORT int GetNpoints()
Array< OneD, Array< OneD, NekDouble > > m_traceNormals
Array holding trace normals for DG simulations in the forwards direction.
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.
std::shared_ptr< GJPStabilisation > GJPStabilisationSharedPtr
std::shared_ptr< ContField > ContFieldSharedPtr
Definition: ContField.h:268
std::map< ConstFactorType, NekDouble > ConstFactorMap
Definition: StdRegions.hpp:430
StdRegions::ConstFactorMap factors
static Array< OneD, NekDouble > NullNekDouble1DArray
double NekDouble
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.hpp:825

References ASSERTL0, Nektar::MultiRegions::eDiscontinuous, Nektar::StdRegions::eFactorGJP, Nektar::MultiRegions::eGalerkin, Nektar::StdRegions::eMass, Nektar::StdRegions::eMassGJP, Nektar::MultiRegions::eMixed_CG_Discontinuous, Nektar::VarcoeffHashingTest::factors, Nektar::SolverUtils::EquationSystem::GetNpoints(), Nektar::SolverUtils::ALEHelper::m_ALESolver, Nektar::SolverUtils::EquationSystem::m_fields, m_GJPJumpScale, Nektar::SolverUtils::EquationSystem::m_projectionType, Nektar::SolverUtils::EquationSystem::m_timestep, Nektar::SolverUtils::EquationSystem::m_traceNormals, m_useGJPStabilisation, Nektar::SolverUtils::ALEHelper::MoveMesh(), Nektar::NullNekDouble1DArray, Nektar::SolverUtils::EquationSystem::SetBoundaryConditions(), and Vmath::Vcopy().

Referenced by v_InitObject().

◆ DoOdeRhs()

void Nektar::UnsteadyAdvection::DoOdeRhs ( const Array< OneD, const Array< OneD, NekDouble > > &  inarray,
Array< OneD, Array< OneD, NekDouble > > &  outarray,
const NekDouble  time 
)
protected

Compute the RHS.

Compute the right-hand side for the linear advection equation.

Parameters
inarrayGiven fields.
outarrayCalculated solution.
timeTime.

Definition at line 182 of file UnsteadyAdvection.cpp.

185{
186 // Number of fields (variables of the problem)
187 int nVariables = inarray.size();
188
189 LibUtilities::Timer timer;
190 if (m_ALESolver)
191 {
192 timer.Start();
193 Array<OneD, Array<OneD, NekDouble>> tmpIn(nVariables);
194 // If ALE we must take Mu coefficient space to u physical space
196 auto advWeakDGObject =
197 std::dynamic_pointer_cast<SolverUtils::AdvectionWeakDG>(
199 advWeakDGObject->AdvectCoeffs(nVariables, m_fields, m_velocity, tmpIn,
200 outarray, time);
201 timer.Stop();
202 }
203 else
204 {
205 timer.Start();
206 m_advObject->Advect(nVariables, m_fields, m_velocity, inarray, outarray,
207 time);
208 timer.Stop();
209 }
210
211 // Elapsed time
212 timer.AccumulateRegion("Advect");
213
214 // Negate the RHS
215 for (int i = 0; i < nVariables; ++i)
216 {
217 Vmath::Neg(outarray[i].size(), outarray[i], 1);
218 }
219
220 // Add forcing terms
221 for (auto &x : m_forcing)
222 {
223 // set up non-linear terms
224 x->Apply(m_fields, inarray, outarray, time);
225 }
226}
SOLVER_UTILS_EXPORT void ALEDoElmtInvMassBwdTrans(const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray)
Definition: ALEHelper.cpp:148
SolverUtils::AdvectionSharedPtr m_advObject
Advection term.
std::vector< SolverUtils::ForcingSharedPtr > m_forcing
Forcing terms.
Array< OneD, Array< OneD, NekDouble > > m_velocity
Advection velocity.
void Neg(int n, T *x, const int incx)
Negate x = -x.
Definition: Vmath.hpp:292

References Nektar::LibUtilities::Timer::AccumulateRegion(), Nektar::SolverUtils::ALEHelper::ALEDoElmtInvMassBwdTrans(), Nektar::SolverUtils::AdvectionSystem::m_advObject, Nektar::SolverUtils::ALEHelper::m_ALESolver, Nektar::SolverUtils::EquationSystem::m_fields, m_forcing, m_velocity, Vmath::Neg(), Nektar::LibUtilities::Timer::Start(), and Nektar::LibUtilities::Timer::Stop().

Referenced by Nektar::UnsteadyAdvectionDiffusion::DoOdeRhs(), and v_InitObject().

◆ GetFluxVector()

void Nektar::UnsteadyAdvection::GetFluxVector ( const Array< OneD, Array< OneD, NekDouble > > &  physfield,
Array< OneD, Array< OneD, Array< OneD, NekDouble > > > &  flux 
)
protected

Evaluate the flux at each solution point.

Return the flux vector for the linear advection equation.

Parameters
physfieldFields.
fluxResulting flux.

Definition at line 375 of file UnsteadyAdvection.cpp.

378{
379 ASSERTL1(flux[0].size() == m_velocity.size(),
380 "Dimension of flux array and velocity array do not match");
381
382 const int nq = m_fields[0]->GetNpoints();
383
384 for (int i = 0; i < flux.size(); ++i)
385 {
386 for (int j = 0; j < flux[0].size(); ++j)
387 {
388 for (int k = 0; k < nq; ++k)
389 {
390 // If ALE we need to take off the grid velocity
391 flux[i][j][k] =
392 physfield[i][k] * (m_velocity[j][k] - m_gridVelocity[j][k]);
393 }
394 }
395 }
396}
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode....
Definition: ErrorUtil.hpp:242
Array< OneD, Array< OneD, NekDouble > > m_gridVelocity
Definition: ALEHelper.h:89

References ASSERTL1, Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::ALEHelper::m_gridVelocity, and m_velocity.

Referenced by v_InitObject().

◆ GetFluxVectorDeAlias()

void Nektar::UnsteadyAdvection::GetFluxVectorDeAlias ( const Array< OneD, Array< OneD, NekDouble > > &  physfield,
Array< OneD, Array< OneD, Array< OneD, NekDouble > > > &  flux 
)
protected

Evaluate the flux at each solution point using dealiasing.

Return the flux vector for the linear advection equation using the dealiasing technique.

Parameters
physfieldFields.
fluxResulting flux.

Definition at line 405 of file UnsteadyAdvection.cpp.

408{
409 ASSERTL1(flux[0].size() == m_velocity.size(),
410 "Dimension of flux array and velocity array do not match");
411
412 int nq = physfield[0].size();
413 int nVariables = physfield.size();
414
415 // Factor to rescale 1d points in dealiasing
416 NekDouble OneDptscale = 2;
417
418 Array<OneD, Array<OneD, NekDouble>> advVel_plane(m_velocity.size());
419
420 // Get number of points to dealias a cubic non-linearity
421 nq = m_fields[0]->Get1DScaledTotPoints(OneDptscale);
422
423 // Initialisation of higher-space variables
424 Array<OneD, Array<OneD, NekDouble>> physfieldInterp(nVariables);
425 Array<OneD, Array<OneD, NekDouble>> velocityInterp(m_expdim);
426 Array<OneD, Array<OneD, Array<OneD, NekDouble>>> fluxInterp(nVariables);
427
428 // Interpolation to higher space of physfield
429 for (int i = 0; i < nVariables; ++i)
430 {
431 physfieldInterp[i] = Array<OneD, NekDouble>(nq);
432 fluxInterp[i] = Array<OneD, Array<OneD, NekDouble>>(m_expdim);
433 for (int j = 0; j < m_expdim; ++j)
434 {
435 fluxInterp[i][j] = Array<OneD, NekDouble>(nq);
436 }
437
438 m_fields[0]->PhysInterp1DScaled(OneDptscale, physfield[i],
439 physfieldInterp[i]);
440 }
441
442 // Interpolation to higher space of velocity
443 for (int j = 0; j < m_expdim; ++j)
444 {
445 velocityInterp[j] = Array<OneD, NekDouble>(nq);
446
447 m_fields[0]->PhysInterp1DScaled(OneDptscale, m_velocity[j],
448 velocityInterp[j]);
449 }
450
451 // Evaluation of flux vector in the higher space
452 for (int i = 0; i < flux.size(); ++i)
453 {
454 for (int j = 0; j < flux[0].size(); ++j)
455 {
456 Vmath::Vmul(nq, physfieldInterp[i], 1, velocityInterp[j], 1,
457 fluxInterp[i][j], 1);
458 }
459 }
460
461 // Galerkin project solution back to original space
462 for (int i = 0; i < nVariables; ++i)
463 {
464 for (int j = 0; j < m_spacedim; ++j)
465 {
466 m_fields[0]->PhysGalerkinProjection1DScaled(
467 OneDptscale, fluxInterp[i][j], flux[i][j]);
468 }
469 }
470}
int m_spacedim
Spatial dimension (>= expansion dim).
int m_expdim
Expansion dimension.
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.hpp:72

References ASSERTL1, Nektar::SolverUtils::EquationSystem::m_expdim, Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::EquationSystem::m_spacedim, m_velocity, and Vmath::Vmul().

Referenced by v_InitObject().

◆ GetNormalVel()

Array< OneD, NekDouble > & Nektar::UnsteadyAdvection::GetNormalVel ( const Array< OneD, const Array< OneD, NekDouble > > &  velfield)
protected

Get the normal velocity based on input velfield.

Definition at line 342 of file UnsteadyAdvection.cpp.

344{
345 // Number of trace (interface) points
346 int nTracePts = GetTraceNpoints();
347 int nPts = m_velocity[0].size();
348
349 // Auxiliary variable to compute the normal velocity
350 Array<OneD, NekDouble> tmp(nPts), tmp2(nTracePts);
351
352 // Reset the normal velocity
353 Vmath::Zero(nTracePts, m_traceVn, 1);
354
355 for (int i = 0; i < velfield.size(); ++i)
356 {
357 // velocity - grid velocity for ALE before getting trace velocity
358 Vmath::Vsub(nPts, velfield[i], 1, m_gridVelocity[i], 1, tmp, 1);
359
360 m_fields[0]->ExtractTracePhys(tmp, tmp2);
361
362 Vmath::Vvtvp(nTracePts, m_traceNormals[i], 1, tmp2, 1, m_traceVn, 1,
363 m_traceVn, 1);
364 }
365
366 return m_traceVn;
367}
SOLVER_UTILS_EXPORT int GetTraceNpoints()
Array< OneD, NekDouble > m_traceVn
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.hpp:366
void Zero(int n, T *x, const int incx)
Zero vector.
Definition: Vmath.hpp:273
void Vsub(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Subtract vector z = x-y.
Definition: Vmath.hpp:220

References Nektar::SolverUtils::EquationSystem::GetTraceNpoints(), Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::ALEHelper::m_gridVelocity, Nektar::SolverUtils::EquationSystem::m_traceNormals, m_traceVn, m_velocity, Vmath::Vsub(), Vmath::Vvtvp(), and Vmath::Zero().

Referenced by Nektar::UnsteadyAdvectionDiffusion::AddAdvectionPenaltyFlux(), and GetNormalVelocity().

◆ GetNormalVelocity()

Array< OneD, NekDouble > & Nektar::UnsteadyAdvection::GetNormalVelocity ( )
protected

Get the normal velocity.

Get the normal velocity for the linear advection equation.

Definition at line 336 of file UnsteadyAdvection.cpp.

337{
339 return m_traceVn;
340}
Array< OneD, NekDouble > & GetNormalVel(const Array< OneD, const Array< OneD, NekDouble > > &velfield)
Get the normal velocity based on input velfield.

References GetNormalVel(), m_traceVn, and m_velocity.

Referenced by v_InitObject(), and Nektar::UnsteadyAdvectionDiffusion::v_InitObject().

◆ v_ALEInitObject()

void Nektar::UnsteadyAdvection::v_ALEInitObject ( int  spaceDim,
Array< OneD, MultiRegions::ExpListSharedPtr > &  fields 
)
overrideprotectedvirtual

Reimplemented from Nektar::SolverUtils::ALEHelper.

Reimplemented in Nektar::UnsteadyAdvectionDiffusion.

Definition at line 502 of file UnsteadyAdvection.cpp.

504{
506 {
507 m_spaceDim = spaceDim;
508 m_fieldsALE = fields;
509
510 // Initialise grid velocities as 0s
511 m_gridVelocity = Array<OneD, Array<OneD, NekDouble>>(m_spaceDim);
512 m_gridVelocityTrace = Array<OneD, Array<OneD, NekDouble>>(m_spaceDim);
513 for (int i = 0; i < spaceDim; ++i)
514 {
515 m_gridVelocity[i] =
516 Array<OneD, NekDouble>(fields[0]->GetTotPoints(), 0.0);
517 m_gridVelocityTrace[i] = Array<OneD, NekDouble>(
518 fields[0]->GetTrace()->GetTotPoints(), 0.0);
519 }
520 }
521 ALEHelper::InitObject(spaceDim, fields);
522}
Array< OneD, MultiRegions::ExpListSharedPtr > m_fieldsALE
Definition: ALEHelper.h:88
SOLVER_UTILS_EXPORT void InitObject(int spaceDim, Array< OneD, MultiRegions::ExpListSharedPtr > &fields)
Definition: ALEHelper.cpp:48
Array< OneD, Array< OneD, NekDouble > > m_gridVelocityTrace
Definition: ALEHelper.h:90
SOLVER_UTILS_EXPORT int GetTotPoints()

References Nektar::MultiRegions::eDiscontinuous, Nektar::SolverUtils::EquationSystem::GetTotPoints(), Nektar::SolverUtils::ALEHelper::InitObject(), Nektar::SolverUtils::ALEHelper::m_fieldsALE, Nektar::SolverUtils::ALEHelper::m_gridVelocity, Nektar::SolverUtils::ALEHelper::m_gridVelocityTrace, Nektar::SolverUtils::EquationSystem::m_projectionType, and Nektar::SolverUtils::ALEHelper::m_spaceDim.

◆ v_ExtraFldOutput()

void Nektar::UnsteadyAdvection::v_ExtraFldOutput ( std::vector< Array< OneD, NekDouble > > &  fieldcoeffs,
std::vector< std::string > &  variables 
)
overrideprotectedvirtual

Reimplemented from Nektar::SolverUtils::EquationSystem.

Reimplemented in Nektar::UnsteadyAdvectionDiffusion.

Definition at line 489 of file UnsteadyAdvection.cpp.

492{
493 bool extraFields;
494 m_session->MatchSolverInfo("OutputExtraFields", "True", extraFields, true);
495
496 if (extraFields && m_ALESolver)
497 {
498 ExtraFldOutputGridVelocity(fieldcoeffs, variables);
499 }
500}
SOLVER_UTILS_EXPORT void ExtraFldOutputGridVelocity(std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables)
Definition: ALEHelper.cpp:389
LibUtilities::SessionReaderSharedPtr m_session
The session reader.

References Nektar::SolverUtils::ALEHelper::ExtraFldOutputGridVelocity(), Nektar::SolverUtils::ALEHelper::m_ALESolver, and Nektar::SolverUtils::EquationSystem::m_session.

◆ v_GenerateSummary()

void Nektar::UnsteadyAdvection::v_GenerateSummary ( SolverUtils::SummaryList s)
overrideprotectedvirtual

Print Summary.

Reimplemented from Nektar::SolverUtils::UnsteadySystem.

Reimplemented in Nektar::UnsteadyAdvectionDiffusion.

Definition at line 472 of file UnsteadyAdvection.cpp.

473{
476 {
478 s, "GJP Stab. Impl. ",
479 m_session->GetSolverInfo("GJPStabilisation"));
480 SolverUtils::AddSummaryItem(s, "GJP Stab. JumpScale", m_GJPJumpScale);
481 }
482}
SOLVER_UTILS_EXPORT void v_GenerateSummary(SummaryList &s) override
Print a summary of time stepping parameters.
void AddSummaryItem(SummaryList &l, const std::string &name, const std::string &value)
Adds a summary item to the summary info list.
Definition: Misc.cpp:47

References Nektar::SolverUtils::AddSummaryItem(), m_GJPJumpScale, Nektar::SolverUtils::EquationSystem::m_session, m_useGJPStabilisation, and Nektar::SolverUtils::UnsteadySystem::v_GenerateSummary().

Referenced by Nektar::UnsteadyAdvectionDiffusion::v_GenerateSummary().

◆ v_InitObject()

void Nektar::UnsteadyAdvection::v_InitObject ( bool  DeclareFields = true)
overrideprotectedvirtual

Initialise the object.

Initialisation object for the unsteady linear advection equation.

Reimplemented from Nektar::SolverUtils::AdvectionSystem.

Reimplemented in Nektar::UnsteadyAdvectionDiffusion.

Definition at line 59 of file UnsteadyAdvection.cpp.

60{
61 // Call to the initialisation object of UnsteadySystem
62 AdvectionSystem::v_InitObject(DeclareFields);
63
64 // Read the advection velocities from session file
65 m_session->LoadParameter("wavefreq", m_waveFreq, 0.0);
66
67 // check to see if it is explicity turned off
68 m_session->MatchSolverInfo("GJPStabilisation", "False",
70
71 // if GJPStabilisation set to False bool will be true and
72 // if not false so negate/revese bool
74
75 m_session->LoadParameter("GJPJumpScale", m_GJPJumpScale, 1.0);
76
77 // Define Velocity fields
78 std::vector<std::string> vel;
79 vel.push_back("Vx");
80 vel.push_back("Vy");
81 vel.push_back("Vz");
82
83 // Resize the advection velocities vector to dimension of the problem
84 vel.resize(m_spacedim);
85
86 // Store in the global variable m_velocity the advection velocities
87 m_velocity = Array<OneD, Array<OneD, NekDouble>>(m_spacedim);
88 GetFunction("AdvectionVelocity")->Evaluate(vel, m_velocity);
89
90 // Type of advection class to be used
91 switch (m_projectionType)
92 {
93 // Discontinuous field
95 {
96 // Do not forwards transform initial condition
97 m_homoInitialFwd = false;
98
99 // Define the normal velocity fields
100 if (m_fields[0]->GetTrace())
101 {
102 m_traceVn = Array<OneD, NekDouble>(GetTraceNpoints());
103 }
104
105 std::string advName;
106 std::string riemName;
107 m_session->LoadSolverInfo("AdvectionType", advName, "WeakDG");
109 advName, advName);
111 {
112 m_advObject->SetFluxVector(
114 }
115 else
116 {
118 this);
119 }
120 m_session->LoadSolverInfo("UpwindType", riemName, "Upwind");
123 riemName, m_session);
124 m_riemannSolver->SetScalar(
126 m_advObject->SetRiemannSolver(m_riemannSolver);
127 m_advObject->InitObject(m_session, m_fields);
128 break;
129 }
130 // Continuous field
133 {
134 std::string advName;
135 m_session->LoadSolverInfo("AdvectionType", advName,
136 "NonConservative");
138 advName, advName);
140 {
141 m_advObject->SetFluxVector(
143 }
144 else
145 {
147 this);
148 }
149 break;
150 }
151 default:
152 {
153 ASSERTL0(false, "Unsupported projection type.");
154 break;
155 }
156 }
157
158 // Forcing terms
159 m_forcing = SolverUtils::Forcing::Load(m_session, shared_from_this(),
160 m_fields, m_fields.size());
161
162 // If explicit it computes RHS and PROJECTION for the time integration
164 {
167 }
168 // Otherwise it gives an error (no implicit integration)
169 else
170 {
171 ASSERTL0(false, "Implicit unsteady Advection not set up.");
172 }
173}
tBaseSharedPtr CreateInstance(tKey idKey, tParam... args)
Create an instance of the class referred to by idKey.
void DefineProjection(FuncPointerT func, ObjectPointerT obj)
void DefineOdeRhs(FuncPointerT func, ObjectPointerT obj)
SOLVER_UTILS_EXPORT void v_InitObject(bool DeclareField=true) override
Initialisation object for EquationSystem.
bool m_specHP_dealiasing
Flag to determine if dealisising is usde for the Spectral/hp element discretisation.
SOLVER_UTILS_EXPORT SessionFunctionSharedPtr GetFunction(std::string name, const MultiRegions::ExpListSharedPtr &field=MultiRegions::NullExpListSharedPtr, bool cache=false)
Get a SessionFunction by name.
static SOLVER_UTILS_EXPORT std::vector< ForcingSharedPtr > Load(const LibUtilities::SessionReaderSharedPtr &pSession, const std::weak_ptr< EquationSystem > &pEquation, const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const unsigned int &pNumForcingFields=0)
Definition: Forcing.cpp:76
LibUtilities::TimeIntegrationSchemeOperators m_ode
The time integration scheme operators to use.
bool m_explicitAdvection
Indicates if explicit or implicit treatment of advection is used.
bool m_homoInitialFwd
Flag to determine if simulation should start in homogeneous forward transformed state.
Array< OneD, NekDouble > & GetNormalVelocity()
Get the normal velocity.
void DoOdeRhs(const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
Compute the RHS.
void DoOdeProjection(const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
Compute the projection.
void GetFluxVectorDeAlias(const Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, Array< OneD, NekDouble > > > &flux)
Evaluate the flux at each solution point using dealiasing.
void GetFluxVector(const Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, Array< OneD, NekDouble > > > &flux)
Evaluate the flux at each solution point.
SolverUtils::RiemannSolverSharedPtr m_riemannSolver
AdvectionFactory & GetAdvectionFactory()
Gets the factory for initialising advection objects.
Definition: Advection.cpp:43
RiemannSolverFactory & GetRiemannSolverFactory()

References ASSERTL0, Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::CreateInstance(), Nektar::LibUtilities::TimeIntegrationSchemeOperators::DefineOdeRhs(), Nektar::LibUtilities::TimeIntegrationSchemeOperators::DefineProjection(), DoOdeProjection(), DoOdeRhs(), Nektar::MultiRegions::eDiscontinuous, Nektar::MultiRegions::eGalerkin, Nektar::MultiRegions::eMixed_CG_Discontinuous, Nektar::SolverUtils::GetAdvectionFactory(), GetFluxVector(), GetFluxVectorDeAlias(), Nektar::SolverUtils::EquationSystem::GetFunction(), GetNormalVelocity(), Nektar::SolverUtils::GetRiemannSolverFactory(), Nektar::SolverUtils::EquationSystem::GetTraceNpoints(), Nektar::SolverUtils::Forcing::Load(), Nektar::SolverUtils::AdvectionSystem::m_advObject, Nektar::SolverUtils::UnsteadySystem::m_explicitAdvection, Nektar::SolverUtils::EquationSystem::m_fields, m_forcing, m_GJPJumpScale, Nektar::SolverUtils::UnsteadySystem::m_homoInitialFwd, Nektar::SolverUtils::UnsteadySystem::m_ode, Nektar::SolverUtils::EquationSystem::m_projectionType, m_riemannSolver, Nektar::SolverUtils::EquationSystem::m_session, Nektar::SolverUtils::EquationSystem::m_spacedim, Nektar::SolverUtils::EquationSystem::m_specHP_dealiasing, m_traceVn, m_useGJPStabilisation, m_velocity, m_waveFreq, and Nektar::SolverUtils::AdvectionSystem::v_InitObject().

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

◆ v_PreIntegrate()

bool Nektar::UnsteadyAdvection::v_PreIntegrate ( int  step)
overrideprotectedvirtual

Reimplemented from Nektar::SolverUtils::UnsteadySystem.

Reimplemented in Nektar::UnsteadyAdvectionDiffusion.

Definition at line 484 of file UnsteadyAdvection.cpp.

485{
486 return false;
487}

Friends And Related Function Documentation

◆ MemoryManager< UnsteadyAdvection >

friend class MemoryManager< UnsteadyAdvection >
friend

Definition at line 1 of file UnsteadyAdvection.h.

Member Data Documentation

◆ className

std::string Nektar::UnsteadyAdvection::className
static
Initial value:
=
"UnsteadyAdvection", UnsteadyAdvection::create,
"Unsteady Advection equation.")
tKey RegisterCreatorFunction(tKey idKey, CreatorFunction classCreator, std::string pDesc="")
Register a class with the factory.
static SolverUtils::EquationSystemSharedPtr create(const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
Creates an instance of this class.
EquationSystemFactory & GetEquationSystemFactory()

Name of class.

Definition at line 62 of file UnsteadyAdvection.h.

◆ m_forcing

std::vector<SolverUtils::ForcingSharedPtr> Nektar::UnsteadyAdvection::m_forcing
protected

Forcing terms.

Definition at line 73 of file UnsteadyAdvection.h.

Referenced by DoOdeRhs(), and v_InitObject().

◆ m_GJPJumpScale

NekDouble Nektar::UnsteadyAdvection::m_GJPJumpScale
protected

◆ m_riemannSolver

SolverUtils::RiemannSolverSharedPtr Nektar::UnsteadyAdvection::m_riemannSolver
protected

◆ m_traceVn

Array<OneD, NekDouble> Nektar::UnsteadyAdvection::m_traceVn
protected

◆ m_useGJPStabilisation

bool Nektar::UnsteadyAdvection::m_useGJPStabilisation
protected

◆ m_velocity

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

◆ m_waveFreq

NekDouble Nektar::UnsteadyAdvection::m_waveFreq
private

Definition at line 122 of file UnsteadyAdvection.h.

Referenced by v_InitObject().