In This Package:

DataAnalyses.cc

Go to the documentation of this file.

#include "DataAnalyses.h"
#include "Event/CalibReadoutHeader.h"
#include "Event/CalibReadoutPmtCrate.h"
#include "Event/ReadoutHeader.h"
#include "Event/ReadoutPmtCrate.h"
#include "Event/RawEventHeader.h"
#include "Event/RawRom.h"
#include "Event/RawRomLtb.h"
#include "Event/RawPmtChannel.h"
#include "Event/GenHeader.h"
#include "HepMC/GenEvent.h"
#include "HepMC/GenVertex.h"
#include "Event/RecHeader.h"
#include "DetHelpers/IPmtGeomInfoSvc.h"
#include "DataSvc/ICableSvc.h"
#include "DatabaseInterface/DbiResultPtr.h"
#include <map>

using namespace std;
using namespace DayaBay;

uint32_t uTriggerSum= 0;
int last_trig_timeSec = 0;
int last_trig_timeNanoSec = 0;
int Max_MultiTDC = 4;

  DataAnalyses::DataAnalyses(const string& name, ISvcLocator* svcloc)
: GaudiAlgorithm(name, svcloc), m_log(msgSvc(), name)
, m_cableSvc(0)
//, m_pmtGeomSvc(0)
{
  declareProperty("PrintFreq", m_printFreq = 100, "print frequency for event information");
  declareProperty("CheckGen", m_checkGen = false, "check GenEvent");
  declareProperty("CheckReadout", m_checkReadout = false, "check ReadoutEvent");
  declareProperty("CheckLtb", m_checkLtb = false, "check Ltb information");
  declareProperty("CheckCalibReadout", m_checkCalibReadout = false, "check CalibReadoutEvent");
  declareProperty("CheckRec", m_checkRec = false, "check RecEvent");
  declareProperty("CableSvcName", m_cableSvcName = "StaticCableSvc",
    "Name of service to map between detector, hardware, and electronic IDs");
  declareProperty("PmtGeomSvcName", m_pmtGeomSvcName = "PmtGeomInfoSvc",
    "Name of Pmt Geometry Information Service");
  m_execNum = 0;
  m_ntuple0 = 0;
  m_ntuple1 = 0;
  m_ntuple2 = 0;
  m_ntuple3 = 0;
}

DataAnalyses::~DataAnalyses()
{
}

