GyotoPython.h

Go to the documentation of this file.

/*
    Copyright 2015-2016, 2022 Thibaut Paumard

    This file is part of Gyoto.

    Gyoto 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.

    Gyoto is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Gyoto.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef __GyotoPython_H_ 
#define __GyotoPython_H_ 
#include <GyotoSpectrum.h>
#include <GyotoMetric.h>
#include <GyotoStandardAstrobj.h>
#include <GyotoThinDisk.h>
#include <GyotoProperty.h>
#include <GyotoValue.h>
#include <GyotoScreen.h>
#include <GyotoFactoryMessenger.h>
#include <Python.h>

namespace Gyoto {
  namespace Python {
    class GILGuard;
    class Base;
    template <class O> class Object;
    PyObject * PyObject_FromGyotoValue(const Gyoto::Value&);

    PyObject * PyInstance_GetMethod(PyObject* pInstance, const char *name);

    PyObject * PyImport_Gyoto();

    void PyInstance_SetThis(PyObject * pInstance,
                            PyObject * pNew,
                            void * ptr);

    bool PyCallable_HasVarArg(PyObject * pMethod);

    PyObject * PyModule_NewFromPythonCode(const char * code);

    PyObject * pGyotoMetric() ;
    PyObject * pGyotoScreen() ;
    PyObject * pGyotoAstrobj() ;
    PyObject * pGyotoSpectrum() ;
    PyObject * pGyotoSpectrometer() ;
    PyObject * pGyotoStandardAstrobj() ;
    PyObject * pGyotoThinDisk() ;
  }
  namespace Spectrum {
    class Python;
  }
  namespace Metric {
    class Python;
  }
  namespace Astrobj {
    namespace Python {
      class Standard;
      class ThinDisk;
    }
  }
}

class Gyoto::Python::GILGuard {
public:
  GILGuard();


  ~GILGuard();

  void track(PyObject*& obj);

  // Delete copy constructor and assignment operator to prevent misuse
  GILGuard(const GILGuard&) = delete;
  GILGuard& operator=(const GILGuard&) = delete;

private:
  PyGILState_STATE gstate_;
  std::vector<PyObject**> tracked_objects_;
};

class Gyoto::Python::Base {
 protected:
  std::string module_;

  std::string inline_module_;

  std::string class_;

  std::vector<double> parameters_;

  PyObject * pModule_;

  PyObject * pInstance_;

  PyObject * pProperties_;

  PyObject * pSet_;

  PyObject * pGet_;

 public:
  Base();
  Base(const Base&);
  ~Base();

  virtual std::string module() const ; 
  virtual std::string inlineModule() const ; 

  virtual void module(const std::string&);

  virtual void inlineModule(const std::string&);

  virtual void instance(PyObject * pinstance);

  virtual std::string klass() const ;

  virtual void klass(const std::string& c);

  virtual std::vector<double> parameters() const;
  virtual void parameters(const std::vector<double>&);

  virtual bool hasPythonProperty(std::string const &key) const ;
  virtual void setPythonProperty(std::string const &key, Value val);
  virtual void setPythonProperty(std::string const &key, Value val, std::string const &unit);
  virtual Value getPythonProperty(std::string const &key) const;
  virtual Value getPythonProperty(std::string const &key, std::string const &unit) const;
  virtual Gyoto::Property::type_e pythonPropertyType(std::string const &key) const;


  /* Helper methods */

  void checkModuleForSingleClass();

  virtual void detachInstance();


  virtual void attachInstance(PyObject *instance);


  PyObject * instantiateClass(std::string &klass) const;

};

