PyElement.h

Go to the documentation of this file.

#ifndef PyElement_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"
 
namespace PyOpal {
 
namespace PyElementNS {
 
// forward declarations
template <class C> class PyElement;
template <class C> struct PyElementGetProperty;
template <class C> struct PyElementSetProperty;
 
enum AttributeType {DOUBLE, STRING, BOOL, INT};
 
extern std::map<AttributeType, std::string> attributeName; // defined in PyElement.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 PyElement {
public:
    typedef PyElement<C> PyC; // for convenience
    inline PyElement();
    PyElement(std::shared_ptr<C> element) : element_m(element) {}
    PyElement(const PyElement<C>& rhs);
    ~PyElement() {}
 
    boost::python::class_<PyC> make_class(const char* className);
 
    void addAttributes(boost::python::class_<PyC>& pyclass);
 
 
    template <class ValueType>
    ValueType dummyGet() const {PyElementGetProperty<C>::setElement(this); return 0;}
 
    template <class ValueType>
    void dummySet(ValueType test) {PyElementSetProperty<C>::setElement(this);}
 
    PyObject* getAttribute(AttributeType type, std::string opalName) const;
 
    void setAttribute(AttributeType type, std::string opalName, PyObject* value);
 
    boost::python::object getFieldValue(double x, double y, double z, double t) const;
 
    boost::python::object getPyOpalElement();
 
    OpalElement* getOpalElement();
 
    C* getElement() {return element_m.get();}
 
protected:
    static std::vector<AttributeDef> attributes; 
    static std::string classDocstring; 
    static bool converterRegistered; 
    static bool hasGetFieldValue; 
    std::shared_ptr<C> element_m; 
    std::string getDocString(AttributeDef& def);
};
 
template <class C>
struct PyElementGetProperty : boost::python::default_call_policies {
public:
    PyElementGetProperty(AttributeType type, std::string opalName): type_m(type), opalName_m(opalName) {}
    ~PyElementGetProperty() {;}
 
    template <class ArgumentPackage>
    PyObject* postcall(ArgumentPackage const&, PyObject* result);
 
    static void setElement(const PyElement<C>* element) {element_m = element;}
 
private:
    AttributeType type_m;
    std::string opalName_m;
    static const PyElement<C>* element_m;
};
 
template <class C>
struct PyElementSetProperty : boost::python::default_call_policies {
public:
    PyElementSetProperty(AttributeType type, std::string opalName): type_m(type), opalName_m(opalName) {}
    ~PyElementSetProperty() {;}
 
    template <class ArgumentPackage>
    PyObject* postcall(ArgumentPackage const& args, PyObject* result);
 
