Nektar++
Public Member Functions | Protected Types | Protected Member Functions | Protected Attributes | Static Protected Attributes | Private Member Functions | List of all members
Nektar::SolverUtils::EquationSystem Class Reference

A base class for describing how to solve specific equations. More...

#include <EquationSystem.h>

Inheritance diagram for Nektar::SolverUtils::EquationSystem:
[legend]

Public Member Functions

virtual SOLVER_UTILS_EXPORT ~EquationSystem ()
 Destructor. More...
 
SOLVER_UTILS_EXPORT void InitObject (bool DeclareField=true)
 Initialises the members of this object. More...
 
SOLVER_UTILS_EXPORT void DoInitialise (bool dumpInitialConditions=true)
 Perform any initialisation necessary before solving the problem. More...
 
SOLVER_UTILS_EXPORT void DoSolve ()
 Solve the problem. More...
 
SOLVER_UTILS_EXPORT void TransCoeffToPhys ()
 Transform from coefficient to physical space. More...
 
SOLVER_UTILS_EXPORT void TransPhysToCoeff ()
 Transform from physical to coefficient space. More...
 
SOLVER_UTILS_EXPORT void Output ()
 Perform output operations after solve. More...
 
SOLVER_UTILS_EXPORT std::string GetSessionName ()
 Get Session name. More...
 
template<class T >
std::shared_ptr< T > as ()
 
SOLVER_UTILS_EXPORT void ResetSessionName (std::string newname)
 Reset Session name. More...
 
SOLVER_UTILS_EXPORT LibUtilities::SessionReaderSharedPtr GetSession ()
 Get Session name. More...
 
SOLVER_UTILS_EXPORT MultiRegions::ExpListSharedPtr GetPressure ()
 Get pressure field if available. More...
 
SOLVER_UTILS_EXPORT void ExtraFldOutput (std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables)
 
SOLVER_UTILS_EXPORT void PrintSummary (std::ostream &out)
 Print a summary of parameters and solver characteristics. More...
 
SOLVER_UTILS_EXPORT void SetLambda (NekDouble lambda)
 Set parameter m_lambda. More...
 
SOLVER_UTILS_EXPORT SessionFunctionSharedPtr GetFunction (std::string name, const MultiRegions::ExpListSharedPtr &field=MultiRegions::NullExpListSharedPtr, bool cache=false)
 Get a SessionFunction by name. More...
 
SOLVER_UTILS_EXPORT void SetInitialConditions (NekDouble initialtime=0.0, bool dumpInitialConditions=true, const int domain=0)
 Initialise the data in the dependent fields. More...
 
SOLVER_UTILS_EXPORT void EvaluateExactSolution (int field, Array< OneD, NekDouble > &outfield, const NekDouble time)
 Evaluates an exact solution. More...
 
SOLVER_UTILS_EXPORT NekDouble L2Error (unsigned int field, const Array< OneD, NekDouble > &exactsoln, bool Normalised=false)
 Compute the L2 error between fields and a given exact solution. More...
 
SOLVER_UTILS_EXPORT NekDouble L2Error (unsigned int field, bool Normalised=false)
 Compute the L2 error of the fields. More...
 
SOLVER_UTILS_EXPORT NekDouble LinfError (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray)
 Linf error computation. More...
 
SOLVER_UTILS_EXPORT NekDouble H1Error (unsigned int field, const Array< OneD, NekDouble > &exactsoln, bool Normalised=false)
 Compute the H1 error between fields and a given exact solution. More...
 
SOLVER_UTILS_EXPORT Array< OneD, NekDoubleErrorExtraPoints (unsigned int field)
 Compute error (L2 and L_inf) over an larger set of quadrature points return [L2 Linf]. More...
 
SOLVER_UTILS_EXPORT void Checkpoint_Output (const int n)
 Write checkpoint file of m_fields. More...
 
SOLVER_UTILS_EXPORT void Checkpoint_Output (const int n, MultiRegions::ExpListSharedPtr &field, std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables)
 Write checkpoint file of custom data fields. More...
 
SOLVER_UTILS_EXPORT void Checkpoint_BaseFlow (const int n)
 Write base flow file of m_fields. More...
 
SOLVER_UTILS_EXPORT void WriteFld (const std::string &outname)
 Write field data to the given filename. More...
 
SOLVER_UTILS_EXPORT void WriteFld (const std::string &outname, MultiRegions::ExpListSharedPtr &field, std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables)
 Write input fields to the given filename. More...
 
SOLVER_UTILS_EXPORT void ImportFld (const std::string &infile, Array< OneD, MultiRegions::ExpListSharedPtr > &pFields)
 Input field data from the given file. More...
 
SOLVER_UTILS_EXPORT void ImportFldToMultiDomains (const std::string &infile, Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const int ndomains)
 Input field data from the given file to multiple domains. More...
 
SOLVER_UTILS_EXPORT void ImportFld (const std::string &infile, std::vector< std::string > &fieldStr, Array< OneD, Array< OneD, NekDouble > > &coeffs)
 Output a field. Input field data into array from the given file. More...
 
SOLVER_UTILS_EXPORT void ImportFld (const std::string &infile, MultiRegions::ExpListSharedPtr &pField, std::string &pFieldName)
 Output a field. Input field data into ExpList from the given file. More...
 
SOLVER_UTILS_EXPORT void SessionSummary (SummaryList &vSummary)
 Write out a session summary. More...
 
SOLVER_UTILS_EXPORT Array< OneD, MultiRegions::ExpListSharedPtr > & UpdateFields ()
 
SOLVER_UTILS_EXPORT LibUtilities::FieldMetaDataMapUpdateFieldMetaDataMap ()
 Get hold of FieldInfoMap so it can be updated. More...
 
SOLVER_UTILS_EXPORT NekDouble GetTime ()
 Return final time. More...
 
SOLVER_UTILS_EXPORT int GetNcoeffs ()
 
SOLVER_UTILS_EXPORT int GetNcoeffs (const int eid)
 
SOLVER_UTILS_EXPORT int GetNumExpModes ()
 
SOLVER_UTILS_EXPORT const Array< OneD, int > GetNumExpModesPerExp ()
 
SOLVER_UTILS_EXPORT int GetNvariables ()
 
SOLVER_UTILS_EXPORT const std::string GetVariable (unsigned int i)
 
SOLVER_UTILS_EXPORT int GetTraceTotPoints ()
 
SOLVER_UTILS_EXPORT int GetTraceNpoints ()
 
SOLVER_UTILS_EXPORT int GetExpSize ()
 
SOLVER_UTILS_EXPORT int GetPhys_Offset (int n)
 
SOLVER_UTILS_EXPORT int GetCoeff_Offset (int n)
 
SOLVER_UTILS_EXPORT int GetTotPoints ()
 
SOLVER_UTILS_EXPORT int GetTotPoints (int n)
 
SOLVER_UTILS_EXPORT int GetNpoints ()
 
SOLVER_UTILS_EXPORT int GetSteps ()
 
SOLVER_UTILS_EXPORT void SetSteps (const int steps)
 
SOLVER_UTILS_EXPORT NekDouble GetTimeStep ()
 
SOLVER_UTILS_EXPORT void CopyFromPhysField (const int i, Array< OneD, NekDouble > &output)
 
SOLVER_UTILS_EXPORT void CopyToPhysField (const int i, const Array< OneD, const NekDouble > &input)
 
SOLVER_UTILS_EXPORT Array< OneD, NekDouble > & UpdatePhysField (const int i)
 
SOLVER_UTILS_EXPORT void ZeroPhysFields ()
 
SOLVER_UTILS_EXPORT void FwdTransFields ()
 
SOLVER_UTILS_EXPORT void SetModifiedBasis (const bool modbasis)
 
SOLVER_UTILS_EXPORT int GetCheckpointNumber ()
 
SOLVER_UTILS_EXPORT void SetCheckpointNumber (int num)
 
SOLVER_UTILS_EXPORT int GetCheckpointSteps ()
 
SOLVER_UTILS_EXPORT void SetCheckpointSteps (int num)
 
SOLVER_UTILS_EXPORT int GetInfoSteps ()
 
SOLVER_UTILS_EXPORT void SetInfoSteps (int num)
 
SOLVER_UTILS_EXPORT void SetIterationNumberPIT (int num)
 
SOLVER_UTILS_EXPORT void SetWindowNumberPIT (int num)
 
SOLVER_UTILS_EXPORT Array< OneD, const Array< OneD, NekDouble > > GetTraceNormals ()
 
SOLVER_UTILS_EXPORT void SetTime (const NekDouble time)
 
SOLVER_UTILS_EXPORT void SetTimeStep (const NekDouble timestep)
 
SOLVER_UTILS_EXPORT void SetInitialStep (const int step)
 
SOLVER_UTILS_EXPORT void SetBoundaryConditions (NekDouble time)
 Evaluates the boundary conditions at the given time. More...
 
SOLVER_UTILS_EXPORT bool NegatedOp ()
 Identify if operator is negated in DoSolve. More...
 

Protected Types

enum  HomogeneousType { eHomogeneous1D , eHomogeneous2D , eHomogeneous3D , eNotHomogeneous }
 Parameter for homogeneous expansions. More...
 

Protected Member Functions

SOLVER_UTILS_EXPORT EquationSystem (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
 Initialises EquationSystem class members. More...
 
virtual SOLVER_UTILS_EXPORT void v_InitObject (bool DeclareFeld=true)
 Initialisation object for EquationSystem. More...
 
virtual SOLVER_UTILS_EXPORT void v_DoInitialise (bool dumpInitialConditions=true)
 Virtual function for initialisation implementation. More...
 
virtual SOLVER_UTILS_EXPORT void v_DoSolve ()
 Virtual function for solve implementation. More...
 
virtual SOLVER_UTILS_EXPORT NekDouble v_LinfError (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray)
 Virtual function for the L_inf error computation between fields and a given exact solution. More...
 
virtual SOLVER_UTILS_EXPORT NekDouble v_L2Error (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray, bool Normalised=false)
 Virtual function for the L_2 error computation between fields and a given exact solution. More...
 
virtual SOLVER_UTILS_EXPORT NekDouble v_H1Error (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray, bool Normalised=false)
 Virtual function for the H_1 error computation between fields and a given exact solution. More...
 
virtual SOLVER_UTILS_EXPORT void v_TransCoeffToPhys ()
 Virtual function for transformation to physical space. More...
 
virtual SOLVER_UTILS_EXPORT void v_TransPhysToCoeff ()
 Virtual function for transformation to coefficient space. More...
 
virtual SOLVER_UTILS_EXPORT void v_GenerateSummary (SummaryList &l)
 Virtual function for generating summary information. More...
 
virtual SOLVER_UTILS_EXPORT void v_SetInitialConditions (NekDouble initialtime=0.0, bool dumpInitialConditions=true, const int domain=0)
 
virtual SOLVER_UTILS_EXPORT void v_EvaluateExactSolution (unsigned int field, Array< OneD, NekDouble > &outfield, const NekDouble time)
 
virtual SOLVER_UTILS_EXPORT void v_Output (void)
 
virtual SOLVER_UTILS_EXPORT MultiRegions::ExpListSharedPtr v_GetPressure (void)
 
virtual SOLVER_UTILS_EXPORT bool v_NegatedOp (void)
 Virtual function to identify if operator is negated in DoSolve. More...
 
virtual SOLVER_UTILS_EXPORT void v_ExtraFldOutput (std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables)
 

Protected Attributes

LibUtilities::CommSharedPtr m_comm
 Communicator. More...
 
bool m_verbose
 
LibUtilities::SessionReaderSharedPtr m_session
 The session reader. More...
 
std::map< std::string, SolverUtils::SessionFunctionSharedPtrm_sessionFunctions
 Map of known SessionFunctions. More...
 
LibUtilities::FieldIOSharedPtr m_fld
 Field input/output. More...
 
Array< OneD, MultiRegions::ExpListSharedPtrm_fields
 Array holding all dependent variables. More...
 
SpatialDomains::BoundaryConditionsSharedPtr m_boundaryConditions
 Pointer to boundary conditions object. More...
 
SpatialDomains::MeshGraphSharedPtr m_graph
 Pointer to graph defining mesh. More...
 
std::string m_sessionName
 Name of the session. More...
 
NekDouble m_time
 Current time of simulation. More...
 
int m_initialStep
 Number of the step where the simulation should begin. More...
 
NekDouble m_fintime
 Finish time of the simulation. More...
 
NekDouble m_timestep
 Time step size. More...
 
NekDouble m_lambda
 Lambda constant in real system if one required. More...
 
NekDouble m_checktime
 Time between checkpoints. More...
 
NekDouble m_lastCheckTime
 
NekDouble m_TimeIncrementFactor
 
int m_nchk
 Number of checkpoints written so far. More...
 
int m_steps
 Number of steps to take. More...
 
int m_checksteps
 Number of steps between checkpoints. More...
 
int m_infosteps
 Number of time steps between outputting status information. More...
 
int m_iterPIT = 0
 Number of parallel-in-time time iteration. More...
 
int m_windowPIT = 0
 Index of windows for parallel-in-time time iteration. More...
 
int m_spacedim
 Spatial dimension (>= expansion dim). More...
 
int m_expdim
 Expansion dimension. More...
 
bool m_singleMode
 Flag to determine if single homogeneous mode is used. More...
 
bool m_halfMode
 Flag to determine if half homogeneous mode is used. More...
 
bool m_multipleModes
 Flag to determine if use multiple homogenenous modes are used. More...
 
bool m_useFFT
 Flag to determine if FFT is used for homogeneous transform. More...
 
bool m_homogen_dealiasing
 Flag to determine if dealiasing is used for homogeneous simulations. More...
 
bool m_specHP_dealiasing
 Flag to determine if dealisising is usde for the Spectral/hp element discretisation. More...
 
enum MultiRegions::ProjectionType m_projectionType
 Type of projection; e.g continuous or discontinuous. More...
 
Array< OneD, Array< OneD, NekDouble > > m_traceNormals
 Array holding trace normals for DG simulations in the forwards direction. More...
 
Array< OneD, bool > m_checkIfSystemSingular
 Flag to indicate if the fields should be checked for singularity. More...
 
LibUtilities::FieldMetaDataMap m_fieldMetaDataMap
 Map to identify relevant solver info to dump in output fields. More...
 
Array< OneD, NekDoublem_movingFrameData
 Moving reference frame status in the inertial frame X, Y, Z, Theta_x, Theta_y, Theta_z, U, V, W, Omega_x, Omega_y, Omega_z, A_x, A_y, A_z, DOmega_x, DOmega_y, DOmega_z, pivot_x, pivot_y, pivot_z. More...
 
std::vector< std::string > m_strFrameData
 variable name in m_movingFrameData More...
 
int m_NumQuadPointsError
 Number of Quadrature points used to work out the error. More...
 
enum HomogeneousType m_HomogeneousType
 
NekDouble m_LhomX
 physical length in X direction (if homogeneous) More...
 
NekDouble m_LhomY
 physical length in Y direction (if homogeneous) More...
 
NekDouble m_LhomZ
 physical length in Z direction (if homogeneous) More...
 
int m_npointsX
 number of points in X direction (if homogeneous) More...
 
int m_npointsY
 number of points in Y direction (if homogeneous) More...
 
int m_npointsZ
 number of points in Z direction (if homogeneous) More...
 
int m_HomoDirec
 number of homogenous directions More...
 

Static Protected Attributes

static std::string equationSystemTypeLookupIds []
 
static std::string projectionTypeLookupIds []
 

Private Member Functions

virtual SOLVER_UTILS_EXPORT Array< OneD, bool > v_GetSystemSingularChecks ()
 
SOLVER_UTILS_EXPORT void PrintProgressbar (const int position, const int goal) const
 

Detailed Description

A base class for describing how to solve specific equations.

This class is a base class for all solver implementations. It provides the underlying generic functionality and interface for solving equations.

To solve a steady-state equation, create a derived class from this class and reimplement the virtual functions to provide custom implementation for the problem.

To solve unsteady problems, derive from the UnsteadySystem class instead which provides general time integration.

Definition at line 75 of file EquationSystem.h.

Member Enumeration Documentation

◆ HomogeneousType

Parameter for homogeneous expansions.

Enumerator
eHomogeneous1D 
eHomogeneous2D 
eHomogeneous3D 
eNotHomogeneous 

Definition at line 548 of file EquationSystem.h.

Constructor & Destructor Documentation

◆ ~EquationSystem()

Nektar::SolverUtils::EquationSystem::~EquationSystem ( )
virtual

Destructor.

Destructor for class EquationSystem.

Definition at line 132 of file EquationSystem.cpp.

133{
134 LibUtilities::NekManager<LocalRegions::MatrixKey, DNekScalMat,
135 LocalRegions::MatrixKey::opLess>::ClearManager();
136 LibUtilities::NekManager<LocalRegions::MatrixKey, DNekScalBlkMat,
137 LocalRegions::MatrixKey::opLess>::ClearManager();
138}
NekMatrix< NekMatrix< NekMatrix< NekDouble, StandardMatrixTag >, ScaledMatrixTag >, BlockMatrixTag > DNekScalBlkMat
Definition: NekTypeDefs.hpp:68
NekMatrix< NekMatrix< NekDouble, StandardMatrixTag >, ScaledMatrixTag > DNekScalMat

◆ EquationSystem()

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

Initialises EquationSystem class members.

This constructor is protected as the objects of this class are never instantiated directly.

Parameters
pSessionThe session reader holding problem parameters.

Definition at line 110 of file EquationSystem.cpp.

113 : m_comm(pSession->GetComm()), m_session(pSession), m_graph(pGraph),
114 m_lambda(0), m_infosteps(10),
116{
117 // set up session names in fieldMetaDataMap
118 const vector<std::string> filenames = m_session->GetFilenames();
119
120 for (int i = 0; i < filenames.size(); ++i)
121 {
122 string sessionname = "SessionName";
123 sessionname += std::to_string(i);
124 m_fieldMetaDataMap[sessionname] = filenames[i];
125 m_fieldMetaDataMap["ChkFileNum"] = std::to_string(0);
126 }
127}
SpatialDomains::MeshGraphSharedPtr m_graph
Pointer to graph defining mesh.
LibUtilities::CommSharedPtr m_comm
Communicator.
int m_infosteps
Number of time steps between outputting status information.
NekDouble m_lambda
Lambda constant in real system if one required.
LibUtilities::SessionReaderSharedPtr m_session
The session reader.
LibUtilities::FieldMetaDataMap m_fieldMetaDataMap
Map to identify relevant solver info to dump in output fields.
static FieldMetaDataMap NullFieldMetaDataMap
Definition: FieldIO.h:51

References m_fieldMetaDataMap, and m_session.

Member Function Documentation

◆ as()

template<class T >
std::shared_ptr< T > Nektar::SolverUtils::EquationSystem::as ( )
inline

Definition at line 124 of file EquationSystem.h.

125 {
126 return std::dynamic_pointer_cast<T>(shared_from_this());
127 }

◆ Checkpoint_BaseFlow()

void Nektar::SolverUtils::EquationSystem::Checkpoint_BaseFlow ( const int  n)

Write base flow file of m_fields.

Write the n-th base flow into a .chk file

Parameters
nThe index of the base flow file.

Definition at line 1304 of file EquationSystem.cpp.

1305{
1306 std::string outname = m_sessionName + "_BaseFlow_" + std::to_string(n);
1307
1308 WriteFld(outname + ".chk");
1309}
SOLVER_UTILS_EXPORT void WriteFld(const std::string &outname)
Write field data to the given filename.
std::string m_sessionName
Name of the session.

References m_sessionName, and WriteFld().

◆ Checkpoint_Output() [1/2]

void Nektar::SolverUtils::EquationSystem::Checkpoint_Output ( const int  n)

Write checkpoint file of m_fields.

Write the n-th checkpoint file.

Parameters
nThe index of the checkpoint file.

Definition at line 1253 of file EquationSystem.cpp.

1254{
1255 if (!m_comm->IsParallelInTime())
1256 {
1257 // Serial-in-time
1258 std::string outname = m_sessionName + "_" + std::to_string(n);
1259 WriteFld(outname + ".chk");
1260 }
1261 else
1262 {
1263 // Parallel-in-time
1264 auto loc = m_sessionName.find("_xml/");
1265 auto sessionName = m_sessionName.substr(0, loc);
1266 std::string paradir =
1267 sessionName + "_" + std::to_string(m_iterPIT) + ".pit";
1268 if (!fs::is_directory(paradir))
1269 {
1270 fs::create_directory(paradir);
1271 }
1272 std::string outname = paradir + "/" + sessionName + "_timeLevel" +
1273 std::to_string(m_session->GetTimeLevel()) + "_" +
1274 std::to_string(n);
1275 WriteFld(outname + ".chk");
1276 }
1277}
int m_iterPIT
Number of parallel-in-time time iteration.

References CG_Iterations::loc, m_comm, m_iterPIT, m_session, m_sessionName, and WriteFld().

Referenced by Nektar::SolverUtils::FileSolution::v_DoInitialise(), Nektar::SolverUtils::UnsteadySystem::v_DoSolve(), Nektar::MMFAdvection::v_DoSolve(), Nektar::MMFMaxwell::v_DoSolve(), Nektar::MMFSWE::v_DoSolve(), Nektar::CoupledLinearNS::v_DoSolve(), v_SetInitialConditions(), Nektar::CompressibleFlowSystem::v_SetInitialConditions(), and Nektar::NonlinearPeregrine::v_SetInitialConditions().

◆ Checkpoint_Output() [2/2]

void Nektar::SolverUtils::EquationSystem::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.

Write the n-th checkpoint file.

Parameters
nThe index of the checkpoint file.

Definition at line 1283 of file EquationSystem.cpp.

1287{
1288 if (!m_comm->IsParallelInTime())
1289 {
1290 // Serial-in-time
1291 std::string outname = m_sessionName + "_" + std::to_string(n);
1292 WriteFld(outname, field, fieldcoeffs, variables);
1293 }
1294 else
1295 {
1296 ASSERTL0(false, "Not Implemented for Parallel-in-Time");
1297 }
1298}
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:208

References ASSERTL0, FilterPython_Function::field, m_comm, m_sessionName, and WriteFld().

◆ CopyFromPhysField()

void Nektar::SolverUtils::EquationSystem::CopyFromPhysField ( const int  i,
Array< OneD, NekDouble > &  output 
)
inline

Definition at line 683 of file EquationSystem.h.

685{
686 Vmath::Vcopy(output.size(), m_fields[i]->GetPhys(), 1, output, 1);
687}
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.hpp:825

References m_fields, and Vmath::Vcopy().

◆ CopyToPhysField()

void Nektar::SolverUtils::EquationSystem::CopyToPhysField ( const int  i,
const Array< OneD, const NekDouble > &  input 
)
inline

Definition at line 689 of file EquationSystem.h.

691{
692 Vmath::Vcopy(input.size(), input, 1, m_fields[i]->UpdatePhys(), 1);
693}

References m_fields, and Vmath::Vcopy().

◆ DoInitialise()

SOLVER_UTILS_EXPORT void Nektar::SolverUtils::EquationSystem::DoInitialise ( bool  dumpInitialConditions = true)
inline

Perform any initialisation necessary before solving the problem.

Definition at line 88 of file EquationSystem.h.

90 {
91 v_DoInitialise(dumpInitialConditions);
92 }
virtual SOLVER_UTILS_EXPORT void v_DoInitialise(bool dumpInitialConditions=true)
Virtual function for initialisation implementation.

References v_DoInitialise().

◆ DoSolve()

SOLVER_UTILS_EXPORT void Nektar::SolverUtils::EquationSystem::DoSolve ( )
inline

Solve the problem.

Definition at line 95 of file EquationSystem.h.

96 {
97 v_DoSolve();
98 }
virtual SOLVER_UTILS_EXPORT void v_DoSolve()
Virtual function for solve implementation.

References v_DoSolve().

◆ ErrorExtraPoints()

Array< OneD, NekDouble > Nektar::SolverUtils::EquationSystem::ErrorExtraPoints ( unsigned int  field)

Compute error (L2 and L_inf) over an larger set of quadrature points return [L2 Linf].

Compute the error in the L2-, Linf- and H1-norm for a larger number of quadrature points.

Parameters
fieldThe field to compare.
Returns
Error in the L2-, Linf- and H1-norm.

Definition at line 974 of file EquationSystem.cpp.

975{
976 int NumModes = GetNumExpModes();
977 Array<OneD, NekDouble> errNorms(3); // Expects 3 norms (L2, Linf, H1)
978
979 const LibUtilities::PointsKey PkeyT1(m_NumQuadPointsError,
981 const LibUtilities::PointsKey PkeyT2(m_NumQuadPointsError,
982 LibUtilities::eGaussRadauMAlpha1Beta0);
983 const LibUtilities::PointsKey PkeyQ1(m_NumQuadPointsError,
985 const LibUtilities::PointsKey PkeyQ2(m_NumQuadPointsError,
987 const LibUtilities::BasisKey BkeyT1(LibUtilities::eModified_A, NumModes,
988 PkeyT1);
989 const LibUtilities::BasisKey BkeyT2(LibUtilities::eModified_B, NumModes,
990 PkeyT2);
991 const LibUtilities::BasisKey BkeyQ1(LibUtilities::eModified_A, NumModes,
992 PkeyQ1);
993 const LibUtilities::BasisKey BkeyQ2(LibUtilities::eModified_A, NumModes,
994 PkeyQ2);
995
996 LibUtilities::BasisKeyVector Tkeys, Qkeys;
997
998 // make a copy of the ExpansionInfoMap
999 SpatialDomains::ExpansionInfoMap NewExpInfo = m_graph->GetExpansionInfo();
1002 NewExpInfo);
1003
1004 // reset new graph with new keys
1005 Tkeys.push_back(BkeyT1);
1006 Tkeys.push_back(BkeyT2);
1007 m_graph->ResetExpansionInfoToBasisKey(ExpInfo, LibUtilities::eTriangle,
1008 Tkeys);
1009 Qkeys.push_back(BkeyQ1);
1010 Qkeys.push_back(BkeyQ2);
1011 m_graph->ResetExpansionInfoToBasisKey(ExpInfo, LibUtilities::eQuadrilateral,
1012 Qkeys);
1013
1014 MultiRegions::ExpListSharedPtr ErrorExplist =
1016 NewExpInfo);
1017
1018 int ErrorCoordim = ErrorExplist->GetCoordim(0);
1019 int ErrorNq = ErrorExplist->GetTotPoints();
1020
1021 Array<OneD, NekDouble> ErrorXc0(ErrorNq, 0.0);
1022 Array<OneD, NekDouble> ErrorXc1(ErrorNq, 0.0);
1023 Array<OneD, NekDouble> ErrorXc2(ErrorNq, 0.0);
1024
1025 switch (ErrorCoordim)
1026 {
1027 case 1:
1028 ErrorExplist->GetCoords(ErrorXc0);
1029 break;
1030 case 2:
1031 ErrorExplist->GetCoords(ErrorXc0, ErrorXc1);
1032 break;
1033 case 3:
1034 ErrorExplist->GetCoords(ErrorXc0, ErrorXc1, ErrorXc2);
1035 break;
1036 }
1038 m_session->GetFunction("ExactSolution", field);
1039
1040 // Evaluate the exact solution
1041 Array<OneD, NekDouble> ErrorSol(ErrorNq);
1042
1043 exSol->Evaluate(ErrorXc0, ErrorXc1, ErrorXc2, m_time, ErrorSol);
1044
1045 // Calcualte spectral/hp approximation on the quadrature points
1046 // of this new expansion basis
1047 ErrorExplist->BwdTrans(m_fields[field]->GetCoeffs(),
1048 ErrorExplist->UpdatePhys());
1049
1050 errNorms[0] = ErrorExplist->L2(ErrorExplist->GetPhys(), ErrorSol);
1051 errNorms[1] = ErrorExplist->Linf(ErrorExplist->GetPhys(), ErrorSol);
1052 errNorms[2] = ErrorExplist->H1(ErrorExplist->GetPhys(), ErrorSol);
1053
1054 return errNorms;
1055}
static std::shared_ptr< DataType > AllocateSharedPtr(const Args &...args)
Allocate a shared pointer from the memory pool.
NekDouble m_time
Current time of simulation.
SOLVER_UTILS_EXPORT int GetNumExpModes()
int m_NumQuadPointsError
Number of Quadrature points used to work out the error.
std::vector< BasisKey > BasisKeyVector
Name for a vector of BasisKeys.
std::shared_ptr< Equation > EquationSharedPtr
Definition: Equation.h:125
@ eGaussLobattoLegendre
1D Gauss-Lobatto-Legendre quadrature points
Definition: PointsType.h:51
@ eModified_B
Principle Modified Functions .
Definition: BasisType.h:49
@ eModified_A
Principle Modified Functions .
Definition: BasisType.h:48
std::shared_ptr< ExpList > ExpListSharedPtr
Shared pointer to an ExpList object.
std::shared_ptr< ExpansionInfoMap > ExpansionInfoMapShPtr
Definition: MeshGraph.h:143
std::map< int, ExpansionInfoShPtr > ExpansionInfoMap
Definition: MeshGraph.h:141

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eModified_A, Nektar::LibUtilities::eModified_B, Nektar::LibUtilities::eQuadrilateral, Nektar::LibUtilities::eTriangle, FilterPython_Function::field, GetNumExpModes(), m_fields, m_graph, m_NumQuadPointsError, m_session, and m_time.

Referenced by v_H1Error(), Nektar::MMFSWE::v_L2Error(), v_L2Error(), and v_LinfError().

◆ EvaluateExactSolution()

SOLVER_UTILS_EXPORT void Nektar::SolverUtils::EquationSystem::EvaluateExactSolution ( int  field,
Array< OneD, NekDouble > &  outfield,
const NekDouble  time 
)
inline

Evaluates an exact solution.

Definition at line 179 of file EquationSystem.h.

181 {
182 v_EvaluateExactSolution(field, outfield, time);
183 }
virtual SOLVER_UTILS_EXPORT void v_EvaluateExactSolution(unsigned int field, Array< OneD, NekDouble > &outfield, const NekDouble time)

References FilterPython_Function::field, and v_EvaluateExactSolution().

Referenced by Nektar::PulseWaveSystem::v_L2Error(), Nektar::MMFSWE::v_LinfError(), and Nektar::PulseWaveSystem::v_LinfError().

◆ ExtraFldOutput()

SOLVER_UTILS_EXPORT void Nektar::SolverUtils::EquationSystem::ExtraFldOutput ( std::vector< Array< OneD, NekDouble > > &  fieldcoeffs,
std::vector< std::string > &  variables 
)
inline

Definition at line 147 of file EquationSystem.h.

150 {
151 v_ExtraFldOutput(fieldcoeffs, variables);
152 }
virtual SOLVER_UTILS_EXPORT void v_ExtraFldOutput(std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables)

References v_ExtraFldOutput().

Referenced by WriteFld().

◆ FwdTransFields()

void Nektar::SolverUtils::EquationSystem::FwdTransFields ( void  )

FwdTrans the m_fields members

Definition at line 1239 of file EquationSystem.cpp.

1240{
1241 for (int i = 0; i < m_fields.size(); i++)
1242 {
1243 m_fields[i]->FwdTrans(m_fields[i]->GetPhys(),
1244 m_fields[i]->UpdateCoeffs());
1245 m_fields[i]->SetPhysState(false);
1246 }
1247}

References m_fields.

◆ GetCheckpointNumber()

SOLVER_UTILS_EXPORT int Nektar::SolverUtils::EquationSystem::GetCheckpointNumber ( )
inline

Definition at line 386 of file EquationSystem.h.

387 {
388 return m_nchk;
389 }
int m_nchk
Number of checkpoints written so far.

References m_nchk.

◆ GetCheckpointSteps()

SOLVER_UTILS_EXPORT int Nektar::SolverUtils::EquationSystem::GetCheckpointSteps ( )
inline

Definition at line 396 of file EquationSystem.h.

397 {
398 return m_checksteps;
399 }
int m_checksteps
Number of steps between checkpoints.

References m_checksteps.

◆ GetCoeff_Offset()

SOLVER_UTILS_EXPORT int Nektar::SolverUtils::EquationSystem::GetCoeff_Offset ( int  n)
inline

Definition at line 336 of file EquationSystem.h.

337 {
338 return m_fields[0]->GetCoeff_Offset(n);
339 }

References m_fields.

◆ GetExpSize()

SOLVER_UTILS_EXPORT int Nektar::SolverUtils::EquationSystem::GetExpSize ( void  )
inline

◆ GetFunction()

SessionFunctionSharedPtr Nektar::SolverUtils::EquationSystem::GetFunction ( std::string  name,
const MultiRegions::ExpListSharedPtr field = MultiRegions::NullExpListSharedPtr,
bool  cache = false 
)

Get a SessionFunction by name.

Definition at line 741 of file EquationSystem.cpp.

743{
745 if (!field)
746 {
747 vField = m_fields[0];
748 }
749
750 if (cache)
751 {
752 if ((m_sessionFunctions.find(name) == m_sessionFunctions.end()) ||
753 (m_sessionFunctions[name]->GetSession() != m_session) ||
754 (m_sessionFunctions[name]->GetExpansion() != vField))
755 {
758 m_session, vField, name, cache);
759 }
760
761 return m_sessionFunctions[name];
762 }
763 else
764 {
766 new SessionFunction(m_session, vField, name, cache));
767 }
768}
std::map< std::string, SolverUtils::SessionFunctionSharedPtr > m_sessionFunctions
Map of known SessionFunctions.
std::shared_ptr< SessionFunction > SessionFunctionSharedPtr

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), FilterPython_Function::field, m_fields, m_session, m_sessionFunctions, and CellMLToNektar.pycml::name.

