GetRawETS.cxx

Go to the documentation of this file.

#include <iomanip>
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/SmartDataPtr.h"
 
#include "EventModel/EventHeader.h"
 
#include "GetRawETS.h"
 
using namespace std;
 
GetRawETS::GetRawETS(const std::string& name, ISvcLocator* pSvcLocator)
   : Algorithm(name, pSvcLocator),
     m_flag(0),
     m_ets2(0)
{
   declareProperty("dump",     m_dump = false);
   declareProperty("InjectionInterval",  m_interval = 60); /*in ms*/
   declareProperty("NumFill",  m_nfill = 1);
   declareProperty("FirstEvtInTopUpFlag",  m_1stFlag = 0);
   declareProperty("ETS_FILE", m_etsfile = "ets2.root");
   declareProperty("ReadFromDB", m_readFromDB = true);
 
   m_printInterval = true;
}
 
//static TTree*        _TestTree;
//static unsigned long _Event;
//static unsigned int  _EvtTime;
//static unsigned long _ETS1;
//static unsigned long _ETS2;
 
StatusCode GetRawETS::initialize()
{
   MsgStream log(msgSvc(), name());
 
   m_tree = new TTree("ist", "The IST time for BES3 raw data");
   m_tree->Branch("flag", &m_flag, "flag/I");
   m_tree->Branch("IST", &m_ets2, "IST/l");
 
   m_root = TFile::Open( m_etsfile.c_str(), "RECREATE");
   m_tree->SetDirectory(m_root);
 
   //_TestTree = new TTree("test", "The test TTree");
   //_TestTree->Branch("event", &_Event, "event/I");
   //_TestTree->Branch("time", &_EvtTime, "time/I");
   //_TestTree->Branch("ets1", &_ETS1, "ets1/l");
   //_TestTree->Branch("ets2", &_ETS2, "ets2/l");
   //_TestTree->SetDirectory(m_root);
 
   StatusCode sc = service("InjSigIntervalSvc", m_InjSigIntervalSvc);
   if( sc != StatusCode::SUCCESS ){
      log << MSG::FATAL << "can not use InjSigIntervalSvc" << endreq;
   }
   return StatusCode::SUCCESS;
}
 
StatusCode GetRawETS::execute()
{
   MsgStream log(msgSvc(), name());
 
   SmartDataPtr<Event::EventHeader> eventHeader(eventSvc(),"/Event/EventHeader");
   unsigned long t1 = eventHeader->etsT1();  //500ns
   unsigned long t2 = eventHeader->etsT2();  //500ns
 
   if(m_readFromDB){
      m_interval = m_InjSigIntervalSvc->getTInterval();
      m_readFromDB = false;
   }
 
   if(m_printInterval){
    cout << "GetRawETS::execute() m_interval = " << m_interval << endl;
    m_printInterval = false;
   }
   if ( m_dump ) {
       double dt1 = (double(t1)/double(2000000.));  //in seconds
       double dt2 = (double(t2)/double(2000000.));  //in seconds
 
       std::cout << "Event: " << eventHeader->eventNumber()
           << "  run: " <<  eventHeader->runNumber()
           << "  time: " << eventHeader->time()
           << "  EtsT1: " << t1
           << "  EtsT2: " << t2
           << std::endl;
   }
 
   if ( t2 != 0 && t2 != m_ets2 ) {
       m_ets2 = t2;
       m_vec.push_back(m_ets2);
   }
 
   //{
   //    _Event = eventHeader->eventNumber();
   //    _EvtTime = eventHeader->time();
   //    _ETS1 = t1;
   //    _ETS2 = t2;
   //    _TestTree->Fill();
   //}
 
   return StatusCode::SUCCESS;
}
 
StatusCode GetRawETS::finalize()
{
    if ( m_vec.empty() ) {
        // DO NOT CRASH when m_vec is empty
        m_root->Write();
        return StatusCode::SUCCESS;
    }
 
    std::sort(m_vec.begin(), m_vec.end());
    m_vec.erase(std::unique(m_vec.begin(), m_vec.end()), m_vec.end());
 
    unsigned long _interval = m_interval * 2000;  // -> 500ns
 
    // Fill the Tree
    {
        unsigned long tmp = m_vec.front();
        for ( int j = m_nfill; j > 0; --j ) {
            if ( tmp <= _interval*j ) continue;
            m_flag = 10 + j;
            m_ets2 = tmp - _interval*j;
            m_tree->Fill();  //case 13,12,11: prepend N addtional ets to current injection period
        }
        m_flag = m_1stFlag;
        m_ets2 = tmp;
        m_tree->Fill();  //the first real ets
    }
    for ( unsigned int i = 1; i < m_vec.size(); ++i ) {
        unsigned long diff = m_vec[i] - m_vec[i-1];
        bool _1stEvtInTopUp = false;
 
        if ( diff > _interval*(m_nfill+1)*2+10000 ) {  //long gap: +5ms for safe
            _1stEvtInTopUp = true;
            for ( int j = 1; j < m_nfill+1; ++j ) {
                m_flag = 20 + j;
                m_ets2 = m_vec[i-1] + _interval*j;
                m_tree->Fill();  //case 21,22,23: append N addtional ets to previous injection period
            }
            for ( int j = m_nfill; j > 0; --j ) {
                m_flag = 10 + j;
                m_ets2 = m_vec[i] - _interval*j;
                m_tree->Fill();  //case 13,12,11: prepend N addtional ets to current injection period
            }
        }
        else if ( diff > _interval+10000 ) {  //missing ets2: +5ms for safe
            for ( int j = 1; j < 10; ++j ) {
                m_flag = 1;
                m_ets2 = m_vec[i-1] + _interval*j;  //m_interval * ms * j
                if ( m_ets2 >= m_vec[i] || m_vec[i]-m_ets2 < 10000 ) {  //5ms
                    break;
                }
                m_tree->Fill();  //case 1: fill the missing ets2 explicitly
            }
        }
 
        m_flag = _1stEvtInTopUp ? m_1stFlag : 0;
        m_ets2 = m_vec[i];
        m_tree->Fill();  //case 0: good ets2
    }
    {
        unsigned long tmp = m_vec.back();
        for ( int j = 1; j < m_nfill+1; ++j ) {
            m_flag = 20 + j;
            m_ets2 = tmp + _interval*j;
            m_tree->Fill();  //case 21,22,23: append N addtional ets to the last injection period
        }
    }
 
    // Write ROOT file
    m_root->Write();
 
    return StatusCode::SUCCESS;
}