In This Package:

RawDataReader.cc

Go to the documentation of this file.

#include "RawDataReader.h"
#include "Event/ReadoutHeader.h"
#include "Event/ReadoutPmtCrate.h"
#include "Event/RawEventHeader.h"
#include "Event/RawRom.h"
#include "Event/RawRomFee.h"
#include "Event/RawPmtChannel.h"
#include "Event/RawRomLtb.h"
#include "Event/RawLtbFrame.h"

using namespace std;
using namespace DayaBay;

RawDataReader::RawDataReader(const string& name, ISvcLocator* svcloc)
      : GaudiAlgorithm(name, svcloc)
      , m_log(msgSvc(), name)
{
   declareProperty("PrintFreq", m_printFreq = 100, "print frequency for event information");
   declareProperty("CheckRawEvent", m_checkRawEvent = false, "Whether check raw event");
}

RawDataReader::~RawDataReader()
{
}

StatusCode RawDataReader::initialize()
{
   m_log << MSG::DEBUG << "initialize()" << endreq;
   return StatusCode::SUCCESS;
}

StatusCode RawDataReader::execute()
{
   m_log << MSG::DEBUG << "execute() ______________________________ start" << endreq;

   ReadoutHeader* roh = get<ReadoutHeader>("/Event/Readout/ReadoutHeader");
   if (roh == 0) {
      m_log << MSG::ERROR << " =======> Requested Object can not be accessable." << endreq;
      return StatusCode::FAILURE;
   }


   Readout* readout = const_cast<Readout*>(roh->readout());
   ReadoutPmtCrate* crate = dynamic_cast<ReadoutPmtCrate*>(readout);
   ReadoutPmtCrate::PmtChannelReadouts channels = crate->channelReadout();

   if (m_printFreq > 0 && crate->triggerNumber() % m_printFreq == 0) {
      m_log << MSG::INFO << "detector: " << crate->detector().detName() 
        << " site="<<crate->detector().site() << " detectorId="<<crate->detector().detectorId()  << endreq;
      m_log << MSG::INFO << "Readout: " << (Readout)(*(roh->readout()))  << endreq;
      m_log << MSG::INFO << "Readout: " << *readout  << endreq;
      m_log << MSG::INFO << "ReadoutPmtCrate: " << *crate  << endreq;

      m_log << MSG::INFO << "FADC size=" << crate->fadcReadout().size()  << endreq;
      ReadoutPmtCrate::FadcReadouts &fadcReadouts = crate->fadcReadout();
      ReadoutPmtCrate::FadcReadouts::iterator itfadc;
      for(itfadc=fadcReadouts.begin(); itfadc!=fadcReadouts.end(); itfadc++) {
        m_log << MSG::INFO << itfadc->first << " => " << itfadc->second  << endreq;
      }
      
      m_log << MSG::INFO << "#channels=" << crate->channelReadout().size()  << endreq;
      ReadoutPmtCrate::PmtChannelReadouts::iterator it;
      for (it=channels.begin(); it != channels.end(); it++) {
         m_log << MSG::INFO << it->first << " => " << it->second  << endreq;

         for(unsigned int i=0; i<it->second.size(); i++) {
           m_log << MSG::DEBUG << "ADC= (" << it->second.adc(i) 
             << "," << it->second.adcRange(i) << "," << it->second.adcCycle(i)
             << "), TDC= (" << it->second.tdc(i) << "," << it->second.tdcHitCount(i) << ")" << endreq;
         }

         m_log << MSG::DEBUG << "size = " << it->second.size() 
           << ", maxAdcIndex= " << it->second.maxAdcIndex()
           << ", maxAdc= " << it->second.maxAdc()
           << ", sumAdc= " << it->second.sumAdc()
           << ", earliestTdcIndex= " << it->second.earliestTdcIndex()
           << ", earliestTdc= " << it->second.earliestTdc()
           << ", earliestAdc= " << it->second.earliestAdc()
           << endreq;
      }
      
   }

   if(m_checkRawEvent) {

     RawEventHeader* reh = get<RawEventHeader>(RawEventHeaderLocation::Default);
     if (reh == 0) {
       m_log << MSG::ERROR << " =======> Requested Object can not be accessable." << endreq;
       return StatusCode::FAILURE;
     }

     if (m_printFreq > 0 && reh->evtNum() % m_printFreq == 0) {
       //m_log << MSG::INFO << *reh << endreq;
       const vector<RawRom*>& modules = reh->modules();
       for(unsigned int i=0; i<modules.size(); i++) {
         m_log << MSG::INFO << "Rom type: " << modules[i]->type() << endreq;
         switch(modules[i]->type()) {
           case 1:  //RomFee 
             {
               RawRomFee* rawRomFee = dynamic_cast<RawRomFee*>(modules[i]);
               m_log << MSG::INFO << "RawRomFee: " << *rawRomFee << endreq;
               const vector<DayaBay::RawPmtChannel*>& channels = rawRomFee->channels();
               for(unsigned int j=0; j<channels.size(); j++) {
                 m_log << MSG::INFO << "RawPmtChannel: " << *(channels[j]) << endreq;
               }
             }
             break;
           case 3:  //RomLtb
             {
               RawRomLtb* rawRomLtb = dynamic_cast<RawRomLtb*>(modules[i]);
               m_log << MSG::INFO << "RawRomLtb: " << *rawRomLtb << endreq;
               const vector<DayaBay::RawLtbFrame*>& frames = rawRomLtb->frames();
               for(unsigned int j=0; j<frames.size(); j++) {
                 m_log << MSG::INFO << "RawLtbFrame: " << *(frames[j]) << endreq;
               }
             }
             break;
           default:
             break;
         }
       }
     }

   }

   m_log << MSG::DEBUG << "execute() ______________________________ end" << endreq;
   return StatusCode::SUCCESS;
}

StatusCode RawDataReader::finalize()
{
  m_log << MSG::DEBUG << "finalize()" << endreq;
  return StatusCode::SUCCESS;
}

---