FieldUtils.cpp File Reference

#include <LibUtilities/Python/NekPyConfig.hpp>

Go to the source code of this file.

Functions
void	export_Field (py::module &m)
void	export_Module (py::module &m)
	PYBIND11_MODULE (_FieldUtils, m)

Function Documentation

export_Field()

void export_Field

(

py::module &

m

)

Definition at line 196 of file Field.cpp.

{
    py::class_<Field, std::shared_ptr<Field>>(m, "Field")
        .def(py::init<>(&Field_Init), 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(), and NewPartition().

Referenced by PYBIND11_MODULE().

export_Module()

void export_Module

(

py::module &

m

)

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

{
    static NekFactory_Register<ModuleFactory> fac(GetModuleFactory());
 
    // Export ModuleType enum.
    NEKPY_WRAP_ENUM_STRING(m, ModuleType, ModuleTypeMap);
 
    // 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::classh<Module, ModuleWrap<Module>>(m, "Module")
        .def(py::init<FieldSharedPtr>())
 
        // Process function for this module.
        .def("Process", &Module_Process)
        .def("Run", &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)
 
        // Allow direct access to field object through a property.
        .def_readwrite("field", &ModuleWrap<Module>::m_f)
 
        // Factory functions.
        .def_static("Register", [](ModuleType const &modType,
                                   std::string const &modName,
                                   py::object &obj) {
            ModuleKey key(modType, modName);
            fac(key, obj, std::string(ModuleTypeMap[modType]) + "_" + modName);
        });
 
    PythonModuleClass<InputModule>(m, "InputModule");
    PythonModuleClass<ProcessModule>(m, "ProcessModule");
    PythonModuleClass<OutputModule>(m, "OutputModule");
}

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

Referenced by PYBIND11_MODULE().

PYBIND11_MODULE()

PYBIND11_MODULE	(	_FieldUtils	,
		m
	)

Definition at line 40 of file FieldUtils.cpp.

{
    export_Field(m);
    export_Module(m);
}

References export_Field(), and export_Module().