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 SetUpTraceNormals (void)
 
SOLVER_UTILS_EXPORT void InitObject (bool DeclareField=true)
 Initialises the members of this object. More...
 
SOLVER_UTILS_EXPORT void DoInitialise ()
 Perform any initialisation necessary before solving the problem. More...
 
SOLVER_UTILS_EXPORT void DoSolve ()
 Solve the problem. More...
 
SOLVER_UTILS_EXPORT void TransCoeffToPhys ()
 Transform from coefficient to physical space. More...
 
SOLVER_UTILS_EXPORT void TransPhysToCoeff ()
 Transform from physical to coefficient space. More...
 
SOLVER_UTILS_EXPORT void Output ()
 Perform output operations after solve. More...
 
SOLVER_UTILS_EXPORT NekDouble LinfError (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray)
 Linf error computation. More...
 
SOLVER_UTILS_EXPORT std::string GetSessionName ()
 Get Session name. More...
 
template<class T >
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 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 GetFinalTime ()
 Return final time. More...
 
SOLVER_UTILS_EXPORT int GetNcoeffs ()
 
SOLVER_UTILS_EXPORT int GetNcoeffs (const int eid)
 
SOLVER_UTILS_EXPORT int GetNumExpModes ()
 
SOLVER_UTILS_EXPORT const Array< OneD, int > GetNumExpModesPerExp ()
 
SOLVER_UTILS_EXPORT int GetNvariables ()
 
SOLVER_UTILS_EXPORT const std::string GetVariable (unsigned int i)
 
SOLVER_UTILS_EXPORT int GetTraceTotPoints ()
 
SOLVER_UTILS_EXPORT int GetTraceNpoints ()
 
SOLVER_UTILS_EXPORT int GetExpSize ()
 
SOLVER_UTILS_EXPORT int GetPhys_Offset (int n)
 
SOLVER_UTILS_EXPORT int GetCoeff_Offset (int n)
 
SOLVER_UTILS_EXPORT int GetTotPoints ()
 
SOLVER_UTILS_EXPORT int GetTotPoints (int n)
 
SOLVER_UTILS_EXPORT int GetNpoints ()
 
SOLVER_UTILS_EXPORT int GetSteps ()
 
SOLVER_UTILS_EXPORT NekDouble GetTimeStep ()
 
SOLVER_UTILS_EXPORT void CopyFromPhysField (const int i, Array< OneD, NekDouble > &output)
 
SOLVER_UTILS_EXPORT void CopyToPhysField (const int i, Array< OneD, NekDouble > &output)
 
SOLVER_UTILS_EXPORT void SetSteps (const int steps)
 
SOLVER_UTILS_EXPORT void ZeroPhysFields ()
 
SOLVER_UTILS_EXPORT void FwdTransFields ()
 
SOLVER_UTILS_EXPORT void 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 Array< OneD, const Array< OneD, NekDouble > > GetTraceNormals ()
 
SOLVER_UTILS_EXPORT void SetTime (const NekDouble time)
 
SOLVER_UTILS_EXPORT void SetInitialStep (const int step)
 
SOLVER_UTILS_EXPORT void SetBoundaryConditions (NekDouble time)
 Evaluates the boundary conditions at the given time. More...
 
virtual SOLVER_UTILS_EXPORT bool v_NegatedOp ()
 Virtual function to identify if operator is negated in DoSolve. More...
 

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 ()
 Virtual function for initialisation implementation. More...
 
virtual SOLVER_UTILS_EXPORT void v_DoSolve ()
 Virtual function for solve implementation. More...
 
virtual SOLVER_UTILS_EXPORT NekDouble v_LinfError (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray)
 Virtual function for the L_inf error computation between fields and a given exact solution. More...
 
virtual SOLVER_UTILS_EXPORT NekDouble v_L2Error (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray, bool Normalised=false)
 Virtual function for the L_2 error computation between fields and a given exact solution. More...
 
virtual SOLVER_UTILS_EXPORT void v_TransCoeffToPhys ()
 Virtual function for transformation to physical space. More...
 
virtual SOLVER_UTILS_EXPORT void v_TransPhysToCoeff ()
 Virtual function for transformation to coefficient space. More...
 
virtual SOLVER_UTILS_EXPORT void v_GenerateSummary (SummaryList &l)
 Virtual function for generating summary information. More...
 
virtual SOLVER_UTILS_EXPORT void v_SetInitialConditions (NekDouble initialtime=0.0, bool dumpInitialConditions=true, const int domain=0)
 
virtual SOLVER_UTILS_EXPORT void v_EvaluateExactSolution (unsigned int field, Array< OneD, NekDouble > &outfield, const NekDouble time)
 
virtual SOLVER_UTILS_EXPORT void v_Output (void)
 
virtual SOLVER_UTILS_EXPORT MultiRegions::ExpListSharedPtr v_GetPressure (void)
 
virtual SOLVER_UTILS_EXPORT 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
 
bool m_root
 
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_timestepMax = -1.0
 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_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_movingFrameVelsxyz
 Moving frame of reference velocities. More...
 
Array< OneD, NekDoublem_movingFrameTheta
 Moving frame of reference angles with respect to the. More...
 
boost::numeric::ublas::matrix< NekDoublem_movingFrameProjMat
 Projection matrix for transformation between inertial and moving. More...
 
int m_NumQuadPointsError
 Number of Quadrature points used to work out the error. More...
 
enum HomogeneousType m_HomogeneousType
 
NekDouble m_LhomX
 physical length in X direction (if homogeneous) More...
 
NekDouble m_LhomY
 physical length in Y direction (if homogeneous) More...
 
NekDouble m_LhomZ
 physical length in Z direction (if homogeneous) More...
 
int m_npointsX
 number of points in X direction (if homogeneous) More...
 
int m_npointsY
 number of points in Y direction (if homogeneous) More...
 
int m_npointsZ
 number of points in Z direction (if homogeneous) More...
 
int m_HomoDirec
 number of homogenous directions More...
 

Static Protected Attributes

static std::string equationSystemTypeLookupIds []
 

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 76 of file EquationSystem.h.

Member Enumeration Documentation

◆ HomogeneousType

Parameter for homogeneous expansions.

Enumerator
eHomogeneous1D 
eHomogeneous2D 
eHomogeneous3D 
eNotHomogeneous 

Definition at line 414 of file EquationSystem.h.

Constructor & Destructor Documentation

◆ ~EquationSystem()

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

Destructor.

Destructor for class EquationSystem.

Definition at line 673 of file EquationSystem.cpp.

674 {
675  LibUtilities::NekManager<LocalRegions::MatrixKey, DNekScalMat,
676  LocalRegions::MatrixKey::opLess>::ClearManager();
677  LibUtilities::NekManager<LocalRegions::MatrixKey, DNekScalBlkMat,
678  LocalRegions::MatrixKey::opLess>::ClearManager();
679 }
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 96 of file EquationSystem.cpp.

99  : m_comm(pSession->GetComm()), m_session(pSession), m_graph(pGraph),
101 {
102  // set up session names in fieldMetaDataMap
103  const vector<std::string> filenames = m_session->GetFilenames();
104 
105  for (int i = 0; i < filenames.size(); ++i)
106  {
107  string sessionname = "SessionName";
108  sessionname += boost::lexical_cast<std::string>(i);
109  m_fieldMetaDataMap[sessionname] = filenames[i];
110  m_fieldMetaDataMap["ChkFileNum"] = boost::lexical_cast<std::string>(0);
111  }
112 }
SpatialDomains::MeshGraphSharedPtr m_graph
Pointer to graph defining mesh.
LibUtilities::CommSharedPtr m_comm
Communicator.
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:53

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 114 of file EquationSystem.h.

115  {
116  return std::dynamic_pointer_cast<T>(shared_from_this());
117  }

◆ 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 1111 of file EquationSystem.cpp.

1112 {
1113  std::string outname =
1114  m_sessionName + "_BaseFlow_" + boost::lexical_cast<std::string>(n);
1115 
1116  WriteFld(outname + ".chk");
1117 }
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 1086 of file EquationSystem.cpp.

1087 {
1088  std::string outname =
1089  m_sessionName + "_" + boost::lexical_cast<std::string>(n);
1090  WriteFld(outname + ".chk");
1091 }

References m_sessionName, and WriteFld().

Referenced by 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(), Nektar::IsentropicVortex::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 1097 of file EquationSystem.cpp.

1101 {
1102  std::string outname =
1103  m_sessionName + "_" + boost::lexical_cast<std::string>(n);
1104  WriteFld(outname, field, fieldcoeffs, variables);
1105 }

References m_sessionName, and WriteFld().

◆ CopyFromPhysField()

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

Definition at line 750 of file EquationSystem.h.

752 {
753  Vmath::Vcopy(output.size(), m_fields[i]->GetPhys(), 1, output, 1);
754 }
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.cpp:1255

References m_fields, and Vmath::Vcopy().

◆ CopyToPhysField()

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

Definition at line 756 of file EquationSystem.h.

758 {
759  Vmath::Vcopy(output.size(), output, 1, m_fields[i]->UpdatePhys(), 1);
760 }

References m_fields, and Vmath::Vcopy().

◆ DoInitialise()

void Nektar::SolverUtils::EquationSystem::DoInitialise ( )
inline

Perform any initialisation necessary before solving the problem.

This allows initialisation of the solver which cannot be completed during object construction (such as setting of initial conditions).

Public interface routine to virtual function implementation.

Definition at line 516 of file EquationSystem.h.

517 {
518  v_DoInitialise();
519 }
virtual SOLVER_UTILS_EXPORT void v_DoInitialise()
Virtual function for initialisation implementation.

References v_DoInitialise().

◆ DoSolve()

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

Solve the problem.

Performs the actual solve.

Public interface routine to virtual function implementation.

Definition at line 546 of file EquationSystem.h.

547 {
548  v_DoSolve();
549 }
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-norm, L-inf for a larger number of quadrature points.

Parameters
fieldThe field to compare.
Returns
Error in the L2-norm and L-inf norm.

Definition at line 839 of file EquationSystem.cpp.

