FieldUtils.cpp File Reference

#include <LibUtilities/Python/NekPyConfig.hpp>

Go to the source code of this file.

Functions
void	export_Field ()
void	export_Module ()
	BOOST_PYTHON_MODULE (_FieldUtils)

Function Documentation

BOOST_PYTHON_MODULE()

BOOST_PYTHON_MODULE

(

_FieldUtils

)

Definition at line 40 of file FieldUtils.cpp.

{
    np::initialize();
    export_Field();
    export_Module();
}

References export_Field(), and export_Module().

export_Field()

void export_Field

(

)

Definition at line 221 of file Field.cpp.

{
    py::class_<Field, std::shared_ptr<Field>>("Field", py::no_init)
        .def("__init__",
             py::make_constructor(
                 &Field_Init, py::default_call_policies(),
                 (py::arg("argv") = py::list(), py::arg("nparts") = 0,
                  py::arg("output_points")       = 0,
                  py::arg("output_points_hom_z") = 0, py::arg("error") = false,
                  py::arg("force_output")  = false,
                  py::arg("no_equispaced") = false, py::arg("npz") = 0,
                  py::arg("onlyshape") = "", py::arg("part_only") = 0,
                  py::arg("part_only_overlapping") = 0,
                  py::arg("use_session_variables") = false,
                  py::arg("use_session_expansion") = false,
                  py::arg("verbose") = false, py::arg("domain") = "")))
 
        .def("GetPts", &Field_GetPts)
        .def("SetPts", &Field_SetPts)
        .def("ClearField", &Field::ClearField)
        .def("NewPartition", &NewPartition)
        .def("ReadFieldDefs", &Field::ReadFieldDefs)
 
        .def("SetupFromExpList", Field_SetupFromExpList)
 
        .def_readwrite("graph", &Field::m_graph)
        .def_readwrite("session", &Field::m_session)
        .def_readwrite("verbose", &Field::m_verbose)
        .def_readwrite("comm", &Field::m_comm);
}

References Field_GetPts(), Field_Init(), Field_SetPts(), Field_SetupFromExpList(), and NewPartition().

Referenced by BOOST_PYTHON_MODULE().

export_Module()

void export_Module

(

)

Definition at line 437 of file Python/Module.cpp.

{
    // Export ModuleType enum.
    NEKPY_WRAP_ENUM_STRING(ModuleType, ModuleTypeMap);
 
#ifdef NEKTAR_USING_VTK
    VTK_PYTHON_CONVERSION(vtkUnstructuredGrid);
#endif
 
    // Define ModuleWrap to be implicitly convertible to a Module, since it
    // seems that doesn't sometimes get picked up.
    py::implicitly_convertible<std::shared_ptr<ModuleWrap<Module>>,
                               std::shared_ptr<Module>>();
    py::implicitly_convertible<std::shared_ptr<ModuleWrap<InputModule>>,
                               std::shared_ptr<Module>>();
    py::implicitly_convertible<std::shared_ptr<ModuleWrap<OutputModule>>,
                               std::shared_ptr<Module>>();
    py::implicitly_convertible<std::shared_ptr<ModuleWrap<ProcessModule>>,
                               std::shared_ptr<Module>>();
 
    // Wrapper for the Module class. Note that since Module contains a pure
    // virtual function, we need the ModuleWrap helper class to handle this for
    // us. In the lightweight wrappers above, we therefore need to ensure we're
    // passing std::shared_ptr<Module> as the first argument, otherwise they
    // won't accept objects constructed from Python.
    py::class_<ModuleWrap<Module>, std::shared_ptr<ModuleWrap<Module>>,
               boost::noncopyable>("Module", py::init<FieldSharedPtr>())
 
        // Process function for this module.
        .def("Process", py::pure_virtual(&Module_Process))
        .def("Run", py::pure_virtual(&Module_Process))
 
        // Configuration options.
        .def("RegisterConfig", Module_RegisterConfig,
             (py::arg("key"), py::arg("value") = ""))
        .def("PrintConfig", &Module::PrintConfig)
        .def("SetDefaults", &Module::SetDefaults)
        .def("GetStringConfig", Module_GetConfig<std::string>)
        .def("GetFloatConfig", Module_GetConfig<double>)
        .def("GetIntConfig", Module_GetConfig<int>)
        .def("GetBoolConfig", Module_GetConfig<bool>)
        .def("AddConfigOption", ModuleWrap_AddConfigOption<Module>,
             (py::arg("key"), py::arg("defValue"), py::arg("desc"),
              py::arg("isBool") = false))
        .def("GetVtkGrid", Module_GetVtkGrid,
             py::return_value_policy<py::return_by_value>())
 
        // Allow direct access to field object through a property.
        .def_readwrite("field", &ModuleWrap<Module>::m_f)
 
        // Factory functions.
        .def("Register", &Module_Register)
        .staticmethod("Register");
 
    ModuleWrapConverter<Module>();
 
    PythonModuleClass<InputModule>("InputModule");
    PythonModuleClass<ProcessModule>("ProcessModule");
    PythonModuleClass<OutputModule>("OutputModule");
}

References Module_GetVtkGrid(), Module_Process(), Module_Register(), Module_RegisterConfig(), Nektar::FieldUtils::ModuleTypeMap, NEKPY_WRAP_ENUM_STRING, and VTK_PYTHON_CONVERSION.

Referenced by BOOST_PYTHON_MODULE().