TrigEgammaPrecisionPhotonCaloIsoHypoTool Class Reference

#include <TrigEgammaPrecisionPhotonCaloIsoHypoTool.h>

Inheritance diagram for TrigEgammaPrecisionPhotonCaloIsoHypoTool:

Collaboration diagram for TrigEgammaPrecisionPhotonCaloIsoHypoTool:

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

Private Member Functions
int	findCutIndex (float eta) const

Private Attributes
HLT::Identifier	m_decisionId
Gaudi::Property< std::vector< float > >	m_etabin { this, "EtaBins", {} , "Bins of eta" }
	selection variable for PRECISION calo selection:eta bins More...
Gaudi::Property< std::vector< float > >	m_RelEtConeCut { this, "RelEtConeCut", {999., 999., 999.} , "Calo isolation cut on etcone20" }
Gaudi::Property< std::vector< float > >	m_RelTopoEtConeCut { this, "RelTopoEtConeCut", {999., 999., 999.}, "Calo isolation cut in [TopoEtcone20/pt, TopoEtcone30/pt, TopoEtcone40/pt]" }
Gaudi::Property< std::vector< float > >	m_CutOffset { this, "Offset", {0., 0., 0.} , "Calo isolation offset cut in [(Topo)Etcone20/pt, (Topo)Etcone30/pt, (Topo)Etcone40/pt]" }
Gaudi::Property< std::string >	m_pidName {this, "PidName", "", "Pid name"}
Gaudi::Property< bool >	m_acceptAll {this, "AcceptAll", false, "Force accept the event"}
ToolHandle< GenericMonitoringTool >	m_monTool { this, "MonTool", "", "Monitoring tool" }
SG::ReadDecorHandleKey< xAOD::EventInfo >	m_avgMuKey { this, "averageInteractionsPerCrossingKey", "EventInfo.averageInteractionsPerCrossing", "Decoration for Average Interaction Per Crossing" }

Detailed Description

Definition at line 35 of file TrigEgammaPrecisionPhotonCaloIsoHypoTool.h.

Constructor & Destructor Documentation

TrigEgammaPrecisionPhotonCaloIsoHypoTool()

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

Definition at line 31 of file TrigEgammaPrecisionPhotonCaloIsoHypoTool.cxx.

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

Member Function Documentation

decide() [1/2]

bool TrigEgammaPrecisionPhotonCaloIsoHypoTool::decide ( const ITrigEgammaPrecisionPhotonCaloIsoHypoTool::PhotonInfo &  i ) const

overridevirtual

Definition at line 65 of file TrigEgammaPrecisionPhotonCaloIsoHypoTool.cxx.

