AsgElectronIsEMSelector Class Reference

Tool to select objects. More...

#include <AsgElectronIsEMSelector.h>

Inheritance diagram for AsgElectronIsEMSelector:

Collaboration diagram for AsgElectronIsEMSelector:

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
virtual ASG_TOOL_CLASS3(AsgElectronIsEMSelector, IAsgElectronIsEMSelector, IAsgEGammaIsEMSelector, IAsgSelectionTool) public	~AsgElectronIsEMSelector ()
	Standard constructor.
virtual StatusCode	initialize () override
	Gaudi Service Interface method implementations.
virtual asg::AcceptData	accept (const EventContext &ctx, const xAOD::Egamma *part) const override final
	Accept with Egamma objects.
virtual std::string	getOperatingPointName () const override final
	Method to get the operating point.
unsigned int	calocuts_electrons (const xAOD::Egamma *eg, float eta2, double et, double trigEtTh, unsigned int iflag) const
unsigned int	TrackCut (const xAOD::Electron *eg, float eta2, double et, double energy, unsigned int iflag) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>
Methods from the IAsgSelectionTool interface
virtual const asg::AcceptInfo &	getAcceptInfo () const override final
	Method to get the plain AcceptInfo.
virtual asg::AcceptData	accept (const xAOD::IParticle *part) const override final
	Accept with generic interface.
virtual asg::AcceptData	accept (const EventContext &ctx, const xAOD::IParticle *part) const override final
Methods from the IAsgElectronIsEMSelectorinterface
virtual asg::AcceptData	accept (const EventContext &ctx, const xAOD::Photon *part) const override final
	Accept with Photon objects.
virtual asg::AcceptData	accept (const EventContext &ctx, const xAOD::Electron *part) const override final
	Accept with Electron objects.
virtual StatusCode	execute (const EventContext &ctx, const xAOD::Egamma *eg, unsigned int &isEM) const override final
	Add a legacy execute method - return isEM value.

Private Attributes
std::string	m_WorkingPoint
	Working Point.
std::string	m_configFile
	Config File.
Root::TElectronIsEMSelector *	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
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

Tool to select objects.

Electron isEM selector.

Tool to select photons.

Author

Jovan Mitrevski (UCSC) Karsten Koeneke (CERN)

Date

Dec 2011 - Fab 2012

Based on egammaElectronCutIDTool, by F. Derue.

11-MAR-2014, convert to ASGTool (Jovan Mitrevski)

Author

Jovan Mitrevski (UCSC) Karsten Koeneke (CERN)

Date

Dec 2011 - Fab 2012

Based on egammaPhotonCutIDTool, by F. Derue.

11-MAR-2014, convert to ASGTool

Author

Jovan Mitrevski (UCSC) Karsten Koeneke (CERN)

Date

Dec 2011 - Fab 2012

11-MAR-2014 convert to ASG tool (Jovan Mitrevski)

Definition at line 36 of file AsgElectronIsEMSelector.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Function Documentation

accept() [1/5]

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

finaloverrideprivatevirtual

Accept with Egamma objects.

Implements IAsgEGammaIsEMSelector.

Definition at line 205 of file AsgElectronIsEMSelector.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 AsgElectronIsEMSelector::accept ( const EventContext & ctx, const xAOD::Electron * part ) const

finaloverrideprivatevirtual

Accept with Electron objects.

Implements IAsgEGammaIsEMSelector.

Definition at line 224 of file AsgElectronIsEMSelector.cxx.

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

accept() [3/5]

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

finaloverrideprivatevirtual

Implements IAsgEGammaIsEMSelector.

Definition at line 190 of file AsgElectronIsEMSelector.cxx.

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

accept() [4/5]

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

finaloverrideprivatevirtual

Accept with Photon objects.

Implements IAsgEGammaIsEMSelector.

Definition at line 231 of file AsgElectronIsEMSelector.cxx.

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

accept() [5/5]

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

finaloverrideprivatevirtual

Accept with generic interface.

Implements IAsgEGammaIsEMSelector.

Definition at line 184 of file AsgElectronIsEMSelector.cxx.

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

calocuts_electrons()

unsigned int AsgElectronIsEMSelector::calocuts_electrons ( const xAOD::Egamma * eg, float eta2, double et, double trigEtTh, unsigned int iflag ) const

private

Definition at line 343 of file AsgElectronIsEMSelector.cxx.

