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:

Public Member Functions
virtual SOLVER_UTILS_EXPORT	~EquationSystem ()
	Destructor. More...
SOLVER_UTILS_EXPORT void	InitObject (bool DeclareField=true)
	Initialises the members of this object. More...
SOLVER_UTILS_EXPORT void	DoInitialise (bool dumpInitialConditions=true)
	Perform any initialisation necessary before solving the problem. More...
SOLVER_UTILS_EXPORT void	DoSolve ()
	Solve the problem. More...
SOLVER_UTILS_EXPORT void	TransCoeffToPhys ()
	Transform from coefficient to physical space. More...
SOLVER_UTILS_EXPORT void	TransPhysToCoeff ()
	Transform from physical to coefficient space. More...
SOLVER_UTILS_EXPORT void	Output ()
	Perform output operations after solve. More...
SOLVER_UTILS_EXPORT std::string	GetSessionName ()
	Get Session name. More...
template<class T >
std::shared_ptr< T >	as ()
SOLVER_UTILS_EXPORT void	ResetSessionName (std::string newname)
	Reset Session name. More...
SOLVER_UTILS_EXPORT LibUtilities::SessionReaderSharedPtr	GetSession ()
	Get Session name. More...
SOLVER_UTILS_EXPORT MultiRegions::ExpListSharedPtr	GetPressure ()
	Get pressure field if available. More...
SOLVER_UTILS_EXPORT void	ExtraFldOutput (std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables)
SOLVER_UTILS_EXPORT void	PrintSummary (std::ostream &out)
	Print a summary of parameters and solver characteristics. More...
SOLVER_UTILS_EXPORT void	SetLambda (NekDouble lambda)
	Set parameter m_lambda. More...
SOLVER_UTILS_EXPORT SessionFunctionSharedPtr	GetFunction (std::string name, const MultiRegions::ExpListSharedPtr &field=MultiRegions::NullExpListSharedPtr, bool cache=false)
	Get a SessionFunction by name. More...
SOLVER_UTILS_EXPORT void	SetInitialConditions (NekDouble initialtime=0.0, bool dumpInitialConditions=true, const int domain=0)
	Initialise the data in the dependent fields. More...
SOLVER_UTILS_EXPORT void	EvaluateExactSolution (int field, Array< OneD, NekDouble > &outfield, const NekDouble time)
	Evaluates an exact solution. More...
SOLVER_UTILS_EXPORT NekDouble	L2Error (unsigned int field, const Array< OneD, NekDouble > &exactsoln, bool Normalised=false)
	Compute the L2 error between fields and a given exact solution. More...
SOLVER_UTILS_EXPORT NekDouble	L2Error (unsigned int field, bool Normalised=false)
	Compute the L2 error of the fields. More...
SOLVER_UTILS_EXPORT NekDouble	LinfError (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray)
	Linf error computation. More...
SOLVER_UTILS_EXPORT Array< OneD, NekDouble >	ErrorExtraPoints (unsigned int field)
	Compute error (L2 and L_inf) over an larger set of quadrature points return [L2 Linf]. More...
SOLVER_UTILS_EXPORT void	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::FieldMetaDataMap &	UpdateFieldMetaDataMap ()
	Get hold of FieldInfoMap so it can be updated. More...
SOLVER_UTILS_EXPORT NekDouble	GetTime ()
	Return final time. More...
SOLVER_UTILS_EXPORT int	GetNcoeffs ()
SOLVER_UTILS_EXPORT int	GetNcoeffs (const int eid)
SOLVER_UTILS_EXPORT int	GetNumExpModes ()
SOLVER_UTILS_EXPORT const Array< OneD, int >	GetNumExpModesPerExp ()
SOLVER_UTILS_EXPORT int	GetNvariables ()
SOLVER_UTILS_EXPORT const std::string	GetVariable (unsigned int i)
SOLVER_UTILS_EXPORT int	GetTraceTotPoints ()
SOLVER_UTILS_EXPORT int	GetTraceNpoints ()
SOLVER_UTILS_EXPORT int	GetExpSize ()
SOLVER_UTILS_EXPORT int	GetPhys_Offset (int n)
SOLVER_UTILS_EXPORT int	GetCoeff_Offset (int n)
SOLVER_UTILS_EXPORT int	GetTotPoints ()
SOLVER_UTILS_EXPORT int	GetTotPoints (int n)
SOLVER_UTILS_EXPORT int	GetNpoints ()
SOLVER_UTILS_EXPORT int	GetSteps ()
SOLVER_UTILS_EXPORT NekDouble	GetTimeStep ()
SOLVER_UTILS_EXPORT void	CopyFromPhysField (const int i, Array< OneD, NekDouble > &output)
SOLVER_UTILS_EXPORT void	CopyToPhysField (const int i, const Array< OneD, const NekDouble > &input)
SOLVER_UTILS_EXPORT Array< OneD, NekDouble > &	UpdatePhysField (const int i)
SOLVER_UTILS_EXPORT void	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 int	GetInfoSteps ()
SOLVER_UTILS_EXPORT void	SetInfoSteps (int num)
SOLVER_UTILS_EXPORT void	SetIterationNumberPIT (int num)
SOLVER_UTILS_EXPORT void	SetWindowNumberPIT (int num)
SOLVER_UTILS_EXPORT Array< OneD, const Array< OneD, NekDouble > >	GetTraceNormals ()
SOLVER_UTILS_EXPORT void	SetTime (const NekDouble time)
SOLVER_UTILS_EXPORT void	SetTimeStep (const NekDouble timestep)
SOLVER_UTILS_EXPORT void	SetInitialStep (const int step)
SOLVER_UTILS_EXPORT void	SetBoundaryConditions (NekDouble time)
	Evaluates the boundary conditions at the given time. More...
SOLVER_UTILS_EXPORT bool	NegatedOp ()
	Identify if operator is negated in DoSolve. More...

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

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

Protected Attributes
LibUtilities::CommSharedPtr	m_comm
	Communicator. More...
bool	m_verbose
LibUtilities::SessionReaderSharedPtr	m_session
	The session reader. More...
std::map< std::string, SolverUtils::SessionFunctionSharedPtr >	m_sessionFunctions
	Map of known SessionFunctions. More...
LibUtilities::FieldIOSharedPtr	m_fld
	Field input/output. More...
Array< OneD, MultiRegions::ExpListSharedPtr >	m_fields
	Array holding all dependent variables. More...
SpatialDomains::BoundaryConditionsSharedPtr	m_boundaryConditions
	Pointer to boundary conditions object. More...
SpatialDomains::MeshGraphSharedPtr	m_graph
	Pointer to graph defining mesh. More...
std::string	m_sessionName
	Name of the session. More...
NekDouble	m_time
	Current time of simulation. More...
int	m_initialStep
	Number of the step where the simulation should begin. More...
NekDouble	m_fintime
	Finish time of the simulation. More...
NekDouble	m_timestep
	Time step size. More...
NekDouble	m_lambda
	Lambda constant in real system if one required. More...
NekDouble	m_checktime
	Time between checkpoints. More...
NekDouble	m_lastCheckTime
NekDouble	m_TimeIncrementFactor
int	m_nchk
	Number of checkpoints written so far. More...
int	m_steps
	Number of steps to take. More...
int	m_checksteps
	Number of steps between checkpoints. More...
int	m_infosteps
	Number of time steps between outputting status information. More...
int	m_iterPIT = 0
	Number of parallel-in-time time iteration. More...
int	m_windowPIT = 0
	Index of windows for parallel-in-time time iteration. More...
int	m_spacedim
	Spatial dimension (>= expansion dim). More...
int	m_expdim
	Expansion dimension. More...
bool	m_singleMode
	Flag to determine if single homogeneous mode is used. More...
bool	m_halfMode
	Flag to determine if half homogeneous mode is used. More...
bool	m_multipleModes
	Flag to determine if use multiple homogenenous modes are used. More...
bool	m_useFFT
	Flag to determine if FFT is used for homogeneous transform. More...
bool	m_homogen_dealiasing
	Flag to determine if dealiasing is used for homogeneous simulations. More...
bool	m_specHP_dealiasing
	Flag to determine if dealisising is usde for the Spectral/hp element discretisation. More...
enum MultiRegions::ProjectionType	m_projectionType
	Type of projection; e.g continuous or discontinuous. More...
Array< OneD, Array< OneD, NekDouble > >	m_traceNormals
	Array holding trace normals for DG simulations in the forwards direction. More...
Array< OneD, bool >	m_checkIfSystemSingular
	Flag to indicate if the fields should be checked for singularity. More...
LibUtilities::FieldMetaDataMap	m_fieldMetaDataMap
	Map to identify relevant solver info to dump in output fields. More...
Array< OneD, NekDouble >	m_movingFrameVelsxyz
	Moving frame of reference velocities (u, v, w, omega_x, omega_y, omega_z, a_x, a_y, a_z, domega_x, domega_y, domega_z) More...
Array< OneD, NekDouble >	m_movingFrameData
	Moving frame of reference angles with respect to the. More...
boost::numeric::ublas::matrix< NekDouble >	m_movingFrameProjMat
	Projection matrix for transformation between inertial and moving. More...
int	m_NumQuadPointsError
	Number of Quadrature points used to work out the error. More...
enum HomogeneousType	m_HomogeneousType
NekDouble	m_LhomX
	physical length in X direction (if homogeneous) More...
NekDouble	m_LhomY
	physical length in Y direction (if homogeneous) More...
NekDouble	m_LhomZ
	physical length in Z direction (if homogeneous) More...
int	m_npointsX
	number of points in X direction (if homogeneous) More...
int	m_npointsY
	number of points in Y direction (if homogeneous) More...
int	m_npointsZ
	number of points in Z direction (if homogeneous) More...
int	m_HomoDirec
	number of homogenous directions More...

Static Protected Attributes
static std::string	equationSystemTypeLookupIds []
static std::string	projectionTypeLookupIds []

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

Detailed Description

A base class for describing how to solve specific equations.

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

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

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

Definition at line 75 of file EquationSystem.h.

Member Enumeration Documentation

HomogeneousType

enum Nektar::SolverUtils::EquationSystem::HomogeneousType

protected

Parameter for homogeneous expansions.

Enumerator
eHomogeneous1D
eHomogeneous2D
eHomogeneous3D
eNotHomogeneous

Definition at line 445 of file EquationSystem.h.

    {
        eHomogeneous1D,
        eHomogeneous2D,
        eHomogeneous3D,
        eNotHomogeneous
    };

Constructor & Destructor Documentation

~EquationSystem()

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

virtual

Destructor.

Destructor for class EquationSystem.

Definition at line 132 of file EquationSystem.cpp.

{
    LibUtilities::NekManager<LocalRegions::MatrixKey, DNekScalMat,
                             LocalRegions::MatrixKey::opLess>::ClearManager();
    LibUtilities::NekManager<LocalRegions::MatrixKey, DNekScalBlkMat,
                             LocalRegions::MatrixKey::opLess>::ClearManager();
}

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

pSession

The session reader holding problem parameters.

Definition at line 110 of file EquationSystem.cpp.

    : m_comm(pSession->GetComm()), m_session(pSession), m_graph(pGraph),
      m_lambda(0), m_infosteps(10),
      m_fieldMetaDataMap(LibUtilities::NullFieldMetaDataMap)
{
    // set up session names in fieldMetaDataMap
    const vector<std::string> filenames = m_session->GetFilenames();
 
    for (int i = 0; i < filenames.size(); ++i)
    {
        string sessionname = "SessionName";
        sessionname += std::to_string(i);
        m_fieldMetaDataMap[sessionname]  = filenames[i];
        m_fieldMetaDataMap["ChkFileNum"] = std::to_string(0);
    }
}

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

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

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

n	The index of the base flow file.

Definition at line 1227 of file EquationSystem.cpp.

{
    std::string outname = m_sessionName + "_BaseFlow_" + std::to_string(n);
 
    WriteFld(outname + ".chk");
}

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

n	The index of the checkpoint file.

Definition at line 1176 of file EquationSystem.cpp.

{
    if (!m_comm->IsParallelInTime())
    {
        // Serial-in-time
        std::string outname = m_sessionName + "_" + std::to_string(n);
        WriteFld(outname + ".chk");
    }
    else
    {
        // Parallel-in-time
        auto loc         = m_sessionName.find("_xml/");
        auto sessionName = m_sessionName.substr(0, loc);
        std::string paradir =
            sessionName + "_" + std::to_string(m_iterPIT) + ".pit";
        if (!fs::is_directory(paradir))
        {
            fs::create_directory(paradir);
        }
        std::string outname = paradir + "/" + sessionName + "_timeLevel" +
                              std::to_string(m_session->GetTimeLevel()) + "_" +
                              std::to_string(n);
        WriteFld(outname + ".chk");
    }
}

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

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

Checkpoint_Output() [2/2]

void Nektar::SolverUtils::EquationSystem::Checkpoint_Output	(	const int	n,
		MultiRegions::ExpListSharedPtr &	field,
		std::vector< Array< OneD, NekDouble > > &	fieldcoeffs,
		std::vector< std::string > &	variables
	)

Write checkpoint file of custom data fields.

Write the n-th checkpoint file.

Parameters

n	The index of the checkpoint file.

Definition at line 1206 of file EquationSystem.cpp.

{
    if (!m_comm->IsParallelInTime())
    {
        // Serial-in-time
        std::string outname = m_sessionName + "_" + std::to_string(n);
        WriteFld(outname, field, fieldcoeffs, variables);
    }
    else
    {
        ASSERTL0(false, "Not Implemented for Parallel-in-Time");
    }
}

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

CopyFromPhysField()

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

inline

Definition at line 794 of file EquationSystem.h.

{
    Vmath::Vcopy(output.size(), m_fields[i]->GetPhys(), 1, output, 1);
}

References m_fields, and Vmath::Vcopy().

CopyToPhysField()

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

inline

Definition at line 800 of file EquationSystem.h.

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

References m_fields, and Vmath::Vcopy().

DoInitialise()

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

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

{
    v_DoInitialise(dumpInitialConditions);
}

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

{
    v_DoSolve();
}

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

field

The field to compare.

Returns

Error in the L2-norm and L-inf norm.

Definition at line 899 of file EquationSystem.cpp.

