EGammaAmbiguityTool Class Reference

Electron / photon ambiguity resolution. More...

#include <EGammaAmbiguityTool.h>

Inheritance diagram for EGammaAmbiguityTool:

Collaboration diagram for EGammaAmbiguityTool:

Public Member Functions
	EGammaAmbiguityTool (const std::string &myname)
	Standard constructor.
virtual	~EGammaAmbiguityTool ()=default
	Standard destructor.
virtual StatusCode	initialize () override final
	Gaudi Service Interface method implementations.
virtual unsigned int	ambiguityResolve (const xAOD::CaloCluster *cluster, const xAOD::Vertex *vx, const xAOD::TrackParticle *tp, xAOD::AmbiguityTool::AmbiguityType &type) const override final
	Return value: AuthorElectron, AuthorPhoton, AuthorAmbiguous, AuthorUnknown.
virtual unsigned int	ambiguityResolve (const xAOD::CaloCluster *cluster, const xAOD::Vertex *vx, const xAOD::TrackParticle *tp) const override final
	Return value: AuthorElectron, AuthorPhoton, AuthorAmbiguous, AuthorUnknown Needed because of existing client usage (i.e Trigger).
virtual unsigned int	ambiguityResolve (const xAOD::Egamma &egamma) const override final
	Access the ambiguity resolution of central electrons and photons and return AuthorElectron, AuthorPhoton, AuthorAmbiguous, AuthorUnknown or the author of the object if no overlapping object is found.
