Python_Proc.cpp File Reference

#include <vector>
#include <map>
#include <list>
#include "TH1D.h"
#include "ProcDataBase.h"
#include "Processus.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>

Go to the source code of this file.

Classes
struct	ProcessusWrap

Functions
void	export_proc ()

Function Documentation

export_proc()

void export_proc

(

)

Definition at line 29 of file Python_Proc.cpp.

References Histo1D::bins(), Histo2D::bins(), Histo1D::centers(), Processus::data(), Histo1D::edges(), Processus::element(), Processus::endProcessing(), Processus::execute(), Processus::finalize(), Data::hist1d(), Processus::hist1d(), Data::hist2d(), Processus::hist2d(), Processus::initialize(), ProcDataBase::list(), Histo2D::maxX(), Histo1D::maxX(), Histo1D::maxY(), Histo2D::maxY(), Histo2D::maxZ(), Histo2D::minX(), Histo1D::minX(), Histo1D::minY(), Histo2D::minY(), Histo2D::minZ(), Object::name(), Histo1D::nBin(), Histo2D::nxbins(), Histo2D::nybins(), Histo1D::overflow(), Data::print(), Processus::setElement(), TestSuite::setSigma(), Processus::setStorage(), TestSuite::sigma(), Processus::startProcessing(), Processus::storage(), Object::title(), Histo1D::underflow(), Data::vector(), Histo2D::xbins(), and Histo2D::ybins().

Referenced by BOOST_PYTHON_MODULE().

{
  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) 
    ;  
}