VeeVertex.cxx

Go to the documentation of this file.

#include "VeeVertex.h"
#include "EventModel/Event.h"
#include "EventModel/EventModel.h"
#include "EvtRecEvent/EvtRecEvent.h"
#include "EvtRecEvent/EvtRecVeeVertex.h"
#include "Gaudi/Sequence.h"
#include "GaudiKernel/IDataManagerSvc.h"
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/PropertyMgr.h"
#include "GaudiKernel/SmartDataPtr.h"
#include <vector>
DECLARE_COMPONENT( VeeVertex )
//**************************************************************************************
VeeVertex::VeeVertex( const std::string& name, ISvcLocator* pSvcLocator )
    : Gaudi::Sequence( name, pSvcLocator ) {
  // Declare the properties
  declareProperty( "KShortReconstruction", m_recKShort = true );
  declareProperty( "LambdaReconstruction", m_recLambda = true );
  declareProperty( "GammaConversionReconstruction", m_recGC = true );
}
 
// ***********************************************************************************
StatusCode VeeVertex::initialize() {
 
  MsgStream log( msgSvc(), name() );
 
  log << MSG::INFO << "creating VeeVertex sub Algorithm" << endmsg;
 
  StatusCode sc;
 
  if ( m_recKShort )
  {
    sc = createSubAlgorithm( "KShortReconstruction", "KShortReconstruction",
                             m_KShortReconstruction );
    if ( sc.isFailure() )
    {
      log << MSG::ERROR << "Error while creating KShortReconstruction" << endmsg;
      return StatusCode::FAILURE;
    }
  }
  if ( m_recLambda )
  {
    sc = createSubAlgorithm( "LambdaReconstruction", "LambdaReconstruction",
                             m_LambdaReconstruction );
    if ( sc.isFailure() )
    {
      log << MSG::ERROR << "Error while creating LambdaReconstruction" << endmsg;
      return StatusCode::FAILURE;
    }
  }
  if ( m_recGC )
  {
    sc = createSubAlgorithm( "GammaConversionReconstruction", "GammaConversionReconstruction",
                             m_gcReconstruction );
    if ( sc.isFailure() )
    {
      log << MSG::ERROR << "Error while creating GammaConversionReconstruction" << endmsg;
      return StatusCode::FAILURE;
    }
  }
 
  log << MSG::INFO << "Calling Sequence::initialize()" << endmsg;
  // return StatusCode::SUCCESS;
  return Sequence::initialize();
}
 
StatusCode VeeVertex::registerParent( MsgStream& log ) const {
  DataObject* aEvtRecEvent;
  eventSvc()->findObject( "/Event/EvtRec", aEvtRecEvent );
  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 VeeVertex::clearEvtRecVeeVertexCol( MsgStream& log ) const {
  StatusCode sc = registerParent( log );
  if ( sc != StatusCode::SUCCESS ) { return sc; }
 
  DataObject* aEvtRecVeeVertexCol;
  eventSvc()->findObject( "/Event/EvtRec/EvtRecVeeVertexCol", aEvtRecVeeVertexCol );
  if ( aEvtRecVeeVertexCol != NULL )
  {
    SmartIF<IDataManagerSvc> dataManSvc( eventSvc() );
    dataManSvc->clearSubTree( "/Event/EvtRec/EvtRecVeeVertexCol" );
    eventSvc()->unregisterObject( "/Event/EvtRec/EvtRecVeeVertexCol" );
  }
  return StatusCode::SUCCESS;
}
 
void VeeVertex::registerEvtRecVeeVertexCol( MsgStream& log ) const {
  EvtRecVeeVertexCol* aNewEvtRecVeeVertexCol = new EvtRecVeeVertexCol;
  StatusCode          sc =
      eventSvc()->registerObject( "/Event/EvtRec/EvtRecVeeVertexCol", aNewEvtRecVeeVertexCol );
  if ( sc != StatusCode::SUCCESS )
  { log << MSG::FATAL << "Could not register EvtRecVeeVertexCol in TDS!" << endmsg; }
}
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
// StatusCode VeeVertex::execute() {
StatusCode VeeVertex::execute( const EventContext& ctx ) const {
  MsgStream log( msgSvc(), name() );
 
  StatusCode sc = clearEvtRecVeeVertexCol( log );
  if ( sc != StatusCode::SUCCESS ) { return sc; }
 
  // 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; }
  // }
 
  for ( auto subAlg : *subAlgorithms() )
  {
    sc = subAlg->execute( ctx );
    if ( sc.isFailure() ) { log << "Error executing selection " << subAlg->name() << endmsg; }
  }
 
  DataObject* aEvtRecVeeVertexCol;
  eventSvc()->findObject( "/Event/EvtRec/EvtRecVeeVertexCol", aEvtRecVeeVertexCol );
  if ( aEvtRecVeeVertexCol == NULL ) { registerEvtRecVeeVertexCol( log ); }
 
  return StatusCode::SUCCESS;
}
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
StatusCode VeeVertex::finalize() {
 
  MsgStream log( msgSvc(), name() );
  log << MSG::INFO << "in finalize()" << endmsg;
  return StatusCode::SUCCESS;
}