Python.cpp

Go to the documentation of this file.

#include <vector>
#include <list>

#include "Processus.h"

#include "Element.h"
#include "A3PE.h"
#include "Proto40MHz_v1.h"

#include "Acquisition.h"
#include "A3PE_BitFlip.h"
#include "UsbFTInterface.h"

#include "RegisterTest.h"
#include "UsbFTInterfaceTest.h"

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

using namespace boost::python;

BOOST_PYTHON_MODULE(libCatCaloProto40MHz)
{
  class_<A3PE, bases <Element> >("A3PE")
    .def("ctrlReg"    ,&A3PE::ctrlReg,return_value_policy<reference_existing_object>())
    .def("resetReg"    ,&A3PE::resetReg,return_value_policy<reference_existing_object>())
    .def("setupReg"    ,&A3PE::setupReg,return_value_policy<reference_existing_object>())
    .def("statusReg"    ,&A3PE::statusReg,return_value_policy<reference_existing_object>())
    .def("acqReg"    ,&A3PE::acqReg,return_value_policy<reference_existing_object>())
    .def("latencyReg"    ,&A3PE::acqReg,return_value_policy<reference_existing_object>())
    .def("writeLengthFifoReg"    ,&A3PE::writeLengthFifoReg,return_value_policy<reference_existing_object>())
    .def("ctrlAnaMezzReg"    ,&A3PE::ctrlAnaMezzReg,return_value_policy<reference_existing_object>())
    .def("clockDivisionReg"  ,&A3PE::clockDivisionReg,return_value_policy<reference_existing_object>())
    .def("triggerReg"  ,&A3PE::triggerReg,return_value_policy<reference_existing_object>())
    .def("toAXReg"  ,&A3PE::toAXReg,return_value_policy<reference_existing_object>())
    .def("fromAXReg"  ,&A3PE::fromAXReg,return_value_policy<reference_existing_object>())
    .def("spare3Reg"  ,&A3PE::spare3Reg,return_value_policy<reference_existing_object>())
    .def("storageRam"   ,&A3PE::storageRam,return_value_policy<reference_existing_object>())
    .def("patternRam"   ,&A3PE::patternRam,return_value_policy<reference_existing_object>())
    .def("triggerRam"   ,&A3PE::triggerRam,return_value_policy<reference_existing_object>())
    .def("toAXRam"      ,&A3PE::toAXRam,return_value_policy<reference_existing_object>())
    .def("fromAXRam"    ,&A3PE::fromAXRam,return_value_policy<reference_existing_object>())
    .def("testRam"    ,&A3PE::testRam,return_value_policy<reference_existing_object>())
    .def("reset"    ,&A3PE::reset)
    .def("resetStorageFifo"             ,&A3PE::resetStorageFifo)
    .def("resetTriggerFifo"             ,&A3PE::resetTriggerFifo)
    .def("resetPatternFifo"             ,&A3PE::resetPatternFifo)
    .def("resetFromAXRam"               ,&A3PE::resetFromAXRam)
    .def("resetToAXRam"                 ,&A3PE::resetToAXRam)
    .def("resetSequenceFromToAX"        ,&A3PE::resetSequenceFromToAX)
    .def("resetUsbPhasers"              ,&A3PE::resetUsbPhasers)
    .def("resetLatencyCounter"          ,&A3PE::resetLatencyCounter)
    .def("resetFE"                      ,&A3PE::resetFE)
    .def("resetSPI"                     ,&A3PE::resetSPI)
    .def("setEnableADC" ,&A3PE::setEnableADC)
    .def("enableADC" ,&A3PE::enableADC)
    .def("setWriteStorageFifoUsb" ,&A3PE::setWriteStorageFifoUsb)
    .def("writeStorageFifoUsb" ,&A3PE::writeStorageFifoUsb)
    .def("setReadPatternFifoUsb" ,&A3PE::setReadPatternFifoUsb)
    .def("readPatternFifoUsb" ,&A3PE::readPatternFifoUsb)
    .def("setReadTriggerFifoUsb" ,&A3PE::setReadTriggerFifoUsb)
    .def("readTriggerFifoUsb" ,&A3PE::readTriggerFifoUsb)
    .def("setReadToAXRamUsb" ,&A3PE::setReadToAXRamUsb)
    .def("readToAXRamUsb" ,&A3PE::readToAXRamUsb)
    .def("setWriteFromAXRamUsb" ,&A3PE::setWriteFromAXRamUsb)
    .def("writeFromAXRamUsb" ,&A3PE::writeFromAXRamUsb)
    .def("setSoftwareTrigger" ,&A3PE::setSoftwareTrigger)
    .def("softwareTrigger" ,&A3PE::softwareTrigger)
    .def("setClockDivision" ,&A3PE::setClockDivision)
    .def("clockDivision" ,&A3PE::clockDivision)
    .def("setTriggerDelay" ,&A3PE::setTriggerDelay)
    //    .def("setSeqPulseDelay" ,&A3PE::setSeqPulseDelay)
    .def("triggerDelay" ,&A3PE::triggerDelay)
    //    .def("seqPulseDelay" ,&A3PE::seqPulseDelay)
    .def("setTriggerRate" ,&A3PE::setTriggerRate)
    .def("triggerRate" ,&A3PE::triggerRate)
    .def("setNTrigger" ,&A3PE::setNTrigger)
    .def("nTrigger" ,&A3PE::nTrigger)
    .def("setFifoLatency"  ,&A3PE::setFifoLatency)
    .def("fifoLatency"  ,&A3PE::fifoLatency)
    .def("setFifoDepth", &A3PE::setFifoDepth)
    .def("fifoDepth", &A3PE::fifoDepth)
    .def("acquisition", &A3PE::acquisition)
    .def("trigger", &A3PE::trigger)
    .def("enableStorage", &A3PE::enableStorage)
    .def("dataReady", &A3PE::dataReady)
    .def("dumpStorage", &A3PE::dumpStorage)
    .def("dumpPattern", &A3PE::dumpPattern)
    .def("dumpTrigger", &A3PE::dumpTrigger)
    .def("dumpToAX", &A3PE::dumpToAX)
    .def("dumpFromAX", &A3PE::dumpFromAX)
    .def("loadStorage", &A3PE::loadStorage)
    .def("loadPattern", &A3PE::loadPattern)
    .def("loadTrigger", &A3PE::loadTrigger)
    .def("loadToAX", &A3PE::loadToAX)
    .def("loadFromAX", &A3PE::loadFromAX)
    .def("setInternalAXSequence", &A3PE::setInternalAXSequence)
    .def("internalAXSequence", &A3PE::internalAXSequence)
    .def("setLengthAX", &A3PE::setLengthAX)
    .def("lengthAX", &A3PE::lengthAX)
    .def("setLatencyAX", &A3PE::setLatencyAX)
    .def("latencyAX", &A3PE::latencyAX)
    .def("setAddFromAXRam", &A3PE::setAddFromAXRam)
    .def("setAddToAXRam", &A3PE::setAddToAXRam)
    .def("startSequenceAX", &A3PE::startSequenceAX)
    .def("setPipeline", &A3PE::setPipeline)
    .def("pipeline", &A3PE::pipeline)
    ;

  class_<Proto40MHz_v1, bases <Element> >("Proto40MHz_v1")
    .def("usb",&Proto40MHz_v1::usb,return_value_policy<reference_existing_object>())
    .def("phaser0",&Proto40MHz_v1::phaser0,return_value_policy<reference_existing_object>())
    .def("phaser1",&Proto40MHz_v1::phaser1,return_value_policy<reference_existing_object>())
    .def("phaser2",&Proto40MHz_v1::phaser2,return_value_policy<reference_existing_object>())
    .def("a3pe",   &Proto40MHz_v1::a3pe,return_value_policy<reference_existing_object>())
  ;

  class_<Acquisition,bases <Processus> >("Acquisition")
    .def("initialize",&Acquisition::initialize)
    .def("execute",&Acquisition::execute)
    .def("finalize",&Acquisition::finalize)
    .def("setDepth",&Acquisition::setDepth)
    .def("depth",&Acquisition::depth)
    .def("setChannels",&Acquisition::setChannels)
    .def("channels",&Acquisition::channels)
    .def("setTrigger",&Acquisition::setTrigger)
    .def("trigger",&Acquisition::trigger)
    .def("setStoreTree",&Acquisition::setStoreTree)
    .def("setStoreTrend",&Acquisition::setStoreTrend)
    .def("setStoreSample",&Acquisition::setStoreSample)
    .def("storeTree",&Acquisition::storeTree)
    .def("storeTrend",&Acquisition::storeTrend)
    .def("storeSample",&Acquisition::storeSample)
    .def("setDeadTime",&Acquisition::setDeadTime)
    .def("deadTime",&Acquisition::deadTime)
    .def("setSample",&Acquisition::setSample)
    .def("sample",&Acquisition::sample)
    .def("setNBins",&Acquisition::setNBins)
    .def("nBins",&Acquisition::nBins)
    .def("setMinRange",&Acquisition::setMinRange)
    .def("minRange",&Acquisition::minRange)
    .def("setMaxRange",&Acquisition::setMaxRange)
    .def("maxRange",&Acquisition::maxRange)
    ;

  class_<A3PE_BitFlip,bases <Processus> >("A3PE_BitFlip")
    .def("initialize",&A3PE_BitFlip::initialize)
    .def("execute",&A3PE_BitFlip::execute)
    .def("finalize",&A3PE_BitFlip::finalize)
    .def("setFile",&A3PE_BitFlip::setFile)
    .def("file",&A3PE_BitFlip::file)
    ;

  enum_<UsbFTInterface::WordSize>("WordSize")
    .value("U8", UsbFTInterface::WS_Byte)
    .value("U16", UsbFTInterface::WS_Word)
    .value("U32", UsbFTInterface::WS_DWord)
    ;

  StatusCode (UsbFTInterface::*write_1)(unsigned long int, boost::python::list) = (&UsbFTInterface::write);
  StatusCode (UsbFTInterface::*write_2)(IOdata*) = (&UsbFTInterface::write);
  StatusCode (UsbFTInterface::*read_1)(unsigned long int,unsigned long int, boost::python::list&) = (&UsbFTInterface::read);
  StatusCode (UsbFTInterface::*read_2)(IOdata*) = (&UsbFTInterface::read);

  class_<UsbFTInterface, bases <Element> > ("UsbFTInterface")
    .def("init"           ,&UsbFTInterface::init)
    .def("setSerialNum"   ,&UsbFTInterface::setSerialNum)
    .def("setDeviceDesc"  ,&UsbFTInterface::setDeviceDesc)
    .def("serialNum"      ,&UsbFTInterface::serialNum)
    .def("deviceDesc"     ,&UsbFTInterface::deviceDesc)
    .def("setWordSize"    ,&UsbFTInterface::setWordSize)
    .def("wordSize"       ,&UsbFTInterface::wordSize)
    .def("close"          ,&UsbFTInterface::close)
    .def("setLatencyTimer",&UsbFTInterface::setLatencyTimer)
    .def("latencyTimer"   ,&UsbFTInterface::latencyTimer)
    .def("setTimeOut"     ,&UsbFTInterface::setTimeOut)
    .def("txTimeOut"      ,&UsbFTInterface::txTimeOut)
    .def("rxTimeOut"      ,&UsbFTInterface::rxTimeOut)
    .def("setBuffer"      ,&UsbFTInterface::setBuffer)
    .def("txBuffer"       ,&UsbFTInterface::txBuffer)
    .def("rxBuffer"       ,&UsbFTInterface::rxBuffer)
    .def("write"          ,write_1)
    .def("write"          ,write_2)
    .def("read"           ,read_1)
    .def("read"           ,read_2)
    ;

  class_<UsbFTInterfaceTest, bases<Processus> > ("UsbFTInterfaceTest")
    .def("setAddress", &UsbFTInterfaceTest::setAddress)
    .def("setParam", &UsbFTInterfaceTest::setParam)
    .def("mean", &UsbFTInterfaceTest::mean)
    .def("sigma", &UsbFTInterfaceTest::sigma)
    ;

  class_<RegisterTest, bases<Processus> > ("RegisterTest")
    .def("setAddress", &UsbFTInterfaceTest::setAddress)
    .def("setParam", &UsbFTInterfaceTest::setParam)
    .def("mean", &UsbFTInterfaceTest::mean)
    .def("sigma", &UsbFTInterfaceTest::sigma)
    ;

}