{
 
  //
  // apply cut-based selection based on calo information
  // eg : xAOD::Electron object
  // trigETthr : threshold in ET to apply the cuts at trigger level
  // iflag: the starting isEM
  //
 
  float Reta(0);
  float Rphi(0);
  float Rhad1(0);
  float Rhad(0);
  float e277(0);
  float weta1c(0);
  float weta2c(0);
  float f1(0);
  float emax2(0);
  float Eratio(0);
  float DeltaE(0);
  float wtot(0);
  float fracm(0);
  float f3(0);
 
  bool allFound = true;
  // Reta
  allFound =
    allFound && eg->showerShapeValue(Reta, xAOD::EgammaParameters::Reta);
  // Rphi
  allFound =
    allFound && eg->showerShapeValue(Rphi, xAOD::EgammaParameters::Rphi);
  // transverse energy in 1st scintillator of hadronic calorimeter
  allFound =
    allFound && eg->showerShapeValue(Rhad1, xAOD::EgammaParameters::Rhad1);
  // transverse energy in hadronic calorimeter
  allFound =
    allFound && eg->showerShapeValue(Rhad, xAOD::EgammaParameters::Rhad);
  // E(7*7) in 2nd sampling
  allFound =
    allFound && eg->showerShapeValue(e277, xAOD::EgammaParameters::e277);
  // shower width in 3 strips in 1st sampling
  allFound =
    allFound && eg->showerShapeValue(weta1c, xAOD::EgammaParameters::weta1);
  // shower width in 2nd sampling
  allFound =
    allFound && eg->showerShapeValue(weta2c, xAOD::EgammaParameters::weta2);
  // fraction of energy reconstructed in the 1st sampling
  allFound = allFound && eg->showerShapeValue(f1, xAOD::EgammaParameters::f1);
  // E of 2nd max between max and min in strips
  allFound =
    allFound && eg->showerShapeValue(Eratio, xAOD::EgammaParameters::Eratio);
  // E of 1st max in strips
  allFound =
    allFound && eg->showerShapeValue(DeltaE, xAOD::EgammaParameters::DeltaE);
  // total shower width in 1st sampling
  allFound =
    allFound && eg->showerShapeValue(wtot, xAOD::EgammaParameters::wtots1);
  // E(+/-3)-E(+/-1)/E(+/-1)
  allFound =
    allFound && eg->showerShapeValue(fracm, xAOD::EgammaParameters::fracs1);
 
  if (m_useF3core) {
    allFound =
      allFound && eg->showerShapeValue(f3, xAOD::EgammaParameters::f3core);
  } else {
    allFound = allFound && eg->showerShapeValue(f3, xAOD::EgammaParameters::f3);
  }
 
  if (!allFound) {
    // if object is bad then use the bit for "bad eta"
    ATH_MSG_WARNING("Have some variables missing.");
    iflag = (0x1 << egammaPID::ClusterEtaRange_Electron);
    return iflag;
  }
 
  // For cut-based triggers above 20 GeV threshold, the online cut values on the
  // discriminant variables are always taken from the 20 GeV optimisation.
  //  if(et > 20000 )  { if(trigEtTh > 0) et = trigEtTh*1.01; }
 
  return m_rootTool->calocuts_electrons(eta2,
                                        et,
                                        Reta,  // replacing e233
                                        Rphi,  // replacing e237,
                                        Rhad1, // replacing ethad1,
                                        Rhad,  // replacing ethad,
                                        e277,
                                        weta1c,
                                        weta2c,
                                        f1,
                                        emax2,  // emax2
                                        Eratio, // emax
                                        DeltaE, // emin,
                                        wtot,
                                        fracm,
                                        f3,
                                        iflag,
                                        trigEtTh);
}

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 AsgElectronIsEMSelector::execute ( const EventContext & ctx, const xAOD::Egamma * eg, unsigned int & isEM ) const

finaloverrideprivatevirtual

Add a legacy execute method - return isEM value.

Implements IAsgEGammaIsEMSelector.

Definition at line 285 of file AsgElectronIsEMSelector.cxx.