virtual bool	accept (const xAOD::Egamma &egamma) const override final
	Accept or reject egamma object based on ambiguity resolution (e.g.
bool	hasInnermostPixelHit (const xAOD::TrackParticle &tp) const
	Return true if track has innermost pixel hit or next-to-innermost in case innermost is not expected or at least m_MinNoPixHits pixel hits in case next-to-innermost is not expected.
size_t	nTrkWithInnermostPixelHits (const xAOD::Vertex &vx) const
	Return the number of tracks with "innermost pixel hits" (see above) in the given vertex.
bool	isInVertex (const xAOD::TrackParticle &, const xAOD::Vertex &) const
	Return true if the given TrackParticle is part of the vertex.
bool	passDeltaR_innermost (const xAOD::Vertex &vx) const
	Return true if the vertex passes the requirement on Rconv - RfirstHit.
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
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
int	m_MinNoSiHits
	Minimum number of silicon hits to be an electron and not a photon.
int	m_MinNoPixHits
	Minimum number of pixel hits to be an electron and not a photon.
float	m_maxEoverPCut
	Maximum EoverP, more that this is ambiguous.
float	m_minPtCut
	Minimum Pt, less that this is ambiguous.
float	m_maxDeltaR_innermost
	Maximum value for Rconv - RfirstHit for Si+Si conversions where both tracks have innermost hits.
bool	m_noVertexNoInnermostAsAmb
	no vertex && no innermost hit -> amb.
bool	m_acceptAmbiguous
	@When used as a selector reject/accpet ambiguous cases
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

Electron / photon ambiguity resolution.

Dual-use version

Authors

Bruno Lenzi, Anastopoulos Christos, Ludovica Apperio Bella

Date

May 2015

Dual-use version

Author

Bruno Lenzi , Christos Anastopoulos, Ruggero Turra

Date

May 2015

Dual-use version, interface

Author

Bruno Lenzi

Date

May 2015

Definition at line 21 of file EGammaAmbiguityTool.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

EGammaAmbiguityTool()

EGammaAmbiguityTool::EGammaAmbiguityTool

(

const std::string &

myname

)

Standard constructor.

Definition at line 38 of file EGammaAmbiguityTool.cxx.

  : asg::AsgTool(myname)
{
  declareProperty(
    "minNoSiHits",
    m_MinNoSiHits = 4,
    "Minimum number of silicon hits to be an electron==>not photon for sure");
  declareProperty(
    "minNoPixHits",
    m_MinNoPixHits = 2,
    "Minimum number of Pixel hits to be an electron==>not photon for sure");
  declareProperty("maxEoverPCut",
                  m_maxEoverPCut = 10,
                  "Maximum EoverP , more that this is ambiguous");
  declareProperty(
    "minPCut", m_minPtCut = 2000, "Minimum Pt, less than that is ambiguous");
  declareProperty("maxDeltaR_innermost",
                  m_maxDeltaR_innermost = 40,
                  "Maximum value for Rconv - RfirstHit for Si+Si conversions "
                  "where both tracks have innermost hits");
  declareProperty("noVertexNoInnermostAsAmb",
                  m_noVertexNoInnermostAsAmb = true,
                  "If true classify as ambiguous when there is no vertex and "
                  "no innermost Hits. "
                  "If false classify no vertex as for sure not photon");
  declareProperty("AcceptAmbiguous",
                  m_acceptAmbiguous = true,
                  "When used as a selector accept the ambiguous as default");
}

~EGammaAmbiguityTool()

virtual EGammaAmbiguityTool::~EGammaAmbiguityTool ( )

virtualdefault

Standard destructor.

Member Function Documentation

accept()

bool EGammaAmbiguityTool::accept ( const xAOD::Egamma & egamma ) const

finaloverridevirtual

Accept or reject egamma object based on ambiguity resolution (e.g.

Accept or reject egamma object based on ambiguity resolution.

if object is a photon and ambiguity return value is electron -> reject)

Implements IEGammaAmbiguityTool.

Definition at line 289 of file EGammaAmbiguityTool.cxx.

                                                               {
  unsigned int author = ambiguityResolve(egamma);
 
  if (author == xAOD::EgammaParameters::AuthorFwdElectron ||
      author == xAOD::EgammaParameters::AuthorCaloTopo35){
    return true;
  }
 
  if (m_acceptAmbiguous && author == xAOD::EgammaParameters::AuthorAmbiguous){
    return true;
  }
 
 return (author == (egamma.type() == xAOD::Type::Electron ?
             xAOD::EgammaParameters::AuthorElectron : xAOD::EgammaParameters::AuthorPhoton) );
}

ambiguityResolve() [1/3]

unsigned int EGammaAmbiguityTool::ambiguityResolve ( const xAOD::CaloCluster * cluster, const xAOD::Vertex * vx, const xAOD::TrackParticle * tp ) const

finaloverridevirtual

Return value: AuthorElectron, AuthorPhoton, AuthorAmbiguous, AuthorUnknown Needed because of existing client usage (i.e Trigger).

Implementation calls method above

Implements IEGammaAmbiguityTool.

Definition at line 232 of file EGammaAmbiguityTool.cxx.

                                                                                     {
 
  xAOD::AmbiguityTool::AmbiguityType type;
  return ambiguityResolve(cluster,
              vx,
              tp,
              type);
 
}

ambiguityResolve() [2/3]

unsigned int EGammaAmbiguityTool::ambiguityResolve ( const xAOD::CaloCluster * cluster, const xAOD::Vertex * vx, const xAOD::TrackParticle * tp, xAOD::AmbiguityTool::AmbiguityType & type ) const

finaloverridevirtual

Return value: AuthorElectron, AuthorPhoton, AuthorAmbiguous, AuthorUnknown.

Implements IEGammaAmbiguityTool.

Definition at line 75 of file EGammaAmbiguityTool.cxx.

                                                                      {
 
  type=xAOD::AmbiguityTool::unknown;
  // Result should stay the same before after calibration corrections
  double cluster_e = (cluster->clusterSize() != xAOD::CaloCluster::SW_35ele &&
                      cluster->clusterSize() != xAOD::CaloCluster::SW_35gam &&
                      cluster->clusterSize() != xAOD::CaloCluster::SuperCluster)
                       ? cluster->altE()
                       : cluster->e();
 
  //Number of hits from the track
  uint8_t trkPixelHits(0);
  uint8_t trkSiHits(0);
  if (tp && !tp->summaryValue(trkPixelHits,xAOD::numberOfPixelHits)){
    ATH_MSG_WARNING("Could not retrieve number of pixel hits from track");
  }
  if (tp && !tp->summaryValue(trkSiHits, xAOD::numberOfSCTHits)){
    ATH_MSG_WARNING("Could not retrieve number of SCT hits from track");
  }
  trkSiHits += trkPixelHits;
 
  //Check if the vertex is double silicon
  xAOD::EgammaParameters::ConversionType convType(xAOD::EgammaHelpers::conversionType(vx));
  bool vxDoubleSi = (convType == xAOD::EgammaParameters::doubleSi);
 
  // Check if the track particle and the ones associated to the conversion vertex
  // have innermost pixel hits
  bool trkHasInnermostHit = tp && hasInnermostPixelHit(*tp);
  size_t nTrkVxWithInnermostHit{};
  if (vx and vxDoubleSi) nTrkVxWithInnermostHit = nTrkWithInnermostPixelHits(*vx);
 
  //See if the Si+Si conversion shares one track with the electron
  //if not we might have a trident.
  //if yes and the track is not good we definitely matched the conversion as electron.
  bool shareTrack = vx && tp && trkSiHits>=m_MinNoSiHits && vxDoubleSi && isInVertex(*tp, *vx);
 
  //Debug messages
  ATH_MSG_DEBUG("Vertex, SiSi, tracks with innermost pixel hits: "
        << (vx != nullptr) << ", " << vxDoubleSi << ",  " << nTrkVxWithInnermostHit);
  ATH_MSG_DEBUG("Track, Si hits, pixel hits, has innermost pixel hit: "
        << (tp != nullptr) << ", " << (int) trkSiHits << ", " << (int) trkPixelHits
        << " , " <<  (int) trkHasInnermostHit);
  ATH_MSG_DEBUG("Share track : " << shareTrack);
 
  //The Electron collection will NOT contain Photons
  //The Photon collection will NOT contain Electrons
 
  //So for conversions vs electrons better to go to ambiguous
  //except  if we are sure.
 
  //Practically a photon here means definetely not Electron
  //And vice-versa
 
  //Photon ==> Surely not electron
  // - no track
  // - or no track with the minimum requirent hits to be an electron
  // - or Si+Si vertex and
  //    - No pixel
  //    - The electron track is part of the conversion
  // In this case we do not want this to be in Electrons
  if (!tp ||
      trkSiHits<m_MinNoSiHits ||
      (vxDoubleSi && !trkPixelHits && shareTrack)){
    ATH_MSG_DEBUG("Returning Photon");
    type= xAOD::AmbiguityTool::photon;
    return xAOD::EgammaParameters::AuthorPhoton;
  }
 
  // Ambigous due to E/P, Min Pt, pixel hits
  // We are not sure it is a Photon, but is not good enough either to be surely
  // an Electron
  // - E/P >10  or track Pt < 2.0 GeV or no-pixel then Ambiguous
  double track_ep = cluster_e * fabs(tp->qOverP());
 
  if(tp->pt()<m_minPtCut) {
    ATH_MSG_DEBUG("Returning Ambiguous due  min Pt");
    type=xAOD::AmbiguityTool::ambiguousTrackLowPt;
    return xAOD::EgammaParameters::AuthorAmbiguous;
  }
 
  if( track_ep > m_maxEoverPCut) {
    ATH_MSG_DEBUG("Returning Ambiguous due to E over P");
    type=xAOD::AmbiguityTool::ambiguousTrackHighEoverP;
    return xAOD::EgammaParameters::AuthorAmbiguous;
  }
 
 
  if(!trkPixelHits) {
    ATH_MSG_DEBUG("Returning Ambiguous due to  no pixels");
    type=xAOD::AmbiguityTool::ambiguousTrackNoPixel;
    return xAOD::EgammaParameters::AuthorAmbiguous;
  }
 
  // Electron ==> Surely not Photon
  // - No vertex Matched (and trk has "innermost pixel hits" when
  // m_noVertexNoInnermostAsAmb is true,
  //   othewise ambiguous)
  // - Track with at least the minimum Si and Pixel hits (previous selection for
  // photons/ambiguous)
  // - And has E/P < 10 and Pt > 2.0 GeV (previous for ambiguous)
  // - Or if a vertex exists and:
  //   * is not Si+Si
  //   * is Si+Si but only 1 trk has "innermost pixel hits"
  //   * is Si+Si and both tracks have "innermost pixel hits" but
  //     Rconv - RfirstHit > maxDeltaR_innermost
  // In this case we do not want this to be in Photons
 
  if (!vx) {
    if (trkHasInnermostHit || !m_noVertexNoInnermostAsAmb) {
      ATH_MSG_DEBUG("Returning Electron");
      type = xAOD::AmbiguityTool::electron;
      return xAOD::EgammaParameters::AuthorElectron;
    } else {
      // the true photons falling here are classified as unconverted photons
      // but it may happen that they are late single-track conversions
      // very few true electrons are falling here, since there is no innermost
      // hits
      ATH_MSG_DEBUG("Returning Ambiguous due to no conv vertex and track with "
                    "no innermost hits");
      type = xAOD::AmbiguityTool::ambiguousNoInnermost;
      return xAOD::EgammaParameters::AuthorAmbiguous;
    }
  }
 
  // here we have a conv vertex
  if (trkHasInnermostHit && (!vxDoubleSi || nTrkVxWithInnermostHit == 1 ||
                             !passDeltaR_innermost(*vx))) {
    ATH_MSG_DEBUG("Returning Electron");
    type = xAOD::AmbiguityTool::electron;
    return xAOD::EgammaParameters::AuthorElectron;
  }
 
  // Ambiguous all else, these will go to both electrons and photons
  // A matched Si+Si vertex (where either both or none of the tracks have
  // "innermost pixel hits")
  // and a track with "innermost pixel hits"
  // A non Si+Si vertex matched and a track with no "innermost pixel hits"
 
  //If we have no double si
  //or if the single track p matches the cluster E than the vertex p
  //mark TrackEoverPBetterThanVertexEover.
  //Otherwise maek as TrackEoverPBetterThanVertexEover
  //as the double si vertex is a better match to the cluster E.
  const double track_p = fabs(1.0/tp->qOverP());
  const double vertex_p=xAOD::EgammaHelpers::momentumAtVertex(*vx).mag() ;
  type = !vxDoubleSi || (fabs(track_p - cluster_e) < fabs(vertex_p- cluster_e))?
    xAOD::AmbiguityTool::ambiguousTrackEoverPBetterThanVertexEoverP :
    xAOD::AmbiguityTool::ambiguousVertexEoverPBetterThanTrackEoverP ;
  //end of types
 
  ATH_MSG_DEBUG("Returning Ambiguous");
  return xAOD::EgammaParameters::AuthorAmbiguous;
}

ambiguityResolve() [3/3]

unsigned int EGammaAmbiguityTool::ambiguityResolve ( const xAOD::Egamma & egamma ) const

finaloverridevirtual

Access the ambiguity resolution of central electrons and photons and return AuthorElectron, AuthorPhoton, AuthorAmbiguous, AuthorUnknown or the author of the object if no overlapping object is found.

Redo the ambiguity resolution of central electrons and photons and return AuthorElectron, AuthorPhoton, AuthorAmbiguous, AuthorUnknown or the author of the object if no overlapping object is found.

ELink.isAvailable(*egamma)) {

Implements IEGammaAmbiguityTool.

Definition at line 250 of file EGammaAmbiguityTool.cxx.

                                                                                {
 
    //Fwd and Topo seeded not handled
  if (egamma.author() == xAOD::EgammaParameters::AuthorFwdElectron ||
      egamma.author() == xAOD::EgammaParameters::AuthorCaloTopo35){
    ATH_MSG_DEBUG("Author Fwd of Topo seeded.  Do not do overlap or ambiguity");
    return egamma.author();
  }
 
  //No overlap found so either photon or electron
  if (!egamma.ambiguousObject()){
    ATH_MSG_DEBUG("No overlaping object found");
    return egamma.author();
  }
 
  // Overlap found. define the electron and the photon
  const xAOD::Electron* electron = static_cast<const xAOD::Electron*>(
    egamma.type() == xAOD::Type::Electron ? &egamma : egamma.ambiguousObject());
  const xAOD::Photon* photon = static_cast<const xAOD::Photon*>(
    egamma.type() == xAOD::Type::Photon ? &egamma : egamma.ambiguousObject());
 
  //Error if cannot define any of them
  if (!electron || !photon){
    ATH_MSG_WARNING("Could not cast to electron and/or photon");
    return egamma.author();
  }
 
  //pass the proper input to the ambiguity resolve method
  xAOD::AmbiguityTool::AmbiguityType type;
  unsigned int result = ambiguityResolve(electron->caloCluster(),
                     photon->vertex(),
                     electron->trackParticle(),
                     type);
  ATH_MSG_DEBUG("Performed ambiguity resolution, resulting type is: "<< type);
  return result;
}

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

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

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
   }