840 {
841  int NumModes = GetNumExpModes();
842  Array<OneD, NekDouble> L2INF(2);
843 
844  const LibUtilities::PointsKey PkeyT1(m_NumQuadPointsError,
846  const LibUtilities::PointsKey PkeyT2(m_NumQuadPointsError,
847  LibUtilities::eGaussRadauMAlpha1Beta0);
848  const LibUtilities::PointsKey PkeyQ1(m_NumQuadPointsError,
850  const LibUtilities::PointsKey PkeyQ2(m_NumQuadPointsError,
852  const LibUtilities::BasisKey BkeyT1(LibUtilities::eModified_A, NumModes,
853  PkeyT1);
854  const LibUtilities::BasisKey BkeyT2(LibUtilities::eModified_B, NumModes,
855  PkeyT2);
856  const LibUtilities::BasisKey BkeyQ1(LibUtilities::eModified_A, NumModes,
857  PkeyQ1);
858  const LibUtilities::BasisKey BkeyQ2(LibUtilities::eModified_A, NumModes,
859  PkeyQ2);
860 
861  LibUtilities::BasisKeyVector Tkeys, Qkeys;
862 
863  // make a copy of the ExpansionInfoMap
864  SpatialDomains::ExpansionInfoMap NewExpInfo = m_graph->GetExpansionInfo();
867  NewExpInfo);
868 
869  // reset new graph with new keys
870  Tkeys.push_back(BkeyT1);
871  Tkeys.push_back(BkeyT2);
872  m_graph->ResetExpansionInfoToBasisKey(ExpInfo, LibUtilities::eTriangle,
873  Tkeys);
874  Qkeys.push_back(BkeyQ1);
875  Qkeys.push_back(BkeyQ2);
876  m_graph->ResetExpansionInfoToBasisKey(ExpInfo, LibUtilities::eQuadrilateral,
877  Qkeys);
878 
881  NewExpInfo);
882 
883  int ErrorCoordim = ErrorExp->GetCoordim(0);
884  int ErrorNq = ErrorExp->GetTotPoints();
885 
886  Array<OneD, NekDouble> ErrorXc0(ErrorNq, 0.0);
887  Array<OneD, NekDouble> ErrorXc1(ErrorNq, 0.0);
888  Array<OneD, NekDouble> ErrorXc2(ErrorNq, 0.0);
889 
890  switch (ErrorCoordim)
891  {
892  case 1:
893  ErrorExp->GetCoords(ErrorXc0);
894  break;
895  case 2:
896  ErrorExp->GetCoords(ErrorXc0, ErrorXc1);
897  break;
898  case 3:
899  ErrorExp->GetCoords(ErrorXc0, ErrorXc1, ErrorXc2);
900  break;
901  }
903  m_session->GetFunction("ExactSolution", field);
904 
905  // Evaluate the exact solution
906  Array<OneD, NekDouble> ErrorSol(ErrorNq);
907 
908  exSol->Evaluate(ErrorXc0, ErrorXc1, ErrorXc2, m_time, ErrorSol);
909 
910  // Calcualte spectral/hp approximation on the quadrature points
911  // of this new expansion basis
912  ErrorExp->BwdTrans(m_fields[field]->GetCoeffs(), ErrorExp->UpdatePhys());
913 
914  L2INF[0] = ErrorExp->L2(ErrorExp->GetPhys(), ErrorSol);
915  L2INF[1] = ErrorExp->Linf(ErrorExp->GetPhys(), ErrorSol);
916 
917  return L2INF;
918 }
static std::shared_ptr< DataType > AllocateSharedPtr(const Args &...args)
Allocate a shared pointer from the memory pool.
NekDouble m_time
Current time of simulation.
int m_NumQuadPointsError
Number of Quadrature points used to work out the error.
SOLVER_UTILS_EXPORT int GetNumExpModes()
std::vector< BasisKey > BasisKeyVector
Name for a vector of BasisKeys.
std::shared_ptr< Equation > EquationSharedPtr
Definition: Equation.h:130
@ eGaussLobattoLegendre
1D Gauss-Lobatto-Legendre quadrature points
Definition: PointsType.h:53
@ eModified_B
Principle Modified Functions .
Definition: BasisType.h:51
@ eModified_A
Principle Modified Functions .
Definition: BasisType.h:50
std::shared_ptr< ExpList > ExpListSharedPtr
Shared pointer to an ExpList object.
std::shared_ptr< ExpansionInfoMap > ExpansionInfoMapShPtr
Definition: MeshGraph.h:145
std::map< int, ExpansionInfoShPtr > ExpansionInfoMap
Definition: MeshGraph.h:143

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

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

◆ EvaluateExactSolution()

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

Evaluates an exact solution.

Definition at line 644 of file EquationSystem.h.

646 {
647  v_EvaluateExactSolution(field, outfield, time);
648 }
virtual SOLVER_UTILS_EXPORT void v_EvaluateExactSolution(unsigned int field, Array< OneD, NekDouble > &outfield, const NekDouble time)

References v_EvaluateExactSolution().

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

◆ ExtraFldOutput()

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

Append the coefficients and name of variables with solver specific extra variables

Parameters
fieldcoeffsVector with coefficients
variablesVector with name of variables

Definition at line 595 of file EquationSystem.h.

598 {
599  v_ExtraFldOutput(fieldcoeffs, variables);
600 }
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 1072 of file EquationSystem.cpp.

1073 {
1074  for (int i = 0; i < m_fields.size(); i++)
1075  {
1076  m_fields[i]->FwdTrans(m_fields[i]->GetPhys(),
1077  m_fields[i]->UpdateCoeffs());
1078  m_fields[i]->SetPhysState(false);
1079  }
1080 }

References m_fields.

◆ GetCheckpointNumber()

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

Definition at line 281 of file EquationSystem.h.

282  {
283  return m_nchk;
284  }
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 291 of file EquationSystem.h.

292  {
293  return m_checksteps;
294  }
int m_checksteps
Number of steps between checkpoints.

References m_checksteps.

◆ GetCoeff_Offset()

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

Definition at line 715 of file EquationSystem.h.

716 {
717  return m_fields[0]->GetCoeff_Offset(n);
718 }

References m_fields.

◆ GetExpSize()

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

◆ GetFinalTime()

NekDouble Nektar::SolverUtils::EquationSystem::GetFinalTime ( )
inline

Return final time.

Definition at line 657 of file EquationSystem.h.

658 {
659  return m_time;
660 }

References m_time.

◆ 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 681 of file EquationSystem.cpp.

683 {
684  MultiRegions::ExpListSharedPtr vField = field;
685  if (!field)
686  {
687  vField = m_fields[0];
688  }
689 
690  if (cache)
691  {
692  if ((m_sessionFunctions.find(name) == m_sessionFunctions.end()) ||
693  (m_sessionFunctions[name]->GetSession() != m_session) ||
694  (m_sessionFunctions[name]->GetExpansion() != vField))
695  {
698  m_session, vField, name, cache);
699  }
700 
701  return m_sessionFunctions[name];
702  }
703  else
704  {
706  new SessionFunction(m_session, vField, name, cache));
707  }
708 }
std::map< std::string, SolverUtils::SessionFunctionSharedPtr > m_sessionFunctions
Map of known SessionFunctions.
std::shared_ptr< SessionFunction > SessionFunctionSharedPtr

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), 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(), Nektar::BidomainRoth::v_InitObject(), Nektar::Monodomain::v_InitObject(), Nektar::PulseWaveSystem::v_InitObject(), Nektar::APE::v_InitObject(), Nektar::LEE::v_InitObject(), Nektar::CFLtester::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(), Nektar::UnsteadyAdvectionDiffusion::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().

◆ GetNcoeffs() [1/2]

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

Definition at line 662 of file EquationSystem.h.

663 {
664  return m_fields[0]->GetNcoeffs();
665 }

References m_fields.

Referenced by Nektar::LinearSWE::AddCoriolis(), Nektar::NonlinearPeregrine::AddCoriolis(), Nektar::NonlinearSWE::AddCoriolis(), Nektar::NonlinearPeregrine::AddVariableDepth(), Nektar::NonlinearSWE::AddVariableDepth(), Nektar::CoupledLinearNS::DefineForcingTerm(), Nektar::CFLtester::DoOdeProjection(), Nektar::MMFAdvection::DoOdeProjection(), Nektar::UnsteadyAdvectionDiffusion::DoOdeProjection(), Nektar::UnsteadyDiffusion::DoOdeProjection(), Nektar::UnsteadyInviscidBurger::DoOdeProjection(), Nektar::UnsteadyReactionDiffusion::DoOdeProjection(), Nektar::LinearSWE::DoOdeProjection(), Nektar::NonlinearPeregrine::DoOdeProjection(), Nektar::NonlinearSWE::DoOdeProjection(), Nektar::MMFMaxwell::DoOdeRhs(), Nektar::MMFSWE::DoOdeRhs(), Nektar::NonlinearPeregrine::DoOdeRhs(), Nektar::CFSImplicit::DoOdeRhsCoeff(), ImportFld(), ImportFldToMultiDomains(), Nektar::CFSImplicit::MultiplyElmtInvMassPlusSource(), Nektar::VelocityCorrectionScheme::SetupFlowrate(), Nektar::CoupledLinearNS::Solve(), Nektar::CoupledLinearNS::SolveLinearNS(), Nektar::CoupledLinearNS::SolveSteadyNavierStokes(), Nektar::CoupledLinearNS::SolveUnsteadyStokesSystem(), Nektar::LEE::v_AddLinTerm(), Nektar::NavierStokesImplicitCFE::v_DoDiffusionCoeff(), Nektar::EigenValuesAdvection::v_DoSolve(), Nektar::Laplace::v_DoSolve(), Nektar::Projection::v_DoSolve(), Nektar::SteadyAdvectionDiffusion::v_DoSolve(), Nektar::AcousticSystem::v_ExtraFldOutput(), Nektar::CoupledLinearNS::v_Output(), v_SetInitialConditions(), Nektar::MMFAdvection::WeakDGDirectionalAdvection(), Nektar::MMFMaxwell::WeakDGMaxwellDirDeriv(), Nektar::MMFSWE::WeakDGSWEDirDeriv(), WriteFld(), and Nektar::PulseWaveSystem::WriteVessels().

◆ GetNcoeffs() [2/2]

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

Definition at line 667 of file EquationSystem.h.

668 {
669  return m_fields[0]->GetNcoeffs(eid);
670 }

References m_fields.

◆ GetNpoints()

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

Definition at line 730 of file EquationSystem.h.

731 {
732  return m_fields[0]->GetNpoints();
733 }

References m_fields.

Referenced by Nektar::MMFMaxwell::ComputeMaterialMicroWaveCloak(), Nektar::MMFMaxwell::ComputeMaterialOpticalCloak(), Nektar::MMFMaxwell::ComputeRadCloak(), Nektar::CFLtester::DoOdeProjection(), Nektar::MMFAdvection::DoOdeProjection(), Nektar::UnsteadyAdvection::DoOdeProjection(), Nektar::UnsteadyAdvectionDiffusion::DoOdeProjection(), Nektar::UnsteadyDiffusion::DoOdeProjection(), Nektar::UnsteadyInviscidBurger::DoOdeProjection(), Nektar::UnsteadyViscousBurgers::DoOdeProjection(), Nektar::CompressibleFlowSystem::DoOdeProjection(), Nektar::ImageWarpingSystem::DoOdeProjection(), Nektar::MMFMaxwell::DoOdeProjection(), Nektar::LinearSWE::DoOdeProjection(), Nektar::NonlinearPeregrine::DoOdeProjection(), Nektar::NonlinearSWE::DoOdeProjection(), Nektar::CFLtester::DoOdeRhs(), Nektar::MMFAdvection::DoOdeRhs(), Nektar::UnsteadyAdvection::DoOdeRhs(), Nektar::UnsteadyAdvectionDiffusion::DoOdeRhs(), Nektar::UnsteadyInviscidBurger::DoOdeRhs(), Nektar::UnsteadyViscousBurgers::DoOdeRhs(), Nektar::CompressibleFlowSystem::DoOdeRhs(), Nektar::ImageWarpingSystem::DoOdeRhs(), Nektar::UnsteadyInviscidBurger::GetFluxVector(), Nektar::UnsteadyInviscidBurger::GetNormalVelocity(), Nektar::CFSImplicit::NumCalcRiemFluxJac(), Nektar::CoupledLinearNS::Solve(), Nektar::SolverUtils::UnsteadySystem::v_AppendOutput1D(), Nektar::NavierStokesCFE::v_DoDiffusion(), Nektar::NavierStokesCFEAxisym::v_DoDiffusion(), Nektar::NavierStokesImplicitCFE::v_DoDiffusionCoeff(), Nektar::EigenValuesAdvection::v_DoSolve(), Nektar::LinearElasticSystem::v_DoSolve(), 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()

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

Definition at line 672 of file EquationSystem.h.

673 {
674  return m_graph->GetExpansionInfo()
675  .begin()
676  ->second->m_basisKeyVector[0]
677  .GetNumModes();
678 }

References m_graph.

Referenced by ErrorExtraPoints().

◆ GetNumExpModesPerExp()

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

Definition at line 680 of file EquationSystem.h.

681 {
682  return m_fields[0]->EvalBasisNumModesMaxPerExp();
683 }

References m_fields.

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

◆ GetNvariables()

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

Definition at line 685 of file EquationSystem.h.

686 {
687  return m_session->GetVariables().size();
688 }

References m_session.

Referenced by ImportFldToMultiDomains().

◆ GetPhys_Offset()

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

Definition at line 710 of file EquationSystem.h.

711 {
712  return m_fields[0]->GetPhys_Offset(n);
713 }

References m_fields.

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

◆ GetPressure()

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

Get pressure field if available.

Get Pressure field if available

Definition at line 583 of file EquationSystem.h.

584 {
585  return v_GetPressure();
586 }
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 126 of file EquationSystem.h.

127  {
128  return m_session;
129  }

References m_session.

◆ GetSessionName()

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

Get Session name.

Definition at line 109 of file EquationSystem.h.

110  {
111  return m_sessionName;
112  }

References m_sessionName.

◆ GetSteps()

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

Definition at line 735 of file EquationSystem.h.

736 {
737  return m_steps;
738 }
int m_steps
Number of steps to take.

References m_steps.

◆ GetTimeStep()

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

Definition at line 740 of file EquationSystem.h.

741 {
742  return m_timestep;
743 }
NekDouble m_timestep
Time step size.

References m_timestep.

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

◆ GetTotPoints() [1/2]

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

Definition at line 720 of file EquationSystem.h.

721 {
722  return m_fields[0]->GetNpoints();
723 }

References m_fields.

