AsgPhotonIsEMSelector Class Reference

Photon isEM selector. More...

#include <AsgPhotonIsEMSelector.h>

Inheritance diagram for AsgPhotonIsEMSelector:

Collaboration diagram for AsgPhotonIsEMSelector:

Public Member Functions
virtual void	print () const
	Print the state of the tool.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const
Additional helper functions, not directly mimicking Athena
template<class T>
const T *	getProperty (const std::string &name) const
	Get one of the tool's properties.
const std::string &	msg_level_name () const __attribute__((deprecated))
	A deprecated function for getting the message level's name.
const std::string &	getName (const void *ptr) const
	Get the name of an object that is / should be in the event store.
SG::sgkey_t	getKey (const void *ptr) const
	Get the (hashed) key of an object that is in the event store.

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
ASG_TOOL_CLASS3(AsgPhotonIsEMSelector, IAsgPhotonIsEMSelector, IAsgEGammaIsEMSelector, IAsgSelectionTool) public	~AsgPhotonIsEMSelector ()
	Default constructor.
virtual StatusCode	initialize ()
	AlgTool initialize method.
virtual const asg::AcceptInfo &	getAcceptInfo () const
	Method to get the plain AcceptInfo.
virtual asg::AcceptData	accept (const xAOD::IParticle *part) const
	Accept with generic interface.
virtual asg::AcceptData	accept (const EventContext &ctx, const xAOD::IParticle *part) const
virtual asg::AcceptData	accept (const EventContext &ctx, const xAOD::Egamma *part) const
	Accept with Egamma objects.
virtual asg::AcceptData	accept (const EventContext &ctx, const xAOD::Photon *part) const
	The main accept method: the actual cuts are applied here.
virtual asg::AcceptData	accept (const EventContext &ctx, const xAOD::Electron *part) const
	The main accept method: the actual cuts are applied here.
virtual std::string	getOperatingPointName () const
	Method to get the operating point.
virtual StatusCode	execute (const EventContext &ctx, const xAOD::Egamma *eg, unsigned int &isEM) const
	The basic isem.
float	getMu (const EventContext &ctx) const
int	RunNumber (const EventContext &ctx) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
std::string	m_WorkingPoint
	Working Point.
std::string	m_configFile
	Config File.
Root::TPhotonIsEMSelector *	m_rootTool
	Pointer to the underlying ROOT based tool.
bool	m_useF3core
	use f3core or f3 (default: use f3)
bool	m_caloOnly
	Flag for calo only cut-base.
float	m_trigEtTh
bool	m_skipAmbiguityCut
bool	m_removeTRTConversion
bool	m_isMuDep = false
SG::ReadHandleKey< xAOD::EventInfo >	m_EvtInfoKey
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Photon isEM selector.

Author

Jovan Mitrevski Karsten Koeneke

Date

Dec 2011 - Fab 2012 11-MAR-2014 convert to ASG tool

Definition at line 38 of file AsgPhotonIsEMSelector.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

~AsgPhotonIsEMSelector()

AsgPhotonIsEMSelector::~AsgPhotonIsEMSelector ( )

private

Default constructor.

Destructor

Definition at line 82 of file AsgPhotonIsEMSelector.cxx.

{
  delete m_rootTool;
}

Member Function Documentation

accept() [1/5]

asg::AcceptData AsgPhotonIsEMSelector::accept ( const EventContext & ctx, const xAOD::Egamma * part ) const

privatevirtual

Accept with Egamma objects.

Implements IAsgEGammaIsEMSelector.

Definition at line 247 of file AsgPhotonIsEMSelector.cxx.

{
 
  if (eg) {
    unsigned int isEM = ~0;
    StatusCode sc = execute(ctx, eg, isEM);
    if (sc.isFailure()) {
      ATH_MSG_ERROR("could not calculate isEM");
      return m_rootTool->accept();
    }
    return m_rootTool->fillAccept(isEM);
  }
 
  ATH_MSG_ERROR("AsgElectronIsEMSelector::accept was given a bad argument");
  return m_rootTool->accept();
}

accept() [2/5]

