PyOpalObject.h

Go to the documentation of this file.

//
// Python API for PolynomialCoefficient (part of the multidimensional polynomial fitting routines)
//
// Copyright (c) 2008-2023, Chris Rogers, STFC Rutherford Appleton Laboratory, Didcot, UK
//
// This file is part of OPAL.
//
// OPAL is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// You should have received a copy of the GNU General Public License
// along with OPAL.  If not, see <https://www.gnu.org/licenses/>.
//
 
#ifndef PyOpalObject_H
#define PyOpalObject_H
 
#include <Python.h>
#include <structmember.h>
 
#include <memory>
#include <exception>
#include <iostream>
#include <boost/python.hpp>
#include <boost/noncopyable.hpp>
#include <boost/mpl/front.hpp>
 
#include "Utilities/OpalException.h"
#include "Elements/OpalElement.h"
#include "AbstractObjects/OpalData.h"
#include "AbstractObjects/Object.h"
#include "AbsBeamline/Component.h"
#include "Attributes/Attributes.h"
#include "OpalConfigure/Configure.h"
 
extern Inform *gmsg;
 
namespace PyOpal {
 
namespace PyOpalObjectNS {
 
// forward declarations
template <class C> class PyOpalObject;
template <class C> struct PyOpalObjectGetProperty;
template <class C> struct PyOpalObjectSetProperty;
 
enum AttributeType {STRING, PREDEFINED_STRING, UPPER_CASE_STRING, STRING_LIST,
                    DOUBLE, BOOL, INT, FLOAT_LIST};
 
extern std::map<AttributeType, std::string> attributeName; // defined in PyOpalObject.cpp
 
struct AttributeDef {
    std::string opalName_m;
    std::string pyName_m;
    std::string docString_m;
    AttributeType type_m;
    // could also add a "read only" flag as some attributes are read only
};
 
template <class C>
class PyOpalObject {
public:
    typedef PyOpalObject<C> PyC; // for convenience
    inline PyOpalObject();
    PyOpalObject(std::shared_ptr<C> object) : object_m(object) {}
    PyOpalObject(const PyOpalObject<C>& rhs);
    virtual ~PyOpalObject() = default;
 
    inline boost::python::class_<PyC> make_class(const char* className);
 
    inline boost::python::class_<PyC> make_element_class(const char* className);
 
 
    inline boost::python::class_<PyC> make_generic_class(const char* className);
 
 
    template <class PYCLASS>
    void addAttributes(PYCLASS& pyclass);
 
    template <class PYCLASS>
    void addExecute(PYCLASS& pyclass);
 
    template <class PYCLASS>
    void addRegister(PYCLASS& pyclass);
 
    template <class PYCLASS>
    void addGetOpalName(PYCLASS& pyclass);
 
    template <class PYCLASS>
    void addSetAttributes(PYCLASS& pyclass);
 
    template <class PYCLASS>
    void addSetOpalName(PYCLASS& pyclass);
 
    template <class PYCLASS>
    void addSetOpalElementName(PYCLASS& pyclass);
 
    template <class PYCLASS>
    void addGetOpalElement(PYCLASS& pyclass);
 
    template <class PYCLASS>
    void addGetFieldValue(PYCLASS& pyclass,
                          double distanceUnits, double timeUnits,
                          double bfieldUnits, double efieldUnits);
 
    template <class ValueType>
    ValueType dummyGet() const {PyOpalObjectGetProperty<C>::setObject(this); return ValueType();}
 
    virtual void doSetup() {}
 
    template <class ValueType>
    inline void dummySet(ValueType test);
 
    PyObject* getAttribute(AttributeType type, std::string opalName) const;
 
    void setAttribute(AttributeType type, std::string opalName, PyObject* value);
 
    std::shared_ptr<C> getOpalShared() {return object_m;}
 