Referenced by Nektar::CoupledLinearNS::DefineForcingTerm(), Nektar::MMFSWE::EvaluateCoriolis(), Nektar::ShallowWaterSystem::EvaluateCoriolis(), Nektar::ShallowWaterSystem::EvaluateWaterDepth(), Nektar::SmoothedProfileMethod::ReadPhi(), Nektar::VelocityCorrectionScheme::SetUpSVV(), Nektar::SteadyAdvectionDiffusion::v_DoInitialise(), Nektar::CoupledLinearNS::v_DoInitialise(), Nektar::LinearElasticSystem::v_DoSolve(), v_EvaluateExactSolution(), Nektar::Poisson::v_GenerateSummary(), v_H1Error(), Nektar::PulseWaveSystem::v_InitObject(), Nektar::BidomainRoth::v_InitObject(), Nektar::Monodomain::v_InitObject(), Nektar::APE::v_InitObject(), Nektar::LEE::v_InitObject(), Nektar::EigenValuesAdvection::v_InitObject(), Nektar::MMFAdvection::v_InitObject(), Nektar::Poisson::v_InitObject(), Nektar::Projection::v_InitObject(), Nektar::SteadyAdvectionDiffusion::v_InitObject(), Nektar::UnsteadyAdvection::v_InitObject(), v_L2Error(), Nektar::PulseWaveSystem::v_L2Error(), v_LinfError(), Nektar::PulseWaveSystem::v_LinfError(), Nektar::Dummy::v_PostIntegrate(), Nektar::AcousticSystem::v_PreIntegrate(), and v_SetInitialConditions().

◆ GetInfoSteps()

SOLVER_UTILS_EXPORT int Nektar::SolverUtils::EquationSystem::GetInfoSteps ( )
inline

Definition at line 406 of file EquationSystem.h.

407 {
408 return m_infosteps;
409 }

References m_infosteps.

◆ GetNcoeffs() [1/2]

SOLVER_UTILS_EXPORT int Nektar::SolverUtils::EquationSystem::GetNcoeffs ( void  )
inline

◆ GetNcoeffs() [2/2]

SOLVER_UTILS_EXPORT int Nektar::SolverUtils::EquationSystem::GetNcoeffs ( const int  eid)
inline

Definition at line 288 of file EquationSystem.h.

289 {
290 return m_fields[0]->GetNcoeffs(eid);
291 }

References m_fields.

◆ GetNpoints()

SOLVER_UTILS_EXPORT int Nektar::SolverUtils::EquationSystem::GetNpoints ( void  )
inline

Definition at line 351 of file EquationSystem.h.

352 {
353 return m_fields[0]->GetNpoints();
354 }

References m_fields.

Referenced by Nektar::SolverUtils::UnsteadySystem::AppendOutput1D(), Nektar::MMFMaxwell::ComputeMaterialMicroWaveCloak(), Nektar::MMFMaxwell::ComputeMaterialOpticalCloak(), Nektar::MMFMaxwell::ComputeRadCloak(), Nektar::SolverUtils::UnsteadySystem::DoDummyProjection(), Nektar::MMFAdvection::DoOdeProjection(), Nektar::UnsteadyAdvection::DoOdeProjection(), Nektar::UnsteadyDiffusion::DoOdeProjection(), Nektar::UnsteadyInviscidBurgers::DoOdeProjection(), Nektar::ImageWarpingSystem::DoOdeProjection(), Nektar::MMFMaxwell::DoOdeProjection(), Nektar::ShallowWaterSystem::DoOdeProjection(), Nektar::MMFAdvection::DoOdeRhs(), Nektar::UnsteadyInviscidBurgers::DoOdeRhs(), Nektar::UnsteadyViscousBurgers::DoOdeRhs(), Nektar::ImageWarpingSystem::DoOdeRhs(), Nektar::SolverUtils::FileSolution::DoOdeRhs(), Nektar::UnsteadyInviscidBurgers::GetFluxVector(), Nektar::UnsteadyInviscidBurgers::GetNormalVelocity(), Nektar::CFSImplicit::NumCalcRiemFluxJac(), Nektar::CoupledLinearNS::Solve(), Nektar::NavierStokesCFE::v_DoDiffusion(), Nektar::NavierStokesCFEAxisym::v_DoDiffusion(), Nektar::NavierStokesImplicitCFE::v_DoDiffusionCoeff(), Nektar::EigenValuesAdvection::v_DoSolve(), Nektar::LinearElasticSystem::v_DoSolve(), Nektar::SolverUtils::FileSolution::v_GetDensity(), v_H1Error(), Nektar::NavierStokesCFEAxisym::v_InitObject(), Nektar::MMFSWE::v_L2Error(), v_L2Error(), Nektar::PulseWaveSystem::v_L2Error(), v_LinfError(), Nektar::PulseWaveSystem::v_LinfError(), Nektar::MMFMaxwell::WeakDGMaxwellDirDeriv(), Nektar::MMFSWE::WeakDGSWEDirDeriv(), and ZeroPhysFields().

◆ GetNumExpModes()

SOLVER_UTILS_EXPORT int Nektar::SolverUtils::EquationSystem::GetNumExpModes ( )
inline

Definition at line 293 of file EquationSystem.h.

294 {
295 return m_graph->GetExpansionInfo()
296 .begin()
297 ->second->m_basisKeyVector[0]
298 .GetNumModes();
299 }

References m_graph.

Referenced by ErrorExtraPoints().

◆ GetNumExpModesPerExp()

SOLVER_UTILS_EXPORT const Array< OneD, int > Nektar::SolverUtils::EquationSystem::GetNumExpModesPerExp ( )
inline

Definition at line 301 of file EquationSystem.h.

302 {
303 return m_fields[0]->EvalBasisNumModesMaxPerExp();
304 }

References m_fields.

Referenced by Nektar::SolverUtils::AdvectionSystem::GetElmtCFLVals().

◆ GetNvariables()

SOLVER_UTILS_EXPORT int Nektar::SolverUtils::EquationSystem::GetNvariables ( )
inline

Definition at line 306 of file EquationSystem.h.

307 {
308 return m_session->GetVariables().size();
309 }

References m_session.

Referenced by ImportFldToMultiDomains().

◆ GetPhys_Offset()

SOLVER_UTILS_EXPORT int Nektar::SolverUtils::EquationSystem::GetPhys_Offset ( int  n)
inline

Definition at line 331 of file EquationSystem.h.

332 {
333 return m_fields[0]->GetPhys_Offset(n);
334 }

References m_fields.

Referenced by Nektar::CFSImplicit::AddMatNSBlkDiagVol(), and Nektar::IncNavierStokes::SetRadiationBoundaryForcing().

◆ GetPressure()

SOLVER_UTILS_EXPORT MultiRegions::ExpListSharedPtr Nektar::SolverUtils::EquationSystem::GetPressure ( )
inline

Get pressure field if available.

Definition at line 142 of file EquationSystem.h.

143 {
144 return v_GetPressure();
145 }
virtual SOLVER_UTILS_EXPORT MultiRegions::ExpListSharedPtr v_GetPressure(void)

References v_GetPressure().

◆ GetSession()

SOLVER_UTILS_EXPORT LibUtilities::SessionReaderSharedPtr Nektar::SolverUtils::EquationSystem::GetSession ( )
inline

Get Session name.

Definition at line 136 of file EquationSystem.h.

137 {
138 return m_session;
139 }

References m_session.

◆ GetSessionName()

SOLVER_UTILS_EXPORT std::string Nektar::SolverUtils::EquationSystem::GetSessionName ( )
inline

Get Session name.

Definition at line 119 of file EquationSystem.h.

120 {
121 return m_sessionName;
122 }

References m_sessionName.

◆ GetSteps()

SOLVER_UTILS_EXPORT int Nektar::SolverUtils::EquationSystem::GetSteps ( )
inline

Definition at line 356 of file EquationSystem.h.

357 {
358 return m_steps;
359 }
int m_steps
Number of steps to take.

References m_steps.

◆ GetTime()

SOLVER_UTILS_EXPORT NekDouble Nektar::SolverUtils::EquationSystem::GetTime ( )
inline

Return final time.

Definition at line 278 of file EquationSystem.h.

279 {
280 return m_time;
281 }

References m_time.

◆ GetTimeStep()

SOLVER_UTILS_EXPORT NekDouble Nektar::SolverUtils::EquationSystem::GetTimeStep ( )
inline

Definition at line 366 of file EquationSystem.h.

367 {
368 return m_timestep;
369 }
NekDouble m_timestep
Time step size.

References m_timestep.

Referenced by Nektar::SolverUtils::UnsteadySystem::GetTimeStep().

◆ GetTotPoints() [1/2]

SOLVER_UTILS_EXPORT int Nektar::SolverUtils::EquationSystem::GetTotPoints ( void  )
inline

Definition at line 341 of file EquationSystem.h.

342 {
343 return m_fields[0]->GetNpoints();
344 }

References m_fields.

