ResetEtsAlg.cxx

Go to the documentation of this file.

#include <iomanip>
#include <typeinfo>
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/SmartDataPtr.h"
 
#include "EventModel/EventHeader.h"
#include "CalibData/Ets/CorrectedETSCal.h"
#include "ResetEtsAlg/ResetEtsAlg.h"
#include <fstream>
#include <algorithm>
 
 
using namespace std;
 
 
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" << endreq;
            return StatusCode::FAILURE;
        }
 
    sc = service("InjSigIntervalSvc", m_InjSigIntervalSvc);
    if( sc != StatusCode::SUCCESS ){
        log << MSG::FATAL << "can not use InjSigIntervalSvc" << endreq;
    }
 
    sc = service("InjSigTimeSvc", m_InjSigTimeSvc);
    if( sc != StatusCode::SUCCESS ){
        log << MSG::FATAL << "can not use InjSigTimeSvc" << endreq;
    }
 
        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 << endreq;
                    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" << endreq;
                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" << endreq;
                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;
}