Python/Filter.cpp File Reference

#include <LibUtilities/Python/BasicUtils/NekFactory.hpp>
#include <LibUtilities/Python/NekPyConfig.hpp>
#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...

Functions
FilterSharedPtr	Filter_Create (py::tuple args, py::dict kwargs)
	Lightweight wrapper for Filter factory creation function. More...
void	Filter_Initialise (std::shared_ptr< Filter > filter, Array< OneD, MultiRegions::ExpListSharedPtr > expLists, NekDouble time)
void	Filter_Update (std::shared_ptr< Filter > filter, Array< OneD, MultiRegions::ExpListSharedPtr > expLists, NekDouble time)
void	Filter_Finalise (std::shared_ptr< Filter > filter, Array< OneD, MultiRegions::ExpListSharedPtr > expLists, NekDouble time)
bool	Filter_IsTimeDependent (std::shared_ptr< Filter > filter)
void	export_Filter ()

Function Documentation

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

Filter_Create()

FilterSharedPtr Filter_Create	(	py::tuple	args,
		py::dict	kwargs
	)

Lightweight wrapper for Filter factory creation function.

Definition at line 103 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::extract<std::string>(args[0]);
 
    if (!py::extract<LibUtilities::SessionReaderSharedPtr>(args[1]).check())
    {
        throw NekError("Second argument to Create() should be a SessionReader "
                       "object.");
    }
 
    if (!py::extract<EquationSystemSharedPtr>(args[2]).check())
    {
        throw NekError("Second argument to Create() should be a EquationSystem "
                       "object.");
    }
 
    LibUtilities::SessionReaderSharedPtr session =
        py::extract<LibUtilities::SessionReaderSharedPtr>(args[1]);
    EquationSystemSharedPtr eqn = py::extract<EquationSystemSharedPtr>(args[2]);
 
    // Process keyword arguments.
    py::list items = kwargs.items();
    Filter::ParamMap params;
 
    for (int i = 0; i < py::len(items); ++i)
    {
        std::string arg = py::extract<std::string>(items[i][0]);
        std::string val =
            py::extract<std::string>(items[i][1].attr("__str__")());
        params[arg] = val;
    }
 
    std::shared_ptr<Filter> filter =
        GetFilterFactory().CreateInstance(filterName, session, eqn, params);
 
    return filter;
}

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

Referenced by export_Filter().

Filter_Finalise()

void Filter_Finalise	(	std::shared_ptr< Filter >	filter,
		Array< OneD, MultiRegions::ExpListSharedPtr >	expLists,
		NekDouble	time
	)

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

{
    filter->Finalise(expLists, time);
}

Referenced by export_Filter().

Filter_Initialise()

void Filter_Initialise	(	std::shared_ptr< Filter >	filter,
		Array< OneD, MultiRegions::ExpListSharedPtr >	expLists,
		NekDouble	time
	)

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

{
    filter->Initialise(expLists, time);
}

Referenced by export_Filter().

Filter_IsTimeDependent()

bool Filter_IsTimeDependent

(

std::shared_ptr< Filter >

filter

)

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

{
    return filter->IsTimeDependent();
}

Referenced by export_Filter().

Filter_Update()

void Filter_Update	(	std::shared_ptr< Filter >	filter,
		Array< OneD, MultiRegions::ExpListSharedPtr >	expLists,
		NekDouble	time
	)

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

{
    filter->Update(expLists, time);
}

Referenced by export_Filter().