getProperty()

template<class T>

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

inherited

Get one of the tool's properties.

hasInnermostPixelHit()

bool EGammaAmbiguityTool::hasInnermostPixelHit

(

const xAOD::TrackParticle &

tp

)

const

Return true if track has innermost pixel hit or next-to-innermost in case innermost is not expected or at least m_MinNoPixHits pixel hits in case next-to-innermost is not expected.

Definition at line 309 of file EGammaAmbiguityTool.cxx.

{
  uint8_t trkExpectHit(0);
  uint8_t trkNhits(0);
  CHECK_HITS( tp.summaryValue(trkNhits,xAOD::numberOfInnermostPixelLayerHits) );
  if (trkNhits) {return true;}
 
  CHECK_HITS( tp.summaryValue(trkExpectHit,xAOD::expectInnermostPixelLayerHit) );
  if (trkExpectHit) {return false;}
 
  CHECK_HITS( tp.summaryValue(trkNhits,xAOD::numberOfNextToInnermostPixelLayerHits) );
  if (trkNhits) {return true;}
 
  CHECK_HITS( tp.summaryValue(trkExpectHit,xAOD::expectNextToInnermostPixelLayerHit) );
  if (trkExpectHit) {return false;}
 
  CHECK_HITS( tp.summaryValue(trkNhits,xAOD::numberOfPixelHits) );
  return (trkNhits >= m_MinNoPixHits);
}