{
  //
  // Particle identification for electrons based on cuts
  //
  (void)ctx;
  // initialisation
  isEM = 0;
  // protection against null pointer
  if (eg == nullptr) {
    // if object is bad then use the bit for "bad eta"
    ATH_MSG_ERROR("exiting because el is NULL");
    isEM = (0x1 << egammaPID::ClusterEtaRange_Electron);
    return StatusCode::SUCCESS;
  }
  // retrieve associated cluster
  const xAOD::CaloCluster* cluster = eg->caloCluster();
  if (cluster == nullptr) {
    // if object is bad then use the bit for "bad eta"
    ATH_MSG_ERROR("exiting because cluster is NULL");
    isEM = (0x1 << egammaPID::ClusterEtaRange_Electron);
    return StatusCode::SUCCESS;
  }
  // eta position in second sampling
  const float eta2 = fabsf(cluster->etaBE(2));
  // energy in calorimeter
  const double energy = cluster->e();
  // transverse energy of the electron (using the track eta)
  // const double et = el->pt();
  double et = (cosh(eta2) != 0.) ? energy / cosh(eta2) : 0.;
  ;
 
  // see if we have an electron, with track, for eta
  const xAOD::Electron* el = nullptr;
  if (eg->type() == xAOD::Type::Electron) {
    el = static_cast<const xAOD::Electron*>(eg);
  }
  if (el && el->trackParticle() && !m_caloOnly) {
    et = (cosh(el->trackParticle()->eta()) != 0.)
           ? energy / cosh(el->trackParticle()->eta())
           : 0.;
  }
 
  // Call the calocuts using the egamma object
  isEM = calocuts_electrons(eg, eta2, et, m_trigEtTh, 0);
 
  // Call the calo cuts using the el , if available and we want to apply them
  if (el && el->trackParticle() && !m_caloOnly) {
    isEM = TrackCut(el, eta2, et, energy, isEM);
  }
 
  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 & AsgElectronIsEMSelector::getAcceptInfo ( ) const

finaloverrideprivatevirtual

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 175 of file AsgElectronIsEMSelector.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
   }

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 AsgElectronIsEMSelector::getOperatingPointName ( ) const

finaloverrideprivatevirtual

Method to get the operating point.

Get the name of the current operating point.

Implements IAsgEGammaIsEMSelector.

Definition at line 241 of file AsgElectronIsEMSelector.cxx.

