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 Attributes | Friends | List of all members
Nektar::UnsteadyAdvectionDiffusion Class Reference

#include <UnsteadyAdvectionDiffusion.h>

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

Public Member Functions

virtual ~UnsteadyAdvectionDiffusion ()
 Destructor. More...
 
- Public Member Functions inherited from Nektar::SolverUtils::AdvectionSystem
SOLVER_UTILS_EXPORT AdvectionSystem (const LibUtilities::SessionReaderSharedPtr &pSession)
 
virtual SOLVER_UTILS_EXPORT ~AdvectionSystem ()
 
AdvectionSharedPtr GetAdvObject ()
 Returns the advection object held by this instance. More...
 
- 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
SolverUtils::EquationSystemSharedPtr 
create (const LibUtilities::SessionReaderSharedPtr &pSession)
 Creates an instance of this class. More...
 

Static Public Attributes

static std::string className
 Name of class. More...
 

Protected Member Functions

 UnsteadyAdvectionDiffusion (const LibUtilities::SessionReaderSharedPtr &pSession)
 Session reader. More...
 
void GetFluxVectorAdv (const Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, Array< OneD, NekDouble > > > &flux)
 Evaluate the flux at each solution point for the advection part. More...
 
void GetFluxVectorDiff (const int i, const int j, const Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &derivatives, Array< OneD, Array< OneD, NekDouble > > &flux)
 Evaluate the flux at each solution point for the diffusion part. More...
 
virtual 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)
 Perform the projection. More...
 
virtual void DoImplicitSolve (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, NekDouble time, NekDouble lambda)
 Solve implicitly the diffusion term. More...
 
Array< OneD, NekDouble > & GetNormalVelocity ()
 Get the normal velocity based on m_velocity. More...
 
Array< OneD, NekDouble > & GetNormalVel (const Array< OneD, const Array< OneD, NekDouble > > &velfield)
 Get the normal velocity based on input velfield. More...
 
virtual void v_InitObject ()
 Initialise the object. More...
 
virtual void v_GenerateSummary (SolverUtils::SummaryList &s)
 Print Summary. More...
 
virtual bool v_PreIntegrate (int step)
 PreIntegration step for substepping. More...
 
void SubStepAdvance (const LibUtilities::TimeIntegrationSolutionSharedPtr &integrationSoln, int nstep, NekDouble time)
 
NekDouble GetSubstepTimeStep ()
 
void SetUpSubSteppingTimeIntegration (int intMethod, const LibUtilities::TimeIntegrationWrapperSharedPtr &IntegrationScheme)
 
