DQACtrlSamples.cxx

Go to the documentation of this file.

#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/SmartDataPtr.h"
#include <GaudiKernel/Algorithm.h>
 
#include "DQACtrlSamples.h"
#include "DQAEvent/DQAEvent.h"
 
DECLARE_COMPONENT( DQACtrlSamples )
 
using Gaudi::details::LegacyAlgorithmAdapter;
 
/////////////////////////////////////////////////////////////////////////////
 
DQACtrlSamples::DQACtrlSamples( const std::string& name, ISvcLocator* pSvcLocator )
    : Gaudi::Sequence( name, pSvcLocator ) {
 
  // Declare the properties
  declareProperty( "SelectBhabha", m_selBhabha = true );
  declareProperty( "SelectDimu", m_selDimu = true );
  declareProperty( "SelectHadron", m_selHadron = false );
  declareProperty( "SelectRhopi", m_selRhopi = false );
  declareProperty( "SelectPpbar", m_selPpbar = false );
  declareProperty( "SelectKstark", m_selKstark = false );
  declareProperty( "SelectLambdalambda", m_selLambdalambda = false );
  declareProperty( "SelectPPpipi", m_selPPpipi = false );
  declareProperty( "SelectKsKpiDedx", m_selKsKpiDedx = false );
 
  declareProperty( "SelectpipiJpsi", m_selpipiJpsi = false );
 
  declareProperty( "OutputBhabha", m_OutBhabha = false );
  declareProperty( "OutputDimu", m_OutDimu = false );
  declareProperty( "OutputHadron", m_OutHadron = false );
  declareProperty( "OutputRhopi", m_OutRhopi = false );
  declareProperty( "OutputPpbar", m_OutPpbar = false );
  declareProperty( "OutputKstark", m_OutKstark = false );
  declareProperty( "OutputLambdalambda", m_OutLambdalambda = false );
  declareProperty( "OutputPPpipi", m_OutPPpipi = false );
  declareProperty( "OutputKsKpiDedx", m_OutKsKpiDedx = false );
 
  declareProperty( "OutputpipiJpsi", m_OutpipiJpsi = false );
}
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
StatusCode DQACtrlSamples::initialize() {
  MsgStream log( msgSvc(), name() );
 
  log << MSG::INFO << "in initialize()" << endmsg;
  StatusCode sc;
 
  if ( m_selBhabha )
  {
    sc = createSubAlgorithm( "DQASelBhabha", "DQASelBhabha", m_dqaBhabha );
    if ( sc.isFailure() )
    {
      log << MSG::ERROR << "Error creating Sub-Algorithm DQASelBhabha" << endmsg;
      return StatusCode::FAILURE;
    }
    if ( m_OutBhabha )
    {
      sc = createSubAlgorithm( "EventWriter", "DQAOutBhabha", m_dqaoutBhabha );
      if ( sc.isFailure() )
      {
        log << MSG::ERROR << "Error creating Sub-Algorithm DQAOutBhabha" << endmsg;
        return StatusCode::FAILURE;
      }
    }
  }
 
  if ( m_selDimu )
  {
    sc = createSubAlgorithm( "DQASelDimu", "DQASelDimu", m_dqaDimu );
    if ( sc.isFailure() )
    {
      log << MSG::ERROR << "Error creating Sub-Algorithm DQASelDimu" << endmsg;
      return StatusCode::FAILURE;
    }
    if ( m_OutDimu )
    {
      sc = createSubAlgorithm( "EventWriter", "DQAOutDimu", m_dqaoutDimu );
      if ( sc.isFailure() )
      {
        log << MSG::ERROR << "Error creating Sub-Algorithm DQAOutDimu" << endmsg;
        return StatusCode::FAILURE;
      }
    }
  }
 
  if ( m_selHadron )
  {
    sc = createSubAlgorithm( "DQASelHadron", "DQASelHadron", m_dqaHadron );
    if ( sc.isFailure() )
    {
      log << MSG::ERROR << "Error creating Sub-Algorithm DQASelHadron" << endmsg;
      return StatusCode::FAILURE;
    }
    if ( m_OutHadron )
    {
      sc = createSubAlgorithm( "EventWriter", "DQAOutHadron", m_dqaoutHadron );
      if ( sc.isFailure() )
      {
        log << MSG::ERROR << "Error creating Sub-Algorithm DQAOutHadron" << endmsg;
        return StatusCode::FAILURE;
      }
    }
  }
 
  if ( m_selRhopi )
  {
    sc = createSubAlgorithm( "DQARhopi", "DQARhopi", m_dqaRhopi );
    if ( sc.isFailure() )
    {
      log << MSG::ERROR << "Error creating Sub-Algorithm DQARhopiAlg" << endmsg;
      return StatusCode::FAILURE;
    }
    if ( m_OutRhopi )
    {
      sc = createSubAlgorithm( "EventWriter", "DQAOutRhopi", m_dqaoutRhopi );
      if ( sc.isFailure() )
      {
        log << MSG::ERROR << "Error creating Sub-Algorithm DQAOutRhopi" << endmsg;
        return StatusCode::FAILURE;
      }
    }
  }
 
  if ( m_selPpbar )
  {
    sc = createSubAlgorithm( "DQAJpsi2PPbarAlg", "DQAJpsi2PPbarAlg", m_dqaPpbar );
    if ( sc.isFailure() )
    {
      log << MSG::ERROR << "Error creating Sub-Algorithm Jpsi2PPbarAlg" << endmsg;
      return StatusCode::FAILURE;
    }
    if ( m_OutPpbar )
    {
      sc = createSubAlgorithm( "EventWriter", "DQAOutPpbar", m_dqaoutPpbar );
      if ( sc.isFailure() )
      {
        log << MSG::ERROR << "Error creating Sub-Algorithm DQAOutPpbar" << endmsg;
        return StatusCode::FAILURE;
      }
    }
  }
 
  if ( m_selKstark )
  {
    sc = createSubAlgorithm( "DQAKsKpi", "DQAKsKpi", m_dqaKstark );
    if ( sc.isFailure() )
    {
      log << MSG::ERROR << "Error creating Sub-Algorithm DQAKsKpi" << endmsg;
      return StatusCode::FAILURE;
    }
    if ( m_OutKstark )
    {
      sc = createSubAlgorithm( "EventWriter", "DQAOutKstark", m_dqaoutKstark );
      if ( sc.isFailure() )
      {
        log << MSG::ERROR << "Error creating Sub-Algorithm DQAOutKstark" << endmsg;
        return StatusCode::FAILURE;
      }
    }
  }
 
  if ( m_selLambdalambda )
  {
    sc = createSubAlgorithm( "JsiLL", "JsiLL", m_dqaLambdalambda );
    if ( sc.isFailure() )
    {
      log << MSG::ERROR << "Error creating Sub-Algorithm JsiLL" << endmsg;
      return StatusCode::FAILURE;
    }
    if ( m_OutLambdalambda )
    {
      sc = createSubAlgorithm( "EventWriter", "DQAOutLambdalambda", m_dqaoutLambdalambda );
      if ( sc.isFailure() )
      {
        log << MSG::ERROR << "Error creating Sub-Algorithm DQAOutLambdalambda" << endmsg;
        return StatusCode::FAILURE;
      }
    }
  }
 
  if ( m_selPPpipi )
  {
    sc = createSubAlgorithm( "DQAPi2p2", "DQAPi2p2", m_dqaPPpipi );
    if ( sc.isFailure() )
    {
      log << MSG::ERROR << "Error creating Sub-Algorithm DQAPi2p2" << endmsg;
      return StatusCode::FAILURE;
    }
    if ( m_OutPPpipi )
    {
      sc = createSubAlgorithm( "EventWriter", "DQAOutPPpipi", m_dqaoutPPpipi );
      if ( sc.isFailure() )
      {
        log << MSG::ERROR << "Error creating Sub-Algorithm DQAPi2p2" << endmsg;
        return StatusCode::FAILURE;
      }
    }
  }
 
  if ( m_selKsKpiDedx )
  {
    sc = createSubAlgorithm( "DQAKsKpiDEDX", "DQAKsKpiDEDX", m_dqaKsKpiDedx );
    if ( sc.isFailure() )
    {
      log << MSG::ERROR << "Error creating Sub-Algorithm DQAKsKpiDedx" << endmsg;
      return StatusCode::FAILURE;
    }
    if ( m_OutKsKpiDedx )
    {
      sc = createSubAlgorithm( "EventWriter", "DQAOutKsKpiDedx", m_dqaoutKsKpiDedx );
      if ( sc.isFailure() )
      {
        log << MSG::ERROR << "Error creating Sub-Algorithm DQAOutKsKpiDedx" << endmsg;
        return StatusCode::FAILURE;
      }
    }
  }
 
  if ( m_selpipiJpsi )
  {
    sc = createSubAlgorithm( "PipiJpsi", "PipiJpsi", m_dqapipiJpsi );
    if ( sc.isFailure() )
    {
      log << MSG::ERROR << "Error creating Sub-Algorithm DQApipiJpsi" << endmsg;
      return StatusCode::FAILURE;
    }
    if ( m_OutpipiJpsi )
    {
      sc = createSubAlgorithm( "EventWriter", "DQAOutpipiJpsi", m_dqaoutpipiJpsi );
      if ( sc.isFailure() )
      {
        log << MSG::ERROR << "Error creating Sub-Algorithm DQAOutpipiJpsi" << endmsg;
        return StatusCode::FAILURE;
      }
    }
  }
 
  log << MSG::INFO << "successfully return from initialize()" << endmsg;
  return StatusCode::SUCCESS;
}
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
StatusCode DQACtrlSamples::execute( const EventContext& ctx ) const {
 
  MsgStream log( msgSvc(), name() );
  log << MSG::INFO << "in execute()" << endmsg;
 
  SmartDataPtr<DQAEvent::DQAEvent> dqaevt( eventSvc(), "/Event/DQATag" );
  if ( !dqaevt )
  {
    dqaevt = new DQAEvent::DQAEvent;
    StatusCode sc;
    sc = eventSvc()->registerObject( "/Event/DQATag", dqaevt );
    if ( sc.isFailure() )
    {
      log << MSG::ERROR << "Could not register DQAEvent to TDS" << endmsg;
      return StatusCode::FAILURE;
      return sc;
    }
  }
 
  if ( m_selBhabha )
  {
    m_dqaBhabha->execute( ctx ).ignore();
    if ( dynamic_cast<LegacyAlgorithmAdapter*>( m_dqaBhabha )->filterPassed() )
    {
      dqaevt->setBhabha( 1 );
      if ( m_OutBhabha ) m_dqaoutBhabha->execute( ctx ).ignore();
    }
  }
 
  if ( m_selDimu )
  {
    m_dqaDimu->execute( ctx ).ignore();
    if ( dynamic_cast<LegacyAlgorithmAdapter*>( m_dqaDimu )->filterPassed() )
    {
      dqaevt->setDimu( 1 );
      if ( m_OutDimu ) m_dqaoutDimu->execute( ctx ).ignore();
    }
  }
 
  if ( m_selHadron )
  {
    m_dqaHadron->execute( ctx ).ignore();
    if ( dynamic_cast<LegacyAlgorithmAdapter*>( m_dqaHadron )->filterPassed() )
    {
      dqaevt->setHadron( 1 );
      if ( m_OutHadron ) m_dqaoutHadron->execute( ctx ).ignore();
    }
  }
 
  if ( m_selRhopi )
  {
    m_dqaRhopi->execute( ctx ).ignore();
    if ( dynamic_cast<LegacyAlgorithmAdapter*>( m_dqaRhopi )->filterPassed() )
    {
      dqaevt->setRhopi( 1 );
      if ( m_OutRhopi ) m_dqaoutRhopi->execute( ctx ).ignore();
    }
  }
 
  if ( m_selPpbar )
  {
    m_dqaPpbar->execute( ctx ).ignore();
    if ( dynamic_cast<LegacyAlgorithmAdapter*>( m_dqaPpbar )->filterPassed() )
    {
      dqaevt->setPpbar( 1 );
      if ( m_OutPpbar ) m_dqaoutPpbar->execute( ctx ).ignore();
    }
  }
 
  if ( m_selKstark )
  {
    m_dqaKstark->execute( ctx ).ignore();
    if ( dynamic_cast<LegacyAlgorithmAdapter*>( m_dqaKstark )->filterPassed() )
    {
      dqaevt->setKstark( 1 );
      if ( m_OutKstark ) m_dqaoutKstark->execute( ctx ).ignore();
    }
  }
 
  if ( m_selLambdalambda )
  {
    m_dqaLambdalambda->execute( ctx ).ignore();
    if ( dynamic_cast<LegacyAlgorithmAdapter*>( m_dqaLambdalambda )->filterPassed() )
    {
      dqaevt->setLambdalambdabar( 1 );
      if ( m_OutLambdalambda ) m_dqaoutLambdalambda->execute( ctx ).ignore();
    }
  }
 
  if ( m_selPPpipi )
  {
    m_dqaPPpipi->execute( ctx ).ignore();
    if ( dynamic_cast<LegacyAlgorithmAdapter*>( m_dqaPPpipi )->filterPassed() )
    {
      dqaevt->setPpbarpipi( 1 );
      if ( m_OutPPpipi ) m_dqaoutPPpipi->execute( ctx ).ignore();
    }
  }
 
  if ( m_selKsKpiDedx )
  {
    m_dqaKsKpiDedx->execute( ctx ).ignore();
    if ( dynamic_cast<LegacyAlgorithmAdapter*>( m_dqaKsKpiDedx )->filterPassed() )
    {
      dqaevt->setKstark( 1 );
      if ( m_OutKsKpiDedx ) m_dqaoutKsKpiDedx->execute( ctx ).ignore();
    }
  }
 
  if ( m_selpipiJpsi )
  {
    m_dqapipiJpsi->execute( ctx ).ignore();
    if ( dynamic_cast<LegacyAlgorithmAdapter*>( m_dqapipiJpsi )->filterPassed() )
    {
      dqaevt->setHadron( 1 );
      if ( m_OutpipiJpsi ) m_dqaoutpipiJpsi->execute( ctx ).ignore();
    }
  }
 
  return StatusCode::SUCCESS;
}
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
StatusCode DQACtrlSamples::finalize() {
 
  MsgStream log( msgSvc(), name() );
  log << MSG::INFO << "in finalize()" << endmsg;
  return StatusCode::SUCCESS;
}