template <class O>
class Gyoto::Python::Object
  : public O, public Gyoto::Python::Base
{
public:
  Object() : O(), Gyoto::Python::Base() {}
  Object(const Object& o) : O(o), Base(o) {}
  virtual ~Object() {};

  using O::set;

  virtual bool knowsProperty(const std::string &name) const {
    return (O::property(name) || hasPythonProperty(name));
  }

  virtual void set(std::string const &key, Value val) {
    GYOTO_DEBUG_EXPR(key);
    GYOTO_DEBUG_EXPR(val.type);
    if (hasPythonProperty(key)) {
      GYOTO_DEBUG << "Python key " << key << " exists" << std::endl;
      setPythonProperty(key, val);
    } else {
      GYOTO_DEBUG << "Python key " << key << " does not exist" << std::endl;
      O::set(key, val);
    }
  }

  virtual void set(std::string const &key, Value val, std::string const &unit) {
    GYOTO_DEBUG_EXPR(key);
    GYOTO_DEBUG_EXPR(val.type);
    if (hasPythonProperty(key)) {
      GYOTO_DEBUG << "Python key " << key << " exists" << std::endl;
      setPythonProperty(key, val, unit);
    } else {
      GYOTO_DEBUG << "Python key " << key << " does not exist" << std::endl;
      O::set(key, val, unit);
    }
  }

  virtual void set(Property const &p, Value val){
    std::string key=p.name;
    GYOTO_DEBUG_EXPR(key);
    if (!hasPythonProperty(key)) {
      GYOTO_DEBUG << "calling Generic::set" << std::endl;
      O::set(p, val);
      return;
    }
    setPythonProperty(key, val);
  }

  virtual void set(Property const &p, Value val, std::string const &unit) {
    GYOTO_DEBUG_EXPR(p.name);
    if (hasPythonProperty(p.name)) {
      GYOTO_DEBUG << "Python key " << p.name << " exists" << std::endl;
      if (unit!="") GYOTO_ERROR("units not implemented");
      setPythonProperty(p.name, val);
    } else {
      GYOTO_DEBUG << "Python key " << p.name << " does not exist" << std::endl;
      O::set(p, val, unit);
    }
  }

  using O::get;

  virtual Value get(std::string const &key) const {
    GYOTO_DEBUG_EXPR(key);
    if (!hasPythonProperty(key)) {
      GYOTO_DEBUG << "calling Generic::get" << std::endl;
      return O::get(key);
    }
    return getPythonProperty(key);
  }

  virtual Value get(std::string const &key, std::string const &unit) const {
    GYOTO_DEBUG_EXPR(key);
    if (!hasPythonProperty(key)) {
      GYOTO_DEBUG << "calling Generic::get" << std::endl;
      return O::get(key, unit);
    }
    return getPythonProperty(key, unit);
  }

  Value get(Property const &p,
            std::string const &unit) const {
    if (!hasPythonProperty(p.name)) {
      GYOTO_DEBUG << "calling Generic::get" << std::endl;
      return O::get(p, unit);
    }
    return getPythonProperty(p.name);
  }

  Value get(Property const &p) const {
    if (!hasPythonProperty(p.name)) {
      GYOTO_DEBUG << "calling Generic::get" << std::endl;
      return O::get(p);
    }
    return getPythonProperty(p.name);
  }

  using O::setParameter;

  virtual int setParameter(std::string name, std::string content, std::string unit) {
    GYOTO_DEBUG_EXPR(name);
    GYOTO_DEBUG_EXPR(content);
    GYOTO_DEBUG_EXPR(unit);
    if (hasPythonProperty(name)) {
      Property p(NULL);
      p.name=name;
      p.type=pythonPropertyType(name);
      GYOTO_DEBUG << "Calling setParameter(p, name, content, unit)" << std::endl;
      setParameter(p, name, content, unit);
      return 0;
    }
    return O::setParameter(name, content, unit);
  }


  virtual void fillProperty(Gyoto::FactoryMessenger *fmp,
                            Property const &p) const {
    if ((p.name == "Instance") ||
        (p.name == "Module" && module_=="") ||
        (p.name == "InlineModule" && inline_module_=="")) {
      GYOTO_DEBUG << "skipping " << p.name << std::endl;
      return;
    } else O::fillProperty(fmp, p);
  }

  virtual void fillElement(Gyoto::FactoryMessenger *fmp) const {
    GYOTO_DEBUG << "filling C++ properties" << std::endl;
    O::fillElement(fmp);
    GYOTO_DEBUG << "filling Python properties" << std::endl;
    if (pProperties_) {
      Py_ssize_t pos=0;
      PyObject *pKey, *pVal;
      while (PyDict_Next(pProperties_, &pos, &pKey, &pVal)) {
        if (!PyUnicode_Check(pKey)) GYOTO_ERROR("key is not a UNICODE string");
        std::string key=PyUnicode_AsUTF8(pKey);
        if (PyDict_Check(pVal)) pVal=PyDict_GetItemString(pVal, "type");
        if (!pVal) GYOTO_ERROR("could not get type for property "+key);
        if (!PyUnicode_Check(pVal)) GYOTO_ERROR("type is not a UNICODE string");
        std::string stype=PyUnicode_AsUTF8(pVal);
        GYOTO_DEBUG << "creating XML element for Python property "
                    << key << " of type " << stype << std::endl;
        Property::type_e type = Property::typeFromString(stype);
        const Property p (key, type);
        this->fillProperty(fmp, p);
      }
    }
  }

  void setParameters(Gyoto::FactoryMessenger *fmp)  {
    std::string name="", content="", unit="";
    FactoryMessenger * child = NULL;
    if (fmp) {
      // add xml file directory to sys.path
      std::string xmldir = fmp->fullPath("");
      if (xmldir.size()) {
        GYOTO_DEBUG << "adding '"+xmldir+"' to sys.path" << std::endl;
        // retrieve sys.path
        PyObject* sysPath = PySys_GetObject("path");
        if (!sysPath) {
          PyErr_Print();
          return;
        }
        // create Python variable around xmldir variable
        PyObject* pyPath = PyUnicode_FromString(xmldir.c_str());
        // check whether xmldir is already in sys.path
        Py_ssize_t pathSize = PyList_Size(sysPath);
        bool found = false;
        for (Py_ssize_t i = 0; i < pathSize; ++i) {
          PyObject* item = PyList_GetItem(sysPath, i);
          if (PyUnicode_Compare(item, pyPath) == 0) {
            found = true;
            break;
          }
          // if not, prepend it
          if (!found) {
            PyList_Insert(sysPath, 0, pyPath);
          }
          // clean memory
          Py_DECREF(pyPath);
        }
      }
      // loop on parameters
      while (fmp->getNextParameter(&name, &content, &unit)) {
        GYOTO_DEBUG << "Setting '" << name << "' to '" << content
                    << "' (unit='"<<unit<<"')" << std::endl;
        const Property * prop =NULL;
        bool need_delete= false;
        if (hasPythonProperty(name)) {
          need_delete=true;
          prop = new Property(name, pythonPropertyType(name));
        } else {
          need_delete=false;
          prop = this->property(name);
        }
        if (!prop) {;
          GYOTO_DEBUG << "'" << name << "' not found, calling setParameter()"
                      << std::endl;
          // The specific setParameter() implementation may well know
          // this entity
          setParameter(name, content, unit);
        } else {
          GYOTO_DEBUG << "'" << name << "' found "<< std::endl;
          std::vector<std::string> plugins;
          switch (prop->type) {
          case Property::metric_t:
            set(*prop, fmp->metric());
            break;
          case Property::astrobj_t:
            set(*prop, fmp->astrobj());
            break;
          case Property::screen_t:
            set(*prop, fmp->screen());
            break;
          case Property::spectrum_t:
            content = fmp -> getAttribute("kind");
            child = fmp -> getChild();
            plugins = Gyoto::split(fmp -> getAttribute("plugin"), ",");
            set(*prop, (*Spectrum::getSubcontractor(content, plugins))(child, plugins) );
            delete child;
            break;
          case Property::spectrometer_t:
            content = fmp -> getAttribute("kind");
            child = fmp -> getChild();
            plugins = Gyoto::split(fmp -> getAttribute("plugin"), ",");
            set(*prop, (*Spectrometer::getSubcontractor(content, plugins))(child, plugins) );
            delete child;
            break;
          case Property::filename_t:
            content = fmp->fullPath(content);
            [[fallthrough]]; // no 'break;' here, we need to proceed
          default:
            setParameter(*prop, name, content, unit);
            break;
          }
        }
        if (need_delete) delete prop;
      }
    }
    GYOTO_DEBUG << "Done processing parameters" << std::endl;
  }
};