{
 
  bool pass = false;
 
  auto mon_ET              = Monitored::Scalar( "Et_em", -1.0 );
  auto mon_etaBin          = Monitored::Scalar( "EtaBin", -1.0 );
  auto mon_Eta             = Monitored::Scalar( "Eta", -99. );
  auto mon_Phi             = Monitored::Scalar( "Phi", -99. );
  auto mon_mu              = Monitored::Scalar("mu",   -1.);
  auto mon_etcone20        = Monitored::Scalar("etcone20",   -99.);
  auto mon_topoetcone20    = Monitored::Scalar("topoetcone20",   -99.);
  auto mon_reletcone20     = Monitored::Scalar("reletcone20",   -99.);
  auto mon_reltopoetcone20 = Monitored::Scalar("reltopoetcone20",   -99.);
 
  auto mon_etcone30        = Monitored::Scalar("etcone30",   -99.);
  auto mon_topoetcone30    = Monitored::Scalar("topoetcone30",   -99.);
  auto mon_reletcone30     = Monitored::Scalar("reletcone30",   -99.);
  auto mon_reltopoetcone30 = Monitored::Scalar("reltopoetcone30",   -99.);
 
  auto mon_etcone40        = Monitored::Scalar("etcone40",   -99.);
  auto mon_topoetcone40    = Monitored::Scalar("topoetcone40",   -99.);
  auto mon_reletcone40     = Monitored::Scalar("reletcone40",   -99.);
  auto mon_reltopoetcone40 = Monitored::Scalar("reltopoetcone40",   -99.);
 
  auto PassedCuts          = Monitored::Scalar<int>( "CutCounter", -1 );  
  auto monitorIt           = Monitored::Group( m_monTool, 
                                        mon_etaBin, mon_Eta, mon_Phi, mon_mu, 
                                        mon_etcone20, mon_topoetcone20, mon_reletcone20, mon_reltopoetcone20, 
                                        mon_etcone30, mon_topoetcone30, mon_reletcone30, mon_reltopoetcone30, 
                                        mon_etcone40, mon_topoetcone40, mon_reletcone40, mon_reltopoetcone40, 
                                        PassedCuts );
 
  // when leaving scope it will ship data to monTool
  PassedCuts = PassedCuts + 1; //got called (data in place)
 
  float ET(0);
 
  auto roiDescriptor = input.roi;
 
  if ( fabs( roiDescriptor->eta() ) > 2.6 ) {
      ATH_MSG_DEBUG( "REJECT The photon had eta coordinates beyond the EM fiducial volume : " 
                    << roiDescriptor->eta() << "; stop the chain now" );
      pass=false; // special case       
      return pass;
  } 
 
  ATH_MSG_DEBUG( "; RoI ID = " << roiDescriptor->roiId() 
                << ": Eta = " << roiDescriptor->eta() 
                << ", Phi = " << roiDescriptor->phi() );
 
 
  auto pClus = input.photon->caloCluster();
  
  float absEta = fabs( pClus->eta() );
  const int cutIndex = findCutIndex( absEta );
  
  ET  = pClus->et();
  // eta = pClus->eta();
  // phi = pClus->phi();
 
  // eta range
  if ( !m_acceptAll && cutIndex == -1 ) {  // VD
    ATH_MSG_DEBUG( "Photon : " << absEta << " outside eta range " << m_etabin[m_etabin.size()-1] );
    return pass;
  } else { 
    ATH_MSG_DEBUG( "eta bin used for cuts " << cutIndex << " AcceptAll = " << m_acceptAll );
  }
  mon_etaBin = m_etabin[cutIndex]; 
  PassedCuts = PassedCuts + 1; // passed eta cut
  
  mon_ET = ET; 
 
  // get average luminosity information to calculate LH
  float avg_mu = 0; 
  SG::ReadDecorHandle<xAOD::EventInfo,float> eventInfoDecor(m_avgMuKey);
  if(eventInfoDecor.isPresent()) {
    avg_mu = eventInfoDecor(0);
    ATH_MSG_DEBUG("Average mu " << avg_mu);
  }
  mon_mu = avg_mu;
 
  float ptcone20(999), ptcone30(999), ptcone40(999), 
        etcone20(999), etcone30(999), etcone40(999), 
        topoetcone20(999), topoetcone30(999), topoetcone40(999), 
        reletcone20(999), reletcone30(999), reletcone40(999), 
        reltopoetcone20(999), reltopoetcone30(999), reltopoetcone40(999);
 
    
  // isolation variables
  input.photon->isolationValue(ptcone20, xAOD::Iso::ptcone20);
 
  input.photon->isolationValue(ptcone30, xAOD::Iso::ptcone30);
 
  input.photon->isolationValue(ptcone40, xAOD::Iso::ptcone40);
 
  input.photon->isolationValue(etcone20, xAOD::Iso::etcone20);
 
  input.photon->isolationValue(etcone30, xAOD::Iso::etcone30);
 
  input.photon->isolationValue(etcone40, xAOD::Iso::etcone40);
 
  input.photon->isolationValue(topoetcone20, xAOD::Iso::topoetcone20);
 
  input.photon->isolationValue(topoetcone30, xAOD::Iso::topoetcone30);
 
  input.photon->isolationValue(topoetcone40, xAOD::Iso::topoetcone40);
 
  ATH_MSG_DEBUG( " ptcone20     = " << ptcone20 ) ;
  ATH_MSG_DEBUG( " ptcone30     = " << ptcone30 ) ;
  ATH_MSG_DEBUG( " ptcone40     = " << ptcone40 ) ;
  ATH_MSG_DEBUG( " etcone20     = " << etcone20 ) ;
  ATH_MSG_DEBUG( " etcone30     = " << etcone30 ) ;
  ATH_MSG_DEBUG( " etcone40     = " << etcone40 ) ;
  ATH_MSG_DEBUG( " topoetcone20 = " << topoetcone20 ) ;
  ATH_MSG_DEBUG( " topoetcone30 = " << topoetcone30 ) ;
  ATH_MSG_DEBUG( " topoetcone40 = " << topoetcone40 ) ;
 
  // Monitor showershapes                      
  float photon_eT = input.photon->caloCluster()->et();
  mon_etcone20 = etcone20;
  reletcone20 = etcone20/photon_eT;
  ATH_MSG_DEBUG("reletcone20 = " <<reletcone20  );
  mon_reletcone20 = reletcone20;
 
  mon_topoetcone20 = topoetcone20;
  reltopoetcone20 = topoetcone20/photon_eT;
  ATH_MSG_DEBUG("reltopoetcone20 = " <<reltopoetcone20  );
  mon_reltopoetcone20 = reltopoetcone20;
 
  mon_etcone30 = etcone30;
  reletcone30 = etcone30/photon_eT;
  ATH_MSG_DEBUG("reletcone30 = " <<reletcone30  );
  mon_reletcone30 = reletcone30;
 
  mon_topoetcone30 = topoetcone30;
  reltopoetcone30 = topoetcone30/photon_eT;
  ATH_MSG_DEBUG("reltopoetcone30 = " <<reltopoetcone30  );
  mon_reltopoetcone30 = reltopoetcone30;
 
  mon_etcone40 = etcone40;
  reletcone40 = etcone40/photon_eT;
  ATH_MSG_DEBUG("reletcone40 = " <<reletcone40  );
  mon_reletcone40 = reletcone40;
 
  mon_topoetcone40 = topoetcone40;
  reltopoetcone40 = topoetcone40/photon_eT;
  ATH_MSG_DEBUG("reltopoetcone40 = " <<reltopoetcone40  );
  mon_reltopoetcone40 = reltopoetcone40;
 
  // Place here all etcone variables to apply the cuts within the loop on cone sizes
  std::vector<float> reltopoetcone;
  reltopoetcone.push_back(reltopoetcone20);
  reltopoetcone.push_back(reltopoetcone30);
  reltopoetcone.push_back(reltopoetcone40);
 
  std::vector<float> reletcone;
  reletcone.push_back(etcone20);
  reletcone.push_back(etcone30);
  reletcone.push_back(etcone40);
 
 
  bool pass_reletcone = true;    // If cut is not succeeded, this will be "AND"ed with a False result
  bool pass_reltopoetcone = true;
 
  // Loop over three indices 0,1 and 2, each referring to cones 20 30 and 40 and checking whether it passes or not
  for (unsigned int conesize=0; conesize<3; conesize++){
      ATH_MSG_DEBUG("m_RelEtConeCut[" << conesize << "] = " << m_RelEtConeCut[conesize] );
      ATH_MSG_DEBUG("m_RelTopoEtConeCut[" << conesize << "] = " << m_RelTopoEtConeCut[conesize] );
      ATH_MSG_DEBUG("m_CutOffset[" << conesize << "] = " << m_CutOffset[conesize] );
 
      // Check if need to apply isolation
      // First check logic. if cut is very big, then no isolation cut is defined
      // Applies to both reletcone[20,30,40] and reltopoetcone[20,30,40]
      if (m_RelEtConeCut[conesize] > 900){ // I guess we want to deprecate this?
          ATH_MSG_DEBUG(" not applying etcone[" << conesize << "] isolation.");
      }
      if (m_RelTopoEtConeCut[conesize] > 900){ // I guess we want to deprecate this?
          ATH_MSG_DEBUG(" not applying topoetcone[" << conesize << "] isolation.");
      }
      bool pass_this_reletcone     = ( m_RelEtConeCut[conesize] > 900 || ( reletcone[conesize] - m_CutOffset[conesize]/photon_eT < m_RelEtConeCut[conesize]));
      bool pass_this_reltopoetcone = ( m_RelTopoEtConeCut[conesize] > 900 || ( reltopoetcone[conesize] - m_CutOffset[conesize]/photon_eT  < m_RelTopoEtConeCut[conesize]));
 
      ATH_MSG_DEBUG(" pass_reletcone[" << conesize << "] =  "  << reletcone[conesize] << " - " << m_CutOffset[conesize] << "/" << photon_eT << "  < " << m_RelEtConeCut[conesize]  << " = " << pass_reletcone);
      ATH_MSG_DEBUG(" pass_reltopoetcone[" << conesize << "] =  "  << reltopoetcone[conesize] << " - " << m_CutOffset[conesize] << "/" << photon_eT << "  < " << m_RelEtConeCut[conesize] << " = " << pass_reltopoetcone);
 
      pass_reletcone     = pass_reletcone     && pass_this_reletcone     ; 
      pass_reltopoetcone = pass_reltopoetcone && pass_this_reltopoetcone ; 
  }
  // Reach this point successfully  
  pass = m_acceptAll || (pass_reletcone && pass_reltopoetcone);
  ATH_MSG_DEBUG( "AcceptAll          = " << m_acceptAll );
  ATH_MSG_DEBUG( "pass_reletcone     = " << pass_reletcone );
  ATH_MSG_DEBUG( "pass_reltopoetcone = " << pass_reltopoetcone );
  ATH_MSG_DEBUG( "pass               = " << pass );
 
  return pass;
 
}

