OfflineEvtFilterAlg.cxx

Go to the documentation of this file.

#include "OfflineEvtFilterAlg.h"
#include "EventModel/EventHeader.h"
#include "EventModel/EventModel.h"
 
#include "DstEvent/DstEvent.h"
#include "EvtRecEvent/EvtRecObject.h"
#include "HltEvent/DstHltInf.h"
#include "HltEvent/HltEvent.h"
#include "RawEvent/DigiEvent.h"
#include "ReconEvent/ReconEvent.h"
#include "TrigEvent/TrigData.h"
#include "TrigEvent/TrigEvent.h"
 
#include "GaudiKernel/IIncidentSvc.h"
#include "GaudiKernel/Incident.h"
#include "GaudiKernel/SmartDataPtr.h"
 
 
// Declaration of the Algorithm Factory
DECLARE_COMPONENT( OfflineEvtFilterAlg )
 
//=============================================================================
// Standard constructor, initializes variables
//=============================================================================
OfflineEvtFilterAlg::OfflineEvtFilterAlg( const std::string& name, ISvcLocator* pSvcLocator )
    : Algorithm( 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;
 
  StatusCode sc = service( "OfflineEvtFilterSvc", m_evtFilterSvc );
  if ( sc != StatusCode::SUCCESS )
  {
    fatal() << "can not use OfflineEvtFilterSvc" << endmsg;
    return sc;
  }
 
  m_dataSvc     = eventSvc();
  m_incidentSvc = service<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 StatusCode::SUCCESS;
  //GaudiAlgorithm::finalize(); // must be called after all other actions
}