In This Package:

ReadoutEventCnv.cc

Go to the documentation of this file.

#include "ReadoutEventCnv.h"
#include "PerBaseEvent/HeaderObjectCnv.h"
#include "Conventions/Electronics.h"
#include "Context/TimeStamp.h"

//#include "Event/ReadoutHeader.h"
//#include "PerReadoutEvent/PerReadout.h"

#include "Event/DaqPmtCrate.h"

#include "DaqReadoutFormat/ByteBuffer.h"

using namespace DayaBay;
using namespace std;

using DybDaq::ByteBuffer;
using DybDaq::DaqBuffer;
using DybDaq::EventReadout;

ReadoutHeaderCnv::ReadoutHeaderCnv(ISvcLocator* svc)
      : RootIOTypedCnv<PerReadoutHeader,ReadoutHeader>("PerReadoutHeader",
                                                       classID(),svc),
            m_buffers(new DaqBuffer::OutputBufferList())
{
    m_writefadc = true;
}


ReadoutHeaderCnv::~ReadoutHeaderCnv()
{
  delete m_buffers;
}

StatusCode ReadoutHeaderCnv::PerToTran(const PerReadoutHeader& perobj,
                                       DayaBay::ReadoutHeader& tranobj)
{
  MsgStream log(msgSvc(), "ReadoutHeaderCnv::PerToTran");
  StatusCode sc = HeaderObjectCnv::toTran(perobj,tranobj);
  if (sc.isFailure()) return sc;

  delete tranobj.readout();
  if(perobj.readout){
    DayaBay::Readout* readout = convert( *(perobj.readout) );
    if (0 != readout) {
      readout->setHeader( &tranobj );
      tranobj.setReadout( readout );
    }
    if (!((perobj.readout)->rawEvent).empty()) {
      tranobj.setDaqCrate(new DaqPmtCrate(perobj.daqPmtCrate(true)));
    }
  }else{
    // Header has no readout
    tranobj.setReadout(0);
  }

  return StatusCode::SUCCESS;
}                                       

StatusCode ReadoutHeaderCnv::TranToPer(const DayaBay::ReadoutHeader& tranobj,
                                       PerReadoutHeader& perobj)
{
  MsgStream log(msgSvc(), "ReadoutHeaderCnv::TranToPer");
  StatusCode sc = HeaderObjectCnv::toPer(tranobj,perobj);
  if (sc.isFailure()) return sc;

  delete perobj.readout;
  const Readout* readout = tranobj.readout();
  const DayaBay::DaqCrate* daqCrate = tranobj.daqCrate();
  if(0 != readout && m_rioSvc->isReadoutForced()) {
    perobj.readout = convert( *(readout ) );
    if ((0 == readout->rawEvent()) && (0 != daqCrate)) {
      return TranToPer(*daqCrate,
                       perobj);
    }
  }else{
    if (0 == daqCrate) {
      perobj.readout = 0;
    } else {
      perobj.readout = new PerReadout();
      return TranToPer(*daqCrate,
                       perobj);
    }
  }
  
  return StatusCode::SUCCESS;
}

StatusCode ReadoutHeaderCnv::TranToPer(const DayaBay::DaqCrate& tranobj,
                                       PerReadoutHeader& perobj) {
  const DybDaq::EventReadout& eventReadout = tranobj.eventReadout();
  std::vector<unsigned int>& daqBytes = perobj.readout->rawEvent;
  daqBytes.resize(eventReadout.bufferSize() * ByteBuffer::BYTES_IN_INT);
  unsigned int index = 0;
  eventReadout.gather(*m_buffers);
  DaqBuffer::OutputBufferList::const_iterator buffer;
  for (buffer = m_buffers->begin();
       buffer != m_buffers->end();
       ++buffer) {
    unsigned int capacity = (*buffer).second;
    memcpy(&(daqBytes[index]),
           (*buffer).first,
           capacity);
    index += (capacity / ByteBuffer::BYTES_IN_INT);
  }
  m_buffers->clear();
  return StatusCode::SUCCESS;
}

StatusCode ReadoutHeaderCnv::fillRepRefs(IOpaqueAddress*, DataObject* dobj)
{
    MsgStream log(msgSvc(), "ReadoutHeaderCnv::fillRepRefs");
    ReadoutHeader* rh = dynamic_cast<ReadoutHeader*>(dobj);

    log << MSG::DEBUG
        << "Saving links to " << rh->inputHeaders().size() 
        << " input headers" << endreq;

    StatusCode sc = HeaderObjectCnv::fillPer(m_rioSvc,*rh,*m_perOutObj);
    if (sc.isFailure()) {
        log << MSG::ERROR << "Failed to fill HeaderObject part" << endreq;
        return sc;
    }

    // ... fill ReadoutHeader part...
    return sc;
}