decide() [2/2]

virtual StatusCode TrigEgammaPrecisionPhotonCaloIsoHypoTool::decide ( std::vector< ITrigEgammaPrecisionPhotonCaloIsoHypoTool::PhotonInfo > &  input ) const

overridevirtual

findCutIndex()

int TrigEgammaPrecisionPhotonCaloIsoHypoTool::findCutIndex ( float  eta ) const

private

Definition at line 265 of file TrigEgammaPrecisionPhotonCaloIsoHypoTool.cxx.

                                                                            {
  const float absEta = std::abs(eta);
  
  auto binIterator = std::adjacent_find( m_etabin.begin(), m_etabin.end(), [=](float left, float right){ return left < absEta and absEta < right; }  );
  if ( binIterator == m_etabin.end() ) {
    return -1;
  }
  return  binIterator - m_etabin.begin();
}

initialize()

StatusCode TrigEgammaPrecisionPhotonCaloIsoHypoTool::initialize ( )

overridevirtual

Definition at line 39 of file TrigEgammaPrecisionPhotonCaloIsoHypoTool.cxx.

{
  ATH_MSG_DEBUG( "Initialization completed successfully"   );    
  ATH_MSG_DEBUG( "EtaBins        = " << m_etabin   );
  
   if ( m_etabin.empty() ) {
    ATH_MSG_ERROR(  " There are no cuts set (EtaBins property is an empty list)" );
    return StatusCode::FAILURE;
  }
 
  // Now we try to retrieve the ElectronPhotonSelectorTools that we will use to apply the photon Identification. This is a *must*
 
 
  // Retrieving Luminosity info
  ATH_MSG_DEBUG( "Retrieving luminosityCondData..."  );
  ATH_CHECK( m_avgMuKey.initialize() );
 
  ATH_MSG_DEBUG( "Tool configured for chain/id: " << m_decisionId );
 
  if ( not m_monTool.name().empty() ) 
    CHECK( m_monTool.retrieve() );
 
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_acceptAll

Gaudi::Property< bool > TrigEgammaPrecisionPhotonCaloIsoHypoTool::m_acceptAll {this, "AcceptAll", false, "Force accept the event"}

private

Definition at line 56 of file TrigEgammaPrecisionPhotonCaloIsoHypoTool.h.

m_avgMuKey

SG::ReadDecorHandleKey<xAOD::EventInfo> TrigEgammaPrecisionPhotonCaloIsoHypoTool::m_avgMuKey { this, "averageInteractionsPerCrossingKey", "EventInfo.averageInteractionsPerCrossing", "Decoration for Average Interaction Per Crossing" }

private

Definition at line 61 of file TrigEgammaPrecisionPhotonCaloIsoHypoTool.h.

m_CutOffset

Gaudi::Property< std::vector<float> > TrigEgammaPrecisionPhotonCaloIsoHypoTool::m_CutOffset { this, "Offset", {0., 0., 0.} , "Calo isolation offset cut in [(Topo)Etcone20/pt, (Topo)Etcone30/pt, (Topo)Etcone40/pt]" }

private

Definition at line 52 of file TrigEgammaPrecisionPhotonCaloIsoHypoTool.h.

m_decisionId

HLT::Identifier TrigEgammaPrecisionPhotonCaloIsoHypoTool::m_decisionId

private

Definition at line 46 of file TrigEgammaPrecisionPhotonCaloIsoHypoTool.h.

m_etabin

Gaudi::Property< std::vector<float> > TrigEgammaPrecisionPhotonCaloIsoHypoTool::m_etabin { this, "EtaBins", {} , "Bins of eta" }

private

selection variable for PRECISION calo selection:eta bins

Definition at line 49 of file TrigEgammaPrecisionPhotonCaloIsoHypoTool.h.

m_monTool

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

private

Definition at line 58 of file TrigEgammaPrecisionPhotonCaloIsoHypoTool.h.

m_pidName

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

private

Definition at line 53 of file TrigEgammaPrecisionPhotonCaloIsoHypoTool.h.

m_RelEtConeCut

Gaudi::Property< std::vector<float> > TrigEgammaPrecisionPhotonCaloIsoHypoTool::m_RelEtConeCut { this, "RelEtConeCut", {999., 999., 999.} , "Calo isolation cut on etcone20" }

private

Definition at line 50 of file TrigEgammaPrecisionPhotonCaloIsoHypoTool.h.

m_RelTopoEtConeCut

Gaudi::Property< std::vector<float> > TrigEgammaPrecisionPhotonCaloIsoHypoTool::m_RelTopoEtConeCut { this, "RelTopoEtConeCut", {999., 999., 999.}, "Calo isolation cut in [TopoEtcone20/pt, TopoEtcone30/pt, TopoEtcone40/pt]" }

private

Definition at line 51 of file TrigEgammaPrecisionPhotonCaloIsoHypoTool.h.

---

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

• TrigEgammaPrecisionPhotonCaloIsoHypoTool.h
• TrigEgammaPrecisionPhotonCaloIsoHypoTool.cxx