Python.cpp File Reference

#include <vector>
#include <map>
#include <list>
#include <boost/python/class.hpp>
#include <boost/python/module.hpp>
#include <boost/python/def.hpp>

Go to the source code of this file.

Functions
void	export_base ()
void	export_obj ()
void	export_proc ()
	BOOST_PYTHON_MODULE (libCatKernel)

Function Documentation

BOOST_PYTHON_MODULE()

BOOST_PYTHON_MODULE

(

libCatKernel

)

Definition at line 40 of file Python.cpp.

References export_base(), export_obj(), and export_proc().

{
  export_base();
  export_obj();
  export_proc();
}

export_base()

void export_base

(

)

Definition at line 17 of file Python_Base.cpp.

References DLLMgr::createElement(), DLLMgr::createProcessus(), Options::currentPath(), Options::dataFile(), Options::dataFileFullName(), Options::dataStorage(), MsgSvc::DEBUG, Options::defFile(), DLLMgr::destroy(), DLLMgr::dll(), DLLMgr::dlls(), MsgSvc::ERR, StatusCode::FAILURE, MsgSvc::FATAL, Options::incNErrors(), Options::incNEvt(), Options::incRunNumber(), MsgSvc::INFO, StatusCode::isFailure(), StatusCode::isSuccess(), DLLMgr::libraryOfObject(), ProcDataBase::list(), DLLMgr::load(), Options::logDefFile(), Options::logFile(), Options::logOutputLevel(), Options::logStorage(), MsgSvc::msgSvc(), Options::nErrors(), Options::nEvt(), Options::nEvtMax(), MsgSvc::NONE, Options::plotFreq(), DLLMgr::print(), DLL::print(), Options::print(), Options::printFreq(), Options::runNumber(), Options::runNumberManagement(), MsgSvc::setCallSize(), Options::setCurrentPath(), Options::setDataStorage(), Options::setDefFile(), MsgSvc::setLineLength(), Options::setLogDefFile(), Options::setLogOutputLevel(), Options::setLogStorage(), Options::setNErrors(), Options::setNEvt(), Options::setNEvtMax(), Options::setPlotFreq(), Options::setPrintFreq(), Options::setRunNumber(), Options::setRunNumberManagement(), Options::setStopOnError(), Options::setStorageDir(), Options::setStorageFile(), Options::setStoragePath(), Options::setStream(), Options::stopOnError(), Options::storageDir(), Options::storageFile(), Options::storageFileFullName(), Options::storageFullPath(), Options::storagePath(), StatusCode::SUCCESS, DLLMgr::unload(), MsgSvc::VERBOSE, and MsgSvc::WARNING.

Referenced by BOOST_PYTHON_MODULE().