{
 
  if (!m_WorkingPoint.empty()) {
    return m_WorkingPoint;
  }
  if (m_rootTool->m_isEMMask == egammaPID::ElectronLoosePP) {
    return "Loose";
  }
  if (m_rootTool->m_isEMMask == egammaPID::ElectronMediumPP) {
    return "Medium";
  }
  if (m_rootTool->m_isEMMask == egammaPID::ElectronTightPP) {
    return "Tight";
  }
  if (m_rootTool->m_isEMMask == egammaPID::ElectronLoose1) {
    return "Loose1";
  }
  if (m_rootTool->m_isEMMask == egammaPID::ElectronMedium1) {
    return "Medium1";
  }
  if (m_rootTool->m_isEMMask == egammaPID::ElectronTight1) {
    return "Tight1";
  }
  if (m_rootTool->m_isEMMask == egammaPID::ElectronLooseHLT) {
    return "LooseHLT";
  }
  if (m_rootTool->m_isEMMask == egammaPID::ElectronMediumHLT) {
    return "MediumHLT";
  }
  if (m_rootTool->m_isEMMask == egammaPID::ElectronTightHLT) {
    return "TightHLT";
  }
  if (m_rootTool->m_isEMMask == 0) {
    return "0 No cuts applied";
  }
 
  ATH_MSG_INFO("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 AsgElectronIsEMSelector::initialize ( void )

overrideprivatevirtual

Gaudi Service Interface method implementations.

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

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

Reimplemented from asg::AsgTool.

Definition at line 74 of file AsgElectronIsEMSelector.cxx.

{
  // The standard status code
  StatusCode sc = StatusCode::SUCCESS;
 
  if (!m_WorkingPoint.empty()) {
    m_configFile = AsgConfigHelper::findConfigFile(
      m_WorkingPoint, EgammaSelectors::ElectronCutPointToConfFile);
  }
 
  // find the file and read it in
  std::string filename = PathResolverFindCalibFile(m_configFile);
  if (filename.empty()) {
    ATH_MSG_ERROR("Could not locate " << m_configFile);
    sc = StatusCode::FAILURE;
    return sc;
  }
  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) {
    int default_mask = static_cast<int>(egammaPID::EgPidUndefined);
    int mask(env.GetValue("isEMMask", default_mask));
    m_rootTool->m_isEMMask = static_cast<unsigned int>(mask);
  }
  //
  // From here on the conf ovverides all other properties
  bool useTRTOutliers(env.GetValue("useTRTOutliers", true));
  m_rootTool->m_useTRTOutliers = useTRTOutliers;
  bool useTRTXenonHits(env.GetValue(" useTRTXenonHits", false));
  m_rootTool->m_useTRTXenonHits = useTRTXenonHits;

  m_rootTool->m_cutBinEta = AsgConfigHelper::HelperFloat("CutBinEta", env);
  m_rootTool->m_cutBinET = AsgConfigHelper::HelperFloat("CutBinET", env);
  m_rootTool->m_cutF1 = AsgConfigHelper::HelperFloat("CutF1", env);
  m_rootTool->m_cutHadLeakage =
    AsgConfigHelper::HelperFloat("CutHadLeakage", env);
  m_rootTool->m_cutReta37 = AsgConfigHelper::HelperFloat("CutReta37", env);
  m_rootTool->m_cutRphi33 = AsgConfigHelper::HelperFloat("CutRphi33", env);
  m_rootTool->m_cutWeta2c = AsgConfigHelper::HelperFloat("CutWeta2c", env);
  m_rootTool->m_cutDeltaEmax2 =
    AsgConfigHelper::HelperFloat("CutDeltaEmax2", env);
  m_rootTool->m_cutDeltaE = AsgConfigHelper::HelperFloat("CutDeltaE", env);
  m_rootTool->m_cutDEmaxs1 = AsgConfigHelper::HelperFloat("CutDEmaxs1", env);
  m_rootTool->m_cutDeltaE = AsgConfigHelper::HelperFloat("CutDeltaE", env);
  m_rootTool->m_cutWtot = AsgConfigHelper::HelperFloat("CutWtot", env);
  m_rootTool->m_cutWeta1c = AsgConfigHelper::HelperFloat("CutWeta1c", env);
  m_rootTool->m_cutFracm = AsgConfigHelper::HelperFloat("CutFracm", env);
  m_rootTool->m_cutF3 = AsgConfigHelper::HelperFloat("CutF3", env);
  m_rootTool->m_cutBL = AsgConfigHelper::HelperInt("CutBL", env);
  m_rootTool->m_cutPi = AsgConfigHelper::HelperInt("CutPi", env);
  m_rootTool->m_cutSi = AsgConfigHelper::HelperInt("CutSi", env);
  m_rootTool->m_cutA0 = AsgConfigHelper::HelperFloat("CutA0", env);
  m_rootTool->m_cutA0Tight = AsgConfigHelper::HelperFloat("CutA0Tight", env);
  m_rootTool->m_cutDeltaEta = AsgConfigHelper::HelperFloat("CutDeltaEta", env);
  m_rootTool->m_cutDeltaEtaTight =
    AsgConfigHelper::HelperFloat("CutDeltaEtaTight", env);
  m_rootTool->m_cutminDeltaPhi =
    AsgConfigHelper::HelperFloat("CutminDeltaPhi", env);
  m_rootTool->m_cutmaxDeltaPhi =
    AsgConfigHelper::HelperFloat("CutmaxDeltaPhi", env);
  m_rootTool->m_cutminEp = AsgConfigHelper::HelperFloat("CutminEp", env);
  m_rootTool->m_cutmaxEp = AsgConfigHelper::HelperFloat("CutmaxEp", env);
  m_rootTool->m_cutBinEta_TRT =
    AsgConfigHelper::HelperFloat("CutBinEta_TRT", env);
  m_rootTool->m_cutBinET_TRT =
    AsgConfigHelper::HelperFloat("CutBinET_TRT", env);
  m_rootTool->m_cutNumTRT = AsgConfigHelper::HelperFloat("CutNumTRT", env);
  m_rootTool->m_cutTRTRatio = AsgConfigHelper::HelperFloat("CutTRTRatio", env);
  m_rootTool->m_cutTRTRatio90 =
    AsgConfigHelper::HelperFloat("CutTRTRatio90", env);
  m_rootTool->m_cutEProbabilityHT =
    AsgConfigHelper::HelperFloat("CutEProbabilityHT", env);
 
  ATH_MSG_INFO("operating point : " << this->getOperatingPointName()
                                    << " with mask: "
                                    << m_rootTool->m_isEMMask);
 
  // 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 TElectronIsEMSelector!");
    sc = StatusCode::FAILURE;
    return sc;
  }
 
  return sc;
}

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();
  }

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.

TrackCut()

unsigned int AsgElectronIsEMSelector::TrackCut ( const xAOD::Electron * eg, float eta2, double et, double energy, unsigned int iflag ) const

private

Definition at line 449 of file AsgElectronIsEMSelector.cxx.

