OfflineEvtFilterAlg.cxx

Go to the documentation of this file.

#include "OfflineEvtFilterAlg.h"
#include "EventModel/EventModel.h"
#include "EventModel/EventHeader.h"
 
#include "RawEvent/DigiEvent.h"
#include "DstEvent/DstEvent.h"
#include "TrigEvent/TrigEvent.h"
#include "TrigEvent/TrigData.h"
#include "EvtRecEvent/EvtRecObject.h"
#include "HltEvent/HltEvent.h"
#include "HltEvent/DstHltInf.h"
#include "ReconEvent/ReconEvent.h"
 
#include "GaudiKernel/AlgFactory.h" 
#include "GaudiKernel/Incident.h" 
#include "GaudiKernel/IIncidentSvc.h" 
 
// Declaration of the Algorithm Factory
DECLARE_ALGORITHM_FACTORY( OfflineEvtFilterAlg )
 
//=============================================================================
// Standard constructor, initializes variables
//=============================================================================
OfflineEvtFilterAlg::OfflineEvtFilterAlg( const std::string& name,
        ISvcLocator* pSvcLocator)
: GaudiAlgorithm ( name , pSvcLocator )
{
}
//=============================================================================
// Destructor
//=============================================================================
OfflineEvtFilterAlg::~OfflineEvtFilterAlg() {} 
 
//=============================================================================
// Initialization
//=============================================================================
StatusCode OfflineEvtFilterAlg::initialize() {
    StatusCode sc = GaudiAlgorithm::initialize(); // must be executed first
    if ( sc.isFailure() ) return sc;  // error printed already by GaudiAlgorithm
 
    debug() << "==> Initialize" << endmsg;
 
    sc = service("OfflineEvtFilterSvc", m_evtFilterSvc);
    if ( sc != StatusCode::SUCCESS ) {
        fatal() << "can not use OfflineEvtFilterSvc" << endreq;
        return sc;
    }
 
    m_dataSvc = eventSvc();
    m_incidentSvc = svc<IIncidentSvc>("IncidentSvc",true);
 
    return StatusCode::SUCCESS;
}
 
//=============================================================================
// Main execution
//=============================================================================
StatusCode OfflineEvtFilterAlg::execute() {
 
    SmartDataPtr<Event::EventHeader> eventHeader(eventSvc(),"/Event/EventHeader");
 
    // whether to keep this event for further reconstruction
    bool keep = true;
    int npar = m_evtFilterSvc->getNpar();
 
    int iPar = 0;
    /// filter with ets-ist
    if ( eventHeader->etsFlag() != 21 ) {
        double dtEts = (long(eventHeader->etsT1()) - long(eventHeader->etsT2())) / double(2000.);  //in ms
        for ( ; iPar < npar && m_evtFilterSvc->getFlag(iPar) == 0; ++iPar ) {
            if ( dtEts < m_evtFilterSvc->getTBegin(iPar) ) {
                //keep = true by default
                break;
            }
            else if ( dtEts < m_evtFilterSvc->getTEnd(iPar) ) {
                keep = false;
                break;
            }
        }
    }
    /// filter with ets
    if ( keep && iPar < npar ) {
        double tEts  = eventHeader->etsT1() / double(2000000.);  //in second
        for ( ; iPar < npar; ++iPar ) {
            if ( m_evtFilterSvc->getFlag(iPar) == 0 ) {
                continue;
            }
            if ( tEts < m_evtFilterSvc->getTBegin(iPar) ) {
                //keep = true by default
                break;
            }
            else if ( tEts < m_evtFilterSvc->getTEnd(iPar) ) {
                keep = false;
                break;
            }
        }
    }
 
    if ( keep ) {
        // this is a good event, nothing to do
        return StatusCode::SUCCESS;
    }
 
    // Otherwise, this is a bad event ...
    // We register empty data objects without any hits to the Gaudi EDS
 
    {
        DigiEvent *digi = new DigiEvent();
        digi->initialize(false);  //not from MC
        m_dataSvc->registerObject(EventModel::Digi::Event, digi);
    }
 
    {
        DstEvent* dst = new DstEvent();
        m_dataSvc->registerObject(EventModel::Dst::Event, dst);
    }
 
    {
        TrigEvent * trig = new TrigEvent();
        trig->initialize(false);  //not from MC
        m_dataSvc->registerObject(EventModel::Trig::Event, trig);
        TrigData* trigData = new TrigData();
        m_dataSvc->registerObject(EventModel::Trig::TrigData, trigData);
    }
 
    {
        EvtRecObject* evtRecObject = new EvtRecObject();
        m_dataSvc->registerObject(EventModel::EvtRec::Event, evtRecObject);
    }
 
    {
        HltEvent * hlt = new HltEvent();
        hlt->initialize(false);  //not from MC
        m_dataSvc->registerObject(EventModel::Hlt::Event, hlt);
        DstHltInf* dstHltInf = new DstHltInf();
        m_dataSvc->registerObject(EventModel::Hlt::DstHltInf, dstHltInf);
    }
 
    {
        ReconEvent * recon = new ReconEvent();
        m_dataSvc->registerObject(EventModel::Recon::Event, recon);
    }
 
    debug() << "event " << eventHeader->eventNumber() << " is passed" << endmsg;
    m_incidentSvc->fireIncident(Incident(name(), IncidentType::AbortEvent));
 
    return StatusCode::SUCCESS;
}
 
//=============================================================================
//  Finalize
//=============================================================================
StatusCode OfflineEvtFilterAlg::finalize() {
 
    debug() << "==> Finalize" << endmsg;
 
    return GaudiAlgorithm::finalize();  // must be called after all other actions
}