{
  enum_<MsgSvc::MsgLevel>("MsgLevel")
    .value("VERBOSE", MsgSvc::VERBOSE)
    .value("DEBUG",   MsgSvc::DEBUG)
    .value("INFO",    MsgSvc::INFO)
    .value("WARNING", MsgSvc::WARNING)
    .value("ERROR",   MsgSvc::ERR)
    .value("FATAL",   MsgSvc::FATAL)
    .value("NONE",    MsgSvc::NONE)
    ;
  
  class_<MsgSvc>("MsgSvc")
    .def("msgSvc",&MsgSvc::msgSvc)
    .def("setLineLength",&MsgSvc::setLineLength)
    .def("setCallSize",&MsgSvc::setCallSize)
    ;
  
  enum_<StatusCode::Type>("Code")
    .value("FAILURE",StatusCode::FAILURE)
    .value("SUCCESS",StatusCode::SUCCESS)
    ;
  
  class_<StatusCode>("StatusCode")
    .def("isSuccess", &StatusCode::isSuccess)
    .def("isFailure", &StatusCode::isFailure)
    ;
  
  class_<Options>("Options")
    .def("setLogOutputLevel", &Options::setLogOutputLevel)
    .def("logOutputLevel",    &Options::logOutputLevel)
    .def("setPrintFreq",      &Options::setPrintFreq)
    .def("printFreq",         &Options::printFreq)
    .def("setRunNumber",      &Options::setRunNumber)
    .def("runNumber",         &Options::runNumber)
    .def("setNEvt",             &Options::setNEvt)
    .def("nEvt",                &Options::nEvt)
    .def("setNEvtMax",          &Options::setNEvtMax)
    .def("nEvtMax",             &Options::nEvtMax)
    .def("setPlotFreq",         &Options::setPlotFreq)
    .def("plotFreq",            &Options::plotFreq)
    .def("setNErrors",          &Options::setNErrors)
    .def("nErrors",             &Options::nErrors)
    .def("setRunNumberMgr",   &Options::setRunNumberManagement)
    .def("runNumberMgr",      &Options::runNumberManagement)
    .def("setCurrentPath",    &Options::setCurrentPath)
    .def("currentPath",       &Options::currentPath)
    .def("setStoragePath",    &Options::setStoragePath)
    .def("storagePath",       &Options::storagePath)
    .def("storageFullPath",   &Options::storageFullPath)
    .def("setStorageDir",     &Options::setStorageDir)
    .def("storageDir",          &Options::storageDir)
    .def("setStorageFile",    &Options::setStorageFile)
    .def("storageFile",         &Options::storageFile)
    .def("storageFileFullName",&Options::storageFileFullName)
    .def("dataFileFullName",  &Options::dataFileFullName)
    .def("dataFile",            &Options::dataFile)
    .def("logFile",             &Options::logFile)
    .def("setDataStorage",    &Options::setDataStorage)
    .def("dataStorage",         &Options::dataStorage)
    .def("setLogStorage",     &Options::setLogStorage)
    .def("logStorage",        &Options::logStorage)
    .def("setLogDefFile",     &Options::setLogDefFile)
    .def("logDefFile",        &Options::logDefFile)
    .def("setDefFile",        &Options::setDefFile)
    .def("defFile",             &Options::defFile)
    .def("incRunNumber",      &Options::incRunNumber)
    .def("incNEvt",             &Options::incNEvt)
    .def("incNErrors",          &Options::incNErrors)
    .def("setStream",         &Options::setStream)     
    .def("stopOnError",       &Options::stopOnError)
    .def("setStopOnError",    &Options::setStopOnError)
    .def("dump",              &Options::print)
    ;

  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_<DLL>("DLL")
    .def("info",&DLL::print)
    ;

  class_< std::vector< DLL* > >("DLLPtrVec")
    .def(vector_indexing_suite< std::vector< DLL* > >())
    ;

  StatusCode (DLLMgr::*destroyElement)  (Element*)     = (&DLLMgr::destroy);
  StatusCode (DLLMgr::*destroyProcessus)(Processus*)   = (&DLLMgr::destroy);

  class_<DLLMgr>("DLLMgr")
    .def("load", &DLLMgr::load)
    .def("unload", &DLLMgr::unload)
    .def("info",&DLLMgr::print)
    .def("dll", &DLLMgr::dll,return_value_policy<reference_existing_object>())
    .def("dlls", &DLLMgr::dlls)
    .def("dllOfObject", &DLLMgr::libraryOfObject,return_value_policy<reference_existing_object>())
    .def("createElement", &DLLMgr::createElement,return_value_policy<reference_existing_object>())
    .def("createProcessus",&DLLMgr::createProcessus,return_value_policy<reference_existing_object>())
    .def("destroy",destroyElement)
    .def("destroy",destroyProcessus)
    ;
}

export_obj()

void export_obj

(

)

Definition at line 27 of file Python_Obj.cpp.

References Attrib::add(), Hierarchy::addChild(), Attrib::attributs(), Application::cd(), Hierarchy::child(), Hierarchy::children(), Hierarchy::childTyped(), Hierarchy::clear(), Application::computer(), Element::connection(), Application::create(), Application::ctrl(), Application::current(), Object::debug(), Hierarchy::delChild(), Application::dllMgr(), Object::dllName(), Object::error(), Object::fatal(), Application::finalize(), Hierarchy::hasChildren(), Element::help(), Computer::help(), Application::hostname(), Object::id(), Object::info(), Element::init(), Computer::init(), Application::initialize(), Attrib::is(), Application::loop(), Object::msg(), Object::msgSvc(), Object::name(), Hierarchy::numberOfChildren(), Application::options(), Hierarchy::origin(), Hierarchy::parent(), Hierarchy::path(), Hierarchy::pathTyped(), Application::prepare(), Application::procDb(), Element::recursiveInitCommunications(), Element::recursiveInitElement(), Attrib::remove(), Element::reset(), Computer::reset(), Application::run(), Element::setConnection(), Application::setCtrl(), Application::setCurrent(), Object::setId(), Object::setName(), Hierarchy::setParent(), Object::setTitle(), Object::setType(), Application::terminate(), Object::title(), Hierarchy::tree(), Object::type(), Element::update(), Computer::update(), Object::verbose(), and Object::warning().

Referenced by BOOST_PYTHON_MODULE().

