Python/Module.cpp File Reference

#include <FieldUtils/Module.h>
#include <LibUtilities/Python/BasicUtils/NekFactory.hpp>
#include <LibUtilities/Python/BasicUtils/SharedArray.hpp>
#include <LibUtilities/Python/NekPyConfig.hpp>
#include <boost/program_options.hpp>

Go to the source code of this file.

Classes
struct	ModuleWrap< MODTYPE >
	Module wrapper to handle virtual function calls in Module and its subclasses as defined by the template parameter. More...
struct	ModulePublic< MODTYPE >
struct	ModuleTypeProxy< MODTYPE >
struct	ModuleTypeProxy< InputModule >
struct	ModuleTypeProxy< ProcessModule >
struct	ModuleTypeProxy< OutputModule >
struct	PythonModuleClass< MODTYPE >

Functions
void	Module_Process (ModuleSharedPtr m)
template<typename T >
T	Module_GetConfig (std::shared_ptr< Module > mod, const std::string &key)
void	Module_GetVtkGrid (std::shared_ptr< Module > mod)
template<typename MODTYPE >
ModuleSharedPtr	Module_Create (py::args args, const py::kwargs &kwargs)
	Lightweight wrapper for Module factory creation function. More...
void	Module_RegisterConfig (std::shared_ptr< Module > mod, std::string const &key, std::string const &value)
	Lightweight wrapper for FieldUtils::Module::RegisterConfig. More...
template<typename MODTYPE >
void	ModuleWrap_AddConfigOption (std::shared_ptr< ModuleWrap< MODTYPE > > mod, std::string const &key, std::string const &defValue, std::string const &desc, bool isBool)
void	export_Module (py::module &m)

Function Documentation

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

Module_Create()

template<typename MODTYPE >

ModuleSharedPtr Module_Create	(	py::args	args,
		const py::kwargs &	kwargs
	)

Lightweight wrapper for Module factory creation function.

Parameters

modType	Module type (input/process/output).
modName	Module name (typically filename extension).
field	Field that will be passed between modules.

Template Parameters

MODTYPE

Subclass of Module (e.g #InputModule, #OutputModule)

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

{
    ModuleType modType = ModuleTypeProxy<MODTYPE>::value;
 
    using NekError = ErrorUtil::NekError;
 
    if (modType == eProcessModule && py::len(args) != 2)
    {
        throw NekError("ProcessModule.Create() requires two arguments: "
                       "module name and a Field object.");
    }
    else if (modType != eProcessModule && py::len(args) < 2)
    {
        throw NekError(ModuleTypeMap[modType] +
                       "Module.Create() requires "
                       "two arguments: module name and a Field object; "
                       "optionally a filename.");
    }
 
    std::string modName = py::str(args[0]);
    ModuleKey modKey    = std::make_pair(modType, modName);
 
    FieldSharedPtr field;
 
    try
    {
        field = py::cast<FieldSharedPtr>(args[1]);
    }
    catch (...)
    {
        throw NekError("Second argument to Create() should be a Field object.");
    }
 
    if (!GetModuleFactory().ModuleExists(modKey))
    {
        throw ErrorUtil::NekError("Module '" + modName + "' does not exist.");
    }
 
    ModuleSharedPtr mod = GetModuleFactory().CreateInstance(modKey, field);
 
    if (modType == eInputModule)
    {
        // For input modules we can try to interpret the remaining arguments as
        // input files. Assume that the file's type is identical to the module
        // name.
        for (int i = 2; i < py::len(args); ++i)
        {
            std::string in_fname = py::str(args[i]);
            mod->RegisterConfig("infile", in_fname);
            mod->AddFile(modName, in_fname);
        }
    }
    else if (modType == eOutputModule && py::len(args) >= 3)
    {
        // For output modules we can try to interpret the remaining argument as
        // an output file.
        mod->RegisterConfig("outfile", py::str(args[2]));
    }
 
    // Process keyword arguments.
    for (auto &kv : kwargs)
    {
        std::string arg = py::str(kv.first);
 
        if (arg == "infile" && modKey.first == eInputModule)
        {
            if (!py::isinstance<py::dict>(kv.second))
            {
                throw NekError("infile should be a dictionary.");
            }
 
            py::dict ftype_fname_dict = py::cast<py::dict>(kv.second);
 
            for (auto &kv2 : ftype_fname_dict)
            {
                std::string f_type = py::str(kv2.first);
                std::string f_name = py::str(kv2.second);
                mod->RegisterConfig(arg, f_name);
                mod->AddFile(f_type, f_name);
            }
        }
        else
        {
            std::string val = py::str(kv.second);
            mod->RegisterConfig(arg, val);
        }
    }
 
    mod->SetDefaults();
 
    return mod;
}

References Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::CreateInstance(), Nektar::FieldUtils::eInputModule, Nektar::FieldUtils::eOutputModule, Nektar::FieldUtils::eProcessModule, FilterPython_Function::field, Nektar::FieldUtils::GetModuleFactory(), and Nektar::FieldUtils::ModuleTypeMap.

Module_GetConfig()

template<typename T >

T Module_GetConfig	(	std::shared_ptr< Module >	mod,
		const std::string &	key
	)

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

{
    return mod->GetConfigOption(key).as<T>();
}

Module_GetVtkGrid()

void Module_GetVtkGrid

(

std::shared_ptr< Module >

mod

)

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

{
    using NekError = ErrorUtil::NekError;
    throw NekError("Nektar++ has not been compiled with VTK support.");
}

Referenced by export_Module().

Module_Process()

void Module_Process

(

ModuleSharedPtr

m

)

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

{
    if (m->m_f->m_nParts > 1)
    {
        if (m->GetModulePriority() == eOutput)
        {
            m->m_f->m_comm = m->m_f->m_partComm;
            if (m->GetModuleName() != "OutputInfo")
            {
                m->RegisterConfig("writemultiplefiles");
            }
        }
        else if (m->GetModulePriority() == eCreateGraph)
        {
            m->m_f->m_comm = m->m_f->m_partComm;
        }
        else
        {
            m->m_f->m_comm = m->m_f->m_defComm;
        }
    }
    m->SetDefaults();
    m->Process(m->m_f->m_vm);
}

References Nektar::FieldUtils::eCreateGraph, and Nektar::FieldUtils::eOutput.

Referenced by export_Module().

Module_RegisterConfig()

void Module_RegisterConfig	(	std::shared_ptr< Module >	mod,
		std::string const &	key,
		std::string const &	value
	)

Lightweight wrapper for FieldUtils::Module::RegisterConfig.

Parameters

mod	Module to call
key	Configuration key.
value	Optional value (some configuration options are boolean).

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

{
    mod->RegisterConfig(key, value);
}

Referenced by export_Module().

ModuleWrap_AddConfigOption()

template<typename MODTYPE >

void ModuleWrap_AddConfigOption	(	std::shared_ptr< ModuleWrap< MODTYPE > >	mod,
		std::string const &	key,
		std::string const &	defValue,
		std::string const &	desc,
		bool	isBool
	)

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

{
    mod->AddConfigOption(key, defValue, desc, isBool);
}