#include <NonlinearPeregrine.h>
Inheritance diagram for Nektar::NonlinearPeregrine:
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 Member Functions inherited from Nektar::ShallowWaterSystem | |
| 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::ShallowWaterSystem | |
| 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 | |
| NonlinearPeregrine (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph) | |
| void | v_InitObject (bool DeclareFields=true) override |
| Init object for UnsteadySystem class. More... | |
| void | DoOdeRhs (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time) |
| void | DoOdeProjection (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time) |
| void | GetFluxVector (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, Array< OneD, NekDouble > > > &flux) |
| void | v_GenerateSummary (SolverUtils::SummaryList &s) override |
| Print a summary of time stepping parameters. More... | |
| void | v_PrimitiveToConservative () override |
| void | v_ConservativeToPrimitive () override |
| void | v_SetInitialConditions (NekDouble initialtime=0.0, bool dumpInitialConditions=true, const int domain=0) override |
| Set the initial conditions. More... | |
| const Array< OneD, NekDouble > & | GetDepthFwd () |
| const Array< OneD, NekDouble > & | GetDepthBwd () |
| Protected Member Functions inherited from Nektar::ShallowWaterSystem | |
| ShallowWaterSystem (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph) | |
| Initialises UnsteadySystem class members. More... | |
| void | v_GenerateSummary (SolverUtils::SummaryList &s) override |
| Print a summary of time stepping parameters. More... | |
| void | v_InitObject (bool DeclareFields=true) override |
| Init object for UnsteadySystem class. More... | |
| void | PrimitiveToConservative () |
| virtual void | v_PrimitiveToConservative () |
| void | ConservativeToPrimitive () |
| virtual void | v_ConservativeToPrimitive () |
| NekDouble | GetGravity () |
| const Array< OneD, const Array< OneD, NekDouble > > & | GetVecLocs () |
| const Array< OneD, const Array< OneD, NekDouble > > & | GetNormals () |
| const Array< OneD, NekDouble > & | GetDepth () |
| bool | IsConstantDepth () |
| void | CopyBoundaryTrace (const Array< OneD, NekDouble > &Fwd, Array< OneD, NekDouble > &Bwd) |
| 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 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) |
Private Attributes | |
| StdRegions::ConstFactorMap | m_factors |
| Array< OneD, NekDouble > | m_dFwd |
| Still water depth traces. More... | |
| Array< OneD, NekDouble > | m_dBwd |
| problem type selector More... | |
| ProblemType | m_problemType |
| NekDouble | m_const_depth |
Friends | |
| class | MemoryManager< NonlinearPeregrine > |
Additional Inherited Members | |
| Protected Types inherited from Nektar::SolverUtils::EquationSystem | |
| enum | HomogeneousType { eHomogeneous1D , eHomogeneous2D , eHomogeneous3D , eNotHomogeneous } |
| Parameter for homogeneous expansions. More... | |
| Protected Attributes inherited from Nektar::ShallowWaterSystem | |
| SolverUtils::RiemannSolverSharedPtr | m_riemannSolver |
| SolverUtils::AdvectionSharedPtr | m_advection |
| SolverUtils::DiffusionSharedPtr | m_diffusion |
| bool | m_primitive |
| Indicates if variables are primitive or conservative. More... | |
| bool | m_constantDepth |
| Indicates if constant depth case. More... | |
| NekDouble | m_g |
| Acceleration of gravity. More... | |
| Array< OneD, NekDouble > | m_depth |
| Still water depth. More... | |
| Array< OneD, Array< OneD, NekDouble > > | m_bottomSlope |
| Array< OneD, NekDouble > | m_coriolis |
| Coriolis force. More... | |
| Array< OneD, Array< OneD, NekDouble > > | m_vecLocs |
| 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::SessionFunctionSharedPtr > | m_sessionFunctions |
| Map of known SessionFunctions. More... | |
| LibUtilities::FieldIOSharedPtr | m_fld |
| Field input/output. More... | |
| Array< OneD, MultiRegions::ExpListSharedPtr > | m_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, NekDouble > | m_movingFrameVelsxyz |
| Moving frame of reference velocities (u, v, w, omega_x, omega_y, omega_z, a_x, a_y, a_z, domega_x, domega_y, domega_z) More... | |
| Array< OneD, NekDouble > | m_movingFrameData |
| Moving frame of reference angles with respect to the. More... | |
| boost::numeric::ublas::matrix< NekDouble > | m_movingFrameProjMat |
| Projection matrix for transformation between inertial and moving. 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... | |
| Static Protected Attributes inherited from Nektar::SolverUtils::EquationSystem | |
| static std::string | equationSystemTypeLookupIds [] |
| static std::string | projectionTypeLookupIds [] |
Detailed Description
Definition at line 58 of file NonlinearPeregrine.h.
Constructor & Destructor Documentation
◆ ~NonlinearPeregrine()
|
override |
Definition at line 167 of file NonlinearPeregrine.cpp.
168{
169}
◆ NonlinearPeregrine()
|
protected |
Definition at line 54 of file NonlinearPeregrine.cpp.
58{
61 // note: eFactorTau = 1.0 becomes unstable...
62 // we need to investigate the behaviuor w.r.t. tau
63}
StdRegions::ConstFactorMap m_factors
Definition: NonlinearPeregrine.h:179
ShallowWaterSystem(const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
Initialises UnsteadySystem class members.
Definition: ShallowWaterSystem.cpp:67
References Nektar::StdRegions::eFactorLambda, Nektar::StdRegions::eFactorTau, and m_factors.
Member Function Documentation
◆ AddCoriolis()
|
private |
Definition at line 172 of file NonlinearPeregrine.cpp.
175{
176
179
180 Array<OneD, NekDouble> tmp(nq);
181 Array<OneD, NekDouble> mod(ncoeffs);
182
184 {
186 {
187 // add to hu equation
189 m_fields[0]->IProductWRTBase(tmp, mod);
190 m_fields[0]->MultiplyByElmtInvMass(mod, mod);
191 m_fields[0]->BwdTrans(mod, tmp);
192 Vmath::Vadd(nq, tmp, 1, outarray[1], 1, outarray[1], 1);
193
194 // add to hv equation
196 Vmath::Neg(nq, tmp, 1);
197 m_fields[0]->IProductWRTBase(tmp, mod);
198 m_fields[0]->MultiplyByElmtInvMass(mod, mod);
199 m_fields[0]->BwdTrans(mod, tmp);
200 Vmath::Vadd(nq, tmp, 1, outarray[2], 1, outarray[2], 1);
201 break;
202 }
205 {
206 // add to hu equation
208 Vmath::Vadd(nq, tmp, 1, outarray[1], 1, outarray[1], 1);
209
210 // add to hv equation
212 Vmath::Neg(nq, tmp, 1);
213 Vmath::Vadd(nq, tmp, 1, outarray[2], 1, outarray[2], 1);
214 break;
215 }
216 default:
218 break;
219 }
220}
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
Definition: EquationSystem.h:359
SOLVER_UTILS_EXPORT int GetNcoeffs()
Definition: EquationSystem.h:706
enum MultiRegions::ProjectionType m_projectionType
Type of projection; e.g continuous or discontinuous.
Definition: EquationSystem.h:418
SOLVER_UTILS_EXPORT int GetTotPoints()
Definition: EquationSystem.h:764
@ eMixed_CG_Discontinuous
Definition: MultiRegions.hpp:103
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
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.hpp:180
References ASSERTL0, Nektar::MultiRegions::eDiscontinuous, Nektar::MultiRegions::eGalerkin, Nektar::MultiRegions::eMixed_CG_Discontinuous, Nektar::SolverUtils::EquationSystem::GetNcoeffs(), Nektar::SolverUtils::EquationSystem::GetTotPoints(), Nektar::ShallowWaterSystem::m_coriolis, Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::EquationSystem::m_projectionType, Vmath::Neg(), Vmath::Vadd(), and Vmath::Vmul().
Referenced by DoOdeRhs().
◆ AddVariableDepth()
|
private |
Definition at line 223 of file NonlinearPeregrine.cpp.
226{
229
230 Array<OneD, NekDouble> tmp(nq);
231 Array<OneD, NekDouble> mod(ncoeffs);
232
234 {
236 {
238 {
241 m_fields[0]->IProductWRTBase(tmp, mod);
242 m_fields[0]->MultiplyByElmtInvMass(mod, mod);
243 m_fields[0]->BwdTrans(mod, tmp);
244 Vmath::Vadd(nq, tmp, 1, outarray[i + 1], 1, outarray[i + 1], 1);
245 }
246 break;
247 }
250 {
252 {
255 Vmath::Vadd(nq, tmp, 1, outarray[i + 1], 1, outarray[i + 1], 1);
256 }
257 break;
258 }
259 default:
261 break;
262 }
263}
Array< OneD, Array< OneD, NekDouble > > m_bottomSlope
Definition: ShallowWaterSystem.h:82
void Smul(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Scalar multiply y = alpha*x.
Definition: Vmath.hpp:100
References ASSERTL0, Nektar::MultiRegions::eDiscontinuous, Nektar::MultiRegions::eGalerkin, Nektar::MultiRegions::eMixed_CG_Discontinuous, Nektar::SolverUtils::EquationSystem::GetNcoeffs(), Nektar::SolverUtils::EquationSystem::GetTotPoints(), Nektar::ShallowWaterSystem::m_bottomSlope, Nektar::SolverUtils::EquationSystem::m_fields, Nektar::ShallowWaterSystem::m_g, Nektar::SolverUtils::EquationSystem::m_projectionType, Nektar::SolverUtils::EquationSystem::m_spacedim, Vmath::Smul(), Vmath::Vadd(), and Vmath::Vmul().
◆ ConservativeToPrimitive()
|
private |
Definition at line 739 of file NonlinearPeregrine.cpp.
742{
744
745 if (physin.get() == physout.get())
746 {
747 // copy indata and work with tmp array
748 Array<OneD, Array<OneD, NekDouble>> tmp(3);
749 for (int i = 0; i < 3; ++i)
750 {
751 // deep copy
752 tmp[i] = Array<OneD, NekDouble>(nq);
753 Vmath::Vcopy(nq, physin[i], 1, tmp[i], 1);
754 }
755
756 // \eta = h - d
758
759 // u = hu/h
760 Vmath::Vdiv(nq, tmp[1], 1, tmp[0], 1, physout[1], 1);
761
762 // v = hv/ v
763 Vmath::Vdiv(nq, tmp[2], 1, tmp[0], 1, physout[2], 1);
764 }
765 else
766 {
767 // \eta = h - d
769
770 // u = hu/h
771 Vmath::Vdiv(nq, physin[1], 1, physin[0], 1, physout[1], 1);
772
773 // v = hv/ v
774 Vmath::Vdiv(nq, physin[2], 1, physin[0], 1, physout[2], 1);
775 }
776}
void Vdiv(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:126
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.hpp:825
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::GetTotPoints(), Nektar::ShallowWaterSystem::m_depth, Vmath::Vcopy(), Vmath::Vdiv(), and Vmath::Vsub().
◆ create()
|
inlinestatic |
Creates an instance of this class.
Definition at line 64 of file NonlinearPeregrine.h.
67 {
69 MemoryManager<NonlinearPeregrine>::AllocateSharedPtr(pSession,
70 pGraph);
71 p->InitObject();
73 }
static std::shared_ptr< DataType > AllocateSharedPtr(const Args &...args)
Allocate a shared pointer from the memory pool.
Definition: NekMemoryManager.hpp:166
std::shared_ptr< EquationSystem > EquationSystemSharedPtr
A shared pointer to an EquationSystem object.
Definition: EquationSystem.h:65
References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), and CellMLToNektar.cellml_metadata::p.
◆ DoOdeProjection()
|
protected |
Definition at line 486 of file NonlinearPeregrine.cpp.
489{
490 int i;
491 int nvariables = inarray.size();
492
494 {
496 {
497
498 // Just copy over array
499 if (inarray != outarray)
500 {
502
503 for (i = 0; i < nvariables; ++i)
504 {
505 Vmath::Vcopy(npoints, inarray[i], 1, outarray[i], 1);
506 }
507 }
508
509 SetBoundaryConditions(outarray, time);
510 break;
511 }
514 {
515
516 EquationSystem::SetBoundaryConditions(time);
518
519 for (i = 0; i < nvariables; ++i)
520 {
521 m_fields[i]->FwdTrans(inarray[i], coeffs);
522 m_fields[i]->BwdTrans(coeffs, outarray[i]);
523 }
524 break;
525 }
526 default:
528 break;
529 }
530}
void SetBoundaryConditions(Array< OneD, Array< OneD, NekDouble > > &physarray, NekDouble time)
Definition: NonlinearPeregrine.cpp:533
SOLVER_UTILS_EXPORT int GetNpoints()
Definition: EquationSystem.h:774
SOLVER_UTILS_EXPORT void SetBoundaryConditions(NekDouble time)
Evaluates the boundary conditions at the given time.
Definition: EquationSystem.cpp:775
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, SetBoundaryConditions(), Nektar::SolverUtils::EquationSystem::SetBoundaryConditions(), and Vmath::Vcopy().
Referenced by v_InitObject().
◆ DoOdeRhs()
|
protected |
Definition at line 265 of file NonlinearPeregrine.cpp.
268{
269 int i;
270 int nvariables = inarray.size();
273
275 {
277 {
278
279 //-------------------------------------------------------
280 // inarray in physical space
281 Array<OneD, Array<OneD, NekDouble>> modarray(2);
282 for (i = 0; i < 2; ++i)
283 {
284 modarray[i] = Array<OneD, NekDouble>(ncoeffs, 0.0);
285 }
286 //-------------------------------------------------------
287
288 //-------------------------------------------------------
289 // Compute the DG advection including the numerical flux
290 // by using SolverUtils/Advection
291 // Input and output in physical space
293 NullNekDoubleArrayOfArray, inarray, outarray,
294 time);
295 //-------------------------------------------------------
296
297 //-------------------------------------------------------
298 // negate the outarray since moving terms to the rhs
299 for (i = 0; i < nvariables - 1; ++i)
300 {
301 Vmath::Neg(nq, outarray[i], 1);
302 }
303 //-------------------------------------------------------
304
305 //-------------------------------------------------
306 // Add "source terms"
307 // Input and output in physical space
308
309 // Coriolis forcing
311 {
312 AddCoriolis(inarray, outarray);
313 }
314
315 // Variable Depth
317 {
319 "Variable depth not supported for the Peregrine "
320 "equations");
321 }
322
323 //-------------------------------------------------
324
325 //---------------------------------------
326 // As no more terms is required for the
327 // continuity equation and we have aleady evaluated
328 // the values for h_t we are done for h
329 //---------------------------------------
330
331 //-------------------------------------------------
332 // go to modal space
333 m_fields[0]->IProductWRTBase(outarray[1], modarray[0]);
334 m_fields[0]->IProductWRTBase(outarray[2], modarray[1]);
335
336 // store f1 and f2 for later use (modal space)
337 Array<OneD, NekDouble> f1(ncoeffs);
338 Array<OneD, NekDouble> f2(ncoeffs);
339
342
343 // Solve the remaining block-diagonal systems
344 m_fields[0]->MultiplyByElmtInvMass(modarray[0], modarray[0]);
345 m_fields[0]->MultiplyByElmtInvMass(modarray[1], modarray[1]);
346 //---------------------------------------------
347
348 //---------------------------------------------
349
350 //-------------------------------------------------
351 // create tmp fields to be used during
352 // the dispersive section
353
354 Array<OneD, Array<OneD, NekDouble>> coeffsfield(2);
355 Array<OneD, Array<OneD, NekDouble>> physfield(2);
356
357 for (i = 0; i < 2; ++i)
358 {
359 coeffsfield[i] = Array<OneD, NekDouble>(ncoeffs);
360 physfield[i] = Array<OneD, NekDouble>(nq);
361 }
362 //---------------------------------------------
363
364 //---------------------------------------------
365 // Go from modal to physical space
366 Vmath::Vcopy(nq, outarray[1], 1, physfield[0], 1);
367 Vmath::Vcopy(nq, outarray[2], 1, physfield[1], 1);
368 //---------------------------------------
369
370 //---------------------------------------
371 // Start for solve of mixed dispersive terms
372 // using the 'WCE method'
373 // (Eskilsson & Sherwin, JCP 2006)
374
375 // constant depth case
376 // \nabla \cdot (\nabla z) - invgamma z
377 // = - invgamma (\nabla \cdot {\bf f}_(2,3)
378
380 NekDouble invgamma = 1.0 / gamma;
381
383 Array<OneD, NekDouble> upwindX(nTraceNumPoints);
384 Array<OneD, NekDouble> upwindY(nTraceNumPoints);
385 //--------------------------------------------
386
387 //--------------------------------------------
388 // Compute the forcing function for the
389 // wave continuity equation
390
391 // Set boundary condidtions for z
392 SetBoundaryConditionsForcing(physfield, time);
393
394 // \nabla \phi \cdot f_{2,3}
395 m_fields[0]->IProductWRTDerivBase(0, physfield[0], coeffsfield[0]);
396 m_fields[0]->IProductWRTDerivBase(1, physfield[1], coeffsfield[1]);
397 Vmath::Vadd(ncoeffs, coeffsfield[0], 1, coeffsfield[1], 1,
398 coeffsfield[0], 1);
399 Vmath::Neg(ncoeffs, coeffsfield[0], 1);
400
401 // Evaluate upwind numerical flux (physical space)
402 NumericalFluxForcing(physfield, upwindX, upwindY);
403 Array<OneD, NekDouble> normflux(nTraceNumPoints);
405 upwindY, 1, m_traceNormals[1], 1, normflux, 1);
406 m_fields[0]->AddTraceIntegral(normflux, coeffsfield[0]);
407 m_fields[0]->MultiplyByElmtInvMass(coeffsfield[0], coeffsfield[0]);
408 m_fields[0]->BwdTrans(coeffsfield[0], physfield[0]);
409
410 Vmath::Smul(nq, -invgamma, physfield[0], 1, physfield[0], 1);
411
412 // ok: forcing function for HelmSolve... done!
413 //--------------------------------------
414
415 //--------------------------------------
416 // Solve the Helmhotz-type equation
417 // for the wave continuity equation
418 // (missing slope terms...)
419
420 // note: this is just valid for the constant depth case:
421
422 // as of now we need not to specify any
423 // BC routine for the WCE: periodic
424 // and zero Neumann (for walls)
425
426 WCESolve(physfield[0], invgamma);
427
429
430 // ok: Wave Continuity Equation... done!
431 //------------------------------------
432
433 //------------------------------------
434 // Return to the primary variables
435
436 // (h {\bf u})_t = gamma \nabla z + {\bf f}_{2,3}
437
438 Vmath::Smul(nq, gamma, physfield[0], 1, physfield[0], 1);
439
440 // Set boundary conditions
441 SetBoundaryConditionsContVariables(physfield[0], time);
442
443 m_fields[0]->IProductWRTDerivBase(0, physfield[0], coeffsfield[0]);
444 m_fields[0]->IProductWRTDerivBase(1, physfield[0], coeffsfield[1]);
445
446 Vmath::Neg(ncoeffs, coeffsfield[0], 1);
447 Vmath::Neg(ncoeffs, coeffsfield[1], 1);
448
449 // Evaluate upwind numerical flux (physical space)
450 NumericalFluxConsVariables(physfield[0], upwindX, upwindY);
451
452 {
453 Array<OneD, NekDouble> uptemp(nTraceNumPoints, 0.0);
455 1, uptemp, 1, m_traceNormals[1], 1, normflux, 1);
456 m_fields[0]->AddTraceIntegral(normflux, coeffsfield[0]);
458 upwindY, 1, m_traceNormals[1], 1, normflux, 1);
459 m_fields[0]->AddTraceIntegral(normflux, coeffsfield[1]);
460 }
461
462 Vmath::Vadd(ncoeffs, f1, 1, coeffsfield[0], 1, modarray[0], 1);
463 Vmath::Vadd(ncoeffs, f2, 1, coeffsfield[1], 1, modarray[1], 1);
464
465 m_fields[1]->MultiplyByElmtInvMass(modarray[0], modarray[0]);
466 m_fields[2]->MultiplyByElmtInvMass(modarray[1], modarray[1]);
467
468 m_fields[1]->BwdTrans(modarray[0], outarray[1]);
469 m_fields[2]->BwdTrans(modarray[1], outarray[2]);
470
471 // ok: returned to conservative variables... done!
472 //---------------------
473
474 break;
475 }
479 break;
480 default:
482 break;
483 }
484}
void SetBoundaryConditionsForcing(Array< OneD, Array< OneD, NekDouble > > &inarray, NekDouble time)
Definition: NonlinearPeregrine.cpp:940
NekDouble m_const_depth
Definition: NonlinearPeregrine.h:188
void NumericalFluxForcing(const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, NekDouble > &numfluxX, Array< OneD, NekDouble > &numfluxY)
Definition: NonlinearPeregrine.cpp:903
void SetBoundaryConditionsContVariables(Array< OneD, NekDouble > &inarray, NekDouble time)
Definition: NonlinearPeregrine.cpp:1046
void AddCoriolis(const Array< OneD, const Array< OneD, NekDouble > > &physarray, Array< OneD, Array< OneD, NekDouble > > &outarray)
Definition: NonlinearPeregrine.cpp:172
void NumericalFluxConsVariables(Array< OneD, NekDouble > &physfield, Array< OneD, NekDouble > &outX, Array< OneD, NekDouble > &outY)
Definition: NonlinearPeregrine.cpp:1100
void WCESolve(Array< OneD, NekDouble > &fce, NekDouble lambda)
Definition: NonlinearPeregrine.cpp:880
SolverUtils::AdvectionSharedPtr m_advection
Definition: ShallowWaterSystem.h:70
SOLVER_UTILS_EXPORT int GetTraceTotPoints()
Definition: EquationSystem.h:739
Array< OneD, Array< OneD, NekDouble > > m_traceNormals
Array holding trace normals for DG simulations in the forwards direction.
Definition: EquationSystem.h:421
static Array< OneD, Array< OneD, NekDouble > > NullNekDoubleArrayOfArray
Definition: SharedArray.hpp:889
void Vvtvvtp(int n, const T *v, int incv, const T *w, int incw, const T *x, int incx, const T *y, int incy, T *z, int incz)
vvtvvtp (vector times vector plus vector times vector):
Definition: Vmath.hpp:439
References AddCoriolis(), ASSERTL0, Nektar::MultiRegions::eDiscontinuous, Nektar::MultiRegions::eGalerkin, Nektar::MultiRegions::eMixed_CG_Discontinuous, Nektar::SolverUtils::EquationSystem::GetNcoeffs(), Nektar::SolverUtils::EquationSystem::GetTotPoints(), Nektar::SolverUtils::EquationSystem::GetTraceTotPoints(), Nektar::ShallowWaterSystem::m_advection, m_const_depth, Nektar::ShallowWaterSystem::m_constantDepth, Nektar::ShallowWaterSystem::m_coriolis, Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::EquationSystem::m_projectionType, Nektar::SolverUtils::EquationSystem::m_traceNormals, Vmath::Neg(), Nektar::NullNekDoubleArrayOfArray, NumericalFluxConsVariables(), NumericalFluxForcing(), SetBoundaryConditionsContVariables(), SetBoundaryConditionsForcing(), Vmath::Smul(), Vmath::Vadd(), Vmath::Vcopy(), Vmath::Vvtvvtp(), and WCESolve().
Referenced by v_InitObject().
◆ GetDepthBwd()
Definition at line 111 of file NonlinearPeregrine.h.
112 {
114 }
References m_dBwd.
◆ GetDepthFwd()
Definition at line 107 of file NonlinearPeregrine.h.
108 {
110 }
References m_dFwd.
◆ GetFluxVector()
|
protected |
Definition at line 701 of file NonlinearPeregrine.cpp.
704{
705 int i, j;
707
710
711 // Flux vector for the mass equation
713 {
714 velocity[i] = Array<OneD, NekDouble>(nq);
715 Vmath::Vcopy(nq, physfield[i + 1], 1, flux[0][i], 1);
716 }
717
719
720 // Put (0.5 g h h) in tmp
721 Array<OneD, NekDouble> tmp(nq);
722 Vmath::Vmul(nq, physfield[0], 1, physfield[0], 1, tmp, 1);
723 Vmath::Smul(nq, 0.5 * g, tmp, 1, tmp, 1);
724
725 // Flux vector for the momentum equations
727 {
729 {
731 1);
732 }
733
734 // Add (0.5 g h h) to appropriate field
735 Vmath::Vadd(nq, flux[i + 1][i], 1, tmp, 1, flux[i + 1][i], 1);
736 }
737}
void GetVelocityVector(const Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &velocity)
Compute the velocity field given the momentum .
Definition: NonlinearPeregrine.cpp:859
const std::vector< NekDouble > velocity
Definition: TestMovement.cpp:57
References GetVelocityVector(), Nektar::SolverUtils::EquationSystem::m_fields, Nektar::ShallowWaterSystem::m_g, Nektar::SolverUtils::EquationSystem::m_spacedim, Vmath::Smul(), Vmath::Vadd(), Vmath::Vcopy(), Nektar::MovementTests::velocity, and Vmath::Vmul().
Referenced by v_InitObject().
◆ GetVelocityVector()
|
private |
Compute the velocity field \( \mathbf{v} \) given the momentum \( h\mathbf{v} \).
- Parameters
-
physfield Momentum field. velocity Velocity field.
Definition at line 859 of file NonlinearPeregrine.cpp.
862{
863 const int npts = physfield[0].size();
864
866 {
868 }
869}
References Nektar::SolverUtils::EquationSystem::m_spacedim, Vmath::Vdiv(), and Nektar::MovementTests::velocity.
Referenced by GetFluxVector().
◆ LaitoneSolitaryWave()
|
private |
Definition at line 1131 of file NonlinearPeregrine.cpp.
1133{
1135
1138
1139 Array<OneD, NekDouble> x0(nq);
1140 Array<OneD, NekDouble> x1(nq);
1141 Array<OneD, NekDouble> zeros(nq, 0.0);
1142
1143 // get the coordinates (assuming all fields have the same
1144 // discretisation)
1145 m_fields[0]->GetCoords(x0, x1);
1146
1147 for (int i = 0; i < nq; i++)
1148 {
1149 (m_fields[0]->UpdatePhys())[i] =
1151 (A * (x0[i] + x_offset) - C * time))),
1152 2.0);
1153 (m_fields[1]->UpdatePhys())[i] =
1154 (amp / d) *
1156 (A * (x0[i] + x_offset) - C * time))),
1157 2.0) *
1159 }
1160
1163 m_fields[1]->UpdatePhys(), 1);
1166
1167 // Forward transform to fill the coefficient space
1168 for (int i = 0; i < 4; ++i)
1169 {
1172 m_fields[i]->UpdateCoeffs());
1173 }
1174}
std::vector< double > d(NPUPPER *NPUPPER)
void Sadd(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Add vector y = alpha + x.
Definition: Vmath.hpp:194
References Nektar::UnitTests::d(), Nektar::SolverUtils::EquationSystem::GetTotPoints(), Nektar::SolverUtils::EquationSystem::m_fields, Nektar::ShallowWaterSystem::m_g, Vmath::Sadd(), tinysimd::sqrt(), Vmath::Vcopy(), and Vmath::Vmul().
Referenced by v_SetInitialConditions().
◆ NumericalFlux1D()
|
private |
◆ NumericalFlux2D()
|
private |
◆ NumericalFluxConsVariables()
|
private |
Definition at line 1100 of file NonlinearPeregrine.cpp.
1103{
1104 int i;
1106
1107 //-----------------------------------------------------
1108 // get temporary arrays
1109 Array<OneD, NekDouble> Fwd(nTraceNumPoints);
1110 Array<OneD, NekDouble> Bwd(nTraceNumPoints);
1111 //-----------------------------------------------------
1112
1113 //-----------------------------------------------------
1114 // get the physical values at the trace
1115 // (we have put any time-dependent BC in field[1])
1116
1117 m_fields[1]->GetFwdBwdTracePhys(physfield, Fwd, Bwd);
1118 //-----------------------------------------------------
1119
1120 //-----------------------------------------------------
1121 // use centred fluxes for the numerical flux
1122 for (i = 0; i < nTraceNumPoints; ++i)
1123 {
1124 outX[i] = 0.5 * (Fwd[i] + Bwd[i]);
1125 outY[i] = 0.5 * (Fwd[i] + Bwd[i]);
1126 }
1127 //-----------------------------------------------------
1128}
References Nektar::SolverUtils::EquationSystem::GetTraceTotPoints(), and Nektar::SolverUtils::EquationSystem::m_fields.
Referenced by DoOdeRhs().
◆ NumericalFluxForcing()
|
private |
Definition at line 903 of file NonlinearPeregrine.cpp.
906{
907 int i;
909
910 //-----------------------------------------------------
911 // get temporary arrays
912 Array<OneD, Array<OneD, NekDouble>> Fwd(2);
913 Array<OneD, Array<OneD, NekDouble>> Bwd(2);
914
915 for (i = 0; i < 2; ++i)
916 {
917 Fwd[i] = Array<OneD, NekDouble>(nTraceNumPoints);
918 Bwd[i] = Array<OneD, NekDouble>(nTraceNumPoints);
919 }
920 //-----------------------------------------------------
921
922 //-----------------------------------------------------
923 // get the physical values at the trace
924 // (any time-dependent BC previously put in fields[1] and [2]
925
926 m_fields[1]->GetFwdBwdTracePhys(inarray[0], Fwd[0], Bwd[0]);
927 m_fields[2]->GetFwdBwdTracePhys(inarray[1], Fwd[1], Bwd[1]);
928 //-----------------------------------------------------
929
930 //-----------------------------------------------------
931 // use centred fluxes for the numerical flux
932 for (i = 0; i < nTraceNumPoints; ++i)
933 {
934 numfluxX[i] = 0.5 * (Fwd[0][i] + Bwd[0][i]);
935 numfluxY[i] = 0.5 * (Fwd[1][i] + Bwd[1][i]);
936 }
937 //-----------------------------------------------------
938}
References Nektar::SolverUtils::EquationSystem::GetTraceTotPoints(), and Nektar::SolverUtils::EquationSystem::m_fields.
Referenced by DoOdeRhs().
◆ PrimitiveToConservative()
|
private |
Definition at line 795 of file NonlinearPeregrine.cpp.
798{
799
801
802 if (physin.get() == physout.get())
803 {
804 // copy indata and work with tmp array
805 Array<OneD, Array<OneD, NekDouble>> tmp(3);
806 for (int i = 0; i < 3; ++i)
807 {
808 // deep copy
809 tmp[i] = Array<OneD, NekDouble>(nq);
810 Vmath::Vcopy(nq, physin[i], 1, tmp[i], 1);
811 }
812
813 // h = \eta + d
815
816 // hu = h * u
817 Vmath::Vmul(nq, physout[0], 1, tmp[1], 1, physout[1], 1);
818
819 // hv = h * v
820 Vmath::Vmul(nq, physout[0], 1, tmp[2], 1, physout[2], 1);
821 }
822 else
823 {
824 // h = \eta + d
826
827 // hu = h * u
828 Vmath::Vmul(nq, physout[0], 1, physin[1], 1, physout[1], 1);
829
830 // hv = h * v
831 Vmath::Vmul(nq, physout[0], 1, physin[2], 1, physout[2], 1);
832 }
833}
References Nektar::SolverUtils::EquationSystem::GetTotPoints(), Nektar::ShallowWaterSystem::m_depth, Vmath::Vadd(), Vmath::Vcopy(), and Vmath::Vmul().
◆ SetBoundaryConditions()
|
private |
Definition at line 533 of file NonlinearPeregrine.cpp.
535{
536
538 int cnt = 0;
540
541 // Extract trace for boundaries. Needs to be done on all processors to avoid
542 // deadlock.
543 Array<OneD, Array<OneD, NekDouble>> Fwd(nvariables - 1);
544 for (int i = 0; i < nvariables - 1; ++i)
545 {
546 Fwd[i] = Array<OneD, NekDouble>(nTracePts);
547 m_fields[i]->ExtractTracePhys(inarray[i], Fwd[i]);
548 }
549
550 // loop over Boundary Regions
552 {
553
554 // Wall Boundary Condition
556 "Wall"))
557 {
558 WallBoundary2D(n, cnt, Fwd, inarray);
559 }
560
561 // Time Dependent Boundary Condition (specified in meshfile)
563 {
564 for (int i = 0; i < nvariables; ++i)
565 {
566 m_fields[i]->EvaluateBoundaryConditions(time);
567 }
568 }
569 cnt += m_fields[0]->GetBndCondExpansions()[n]->GetExpSize();
570 }
571}
void WallBoundary2D(int bcRegion, int cnt, Array< OneD, Array< OneD, NekDouble > > &Fwd, Array< OneD, Array< OneD, NekDouble > > &physarray)
Definition: NonlinearPeregrine.cpp:625
References Nektar::SolverUtils::EquationSystem::GetTraceTotPoints(), Nektar::SolverUtils::EquationSystem::m_fields, and WallBoundary2D().
Referenced by DoOdeProjection().
◆ SetBoundaryConditionsContVariables()
|
private |
Definition at line 1046 of file NonlinearPeregrine.cpp.
1048{
1049 int cnt = 0;
1050
1051 // loop over Boundary Regions
1053 {
1054 // Use wall for all
1055 // Wall Boundary Condition
1057 "Wall"))
1058 {
1059 WallBoundaryContVariables(n, cnt, inarray);
1060 }
1061
1063 {
1064 WallBoundaryContVariables(n, cnt, inarray);
1065 }
1066
1067 cnt += m_fields[0]->GetBndCondExpansions()[n]->GetExpSize() - 1;
1068 }
1069}
void WallBoundaryContVariables(int bcRegion, int cnt, Array< OneD, NekDouble > &inarray)
Definition: NonlinearPeregrine.cpp:1071
References Nektar::SolverUtils::EquationSystem::m_fields, and WallBoundaryContVariables().
Referenced by DoOdeRhs().
◆ SetBoundaryConditionsForcing()
|
private |
Definition at line 940 of file NonlinearPeregrine.cpp.
943{
944 int cnt = 0;
945
946 // loop over Boundary Regions
948 {
949 // Use wall for all BC...
950 // Wall Boundary Condition
952 "Wall"))
953 {
954 WallBoundaryForcing(n, cnt, inarray);
955 }
956
957 // Timedependent Boundary Condition
959 {
961 }
962 cnt += m_fields[0]->GetBndCondExpansions()[n]->GetExpSize();
963 }
964}
void WallBoundaryForcing(int bcRegion, int cnt, Array< OneD, Array< OneD, NekDouble > > &inarray)
Definition: NonlinearPeregrine.cpp:967
References ASSERTL0, Nektar::SolverUtils::EquationSystem::m_fields, and WallBoundaryForcing().
Referenced by DoOdeRhs().
◆ v_ConservativeToPrimitive()
|
overrideprotectedvirtual |
Reimplemented from Nektar::ShallowWaterSystem.
Definition at line 778 of file NonlinearPeregrine.cpp.
779{
781
782 // u = hu/h
784 m_fields[1]->UpdatePhys(), 1);
785
786 // v = hv/ v
788 m_fields[2]->UpdatePhys(), 1);
789
790 // \eta = h - d
792 m_fields[0]->UpdatePhys(), 1);
793}
References Nektar::SolverUtils::EquationSystem::GetTotPoints(), Nektar::ShallowWaterSystem::m_depth, Nektar::SolverUtils::EquationSystem::m_fields, Vmath::Vdiv(), and Vmath::Vsub().
◆ v_GenerateSummary()
|
overrideprotectedvirtual |
Print a summary of time stepping parameters.
Prints a summary with some information regards the time-stepping.
Reimplemented from Nektar::SolverUtils::UnsteadySystem.
Definition at line 871 of file NonlinearPeregrine.cpp.
872{
878}
void v_GenerateSummary(SolverUtils::SummaryList &s) override
Print a summary of time stepping parameters.
Definition: ShallowWaterSystem.cpp:136
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(), and Nektar::ShallowWaterSystem::v_GenerateSummary().
◆ v_InitObject()
|
overrideprotectedvirtual |
Init object for UnsteadySystem class.
Initialization object for UnsteadySystem class.
Reimplemented from Nektar::SolverUtils::UnsteadySystem.
Definition at line 65 of file NonlinearPeregrine.cpp.
66{
67 ShallowWaterSystem::v_InitObject(DeclareFields);
68
70 {
71 int i;
74 {
76 {
78 break;
79 }
80 }
81 }
82 else
83 {
85 }
86
88 {
91 }
92 else
93 {
95 }
96
97 // NB! At the moment only the constant depth case is
98 // supported for the Peregrine eq.
100 {
102 }
103 else
104 {
106 }
107
108 // Type of advection class to be used
110 {
111 // Continuous field
113 {
115 "Continuous projection type not supported for Peregrine.");
116 break;
117 }
118 // Discontinuous field
120 {
121 string advName;
122 string diffName;
123 string riemName;
124
125 //---------------------------------------------------------------
126 // Setting up advection and diffusion operators
127 // NB: diffusion not set up for SWE at the moment
128 // but kept here for future use ...
130 // m_session->LoadSolverInfo("DiffusionType", diffName, "LDG");
132 advName, advName);
133
135 this);
136
137 // Setting up Riemann solver for advection operator
139
140 m_riemannSolver =
142 riemName, m_session);
143
144 // Setting up parameters for advection operator Riemann solver
150 this);
152 this);
153
154 // Concluding initialisation of advection / diffusion operators
157 break;
158 }
159 default:
160 {
162 break;
163 }
164 }
165}
tBaseSharedPtr CreateInstance(tKey idKey, tParam... args)
Create an instance of the class referred to by idKey.
Definition: NekFactory.hpp:143
void DefineProjection(FuncPointerT func, ObjectPointerT obj)
Definition: TimeIntegrationSchemeOperators.h:92
void DefineOdeRhs(FuncPointerT func, ObjectPointerT obj)
Definition: TimeIntegrationSchemeOperators.h:84
void DoOdeRhs(const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
Definition: NonlinearPeregrine.cpp:265
void DoOdeProjection(const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
Definition: NonlinearPeregrine.cpp:486
ProblemType m_problemType
Definition: NonlinearPeregrine.h:186
void GetFluxVector(const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, Array< OneD, NekDouble > > > &flux)
Definition: NonlinearPeregrine.cpp:701
SolverUtils::RiemannSolverSharedPtr m_riemannSolver
Definition: ShallowWaterSystem.h:69
const Array< OneD, NekDouble > & GetDepth()
Definition: ShallowWaterSystem.h:124
void v_InitObject(bool DeclareFields=true) override
Init object for UnsteadySystem class.
Definition: ShallowWaterSystem.cpp:74
const Array< OneD, const Array< OneD, NekDouble > > & GetNormals()
Definition: ShallowWaterSystem.h:119
const Array< OneD, const Array< OneD, NekDouble > > & GetVecLocs()
Definition: ShallowWaterSystem.h:114
LibUtilities::TimeIntegrationSchemeOperators m_ode
The time integration scheme operators to use.
Definition: UnsteadySystem.h:88
bool m_explicitAdvection
Indicates if explicit or implicit treatment of advection is used.
Definition: UnsteadySystem.h:108
AdvectionFactory & GetAdvectionFactory()
Gets the factory for initialising advection objects.
Definition: Advection.cpp:43
RiemannSolverFactory & GetRiemannSolverFactory()
Definition: RiemannSolver.cpp:63
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::SolverUtils::GetAdvectionFactory(), Nektar::ShallowWaterSystem::GetDepth(), GetFluxVector(), Nektar::ShallowWaterSystem::GetGravity(), Nektar::ShallowWaterSystem::GetNormals(), Nektar::SolverUtils::GetRiemannSolverFactory(), Nektar::ShallowWaterSystem::GetVecLocs(), Nektar::ShallowWaterSystem::m_advection, m_const_depth, Nektar::SolverUtils::UnsteadySystem::m_explicitAdvection, Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::UnsteadySystem::m_ode, m_problemType, Nektar::SolverUtils::EquationSystem::m_projectionType, Nektar::ShallowWaterSystem::m_riemannSolver, Nektar::SolverUtils::EquationSystem::m_session, Nektar::ProblemTypeMap, Nektar::SIZE_ProblemType, and Nektar::ShallowWaterSystem::v_InitObject().
◆ v_PrimitiveToConservative()
|
overrideprotectedvirtual |
Reimplemented from Nektar::ShallowWaterSystem.
Definition at line 835 of file NonlinearPeregrine.cpp.
836{
838
839 // h = \eta + d
841 m_fields[0]->UpdatePhys(), 1);
842
843 // hu = h * u
845 m_fields[1]->UpdatePhys(), 1);
846
847 // hv = h * v
849 m_fields[2]->UpdatePhys(), 1);
850}
References Nektar::SolverUtils::EquationSystem::GetTotPoints(), Nektar::ShallowWaterSystem::m_depth, Nektar::SolverUtils::EquationSystem::m_fields, Vmath::Vadd(), and Vmath::Vmul().
◆ v_SetInitialConditions()
|
overrideprotectedvirtual |
Set the initial conditions.
Reimplemented from Nektar::SolverUtils::EquationSystem.
Definition at line 1179 of file NonlinearPeregrine.cpp.
1182{
1184 {
1186 {
1188 break;
1189 }
1190 default:
1191 {
1194 break;
1195 }
1196 }
1197
1199 !m_comm->IsParallelInTime())
1200 {
1202 }
1204 {
1206 if (!fs::is_directory(newdir))
1207 {
1208 fs::create_directory(newdir);
1209 }
1211 {
1213 }
1214 }
1215 m_nchk++;
1216}
void LaitoneSolitaryWave(NekDouble amp, NekDouble d, NekDouble time, NekDouble x_offset)
Definition: NonlinearPeregrine.cpp:1131
virtual SOLVER_UTILS_EXPORT void v_SetInitialConditions(NekDouble initialtime=0.0, bool dumpInitialConditions=true, const int domain=0)
Definition: EquationSystem.cpp:986
SOLVER_UTILS_EXPORT void Checkpoint_Output(const int n)
Write checkpoint file of m_fields.
Definition: EquationSystem.cpp:1176
SOLVER_UTILS_EXPORT void WriteFld(const std::string &outname)
Write field data to the given filename.
Definition: EquationSystem.cpp:1238
References Nektar::SolverUtils::EquationSystem::Checkpoint_Output(), Nektar::eSolitaryWave, LaitoneSolitaryWave(), Nektar::SolverUtils::EquationSystem::m_checksteps, Nektar::SolverUtils::EquationSystem::m_comm, m_const_depth, Nektar::SolverUtils::EquationSystem::m_nchk, m_problemType, Nektar::SolverUtils::EquationSystem::m_sessionName, Nektar::SolverUtils::EquationSystem::v_SetInitialConditions(), and Nektar::SolverUtils::EquationSystem::WriteFld().
◆ WallBoundary()
|
private |
Wall boundary condition.
Definition at line 577 of file NonlinearPeregrine.cpp.
580{
581 int i;
582 int nvariables = physarray.size();
583
584 // Adjust the physical values of the trace to take
585 // user defined boundaries into account
586 int e, id1, id2, npts;
587 MultiRegions::ExpListSharedPtr bcexp =
588 m_fields[0]->GetBndCondExpansions()[bcRegion];
589 for (e = 0; e < bcexp->GetExpSize(); ++e)
590 {
591 npts = bcexp->GetExp(e)->GetTotPoints();
592 id1 = bcexp->GetPhys_Offset(e);
593 id2 = m_fields[0]->GetTrace()->GetPhys_Offset(
594 m_fields[0]->GetTraceMap()->GetBndCondIDToGlobalTraceID(cnt + e));
595
596 // For 2D/3D, define: v* = v - 2(v.n)n
597 Array<OneD, NekDouble> tmp(npts, 0.0);
598
599 // Calculate (v.n)
601 {
603 &tmp[0], 1, &tmp[0], 1);
604 }
605
606 // Calculate 2.0(v.n)
607 Vmath::Smul(npts, -2.0, &tmp[0], 1, &tmp[0], 1);
608
609 // Calculate v* = v - 2.0(v.n)n
611 {
613 &Fwd[1 + i][id2], 1, &Fwd[1 + i][id2], 1);
614 }
615
616 // copy boundary adjusted values into the boundary expansion
617 for (i = 0; i < nvariables; ++i)
618 {
619 bcexp = m_fields[i]->GetBndCondExpansions()[bcRegion];
620 Vmath::Vcopy(npts, &Fwd[i][id2], 1, &(bcexp->UpdatePhys())[id1], 1);
621 }
622 }
623}
std::shared_ptr< ExpList > ExpListSharedPtr
Shared pointer to an ExpList object.
Definition: LocTraceToTraceMap.h:56
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
References Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::EquationSystem::m_spacedim, Nektar::SolverUtils::EquationSystem::m_traceNormals, Vmath::Smul(), Vmath::Vcopy(), and Vmath::Vvtvp().
◆ WallBoundary2D()
|
private |
Definition at line 625 of file NonlinearPeregrine.cpp.
628{
629 int i;
630 int nvariables = 3;
631
632 // Adjust the physical values of the trace to take
633 // user defined boundaries into account
634 int e, id1, id2, npts;
635 MultiRegions::ExpListSharedPtr bcexp =
636 m_fields[0]->GetBndCondExpansions()[bcRegion];
637
638 for (e = 0; e < bcexp->GetExpSize(); ++e)
639 {
640 npts = bcexp->GetExp(e)->GetNumPoints(0);
641 id1 = bcexp->GetPhys_Offset(e);
642 id2 = m_fields[0]->GetTrace()->GetPhys_Offset(
643 m_fields[0]->GetTraceMap()->GetBndCondIDToGlobalTraceID(cnt + e));
644
646 {
647 case 1:
648 {
649 // negate the forward flux
650 Vmath::Neg(npts, &Fwd[1][id2], 1);
651 break;
652 }
653 case 2:
654 {
655 Array<OneD, NekDouble> tmp_n(npts);
656 Array<OneD, NekDouble> tmp_t(npts);
657
659 &tmp_n[0], 1);
661 &tmp_n[0], 1, &tmp_n[0], 1);
662
664 &tmp_t[0], 1);
666 &tmp_t[0], 1, &tmp_t[0], 1);
667
668 // negate the normal flux
669 Vmath::Neg(npts, tmp_n, 1);
670
671 // rotate back to Cartesian
673 &Fwd[1][id2], 1);
675 &Fwd[1][id2], 1, &Fwd[1][id2], 1);
676
678 &Fwd[2][id2], 1);
680 &Fwd[2][id2], 1, &Fwd[2][id2], 1);
681 break;
682 }
683 case 3:
685 "3D not implemented for Shallow Water Equations");
686 break;
687 default:
689 }
690
691 // copy boundary adjusted values into the boundary expansion
692 for (i = 0; i < nvariables; ++i)
693 {
694 bcexp = m_fields[i]->GetBndCondExpansions()[bcRegion];
695 Vmath::Vcopy(npts, &Fwd[i][id2], 1, &(bcexp->UpdatePhys())[id1], 1);
696 }
697 }
698}
void Vvtvm(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)
vvtvm (vector times vector minus vector): z = w*x - y
Definition: Vmath.hpp:381
References ASSERTL0, Nektar::SolverUtils::EquationSystem::m_expdim, Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::EquationSystem::m_traceNormals, Vmath::Neg(), Vmath::Vcopy(), Vmath::Vmul(), Vmath::Vvtvm(), and Vmath::Vvtvp().
Referenced by SetBoundaryConditions().
◆ WallBoundaryContVariables()
|
private |
Definition at line 1071 of file NonlinearPeregrine.cpp.
1073{
1075
1076 // get physical values of z for the forward trace
1077 Array<OneD, NekDouble> z(nTraceNumPoints);
1079
1080 // Adjust the physical values of the trace to take
1081 // user defined boundaries into account
1082 int e, id1, id2, npts;
1083 MultiRegions::ExpListSharedPtr bcexp =
1084 m_fields[0]->GetBndCondExpansions()[bcRegion];
1085
1086 for (e = 0; e < bcexp->GetExpSize(); ++e)
1087 {
1088 npts = bcexp->GetExp(e)->GetTotPoints();
1089 id1 = bcexp->GetPhys_Offset(e);
1090 id2 = m_fields[0]->GetTrace()->GetPhys_Offset(
1091 m_fields[0]->GetTraceMap()->GetBndCondIDToGlobalTraceID(cnt + e));
1092
1093 // copy boundary adjusted values into the boundary expansion
1094 // field[1] and field[2]
1095 bcexp = m_fields[1]->GetBndCondExpansions()[bcRegion];
1097 }
1098}
std::vector< double > z(NPUPPER)
References Nektar::SolverUtils::EquationSystem::GetTraceTotPoints(), Nektar::SolverUtils::EquationSystem::m_fields, Vmath::Vcopy(), and Nektar::UnitTests::z().
Referenced by SetBoundaryConditionsContVariables().
◆ WallBoundaryForcing()
|
private |
Definition at line 967 of file NonlinearPeregrine.cpp.
969{
971 int nvariables = 2;
972
973 // get physical values of f1 and f2 for the forward trace
974 Array<OneD, Array<OneD, NekDouble>> Fwd(nvariables);
975 for (int i = 0; i < nvariables; ++i)
976 {
977 Fwd[i] = Array<OneD, NekDouble>(nTraceNumPoints);
978 m_fields[i]->ExtractTracePhys(inarray[i], Fwd[i]);
979 }
980
981 // Adjust the physical values of the trace to take
982 // user defined boundaries into account
983 int e, id1, id2, npts;
984 MultiRegions::ExpListSharedPtr bcexp =
985 m_fields[0]->GetBndCondExpansions()[bcRegion];
986 for (e = 0; e < bcexp->GetExpSize(); ++e)
987 {
988 npts = bcexp->GetExp(e)->GetTotPoints();
989 id1 = bcexp->GetPhys_Offset(e);
990 id2 = m_fields[0]->GetTrace()->GetPhys_Offset(
991 m_fields[0]->GetTraceMap()->GetBndCondIDToGlobalTraceID(cnt + e));
992
994 {
995 case 1:
996 {
998 break;
999 }
1000 case 2:
1001 {
1002 Array<OneD, NekDouble> tmp_n(npts);
1003 Array<OneD, NekDouble> tmp_t(npts);
1004
1006 &tmp_n[0], 1);
1008 &tmp_n[0], 1, &tmp_n[0], 1);
1009
1011 &tmp_t[0], 1);
1013 &tmp_t[0], 1, &tmp_t[0], 1);
1014
1015 // negate the normal flux
1016 Vmath::Neg(npts, tmp_n, 1);
1017
1018 // rotate back to Cartesian
1020 &Fwd[0][id2], 1);
1022 &Fwd[0][id2], 1, &Fwd[0][id2], 1);
1023
1025 &Fwd[1][id2], 1);
1027 &Fwd[1][id2], 1, &Fwd[1][id2], 1);
1028 break;
1029 }
1030 case 3:
1032 break;
1033 default:
1035 }
1036
1037 // copy boundary adjusted values into the boundary expansion
1038 bcexp = m_fields[1]->GetBndCondExpansions()[bcRegion];
1039 Vmath::Vcopy(npts, &Fwd[0][id2], 1, &(bcexp->UpdatePhys())[id1], 1);
1040
1041 bcexp = m_fields[2]->GetBndCondExpansions()[bcRegion];
1042 Vmath::Vcopy(npts, &Fwd[1][id2], 1, &(bcexp->UpdatePhys())[id1], 1);
1043 }
1044}
References ASSERTL0, Nektar::SolverUtils::EquationSystem::GetTraceTotPoints(), Nektar::SolverUtils::EquationSystem::m_expdim, Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::EquationSystem::m_traceNormals, Vmath::Neg(), Vmath::Vcopy(), Vmath::Vmul(), Vmath::Vvtvm(), and Vmath::Vvtvp().
Referenced by SetBoundaryConditionsForcing().
◆ WCESolve()
|
private |
Definition at line 880 of file NonlinearPeregrine.cpp.
881{
883
885
886 for (int j = 0; j < nq; j++)
887 {
888 (m_fields[3]->UpdatePhys())[j] = fce[j];
889 }
890
892
894 m_factors);
895
897
899
901}
References Nektar::StdRegions::eFactorLambda, Nektar::SolverUtils::EquationSystem::GetTotPoints(), m_factors, Nektar::SolverUtils::EquationSystem::m_fields, and Vmath::Vcopy().
Referenced by DoOdeRhs().
Friends And Related Function Documentation
◆ MemoryManager< NonlinearPeregrine >
|
friend |
Definition at line 51 of file NonlinearPeregrine.h.
Member Data Documentation
◆ className
|
static |
Initial value:
=
"NonlinearPeregrine", NonlinearPeregrine::create,
"Nonlinear Peregrine equations in conservative variables.")
tKey RegisterCreatorFunction(tKey idKey, CreatorFunction classCreator, std::string pDesc="")
Register a class with the factory.
Definition: NekFactory.hpp:197
static SolverUtils::EquationSystemSharedPtr create(const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
Creates an instance of this class.
Definition: NonlinearPeregrine.h:64
EquationSystemFactory & GetEquationSystemFactory()
Definition: EquationSystem.cpp:99
Name of class.
Definition at line 75 of file NonlinearPeregrine.h.
◆ m_const_depth
|
private |
Definition at line 188 of file NonlinearPeregrine.h.
Referenced by DoOdeRhs(), v_InitObject(), and v_SetInitialConditions().
◆ m_dBwd
problem type selector
Definition at line 183 of file NonlinearPeregrine.h.
Referenced by GetDepthBwd().
◆ m_dFwd
Still water depth traces.
Definition at line 182 of file NonlinearPeregrine.h.
Referenced by GetDepthFwd().
◆ m_factors
|
private |
Definition at line 179 of file NonlinearPeregrine.h.
Referenced by NonlinearPeregrine(), and WCESolve().
◆ m_problemType
|
private |
Definition at line 186 of file NonlinearPeregrine.h.
Referenced by v_InitObject(), and v_SetInitialConditions().