Referenced by Nektar::ShallowWaterSystem::AddCoriolis(), Nektar::SolverUtils::MMFSystem::AdddedtMaxwell(), Nektar::NonlinearSWE::AddVariableDepth(), Nektar::SolverUtils::UnsteadySystem::CheckSteadyState(), Nektar::SolverUtils::MMFSystem::Computedemdxicdote(), Nektar::MMFMaxwell::ComputeEnergyDensity(), Nektar::ShallowWaterSystem::ConservativeToPrimitive(), Nektar::MMFSWE::ConservativeToPrimitive(), Nektar::CoupledLinearNS::Continuation(), Nektar::CoupledLinearNS::DefineForcingTerm(), Nektar::SolverUtils::MMFSystem::DeriveCrossProductMF(), Nektar::AcousticSystem::DoOdeRhs(), Nektar::MMFDiffusion::DoOdeRhs(), Nektar::Dummy::DoOdeRhs(), Nektar::MMFMaxwell::DoOdeRhs(), Nektar::MMFSWE::DoOdeRhs(), Nektar::MMFMaxwell::EvaluateCoriolis(), Nektar::MMFSWE::EvaluateCoriolisForZonalFlow(), Nektar::CompressibleFlowSystem::EvaluateIsentropicVortex(), Nektar::CoupledLinearNS::EvaluateNewtonRHS(), Nektar::MMFSWE::EvaluateStandardCoriolis(), Nektar::MMFSWE::EvaluateWaterDepth(), Nektar::CompressibleFlowSystem::GetExactRinglebFlow(), Nektar::MMFSWE::IsolatedMountainFlow(), Nektar::NonlinearPeregrine::LaitoneSolitaryWave(), Nektar::MMFDiffusion::Morphogenesis(), Nektar::CFSImplicit::MultiplyElmtInvMassPlusSource(), Nektar::MMFDiffusion::PlanePhiWave(), Nektar::ShallowWaterSystem::PrimitiveToConservative(), Nektar::MMFSWE::PrimitiveToConservative(), Nektar::MMFSWE::RossbyWave(), Nektar::CoupledLinearNS::SetUpCoupledMatrix(), Nektar::CoupledLinearNS::SolveSteadyNavierStokes(), Nektar::MMFSWE::SteadyZonalFlow(), Nektar::MMFDiffusion::TestCubeProblem(), Nektar::MMFDiffusion::TestPlaneProblem(), Nektar::MMFSWE::UnstableJetFlow(), Nektar::MMFSWE::UnsteadyZonalFlow(), Nektar::LEE::v_AddLinTerm(), Nektar::UnsteadyAdvection::v_ALEInitObject(), Nektar::UnsteadyAdvectionDiffusion::v_ALEInitObject(), Nektar::CompressibleFlowSystem::v_ALEInitObject(), Nektar::CFSImplicit::v_ALEInitObject(), Nektar::NavierStokesImplicitCFE::v_CalcPhysDeriv(), Nektar::VCSImplicit::v_DoInitialise(), Nektar::CoupledLinearNS::v_DoInitialise(), Nektar::VCSMapping::v_DoInitialise(), Nektar::VelocityCorrectionScheme::v_DoInitialise(), Nektar::LinearSWE::v_DoOdeRhs(), Nektar::NonlinearPeregrine::v_DoOdeRhs(), Nektar::NonlinearSWE::v_DoOdeRhs(), Nektar::SolverUtils::UnsteadySystem::v_DoSolve(), Nektar::SteadyAdvectionDiffusion::v_DoSolve(), Nektar::MMFMaxwell::v_DoSolve(), Nektar::MMFDiffusion::v_EvaluateExactSolution(), Nektar::CompressibleFlowSystem::v_GetMaxStdVelocity(), Nektar::APE::v_InitObject(), Nektar::LEE::v_InitObject(), Nektar::ShallowWaterSystem::v_InitObject(), v_L2Error(), Nektar::Dummy::v_Output(), Nektar::MMFMaxwell::v_SetInitialConditions(), Nektar::MMFSWE::v_SetInitialConditions(), Nektar::MMFDiffusion::v_SetInitialConditions(), Nektar::SolverUtils::UnsteadySystem::v_SteadyStateResidual(), and Nektar::CompressibleFlowSystem::v_SteadyStateResidual().

◆ GetTotPoints() [2/2]

SOLVER_UTILS_EXPORT int Nektar::SolverUtils::EquationSystem::GetTotPoints ( int  n)
inline

Definition at line 346 of file EquationSystem.h.

347 {
348 return m_fields[0]->GetTotPoints(n);
349 }

References m_fields.

◆ GetTraceNormals()

SOLVER_UTILS_EXPORT Array< OneD, const Array< OneD, NekDouble > > Nektar::SolverUtils::EquationSystem::GetTraceNormals ( )
inline

Definition at line 426 of file EquationSystem.h.

427 {
428 return m_traceNormals;
429 }
Array< OneD, Array< OneD, NekDouble > > m_traceNormals
Array holding trace normals for DG simulations in the forwards direction.

References m_traceNormals.

◆ GetTraceNpoints()

SOLVER_UTILS_EXPORT int Nektar::SolverUtils::EquationSystem::GetTraceNpoints ( )
inline

◆ GetTraceTotPoints()

SOLVER_UTILS_EXPORT int Nektar::SolverUtils::EquationSystem::GetTraceTotPoints ( )
inline

Definition at line 316 of file EquationSystem.h.

317 {
318 return GetTraceNpoints();
319 }
SOLVER_UTILS_EXPORT int GetTraceNpoints()

References GetTraceNpoints().

Referenced by Nektar::SolverUtils::MMFSystem::AverageMaxwellFlux1D(), Nektar::SolverUtils::MMFSystem::ComputeMFtrace(), Nektar::SolverUtils::MMFSystem::ComputeNtimesF12(), Nektar::SolverUtils::MMFSystem::ComputeNtimesFz(), Nektar::SolverUtils::MMFSystem::ComputeNtimestimesdF12(), Nektar::SolverUtils::MMFSystem::ComputeNtimestimesdFz(), Nektar::MMFMaxwell::ComputeSurfaceCurrent(), Nektar::CompressibleFlowSystem::DoOdeRhs(), Nektar::CFSImplicit::DoOdeRhsCoeff(), Nektar::CFSImplicit::GetTraceJac(), Nektar::SolverUtils::MMFSystem::LaxFriedrichMaxwellFlux1D(), Nektar::CFSImplicit::NumCalcRiemFluxJac(), Nektar::NonlinearPeregrine::NumericalFluxConsVariables(), Nektar::NonlinearPeregrine::NumericalFluxForcing(), Nektar::SolverUtils::MMFSystem::NumericalMaxwellFluxTE(), Nektar::SolverUtils::MMFSystem::NumericalMaxwellFluxTM(), Nektar::MMFSWE::NumericalSWEFlux(), Nektar::MMFMaxwell::Printout_SurfaceCurrent(), Nektar::AcousticSystem::SetBoundaryConditions(), Nektar::CompressibleFlowSystem::SetBoundaryConditions(), Nektar::ShallowWaterSystem::SetBoundaryConditions(), Nektar::SolverUtils::MMFSystem::UpwindMaxwellFlux1D(), Nektar::NavierStokesCFE::v_DoDiffusion(), Nektar::NavierStokesImplicitCFE::v_DoDiffusionCoeff(), Nektar::NonlinearPeregrine::v_DoOdeRhs(), Nektar::NavierStokesCFE::v_ExtraFldOutput(), Nektar::PulseWaveSystem::v_InitObject(), Nektar::MMFSWE::WallBoundary2D(), Nektar::NonlinearPeregrine::WallBoundaryContVariables(), and Nektar::NonlinearPeregrine::WallBoundaryForcing().

◆ GetVariable()

SOLVER_UTILS_EXPORT const std::string Nektar::SolverUtils::EquationSystem::GetVariable ( unsigned int  i)
inline

Definition at line 311 of file EquationSystem.h.

312 {
313 return m_session->GetVariable(i);
314 }

References m_session.

◆ H1Error()

SOLVER_UTILS_EXPORT NekDouble Nektar::SolverUtils::EquationSystem::H1Error ( unsigned int  field,
const Array< OneD, NekDouble > &  exactsoln,
bool  Normalised = false 
)
inline

Compute the H1 error between fields and a given exact solution.

Definition at line 212 of file EquationSystem.h.

214 {
215 return v_H1Error(field, exactsoln, Normalised);
216 }
virtual SOLVER_UTILS_EXPORT NekDouble v_H1Error(unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray, bool Normalised=false)
Virtual function for the H_1 error computation between fields and a given exact solution.

References FilterPython_Function::field, and v_H1Error().

◆ ImportFld() [1/3]

void Nektar::SolverUtils::EquationSystem::ImportFld ( const std::string &  infile,
Array< OneD, MultiRegions::ExpListSharedPtr > &  pFields 
)

Input field data from the given file.

Import field from infile and load into m_fields. This routine will also perform a BwdTrans to ensure data is in both the physical and coefficient storage.

Parameters
infileFilename to read.

Definition at line 1413 of file EquationSystem.cpp.

1416{
1417 std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef;
1418 std::vector<std::vector<NekDouble>> FieldData;
1421 field_fld->Import(infile, FieldDef, FieldData);
1422
1423 // Copy FieldData into m_fields
1424 for (int j = 0; j < pFields.size(); ++j)
1425 {
1426 Vmath::Zero(pFields[j]->GetNcoeffs(), pFields[j]->UpdateCoeffs(), 1);
1427
1428 for (int i = 0; i < FieldDef.size(); ++i)
1429 {
1430 ASSERTL1(FieldDef[i]->m_fields[j] == m_session->GetVariable(j),
1431 std::string("Order of ") + infile +
1432 std::string(" data and that defined in "
1433 "m_boundaryconditions differs"));
1434
1435 pFields[j]->ExtractDataToCoeffs(FieldDef[i], FieldData[i],
1436 FieldDef[i]->m_fields[j],
1437 pFields[j]->UpdateCoeffs());
1438 }
1439 pFields[j]->BwdTrans(pFields[j]->GetCoeffs(), pFields[j]->UpdatePhys());
1440 }
1441}
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode....
Definition: ErrorUtil.hpp:242
static std::shared_ptr< FieldIO > CreateForFile(const LibUtilities::SessionReaderSharedPtr session, const std::string &filename)
Construct a FieldIO object for a given input filename.
Definition: FieldIO.cpp:223
SOLVER_UTILS_EXPORT int GetNcoeffs()
std::shared_ptr< FieldIO > FieldIOSharedPtr
Definition: FieldIO.h:322
void Zero(int n, T *x, const int incx)
Zero vector.
Definition: Vmath.hpp:273

References ASSERTL1, Nektar::LibUtilities::FieldIO::CreateForFile(), GetNcoeffs(), m_fields, m_session, and Vmath::Zero().

◆ ImportFld() [2/3]

void Nektar::SolverUtils::EquationSystem::ImportFld ( const std::string &  infile,
MultiRegions::ExpListSharedPtr pField,
std::string &  pFieldName 
)

Output a field. Input field data into ExpList from the given file.

Import field from infile and load into pField. This routine will also perform a BwdTrans to ensure data is in both the physical and coefficient storage.

Definition at line 1497 of file EquationSystem.cpp.

1500{
1501 std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef;
1502 std::vector<std::vector<NekDouble>> FieldData;
1503
1506 field_fld->Import(infile, FieldDef, FieldData);
1507 int idx = -1;
1508
1509 Vmath::Zero(pField->GetNcoeffs(), pField->UpdateCoeffs(), 1);
1510
1511 for (int i = 0; i < FieldDef.size(); ++i)
1512 {
1513 // find the index of the required field in the file.
1514 for (int j = 0; j < FieldData.size(); ++j)
1515 {
1516 if (FieldDef[i]->m_fields[j] == pFieldName)
1517 {
1518 idx = j;
1519 }
1520 }
1521 ASSERTL1(idx >= 0, "Field " + pFieldName + " not found.");
1522
1523 pField->ExtractDataToCoeffs(FieldDef[i], FieldData[i],
1524 FieldDef[i]->m_fields[idx],
1525 pField->UpdateCoeffs());
1526 }
1527 pField->BwdTrans(pField->GetCoeffs(), pField->UpdatePhys());
1528}

References ASSERTL1, Nektar::LibUtilities::FieldIO::CreateForFile(), m_fields, m_session, and Vmath::Zero().

◆ ImportFld() [3/3]

void Nektar::SolverUtils::EquationSystem::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.

Import field from infile and load into the array coeffs.

Parameters
infileFilename to read.
fieldStran array of string identifying fields to be imported
coeffsarray of array of coefficients to store imported data

Definition at line 1537 of file EquationSystem.cpp.

1540{
1541
1542 ASSERTL0(fieldStr.size() <= coeffs.size(),
1543 "length of fieldstr should be the same as coeffs");
1544
1545 std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef;
1546 std::vector<std::vector<NekDouble>> FieldData;
1547
1550 field_fld->Import(infile, FieldDef, FieldData);
1551
1552 // Copy FieldData into m_fields
1553 for (int j = 0; j < fieldStr.size(); ++j)
1554 {
1555 Vmath::Zero(coeffs[j].size(), coeffs[j], 1);
1556 for (int i = 0; i < FieldDef.size(); ++i)
1557 {
1558 m_fields[0]->ExtractDataToCoeffs(FieldDef[i], FieldData[i],
1559 fieldStr[j], coeffs[j]);
1560 }
1561 }
1562}

References ASSERTL0, Nektar::LibUtilities::FieldIO::CreateForFile(), m_fields, m_session, and Vmath::Zero().

◆ ImportFldToMultiDomains()

void Nektar::SolverUtils::EquationSystem::ImportFldToMultiDomains ( const std::string &  infile,
Array< OneD, MultiRegions::ExpListSharedPtr > &  pFields,
const int  ndomains 
)

Input field data from the given file to multiple domains.

Import field from infile and load into m_fields. This routine will also perform a BwdTrans to ensure data is in both the physical and coefficient storage.

Parameters
infileFilename to read. If optionan ndomains is specified it assumes we loop over nodmains for each nvariables.

Definition at line 1451 of file EquationSystem.cpp.

1454{
1455 std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef;
1456 std::vector<std::vector<NekDouble>> FieldData;
1457
1458 LibUtilities::Import(infile, FieldDef, FieldData);
1459
1460 int nvariables = GetNvariables();
1461
1462 ASSERTL0(
1463 ndomains * nvariables == pFields.size(),
1464 "Number of fields does not match the number of variables and domains");
1465
1466 // Copy FieldData into m_fields
1467 for (int j = 0; j < ndomains; ++j)
1468 {
1469 for (int i = 0; i < nvariables; ++i)
1470 {
1471 Vmath::Zero(pFields[j * nvariables + i]->GetNcoeffs(),
1472 pFields[j * nvariables + i]->UpdateCoeffs(), 1);
1473
1474 for (int n = 0; n < FieldDef.size(); ++n)
1475 {
1476 ASSERTL1(FieldDef[n]->m_fields[i] == m_session->GetVariable(i),
1477 std::string("Order of ") + infile +
1478 std::string(" data and that defined in "
1479 "m_boundaryconditions differs"));
1480
1481 pFields[j * nvariables + i]->ExtractDataToCoeffs(
1482 FieldDef[n], FieldData[n], FieldDef[n]->m_fields[i],
1483 pFields[j * nvariables + i]->UpdateCoeffs());
1484 }
1485 pFields[j * nvariables + i]->BwdTrans(
1486 pFields[j * nvariables + i]->GetCoeffs(),
1487 pFields[j * nvariables + i]->UpdatePhys());
1488 }
1489 }
1490}
SOLVER_UTILS_EXPORT int GetNvariables()
void Import(const std::string &infilename, std::vector< FieldDefinitionsSharedPtr > &fielddefs, std::vector< std::vector< NekDouble > > &fielddata, FieldMetaDataMap &fieldinfomap, const Array< OneD, int > &ElementIDs)
This function allows for data to be imported from an FLD file when a session and/or communicator is n...
Definition: FieldIO.cpp:287

References ASSERTL0, ASSERTL1, GetNcoeffs(), GetNvariables(), Nektar::LibUtilities::Import(), m_fields, m_session, and Vmath::Zero().

◆ InitObject()

SOLVER_UTILS_EXPORT void Nektar::SolverUtils::EquationSystem::InitObject ( bool  DeclareField = true)
inline

Initialises the members of this object.

Definition at line 82 of file EquationSystem.h.

83 {
84 v_InitObject(DeclareField);
85 }
virtual SOLVER_UTILS_EXPORT void v_InitObject(bool DeclareFeld=true)
Initialisation object for EquationSystem.

References v_InitObject().

◆ L2Error() [1/2]

SOLVER_UTILS_EXPORT NekDouble Nektar::SolverUtils::EquationSystem::L2Error ( unsigned int  field,
bool  Normalised = false 
)
inline

Compute the L2 error of the fields.

Definition at line 195 of file EquationSystem.h.

197 {
198 return L2Error(field, NullNekDouble1DArray, Normalised);
199 }
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.
static Array< OneD, NekDouble > NullNekDouble1DArray

References FilterPython_Function::field, L2Error(), and Nektar::NullNekDouble1DArray.

◆ L2Error() [2/2]

SOLVER_UTILS_EXPORT NekDouble Nektar::SolverUtils::EquationSystem::L2Error ( unsigned int  field,
const Array< OneD, NekDouble > &  exactsoln,
bool  Normalised = false 
)
inline

Compute the L2 error between fields and a given exact solution.

Definition at line 188 of file EquationSystem.h.

190 {
191 return v_L2Error(field, exactsoln, Normalised);
192 }
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.

References FilterPython_Function::field, and v_L2Error().

Referenced by L2Error().

◆ LinfError()

SOLVER_UTILS_EXPORT NekDouble Nektar::SolverUtils::EquationSystem::LinfError ( unsigned int  field,
const Array< OneD, NekDouble > &  exactsoln = NullNekDouble1DArray 
)
inline

Linf error computation.

Definition at line 203 of file EquationSystem.h.

205 {
206 return v_LinfError(field, exactsoln);
207 }
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.

References FilterPython_Function::field, and v_LinfError().

Referenced by Nektar::MMFSWE::v_LinfError().

◆ NegatedOp()

SOLVER_UTILS_EXPORT bool Nektar::SolverUtils::EquationSystem::NegatedOp ( )
inline

Identify if operator is negated in DoSolve.

Definition at line 450 of file EquationSystem.h.

451 {
452 return v_NegatedOp();
453 }
virtual SOLVER_UTILS_EXPORT bool v_NegatedOp(void)
Virtual function to identify if operator is negated in DoSolve.

References v_NegatedOp().

◆ Output()

SOLVER_UTILS_EXPORT void Nektar::SolverUtils::EquationSystem::Output ( )
inline

Perform output operations after solve.

Definition at line 113 of file EquationSystem.h.

114 {
115 v_Output();
116 }
virtual SOLVER_UTILS_EXPORT void v_Output(void)

References v_Output().

◆ PrintProgressbar()

SOLVER_UTILS_EXPORT void Nektar::SolverUtils::EquationSystem::PrintProgressbar ( const int  position,
const int  goal 
) const
inlineprivate

Definition at line 639 of file EquationSystem.h.

641 {
642 LibUtilities::PrintProgressbar(position, goal, "Interpolating");
643 }
int PrintProgressbar(const int position, const int goal, const std::string message, int lastprogress=-1)
Prints a progressbar.
Definition: Progressbar.hpp:65

References Nektar::LibUtilities::PrintProgressbar().

◆ PrintSummary()

void Nektar::SolverUtils::EquationSystem::PrintSummary ( std::ostream &  out)
inline

Print a summary of parameters and solver characteristics.

Prints a summary of variables and problem parameters.

Public interface routine to virtual function implementation.

Parameters
outThe ostream object to write to.

Definition at line 653 of file EquationSystem.h.

654{
655 if (m_session->GetComm()->GetRank() == 0)
656 {
657 std::vector<std::pair<std::string, std::string>> vSummary;
658 v_GenerateSummary(vSummary);
659
660 out << "==============================================================="
661 "========"
662 << std::endl
663 << std::flush;
664 for (auto &x : vSummary)
665 {
666 out << "\t";
667 out.width(20);
668 out << x.first << ": " << x.second << std::endl << std::flush;
669 }
670 out << "==============================================================="
671 "========"
672 << std::endl
673 << std::flush;
674 }
675}
virtual SOLVER_UTILS_EXPORT void v_GenerateSummary(SummaryList &l)
Virtual function for generating summary information.

References m_session, and v_GenerateSummary().

◆ ResetSessionName()

SOLVER_UTILS_EXPORT void Nektar::SolverUtils::EquationSystem::ResetSessionName ( std::string  newname)
inline

Reset Session name.

Definition at line 130 of file EquationSystem.h.

131 {
132 m_sessionName = newname;
133 }

References m_sessionName.

◆ SessionSummary()

void Nektar::SolverUtils::EquationSystem::SessionSummary ( SummaryList s)

Write out a session summary.

Write out a summary of the session data.

Parameters
outOutput stream to write data to.

Definition at line 1568 of file EquationSystem.cpp.