class Gyoto::Spectrum::Python
  : public Gyoto::Python::Object<Gyoto::Spectrum::Generic>
{
  friend class Gyoto::SmartPointer<Gyoto::Spectrum::Python>;
 protected:

  PyObject * pCall_;

  PyObject * pIntegrate_;

  bool pCall_overloaded_;

 public:
  GYOTO_OBJECT;
  GYOTO_OBJECT_THREAD_SAFETY;

  Python();

  Python(const Python&);

  virtual Python * clone() const;

  ~Python();

  // For some reason we need to implement the bunch although only one
  // is non-trivial
  virtual std::string module() const ;
  virtual void module(const std::string&);
  virtual std::string inlineModule() const ;
  virtual void inlineModule(const std::string&);
  virtual std::string klass() const ;
  virtual void klass(const std::string&);
  using Gyoto::Python::Base::instance;


  virtual size_t instance() const ;
  virtual void instance(size_t address);
  virtual void detachInstance();
  virtual void attachInstance(PyObject *instance);
  virtual std::vector<double> parameters() const;
  virtual void parameters(const std::vector<double>&);

  virtual double operator()(double nu) const;
  virtual double operator()(double nu, double opacity, double ds) const;

  virtual double integrate(double nu1, double nu2) ;

};


class Gyoto::Metric::Python
  : public Gyoto::Python::Object<Gyoto::Metric::Generic>
{
  friend class Gyoto::SmartPointer<Gyoto::Metric::Python>;

 private:
  // Variables to cache Python objects:
  PyObject * pGmunu_;

  PyObject * pChristoffel_;

  PyObject * pGetRmb_;

  PyObject * pGetRms_;

  PyObject * pGetSpecificAngularMomentum_;

  PyObject * pGetPotential_;

  PyObject * pIsStopCondition_;

  PyObject * pCircularVelocity_;

 public:
  GYOTO_OBJECT;
  GYOTO_OBJECT_THREAD_SAFETY;
  Python();
  Python(const Python&);
  ~Python();
  virtual Python* clone() const ;

  // Accessors for the Gyoto::Property members:
  // Those are mere wrappers arround Generic::coordKind(), useful for
  // declaring a boolen property using the macro GYOTO_PROPERTY_BOOL:
  void spherical(bool);
  bool spherical() const;
  virtual std::string module() const ;
  virtual void module(const std::string&);
  virtual std::string inlineModule() const ;
  virtual void inlineModule(const std::string&);
  virtual std::string klass() const ;
  virtual void klass(const std::string&);
  using Gyoto::Python::Base::instance;


  virtual size_t instance() const ;
  virtual void instance(size_t address);
  virtual void detachInstance();
  virtual void attachInstance(PyObject *instance);
  virtual std::vector<double> parameters() const;
  virtual void parameters(const std::vector<double>&);
  using Gyoto::Metric::Generic::mass;
  virtual void mass(double m);

  // The minimal Gyoto::Metric API:
  void gmunu(double g[4][4], const double * x) const ;
  int christoffel(double dst[4][4][4], const double * x) const ;

  // Little more
  double getRmb() const;
  double getRms() const;
  double getSpecificAngularMomentum(double rr) const;
  double getPotential(double const pos[4], double l_cst) const;
  int isStopCondition(double const coord[8]) const;
  void circularVelocity(double const pos[4], double vel[4],
                        double dir=1.) const ;

};