{
    int NumModes = GetNumExpModes();
    Array<OneD, NekDouble> L2INF(2);
 
    const LibUtilities::PointsKey PkeyT1(m_NumQuadPointsError,
                                         LibUtilities::eGaussLobattoLegendre);
    const LibUtilities::PointsKey PkeyT2(m_NumQuadPointsError,
                                         LibUtilities::eGaussRadauMAlpha1Beta0);
    const LibUtilities::PointsKey PkeyQ1(m_NumQuadPointsError,
                                         LibUtilities::eGaussLobattoLegendre);
    const LibUtilities::PointsKey PkeyQ2(m_NumQuadPointsError,
                                         LibUtilities::eGaussLobattoLegendre);
    const LibUtilities::BasisKey BkeyT1(LibUtilities::eModified_A, NumModes,
                                        PkeyT1);
    const LibUtilities::BasisKey BkeyT2(LibUtilities::eModified_B, NumModes,
                                        PkeyT2);
    const LibUtilities::BasisKey BkeyQ1(LibUtilities::eModified_A, NumModes,
                                        PkeyQ1);
    const LibUtilities::BasisKey BkeyQ2(LibUtilities::eModified_A, NumModes,
                                        PkeyQ2);
 
    LibUtilities::BasisKeyVector Tkeys, Qkeys;
 
    // make a copy of the ExpansionInfoMap
    SpatialDomains::ExpansionInfoMap NewExpInfo = m_graph->GetExpansionInfo();
    SpatialDomains::ExpansionInfoMapShPtr ExpInfo =
        MemoryManager<SpatialDomains::ExpansionInfoMap>::AllocateSharedPtr(
            NewExpInfo);
 
    // reset new graph with new keys
    Tkeys.push_back(BkeyT1);
    Tkeys.push_back(BkeyT2);
    m_graph->ResetExpansionInfoToBasisKey(ExpInfo, LibUtilities::eTriangle,
                                          Tkeys);
    Qkeys.push_back(BkeyQ1);
    Qkeys.push_back(BkeyQ2);
    m_graph->ResetExpansionInfoToBasisKey(ExpInfo, LibUtilities::eQuadrilateral,
                                          Qkeys);
 
    MultiRegions::ExpListSharedPtr ErrorExp =
        MemoryManager<MultiRegions::ExpList>::AllocateSharedPtr(m_session,
                                                                NewExpInfo);
 
    int ErrorCoordim = ErrorExp->GetCoordim(0);
    int ErrorNq      = ErrorExp->GetTotPoints();
 
    Array<OneD, NekDouble> ErrorXc0(ErrorNq, 0.0);
    Array<OneD, NekDouble> ErrorXc1(ErrorNq, 0.0);
    Array<OneD, NekDouble> ErrorXc2(ErrorNq, 0.0);
 
    switch (ErrorCoordim)
    {
        case 1:
            ErrorExp->GetCoords(ErrorXc0);
            break;
        case 2:
            ErrorExp->GetCoords(ErrorXc0, ErrorXc1);
            break;
        case 3:
            ErrorExp->GetCoords(ErrorXc0, ErrorXc1, ErrorXc2);
            break;
    }
    LibUtilities::EquationSharedPtr exSol =
        m_session->GetFunction("ExactSolution", field);
 
    // Evaluate the exact solution
    Array<OneD, NekDouble> ErrorSol(ErrorNq);
 
    exSol->Evaluate(ErrorXc0, ErrorXc1, ErrorXc2, m_time, ErrorSol);
 
    // Calcualte spectral/hp approximation on the quadrature points
    // of this new expansion basis
    ErrorExp->BwdTrans(m_fields[field]->GetCoeffs(), ErrorExp->UpdatePhys());
 
    L2INF[0] = ErrorExp->L2(ErrorExp->GetPhys(), ErrorSol);
    L2INF[1] = ErrorExp->Linf(ErrorExp->GetPhys(), ErrorSol);
 
    return L2INF;
}

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

