TrigEgammaFastElectronHypoTool Class Reference

#include <TrigEgammaFastElectronHypoTool.h>

Inheritance diagram for TrigEgammaFastElectronHypoTool:

Collaboration diagram for TrigEgammaFastElectronHypoTool:

Public Member Functions
	TrigEgammaFastElectronHypoTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual StatusCode	initialize () override
virtual StatusCode	decide (std::vector< ITrigEgammaFastElectronHypoTool::ElectronInfo > &input) const override
virtual bool	decide (const ITrigEgammaFastElectronHypoTool::ElectronInfo &i) const override

Private Member Functions
bool	decide_cb (const ITrigEgammaFastElectronHypoTool::ElectronInfo &i) const
bool	decide_ringer (const ITrigEgammaFastElectronHypoTool::ElectronInfo &i) const

Private Attributes
HLT::Identifier	m_decisionId
Gaudi::Property< bool >	m_acceptAll { this, "AcceptAll", false, "Ignore selection" }
Gaudi::Property< bool >	m_doLRT { this, "DoLRT", false, "apply d0 cut for LRT triggers" }
Gaudi::Property< bool >	m_doRinger { this, "DoRinger", false, "apply NN ringer selection" }
Gaudi::Property< float >	m_trackPt { this, "TrackPt", 5.0*Gaudi::Units::GeV, "Track pT requirement ( separate threshold for each electron )" }
Gaudi::Property< float >	m_caloTrackDEta { this, "CaloTrackdETA", 0, "Delta Eta between the track and cluster" }
Gaudi::Property< float >	m_caloTrackDPhi { this, "CaloTrackdPHI", 0, "Delta Phi between track and cluster" }
Gaudi::Property< float >	m_caloTrackdEoverPLow { this, "CaloTrackdEoverPLow", 0, "Min E over Pt cut "}
Gaudi::Property< float >	m_caloTrackdEoverPHigh { this, "CaloTrackdEoverPHigh", 0, "Max E over pT cut" }
Gaudi::Property< float >	m_trtRatio { this, "TRTRatio", 0, "TRT HT ratio" }
Gaudi::Property< float >	m_d0 { this, "d0Cut", 0, "d0 cut" }
Gaudi::Property< std::string >	m_pidName {this,"PidName", "", "Pid name"}
ToolHandle< GenericMonitoringTool >	m_monTool { this, "MonTool", "", "Monitoring tool" }

Detailed Description

Definition at line 23 of file TrigEgammaFastElectronHypoTool.h.

Constructor & Destructor Documentation

TrigEgammaFastElectronHypoTool()

TrigEgammaFastElectronHypoTool::TrigEgammaFastElectronHypoTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent
	)

Definition at line 14 of file TrigEgammaFastElectronHypoTool.cxx.

  : base_class( type, name, parent ),
    m_decisionId( HLT::Identifier::fromToolName( name ) ) 
{}

Member Function Documentation

decide() [1/2]

bool TrigEgammaFastElectronHypoTool::decide ( const ITrigEgammaFastElectronHypoTool::ElectronInfo &  i ) const

overridevirtual

Definition at line 61 of file TrigEgammaFastElectronHypoTool.cxx.

{
  return m_doRinger ? decide_ringer(input) : decide_cb(input);
}

decide() [2/2]

StatusCode TrigEgammaFastElectronHypoTool::decide ( std::vector< ITrigEgammaFastElectronHypoTool::ElectronInfo > &  input ) const

overridevirtual

Definition at line 48 of file TrigEgammaFastElectronHypoTool.cxx.

                                                                                                                       {
  for ( auto& i: input ) {
    if ( TCU::passed ( m_decisionId.numeric(), i.previousDecisionIDs ) ) {
      if ( decide( i ) ) {
        TCU::addDecisionID( m_decisionId, i.decision );
      }
    }
  }
  return StatusCode::SUCCESS;
}

decide_cb()

bool TrigEgammaFastElectronHypoTool::decide_cb ( const ITrigEgammaFastElectronHypoTool::ElectronInfo &  i ) const

private

Definition at line 68 of file TrigEgammaFastElectronHypoTool.cxx.