void SubStepAdvection (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
 
void SubStepProjection (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
 
void AddAdvectionPenaltyFlux (const Array< OneD, const Array< OneD, NekDouble > > &velfield, const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &Outarray)
 
Array< OneD, NekDoubleGetMaxStdVelocity (const Array< OneD, Array< OneD, NekDouble > > inarray)
 
- 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 > > &numflux)
 
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_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

bool m_subSteppingScheme
 
bool m_useSpecVanVisc
 
NekDouble m_sVVCutoffRatio
 
NekDouble m_sVVDiffCoeff
 
SolverUtils::RiemannSolverSharedPtr m_riemannSolver
 
SolverUtils::DiffusionSharedPtr m_diffusion
 
Array< OneD, Array< OneD,
NekDouble > > 
m_velocity
 
Array< OneD, NekDoublem_traceVn
 
int m_planeNumber
 
LibUtilities::TimeIntegrationWrapperSharedPtr m_subStepIntegrationScheme
 
LibUtilities::TimeIntegrationSchemeOperators m_subStepIntegrationOps
 
int m_intSteps
 
NekDouble m_cflSafetyFactor
 
int m_infosteps
 
int m_minsubsteps
 
- Protected Attributes inherited from Nektar::SolverUtils::AdvectionSystem
SolverUtils::AdvectionSharedPtr m_advObject
 Advection term. More...
 
- 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 Attributes

NekDouble m_waveFreq
 
NekDouble m_epsilon
 

Friends

class MemoryManager< UnsteadyAdvectionDiffusion >
 

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 46 of file UnsteadyAdvectionDiffusion.h.

Constructor & Destructor Documentation

Nektar::UnsteadyAdvectionDiffusion::~UnsteadyAdvectionDiffusion ( )
virtual

Destructor.

Unsteady linear advection diffusion equation destructor.

Definition at line 196 of file UnsteadyAdvectionDiffusion.cpp.

197  {
198  }
Nektar::UnsteadyAdvectionDiffusion::UnsteadyAdvectionDiffusion ( const LibUtilities::SessionReaderSharedPtr pSession)
protected

Session reader.

Definition at line 49 of file UnsteadyAdvectionDiffusion.cpp.

References m_planeNumber.

51  : UnsteadySystem(pSession),
52  AdvectionSystem(pSession)
53  {
54  m_planeNumber = 0;
55  }
SOLVER_UTILS_EXPORT AdvectionSystem(const LibUtilities::SessionReaderSharedPtr &pSession)
SOLVER_UTILS_EXPORT UnsteadySystem(const LibUtilities::SessionReaderSharedPtr &pSession)
Initialises UnsteadySystem class members.

Member Function Documentation

void Nektar::UnsteadyAdvectionDiffusion::AddAdvectionPenaltyFlux ( const Array< OneD, const Array< OneD, NekDouble > > &  velfield,
const Array< OneD, const Array< OneD, NekDouble > > &  physfield,
Array< OneD, Array< OneD, NekDouble > > &  Outarray 
)
protected

Number of trace points

Forward state array

Backward state array

upwind numerical flux state array

Normal velocity array

Extract forwards/backwards trace spaces Note: Needs to have correct i value to get boundary conditions

Upwind between elements

Construct difference between numflux and Fwd,Bwd

Calculate the numerical fluxes multipling Fwd, Bwd and numflux by the normal advection velocity

Definition at line 655 of file UnsteadyAdvectionDiffusion.cpp.

References ASSERTL1, GetNormalVel(), Nektar::SolverUtils::EquationSystem::m_fields, Vmath::Vmul(), and Vmath::Vsub().

Referenced by SubStepAdvection().

659  {
660  ASSERTL1(physfield.num_elements() == Outarray.num_elements(),
661  "Physfield and outarray are of different dimensions");
662 
663  int i;
664 
665  /// Number of trace points
666  int nTracePts = m_fields[0]->GetTrace()->GetNpoints();
667 
668  /// Forward state array
669  Array<OneD, NekDouble> Fwd(3*nTracePts);
670 
671  /// Backward state array
672  Array<OneD, NekDouble> Bwd = Fwd + nTracePts;
673 
674  /// upwind numerical flux state array
675  Array<OneD, NekDouble> numflux = Bwd + nTracePts;
676 
677  /// Normal velocity array
678  Array<OneD, NekDouble> Vn = GetNormalVel(velfield);
679 
680  for(i = 0; i < physfield.num_elements(); ++i)
681  {
682  /// Extract forwards/backwards trace spaces
683  /// Note: Needs to have correct i value to get boundary conditions
684  m_fields[i]->GetFwdBwdTracePhys(physfield[i], Fwd, Bwd);
685 
686  /// Upwind between elements
687  m_fields[0]->GetTrace()->Upwind(Vn, Fwd, Bwd, numflux);
688 
689  /// Construct difference between numflux and Fwd,Bwd
690  Vmath::Vsub(nTracePts, numflux, 1, Fwd, 1, Fwd, 1);
691  Vmath::Vsub(nTracePts, numflux, 1, Bwd, 1, Bwd, 1);
692 
693  /// Calculate the numerical fluxes multipling Fwd, Bwd and
694  /// numflux by the normal advection velocity
695  Vmath::Vmul(nTracePts, Fwd, 1, Vn, 1, Fwd, 1);
696  Vmath::Vmul(nTracePts, Bwd, 1, Vn, 1, Bwd, 1);
697 
698  m_fields[0]->AddFwdBwdTraceIntegral(Fwd,Bwd,Outarray[i]);
699  }
700  }
Array< OneD, NekDouble > & GetNormalVel(const Array< OneD, const Array< OneD, NekDouble > > &velfield)
Get the normal velocity based on input velfield.
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.cpp:329
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
#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
static SolverUtils::EquationSystemSharedPtr Nektar::UnsteadyAdvectionDiffusion::create ( const LibUtilities::SessionReaderSharedPtr pSession)
inlinestatic

Creates an instance of this class.

Definition at line 52 of file UnsteadyAdvectionDiffusion.h.

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

53  {
56  AllocateSharedPtr(pSession);
57  p->InitObject();
58  return p;
59  }
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::UnsteadyAdvectionDiffusion::DoImplicitSolve ( const Array< OneD, const Array< OneD, NekDouble > > &  inarray,
Array< OneD, Array< OneD, NekDouble > > &  outarray,
NekDouble  time,
NekDouble  lambda 
)
protectedvirtual

Solve implicitly the diffusion term.

Definition at line 345 of file UnsteadyAdvectionDiffusion.cpp.

References Nektar::StdRegions::eFactorLambda, Nektar::StdRegions::eFactorSVVCutoffRatio, Nektar::StdRegions::eFactorSVVDiffCoeff, m_epsilon, Nektar::SolverUtils::EquationSystem::m_fields, m_sVVCutoffRatio, m_sVVDiffCoeff, m_useSpecVanVisc, Nektar::NullFlagList, Nektar::SolverUtils::EquationSystem::SetBoundaryConditions(), and Vmath::Smul().

Referenced by v_InitObject().

350  {
351  int nvariables = inarray.num_elements();
352  int nq = m_fields[0]->GetNpoints();
353 
355  factors[StdRegions::eFactorLambda] = 1.0/lambda/m_epsilon;
356 
357  if(m_useSpecVanVisc)
358  {
361  }
362 
363  Array<OneD, Array< OneD, NekDouble> > F(nvariables);
364  F[0] = Array<OneD, NekDouble> (nq*nvariables);
365 
366  for (int n = 1; n < nvariables; ++n)
367  {
368  F[n] = F[n-1] + nq;
369  }
370 
371  // We solve ( \nabla^2 - HHlambda ) Y[i] = rhs [i]
372  // inarray = input: \hat{rhs} -> output: \hat{Y}
373  // outarray = output: nabla^2 \hat{Y}
374  // where \hat = modal coeffs
375  for (int i = 0; i < nvariables; ++i)
376  {
377  // Multiply 1.0/timestep/lambda
378  Vmath::Smul(nq, -factors[StdRegions::eFactorLambda],
379  inarray[i], 1, F[i], 1);
380  }
381 
382  //Setting boundary conditions
383  SetBoundaryConditions(time);
384 
385  for (int i = 0; i < nvariables; ++i)
386  {
387  // Solve a system of equations with Helmholtz solver
388  m_fields[i]->HelmSolve(F[i], m_fields[i]->UpdateCoeffs(),
389  NullFlagList, factors);
390 
391  m_fields[i]->BwdTrans(m_fields[i]->GetCoeffs(), outarray[i]);
392  }
393  }
std::map< ConstFactorType, NekDouble > ConstFactorMap
Definition: StdRegions.hpp:251
void Smul(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Scalar multiply y = alpha*y.
Definition: Vmath.cpp:199
SOLVER_UTILS_EXPORT void SetBoundaryConditions(NekDouble time)
Evaluates the boundary conditions at the given time.
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
static FlagList NullFlagList
An empty flag list.
void Nektar::UnsteadyAdvectionDiffusion::DoOdeProjection ( const Array< OneD, const Array< OneD, NekDouble > > &  inarray,
Array< OneD, Array< OneD, NekDouble > > &  outarray,
const NekDouble  time 
)
protected

Perform the projection.

Compute the projection for the unsteady advection diffusion problem.

Parameters
inarrayGiven fields.
outarrayCalculated solution.
timeTime.

Definition at line 296 of file UnsteadyAdvectionDiffusion.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().

300  {
301  int i;
302  int nvariables = inarray.num_elements();
303  SetBoundaryConditions(time);
304  switch(m_projectionType)
305  {
307  {
308  // Just copy over array
309  int npoints = GetNpoints();
310 
311  for(i = 0; i < nvariables; ++i)
312  {
313  Vmath::Vcopy(npoints, inarray[i], 1, outarray[i], 1);
314  }
315  break;
316  }
319  {
320  Array<OneD, NekDouble> coeffs(m_fields[0]->GetNcoeffs());
321 
322  for(i = 0; i < nvariables; ++i)
323  {
324  m_fields[i]->FwdTrans(inarray[i], coeffs);
325  m_fields[i]->BwdTrans_IterPerExp(coeffs, outarray[i]);
326  }
327  break;
328  }
329  default:
330  {
331  ASSERTL0(false, "Unknown projection scheme");
332  break;
333  }
334  }
335  }
#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::UnsteadyAdvectionDiffusion::DoOdeRhs ( const Array< OneD, const Array< OneD, NekDouble > > &  inarray,
Array< OneD, Array< OneD, NekDouble > > &  outarray,
const NekDouble  time 
)
protectedvirtual

Compute the RHS.

Compute the right-hand side for the unsteady linear advection diffusion problem.

Parameters
inarrayGiven fields.
outarrayCalculated solution.
timeTime.

Definition at line 246 of file UnsteadyAdvectionDiffusion.cpp.

References Nektar::MultiRegions::eDiscontinuous, Nektar::SolverUtils::EquationSystem::GetNpoints(), Nektar::SolverUtils::AdvectionSystem::m_advObject, m_diffusion, Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::EquationSystem::m_projectionType, m_velocity, Vmath::Neg(), and Vmath::Vadd().

Referenced by v_InitObject().

250  {
251  // Number of fields (variables of the problem)
252  int nVariables = inarray.num_elements();
253 
254  // Number of solution points
255  int nSolutionPts = GetNpoints();
256 
257  Array<OneD, Array<OneD, NekDouble> > outarrayDiff(nVariables);
258 
259  for (int i = 0; i < nVariables; ++i)
260  {
261  outarrayDiff[i] = Array<OneD, NekDouble>(nSolutionPts, 0.0);
262  }
263 
264  // RHS computation using the new advection base class
265  m_advObject->Advect(nVariables, m_fields, m_velocity,
266  inarray, outarray, time);
267 
268  // Negate the RHS
269  for (int i = 0; i < nVariables; ++i)
270  {
271  Vmath::Neg(nSolutionPts, outarray[i], 1);
272  }
273 
274  // No explicit diffusion for CG
276  {
277  m_diffusion->Diffuse(nVariables, m_fields, inarray, outarrayDiff);
278 
279  for (int i = 0; i < nVariables; ++i)
280  {
281  Vmath::Vadd(nSolutionPts, &outarray[i][0], 1,
282  &outarrayDiff[i][0], 1, &outarray[i][0], 1);
283  }
284  }
285 
286  }
SolverUtils::AdvectionSharedPtr m_advObject
Advection term.
Array< OneD, Array< OneD, NekDouble > > m_velocity
enum MultiRegions::ProjectionType m_projectionType
Type of projection; e.g continuous or discontinuous.
SolverUtils::DiffusionSharedPtr m_diffusion
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.
void Vadd(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Add vector z = x+y.
Definition: Vmath.cpp:285
void Nektar::UnsteadyAdvectionDiffusion::GetFluxVectorAdv ( const Array< OneD, Array< OneD, NekDouble > > &  physfield,
Array< OneD, Array< OneD, Array< OneD, NekDouble > > > &  flux 
)
protected

Evaluate the flux at each solution point for the advection part.

Return the flux vector for the advection part.

Parameters
physfieldFields.
fluxResulting flux.

Definition at line 401 of file UnsteadyAdvectionDiffusion.cpp.

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

Referenced by v_InitObject().

404  {
405  ASSERTL1(flux[0].num_elements() == m_velocity.num_elements(),
406  "Dimension of flux array and velocity array do not match");
407 
408  const int nq = m_fields[0]->GetNpoints();
409 
410  for (int i = 0; i < flux.num_elements(); ++i)
411  {
412  for (int j = 0; j < flux[0].num_elements(); ++j)
413  {
414  Vmath::Vmul(nq, physfield[i], 1, m_velocity[j], 1,
415  flux[i][j], 1);
416  }
417  }
418  }
Array< OneD, Array< OneD, NekDouble > > m_velocity
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
#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
void Nektar::UnsteadyAdvectionDiffusion::GetFluxVectorDiff ( const int  i,
const int  j,
const Array< OneD, Array< OneD, NekDouble > > &  physfield,
Array< OneD, Array< OneD, NekDouble > > &  derivatives,
Array< OneD, Array< OneD, NekDouble > > &  flux 
)
protected

Evaluate the flux at each solution point for the diffusion part.

Return the flux vector for the diffusion part.

Parameters
iEquation number.
jSpatial direction.
physfieldFields.
derivativesFirst order derivatives.
fluxResulting flux.

Definition at line 429 of file UnsteadyAdvectionDiffusion.cpp.

References Nektar::SolverUtils::EquationSystem::GetNpoints(), Vmath::Vcopy(), and Vmath::Zero().

Referenced by v_InitObject().

435  {
436  for (int k = 0; k < flux.num_elements(); ++k)
437  {
438  Vmath::Zero(GetNpoints(), flux[k], 1);
439  }
440  Vmath::Vcopy(GetNpoints(), physfield[i], 1, flux[j], 1);
441  }
SOLVER_UTILS_EXPORT int GetNpoints()
void Zero(int n, T *x, const int incx)
Zero vector.
Definition: Vmath.cpp:359
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1047
Array< OneD, NekDouble > Nektar::UnsteadyAdvectionDiffusion::GetMaxStdVelocity ( const Array< OneD, Array< OneD, NekDouble > >  inarray)
protected

Definition at line 703 of file UnsteadyAdvectionDiffusion.cpp.

References ASSERTL0, Nektar::SpatialDomains::eDeformed, and Nektar::SolverUtils::EquationSystem::m_fields.

Referenced by GetSubstepTimeStep().

705  {
706 
707  int n_points_0 = m_fields[0]->GetExp(0)->GetTotPoints();
708  int n_element = m_fields[0]->GetExpSize();
709  int nvel = inarray.num_elements();
710  int cnt;
711 
712  ASSERTL0(nvel >= 2, "Method not implemented for 1D");
713 
714  NekDouble pntVelocity;
715 
716  // Getting the standard velocity vector on the 2D normal space
717  Array<OneD, Array<OneD, NekDouble> > stdVelocity(nvel);
718  Array<OneD, NekDouble> maxV(n_element, 0.0);
720 
721  for (int i = 0; i < nvel; ++i)
722  {
723  stdVelocity[i] = Array<OneD, NekDouble>(n_points_0);
724  }
725 
726  if (nvel == 2)
727  {
728  cnt = 0.0;
729  for (int el = 0; el < n_element; ++el)
730  {
731  int n_points = m_fields[0]->GetExp(el)->GetTotPoints();
732  ptsKeys = m_fields[0]->GetExp(el)->GetPointsKeys();
733 
734  // reset local space if necessary
735  if(n_points != n_points_0)
736  {
737  for (int j = 0; j < nvel; ++j)
738  {
739  stdVelocity[j] = Array<OneD, NekDouble>(n_points);
740  }
741  n_points_0 = n_points;
742  }
743 
744  Array<TwoD, const NekDouble> gmat =
745  m_fields[0]->GetExp(el)->GetGeom()->GetMetricInfo()->GetDerivFactors(ptsKeys);
746 
747  if (m_fields[0]->GetExp(el)->GetGeom()->GetMetricInfo()->GetGtype()
749  {
750  for (int i = 0; i < n_points; i++)
751  {
752  stdVelocity[0][i] = gmat[0][i]*inarray[0][i+cnt]
753  + gmat[2][i]*inarray[1][i+cnt];
754 
755  stdVelocity[1][i] = gmat[1][i]*inarray[0][i+cnt]
756  + gmat[3][i]*inarray[1][i+cnt];
757  }
758  }
759  else
760  {
761  for (int i = 0; i < n_points; i++)
762  {
763  stdVelocity[0][i] = gmat[0][0]*inarray[0][i+cnt]
764  + gmat[2][0]*inarray[1][i+cnt];
765 
766  stdVelocity[1][i] = gmat[1][0]*inarray[0][i+cnt]
767  + gmat[3][0]*inarray[1][i+cnt];
768  }
769  }
770 
771  cnt += n_points;
772 
773 
774  for (int i = 0; i < n_points; i++)
775  {
776  pntVelocity = stdVelocity[0][i]*stdVelocity[0][i]
777  + stdVelocity[1][i]*stdVelocity[1][i];
778 
779  if (pntVelocity>maxV[el])
780  {
781  maxV[el] = pntVelocity;
782  }
783  }
784  maxV[el] = sqrt(maxV[el]);
785  }
786  }
787  else
788  {
789  cnt = 0;
790  for (int el = 0; el < n_element; ++el)
791  {
792 
793  int n_points = m_fields[0]->GetExp(el)->GetTotPoints();
794  ptsKeys = m_fields[0]->GetExp(el)->GetPointsKeys();
795 
796  // reset local space if necessary
797  if(n_points != n_points_0)
798  {
799  for (int j = 0; j < nvel; ++j)
800  {
801  stdVelocity[j] = Array<OneD, NekDouble>(n_points);
802  }
803  n_points_0 = n_points;
804  }
805 
806  Array<TwoD, const NekDouble> gmat =
807  m_fields[0]->GetExp(el)->GetGeom()->GetMetricInfo()->GetDerivFactors(ptsKeys);
808 
809  if (m_fields[0]->GetExp(el)->GetGeom()->GetMetricInfo()->GetGtype()
811  {
812  for (int i = 0; i < n_points; i++)
813  {
814  stdVelocity[0][i] = gmat[0][i]*inarray[0][i+cnt]
815  + gmat[3][i]*inarray[1][i+cnt]
816  + gmat[6][i]*inarray[2][i+cnt];
817 
818  stdVelocity[1][i] = gmat[1][i]*inarray[0][i+cnt]
819  + gmat[4][i]*inarray[1][i+cnt]
820  + gmat[7][i]*inarray[2][i+cnt];
821 
822  stdVelocity[2][i] = gmat[2][i]*inarray[0][i+cnt]
823  + gmat[5][i]*inarray[1][i+cnt]
824  + gmat[8][i]*inarray[2][i+cnt];
825  }
826  }
827  else
828  {
829  for (int i = 0; i < n_points; i++)
830  {
831  stdVelocity[0][i] = gmat[0][0]*inarray[0][i+cnt]
832  + gmat[3][0]*inarray[1][i+cnt]
833  + gmat[6][0]*inarray[2][i+cnt];
834 
835  stdVelocity[1][i] = gmat[1][0]*inarray[0][i+cnt]
836  + gmat[4][0]*inarray[1][i+cnt]
837  + gmat[7][0]*inarray[2][i+cnt];
838 
839  stdVelocity[2][i] = gmat[2][0]*inarray[0][i+cnt]
840  + gmat[5][0]*inarray[1][i+cnt]
841  + gmat[8][0]*inarray[2][i+cnt];
842  }
843  }
844 
845  cnt += n_points;
846 
847  for (int i = 0; i < n_points; i++)
848  {
849  pntVelocity = stdVelocity[0][i]*stdVelocity[0][i]
850  + stdVelocity[1][i]*stdVelocity[1][i]
851  + stdVelocity[2][i]*stdVelocity[2][i];
852 
853  if (pntVelocity > maxV[el])
854  {
855  maxV[el] = pntVelocity;
856  }
857  }
858 
859  maxV[el] = sqrt(maxV[el]);
860  //cout << maxV[el]*maxV[el] << endl;
861  }
862  }
863 
864  return maxV;
865  }
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:161
std::vector< PointsKey > PointsKeyVector
Definition: Points.h:220
double NekDouble
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
Geometry is curved or has non-constant factors.
Array< OneD, NekDouble > & Nektar::UnsteadyAdvectionDiffusion::GetNormalVel ( const Array< OneD, const Array< OneD, NekDouble > > &  velfield)
protected

Get the normal velocity based on input velfield.

Definition at line 210 of file UnsteadyAdvectionDiffusion.cpp.

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

Referenced by AddAdvectionPenaltyFlux(), and GetNormalVelocity().

212  {
213  // Number of trace (interface) points
214  int i;
215  int nTracePts = GetTraceNpoints();
216 
217  // Auxiliary variable to compute the normal velocity
218  Array<OneD, NekDouble> tmp(nTracePts);
219  m_traceVn = Array<OneD, NekDouble>(nTracePts, 0.0);
220 
221  // Reset the normal velocity
222  Vmath::Zero(nTracePts, m_traceVn, 1);
223 
224  for (i = 0; i < velfield.num_elements(); ++i)
225  {
226  m_fields[0]->ExtractTracePhys(velfield[i], tmp);
227 
228  Vmath::Vvtvp(nTracePts,
229  m_traceNormals[i], 1,
230  tmp, 1,
231  m_traceVn, 1,
232  m_traceVn, 1);
233  }
234 
235  return m_traceVn;
236  }
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.
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
SOLVER_UTILS_EXPORT int GetTraceNpoints()
void Zero(int n, T *x, const int incx)
Zero vector.
Definition: Vmath.cpp:359
Array< OneD, NekDouble > & Nektar::UnsteadyAdvectionDiffusion::GetNormalVelocity ( )
protected

Get the normal velocity based on m_velocity.

Get the normal velocity for the unsteady linear advection diffusion equation.

Definition at line 204 of file UnsteadyAdvectionDiffusion.cpp.

References GetNormalVel(), and m_velocity.

Referenced by v_InitObject().

205  {
206  return GetNormalVel(m_velocity);
207  }
Array< OneD, Array< OneD, NekDouble > > m_velocity
Array< OneD, NekDouble > & GetNormalVel(const Array< OneD, const Array< OneD, NekDouble > > &velfield)
Get the normal velocity based on input velfield.
NekDouble Nektar::UnsteadyAdvectionDiffusion::GetSubstepTimeStep ( )
protected

Definition at line 529 of file UnsteadyAdvectionDiffusion.cpp.

References GetMaxStdVelocity(), m_cflSafetyFactor, Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::EquationSystem::m_session, m_velocity, Nektar::LibUtilities::ReduceMin, and Vmath::Vmin().

Referenced by SubStepAdvance().

530  {
531  int n_element = m_fields[0]->GetExpSize();
532 
533  const Array<OneD, int> ExpOrder=m_fields[0]->EvalBasisNumModesMaxPerExp();
534  Array<OneD, int> ExpOrderList (n_element, ExpOrder);
535 
536  const NekDouble cLambda = 0.2; // Spencer book pag. 317
537 
538  Array<OneD, NekDouble> tstep (n_element, 0.0);
539  Array<OneD, NekDouble> stdVelocity(n_element, 0.0);
540 
541  stdVelocity = GetMaxStdVelocity(m_velocity);
542 
543  for(int el = 0; el < n_element; ++el)
544  {
545  tstep[el] = m_cflSafetyFactor /
546  (stdVelocity[el] * cLambda *
547  (ExpOrder[el]-1) * (ExpOrder[el]-1));
548  }
549 
550  NekDouble TimeStep = Vmath::Vmin(n_element, tstep, 1);
551  m_session->GetComm()->AllReduce(TimeStep,LibUtilities::ReduceMin);
552 
553  return TimeStep;
554  }
Array< OneD, NekDouble > GetMaxStdVelocity(const Array< OneD, Array< OneD, NekDouble > > inarray)
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, Array< OneD, NekDouble > > m_velocity
double NekDouble
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
LibUtilities::SessionReaderSharedPtr m_session
The session reader.
void Nektar::UnsteadyAdvectionDiffusion::SetUpSubSteppingTimeIntegration ( int  intMethod,
const LibUtilities::TimeIntegrationWrapperSharedPtr IntegrationScheme 
)
protected

Definition at line 556 of file UnsteadyAdvectionDiffusion.cpp.

References ASSERTL0, Nektar::LibUtilities::NekFactory< tKey, tBase, >::CreateInstance(), Nektar::LibUtilities::TimeIntegrationSchemeOperators::DefineOdeRhs(), Nektar::LibUtilities::TimeIntegrationSchemeOperators::DefineProjection(), Nektar::LibUtilities::eBackwardEuler, Nektar::LibUtilities::eBDFImplicitOrder1, Nektar::LibUtilities::eBDFImplicitOrder2, Nektar::LibUtilities::GetTimeIntegrationWrapperFactory(), m_intSteps, m_subStepIntegrationOps, m_subStepIntegrationScheme, SubStepAdvection(), and SubStepProjection().

Referenced by v_InitObject().

559  {
560  // Set to 1 for first step and it will then be increased in
561  // time advance routines
562  switch(intMethod)
563  {
566  {
568 
569  }
570  break;
572  {
574  }
575  break;
576  default:
577  ASSERTL0(0,"Integration method not suitable: Options include BackwardEuler or BDFImplicitOrder1");
578  break;
579  }
580  m_intSteps = IntegrationScheme->GetIntegrationSteps();
581 
582  // set explicit time-integration class operators
585  }
void SubStepProjection(const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:161
BDF multi-step scheme of order 1 (implicit)
tBaseSharedPtr CreateInstance(tKey idKey BOOST_PP_COMMA_IF(MAX_PARAM) BOOST_PP_ENUM_BINARY_PARAMS(MAX_PARAM, tParam, x))
Create an instance of the class referred to by idKey.
Definition: NekFactory.hpp:162
LibUtilities::TimeIntegrationWrapperSharedPtr m_subStepIntegrationScheme
void SubStepAdvection(const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
void DefineProjection(FuncPointerT func, ObjectPointerT obj)
void DefineOdeRhs(FuncPointerT func, ObjectPointerT obj)
TimeIntegrationWrapperFactory & GetTimeIntegrationWrapperFactory()
BDF multi-step scheme of order 2 (implicit)
LibUtilities::TimeIntegrationSchemeOperators m_subStepIntegrationOps
void Nektar::UnsteadyAdvectionDiffusion::SubStepAdvance ( const LibUtilities::TimeIntegrationSolutionSharedPtr integrationSoln,
int  nstep,
NekDouble  time 
)
protected

Definition at line 467 of file UnsteadyAdvectionDiffusion.cpp.

References Nektar::SolverUtils::EquationSystem::GetExpSize(), GetSubstepTimeStep(), m_cflSafetyFactor, Nektar::SolverUtils::EquationSystem::m_fields, m_infosteps, m_intSteps, m_minsubsteps, Nektar::SolverUtils::EquationSystem::m_session, m_subStepIntegrationOps, m_subStepIntegrationScheme, and Nektar::SolverUtils::EquationSystem::m_timestep.

Referenced by v_PreIntegrate().

471  {
472  int n;
473  int nsubsteps;
474 
475  NekDouble dt;
476 
477  Array<OneD, Array<OneD, NekDouble> > fields, velfields;
478 
479  static int ncalls = 1;
480  int nint = min(ncalls++, m_intSteps);
481 
482  Array<OneD, NekDouble> CFL(m_fields[0]->GetExpSize(),
484 
485  LibUtilities::CommSharedPtr comm = m_session->GetComm();
486 
487  // Get the proper time step with CFL control
488  dt = GetSubstepTimeStep();
489 
490  nsubsteps = (m_timestep > dt)? ((int)(m_timestep/dt)+1):1;
491  nsubsteps = max(m_minsubsteps, nsubsteps);
492 
493  dt = m_timestep/nsubsteps;
494 
495  if (m_infosteps && !((nstep+1)%m_infosteps) && comm->GetRank() == 0)
496  {
497  cout << "Sub-integrating using "<< nsubsteps
498  << " steps over Dt = " << m_timestep
499  << " (SubStep CFL=" << m_cflSafetyFactor << ")"<< endl;
500  }
501 
502  for (int m = 0; m < nint; ++m)
503  {
504  // We need to update the fields held by the m_integrationSoln
505  fields = integrationSoln->UpdateSolutionVector()[m];
506 
507  // Initialise NS solver which is set up to use a GLM method
508  // with calls to EvaluateAdvection_SetPressureBCs and
509  // SolveUnsteadyStokesSystem
511  SubIntegrationSoln = m_subStepIntegrationScheme->
512  InitializeScheme(dt, fields, time, m_subStepIntegrationOps);
513 
514  for(n = 0; n < nsubsteps; ++n)
515  {
516  fields = m_subStepIntegrationScheme->TimeIntegrate(n, dt, SubIntegrationSoln,
518  }
519 
520  // Reset time integrated solution in m_integrationSoln
521  integrationSoln->SetSolVector(m,fields);
522  }
523  }
LibUtilities::TimeIntegrationWrapperSharedPtr m_subStepIntegrationScheme
NekDouble m_timestep
Time step size.
boost::shared_ptr< Comm > CommSharedPtr
Pointer to a Communicator object.
Definition: Comm.h:53
double NekDouble
LibUtilities::TimeIntegrationSchemeOperators m_subStepIntegrationOps
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
SOLVER_UTILS_EXPORT int GetExpSize()
LibUtilities::SessionReaderSharedPtr m_session
The session reader.
boost::shared_ptr< TimeIntegrationSolution > TimeIntegrationSolutionSharedPtr
void Nektar::UnsteadyAdvectionDiffusion::SubStepAdvection ( const Array< OneD, const Array< OneD, NekDouble > > &  inarray,
Array< OneD, Array< OneD, NekDouble > > &  outarray,
const NekDouble  time 
)
protected

Explicit Advection terms used by SubStepAdvance time integration

Get the number of coefficients

Define an auxiliary variable to compute the RHS

Operations to compute the RHS

Multiply the flux by the inverse of the mass matrix

Store in outarray the physical values of the RHS

Definition at line 590 of file UnsteadyAdvectionDiffusion.cpp.

References AddAdvectionPenaltyFlux(), Nektar::SolverUtils::AdvectionSystem::m_advObject, Nektar::SolverUtils::EquationSystem::m_fields, m_velocity, and Vmath::Neg().

Referenced by SetUpSubSteppingTimeIntegration().

594  {
595  int i;
596  int nVariables = inarray.num_elements();
597 
598  /// Get the number of coefficients
599  int ncoeffs = m_fields[0]->GetNcoeffs();
600 
601  /// Define an auxiliary variable to compute the RHS
602  Array<OneD, Array<OneD, NekDouble> > WeakAdv(nVariables);
603  WeakAdv[0] = Array<OneD, NekDouble> (ncoeffs*nVariables);
604  for(i = 1; i < nVariables; ++i)
605  {
606  WeakAdv[i] = WeakAdv[i-1] + ncoeffs;
607  }
608 
609  // Currently assume velocity field is time independent and does not therefore
610  // need extrapolating.
611  // RHS computation using the advection base class
612  m_advObject->Advect(nVariables, m_fields, m_velocity,
613  inarray, outarray, time);
614 
615  for(i = 0; i < nVariables; ++i)
616  {
617  m_fields[i]->IProductWRTBase(outarray[i],WeakAdv[i]);
618  // negation requried due to sign of DoAdvection term to be consistent
619  Vmath::Neg(ncoeffs, WeakAdv[i], 1);
620  }
621 
622  AddAdvectionPenaltyFlux(m_velocity, inarray, WeakAdv);
623 
624 
625  /// Operations to compute the RHS
626  for(i = 0; i < nVariables; ++i)
627  {
628  // Negate the RHS
629  Vmath::Neg(ncoeffs, WeakAdv[i], 1);
630 
631  /// Multiply the flux by the inverse of the mass matrix
632  m_fields[i]->MultiplyByElmtInvMass(WeakAdv[i], WeakAdv[i]);
633 
634  /// Store in outarray the physical values of the RHS
635  m_fields[i]->BwdTrans(WeakAdv[i], outarray[i]);
636  }
637  }
SolverUtils::AdvectionSharedPtr m_advObject
Advection term.
Array< OneD, Array< OneD, NekDouble > > m_velocity
void Neg(int n, T *x, const int incx)
Negate x = -x.
Definition: Vmath.cpp:382
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
void AddAdvectionPenaltyFlux(const Array< OneD, const Array< OneD, NekDouble > > &velfield, const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &Outarray)
void Nektar::UnsteadyAdvectionDiffusion::SubStepProjection ( const Array< OneD, const Array< OneD, NekDouble > > &  inarray,
Array< OneD, Array< OneD, NekDouble > > &  outarray,
const NekDouble  time 
)
protected

Projection used by SubStepAdvance time integration

Definition at line 642 of file UnsteadyAdvectionDiffusion.cpp.

References ASSERTL1, and Vmath::Vcopy().

Referenced by SetUpSubSteppingTimeIntegration().

646  {
647  ASSERTL1(inarray.num_elements() == outarray.num_elements(),"Inarray and outarray of different sizes ");
648 
649  for(int i = 0; i < inarray.num_elements(); ++i)
650  {
651  Vmath::Vcopy(inarray[i].num_elements(),inarray[i],1,outarray[i],1);
652  }
653  }
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:191
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1047
void Nektar::UnsteadyAdvectionDiffusion::v_GenerateSummary ( SolverUtils::SummaryList s)
protectedvirtual

Print Summary.

Reimplemented from Nektar::SolverUtils::UnsteadySystem.

Definition at line 443 of file UnsteadyAdvectionDiffusion.cpp.

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

445  {
447  }
virtual SOLVER_UTILS_EXPORT void v_GenerateSummary(SummaryList &s)
Print a summary of time stepping parameters.
void Nektar::UnsteadyAdvectionDiffusion::v_InitObject ( )
protectedvirtual

Initialise the object.

Initialisation object for the unsteady linear advection diffusion equation.

Reimplemented from Nektar::SolverUtils::AdvectionSystem.

Definition at line 61 of file UnsteadyAdvectionDiffusion.cpp.

References ASSERTL0, Nektar::LibUtilities::TimeIntegrationSchemeOperators::DefineImplicitSolve(), Nektar::LibUtilities::TimeIntegrationSchemeOperators::DefineOdeRhs(), Nektar::LibUtilities::TimeIntegrationSchemeOperators::DefineProjection(), DoImplicitSolve(), DoOdeProjection(), DoOdeRhs(), Nektar::MultiRegions::eDiscontinuous, Nektar::MultiRegions::eGalerkin, Nektar::MultiRegions::eMixed_CG_Discontinuous, Nektar::SolverUtils::EquationSystem::EvaluateFunction(), Nektar::SolverUtils::GetAdvectionFactory(), Nektar::SolverUtils::GetDiffusionFactory(), GetFluxVectorAdv(), GetFluxVectorDiff(), GetNormalVelocity(), Nektar::SolverUtils::GetRiemannSolverFactory(), Nektar::SolverUtils::AdvectionSystem::m_advObject, m_diffusion, m_epsilon, Nektar::SolverUtils::UnsteadySystem::m_explicitDiffusion, Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::UnsteadySystem::m_homoInitialFwd, Nektar::SolverUtils::UnsteadySystem::m_intScheme, Nektar::SolverUtils::UnsteadySystem::m_ode, Nektar::SolverUtils::EquationSystem::m_projectionType, m_riemannSolver, Nektar::SolverUtils::EquationSystem::m_session, Nektar::SolverUtils::EquationSystem::m_spacedim, m_subSteppingScheme, m_sVVCutoffRatio, m_sVVDiffCoeff, m_useSpecVanVisc, m_velocity, m_waveFreq, SetUpSubSteppingTimeIntegration(), and Nektar::SolverUtils::AdvectionSystem::v_InitObject().

62  {
64 
65  m_session->LoadParameter("wavefreq", m_waveFreq, 0.0);
66  m_session->LoadParameter("epsilon", m_epsilon, 0.0);
67 
68  // turn on substepping
69  m_session->MatchSolverInfo("Extrapolation", "SubStepping",
70  m_subSteppingScheme, false);
71 
72  // Define Velocity fields
73  m_velocity = Array<OneD, Array<OneD, NekDouble> >(m_spacedim);
74  std::vector<std::string> vel;
75  vel.push_back("Vx");
76  vel.push_back("Vy");
77  vel.push_back("Vz");
78  vel.resize(m_spacedim);
79 
80  EvaluateFunction(vel, m_velocity, "AdvectionVelocity");
81 
82  m_session->MatchSolverInfo(
83  "SpectralVanishingViscosity", "True", m_useSpecVanVisc, false);
84 
86  {
87  m_session->LoadParameter("SVVCutoffRatio",m_sVVCutoffRatio,0.75);
88  m_session->LoadParameter("SVVDiffCoeff",m_sVVDiffCoeff,0.1);
89  }
90 
91  // Type of advection and diffusion classes to be used
92  switch(m_projectionType)
93  {
94  // Discontinuous field
96  {
97  // Do not forwards transform initial condition
98  m_homoInitialFwd = false;
99 
100  // Advection term
101  string advName;
102  string riemName;
103  m_session->LoadSolverInfo("AdvectionType", advName, "WeakDG");
105  CreateInstance(advName, advName);
106  m_advObject->SetFluxVector(&UnsteadyAdvectionDiffusion::
107  GetFluxVectorAdv, this);
108  m_session->LoadSolverInfo("UpwindType", riemName, "Upwind");
110  CreateInstance(riemName);
111  m_riemannSolver->SetScalar("Vn", &UnsteadyAdvectionDiffusion::
112  GetNormalVelocity, this);
113  m_advObject->SetRiemannSolver(m_riemannSolver);
114  m_advObject->InitObject (m_session, m_fields);
115 
116  // Diffusion term
117  std::string diffName;
118  m_session->LoadSolverInfo("DiffusionType", diffName, "LDG");
120  CreateInstance(diffName, diffName);
121  m_diffusion->SetFluxVector(&UnsteadyAdvectionDiffusion::
122  GetFluxVectorDiff, this);
123  m_diffusion->InitObject(m_session, m_fields);
124 
125  ASSERTL0(m_subSteppingScheme == false,"SubSteppingScheme is not set up for DG projection");
126  break;
127  }
128  // Continuous field
131  {
132  // Advection term
133  std::string advName;
134  m_session->LoadSolverInfo("AdvectionType", advName,
135  "NonConservative");
137  CreateInstance(advName, advName);
138  m_advObject->SetFluxVector(&UnsteadyAdvectionDiffusion::
139  GetFluxVectorAdv, this);
140 
141  if(advName.compare("WeakDG") == 0)
142  {
143  string riemName;
144  m_session->LoadSolverInfo("UpwindType", riemName, "Upwind");
146  CreateInstance(riemName);
147  m_riemannSolver->SetScalar("Vn",
149  GetNormalVelocity, this);
150  m_advObject->SetRiemannSolver(m_riemannSolver);
151  m_advObject->InitObject (m_session, m_fields);
152  }
153 
154  // In case of Galerkin explicit diffusion gives an error
156  {
157  ASSERTL0(false, "Explicit Galerkin diffusion not set up.");
158  }
159  // In case of Galerkin implicit diffusion: do nothing
160  break;
161  }
162  default:
163  {
164  ASSERTL0(false, "Unsupported projection type.");
165  break;
166  }
167  }
168 
171 
172  if(m_subSteppingScheme) // Substepping
173  {
175  "Projection must be set to Mixed_CG_Discontinuous for "
176  "substepping");
178  m_intScheme->GetIntegrationMethod(), m_intScheme);
179 
180  }
181  else // Standard velocity correction scheme
182  {
184  }
185 
187  m_explicitDiffusion == 1)
188  {
190  }
191  }
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:161
void GetFluxVectorAdv(const Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, Array< OneD, NekDouble > > > &flux)
Evaluate the flux at each solution point for the advection part.
bool m_homoInitialFwd
Flag to determine if simulation should start in homogeneous forward transformed state.
SolverUtils::AdvectionSharedPtr m_advObject
Advection term.
bool m_explicitDiffusion
Indicates if explicit or implicit treatment of diffusion is used.
void DefineImplicitSolve(FuncPointerT func, ObjectPointerT obj)
LibUtilities::TimeIntegrationSchemeOperators m_ode
The time integration scheme operators to use.
Array< OneD, Array< OneD, NekDouble > > m_velocity
DiffusionFactory & GetDiffusionFactory()
Definition: Diffusion.cpp:42
enum MultiRegions::ProjectionType m_projectionType
Type of projection; e.g continuous or discontinuous.
Array< OneD, NekDouble > & GetNormalVelocity()
Get the normal velocity based on m_velocity.
SolverUtils::RiemannSolverSharedPtr m_riemannSolver
void DoOdeProjection(const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
Perform the projection.
void DefineProjection(FuncPointerT func, ObjectPointerT obj)
virtual void DoOdeRhs(const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
Compute the RHS.
void DefineOdeRhs(FuncPointerT func, ObjectPointerT obj)
RiemannSolverFactory & GetRiemannSolverFactory()
int m_spacedim
Spatial dimension (>= expansion dim).
void SetUpSubSteppingTimeIntegration(int intMethod, const LibUtilities::TimeIntegrationWrapperSharedPtr &IntegrationScheme)
SolverUtils::DiffusionSharedPtr m_diffusion
AdvectionFactory & GetAdvectionFactory()
Gets the factory for initialising advection objects.
Definition: Advection.cpp:46
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.
UnsteadyAdvectionDiffusion(const LibUtilities::SessionReaderSharedPtr &pSession)
Session reader.
virtual void DoImplicitSolve(const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, NekDouble time, NekDouble lambda)
Solve implicitly the diffusion term.
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
LibUtilities::SessionReaderSharedPtr m_session
The session reader.
LibUtilities::TimeIntegrationWrapperSharedPtr m_intScheme
Wrapper to the time integration scheme.
virtual SOLVER_UTILS_EXPORT void v_InitObject()
Init object for UnsteadySystem class.
void GetFluxVectorDiff(const int i, const int j, const Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &derivatives, Array< OneD, Array< OneD, NekDouble > > &flux)
Evaluate the flux at each solution point for the diffusion part.
bool Nektar::UnsteadyAdvectionDiffusion::v_PreIntegrate ( int  step)
protectedvirtual

PreIntegration step for substepping.

Perform the extrapolation.

Reimplemented from Nektar::SolverUtils::UnsteadySystem.

Definition at line 453 of file UnsteadyAdvectionDiffusion.cpp.

References Nektar::SolverUtils::UnsteadySystem::m_intSoln, m_subSteppingScheme, Nektar::SolverUtils::EquationSystem::m_time, and SubStepAdvance().

454  {
456  {
458  }
459 
460  return false;
461  }
NekDouble m_time
Current time of simulation.
void SubStepAdvance(const LibUtilities::TimeIntegrationSolutionSharedPtr &integrationSoln, int nstep, NekDouble time)
LibUtilities::TimeIntegrationSolutionSharedPtr m_intSoln

Friends And Related Function Documentation

friend class MemoryManager< UnsteadyAdvectionDiffusion >
friend

Definition at line 49 of file UnsteadyAdvectionDiffusion.h.

Member Data Documentation

string Nektar::UnsteadyAdvectionDiffusion::className
static
Initial value:

Name of class.

Definition at line 61 of file UnsteadyAdvectionDiffusion.h.

NekDouble Nektar::UnsteadyAdvectionDiffusion::m_cflSafetyFactor
protected

Definition at line 159 of file UnsteadyAdvectionDiffusion.h.

Referenced by GetSubstepTimeStep(), and SubStepAdvance().

SolverUtils::DiffusionSharedPtr Nektar::UnsteadyAdvectionDiffusion::m_diffusion
protected

Definition at line 72 of file UnsteadyAdvectionDiffusion.h.

Referenced by DoOdeRhs(), and v_InitObject().

NekDouble Nektar::UnsteadyAdvectionDiffusion::m_epsilon
private

Definition at line 165 of file UnsteadyAdvectionDiffusion.h.

Referenced by DoImplicitSolve(), and v_InitObject().

int Nektar::UnsteadyAdvectionDiffusion::m_infosteps
protected

Definition at line 160 of file UnsteadyAdvectionDiffusion.h.

Referenced by SubStepAdvance().

int Nektar::UnsteadyAdvectionDiffusion::m_intSteps
protected
int Nektar::UnsteadyAdvectionDiffusion::m_minsubsteps
protected

Definition at line 161 of file UnsteadyAdvectionDiffusion.h.

Referenced by SubStepAdvance().

int Nektar::UnsteadyAdvectionDiffusion::m_planeNumber
protected

Definition at line 78 of file UnsteadyAdvectionDiffusion.h.

Referenced by UnsteadyAdvectionDiffusion().

SolverUtils::RiemannSolverSharedPtr Nektar::UnsteadyAdvectionDiffusion::m_riemannSolver
protected

Definition at line 71 of file UnsteadyAdvectionDiffusion.h.

Referenced by v_InitObject().

LibUtilities::TimeIntegrationSchemeOperators Nektar::UnsteadyAdvectionDiffusion::m_subStepIntegrationOps
protected
LibUtilities::TimeIntegrationWrapperSharedPtr Nektar::UnsteadyAdvectionDiffusion::m_subStepIntegrationScheme
protected
bool Nektar::UnsteadyAdvectionDiffusion::m_subSteppingScheme
protected

Definition at line 67 of file UnsteadyAdvectionDiffusion.h.

Referenced by v_InitObject(), and v_PreIntegrate().

NekDouble Nektar::UnsteadyAdvectionDiffusion::m_sVVCutoffRatio
protected

Definition at line 69 of file UnsteadyAdvectionDiffusion.h.

Referenced by DoImplicitSolve(), and v_InitObject().

NekDouble Nektar::UnsteadyAdvectionDiffusion::m_sVVDiffCoeff
protected

Definition at line 70 of file UnsteadyAdvectionDiffusion.h.

Referenced by DoImplicitSolve(), and v_InitObject().

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

Definition at line 74 of file UnsteadyAdvectionDiffusion.h.

Referenced by GetNormalVel().

bool Nektar::UnsteadyAdvectionDiffusion::m_useSpecVanVisc
protected

Definition at line 68 of file UnsteadyAdvectionDiffusion.h.

Referenced by DoImplicitSolve(), and v_InitObject().

Array<OneD, Array<OneD, NekDouble> > Nektar::UnsteadyAdvectionDiffusion::m_velocity
protected
NekDouble Nektar::UnsteadyAdvectionDiffusion::m_waveFreq
private

Definition at line 164 of file UnsteadyAdvectionDiffusion.h.

Referenced by v_InitObject().