{
  // apply track cuts for electron identification
  //  - Track quality cuts
  //  - (eta,phi) and E/p matching between ID and ECAL
  //  - use of TRT
  // eg : egamma object
  // iflag: the starting isEM to use
  //
  // retrieve associated track
  const xAOD::TrackParticle* t = eg->trackParticle();
 
  // protection against bad pointers
  if (t == nullptr) {
    ATH_MSG_ERROR("Something is bad with the variables as passed");
    // if object is bad then use the bit for "bad eta"
    iflag = (0x1 << egammaPID::ClusterEtaRange_Electron);
    return iflag;
  }
 
  // Track quality cuts
  uint8_t nSiHitsPlusDeadSensors =
    ElectronSelectorHelpers::numberOfSiliconHitsAndDeadSensors(*t);
  uint8_t nPixHitsPlusDeadSensors =
    ElectronSelectorHelpers::numberOfPixelHitsAndDeadSensors(*t);
  bool passBLayerRequirement =
    ElectronSelectorHelpers::passBLayerRequirement(*t);
 
  // TRT information
  uint8_t nTRThigh = 0;
  uint8_t nTRThighOutliers = 0;
  uint8_t nTRT = 0;
  uint8_t nTRTOutliers = 0;
  uint8_t nTRTXenonHits = 0;
  float TRT_PID = 0.0;
 
  bool allFound = true;
 
  allFound =
    allFound && t->summaryValue(nTRThigh, xAOD::numberOfTRTHighThresholdHits);
  allFound =
    allFound &&
    t->summaryValue(nTRThighOutliers, xAOD::numberOfTRTHighThresholdOutliers);
  allFound = allFound && t->summaryValue(nTRT, xAOD::numberOfTRTHits);
  allFound =
    allFound && t->summaryValue(nTRTOutliers, xAOD::numberOfTRTOutliers);
  allFound =
    allFound && t->summaryValue(nTRTXenonHits, xAOD::numberOfTRTXenonHits);
  allFound = allFound && t->summaryValue(TRT_PID, xAOD::eProbabilityHT);
 
  const float trackd0 = fabsf(t->d0());
 
  // Delta eta,phi matching
  float deltaeta;
  float deltaphi;
 
  allFound = allFound && eg->trackCaloMatchValue(
                           deltaeta, xAOD::EgammaParameters::deltaEta1);
  allFound = allFound && eg->trackCaloMatchValue(
                           deltaphi, xAOD::EgammaParameters::deltaPhi2);
 
  // E/p
  const double ep = energy * fabs(t->qOverP());
 
  if (!allFound) {
    // if object is bad then use the bit for "bad eta"
    ATH_MSG_WARNING("Have some variables missing.");
    iflag = (0x1 << egammaPID::ClusterEtaRange_Electron);
    return iflag;
  }
 
  return m_rootTool->TrackCut(eta2,
                              et,
                              passBLayerRequirement,
                              nPixHitsPlusDeadSensors,
                              nSiHitsPlusDeadSensors,
                              nTRThigh,
                              nTRThighOutliers,
                              nTRT,
                              nTRTOutliers,
                              nTRTXenonHits,
                              TRT_PID,
                              trackd0,
                              deltaeta,
                              deltaphi,
                              ep,
                              iflag);
}

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);
      }
    }
  }

~AsgElectronIsEMSelector()

AsgElectronIsEMSelector::~AsgElectronIsEMSelector ( )

privatevirtual

Standard constructor.

Standard destructor

Definition at line 68 of file AsgElectronIsEMSelector.cxx.

{
  delete m_rootTool;
}

Member Data Documentation

m_caloOnly

bool AsgElectronIsEMSelector::m_caloOnly

private

Flag for calo only cut-base.

Definition at line 121 of file AsgElectronIsEMSelector.h.

m_configFile

std::string AsgElectronIsEMSelector::m_configFile

private

Config File.

Definition at line 112 of file AsgElectronIsEMSelector.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_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_rootTool

Root::TElectronIsEMSelector* AsgElectronIsEMSelector::m_rootTool

private

Pointer to the underlying ROOT based tool.

Definition at line 115 of file AsgElectronIsEMSelector.h.

m_trigEtTh

float AsgElectronIsEMSelector::m_trigEtTh

private

Definition at line 122 of file AsgElectronIsEMSelector.h.

m_useF3core

bool AsgElectronIsEMSelector::m_useF3core

private

use f3core or f3 (default: use f3)

Definition at line 118 of file AsgElectronIsEMSelector.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 AsgElectronIsEMSelector::m_WorkingPoint

private

Working Point.

Definition at line 109 of file AsgElectronIsEMSelector.h.

---

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

• AsgElectronIsEMSelector.h
• AsgElectronIsEMSelector.cxx