StatusCode ReadoutHeaderCnv::fillObjRefs(IOpaqueAddress*, DataObject* dobj)
{
    MsgStream log(msgSvc(), "ReadoutHeaderCnv::fillObjRefs");
    HeaderObject* hobj = dynamic_cast<HeaderObject*>(dobj);
    StatusCode sc = HeaderObjectCnv::fillTran(m_rioSvc,*m_perInObj,*hobj);
    if (sc.isFailure()) {
        log << MSG::ERROR << "Failed to fill HeaderObject part" << endreq;
        return sc;
    }

    log << MSG::DEBUG
        << "Restored links to " << hobj->inputHeaders().size() 
        << " input headers" << endreq;

    // ... fill ReadoutHeader part...
    return sc;
}

PerReadout* ReadoutHeaderCnv::convert(const DayaBay::Readout& roRo)
{
  Detector det(roRo.detector());
  if(det.detectorId() == DetectorId::kUnknown){
      return 0; 
  }else if( det.detectorId() != DetectorId::kRPC ){
      return convert( static_cast<const ReadoutPmtCrate&>(roRo) );
  }else{
      //return convert( static_cast<const ReadoutRpcCrate&>(roRo) ); 
    return 0; // do RPC later
  }
  return 0;
}

PerReadoutPmtCrate* ReadoutHeaderCnv::convert(const DayaBay::ReadoutPmtCrate& roPmtCrate)
{
  MsgStream log(msgSvc(), "ReadoutHeaderCnv::convert(ReadoutPmtCrate&)");
  PerReadoutPmtCrate *perRoPcr = new PerReadoutPmtCrate();
  perRoPcr->detector = (roPmtCrate.detector()).siteDetPackedData();
  perRoPcr->triggerType = roPmtCrate.triggerType();
  perRoPcr->triggerNumber = roPmtCrate.triggerNumber();
  
  perRoPcr->triggerTimeSec = roPmtCrate.triggerTime().GetSec(); /* FIXME */
  perRoPcr->triggerTimeNanoSec = roPmtCrate.triggerTime().GetNanoSec();
  const DayaBay::RawEvent* rawEvent = roPmtCrate.rawEvent();
  if( rawEvent && rawEvent->isValid() ){
    perRoPcr->rawEvent.resize( roPmtCrate.rawEvent()->size() );
    memcpy(&(perRoPcr->rawEvent[0]), roPmtCrate.rawEvent()->buffer(),
           roPmtCrate.rawEvent()->size()*sizeof(unsigned int) );
  }
  ReadoutPmtCrate::PmtChannelReadouts chReadouts = roPmtCrate.channelReadout();
  ReadoutPmtCrate::PmtChannelReadouts::iterator it;
  
  std::vector<PerReadoutPmtChannel*> out_vec;
  
  for(it=chReadouts.begin();it!=chReadouts.end();++it)
  {
    PerReadoutPmtChannel* perRoPch = convert( it->second );
    perRoPch->channelId = (it->first).fullPackedData();
    out_vec.push_back(perRoPch);
  }
  perRoPcr->perChannelReadouts = out_vec;
  if(roPmtCrate.triggerDataPkg()){
      perRoPcr->perTriggerDataPkg = convert (*(roPmtCrate.triggerDataPkg()));
  }else{
      log << MSG::WARNING << "TriggerDataPackage Not Found" << endreq;
  }
  
  // now do fadc data
  if(m_writefadc)
  {
      const map<FadcChannelId, DigitalSignal>& in_fadcReadouts = roPmtCrate.fadcReadout();
      map<FadcChannelId, DigitalSignal>::const_iterator fadc_it, done=in_fadcReadouts.end();
      for( fadc_it = in_fadcReadouts.begin() ; fadc_it != done ; ++fadc_it ){
        (perRoPcr->perFadcReadouts)[(fadc_it->first).fullPackedData()] = fadc_it->second ;
      }   
  }
  
  //perRoPcr->fadcReadouts = chan;
  
  return perRoPcr;
}