    std::shared_ptr<C> getOpalShared() const {return object_m;}
 
 
protected:
    static std::vector<AttributeDef> attributes; 
    static std::map<std::string, AttributeDef> pyNameToAttribute; 
    static std::string classDocstring; 
    static bool converterRegistered; 
    std::shared_ptr<C> object_m; 
    std::string getDocString(AttributeDef& def);
    static boost::python::object getFieldValue(
                    PyOpalObjectNS::PyOpalObject<C>& pyobject,
                    double x, double y, double z, double t);
    static std::string getOpalName(const PyOpalObject<C>& pyobject);
    static void setOpalName(PyOpalObject<C>& pyobject, std::string name);
    static void setOpalElementName(PyOpalObject<C>& pyobject, std::string name);
    static void execute(PyOpalObject<C>& pyobject);
    static void registerObject(PyOpalObject<C>& pyobject);
    static boost::python::object getPyOpalElement(PyOpalObject<C>& pyobject);
    static boost::python::object setAttributes(boost::python::tuple args,
                                               boost::python::dict kwargs);
    // unit definitions for getFieldValue method
    static double distanceUnits_m;
    static double timeUnits_m;
    static double bfieldUnits_m;
    static double efieldUnits_m;
    static const std::string getFieldValueDocString;
};
 
template <class C>
std::map<std::string, AttributeDef> PyOpalObject<C>::pyNameToAttribute;
 
template <class C>
void update(PyOpalObjectNS::PyOpalObject<C> pyelement) {
    std::shared_ptr<C> objectPtr = pyelement.getOpalShared();
    objectPtr->update();
}
 
template <class C>
template <class ValueType>
void PyOpalObject<C>::dummySet(ValueType test) {
    (void)test; // disable Wunused-parameter
    PyOpalObjectSetProperty<C>::setObject(this);
}
 
template <class C>
boost::python::object PyOpalObject<C>::getFieldValue(
            PyOpalObjectNS::PyOpalObject<C>& pyobject, 
            double x, double y, double z, double t) {
    std::shared_ptr<C> objectPtr = pyobject.getOpalShared();
    objectPtr->update();
    pyobject.doSetup();
    ElementBase* element = objectPtr->getElement();
    Component* component = dynamic_cast<Component*>(element);
    if (component == nullptr) {
        throw OpalException("PyElement<C>::getFieldValue",
                            "Failed to deduce Component from ElementBase.");
    }
    Vector_t R(x*distanceUnits_m, y*distanceUnits_m, z*distanceUnits_m);
    Vector_t P(0.0, 0.0, 0.0);
    Vector_t B;
    Vector_t E;
    t *= timeUnits_m;
    bool outOfBounds = component->apply(R, P, t, E, B);
    return boost::python::make_tuple(outOfBounds,
                    B[0]*bfieldUnits_m, B[1]*bfieldUnits_m, B[2]*bfieldUnits_m,
                    E[0]*efieldUnits_m, E[1]*efieldUnits_m, E[2]*efieldUnits_m);
}
 
template <class C>
boost::python::object PyOpalObject<C>::setAttributes(boost::python::tuple args,
                                                     boost::python::dict kwargs) {
    if (boost::python::len(args) == 0) {
        throw OpalException("PyOpalObject::setAttributes",
            "Did not find class instance (i.e. 'self') when calling "
            "set_attributes");
    } else if (boost::python::len(args) > 1) {
        throw OpalException("PyOpalObject::setAttributes",
            "set_attributes cannot take any non-keyword args (except the class"
            " instance");
    }
    PyOpalObject<C> self = boost::python::extract<PyOpalObject<C> >(args[0]);
    boost::python::list key_list = kwargs.keys();
    for (boost::python::ssize_t i = 0; i < boost::python::len(key_list); ++i) {
        boost::python::object key = key_list[i];
        std::string keyStr = boost::python::extract<std::string>(key);
        boost::python::object value = kwargs[key];
        if (PyOpalObject<C>::pyNameToAttribute.find(keyStr) ==
                                    PyOpalObject<C>::pyNameToAttribute.end()) {
            throw OpalException("PyOpalObject::setAttributes",
                                "Did not recognise attribute '"+keyStr+"'");
        }
        AttributeDef att = PyOpalObject<C>::pyNameToAttribute[keyStr];
        self.setAttribute(att.type_m, att.opalName_m, value.ptr());
    }
    boost::python::object obj;
    return obj;
}
 
template <class C>
struct PyOpalObjectGetProperty : boost::python::default_call_policies {
public:
    PyOpalObjectGetProperty(AttributeType type, std::string opalName): type_m(type), opalName_m(opalName) {}
    ~PyOpalObjectGetProperty() {;}
 