Referenced by Nektar::LinearSWE::AddCoriolis(), Nektar::NonlinearPeregrine::AddCoriolis(), Nektar::NonlinearSWE::AddCoriolis(), Nektar::SolverUtils::MMFSystem::AdddedtMaxwell(), Nektar::NonlinearPeregrine::AddVariableDepth(), Nektar::NonlinearSWE::AddVariableDepth(), Nektar::SolverUtils::UnsteadySystem::CheckSteadyState(), Nektar::SolverUtils::MMFSystem::Computedemdxicdote(), Nektar::MMFMaxwell::ComputeEnergyDensity(), Nektar::LinearSWE::ConservativeToPrimitive(), Nektar::MMFSWE::ConservativeToPrimitive(), Nektar::NonlinearPeregrine::ConservativeToPrimitive(), Nektar::NonlinearSWE::ConservativeToPrimitive(), Nektar::CoupledLinearNS::Continuation(), Nektar::CoupledLinearNS::DefineForcingTerm(), Nektar::SolverUtils::MMFSystem::DeriveCrossProductMF(), Nektar::AcousticSystem::DoOdeRhs(), Nektar::MMFDiffusion::DoOdeRhs(), Nektar::Dummy::DoOdeRhs(), Nektar::MMFMaxwell::DoOdeRhs(), Nektar::LinearSWE::DoOdeRhs(), Nektar::MMFSWE::DoOdeRhs(), Nektar::NonlinearPeregrine::DoOdeRhs(), Nektar::NonlinearSWE::DoOdeRhs(), Nektar::MMFMaxwell::EvaluateCoriolis(), Nektar::MMFSWE::EvaluateCoriolisForZonalFlow(), Nektar::CoupledLinearNS::EvaluateNewtonRHS(), Nektar::MMFSWE::EvaluateStandardCoriolis(), Nektar::MMFSWE::EvaluateWaterDepth(), Nektar::RinglebFlow::GetExactRinglebFlow(), Nektar::CFLtester::GetStdVelocity(), Nektar::MMFSWE::IsolatedMountainFlow(), Nektar::NonlinearPeregrine::LaitoneSolitaryWave(), Nektar::MMFDiffusion::Morphogenesis(), Nektar::CFSImplicit::MultiplyElmtInvMassPlusSource(), Nektar::MMFDiffusion::PlanePhiWave(), Nektar::LinearSWE::PrimitiveToConservative(), Nektar::MMFSWE::PrimitiveToConservative(), Nektar::NonlinearPeregrine::PrimitiveToConservative(), Nektar::NonlinearSWE::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::NavierStokesImplicitCFE::v_CalcPhysDeriv(), Nektar::LinearSWE::v_ConservativeToPrimitive(), Nektar::NonlinearPeregrine::v_ConservativeToPrimitive(), Nektar::NonlinearSWE::v_ConservativeToPrimitive(), Nektar::CoupledLinearNS::v_DoInitialise(), Nektar::VCSMapping::v_DoInitialise(), Nektar::VelocityCorrectionScheme::v_DoInitialise(), Nektar::MMFMaxwell::v_DoSolve(), Nektar::MMFDiffusion::v_EvaluateExactSolution(), Nektar::IsentropicVortex::v_EvaluateExactSolution(), Nektar::CompressibleFlowSystem::v_GetMaxStdVelocity(), Nektar::APE::v_InitObject(), Nektar::LEE::v_InitObject(), Nektar::ShallowWaterSystem::v_InitObject(), Nektar::Dummy::v_Output(), Nektar::LinearSWE::v_PrimitiveToConservative(), Nektar::NonlinearPeregrine::v_PrimitiveToConservative(), Nektar::NonlinearSWE::v_PrimitiveToConservative(), Nektar::MMFMaxwell::v_SetInitialConditions(), Nektar::MMFSWE::v_SetInitialConditions(), Nektar::MMFDiffusion::v_SetInitialConditions(), Nektar::IsentropicVortex::v_SetInitialConditions(), Nektar::SolverUtils::UnsteadySystem::v_SteadyStateResidual(), Nektar::CompressibleFlowSystem::v_SteadyStateResidual(), and Nektar::NonlinearPeregrine::WCESolve().

◆ GetTotPoints() [2/2]

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

Definition at line 725 of file EquationSystem.h.

726 {
727  return m_fields[0]->GetTotPoints(n);
728 }

References m_fields.

◆ GetTraceNormals()

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

Definition at line 301 of file EquationSystem.h.

302  {
303  return m_traceNormals;
304  }
Array< OneD, Array< OneD, NekDouble > > m_traceNormals
Array holding trace normals for DG simulations in the forwards direction.

References m_traceNormals.

◆ GetTraceNpoints()

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

◆ GetTraceTotPoints()

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

Definition at line 695 of file EquationSystem.h.

696 {
697  return GetTraceNpoints();
698 }
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::NonlinearPeregrine::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::LinearSWE::SetBoundaryConditions(), Nektar::NonlinearPeregrine::SetBoundaryConditions(), Nektar::NonlinearSWE::SetBoundaryConditions(), Nektar::SolverUtils::MMFSystem::UpwindMaxwellFlux1D(), Nektar::NavierStokesCFE::v_DoDiffusion(), Nektar::NavierStokesImplicitCFE::v_DoDiffusionCoeff(), Nektar::NavierStokesCFE::v_ExtraFldOutput(), Nektar::PulseWaveSystem::v_InitObject(), Nektar::MMFSWE::WallBoundary2D(), Nektar::NonlinearPeregrine::WallBoundaryContVariables(), and Nektar::NonlinearPeregrine::WallBoundaryForcing().

◆ GetVariable()

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

Definition at line 690 of file EquationSystem.h.

691 {
692  return m_session->GetVariable(i);
693 }

References m_session.

◆ 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 1225 of file EquationSystem.cpp.

1228 {
1229  std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef;
1230  std::vector<std::vector<NekDouble>> FieldData;
1231  LibUtilities::FieldIOSharedPtr field_fld =
1233  field_fld->Import(infile, FieldDef, FieldData);
1234 
1235  // Copy FieldData into m_fields
1236  for (int j = 0; j < pFields.size(); ++j)
1237  {
1238  Vmath::Zero(pFields[j]->GetNcoeffs(), pFields[j]->UpdateCoeffs(), 1);
1239 
1240  for (int i = 0; i < FieldDef.size(); ++i)
1241  {
1242  ASSERTL1(FieldDef[i]->m_fields[j] == m_session->GetVariable(j),
1243  std::string("Order of ") + infile +
1244  std::string(" data and that defined in "
1245  "m_boundaryconditions differs"));
1246 
1247  pFields[j]->ExtractDataToCoeffs(FieldDef[i], FieldData[i],
1248  FieldDef[i]->m_fields[j],
1249  pFields[j]->UpdateCoeffs());
1250  }
1251  pFields[j]->BwdTrans(pFields[j]->GetCoeffs(), pFields[j]->UpdatePhys());
1252  }
1253 }
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode....
Definition: ErrorUtil.hpp:249
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:227
SOLVER_UTILS_EXPORT int GetNcoeffs()
std::shared_ptr< FieldIO > FieldIOSharedPtr
Definition: FieldIO.h:301
void Zero(int n, T *x, const int incx)
Zero vector.
Definition: Vmath.cpp:492

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 1309 of file EquationSystem.cpp.

1312 {
1313  std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef;
1314  std::vector<std::vector<NekDouble>> FieldData;
1315 
1316  LibUtilities::FieldIOSharedPtr field_fld =
1318  field_fld->Import(infile, FieldDef, FieldData);
1319  int idx = -1;
1320 
1321  Vmath::Zero(pField->GetNcoeffs(), pField->UpdateCoeffs(), 1);
1322 
1323  for (int i = 0; i < FieldDef.size(); ++i)
1324  {
1325  // find the index of the required field in the file.
1326  for (int j = 0; j < FieldData.size(); ++j)
1327  {
1328  if (FieldDef[i]->m_fields[j] == pFieldName)
1329  {
1330  idx = j;
1331  }
1332  }
1333  ASSERTL1(idx >= 0, "Field " + pFieldName + " not found.");
1334 
1335  pField->ExtractDataToCoeffs(FieldDef[i], FieldData[i],
1336  FieldDef[i]->m_fields[idx],
1337  pField->UpdateCoeffs());
1338  }
1339  pField->BwdTrans(pField->GetCoeffs(), pField->UpdatePhys());
1340 }

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 1349 of file EquationSystem.cpp.

1352 {
1353 
1354  ASSERTL0(fieldStr.size() <= coeffs.size(),
1355  "length of fieldstr should be the same as pFields");
1356 
1357  std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef;
1358  std::vector<std::vector<NekDouble>> FieldData;
1359 
1360  LibUtilities::FieldIOSharedPtr field_fld =
1362  field_fld->Import(infile, FieldDef, FieldData);
1363 
1364  // Copy FieldData into m_fields
1365  for (int j = 0; j < fieldStr.size(); ++j)
1366  {
1367  Vmath::Zero(coeffs[j].size(), coeffs[j], 1);
1368  for (int i = 0; i < FieldDef.size(); ++i)
1369  {
1370  m_fields[0]->ExtractDataToCoeffs(FieldDef[i], FieldData[i],
1371  fieldStr[j], coeffs[j]);
1372  }
1373  }
1374 }
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:215

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 1263 of file EquationSystem.cpp.

1266 {
1267  std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef;
1268  std::vector<std::vector<NekDouble>> FieldData;
1269 
1270  LibUtilities::Import(infile, FieldDef, FieldData);
1271 
1272  int nvariables = GetNvariables();
1273 
1274  ASSERTL0(
1275  ndomains * nvariables == pFields.size(),
1276  "Number of fields does not match the number of variables and domains");
1277 
1278  // Copy FieldData into m_fields
1279  for (int j = 0; j < ndomains; ++j)
1280  {
1281  for (int i = 0; i < nvariables; ++i)
1282  {
1283  Vmath::Zero(pFields[j * nvariables + i]->GetNcoeffs(),
1284  pFields[j * nvariables + i]->UpdateCoeffs(), 1);
1285 
1286  for (int n = 0; n < FieldDef.size(); ++n)
1287  {
1288  ASSERTL1(FieldDef[n]->m_fields[i] == m_session->GetVariable(i),
1289  std::string("Order of ") + infile +
1290  std::string(" data and that defined in "
1291  "m_boundaryconditions differs"));
1292 
1293  pFields[j * nvariables + i]->ExtractDataToCoeffs(
1294  FieldDef[n], FieldData[n], FieldDef[n]->m_fields[i],
1295  pFields[j * nvariables + i]->UpdateCoeffs());
1296  }
1297  pFields[j * nvariables + i]->BwdTrans(
1298  pFields[j * nvariables + i]->GetCoeffs(),
1299  pFields[j * nvariables + i]->UpdatePhys());
1300  }
1301  }
1302 }
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:291

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

◆ InitObject()

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

Initialises the members of this object.

This is the second part of the two-phase initialisation process. Calls to virtual functions will correctly resolve to the derived class during this phase of the construction.

Definition at line 505 of file EquationSystem.h.

506 {
507  v_InitObject(DeclareField);
508 }
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 167 of file EquationSystem.h.

169  {
170  return L2Error(field, NullNekDouble1DArray, Normalised);
171  }
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 L2Error(), and Nektar::NullNekDouble1DArray.

◆ L2Error() [2/2]

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.

L_2 Error computation Public interface routine to virtual function implementation.

Definition at line 573 of file EquationSystem.h.

576 {
577  return v_L2Error(field, exactsoln, Normalised);
578 }
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 v_L2Error().

Referenced by L2Error().

◆ LinfError()

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

Linf error computation.

L_inf Error computation Public interface routine to virtual function implementation.

Definition at line 563 of file EquationSystem.h.

565 {
566  return v_LinfError(field, exactsoln);
567 }
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 v_LinfError().

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

◆ Output()

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

Perform output operations after solve.

Perform output operations after solve.

Definition at line 554 of file EquationSystem.h.

555 {
556  v_Output();
557 }
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 493 of file EquationSystem.h.

495  {
496  LibUtilities::PrintProgressbar(position, goal, "Interpolating");
497  }
int PrintProgressbar(const int position, const int goal, const std::string message, int lastprogress=-1)
Prints a progressbar.
Definition: Progressbar.hpp:67

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 609 of file EquationSystem.h.

610 {
611  if (m_session->GetComm()->GetRank() == 0)
612  {
613  std::vector<std::pair<std::string, std::string>> vSummary;
614  v_GenerateSummary(vSummary);
615 
616  out << "==============================================================="
617  "========"
618  << std::endl;
619  for (auto &x : vSummary)
620  {
621  out << "\t";
622  out.width(20);
623  out << x.first << ": " << x.second << std::endl;
624  }
625  out << "==============================================================="
626  "========"
627  << std::endl;
628  }
629 }
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 120 of file EquationSystem.h.