1569{
1570 if (m_session->DefinesSolverInfo("EQTYPE"))
1571 {
1572 AddSummaryItem(s, "EquationType", m_session->GetSolverInfo("EQTYPE"));
1573 }
1574 AddSummaryItem(s, "Session Name", m_sessionName);
1575 AddSummaryItem(s, "Spatial Dim.", m_spacedim);
1576 AddSummaryItem(s, "Max SEM Exp. Order",
1577 m_fields[0]->EvalBasisNumModesMax());
1578
1579 if (m_session->GetComm()->GetSize() > 1)
1580 {
1581 AddSummaryItem(s, "Num. Processes", m_session->GetComm()->GetSize());
1582 }
1583
1585 {
1586 AddSummaryItem(s, "Quasi-3D", "Homogeneous in z-direction");
1587 AddSummaryItem(s, "Expansion Dim.", m_expdim + 1);
1588 AddSummaryItem(s, "Num. Hom. Modes (z)", m_npointsZ);
1589 AddSummaryItem(s, "Hom. length (LZ)", m_LhomZ);
1590 AddSummaryItem(s, "FFT Type", m_useFFT ? "FFTW" : "MVM");
1591 if (m_halfMode)
1592 {
1593 AddSummaryItem(s, "ModeType", "Half Mode");
1594 }
1595 else if (m_singleMode)
1596 {
1597 AddSummaryItem(s, "ModeType", "Single Mode");
1598 }
1599 else if (m_multipleModes)
1600 {
1601 AddSummaryItem(s, "ModeType", "Multiple Modes");
1602 }
1603 }
1605 {
1606 AddSummaryItem(s, "Quasi-3D", "Homogeneous in yz-plane");
1607 AddSummaryItem(s, "Expansion Dim.", m_expdim + 2);
1608 AddSummaryItem(s, "Num. Hom. Modes (y)", m_npointsY);
1609 AddSummaryItem(s, "Num. Hom. Modes (z)", m_npointsZ);
1610 AddSummaryItem(s, "Hom. length (LY)", m_LhomY);
1611 AddSummaryItem(s, "Hom. length (LZ)", m_LhomZ);
1612 AddSummaryItem(s, "FFT Type", m_useFFT ? "FFTW" : "MVM");
1613 }
1614 else
1615 {
1616 AddSummaryItem(s, "Expansion Dim.", m_expdim);
1617 }
1618
1619 if (m_session->DefinesSolverInfo("UpwindType"))
1620 {
1621 AddSummaryItem(s, "Riemann Solver",
1622 m_session->GetSolverInfo("UpwindType"));
1623 }
1624
1625 if (m_session->DefinesSolverInfo("AdvectionType"))
1626 {
1627 std::string AdvectionType;
1628 AdvectionType = m_session->GetSolverInfo("AdvectionType");
1630 s, "Advection Type",
1631 GetAdvectionFactory().GetClassDescription(AdvectionType));
1632 }
1633
1634 if (m_session->DefinesSolverInfo("DiffusionType"))
1635 {
1636 std::string DiffusionType;
1637 DiffusionType = m_session->GetSolverInfo("DiffusionType");
1639 s, "Diffusion Type",
1640 GetDiffusionFactory().GetClassDescription(DiffusionType));
1641 }
1642
1644 {
1645 AddSummaryItem(s, "Projection Type", "Continuous Galerkin");
1646 }
1648 {
1649 AddSummaryItem(s, "Projection Type", "Discontinuous Galerkin");
1650 }
1652 {
1653 AddSummaryItem(s, "Projection Type",
1654 "Mixed Continuous Galerkin and Discontinuous");
1655 }
1656}
int m_spacedim
Spatial dimension (>= expansion dim).
bool m_useFFT
Flag to determine if FFT is used for homogeneous transform.
int m_expdim
Expansion dimension.
bool m_multipleModes
Flag to determine if use multiple homogenenous modes are used.
int m_npointsZ
number of points in Z direction (if homogeneous)
NekDouble m_LhomY
physical length in Y direction (if homogeneous)
int m_npointsY
number of points in Y direction (if homogeneous)
bool m_singleMode
Flag to determine if single homogeneous mode is used.
enum HomogeneousType m_HomogeneousType
enum MultiRegions::ProjectionType m_projectionType
Type of projection; e.g continuous or discontinuous.
NekDouble m_LhomZ
physical length in Z direction (if homogeneous)
bool m_halfMode
Flag to determine if half homogeneous mode is used.
AdvectionFactory & GetAdvectionFactory()
Gets the factory for initialising advection objects.
Definition: Advection.cpp:43
DiffusionFactory & GetDiffusionFactory()
Definition: Diffusion.cpp:39
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(), Nektar::MultiRegions::eDiscontinuous, Nektar::MultiRegions::eGalerkin, eHomogeneous1D, eHomogeneous2D, Nektar::MultiRegions::eMixed_CG_Discontinuous, Nektar::SolverUtils::GetAdvectionFactory(), Nektar::SolverUtils::GetDiffusionFactory(), m_expdim, m_fields, m_halfMode, m_HomogeneousType, m_LhomY, m_LhomZ, m_multipleModes, m_npointsY, m_npointsZ, m_projectionType, m_session, m_sessionName, m_singleMode, m_spacedim, and m_useFFT.

Referenced by Nektar::Laplace::v_GenerateSummary(), Nektar::Projection::v_GenerateSummary(), Nektar::LinearElasticSystem::v_GenerateSummary(), and v_GenerateSummary().

◆ SetBoundaryConditions()

void Nektar::SolverUtils::EquationSystem::SetBoundaryConditions ( NekDouble  time)

Evaluates the boundary conditions at the given time.

If boundary conditions are time-dependent, they will be evaluated at the time specified.

Parameters
timeThe time at which to evaluate the BCs

Definition at line 775 of file EquationSystem.cpp.

776{
777 std::string varName;
778 int nvariables = m_fields.size();
779 for (int i = 0; i < nvariables; ++i)
780 {
781 varName = m_session->GetVariable(i);
782 m_fields[i]->EvaluateBoundaryConditions(time, varName);
783 }
784}

References m_fields, and m_session.

Referenced by Nektar::UnsteadyAdvectionDiffusion::DoImplicitSolve(), Nektar::UnsteadyViscousBurgers::DoImplicitSolve(), Nektar::MMFDiffusion::DoImplicitSolve(), Nektar::MMFAdvection::DoOdeProjection(), Nektar::UnsteadyAdvection::DoOdeProjection(), Nektar::UnsteadyDiffusion::DoOdeProjection(), Nektar::UnsteadyInviscidBurgers::DoOdeProjection(), Nektar::ImageWarpingSystem::DoOdeProjection(), Nektar::ShallowWaterSystem::DoOdeProjection(), Nektar::PulseWavePropagation::SetPulseWaveBoundaryConditions(), Nektar::SolverUtils::FileSolution::v_DoInitialise(), Nektar::SolverUtils::UnsteadySystem::v_DoInitialise(), and Nektar::SolverUtils::UnsteadySystem::v_DoSolve().

◆ SetCheckpointNumber()

SOLVER_UTILS_EXPORT void Nektar::SolverUtils::EquationSystem::SetCheckpointNumber ( int  num)
inline

Definition at line 391 of file EquationSystem.h.

392 {
393 m_nchk = num;
394 }

References m_nchk.

◆ SetCheckpointSteps()

SOLVER_UTILS_EXPORT void Nektar::SolverUtils::EquationSystem::SetCheckpointSteps ( int  num)
inline

Definition at line 401 of file EquationSystem.h.

402 {
403 m_checksteps = num;
404 }

References m_checksteps.

◆ SetInfoSteps()

SOLVER_UTILS_EXPORT void Nektar::SolverUtils::EquationSystem::SetInfoSteps ( int  num)
inline

Definition at line 411 of file EquationSystem.h.

412 {
413 m_infosteps = num;
414 }

References m_infosteps.

◆ SetInitialConditions()

SOLVER_UTILS_EXPORT void Nektar::SolverUtils::EquationSystem::SetInitialConditions ( NekDouble  initialtime = 0.0,
bool  dumpInitialConditions = true,
const int  domain = 0 
)
inline

Initialise the data in the dependent fields.

Definition at line 171 of file EquationSystem.h.

174 {
175 v_SetInitialConditions(initialtime, dumpInitialConditions, domain);
176 }
virtual SOLVER_UTILS_EXPORT void v_SetInitialConditions(NekDouble initialtime=0.0, bool dumpInitialConditions=true, const int domain=0)

References v_SetInitialConditions().

Referenced by main(), Nektar::PulseWaveSystem::v_DoInitialise(), Nektar::MMFSWE::v_DoInitialise(), Nektar::SolverUtils::UnsteadySystem::v_DoInitialise(), and Nektar::CoupledLinearNS::v_DoInitialise().

◆ SetInitialStep()

SOLVER_UTILS_EXPORT void Nektar::SolverUtils::EquationSystem::SetInitialStep ( const int  step)
inline

Definition at line 441 of file EquationSystem.h.

442 {
443 m_initialStep = step;
444 }
int m_initialStep
Number of the step where the simulation should begin.

References m_initialStep.

◆ SetIterationNumberPIT()

SOLVER_UTILS_EXPORT void Nektar::SolverUtils::EquationSystem::SetIterationNumberPIT ( int  num)
inline

Definition at line 416 of file EquationSystem.h.

417 {
418 m_iterPIT = num;
419 }

References m_iterPIT.

◆ SetLambda()

SOLVER_UTILS_EXPORT void Nektar::SolverUtils::EquationSystem::SetLambda ( NekDouble  lambda)
inline

Set parameter m_lambda.

Definition at line 158 of file EquationSystem.h.

159 {
160 m_lambda = lambda;
161 }

References m_lambda.

◆ SetModifiedBasis()

SOLVER_UTILS_EXPORT void Nektar::SolverUtils::EquationSystem::SetModifiedBasis ( const bool  modbasis)
inline

◆ SetSteps()

SOLVER_UTILS_EXPORT void Nektar::SolverUtils::EquationSystem::SetSteps ( const int  steps)
inline

Definition at line 361 of file EquationSystem.h.

362 {
363 m_steps = steps;
364 }

References m_steps.

◆ SetTime()

SOLVER_UTILS_EXPORT void Nektar::SolverUtils::EquationSystem::SetTime ( const NekDouble  time)
inline

Definition at line 431 of file EquationSystem.h.

432 {
433 m_time = time;
434 }

References m_time.

◆ SetTimeStep()

SOLVER_UTILS_EXPORT void Nektar::SolverUtils::EquationSystem::SetTimeStep ( const NekDouble  timestep)
inline

Definition at line 436 of file EquationSystem.h.

437 {
438 m_timestep = timestep;
439 }

References m_timestep.

Referenced by Nektar::SolverUtils::UnsteadySystem::SetTimeStep().

◆ SetWindowNumberPIT()

SOLVER_UTILS_EXPORT void Nektar::SolverUtils::EquationSystem::SetWindowNumberPIT ( int  num)
inline

Definition at line 421 of file EquationSystem.h.

422 {
423 m_windowPIT = num;
424 }
int m_windowPIT
Index of windows for parallel-in-time time iteration.

References m_windowPIT.

◆ TransCoeffToPhys()

SOLVER_UTILS_EXPORT void Nektar::SolverUtils::EquationSystem::TransCoeffToPhys ( )
inline

Transform from coefficient to physical space.

Definition at line 101 of file EquationSystem.h.

102 {
104 }
virtual SOLVER_UTILS_EXPORT void v_TransCoeffToPhys()
Virtual function for transformation to physical space.

References v_TransCoeffToPhys().

◆ TransPhysToCoeff()

SOLVER_UTILS_EXPORT void Nektar::SolverUtils::EquationSystem::TransPhysToCoeff ( )
inline

Transform from physical to coefficient space.

Definition at line 107 of file EquationSystem.h.

108 {
110 }
virtual SOLVER_UTILS_EXPORT void v_TransPhysToCoeff()
Virtual function for transformation to coefficient space.

References v_TransPhysToCoeff().

◆ UpdateFieldMetaDataMap()

SOLVER_UTILS_EXPORT LibUtilities::FieldMetaDataMap & Nektar::SolverUtils::EquationSystem::UpdateFieldMetaDataMap ( )
inline

Get hold of FieldInfoMap so it can be updated.

◆ UpdateFields()

Array< OneD, MultiRegions::ExpListSharedPtr > & Nektar::SolverUtils::EquationSystem::UpdateFields ( void  )
inline

Definition at line 677 of file EquationSystem.h.

679{
680 return m_fields;
681}

References m_fields.

◆ UpdatePhysField()

Array< OneD, NekDouble > & Nektar::SolverUtils::EquationSystem::UpdatePhysField ( const int  i)
inline

Definition at line 695 of file EquationSystem.h.

696{
697 return m_fields[i]->UpdatePhys();
698}

References m_fields.

◆ v_DoInitialise()

void Nektar::SolverUtils::EquationSystem::v_DoInitialise ( bool  dumpInitialConditions = true)
protectedvirtual

Virtual function for initialisation implementation.

By default, nothing needs initialising at the EquationSystem level.

Reimplemented in Nektar::VCSImplicit, Nektar::SolverUtils::FileSolution, Nektar::EigenValuesAdvection, Nektar::SteadyAdvectionDiffusion, Nektar::PulseWaveSystem, Nektar::MMFSWE, Nektar::SolverUtils::UnsteadySystem, Nektar::CoupledLinearNS, Nektar::VCSMapping, and Nektar::VelocityCorrectionScheme.

Definition at line 1158 of file EquationSystem.cpp.

1159{
1160}

Referenced by DoInitialise().

◆ v_DoSolve()

void Nektar::SolverUtils::EquationSystem::v_DoSolve ( void  )
protectedvirtual

◆ v_EvaluateExactSolution()

void Nektar::SolverUtils::EquationSystem::v_EvaluateExactSolution ( unsigned int  field,
Array< OneD, NekDouble > &  outfield,
const NekDouble  time 
)
protectedvirtual

Reimplemented in Nektar::MMFAdvection, Nektar::MMFDiffusion, Nektar::MMFMaxwell, Nektar::MMFSWE, and Nektar::CompressibleFlowSystem.

Definition at line 1141 of file EquationSystem.cpp.

1144{
1145 ASSERTL0(outfield.size() == m_fields[field]->GetNpoints(),
1146 "ExactSolution array size mismatch.");
1147 Vmath::Zero(outfield.size(), outfield, 1);
1148 if (m_session->DefinesFunction("ExactSolution"))
1149 {
1150 GetFunction("ExactSolution")
1151 ->Evaluate(m_session->GetVariable(field), outfield, time);
1152 }
1153}
SOLVER_UTILS_EXPORT SessionFunctionSharedPtr GetFunction(std::string name, const MultiRegions::ExpListSharedPtr &field=MultiRegions::NullExpListSharedPtr, bool cache=false)
Get a SessionFunction by name.

References ASSERTL0, FilterPython_Function::field, GetFunction(), m_fields, m_session, and Vmath::Zero().

Referenced by EvaluateExactSolution(), Nektar::MMFDiffusion::v_EvaluateExactSolution(), and Nektar::CompressibleFlowSystem::v_EvaluateExactSolution().

◆ v_ExtraFldOutput()

void Nektar::SolverUtils::EquationSystem::v_ExtraFldOutput ( std::vector< Array< OneD, NekDouble > > &  fieldcoeffs,
std::vector< std::string > &  variables 
)
protectedvirtual

◆ v_GenerateSummary()

void Nektar::SolverUtils::EquationSystem::v_GenerateSummary ( SummaryList l)
protectedvirtual

◆ v_GetPressure()

MultiRegions::ExpListSharedPtr Nektar::SolverUtils::EquationSystem::v_GetPressure ( void  )
protectedvirtual

Reimplemented in Nektar::CompressibleFlowSystem, and Nektar::IncNavierStokes.

Definition at line 1669 of file EquationSystem.cpp.

1670{
1671 ASSERTL0(false, "This function is not valid for the Base class");
1673 return null;
1674}

References ASSERTL0.

Referenced by GetPressure().

◆ v_GetSystemSingularChecks()

Array< OneD, bool > Nektar::SolverUtils::EquationSystem::v_GetSystemSingularChecks ( )
privatevirtual

Reimplemented in Nektar::Helmholtz, Nektar::Laplace, Nektar::Poisson, and Nektar::VelocityCorrectionScheme.

Definition at line 1661 of file EquationSystem.cpp.

1662{
1663 return Array<OneD, bool>(m_session->GetVariables().size(), false);
1664}

References m_session.

Referenced by v_InitObject().

◆ v_H1Error()

NekDouble Nektar::SolverUtils::EquationSystem::v_H1Error ( unsigned int  field,
const Array< OneD, NekDouble > &  exactsoln = NullNekDouble1DArray,
bool  Normalised = false 
)
protectedvirtual

Virtual function for the H_1 error computation between fields and a given exact solution.

Compute the error in the H1-norm.

Parameters
fieldThe field to compare.
exactsolnThe exact solution to compare with.
NormalisedNormalise H1-error.
Returns
Error in the H1-norm.

Definition at line 919 of file EquationSystem.cpp.

922{
923 NekDouble error = -1.0;
924
925 if (m_NumQuadPointsError == 0)
926 {
927 if (m_fields[field]->GetPhysState() == false)
928 {
929 m_fields[field]->BwdTrans(m_fields[field]->GetCoeffs(),
930 m_fields[field]->UpdatePhys());
931 }
932
933 if (exactsoln.size())
934 {
935 error = m_fields[field]->H1(m_fields[field]->GetPhys(), exactsoln);
936 }
937 else if (m_session->DefinesFunction("ExactSolution"))
938 {
939 Array<OneD, NekDouble> exactsoln(m_fields[field]->GetNpoints());
940
941 GetFunction("ExactSolution")
942 ->Evaluate(m_session->GetVariable(field), exactsoln, m_time);
943
944 error = m_fields[field]->H1(m_fields[field]->GetPhys(), exactsoln);
945 }
946 else
947 {
948 error = m_fields[field]->H1(m_fields[field]->GetPhys());
949 }
950
951 if (Normalised == true)
952 {
953 Array<OneD, NekDouble> one(m_fields[field]->GetNpoints(), 1.0);
954
955 NekDouble Vol = m_fields[field]->Integral(one);
956 error = sqrt(error * error / Vol);
957 }
958 }
959 else
960 {
961 Array<OneD, NekDouble> errNorms(3);
962 errNorms = ErrorExtraPoints(field);
963 error = errNorms[2];
964 }
965 return error;
966}
SOLVER_UTILS_EXPORT int GetNpoints()
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].
double NekDouble
scalarT< T > sqrt(scalarT< T > in)
Definition: scalar.hpp:285

References ErrorExtraPoints(), FilterPython_Function::field, GetFunction(), GetNpoints(), m_fields, m_NumQuadPointsError, m_session, m_time, and tinysimd::sqrt().

Referenced by H1Error().

◆ v_InitObject()

void Nektar::SolverUtils::EquationSystem::v_InitObject ( bool  DeclareFeld = true)
protectedvirtual

Initialisation object for EquationSystem.

Continuous field

Setting up the normals

Setting up the normals

Reimplemented in DummyEquationSystem, Nektar::PulseWavePropagation, Nektar::PulseWaveSystem, Nektar::SolverUtils::AdvectionSystem, Nektar::SolverUtils::UnsteadySystem, Nektar::Bidomain, Nektar::BidomainRoth, Nektar::Monodomain, Nektar::NavierStokesCFE, Nektar::MMFDiffusion, Nektar::ImageWarpingSystem, Nektar::CoupledLinearNS, Nektar::IncNavierStokes, Nektar::SmoothedProfileMethod, Nektar::VCSMapping, Nektar::VelocityCorrectionScheme, Nektar::SolverUtils::FileSolution, Nektar::AcousticSystem, Nektar::APE, Nektar::LEE, Nektar::EigenValuesAdvection, Nektar::Helmholtz, Nektar::Laplace, Nektar::MMFAdvection, Nektar::Poisson, Nektar::Projection, Nektar::SteadyAdvectionDiffusion, Nektar::SteadyAdvectionDiffusionReaction, Nektar::UnsteadyAdvection, Nektar::UnsteadyAdvectionDiffusion, Nektar::UnsteadyDiffusion, Nektar::UnsteadyInviscidBurgers, Nektar::UnsteadyReactionDiffusion, Nektar::UnsteadyViscousBurgers, Nektar::CompressibleFlowSystem, Nektar::CFSImplicit, Nektar::EulerCFE, Nektar::EulerImplicitCFE, Nektar::NavierStokesCFEAxisym, Nektar::NavierStokesImplicitCFE, Nektar::Dummy, Nektar::IterativeElasticSystem, Nektar::LinearElasticSystem, Nektar::MMFMaxwell, Nektar::LinearSWE, Nektar::MMFSWE, Nektar::NonlinearPeregrine, Nektar::NonlinearSWE, and Nektar::ShallowWaterSystem.

Definition at line 143 of file EquationSystem.cpp.

