GetRawETS.cxx

Go to the documentation of this file.

#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/SmartDataPtr.h"
#include <iomanip>
 
#include "EventModel/EventHeader.h"
 
#include "GetRawETS.h"
 
using namespace std;
DECLARE_COMPONENT( GetRawETS )
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" << endmsg; }
  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;
}