class Gyoto::Astrobj::Python::Standard
  : public Gyoto::Python::Object<Gyoto::Astrobj::Standard>
{
  friend class Gyoto::SmartPointer<Gyoto::Astrobj::Python::Standard>;

 private:
  PyObject *pEmission_, *pIntegrateEmission_, *pTransmission_, *pCall_,
    *pGetVelocity_, *pGiveDelta_;
  bool pEmission_overloaded_, pIntegrateEmission_overloaded_;

 public:
  GYOTO_OBJECT;
  GYOTO_OBJECT_THREAD_SAFETY;

  /* Birth and Death*/
  Standard();
  Standard(const Standard&);
  ~Standard();
  Standard* clone() const;

  /* Astrobj::Generic API */
  virtual double emission(double nu_em, double dsem, state_t const &coord_ph,
                          double const coord_obj[8]=NULL) const ;

  virtual void emission(double Inu[], double const nu_em[], size_t nbnu,
                        double dsem, state_t const &coord_ph,
                        double const coord_obj[8]=NULL) const ;

  virtual double integrateEmission(double nu1, double nu2, double dsem,
                                   state_t const &c_ph, double const c_obj[8]=NULL) const;

  virtual void integrateEmission(double * I, double const * boundaries,
                                 size_t const * chaninds, size_t nbnu,
                                 double dsem, state_t const &cph, double const *co) const;

  virtual double transmission(double nuem, double dsem, state_t const &cph, double const *co) const ;

  /* Astrobj::Standard API */
  virtual double operator()(double const coord[4]) ;
  virtual void getVelocity(double const pos[4], double vel[4]) ;
  virtual double giveDelta(double coord[8]);

  /* Python::Base */
  virtual std::string module() const ;
  virtual void module(const std::string&);
  virtual std::string inlineModule() const ;
  virtual void inlineModule(const std::string&);
  virtual std::string klass() const ;
  virtual void klass(const std::string& c);
  using Gyoto::Python::Base::instance;


  virtual size_t instance() const ;
  virtual void instance(size_t address);
  virtual void detachInstance();
  virtual void attachInstance(PyObject *instance);
  virtual std::vector<double> parameters() const;
  virtual void parameters(const std::vector<double>&);
  virtual double criticalValue() const ;
  virtual void criticalValue(double) ;

};