{
    v_EvaluateExactSolution(field, outfield, 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

fieldcoeffs	Vector with coefficients
variables	Vector with name of variables

Definition at line 631 of file EquationSystem.h.

{
    v_ExtraFldOutput(fieldcoeffs, variables);
}

References v_ExtraFldOutput().

Referenced by WriteFld().

FwdTransFields()

void Nektar::SolverUtils::EquationSystem::FwdTransFields

(

void

)

FwdTrans the m_fields members

Definition at line 1162 of file EquationSystem.cpp.

{
    for (int i = 0; i < m_fields.size(); i++)
    {
        m_fields[i]->FwdTrans(m_fields[i]->GetPhys(),
                              m_fields[i]->UpdateCoeffs());
        m_fields[i]->SetPhysState(false);
    }
}

References m_fields.

GetCheckpointNumber()

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

inline

Definition at line 281 of file EquationSystem.h.

    {
        return m_nchk;
    }

References m_nchk.

GetCheckpointSteps()

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

inline

Definition at line 291 of file EquationSystem.h.

    {
        return m_checksteps;
    }

References m_checksteps.

GetCoeff_Offset()

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

inline

Definition at line 759 of file EquationSystem.h.

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

References m_fields.

GetExpSize()

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

inline

Definition at line 749 of file EquationSystem.h.

{
    return m_fields[0]->GetExpSize();
}

References m_fields.

Referenced by Nektar::SolverUtils::MMFSystem::CopyBoundaryTrace(), Nektar::AcousticSystem::CopyBoundaryTrace(), Nektar::ShallowWaterSystem::CopyBoundaryTrace(), Nektar::CompressibleFlowSystem::GetStabilityLimitVector(), Nektar::UnsteadyAdvectionDiffusion::SubStepAdvance(), Nektar::LinearSWE::WallBoundary(), Nektar::NonlinearSWE::WallBoundary(), Nektar::LinearSWE::WallBoundary2D(), Nektar::NonlinearSWE::WallBoundary2D(), and Nektar::MMFSWE::WallBoundary2D().

GetFunction()

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

Get a SessionFunction by name.

Definition at line 741 of file EquationSystem.cpp.

{
    MultiRegions::ExpListSharedPtr vField = field;
    if (!field)
    {
        vField = m_fields[0];
    }
 
    if (cache)
    {
        if ((m_sessionFunctions.find(name) == m_sessionFunctions.end()) ||
            (m_sessionFunctions[name]->GetSession() != m_session) ||
            (m_sessionFunctions[name]->GetExpansion() != vField))
        {
            m_sessionFunctions[name] =
                MemoryManager<SessionFunction>::AllocateSharedPtr(
                    m_session, vField, name, cache);
        }
 
        return m_sessionFunctions[name];
    }
    else
    {
        return SessionFunctionSharedPtr(
            new SessionFunction(m_session, vField, name, cache));
    }
}

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::PulseWaveSystem::v_InitObject(), Nektar::BidomainRoth::v_InitObject(), Nektar::Monodomain::v_InitObject(), Nektar::APE::v_InitObject(), Nektar::LEE::v_InitObject(), Nektar::EigenValuesAdvection::v_InitObject(), Nektar::MMFAdvection::v_InitObject(), Nektar::Poisson::v_InitObject(), Nektar::Projection::v_InitObject(), Nektar::SteadyAdvectionDiffusion::v_InitObject(), Nektar::UnsteadyAdvection::v_InitObject(), v_L2Error(), Nektar::PulseWaveSystem::v_L2Error(), v_LinfError(), Nektar::PulseWaveSystem::v_LinfError(), Nektar::Dummy::v_PostIntegrate(), Nektar::AcousticSystem::v_PreIntegrate(), and v_SetInitialConditions().

GetInfoSteps()

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

inline

Definition at line 301 of file EquationSystem.h.

    {
        return m_infosteps;
    }

References m_infosteps.

GetNcoeffs() [1/2]

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

inline

Definition at line 706 of file EquationSystem.h.

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

References m_fields.

Referenced by Nektar::LinearSWE::AddCoriolis(), Nektar::NonlinearPeregrine::AddCoriolis(), Nektar::NonlinearSWE::AddCoriolis(), Nektar::NonlinearPeregrine::AddVariableDepth(), Nektar::NonlinearSWE::AddVariableDepth(), Nektar::CoupledLinearNS::DefineForcingTerm(), Nektar::MMFAdvection::DoOdeProjection(), Nektar::UnsteadyDiffusion::DoOdeProjection(), Nektar::UnsteadyInviscidBurgers::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 711 of file EquationSystem.h.

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

References m_fields.

GetNpoints()

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

inline

Definition at line 774 of file EquationSystem.h.

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

References m_fields.

Referenced by Nektar::SolverUtils::UnsteadySystem::AppendOutput1D(), Nektar::MMFMaxwell::ComputeMaterialMicroWaveCloak(), Nektar::MMFMaxwell::ComputeMaterialOpticalCloak(), Nektar::MMFMaxwell::ComputeRadCloak(), Nektar::SolverUtils::UnsteadySystem::DoDummyProjection(), Nektar::MMFAdvection::DoOdeProjection(), Nektar::UnsteadyAdvection::DoOdeProjection(), Nektar::UnsteadyDiffusion::DoOdeProjection(), Nektar::UnsteadyInviscidBurgers::DoOdeProjection(), Nektar::CompressibleFlowSystem::DoOdeProjection(), Nektar::ImageWarpingSystem::DoOdeProjection(), Nektar::MMFMaxwell::DoOdeProjection(), Nektar::LinearSWE::DoOdeProjection(), Nektar::NonlinearPeregrine::DoOdeProjection(), Nektar::NonlinearSWE::DoOdeProjection(), Nektar::MMFAdvection::DoOdeRhs(), Nektar::UnsteadyAdvection::DoOdeRhs(), Nektar::UnsteadyAdvectionDiffusion::DoOdeRhs(), Nektar::UnsteadyInviscidBurgers::DoOdeRhs(), Nektar::UnsteadyViscousBurgers::DoOdeRhs(), Nektar::CompressibleFlowSystem::DoOdeRhs(), Nektar::ImageWarpingSystem::DoOdeRhs(), Nektar::SolverUtils::FileSolution::DoOdeRhs(), Nektar::UnsteadyInviscidBurgers::GetFluxVector(), Nektar::UnsteadyInviscidBurgers::GetNormalVelocity(), Nektar::CFSImplicit::NumCalcRiemFluxJac(), Nektar::CoupledLinearNS::Solve(), Nektar::NavierStokesCFE::v_DoDiffusion(), Nektar::NavierStokesCFEAxisym::v_DoDiffusion(), Nektar::NavierStokesImplicitCFE::v_DoDiffusionCoeff(), Nektar::EigenValuesAdvection::v_DoSolve(), Nektar::LinearElasticSystem::v_DoSolve(), Nektar::SolverUtils::FileSolution::v_GetDensity(), 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 716 of file EquationSystem.h.

{
    return m_graph->GetExpansionInfo()
        .begin()
        ->second->m_basisKeyVector[0]
        .GetNumModes();
}

References m_graph.

Referenced by ErrorExtraPoints().

GetNumExpModesPerExp()

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

inline

Definition at line 724 of file EquationSystem.h.

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

References m_fields.

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

GetNvariables()

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

inline

Definition at line 729 of file EquationSystem.h.

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

References m_session.

Referenced by ImportFldToMultiDomains().

GetPhys_Offset()

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

inline

Definition at line 754 of file EquationSystem.h.

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

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

{
    return v_GetPressure();
}

References v_GetPressure().

GetSession()

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

inline

Get Session name.

Definition at line 118 of file EquationSystem.h.

    {
        return m_session;
    }

References m_session.

GetSessionName()

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

inline

Get Session name.

Definition at line 101 of file EquationSystem.h.

    {
        return m_sessionName;
    }

References m_sessionName.

GetSteps()

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

inline

Definition at line 779 of file EquationSystem.h.

{
    return m_steps;
}

References m_steps.

GetTime()

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

inline

Return final time.

Return time.

Definition at line 701 of file EquationSystem.h.

{
    return m_time;
}

References m_time.

GetTimeStep()

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

inline

Definition at line 784 of file EquationSystem.h.

{
    return m_timestep;
}

References m_timestep.

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

GetTotPoints() [1/2]

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

inline

Definition at line 764 of file EquationSystem.h.

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

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::CompressibleFlowSystem::EvaluateIsentropicVortex(), Nektar::CoupledLinearNS::EvaluateNewtonRHS(), Nektar::MMFSWE::EvaluateStandardCoriolis(), Nektar::MMFSWE::EvaluateWaterDepth(), Nektar::CompressibleFlowSystem::GetExactRinglebFlow(), Nektar::MMFSWE::IsolatedMountainFlow(), Nektar::NonlinearPeregrine::LaitoneSolitaryWave(), Nektar::MMFDiffusion::Morphogenesis(), Nektar::CFSImplicit::MultiplyElmtInvMassPlusSource(), Nektar::MMFDiffusion::PlanePhiWave(), Nektar::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::VCSImplicit::v_DoInitialise(), Nektar::CoupledLinearNS::v_DoInitialise(), Nektar::VCSMapping::v_DoInitialise(), Nektar::VelocityCorrectionScheme::v_DoInitialise(), Nektar::SolverUtils::UnsteadySystem::v_DoSolve(), Nektar::SteadyAdvectionDiffusion::v_DoSolve(), Nektar::MMFMaxwell::v_DoSolve(), Nektar::MMFDiffusion::v_EvaluateExactSolution(), Nektar::CompressibleFlowSystem::v_GetMaxStdVelocity(), Nektar::APE::v_InitObject(), Nektar::LEE::v_InitObject(), Nektar::ShallowWaterSystem::v_InitObject(), 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::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 769 of file EquationSystem.h.

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

References m_fields.

GetTraceNormals()

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

inline

Definition at line 321 of file EquationSystem.h.

    {
        return m_traceNormals;
    }

References m_traceNormals.

GetTraceNpoints()

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

inline

Definition at line 744 of file EquationSystem.h.

{
    return m_fields[0]->GetTrace()->GetNpoints();
}

References m_fields.

Referenced by Nektar::SolverUtils::MMFSystem::ComputencdotMF(), Nektar::SolverUtils::MMFSystem::ComputeNtimesMF(), Nektar::SolverUtils::MMFSystem::ComputeZimYim(), Nektar::UnsteadyAdvection::GetNormalVel(), Nektar::EigenValuesAdvection::GetNormalVelocity(), Nektar::MMFAdvection::GetNormalVelocity(), Nektar::UnsteadyInviscidBurgers::GetNormalVelocity(), Nektar::ImageWarpingSystem::GetNormalVelocity(), GetTraceTotPoints(), Nektar::MMFMaxwell::v_DoSolve(), v_InitObject(), Nektar::ImageWarpingSystem::v_InitObject(), Nektar::APE::v_InitObject(), Nektar::LEE::v_InitObject(), Nektar::EigenValuesAdvection::v_InitObject(), Nektar::MMFAdvection::v_InitObject(), Nektar::UnsteadyAdvection::v_InitObject(), Nektar::UnsteadyAdvectionDiffusion::v_InitObject(), Nektar::UnsteadyInviscidBurgers::v_InitObject(), Nektar::UnsteadyViscousBurgers::v_InitObject(), Nektar::MMFAdvection::WeakDGDirectionalAdvection(), Nektar::MMFMaxwell::WeakDGMaxwellDirDeriv(), and Nektar::MMFSWE::WeakDGSWEDirDeriv().

GetTraceTotPoints()

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

inline

Definition at line 739 of file EquationSystem.h.

{
    return 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 734 of file EquationSystem.h.

{
    return m_session->GetVariable(i);
}

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

infile

Filename to read.

Definition at line 1334 of file EquationSystem.cpp.

{
    std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef;
    std::vector<std::vector<NekDouble>> FieldData;
    LibUtilities::FieldIOSharedPtr field_fld =
        LibUtilities::FieldIO::CreateForFile(m_session, infile);
    field_fld->Import(infile, FieldDef, FieldData);
 
    // Copy FieldData into m_fields
    for (int j = 0; j < pFields.size(); ++j)
    {
        Vmath::Zero(pFields[j]->GetNcoeffs(), pFields[j]->UpdateCoeffs(), 1);
 
        for (int i = 0; i < FieldDef.size(); ++i)
        {
            ASSERTL1(FieldDef[i]->m_fields[j] == m_session->GetVariable(j),
                     std::string("Order of ") + infile +
                         std::string(" data and that defined in "
                                     "m_boundaryconditions differs"));
 
            pFields[j]->ExtractDataToCoeffs(FieldDef[i], FieldData[i],
                                            FieldDef[i]->m_fields[j],
                                            pFields[j]->UpdateCoeffs());
        }
        pFields[j]->BwdTrans(pFields[j]->GetCoeffs(), pFields[j]->UpdatePhys());
    }
}

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

{
    std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef;
    std::vector<std::vector<NekDouble>> FieldData;
 
    LibUtilities::FieldIOSharedPtr field_fld =
        LibUtilities::FieldIO::CreateForFile(m_session, infile);
    field_fld->Import(infile, FieldDef, FieldData);
    int idx = -1;
 
    Vmath::Zero(pField->GetNcoeffs(), pField->UpdateCoeffs(), 1);
 
    for (int i = 0; i < FieldDef.size(); ++i)
    {
        // find the index of the required field in the file.
        for (int j = 0; j < FieldData.size(); ++j)
        {
            if (FieldDef[i]->m_fields[j] == pFieldName)
            {
                idx = j;
            }
        }
        ASSERTL1(idx >= 0, "Field " + pFieldName + " not found.");
 
        pField->ExtractDataToCoeffs(FieldDef[i], FieldData[i],
                                    FieldDef[i]->m_fields[idx],
                                    pField->UpdateCoeffs());
    }
    pField->BwdTrans(pField->GetCoeffs(), pField->UpdatePhys());
}

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

infile	Filename to read.
fieldStr	an array of string identifying fields to be imported
coeffs	array of array of coefficients to store imported data

Definition at line 1458 of file EquationSystem.cpp.

{
 
    ASSERTL0(fieldStr.size() <= coeffs.size(),
             "length of fieldstr should be the same as coeffs");
 
    std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef;
    std::vector<std::vector<NekDouble>> FieldData;
 
    LibUtilities::FieldIOSharedPtr field_fld =
        LibUtilities::FieldIO::CreateForFile(m_session, infile);
    field_fld->Import(infile, FieldDef, FieldData);
 
    // Copy FieldData into m_fields
    for (int j = 0; j < fieldStr.size(); ++j)
    {
        Vmath::Zero(coeffs[j].size(), coeffs[j], 1);
        for (int i = 0; i < FieldDef.size(); ++i)
        {
            m_fields[0]->ExtractDataToCoeffs(FieldDef[i], FieldData[i],
                                             fieldStr[j], coeffs[j]);
        }
    }
}

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

infile

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

Definition at line 1372 of file EquationSystem.cpp.

{
    std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef;
    std::vector<std::vector<NekDouble>> FieldData;
 
    LibUtilities::Import(infile, FieldDef, FieldData);
 
    int nvariables = GetNvariables();
 
    ASSERTL0(
        ndomains * nvariables == pFields.size(),
        "Number of fields does not match the number of variables and domains");
 
    // Copy FieldData into m_fields
    for (int j = 0; j < ndomains; ++j)
    {
        for (int i = 0; i < nvariables; ++i)
        {
            Vmath::Zero(pFields[j * nvariables + i]->GetNcoeffs(),
                        pFields[j * nvariables + i]->UpdateCoeffs(), 1);
 
            for (int n = 0; n < FieldDef.size(); ++n)
            {
                ASSERTL1(FieldDef[n]->m_fields[i] == m_session->GetVariable(i),
                         std::string("Order of ") + infile +
                             std::string(" data and that defined in "
                                         "m_boundaryconditions differs"));
 
                pFields[j * nvariables + i]->ExtractDataToCoeffs(
                    FieldDef[n], FieldData[n], FieldDef[n]->m_fields[i],
                    pFields[j * nvariables + i]->UpdateCoeffs());
            }
            pFields[j * nvariables + i]->BwdTrans(
                pFields[j * nvariables + i]->GetCoeffs(),
                pFields[j * nvariables + i]->UpdatePhys());
        }
    }
}

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

{
    v_InitObject(DeclareField);
}

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

    {
        return L2Error(field, NullNekDouble1DArray, Normalised);
    }

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

{
    return v_L2Error(field, exactsoln, Normalised);
}

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

{
    return v_LinfError(field, exactsoln);
}

References v_LinfError().

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

NegatedOp()

bool Nektar::SolverUtils::EquationSystem::NegatedOp ( void  )

inline

Identify if operator is negated in DoSolve.

Definition at line 689 of file EquationSystem.h.

{
    return v_NegatedOp();
}

References v_NegatedOp().

Output()

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

inline

Perform output operations after solve.

Perform output operations after solve.

Definition at line 590 of file EquationSystem.h.

{
    v_Output();
}

References v_Output().

PrintProgressbar()

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

inlineprivate

Definition at line 529 of file EquationSystem.h.

    {
        LibUtilities::PrintProgressbar(position, goal, "Interpolating");
    }

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

out	The ostream object to write to.

Definition at line 645 of file EquationSystem.h.

{
    if (m_session->GetComm()->GetRank() == 0)
    {
        std::vector<std::pair<std::string, std::string>> vSummary;
        v_GenerateSummary(vSummary);
 
        out << "==============================================================="
               "========"
            << std::endl
            << std::flush;
        for (auto &x : vSummary)
        {
            out << "\t";
            out.width(20);
            out << x.first << ": " << x.second << std::endl << std::flush;
        }
        out << "==============================================================="
               "========"
            << std::endl
            << std::flush;
    }
}

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

    {
        m_sessionName = newname;
    }

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

out	Output stream to write data to.

Definition at line 1489 of file EquationSystem.cpp.

{
    AddSummaryItem(s, "EquationType", m_session->GetSolverInfo("EQTYPE"));
    AddSummaryItem(s, "Session Name", m_sessionName);
    AddSummaryItem(s, "Spatial Dim.", m_spacedim);
    AddSummaryItem(s, "Max SEM Exp. Order",
                   m_fields[0]->EvalBasisNumModesMax());
 
    if (m_session->GetComm()->GetSize() > 1)
    {
        AddSummaryItem(s, "Num. Processes", m_session->GetComm()->GetSize());
    }
 
    if (m_HomogeneousType == eHomogeneous1D)
    {
        AddSummaryItem(s, "Quasi-3D", "Homogeneous in z-direction");
        AddSummaryItem(s, "Expansion Dim.", m_expdim + 1);
        AddSummaryItem(s, "Num. Hom. Modes (z)", m_npointsZ);
        AddSummaryItem(s, "Hom. length (LZ)", m_LhomZ);
        AddSummaryItem(s, "FFT Type", m_useFFT ? "FFTW" : "MVM");
        if (m_halfMode)
        {
            AddSummaryItem(s, "ModeType", "Half Mode");
        }
        else if (m_singleMode)
        {
            AddSummaryItem(s, "ModeType", "Single Mode");
        }
        else if (m_multipleModes)
        {
            AddSummaryItem(s, "ModeType", "Multiple Modes");
        }
    }
    else if (m_HomogeneousType == eHomogeneous2D)
    {
        AddSummaryItem(s, "Quasi-3D", "Homogeneous in yz-plane");
        AddSummaryItem(s, "Expansion Dim.", m_expdim + 2);
        AddSummaryItem(s, "Num. Hom. Modes (y)", m_npointsY);
        AddSummaryItem(s, "Num. Hom. Modes (z)", m_npointsZ);
        AddSummaryItem(s, "Hom. length (LY)", m_LhomY);
        AddSummaryItem(s, "Hom. length (LZ)", m_LhomZ);
        AddSummaryItem(s, "FFT Type", m_useFFT ? "FFTW" : "MVM");
    }
    else
    {
        AddSummaryItem(s, "Expansion Dim.", m_expdim);
    }
 
    if (m_session->DefinesSolverInfo("UpwindType"))
    {
        AddSummaryItem(s, "Riemann Solver",
                       m_session->GetSolverInfo("UpwindType"));
    }
 
    if (m_session->DefinesSolverInfo("AdvectionType"))
    {
        std::string AdvectionType;
        AdvectionType = m_session->GetSolverInfo("AdvectionType");
        AddSummaryItem(
            s, "Advection Type",
            GetAdvectionFactory().GetClassDescription(AdvectionType));
    }
 
    if (m_projectionType == MultiRegions::eGalerkin)
    {
        AddSummaryItem(s, "Projection Type", "Continuous Galerkin");
    }
    else if (m_projectionType == MultiRegions::eDiscontinuous)
    {
        AddSummaryItem(s, "Projection Type", "Discontinuous Galerkin");
    }
    else if (m_projectionType == MultiRegions::eMixed_CG_Discontinuous)
    {
        AddSummaryItem(s, "Projection Type",
                       "Mixed Continuous Galerkin and Discontinuous");
    }
 
    if (m_session->DefinesSolverInfo("DiffusionType"))
    {
        std::string DiffusionType;
        DiffusionType = m_session->GetSolverInfo("DiffusionType");
        AddSummaryItem(
            s, "Diffusion Type",
            GetDiffusionFactory().GetClassDescription(DiffusionType));
    }
}

References Nektar::SolverUtils::AddSummaryItem(), Nektar::MultiRegions::eDiscontinuous, Nektar::MultiRegions::eGalerkin, eHomogeneous1D, eHomogeneous2D, Nektar::MultiRegions::eMixed_CG_Discontinuous, Nektar::SolverUtils::GetAdvectionFactory(), Nektar::SolverUtils::GetDiffusionFactory(), m_expdim, m_fields, m_halfMode, m_HomogeneousType, m_LhomY, m_LhomZ, m_multipleModes, m_npointsY, m_npointsZ, m_projectionType, m_session, m_sessionName, m_singleMode, m_spacedim, and m_useFFT.

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

SetBoundaryConditions()

void Nektar::SolverUtils::EquationSystem::SetBoundaryConditions

(

NekDouble

time

)

Evaluates the boundary conditions at the given time.

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

Parameters

time	The time at which to evaluate the BCs

Definition at line 775 of file EquationSystem.cpp.

{
    std::string varName;
    int nvariables = m_fields.size();
    for (int i = 0; i < nvariables; ++i)
    {
        varName = m_session->GetVariable(i);
        m_fields[i]->EvaluateBoundaryConditions(time, varName);
    }
}

References m_fields, and m_session.

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

SetCheckpointNumber()

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

inline

Definition at line 286 of file EquationSystem.h.

    {
        m_nchk = num;
    }

References m_nchk.

SetCheckpointSteps()

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

inline

Definition at line 296 of file EquationSystem.h.

    {
        m_checksteps = num;
    }

References m_checksteps.

SetInfoSteps()

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

inline

Definition at line 306 of file EquationSystem.h.

    {
        m_infosteps = num;
    }

References m_infosteps.

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

{
    v_SetInitialConditions(initialtime, dumpInitialConditions, domain);
}

References v_SetInitialConditions().

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

SetInitialStep()

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

inline

Definition at line 336 of file EquationSystem.h.

    {
        m_initialStep = step;
    }

References m_initialStep.

SetIterationNumberPIT()

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

inline

Definition at line 311 of file EquationSystem.h.

    {
        m_iterPIT = num;
    }

References m_iterPIT.

SetLambda()

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

inline

Set parameter m_lambda.

Definition at line 669 of file EquationSystem.h.

{
    m_lambda = lambda;
}

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

{
    m_steps = steps;
}

References m_steps.

SetTime()

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

inline

Definition at line 326 of file EquationSystem.h.

    {
        m_time = time;
    }

References m_time.

SetTimeStep()

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

inline

Definition at line 331 of file EquationSystem.h.

    {
        m_timestep = timestep;
    }

References m_timestep.

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

SetWindowNumberPIT()

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

inline

Definition at line 316 of file EquationSystem.h.

    {
        m_windowPIT = num;
    }

References m_windowPIT.

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

{
    v_TransCoeffToPhys();
}

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

{
    v_TransPhysToCoeff();
}

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

{
    return m_fields;
}

References m_fields.

UpdatePhysField()

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

inline

Definition at line 806 of file EquationSystem.h.

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

References m_fields.

v_DoInitialise()

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

protectedvirtual

Virtual function for initialisation implementation.

By default, nothing needs initialising at the EquationSystem level.

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

Definition at line 1081 of file EquationSystem.cpp.

{
}

Referenced by DoInitialise().

v_DoSolve()

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

protectedvirtual

Virtual function for solve implementation.

Reimplemented in Nektar::SolverUtils::UnsteadySystem, Nektar::EigenValuesAdvection, Nektar::Laplace, Nektar::MMFAdvection, Nektar::Projection, Nektar::SteadyAdvectionDiffusion, Nektar::CFSImplicit, Nektar::IterativeElasticSystem, Nektar::LinearElasticSystem, Nektar::MMFMaxwell, Nektar::PulseWaveSystem, Nektar::MMFSWE, and Nektar::CoupledLinearNS.

Definition at line 1088 of file EquationSystem.cpp.

{
}

Referenced by DoSolve().

v_EvaluateExactSolution()

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

protectedvirtual

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

Definition at line 1064 of file EquationSystem.cpp.

{
    ASSERTL0(outfield.size() == m_fields[field]->GetNpoints(),
             "ExactSolution array size mismatch.");
    Vmath::Zero(outfield.size(), outfield, 1);
    if (m_session->DefinesFunction("ExactSolution"))
    {
        GetFunction("ExactSolution")
            ->Evaluate(m_session->GetVariable(field), outfield, time);
    }
}

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

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

v_ExtraFldOutput()

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

protectedvirtual

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

Definition at line 1597 of file EquationSystem.cpp.

{
}

Referenced by ExtraFldOutput().

v_GenerateSummary()

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

protectedvirtual

Virtual function for generating summary information.

Reimplemented in Nektar::Helmholtz, Nektar::Laplace, Nektar::MMFAdvection, Nektar::Poisson, Nektar::Projection, Nektar::SteadyAdvectionDiffusion, Nektar::SteadyAdvectionDiffusionReaction, Nektar::UnsteadyAdvection, Nektar::UnsteadyAdvectionDiffusion, Nektar::UnsteadyInviscidBurgers, Nektar::UnsteadyViscousBurgers, Nektar::CompressibleFlowSystem, Nektar::MMFDiffusion, Nektar::ImageWarpingSystem, Nektar::CoupledLinearNS, Nektar::SmoothedProfileMethod, Nektar::VelocityCorrectionScheme, Nektar::VCSImplicit, Nektar::VCSWeakPressure, Nektar::IterativeElasticSystem, Nektar::LinearElasticSystem, Nektar::MMFMaxwell, Nektar::PulseWavePropagation, Nektar::LinearSWE, Nektar::MMFSWE, Nektar::NonlinearPeregrine, Nektar::NonlinearSWE, Nektar::ShallowWaterSystem, Nektar::SolverUtils::MMFSystem, Nektar::SolverUtils::UnsteadySystem, Nektar::CFLtester, Nektar::UnsteadyDiffusion, Nektar::Bidomain, Nektar::BidomainRoth, and Nektar::Monodomain.

Definition at line 1117 of file EquationSystem.cpp.

{
    SessionSummary(l);
}

References SessionSummary().

Referenced by PrintSummary(), and Nektar::SolverUtils::UnsteadySystem::v_GenerateSummary().

v_GetPressure()

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

protectedvirtual

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

Definition at line 1587 of file EquationSystem.cpp.

{
    ASSERTL0(false, "This function is not valid for the Base class");
    MultiRegions::ExpListSharedPtr null;
    return null;
}

References ASSERTL0.

Referenced by GetPressure().

v_GetSystemSingularChecks()

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

privatevirtual

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

Definition at line 1579 of file EquationSystem.cpp.

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

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

Definition at line 143 of file EquationSystem.cpp.

{
    // Save the basename of input file name for output details
    m_sessionName = m_session->GetSessionName();
 
    // Instantiate a field reader/writer
    m_fld = LibUtilities::FieldIO::CreateDefault(m_session);
 
    // Also read and store the boundary conditions
    m_boundaryConditions =
        MemoryManager<SpatialDomains::BoundaryConditions>::AllocateSharedPtr(
            m_session, m_graph);
 
    // Set space dimension for use in class
    m_spacedim = m_graph->GetSpaceDimension();
 
    // Setting parameteres for homogenous problems
    m_HomoDirec          = 0;
    m_useFFT             = false;
    m_homogen_dealiasing = false;
    m_singleMode         = false;
    m_halfMode           = false;
    m_multipleModes      = false;
    m_HomogeneousType    = eNotHomogeneous;
 
    m_verbose = m_session->DefinesCmdLineArgument("verbose");
 
    if (m_session->DefinesSolverInfo("HOMOGENEOUS"))
    {
        std::string HomoStr = m_session->GetSolverInfo("HOMOGENEOUS");
        m_spacedim          = 3;
 
        if ((HomoStr == "HOMOGENEOUS1D") || (HomoStr == "Homogeneous1D") ||
            (HomoStr == "1D") || (HomoStr == "Homo1D"))
        {
            m_HomogeneousType = eHomogeneous1D;
            m_session->LoadParameter("LZ", m_LhomZ);
            m_HomoDirec = 1;
 
            if (m_session->DefinesSolverInfo("ModeType"))
            {
                m_session->MatchSolverInfo("ModeType", "SingleMode",
                                           m_singleMode, false);
                m_session->MatchSolverInfo("ModeType", "HalfMode", m_halfMode,
                                           false);
                m_session->MatchSolverInfo("ModeType", "MultipleModes",
                                           m_multipleModes, false);
            }
 
            // Stability Analysis flags
            if (m_session->DefinesSolverInfo("ModeType"))
            {
                if (m_singleMode)
                {
                    m_npointsZ = 2;
                }
                else if (m_halfMode)
                {
                    m_npointsZ = 1;
                }
                else if (m_multipleModes)
                {
                    m_npointsZ = m_session->GetParameter("HomModesZ");
                }
                else
                {
                    ASSERTL0(false, "SolverInfo ModeType not valid");
                }
            }
            else
            {
                m_npointsZ = m_session->GetParameter("HomModesZ");
            }
        }
 
        if ((HomoStr == "HOMOGENEOUS2D") || (HomoStr == "Homogeneous2D") ||
            (HomoStr == "2D") || (HomoStr == "Homo2D"))
        {
            m_HomogeneousType = eHomogeneous2D;
            m_session->LoadParameter("HomModesY", m_npointsY);
            m_session->LoadParameter("LY", m_LhomY);
            m_session->LoadParameter("HomModesZ", m_npointsZ);
            m_session->LoadParameter("LZ", m_LhomZ);
            m_HomoDirec = 2;
        }
 
        if ((HomoStr == "HOMOGENEOUS3D") || (HomoStr == "Homogeneous3D") ||
            (HomoStr == "3D") || (HomoStr == "Homo3D"))
        {
            m_HomogeneousType = eHomogeneous3D;
            m_session->LoadParameter("HomModesY", m_npointsY);
            m_session->LoadParameter("LY", m_LhomY);
            m_session->LoadParameter("HomModesZ", m_npointsZ);
            m_session->LoadParameter("LZ", m_LhomZ);
            m_HomoDirec = 2;
        }
 
        m_session->MatchSolverInfo("USEFFT", "FFTW", m_useFFT, false);
 
        m_session->MatchSolverInfo("DEALIASING", "True", m_homogen_dealiasing,
                                   false);
    }
    else
    {
        // set to default value so can use to identify 2d or 3D
        // (homogeneous) expansions
        m_npointsZ = 1;
    }
 
    m_session->MatchSolverInfo("SPECTRALHPDEALIASING", "True",
                               m_specHP_dealiasing, false);
    if (m_specHP_dealiasing == false)
    {
        m_session->MatchSolverInfo("SPECTRALHPDEALIASING", "On",
                                   m_specHP_dealiasing, false);
    }
 
    // Options to determine type of projection from file or directly
    // from constructor
    if (m_session->DefinesSolverInfo("PROJECTION"))
    {
        std::string ProjectStr = m_session->GetSolverInfo("PROJECTION");
 
        if ((ProjectStr == "Continuous") || (ProjectStr == "Galerkin") ||
            (ProjectStr == "CONTINUOUS") || (ProjectStr == "GALERKIN"))
        {
            m_projectionType = MultiRegions::eGalerkin;
        }
        else if ((ProjectStr == "MixedCGDG") ||
                 (ProjectStr == "Mixed_CG_Discontinuous"))
        {
            m_projectionType = MultiRegions::eMixed_CG_Discontinuous;
        }
        else if (ProjectStr == "DisContinuous")
        {
            m_projectionType = MultiRegions::eDiscontinuous;
        }
        else
        {
            ASSERTL0(false, "PROJECTION value not recognised");
        }
    }
    else
    {
        cerr << "Projection type not specified in SOLVERINFO,"
                "defaulting to continuous Galerkin"
             << endl;
        m_projectionType = MultiRegions::eGalerkin;
    }
 
    // Enforce singularity check for some problems
    m_checkIfSystemSingular = v_GetSystemSingularChecks();
 
    int i;
    int nvariables              = m_session->GetVariables().size();
    bool DeclareCoeffPhysArrays = true;
 
    m_fields   = Array<OneD, MultiRegions::ExpListSharedPtr>(nvariables);
    m_spacedim = m_graph->GetSpaceDimension() + m_HomoDirec;
    m_expdim   = m_graph->GetMeshDimension();
 
    if (DeclareFields) // declare field if required
    {
        /// Continuous field
        if (m_projectionType == MultiRegions::eGalerkin ||
            m_projectionType == MultiRegions::eMixed_CG_Discontinuous)
        {
            switch (m_expdim)
            {
                case 1:
                {
                    if (m_HomogeneousType == eHomogeneous2D ||
                        m_HomogeneousType == eHomogeneous3D)
                    {
                        const LibUtilities::PointsKey PkeyY(
                            m_npointsY, LibUtilities::eFourierEvenlySpaced);
                        const LibUtilities::BasisKey BkeyY(
                            LibUtilities::eFourier, m_npointsY, PkeyY);
                        const LibUtilities::PointsKey PkeyZ(
                            m_npointsZ, LibUtilities::eFourierEvenlySpaced);
                        const LibUtilities::BasisKey BkeyZ(
                            LibUtilities::eFourier, m_npointsZ, PkeyZ);
 
                        for (i = 0; i < m_fields.size(); i++)
                        {
                            m_fields[i] = MemoryManager<
                                MultiRegions::ContField3DHomogeneous2D>::
                                AllocateSharedPtr(m_session, BkeyY, BkeyZ,
                                                  m_LhomY, m_LhomZ, m_useFFT,
                                                  m_homogen_dealiasing, m_graph,
                                                  m_session->GetVariable(i));
                        }
                    }
                    else
                    {
                        for (i = 0; i < m_fields.size(); i++)
                        {
                            m_fields[i] =
                                MemoryManager<MultiRegions::ContField>::
                                    AllocateSharedPtr(
                                        m_session, m_graph,
                                        m_session->GetVariable(i));
                        }
                    }
                    break;
                }
                case 2:
                {
                    if (m_HomogeneousType == eHomogeneous1D)
                    {
                        // Fourier single mode stability analysis
                        if (m_singleMode)
                        {
                            const LibUtilities::PointsKey PkeyZ(
                                m_npointsZ,
                                LibUtilities::eFourierSingleModeSpaced);
 
                            const LibUtilities::BasisKey BkeyZ(
                                LibUtilities::eFourierSingleMode, m_npointsZ,
                                PkeyZ);
 
                            for (i = 0; i < m_fields.size(); i++)
                            {
                                m_fields[i] = MemoryManager<
                                    MultiRegions::ContField3DHomogeneous1D>::
                                    AllocateSharedPtr(
                                        m_session, BkeyZ, m_LhomZ, m_useFFT,
                                        m_homogen_dealiasing, m_graph,
                                        m_session->GetVariable(i),
                                        m_checkIfSystemSingular[i]);
                            }
                        }
                        // Half mode stability analysis
                        else if (m_halfMode)
                        {
                            const LibUtilities::PointsKey PkeyZ(
                                m_npointsZ,
                                LibUtilities::eFourierSingleModeSpaced);
 
                            const LibUtilities::BasisKey BkeyZR(
                                LibUtilities::eFourierHalfModeRe, m_npointsZ,
                                PkeyZ);
 
                            const LibUtilities::BasisKey BkeyZI(
                                LibUtilities::eFourierHalfModeIm, m_npointsZ,
                                PkeyZ);
 
                            for (i = 0; i < m_fields.size(); i++)
                            {
                                if (m_session->GetVariable(i).compare("w") == 0)
                                {
                                    m_fields[i] = MemoryManager<
                                        MultiRegions::
                                            ContField3DHomogeneous1D>::
                                        AllocateSharedPtr(
                                            m_session, BkeyZI, m_LhomZ,
                                            m_useFFT, m_homogen_dealiasing,
                                            m_graph, m_session->GetVariable(i),
                                            m_checkIfSystemSingular[i]);
                                }
                                else
                                {
                                    m_fields[i] = MemoryManager<
                                        MultiRegions::
                                            ContField3DHomogeneous1D>::
                                        AllocateSharedPtr(
                                            m_session, BkeyZR, m_LhomZ,
                                            m_useFFT, m_homogen_dealiasing,
                                            m_graph, m_session->GetVariable(i),
                                            m_checkIfSystemSingular[i]);
                                }
                            }
                        }
                        // Normal homogeneous 1D
                        else
                        {
                            const LibUtilities::PointsKey PkeyZ(
                                m_npointsZ, LibUtilities::eFourierEvenlySpaced);
                            const LibUtilities::BasisKey BkeyZ(
                                LibUtilities::eFourier, m_npointsZ, PkeyZ);
 
                            for (i = 0; i < m_fields.size(); i++)
                            {
                                m_fields[i] = MemoryManager<
                                    MultiRegions::ContField3DHomogeneous1D>::
                                    AllocateSharedPtr(
                                        m_session, BkeyZ, m_LhomZ, m_useFFT,
                                        m_homogen_dealiasing, m_graph,
                                        m_session->GetVariable(i),
                                        m_checkIfSystemSingular[i]);
                            }
                        }
                    }
                    else
                    {
                        i = 0;
                        MultiRegions::ContFieldSharedPtr firstfield;
                        firstfield = MemoryManager<MultiRegions::ContField>::
                            AllocateSharedPtr(m_session, m_graph,
                                              m_session->GetVariable(i),
                                              DeclareCoeffPhysArrays,
                                              m_checkIfSystemSingular[0]);
                        m_fields[0] = firstfield;
                        for (i = 1; i < m_fields.size(); i++)
                        {
                            if (m_graph->SameExpansionInfo(
                                    m_session->GetVariable(0),
                                    m_session->GetVariable(i)))
                            {
                                m_fields[i] =
                                    MemoryManager<MultiRegions::ContField>::
                                        AllocateSharedPtr(
                                            *firstfield, m_graph,
                                            m_session->GetVariable(i),
                                            DeclareCoeffPhysArrays,
                                            m_checkIfSystemSingular[i]);
                            }
                            else
                            {
                                m_fields[i] =
                                    MemoryManager<MultiRegions::ContField>::
                                        AllocateSharedPtr(
                                            m_session, m_graph,
                                            m_session->GetVariable(i),
                                            DeclareCoeffPhysArrays,
                                            m_checkIfSystemSingular[i]);
                            }
                        }
 
                        if (m_projectionType ==
                            MultiRegions::eMixed_CG_Discontinuous)
                        {
                            /// Setting up the normals
                            m_traceNormals =
                                Array<OneD, Array<OneD, NekDouble>>(m_spacedim);
 
                            for (i = 0; i < m_spacedim; ++i)
                            {
                                m_traceNormals[i] =
                                    Array<OneD, NekDouble>(GetTraceNpoints());
                            }
 
                            m_fields[0]->GetTrace()->GetNormals(m_traceNormals);
                        }
                    }
 
                    break;
                }
                case 3:
                {
                    i = 0;
                    MultiRegions::ContFieldSharedPtr firstfield =
                        MemoryManager<MultiRegions::ContField>::
                            AllocateSharedPtr(m_session, m_graph,
                                              m_session->GetVariable(i),
                                              DeclareCoeffPhysArrays,
                                              m_checkIfSystemSingular[i]);
 
                    m_fields[0] = firstfield;
                    for (i = 1; i < m_fields.size(); i++)
                    {
                        if (m_graph->SameExpansionInfo(
                                m_session->GetVariable(0),
                                m_session->GetVariable(i)))
                        {
                            m_fields[i] =
                                MemoryManager<MultiRegions::ContField>::
                                    AllocateSharedPtr(
                                        *firstfield, m_graph,
                                        m_session->GetVariable(i),
                                        DeclareCoeffPhysArrays,
                                        m_checkIfSystemSingular[i]);
                        }
                        else
                        {
                            m_fields[i] =
                                MemoryManager<MultiRegions::ContField>::
                                    AllocateSharedPtr(
                                        m_session, m_graph,
                                        m_session->GetVariable(i),
                                        DeclareCoeffPhysArrays,
                                        m_checkIfSystemSingular[i]);
                        }
                    }
 
                    if (m_projectionType ==
                        MultiRegions::eMixed_CG_Discontinuous)
                    {
                        /// Setting up the normals
                        m_traceNormals =
                            Array<OneD, Array<OneD, NekDouble>>(m_spacedim);
                        for (i = 0; i < m_spacedim; ++i)
                        {
                            m_traceNormals[i] =
                                Array<OneD, NekDouble>(GetTraceNpoints());
                        }
 
                        m_fields[0]->GetTrace()->GetNormals(m_traceNormals);
                        // Call the trace on all fields to ensure DG setup.
                        for (i = 1; i < m_fields.size(); ++i)
                        {
                            m_fields[i]->GetTrace();
                        }
                    }
                    break;
                }
                default:
                    ASSERTL0(false, "Expansion dimension not recognised");
                    break;
            }
        }
        // Discontinuous field
        else
        {
            switch (m_expdim)
            {
                case 1:
                {
                    if (m_HomogeneousType == eHomogeneous2D ||
                        m_HomogeneousType == eHomogeneous3D)
                    {
                        const LibUtilities::PointsKey PkeyY(
                            m_npointsY, LibUtilities::eFourierEvenlySpaced);
                        const LibUtilities::BasisKey BkeyY(
                            LibUtilities::eFourier, m_npointsY, PkeyY);
                        const LibUtilities::PointsKey PkeyZ(
                            m_npointsZ, LibUtilities::eFourierEvenlySpaced);
                        const LibUtilities::BasisKey BkeyZ(
                            LibUtilities::eFourier, m_npointsZ, PkeyZ);
 
                        for (i = 0; i < m_fields.size(); i++)
                        {
                            m_fields[i] = MemoryManager<
                                MultiRegions::DisContField3DHomogeneous2D>::
                                AllocateSharedPtr(m_session, BkeyY, BkeyZ,
                                                  m_LhomY, m_LhomZ, m_useFFT,
                                                  m_homogen_dealiasing, m_graph,
                                                  m_session->GetVariable(i));
                        }
                    }
                    else
                    {
                        for (i = 0; i < m_fields.size(); i++)
                        {
                            m_fields[i] =
                                MemoryManager<MultiRegions::DisContField>::
                                    AllocateSharedPtr(
                                        m_session, m_graph,
                                        m_session->GetVariable(i));
                        }
                    }
 
                    break;
                }
                case 2:
                {
                    if (m_HomogeneousType == eHomogeneous1D)
                    {
                        const LibUtilities::PointsKey PkeyZ(
                            m_npointsZ, LibUtilities::eFourierEvenlySpaced);
                        const LibUtilities::BasisKey BkeyZ(
                            LibUtilities::eFourier, m_npointsZ, PkeyZ);
 
                        for (i = 0; i < m_fields.size(); i++)
                        {
                            m_fields[i] = MemoryManager<
                                MultiRegions::DisContField3DHomogeneous1D>::
                                AllocateSharedPtr(m_session, BkeyZ, m_LhomZ,
                                                  m_useFFT,
                                                  m_homogen_dealiasing, m_graph,
                                                  m_session->GetVariable(i));
                        }
                    }
                    else
                    {
                        i = 0;
                        MultiRegions::DisContFieldSharedPtr firstfield;
                        firstfield = MemoryManager<MultiRegions::DisContField>::
                            AllocateSharedPtr(m_session, m_graph,
                                              m_session->GetVariable(i));
                        m_fields[0] = firstfield;
                        for (i = 1; i < m_fields.size(); i++)
                        {
                            if (m_graph->SameExpansionInfo(
                                    m_session->GetVariable(0),
                                    m_session->GetVariable(i)))
                            {
                                m_fields[i] =
                                    MemoryManager<MultiRegions::DisContField>::
                                        AllocateSharedPtr(
                                            *firstfield, m_graph,
                                            m_session->GetVariable(i));
                            }
                            else
                            {
                                m_fields[i] =
                                    MemoryManager<MultiRegions::DisContField>::
                                        AllocateSharedPtr(
                                            m_session, m_graph,
                                            m_session->GetVariable(i));
                            }
                        }
                    }
 
                    break;
                }
                case 3:
                {
                    if (m_HomogeneousType == eHomogeneous3D)
                    {
                        ASSERTL0(
                            false,
                            "3D fully periodic problems not implemented yet");
                    }
                    else
                    {
                        i = 0;
                        MultiRegions::DisContFieldSharedPtr firstfield =
                            MemoryManager<MultiRegions::DisContField>::
                                AllocateSharedPtr(m_session, m_graph,
                                                  m_session->GetVariable(i));
                        m_fields[0] = firstfield;
                        for (i = 1; i < m_fields.size(); i++)
                        {
                            if (m_graph->SameExpansionInfo(
                                    m_session->GetVariable(0),
                                    m_session->GetVariable(i)))
                            {
                                m_fields[i] =
                                    MemoryManager<MultiRegions::DisContField>::
                                        AllocateSharedPtr(
                                            *firstfield, m_graph,
                                            m_session->GetVariable(i));
                            }
                            else
                            {
                                m_fields[i] =
                                    MemoryManager<MultiRegions::DisContField>::
                                        AllocateSharedPtr(
                                            m_session, m_graph,
                                            m_session->GetVariable(i));
                            }
                        }
                    }
                    break;
                }
                default:
                    ASSERTL0(false, "Expansion dimension not recognised");
                    break;
            }
 
            // Setting up the normals
            m_traceNormals = Array<OneD, Array<OneD, NekDouble>>(m_spacedim);
 
            for (i = 0; i < m_spacedim; ++i)
            {
                m_traceNormals[i] =
                    Array<OneD, NekDouble>(GetTraceNpoints(), 0.0);
            }
 
            m_fields[0]->GetTrace()->GetNormals(m_traceNormals);
        }
        // Zero all physical fields initially
        ZeroPhysFields();
    }
 
    // Set Default Parameter
    m_session->LoadParameter("Time", m_time, 0.0);
    m_session->LoadParameter("TimeStep", m_timestep, 0.0);
    m_session->LoadParameter("NumSteps", m_steps, 0);
    m_session->LoadParameter("IO_CheckSteps", m_checksteps, 0);
    m_session->LoadParameter("IO_CheckTime", m_checktime, 0.0);
    m_session->LoadParameter("FinTime", m_fintime, 0);
    m_session->LoadParameter("NumQuadPointsError", m_NumQuadPointsError, 0);
 
    // Check uniqueness of checkpoint output
    ASSERTL0((m_checktime == 0.0 && m_checksteps == 0) ||
                 (m_checktime > 0.0 && m_checksteps == 0) ||
                 (m_checktime == 0.0 && m_checksteps > 0),
             "Only one of IO_CheckTime and IO_CheckSteps "
             "should be set!");
    m_session->LoadParameter("TimeIncrementFactor", m_TimeIncrementFactor, 1.0);
 
    // Check for parallel-in-time
    if (m_comm->IsParallelInTime())
    {
        ASSERTL0(m_fintime == 0.0,
                 "Only specify NumSteps and TimeSteps for Parallel-in-Time. "
                 "FinTime should not be used! ");
    }
 
    m_nchk    = 0;
    m_iterPIT = 0;
}

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

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

v_L2Error()

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

protectedvirtual

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

Compute the error in the L2-norm.

Parameters

field	The field to compare.
exactsoln	The exact solution to compare with.
Normalised	Normalise L2-error.

Returns

Error in the L2-norm.

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

Definition at line 793 of file EquationSystem.cpp.

{
    NekDouble L2error = -1.0;
 
    if (m_NumQuadPointsError == 0)
    {
        if (m_fields[field]->GetPhysState() == false)
        {
            m_fields[field]->BwdTrans(m_fields[field]->GetCoeffs(),
                                      m_fields[field]->UpdatePhys());
        }
 
        if (exactsoln.size())
        {
            L2error =
                m_fields[field]->L2(m_fields[field]->GetPhys(), exactsoln);
        }
        else if (m_session->DefinesFunction("ExactSolution"))
        {
            Array<OneD, NekDouble> exactsoln(m_fields[field]->GetNpoints());
 
            GetFunction("ExactSolution")
                ->Evaluate(m_session->GetVariable(field), exactsoln, m_time);
 
            L2error =
                m_fields[field]->L2(m_fields[field]->GetPhys(), exactsoln);
        }
        else
        {
            L2error = m_fields[field]->L2(m_fields[field]->GetPhys());
        }
 
        if (Normalised == true)
        {
            Array<OneD, NekDouble> one(m_fields[field]->GetNpoints(), 1.0);
 
            NekDouble Vol = m_fields[field]->Integral(one);
            L2error       = sqrt(L2error * L2error / Vol);
        }
    }
    else
    {
        Array<OneD, NekDouble> L2INF(2);
        L2INF   = ErrorExtraPoints(field);
        L2error = L2INF[0];
    }
    return L2error;
}

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

field	The field to compare.
exactsoln	The exact solution to compare with.

Returns

Error in the L_inft-norm.

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

Definition at line 850 of file EquationSystem.cpp.

{
    NekDouble Linferror = -1.0;
 
    if (m_NumQuadPointsError == 0)
    {
        if (m_fields[field]->GetPhysState() == false)
        {
            m_fields[field]->BwdTrans(m_fields[field]->GetCoeffs(),
                                      m_fields[field]->UpdatePhys());
        }
 
        if (exactsoln.size())
        {
            Linferror =
                m_fields[field]->Linf(m_fields[field]->GetPhys(), exactsoln);
        }
        else if (m_session->DefinesFunction("ExactSolution"))
        {
            Array<OneD, NekDouble> exactsoln(m_fields[field]->GetNpoints());
 
            GetFunction("ExactSolution")
                ->Evaluate(m_session->GetVariable(field), exactsoln, m_time);
 
            Linferror =
                m_fields[field]->Linf(m_fields[field]->GetPhys(), exactsoln);
        }
        else
        {
            Linferror = m_fields[field]->Linf(m_fields[field]->GetPhys());
        }
    }
    else
    {
        Array<OneD, NekDouble> L2INF(2);
        L2INF     = ErrorExtraPoints(field);
        Linferror = L2INF[1];
    }
 
    return Linferror;
}

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  )

protectedvirtual

Virtual function to identify if operator is negated in DoSolve.

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

Reimplemented in Nektar::CoupledLinearNS.

Definition at line 1097 of file EquationSystem.cpp.

{
    return false;
}

Referenced by NegatedOp().

v_Output()

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

protectedvirtual

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

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

Definition at line 1126 of file EquationSystem.cpp.

{
    if (!m_comm->IsParallelInTime())
    {
        // Serial-in-time
        WriteFld(m_sessionName + ".fld");
    }
    else
    {
        // Parallel-in-time
        std::string newdir = m_sessionName + ".pit";
        if (!fs::is_directory(newdir))
        {
            fs::create_directory(newdir);
        }
        WriteFld(newdir + "/" + m_sessionName + "_" +
                 std::to_string(m_windowPIT * m_comm->GetTimeComm()->GetSize() +
                                m_comm->GetTimeComm()->GetRank() + 1) +
                 ".fld");
    }
}

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

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

v_SetInitialConditions()

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

protectedvirtual

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

Parameters

initialtime	Time at which to evaluate the function.
dumpInitialConditions	Write the initial condition to file?

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

Definition at line 986 of file EquationSystem.cpp.

{
    if (m_session->GetComm()->GetRank() == 0)
    {
        cout << "Initial Conditions:" << endl;
    }
 
    if (m_session->DefinesFunction("InitialConditions"))
    {
        GetFunction("InitialConditions")
            ->Evaluate(m_session->GetVariables(), m_fields, m_time, domain);
        // Enforce C0 Continutiy of initial condiiton
        if ((m_projectionType == MultiRegions::eGalerkin) ||
            (m_projectionType == MultiRegions::eMixed_CG_Discontinuous))
        {
            for (int i = 0; i < m_fields.size(); ++i)
            {
                m_fields[i]->LocalToGlobal();
                m_fields[i]->GlobalToLocal();
                m_fields[i]->BwdTrans(m_fields[i]->GetCoeffs(),
                                      m_fields[i]->UpdatePhys());
            }
        }
 
        if (m_session->GetComm()->GetRank() == 0)
        {
            for (int i = 0; i < m_fields.size(); ++i)
            {
                std::string varName = m_session->GetVariable(i);
                cout << "  - Field " << varName << ": "
                     << GetFunction("InitialConditions")
                            ->Describe(varName, domain)
                     << endl;
            }
        }
    }
    else
    {
        int nq = m_fields[0]->GetNpoints();
        for (int i = 0; i < m_fields.size(); i++)
        {
            Vmath::Zero(nq, m_fields[i]->UpdatePhys(), 1);
            m_fields[i]->SetPhysState(true);
            Vmath::Zero(m_fields[i]->GetNcoeffs(), m_fields[i]->UpdateCoeffs(),
                        1);
            if (m_session->GetComm()->GetRank() == 0)
            {
                cout << "  - Field " << m_session->GetVariable(i)
                     << ": 0 (default)" << endl;
            }
        }
    }
 
    if (dumpInitialConditions && m_checksteps && m_nchk == 0 &&
        !m_comm->IsParallelInTime())
    {
        Checkpoint_Output(m_nchk);
    }
    else if (dumpInitialConditions && m_nchk == 0 && m_comm->IsParallelInTime())
    {
        std::string newdir = m_sessionName + ".pit";
        if (!fs::is_directory(newdir))
        {
            fs::create_directory(newdir);
        }
        if (m_comm->GetTimeComm()->GetRank() == 0)
        {
            WriteFld(newdir + "/" + m_sessionName + "_0.fld");
        }
    }
    ++m_nchk;
}

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

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

v_TransCoeffToPhys()

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

protectedvirtual

Virtual function for transformation to physical space.

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

Definition at line 1105 of file EquationSystem.cpp.

{
}

Referenced by TransCoeffToPhys().

v_TransPhysToCoeff()

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

protectedvirtual

Virtual function for transformation to coefficient space.

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

Definition at line 1112 of file EquationSystem.cpp.

{
}

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

outname

Filename to write to.

Definition at line 1238 of file EquationSystem.cpp.

{
    std::vector<Array<OneD, NekDouble>> fieldcoeffs(m_fields.size());
    std::vector<std::string> variables(m_fields.size());
 
    for (int i = 0; i < m_fields.size(); ++i)
    {
        if (m_fields[i]->GetNcoeffs() == m_fields[0]->GetNcoeffs())
        {
            fieldcoeffs[i] = m_fields[i]->UpdateCoeffs();
        }
        else
        {
            fieldcoeffs[i] = Array<OneD, NekDouble>(m_fields[0]->GetNcoeffs());
            m_fields[0]->ExtractCoeffsToCoeffs(
                m_fields[i], m_fields[i]->GetCoeffs(), fieldcoeffs[i]);
        }
        variables[i] = m_boundaryConditions->GetVariable(i);
    }
 
    ExtraFldOutput(fieldcoeffs, variables);
 
    WriteFld(outname, m_fields[0], fieldcoeffs, variables);
}

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

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

WriteFld() [2/2]

void Nektar::SolverUtils::EquationSystem::WriteFld	(	const std::string &	outname,
		MultiRegions::ExpListSharedPtr &	field,
		std::vector< Array< OneD, NekDouble > > &	fieldcoeffs,
		std::vector< std::string > &	variables
	)

Write input fields to the given filename.

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

Parameters

outname	Filename to write to.
field	ExpList on which data is based.
fieldcoeffs	An array of array of expansion coefficients.
variables	An array of variable names.

Definition at line 1270 of file EquationSystem.cpp.

{
    std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef =
        field->GetFieldDefinitions();
    std::vector<std::vector<NekDouble>> FieldData(FieldDef.size());
 
    // Copy Data into FieldData and set variable
    for (int j = 0; j < fieldcoeffs.size(); ++j)
    {
        for (int i = 0; i < FieldDef.size(); ++i)
        {
            // Could do a search here to find correct variable
            FieldDef[i]->m_fields.push_back(variables[j]);
            field->AppendFieldData(FieldDef[i], FieldData[i], fieldcoeffs[j]);
        }
    }
 
    // Update time in field info if required
    if (m_fieldMetaDataMap.find("Time") != m_fieldMetaDataMap.end())
    {
        m_fieldMetaDataMap["Time"] = boost::lexical_cast<std::string>(m_time);
    }
 
    // Update step in field info if required
    if (m_fieldMetaDataMap.find("ChkFileNum") != m_fieldMetaDataMap.end())
    {
        m_fieldMetaDataMap["ChkFileNum"] = std::to_string(m_nchk);
    }
 
    // If necessary, add mapping information to metadata
    //      and output mapping coordinates
    Array<OneD, MultiRegions::ExpListSharedPtr> fields(1);
    fields[0] = field;
    GlobalMapping::MappingSharedPtr mapping =
        GlobalMapping::Mapping::Load(m_session, fields);
    LibUtilities::FieldMetaDataMap fieldMetaDataMap(m_fieldMetaDataMap);
    mapping->Output(fieldMetaDataMap, outname);
 
    // If necessary, add informaton for moving frame reference to metadata
    // X, Y, Z translational displacements
    // Theta_x, Theta_y, Theta_z angular displacements
    // X0, Y0, Z0 pivot point
    std::vector<std::string> strFrameData = {
        "X", "Y", "Z", "Theta_x", "Theta_y", "Theta_z", "X0", "Y0", "Z0"};
    for (size_t i = 0; i < strFrameData.size() && i < m_movingFrameData.size();
         ++i)
    {
        fieldMetaDataMap[strFrameData[i]] =
            boost::lexical_cast<std::string>(m_movingFrameData[i]);
    }
 
    m_fld->Write(outname, FieldDef, FieldData, fieldMetaDataMap,
                 m_session->GetBackups());
}

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

ZeroPhysFields()

void Nektar::SolverUtils::EquationSystem::ZeroPhysFields

(

void

)

Zero the physical fields.

Definition at line 1151 of file EquationSystem.cpp.

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

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

Referenced by v_InitObject().

Member Data Documentation

equationSystemTypeLookupIds

std::string Nektar::SolverUtils::EquationSystem::equationSystemTypeLookupIds

staticprotected

Initial value:

= {
    LibUtilities::SessionReader::RegisterEnumValue("DEALIASING", "True", 0),
    LibUtilities::SessionReader::RegisterEnumValue("DEALIASING", "False", 1)}

Definition at line 523 of file EquationSystem.h.

m_boundaryConditions

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

protected

Pointer to boundary conditions object.

Definition at line 361 of file EquationSystem.h.

Referenced by Nektar::MMFMaxwell::Checkpoint_EDFluxOutput(), Nektar::MMFMaxwell::Checkpoint_EnergyOutput(), Nektar::MMFMaxwell::Checkpoint_TotalFieldOutput(), Nektar::MMFMaxwell::Checkpoint_TotPlotOutput(), Nektar::CoupledLinearNS::DefineForcingTerm(), Nektar::CoupledLinearNS::v_DoInitialise(), v_InitObject(), Nektar::CoupledLinearNS::v_InitObject(), Nektar::IncNavierStokes::v_InitObject(), Nektar::CoupledLinearNS::v_Output(), and WriteFld().

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

Referenced by v_InitObject().

m_checksteps

int Nektar::SolverUtils::EquationSystem::m_checksteps

protected

Number of steps between checkpoints.

Definition at line 388 of file EquationSystem.h.

Referenced by GetCheckpointSteps(), SetCheckpointSteps(), Nektar::SolverUtils::FileSolution::v_DoInitialise(), Nektar::SolverUtils::UnsteadySystem::v_DoSolve(), Nektar::MMFAdvection::v_DoSolve(), Nektar::MMFMaxwell::v_DoSolve(), Nektar::PulseWaveSystem::v_DoSolve(), Nektar::MMFSWE::v_DoSolve(), Nektar::SolverUtils::UnsteadySystem::v_GenerateSummary(), v_InitObject(), v_SetInitialConditions(), Nektar::CompressibleFlowSystem::v_SetInitialConditions(), and Nektar::NonlinearPeregrine::v_SetInitialConditions().

m_checktime

NekDouble Nektar::SolverUtils::EquationSystem::m_checktime

protected

Time between checkpoints.

Definition at line 378 of file EquationSystem.h.

Referenced by Nektar::SolverUtils::UnsteadySystem::v_DoSolve(), Nektar::MMFAdvection::v_DoSolve(), Nektar::MMFMaxwell::v_DoSolve(), Nektar::MMFSWE::v_DoSolve(), v_InitObject(), and Nektar::CFSImplicit::v_UpdateTimeStepCheck().

m_comm

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

protected

Communicator.

Definition at line 349 of file EquationSystem.h.

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

m_expdim

int Nektar::SolverUtils::EquationSystem::m_expdim

protected

Expansion dimension.

Definition at line 398 of file EquationSystem.h.

Referenced by Nektar::UnsteadyAdvection::GetFluxVectorDeAlias(), SessionSummary(), Nektar::MMFSWE::SetBoundaryConditions(), Nektar::VelocityCorrectionScheme::SVVVarDiffCoeff(), v_InitObject(), Nektar::LinearSWE::WallBoundary2D(), Nektar::NonlinearPeregrine::WallBoundary2D(), Nektar::NonlinearSWE::WallBoundary2D(), Nektar::MMFSWE::WallBoundary2D(), and Nektar::NonlinearPeregrine::WallBoundaryForcing().

m_fieldMetaDataMap

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

protected

Map to identify relevant solver info to dump in output fields.

Definition at line 425 of file EquationSystem.h.

Referenced by Nektar::SolverUtils::UnsteadySystem::CheckForRestartTime(), EquationSystem(), Nektar::VCSMapping::v_DoInitialise(), Nektar::VelocityCorrectionScheme::v_DoInitialise(), Nektar::SolverUtils::UnsteadySystem::v_InitObject(), Nektar::IncNavierStokes::v_InitObject(), WriteFld(), and Nektar::PulseWaveSystem::WriteVessels().

m_fields

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

protected

Array holding all dependent variables.

Definition at line 359 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::VCSImplicit::AddImplicitSkewSymAdvection(), 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::SolverUtils::UnsteadySystem::AppendOutput1D(), Nektar::VCSMapping::ApplyIncNSMappingForcing(), Nektar::SolverUtils::MMFSystem::AverageMaxwellFlux1D(), Nektar::SolverUtils::MMFSystem::AvgAbsInt(), Nektar::SolverUtils::MMFSystem::AvgInt(), Nektar::LinearElasticSystem::BuildMatrixSystem(), Nektar::CFSImplicit::CalcRefValues(), Nektar::CFSImplicit::CalcTraceNumericalFlux(), Nektar::CFSImplicit::CalcVolJacStdMat(), Nektar::SolverUtils::MMFSystem::CartesianToMovingframes(), Nektar::SolverUtils::UnsteadySystem::CheckForRestartTime(), Nektar::SolverUtils::MMFSystem::CheckMovingFrames(), Nektar::MMFMaxwell::Checkpoint_EDFluxOutput(), Nektar::MMFMaxwell::Checkpoint_EnergyOutput(), Nektar::MMFSWE::Checkpoint_Output_Cartesian(), Nektar::MMFMaxwell::Checkpoint_PlotOutput(), Nektar::MMFMaxwell::Checkpoint_TotalFieldOutput(), Nektar::MMFMaxwell::Checkpoint_TotPlotOutput(), Nektar::SolverUtils::UnsteadySystem::CheckSteadyState(), Nektar::VCSImplicit::CheckUnsetGlobalLinSys(), Nektar::MMFSWE::Compute_demdt_cdot_ek(), Nektar::SolverUtils::MMFSystem::ComputeCurl(), Nektar::SolverUtils::MMFSystem::Computedemdxicdote(), Nektar::SolverUtils::MMFSystem::ComputeDivCurlMF(), Nektar::MMFSWE::ComputeEnergy(), Nektar::MMFMaxwell::ComputeEnergyDensity(), Nektar::MMFSWE::ComputeEnstrophy(), Nektar::VelocityCorrectionScheme::ComputeGJPNormalVelocity(), Nektar::MMFSWE::ComputeMass(), Nektar::MMFMaxwell::ComputeMaterialMicroWaveCloak(), Nektar::MMFMaxwell::ComputeMaterialOpticalCloak(), Nektar::MMFMaxwell::ComputeMaterialVector(), Nektar::SolverUtils::MMFSystem::ComputeMFtrace(), Nektar::MMFAdvection::ComputeNablaCdotVelocity(), Nektar::MMFSWE::ComputeNablaCdotVelocity(), Nektar::SolverUtils::MMFSystem::ComputencdotMF(), Nektar::MMFMaxwell::ComputeRadCloak(), Nektar::MMFMaxwell::ComputeSurfaceCurrent(), Nektar::MMFAdvection::ComputeveldotMF(), Nektar::MMFSWE::ComputeVorticity(), Nektar::SolverUtils::MMFSystem::ComputeZimYim(), Nektar::MMFSWE::ConservativeToPrimitive(), Nektar::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::UnsteadyViscousBurgers::DoImplicitSolve(), Nektar::Bidomain::DoImplicitSolve(), Nektar::BidomainRoth::DoImplicitSolve(), Nektar::Monodomain::DoImplicitSolve(), Nektar::MMFDiffusion::DoImplicitSolve(), Nektar::CFSImplicit::DoImplicitSolve(), Nektar::CFSImplicit::DoOdeImplicitRhs(), Nektar::AcousticSystem::DoOdeProjection(), Nektar::MMFAdvection::DoOdeProjection(), Nektar::UnsteadyAdvection::DoOdeProjection(), Nektar::UnsteadyDiffusion::DoOdeProjection(), Nektar::UnsteadyInviscidBurgers::DoOdeProjection(), Nektar::CompressibleFlowSystem::DoOdeProjection(), Nektar::Dummy::DoOdeProjection(), Nektar::LinearSWE::DoOdeProjection(), Nektar::NonlinearPeregrine::DoOdeProjection(), Nektar::NonlinearSWE::DoOdeProjection(), Nektar::AcousticSystem::DoOdeRhs(), Nektar::MMFAdvection::DoOdeRhs(), Nektar::UnsteadyAdvection::DoOdeRhs(), Nektar::UnsteadyAdvectionDiffusion::DoOdeRhs(), Nektar::UnsteadyDiffusion::DoOdeRhs(), Nektar::UnsteadyInviscidBurgers::DoOdeRhs(), Nektar::UnsteadyReactionDiffusion::DoOdeRhs(), Nektar::UnsteadyViscousBurgers::DoOdeRhs(), Nektar::Bidomain::DoOdeRhs(), Nektar::BidomainRoth::DoOdeRhs(), Nektar::CompressibleFlowSystem::DoOdeRhs(), Nektar::MMFDiffusion::DoOdeRhs(), Nektar::ImageWarpingSystem::DoOdeRhs(), Nektar::MMFMaxwell::DoOdeRhs(), Nektar::PulseWavePropagation::DoOdeRhs(), Nektar::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::CompressibleFlowSystem::EvaluateIsentropicVortex(), Nektar::CoupledLinearNS::EvaluateNewtonRHS(), Nektar::MMFSWE::EvaluateStandardCoriolis(), Nektar::MMFSWE::EvaluateWaterDepth(), FwdTransFields(), Nektar::MMFMaxwell::GaussianPulse(), Nektar::MMFMaxwell::GenerateSigmaPML(), Nektar::SolverUtils::AdvectionSystem::GetCFLEstimate(), GetCoeff_Offset(), Nektar::SolverUtils::AdvectionSystem::GetElmtCFLVals(), Nektar::CompressibleFlowSystem::GetElmtTimeStep(), Nektar::CompressibleFlowSystem::GetExactRinglebFlow(), GetExpSize(), Nektar::UnsteadyAdvection::GetFluxVector(), Nektar::PulseWavePropagation::GetFluxVector(), Nektar::LinearSWE::GetFluxVector(), Nektar::NonlinearPeregrine::GetFluxVector(), Nektar::NonlinearSWE::GetFluxVector(), Nektar::UnsteadyAdvection::GetFluxVectorDeAlias(), Nektar::CompressibleFlowSystem::GetFluxVectorDeAlias(), GetFunction(), Nektar::SolverUtils::MMFSystem::GetIncidentField(), Nektar::UnsteadyAdvectionDiffusion::GetMaxStdVelocity(), Nektar::SolverUtils::MMFSystem::GetMaxwellFlux1D(), Nektar::SolverUtils::MMFSystem::GetMaxwellFlux2D(), GetNcoeffs(), Nektar::UnsteadyAdvection::GetNormalVel(), Nektar::EigenValuesAdvection::GetNormalVelocity(), Nektar::MMFAdvection::GetNormalVelocity(), Nektar::UnsteadyInviscidBurgers::GetNormalVelocity(), Nektar::ImageWarpingSystem::GetNormalVelocity(), GetNpoints(), GetNumExpModesPerExp(), GetPhys_Offset(), Nektar::CompressibleFlowSystem::GetStabilityLimitVector(), Nektar::UnsteadyAdvectionDiffusion::GetSubstepTimeStep(), Nektar::MMFSWE::GetSWEFluxVector(), GetTotPoints(), Nektar::CFSImplicit::GetTraceJac(), GetTraceNpoints(), Nektar::NavierStokesCFE::GetViscosityAndThermalCondFromTemp(), ImportFld(), ImportFldToMultiDomains(), Nektar::CompressibleFlowSystem::InitAdvection(), Nektar::CFSImplicit::InitialiseNonlinSysSolver(), Nektar::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::NonlinSysEvaluatorCoeff1D(), Nektar::CFSImplicit::NumCalcRiemFluxJac(), Nektar::NonlinearPeregrine::NumericalFluxConsVariables(), Nektar::NonlinearPeregrine::NumericalFluxForcing(), Nektar::SolverUtils::MMFSystem::NumericalMaxwellFluxTE(), Nektar::SolverUtils::MMFSystem::NumericalMaxwellFluxTM(), Nektar::MMFSWE::NumericalSWEFlux(), Nektar::MMFDiffusion::PlanePhiWave(), Nektar::CFSImplicit::PreconCoeff(), Nektar::MMFSWE::PrimitiveToConservative(), Nektar::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::NavierStokesCFE::SpecialBndTreat(), Nektar::MMFSWE::SteadyZonalFlow(), Nektar::UnsteadyAdvectionDiffusion::SubStepAdvance(), Nektar::UnsteadyAdvectionDiffusion::SubStepAdvection(), Nektar::SolverUtils::UnsteadySystem::SVVVarDiffCoeff(), Nektar::VelocityCorrectionScheme::SVVVarDiffCoeff(), Nektar::MMFAdvection::Test2Dproblem(), Nektar::MMFAdvection::Test3Dproblem(), Nektar::MMFDiffusion::TestCubeProblem(), Nektar::MMFMaxwell::TestMaxwell1D(), Nektar::MMFMaxwell::TestMaxwell2DPEC(), Nektar::MMFMaxwell::TestMaxwell2DPMC(), Nektar::MMFMaxwell::TestMaxwellSphere(), Nektar::MMFDiffusion::TestPlaneProblem(), Nektar::MMFSWE::TestSWE2Dproblem(), Nektar::MMFSWE::TestVorticityComputation(), Nektar::MMFSWE::UnstableJetFlow(), Nektar::MMFSWE::UnsteadyZonalFlow(), Nektar::AcousticSystem::UpdateBasefieldFwdBwd(), Nektar::SolverUtils::FileSolution::UpdateField(), UpdateFields(), Nektar::SmoothedProfileMethod::UpdateForcing(), UpdatePhysField(), Nektar::SolverUtils::MMFSystem::UpwindMaxwellFlux1D(), Nektar::LEE::v_AddLinTerm(), Nektar::NavierStokesImplicitCFE::v_CalcPhysDeriv(), Nektar::LinearSWE::v_ConservativeToPrimitive(), Nektar::NonlinearPeregrine::v_ConservativeToPrimitive(), Nektar::NonlinearSWE::v_ConservativeToPrimitive(), Nektar::NavierStokesCFE::v_DoDiffusion(), Nektar::NavierStokesImplicitCFE::v_DoDiffusionCoeff(), Nektar::VCSImplicit::v_DoInitialise(), Nektar::SteadyAdvectionDiffusion::v_DoInitialise(), Nektar::PulseWaveSystem::v_DoInitialise(), Nektar::MMFSWE::v_DoInitialise(), Nektar::CoupledLinearNS::v_DoInitialise(), Nektar::VCSMapping::v_DoInitialise(), Nektar::VelocityCorrectionScheme::v_DoInitialise(), Nektar::SolverUtils::UnsteadySystem::v_DoSolve(), Nektar::EigenValuesAdvection::v_DoSolve(), Nektar::Laplace::v_DoSolve(), Nektar::MMFAdvection::v_DoSolve(), Nektar::Projection::v_DoSolve(), Nektar::SteadyAdvectionDiffusion::v_DoSolve(), Nektar::IterativeElasticSystem::v_DoSolve(), Nektar::LinearElasticSystem::v_DoSolve(), Nektar::MMFMaxwell::v_DoSolve(), Nektar::PulseWaveSystem::v_DoSolve(), Nektar::MMFSWE::v_DoSolve(), Nektar::VelocityCorrectionScheme::v_EvaluateAdvection_SetPressureBCs(), Nektar::VCSMapping::v_EvaluateAdvection_SetPressureBCs(), v_EvaluateExactSolution(), Nektar::MMFMaxwell::v_EvaluateExactSolution(), Nektar::AcousticSystem::v_ExtraFldOutput(), Nektar::CompressibleFlowSystem::v_ExtraFldOutput(), Nektar::NavierStokesCFE::v_ExtraFldOutput(), Nektar::LinearElasticSystem::v_ExtraFldOutput(), Nektar::Poisson::v_GenerateSummary(), Nektar::Projection::v_GenerateSummary(), Nektar::SolverUtils::MMFSystem::v_GenerateSummary(), Nektar::SolverUtils::FileSolution::v_GetDensity(), Nektar::AcousticSystem::v_GetMaxStdVelocity(), Nektar::CompressibleFlowSystem::v_GetMaxStdVelocity(), Nektar::IncNavierStokes::v_GetMaxStdVelocity(), Nektar::CompressibleFlowSystem::v_GetTimeStep(), Nektar::SolverUtils::FileSolution::v_GetVelocity(), Nektar::NavierStokesCFEAxisym::v_GetViscousFluxVector(), Nektar::NavierStokesCFE::v_GetViscousFluxVectorDeAlias(), v_InitObject(), Nektar::PulseWavePropagation::v_InitObject(), Nektar::PulseWaveSystem::v_InitObject(), Nektar::Bidomain::v_InitObject(), Nektar::BidomainRoth::v_InitObject(), Nektar::Monodomain::v_InitObject(), Nektar::MMFDiffusion::v_InitObject(), Nektar::ImageWarpingSystem::v_InitObject(), Nektar::CoupledLinearNS::v_InitObject(), Nektar::IncNavierStokes::v_InitObject(), Nektar::VCSMapping::v_InitObject(), Nektar::VelocityCorrectionScheme::v_InitObject(), Nektar::SolverUtils::FileSolution::v_InitObject(), Nektar::AcousticSystem::v_InitObject(), Nektar::APE::v_InitObject(), Nektar::LEE::v_InitObject(), Nektar::EigenValuesAdvection::v_InitObject(), Nektar::MMFAdvection::v_InitObject(), Nektar::Poisson::v_InitObject(), Nektar::Projection::v_InitObject(), Nektar::UnsteadyAdvection::v_InitObject(), Nektar::UnsteadyAdvectionDiffusion::v_InitObject(), Nektar::UnsteadyDiffusion::v_InitObject(), Nektar::UnsteadyInviscidBurgers::v_InitObject(), Nektar::UnsteadyReactionDiffusion::v_InitObject(), Nektar::UnsteadyViscousBurgers::v_InitObject(), Nektar::CompressibleFlowSystem::v_InitObject(), Nektar::NavierStokesCFEAxisym::v_InitObject(), Nektar::Dummy::v_InitObject(), Nektar::IterativeElasticSystem::v_InitObject(), Nektar::LinearElasticSystem::v_InitObject(), Nektar::MMFMaxwell::v_InitObject(), Nektar::LinearSWE::v_InitObject(), Nektar::MMFSWE::v_InitObject(), Nektar::NonlinearPeregrine::v_InitObject(), Nektar::NonlinearSWE::v_InitObject(), Nektar::ShallowWaterSystem::v_InitObject(), Nektar::MMFSWE::v_L2Error(), v_L2Error(), Nektar::PulseWaveSystem::v_L2Error(), Nektar::MMFSWE::v_LinfError(), v_LinfError(), Nektar::PulseWaveSystem::v_LinfError(), Nektar::CoupledLinearNS::v_Output(), Nektar::Dummy::v_PostIntegrate(), Nektar::AcousticSystem::v_PreIntegrate(), Nektar::Dummy::v_PreIntegrate(), Nektar::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(), v_SetInitialConditions(), Nektar::CompressibleFlowSystem::v_SetInitialConditions(), Nektar::MMFDiffusion::v_SetInitialConditions(), Nektar::VelocityCorrectionScheme::v_SetUpPressureForcing(), Nektar::VCSMapping::v_SetUpPressureForcing(), Nektar::VCSImplicit::v_SetUpPressureForcing(), Nektar::VelocityCorrectionScheme::v_SetUpViscousForcing(), Nektar::VCSMapping::v_SetUpViscousForcing(), Nektar::VCSImplicit::v_SetUpViscousForcing(), Nektar::VCSMapping::v_SolvePressure(), Nektar::VelocityCorrectionScheme::v_SolveUnsteadyStokesSystem(), Nektar::VelocityCorrectionScheme::v_SolveViscous(), Nektar::VCSMapping::v_SolveViscous(), Nektar::VCSImplicit::v_SolveViscous(), Nektar::SolverUtils::UnsteadySystem::v_SteadyStateResidual(), Nektar::CompressibleFlowSystem::v_SteadyStateResidual(), Nektar::CoupledLinearNS::v_TransCoeffToPhys(), Nektar::VelocityCorrectionScheme::v_TransCoeffToPhys(), Nektar::CoupledLinearNS::v_TransPhysToCoeff(), Nektar::VelocityCorrectionScheme::v_TransPhysToCoeff(), Nektar::AcousticSystem::WallBC(), Nektar::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(), Nektar::AcousticSystem::WhiteNoiseBC(), WriteFld(), Nektar::IterativeElasticSystem::WriteGeometry(), and ZeroPhysFields().

m_fintime

NekDouble Nektar::SolverUtils::EquationSystem::m_fintime

protected

Finish time of the simulation.

Definition at line 371 of file EquationSystem.h.

Referenced by Nektar::SolverUtils::UnsteadySystem::v_DoSolve(), Nektar::MMFAdvection::v_DoSolve(), Nektar::MMFMaxwell::v_DoSolve(), Nektar::MMFSWE::v_DoSolve(), v_InitObject(), Nektar::SolverUtils::UnsteadySystem::v_InitObject(), and Nektar::CFSImplicit::v_UpdateTimeStepCheck().

m_fld

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

protected

Field input/output.

Definition at line 357 of file EquationSystem.h.

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

m_graph

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

protected

Pointer to graph defining mesh.

Definition at line 363 of file EquationSystem.h.

Referenced by Nektar::CFSImplicit::AddMatNSBlkDiagVol(), ErrorExtraPoints(), Nektar::CoupledLinearNS::GenPressureExp(), GetNumExpModes(), Nektar::IterativeElasticSystem::v_DoSolve(), Nektar::LinearElasticSystem::v_DoSolve(), Nektar::NavierStokesImplicitCFE::v_GetFluxDerivJacDirctn(), Nektar::NavierStokesImplicitCFE::v_GetFluxDerivJacDirctnElmt(), v_InitObject(), Nektar::PulseWaveSystem::v_InitObject(), Nektar::ImageWarpingSystem::v_InitObject(), Nektar::CoupledLinearNS::v_InitObject(), Nektar::CompressibleFlowSystem::v_InitObject(), Nektar::LinearElasticSystem::v_InitObject(), and Nektar::NavierStokesImplicitCFE::v_MinusDiffusionFluxJacPoint().

m_halfMode

bool Nektar::SolverUtils::EquationSystem::m_halfMode

protected

Flag to determine if half homogeneous mode is used.

Definition at line 402 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 463 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 411 of file EquationSystem.h.

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

m_HomogeneousType

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

protected

Definition at line 453 of file EquationSystem.h.

Referenced by Nektar::CompressibleFlowSystem::DoOdeRhs(), Nektar::CFSImplicit::DoOdeRhsCoeff(), Nektar::SolverUtils::AdvectionSystem::GetCFLEstimate(), Nektar::CFSImplicit::GetTraceJac(), Nektar::VelocityCorrectionScheme::MeasureFlowrate(), SessionSummary(), Nektar::CoupledLinearNS::SetUpCoupledMatrix(), Nektar::SmoothedProfileMethod::SetUpExpansions(), Nektar::VelocityCorrectionScheme::SetupFlowrate(), Nektar::VelocityCorrectionScheme::SetUpSVV(), Nektar::CoupledLinearNS::SolveLinearNS(), Nektar::SmoothedProfileMethod::UpdateForcing(), Nektar::SolverUtils::UnsteadySystem::v_DoSolve(), Nektar::VelocityCorrectionScheme::v_GenerateSummary(), Nektar::VCSImplicit::v_GenerateSummary(), Nektar::VCSWeakPressure::v_GenerateSummary(), Nektar::IncNavierStokes::v_GetMaxStdVelocity(), v_InitObject(), Nektar::CoupledLinearNS::v_InitObject(), Nektar::SmoothedProfileMethod::v_InitObject(), and Nektar::SolverUtils::AdvectionSystem::v_PostIntegrate().

m_infosteps

int Nektar::SolverUtils::EquationSystem::m_infosteps

protected

Number of time steps between outputting status information.

Definition at line 390 of file EquationSystem.h.

Referenced by Nektar::SolverUtils::UnsteadySystem::CheckSteadyState(), GetInfoSteps(), SetInfoSteps(), Nektar::UnsteadyAdvectionDiffusion::SubStepAdvance(), Nektar::SolverUtils::UnsteadySystem::v_DoSolve(), Nektar::MMFAdvection::v_DoSolve(), Nektar::MMFMaxwell::v_DoSolve(), Nektar::PulseWaveSystem::v_DoSolve(), Nektar::MMFSWE::v_DoSolve(), Nektar::SolverUtils::UnsteadySystem::v_InitObject(), Nektar::SolverUtils::UnsteadySystem::v_PrintStatusInformation(), and Nektar::CFSImplicit::v_PrintStatusInformation().

m_initialStep

int Nektar::SolverUtils::EquationSystem::m_initialStep

protected

Number of the step where the simulation should begin.

Definition at line 369 of file EquationSystem.h.

Referenced by Nektar::SolverUtils::UnsteadySystem::CheckSteadyState(), SetInitialStep(), Nektar::SolverUtils::UnsteadySystem::v_DoSolve(), and Nektar::SolverUtils::UnsteadySystem::v_InitObject().

m_iterPIT

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

protected

Number of parallel-in-time time iteration.

Definition at line 392 of file EquationSystem.h.

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

m_lambda

NekDouble Nektar::SolverUtils::EquationSystem::m_lambda

protected

Lambda constant in real system if one required.

Definition at line 376 of file EquationSystem.h.

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

m_lastCheckTime

NekDouble Nektar::SolverUtils::EquationSystem::m_lastCheckTime

protected

Definition at line 379 of file EquationSystem.h.

Referenced by Nektar::SolverUtils::UnsteadySystem::v_DoSolve(), and Nektar::CFSImplicit::v_UpdateTimeStepCheck().

m_LhomX

NekDouble Nektar::SolverUtils::EquationSystem::m_LhomX

protected

physical length in X direction (if homogeneous)

Definition at line 455 of file EquationSystem.h.

m_LhomY

NekDouble Nektar::SolverUtils::EquationSystem::m_LhomY

protected

physical length in Y direction (if homogeneous)

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

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

m_movingFrameData

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

protected

Moving frame of reference angles with respect to the.

Definition at line 435 of file EquationSystem.h.

Referenced by Nektar::IncNavierStokes::v_GetMovingFrameDisp(), Nektar::IncNavierStokes::v_InitObject(), Nektar::IncNavierStokes::v_SetMovingFrameDisp(), and WriteFld().

m_movingFrameProjMat

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

protected

Projection matrix for transformation between inertial and moving.

Definition at line 439 of file EquationSystem.h.

Referenced by Nektar::IncNavierStokes::SetMRFDomainVelBCs(), Nektar::IncNavierStokes::v_GetMovingFrameProjectionMat(), Nektar::IncNavierStokes::v_InitObject(), and Nektar::IncNavierStokes::v_SetMovingFrameProjectionMat().

m_movingFrameVelsxyz

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

protected

Moving frame of reference velocities (u, v, w, omega_x, omega_y, omega_z, a_x, a_y, a_z, domega_x, domega_y, domega_z)

Definition at line 430 of file EquationSystem.h.

Referenced by Nektar::IncNavierStokes::SetMRFWallBCs(), Nektar::IncNavierStokes::v_GetMovingFrameVelocities(), Nektar::IncNavierStokes::v_InitObject(), and Nektar::IncNavierStokes::v_SetMovingFrameVelocities().

m_multipleModes

bool Nektar::SolverUtils::EquationSystem::m_multipleModes

protected

Flag to determine if use multiple homogenenous modes are used.

Definition at line 404 of file EquationSystem.h.

Referenced by SessionSummary(), and v_InitObject().

m_nchk

int Nektar::SolverUtils::EquationSystem::m_nchk

protected

Number of checkpoints written so far.

Definition at line 384 of file EquationSystem.h.

Referenced by GetCheckpointNumber(), SetCheckpointNumber(), Nektar::SolverUtils::FileSolution::v_DoInitialise(), Nektar::SolverUtils::UnsteadySystem::v_DoInitialise(), Nektar::SolverUtils::UnsteadySystem::v_DoSolve(), v_InitObject(), v_SetInitialConditions(), Nektar::CompressibleFlowSystem::v_SetInitialConditions(), Nektar::NonlinearPeregrine::v_SetInitialConditions(), and WriteFld().

m_npointsX

int Nektar::SolverUtils::EquationSystem::m_npointsX

protected

number of points in X direction (if homogeneous)

Definition at line 459 of file EquationSystem.h.

m_npointsY

int Nektar::SolverUtils::EquationSystem::m_npointsY

protected

number of points in Y direction (if homogeneous)

Definition at line 460 of file EquationSystem.h.

Referenced by SessionSummary(), and v_InitObject().

m_npointsZ

int Nektar::SolverUtils::EquationSystem::m_npointsZ

protected

number of points in Z direction (if homogeneous)

Definition at line 461 of file EquationSystem.h.

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

m_NumQuadPointsError

int Nektar::SolverUtils::EquationSystem::m_NumQuadPointsError

protected

Number of Quadrature points used to work out the error.

Definition at line 442 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 418 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::UnsteadyViscousBurgers::DoImplicitSolve(), Nektar::MMFAdvection::DoOdeProjection(), Nektar::UnsteadyAdvection::DoOdeProjection(), Nektar::UnsteadyDiffusion::DoOdeProjection(), Nektar::UnsteadyInviscidBurgers::DoOdeProjection(), Nektar::CompressibleFlowSystem::DoOdeProjection(), Nektar::ImageWarpingSystem::DoOdeProjection(), Nektar::LinearSWE::DoOdeProjection(), Nektar::MMFSWE::DoOdeProjection(), Nektar::NonlinearPeregrine::DoOdeProjection(), Nektar::NonlinearSWE::DoOdeProjection(), Nektar::MMFAdvection::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::EigenValuesAdvection::v_InitObject(), Nektar::UnsteadyAdvection::v_InitObject(), Nektar::UnsteadyAdvectionDiffusion::v_InitObject(), Nektar::UnsteadyDiffusion::v_InitObject(), Nektar::UnsteadyInviscidBurgers::v_InitObject(), Nektar::UnsteadyViscousBurgers::v_InitObject(), Nektar::LinearSWE::v_InitObject(), Nektar::NonlinearPeregrine::v_InitObject(), Nektar::NonlinearSWE::v_InitObject(), Nektar::ShallowWaterSystem::v_InitObject(), and v_SetInitialConditions().

m_session

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

protected

The session reader.

Definition at line 352 of file EquationSystem.h.

Referenced by Nektar::LinearElasticSystem::BuildMatrixSystem(), Nektar::CFSImplicit::CalcTraceNumericalFlux(), Nektar::SolverUtils::UnsteadySystem::CheckForRestartTime(), Checkpoint_Output(), Nektar::SolverUtils::UnsteadySystem::CheckSteadyState(), Nektar::SolverUtils::MMFSystem::CopyBoundaryTrace(), Nektar::IncNavierStokes::DefinedForcing(), Nektar::CoupledLinearNS::DefineForcingTerm(), Nektar::Bidomain::DoImplicitSolve(), Nektar::Bidomain::DoOdeRhs(), Nektar::BidomainRoth::DoOdeRhs(), Nektar::ImageWarpingSystem::DoOdeRhs(), EquationSystem(), ErrorExtraPoints(), Nektar::CompressibleFlowSystem::EvaluateIsentropicVortex(), Nektar::PulseWavePropagation::GetFluxVector(), GetFunction(), Nektar::SmoothedProfileMethod::GetFunctionHdl(), GetNvariables(), GetSession(), Nektar::UnsteadyAdvectionDiffusion::GetSubstepTimeStep(), GetVariable(), Nektar::Helmholtz::Helmholtz(), ImportFld(), ImportFldToMultiDomains(), Nektar::CompressibleFlowSystem::InitAdvection(), Nektar::CFSImplicit::InitialiseNonlinSysSolver(), Nektar::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::SolverUtils::FileSolution::UpdateField(), Nektar::VCSImplicit::v_DoInitialise(), Nektar::SteadyAdvectionDiffusion::v_DoInitialise(), Nektar::PulseWaveSystem::v_DoInitialise(), Nektar::CoupledLinearNS::v_DoInitialise(), Nektar::SolverUtils::UnsteadySystem::v_DoSolve(), Nektar::MMFAdvection::v_DoSolve(), Nektar::IterativeElasticSystem::v_DoSolve(), Nektar::LinearElasticSystem::v_DoSolve(), Nektar::MMFMaxwell::v_DoSolve(), Nektar::PulseWaveSystem::v_DoSolve(), Nektar::MMFSWE::v_DoSolve(), v_EvaluateExactSolution(), Nektar::CompressibleFlowSystem::v_EvaluateExactSolution(), Nektar::AcousticSystem::v_ExtraFldOutput(), Nektar::CompressibleFlowSystem::v_ExtraFldOutput(), Nektar::NavierStokesCFE::v_ExtraFldOutput(), Nektar::Poisson::v_GenerateSummary(), Nektar::Projection::v_GenerateSummary(), Nektar::UnsteadyAdvection::v_GenerateSummary(), Nektar::CompressibleFlowSystem::v_GenerateSummary(), Nektar::VelocityCorrectionScheme::v_GenerateSummary(), Nektar::VCSImplicit::v_GenerateSummary(), Nektar::VCSWeakPressure::v_GenerateSummary(), Nektar::LinearSWE::v_GenerateSummary(), Nektar::SolverUtils::UnsteadySystem::v_GenerateSummary(), Nektar::Monodomain::v_GenerateSummary(), Nektar::SolverUtils::FileSolution::v_GetDensity(), Nektar::VelocityCorrectionScheme::v_GetForceDimension(), Nektar::CoupledLinearNS::v_GetForceDimension(), v_GetSystemSingularChecks(), Nektar::Helmholtz::v_GetSystemSingularChecks(), Nektar::Laplace::v_GetSystemSingularChecks(), Nektar::Poisson::v_GetSystemSingularChecks(), Nektar::VelocityCorrectionScheme::v_GetSystemSingularChecks(), Nektar::SolverUtils::FileSolution::v_GetVelocity(), Nektar::SolverUtils::FileSolution::v_HasConstantDensity(), v_InitObject(), Nektar::PulseWavePropagation::v_InitObject(), Nektar::PulseWaveSystem::v_InitObject(), Nektar::SolverUtils::AdvectionSystem::v_InitObject(), Nektar::SolverUtils::UnsteadySystem::v_InitObject(), Nektar::Bidomain::v_InitObject(), Nektar::BidomainRoth::v_InitObject(), Nektar::Monodomain::v_InitObject(), Nektar::MMFDiffusion::v_InitObject(), Nektar::ImageWarpingSystem::v_InitObject(), Nektar::CoupledLinearNS::v_InitObject(), Nektar::IncNavierStokes::v_InitObject(), Nektar::SmoothedProfileMethod::v_InitObject(), Nektar::VCSMapping::v_InitObject(), Nektar::VelocityCorrectionScheme::v_InitObject(), Nektar::SolverUtils::FileSolution::v_InitObject(), Nektar::AcousticSystem::v_InitObject(), Nektar::APE::v_InitObject(), Nektar::LEE::v_InitObject(), Nektar::EigenValuesAdvection::v_InitObject(), Nektar::MMFAdvection::v_InitObject(), Nektar::Poisson::v_InitObject(), Nektar::Projection::v_InitObject(), Nektar::SteadyAdvectionDiffusion::v_InitObject(), Nektar::SteadyAdvectionDiffusionReaction::v_InitObject(), Nektar::UnsteadyAdvection::v_InitObject(), Nektar::UnsteadyAdvectionDiffusion::v_InitObject(), Nektar::UnsteadyDiffusion::v_InitObject(), Nektar::UnsteadyInviscidBurgers::v_InitObject(), Nektar::UnsteadyReactionDiffusion::v_InitObject(), Nektar::UnsteadyViscousBurgers::v_InitObject(), Nektar::CompressibleFlowSystem::v_InitObject(), Nektar::CFSImplicit::v_InitObject(), Nektar::Dummy::v_InitObject(), Nektar::IterativeElasticSystem::v_InitObject(), Nektar::LinearElasticSystem::v_InitObject(), Nektar::MMFMaxwell::v_InitObject(), Nektar::LinearSWE::v_InitObject(), Nektar::MMFSWE::v_InitObject(), Nektar::NonlinearPeregrine::v_InitObject(), Nektar::NonlinearSWE::v_InitObject(), Nektar::ShallowWaterSystem::v_InitObject(), v_L2Error(), Nektar::PulseWaveSystem::v_L2Error(), v_LinfError(), Nektar::PulseWaveSystem::v_LinfError(), Nektar::Dummy::v_Output(), Nektar::Dummy::v_PostIntegrate(), Nektar::AcousticSystem::v_PreIntegrate(), Nektar::Dummy::v_PreIntegrate(), Nektar::SolverUtils::UnsteadySystem::v_PrintStatusInformation(), Nektar::CFSImplicit::v_PrintStatusInformation(), Nektar::SolverUtils::UnsteadySystem::v_PrintSummaryStatistics(), Nektar::CFSImplicit::v_PrintSummaryStatistics(), v_SetInitialConditions(), Nektar::CompressibleFlowSystem::v_SetInitialConditions(), Nektar::VCSMapping::v_SolvePressure(), Nektar::VCSMapping::v_SolveViscous(), WriteFld(), Nektar::IterativeElasticSystem::WriteGeometry(), and Nektar::PulseWaveSystem::WriteVessels().

m_sessionFunctions

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

protected

Map of known SessionFunctions.

Definition at line 355 of file EquationSystem.h.

Referenced by GetFunction().

m_sessionName

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

protected

Name of the session.

Definition at line 365 of file EquationSystem.h.

Referenced by Checkpoint_BaseFlow(), Nektar::MMFMaxwell::Checkpoint_EDFluxOutput(), Nektar::MMFMaxwell::Checkpoint_EnergyOutput(), Checkpoint_Output(), Nektar::PulseWaveSystem::CheckPoint_Output(), Nektar::MMFMaxwell::Checkpoint_PlotOutput(), Nektar::MMFMaxwell::Checkpoint_TotalFieldOutput(), Nektar::MMFMaxwell::Checkpoint_TotPlotOutput(), GetSessionName(), ResetSessionName(), SessionSummary(), v_InitObject(), v_Output(), Nektar::CoupledLinearNS::v_Output(), Nektar::PulseWaveSystem::v_Output(), Nektar::SolverUtils::AdvectionSystem::v_PostIntegrate(), Nektar::MMFAdvection::v_SetInitialConditions(), Nektar::MMFMaxwell::v_SetInitialConditions(), Nektar::MMFSWE::v_SetInitialConditions(), v_SetInitialConditions(), Nektar::CompressibleFlowSystem::v_SetInitialConditions(), Nektar::MMFDiffusion::v_SetInitialConditions(), and Nektar::NonlinearPeregrine::v_SetInitialConditions().

m_singleMode

bool Nektar::SolverUtils::EquationSystem::m_singleMode

protected

Flag to determine if single homogeneous mode is used.

Definition at line 400 of file EquationSystem.h.

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

m_spacedim

int Nektar::SolverUtils::EquationSystem::m_spacedim

protected

Spatial dimension (>= expansion dim).

Definition at line 396 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::CompressibleFlowSystem::EvaluateIsentropicVortex(), Nektar::LinearSWE::GetFluxVector(), Nektar::NonlinearPeregrine::GetFluxVector(), Nektar::NonlinearSWE::GetFluxVector(), Nektar::CompressibleFlowSystem::GetFluxVector(), Nektar::UnsteadyAdvection::GetFluxVectorDeAlias(), Nektar::CompressibleFlowSystem::GetFluxVectorDeAlias(), Nektar::CFSImplicit::GetFluxVectorJacPoint(), Nektar::UnsteadyInviscidBurgers::GetNormalVelocity(), Nektar::CFSImplicit::GetTraceJac(), Nektar::LinearSWE::GetVelocityVector(), Nektar::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::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::SteadyAdvectionDiffusion::v_DoSolve(), Nektar::CompressibleFlowSystem::v_ExtraFldOutput(), Nektar::NavierStokesCFE::v_ExtraFldOutput(), Nektar::NavierStokesImplicitCFE::v_GetDiffusionFluxJacPoint(), Nektar::APE::v_GetFluxVector(), Nektar::LEE::v_GetFluxVector(), Nektar::AcousticSystem::v_GetMaxStdVelocity(), Nektar::CompressibleFlowSystem::v_GetMaxStdVelocity(), Nektar::IncNavierStokes::v_GetVelocity(), Nektar::NavierStokesCFE::v_GetViscousFluxVector(), Nektar::NavierStokesCFEAxisym::v_GetViscousFluxVector(), Nektar::NavierStokesCFE::v_GetViscousFluxVectorDeAlias(), v_InitObject(), Nektar::Bidomain::v_InitObject(), Nektar::BidomainRoth::v_InitObject(), Nektar::Monodomain::v_InitObject(), Nektar::MMFDiffusion::v_InitObject(), Nektar::ImageWarpingSystem::v_InitObject(), Nektar::IncNavierStokes::v_InitObject(), Nektar::AcousticSystem::v_InitObject(), Nektar::EigenValuesAdvection::v_InitObject(), Nektar::MMFAdvection::v_InitObject(), Nektar::SteadyAdvectionDiffusion::v_InitObject(), Nektar::UnsteadyAdvection::v_InitObject(), Nektar::CompressibleFlowSystem::v_InitObject(), Nektar::NavierStokesImplicitCFE::v_InitObject(), Nektar::MMFMaxwell::v_InitObject(), Nektar::ShallowWaterSystem::v_InitObject(), Nektar::APE::v_RiemannInvariantBC(), Nektar::LEE::v_RiemannInvariantBC(), Nektar::VelocityCorrectionScheme::v_SolveUnsteadyStokesSystem(), Nektar::SolverUtils::MMFSystem::VectorAvgMagnitude(), Nektar::AcousticSystem::WallBC(), Nektar::LinearSWE::WallBoundary(), Nektar::NonlinearPeregrine::WallBoundary(), Nektar::NonlinearSWE::WallBoundary(), and Nektar::AcousticSystem::WhiteNoiseBC().

m_specHP_dealiasing

bool Nektar::SolverUtils::EquationSystem::m_specHP_dealiasing

protected

Flag to determine if dealisising is usde for the Spectral/hp element discretisation.

Definition at line 416 of file EquationSystem.h.

Referenced by Nektar::CompressibleFlowSystem::InitAdvection(), Nektar::NavierStokesCFE::InitObject_Explicit(), Nektar::VelocityCorrectionScheme::v_GenerateSummary(), Nektar::VCSImplicit::v_GenerateSummary(), Nektar::VCSWeakPressure::v_GenerateSummary(), v_InitObject(), and Nektar::UnsteadyAdvection::v_InitObject().

m_steps

int Nektar::SolverUtils::EquationSystem::m_steps

protected

Number of steps to take.

Definition at line 386 of file EquationSystem.h.

Referenced by GetSteps(), SetSteps(), Nektar::SolverUtils::UnsteadySystem::v_DoSolve(), Nektar::MMFAdvection::v_DoSolve(), Nektar::MMFMaxwell::v_DoSolve(), Nektar::PulseWaveSystem::v_DoSolve(), Nektar::MMFSWE::v_DoSolve(), Nektar::SolverUtils::UnsteadySystem::v_GenerateSummary(), v_InitObject(), and Nektar::SolverUtils::UnsteadySystem::v_InitObject().

m_time

NekDouble Nektar::SolverUtils::EquationSystem::m_time

protected

Current time of simulation.

Definition at line 367 of file EquationSystem.h.

Referenced by Nektar::SolverUtils::UnsteadySystem::CheckSteadyState(), Nektar::AcousticSystem::DoOdeRhs(), ErrorExtraPoints(), Nektar::CoupledLinearNS::EvaluateNewtonRHS(), GetTime(), SetTime(), Nektar::IncNavierStokes::SetWomersleyBoundary(), Nektar::SolverUtils::FileSolution::v_DoInitialise(), Nektar::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::SolverUtils::FileSolution::v_PostIntegrate(), Nektar::AcousticSystem::v_PreIntegrate(), Nektar::UnsteadyAdvectionDiffusion::v_PreIntegrate(), Nektar::Dummy::v_PreIntegrate(), Nektar::IncNavierStokes::v_PreIntegrate(), Nektar::SolverUtils::UnsteadySystem::v_PrintStatusInformation(), v_SetInitialConditions(), Nektar::VCSImplicit::v_SetUpPressureForcing(), Nektar::VCSImplicit::v_SetUpViscousForcing(), Nektar::CompressibleFlowSystem::v_SteadyStateResidual(), Nektar::CFSImplicit::v_UpdateTimeStepCheck(), Nektar::AcousticSystem::WhiteNoiseBC(), WriteFld(), and Nektar::PulseWaveSystem::WriteVessels().

m_TimeIncrementFactor

NekDouble Nektar::SolverUtils::EquationSystem::m_TimeIncrementFactor

protected

Definition at line 381 of file EquationSystem.h.

Referenced by Nektar::SolverUtils::UnsteadySystem::v_DoSolve(), and v_InitObject().

m_timestep

NekDouble Nektar::SolverUtils::EquationSystem::m_timestep

protected

Time step size.

Definition at line 373 of file EquationSystem.h.

Referenced by Nektar::UnsteadyAdvection::DoOdeProjection(), Nektar::CompressibleFlowSystem::DoOdeRhs(), Nektar::CFSImplicit::DoOdeRhsCoeff(), Nektar::SolverUtils::AdvectionSystem::GetElmtCFLVals(), Nektar::CompressibleFlowSystem::GetElmtTimeStep(), GetTimeStep(), SetTimeStep(), Nektar::UnsteadyAdvectionDiffusion::SubStepAdvance(), Nektar::VCSMapping::v_DoInitialise(), Nektar::VelocityCorrectionScheme::v_DoInitialise(), Nektar::SolverUtils::UnsteadySystem::v_DoSolve(), Nektar::MMFAdvection::v_DoSolve(), Nektar::MMFMaxwell::v_DoSolve(), Nektar::PulseWaveSystem::v_DoSolve(), Nektar::MMFSWE::v_DoSolve(), Nektar::VCSMapping::v_EvaluateAdvection_SetPressureBCs(), Nektar::SolverUtils::UnsteadySystem::v_GenerateSummary(), v_InitObject(), Nektar::SolverUtils::UnsteadySystem::v_InitObject(), Nektar::IncNavierStokes::v_InitObject(), Nektar::IncNavierStokes::v_PreIntegrate(), Nektar::SolverUtils::UnsteadySystem::v_PrintStatusInformation(), Nektar::SolverUtils::UnsteadySystem::v_PrintSummaryStatistics(), Nektar::VCSImplicit::v_SetUpPressureForcing(), Nektar::VCSImplicit::v_SetUpViscousForcing(), and Nektar::CFSImplicit::v_UpdateTimeStepCheck().

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

Referenced by Nektar::SolverUtils::MMFSystem::AverageMaxwellFlux1D(), Nektar::SolverUtils::MMFSystem::ComputencdotMF(), Nektar::SolverUtils::MMFSystem::ComputeNtimesMF(), Nektar::SolverUtils::MMFSystem::ComputeNtimestimesdFz(), Nektar::NonlinearPeregrine::DoOdeRhs(), Nektar::AcousticSystem::GetNormals(), Nektar::CompressibleFlowSystem::GetNormals(), Nektar::ShallowWaterSystem::GetNormals(), Nektar::UnsteadyAdvection::GetNormalVel(), Nektar::EigenValuesAdvection::GetNormalVelocity(), Nektar::MMFAdvection::GetNormalVelocity(), Nektar::UnsteadyInviscidBurgers::GetNormalVelocity(), Nektar::ImageWarpingSystem::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::WallBC(), Nektar::LinearSWE::WallBoundary(), Nektar::NonlinearPeregrine::WallBoundary(), Nektar::NonlinearSWE::WallBoundary(), Nektar::LinearSWE::WallBoundary2D(), Nektar::NonlinearPeregrine::WallBoundary2D(), Nektar::NonlinearSWE::WallBoundary2D(), Nektar::NonlinearPeregrine::WallBoundaryForcing(), and Nektar::AcousticSystem::WhiteNoiseBC().

m_useFFT

bool Nektar::SolverUtils::EquationSystem::m_useFFT

protected

Flag to determine if FFT is used for homogeneous transform.

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

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

m_windowPIT

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

protected

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

Definition at line 394 of file EquationSystem.h.

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

projectionTypeLookupIds

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

staticprotected

Initial value:

= {
    LibUtilities::SessionReader::RegisterEnumValue("Projection", "Continuous",
                                                   MultiRegions::eGalerkin),
    LibUtilities::SessionReader::RegisterEnumValue("Projection", "CONTINUOUS",
                                                   MultiRegions::eGalerkin),
    LibUtilities::SessionReader::RegisterEnumValue("Projection", "Galerkin",
                                                   MultiRegions::eGalerkin),
    LibUtilities::SessionReader::RegisterEnumValue("Projection", "GALERKIN",
                                                   MultiRegions::eGalerkin),
    LibUtilities::SessionReader::RegisterEnumValue(
        "Projection", "DisContinuous", MultiRegions::eDiscontinuous),
    LibUtilities::SessionReader::RegisterEnumValue(
        "Projection", "Mixed_CG_Discontinuous",
        MultiRegions::eMixed_CG_Discontinuous),
    LibUtilities::SessionReader::RegisterEnumValue(
        "Projection", "MixedCGDG", MultiRegions::eMixed_CG_Discontinuous),
}

Definition at line 524 of file EquationSystem.h.