    template <class ArgumentPackage>
    PyObject* postcall(ArgumentPackage const&, PyObject* result);
 
    static void setObject(const PyOpalObject<C>* object) {object_m = object;}
 
private:
    AttributeType type_m;
    std::string opalName_m;
    static const PyOpalObject<C>* object_m;
};
 
template <class C>
struct PyOpalObjectSetProperty : boost::python::default_call_policies {
public:
    PyOpalObjectSetProperty(AttributeType type, std::string opalName): type_m(type), opalName_m(opalName) {}
    ~PyOpalObjectSetProperty() {;}
 
    template <class ArgumentPackage>
    PyObject* postcall(ArgumentPackage const& args, PyObject* result);
 
    static void setObject(PyOpalObject<C>* object) {object_m = object;}
 
private:
    AttributeType type_m;
    std::string opalName_m;
    static PyOpalObject<C>* object_m;
};
 
 
 
template <class C>
void PyOpalObject<C>::execute(PyOpalObject<C>& pyobject) {
    std::shared_ptr<C> objectPtr = pyobject.getOpalShared();
    objectPtr->execute();
}
 
template <class C>
void PyOpalObject<C>::registerObject(PyOpalObjectNS::PyOpalObject<C>& pyobject) {
    C* wrappedC = pyobject.getOpalShared().get();
    Object* objectPtr = dynamic_cast<Object*>(wrappedC);
    if (objectPtr == nullptr) {
        throw OpalException("PyOpalObject<C>::registerObject",
                            "Trying to register something that was not a Opal Object");
    }
    //Object* objectPtr = &(*pyobject.getOpalShared());
    OpalData::getInstance()->define(objectPtr);
}
 
template <class C>
std::string PyOpalObject<C>::getOpalName(const PyOpalObject<C>& pyobject) {
    std::shared_ptr<C> objectPtr = pyobject.getOpalShared();
    return objectPtr->getOpalName();
}
 
template <class C>
void PyOpalObject<C>::setOpalName(PyOpalObject<C>& pyobject, std::string name) {
    std::shared_ptr<C> objectPtr = pyobject.getOpalShared();
    objectPtr->setOpalName(name);
}
 
template <class C>
void PyOpalObject<C>::setOpalElementName(PyOpalObject<C>& pyobject, std::string name) {
    std::shared_ptr<C> objectPtr = pyobject.getOpalShared();
    objectPtr->setOpalName(name);
    if (objectPtr->getElement()) { // some OpalThings don't define an Element
        objectPtr->getElement()->setName(name);
    }
}
 
template <class C>
boost::python::object PyOpalObject<C>::getPyOpalElement(PyOpalObjectNS::PyOpalObject<C>& pyobject) {
    std::shared_ptr<OpalElement> elementPtr =
            std::dynamic_pointer_cast<OpalElement, C>(pyobject.getOpalShared());
    if (elementPtr.get() == nullptr) {
        throw OpalException("PyOpalObject<C>::getPyOpalElement",
                            "Wrapped object was not an OpalElement");
    }
    PyOpalObject<OpalElement> element(elementPtr);
    boost::python::object pyelement(element);
    return pyelement;
}
 
 
// defined in PyOpalElement
template <>
PyOpalObject<OpalElement>::PyOpalObject();
 
template <class C>
PyOpalObject<C>::PyOpalObject() : object_m(new C) {}
 
template <class C>
PyObject* PyOpalObject<C>::getAttribute(AttributeType type, std::string opalName) const {
    if (!object_m) {
        throw OpalException("PyOpalObject<C>::getRealAttribute",
                            "Object was not initialised");       
    }
    Attribute* attribute = object_m->findAttribute(opalName);
    if (attribute == nullptr) {
        throw OpalException("PyOpalObject<C>::getRealAttribute",
                            "Failed to parse attribute "+opalName);
    }
    PyObject* pyvalue;
    // I spent quite a bit of time trying to get this type unwinding to work
    // using templates (so it is done at compile time). In the end I couldn't
    // fight the template syntax and had to do it at runtime using an enum; it's
    // not so bad - the memory footprint is smaller and, tbh, template syntax is
    // horrible so might be easier to use.
    switch (type) {
        case DOUBLE: 
        {
            double value = Attributes::getReal(*attribute);
            pyvalue = PyFloat_FromDouble(value);
            break;
        }
        case INT:
        {
            double value = Attributes::getReal(*attribute);
            pyvalue = PyLong_FromDouble(value);
            break;
        }
        case STRING:
        case PREDEFINED_STRING:
        case UPPER_CASE_STRING:
        {
            std::string value = Attributes::getString(*attribute);
            pyvalue = PyUnicode_FromString(value.c_str());
            break;
        }
        case BOOL:
        {
            bool value = Attributes::getBool(*attribute);
            if (value) {
                pyvalue = Py_True;
            } else {
                pyvalue = Py_False;        
            }
            break;
        }
        case FLOAT_LIST:
        {
            std::vector<double> value = Attributes::getRealArray(*attribute);
            pyvalue = PyList_New(value.size());
            for (size_t i = 0; i < value.size(); ++i) {
                PyList_SetItem(pyvalue, i, PyFloat_FromDouble(value[i]));
            }
            break;
        }
        case STRING_LIST:
        {
            std::vector<std::string> value = Attributes::getStringArray(*attribute);
            pyvalue = PyList_New(value.size());
            for (size_t i = 0; i < value.size(); ++i) {
                PyList_SetItem(pyvalue, i, PyUnicode_FromString(value[i].c_str()));
            }
            break;
        }
        default:
        {
            throw OpalException("PyOpalObject<C>::getAttribute",
                            "Attribute type "+attributeName[type]+" not implemented");
        }
    }
    Py_INCREF(pyvalue);
    return pyvalue;
}
 
 
template <class C>
void PyOpalObject<C>::setAttribute(AttributeType type, std::string opalName, PyObject* pyvalue) {
    if (!object_m) {
        throw OpalException("PyOpalObject<C>::setAttribute",
                            "Element was not initialised");
    }
    Attribute* attribute = object_m->findAttribute(opalName);
    if (attribute == nullptr) {
        throw OpalException("PyOpalObject<C>::setAttribute",
                            "Failed to parse attribute "+opalName);
    }
    switch (type) {
        case DOUBLE:
        {
            double value = PyFloat_AsDouble(pyvalue);
            Attributes::setReal(*attribute, value);
            break;
        }
        case INT:
        {
            double value = PyLong_AsDouble(pyvalue);
            Attributes::setReal(*attribute, value);
            break;
        }
        case STRING:
        {
            std::string value = PyUnicode_AsUTF8(pyvalue);
            Attributes::setString(*attribute, value);
            break;
        }
        case PREDEFINED_STRING:
        {
            // predefined string is a string with a list of options
            // note that value checking never happens - method exists in 
            // src/Attributes/PredefinedString.h but requires a Statement object
            // which seems hard to construct (Classic/Parser/Statement.h)
            std::string value = PyUnicode_AsUTF8(pyvalue);
            Attributes::setPredefinedString(*attribute, value);
            break;
        }
        case UPPER_CASE_STRING:
        {
            std::string value = PyUnicode_AsUTF8(pyvalue);
            Attributes::setUpperCaseString(*attribute, value);
            break;
        }
        case BOOL:
        {
            bool value = PyObject_IsTrue(pyvalue);
            Attributes::setBool(*attribute, value);
            break;
        }
        case FLOAT_LIST:
        {
            Py_ssize_t listSize = PyList_Size(pyvalue);
            std::vector<double> value(listSize);
            for (Py_ssize_t i = 0; i < listSize; ++i) {
                double value_i = PyFloat_AsDouble(PyList_GetItem(pyvalue, i));
                value[i] = value_i;
            }
            Attributes::setRealArray(*attribute, value);
            break;
        }
        case STRING_LIST:
        {
            Py_ssize_t listSize = PyList_Size(pyvalue);
            std::vector<std::string> value(listSize);
            for (Py_ssize_t i = 0; i < listSize; ++i) {
                PyObject* pyvalue_i = PyList_GetItem(pyvalue, i);
                std::string value_i = PyUnicode_AsUTF8(pyvalue_i);
                value[i] = value_i;
            }
            Attributes::setStringArray(*attribute, value);
            break;
        }
        default:
        {
            throw OpalException("PyOpalObject<C>::setAttribute",
                                "Attribute type "+attributeName[type]+" not implemented");
        }
    }
}
 
template <class C>
PyOpalObject<C>::PyOpalObject(const PyOpalObject<C>& rhs) : object_m(rhs.object_m) { 
}
 
template <class C>
std::string PyOpalObject<C>::getDocString(AttributeDef& def) {
    Attribute* attribute = object_m->findAttribute(def.opalName_m);
    if (attribute == nullptr) {
        throw OpalException("PyOpalObject<C>::getRealAttribute",
                            "Failed to parse attribute "+def.opalName_m);
    }
    std::string docString = def.pyName_m+" ("+attributeName[def.type_m]+"): "+attribute->getHelp();
    if (def.docString_m != "") {
        docString = def.pyName_m+" ("+attributeName[def.type_m]+"): "+def.docString_m;
    }
    return docString;
}
 
template <class C>
boost::python::class_<PyOpalObject<C> > PyOpalObject<C>::make_generic_class(const char* className) {
    // WARNING - boost::python is bugged so that in module initialisation, 
    // errors are not handled correctly
    //    https://github.com/boostorg/python/issues/280
    // so if you get the attribute name wrong you get a bad error
    // hence I do some local error handling
    typedef boost::python::class_<PyOpalObject<C> > PyClass;
    boost::python::docstring_options docop(true, true, false); // user_def, py_sig, cpp_sig
    PyClass pyclass = PyClass(className);
    try {
        addAttributes(pyclass);
        addGetOpalName(pyclass);
        addSetAttributes(pyclass);
    } catch (OpalException& exc) {
        std::cerr << "Failed to initialise class because '" << exc.what() 
                  << "'" << std::endl;
        throw exc;
    } catch (std::exception& exc) {
        std::cerr << "Failed to initialise class because '" << exc.what() 
                  << "'" << std::endl;
        throw exc;
    }
    if (gmsg == nullptr) {
        std::cerr <<
            "Failed to initialise class because gmsg was not initialised.\n"
            "PyOpal::Globals::Initialise() must be called before attempting to\n"
            "initialise classes" << std::endl;
        throw OpalException("PyOpalObject::make_generic_class",
                            "Globals not initialised");
    }
    return pyclass;
}
 
template <class C>
boost::python::class_<PyOpalObject<C> > PyOpalObject<C>::make_class(const char* className) {
    auto pyclass = make_generic_class(className);
    addSetOpalName(pyclass);
    return pyclass;
}
 
template <class C>
boost::python::class_<PyOpalObject<C> > PyOpalObject<C>::make_element_class(const char* className) {
    auto pyclass = make_generic_class(className);
    addSetOpalElementName(pyclass);
    addGetOpalElement(pyclass);
    return pyclass;
}
 
template <class C>
template <class PYCLASS>
void PyOpalObject<C>::addExecute(PYCLASS& pyclass) {
    pyclass.def("execute", &PyOpalObject<C>::execute);
}
 
template <class C>
template <class PYCLASS>
void PyOpalObject<C>::addRegister(PYCLASS& pyclass) {
    pyclass.def("register", &PyOpalObject<C>::registerObject);
}
 
template <class C>
template <class PYCLASS>
void PyOpalObject<C>::addGetOpalName(PYCLASS& pyclass) {
    pyclass.def("get_opal_name", &PyOpalObject<C>::getOpalName);
}
 
template <class C>
template <class PYCLASS>
void PyOpalObject<C>::addSetAttributes(PYCLASS& pyclass) {
    pyclass.def("set_attributes",
                boost::python::raw_function(&PyOpalObject<C>::setAttributes, 0)
                );
}
 
template <class C>
template <class PYCLASS>
void PyOpalObject<C>::addSetOpalName(PYCLASS& pyclass) {
    pyclass.def("set_opal_name", &PyOpalObject<C>::setOpalName);
}
 
template <class C>
template <class PYCLASS>
void PyOpalObject<C>::addSetOpalElementName(PYCLASS& pyclass) {
    pyclass.def("set_opal_name", &PyOpalObject<C>::setOpalElementName);
}
 
template <class C>
template <class PYCLASS>
void PyOpalObject<C>::addGetOpalElement(PYCLASS& pyclass) {
    pyclass.def("get_opal_element", &PyOpalObject<C>::getPyOpalElement);
}
 
template <class C>
template <class PYCLASS>
void PyOpalObject<C>::addGetFieldValue(PYCLASS& pyclass,
                                      double distanceUnits, double timeUnits,
                                      double efieldUnits, double bfieldUnits) {
    distanceUnits_m = distanceUnits;
    timeUnits_m = timeUnits;
    bfieldUnits_m = bfieldUnits;
    efieldUnits_m = efieldUnits;
    pyclass.def("get_field_value",
                &PyOpalObject<C>::getFieldValue,
                boost::python::args("x", "y", "z", "t"),
                getFieldValueDocString.c_str());
}
 
template <class C>
template <class PYCLASS>
void PyOpalObject<C>::addAttributes(PYCLASS& pyclass) {
    for (std::vector<AttributeDef>::iterator iter = attributes.begin(); iter != attributes.end(); ++iter) {
        pyNameToAttribute[iter->pyName_m] = *iter;
        PyOpalObjectGetProperty<C> getProp(iter->type_m, iter->opalName_m);
        PyOpalObjectSetProperty<C> setProp(iter->type_m, iter->opalName_m);
        std::string docString = getDocString(*iter);
        std::string pyname = iter->pyName_m.c_str();
        switch (iter->type_m) {
            case DOUBLE:
            {
                pyclass.add_property(pyname.c_str(),
                                     boost::python::make_function(&PyC::dummyGet<double>, getProp),
                                     boost::python::make_function(&PyC::dummySet<double>, setProp),
                                     docString.c_str()
                );
                break;
            }
            case INT:
            {
                pyclass.add_property(pyname.c_str(),
                                     boost::python::make_function(&PyC::dummyGet<int>, getProp),
                                     boost::python::make_function(&PyC::dummySet<int>, setProp),
                                     docString.c_str()
                );
                break;
            }
            case STRING:
            case PREDEFINED_STRING:
            case UPPER_CASE_STRING:
            {
                pyclass.add_property(pyname.c_str(),
                                     boost::python::make_function(&PyC::dummyGet<std::string>, getProp),
                                     boost::python::make_function(&PyC::dummySet<std::string>, setProp),
                                     docString.c_str()
                );
                break;
            }
            case BOOL:
            {
                pyclass.add_property(pyname.c_str(),
                                     boost::python::make_function(&PyC::dummyGet<bool>, getProp),
                                     boost::python::make_function(&PyC::dummySet<bool>, setProp),
                                     docString.c_str()
                );
                break;
            }
            case FLOAT_LIST:
            case STRING_LIST:
            {
                pyclass.add_property(pyname.c_str(),
                                     boost::python::make_function(&PyC::dummyGet<boost::python::list>, getProp),
                                     boost::python::make_function(&PyC::dummySet<boost::python::list>, setProp),
                                     docString.c_str()
                );
                break;
            } 
            default:
            {
                // Looks like exception handling doesn't work properly at module
                // import time so this may not be handled politely - thrown as an 
                // unrecognised SystemError
                throw OpalException("PyOpalObject<C>::addAttributes", "Type not implemented");
            }
        }
    }
}
 
template <class C> double PyOpalObject<C>::distanceUnits_m = 1;
template <class C> double PyOpalObject<C>::timeUnits_m = 1;
template <class C> double PyOpalObject<C>::bfieldUnits_m = 1;
template <class C> double PyOpalObject<C>::efieldUnits_m = 1;
 
template <class C>  const std::string PyOpalObject<C>::getFieldValueDocString =
  "Get the field value at a point in the field map.\n"
  "\n"
  "The field lookup is performed against the last RINGDEFINITION that was\n"
  "instantiated. This should be instantiated by calling\n"
  "pyopal.parser.initialise_from_opal_file\n"
  "\n"
  "Parameters\n"
  "----------\n"
  "x : float\n"
  "    x position [m]\n"
  "y : float\n"
  "    y position [m]\n"
  "z : float\n"
  "    z position [m]\n"
  "t: float\n"
  "    time [ns]\n"
  "\n"
  "Returns\n"
  "-------\n"
  "The function returns a tuple containing 7 values:\n"
  "out of bounds : int\n"
  "    1 if the event was out of the field map boundary, else 0.\n"
  "Bx : float\n"
  "    x magnetic field [T]\n"
  "By : float\n"
  "    y magnetic field [T]\n"
  "Bz : float\n"
  "    z magnetic field [T]\n"
  "Ex : float\n"
  "    x electric field [MV/m]\n"
  "Ey : float\n"
  "    y electric field [MV/m]\n"
  "Ez : float\n"
  "    z electric field [MV/m]\n";
 
 
 
template <class C>
template <class ArgumentPackage>
PyObject* PyOpalObjectGetProperty<C>::postcall(ArgumentPackage const&, PyObject* result) {
        Py_DECREF(result);
        result = object_m->getAttribute(type_m, opalName_m);
        return result;
}
 
template <class C>
const PyOpalObject<C>* PyOpalObjectGetProperty<C>::object_m = nullptr;
 
 
template <class C>
template <class ArgumentPackage>
PyObject* PyOpalObjectSetProperty<C>::postcall(ArgumentPackage const& args, PyObject* result) {
    PyObject* value;
    PyObject* pyObject; // this is a direct pointer to the C but I don't know how to unwrap it...
    if (!PyArg_ParseTuple(args, "OO", &pyObject, &value)) {
        return nullptr; // ParseTuple sets the error message
    }
    Py_DECREF(result);
    object_m->setAttribute(type_m, opalName_m, value);
    object_m = nullptr;
    Py_RETURN_NONE;
}
 
template <class C>
PyOpalObject<C>* PyOpalObjectSetProperty<C>::object_m = nullptr;
 
} // PyOpalObject
} // PyOpal
 
#endif // PyOpalObject_H