Base class for the development of solvers. More...

#include <Driver.h>

Inheritance diagram for Nektar::SolverUtils::Driver:

Public Member Functions
virtual	~Driver ()=default
	Destructor. More...

SOLVER_UTILS_EXPORT void	InitObject (std::ostream &out=std::cout)
	Initialise Object. More...

SOLVER_UTILS_EXPORT void	Execute (std::ostream &out=std::cout)
	Execute driver. More...

SOLVER_UTILS_EXPORT Array< OneD, EquationSystemSharedPtr >	GetEqu ()

Protected Member Functions
	Driver (const LibUtilities::SessionReaderSharedPtr pSession, const SpatialDomains::MeshGraphSharedPtr pGraph)
	Initialises EquationSystem class members. More...

virtual SOLVER_UTILS_EXPORT void	v_InitObject (std::ostream &out=std::cout)
	Virtual function for initialisation implementation. More...

virtual SOLVER_UTILS_EXPORT void	v_Execute (std::ostream &out=std::cout)=0
	Virtual function for solve implementation. More...

Protected Attributes
LibUtilities::CommSharedPtr	m_comm
	Communication object. More...

LibUtilities::SessionReaderSharedPtr	m_session
	Session reader object. More...

LibUtilities::SessionReaderSharedPtr	session_LinNS
	Coupling between SFD and arnoldi. More...

SpatialDomains::MeshGraphSharedPtr	m_graph
	MeshGraph object. More...

Array< OneD, EquationSystemSharedPtr >	m_equ
	Equation system to solve. More...

int	m_nequ
	number of equations More...

enum EvolutionOperatorType	m_EvolutionOperator
	Evolution Operator. More...

Static Protected Attributes
static std::string	evolutionOperatorLookupIds []

static std::string	evolutionOperatorDef

static std::string	driverDefault

Detailed Description

Base class for the development of solvers.

Definition at line 64 of file Driver.h.

Constructor & Destructor Documentation

◆ ~Driver()

virtual Nektar::SolverUtils::Driver::~Driver ( )

virtualdefault

Destructor.

◆ Driver()

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

protected

Initialises EquationSystem class members.

Definition at line 75 of file Driver.cpp.

    : m_comm(pSession->GetComm()), m_session(pSession), m_graph(pGraph)
{
}

Member Function Documentation

◆ Execute()

void Nektar::SolverUtils::Driver::Execute ( std::ostream & out = std::cout )

inline

Execute driver.

Definition at line 122 of file Driver.h.

{
    v_Execute(out);
}

References v_Execute().

◆ GetEqu()

Array< OneD, EquationSystemSharedPtr > Nektar::SolverUtils::Driver::GetEqu ( )

inline

Definition at line 127 of file Driver.h.

{
    return m_equ;
}

References m_equ.

◆ InitObject()

void Nektar::SolverUtils::Driver::InitObject ( std::ostream & out = std::cout )

inline

Initialise Object.

Definition at line 117 of file Driver.h.

{
    v_InitObject(out);
}

References v_InitObject().

◆ v_Execute()

virtual SOLVER_UTILS_EXPORT void Nektar::SolverUtils::Driver::v_Execute ( std::ostream & out = std::cout )

protectedpure virtual

Virtual function for solve implementation.

Implemented in Nektar::SolverUtils::DriverAdaptive, Nektar::SolverUtils::DriverArnoldi, Nektar::SolverUtils::DriverArpack, Nektar::SolverUtils::DriverModifiedArnoldi, Nektar::SolverUtils::DriverParallelInTime, Nektar::SolverUtils::DriverParareal, Nektar::SolverUtils::DriverPFASST, Nektar::SolverUtils::DriverStandard, and Nektar::SolverUtils::DriverSteadyState.

Referenced by Execute().

◆ v_InitObject()

void Nektar::SolverUtils::Driver::v_InitObject ( std::ostream & out = std::cout )

protectedvirtual

Virtual function for initialisation implementation.

Todo:: At the moment this is Navier-Stokes specific - generalise?

Reimplemented in Nektar::SolverUtils::DriverAdaptive, Nektar::SolverUtils::DriverArnoldi, Nektar::SolverUtils::DriverArpack, Nektar::SolverUtils::DriverModifiedArnoldi, Nektar::SolverUtils::DriverParallelInTime, Nektar::SolverUtils::DriverParareal, Nektar::SolverUtils::DriverPFASST, Nektar::SolverUtils::DriverStandard, and Nektar::SolverUtils::DriverSteadyState.

Definition at line 84 of file Driver.cpp.