{
  class_<Attrib>("Attrib")
    .def("is",     &Attrib::is)
    .def("add",    &Attrib::add)
    .def("remove", &Attrib::remove)
    .def("attributs", &Attrib::attributs)
    ;

  void (Object::*msgx1)(std::string)                = (&Object::msg);
  void (Object::*msgx2)(std::string, std::string)   = (&Object::msg);
  void (Object::*verbosex1)(std::string)                = (&Object::verbose);
  void (Object::*verbosex2)(std::string, std::string)   = (&Object::verbose);
  void (Object::*debugx1)(std::string)                = (&Object::debug);
  void (Object::*debugx2)(std::string, std::string)   = (&Object::debug);
  void (Object::*infox1)(std::string)                = (&Object::info);
  void (Object::*infox2)(std::string, std::string)   = (&Object::info);
  void (Object::*warningx1)(std::string)                = (&Object::warning);
  void (Object::*warningx2)(std::string, std::string)   = (&Object::warning);
  void (Object::*errorx1)(std::string)                = (&Object::error);
  void (Object::*errorx2)(std::string, std::string)   = (&Object::error);
  void (Object::*fatalx1)(std::string)                = (&Object::fatal);
  void (Object::*fatalx2)(std::string, std::string)   = (&Object::fatal);
  
  class_<Object, bases <Attrib> >("Object")
    .def("name",  &Object::name)
    .def("type",  &Object::type)
    .def("id",    &Object::id)
    .def("title", &Object::title)
    .def("dllName",   &Object::dllName)
    .def("setName",  &Object::setName)
    .def("setType",  &Object::setType)
    .def("setId",    &Object::setId)
    .def("setTitle", &Object::setTitle)
    .def("msgSvc",&Object::msgSvc)
    .def("msg", msgx1)
    .def("msg", msgx2)
    .def("verbose", verbosex1)
    .def("verbose", verbosex2)
    .def("debug", debugx1)
    .def("debug", debugx2)
    .def("info", infox1)
    .def("info", infox2)
    .def("warning", warningx1)
    .def("warning", warningx2)
    .def("error", errorx1)
    .def("error", errorx2)
    .def("fatal", fatalx1)
    .def("fatal", fatalx2)
    ;

  class_<Application, bases <Object> >("Application")
    .def("initialize", &Application::initialize)
    .def("run",        &Application::run)
    .def("finalize",   &Application::finalize)
    .def("create",     &Application::create)
    .def("cd",         &Application::cd)
    .def("options",    &Application::options, 
         return_value_policy<reference_existing_object>())
    .def("hostname",   &Application::hostname)
    .def("setCurrent", &Application::setCurrent)
    .def("current",    &Application::current,
         return_value_policy<reference_existing_object>())
    .def("computer",   &Application::computer,
         return_value_policy<reference_existing_object>())
    .def("dllMgr",     &Application::dllMgr,
         return_value_policy<reference_existing_object>())
    .def("procDb",     &Application::procDb,
         return_value_policy<reference_existing_object>())
    .def("ctrl",       &Application::ctrl)
    .def("setCtrl",    &Application::setCtrl)
    .def("prepare",    &Application::prepare)
    .def("loop",       &Application::loop)
    .def("terminate",  &Application::terminate)
    ;    

  Hierarchy* (Hierarchy::*parentx0)()              = (&Hierarchy::parent);
  Hierarchy* (Hierarchy::*parentx1)(std::string)   = (&Hierarchy::parent);
  void       (Hierarchy::*delChildx0)(Hierarchy*)  = (&Hierarchy::delChild);
  void       (Hierarchy::*delChildx1)(std::string) = (&Hierarchy::delChild);  
  void       (Hierarchy::*treex0)()                = (&Hierarchy::tree);

  class_< std::vector<Hierarchy*> >("HierarchyPtrVec")
    .def(vector_indexing_suite< std::vector<Hierarchy*> >())
    ;

  class_<Hierarchy, bases<Object> >("Hierarchy")
    .def("clear", &Hierarchy::clear)
    .def("setParent", &Hierarchy::setParent)
    .def("parent", parentx0,return_value_policy<reference_existing_object>())
    .def("parent", parentx1,return_value_policy<reference_existing_object>())
    .def("origin", &Hierarchy::origin,return_value_policy<reference_existing_object>())
    .def("addChild", &Hierarchy::addChild)
    .def("children", &Hierarchy::children)
    .def("child", &Hierarchy::child,return_value_policy<reference_existing_object>())
    .def("childTyped", &Hierarchy::childTyped,return_value_policy<reference_existing_object>())
    .def("numberOfChildren", &Hierarchy::numberOfChildren)
    .def("hasChildren", &Hierarchy::hasChildren)
    .def("delChild", delChildx0)
    .def("delChild", delChildx1)
    .def("path", &Hierarchy::path)
    .def("pathTyped", &Hierarchy::pathTyped)
    .def("tree", treex0)
    ;  

  class_<ElementWrap, boost::noncopyable, bases<Hierarchy> >("Element")
    .def("help",pure_virtual(&Element::help))
    .def("init",pure_virtual(&Element::init))
    .def("reset",pure_virtual(&Element::reset))
    .def("update",pure_virtual(&Element::update))
    .def("recursiveInitElement",&Element::recursiveInitElement)
    .def("recursiveInitCommunications",&Element::recursiveInitCommunications)
    .def("setConnection",&Element::setConnection)
    .def("connection",&Element::connection,return_value_policy<reference_existing_object>())
    ;

  class_<Computer, bases<Element> >("Computer")
    .def("help",&Computer::help)
    .def("init",&Computer::init)
    .def("reset",&Computer::reset)
    .def("update",&Computer::update)
    ;  
}

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