asg::AcceptData AsgPhotonIsEMSelector::accept ( const EventContext & ctx, const xAOD::Electron * part ) const

privatevirtual

The main accept method: the actual cuts are applied here.

Implements IAsgEGammaIsEMSelector.

Definition at line 271 of file AsgPhotonIsEMSelector.cxx.

{
  return accept(ctx, static_cast<const xAOD::Egamma*>(el));
}

accept() [3/5]

asg::AcceptData AsgPhotonIsEMSelector::accept ( const EventContext & ctx, const xAOD::IParticle * part ) const

privatevirtual

Implements IAsgEGammaIsEMSelector.

Definition at line 233 of file AsgPhotonIsEMSelector.cxx.

{
 
  if (part->type() == xAOD::Type::Photon ||
      part->type() == xAOD::Type::Electron) {
    return accept(ctx, static_cast<const xAOD::Egamma*>(part));
  }
 
  ATH_MSG_ERROR(
    "AsgElectronIsEMSelector::could not convert argument to Photon/Electron");
  return m_rootTool->accept();
}

accept() [4/5]

asg::AcceptData AsgPhotonIsEMSelector::accept ( const EventContext & ctx, const xAOD::Photon * part ) const

privatevirtual

The main accept method: the actual cuts are applied here.

Implements IAsgEGammaIsEMSelector.

Definition at line 265 of file AsgPhotonIsEMSelector.cxx.

{
  return accept(ctx, static_cast<const xAOD::Egamma*>(ph));
}

accept() [5/5]

asg::AcceptData AsgPhotonIsEMSelector::accept ( const xAOD::IParticle * part ) const

privatevirtual

Accept with generic interface.

Implements IAsgEGammaIsEMSelector.

Definition at line 227 of file AsgPhotonIsEMSelector.cxx.