initialize()

StatusCode EGammaAmbiguityTool::initialize ( void )

finaloverridevirtual

Gaudi Service Interface method implementations.

Reimplemented from asg::AsgTool.

Definition at line 68 of file EGammaAmbiguityTool.cxx.

                                          {
  ATH_MSG_DEBUG("Initializing " << name() << "...");
  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.

isInVertex()

bool EGammaAmbiguityTool::isInVertex	(	const xAOD::TrackParticle &	trk,
		const xAOD::Vertex &	vx ) const

Return true if the given TrackParticle is part of the vertex.

Definition at line 342 of file EGammaAmbiguityTool.cxx.

                                                                                            {
  for (size_t i = 0; i < vx.nTrackParticles(); ++i){
    const xAOD::TrackParticle *tp = vx.trackParticle(i);
    if (!tp) {ATH_MSG_WARNING("Null pointer to track particle in vertex");}
    if (tp == &trk) {return true;}
  }
  return false;
}

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

nTrkWithInnermostPixelHits()

size_t EGammaAmbiguityTool::nTrkWithInnermostPixelHits

(

const xAOD::Vertex &

vx

)

const

Return the number of tracks with "innermost pixel hits" (see above) in the given vertex.

Definition at line 331 of file EGammaAmbiguityTool.cxx.

                                                                                {
  size_t n = 0;
  for (size_t i = 0; i < vx.nTrackParticles(); ++i){
    const xAOD::TrackParticle *tp = vx.trackParticle(i);
    if (!tp) {ATH_MSG_WARNING("Null pointer to track particle in vertex");}
    else if (hasInnermostPixelHit(*tp)) {++n;}
  }
  return n;
}

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.

passDeltaR_innermost()

bool EGammaAmbiguityTool::passDeltaR_innermost

(

const xAOD::Vertex &

vx

)

const

Return true if the vertex passes the requirement on Rconv - RfirstHit.

Definition at line 352 of file EGammaAmbiguityTool.cxx.

{
  static const SG::AuxElement::Accessor<float> minRfirstHitAcc("minRfirstHit");
  if (not minRfirstHitAcc.isAvailable(vx)) {
    ATH_MSG_WARNING("minRfirstHit not available");
    return false;
  }
  return xAOD::EgammaHelpers::conversionRadius(&vx) - minRfirstHitAcc(vx) < m_maxDeltaR_innermost;
}

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.

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_acceptAmbiguous

bool EGammaAmbiguityTool::m_acceptAmbiguous

private

@When used as a selector reject/accpet ambiguous cases

Definition at line 97 of file EGammaAmbiguityTool.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_maxDeltaR_innermost

float EGammaAmbiguityTool::m_maxDeltaR_innermost

private

Maximum value for Rconv - RfirstHit for Si+Si conversions where both tracks have innermost hits.

Definition at line 93 of file EGammaAmbiguityTool.h.

m_maxEoverPCut

float EGammaAmbiguityTool::m_maxEoverPCut

private

Maximum EoverP, more that this is ambiguous.

Definition at line 89 of file EGammaAmbiguityTool.h.

m_MinNoPixHits

int EGammaAmbiguityTool::m_MinNoPixHits

private

Minimum number of pixel hits to be an electron and not a photon.

Definition at line 87 of file EGammaAmbiguityTool.h.

m_MinNoSiHits

int EGammaAmbiguityTool::m_MinNoSiHits

private

Minimum number of silicon hits to be an electron and not a photon.

Definition at line 85 of file EGammaAmbiguityTool.h.

m_minPtCut

float EGammaAmbiguityTool::m_minPtCut

private

Minimum Pt, less that this is ambiguous.

Definition at line 91 of file EGammaAmbiguityTool.h.

m_noVertexNoInnermostAsAmb

bool EGammaAmbiguityTool::m_noVertexNoInnermostAsAmb

private

no vertex && no innermost hit -> amb.

Use true in reconstruction to have more ambiguous

Definition at line 95 of file EGammaAmbiguityTool.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.

---

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

• EGammaAmbiguityTool.h
• EGammaAmbiguityTool.cxx