Python/Filter.cpp File Reference

#include <LibUtilities/Python/BasicUtils/NekFactory.hpp>
#include <LibUtilities/Python/BasicUtils/SharedArray.hpp>
#include <LibUtilities/Python/NekPyConfig.hpp>
#include <MultiRegions/ContField.h>
#include <SolverUtils/Filters/Filter.h>

Go to the source code of this file.

Classes
struct	FilterWrap
	Filter wrapper to handle virtual function calls in Filter and its subclasses. More...
struct	FilterPublic

Functions
FilterSharedPtr	Filter_Create (py::args args, const py::kwargs &kwargs)
	Lightweight wrapper for Filter factory creation function. More...
void	export_Filter (py::module &m)

Function Documentation

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

Filter_Create()

FilterSharedPtr Filter_Create	(	py::args	args,
		const py::kwargs &	kwargs
	)

Lightweight wrapper for Filter factory creation function.

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

{
    using NekError = ErrorUtil::NekError;
 
    if (py::len(args) != 3)
    {
        throw NekError("Filter.Create() requires three arguments: "
                       "filter name, a SessionReader object and an "
                       "EquationSystem object.");
    }
 
    std::string filterName = py::cast<std::string>(args[0]);
 
    LibUtilities::SessionReaderSharedPtr session;
    EquationSystemSharedPtr eqsys;
 
    try
    {
        session = py::cast<LibUtilities::SessionReaderSharedPtr>(args[1]);
    }
    catch (...)
    {
        throw NekError("Second argument to Create() should be a SessionReader "
                       "object.");
    }
 
    try
    {
        eqsys = py::cast<EquationSystemSharedPtr>(args[2]);
    }
    catch (...)
    {
        throw NekError("Second argument to Create() should be a EquationSystem "
                       "object.");
    }
 
    // Process keyword arguments.
    Filter::ParamMap params;
 
    for (auto &kwarg : kwargs)
    {
        std::string arg = py::cast<std::string>(kwarg.first);
        std::string val = py::cast<std::string>(py::str(kwarg.second));
        params[arg]     = val;
    }
 
    std::shared_ptr<Filter> filter =
        GetFilterFactory().CreateInstance(filterName, session, eqsys, params);
 
    return filter;
}

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

Referenced by export_Filter().