StatusCode DataAnalyses::initialize()
{
  m_log << MSG::DEBUG << "initialize()" << endreq;
  // Get Cable Service
  m_cableSvc = svc<ICableSvc>(m_cableSvcName, true);

  // Get PmtGeomInfo Service
  m_pmtGeomSvc = svc<IPmtGeomInfoSvc>(m_pmtGeomSvcName, true);

  //  Book NTuple 0
  if(m_checkGen) {
    NTuplePtr nt0(ntupleSvc(), "FILE1/Gen");
    if ( nt0 ) m_ntuple0 = nt0;
    else {
      m_ntuple0 = ntupleSvc()->book("FILE1/Gen", CLID_ColumnWiseTuple, "Gen");
      if ( m_ntuple0 )    {
        m_ntuple0->addItem ("EventType",      m_eventType);
        m_ntuple0->addItem ("VertexSize",     m_nVertex, 0, 30);
        m_ntuple0->addItem ("ver_x0",  m_nVertex, m_verX0);
        m_ntuple0->addItem ("ver_y0",  m_nVertex, m_verY0);
        m_ntuple0->addItem ("ver_z0",  m_nVertex, m_verZ0);
        m_ntuple0->addItem ("ParticleSize",   m_nParticle, 0, 30);
        m_ntuple0->addItem ("ver_px",  m_nParticle, m_verPx);
        m_ntuple0->addItem ("ver_py",  m_nParticle, m_verPy);
        m_ntuple0->addItem ("ver_pz",  m_nParticle, m_verPz);
      }
      else { // Did not manage to book the NTuple....
        error() << "Can not book NTuple:" << long(m_ntuple0) << endmsg;
        return StatusCode::FAILURE;
      }
    }
  }

  //  Book NTuple 1
  if(m_checkReadout) {
    NTuplePtr nt1(ntupleSvc(), "FILE1/Readout");
    if ( nt1 ) m_ntuple1 = nt1;
    else {
      m_ntuple1 = ntupleSvc()->book("FILE1/Readout", CLID_ColumnWiseTuple, "Readout");
      if ( m_ntuple1 )    {
        info() << "Start m_ntuple1 addItem successful!" << endmsg;
        // Trigger number serial
        m_ntuple1->addItem ("TriggerNumber",m_triggerNumber);

        // Trigger Type
        m_ntuple1->addItem ("TriggerType",  m_triggerType);

        // Trigger Time from LTB is recorded in two stage:
        // TimeSec: absolute time at 'Second' level, unit: sec
        // TimeNanoSec: relative time at sub-second level, unit: nanosec
        // Final Trigger Time calculation: (TimeSec + TimeNanoSec*1.0e-9), unit: sec
        // Above irect calculation may have precision problem
        // for 'double'-'integer' conversion.
        m_ntuple1->addItem ("TriggerTime",  m_triggerTime);
        m_ntuple1->addItem ("TriggerTimeSec",  m_triggerTimeSec);
        m_ntuple1->addItem ("TriggerTimeNanoSec",  m_triggerTimeNanoSec);
        m_ntuple1->addItem ("TrigTimeInterval",  m_trigTimeInterval);
        
        // Adc sum for all channels
        m_ntuple1->addItem ("QSum",         m_QSum);

        // Number of channels that have Tdc, Adc record
        m_ntuple1->addItem ("ChannelSize",  m_nChannel, 0, 250);
        
        // Tdc multiplicity for each channel
        m_ntuple1->addItem ("MultiTDC",     m_nChannel, m_MultiTDC);

        // Adc value for each channel
        m_ntuple1->addItem ("ADC",          m_nChannel, m_adc);

        // Adc Gain for each channel
        m_ntuple1->addItem ("ADCGain",      m_nChannel, m_adcGain);

        // Adc Range for each channel
        m_ntuple1->addItem ("ADCRange",     m_nChannel, m_adcRange);

        // The clock cycle during ADC peaking-finding
        m_ntuple1->addItem ("ADCPeakingCycle", m_nChannel, m_adcPeakingCycle);

        // Pedestal for each channel
        m_ntuple1->addItem ("Pedestal",          m_nChannel, m_pedestal);

        // The first TDC for each channel.
        // TDC is recorded as the PMT hit time relative to trigger time,
        // then the earlier PMT hit time, the larger TDC value
        m_ntuple1->addItem ("FirstTDC",    m_nChannel, m_firstTdc);

        // The second to fourth TDC for each channel if multiple TDC hits exist
        m_ntuple1->addItem ("SecondTDC",    m_nChannel, m_secondTdc);
        m_ntuple1->addItem ("ThirdTDC",    m_nChannel, m_thirdTdc);
        m_ntuple1->addItem ("FourthTDC",    m_nChannel, m_fourthTdc);
        //m_ntuple1->addItem ("TDC",        m_nChannel*Max_MultiTDC, m_firstTdc);

        // Fee Channel ID
        m_ntuple1->addItem ("ChannelID",    m_nChannel, m_channelId);

        // The slot number that this Fee board loactes
        m_ntuple1->addItem ("Slot",         m_nChannel, m_slot);

        // The corresponding channel number on this Fee board
        m_ntuple1->addItem ("Connector",    m_nChannel, m_connector);

        // PMT Sensor ID
        m_ntuple1->addItem ("SensorID",    m_nChannel, m_sensorId);

        // The corresponding ring number on this Fee board
        m_ntuple1->addItem ("Ring",    m_nChannel, m_ring);

        // The corresponding column number on this Fee board
        m_ntuple1->addItem ("Column",    m_nChannel, m_column);

        // The Tdc value and channel number for the earliest hit in this event
        m_ntuple1->addItem ("EarliestHitChn",  m_earliestHitChn);
        m_ntuple1->addItem ("EarliestHitTdc",  m_earliestHitTdc);

        // The Tdc value and channel number for the latest hit in this event
        m_ntuple1->addItem ("LatestHitChn",  m_latestHitChn);
        m_ntuple1->addItem ("LatestHitTdc",  m_latestHitTdc);
      }
      else { // Did not manage to book the NTuple....
        error() << "Can not book NTuple:" << long(m_ntuple1) << endmsg;
        return StatusCode::FAILURE;
      }
    }
  }

  //  Book NTuple 2
  if(m_checkCalibReadout) {
    NTuplePtr nt2(ntupleSvc(), "FILE1/CalibReadout");
    if ( nt2 ) m_ntuple2 = nt2;
    else {
      m_ntuple2 = ntupleSvc()->book("FILE1/CalibReadout", CLID_ColumnWiseTuple, "CalibReadout");
      if ( m_ntuple2 )    {
        m_ntuple2->addItem ("TriggerNumber",m_calibTriggerNumber);
        m_ntuple2->addItem ("EvtNumber",    m_calibEvtNumber);
        m_ntuple2->addItem ("TriggerTimeSec",  m_calibTriggerTimeSec);
        m_ntuple2->addItem ("TriggerTimeNanoSec",  m_calibTriggerTimeNanoSec);
        //m_ntuple2->addItem ("EarliesTime",  m_calibEarliestTime);
        m_ntuple2->addItem ("QSum",         m_calibQSum);
        m_ntuple2->addItem ("ChannelSize",  m_nCalibChannel, 0, 250);
        m_ntuple2->addItem ("Charge",       m_nCalibChannel, m_calibAdc);
        m_ntuple2->addItem ("Time",         m_nCalibChannel, m_calibTdc);
        m_ntuple2->addItem ("Ring",         m_nCalibChannel, m_calibRing);
        m_ntuple2->addItem ("Column",       m_nCalibChannel, m_calibColumn);
      }
      else { // Did not manage to book the NTuple....
        error() << "Can not book NTuple:" << long(m_ntuple2) << endmsg;
        return StatusCode::FAILURE;
      }
    }
  }

  //  Book NTuple 3
  if(m_checkRec) {
    NTuplePtr nt3(ntupleSvc(), "FILE1/Rec");
    if ( nt3 ) m_ntuple3 = nt3;
    else {
      m_ntuple3 = ntupleSvc()->book("FILE1/Rec", CLID_ColumnWiseTuple, "Rec");
      if ( m_ntuple3 )    {
        m_ntuple3->addItem ("RecSize",  m_nRec, 0,  30);
        m_ntuple3->addItem ("Energy",   m_nRec, m_energy);
        m_ntuple3->addItem ("RecX",     m_nRec, m_recX);
        m_ntuple3->addItem ("RecY",     m_nRec, m_recY);
        m_ntuple3->addItem ("RecZ",     m_nRec, m_recZ);
        m_ntuple3->addItem ("RecPx",    m_nRec, m_recPx);
        m_ntuple3->addItem ("RecPy",    m_nRec, m_recPy);
        m_ntuple3->addItem ("RecPz",    m_nRec, m_recPz);
      }
      else { // Did not manage to book the NTuple....
        error() << "Can not book NTuple:" << long(m_ntuple3) << endmsg;
        return StatusCode::FAILURE;
      }
    }
  }

  //  Book NTuple 4
  if(m_checkLtb) {
    NTuplePtr nt4(ntupleSvc(), "FILE1/Ltb");
    if ( nt4 ) m_ntuple4 = nt4;
    else {
      m_ntuple4 = ntupleSvc()->book("FILE1/Ltb", CLID_ColumnWiseTuple, "Ltb");
      if ( m_ntuple4 )    {
        info() << "Start m_ntuple4 addItem successful!" << endmsg;
        m_ntuple4->addItem("LtbFrameNum",           m_ltbFrameNum, 0, 20);
        m_ntuple4->addItem("LtbTimestampType",      m_ltbFrameNum, m_ltbTimestampType);
        m_ntuple4->addItem("LtbTrigTimeSec",        m_ltbFrameNum, m_ltbTrigTimeSec);
        m_ntuple4->addItem("LtbTrigTimeNanoSec",    m_ltbFrameNum, m_ltbTrigTimeNanoSec);
        m_ntuple4->addItem("LtbTrigType",           m_ltbFrameNum, m_ltbTrigType);
        m_ntuple4->addItem("LtbHSum",               m_ltbFrameNum, m_ltbHSum);
        m_ntuple4->addItem("LtbESumComp",           m_ltbFrameNum, m_ltbESumComp);
        m_ntuple4->addItem("LtbESumADC",            m_ltbFrameNum, m_ltbESumADC);
        m_ntuple4->addItem("LtbBlockedValidTrigger",m_ltbFrameNum, m_ltbBlockedValidTrigger);
      }
      else { // Did not manage to book the NTuple....
        error() << "Can not book NTuple:" << long(m_ntuple4) << endmsg;
        return StatusCode::FAILURE;
      }
    }
  }

  return StatusCode::SUCCESS;
}

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

  if(m_printFreq>0 && m_execNum%m_printFreq==0) cout << "---------- " << m_execNum << endl;

  map<int,int> m_sensorIdMap;

  //----------------------------------------------------------------------------------------
  //GenHeader

  if(m_checkGen) {

    GenHeader* gh = get<GenHeader>("/Event/Gen/GenHeader");

    if (gh == 0) {
      m_log << MSG::ERROR << " =======> Requested Object can not be accessable." << endreq;
      return StatusCode::FAILURE;
    }

    if (m_printFreq > 0 && m_execNum % m_printFreq == 0) {
      //m_log << MSG::INFO << "Gen Header: " << *gh << endreq;
      m_log << MSG::INFO << "execNumber: " << gh->execNumber() << endreq;
      //gh->event()->print();
      m_log << MSG::INFO << "signal_process_id= " << gh->event()->signal_process_id() << endreq;
      m_log << MSG::INFO << "vertices_size= " << gh->event()->vertices_size() << endreq;
    }

    m_eventType = gh->event()->signal_process_id();
    m_nVertex = gh->event()->vertices_size();
    m_nParticle = gh->event()->particles_size();

    unsigned int iVertex = 0;
    for(HepMC::GenEvent::vertex_const_iterator it = gh->event()->vertices_begin();
        it != gh->event()->vertices_end();
        it++ ) {
      if(m_printFreq > 0 && m_execNum % m_printFreq == 0) {
        m_log << MSG::INFO << "vertex= " << (*it)->position().x() 
              <<","<< (*it)->position().y()<<","<<(*it)->position().z()
              << endreq;
      }
      m_verX0[iVertex] = (*it)->position().x();
      m_verY0[iVertex] = (*it)->position().y();
      m_verZ0[iVertex] = (*it)->position().z();
      iVertex++;
    }

    unsigned int iParticle = 0;
    for(HepMC::GenEvent::particle_const_iterator it = gh->event()->particles_begin();
        it != gh->event()->particles_end();
        it++ ) {
      if(m_printFreq > 0 && m_execNum % m_printFreq == 0) {
        m_log << MSG::INFO << "particle momentum= " 
              << (*it)->momentum().x() <<","
              << (*it)->momentum().y() <<","
              << (*it)->momentum().z() 
              << endreq;
      }
      m_verPx[iParticle] = (*it)->momentum().x();
      m_verPy[iParticle] = (*it)->momentum().y();
      m_verPz[iParticle] = (*it)->momentum().z();
      iParticle++;
    }

    m_ntuple0->write();

  }//GenHeader

  //----------------------------------------------------------------------------------------
  //ReadoutHeader

  if(m_checkReadout) {

    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());
    if(!readout) return StatusCode::SUCCESS;
    ReadoutPmtCrate* crate = dynamic_cast<ReadoutPmtCrate*>(readout);
    ReadoutPmtCrate::PmtChannelReadouts channels = crate->channelReadout();

    if(m_printFreq > 0 && m_execNum % m_printFreq == 0) {
      m_log << MSG::INFO << "Readout Header: " << *roh << endreq;
      m_log << MSG::INFO << "channels=" << crate->channelReadout().size()  << endreq;
    }

    //  Context, ServiceMode for this data
    int task = 0;
    ServiceMode svcMode(roh->context(), task);

    if(m_execNum==0) m_firstTime = readout->triggerTime();

    m_triggerNumber = crate->triggerNumber();
    m_triggerTime = (readout->triggerTime()-m_firstTime).GetSeconds();
    m_triggerTimeSec = readout->triggerTime().GetSec();
    m_triggerTimeNanoSec = readout->triggerTime().GetNanoSec();
    if(m_execNum==0) {
      m_trigTimeInterval = 0.0;
    }
    else {
      m_trigTimeInterval = (m_triggerTimeSec - last_trig_timeSec)
        + 1.0e-9*( m_triggerTimeNanoSec - last_trig_timeNanoSec);
    }

    last_trig_timeSec=readout->triggerTime().GetSec();
    last_trig_timeNanoSec=readout->triggerTime().GetNanoSec();

    /* Another method to get trigger time
       currentTriggerTime = readout->triggerTime();

       if(m_execNum==0) {
       lastTriggerTime = readout->triggerTime();
       }
       trigTimeInterval = currentTriggerTime - lastTriggerTime;
       m_triggerTimeSec = currentTriggerTime.GetSec();
       m_triggerTimeNanoSec = currentTriggerTime.GetNanoSec();
       m_trigTimeInterval = trigTimeInterval.GetSeconds();

       lastTriggerTime = readout->triggerTime();
       */

    m_triggerType = crate->triggerType();

    m_QSum = 0.0;
    m_nChannel = crate->channelReadout().size();
    unsigned int ichannel = 0;
    map<long, long> firstHitTdcMap;
    vector<long> firstHitTdcVec;
    ReadoutPmtCrate::PmtChannelReadouts::iterator it;
    for (it=channels.begin(); it != channels.end(); it++) {

      const vector<int>& adc = it->second.adc();
      const vector<int>& tdc = it->second.tdc();
      const vector<int>& adcPeakingCycle = it->second.adcCycle();
      const vector<int>& adcRange = it->second.adcRange();
      int firstTdc = it->second.earliestTdc();
      DayaBay::FeeChannelId channelId = it->first;
      unsigned int size = adc.size();
      int slot = channelId.board();
      int connector = channelId.connector() - 1;
      int localChannelId = slot*16 + connector;

      DayaBay::AdPmtSensor adPmtId = m_cableSvc->adPmtSensor(channelId, svcMode);
      m_sensorIdMap[adPmtId.sensorId()] = ichannel;

      int ring = adPmtId.ring();
      int column = adPmtId.column();
      int sensorId;
      if(ring==0) { //2 inch PMT
        sensorId = 192 + column;
      } else {
        sensorId = (column-1)*8+ring;
      }
      //if(size != tdc.size()) {
      //  m_log << MSG::ERROR << "ADC and TDC vector have different size!" << endreq;
      //  return StatusCode::FAILURE;
      //}
      if(size>0) {
        m_adc[ichannel] = it->second.earliestAdc();
        m_QSum += it->second.earliestAdc();
        m_adcPeakingCycle[ichannel] = it->second.adcCycle(it->second.earliestTdcIndex());
        m_adcRange[ichannel] = it->second.adcRange(it->second.earliestTdcIndex());
        m_pedestal[ichannel] = it->second.pedestal(it->second.earliestTdcIndex());

        m_MultiTDC[ichannel] = tdc.size();
        m_channelId[ichannel] = localChannelId;
        m_slot[ichannel] = slot;
        m_connector[ichannel] = connector;
        m_sensorId[ichannel] = sensorId;
        m_ring[ichannel] = ring;
        m_column[ichannel] = column;

        m_firstTdc[ichannel] = firstTdc;
        firstHitTdcVec.push_back(firstTdc);
        firstHitTdcMap[firstTdc] = localChannelId;


        if(size==1) {
          m_secondTdc[ichannel]  = -9999;
          m_thirdTdc[ichannel]  = -9999;
          m_fourthTdc[ichannel]  = -9999;
        }
        if(size==2) {
          m_secondTdc[ichannel]  = tdc[1];
          m_thirdTdc[ichannel]  = -9999;
          m_fourthTdc[ichannel]  = -9999;
        }
        if(size==3) {
          m_secondTdc[ichannel]  = tdc[1];
          m_thirdTdc[ichannel]  = tdc[2];
          m_fourthTdc[ichannel]  = -9999;
        }
        if(size>=4) {
          m_secondTdc[ichannel]  = tdc[1];
          m_thirdTdc[ichannel]  = tdc[2];
          m_fourthTdc[ichannel]  = tdc[3];
        }

        ichannel++;
      }

      if(m_printFreq > 0 && m_execNum % m_printFreq == 0) {
        m_log << MSG::INFO << it->second << endreq;
      }
    }

    if(channels.size()>0) {
      sort(firstHitTdcVec.begin(), firstHitTdcVec.end());
      m_earliestHitTdc = firstHitTdcVec[ichannel-1];
      m_latestHitTdc = firstHitTdcVec[0];
      m_earliestHitChn = (firstHitTdcMap.find(m_earliestHitTdc))->second;
      m_latestHitChn = (firstHitTdcMap.find(m_latestHitTdc))->second;
    }

    m_ntuple1->write();

  }//ReadoutHeader


  //----------------------------------------------------------------------------------------
  //CalibReadoutHeader

  if(m_checkCalibReadout) {

    CalibReadoutHeader* croh = get<CalibReadoutHeader>("/Event/CalibReadout/CalibReadoutHeader");
    if (croh == 0) {
      m_log << MSG::ERROR << " =======> Requested Object can not be accessable." << endreq;
      return StatusCode::FAILURE;
    }
    m_calibEvtNumber = croh->execNumber();

    CalibReadout* calibReadout = const_cast<CalibReadout*>(croh->calibReadout());
    CalibReadoutPmtCrate* calibCrate = dynamic_cast<CalibReadoutPmtCrate*>(calibReadout);
    CalibReadoutPmtCrate::PmtChannelReadouts calibChannels = calibCrate->channelReadout();

    if(m_printFreq > 0 && m_execNum % m_printFreq == 0) {
      m_log << MSG::INFO << "CalibReadout Header: " << *croh << endreq;
      m_log << MSG::INFO << "calibChannels=" << calibChannels.size()  << endreq;
    }

    m_calibTriggerNumber = calibCrate->triggerNumber();
    m_calibTriggerTimeSec = calibCrate->triggerTime().GetSec();
    m_calibTriggerTimeNanoSec = calibCrate->triggerTime().GetNanoSec();

    m_nCalibChannel = calibCrate->channelReadout().size();
    unsigned int ichannel = 0;
    double qsum = 0;
    CalibReadoutPmtCrate::PmtChannelReadouts::iterator it;
    for (it=calibChannels.begin(); it != calibChannels.end(); it++) {

      if(m_checkReadout) {  //associate readout and calib readout
        ichannel = m_sensorIdMap[it->pmtSensorId().sensorId()];
      }
      //cout << "ichannel= " << ichannel << endl;

      if(it->size()>0) {
        // get ring and column
        DayaBay::AdPmtSensor adPmtSensor(it->pmtSensorId().sensorId());
        m_calibRing[ichannel] = adPmtSensor.ring();
        m_calibColumn[ichannel] = adPmtSensor.column();

        //get earliest charge and time of this PMT
        double earliestCharge = it->earliestCharge();
        double earliestTime= it->earliestTime();

        m_calibAdc[ichannel] = earliestCharge;
        m_calibTdc[ichannel] = earliestTime;

        qsum += earliestCharge;

        if(!m_checkReadout) ichannel++;
      }
      m_calibQSum = qsum;

      if(m_printFreq > 0 && m_execNum % m_printFreq == 0) {
        m_log << MSG::INFO << (*it)  << endreq;
      }
    }

    m_ntuple2->write();

  }//CalibReadoutHeader


  //----------------------------------------------------------------------------------------
  //RecHeader

  if(m_checkRec) {

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

    RecTrigger& recTrigger = rh->recTrigger();
    m_nRec = 1;
    m_energy[0] = recTrigger.energy();
    m_recX[0] = recTrigger.position().x();
    m_recY[0] = recTrigger.position().y();
    m_recZ[0] = recTrigger.position().z();
    m_recPx[0] = recTrigger.direction().x();
    m_recPy[0] = recTrigger.direction().y();
    m_recPz[0] = recTrigger.direction().z();

    m_ntuple3->write();

  }

  //----------------------------------------------------------------------------------------
  // Ltb information
  if(m_checkLtb) {
    debug() << "Check Ltb information" << endreq;
    RawEventHeader* reh = get<RawEventHeader>(RawEventHeaderLocation::Default);
    if(reh == 0) {
      m_log << MSG::ERROR << "=======> Request Object can not be accessable." << endreq;
      return StatusCode::FAILURE;
    }

    const vector<DayaBay::RawRom*>& modules = reh->modules();
    for(unsigned int i=0; i<modules.size(); i++) {
      if(modules[i]->type()==3) { // RomLtb
        DayaBay::RawRomLtb* rawRomLtb;
        rawRomLtb = dynamic_cast<DayaBay::RawRomLtb*>(modules[i]);
        const std::vector<DayaBay::RawLtbFrame*> & ltbFrame = rawRomLtb->frames();
        m_ltbFrameNum = ltbFrame.size();
        for(size_t j=0; j<ltbFrame.size(); j++) {
          m_ltbTimestampType[j] = ltbFrame[j]->timestampType() ? 1 : 0;
          m_ltbTrigTimeSec[j] = ltbFrame[j]->timestamp().GetSec();
          m_ltbTrigTimeNanoSec[j] = ltbFrame[j]->timestamp().GetNanoSec();
          m_ltbTrigType[j] = ltbFrame[j]->triggerSrc();
          m_ltbHSum[j] = ltbFrame[j]->hsum();
          m_ltbESumComp[j] = ltbFrame[j]->esumComp();
          m_ltbESumADC[j] = ltbFrame[j]->esumADC();
          m_ltbBlockedValidTrigger[j] = ltbFrame[j]->blockedValidTrigger();
        }
        break;
      }
    }

    m_ntuple4->write();
  }

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

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

---