45 string UnsteadyViscousBurgers::className
47 "UnsteadyViscousBurgers",
48 UnsteadyViscousBurgers::create);
50 UnsteadyViscousBurgers::UnsteadyViscousBurgers(
91 ASSERTL0(
false,
"Need to implement for DG");
98 m_session->LoadSolverInfo(
"AdvectionType", advName,
"WeakDG");
100 CreateInstance(advName, advName);
103 m_session->LoadSolverInfo(
"UpwindType", riemName,
"Upwind");
105 CreateInstance(riemName);
110 std::string diffName;
111 m_session->LoadSolverInfo(
"DiffusionType", diffName,
"LDG");
113 CreateInstance(diffName, diffName);
125 m_session->LoadSolverInfo(
"AdvectionType", advName,
128 CreateInstance(advName, advName);
135 for(
int i = 0; i <
m_fields.num_elements(); ++i)
145 ASSERTL0(
false,
"Explicit Galerkin diffusion not set up.");
152 ASSERTL0(
false,
"Unsupported projection type.");
196 for (i = 0; i < inarray.num_elements(); ++i)
198 m_fields[0]->ExtractTracePhys(inarray[i], tmp);
224 int nVariables = inarray.num_elements();
231 for (
int i = 0; i < nVariables; ++i)
238 inarray, outarray, time);
241 for (
int i = 0; i < nVariables; ++i)
251 for (
int i = 0; i < nVariables; ++i)
254 &outarrayDiff[i][0], 1, &outarray[i][0], 1);
259 std::vector<SolverUtils::ForcingSharedPtr>::const_iterator x;
263 (*x)->Apply(
m_fields, inarray, outarray, time);
281 int nvariables = inarray.num_elements();
290 for(i = 0; i < nvariables; ++i)
303 ASSERTL0(
false,
"Unknown projection scheme");
323 int nvariables = inarray.num_elements();
338 for (
int n = 1; n < nvariables; ++n)
347 for (
int i = 0; i < nvariables; ++i)
351 inarray[i], 1, F[i], 1);
364 for(
int i = 0; i <
m_fields.num_elements(); ++i)
366 m_fields[i]->ClearGlobalLinSysManager();
373 for (
int i = 0; i < nvariables; ++i)
394 const int nq =
m_fields[0]->GetNpoints();
396 for (
int i = 0; i < flux.num_elements(); ++i)
398 for (
int j = 0; j < flux[0].num_elements(); ++j)
422 for (
int k = 0; k < flux.num_elements(); ++k)
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.
#define ASSERTL0(condition, msg)
SolverUtils::RiemannSolverSharedPtr m_riemannSolver
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.
std::vector< std::pair< std::string, std::string > > SummaryList
NekDouble m_sVVCutoffRatio
DiffusionFactory & GetDiffusionFactory()
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
enum MultiRegions::ProjectionType m_projectionType
Type of projection; e.g continuous or discontinuous.
Array< OneD, NekDouble > m_traceVn
std::map< ConstFactorType, NekDouble > ConstFactorMap
StdRegions::VarCoeffMap m_varCoeffLap
Variable Coefficient map for the Laplacian which can be activated as part of SVV or otherwise...
static SOLVER_UTILS_EXPORT std::vector< ForcingSharedPtr > Load(const LibUtilities::SessionReaderSharedPtr &pSession, const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const unsigned int &pNumForcingFields=0)
boost::shared_ptr< SessionReader > SessionReaderSharedPtr
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 t...
Array< OneD, Array< OneD, NekDouble > > m_traceNormals
Array holding trace normals for DG simulations in the forwards direction.
virtual ~UnsteadyViscousBurgers()
Destructor.
void DefineProjection(FuncPointerT func, ObjectPointerT obj)
virtual SOLVER_UTILS_EXPORT void v_GenerateSummary(SummaryList &s)
Print a summary of time stepping parameters.
void Smul(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Scalar multiply y = alpha*y.
void DefineOdeRhs(FuncPointerT func, ObjectPointerT obj)
Base class for unsteady solvers.
void AddSummaryItem(SummaryList &l, const std::string &name, const std::string &value)
Adds a summary item to the summary info list.
RiemannSolverFactory & GetRiemannSolverFactory()
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.
void DoOdeProjection(const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
Perform the projection.
AdvectionFactory & GetAdvectionFactory()
Gets the factory for initialising advection objects.
void Neg(int n, T *x, const int incx)
Negate x = -x.
virtual void v_GenerateSummary(SolverUtils::SummaryList &s)
Print Summary.
EquationSystemFactory & GetEquationSystemFactory()
SOLVER_UTILS_EXPORT void SetBoundaryConditions(NekDouble time)
Evaluates the boundary conditions at the given time.
virtual void DoOdeRhs(const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
Compute the RHS.
Array< OneD, NekDouble > & GetNormalVelocity(Array< OneD, Array< OneD, NekDouble > > &inarray)
Get the normal velocity.
SolverUtils::DiffusionSharedPtr m_diffusion
SOLVER_UTILS_EXPORT int GetNpoints()
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
LibUtilities::SessionReaderSharedPtr m_session
The session reader.
SOLVER_UTILS_EXPORT int GetTraceNpoints()
virtual void v_InitObject()
Initialise the object.
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.
virtual SOLVER_UTILS_EXPORT void v_InitObject()
Init object for UnsteadySystem class.
void Zero(int n, T *x, const int incx)
Zero vector.
A base class for PDEs which include an advection component.
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
bool m_useSpecVanViscVarDiff
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.
std::vector< SolverUtils::ForcingSharedPtr > m_forcing
Forcing terms.
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.
static FlagList NullFlagList
An empty flag list.
static VarCoeffMap NullVarCoeffMap
tKey RegisterCreatorFunction(tKey idKey, CreatorFunction classCreator, tDescription pDesc="")
Register a class with the factory.