Python/EquationSystem.cpp File Reference

#include <LibUtilities/Python/BasicUtils/NekFactory.hpp>
#include <LibUtilities/Python/NekPyConfig.hpp>
#include <SolverUtils/EquationSystem.h>
#include <SolverUtils/Python/EquationSystem.h>

Go to the source code of this file.

Classes
class	DummyEquationSystem
	Dummy equation system that can be used for Python testing. More...

Functions
EquationSystemSharedPtr	EquationSystem_Create (std::string eqnSysName, LibUtilities::SessionReaderSharedPtr session, SpatialDomains::MeshGraphSharedPtr mesh)
Array< OneD, MultiRegions::ExpListSharedPtr >	EquationSystem_GetFields (EquationSystemSharedPtr eqSys)
void	EquationSystem_PrintSummary (EquationSystemSharedPtr eqSys)
std::shared_ptr< SessionFunction >	EquationSystem_GetFunction1 (EquationSystemSharedPtr eqSys, std::string name)
std::shared_ptr< SessionFunction >	EquationSystem_GetFunction2 (EquationSystemSharedPtr eqSys, std::string name, MultiRegions::ExpListSharedPtr field)
void	EquationSystem_WriteFld (EquationSystemSharedPtr eqSys, std::string name)
void	EquationSystem_Checkpoint_Output (EquationSystemSharedPtr eqSys, int n)
void	export_EquationSystem ()

Function Documentation

EquationSystem_Checkpoint_Output()

void EquationSystem_Checkpoint_Output	(	EquationSystemSharedPtr	eqSys,
		int	n
	)

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

{
    eqSys->Checkpoint_Output(n);
}

EquationSystem_Create()

EquationSystemSharedPtr EquationSystem_Create	(	std::string	eqnSysName,
		LibUtilities::SessionReaderSharedPtr	session,
		SpatialDomains::MeshGraphSharedPtr	mesh
	)

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

{
    EquationSystemSharedPtr ret =
        GetEquationSystemFactory().CreateInstance(eqnSysName, session, mesh);
    return ret;
}

References Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::CreateInstance(), and Nektar::SolverUtils::GetEquationSystemFactory().

EquationSystem_GetFields()

Array< OneD, MultiRegions::ExpListSharedPtr > EquationSystem_GetFields

(

EquationSystemSharedPtr

eqSys

)

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

{
    return eqSys->UpdateFields();
}

EquationSystem_GetFunction1()

std::shared_ptr< SessionFunction > EquationSystem_GetFunction1	(	EquationSystemSharedPtr	eqSys,
		std::string	name
	)

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

{
    return eqSys->GetFunction(name);
}

References CellMLToNektar.pycml::name.

EquationSystem_GetFunction2()

std::shared_ptr< SessionFunction > EquationSystem_GetFunction2	(	EquationSystemSharedPtr	eqSys,
		std::string	name,
		MultiRegions::ExpListSharedPtr	field
	)

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

{
    return eqSys->GetFunction(name, field);
}

References FilterPython_Function::field, and CellMLToNektar.pycml::name.

EquationSystem_PrintSummary()

void EquationSystem_PrintSummary

(

EquationSystemSharedPtr

eqSys

)

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

{
    eqSys->PrintSummary(std::cout);
}

EquationSystem_WriteFld()

void EquationSystem_WriteFld	(	EquationSystemSharedPtr	eqSys,
		std::string	name
	)

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

{
    eqSys->WriteFld(name);
}

References CellMLToNektar.pycml::name.

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().