OfflineEvtFilterSvc.cxx

Go to the documentation of this file.

#include "OfflineEvtFilterSvc/OfflineEvtFilterSvc.h"
 
#include "GaudiKernel/Kernel.h"
#include "GaudiKernel/IInterface.h"
#include "GaudiKernel/StatusCode.h"
#include "GaudiKernel/SvcFactory.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/IIncidentSvc.h"
#include "GaudiKernel/Incident.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/Bootstrap.h"
#include "GaudiKernel/SmartDataPtr.h"
#include "GaudiKernel/DataSvc.h"
 
#include "EventModel/EventHeader.h"
#include "CalibData/Ets/OffEvtFilterCal.h"
#include "CalibData/CalibModel.h"
 
#include <iomanip>
#include <iostream>
#include <fstream>
 
using namespace std;
 
DECLARE_COMPONENT(OfflineEvtFilterSvc)
OfflineEvtFilterSvc::OfflineEvtFilterSvc( const string& name, ISvcLocator* svcloc) :
     base_class (name, svcloc) {
}
 
OfflineEvtFilterSvc::~OfflineEvtFilterSvc(){
}
 
/*StatusCode OfflineEvtFilterSvc::queryInterface(const InterfaceID& riid, void** ppvInterface){
     if( IID_IOfflineEvtFilterSvc.versionMatch(riid) ){
      *ppvInterface = static_cast<IOfflineEvtFilterSvc*> (this);
     } else{
      return Service::queryInterface(riid, ppvInterface);
     }
     return StatusCode::SUCCESS;
}
*/
StatusCode OfflineEvtFilterSvc::initialize(){
     MsgStream log(messageService(), name());
     log << MSG::INFO << "OfflineEvtFilterSvc::initialize()" << endreq;
 
     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" << endreq;
     }else{
          log << MSG::FATAL << "can not get IDataProviderSvc" << endreq;
     }
 
     return StatusCode::SUCCESS;
}
 
StatusCode OfflineEvtFilterSvc::finalize(){
     MsgStream log(messageService(), name());
     log << MSG::INFO << "OfflineEvtFilterSvc::finalize()" << endreq;
 
     m_npar = 0;
     m_flag.clear();
     m_tBegin.clear();
     m_tEnd.clear();
 
     return StatusCode::SUCCESS;
}
 
void OfflineEvtFilterSvc::handle(const Incident& inc){
     MsgStream log( messageService(), name() );
     log << MSG::DEBUG << "handle: " << inc.type() << endreq;
 
     if ( inc.type() == "NewRun" ){
      log << MSG::DEBUG << "NewRun" << endreq;
 
      if( ! initCalibConst() ){
           log << MSG::ERROR 
           << "can not initilize OffEvtFilter Constants" << endreq;
      }
     } 
}
 
 
bool OfflineEvtFilterSvc::initCalibConst(){
     MsgStream log(messageService(), name());
     log << MSG::INFO << "read calib const from TCDS" << endreq;
 
     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" << endreq;
          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" 
              << endreq;
          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;
}