    static void setElement(PyElement<C>* element) {element_m = element;}
 
private:
    AttributeType type_m;
    std::string opalName_m;
    static PyElement<C>* element_m;
};
 
 
// defined in PyOpalElement
template <>
PyElement<OpalElement>::PyElement();
 
template <class C>
PyElement<C>::PyElement() : element_m(new C) {}
 
template <class C>
bool PyElement<C>::converterRegistered = false;
 
template <class C>
boost::python::object PyElement<C>::getFieldValue(double x, double y, double z, double t) const {
    Vector_t R(x, y, z);
    Vector_t P(0.0, 0.0, 0.0);
    Vector_t B;
    Vector_t E;
    element_m->update();
    ElementBase* element = element_m->getElement()->removeWrappers();
    Component* component = dynamic_cast<Component*>(element);
    if (component == NULL) {
        throw OpalException("PyElement<C>::getFieldValue",
                            "Failed to deduce Component from ElementBase.");
    }
    bool outOfBounds = component->apply(R, P, t, E, B);
    return boost::python::make_tuple(outOfBounds,
                                     B[0], B[1], B[2],
                                     E[0], E[1], E[2]);
}
 
template <class C>
PyObject* PyElement<C>::getAttribute(AttributeType type, std::string opalName) const {
    if (!element_m) {
        throw OpalException("PyElement<C>::getRealAttribute",
                            "Element was not initialised");       
    }
    Attribute* attribute = element_m->findAttribute(opalName);
    if (attribute == NULL) {
        throw OpalException("PyElement<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.
    if (type == DOUBLE) {
        double value = Attributes::getReal(*attribute);
        pyvalue = PyFloat_FromDouble(value);
    } else if (type == INT) {
        double value = Attributes::getReal(*attribute);
        pyvalue = PyLong_FromDouble(value);
    }
    Py_INCREF(pyvalue);
    return pyvalue;
}
 
 
template <class C>
void PyElement<C>::setAttribute(AttributeType type, std::string opalName, PyObject* pyvalue) {
    if (!element_m) {
        throw OpalException("PyElement<C>::getRealAttribute",
                            "Element was not initialised");       
    }
    Attribute* attribute = element_m->findAttribute(opalName);
    if (attribute == NULL) {
        throw OpalException("PyElement<C>::getRealAttribute",
                            "Failed to parse attribute "+opalName);
    }
    if (type == DOUBLE) {
        double value = PyFloat_AsDouble(pyvalue);
        Attributes::setReal(*attribute, value);
    } else if (type == INT) {
        double value = PyLong_AsDouble(pyvalue);
        Attributes::setReal(*attribute, value);
    }
    return;
}
 
template <class C>
PyElement<C>::PyElement(const PyElement<C>& rhs) : element_m(rhs.element_m) { 
}
 
template <class C>
std::string PyElement<C>::getDocString(AttributeDef& def) {
    Attribute* attribute = element_m->findAttribute(def.opalName_m);
    if (attribute == NULL) {
        throw OpalException("PyElement<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_<PyElement<C> > PyElement<C>::make_class(const char* className) {
    boost::python::docstring_options docop(true, true, false); // user_def, py_sig, cpp_sig
    auto pyclass = boost::python::class_<PyC>(className);
    addAttributes(pyclass);
    return pyclass;
}
 
template <class C>
void PyElement<C>::addAttributes(boost::python::class_<PyElement<C> >& pyclass) {
    for (std::vector<AttributeDef>::iterator iter = attributes.begin(); iter != attributes.end(); ++iter) {
        PyElementGetProperty<C> getProp(iter->type_m, iter->opalName_m);
        PyElementSetProperty<C> setProp(iter->type_m, iter->opalName_m);
        std::string docString = getDocString(*iter);
        std::string pyname = iter->pyName_m.c_str();
        if (iter->type_m == 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()
            );
        } else if (iter->type_m == 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()
            );
        }
    }
    pyclass.def("get_opal_element", &PyC::getPyOpalElement);
    if (hasGetFieldValue) {
        pyclass.def("get_field_value", &PyC::getFieldValue);
    }
}
 
 
template <class C>
OpalElement* PyElement<C>::getOpalElement() {
    OpalElement* element = dynamic_cast<OpalElement*>(element_m.get());
    if (element == NULL) {
        throw OpalException("PyElement<C>::getOpalElement",
                            "Failed to cast to OpalElement");
    }
    return element;
}
 
template <class C>
boost::python::object PyElement<C>::getPyOpalElement() {
    std::shared_ptr<OpalElement> elementPtr = std::dynamic_pointer_cast<OpalElement, C>(element_m);
    if (elementPtr.get() == NULL) {
        throw OpalException("PyElement<C>::getPyOpalElement", "Wrapped object was not an OpalElement");
    }
    PyElement<OpalElement> element(elementPtr);
    boost::python::object pyelement(element);
    return pyelement;
}
 
 
template <class C>
template <class ArgumentPackage>
PyObject* PyElementGetProperty<C>::postcall(ArgumentPackage const&, PyObject* result) {
        Py_DECREF(result);
        result = element_m->getAttribute(DOUBLE, opalName_m);
        return result;
}
 
template <class C>
const PyElement<C>* PyElementGetProperty<C>::element_m = NULL;
 
 
template <class C>
template <class ArgumentPackage>
PyObject* PyElementSetProperty<C>::postcall(ArgumentPackage const& args, PyObject* result) {
    PyObject* value;
    PyObject* pyElement; // this is a direct pointer to the C but I don't know how to unwrap it...
    if (!PyArg_ParseTuple(args, "OO", &pyElement, &value)) {
        return NULL; // ParseTuple sets the error message
    }
    Py_DECREF(result);
    element_m->setAttribute(DOUBLE, opalName_m, value);
    element_m = NULL;
    Py_RETURN_NONE;
}
 
template <class C>
PyElement<C>* PyElementSetProperty<C>::element_m = NULL;
 
} // PyElementNS
} // PyOpal
 
#endif // PyElement_H