{
    try
    {
        // Retrieve the equation system to solve.
        ASSERTL0(m_session->DefinesSolverInfo("EqType"),
                 "EqType SolverInfo tag must be defined.");
        std::string vEquation = m_session->GetSolverInfo("EqType");
        if (m_session->DefinesSolverInfo("SolverType"))
        {
            vEquation = m_session->GetSolverInfo("SolverType");
        }
 
        // Check such a module exists for this equation.
        ASSERTL0(
            GetEquationSystemFactory().ModuleExists(vEquation),
            "EquationSystem '" + vEquation +
                "' is not defined.\n"
                "Ensure equation name is correct and module is compiled.\n");
 
        // Retrieve the type of evolution operator to use
        /// @todo At the moment this is Navier-Stokes specific - generalise?
        m_EvolutionOperator =
            m_session->GetSolverInfoAsEnum<EvolutionOperatorType>(
                "EvolutionOperator");
 
        m_nequ = ((m_EvolutionOperator == eTransientGrowth ||
                   m_EvolutionOperator == eAdaptiveSFD)
                      ? 2
                      : 1);
 
        m_equ = Array<OneD, EquationSystemSharedPtr>(m_nequ);
 
        // Set the AdvectiveType tag and create EquationSystem objects.
        switch (m_EvolutionOperator)
        {
            case eNonlinear:
                m_session->SetTag("AdvectiveType", "Convective");
                m_equ[0] = GetEquationSystemFactory().CreateInstance(
                    vEquation, m_session, m_graph);
                break;
            case eDirect:
                m_session->SetTag("AdvectiveType", "Linearised");
                m_equ[0] = GetEquationSystemFactory().CreateInstance(
                    vEquation, m_session, m_graph);
                break;
            case eAdjoint:
                m_session->SetTag("AdvectiveType", "Adjoint");
                m_equ[0] = GetEquationSystemFactory().CreateInstance(
                    vEquation, m_session, m_graph);
                break;
            case eTransientGrowth:
                // forward timestepping
                m_session->SetTag("AdvectiveType", "Linearised");
                m_equ[0] = GetEquationSystemFactory().CreateInstance(
                    vEquation, m_session, m_graph);
 
                // backward timestepping
                m_session->SetTag("AdvectiveType", "Adjoint");
                m_equ[1] = GetEquationSystemFactory().CreateInstance(
                    vEquation, m_session, m_graph);
                break;
            case eSkewSymmetric:
                m_session->SetTag("AdvectiveType", "SkewSymmetric");
                m_equ[0] = GetEquationSystemFactory().CreateInstance(
                    vEquation, m_session, m_graph);
                break;
            case eAdaptiveSFD:
            {
                // use-opt-file
                bool useOptFile =
                    m_session->DefinesCmdLineArgument("use-opt-file");
                std::string optfilename =
                    useOptFile ? m_session->GetFilenames()[0] : "";
 
                char *argv[] = {const_cast<char *>("IncNavierStokesSolver"),
                                const_cast<char *>("--use-opt-file"),
                                const_cast<char *>(optfilename.c_str()),
                                nullptr};
 
                size_t argc = useOptFile ? 3 : 1;
 
                std::vector<std::string> LinNSFilename;
                if (m_comm->GetSize() == 1)
                {
                    // Use .xml.gz file for serial case
                    LinNSFilename.push_back(m_session->GetSessionName() +
                                            ".xml.gz");
                }
                else
                {
                    // Use previous partition for parallel case
                    LinNSFilename.push_back(m_session->GetSessionName() +
                                            "_xml");
                }
                LinNSFilename.push_back(m_session->GetSessionName() +
                                        "_LinNS.xml");
 
                session_LinNS = LibUtilities::SessionReader::CreateInstance(
                    argc, argv, LinNSFilename, m_comm);
 
                // Set graph for LinNs solver.
                SpatialDomains::MeshGraphSharedPtr graph_linns =
                    SpatialDomains::MeshGraphIO::Read(session_LinNS);
 
                // For running stability analysis
                session_LinNS->SetTag("AdvectiveType", "Linearised");
                m_equ[0] = GetEquationSystemFactory().CreateInstance(
                    vEquation, session_LinNS, graph_linns);
 
                // For running the SFD method on the nonlinear problem
                m_session->SetTag("AdvectiveType", "Convective");
                m_equ[1] = GetEquationSystemFactory().CreateInstance(
                    vEquation, m_session, m_graph);
            }
            break;
            default:
                ASSERTL0(false, "Unrecognised evolution operator.");
        }
    }
    catch (int e)
    {
        ASSERTL0(e == -1, "No such class class defined.");
        out << "An error occurred during driver initialisation." << endl;
    }
}

References ASSERTL0, Nektar::LibUtilities::SessionReader::CreateInstance(), Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::CreateInstance(), Nektar::SolverUtils::eAdaptiveSFD, Nektar::SolverUtils::eAdjoint, Nektar::SolverUtils::eDirect, Nektar::SolverUtils::eNonlinear, Nektar::SolverUtils::eSkewSymmetric, Nektar::SolverUtils::eTransientGrowth, Nektar::SolverUtils::GetEquationSystemFactory(), m_comm, m_equ, m_EvolutionOperator, m_graph, m_nequ, m_session, Nektar::SpatialDomains::MeshGraphIO::Read(), and session_LinNS.