121  {
122  m_sessionName = newname;
123  }

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 1380 of file EquationSystem.cpp.

1381 {
1382  AddSummaryItem(s, "EquationType", m_session->GetSolverInfo("EQTYPE"));
1383  AddSummaryItem(s, "Session Name", m_sessionName);
1384  AddSummaryItem(s, "Spatial Dim.", m_spacedim);
1385  AddSummaryItem(s, "Max SEM Exp. Order",
1386  m_fields[0]->EvalBasisNumModesMax());
1387 
1388  if (m_session->GetComm()->GetSize() > 1)
1389  {
1390  AddSummaryItem(s, "Num. Processes", m_session->GetComm()->GetSize());
1391  }
1392 
1394  {
1395  AddSummaryItem(s, "Quasi-3D", "Homogeneous in z-direction");
1396  AddSummaryItem(s, "Expansion Dim.", m_expdim + 1);
1397  AddSummaryItem(s, "Num. Hom. Modes (z)", m_npointsZ);
1398  AddSummaryItem(s, "Hom. length (LZ)", m_LhomZ);
1399  AddSummaryItem(s, "FFT Type", m_useFFT ? "FFTW" : "MVM");
1400  if (m_halfMode)
1401  {
1402  AddSummaryItem(s, "ModeType", "Half Mode");
1403  }
1404  else if (m_singleMode)
1405  {
1406  AddSummaryItem(s, "ModeType", "Single Mode");
1407  }
1408  else if (m_multipleModes)
1409  {
1410  AddSummaryItem(s, "ModeType", "Multiple Modes");
1411  }
1412  }
1413  else if (m_HomogeneousType == eHomogeneous2D)
1414  {
1415  AddSummaryItem(s, "Quasi-3D", "Homogeneous in yz-plane");
1416  AddSummaryItem(s, "Expansion Dim.", m_expdim + 2);
1417  AddSummaryItem(s, "Num. Hom. Modes (y)", m_npointsY);
1418  AddSummaryItem(s, "Num. Hom. Modes (z)", m_npointsZ);
1419  AddSummaryItem(s, "Hom. length (LY)", m_LhomY);
1420  AddSummaryItem(s, "Hom. length (LZ)", m_LhomZ);
1421  AddSummaryItem(s, "FFT Type", m_useFFT ? "FFTW" : "MVM");
1422  }
1423  else
1424  {
1425  AddSummaryItem(s, "Expansion Dim.", m_expdim);
1426  }
1427 
1428  if (m_session->DefinesSolverInfo("UpwindType"))
1429  {
1430  AddSummaryItem(s, "Riemann Solver",
1431  m_session->GetSolverInfo("UpwindType"));
1432  }
1433 
1434  if (m_session->DefinesSolverInfo("AdvectionType"))
1435  {
1436  std::string AdvectionType;
1437  AdvectionType = m_session->GetSolverInfo("AdvectionType");
1439  s, "Advection Type",
1440  GetAdvectionFactory().GetClassDescription(AdvectionType));
1441  }
1442 
1444  {
1445  AddSummaryItem(s, "Projection Type", "Continuous Galerkin");
1446  }
1448  {
1449  AddSummaryItem(s, "Projection Type", "Discontinuous Galerkin");
1450  }
1452  {
1453  AddSummaryItem(s, "Projection Type",
1454  "Mixed Continuous Galerkin and Discontinuous");
1455  }
1456 
1457  if (m_session->DefinesSolverInfo("DiffusionType"))
1458  {
1459  std::string DiffusionType;
1460  DiffusionType = m_session->GetSolverInfo("DiffusionType");
1462  s, "Diffusion Type",
1463  GetDiffusionFactory().GetClassDescription(DiffusionType));
1464  }
1465 }
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:47
DiffusionFactory & GetDiffusionFactory()
Definition: Diffusion.cpp:41
void AddSummaryItem(SummaryList &l, const std::string &name, const std::string &value)
Adds a summary item to the summary info list.
Definition: Misc.cpp:49

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)

◆ SetCheckpointNumber()

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

Definition at line 286 of file EquationSystem.h.

287  {
288  m_nchk = num;
289  }

References m_nchk.

◆ SetCheckpointSteps()

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

Definition at line 296 of file EquationSystem.h.

297  {
298  m_checksteps = num;
299  }

References m_checksteps.

◆ SetInitialConditions()

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 636 of file EquationSystem.h.

639 {
640  v_SetInitialConditions(initialtime, dumpInitialConditions, domain);
641 }
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::SolverUtils::UnsteadySystem::v_DoInitialise(), Nektar::PulseWaveSystem::v_DoInitialise(), Nektar::MMFSWE::v_DoInitialise(), and Nektar::CoupledLinearNS::v_DoInitialise().

◆ SetInitialStep()

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

Definition at line 311 of file EquationSystem.h.

312  {
313  m_initialStep = step;
314  }
int m_initialStep
Number of the step where the simulation should begin.

References m_initialStep.

◆ SetLambda()

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

Set parameter m_lambda.

Definition at line 631 of file EquationSystem.h.

632 {
633  m_lambda = lambda;
634 }

References m_lambda.

◆ SetModifiedBasis()

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

◆ SetSteps()

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

Definition at line 745 of file EquationSystem.h.

746 {
747  m_steps = steps;
748 }

References m_steps.

◆ SetTime()

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

Definition at line 306 of file EquationSystem.h.

307  {
308  m_time = time;
309  }

References m_time.

◆ SetUpTraceNormals()

SOLVER_UTILS_EXPORT void Nektar::SolverUtils::EquationSystem::SetUpTraceNormals ( void  )

◆ TransCoeffToPhys()

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

Transform from coefficient to physical space.

Performs the transformation from coefficient to physical space.

Public interface routine to virtual function implementation.

Definition at line 526 of file EquationSystem.h.

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

References v_TransCoeffToPhys().

◆ TransPhysToCoeff()

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

Transform from physical to coefficient space.

Performs the transformation from physical to coefficient space.

Public interface routine to virtual function implementation.

Definition at line 536 of file EquationSystem.h.

537 {
539 }
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 651 of file EquationSystem.h.

652 {
653  return m_fields;
654 }

References m_fields.

◆ v_DoInitialise()

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

Virtual function for initialisation implementation.

By default, nothing needs initialising at the EquationSystem level.

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

Definition at line 1008 of file EquationSystem.cpp.

1009 {
1010 }

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::RinglebFlow, Nektar::IsentropicVortex, Nektar::MMFSWE, Nektar::MMFMaxwell, Nektar::MMFDiffusion, and Nektar::MMFAdvection.

Definition at line 991 of file EquationSystem.cpp.

994 {
995  ASSERTL0(outfield.size() == m_fields[field]->GetNpoints(),
996  "ExactSolution array size mismatch.");
997  Vmath::Zero(outfield.size(), outfield, 1);
998  if (m_session->DefinesFunction("ExactSolution"))
999  {
1000  GetFunction("ExactSolution")
1001  ->Evaluate(m_session->GetVariable(field), outfield, time);
1002  }
1003 }
SOLVER_UTILS_EXPORT SessionFunctionSharedPtr GetFunction(std::string name, const MultiRegions::ExpListSharedPtr &field=MultiRegions::NullExpListSharedPtr, bool cache=false)
Get a SessionFunction by name.

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

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

◆ v_ExtraFldOutput()

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

Reimplemented in Nektar::NavierStokesCFE, Nektar::LinearElasticSystem, Nektar::CompressibleFlowSystem, and Nektar::AcousticSystem.

Definition at line 1479 of file EquationSystem.cpp.

1482 {
1483  boost::ignore_unused(fieldcoeffs, variables);
1484 }

Referenced by ExtraFldOutput().

◆ 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::IncNavierStokes.

Definition at line 1472 of file EquationSystem.cpp.

1473 {
1474  ASSERTL0(false, "This function is not valid for the Base class");
1476  return null;
1477 }

References ASSERTL0.

Referenced by GetPressure().

◆ v_GetSystemSingularChecks()

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

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

Definition at line 1467 of file EquationSystem.cpp.

1468 {
1469  return Array<OneD, bool>(m_session->GetVariables().size(), false);
1470 }

References m_session.

Referenced by v_InitObject().

◆ 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 Nektar::NavierStokesImplicitCFE, Nektar::NavierStokesCFEAxisym, Nektar::ShallowWaterSystem, Nektar::NonlinearSWE, Nektar::NonlinearPeregrine, Nektar::MMFSWE, Nektar::LinearSWE, Nektar::MMFMaxwell, Nektar::LinearElasticSystem, Nektar::IterativeElasticSystem, Nektar::Dummy, Nektar::EulerImplicitCFE, Nektar::EulerCFE, Nektar::CFSImplicit, Nektar::CompressibleFlowSystem, Nektar::UnsteadyViscousBurgers, Nektar::UnsteadyReactionDiffusion, Nektar::UnsteadyInviscidBurger, Nektar::UnsteadyDiffusion, Nektar::UnsteadyAdvectionDiffusion, Nektar::UnsteadyAdvection, Nektar::SteadyAdvectionDiffusionReaction, Nektar::SteadyAdvectionDiffusion, Nektar::Projection, Nektar::Poisson, Nektar::MMFAdvection, Nektar::Laplace, Nektar::Helmholtz, Nektar::EigenValuesAdvection, Nektar::CFLtester, Nektar::LEE, Nektar::APE, Nektar::AcousticSystem, Nektar::IncNavierStokes, Nektar::NavierStokesCFE, Nektar::VelocityCorrectionScheme, Nektar::VCSMapping, Nektar::SmoothedProfileMethod, Nektar::CoupledLinearNS, Nektar::ImageWarpingSystem, Nektar::MMFDiffusion, Nektar::SolverUtils::UnsteadySystem, Nektar::SolverUtils::AdvectionSystem, Nektar::PulseWaveSystem, and Nektar::PulseWavePropagation.

Definition at line 117 of file EquationSystem.cpp.

