DTag.cxx

Go to the documentation of this file.

#include "GaudiKernel/IDataManagerSvc.h"
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/SmartDataPtr.h"
#include "GaudiKernel/SmartIF.h"
#include <vector>
 
#include "EventModel/EventModel.h"
#include "EvtRecEvent/EvtRecDTag.h"
#include "EvtRecEvent/EvtRecEvent.h"
 
#include "DTag.h"
 
DECLARE_COMPONENT( DTag )
//**************************************************************************************
DTag::DTag( const std::string& name, ISvcLocator* pSvcLocator )
    : Gaudi::Sequence( name, pSvcLocator ) {
  // Declare the properties
  declareProperty( "NeutralDReconstruction", m_recD0 = true );
  declareProperty( "ChargedDReconstruction", m_recDp = true );
  declareProperty( "DsReconstruction", m_recDs = true );
  declareProperty( "LambdaCReconstruction", m_recLc = true );
  // declareProperty("RawDstOnly",              m_rawdstonly = true);
}
 
// ***********************************************************************************
StatusCode DTag::initialize() {
 
  MsgStream log( msgSvc(), name() );
 
  log << MSG::INFO << "creating DTag sub Algorithm" << endmsg;
 
  StatusCode sc;
 
  if ( m_recD0 )
  {
    sc = createSubAlgorithm( "NeutralDReconstruction", "NeutralDReconstruction",
                             m_NeutralDReconstruction );
    if ( sc.isFailure() )
    {
      log << MSG::ERROR << "Error while creating D0Reconstruction" << endmsg;
      return StatusCode::FAILURE;
    }
  }
 
  if ( m_recDp )
  {
    sc = createSubAlgorithm( "ChargedDReconstruction", "ChargedDReconstruction",
                             m_ChargedDReconstruction );
    if ( sc.isFailure() )
    {
      log << MSG::ERROR << "Error while creating D+Reconstruction" << endmsg;
      return StatusCode::FAILURE;
    }
  }
 
  if ( m_recDs )
  {
    sc = createSubAlgorithm( "DsReconstruction", "DsReconstruction", m_DsReconstruction );
    if ( sc.isFailure() )
    {
      log << MSG::ERROR << "Error while creating DsReconstruction" << endmsg;
      return StatusCode::FAILURE;
    }
  }
 
  if ( m_recLc )
  {
    sc = createSubAlgorithm( "LambdaCReconstruction", "LambdaCReconstruction",
                             m_LambdaCReconstruction );
    if ( sc.isFailure() )
    {
      log << MSG::ERROR << "Error while creating LcReconstruction" << endmsg;
      return StatusCode::FAILURE;
    }
  }
 
  log << MSG::INFO << "Calling Sequence::initialize()" << endmsg;
  return Gaudi::Sequence::initialize();
}
 
StatusCode DTag::registerParent( MsgStream& log ) const {
  DataObject* aEvtRecEvent;
  eventSvc()->findObject( "/Event/EvtRec", aEvtRecEvent ).ignore();
  if ( aEvtRecEvent == NULL )
  {
    aEvtRecEvent  = new EvtRecEvent();
    StatusCode sc = eventSvc()->registerObject( "/Event/EvtRec", aEvtRecEvent );
    if ( sc != StatusCode::SUCCESS )
    {
      log << MSG::FATAL << "Could not register EvtRecEvent" << endmsg;
      return StatusCode::FAILURE;
    }
  }
  return StatusCode::SUCCESS;
}
 
StatusCode DTag::clearEvtRecDTagCol( MsgStream& log ) const {
  StatusCode sc = registerParent( log );
  if ( sc != StatusCode::SUCCESS ) { return sc; }
 
  DataObject* aEvtRecDTagCol;
  eventSvc()->findObject( "/Event/EvtRec/EvtRecDTagCol", aEvtRecDTagCol ).ignore();
  if ( aEvtRecDTagCol )
  {
    // IDataManagerSvc* dataManSvc = dynamic_cast<IDataManagerSvc*>(eventSvc());
    SmartIF<IDataManagerSvc> dataManSvc( eventSvc() );
    dataManSvc->clearSubTree( "/Event/EvtRec/EvtRecDTagCol" ).ignore();
    eventSvc()->unregisterObject( "/Event/EvtRec/EvtRecDTagCol" ).ignore();
  }
 
  SmartDataPtr<EvtRecDTagCol> evtRecDTagCol( eventSvc(), EventModel::EvtRec::EvtRecDTagCol );
  if ( evtRecDTagCol )
  {
    // IDataManagerSvc* dataManSvc = dynamic_cast<IDataManagerSvc*>(eventSvc());
    SmartIF<IDataManagerSvc> dataManSvc( eventSvc() );
    dataManSvc->clearSubTree( "/Event/EvtRec/EvtRecDTagCol" ).ignore();
    eventSvc()->unregisterObject( "/Event/EvtRec/EvtRecDTagCol" ).ignore();
  }
 
  return StatusCode::SUCCESS;
}
 
void DTag::registerEvtRecDTagCol( MsgStream& log ) const {
  EvtRecDTagCol* aNewEvtRecDTagCol = new EvtRecDTagCol;
  StatusCode     sc =
      eventSvc()->registerObject( "/Event/EvtRec/EvtRecDTagCol", aNewEvtRecDTagCol );
  if ( sc != StatusCode::SUCCESS )
  { log << MSG::FATAL << "Could not register EvtRecDTagCol in TDS!" << endmsg; }
}
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
StatusCode DTag::execute( const EventContext& ctx ) const {
 
  // check if DTagList exists
  // if true, will exit the program
  SmartDataPtr<EvtRecDTagCol> evtRecDTagCol( eventSvc(), EventModel::EvtRec::EvtRecDTagCol );
  if ( evtRecDTagCol )
  {
    if ( evtRecDTagCol->size() > 0 )
    {
      cout << "************************************************" << endl;
      cout << "EvtRecDTagCol already exists in this file!" << endl;
      cout << " Please run this program on a raw dst file!" << endl;
      cout << " *** This job is now being killed. ***" << endl;
      cout << "************************************************" << endl;
      return StatusCode::FAILURE;
    } /// End of "evtRecDTagCol->size()>0" IF
  } /// End of "evtRecDTagCol != NULL" IF
 
  MsgStream  log( msgSvc(), name() );
  StatusCode sc = clearEvtRecDTagCol( log );
  if ( sc != StatusCode::SUCCESS ) { return sc; }
 
  DataObject* aEvtRecDTagCol;
  eventSvc()->findObject( "/Event/EvtRec/EvtRecDTagCol", aEvtRecDTagCol ).ignore();
  if ( aEvtRecDTagCol == NULL ) { registerEvtRecDTagCol( log ); }
 
  std::vector<Algorithm*>::const_iterator it  = subAlgorithms()->begin();
  std::vector<Algorithm*>::const_iterator end = subAlgorithms()->end();
  for ( ; it != end; it++ )
  {
    sc = ( *it )->execute( ctx );
    if ( sc.isFailure() ) { log << "Error executing selection " << ( *it )->name() << endmsg; }
  }
 
  return StatusCode::SUCCESS;
}
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
StatusCode DTag::finalize() {
 
  MsgStream log( msgSvc(), name() );
  log << MSG::INFO << "in finalize()" << endmsg;
  return Gaudi::Sequence::finalize();
}