{
  return AsgPhotonIsEMSelector::accept(Gaudi::Hive::currentContext(), part);
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

StatusCode AsgPhotonIsEMSelector::execute ( const EventContext & ctx, const xAOD::Egamma * eg, unsigned int & isEM ) const

privatevirtual

The basic isem.

Implements IAsgEGammaIsEMSelector.

Definition at line 318 of file AsgPhotonIsEMSelector.cxx.

{
  //
  // Particle identification for photons based on cuts
  // trigEtTh : threshold in ET as applied by trigger
  //
  (void)ctx;
 
  // initialisation
  isEM = 0;
 
  // protection against null pointer
  if (eg == nullptr) {
    ATH_MSG_ERROR("eg == 0");
    // if object is bad then use the bit for "bad eta"
    isEM = (0x1 << egammaPID::ClusterEtaRange_Photon);
    return StatusCode::SUCCESS;
  }
 
  // protection against bad clusters
  const xAOD::CaloCluster* cluster = eg->caloCluster();
  if (cluster == nullptr) {
    ATH_MSG_ERROR("exiting because cluster is NULL " << cluster);
    // if object is bad then use the bit for "bad eta"
    isEM = (0x1 << egammaPID::ClusterEtaRange_Photon);
    return StatusCode::SUCCESS;
  }
 
  // Fill variables
  // eta position in second sampling
  const float eta2 = fabsf(cluster->etaBE(2));
  // transverse energy in calorimeter (using eta position in second sampling)
  const double energy = cluster->e();
  double et = 0.;
  if (eta2 < 999.) {
    const double cosheta = cosh(eta2);
    et = (cosheta != 0.) ? energy / cosheta : 0.;
  }
 
  // variables based on HCAL
  // transverse energy in 1st scintillator of hadronic calorimeter/ET
  float Rhad1 = eg->showerShapeValue(xAOD::EgammaParameters::Rhad1);
  // transverse energy in hadronic calorimeter/ET
  float Rhad = eg->showerShapeValue(xAOD::EgammaParameters::Rhad);
 
  // variables based on S2 of EM CAL
  // E(7*7) in 2nd sampling
  float e277 = eg->showerShapeValue(xAOD::EgammaParameters::e277);
  // E(3*7)/E(7*7) in 2nd sampling
  float Reta = eg->showerShapeValue(xAOD::EgammaParameters::Reta);
  // E(3*3)/E(3*7) in 2nd sampling
  float Rphi = eg->showerShapeValue(xAOD::EgammaParameters::Rphi);
  // shower width in 2nd sampling
  float weta2c = eg->showerShapeValue(xAOD::EgammaParameters::weta2);
 
  // variables based on S1 of EM CAL
  // fraction of energy reconstructed in the 1st sampling
  float f1 = eg->showerShapeValue(xAOD::EgammaParameters::f1);
  // shower width in 3 strips in 1st sampling
  float weta1c = eg->showerShapeValue(xAOD::EgammaParameters::weta1);
  // (E of 1st max in strips-E of 2nd max)/(E of 1st max+E of 2nd max)
  float Eratio = eg->showerShapeValue(xAOD::EgammaParameters::Eratio);
  // E(2nd max)-E(min) in strips
  float DeltaE = eg->showerShapeValue(xAOD::EgammaParameters::DeltaE);
  // total shower width in 1st sampling
  float wtot = eg->showerShapeValue(xAOD::EgammaParameters::wtots1);
  // E(+/-3)-E(+/-1)/E(+/-1)
  float fracm = eg->showerShapeValue(xAOD::EgammaParameters::fracs1);
 
  float f3(0);
  if (m_useF3core) {
    f3 = eg->showerShapeValue(xAOD::EgammaParameters::f3core);
  } else {
    f3 = eg->showerShapeValue(xAOD::EgammaParameters::f3);
  }
 
  // cut on E/p
  double ep = 1.0; // default passes
 
  if (m_caloOnly) {
    ATH_MSG_DEBUG("Doing CaloCutsOnly");
  } else {
    if (xAOD::EgammaHelpers::isConvertedPhoton(
          eg)) // returns false if not photon or no conversion
    {
      const xAOD::Photon* ph = static_cast<const xAOD::Photon*>(eg);
      float p = xAOD::EgammaHelpers::momentumAtVertex(ph).mag();
      if (p != 0.) {
        ep = energy / p;
      } else {
        ep = 9999999.;
      }
    }
  }
 
  // modifiy et when dealing with trigger
  // to be sure that it will take the correct bin (VD)
  if (m_trigEtTh > 0)
    et = m_trigEtTh * 1.01;
 
  // pileup
  float mu = m_isMuDep ? this->getMu(ctx) : -999;
  
  //runnumber
  int runnumber = this->RunNumber(ctx);
  bool excludeTRT = false;
  
  if(runnumber >= 410000 && m_removeTRTConversion) excludeTRT = true; // exclude TRT converted photons only for Run-3
  
 
  // apply calorimeter selection for photons
  isEM = m_rootTool->calcIsEm(eta2,
                              et,
                              Rhad1,
                              Rhad,
                              e277,
                              Reta,
                              Rphi,
                              weta2c,
                              f1,
                              Eratio,
                              DeltaE,
                              weta1c,
                              wtot,
                              fracm,
                              f3,
                              ep,
                              xAOD::EgammaHelpers::isConvertedPhoton(eg, excludeTRT),
                              mu);
 
  // Add ambiguity resolution cut for photon (vs electron)
  // to reproduce release 21.2 ambiguity tool configuration
  if (!m_skipAmbiguityCut){
      static const SG::AuxElement::Accessor<uint8_t> acc("ambiguityType");
      int AmbiguityType = acc(*eg);
      if (eg->author() == xAOD::EgammaParameters::AuthorAmbiguous &&
          AmbiguityType == xAOD::AmbiguityTool::ambiguousNoInnermost) {
        isEM |= (0x1 << egammaPID::AmbiguityResolution_Photon);
      }
  }
 
  return StatusCode::SUCCESS;
}

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

getAcceptInfo()

const asg::AcceptInfo & AsgPhotonIsEMSelector::getAcceptInfo ( ) const

privatevirtual

Method to get the plain AcceptInfo.

This is needed so that one can already get the AcceptInfo and query what cuts are defined before the first object is passed to the tool.

Implements IAsgSelectionTool.

Definition at line 218 of file AsgPhotonIsEMSelector.cxx.

{
  return m_rootTool->getAcceptInfo();
}

getKey()

SG::sgkey_t asg::AsgTool::getKey ( const void * ptr ) const

inherited

Get the (hashed) key of an object that is in the event store.

This is a bit of a special one. StoreGateSvc and xAOD::TEvent both provide ways for getting the SG::sgkey_t key for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

In order to allow tools to efficiently perform this operation, they can use this helper function.

See also

asg::AsgTool::getName

Parameters

ptr	The bare pointer to the object that the event store should know about

Returns

The hashed key of the object in the store. If not found, an invalid (zero) key.

Definition at line 119 of file AsgTool.cxx.

                                                    {
 
#ifdef XAOD_STANDALONE
      // In case we use @c xAOD::TEvent, we have a direct function call
      // for this.
      return evtStore()->event()->getKey( ptr );
#else
      const SG::DataProxy* proxy = evtStore()->proxy( ptr );
      return ( proxy == nullptr ? 0 : proxy->sgkey() );
#endif // XAOD_STANDALONE
   }

getMu()

float AsgPhotonIsEMSelector::getMu ( const EventContext & ctx ) const

private

Definition at line 464 of file AsgPhotonIsEMSelector.cxx.

                                                                {
  SG::ReadHandle<xAOD::EventInfo> evtI(m_EvtInfoKey, ctx);
  if (!evtI.isValid()) {
    ATH_MSG_WARNING("Cannot find EventInfo, returning -999.");
    return -999;
  }
  return evtI->actualInteractionsPerCrossing();
}

getName()

const std::string & asg::AsgTool::getName ( const void * ptr ) const

inherited

Get the name of an object that is / should be in the event store.

This is a bit of a special one. StoreGateSvc and xAOD::TEvent both provide ways for getting the std::string name for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

In order to allow tools to efficiently perform this operation, they can use this helper function.

See also

asg::AsgTool::getKey

Parameters

ptr	The bare pointer to the object that the event store should know about

Returns

The string name of the object in the store. If not found, an empty string.

Definition at line 106 of file AsgTool.cxx.

                                                            {
 
#ifdef XAOD_STANDALONE
      // In case we use @c xAOD::TEvent, we have a direct function call
      // for this.
      return evtStore()->event()->getName( ptr );
#else
      const SG::DataProxy* proxy = evtStore()->proxy( ptr );
      static const std::string dummy = "";
      return ( proxy == nullptr ? dummy : proxy->name() );
#endif // XAOD_STANDALONE
   }

getOperatingPointName()

std::string AsgPhotonIsEMSelector::getOperatingPointName ( ) const

privatevirtual

Method to get the operating point.

Get the name of the current operating point.

Implements IAsgEGammaIsEMSelector.

Definition at line 281 of file AsgPhotonIsEMSelector.cxx.

{
  //
  // For Loose, Medium and Tight ignore if the difference is in bit 23
  if (m_rootTool->m_isEMMask == egammaPID::PhotonLoose ||
      (egammaPID::PhotonLoose ^ m_rootTool->m_isEMMask) ==
        (0x1 << egammaPID::AmbiguityResolution_Photon)) {
    return "Loose";
  }
  if (m_rootTool->m_isEMMask == egammaPID::PhotonMedium ||
      (egammaPID::PhotonMedium ^ m_rootTool->m_isEMMask) ==
        (0x1 << egammaPID::AmbiguityResolution_Photon)) {
    return "Medium";
  }
  if (m_rootTool->m_isEMMask == egammaPID::PhotonTight ||
      (egammaPID::PhotonTight ^ m_rootTool->m_isEMMask) ==
        (0x1 << egammaPID::AmbiguityResolution_Photon)) {
    return "Tight";
  }
  if (m_rootTool->m_isEMMask == egammaPID::PhotonLooseEF) {
    return "LooseEF";
  }
  if (m_rootTool->m_isEMMask == egammaPID::PhotonMediumEF) {
    return "MediumEF";
  }
  if (m_rootTool->m_isEMMask == 0) {
    return "No cuts applied";
  }
 
  ATH_MSG_ERROR("Didn't recognize the given operating point with mask: "
                << m_rootTool->m_isEMMask);
  return "";
}

getProperty()

template<class T>

const T * asg::AsgTool::getProperty ( const std::string & name ) const

inherited

Get one of the tool's properties.

initialize()

StatusCode AsgPhotonIsEMSelector::initialize ( void )

privatevirtual

AlgTool initialize method.

----— Read in the TEnv config ---—///

----— Use helpers to read in the cut arrays ---—///

Reimplemented from asg::AsgTool.

Definition at line 89 of file AsgPhotonIsEMSelector.cxx.

{
  if (!m_WorkingPoint.empty()) {
    m_configFile = AsgConfigHelper::findConfigFile(
      m_WorkingPoint, EgammaSelectors::PhotonCutPointToConfFile);
    m_rootTool->m_isEMMask = AsgConfigHelper::findMask(
      m_WorkingPoint, EgammaSelectors::PhotonCutPointToMask);
  }
 
  std::string filename = PathResolverFindCalibFile(m_configFile);
  if (filename.empty()) {
    ATH_MSG_ERROR("Could not locate " << m_configFile);
    return StatusCode::FAILURE;
  }
  TEnv env;
  env.ReadFile(filename.c_str(), kEnvLocal);
  // Override the mask via the config only if it is not set
  if (m_rootTool->m_isEMMask == egammaPID::EgPidUndefined) {
    unsigned int mask(
      env.GetValue("isEMMask", static_cast<int>(egammaPID::EgPidUndefined)));
    m_rootTool->m_isEMMask = mask;
  }
  m_rootTool->m_cutBinEta_photonsNonConverted =
    AsgConfigHelper::HelperFloat("CutBinEta_photonsNonConverted", env);
  m_rootTool->m_cutBinEnergy_photonsNonConverted =
    AsgConfigHelper::HelperFloat("CutBinEnergy_photonsNonConverted", env);
  m_rootTool->m_cutBinMu_photonsNonConverted =
    AsgConfigHelper::HelperFloat("CutBinMu_photonsNonConverted", env);
  m_rootTool->m_e277_photonsNonConverted =
    AsgConfigHelper::HelperFloat("e277_photonsNonConverted", env);
  m_rootTool->m_cutHadLeakage_photonsNonConverted =
    AsgConfigHelper::HelperFloat("CutHadLeakage_photonsNonConverted", env);
  m_rootTool->m_Reta37_photonsNonConverted =
    AsgConfigHelper::HelperFloat("Reta37_photonsNonConverted", env);
  m_rootTool->m_Rphi33_photonsNonConverted =
    AsgConfigHelper::HelperFloat("Rphi33_photonsNonConverted", env);
  m_rootTool->m_weta2_photonsNonConverted =
    AsgConfigHelper::HelperFloat("weta2_photonsNonConverted", env);
  m_rootTool->m_cutBinEtaStrips_photonsNonConverted =
    AsgConfigHelper::HelperFloat("CutBinEtaStrips_photonsNonConverted", env);
  m_rootTool->m_cutBinEnergyStrips_photonsNonConverted =
    AsgConfigHelper::HelperFloat("CutBinEnergyStrips_photonsNonConverted", env);
  m_rootTool->m_cutBinMuStrips_photonsNonConverted =
    AsgConfigHelper::HelperFloat("CutBinMuStrips_photonsNonConverted", env);
  m_rootTool->m_f1_photonsNonConverted =
    AsgConfigHelper::HelperFloat("f1_photonsNonConverted", env);
  m_rootTool->m_deltae_photonsNonConverted =
    AsgConfigHelper::HelperFloat("deltae_photonsNonConverted", env);
  m_rootTool->m_DEmaxs1_photonsNonConverted =
    AsgConfigHelper::HelperFloat("DEmaxs1_photonsNonConverted", env);
  m_rootTool->m_wtot_photonsNonConverted =
    AsgConfigHelper::HelperFloat("wtot_photonsNonConverted", env);
  m_rootTool->m_fracm_photonsNonConverted =
    AsgConfigHelper::HelperFloat("fracm_photonsNonConverted", env);
  m_rootTool->m_w1_photonsNonConverted =
    AsgConfigHelper::HelperFloat("w1_photonsNonConverted", env);
  m_rootTool->m_cutF3_photonsNonConverted =
    AsgConfigHelper::HelperFloat("CutF3_photonsNonConverted", env);
  m_rootTool->m_cutBinEta_photonsConverted =
    AsgConfigHelper::HelperFloat("CutBinEta_photonsConverted", env);
  m_rootTool->m_cutBinEnergy_photonsConverted =
    AsgConfigHelper::HelperFloat("CutBinEnergy_photonsConverted", env);
  m_rootTool->m_cutBinMu_photonsConverted =
    AsgConfigHelper::HelperFloat("CutBinMu_photonsConverted", env);
  m_rootTool->m_e277_photonsConverted =
    AsgConfigHelper::HelperFloat("e277_photonsConverted", env);
  m_rootTool->m_cutHadLeakage_photonsConverted =
    AsgConfigHelper::HelperFloat("CutHadLeakage_photonsConverted", env);
  m_rootTool->m_Reta37_photonsConverted =
    AsgConfigHelper::HelperFloat("Reta37_photonsConverted", env);
  m_rootTool->m_Rphi33_photonsConverted =
    AsgConfigHelper::HelperFloat("Rphi33_photonsConverted", env);
  m_rootTool->m_weta2_photonsConverted =
    AsgConfigHelper::HelperFloat("weta2_photonsConverted", env);
  m_rootTool->m_cutBinEtaStrips_photonsConverted =
    AsgConfigHelper::HelperFloat("CutBinEtaStrips_photonsConverted", env);
  m_rootTool->m_cutBinEnergyStrips_photonsConverted =
    AsgConfigHelper::HelperFloat("CutBinEnergyStrips_photonsConverted", env);
  m_rootTool->m_cutBinMuStrips_photonsConverted =
    AsgConfigHelper::HelperFloat("CutBinMuStrips_photonsConverted", env);
  m_rootTool->m_f1_photonsConverted =
    AsgConfigHelper::HelperFloat("f1_photonsConverted", env);
  m_rootTool->m_deltae_photonsConverted =
    AsgConfigHelper::HelperFloat("deltae_photonsConverted", env);
  m_rootTool->m_DEmaxs1_photonsConverted =
    AsgConfigHelper::HelperFloat("DEmaxs1_photonsConverted", env);
  m_rootTool->m_wtot_photonsConverted =
    AsgConfigHelper::HelperFloat("wtot_photonsConverted", env);
  m_rootTool->m_fracm_photonsConverted =
    AsgConfigHelper::HelperFloat("fracm_photonsConverted", env);
  m_rootTool->m_w1_photonsConverted =
    AsgConfigHelper::HelperFloat("w1_photonsConverted", env);
  m_rootTool->m_cutminEp_photonsConverted =
    AsgConfigHelper::HelperFloat("CutminEp_photonsConverted", env);
  m_rootTool->m_cutmaxEp_photonsConverted =
    AsgConfigHelper::HelperFloat("CutmaxEp_photonsConverted", env);
  m_rootTool->m_cutF3_photonsConverted =
    AsgConfigHelper::HelperFloat("CutF3_photonsConverted", env);
 
  // Get the message level and set the underlying ROOT tool message level
  // accordingly
  m_rootTool->msg().setLevel(this->msg().level());
 
  // We need to initialize the underlying ROOT TSelectorTool
  if (m_rootTool->initialize().isFailure()) {
    ATH_MSG_ERROR("Could not initialize the TPhotonIsEMSelector!");
    return StatusCode::FAILURE;
  }
 
  // if we use mu-dependent menu
  m_isMuDep =
    !m_rootTool->m_cutBinMu_photonsNonConverted.empty() ||
    !m_rootTool->m_cutBinMu_photonsConverted.empty() ||
    !m_rootTool->m_cutBinMuStrips_photonsNonConverted.empty() ||
    !m_rootTool->m_cutBinMuStrips_photonsConverted.empty();
  ATH_CHECK(m_EvtInfoKey.initialize());
  if (m_isMuDep)
    ATH_MSG_INFO("Running a mu-dependent photon ID menu");
 
  return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg_level_name()

const std::string & asg::AsgTool::msg_level_name ( ) const

inherited

A deprecated function for getting the message level's name.

Instead of using this, weirdly named function, user code should get the string name of the current minimum message level (in case they really need it...), with:

MSG::name( msg().level() )

This function's name doesn't follow the ATLAS coding rules, and as such will be removed in the not too distant future.

Returns

The string name of the current minimum message level that's printed

Definition at line 101 of file AsgTool.cxx.

                                                  {
 
      return MSG::name( msg().level() );
   }

msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

print()

void asg::AsgTool::print ( ) const

virtualinherited

Print the state of the tool.

Implements asg::IAsgTool.

Reimplemented in AsgHelloTool, HI::HIPileupTool, JetBottomUpSoftDrop, JetConstituentsRetriever, JetDumper, JetFinder, JetFromPseudojet, JetModifiedMassDrop, JetPileupLabelingTool, JetPruner, JetPseudojetRetriever, JetReclusterer, JetReclusteringTool, JetRecTool, JetRecursiveSoftDrop, JetSoftDrop, JetSplitter, JetSubStructureMomentToolsBase, JetToolRunner, JetTrimmer, JetTruthLabelingTool, KtDeltaRTool, and LundVariablesTool.

Definition at line 131 of file AsgTool.cxx.

                             {
 
      ATH_MSG_INFO( "AsgTool " << name() << " @ " << this );
      return;
   }

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

RunNumber()

int AsgPhotonIsEMSelector::RunNumber ( const EventContext & ctx ) const

private

Definition at line 473 of file AsgPhotonIsEMSelector.cxx.

                                                                  {
    SG::ReadHandle<xAOD::EventInfo> evtI(m_EvtInfoKey, ctx);
     if (!evtI.isValid()) {
            ATH_MSG_WARNING("Cannot find EventInfo, returning -999.");
            return -999;
    }
    return evtI->runNumber();   
}

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_caloOnly

bool AsgPhotonIsEMSelector::m_caloOnly

private

Flag for calo only cut-base.

Definition at line 96 of file AsgPhotonIsEMSelector.h.

m_configFile

std::string AsgPhotonIsEMSelector::m_configFile

private

Config File.

Definition at line 87 of file AsgPhotonIsEMSelector.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_EvtInfoKey

SG::ReadHandleKey<xAOD::EventInfo> AsgPhotonIsEMSelector::m_EvtInfoKey

private

Initial value:

{ this,
      "EventInfo", "EventInfo", "The event info object key" }

Definition at line 109 of file AsgPhotonIsEMSelector.h.

                                             { this,
      "EventInfo", "EventInfo", "The event info object key" };

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_isMuDep

bool AsgPhotonIsEMSelector::m_isMuDep = false

private

Definition at line 106 of file AsgPhotonIsEMSelector.h.

m_removeTRTConversion

bool AsgPhotonIsEMSelector::m_removeTRTConversion

private

Definition at line 103 of file AsgPhotonIsEMSelector.h.

m_rootTool

Root::TPhotonIsEMSelector* AsgPhotonIsEMSelector::m_rootTool

private

Pointer to the underlying ROOT based tool.

Definition at line 90 of file AsgPhotonIsEMSelector.h.

m_skipAmbiguityCut

bool AsgPhotonIsEMSelector::m_skipAmbiguityCut

private

Definition at line 100 of file AsgPhotonIsEMSelector.h.

m_trigEtTh

float AsgPhotonIsEMSelector::m_trigEtTh

private

Definition at line 97 of file AsgPhotonIsEMSelector.h.

m_useF3core

bool AsgPhotonIsEMSelector::m_useF3core

private

use f3core or f3 (default: use f3)

Definition at line 93 of file AsgPhotonIsEMSelector.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

m_WorkingPoint

std::string AsgPhotonIsEMSelector::m_WorkingPoint

private

Working Point.

Definition at line 84 of file AsgPhotonIsEMSelector.h.

---

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

• AsgPhotonIsEMSelector.h
• AsgPhotonIsEMSelector.cxx