class Gyoto::Astrobj::Python::ThinDisk
  : public Gyoto::Python::Object<Gyoto::Astrobj::ThinDisk>
{
  friend class Gyoto::SmartPointer<Gyoto::Astrobj::Python::ThinDisk>;

 private:
  PyObject *pEmission_, *pIntegrateEmission_, *pTransmission_, *pCall_,
    *pGetVelocity_, *pGiveDelta_;
  bool pEmission_overloaded_, pIntegrateEmission_overloaded_;

 public:
  GYOTO_OBJECT;
  GYOTO_OBJECT_THREAD_SAFETY;

  /* Birth and Death*/
  ThinDisk();
  ThinDisk(const ThinDisk&);
  ~ThinDisk();
  ThinDisk* clone() const;

  /* Astrobj::Generic API */
  virtual double emission(double nu_em, double dsem, state_t const &coord_ph,
                          double const coord_obj[8]=NULL) const ;

  virtual void emission(double Inu[], double const nu_em[], size_t nbnu,
                        double dsem, state_t const &coord_ph,
                        double const coord_obj[8]=NULL) const ;

  virtual double integrateEmission(double nu1, double nu2, double dsem,
                                   state_t const &c_ph, double const c_obj[8]=NULL) const;

  virtual void integrateEmission(double * I, double const * boundaries,
                                 size_t const * chaninds, size_t nbnu,
                                 double dsem, state_t const &cph, double const *co) const;

  virtual double transmission(double nuem, double dsem, state_t const &cph ,double const *co) const ;

  /* Astrobj::ThinDisk API */
  virtual double operator()(double const coord[4]) ;
  virtual void getVelocity(double const pos[4], double vel[4]) ;

  /* Python::Base */
  virtual std::string module() const ;
  virtual void module(const std::string&);
  virtual std::string inlineModule() const ;
  virtual void inlineModule(const std::string&);
  virtual std::string klass() const ;
  virtual void klass(const std::string&);
  using Gyoto::Python::Base::instance;


  virtual size_t instance() const ;
  virtual void instance(size_t address);
  virtual void detachInstance();
  virtual void attachInstance(PyObject *instance);
  virtual std::vector<double> parameters() const;
  virtual void parameters(const std::vector<double>&);

};


#endif