SolverUtils.cpp File Reference

#include <LibUtilities/Python/NekPyConfig.hpp>

Go to the source code of this file.

Functions
void	export_EquationSystem (py::module &m)
void	export_Filter (py::module &m)
void	export_SessionFunction (py::module &m)
void	export_UnsteadySystem (py::module &m)
	PYBIND11_MODULE (_SolverUtils, m)

Function Documentation

export_EquationSystem()

void export_EquationSystem

(

py::module &

m

)

Definition at line 149 of file Python/EquationSystem.cpp.

{
    using EqSysWrap = EquationSystemWrap<EquationSystem>;
    using EqSysPub  = EquationSystemPublic<EquationSystem>;
 
    static NekFactory_Register<EquationSystemFactory> fac(
        GetEquationSystemFactory());
 
    py::classh<EquationSystem, EqSysWrap>(m, "EquationSystem")
        .def(py::init<LibUtilities::SessionReaderSharedPtr,
                      SpatialDomains::MeshGraphSharedPtr>())
 
        // Virtual functions that can be optionally overridden
        .def("InitObject", &EqSysPub::v_InitObject)
        .def("DoInitialise", &EqSysPub::v_DoInitialise)
        .def("DoSolve", &EqSysPub::v_DoSolve)
        .def("SetInitialConditions", &EqSysPub::v_SetInitialConditions)
        .def("EvaluateExactSolution", &EqSysWrap::EvaluateExactSolution)
        .def("LinfError", &EqSysWrap::LinfError)
        .def("L2Error", &EqSysWrap::L2Error)
 
        // Fields accessors (read-only)
        .def("GetFields", &EquationSystem_GetFields)
        .def_property_readonly("fields", &EquationSystem_GetFields)
 
        // Various utility functions
        .def("GetNvariables", &EquationSystem::GetNvariables)
        .def("GetVariable", &EquationSystem::GetVariable)
        .def("GetNpoints", &EquationSystem::GetNpoints)
        .def("SetInitialStep", &EquationSystem::SetInitialStep)
        .def("ZeroPhysFields", &EquationSystem::ZeroPhysFields)
 
        // Time accessors/properties
        .def("GetTime", &EquationSystem::GetTime)
        .def("SetTime", &EquationSystem::SetTime)
        .def_property("time", &EquationSystem::GetTime,
                      &EquationSystem::SetTime)
 
        // Timestep accessors/properties
        .def("GetTimeStep", &EquationSystem::GetTimeStep)
        .def("SetTimeStep", &EquationSystem::SetTimeStep)
        .def_property("timestep", &EquationSystem::GetTimeStep,
                      &EquationSystem::SetTimeStep)
 
        // Steps accessors/properties
        .def("GetSteps", &EquationSystem::GetSteps)
        .def("SetSteps", &EquationSystem::SetSteps)
        .def_property("steps", &EquationSystem::GetSteps,
                      &EquationSystem::SetSteps)
 
        // Print a summary
        .def("PrintSummary", &EquationSystem_PrintSummary)
 
        // Access functions from the session file
        .def("GetFunction", &EquationSystem_GetFunction1)
        .def("GetFunction", &EquationSystem_GetFunction2)
 
        // I/O utility functions
        .def("WriteFld", &EquationSystem_WriteFld)
        .def("Checkpoint_Output", &EquationSystem_Checkpoint_Output)
 
        // Factory functions.
        .def_static("Create", &EquationSystem_Create)
        .def_static("Register", [](std::string &filterName, py::object &obj) {
            fac(filterName, obj, filterName);
        });
}

Referenced by PYBIND11_MODULE().

export_Filter()

void export_Filter

(

py::module &

m

)

Definition at line 158 of file Python/Filter.cpp.

{
    static NekFactory_Register<FilterFactory> fac(GetFilterFactory());
 
    // Wrapper for the Filter class. Note that since Filter contains a pure
    // virtual function, we need the FilterWrap helper class to handle this for
    // us. In the lightweight wrappers above, we therefore need to ensure we're
    // passing std::shared_ptr<Filter> as the first argument, otherwise they
    // won't accept objects constructed from Python.
    py::classh<Filter, FilterWrap>(m, "Filter")
        .def(py::init<LibUtilities::SessionReaderSharedPtr,
                      EquationSystemSharedPtr>())
 
        .def("Initialise", &FilterPublic::v_Initialise)
        .def("Update", &FilterPublic::v_Update)
        .def("Finalise", &FilterPublic::v_Finalise)
        .def("IsTimeDependent", &FilterPublic::v_IsTimeDependent)
 
        // Factory functions.
        .def_static("Create", &Filter_Create)
 
        .def_static("Register", [](std::string &filterName, py::object &obj) {
            fac(filterName, obj, filterName);
        });
}

References Filter_Create(), Nektar::SolverUtils::GetFilterFactory(), Nektar::SolverUtils::Filter::v_Finalise(), Nektar::SolverUtils::Filter::v_Initialise(), Nektar::SolverUtils::Filter::v_IsTimeDependent(), and Nektar::SolverUtils::Filter::v_Update().

Referenced by PYBIND11_MODULE().

export_SessionFunction()

void export_SessionFunction

(

py::module &

m

)

Definition at line 93 of file Python/SessionFunction.cpp.

{
    py::class_<SessionFunction, std::shared_ptr<SessionFunction>>(
        m, "SessionFunction")
        .def(py::init<>(&SessionFunction_Init))
        .def("Describe", &SessionFunction_Describe)
        .def("Evaluate", &SessionFunction_Evaluate)
        .def("Evaluate", &SessionFunction_Evaluate1);
}

References SessionFunction_Describe(), SessionFunction_Evaluate(), SessionFunction_Evaluate1(), and SessionFunction_Init().

Referenced by PYBIND11_MODULE().

export_UnsteadySystem()

void export_UnsteadySystem

(

py::module &

m

)

Definition at line 50 of file Python/UnsteadySystem.cpp.

{
    using USWrap = EquationSystemWrap<UnsteadySystem>;
 
    py::classh<UnsteadySystem, EquationSystem, USWrap>(m, "UnsteadySystem")
 
        .def(py::init<LibUtilities::SessionReaderSharedPtr,
                      SpatialDomains::MeshGraphSharedPtr>())
 
        // Add properties for time integration
        .def_readonly("ode", &PublicUS::m_ode,
                      py::return_value_policy::reference)
        .def_property_readonly("int_scheme",
                               &UnsteadySystem::GetTimeIntegrationScheme,
                               py::return_value_policy::reference_internal);
}

References Nektar::SolverUtils::UnsteadySystem::m_ode.

Referenced by PYBIND11_MODULE().

PYBIND11_MODULE()

PYBIND11_MODULE	(	_SolverUtils	,
		m
	)

Definition at line 42 of file SolverUtils.cpp.

{
    export_EquationSystem(m);
    export_Filter(m);
    export_SessionFunction(m);
    export_UnsteadySystem(m);
}

References export_EquationSystem(), export_Filter(), export_SessionFunction(), and export_UnsteadySystem().