{
 
  if ( m_acceptAll ) {
    ATH_MSG_DEBUG( "AcceptAll property is set: taking all events" );
    return true;
  } else {
     ATH_MSG_DEBUG( "AcceptAll property not set: applying selection" );
  }
 
  auto cutCounter = Monitored::Scalar<int>( "CutCounter", -1 );  
  auto mon_ptCalo     = Monitored::Scalar( "PtCalo", -999. );
  auto mon_ptTrack    = Monitored::Scalar( "PtTrack", -999. );
  auto mon_dEtaCalo   = Monitored::Scalar( "CaloTrackdEta", -1. );
  auto mon_dPhiCalo   = Monitored::Scalar( "CaloTrackdPhi", -1. );
  auto mon_eToverPt   = Monitored::Scalar( "CaloTrackEoverP", -1. );
  auto mon_caloEta    = Monitored::Scalar( "CaloEta", -100. );
  auto mon_caloPhi    = Monitored::Scalar( "CaloPhi", -100. );
  auto mon_trk_d0     = Monitored::Scalar( "d0Value", -1. );
  auto monitorIt  = Monitored::Group( m_monTool, 
                                      cutCounter,
                                      mon_ptCalo, mon_ptTrack,    
                                      mon_dEtaCalo, mon_dPhiCalo,   
                                      mon_eToverPt,   
                                      mon_caloEta, mon_caloPhi, mon_trk_d0);
 
  auto electron = input.electron;
 
  if(!electron){
    ATH_MSG_DEBUG("disconsider candidates without electron");
    return false;
  }
 
  float ptCalo(0), dEtaCalo(0), dPhiCalo(0), eToverPt(0), caloEta(0), caloPhi(0), trk_d0(0); 
 
  const xAOD::TrackParticle* trkIter = electron->trackParticle();
 
  if ( !trkIter ){  // disconsider candidates without track
    ATH_MSG_DEBUG("disconsider candidates without track");
     return false;
  }
  cutCounter++;
 
  // Retrieve all quantities
  dPhiCalo    = electron->trkClusDphi();
  dEtaCalo    = electron->trkClusDeta();
  ptCalo      = electron->pt();   
  eToverPt    = electron->etOverPt();     
  caloEta     = electron->caloEta();
  caloPhi     = electron->caloPhi();
  trk_d0      = std::abs(trkIter->d0());
 
  float NTRHits     = static_cast<float>( electron->nTRTHits() );
  float NStrawHits  = static_cast<float>( electron->nTRTHiThresholdHits() );
  float TRTHitRatio = NStrawHits == 0 ? 1e10 : NTRHits/NStrawHits;
 
  if ( ptCalo < m_trackPt ){ 
    ATH_MSG_DEBUG( "Fails pt cut" << ptCalo << " < " << m_trackPt );
    return  false;
  }
  mon_ptCalo    = ptCalo;
  mon_ptTrack   = m_trackPt;
  cutCounter++;
 
  if ( dEtaCalo > m_caloTrackDEta ) {
    ATH_MSG_DEBUG( "Fails dEta cut " << dEtaCalo << " < " << m_caloTrackDEta );
    return  false;
  }
  mon_dEtaCalo  = dEtaCalo;
  mon_caloEta   = caloEta; 
   
  cutCounter++;
  if ( dPhiCalo > m_caloTrackDPhi ) {
    ATH_MSG_DEBUG( "Fails dPhi cut " << dPhiCalo << " < " << m_caloTrackDPhi );
    return  false;
  }
   
  mon_dPhiCalo  = dPhiCalo;
  mon_caloPhi   = caloPhi;
  cutCounter++;
  if( eToverPt <  m_caloTrackdEoverPLow ) {
    ATH_MSG_DEBUG( "Fails eoverp low cut " << eToverPt << " < " <<  m_caloTrackdEoverPLow );
    return false;
  }
 
 
  cutCounter++;
  if ( eToverPt > m_caloTrackdEoverPHigh ) {
    ATH_MSG_DEBUG( "Fails eoverp high cut " << eToverPt << " < " << m_caloTrackdEoverPHigh );
    return false;
  }
  mon_eToverPt  = eToverPt;
 
  cutCounter++;
  if ( TRTHitRatio < m_trtRatio ){
    ATH_MSG_DEBUG( "Fails TRT cut " << TRTHitRatio << " < " << m_trtRatio );
    return false;
  }
 
 
  cutCounter++;
  if(m_doLRT){
    ATH_MSG_DEBUG( "doLRT: " <<m_doLRT);
    ATH_MSG_DEBUG( "Track d0: " <<trk_d0);
 
    if(trk_d0 < m_d0){
      ATH_MSG_DEBUG( "Fails d0 cut " <<trk_d0<< " < " <<m_d0 );
      return false;
    }
  }
  mon_trk_d0    = trk_d0;
 
  ATH_MSG_DEBUG( "Passed selection" );
  return  true;
 
}

decide_ringer()