PerReadoutPmtChannel* ReadoutHeaderCnv::convert(const DayaBay::ReadoutPmtChannel& roPmtChannel)
{
  PerReadoutPmtChannel* perRoPch = new PerReadoutPmtChannel();
  
  perRoPch->mode = roPmtChannel.mode();
  perRoPch->adc   = roPmtChannel.adc();
  perRoPch->adcRange= roPmtChannel.adcRange();
  perRoPch->adcCycle= roPmtChannel.adcCycle();
  perRoPch->pedestal= roPmtChannel.pedestal();
  perRoPch->tdc   = roPmtChannel.tdc();
  perRoPch->tdcHitCount = roPmtChannel.tdcHitCount();
  perRoPch->waveAdcCycle= roPmtChannel.waveAdcCycle();
  perRoPch->waveAdcHigh = roPmtChannel.waveAdcHigh();
  perRoPch->waveAdcLow = roPmtChannel.waveAdcLow();
  return perRoPch;
}

PerReadoutTriggerDataPkg* ReadoutHeaderCnv::convert(const DayaBay::ReadoutTriggerDataPkg& roPmtTDP)
{
    PerReadoutTriggerDataPkg* perRoTDP= new PerReadoutTriggerDataPkg((roPmtTDP.detector()).siteDetPackedData(),
                                                                      roPmtTDP.trigNumber(),    
                                                                      roPmtTDP.numSubTriggers(),
                                                                      roPmtTDP.boardStatus(),   
                                                                      roPmtTDP.localSN());
    
    //PerReadoutTriggerDataPkg* perRoTDP= new PerReadoutTriggerDataPkg();
    //perRoTDP->detector=(roPmtTDP.detector()).siteDetPackedData();
    //perRoTDP->trigNumber=roPmtTDP.trigNumber();
    //perRoTDP->numSubTriggers=roPmtTDP.numSubTriggers();
    //perRoTDP->boardStatus=roPmtTDP.boardStatus();
    //perRoTDP->localSN=roPmtTDP.localSN();
    
    std::vector<DayaBay::ReadoutTriggerDataFrame*>::const_iterator it;
    for(it=roPmtTDP.frames().begin();it!=roPmtTDP.frames().end();++it){
        (perRoTDP->frames).push_back(convert(**it));
    }
    return perRoTDP;
}


PerReadoutTriggerDataFrame* ReadoutHeaderCnv::convert(const DayaBay::ReadoutTriggerDataFrame& roPmtTDF)
{
    PerReadoutTriggerDataFrame *perRoTDF = new PerReadoutTriggerDataFrame(roPmtTDF.seqNumber(), 
                                                                          roPmtTDF.readoutType(),
                                                                          roPmtTDF.triggerType(),
                                                                          roPmtTDF.triggerTime(),
                                                                          roPmtTDF.cycle(),
                                                                          roPmtTDF.nhit(),
                                                                          roPmtTDF.esumAdc(),
                                                                          roPmtTDF.esumComp(),  
                                                                          roPmtTDF.crossSource());

    return perRoTDF;

}

Readout*  ReadoutHeaderCnv::convert(const PerReadout& perRo)
{
  Detector det(perRo.detector);
  if(det.detectorId() == DetectorId::kUnknown){
      return 0; 
  }else if( det.detectorId() != DetectorId::kRPC ){
      return convert( static_cast<const PerReadoutPmtCrate&>(perRo) );
  }else{
      //return convert( static_cast<const ReadoutRpcCrate&>(roRo) ); 
    return 0; // do RPC later
  }
  return 0;
}

