Python_Proc.cpp

Go to the documentation of this file.

#include <vector>
#include <map>
#include <list>

#include "TH1D.h"

#include "ProcDataBase.h"
#include "Processus.h"
//#include "Plot.h"
#include "Data.h"
#include "Histo1D.h"
#include "Histo2D.h"

#include "TestSuite.h"

#include <boost/python.hpp>
#include <boost/python/suite/indexing/vector_indexing_suite.hpp>

using namespace boost::python;

struct ProcessusWrap : Processus, wrapper<Processus>
{
  StatusCode initialize() {return this->get_override("initialize")();};
  StatusCode execute()    {return this->get_override("execute")();};
  StatusCode finalize()   {return this->get_override("finalize")();};
  Processus* clone()      {return this->get_override("clone")();};
};

void export_proc()
{
  class_< std::vector<Processus*> >("ProcessusPtrVec")
    .def(vector_indexing_suite< std::vector<Processus*> >())
    ;

  std::vector<Processus*> (ProcDataBase::*listElement)(Element*) = (&ProcDataBase::list);
  std::vector<Processus*> (ProcDataBase::*listFull)( )        = (&ProcDataBase::list);

  //  class_<ProcDataBase>("ProcDb")
  //    .def("list", listElement)
  //    .def("list", listFull   )
  //   ;

  class_< std::vector<Histo1D*> >("Histo1DPtrVec")
    .def(vector_indexing_suite< std::vector<Histo1D*> >())
    ;

  class_< std::vector<double> >("DoubleVec")
    .def(vector_indexing_suite< std::vector<double> >())
    ;

  class_<Histo1D, bases<Object> >("Histo1D", init<TH1D*>())
    .def("bins",&Histo1D::bins)
    .def("xbins",&Histo1D::centers)
    .def("edges",&Histo1D::edges)
    .def("minX",&Histo1D::minX)
    .def("maxX",&Histo1D::maxX)
    .def("minY",&Histo1D::minY)
    .def("maxY",&Histo1D::maxY)
    .def("nbins",&Histo1D::nBin)
    .def("overflow",&Histo1D::overflow)
    .def("underflow",&Histo1D::underflow)
    //    .def("overflow",&Histo1D::overflow)
    ;

  class_< std::vector< std::pair < unsigned int , Histo1D* > > >("PairIntHisto1DVec")
    .def(vector_indexing_suite< std::vector< std::pair < unsigned int , Histo1D* > > >())
    ;
  /*
  class_< std::vector< std::vector<double> > > ("VecVecDouble")
    .def(vector_indexing_suite< std::vector< std::vector < double > > >())
    ;
  */
  class_<Histo2D, bases<Object> >("Histo2D", init<TH2D*>())
    .def("bins",&Histo2D::bins)
    .def("xbins",&Histo2D::xbins)
    .def("ybins",&Histo2D::ybins)
    .def("minX",&Histo2D::minX)
    .def("maxX",&Histo2D::maxX)
    .def("minY",&Histo2D::minY)
    .def("maxY",&Histo2D::maxY)
    .def("minY",&Histo2D::minZ)
    .def("maxY",&Histo2D::maxZ)
    .def("nxbins",&Histo2D::nxbins)
    .def("nybins",&Histo2D::nybins)
    /*
    .def("overflow",&Histo1D::overflow)
    .def("underflow",&Histo1D::underflow)
    */
    ;
  /*
  class_<Plot, bases<Object> >("Plot")
    .def("histos", &Plot::histos)
    .def("histo1d",&Plot::histo1d)
    .def("format", &Plot::format)
    .def("pos",    &Plot::pos)
    .def("make",   &Plot::make)
    .def("draw",   &Plot::draw)
    ;
  */
  std::vector<double> (Data::*vectorx0)(unsigned int)  = (&Data::vector);
  std::vector<double> (Data::*vectorx1)(std::string)   = (&Data::vector);

  Histo1D* (Data::*hist1dx0)(unsigned int)  = (&Data::hist1d);
  Histo1D* (Data::*hist1dx1)(std::string)   = (&Data::hist1d);
  Histo2D* (Data::*hist2dx0)(unsigned int)  = (&Data::hist2d);
  Histo2D* (Data::*hist2dx1)(std::string)   = (&Data::hist2d);

  class_<Data, bases<Object> >("Data")
    .def("name",  &Data::name)
    .def("title", &Data::title)
    .def("vector",vectorx0)
    .def("vector",vectorx1)
    .def("info",   &Data::print)
    .def("hist1d",hist1dx0,return_value_policy<reference_existing_object>())
    .def("hist1d",hist1dx1,return_value_policy<reference_existing_object>())
    .def("hist2d",hist2dx0,return_value_policy<reference_existing_object>())
    .def("hist2d",hist2dx1,return_value_policy<reference_existing_object>())
    ;
  
  Data* (Processus::*datax0)                   ()              = (&Processus::data);
  std::vector<double> (Processus::*datax1)     (std::string)   = (&Processus::data);
  std::vector<double> (Processus::*datax2)     (unsigned int)  = (&Processus::data);

  Histo1D* (Processus::*datax3)                (unsigned int)  = (&Processus::hist1d);
  Histo2D* (Processus::*datax4)                (unsigned int)  = (&Processus::hist2d);

  class_<ProcessusWrap, boost::noncopyable, bases<Object> >("Processus")
    .def("initialize",pure_virtual(&Processus::initialize))
    .def("execute",pure_virtual(&Processus::execute))
    .def("finalize",pure_virtual(&Processus::finalize))
    .def("startProcessing",&Processus::startProcessing)
    .def("endProcessing",&Processus::endProcessing)
    .def("setStorage",&Processus::setStorage)
    .def("storage",&Processus::storage)
    .def("setElement",&Processus::setElement)
    .def("element",&Processus::element,return_value_policy<reference_existing_object>())
    .def("data",datax0,return_value_policy<reference_existing_object>())
    .def("data",datax1)
    .def("data",datax2)
    .def("hist1d",datax3,return_value_policy<reference_existing_object>())
    .def("hist2d",datax4,return_value_policy<reference_existing_object>())
    ;

  class_<TestSuite, bases<Processus> > ("TestSuite")
    .def("setSigma", &TestSuite::setSigma) 
    .def("sigma",    &TestSuite::sigma) 
    ;  
}