118 {
119  // Save the basename of input file name for output details
120  m_sessionName = m_session->GetSessionName();
121 
122  // Instantiate a field reader/writer
124 
125  // Also read and store the boundary conditions
128  m_session, m_graph);
129 
130  // Set space dimension for use in class
131  m_spacedim = m_graph->GetSpaceDimension();
132 
133  // Setting parameteres for homogenous problems
134  m_HomoDirec = 0;
135  m_useFFT = false;
136  m_homogen_dealiasing = false;
137  m_singleMode = false;
138  m_halfMode = false;
139  m_multipleModes = false;
141 
142  m_verbose = m_session->DefinesCmdLineArgument("verbose");
143  m_root = false;
144  if (0 == m_comm->GetRank())
145  {
146  m_root = true;
147  }
148 
149  if (m_session->DefinesSolverInfo("HOMOGENEOUS"))
150  {
151  std::string HomoStr = m_session->GetSolverInfo("HOMOGENEOUS");
152  m_spacedim = 3;
153 
154  if ((HomoStr == "HOMOGENEOUS1D") || (HomoStr == "Homogeneous1D") ||
155  (HomoStr == "1D") || (HomoStr == "Homo1D"))
156  {
158  m_session->LoadParameter("LZ", m_LhomZ);
159  m_HomoDirec = 1;
160 
161  if (m_session->DefinesSolverInfo("ModeType"))
162  {
163  m_session->MatchSolverInfo("ModeType", "SingleMode",
164  m_singleMode, false);
165  m_session->MatchSolverInfo("ModeType", "HalfMode", m_halfMode,
166  false);
167  m_session->MatchSolverInfo("ModeType", "MultipleModes",
168  m_multipleModes, false);
169  }
170 
171  // Stability Analysis flags
172  if (m_session->DefinesSolverInfo("ModeType"))
173  {
174  if (m_singleMode)
175  {
176  m_npointsZ = 2;
177  }
178  else if (m_halfMode)
179  {
180  m_npointsZ = 1;
181  }
182  else if (m_multipleModes)
183  {
184  m_npointsZ = m_session->GetParameter("HomModesZ");
185  }
186  else
187  {
188  ASSERTL0(false, "SolverInfo ModeType not valid");
189  }
190  }
191  else
192  {
193  m_npointsZ = m_session->GetParameter("HomModesZ");
194  }
195  }
196 
197  if ((HomoStr == "HOMOGENEOUS2D") || (HomoStr == "Homogeneous2D") ||
198  (HomoStr == "2D") || (HomoStr == "Homo2D"))
199  {
201  m_session->LoadParameter("HomModesY", m_npointsY);
202  m_session->LoadParameter("LY", m_LhomY);
203  m_session->LoadParameter("HomModesZ", m_npointsZ);
204  m_session->LoadParameter("LZ", m_LhomZ);
205  m_HomoDirec = 2;
206  }
207 
208  if ((HomoStr == "HOMOGENEOUS3D") || (HomoStr == "Homogeneous3D") ||
209  (HomoStr == "3D") || (HomoStr == "Homo3D"))
210  {
212  m_session->LoadParameter("HomModesY", m_npointsY);
213  m_session->LoadParameter("LY", m_LhomY);
214  m_session->LoadParameter("HomModesZ", m_npointsZ);
215  m_session->LoadParameter("LZ", m_LhomZ);
216  m_HomoDirec = 2;
217  }
218 
219  m_session->MatchSolverInfo("USEFFT", "FFTW", m_useFFT, false);
220 
221  m_session->MatchSolverInfo("DEALIASING", "True", m_homogen_dealiasing,
222  false);
223  }
224  else
225  {
226  // set to default value so can use to identify 2d or 3D
227  // (homogeneous) expansions
228  m_npointsZ = 1;
229  }
230 
231  m_session->MatchSolverInfo("SPECTRALHPDEALIASING", "True",
232  m_specHP_dealiasing, false);
233  if (m_specHP_dealiasing == false)
234  {
235  m_session->MatchSolverInfo("SPECTRALHPDEALIASING", "On",
236  m_specHP_dealiasing, false);
237  }
238 
239  // Options to determine type of projection from file or directly
240  // from constructor
241  if (m_session->DefinesSolverInfo("PROJECTION"))
242  {
243  std::string ProjectStr = m_session->GetSolverInfo("PROJECTION");
244 
245  if ((ProjectStr == "Continuous") || (ProjectStr == "Galerkin") ||
246  (ProjectStr == "CONTINUOUS") || (ProjectStr == "GALERKIN"))
247  {
249  }
250  else if ((ProjectStr == "MixedCGDG") ||
251  (ProjectStr == "Mixed_CG_Discontinuous"))
252  {
254  }
255  else if (ProjectStr == "DisContinuous")
256  {
258  }
259  else
260  {
261  ASSERTL0(false, "PROJECTION value not recognised");
262  }
263  }
264  else
265  {
266  cerr << "Projection type not specified in SOLVERINFO,"
267  "defaulting to continuous Galerkin"
268  << endl;
270  }
271 
272  // Enforce singularity check for some problems
274 
275  int i;
276  int nvariables = m_session->GetVariables().size();
277  bool DeclareCoeffPhysArrays = true;
278 
279  m_fields = Array<OneD, MultiRegions::ExpListSharedPtr>(nvariables);
280  m_spacedim = m_graph->GetSpaceDimension() + m_HomoDirec;
281  m_expdim = m_graph->GetMeshDimension();
282 
283  if (DeclareFields) // declare field if required
284  {
285  /// Continuous field
288  {
289  switch (m_expdim)
290  {
291  case 1:
292  {
295  {
296  const LibUtilities::PointsKey PkeyY(
298  const LibUtilities::BasisKey BkeyY(
300  const LibUtilities::PointsKey PkeyZ(
302  const LibUtilities::BasisKey BkeyZ(
304 
305  for (i = 0; i < m_fields.size(); i++)
306  {
307  m_fields[i] = MemoryManager<
308  MultiRegions ::ContField3DHomogeneous2D>::
309  AllocateSharedPtr(m_session, BkeyY, BkeyZ,
312  m_session->GetVariable(i));
313  }
314  }
315  else
316  {
317  for (i = 0; i < m_fields.size(); i++)
318  {
319  m_fields[i] =
323  m_session->GetVariable(i));
324  }
325  }
326  break;
327  }
328  case 2:
329  {
331  {
332  // Fourier single mode stability analysis
333  if (m_singleMode)
334  {
335  const LibUtilities::PointsKey PkeyZ(
336  m_npointsZ,
338 
339  const LibUtilities::BasisKey BkeyZ(
341  PkeyZ);
342 
343  for (i = 0; i < m_fields.size(); i++)
344  {
345  m_fields[i] = MemoryManager<
346  MultiRegions ::ContField3DHomogeneous1D>::
347  AllocateSharedPtr(
348  m_session, BkeyZ, m_LhomZ, m_useFFT,
350  m_session->GetVariable(i),
352  }
353  }
354  // Half mode stability analysis
355  else if (m_halfMode)
356  {
357  const LibUtilities::PointsKey PkeyZ(
358  m_npointsZ,
360 
361  const LibUtilities::BasisKey BkeyZR(
363  PkeyZ);
364 
365  const LibUtilities::BasisKey BkeyZI(
367  PkeyZ);
368 
369  for (i = 0; i < m_fields.size(); i++)
370  {
371  if (m_session->GetVariable(i).compare("w") == 0)
372  {
373  m_fields[i] = MemoryManager<
374  MultiRegions ::
375  ContField3DHomogeneous1D>::
376  AllocateSharedPtr(
377  m_session, BkeyZI, m_LhomZ,
379  m_graph, m_session->GetVariable(i),
381  }
382  else
383  {
384  m_fields[i] = MemoryManager<
385  MultiRegions ::
386  ContField3DHomogeneous1D>::
387  AllocateSharedPtr(
388  m_session, BkeyZR, m_LhomZ,
390  m_graph, m_session->GetVariable(i),
392  }
393  }
394  }
395  // Normal homogeneous 1D
396  else
397  {
398  const LibUtilities::PointsKey PkeyZ(
400  const LibUtilities::BasisKey BkeyZ(
402 
403  for (i = 0; i < m_fields.size(); i++)
404  {
405  m_fields[i] = MemoryManager<
406  MultiRegions ::ContField3DHomogeneous1D>::
407  AllocateSharedPtr(
408  m_session, BkeyZ, m_LhomZ, m_useFFT,
410  m_session->GetVariable(i),
412  }
413  }
414  }
415  else
416  {
417  i = 0;
421  m_session->GetVariable(i),
422  DeclareCoeffPhysArrays,
424  m_fields[0] = firstfield;
425  for (i = 1; i < m_fields.size(); i++)
426  {
427  if (m_graph->SameExpansionInfo(
428  m_session->GetVariable(0),
429  m_session->GetVariable(i)))
430  {
431  m_fields[i] =
434  *firstfield, m_graph,
435  m_session->GetVariable(i),
436  DeclareCoeffPhysArrays,
438  }
439  else
440  {
441  m_fields[i] =
445  m_session->GetVariable(i),
446  DeclareCoeffPhysArrays,
448  }
449  }
450 
451  if (m_projectionType ==
453  {
454  /// Setting up the normals
456  Array<OneD, Array<OneD, NekDouble>>(m_spacedim);
457 
458  for (i = 0; i < m_spacedim; ++i)
459  {
460  m_traceNormals[i] =
461  Array<OneD, NekDouble>(GetTraceNpoints());
462  }
463 
464  m_fields[0]->GetTrace()->GetNormals(m_traceNormals);
465  }
466  }
467 
468  break;
469  }
470  case 3:
471  {
472  i = 0;
476  m_session->GetVariable(i),
477  DeclareCoeffPhysArrays,
479 
480  m_fields[0] = firstfield;
481  for (i = 1; i < m_fields.size(); i++)
482  {
483  if (m_graph->SameExpansionInfo(
484  m_session->GetVariable(0),
485  m_session->GetVariable(i)))
486  {
487  m_fields[i] =
490  *firstfield, m_graph,
491  m_session->GetVariable(i),
492  DeclareCoeffPhysArrays,
494  }
495  else
496  {
497  m_fields[i] =
501  m_session->GetVariable(i),
502  DeclareCoeffPhysArrays,
504  }
505  }
506 
507  if (m_projectionType ==
509  {
510  /// Setting up the normals
512  Array<OneD, Array<OneD, NekDouble>>(m_spacedim);
513  for (i = 0; i < m_spacedim; ++i)
514  {
515  m_traceNormals[i] =
516  Array<OneD, NekDouble>(GetTraceNpoints());
517  }
518 
519  m_fields[0]->GetTrace()->GetNormals(m_traceNormals);
520  // Call the trace on all fields to ensure DG setup.
521  for (i = 1; i < m_fields.size(); ++i)
522  {
523  m_fields[i]->GetTrace();
524  }
525  }
526  break;
527  }
528  default:
529  ASSERTL0(false, "Expansion dimension not recognised");
530  break;
531  }
532  }
533  // Discontinuous field
534  else
535  {
536  switch (m_expdim)
537  {
538  case 1:
539  {
542  {
543  const LibUtilities::PointsKey PkeyY(
545  const LibUtilities::BasisKey BkeyY(
547  const LibUtilities::PointsKey PkeyZ(
549  const LibUtilities::BasisKey BkeyZ(
551 
552  for (i = 0; i < m_fields.size(); i++)
553  {
554  m_fields[i] = MemoryManager<
555  MultiRegions ::DisContField3DHomogeneous2D>::
556  AllocateSharedPtr(m_session, BkeyY, BkeyZ,
559  m_session->GetVariable(i));
560  }
561  }
562  else
563  {
564  for (i = 0; i < m_fields.size(); i++)
565  {
566  m_fields[i] =
570  m_session->GetVariable(i));
571  }
572  }
573 
574  break;
575  }
576  case 2:
577  {
579  {
580  const LibUtilities::PointsKey PkeyZ(
582  const LibUtilities::BasisKey BkeyZ(
584 
585  for (i = 0; i < m_fields.size(); i++)
586  {
587  m_fields[i] = MemoryManager<
588  MultiRegions ::DisContField3DHomogeneous1D>::
589  AllocateSharedPtr(m_session, BkeyZ, m_LhomZ,
590  m_useFFT,
592  m_session->GetVariable(i));
593  }
594  }
595  else
596  {
597  for (i = 0; i < m_fields.size(); i++)
598  {
599  m_fields[i] =
603  m_session->GetVariable(i));
604  }
605  }
606 
607  break;
608  }
609  case 3:
610  {
612  {
613  ASSERTL0(
614  false,
615  "3D fully periodic problems not implemented yet");
616  }
617  else
618  {
619  for (i = 0; i < m_fields.size(); i++)
620  {
621  m_fields[i] =
625  m_session->GetVariable(i));
626  }
627  }
628  break;
629  }
630  default:
631  ASSERTL0(false, "Expansion dimension not recognised");
632  break;
633  }
634 
635  // Setting up the normals
636  m_traceNormals = Array<OneD, Array<OneD, NekDouble>>(m_spacedim);
637 
638  for (i = 0; i < m_spacedim; ++i)
639  {
640  m_traceNormals[i] =
641  Array<OneD, NekDouble>(GetTraceNpoints(), 0.0);
642  }
643 
644  m_fields[0]->GetTrace()->GetNormals(m_traceNormals);
645  }
646  // Zero all physical fields initially
647  ZeroPhysFields();
648  }
649 
650  // Set Default Parameter
651  m_session->LoadParameter("Time", m_time, 0.0);
652  m_session->LoadParameter("TimeStep", m_timestep, 0.0);
653  m_session->LoadParameter("NumSteps", m_steps, 0);
654  m_session->LoadParameter("IO_CheckSteps", m_checksteps, 0);
655  m_session->LoadParameter("IO_CheckTime", m_checktime, 0.0);
656  m_session->LoadParameter("FinTime", m_fintime, 0);
657  m_session->LoadParameter("NumQuadPointsError", m_NumQuadPointsError, 0);
658 
659  // Check uniqueness of checkpoint output
660  ASSERTL0((m_checktime == 0.0 && m_checksteps == 0) ||
661  (m_checktime > 0.0 && m_checksteps == 0) ||
662  (m_checktime == 0.0 && m_checksteps > 0),
663  "Only one of IO_CheckTime and IO_CheckSteps "
664  "should be set!");
665  m_session->LoadParameter("TimeIncrementFactor", m_TimeIncrementFactor, 1.0);
666 
667  m_nchk = 0;
668 }
static std::shared_ptr< FieldIO > CreateDefault(const LibUtilities::SessionReaderSharedPtr session)
Returns an object for the default FieldIO method.
Definition: FieldIO.cpp:198
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:76
@ eFourierSingleModeSpaced
1D Non Evenly-spaced points for Single Mode analysis
Definition: PointsType.h:77
@ eFourierSingleMode
Fourier ModifiedExpansion with just the first mode .
Definition: BasisType.h:66
@ eFourierHalfModeIm
Fourier Modified expansions with just the imaginary part of the first mode .
Definition: BasisType.h:70
@ eFourierHalfModeRe
Fourier Modified expansions with just the real part of the first mode .
Definition: BasisType.h:68
@ eFourier
Fourier Expansion .
Definition: BasisType.h:57
std::shared_ptr< ContField > ContFieldSharedPtr
Definition: ContField.h:277

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_LhomY, m_LhomZ, m_multipleModes, m_nchk, m_npointsY, m_npointsZ, m_NumQuadPointsError, m_projectionType, m_root, 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::PulseWaveSystem, and Nektar::MMFSWE.

Definition at line 733 of file EquationSystem.cpp.

736 {
737  NekDouble L2error = -1.0;
738 
739  if (m_NumQuadPointsError == 0)
740  {
741  if (m_fields[field]->GetPhysState() == false)
742  {
743  m_fields[field]->BwdTrans(m_fields[field]->GetCoeffs(),
744  m_fields[field]->UpdatePhys());
745  }
746 
747  if (exactsoln.size())
748  {
749  L2error =
750  m_fields[field]->L2(m_fields[field]->GetPhys(), exactsoln);
751  }
752  else if (m_session->DefinesFunction("ExactSolution"))
753  {
754  Array<OneD, NekDouble> exactsoln(m_fields[field]->GetNpoints());
755 
756  GetFunction("ExactSolution")
757  ->Evaluate(m_session->GetVariable(field), exactsoln, m_time);
758 
759  L2error =
760  m_fields[field]->L2(m_fields[field]->GetPhys(), exactsoln);
761  }
762  else
763  {
764  L2error = m_fields[field]->L2(m_fields[field]->GetPhys());
765  }
766 
767  if (Normalised == true)
768  {
769  Array<OneD, NekDouble> one(m_fields[field]->GetNpoints(), 1.0);
770 
771  NekDouble Vol = m_fields[field]->Integral(one);
772  L2error = sqrt(L2error * L2error / Vol);
773  }
774  }
775  else
776  {
777  Array<OneD, NekDouble> L2INF(2);
778  L2INF = ErrorExtraPoints(field);
779  L2error = L2INF[0];
780  }
781  return L2error;
782 }
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].
SOLVER_UTILS_EXPORT int GetNpoints()
double NekDouble
scalarT< T > sqrt(scalarT< T > in)
Definition: scalar.hpp:291

References ErrorExtraPoints(), GetFunction(), GetNpoints(), 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::PulseWaveSystem, and Nektar::MMFSWE.

Definition at line 790 of file EquationSystem.cpp.

792 {
793  NekDouble Linferror = -1.0;
794 
795  if (m_NumQuadPointsError == 0)
796  {
797  if (m_fields[field]->GetPhysState() == false)
798  {
799  m_fields[field]->BwdTrans(m_fields[field]->GetCoeffs(),
800  m_fields[field]->UpdatePhys());
801  }
802 
803  if (exactsoln.size())
804  {
805  Linferror =
806  m_fields[field]->Linf(m_fields[field]->GetPhys(), exactsoln);
807  }
808  else if (m_session->DefinesFunction("ExactSolution"))
809  {
810  Array<OneD, NekDouble> exactsoln(m_fields[field]->GetNpoints());
811 
812  GetFunction("ExactSolution")
813  ->Evaluate(m_session->GetVariable(field), exactsoln, m_time);
814 
815  Linferror =
816  m_fields[field]->Linf(m_fields[field]->GetPhys(), exactsoln);
817  }
818  else
819  {
820  Linferror = m_fields[field]->Linf(m_fields[field]->GetPhys());
821  }
822  }
823  else
824  {
825  Array<OneD, NekDouble> L2INF(2);
826  L2INF = ErrorExtraPoints(field);
827  Linferror = L2INF[1];
828  }
829 
830  return Linferror;
831 }

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

Referenced by LinfError().

◆ v_NegatedOp()

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

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 1024 of file EquationSystem.cpp.

1025 {
1026  return false;
1027 }

◆ 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::PulseWaveSystem, Nektar::CoupledLinearNS, Nektar::Dummy, and Nektar::AcousticSystem.

Definition at line 1053 of file EquationSystem.cpp.

1054 {
1055  WriteFld(m_sessionName + ".fld");
1056 }

References m_sessionName, 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::NonlinearPeregrine, Nektar::IsentropicVortex, Nektar::CompressibleFlowSystem, Nektar::MMFDiffusion, Nektar::Monodomain, Nektar::BidomainRoth, Nektar::Bidomain, Nektar::MMFSWE, Nektar::MMFMaxwell, and Nektar::MMFAdvection.

Definition at line 926 of file EquationSystem.cpp.

929 {
930  boost::ignore_unused(initialtime);
931 
932  if (m_session->GetComm()->GetRank() == 0)
933  {
934  cout << "Initial Conditions:" << endl;
935  }
936 
937  if (m_session->DefinesFunction("InitialConditions"))
938  {
939  GetFunction("InitialConditions")
940  ->Evaluate(m_session->GetVariables(), m_fields, m_time, domain);
941  // Enforce C0 Continutiy of initial condiiton
944  {
945  for (int i = 0; i < m_fields.size(); ++i)
946  {
947  m_fields[i]->LocalToGlobal();
948  m_fields[i]->GlobalToLocal();
949  m_fields[i]->BwdTrans(m_fields[i]->GetCoeffs(),
950  m_fields[i]->UpdatePhys());
951  }
952  }
953 
954  if (m_session->GetComm()->GetRank() == 0)
955  {
956 
957  for (int i = 0; i < m_fields.size(); ++i)
958  {
959  std::string varName = m_session->GetVariable(i);
960  cout << " - Field " << varName << ": "
961  << GetFunction("InitialConditions")
962  ->Describe(varName, domain)
963  << endl;
964  }
965  }
966  }
967  else
968  {
969  int nq = m_fields[0]->GetNpoints();
970  for (int i = 0; i < m_fields.size(); i++)
971  {
972  Vmath::Zero(nq, m_fields[i]->UpdatePhys(), 1);
973  m_fields[i]->SetPhysState(true);
974  Vmath::Zero(m_fields[i]->GetNcoeffs(), m_fields[i]->UpdateCoeffs(),
975  1);
976  if (m_session->GetComm()->GetRank() == 0)
977  {
978  cout << " - Field " << m_session->GetVariable(i)
979  << ": 0 (default)" << endl;
980  }
981  }
982  }
983 
984  if (dumpInitialConditions && m_checksteps && m_nchk == 0)
985  {
987  }
988  ++m_nchk;
989 }
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_fields, m_nchk, m_projectionType, m_session, m_time, and Vmath::Zero().

Referenced by SetInitialConditions(), Nektar::Bidomain::v_SetInitialConditions(), Nektar::BidomainRoth::v_SetInitialConditions(), Nektar::Monodomain::v_SetInitialConditions(), Nektar::MMFDiffusion::v_SetInitialConditions(), Nektar::CompressibleFlowSystem::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::IncNavierStokes, Nektar::VelocityCorrectionScheme, and Nektar::CoupledLinearNS.

Definition at line 1032 of file EquationSystem.cpp.

1033 {
1034 }

Referenced by TransCoeffToPhys().

◆ v_TransPhysToCoeff()

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

Virtual function for transformation to coefficient space.

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

Definition at line 1039 of file EquationSystem.cpp.

1040 {
1041 }

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 1123 of file EquationSystem.cpp.

1124 {
1125  std::vector<Array<OneD, NekDouble>> fieldcoeffs(m_fields.size());
1126  std::vector<std::string> variables(m_fields.size());
1127 
1128  for (int i = 0; i < m_fields.size(); ++i)
1129  {
1130  if (m_fields[i]->GetNcoeffs() == m_fields[0]->GetNcoeffs())
1131  {
1132  fieldcoeffs[i] = m_fields[i]->UpdateCoeffs();
1133  }
1134  else
1135  {
1136  fieldcoeffs[i] = Array<OneD, NekDouble>(m_fields[0]->GetNcoeffs());
1137  m_fields[0]->ExtractCoeffsToCoeffs(
1138  m_fields[i], m_fields[i]->GetCoeffs(), fieldcoeffs[i]);
1139  }
1140  variables[i] = m_boundaryConditions->GetVariable(i);
1141  }
1142 
1143  ExtraFldOutput(fieldcoeffs, variables);
1144 
1145  WriteFld(outname, m_fields[0], fieldcoeffs, variables);
1146 }
SOLVER_UTILS_EXPORT void ExtraFldOutput(std::vector< Array< OneD, NekDouble >> &fieldcoeffs, std::vector< std::string > &variables)

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

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(), and Nektar::MMFDiffusion::v_SetInitialConditions().

◆ 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 1155 of file EquationSystem.cpp.

1159 {
1160  std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef =
1161  field->GetFieldDefinitions();
1162  std::vector<std::vector<NekDouble>> FieldData(FieldDef.size());
1163 
1164  // Copy Data into FieldData and set variable
1165  for (int j = 0; j < fieldcoeffs.size(); ++j)
1166  {
1167  for (int i = 0; i < FieldDef.size(); ++i)
1168  {
1169  // Could do a search here to find correct variable
1170  FieldDef[i]->m_fields.push_back(variables[j]);
1171  field->AppendFieldData(FieldDef[i], FieldData[i], fieldcoeffs[j]);
1172  }
1173  }
1174 
1175  // Update time in field info if required
1176  if (m_fieldMetaDataMap.find("Time") != m_fieldMetaDataMap.end())
1177  {
1178  m_fieldMetaDataMap["Time"] = boost::lexical_cast<std::string>(m_time);
1179  }
1180 
1181  // Update step in field info if required
1182  if (m_fieldMetaDataMap.find("ChkFileNum") != m_fieldMetaDataMap.end())
1183  {
1184  m_fieldMetaDataMap["ChkFileNum"] =
1185  boost::lexical_cast<std::string>(m_nchk);
1186  }
1187 
1188  // If necessary, add mapping information to metadata
1189  // and output mapping coordinates
1190  Array<OneD, MultiRegions::ExpListSharedPtr> fields(1);
1191  fields[0] = field;
1195  mapping->Output(fieldMetaDataMap, outname);
1196 
1197  // If necessary, add informaton for moving frame reference to metadata
1198  if (m_fieldMetaDataMap.find("Theta_x") != m_fieldMetaDataMap.end())
1199  {
1200  // if one theta exists, add all three thetas
1201  std::vector<std::string> vSuffix = {"_x", "_y", "_z"};
1202  for (int i = 0; i < 3; ++i)
1203  {
1204  std::string sTheta = "Theta" + vSuffix[i];
1205  m_fieldMetaDataMap[sTheta] =
1206  boost::lexical_cast<std::string>(m_movingFrameTheta[i]);
1207  }
1208  }
1209 
1210 #ifdef NEKTAR_DISABLE_BACKUPS
1211  bool backup = false;
1212 #else
1213  bool backup = true;
1214 #endif
1215 
1216  m_fld->Write(outname, FieldDef, FieldData, fieldMetaDataMap, backup);
1217 }
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:269
Array< OneD, NekDouble > m_movingFrameTheta
Moving frame of reference angles with respect to the.
GLOBAL_MAPPING_EXPORT typedef std::shared_ptr< Mapping > MappingSharedPtr
A shared pointer to a Mapping object.
Definition: Mapping.h:50
std::map< std::string, std::string > FieldMetaDataMap
Definition: FieldIO.h:52

References Nektar::GlobalMapping::Mapping::Load(), m_fieldMetaDataMap, m_fld, m_movingFrameTheta, m_nchk, m_session, m_time, and Nektar::GlobalMapping::MappingSharedPtr.

◆ ZeroPhysFields()

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

Zero the physical fields.

Definition at line 1061 of file EquationSystem.cpp.

1062 {
1063  for (int i = 0; i < m_fields.size(); i++)
1064  {
1065  Vmath::Zero(m_fields[i]->GetNpoints(), m_fields[i]->UpdatePhys(), 1);
1066  }
1067 }

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 488 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 395 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

◆ 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 335 of file EquationSystem.h.

Referenced by Nektar::SolverUtils::MMFSystem::AbsIntegral(), Nektar::UnsteadyAdvectionDiffusion::AddAdvectionPenaltyFlux(), Nektar::MMFSWE::AddCoriolis(), Nektar::LinearSWE::AddCoriolis(), Nektar::NonlinearPeregrine::AddCoriolis(), Nektar::NonlinearSWE::AddCoriolis(), Nektar::MMFSWE::AddDivForGradient(), Nektar::MMFSWE::AddElevationEffect(), Nektar::MMFMaxwell::AddGreenDerivCompensate(), Nektar::CFSImplicit::AddMatNSBlkDiagBnd(), Nektar::CFSImplicit::AddMatNSBlkDiagVol(), Nektar::MMFMaxwell::AddPML(), Nektar::MMFSWE::AddRotation(), Nektar::NonlinearPeregrine::AddVariableDepth(), Nektar::NonlinearSWE::AddVariableDepth(), Nektar::MMFAdvection::AdvectionBellPlane(), Nektar::MMFAdvection::AdvectionBellSphere(), Nektar::VCSMapping::ApplyIncNSMappingForcing(), Nektar::SolverUtils::MMFSystem::AverageMaxwellFlux1D(), Nektar::SolverUtils::MMFSystem::AvgAbsInt(), Nektar::SolverUtils::MMFSystem::AvgInt(), Nektar::LinearElasticSystem::BuildMatrixSystem(), Nektar::CFSImplicit::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::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::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::CoupledLinearNS::Continuation(), Nektar::SolverUtils::MMFSystem::CopyBoundaryTrace(), Nektar::AcousticSystem::CopyBoundaryTrace(), Nektar::ShallowWaterSystem::CopyBoundaryTrace(), CopyFromPhysField(), CopyToPhysField(), Nektar::CoupledLinearNS::DefineForcingTerm(), Nektar::CompressibleFlowSystem::DoAdvection(), Nektar::CFSImplicit::DoAdvectionCoeff(), Nektar::UnsteadyAdvectionDiffusion::DoImplicitSolve(), Nektar::UnsteadyDiffusion::DoImplicitSolve(), Nektar::UnsteadyReactionDiffusion::DoImplicitSolve(), Nektar::UnsteadyViscousBurgers::DoImplicitSolve(), Nektar::Bidomain::DoImplicitSolve(), Nektar::BidomainRoth::DoImplicitSolve(), Nektar::Monodomain::DoImplicitSolve(), Nektar::MMFDiffusion::DoImplicitSolve(), Nektar::CFSImplicit::DoImplicitSolve(), Nektar::AcousticSystem::DoOdeProjection(), Nektar::CFLtester::DoOdeProjection(), Nektar::MMFAdvection::DoOdeProjection(), Nektar::UnsteadyAdvection::DoOdeProjection(), Nektar::UnsteadyAdvectionDiffusion::DoOdeProjection(), Nektar::UnsteadyDiffusion::DoOdeProjection(), Nektar::UnsteadyInviscidBurger::DoOdeProjection(), Nektar::UnsteadyReactionDiffusion::DoOdeProjection(), Nektar::CompressibleFlowSystem::DoOdeProjection(), Nektar::Dummy::DoOdeProjection(), Nektar::LinearSWE::DoOdeProjection(), Nektar::NonlinearPeregrine::DoOdeProjection(), Nektar::NonlinearSWE::DoOdeProjection(), Nektar::AcousticSystem::DoOdeRhs(), Nektar::CFLtester::DoOdeRhs(), Nektar::MMFAdvection::DoOdeRhs(), Nektar::UnsteadyAdvection::DoOdeRhs(), Nektar::UnsteadyAdvectionDiffusion::DoOdeRhs(), Nektar::UnsteadyDiffusion::DoOdeRhs(), Nektar::UnsteadyInviscidBurger::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::LinearSWE::DoOdeRhs(), Nektar::MMFSWE::DoOdeRhs(), Nektar::NonlinearPeregrine::DoOdeRhs(), Nektar::NonlinearSWE::DoOdeRhs(), Nektar::CFSImplicit::DoOdeRhsCoeff(), ErrorExtraPoints(), Nektar::CoupledLinearNS::EvaluateAdvection(), Nektar::IncNavierStokes::EvaluateAdvectionTerms(), Nektar::MMFAdvection::EvaluateAdvectionVelocity(), Nektar::MMFMaxwell::EvaluateCoriolis(), Nektar::MMFSWE::EvaluateCoriolisForZonalFlow(), 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::RinglebFlow::GetExactRinglebFlow(), GetExpSize(), Nektar::PulseWavePropagation::GetFluxVector(), Nektar::LinearSWE::GetFluxVector(), Nektar::NonlinearPeregrine::GetFluxVector(), Nektar::NonlinearSWE::GetFluxVector(), Nektar::UnsteadyAdvectionDiffusion::GetFluxVectorAdv(), Nektar::UnsteadyViscousBurgers::GetFluxVectorAdv(), Nektar::UnsteadyAdvection::GetFluxVectorDeAlias(), Nektar::CompressibleFlowSystem::GetFluxVectorDeAlias(), GetFunction(), Nektar::SolverUtils::MMFSystem::GetIncidentField(), Nektar::UnsteadyAdvectionDiffusion::GetMaxStdVelocity(), Nektar::SolverUtils::MMFSystem::GetMaxwellFlux1D(), Nektar::SolverUtils::MMFSystem::GetMaxwellFlux2D(), GetNcoeffs(), Nektar::UnsteadyAdvectionDiffusion::GetNormalVel(), Nektar::CFLtester::GetNormalVelocity(), Nektar::EigenValuesAdvection::GetNormalVelocity(), Nektar::MMFAdvection::GetNormalVelocity(), Nektar::UnsteadyAdvection::GetNormalVelocity(), Nektar::UnsteadyInviscidBurger::GetNormalVelocity(), Nektar::ImageWarpingSystem::GetNormalVelocity(), Nektar::UnsteadyViscousBurgers::GetNormalVelocity(), GetNpoints(), GetNumExpModesPerExp(), GetPhys_Offset(), Nektar::CompressibleFlowSystem::GetStabilityLimitVector(), Nektar::CFLtester::GetStdVelocity(), Nektar::UnsteadyAdvectionDiffusion::GetSubstepTimeStep(), Nektar::MMFSWE::GetSWEFluxVector(), GetTotPoints(), Nektar::CFSImplicit::GetTraceJac(), GetTraceNpoints(), Nektar::NavierStokesCFE::GetViscosityAndThermalCondFromTemp(), ImportFld(), ImportFldToMultiDomains(), Nektar::CompressibleFlowSystem::InitAdvection(), Nektar::CFSImplicit::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::CFSImplicit::NonlinSysEvaluatorCoeff(), 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::MMFMaxwell::Printout_SurfaceCurrent(), Nektar::MMFSWE::RossbyWave(), SessionSummary(), Nektar::MMFSWE::SetBoundaryConditions(), Nektar::AcousticSystem::SetBoundaryConditions(), Nektar::CompressibleFlowSystem::SetBoundaryConditions(), Nektar::LinearSWE::SetBoundaryConditions(), Nektar::NonlinearPeregrine::SetBoundaryConditions(), Nektar::NonlinearSWE::SetBoundaryConditions(), SetBoundaryConditions(), Nektar::IncNavierStokes::SetBoundaryConditions(), Nektar::NonlinearPeregrine::SetBoundaryConditionsContVariables(), Nektar::NonlinearPeregrine::SetBoundaryConditionsForcing(), Nektar::IncNavierStokes::SetMRFDomainVelBCs(), Nektar::IncNavierStokes::SetMRFWallBCs(), 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::VelocityCorrectionScheme::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(), UpdateFields(), Nektar::SmoothedProfileMethod::UpdateForcing(), Nektar::SolverUtils::MMFSystem::UpwindMaxwellFlux1D(), Nektar::LEE::v_AddLinTerm(), Nektar::SolverUtils::UnsteadySystem::v_AppendOutput1D(), Nektar::NavierStokesImplicitCFE::v_CalcPhysDeriv(), Nektar::LinearSWE::v_ConservativeToPrimitive(), Nektar::NonlinearPeregrine::v_ConservativeToPrimitive(), Nektar::NonlinearSWE::v_ConservativeToPrimitive(), Nektar::NavierStokesCFE::v_DoDiffusion(), Nektar::NavierStokesImplicitCFE::v_DoDiffusionCoeff(), 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::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::VCSMapping::v_EvaluateAdvection_SetPressureBCs(), Nektar::VelocityCorrectionScheme::v_EvaluateAdvection_SetPressureBCs(), v_EvaluateExactSolution(), Nektar::MMFMaxwell::v_EvaluateExactSolution(), Nektar::IsentropicVortex::v_EvaluateExactSolution(), Nektar::AcousticSystem::v_ExtraFldOutput(), Nektar::CompressibleFlowSystem::v_ExtraFldOutput(), Nektar::LinearElasticSystem::v_ExtraFldOutput(), Nektar::NavierStokesCFE::v_ExtraFldOutput(), Nektar::Poisson::v_GenerateSummary(), Nektar::Projection::v_GenerateSummary(), Nektar::SolverUtils::MMFSystem::v_GenerateSummary(), Nektar::AcousticSystem::v_GetMaxStdVelocity(), Nektar::CompressibleFlowSystem::v_GetMaxStdVelocity(), Nektar::IncNavierStokes::v_GetMaxStdVelocity(), Nektar::CompressibleFlowSystem::v_GetTimeStep(), Nektar::CFLtester::v_GetTimeStep(), Nektar::NavierStokesCFEAxisym::v_GetViscousFluxVector(), Nektar::NavierStokesCFE::v_GetViscousFluxVectorDeAlias(), Nektar::Bidomain::v_InitObject(), Nektar::BidomainRoth::v_InitObject(), Nektar::Monodomain::v_InitObject(), v_InitObject(), Nektar::PulseWavePropagation::v_InitObject(), Nektar::PulseWaveSystem::v_InitObject(), Nektar::MMFDiffusion::v_InitObject(), Nektar::ImageWarpingSystem::v_InitObject(), Nektar::CoupledLinearNS::v_InitObject(), Nektar::VCSMapping::v_InitObject(), Nektar::VelocityCorrectionScheme::v_InitObject(), Nektar::IncNavierStokes::v_InitObject(), Nektar::AcousticSystem::v_InitObject(), Nektar::APE::v_InitObject(), Nektar::LEE::v_InitObject(), Nektar::CFLtester::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::UnsteadyInviscidBurger::v_InitObject(), Nektar::UnsteadyReactionDiffusion::v_InitObject(), Nektar::UnsteadyViscousBurgers::v_InitObject(), Nektar::CompressibleFlowSystem::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(), Nektar::NavierStokesCFEAxisym::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::LinearSWE::v_PrimitiveToConservative(), Nektar::NonlinearPeregrine::v_PrimitiveToConservative(), Nektar::NonlinearSWE::v_PrimitiveToConservative(), Nektar::APE::v_RiemannInvariantBC(), Nektar::LEE::v_RiemannInvariantBC(), Nektar::MMFAdvection::v_SetInitialConditions(), Nektar::MMFMaxwell::v_SetInitialConditions(), Nektar::MMFSWE::v_SetInitialConditions(), Nektar::MMFDiffusion::v_SetInitialConditions(), v_SetInitialConditions(), Nektar::CompressibleFlowSystem::v_SetInitialConditions(), Nektar::IsentropicVortex::v_SetInitialConditions(), Nektar::VCSMapping::v_SetUpPressureForcing(), Nektar::VelocityCorrectionScheme::v_SetUpPressureForcing(), Nektar::VCSWeakPressure::v_SetUpPressureForcing(), Nektar::VCSMapping::v_SetUpViscousForcing(), Nektar::VelocityCorrectionScheme::v_SetUpViscousForcing(), Nektar::VCSMapping::v_SolvePressure(), Nektar::VCSMapping::v_SolveViscous(), Nektar::VelocityCorrectionScheme::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::v_WallBC(), Nektar::AcousticSystem::v_WhiteNoiseBC(), Nektar::LinearSWE::WallBoundary(), Nektar::NonlinearPeregrine::WallBoundary(), Nektar::NonlinearSWE::WallBoundary(), Nektar::LinearSWE::WallBoundary2D(), Nektar::NonlinearPeregrine::WallBoundary2D(), Nektar::NonlinearSWE::WallBoundary2D(), Nektar::MMFSWE::WallBoundary2D(), Nektar::NonlinearPeregrine::WallBoundaryContVariables(), Nektar::NonlinearPeregrine::WallBoundaryForcing(), Nektar::NonlinearPeregrine::WCESolve(), Nektar::MMFAdvection::WeakDGDirectionalAdvection(), Nektar::MMFMaxwell::WeakDGMaxwellDirDeriv(), Nektar::MMFSWE::WeakDGSWEDirDeriv(), WriteFld(), Nektar::IterativeElasticSystem::WriteGeometry(), 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 333 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 374 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 432 of file EquationSystem.h.

Referenced by v_InitObject().

◆ m_homogen_dealiasing

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

Flag to determine if dealiasing is used for homogeneous simulations.

Definition at line 383 of file EquationSystem.h.

Referenced by Nektar::VelocityCorrectionScheme::v_GenerateSummary(), Nektar::VCSWeakPressure::v_GenerateSummary(), v_InitObject(), and Nektar::CoupledLinearNS::v_InitObject().

◆ m_HomogeneousType

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

◆ m_initialStep

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

◆ m_lambda

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

Lambda constant in real system if one required.

Definition at line 354 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 424 of file EquationSystem.h.

◆ m_LhomY

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

physical length in Y direction (if homogeneous)

Definition at line 425 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 426 of file EquationSystem.h.

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

◆ m_movingFrameProjMat

boost::numeric::ublas::matrix<NekDouble> Nektar::SolverUtils::EquationSystem::m_movingFrameProjMat
protected

◆ m_movingFrameTheta

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

Moving frame of reference angles with respect to the.

Definition at line 404 of file EquationSystem.h.

Referenced by Nektar::IncNavierStokes::GetMovingFrameAngles(), Nektar::IncNavierStokes::SetMovingFrameAngles(), Nektar::IncNavierStokes::v_InitObject(), and WriteFld().

◆ m_movingFrameVelsxyz

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

◆ m_multipleModes

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

Flag to determine if use multiple homogenenous modes are used.

Definition at line 376 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 428 of file EquationSystem.h.

◆ m_npointsY

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

number of points in Y direction (if homogeneous)

Definition at line 429 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

Number of Quadrature points used to work out the error.

Definition at line 411 of file EquationSystem.h.

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

◆ m_projectionType

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

Type of projection; e.g continuous or discontinuous.

Definition at line 388 of file EquationSystem.h.

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

◆ m_root

bool Nektar::SolverUtils::EquationSystem::m_root
protected

Definition at line 326 of file EquationSystem.h.

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

◆ m_session

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

The session reader.

Definition at line 328 of file EquationSystem.h.

Referenced by Nektar::LinearElasticSystem::BuildMatrixSystem(), Nektar::SolverUtils::UnsteadySystem::CheckForRestartTime(), 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::PulseWavePropagation::GetFluxVector(), GetFunction(), Nektar::SmoothedProfileMethod::GetFunctionHdl(), GetNvariables(), Nektar::IncNavierStokes::GetPivotPoint(), GetSession(), Nektar::UnsteadyAdvectionDiffusion::GetSubstepTimeStep(), GetVariable(), Nektar::Helmholtz::Helmholtz(), ImportFld(), ImportFldToMultiDomains(), Nektar::CompressibleFlowSystem::InitAdvection(), Nektar::CFSImplicit::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::LinearSWE::SetBoundaryConditions(), Nektar::NonlinearSWE::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::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::AcousticSystem::v_ExtraFldOutput(), Nektar::CompressibleFlowSystem::v_ExtraFldOutput(), Nektar::NavierStokesCFE::v_ExtraFldOutput(), Nektar::Poisson::v_GenerateSummary(), Nektar::Projection::v_GenerateSummary(), Nektar::UnsteadyAdvection::v_GenerateSummary(), Nektar::UnsteadyAdvectionDiffusion::v_GenerateSummary(), Nektar::VelocityCorrectionScheme::v_GenerateSummary(), Nektar::LinearSWE::v_GenerateSummary(), Nektar::SolverUtils::UnsteadySystem::v_GenerateSummary(), Nektar::Monodomain::v_GenerateSummary(), 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::Bidomain::v_InitObject(), Nektar::BidomainRoth::v_InitObject(), Nektar::Monodomain::v_InitObject(), Nektar::PulseWaveSystemOutput::v_InitObject(), v_InitObject(), Nektar::PulseWavePropagation::v_InitObject(), Nektar::PulseWaveSystem::v_InitObject(), Nektar::SolverUtils::AdvectionSystem::v_InitObject(), Nektar::SolverUtils::UnsteadySystem::v_InitObject(), Nektar::MMFDiffusion::v_InitObject(), Nektar::ImageWarpingSystem::v_InitObject(), Nektar::CoupledLinearNS::v_InitObject(), Nektar::SmoothedProfileMethod::v_InitObject(), Nektar::VCSMapping::v_InitObject(), Nektar::VelocityCorrectionScheme::v_InitObject(), Nektar::IncNavierStokes::v_InitObject(), Nektar::AcousticSystem::v_InitObject(), Nektar::APE::v_InitObject(), Nektar::LEE::v_InitObject(), Nektar::CFLtester::v_InitObject(), Nektar::EigenValuesAdvection::v_InitObject(), Nektar::MMFAdvection::v_InitObject(), Nektar::Poisson::v_InitObject(), Nektar::Projection::v_InitObject(), Nektar::SteadyAdvectionDiffusionReaction::v_InitObject(), Nektar::UnsteadyAdvection::v_InitObject(), Nektar::UnsteadyAdvectionDiffusion::v_InitObject(), Nektar::UnsteadyDiffusion::v_InitObject(), Nektar::UnsteadyInviscidBurger::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(), 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 331 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 368 of file EquationSystem.h.

Referenced by Nektar::CFSImplicit::AddMatNSBlkDiagBnd(), Nektar::CFSImplicit::AddMatNSBlkDiagVol(), Nektar::NonlinearPeregrine::AddVariableDepth(), 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::LinearSWE::DoOdeRhs(), Nektar::NonlinearSWE::DoOdeRhs(), Nektar::MMFAdvection::EvaluateAdvectionVelocity(), Nektar::IsentropicVortex::EvaluateIsentropicVortex(), Nektar::LinearSWE::GetFluxVector(), Nektar::NonlinearPeregrine::GetFluxVector(), Nektar::NonlinearSWE::GetFluxVector(), Nektar::CompressibleFlowSystem::GetFluxVector(), Nektar::UnsteadyAdvection::GetFluxVectorDeAlias(), Nektar::CompressibleFlowSystem::GetFluxVectorDeAlias(), Nektar::CFSImplicit::GetFluxVectorJacPoint(), Nektar::UnsteadyInviscidBurger::GetNormalVelocity(), Nektar::IncNavierStokes::GetPivotPoint(), Nektar::CFSImplicit::GetTraceJac(), Nektar::IncNavierStokes::GetVelocity(), Nektar::LinearSWE::GetVelocityVector(), Nektar::NonlinearPeregrine::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::IncNavierStokes::SetMRFDomainVelBCs(), Nektar::IncNavierStokes::SetMRFWallBCs(), Nektar::VelocityCorrectionScheme::SetupFlowrate(), Nektar::SolverUtils::MMFSystem::SetUpMovingFrames(), Nektar::IncNavierStokes::SetZeroNormalVelocity(), Nektar::VelocityCorrectionScheme::SolveUnsteadyStokesSystem(), 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::SolverUtils::UnsteadySystem::v_DoSolve(), Nektar::IsentropicVortex::v_EvaluateExactSolution(), 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::NavierStokesCFE::v_GetViscousFluxVector(), Nektar::NavierStokesCFEAxisym::v_GetViscousFluxVector(), Nektar::NavierStokesCFE::v_GetViscousFluxVectorDeAlias(), Nektar::Bidomain::v_InitObject(), Nektar::BidomainRoth::v_InitObject(), Nektar::Monodomain::v_InitObject(), v_InitObject(), Nektar::MMFDiffusion::v_InitObject(), Nektar::ImageWarpingSystem::v_InitObject(), Nektar::IncNavierStokes::v_InitObject(), Nektar::AcousticSystem::v_InitObject(), Nektar::CFLtester::v_InitObject(), Nektar::EigenValuesAdvection::v_InitObject(), Nektar::MMFAdvection::v_InitObject(), Nektar::SteadyAdvectionDiffusion::v_InitObject(), Nektar::UnsteadyAdvection::v_InitObject(), Nektar::UnsteadyAdvectionDiffusion::v_InitObject(), Nektar::CompressibleFlowSystem::v_InitObject(), Nektar::MMFMaxwell::v_InitObject(), Nektar::ShallowWaterSystem::v_InitObject(), Nektar::NavierStokesImplicitCFE::v_InitObject(), Nektar::APE::v_RiemannInvariantBC(), Nektar::LEE::v_RiemannInvariantBC(), Nektar::IsentropicVortex::v_SetInitialConditions(), Nektar::AcousticSystem::v_WallBC(), Nektar::AcousticSystem::v_WhiteNoiseBC(), Nektar::SolverUtils::MMFSystem::VectorAvgMagnitude(), Nektar::LinearSWE::WallBoundary(), Nektar::NonlinearPeregrine::WallBoundary(), and Nektar::NonlinearSWE::WallBoundary().

◆ m_specHP_dealiasing

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

◆ m_steps

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

◆ m_time

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

Current time of simulation.

Definition at line 343 of file EquationSystem.h.

Referenced by Nektar::SolverUtils::UnsteadySystem::CheckSteadyState(), Nektar::AcousticSystem::DoOdeRhs(), ErrorExtraPoints(), Nektar::CoupledLinearNS::EvaluateNewtonRHS(), GetFinalTime(), SetTime(), Nektar::IncNavierStokes::SetWomersleyBoundary(), Nektar::CFSImplicit::UpdateTimeStepCheck(), 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_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::AcousticSystem::v_PreIntegrate(), Nektar::UnsteadyAdvectionDiffusion::v_PreIntegrate(), Nektar::Dummy::v_PreIntegrate(), Nektar::IncNavierStokes::v_PreIntegrate(), v_SetInitialConditions(), Nektar::CompressibleFlowSystem::v_SteadyStateResidual(), Nektar::AcousticSystem::v_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_timestepMax

NekDouble Nektar::SolverUtils::EquationSystem::m_timestepMax = -1.0
protected

Time step size.

Definition at line 351 of file EquationSystem.h.

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

◆ m_traceNormals

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

Array holding trace normals for DG simulations in the forwards direction.

Definition at line 393 of file EquationSystem.h.

Referenced by Nektar::SolverUtils::MMFSystem::AverageMaxwellFlux1D(), Nektar::SolverUtils::MMFSystem::ComputencdotMF(), Nektar::SolverUtils::MMFSystem::ComputeNtimesMF(), Nektar::SolverUtils::MMFSystem::ComputeNtimestimesdFz(), Nektar::AcousticSystem::GetNormals(), Nektar::CompressibleFlowSystem::GetNormals(), Nektar::ShallowWaterSystem::GetNormals(), Nektar::UnsteadyAdvectionDiffusion::GetNormalVel(), Nektar::CFLtester::GetNormalVelocity(), Nektar::EigenValuesAdvection::GetNormalVelocity(), Nektar::MMFAdvection::GetNormalVelocity(), Nektar::UnsteadyAdvection::GetNormalVelocity(), Nektar::UnsteadyInviscidBurger::GetNormalVelocity(), Nektar::ImageWarpingSystem::GetNormalVelocity(), Nektar::UnsteadyViscousBurgers::GetNormalVelocity(), GetTraceNormals(), Nektar::SolverUtils::MMFSystem::LaxFriedrichMaxwellFlux1D(), Nektar::SolverUtils::MMFSystem::UpwindMaxwellFlux1D(), v_InitObject(), Nektar::CompressibleFlowSystem::v_InitObject(), Nektar::APE::v_RiemannInvariantBC(), Nektar::LEE::v_RiemannInvariantBC(), Nektar::AcousticSystem::v_WallBC(), Nektar::AcousticSystem::v_WhiteNoiseBC(), Nektar::LinearSWE::WallBoundary(), Nektar::NonlinearPeregrine::WallBoundary(), Nektar::NonlinearSWE::WallBoundary(), Nektar::LinearSWE::WallBoundary2D(), Nektar::NonlinearPeregrine::WallBoundary2D(), Nektar::NonlinearSWE::WallBoundary2D(), and Nektar::NonlinearPeregrine::WallBoundaryForcing().

◆ m_useFFT

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

Flag to determine if FFT is used for homogeneous transform.

Definition at line 378 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 325 of file EquationSystem.h.

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