ResetEtsAlg.cxx

Go to the documentation of this file.

#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/SmartDataPtr.h"
#include <iomanip>
#include <typeinfo>
 
#include "CalibData/Ets/CorrectedETSCal.h"
#include "EventModel/EventHeader.h"
#include "ResetEtsAlg.h"
#include <algorithm>
#include <fstream>
 
using namespace std;
 
DECLARE_COMPONENT( ResetEtsAlg )
ResetEtsAlg::ResetEtsAlg( const std::string& name, ISvcLocator* pSvcLocator )
    : Algorithm( name, pSvcLocator )
    , m_run( -1 )
    , m_count( 0 )
    , m_alreadyInDB( false )
    , m_curIndex( 0 ) {
  declareProperty( "dump", m_dump = false );
  declareProperty( "ReadInjSigIntervalFromDB", m_readInjSigIntervalFromDB = true );
  declareProperty( "ReadInjSigTimeFromDB", m_readInjSigTimeFromDB = true );
  declareProperty( "InjSigInterval", m_interval = 60 );
  declareProperty( "RunListFile", m_runListFile );
  m_printInterval = true;
}
 
StatusCode ResetEtsAlg::initialize() {
  MsgStream log( msgSvc(), name() );
 
  StatusCode sc = service( "CalibDataSvc", m_calibDataSvc );
  if ( sc.isFailure() )
  {
    log << MSG::FATAL << "can not get CalibDataSvc" << endmsg;
    return StatusCode::FAILURE;
  }
 
  sc = service( "InjSigIntervalSvc", m_InjSigIntervalSvc );
  if ( sc != StatusCode::SUCCESS )
  { log << MSG::FATAL << "can not use InjSigIntervalSvc" << endmsg; }
 
  sc = service( "InjSigTimeSvc", m_InjSigTimeSvc );
  if ( sc != StatusCode::SUCCESS )
  { log << MSG::FATAL << "can not use InjSigTimeSvc" << endmsg; }
 
  if ( !m_runListFile.empty() )
  {
    int           runNo;
    std::ifstream ifs( m_runListFile.c_str() );
    ifs >> runNo;
    while ( ifs.good() )
    {
      m_runList.push_back( runNo );
      ifs >> runNo;
    }
    m_fixer = NULL;
  }
  else { m_fixer = new EtsFixing(); }
 
  return StatusCode::SUCCESS;
}
 