144{
145 // Save the basename of input file name for output details
146 m_sessionName = m_session->GetSessionName();
147
148 // Instantiate a field reader/writer
150
151 // Also read and store the boundary conditions
155
156 // Set space dimension for use in class
157 m_spacedim = m_graph->GetSpaceDimension();
158
159 // Setting parameteres for homogenous problems
160 m_HomoDirec = 0;
161 m_useFFT = false;
162 m_homogen_dealiasing = false;
163 m_singleMode = false;
164 m_halfMode = false;
165 m_multipleModes = false;
167
168 m_verbose = m_session->DefinesCmdLineArgument("verbose");
169
170 if (m_session->DefinesSolverInfo("HOMOGENEOUS"))
171 {
172 std::string HomoStr = m_session->GetSolverInfo("HOMOGENEOUS");
173 m_spacedim = 3;
174
175 if ((HomoStr == "HOMOGENEOUS1D") || (HomoStr == "Homogeneous1D") ||
176 (HomoStr == "1D") || (HomoStr == "Homo1D"))
177 {
179 m_session->LoadParameter("LZ", m_LhomZ);
180 m_HomoDirec = 1;
181
182 if (m_session->DefinesSolverInfo("ModeType"))
183 {
184 m_session->MatchSolverInfo("ModeType", "SingleMode",
185 m_singleMode, false);
186 m_session->MatchSolverInfo("ModeType", "HalfMode", m_halfMode,
187 false);
188 m_session->MatchSolverInfo("ModeType", "MultipleModes",
189 m_multipleModes, false);
190 }
191
192 // Stability Analysis flags
193 if (m_session->DefinesSolverInfo("ModeType"))
194 {
195 if (m_singleMode)
196 {
197 m_npointsZ = 2;
198 }
199 else if (m_halfMode)
200 {
201 m_npointsZ = 1;
202 }
203 else if (m_multipleModes)
204 {
205 m_npointsZ = m_session->GetParameter("HomModesZ");
206 }
207 else
208 {
209 ASSERTL0(false, "SolverInfo ModeType not valid");
210 }
211 }
212 else
213 {
214 m_npointsZ = m_session->GetParameter("HomModesZ");
215 }
216 }
217
218 if ((HomoStr == "HOMOGENEOUS2D") || (HomoStr == "Homogeneous2D") ||
219 (HomoStr == "2D") || (HomoStr == "Homo2D"))
220 {
222 m_session->LoadParameter("HomModesY", m_npointsY);
223 m_session->LoadParameter("LY", m_LhomY);
224 m_session->LoadParameter("HomModesZ", m_npointsZ);
225 m_session->LoadParameter("LZ", m_LhomZ);
226 m_HomoDirec = 2;
227 }
228
229 if ((HomoStr == "HOMOGENEOUS3D") || (HomoStr == "Homogeneous3D") ||
230 (HomoStr == "3D") || (HomoStr == "Homo3D"))
231 {
233 m_session->LoadParameter("HomModesY", m_npointsY);
234 m_session->LoadParameter("LY", m_LhomY);
235 m_session->LoadParameter("HomModesZ", m_npointsZ);
236 m_session->LoadParameter("LZ", m_LhomZ);
237 m_HomoDirec = 2;
238 }
239
240 m_session->MatchSolverInfo("USEFFT", "FFTW", m_useFFT, false);
241
242 m_session->MatchSolverInfo("DEALIASING", "True", m_homogen_dealiasing,
243 false);
244 }
245 else
246 {
247 // set to default value so can use to identify 2d or 3D
248 // (homogeneous) expansions
249 m_npointsZ = 1;
250 }
251
252 m_session->MatchSolverInfo("SPECTRALHPDEALIASING", "True",
253 m_specHP_dealiasing, false);
254 if (m_specHP_dealiasing == false)
255 {
256 m_session->MatchSolverInfo("SPECTRALHPDEALIASING", "On",
257 m_specHP_dealiasing, false);
258 }
259
260 // Options to determine type of projection from file or directly
261 // from constructor
262 if (m_session->DefinesSolverInfo("PROJECTION"))
263 {
264 std::string ProjectStr = m_session->GetSolverInfo("PROJECTION");
265
266 if ((ProjectStr == "Continuous") || (ProjectStr == "Galerkin") ||
267 (ProjectStr == "CONTINUOUS") || (ProjectStr == "GALERKIN"))
268 {
270 }
271 else if ((ProjectStr == "MixedCGDG") ||
272 (ProjectStr == "Mixed_CG_Discontinuous"))
273 {
275 }
276 else if (ProjectStr == "DisContinuous")
277 {
279 }
280 else
281 {
282 ASSERTL0(false, "PROJECTION value not recognised");
283 }
284 }
285 else
286 {
287 cerr << "Projection type not specified in SOLVERINFO,"
288 "defaulting to continuous Galerkin"
289 << endl;
291 }
292
293 // Enforce singularity check for some problems
295
296 int i;
297 int nvariables = m_session->GetVariables().size();
298 bool DeclareCoeffPhysArrays = true;
299
300 m_fields = Array<OneD, MultiRegions::ExpListSharedPtr>(nvariables);
301 m_spacedim = m_graph->GetSpaceDimension() + m_HomoDirec;
302 m_expdim = m_graph->GetMeshDimension();
303
304 if (DeclareFields) // declare field if required
305 {
306 /// Continuous field
309 {
310 switch (m_expdim)
311 {
312 case 1:
313 {
316 {
317 const LibUtilities::PointsKey PkeyY(
319 const LibUtilities::BasisKey BkeyY(
321 const LibUtilities::PointsKey PkeyZ(
323 const LibUtilities::BasisKey BkeyZ(
325
326 for (i = 0; i < m_fields.size(); i++)
327 {
328 m_fields[i] = MemoryManager<
329 MultiRegions::ContField3DHomogeneous2D>::
330 AllocateSharedPtr(m_session, BkeyY, BkeyZ,
333 m_session->GetVariable(i));
334 }
335 }
336 else
337 {
338 for (i = 0; i < m_fields.size(); i++)
339 {
340 m_fields[i] =
344 m_session->GetVariable(i));
345 }
346 }
347 break;
348 }
349 case 2:
350 {
352 {
353 // Fourier single mode stability analysis
354 if (m_singleMode)
355 {
356 const LibUtilities::PointsKey PkeyZ(
359
360 const LibUtilities::BasisKey BkeyZ(
362 PkeyZ);
363
364 for (i = 0; i < m_fields.size(); i++)
365 {
366 m_fields[i] = MemoryManager<
367 MultiRegions::ContField3DHomogeneous1D>::
368 AllocateSharedPtr(
369 m_session, BkeyZ, m_LhomZ, m_useFFT,
371 m_session->GetVariable(i),
373 }
374 }
375 // Half mode stability analysis
376 else if (m_halfMode)
377 {
378 const LibUtilities::PointsKey PkeyZ(
381
382 const LibUtilities::BasisKey BkeyZR(
384 PkeyZ);
385
386 const LibUtilities::BasisKey BkeyZI(
388 PkeyZ);
389
390 for (i = 0; i < m_fields.size(); i++)
391 {
392 if (m_session->GetVariable(i).compare("w") == 0)
393 {
394 m_fields[i] = MemoryManager<
395 MultiRegions::
396 ContField3DHomogeneous1D>::
397 AllocateSharedPtr(
398 m_session, BkeyZI, m_LhomZ,
400 m_graph, m_session->GetVariable(i),
402 }
403 else
404 {
405 m_fields[i] = MemoryManager<
406 MultiRegions::
407 ContField3DHomogeneous1D>::
408 AllocateSharedPtr(
409 m_session, BkeyZR, m_LhomZ,
411 m_graph, m_session->GetVariable(i),
413 }
414 }
415 }
416 // Normal homogeneous 1D
417 else
418 {
419 const LibUtilities::PointsKey PkeyZ(
421 const LibUtilities::BasisKey BkeyZ(
423
424 for (i = 0; i < m_fields.size(); i++)
425 {
426 m_fields[i] = MemoryManager<
427 MultiRegions::ContField3DHomogeneous1D>::
428 AllocateSharedPtr(
429 m_session, BkeyZ, m_LhomZ, m_useFFT,
431 m_session->GetVariable(i),
433 }
434 }
435 }
436 else
437 {
438 i = 0;
442 m_session->GetVariable(i),
443 DeclareCoeffPhysArrays,
445 m_fields[0] = firstfield;
446 for (i = 1; i < m_fields.size(); i++)
447 {
448 if (m_graph->SameExpansionInfo(
449 m_session->GetVariable(0),
450 m_session->GetVariable(i)))
451 {
452 m_fields[i] =
455 *firstfield, m_graph,
456 m_session->GetVariable(i),
457 DeclareCoeffPhysArrays,
459 }
460 else
461 {
462 m_fields[i] =
466 m_session->GetVariable(i),
467 DeclareCoeffPhysArrays,
469 }
470 }
471
472 if (m_projectionType ==
474 {
475 /// Setting up the normals
477 Array<OneD, Array<OneD, NekDouble>>(m_spacedim);
478
479 for (i = 0; i < m_spacedim; ++i)
480 {
481 m_traceNormals[i] =
482 Array<OneD, NekDouble>(GetTraceNpoints());
483 }
484
485 m_fields[0]->GetTrace()->GetNormals(m_traceNormals);
486 }
487 }
488
489 break;
490 }
491 case 3:
492 {
493 i = 0;
497 m_session->GetVariable(i),
498 DeclareCoeffPhysArrays,
500
501 m_fields[0] = firstfield;
502 for (i = 1; i < m_fields.size(); i++)
503 {
504 if (m_graph->SameExpansionInfo(
505 m_session->GetVariable(0),
506 m_session->GetVariable(i)))
507 {
508 m_fields[i] =
511 *firstfield, m_graph,
512 m_session->GetVariable(i),
513 DeclareCoeffPhysArrays,
515 }
516 else
517 {
518 m_fields[i] =
522 m_session->GetVariable(i),
523 DeclareCoeffPhysArrays,
525 }
526 }
527
528 if (m_projectionType ==
530 {
531 /// Setting up the normals
533 Array<OneD, Array<OneD, NekDouble>>(m_spacedim);
534 for (i = 0; i < m_spacedim; ++i)
535 {
536 m_traceNormals[i] =
537 Array<OneD, NekDouble>(GetTraceNpoints());
538 }
539
540 m_fields[0]->GetTrace()->GetNormals(m_traceNormals);
541 // Call the trace on all fields to ensure DG setup.
542 for (i = 1; i < m_fields.size(); ++i)
543 {
544 m_fields[i]->GetTrace();
545 }
546 }
547 break;
548 }
549 default:
550 ASSERTL0(false, "Expansion dimension not recognised");
551 break;
552 }
553 }
554 // Discontinuous field
555 else
556 {
557 switch (m_expdim)
558 {
559 case 1:
560 {
563 {
564 const LibUtilities::PointsKey PkeyY(
566 const LibUtilities::BasisKey BkeyY(
568 const LibUtilities::PointsKey PkeyZ(
570 const LibUtilities::BasisKey BkeyZ(
572
573 for (i = 0; i < m_fields.size(); i++)
574 {
575 m_fields[i] = MemoryManager<
576 MultiRegions::DisContField3DHomogeneous2D>::
577 AllocateSharedPtr(m_session, BkeyY, BkeyZ,
580 m_session->GetVariable(i));
581 }
582 }
583 else
584 {
585 for (i = 0; i < m_fields.size(); i++)
586 {
587 m_fields[i] =
591 m_session->GetVariable(i));
592 }
593 }
594
595 break;
596 }
597 case 2:
598 {
600 {
601 const LibUtilities::PointsKey PkeyZ(
603 const LibUtilities::BasisKey BkeyZ(
605
606 for (i = 0; i < m_fields.size(); i++)
607 {
608 m_fields[i] = MemoryManager<
609 MultiRegions::DisContField3DHomogeneous1D>::
610 AllocateSharedPtr(m_session, BkeyZ, m_LhomZ,
611 m_useFFT,
613 m_session->GetVariable(i));
614 }
615 }
616 else
617 {
618 i = 0;
622 m_session->GetVariable(i));
623 m_fields[0] = firstfield;
624 for (i = 1; i < m_fields.size(); i++)
625 {
626 if (m_graph->SameExpansionInfo(
627 m_session->GetVariable(0),
628 m_session->GetVariable(i)))
629 {
630 m_fields[i] =
633 *firstfield, m_graph,
634 m_session->GetVariable(i));
635 }
636 else
637 {
638 m_fields[i] =
642 m_session->GetVariable(i));
643 }
644 }
645 }
646
647 break;
648 }
649 case 3:
650 {
652 {
653 ASSERTL0(
654 false,
655 "3D fully periodic problems not implemented yet");
656 }
657 else
658 {
659 i = 0;
663 m_session->GetVariable(i));
664 m_fields[0] = firstfield;
665 for (i = 1; i < m_fields.size(); i++)
666 {
667 if (m_graph->SameExpansionInfo(
668 m_session->GetVariable(0),
669 m_session->GetVariable(i)))
670 {
671 m_fields[i] =
674 *firstfield, m_graph,
675 m_session->GetVariable(i));
676 }
677 else
678 {
679 m_fields[i] =
683 m_session->GetVariable(i));
684 }
685 }
686 }
687 break;
688 }
689 default:
690 ASSERTL0(false, "Expansion dimension not recognised");
691 break;
692 }
693
694 // Setting up the normals
695 m_traceNormals = Array<OneD, Array<OneD, NekDouble>>(m_spacedim);
696
697 for (i = 0; i < m_spacedim; ++i)
698 {
699 m_traceNormals[i] =
700 Array<OneD, NekDouble>(GetTraceNpoints(), 0.0);
701 }
702
703 m_fields[0]->GetTrace()->GetNormals(m_traceNormals);
704 }
705 // Zero all physical fields initially
707 }
708
709 // Set Default Parameter
710 m_session->LoadParameter("Time", m_time, 0.0);
711 m_session->LoadParameter("TimeStep", m_timestep, 0.0);
712 m_session->LoadParameter("NumSteps", m_steps, 0);
713 m_session->LoadParameter("IO_CheckSteps", m_checksteps, 0);
714 m_session->LoadParameter("IO_CheckTime", m_checktime, 0.0);
715 m_session->LoadParameter("FinTime", m_fintime, 0);
716 m_session->LoadParameter("NumQuadPointsError", m_NumQuadPointsError, 0);
717
718 // Check uniqueness of checkpoint output
719 ASSERTL0((m_checktime == 0.0 && m_checksteps == 0) ||
720 (m_checktime > 0.0 && m_checksteps == 0) ||
721 (m_checktime == 0.0 && m_checksteps > 0),
722 "Only one of IO_CheckTime and IO_CheckSteps "
723 "should be set!");
724 m_session->LoadParameter("TimeIncrementFactor", m_TimeIncrementFactor, 1.0);
725
726 // Check for parallel-in-time
727 if (m_comm->IsParallelInTime())
728 {
729 ASSERTL0(m_fintime == 0.0,
730 "Only specify NumSteps and TimeSteps for Parallel-in-Time. "
731 "FinTime should not be used! ");
732 }
733
734 m_nchk = 0;
735 m_iterPIT = 0;
736}
static std::shared_ptr< FieldIO > CreateDefault(const LibUtilities::SessionReaderSharedPtr session)
Returns an object for the default FieldIO method.
Definition: FieldIO.cpp:194
LibUtilities::FieldIOSharedPtr m_fld
Field input/output.
NekDouble m_fintime
Finish time of the simulation.
NekDouble m_checktime
Time between checkpoints.
bool m_specHP_dealiasing
Flag to determine if dealisising is usde for the Spectral/hp element discretisation.
SOLVER_UTILS_EXPORT void ZeroPhysFields()
int m_HomoDirec
number of homogenous directions
Array< OneD, bool > m_checkIfSystemSingular
Flag to indicate if the fields should be checked for singularity.
bool m_homogen_dealiasing
Flag to determine if dealiasing is used for homogeneous simulations.
virtual SOLVER_UTILS_EXPORT Array< OneD, bool > v_GetSystemSingularChecks()
SpatialDomains::BoundaryConditionsSharedPtr m_boundaryConditions
Pointer to boundary conditions object.
@ eFourierEvenlySpaced
1D Evenly-spaced points using Fourier Fit
Definition: PointsType.h:74
@ eFourierSingleModeSpaced
1D Non Evenly-spaced points for Single Mode analysis
Definition: PointsType.h:75
@ eFourierSingleMode
Fourier ModifiedExpansion with just the first mode .
Definition: BasisType.h:64
@ eFourierHalfModeIm
Fourier Modified expansions with just the imaginary part of the first mode .
Definition: BasisType.h:68
@ eFourierHalfModeRe
Fourier Modified expansions with just the real part of the first mode .
Definition: BasisType.h:66
@ eFourier
Fourier Expansion .
Definition: BasisType.h:55
std::shared_ptr< DisContField > DisContFieldSharedPtr
Definition: DisContField.h:346
std::shared_ptr< ContField > ContFieldSharedPtr
Definition: ContField.h:268

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, Nektar::LibUtilities::FieldIO::CreateDefault(), Nektar::MultiRegions::eDiscontinuous, Nektar::LibUtilities::eFourier, Nektar::LibUtilities::eFourierEvenlySpaced, Nektar::LibUtilities::eFourierHalfModeIm, Nektar::LibUtilities::eFourierHalfModeRe, Nektar::LibUtilities::eFourierSingleMode, Nektar::LibUtilities::eFourierSingleModeSpaced, Nektar::MultiRegions::eGalerkin, eHomogeneous1D, eHomogeneous2D, eHomogeneous3D, Nektar::MultiRegions::eMixed_CG_Discontinuous, eNotHomogeneous, GetTraceNpoints(), m_boundaryConditions, m_checkIfSystemSingular, m_checksteps, m_checktime, m_comm, m_expdim, m_fields, m_fintime, m_fld, m_graph, m_halfMode, m_HomoDirec, m_homogen_dealiasing, m_HomogeneousType, m_iterPIT, m_LhomY, m_LhomZ, m_multipleModes, m_nchk, m_npointsY, m_npointsZ, m_NumQuadPointsError, m_projectionType, m_session, m_sessionName, m_singleMode, m_spacedim, m_specHP_dealiasing, m_steps, m_time, m_TimeIncrementFactor, m_timestep, m_traceNormals, m_useFFT, m_verbose, v_GetSystemSingularChecks(), and ZeroPhysFields().

Referenced by InitObject(), Nektar::SolverUtils::UnsteadySystem::v_InitObject(), Nektar::EigenValuesAdvection::v_InitObject(), Nektar::Laplace::v_InitObject(), Nektar::Projection::v_InitObject(), Nektar::SteadyAdvectionDiffusion::v_InitObject(), and Nektar::LinearElasticSystem::v_InitObject().

◆ v_L2Error()

NekDouble Nektar::SolverUtils::EquationSystem::v_L2Error ( unsigned int  field,
const Array< OneD, NekDouble > &  exactsoln = NullNekDouble1DArray,
bool  Normalised = false 
)
protectedvirtual

Virtual function for the L_2 error computation between fields and a given exact solution.

Compute the error in the L2-norm.

Parameters
fieldThe field to compare.
exactsolnThe exact solution to compare with.
NormalisedNormalise L2-error.
Returns
Error in the L2-norm.

Reimplemented in Nektar::MMFSWE, and Nektar::PulseWaveSystem.

Definition at line 793 of file EquationSystem.cpp.

796{
797 NekDouble L2error = -1.0;
798
799 if (m_NumQuadPointsError == 0)
800 {
801 if (m_fields[field]->GetPhysState() == false)
802 {
803 m_fields[field]->BwdTrans(m_fields[field]->GetCoeffs(),
804 m_fields[field]->UpdatePhys());
805 }
806
807 // Transform from (phys, wave) -> (phys, phys), for 2.5D
808 bool physwavetrans = false;
809 if (m_fields[field]->GetWaveSpace() == true)
810 {
811 m_fields[field]->HomogeneousBwdTrans(
812 m_fields[field]->GetTotPoints(), m_fields[field]->GetPhys(),
813 m_fields[field]->UpdatePhys());
814 physwavetrans = true;
815 }
816
817 if (exactsoln.size())
818 {
819 L2error =
820 m_fields[field]->L2(m_fields[field]->GetPhys(), exactsoln);
821 }
822 else if (m_session->DefinesFunction("ExactSolution"))
823 {
824 Array<OneD, NekDouble> exactsoln(m_fields[field]->GetNpoints());
825
826 GetFunction("ExactSolution")
827 ->Evaluate(m_session->GetVariable(field), exactsoln, m_time);
828
829 L2error =
830 m_fields[field]->L2(m_fields[field]->GetPhys(), exactsoln);
831 }
832 else
833 {
834 L2error = m_fields[field]->L2(m_fields[field]->GetPhys());
835 }
836
837 if (Normalised == true)
838 {
839 Array<OneD, NekDouble> one(m_fields[field]->GetNpoints(), 1.0);
840
841 NekDouble Vol = m_fields[field]->Integral(one);
842 L2error = sqrt(L2error * L2error / Vol);
843 }
844
845 // Transform from (phys, phys) -> (phys, wave), for 2.5D
846 if (physwavetrans == true)
847 {
848 m_fields[field]->HomogeneousFwdTrans(
849 m_fields[field]->GetTotPoints(), m_fields[field]->GetPhys(),
850 m_fields[field]->UpdatePhys());
851 physwavetrans = false;
852 }
853 }
854 else
855 {
856 Array<OneD, NekDouble> errNorms(3);
857 errNorms = ErrorExtraPoints(field);
858 L2error = errNorms[0];
859 }
860 return L2error;
861}
SOLVER_UTILS_EXPORT int GetTotPoints()

References ErrorExtraPoints(), FilterPython_Function::field, GetFunction(), GetNpoints(), GetTotPoints(), m_fields, m_NumQuadPointsError, m_session, m_time, and tinysimd::sqrt().

Referenced by L2Error().

◆ v_LinfError()

NekDouble Nektar::SolverUtils::EquationSystem::v_LinfError ( unsigned int  field,
const Array< OneD, NekDouble > &  exactsoln = NullNekDouble1DArray 
)
protectedvirtual

Virtual function for the L_inf error computation between fields and a given exact solution.

Compute the error in the L_inf-norm

Parameters
fieldThe field to compare.
exactsolnThe exact solution to compare with.
Returns
Error in the L_inft-norm.

Reimplemented in Nektar::MMFSWE, and Nektar::PulseWaveSystem.

Definition at line 869 of file EquationSystem.cpp.

871{
872 NekDouble Linferror = -1.0;
873
874 if (m_NumQuadPointsError == 0)
875 {
876 if (m_fields[field]->GetPhysState() == false)
877 {
878 m_fields[field]->BwdTrans(m_fields[field]->GetCoeffs(),
879 m_fields[field]->UpdatePhys());
880 }
881
882 if (exactsoln.size())
883 {
884 Linferror =
885 m_fields[field]->Linf(m_fields[field]->GetPhys(), exactsoln);
886 }
887 else if (m_session->DefinesFunction("ExactSolution"))
888 {
889 Array<OneD, NekDouble> exactsoln(m_fields[field]->GetNpoints());
890
891 GetFunction("ExactSolution")
892 ->Evaluate(m_session->GetVariable(field), exactsoln, m_time);
893
894 Linferror =
895 m_fields[field]->Linf(m_fields[field]->GetPhys(), exactsoln);
896 }
897 else
898 {
899 Linferror = m_fields[field]->Linf(m_fields[field]->GetPhys());
900 }
901 }
902 else
903 {
904 Array<OneD, NekDouble> errNorms(3);
905 errNorms = ErrorExtraPoints(field);
906 Linferror = errNorms[1];
907 }
908
909 return Linferror;
910}

References ErrorExtraPoints(), FilterPython_Function::field, GetFunction(), GetNpoints(), m_fields, m_NumQuadPointsError, m_session, and m_time.

Referenced by LinfError().

◆ v_NegatedOp()

bool Nektar::SolverUtils::EquationSystem::v_NegatedOp ( void  )
protectedvirtual

Virtual function to identify if operator is negated in DoSolve.

Virtual function to define if operator in DoSolve is negated with regard to the strong form. This is currently only used in Arnoldi solves. Default is false.

Reimplemented in Nektar::CoupledLinearNS.

Definition at line 1174 of file EquationSystem.cpp.

1175{
1176 return false;
1177}

Referenced by NegatedOp().

◆ v_Output()

void Nektar::SolverUtils::EquationSystem::v_Output ( void  )
protectedvirtual

Write the field data to file. The file is named according to the session name with the extension .fld appended.

Reimplemented in Nektar::AcousticSystem, Nektar::Dummy, Nektar::CoupledLinearNS, and Nektar::PulseWaveSystem.

Definition at line 1203 of file EquationSystem.cpp.

1204{
1205 if (!m_comm->IsParallelInTime())
1206 {
1207 // Serial-in-time
1208 WriteFld(m_sessionName + ".fld");
1209 }
1210 else
1211 {
1212 // Parallel-in-time
1213 std::string newdir = m_sessionName + ".pit";
1214 if (!fs::is_directory(newdir))
1215 {
1216 fs::create_directory(newdir);
1217 }
1218 WriteFld(newdir + "/" + m_sessionName + "_" +
1219 std::to_string(m_windowPIT * m_comm->GetTimeComm()->GetSize() +
1220 m_comm->GetTimeComm()->GetRank() + 1) +
1221 ".fld");
1222 }
1223}

References m_comm, m_sessionName, m_windowPIT, and WriteFld().

Referenced by Output(), Nektar::AcousticSystem::v_Output(), and Nektar::Dummy::v_Output().

◆ v_SetInitialConditions()

void Nektar::SolverUtils::EquationSystem::v_SetInitialConditions ( NekDouble  initialtime = 0.0,
bool  dumpInitialConditions = true,
const int  domain = 0 
)
protectedvirtual

Set the physical fields based on a restart file, or a function describing the initial condition given in the session.

Parameters
initialtimeTime at which to evaluate the function.
dumpInitialConditionsWrite the initial condition to file?

Reimplemented in Nektar::MMFAdvection, Nektar::MMFMaxwell, Nektar::MMFSWE, Nektar::Bidomain, Nektar::BidomainRoth, Nektar::Monodomain, Nektar::CompressibleFlowSystem, Nektar::MMFDiffusion, and Nektar::NonlinearPeregrine.

Definition at line 1063 of file EquationSystem.cpp.

1066{
1067 if (m_session->GetComm()->GetRank() == 0)
1068 {
1069 cout << "Initial Conditions:" << endl;
1070 }
1071
1072 if (m_session->DefinesFunction("InitialConditions"))
1073 {
1074 GetFunction("InitialConditions")
1075 ->Evaluate(m_session->GetVariables(), m_fields, m_time, domain);
1076 // Enforce C0 Continutiy of initial condiiton
1079 {
1080 for (int i = 0; i < m_fields.size(); ++i)
1081 {
1082 m_fields[i]->LocalToGlobal();
1083 m_fields[i]->GlobalToLocal();
1084 m_fields[i]->BwdTrans(m_fields[i]->GetCoeffs(),
1085 m_fields[i]->UpdatePhys());
1086 }
1087 }
1088
1089 if (m_session->GetComm()->GetRank() == 0)
1090 {
1091 for (int i = 0; i < m_fields.size(); ++i)
1092 {
1093 std::string varName = m_session->GetVariable(i);
1094 cout << " - Field " << varName << ": "
1095 << GetFunction("InitialConditions")
1096 ->Describe(varName, domain)
1097 << endl;
1098 }
1099 }
1100 }
1101 else
1102 {
1103 int nq = m_fields[0]->GetNpoints();
1104 for (int i = 0; i < m_fields.size(); i++)
1105 {
1106 Vmath::Zero(nq, m_fields[i]->UpdatePhys(), 1);
1107 m_fields[i]->SetPhysState(true);
1108 Vmath::Zero(m_fields[i]->GetNcoeffs(), m_fields[i]->UpdateCoeffs(),
1109 1);
1110 if (m_session->GetComm()->GetRank() == 0)
1111 {
1112 cout << " - Field " << m_session->GetVariable(i)
1113 << ": 0 (default)" << endl;
1114 }
1115 }
1116 }
1117
1118 if (dumpInitialConditions && m_checksteps && m_nchk == 0 &&
1119 !m_comm->IsParallelInTime())
1120 {
1122 }
1123 else if (dumpInitialConditions && m_nchk == 0 && m_comm->IsParallelInTime())
1124 {
1125 std::string newdir = m_sessionName + ".pit";
1126 if (!fs::is_directory(newdir))
1127 {
1128 fs::create_directory(newdir);
1129 }
1130 if (m_comm->GetTimeComm()->GetRank() == 0)
1131 {
1132 WriteFld(newdir + "/" + m_sessionName + "_0.fld");
1133 }
1134 }
1135 ++m_nchk;
1136}
SOLVER_UTILS_EXPORT void Checkpoint_Output(const int n)
Write checkpoint file of m_fields.

References Checkpoint_Output(), Nektar::MultiRegions::eGalerkin, Nektar::MultiRegions::eMixed_CG_Discontinuous, GetFunction(), GetNcoeffs(), m_checksteps, m_comm, m_fields, m_nchk, m_projectionType, m_session, m_sessionName, m_time, WriteFld(), and Vmath::Zero().

Referenced by SetInitialConditions(), Nektar::Bidomain::v_SetInitialConditions(), Nektar::BidomainRoth::v_SetInitialConditions(), Nektar::Monodomain::v_SetInitialConditions(), Nektar::CompressibleFlowSystem::v_SetInitialConditions(), Nektar::MMFDiffusion::v_SetInitialConditions(), and Nektar::NonlinearPeregrine::v_SetInitialConditions().

◆ v_TransCoeffToPhys()

void Nektar::SolverUtils::EquationSystem::v_TransCoeffToPhys ( void  )
protectedvirtual

Virtual function for transformation to physical space.

Reimplemented in Nektar::CoupledLinearNS, Nektar::IncNavierStokes, and Nektar::VelocityCorrectionScheme.

Definition at line 1182 of file EquationSystem.cpp.

1183{
1184}

Referenced by TransCoeffToPhys().

◆ v_TransPhysToCoeff()

void Nektar::SolverUtils::EquationSystem::v_TransPhysToCoeff ( void  )
protectedvirtual

Virtual function for transformation to coefficient space.

Reimplemented in Nektar::CoupledLinearNS, Nektar::IncNavierStokes, and Nektar::VelocityCorrectionScheme.

Definition at line 1189 of file EquationSystem.cpp.

1190{
1191}

Referenced by TransPhysToCoeff().

◆ WriteFld() [1/2]

void Nektar::SolverUtils::EquationSystem::WriteFld ( const std::string &  outname)

Write field data to the given filename.

Writes the field data to a file with the given filename.

Parameters
outnameFilename to write to.

Definition at line 1315 of file EquationSystem.cpp.

1316{
1317 std::vector<Array<OneD, NekDouble>> fieldcoeffs(m_fields.size());
1318 std::vector<std::string> variables(m_fields.size());
1319
1320 for (int i = 0; i < m_fields.size(); ++i)
1321 {
1322 if (m_fields[i]->GetNcoeffs() == m_fields[0]->GetNcoeffs())
1323 {
1324 fieldcoeffs[i] = m_fields[i]->UpdateCoeffs();
1325 }
1326 else
1327 {
1328 fieldcoeffs[i] = Array<OneD, NekDouble>(m_fields[0]->GetNcoeffs());
1329 m_fields[0]->ExtractCoeffsToCoeffs(
1330 m_fields[i], m_fields[i]->GetCoeffs(), fieldcoeffs[i]);
1331 }
1332 variables[i] = m_boundaryConditions->GetVariable(i);
1333 }
1334
1335 ExtraFldOutput(fieldcoeffs, variables);
1336
1337 WriteFld(outname, m_fields[0], fieldcoeffs, variables);
1338}
SOLVER_UTILS_EXPORT void ExtraFldOutput(std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables)

References ExtraFldOutput(), GetNcoeffs(), m_boundaryConditions, m_fields, and WriteFld().

Referenced by Checkpoint_BaseFlow(), Nektar::MMFMaxwell::Checkpoint_EDFluxOutput(), Nektar::MMFMaxwell::Checkpoint_EnergyOutput(), Checkpoint_Output(), Nektar::MMFSWE::Checkpoint_Output_Cartesian(), Nektar::MMFMaxwell::Checkpoint_PlotOutput(), Nektar::MMFMaxwell::Checkpoint_TotalFieldOutput(), Nektar::MMFMaxwell::Checkpoint_TotPlotOutput(), Nektar::BidomainRoth::v_InitObject(), Nektar::Monodomain::v_InitObject(), v_Output(), Nektar::CoupledLinearNS::v_Output(), Nektar::SolverUtils::AdvectionSystem::v_PostIntegrate(), Nektar::MMFAdvection::v_SetInitialConditions(), Nektar::MMFMaxwell::v_SetInitialConditions(), Nektar::MMFSWE::v_SetInitialConditions(), v_SetInitialConditions(), Nektar::CompressibleFlowSystem::v_SetInitialConditions(), Nektar::MMFDiffusion::v_SetInitialConditions(), Nektar::NonlinearPeregrine::v_SetInitialConditions(), and WriteFld().

◆ WriteFld() [2/2]

void Nektar::SolverUtils::EquationSystem::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.

Writes the field data to a file with the given filename.

Parameters
outnameFilename to write to.
fieldExpList on which data is based.
fieldcoeffsAn array of array of expansion coefficients.
variablesAn array of variable names.

Definition at line 1347 of file EquationSystem.cpp.

1351{
1352 std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef =
1353 field->GetFieldDefinitions();
1354 std::vector<std::vector<NekDouble>> FieldData(FieldDef.size());
1355
1356 // Copy Data into FieldData and set variable
1357 for (int j = 0; j < fieldcoeffs.size(); ++j)
1358 {
1359 for (int i = 0; i < FieldDef.size(); ++i)
1360 {
1361 // Could do a search here to find correct variable
1362 FieldDef[i]->m_fields.push_back(variables[j]);
1363 field->AppendFieldData(FieldDef[i], FieldData[i], fieldcoeffs[j]);
1364 }
1365 }
1366
1367 // Update time in field info if required
1368 if (m_fieldMetaDataMap.find("Time") != m_fieldMetaDataMap.end())
1369 {
1370 m_fieldMetaDataMap["Time"] = boost::lexical_cast<std::string>(m_time);
1371 }
1372
1373 // Update step in field info if required
1374 if (m_fieldMetaDataMap.find("ChkFileNum") != m_fieldMetaDataMap.end())
1375 {
1376 m_fieldMetaDataMap["ChkFileNum"] = std::to_string(m_nchk);
1377 }
1378
1379 // If necessary, add mapping information to metadata
1380 // and output mapping coordinates
1381 Array<OneD, MultiRegions::ExpListSharedPtr> fields(1);
1382 fields[0] = field;
1386 mapping->Output(fieldMetaDataMap, outname);
1387
1388 // If necessary, add informaton for moving frame reference to metadata
1389 // X, Y, Z translational displacements
1390 // Theta_x, Theta_y, Theta_z angular displacements
1391 // U, V, W translational velocity
1392 // Omega_x, Omega_y, Omega_z angular velocity
1393 // A_x, A_y, A_z translational acceleration
1394 // DOmega_x, DOmega_y, DOmega_z angular acceleration
1395 // X0, Y0, Z0 pivot point
1396 for (size_t i = 0;
1397 i < m_strFrameData.size() && i < m_movingFrameData.size(); ++i)
1398 {
1399 fieldMetaDataMap[m_strFrameData[i]] =
1400 boost::lexical_cast<std::string>(m_movingFrameData[i]);
1401 }
1402
1403 m_fld->Write(outname, FieldDef, FieldData, fieldMetaDataMap,
1404 m_session->GetBackups());
1405}
static GLOBAL_MAPPING_EXPORT MappingSharedPtr Load(const LibUtilities::SessionReaderSharedPtr &pSession, const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields)
Return a pointer to the mapping, creating it on first call.
Definition: Mapping.cpp:264
std::vector< std::string > m_strFrameData
variable name in m_movingFrameData
Array< OneD, NekDouble > m_movingFrameData
Moving reference frame status in the inertial frame X, Y, Z, Theta_x, Theta_y, Theta_z,...
GLOBAL_MAPPING_EXPORT typedef std::shared_ptr< Mapping > MappingSharedPtr
A shared pointer to a Mapping object.
Definition: Mapping.h:57
std::map< std::string, std::string > FieldMetaDataMap
Definition: FieldIO.h:50

References FilterPython_Function::field, Nektar::GlobalMapping::Mapping::Load(), m_fieldMetaDataMap, m_fld, m_movingFrameData, m_nchk, m_session, m_strFrameData, m_time, and Nektar::GlobalMapping::MappingSharedPtr.

◆ ZeroPhysFields()

void Nektar::SolverUtils::EquationSystem::ZeroPhysFields ( void  )

Zero the physical fields.

Definition at line 1228 of file EquationSystem.cpp.

1229{
1230 for (int i = 0; i < m_fields.size(); i++)
1231 {
1232 Vmath::Zero(m_fields[i]->GetNpoints(), m_fields[i]->UpdatePhys(), 1);
1233 }
1234}

References GetNpoints(), m_fields, and Vmath::Zero().

Referenced by v_InitObject().

Member Data Documentation

◆ equationSystemTypeLookupIds

std::string Nektar::SolverUtils::EquationSystem::equationSystemTypeLookupIds
staticprotected
Initial value:
= {
static std::string RegisterEnumValue(std::string pEnum, std::string pString, int pEnumValue)
Registers an enumeration value.

Definition at line 633 of file EquationSystem.h.

◆ m_boundaryConditions

SpatialDomains::BoundaryConditionsSharedPtr Nektar::SolverUtils::EquationSystem::m_boundaryConditions
protected

◆ m_checkIfSystemSingular

Array<OneD, bool> Nektar::SolverUtils::EquationSystem::m_checkIfSystemSingular
protected

Flag to indicate if the fields should be checked for singularity.

Definition at line 531 of file EquationSystem.h.

Referenced by v_InitObject().

◆ m_checksteps

int Nektar::SolverUtils::EquationSystem::m_checksteps
protected

◆ m_checktime

NekDouble Nektar::SolverUtils::EquationSystem::m_checktime
protected

◆ m_comm

LibUtilities::CommSharedPtr Nektar::SolverUtils::EquationSystem::m_comm
protected

Communicator.

Definition at line 457 of file EquationSystem.h.

Referenced by Nektar::CFSImplicit::CalcRefValues(), Nektar::ShallowWaterSystem::CalcRefValues(), Checkpoint_Output(), Nektar::SolverUtils::UnsteadySystem::CheckSteadyState(), Nektar::SolverUtils::AdvectionSystem::GetCFLEstimate(), Nektar::PulseWaveSystem::GetCommArray(), Nektar::CFSImplicit::InitialiseNonlinSysSolver(), Nektar::ShallowWaterSystem::InitialiseNonlinSysSolver(), Nektar::SolverUtils::UnsteadySystem::InitializeSteadyState(), Nektar::ShallowWaterSystem::MatrixMultiplyMatrixFree(), Nektar::CFSImplicit::MatrixMultiplyMatrixFreeCoeff(), Nektar::VelocityCorrectionScheme::MeasureFlowrate(), Nektar::PulseWaveSystem::SetUpDomainInterfaces(), Nektar::VelocityCorrectionScheme::SetupFlowrate(), Nektar::VelocityCorrectionScheme::SetUpSVV(), Nektar::SolverUtils::UnsteadySystem::v_DoSolve(), Nektar::CompressibleFlowSystem::v_GetTimeStep(), v_InitObject(), Nektar::IterativeElasticSystem::v_InitObject(), Nektar::MMFSWE::v_L2Error(), Nektar::PulseWaveSystem::v_L2Error(), Nektar::PulseWaveSystem::v_LinfError(), Nektar::Dummy::v_Output(), v_Output(), Nektar::CoupledLinearNS::v_Output(), Nektar::SolverUtils::AdvectionSystem::v_PostIntegrate(), Nektar::VelocityCorrectionScheme::v_PostIntegrate(), Nektar::SolverUtils::UnsteadySystem::v_PrintStatusInformation(), v_SetInitialConditions(), Nektar::CompressibleFlowSystem::v_SetInitialConditions(), Nektar::NonlinearPeregrine::v_SetInitialConditions(), Nektar::SolverUtils::UnsteadySystem::v_SteadyStateResidual(), and Nektar::CompressibleFlowSystem::v_SteadyStateResidual().

◆ m_expdim

int Nektar::SolverUtils::EquationSystem::m_expdim
protected

◆ m_fieldMetaDataMap

LibUtilities::FieldMetaDataMap Nektar::SolverUtils::EquationSystem::m_fieldMetaDataMap
protected

◆ m_fields

Array<OneD, MultiRegions::ExpListSharedPtr> Nektar::SolverUtils::EquationSystem::m_fields
protected

Array holding all dependent variables.

Definition at line 467 of file EquationSystem.h.

Referenced by Nektar::SolverUtils::MMFSystem::AbsIntegral(), Nektar::UnsteadyAdvectionDiffusion::AddAdvectionPenaltyFlux(), Nektar::MMFSWE::AddCoriolis(), Nektar::ShallowWaterSystem::AddCoriolis(), Nektar::MMFSWE::AddDivForGradient(), Nektar::MMFSWE::AddElevationEffect(), Nektar::MMFMaxwell::AddGreenDerivCompensate(), Nektar::VCSImplicit::AddImplicitSkewSymAdvection(), Nektar::CFSImplicit::AddMatNSBlkDiagBnd(), Nektar::CFSImplicit::AddMatNSBlkDiagVol(), Nektar::MMFMaxwell::AddPML(), Nektar::MMFSWE::AddRotation(), Nektar::NonlinearSWE::AddVariableDepth(), Nektar::MMFAdvection::AdvectionBellPlane(), Nektar::MMFAdvection::AdvectionBellSphere(), Nektar::SolverUtils::UnsteadySystem::AppendOutput1D(), Nektar::VCSMapping::ApplyIncNSMappingForcing(), Nektar::SolverUtils::MMFSystem::AverageMaxwellFlux1D(), Nektar::SolverUtils::MMFSystem::AvgAbsInt(), Nektar::SolverUtils::MMFSystem::AvgInt(), Nektar::LinearElasticSystem::BuildMatrixSystem(), Nektar::CFSImplicit::CalcRefValues(), Nektar::ShallowWaterSystem::CalcRefValues(), Nektar::CFSImplicit::CalcTraceNumericalFlux(), Nektar::CFSImplicit::CalcVolJacStdMat(), Nektar::SolverUtils::MMFSystem::CartesianToMovingframes(), Nektar::SolverUtils::UnsteadySystem::CheckForRestartTime(), Nektar::SolverUtils::MMFSystem::CheckMovingFrames(), Nektar::MMFMaxwell::Checkpoint_EDFluxOutput(), Nektar::MMFMaxwell::Checkpoint_EnergyOutput(), Nektar::MMFSWE::Checkpoint_Output_Cartesian(), Nektar::MMFMaxwell::Checkpoint_PlotOutput(), Nektar::MMFMaxwell::Checkpoint_TotalFieldOutput(), Nektar::MMFMaxwell::Checkpoint_TotPlotOutput(), Nektar::SolverUtils::UnsteadySystem::CheckSteadyState(), Nektar::VCSImplicit::CheckUnsetGlobalLinSys(), Nektar::MMFSWE::Compute_demdt_cdot_ek(), Nektar::SolverUtils::MMFSystem::ComputeCurl(), Nektar::SolverUtils::MMFSystem::Computedemdxicdote(), Nektar::SolverUtils::MMFSystem::ComputeDivCurlMF(), Nektar::MMFSWE::ComputeEnergy(), Nektar::MMFMaxwell::ComputeEnergyDensity(), Nektar::MMFSWE::ComputeEnstrophy(), Nektar::VelocityCorrectionScheme::ComputeGJPNormalVelocity(), Nektar::MMFSWE::ComputeMass(), Nektar::MMFMaxwell::ComputeMaterialMicroWaveCloak(), Nektar::MMFMaxwell::ComputeMaterialOpticalCloak(), Nektar::MMFMaxwell::ComputeMaterialVector(), Nektar::SolverUtils::MMFSystem::ComputeMFtrace(), Nektar::MMFAdvection::ComputeNablaCdotVelocity(), Nektar::MMFSWE::ComputeNablaCdotVelocity(), Nektar::SolverUtils::MMFSystem::ComputencdotMF(), Nektar::MMFMaxwell::ComputeRadCloak(), Nektar::MMFMaxwell::ComputeSurfaceCurrent(), Nektar::MMFAdvection::ComputeveldotMF(), Nektar::MMFSWE::ComputeVorticity(), Nektar::SolverUtils::MMFSystem::ComputeZimYim(), Nektar::MMFSWE::ConservativeToPrimitive(), Nektar::ShallowWaterSystem::ConservativeToPrimitive(), Nektar::CoupledLinearNS::Continuation(), Nektar::LinearSWE::CopyBoundaryTrace(), Nektar::SolverUtils::MMFSystem::CopyBoundaryTrace(), Nektar::AcousticSystem::CopyBoundaryTrace(), CopyFromPhysField(), CopyToPhysField(), Nektar::CoupledLinearNS::DefineForcingTerm(), Nektar::CompressibleFlowSystem::DoAdvection(), Nektar::CFSImplicit::DoAdvectionCoeff(), Nektar::UnsteadyAdvectionDiffusion::DoImplicitSolve(), Nektar::UnsteadyDiffusion::DoImplicitSolve(), Nektar::UnsteadyViscousBurgers::DoImplicitSolve(), Nektar::Bidomain::DoImplicitSolve(), Nektar::BidomainRoth::DoImplicitSolve(), Nektar::Monodomain::DoImplicitSolve(), Nektar::MMFDiffusion::DoImplicitSolve(), Nektar::CFSImplicit::DoImplicitSolve(), Nektar::ShallowWaterSystem::DoImplicitSolve(), Nektar::CFSImplicit::DoOdeImplicitRhs(), Nektar::AcousticSystem::DoOdeProjection(), Nektar::MMFAdvection::DoOdeProjection(), Nektar::UnsteadyAdvection::DoOdeProjection(), Nektar::UnsteadyDiffusion::DoOdeProjection(), Nektar::UnsteadyInviscidBurgers::DoOdeProjection(), Nektar::CompressibleFlowSystem::DoOdeProjection(), Nektar::Dummy::DoOdeProjection(), Nektar::ShallowWaterSystem::DoOdeProjection(), Nektar::AcousticSystem::DoOdeRhs(), Nektar::MMFAdvection::DoOdeRhs(), Nektar::UnsteadyAdvection::DoOdeRhs(), Nektar::UnsteadyAdvectionDiffusion::DoOdeRhs(), Nektar::UnsteadyDiffusion::DoOdeRhs(), Nektar::UnsteadyInviscidBurgers::DoOdeRhs(), Nektar::UnsteadyReactionDiffusion::DoOdeRhs(), Nektar::UnsteadyViscousBurgers::DoOdeRhs(), Nektar::Bidomain::DoOdeRhs(), Nektar::BidomainRoth::DoOdeRhs(), Nektar::CompressibleFlowSystem::DoOdeRhs(), Nektar::MMFDiffusion::DoOdeRhs(), Nektar::ImageWarpingSystem::DoOdeRhs(), Nektar::MMFMaxwell::DoOdeRhs(), Nektar::PulseWavePropagation::DoOdeRhs(), Nektar::MMFSWE::DoOdeRhs(), Nektar::CFSImplicit::DoOdeRhsCoeff(), ErrorExtraPoints(), Nektar::CoupledLinearNS::EvaluateAdvection(), Nektar::IncNavierStokes::EvaluateAdvectionTerms(), Nektar::MMFAdvection::EvaluateAdvectionVelocity(), Nektar::MMFMaxwell::EvaluateCoriolis(), Nektar::MMFSWE::EvaluateCoriolisForZonalFlow(), Nektar::CompressibleFlowSystem::EvaluateIsentropicVortex(), Nektar::CoupledLinearNS::EvaluateNewtonRHS(), Nektar::MMFSWE::EvaluateStandardCoriolis(), Nektar::MMFSWE::EvaluateWaterDepth(), FwdTransFields(), Nektar::MMFMaxwell::GaussianPulse(), Nektar::MMFMaxwell::GenerateSigmaPML(), Nektar::SolverUtils::AdvectionSystem::GetCFLEstimate(), GetCoeff_Offset(), Nektar::SolverUtils::AdvectionSystem::GetElmtCFLVals(), Nektar::CompressibleFlowSystem::GetElmtTimeStep(), Nektar::CompressibleFlowSystem::GetExactRinglebFlow(), GetExpSize(), Nektar::UnsteadyAdvection::GetFluxVector(), Nektar::PulseWavePropagation::GetFluxVector(), Nektar::LinearSWE::GetFluxVector(), Nektar::NonlinearSWE::GetFluxVector(), Nektar::UnsteadyAdvection::GetFluxVectorDeAlias(), Nektar::CompressibleFlowSystem::GetFluxVectorDeAlias(), GetFunction(), Nektar::SolverUtils::MMFSystem::GetIncidentField(), Nektar::UnsteadyAdvectionDiffusion::GetMaxStdVelocity(), Nektar::SolverUtils::MMFSystem::GetMaxwellFlux1D(), Nektar::SolverUtils::MMFSystem::GetMaxwellFlux2D(), GetNcoeffs(), Nektar::UnsteadyAdvection::GetNormalVel(), Nektar::EigenValuesAdvection::GetNormalVelocity(), Nektar::MMFAdvection::GetNormalVelocity(), Nektar::UnsteadyInviscidBurgers::GetNormalVelocity(), Nektar::ImageWarpingSystem::GetNormalVelocity(), GetNpoints(), GetNumExpModesPerExp(), GetPhys_Offset(), Nektar::CompressibleFlowSystem::GetStabilityLimitVector(), Nektar::UnsteadyAdvectionDiffusion::GetSubstepTimeStep(), Nektar::MMFSWE::GetSWEFluxVector(), GetTotPoints(), Nektar::CFSImplicit::GetTraceJac(), GetTraceNpoints(), Nektar::NavierStokesCFE::GetViscosityAndThermalCondFromTemp(), ImportFld(), ImportFldToMultiDomains(), Nektar::CompressibleFlowSystem::InitAdvection(), Nektar::CFSImplicit::InitialiseNonlinSysSolver(), Nektar::ShallowWaterSystem::InitialiseNonlinSysSolver(), Nektar::SolverUtils::UnsteadySystem::InitializeSteadyState(), Nektar::NavierStokesCFE::InitObject_Explicit(), Nektar::MMFSWE::IsolatedMountainFlow(), Nektar::NonlinearPeregrine::LaitoneSolitaryWave(), Nektar::SolverUtils::MMFSystem::LaxFriedrichMaxwellFlux1D(), Nektar::VCSMapping::MappingAccelerationCorrection(), Nektar::VCSMapping::MappingAdvectionCorrection(), Nektar::VCSMapping::MappingPressureCorrection(), Nektar::VelocityCorrectionScheme::MeasureFlowrate(), Nektar::SolverUtils::MMFSystem::MMFInitObject(), Nektar::MMFDiffusion::Morphogenesis(), Nektar::CFSImplicit::MultiplyElmtInvMassPlusSource(), Nektar::ShallowWaterSystem::NonlinSysEvaluator(), Nektar::ShallowWaterSystem::NonlinSysEvaluator1D(), Nektar::CFSImplicit::NonlinSysEvaluatorCoeff(), Nektar::CFSImplicit::NonlinSysEvaluatorCoeff1D(), Nektar::CFSImplicit::NumCalcRiemFluxJac(), Nektar::NonlinearPeregrine::NumericalFluxConsVariables(), Nektar::NonlinearPeregrine::NumericalFluxForcing(), Nektar::SolverUtils::MMFSystem::NumericalMaxwellFluxTE(), Nektar::SolverUtils::MMFSystem::NumericalMaxwellFluxTM(), Nektar::MMFSWE::NumericalSWEFlux(), Nektar::MMFDiffusion::PlanePhiWave(), Nektar::CFSImplicit::PreconCoeff(), Nektar::MMFSWE::PrimitiveToConservative(), Nektar::ShallowWaterSystem::PrimitiveToConservative(), Nektar::MMFMaxwell::Printout_SurfaceCurrent(), Nektar::MMFSWE::RossbyWave(), SessionSummary(), Nektar::MMFSWE::SetBoundaryConditions(), Nektar::AcousticSystem::SetBoundaryConditions(), Nektar::CompressibleFlowSystem::SetBoundaryConditions(), Nektar::ShallowWaterSystem::SetBoundaryConditions(), SetBoundaryConditions(), Nektar::IncNavierStokes::SetBoundaryConditions(), Nektar::NonlinearPeregrine::SetBoundaryConditionsContVariables(), Nektar::NonlinearPeregrine::SetBoundaryConditionsForcing(), Nektar::IncNavierStokes::SetRadiationBoundaryForcing(), Nektar::SmoothedProfileMethod::SetUpCorrectionPressure(), Nektar::CoupledLinearNS::SetUpCoupledMatrix(), Nektar::SmoothedProfileMethod::SetUpExpansions(), Nektar::VelocityCorrectionScheme::SetUpExtrapolation(), Nektar::VelocityCorrectionScheme::SetupFlowrate(), Nektar::SolverUtils::MMFSystem::SetUpMovingFrames(), Nektar::VelocityCorrectionScheme::SetUpSVV(), Nektar::IncNavierStokes::SetUpWomersley(), Nektar::IncNavierStokes::SetWomersleyBoundary(), Nektar::IncNavierStokes::SetZeroNormalVelocity(), Nektar::CoupledLinearNS::Solve(), Nektar::CoupledLinearNS::SolveLinearNS(), Nektar::CoupledLinearNS::SolveSteadyNavierStokes(), Nektar::CoupledLinearNS::SolveUnsteadyStokesSystem(), Nektar::NavierStokesCFE::SpecialBndTreat(), Nektar::MMFSWE::SteadyZonalFlow(), Nektar::UnsteadyAdvectionDiffusion::SubStepAdvance(), Nektar::UnsteadyAdvectionDiffusion::SubStepAdvection(), Nektar::SolverUtils::UnsteadySystem::SVVVarDiffCoeff(), Nektar::VelocityCorrectionScheme::SVVVarDiffCoeff(), Nektar::MMFAdvection::Test2Dproblem(), Nektar::MMFAdvection::Test3Dproblem(), Nektar::MMFDiffusion::TestCubeProblem(), Nektar::MMFMaxwell::TestMaxwell1D(), Nektar::MMFMaxwell::TestMaxwell2DPEC(), Nektar::MMFMaxwell::TestMaxwell2DPMC(), Nektar::MMFMaxwell::TestMaxwellSphere(), Nektar::MMFDiffusion::TestPlaneProblem(), Nektar::MMFSWE::TestSWE2Dproblem(), Nektar::MMFSWE::TestVorticityComputation(), Nektar::MMFSWE::UnstableJetFlow(), Nektar::MMFSWE::UnsteadyZonalFlow(), Nektar::AcousticSystem::UpdateBasefieldFwdBwd(), Nektar::SolverUtils::FileSolution::UpdateField(), UpdateFields(), Nektar::SmoothedProfileMethod::UpdateForcing(), UpdatePhysField(), Nektar::SolverUtils::MMFSystem::UpwindMaxwellFlux1D(), Nektar::LEE::v_AddLinTerm(), Nektar::NavierStokesImplicitCFE::v_CalcPhysDeriv(), Nektar::NavierStokesCFE::v_DoDiffusion(), Nektar::NavierStokesImplicitCFE::v_DoDiffusionCoeff(), Nektar::VCSImplicit::v_DoInitialise(), Nektar::SteadyAdvectionDiffusion::v_DoInitialise(), Nektar::PulseWaveSystem::v_DoInitialise(), Nektar::MMFSWE::v_DoInitialise(), Nektar::CoupledLinearNS::v_DoInitialise(), Nektar::VCSMapping::v_DoInitialise(), Nektar::VelocityCorrectionScheme::v_DoInitialise(), Nektar::LinearSWE::v_DoOdeRhs(), Nektar::NonlinearPeregrine::v_DoOdeRhs(), Nektar::NonlinearSWE::v_DoOdeRhs(), Nektar::SolverUtils::UnsteadySystem::v_DoSolve(), Nektar::EigenValuesAdvection::v_DoSolve(), Nektar::Laplace::v_DoSolve(), Nektar::MMFAdvection::v_DoSolve(), Nektar::Projection::v_DoSolve(), Nektar::SteadyAdvectionDiffusion::v_DoSolve(), Nektar::IterativeElasticSystem::v_DoSolve(), Nektar::LinearElasticSystem::v_DoSolve(), Nektar::MMFMaxwell::v_DoSolve(), Nektar::PulseWaveSystem::v_DoSolve(), Nektar::MMFSWE::v_DoSolve(), Nektar::VelocityCorrectionScheme::v_EvaluateAdvection_SetPressureBCs(), Nektar::VCSMapping::v_EvaluateAdvection_SetPressureBCs(), v_EvaluateExactSolution(), Nektar::MMFMaxwell::v_EvaluateExactSolution(), Nektar::AcousticSystem::v_ExtraFldOutput(), Nektar::CompressibleFlowSystem::v_ExtraFldOutput(), Nektar::NavierStokesCFE::v_ExtraFldOutput(), Nektar::LinearElasticSystem::v_ExtraFldOutput(), Nektar::Poisson::v_GenerateSummary(), Nektar::Projection::v_GenerateSummary(), Nektar::SolverUtils::MMFSystem::v_GenerateSummary(), Nektar::SolverUtils::FileSolution::v_GetDensity(), Nektar::AcousticSystem::v_GetMaxStdVelocity(), Nektar::CompressibleFlowSystem::v_GetMaxStdVelocity(), Nektar::IncNavierStokes::v_GetMaxStdVelocity(), Nektar::CompressibleFlowSystem::v_GetTimeStep(), Nektar::SolverUtils::FileSolution::v_GetVelocity(), Nektar::NavierStokesCFEAxisym::v_GetViscousFluxVector(), Nektar::NavierStokesCFE::v_GetViscousFluxVectorDeAlias(), v_H1Error(), v_InitObject(), DummyEquationSystem::v_InitObject(), Nektar::PulseWavePropagation::v_InitObject(), Nektar::PulseWaveSystem::v_InitObject(), Nektar::SolverUtils::UnsteadySystem::v_InitObject(), Nektar::Bidomain::v_InitObject(), Nektar::BidomainRoth::v_InitObject(), Nektar::Monodomain::v_InitObject(), Nektar::MMFDiffusion::v_InitObject(), Nektar::ImageWarpingSystem::v_InitObject(), Nektar::CoupledLinearNS::v_InitObject(), Nektar::IncNavierStokes::v_InitObject(), Nektar::VCSMapping::v_InitObject(), Nektar::VelocityCorrectionScheme::v_InitObject(), Nektar::SolverUtils::FileSolution::v_InitObject(), Nektar::AcousticSystem::v_InitObject(), Nektar::APE::v_InitObject(), Nektar::LEE::v_InitObject(), Nektar::EigenValuesAdvection::v_InitObject(), Nektar::MMFAdvection::v_InitObject(), Nektar::Poisson::v_InitObject(), Nektar::Projection::v_InitObject(), Nektar::UnsteadyAdvection::v_InitObject(), Nektar::UnsteadyAdvectionDiffusion::v_InitObject(), Nektar::UnsteadyDiffusion::v_InitObject(), Nektar::UnsteadyInviscidBurgers::v_InitObject(), Nektar::UnsteadyReactionDiffusion::v_InitObject(), Nektar::UnsteadyViscousBurgers::v_InitObject(), Nektar::CompressibleFlowSystem::v_InitObject(), Nektar::NavierStokesCFEAxisym::v_InitObject(), Nektar::Dummy::v_InitObject(), Nektar::IterativeElasticSystem::v_InitObject(), Nektar::LinearElasticSystem::v_InitObject(), Nektar::MMFMaxwell::v_InitObject(), Nektar::LinearSWE::v_InitObject(), Nektar::MMFSWE::v_InitObject(), Nektar::NonlinearSWE::v_InitObject(), Nektar::ShallowWaterSystem::v_InitObject(), Nektar::MMFSWE::v_L2Error(), v_L2Error(), Nektar::PulseWaveSystem::v_L2Error(), Nektar::MMFSWE::v_LinfError(), v_LinfError(), Nektar::PulseWaveSystem::v_LinfError(), Nektar::CoupledLinearNS::v_Output(), Nektar::Dummy::v_PostIntegrate(), Nektar::AcousticSystem::v_PreIntegrate(), Nektar::Dummy::v_PreIntegrate(), Nektar::APE::v_RiemannInvariantBC(), Nektar::LEE::v_RiemannInvariantBC(), Nektar::MMFAdvection::v_SetInitialConditions(), Nektar::MMFMaxwell::v_SetInitialConditions(), Nektar::MMFSWE::v_SetInitialConditions(), v_SetInitialConditions(), Nektar::CompressibleFlowSystem::v_SetInitialConditions(), Nektar::MMFDiffusion::v_SetInitialConditions(), Nektar::VelocityCorrectionScheme::v_SetUpPressureForcing(), Nektar::VCSMapping::v_SetUpPressureForcing(), Nektar::VCSImplicit::v_SetUpPressureForcing(), Nektar::VelocityCorrectionScheme::v_SetUpViscousForcing(), Nektar::VCSMapping::v_SetUpViscousForcing(), Nektar::VCSImplicit::v_SetUpViscousForcing(), Nektar::VCSMapping::v_SolvePressure(), Nektar::VelocityCorrectionScheme::v_SolveUnsteadyStokesSystem(), Nektar::VelocityCorrectionScheme::v_SolveViscous(), Nektar::VCSMapping::v_SolveViscous(), Nektar::VCSImplicit::v_SolveViscous(), Nektar::SolverUtils::UnsteadySystem::v_SteadyStateResidual(), Nektar::CompressibleFlowSystem::v_SteadyStateResidual(), Nektar::CoupledLinearNS::v_TransCoeffToPhys(), Nektar::VelocityCorrectionScheme::v_TransCoeffToPhys(), Nektar::CoupledLinearNS::v_TransPhysToCoeff(), Nektar::VelocityCorrectionScheme::v_TransPhysToCoeff(), Nektar::AcousticSystem::WallBC(), Nektar::ShallowWaterSystem::WallBoundary2D(), Nektar::MMFSWE::WallBoundary2D(), Nektar::NonlinearPeregrine::WallBoundaryContVariables(), Nektar::NonlinearPeregrine::WallBoundaryForcing(), Nektar::NonlinearPeregrine::WCESolve(), Nektar::MMFAdvection::WeakDGDirectionalAdvection(), Nektar::MMFMaxwell::WeakDGMaxwellDirDeriv(), Nektar::MMFSWE::WeakDGSWEDirDeriv(), Nektar::AcousticSystem::WhiteNoiseBC(), WriteFld(), and ZeroPhysFields().

◆ m_fintime

NekDouble Nektar::SolverUtils::EquationSystem::m_fintime
protected

◆ m_fld

LibUtilities::FieldIOSharedPtr Nektar::SolverUtils::EquationSystem::m_fld
protected

Field input/output.

Definition at line 465 of file EquationSystem.h.

Referenced by v_InitObject(), WriteFld(), and Nektar::PulseWaveSystem::WriteVessels().

◆ m_graph

SpatialDomains::MeshGraphSharedPtr Nektar::SolverUtils::EquationSystem::m_graph
protected

◆ m_halfMode

bool Nektar::SolverUtils::EquationSystem::m_halfMode
protected

Flag to determine if half homogeneous mode is used.

Definition at line 510 of file EquationSystem.h.

Referenced by SessionSummary(), and v_InitObject().

◆ m_HomoDirec

int Nektar::SolverUtils::EquationSystem::m_HomoDirec
protected

number of homogenous directions

Definition at line 566 of file EquationSystem.h.

Referenced by v_InitObject().

◆ m_homogen_dealiasing

bool Nektar::SolverUtils::EquationSystem::m_homogen_dealiasing
protected

◆ m_HomogeneousType

enum HomogeneousType Nektar::SolverUtils::EquationSystem::m_HomogeneousType
protected

◆ m_infosteps

int Nektar::SolverUtils::EquationSystem::m_infosteps
protected

◆ m_initialStep

int Nektar::SolverUtils::EquationSystem::m_initialStep
protected

◆ m_iterPIT

int Nektar::SolverUtils::EquationSystem::m_iterPIT = 0
protected

Number of parallel-in-time time iteration.

Definition at line 500 of file EquationSystem.h.

Referenced by Checkpoint_Output(), SetIterationNumberPIT(), and v_InitObject().

◆ m_lambda

NekDouble Nektar::SolverUtils::EquationSystem::m_lambda
protected

Lambda constant in real system if one required.

Definition at line 484 of file EquationSystem.h.

Referenced by SetLambda(), and Nektar::CoupledLinearNS::v_DoInitialise().

◆ m_lastCheckTime

NekDouble Nektar::SolverUtils::EquationSystem::m_lastCheckTime
protected

◆ m_LhomX

NekDouble Nektar::SolverUtils::EquationSystem::m_LhomX
protected

physical length in X direction (if homogeneous)

Definition at line 558 of file EquationSystem.h.

◆ m_LhomY

NekDouble Nektar::SolverUtils::EquationSystem::m_LhomY
protected

physical length in Y direction (if homogeneous)

Definition at line 559 of file EquationSystem.h.

Referenced by SessionSummary(), and v_InitObject().

◆ m_LhomZ

NekDouble Nektar::SolverUtils::EquationSystem::m_LhomZ
protected

physical length in Z direction (if homogeneous)

Definition at line 560 of file EquationSystem.h.

Referenced by SessionSummary(), Nektar::CoupledLinearNS::SetUpCoupledMatrix(), v_InitObject(), and Nektar::CoupledLinearNS::v_InitObject().

◆ m_movingFrameData

Array<OneD, NekDouble> Nektar::SolverUtils::EquationSystem::m_movingFrameData
protected

◆ m_multipleModes

bool Nektar::SolverUtils::EquationSystem::m_multipleModes
protected

Flag to determine if use multiple homogenenous modes are used.

Definition at line 512 of file EquationSystem.h.

Referenced by SessionSummary(), and v_InitObject().

◆ m_nchk

int Nektar::SolverUtils::EquationSystem::m_nchk
protected

◆ m_npointsX

int Nektar::SolverUtils::EquationSystem::m_npointsX
protected

number of points in X direction (if homogeneous)

Definition at line 562 of file EquationSystem.h.

◆ m_npointsY

int Nektar::SolverUtils::EquationSystem::m_npointsY
protected

number of points in Y direction (if homogeneous)

Definition at line 563 of file EquationSystem.h.

Referenced by SessionSummary(), and v_InitObject().

◆ m_npointsZ

int Nektar::SolverUtils::EquationSystem::m_npointsZ
protected

◆ m_NumQuadPointsError

int Nektar::SolverUtils::EquationSystem::m_NumQuadPointsError
protected

◆ m_projectionType

enum MultiRegions::ProjectionType Nektar::SolverUtils::EquationSystem::m_projectionType
protected

Type of projection; e.g continuous or discontinuous.

Definition at line 526 of file EquationSystem.h.

Referenced by Nektar::ShallowWaterSystem::AddCoriolis(), Nektar::NonlinearSWE::AddVariableDepth(), Nektar::UnsteadyAdvectionDiffusion::DoImplicitSolve(), Nektar::UnsteadyViscousBurgers::DoImplicitSolve(), Nektar::MMFAdvection::DoOdeProjection(), Nektar::UnsteadyAdvection::DoOdeProjection(), Nektar::UnsteadyDiffusion::DoOdeProjection(), Nektar::UnsteadyInviscidBurgers::DoOdeProjection(), Nektar::CompressibleFlowSystem::DoOdeProjection(), Nektar::ImageWarpingSystem::DoOdeProjection(), Nektar::MMFSWE::DoOdeProjection(), Nektar::ShallowWaterSystem::DoOdeProjection(), Nektar::MMFAdvection::DoOdeRhs(), Nektar::ImageWarpingSystem::DoOdeRhs(), Nektar::CompressibleFlowSystem::GetStabilityLimit(), Nektar::CompressibleFlowSystem::InitAdvection(), SessionSummary(), Nektar::UnsteadyAdvection::v_ALEInitObject(), Nektar::UnsteadyAdvectionDiffusion::v_ALEInitObject(), Nektar::LinearSWE::v_DoOdeRhs(), Nektar::NonlinearPeregrine::v_DoOdeRhs(), Nektar::NonlinearSWE::v_DoOdeRhs(), Nektar::EigenValuesAdvection::v_DoSolve(), v_InitObject(), Nektar::PulseWaveSystem::v_InitObject(), Nektar::SmoothedProfileMethod::v_InitObject(), Nektar::AcousticSystem::v_InitObject(), Nektar::EigenValuesAdvection::v_InitObject(), Nektar::UnsteadyAdvection::v_InitObject(), Nektar::UnsteadyAdvectionDiffusion::v_InitObject(), Nektar::UnsteadyDiffusion::v_InitObject(), Nektar::UnsteadyInviscidBurgers::v_InitObject(), Nektar::UnsteadyViscousBurgers::v_InitObject(), Nektar::LinearSWE::v_InitObject(), Nektar::NonlinearPeregrine::v_InitObject(), Nektar::NonlinearSWE::v_InitObject(), and v_SetInitialConditions().

◆ m_session

LibUtilities::SessionReaderSharedPtr Nektar::SolverUtils::EquationSystem::m_session
protected

The session reader.

Definition at line 460 of file EquationSystem.h.

Referenced by Nektar::LinearElasticSystem::BuildMatrixSystem(), Nektar::CFSImplicit::CalcTraceNumericalFlux(), Nektar::SolverUtils::UnsteadySystem::CheckForRestartTime(), Checkpoint_Output(), Nektar::SolverUtils::UnsteadySystem::CheckSteadyState(), Nektar::SolverUtils::MMFSystem::CopyBoundaryTrace(), Nektar::IncNavierStokes::DefinedForcing(), Nektar::CoupledLinearNS::DefineForcingTerm(), Nektar::Bidomain::DoImplicitSolve(), Nektar::Bidomain::DoOdeRhs(), Nektar::BidomainRoth::DoOdeRhs(), Nektar::ImageWarpingSystem::DoOdeRhs(), EquationSystem(), ErrorExtraPoints(), Nektar::CompressibleFlowSystem::EvaluateIsentropicVortex(), Nektar::PulseWavePropagation::GetFluxVector(), GetFunction(), Nektar::SmoothedProfileMethod::GetFunctionHdl(), GetNvariables(), GetSession(), Nektar::UnsteadyAdvectionDiffusion::GetSubstepTimeStep(), GetVariable(), Nektar::Helmholtz::Helmholtz(), ImportFld(), ImportFldToMultiDomains(), Nektar::CompressibleFlowSystem::InitAdvection(), Nektar::CFSImplicit::InitialiseNonlinSysSolver(), Nektar::ShallowWaterSystem::InitialiseNonlinSysSolver(), Nektar::CompressibleFlowSystem::InitialiseParameters(), Nektar::SolverUtils::UnsteadySystem::InitializeSteadyState(), Nektar::NavierStokesCFE::InitObject_Explicit(), Nektar::VelocityCorrectionScheme::MeasureFlowrate(), Nektar::SolverUtils::MMFSystem::MMFInitObject(), PrintSummary(), Nektar::SmoothedProfileMethod::ReadPhi(), SessionSummary(), Nektar::AcousticSystem::SetBoundaryConditions(), Nektar::ShallowWaterSystem::SetBoundaryConditions(), SetBoundaryConditions(), Nektar::IncNavierStokes::SetBoundaryConditions(), Nektar::PulseWavePropagation::SetPulseWaveBoundaryConditions(), Nektar::CoupledLinearNS::SetUpCoupledMatrix(), Nektar::PulseWaveSystem::SetUpDomainInterfaceBCs(), Nektar::PulseWaveSystem::SetUpDomainInterfaces(), Nektar::VelocityCorrectionScheme::SetUpExtrapolation(), Nektar::VelocityCorrectionScheme::SetupFlowrate(), Nektar::SolverUtils::MMFSystem::SetUpMovingFrames(), Nektar::VelocityCorrectionScheme::SetUpSVV(), Nektar::SmoothedProfileMethod::SolveCorrectedVelocity(), Nektar::UnsteadyAdvectionDiffusion::SubStepAdvance(), Nektar::SolverUtils::FileSolution::UpdateField(), Nektar::VCSImplicit::v_DoInitialise(), Nektar::SteadyAdvectionDiffusion::v_DoInitialise(), Nektar::PulseWaveSystem::v_DoInitialise(), Nektar::CoupledLinearNS::v_DoInitialise(), Nektar::SolverUtils::UnsteadySystem::v_DoSolve(), Nektar::MMFAdvection::v_DoSolve(), Nektar::IterativeElasticSystem::v_DoSolve(), Nektar::LinearElasticSystem::v_DoSolve(), Nektar::MMFMaxwell::v_DoSolve(), Nektar::PulseWaveSystem::v_DoSolve(), Nektar::MMFSWE::v_DoSolve(), v_EvaluateExactSolution(), Nektar::CompressibleFlowSystem::v_EvaluateExactSolution(), Nektar::AcousticSystem::v_ExtraFldOutput(), Nektar::UnsteadyAdvection::v_ExtraFldOutput(), Nektar::UnsteadyAdvectionDiffusion::v_ExtraFldOutput(), Nektar::CompressibleFlowSystem::v_ExtraFldOutput(), Nektar::NavierStokesCFE::v_ExtraFldOutput(), Nektar::Poisson::v_GenerateSummary(), Nektar::Projection::v_GenerateSummary(), Nektar::UnsteadyAdvection::v_GenerateSummary(), Nektar::CompressibleFlowSystem::v_GenerateSummary(), Nektar::VelocityCorrectionScheme::v_GenerateSummary(), Nektar::VCSImplicit::v_GenerateSummary(), Nektar::VCSWeakPressure::v_GenerateSummary(), Nektar::LinearSWE::v_GenerateSummary(), Nektar::SolverUtils::UnsteadySystem::v_GenerateSummary(), Nektar::Monodomain::v_GenerateSummary(), Nektar::SolverUtils::FileSolution::v_GetDensity(), Nektar::VelocityCorrectionScheme::v_GetForceDimension(), Nektar::CoupledLinearNS::v_GetForceDimension(), v_GetSystemSingularChecks(), Nektar::Helmholtz::v_GetSystemSingularChecks(), Nektar::Laplace::v_GetSystemSingularChecks(), Nektar::Poisson::v_GetSystemSingularChecks(), Nektar::VelocityCorrectionScheme::v_GetSystemSingularChecks(), Nektar::SolverUtils::FileSolution::v_GetVelocity(), v_H1Error(), Nektar::SolverUtils::FileSolution::v_HasConstantDensity(), v_InitObject(), Nektar::PulseWavePropagation::v_InitObject(), Nektar::PulseWaveSystem::v_InitObject(), Nektar::SolverUtils::AdvectionSystem::v_InitObject(), Nektar::SolverUtils::UnsteadySystem::v_InitObject(), Nektar::Bidomain::v_InitObject(), Nektar::BidomainRoth::v_InitObject(), Nektar::Monodomain::v_InitObject(), Nektar::MMFDiffusion::v_InitObject(), Nektar::ImageWarpingSystem::v_InitObject(), Nektar::CoupledLinearNS::v_InitObject(), Nektar::IncNavierStokes::v_InitObject(), Nektar::SmoothedProfileMethod::v_InitObject(), Nektar::VCSMapping::v_InitObject(), Nektar::VelocityCorrectionScheme::v_InitObject(), Nektar::SolverUtils::FileSolution::v_InitObject(), Nektar::AcousticSystem::v_InitObject(), Nektar::APE::v_InitObject(), Nektar::LEE::v_InitObject(), Nektar::EigenValuesAdvection::v_InitObject(), Nektar::MMFAdvection::v_InitObject(), Nektar::Poisson::v_InitObject(), Nektar::Projection::v_InitObject(), Nektar::SteadyAdvectionDiffusion::v_InitObject(), Nektar::SteadyAdvectionDiffusionReaction::v_InitObject(), Nektar::UnsteadyAdvection::v_InitObject(), Nektar::UnsteadyAdvectionDiffusion::v_InitObject(), Nektar::UnsteadyDiffusion::v_InitObject(), Nektar::UnsteadyInviscidBurgers::v_InitObject(), Nektar::UnsteadyReactionDiffusion::v_InitObject(), Nektar::UnsteadyViscousBurgers::v_InitObject(), Nektar::CompressibleFlowSystem::v_InitObject(), Nektar::CFSImplicit::v_InitObject(), Nektar::Dummy::v_InitObject(), Nektar::IterativeElasticSystem::v_InitObject(), Nektar::LinearElasticSystem::v_InitObject(), Nektar::MMFMaxwell::v_InitObject(), Nektar::LinearSWE::v_InitObject(), Nektar::MMFSWE::v_InitObject(), Nektar::NonlinearPeregrine::v_InitObject(), Nektar::NonlinearSWE::v_InitObject(), Nektar::ShallowWaterSystem::v_InitObject(), v_L2Error(), Nektar::PulseWaveSystem::v_L2Error(), v_LinfError(), Nektar::PulseWaveSystem::v_LinfError(), Nektar::Dummy::v_Output(), Nektar::Dummy::v_PostIntegrate(), Nektar::AcousticSystem::v_PreIntegrate(), Nektar::Dummy::v_PreIntegrate(), Nektar::SolverUtils::UnsteadySystem::v_PrintStatusInformation(), Nektar::CFSImplicit::v_PrintStatusInformation(), Nektar::SolverUtils::UnsteadySystem::v_PrintSummaryStatistics(), Nektar::CFSImplicit::v_PrintSummaryStatistics(), v_SetInitialConditions(), Nektar::CompressibleFlowSystem::v_SetInitialConditions(), Nektar::VCSMapping::v_SolvePressure(), Nektar::VCSMapping::v_SolveViscous(), WriteFld(), Nektar::IterativeElasticSystem::WriteGeometry(), and Nektar::PulseWaveSystem::WriteVessels().

◆ m_sessionFunctions

std::map<std::string, SolverUtils::SessionFunctionSharedPtr> Nektar::SolverUtils::EquationSystem::m_sessionFunctions
protected

Map of known SessionFunctions.

Definition at line 463 of file EquationSystem.h.

Referenced by GetFunction().

◆ m_sessionName

std::string Nektar::SolverUtils::EquationSystem::m_sessionName
protected

◆ m_singleMode

bool Nektar::SolverUtils::EquationSystem::m_singleMode
protected

◆ m_spacedim

int Nektar::SolverUtils::EquationSystem::m_spacedim
protected

Spatial dimension (>= expansion dim).

Definition at line 504 of file EquationSystem.h.

Referenced by Nektar::CFSImplicit::AddMatNSBlkDiagBnd(), Nektar::CFSImplicit::AddMatNSBlkDiagVol(), Nektar::NonlinearSWE::AddVariableDepth(), Nektar::CFSImplicit::CalcVolJacStdMat(), Nektar::SolverUtils::MMFSystem::CheckMovingFrames(), Nektar::MMFMaxwell::Checkpoint_EDFluxOutput(), Nektar::MMFMaxwell::Checkpoint_EnergyOutput(), Nektar::MMFSWE::Checkpoint_Output_Cartesian(), Nektar::MMFMaxwell::Checkpoint_PlotOutput(), Nektar::MMFMaxwell::Checkpoint_TotPlotOutput(), Nektar::MMFSWE::Compute_demdt_cdot_ek(), Nektar::SolverUtils::MMFSystem::ComputeCurl(), Nektar::SolverUtils::MMFSystem::Computedemdxicdote(), Nektar::SolverUtils::MMFSystem::ComputeDivCurlMF(), Nektar::MMFSWE::ComputeEnstrophy(), Nektar::SolverUtils::MMFSystem::ComputeMFtrace(), Nektar::MMFAdvection::ComputeNablaCdotVelocity(), Nektar::MMFSWE::ComputeNablaCdotVelocity(), Nektar::SolverUtils::MMFSystem::ComputencdotMF(), Nektar::SolverUtils::MMFSystem::ComputeNtimesF12(), Nektar::SolverUtils::MMFSystem::ComputeNtimesFz(), Nektar::SolverUtils::MMFSystem::ComputeNtimesMF(), Nektar::SolverUtils::MMFSystem::ComputeNtimestimesdFz(), Nektar::MMFAdvection::ComputeveldotMF(), Nektar::SolverUtils::MMFSystem::DeriveCrossProductMF(), Nektar::CompressibleFlowSystem::DoAdvection(), Nektar::CFSImplicit::DoAdvectionCoeff(), Nektar::Bidomain::DoImplicitSolve(), Nektar::AcousticSystem::DoOdeRhs(), Nektar::MMFAdvection::DoOdeRhs(), Nektar::PulseWavePropagation::DoOdeRhs(), Nektar::MMFAdvection::EvaluateAdvectionVelocity(), Nektar::CompressibleFlowSystem::EvaluateIsentropicVortex(), Nektar::LinearSWE::GetFluxVector(), Nektar::NonlinearSWE::GetFluxVector(), Nektar::CompressibleFlowSystem::GetFluxVector(), Nektar::UnsteadyAdvection::GetFluxVectorDeAlias(), Nektar::CompressibleFlowSystem::GetFluxVectorDeAlias(), Nektar::CFSImplicit::GetFluxVectorJacPoint(), Nektar::UnsteadyInviscidBurgers::GetNormalVelocity(), Nektar::CFSImplicit::GetTraceJac(), Nektar::LinearSWE::GetVelocityVector(), Nektar::NonlinearSWE::GetVelocityVector(), Nektar::SolverUtils::MMFSystem::GramSchumitz(), Nektar::CFSImplicit::InitialiseNonlinSysSolver(), Nektar::MMFSWE::IsolatedMountainFlow(), Nektar::VelocityCorrectionScheme::MeasureFlowrate(), Nektar::SolverUtils::MMFSystem::MMFInitObject(), Nektar::CFSImplicit::NumCalcRiemFluxJac(), Nektar::SolverUtils::MMFSystem::NumericalMaxwellFluxTE(), Nektar::SolverUtils::MMFSystem::NumericalMaxwellFluxTM(), Nektar::MMFSWE::RossbyWave(), SessionSummary(), Nektar::VelocityCorrectionScheme::SetupFlowrate(), Nektar::SolverUtils::MMFSystem::SetUpMovingFrames(), Nektar::IncNavierStokes::SetZeroNormalVelocity(), Nektar::MMFSWE::SteadyZonalFlow(), Nektar::MMFMaxwell::TestMaxwellSphere(), Nektar::MMFSWE::TestSWE2Dproblem(), Nektar::MMFSWE::TestVorticityComputation(), Nektar::MMFSWE::UnstableJetFlow(), Nektar::MMFSWE::UnsteadyZonalFlow(), Nektar::LEE::v_AddLinTerm(), Nektar::NavierStokesImplicitCFE::v_CalcPhysDeriv(), Nektar::LinearSWE::v_DoOdeRhs(), Nektar::NonlinearSWE::v_DoOdeRhs(), Nektar::SolverUtils::UnsteadySystem::v_DoSolve(), Nektar::SteadyAdvectionDiffusion::v_DoSolve(), Nektar::CompressibleFlowSystem::v_ExtraFldOutput(), Nektar::NavierStokesCFE::v_ExtraFldOutput(), Nektar::NavierStokesImplicitCFE::v_GetDiffusionFluxJacPoint(), Nektar::APE::v_GetFluxVector(), Nektar::LEE::v_GetFluxVector(), Nektar::AcousticSystem::v_GetMaxStdVelocity(), Nektar::CompressibleFlowSystem::v_GetMaxStdVelocity(), Nektar::IncNavierStokes::v_GetVelocity(), Nektar::NavierStokesCFE::v_GetViscousFluxVector(), Nektar::NavierStokesCFEAxisym::v_GetViscousFluxVector(), Nektar::NavierStokesCFE::v_GetViscousFluxVectorDeAlias(), v_InitObject(), Nektar::SolverUtils::UnsteadySystem::v_InitObject(), Nektar::Bidomain::v_InitObject(), Nektar::BidomainRoth::v_InitObject(), Nektar::Monodomain::v_InitObject(), Nektar::MMFDiffusion::v_InitObject(), Nektar::ImageWarpingSystem::v_InitObject(), Nektar::IncNavierStokes::v_InitObject(), Nektar::AcousticSystem::v_InitObject(), Nektar::EigenValuesAdvection::v_InitObject(), Nektar::MMFAdvection::v_InitObject(), Nektar::SteadyAdvectionDiffusion::v_InitObject(), Nektar::UnsteadyAdvection::v_InitObject(), Nektar::CompressibleFlowSystem::v_InitObject(), Nektar::NavierStokesImplicitCFE::v_InitObject(), Nektar::MMFMaxwell::v_InitObject(), Nektar::ShallowWaterSystem::v_InitObject(), Nektar::APE::v_RiemannInvariantBC(), Nektar::LEE::v_RiemannInvariantBC(), Nektar::VelocityCorrectionScheme::v_SolveUnsteadyStokesSystem(), Nektar::SolverUtils::MMFSystem::VectorAvgMagnitude(), Nektar::AcousticSystem::WallBC(), and Nektar::AcousticSystem::WhiteNoiseBC().

◆ m_specHP_dealiasing

bool Nektar::SolverUtils::EquationSystem::m_specHP_dealiasing
protected

◆ m_steps

int Nektar::SolverUtils::EquationSystem::m_steps
protected

◆ m_strFrameData

std::vector<std::string> Nektar::SolverUtils::EquationSystem::m_strFrameData
protected

◆ m_time

NekDouble Nektar::SolverUtils::EquationSystem::m_time
protected

Current time of simulation.

Definition at line 475 of file EquationSystem.h.

Referenced by Nektar::SolverUtils::UnsteadySystem::CheckSteadyState(), Nektar::AcousticSystem::DoOdeRhs(), ErrorExtraPoints(), Nektar::CoupledLinearNS::EvaluateNewtonRHS(), GetTime(), SetTime(), Nektar::IncNavierStokes::SetWomersleyBoundary(), Nektar::SolverUtils::FileSolution::v_DoInitialise(), Nektar::PulseWaveSystem::v_DoInitialise(), Nektar::SolverUtils::UnsteadySystem::v_DoInitialise(), Nektar::VelocityCorrectionScheme::v_DoInitialise(), Nektar::SolverUtils::UnsteadySystem::v_DoSolve(), Nektar::MMFAdvection::v_DoSolve(), Nektar::IterativeElasticSystem::v_DoSolve(), Nektar::MMFMaxwell::v_DoSolve(), Nektar::PulseWaveSystem::v_DoSolve(), Nektar::MMFSWE::v_DoSolve(), v_H1Error(), v_InitObject(), Nektar::PulseWaveSystem::v_InitObject(), Nektar::SolverUtils::UnsteadySystem::v_InitObject(), Nektar::IncNavierStokes::v_InitObject(), Nektar::APE::v_InitObject(), Nektar::LEE::v_InitObject(), Nektar::MMFSWE::v_L2Error(), v_L2Error(), Nektar::PulseWaveSystem::v_L2Error(), Nektar::MMFSWE::v_LinfError(), v_LinfError(), Nektar::PulseWaveSystem::v_LinfError(), Nektar::Dummy::v_PostIntegrate(), Nektar::VelocityCorrectionScheme::v_PostIntegrate(), Nektar::SolverUtils::FileSolution::v_PostIntegrate(), Nektar::AcousticSystem::v_PreIntegrate(), Nektar::UnsteadyAdvectionDiffusion::v_PreIntegrate(), Nektar::Dummy::v_PreIntegrate(), Nektar::IncNavierStokes::v_PreIntegrate(), Nektar::SolverUtils::UnsteadySystem::v_PrintStatusInformation(), v_SetInitialConditions(), Nektar::VCSImplicit::v_SetUpPressureForcing(), Nektar::VCSImplicit::v_SetUpViscousForcing(), Nektar::CompressibleFlowSystem::v_SteadyStateResidual(), Nektar::CFSImplicit::v_UpdateTimeStepCheck(), Nektar::AcousticSystem::WhiteNoiseBC(), WriteFld(), and Nektar::PulseWaveSystem::WriteVessels().

◆ m_TimeIncrementFactor

NekDouble Nektar::SolverUtils::EquationSystem::m_TimeIncrementFactor
protected

◆ m_timestep

NekDouble Nektar::SolverUtils::EquationSystem::m_timestep
protected

◆ m_traceNormals

Array<OneD, Array<OneD, NekDouble> > Nektar::SolverUtils::EquationSystem::m_traceNormals
protected

◆ m_useFFT

bool Nektar::SolverUtils::EquationSystem::m_useFFT
protected

Flag to determine if FFT is used for homogeneous transform.

Definition at line 514 of file EquationSystem.h.

Referenced by SessionSummary(), v_InitObject(), and Nektar::CoupledLinearNS::v_InitObject().

◆ m_verbose

bool Nektar::SolverUtils::EquationSystem::m_verbose
protected

Definition at line 458 of file EquationSystem.h.

Referenced by Nektar::CFSImplicit::CalcRefValues(), and v_InitObject().

◆ m_windowPIT

int Nektar::SolverUtils::EquationSystem::m_windowPIT = 0
protected

Index of windows for parallel-in-time time iteration.

Definition at line 502 of file EquationSystem.h.

Referenced by SetWindowNumberPIT(), v_Output(), and Nektar::CoupledLinearNS::v_Output().

◆ projectionTypeLookupIds

std::string Nektar::SolverUtils::EquationSystem::projectionTypeLookupIds
staticprotected