OfflineEvtFilterSvc.cxx

Go to the documentation of this file.

#include "OfflineEvtFilterSvc.h"
 
#include "GaudiKernel/Bootstrap.h"
#include "GaudiKernel/DataSvc.h"
#include "GaudiKernel/IIncidentSvc.h"
#include "GaudiKernel/IInterface.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/Incident.h"
#include "GaudiKernel/Kernel.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/SmartDataPtr.h"
#include "GaudiKernel/StatusCode.h"
 
#include "CalibData/CalibModel.h"
#include "CalibData/Ets/OffEvtFilterCal.h"
#include "EventModel/EventHeader.h"
 
#include <fstream>
#include <iomanip>
#include <iostream>
 
using namespace std;
 
DECLARE_COMPONENT( OfflineEvtFilterSvc )
OfflineEvtFilterSvc::OfflineEvtFilterSvc( const string& name, ISvcLocator* svcloc )
    : base_class( name, svcloc ) {}
 
OfflineEvtFilterSvc::~OfflineEvtFilterSvc() {}
 
StatusCode OfflineEvtFilterSvc::initialize() {
  MsgStream log( msgSvc(), name() );
  log << MSG::INFO << "OfflineEvtFilterSvc::initialize()" << endmsg;
 
  StatusCode sc = Service::initialize();
  if ( sc.isFailure() ) return sc;
 
  IIncidentSvc* incsvc;
  sc           = service( "IncidentSvc", incsvc );
  int priority = 100;
  if ( sc.isSuccess() ) { incsvc->addListener( this, "NewRun", priority ); }
 
  sc = service( "CalibDataSvc", m_pCalDataSvc, true );
  if ( sc == StatusCode::SUCCESS )
  { log << MSG::INFO << "Retrieve IDataProviderSvc" << endmsg; }
  else { log << MSG::FATAL << "can not get IDataProviderSvc" << endmsg; }
 
  return StatusCode::SUCCESS;
}
 
StatusCode OfflineEvtFilterSvc::finalize() {
  MsgStream log( msgSvc(), name() );
  log << MSG::INFO << "OfflineEvtFilterSvc::finalize()" << endmsg;
 
  m_npar = 0;
  m_flag.clear();
  m_tBegin.clear();
  m_tEnd.clear();
 
  return StatusCode::SUCCESS;
}
 
void OfflineEvtFilterSvc::handle( const Incident& inc ) {
  MsgStream log( msgSvc(), name() );
  log << MSG::DEBUG << "handle: " << inc.type() << endmsg;
 
  if ( inc.type() == "NewRun" )
  {
    log << MSG::DEBUG << "NewRun" << endmsg;
 
    if ( !initCalibConst() )
    { log << MSG::ERROR << "can not initilize OffEvtFilter Constants" << endmsg; }
  }
}
 
bool OfflineEvtFilterSvc::initCalibConst() {
  MsgStream log( msgSvc(), name() );
  log << MSG::INFO << "read calib const from TCDS" << endmsg;
 
  IDataProviderSvc* eventSvc = NULL;
  Gaudi::svcLocator()->service( "EventDataSvc", eventSvc );
  SmartDataPtr<Event::EventHeader> eventHeader( eventSvc, "/Event/EventHeader" );
  if ( !eventHeader )
  {
    log << MSG::FATAL << "Could not find Event Header" << endmsg;
    return false;
  }
 
  // clear calibration constants vectors
  m_npar = 0;
  m_flag.clear();
  m_tBegin.clear();
  m_tEnd.clear();
 
  string                                   fullPath = "/Calib/OffEvtFilter";
  SmartDataPtr<CalibData::OffEvtFilterCal> calConst( m_pCalDataSvc, fullPath );
  if ( !calConst )
  {
    log << MSG::ERROR << "can not get OffEvtFilter via SmartPtr" << endmsg;
    return false;
  }
 
  m_runFrom   = calConst->getRunFrom();
  m_runTo     = calConst->getRunTo();
  m_eventFrom = calConst->getEventFrom();
  m_eventTo   = calConst->getEventTo();
  m_npar      = calConst->getNpar();
 
  std::vector<double> tBegin[2];
  std::vector<double> tEnd[2];
 
  for ( int i = 0; i < m_npar; i++ )
  {
    int flag = calConst->getFlag( i ); // 0 or 1
    tBegin[flag].push_back( calConst->getTBegin( i ) );
    tEnd[flag].push_back( calConst->getTEnd( i ) );
  }
 
  for ( int i = 0; i < 2; ++i )
  { // loop for flag: 0 or 1
    std::vector<double>& _tBegin = tBegin[i];
    std::vector<double>& _tEnd   = tEnd[i];
    int                  _nPar   = _tBegin.size();
    // sort
    if ( _nPar > 1 )
    {
      for ( int j = 0; j < _nPar - 1; ++j )
      {
        for ( int k = j + 1; k < _nPar; ++k )
        {
          if ( _tBegin[j] > _tBegin[k] )
          {
            double _ttmp = _tBegin[j];
            _tBegin[j]   = _tBegin[k];
            _tBegin[k]   = _ttmp;
            _ttmp        = _tEnd[j];
            _tEnd[j]     = _tEnd[k];
            _tEnd[k]     = _ttmp;
          }
        }
      }
    }
    // set to class data members
    for ( int j = 0; j < _nPar; ++j )
    {
      m_flag.push_back( i ); // 0 or 1
      m_tBegin.push_back( _tBegin[j] );
      m_tEnd.push_back( _tEnd[j] );
    }
  }
 
  return true;
}