StatusCode ResetEtsAlg::execute() {
  MsgStream log( msgSvc(), name() );
 
  SmartDataPtr<Event::EventHeader> eventHeader( eventSvc(), "/Event/EventHeader" );
 
  // the corrected ETS is pre-processed
  if ( m_fixer == NULL )
  {
    // first event
    if ( m_run == -1 )
    {
      m_run = eventHeader->runNumber();
      if ( std::find( m_runList.begin(), m_runList.end(), m_run ) != m_runList.end() )
      {
        SmartDataPtr<CalibData::CorrectedETSCal> calConst( m_calibDataSvc,
                                                           "/Calib/CorrectedETS" );
        if ( calConst ) { m_alreadyInDB = true; }
        else
        {
          log << MSG::FATAL << "no result in DB for run " << m_run << endmsg;
          return StatusCode::FAILURE;
        }
      }
    }
 
    // use corrected ETS in database if available
    if ( m_alreadyInDB )
    {
      if ( m_run != eventHeader->runNumber() )
      {
        log << MSG::FATAL << "crossed runs are not supported" << endmsg;
        return StatusCode::FAILURE;
      }
 
      SmartDataPtr<CalibData::CorrectedETSCal> calConst( m_calibDataSvc,
                                                         "/Calib/CorrectedETS" );
 
      if ( m_count >= calConst->getNpar() ||
           eventHeader->eventNumber() != calConst->getEvt( m_count ) )
      {
        log << MSG::FATAL << "only 1 input file is supported" << endmsg;
        return StatusCode::FAILURE;
      }
 
      eventHeader->setRawEtsT1( eventHeader->etsT1() );
      eventHeader->setEtsT1( calConst->getEts1( m_count ) );
      eventHeader->setEtsT2( calConst->getEts2_pre( m_count ) );
      eventHeader->setEtsFlag( calConst->getFlag_pre( m_count ) );
 
      ++m_count;
 
      return StatusCode::SUCCESS;
    }
    /// else: a good run
    /// no need to correct ETS, and IST will be reset later
  }
  else
  {
    /// no pre-processed result is available, and then calculate ETS on the fly ...
    m_fixer->fixT1( eventHeader );
  }
 
  /// reset IST and the flag...
 
  if ( m_readInjSigTimeFromDB )
  {
    int Npar = m_InjSigTimeSvc->getNpar();
    for ( int i = 0; i < Npar; i++ )
    {
      int       flag = m_InjSigTimeSvc->getFlag( i );
      ULong64_t time = m_InjSigTimeSvc->getIST( i );
      m_vecFlag.push_back( flag );
      m_vecTime.push_back( time );
      if ( m_dump ) { std::cout << "flag: " << flag << "  time: " << time << std::endl; }
    }
    m_readInjSigTimeFromDB = false;
  }
 
  if ( m_readInjSigIntervalFromDB )
  {
    m_interval                 = double( m_InjSigIntervalSvc->getTInterval() );
    m_readInjSigIntervalFromDB = false;
  }
 
  if ( m_printInterval )
  {
    cout << "ResetEts::execute() m_interval = " << m_interval << endl;
    m_printInterval = false;
  }
 
  unsigned long t1 = eventHeader->etsT1(); // 500ns
  unsigned long t2 = eventHeader->etsT2(); // 500ns
 
  if ( m_dump )
  {
 
    std::cout << "raw data" << std::endl
              << "Event: " << eventHeader->eventNumber()
              << "  run: " << eventHeader->runNumber() << "  time: " << eventHeader->time()
              << "  ETS_old: " << t1 << "  IST_old: " << t2 << std::endl;
  }
 
  int           unit     = 2000;
  double        size     = m_interval * unit;
  unsigned long ets2_pre = 0;
  int           flag_pre = 0;
 
  int vec_size = m_vecTime.size();
  for ( int i = m_curIndex; i < vec_size; i++ )
  {
    if ( t1 < m_vecTime[i] )
    {
      if ( i == 0 )
      {
        flag_pre   = m_vecFlag[i];
        ets2_pre   = m_vecTime[i];
        m_curIndex = i;
        break;
      }
      else
      {
 
        double delta = ( (double)m_vecTime[i - 1] - (double)t1 ) / size;
 
        if ( delta > 0 && t1 != 0 )
        {
          int num = ceil( delta );
          i       = i - num - 1;
          if ( i < 0 )
          {
            i = -1; // for protect
          }
          continue;
        }
        else
        {
          ets2_pre   = m_vecTime[i - 1];
          flag_pre   = m_vecFlag[i - 1];
          m_curIndex = i;
          break;
        }
      }
    }
    else if ( t1 >= m_vecTime[vec_size - 1] )
    {
      flag_pre = m_vecFlag[vec_size - 1];
      ets2_pre = m_vecTime[vec_size - 1];
      break;
    }
  }
 
  // eventHeader->setEtsT1(t1);
  eventHeader->setEtsT2( ets2_pre );
  eventHeader->setEtsFlag( flag_pre );
 
  if ( m_dump )
  {
 
    std::cout << "ReSetETSAlg" << std::endl
              << "Event: " << eventHeader->eventNumber()
              << "  run: " << eventHeader->runNumber() << "  time: " << eventHeader->time()
              << "  ETS_new: " << eventHeader->etsT1() << "  IST_new: " << eventHeader->etsT2()
              << "  flag_pre: " << eventHeader->etsFlag() << std::endl;
  }
 
  return StatusCode::SUCCESS;
}
 
StatusCode ResetEtsAlg::finalize() {
  if ( m_fixer != NULL ) { delete m_fixer; }
 
  return StatusCode::SUCCESS;
}