Referenced by InitObject(), Nektar::SolverUtils::DriverAdaptive::v_Execute(), Nektar::SolverUtils::DriverAdaptive::v_InitObject(), Nektar::SolverUtils::DriverArnoldi::v_InitObject(), and Nektar::SolverUtils::DriverStandard::v_InitObject().

Member Data Documentation

◆ driverDefault

std::string Nektar::SolverUtils::Driver::driverDefault

staticprotected

Initial value:

=
    LibUtilities::SessionReader::RegisterDefaultSolverInfo("Driver",
                                                           "Standard")

Definition at line 114 of file Driver.h.

◆ evolutionOperatorDef

std::string Nektar::SolverUtils::Driver::evolutionOperatorDef

staticprotected

Initial value:

=
    LibUtilities::SessionReader::RegisterDefaultSolverInfo("EvolutionOperator",
                                                           "Nonlinear")

Definition at line 113 of file Driver.h.

◆ evolutionOperatorLookupIds

std::string Nektar::SolverUtils::Driver::evolutionOperatorLookupIds

staticprotected

Initial value:

= {
    LibUtilities::SessionReader::RegisterEnumValue("EvolutionOperator",
                                                   "Nonlinear", eNonlinear),
    LibUtilities::SessionReader::RegisterEnumValue("EvolutionOperator",
                                                   "Direct", eDirect),
    LibUtilities::SessionReader::RegisterEnumValue("EvolutionOperator",
                                                   "Adjoint", eAdjoint),
    LibUtilities::SessionReader::RegisterEnumValue(
        "EvolutionOperator", "TransientGrowth", eTransientGrowth),
    LibUtilities::SessionReader::RegisterEnumValue(
        "EvolutionOperator", "SkewSymmetric", eSkewSymmetric),
    LibUtilities::SessionReader::RegisterEnumValue(
        "EvolutionOperator", "AdaptiveSFD", eAdaptiveSFD)}

Definition at line 112 of file Driver.h.

◆ m_comm

LibUtilities::CommSharedPtr Nektar::SolverUtils::Driver::m_comm

protected

Communication object.

Definition at line 80 of file Driver.h.

◆ m_equ

Array<OneD, EquationSystemSharedPtr> Nektar::SolverUtils::Driver::m_equ

protected

Equation system to solve.

Definition at line 92 of file Driver.h.

◆ m_EvolutionOperator

enum EvolutionOperatorType Nektar::SolverUtils::Driver::m_EvolutionOperator

protected

Evolution Operator.

Definition at line 98 of file Driver.h.

Referenced by Nektar::SolverUtils::DriverArnoldi::CopyFieldToArnoldiArray(), Nektar::SolverUtils::DriverModifiedArnoldi::EV_update(), Nektar::SolverUtils::DriverSteadyState::PrintSummarySFD(), Nektar::SolverUtils::DriverArpack::v_Execute(), Nektar::SolverUtils::DriverSteadyState::v_Execute(), v_InitObject(), and Nektar::SolverUtils::DriverParallelInTime::v_InitObject().

◆ m_graph

SpatialDomains::MeshGraphSharedPtr Nektar::SolverUtils::Driver::m_graph

protected

MeshGraph object.

Definition at line 89 of file Driver.h.

Referenced by Nektar::SolverUtils::DriverParallelInTime::SetParallelInTimeEquationSystem(), Nektar::SolverUtils::DriverAdaptive::v_Execute(), and v_InitObject().

◆ m_nequ

int Nektar::SolverUtils::Driver::m_nequ

protected

number of equations

Definition at line 95 of file Driver.h.

Referenced by Nektar::SolverUtils::DriverSteadyState::ComputeSFD(), Nektar::SolverUtils::DriverSteadyState::ConvergenceHistory(), Nektar::SolverUtils::DriverArnoldi::CopyFieldToArnoldiArray(), Nektar::SolverUtils::DriverSteadyState::v_Execute(), v_InitObject(), Nektar::SolverUtils::DriverArpack::v_InitObject(), and Nektar::SolverUtils::DriverModifiedArnoldi::v_InitObject().

◆ m_session

LibUtilities::SessionReaderSharedPtr Nektar::SolverUtils::Driver::m_session

protected

Session reader object.

Definition at line 83 of file Driver.h.

◆ session_LinNS

LibUtilities::SessionReaderSharedPtr Nektar::SolverUtils::Driver::session_LinNS

protected

Coupling between SFD and arnoldi.

Definition at line 86 of file Driver.h.

Referenced by v_InitObject().

Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ~Driver()

◆ Driver()

Member Function Documentation

◆ Execute()

◆ GetEqu()

◆ InitObject()

◆ v_Execute()

◆ v_InitObject()

Member Data Documentation

◆ driverDefault

◆ evolutionOperatorDef

◆ evolutionOperatorLookupIds

◆ m_comm

◆ m_equ

◆ m_EvolutionOperator

◆ m_graph

◆ m_nequ

◆ m_session

◆ session_LinNS