bool TrigEgammaFastElectronHypoTool::decide_ringer ( const ITrigEgammaFastElectronHypoTool::ElectronInfo &  i ) const

private

Definition at line 190 of file TrigEgammaFastElectronHypoTool.cxx.

{
 
  if ( m_acceptAll ) {
    ATH_MSG_DEBUG( "AcceptAll property is set: taking all events" );
    return true;
  } else {
     ATH_MSG_DEBUG( "AcceptAll property not set: applying selection" );
  }
  auto cutCounter     = Monitored::Scalar<int>( "CutCounter", -1 );  
  auto mon_ptCalo     = Monitored::Scalar( "PtCalo", -999. );
  auto mon_ptTrack    = Monitored::Scalar( "PtTrack", -999. );
  auto mon_dEtaCalo   = Monitored::Scalar( "CaloTrackdEta", -1. );
  auto mon_dPhiCalo   = Monitored::Scalar( "CaloTrackdPhi", -1. );
  auto mon_eToverPt   = Monitored::Scalar( "CaloTrackEoverP", -1. );
  auto mon_caloEta    = Monitored::Scalar( "CaloEta", -100. );
  auto mon_caloPhi    = Monitored::Scalar( "CaloPhi", -100. );
  auto mon_trk_d0     = Monitored::Scalar( "d0Value", -1. );
  auto mon_nnOutput   = Monitored::Scalar("NNOutput",-100);
 
  auto mon        = Monitored::Group( m_monTool, 
                                      cutCounter,
                                      mon_ptCalo, 
                                      mon_ptTrack,    
                                      mon_dEtaCalo, 
                                      mon_dPhiCalo,   
                                      mon_eToverPt,   
                                      mon_caloEta, 
                                      mon_caloPhi, 
                                      mon_trk_d0,
                                      mon_nnOutput);
 
  auto el = input.electron;
 
  if(!el){
    return false;
  }
 
  float ptCalo(0), dEtaCalo(0), dPhiCalo(0), eToverPt(0), caloEta(0), caloPhi(0), trk_d0(0), nnOutput(0); 
 
  cutCounter++;
 
  const xAOD::TrackParticle* trk = el->trackParticle();
  if ( !trk ){  
    ATH_MSG_DEBUG("disconsider candidates without track");
    return false;
  }
  cutCounter++;
 
  // Retrieve all quantities
  dPhiCalo    = el->trkClusDphi();
  dEtaCalo    = el->trkClusDeta();
  ptCalo      = el->pt();     
  eToverPt    = el->etOverPt();   
  caloEta     = el->caloEta();
  caloPhi     = el->caloPhi();
  trk_d0      = std::abs(trk->d0());
 
 
  if ( ptCalo < m_trackPt ){ 
    ATH_MSG_DEBUG( "Fails pt cut" << ptCalo << " < " << m_trackPt );
    return  false;
  }
  mon_ptCalo    = ptCalo;
  cutCounter++;
 
  auto rings = input.rings;
  if(!rings){
    ATH_MSG_DEBUG("disconsider candidates without rings");
    return false;
  }
  cutCounter++;
 
  auto clus = input.cluster;
  if(!clus){
    ATH_MSG_DEBUG("disconsider candidates without cluster");
    return false;
  }
  cutCounter++;
 
 
  bool pass = false;
  if( input.pidDecorator.count(m_pidName)){
    nnOutput = input.valueDecorator.at(m_pidName+"NNOutput");
    pass = input.pidDecorator.at(m_pidName);
    ATH_MSG_DEBUG( "Get the decision for " << m_pidName << ": " << (pass?"Yes":"No") );
  }
 
  
  mon_ptTrack   = m_trackPt;
  mon_dEtaCalo  = dEtaCalo; 
  mon_dPhiCalo  = dPhiCalo;
  mon_eToverPt  = eToverPt;
  mon_caloEta   = caloEta; 
  mon_caloPhi   = caloPhi; 
  mon_trk_d0    = trk_d0;
  mon_nnOutput  = nnOutput;
 
 
  return pass;
}

initialize()

StatusCode TrigEgammaFastElectronHypoTool::initialize ( )

overridevirtual

