SolverUtils.cpp File Reference

#include <LibUtilities/Python/NekPyConfig.hpp>

Go to the source code of this file.

Functions
void	export_EquationSystem ()
void	export_Filter ()
void	export_SessionFunction ()
void	export_UnsteadySystem ()
	BOOST_PYTHON_MODULE (_SolverUtils)

Function Documentation

BOOST_PYTHON_MODULE()

BOOST_PYTHON_MODULE

(

_SolverUtils

)

Definition at line 42 of file SolverUtils.cpp.

{
    np::initialize();
 
    export_EquationSystem();
    export_Filter();
    export_SessionFunction();
    export_UnsteadySystem();
}

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

export_EquationSystem()

void export_EquationSystem

(

)

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

{
    using EqSysWrap = EquationSystemWrap<EquationSystem>;
 
    static NekFactory_Register<EquationSystemFactory> fac(
        GetEquationSystemFactory());
 
    py::class_<EqSysWrap, std::shared_ptr<EqSysWrap>, boost::noncopyable>(
        "EquationSystem", py::init<LibUtilities::SessionReaderSharedPtr,
                                   SpatialDomains::MeshGraphSharedPtr>())
 
        // Virtual functions that can be optionally overridden
        .def("InitObject", &EquationSystem::InitObject,
             &EqSysWrap::Default_v_InitObject)
        .def("DoInitialise", &EquationSystem::DoInitialise,
             &EqSysWrap::Default_v_DoInitialise)
        .def("DoSolve", &EquationSystem::DoSolve, &EqSysWrap::Default_v_DoSolve)
        .def("SetInitialConditions", &EquationSystem::SetInitialConditions,
             &EqSysWrap::Default_v_SetInitialConditions)
        .def("EvaluateExactSolution", &EqSysWrap::v_EvaluateExactSolution,
             &EqSysWrap::Default_v_EvaluateExactSolution)
        .def("LinfError", &EqSysWrap::v_LinfError,
             &EqSysWrap::Default_v_LinfError)
        .def("L2Error", &EqSysWrap::v_L2Error, &EqSysWrap::Default_v_L2Error)
 
        // Fields accessors (read-only)
        .def("GetFields", &EquationSystem_GetFields)
        .add_property("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)
        .add_property("time", &EquationSystem::GetTime,
                      &EquationSystem::SetTime)
 
        // Timestep accessors/properties
        .def("GetTimeStep", &EquationSystem::GetTimeStep)
        .def("SetTimeStep", &EquationSystem::SetTimeStep)
        .add_property("timestep", &EquationSystem::GetTimeStep,
                      &EquationSystem::SetTimeStep)
 
        // Steps accessors/properties
        .def("GetSteps", &EquationSystem::GetSteps)
        .def("SetSteps", &EquationSystem::SetSteps)
        .add_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("Create", &EquationSystem_Create)
        .staticmethod("Create")
        .def("Register", [](std::string const &filterName,
                            py::object &obj) { fac(filterName, obj); })
        .staticmethod("Register");
 
    WrapConverter<EquationSystem>();
}

Referenced by BOOST_PYTHON_MODULE().

export_Filter()

void export_Filter

(

)

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

{
    static NekFactory_Register<FilterFactory> fac(GetFilterFactory());
 
    // Define FilterWrap to be implicitly convertible to a Filter, since it
    // seems that doesn't sometimes get picked up.
    py::implicitly_convertible<std::shared_ptr<FilterWrap>,
                               std::shared_ptr<Filter>>();
 
    // 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::class_<FilterWrap, std::shared_ptr<FilterWrap>, boost::noncopyable>(
        "Filter", py::init<LibUtilities::SessionReaderSharedPtr,
                           EquationSystemSharedPtr>())
 
        .def("Initialise", &Filter_Initialise)
        .def("Update", &Filter_Update)
        .def("Finalise", &Filter_Finalise)
        .def("IsTimeDependent", &Filter_IsTimeDependent)
 
        // Factory functions.
        .def("Create", py::raw_function(Filter_Create))
        .staticmethod("Create")
        .def("Register", [](std::string const &filterName,
                            py::object &obj) { fac(filterName, obj); })
        .staticmethod("Register");
 
    WrapConverter<Filter>();
}

References Filter_Create(), Filter_Finalise(), Filter_Initialise(), Filter_IsTimeDependent(), Filter_Update(), and Nektar::SolverUtils::GetFilterFactory().

Referenced by BOOST_PYTHON_MODULE().

export_SessionFunction()

void export_SessionFunction

(

)

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

{
    py::class_<SessionFunction, std::shared_ptr<SessionFunction>,
               boost::noncopyable>("SessionFunction", py::no_init)
        .def("__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 BOOST_PYTHON_MODULE().

export_UnsteadySystem()

void export_UnsteadySystem

(

)

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

{
    using USWrap = EquationSystemWrap<UnsteadySystem>;
 
    py::class_<USWrap, std::shared_ptr<USWrap>, py::bases<EquationSystem>,
               boost::noncopyable>(
        "UnsteadySystem", py::init<LibUtilities::SessionReaderSharedPtr,
                                   SpatialDomains::MeshGraphSharedPtr>())
 
        // Add overrides for this class
        .def("InitObject", &EquationSystem::InitObject,
             &USWrap::Default_v_InitObject)
        .def("DoInitialise", &EquationSystem::DoInitialise,
             &USWrap::Default_v_DoInitialise)
        .def("DoSolve", &EquationSystem::DoSolve, &USWrap::Default_v_DoSolve)
        .def("SetInitialConditions", &EquationSystem::SetInitialConditions,
             &USWrap::Default_v_SetInitialConditions)
        .def("EvaluateExactSolution", &USWrap::v_EvaluateExactSolution,
             &USWrap::Default_v_EvaluateExactSolution)
        .def("LinfError", &USWrap::v_LinfError, &USWrap::Default_v_LinfError)
        .def("L2Error", &USWrap::v_L2Error, &USWrap::Default_v_L2Error)
 
        // Add properties for time integration
        .add_property(
            "ode",
            py::make_function(
                &UnsteadySystem::GetTimeIntegrationSchemeOperators,
                py::return_value_policy<py::reference_existing_object>()))
        .add_property(
            "int_scheme",
            py::make_function(
                &UnsteadySystem::GetTimeIntegrationScheme,
                py::return_value_policy<py::reference_existing_object>()));
 
    WrapConverter<UnsteadySystem>();
}

Referenced by BOOST_PYTHON_MODULE().