ReadoutPmtCrate* ReadoutHeaderCnv::convert(const PerReadoutPmtCrate& perRoPcr)
{
  ReadoutPmtCrate *out_crate = new ReadoutPmtCrate();
  Detector det(perRoPcr.detector);
  out_crate->setDetector(det);
  out_crate->setTriggerType( Trigger::TriggerType_t(perRoPcr.triggerType) );
  out_crate->setTriggerNumber( perRoPcr.triggerNumber );
  
  timespec value = {perRoPcr.triggerTimeSec,perRoPcr.triggerTimeNanoSec};
  TimeStamp tstamp(value);
  out_crate->setTriggerTime(tstamp); 
  if(perRoPcr.rawEvent.size() > 0){
    unsigned int* buffer = const_cast<unsigned int*>(&(perRoPcr.rawEvent[0]));
    out_crate->setRawEvent( RawEvent( buffer ).clone() );
  }
  
  ReadoutPmtCrate::PmtChannelReadouts out_channels;
  
  PerReadoutPmtCrate::PerPmtChannelReadouts in_channels = perRoPcr.perChannelReadouts;
  PerReadoutPmtCrate::PerPmtChannelReadouts::const_iterator it;
  
  for(it=in_channels.begin(); it!=in_channels.end(); ++it){
    ReadoutPmtChannel out_channel = convert(**it);
    out_channel.setReadout(out_crate);
    out_channels[out_channel.channelId()]=out_channel;
  }
  
  out_crate->setChannelReadout(out_channels);
  //Add protection so old version data without TriggerDataPkg can also be read
  if(perRoPcr.perTriggerDataPkg) {
    ReadoutTriggerDataPkg* rotdf = convert( *(perRoPcr.perTriggerDataPkg) );
    rotdf->setReadout(out_crate);
    out_crate->setTriggerDataPkg(rotdf);
  }
  
  ReadoutPmtCrate::FadcReadouts& out_fadcReadouts = out_crate->fadcReadout();
  
  PerReadoutPmtCrate::PerFadcReadouts in_fadcReadouts;
  PerReadoutPmtCrate::PerFadcReadouts::const_iterator fadc_it;
  
  //if(perRoPcr.perFadcReadouts.size()>0){
  //ReadoutPmtCrate::FadcReadouts::iterator fadc_it;
  for(fadc_it=in_fadcReadouts.begin();fadc_it!=in_fadcReadouts.end();++fadc_it){
      out_fadcReadouts[DayaBay::FadcChannelId(fadc_it->first)]=fadc_it->second;
  }
  //}
    
  return out_crate;
}

ReadoutPmtChannel ReadoutHeaderCnv::convert(const PerReadoutPmtChannel& perRoPch)
{
  ReadoutPmtChannel out_ch;
  FeeChannelId id(perRoPch.channelId);
  out_ch.setChannelId(id);
  out_ch.setMode(perRoPch.mode);
  out_ch.setAdc(perRoPch.adc);
  out_ch.setAdcRange(perRoPch.adcRange);
  out_ch.setAdcCycle(perRoPch.adcCycle);
  out_ch.setPedestal(perRoPch.pedestal);
  out_ch.setTdc(perRoPch.tdc);
  out_ch.setTdcHitCount(perRoPch.tdcHitCount);
  out_ch.setWaveAdcCycle(perRoPch.waveAdcCycle);
  out_ch.setWaveAdcHigh(perRoPch.waveAdcHigh);
  out_ch.setWaveAdcLow(perRoPch.waveAdcLow);
  return out_ch;
}

ReadoutTriggerDataPkg* ReadoutHeaderCnv::convert(const PerReadoutTriggerDataPkg& perRoPmtTDP)
{
  ReadoutTriggerDataPkg* roTDP = new ReadoutTriggerDataPkg();
  Detector det(perRoPmtTDP.detector);
  roTDP->setDetector(det);
  roTDP->setTrigNumber(perRoPmtTDP.trigNumber);
  roTDP->setBoardStatus(perRoPmtTDP.boardStatus);
  roTDP->setLocalSN(perRoPmtTDP.localSN);
  std::vector<PerReadoutTriggerDataFrame*>::const_iterator it;
  for(it=perRoPmtTDP.frames.begin();it!=perRoPmtTDP.frames.end();++it)
  {
    ReadoutTriggerDataFrame* rotdf=convert(**it);
    rotdf->setPackage(roTDP);
    roTDP->addFrame(rotdf);
  }
  return roTDP;
}

ReadoutTriggerDataFrame* ReadoutHeaderCnv::convert(const PerReadoutTriggerDataFrame& perToPmtTDF)
{
  ReadoutTriggerDataFrame *rotdf = new ReadoutTriggerDataFrame();
  rotdf->setSeqNumber(perToPmtTDF.seqNumber);
  rotdf->setReadoutType(perToPmtTDF.readoutType);
  rotdf->setTriggerType(Trigger::TriggerType_t(perToPmtTDF.triggerType));
  rotdf->setTriggerTime(perToPmtTDF.triggerTime);
  rotdf->setCycle(perToPmtTDF.cycle);
  rotdf->setNhit(perToPmtTDF.nhit);
  rotdf->setEsumAdc(perToPmtTDF.esumAdc);
  rotdf->setEsumComp(perToPmtTDF.esumComp);
  rotdf->setCrossSource(perToPmtTDF.crossSource);
  return rotdf;
}


// Local Variables:
// c-basic-offset: 2
// End:

---