Definition at line 24 of file TrigEgammaFastElectronHypoTool.cxx.

                                                       {
  
  if ( !m_monTool.empty() ) ATH_CHECK( m_monTool.retrieve() );
 
 
  ATH_MSG_DEBUG( "AcceptAll            = " << ( m_acceptAll? "True" : "False" ) ); 
  ATH_MSG_DEBUG( "Do_Ringer            = " << ( m_doRinger ? "True" : "False" ) ); 
  ATH_MSG_DEBUG( "TrackPt              = " << m_trackPt              ); 
  ATH_MSG_DEBUG( "CaloTrackdETA        = " << m_caloTrackDEta        );
  ATH_MSG_DEBUG( "CaloTrackdPHI        = " << m_caloTrackDPhi        );
  ATH_MSG_DEBUG( "CaloTrackdEoverPLow  = " << m_caloTrackdEoverPLow  );
  ATH_MSG_DEBUG( "CaloTrackdEoverPHigh = " << m_caloTrackdEoverPHigh );
  ATH_MSG_DEBUG( "TRTRatio             = " << m_trtRatio             );
  ATH_MSG_DEBUG( "Do_LRT               = " << m_doLRT                );
  ATH_MSG_DEBUG( "d0Cut                = " << m_d0                   );
 
  ATH_MSG_DEBUG( "Tool configured for chain/id: " << m_decisionId  );
  
  ATH_MSG_DEBUG( "Initialization completed successfully:" );
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_acceptAll

Gaudi::Property<bool> TrigEgammaFastElectronHypoTool::m_acceptAll { this, "AcceptAll", false, "Ignore selection" }

private

Definition at line 43 of file TrigEgammaFastElectronHypoTool.h.

m_caloTrackdEoverPHigh

Gaudi::Property<float> TrigEgammaFastElectronHypoTool::m_caloTrackdEoverPHigh { this, "CaloTrackdEoverPHigh", 0, "Max E over pT cut" }

private

Definition at line 50 of file TrigEgammaFastElectronHypoTool.h.

m_caloTrackdEoverPLow

Gaudi::Property<float> TrigEgammaFastElectronHypoTool::m_caloTrackdEoverPLow { this, "CaloTrackdEoverPLow", 0, "Min E over Pt cut "}

private

Definition at line 49 of file TrigEgammaFastElectronHypoTool.h.

m_caloTrackDEta

Gaudi::Property<float> TrigEgammaFastElectronHypoTool::m_caloTrackDEta { this, "CaloTrackdETA", 0, "Delta Eta between the track and cluster" }

private

Definition at line 47 of file TrigEgammaFastElectronHypoTool.h.

m_caloTrackDPhi

Gaudi::Property<float> TrigEgammaFastElectronHypoTool::m_caloTrackDPhi { this, "CaloTrackdPHI", 0, "Delta Phi between track and cluster" }

private

Definition at line 48 of file TrigEgammaFastElectronHypoTool.h.

m_d0

Gaudi::Property<float> TrigEgammaFastElectronHypoTool::m_d0 { this, "d0Cut", 0, "d0 cut" }

private

Definition at line 52 of file TrigEgammaFastElectronHypoTool.h.

m_decisionId

HLT::Identifier TrigEgammaFastElectronHypoTool::m_decisionId

private

Definition at line 41 of file TrigEgammaFastElectronHypoTool.h.

m_doLRT

Gaudi::Property<bool> TrigEgammaFastElectronHypoTool::m_doLRT { this, "DoLRT", false, "apply d0 cut for LRT triggers" }

private

Definition at line 44 of file TrigEgammaFastElectronHypoTool.h.

m_doRinger

Gaudi::Property<bool> TrigEgammaFastElectronHypoTool::m_doRinger { this, "DoRinger", false, "apply NN ringer selection" }

private

Definition at line 45 of file TrigEgammaFastElectronHypoTool.h.

m_monTool

ToolHandle<GenericMonitoringTool> TrigEgammaFastElectronHypoTool::m_monTool { this, "MonTool", "", "Monitoring tool" }

private

Definition at line 54 of file TrigEgammaFastElectronHypoTool.h.

m_pidName

Gaudi::Property<std::string> TrigEgammaFastElectronHypoTool::m_pidName {this,"PidName", "", "Pid name"}

private

Definition at line 53 of file TrigEgammaFastElectronHypoTool.h.

m_trackPt

Gaudi::Property<float> TrigEgammaFastElectronHypoTool::m_trackPt { this, "TrackPt", 5.0*Gaudi::Units::GeV, "Track pT requirement ( separate threshold for each electron )" }

private

Definition at line 46 of file TrigEgammaFastElectronHypoTool.h.

m_trtRatio

Gaudi::Property<float> TrigEgammaFastElectronHypoTool::m_trtRatio { this, "TRTRatio", 0, "TRT HT ratio" }

private

Definition at line 51 of file TrigEgammaFastElectronHypoTool.h.

---

The documentation for this class was generated from the following files:

• TrigEgammaFastElectronHypoTool.h
• TrigEgammaFastElectronHypoTool.cxx