EMTrackMatchBuilder Class Reference

EMTrackMatch data object builder. More...

#include <EMTrackMatchBuilder.h>

Inheritance diagram for EMTrackMatchBuilder:

Collaboration diagram for EMTrackMatchBuilder:

Classes
struct	TrackMatch
	A structure for keeping track match information. More...
class	TrackMatchSorter
	function object to sort track matches based on quality More...

Public Member Functions
	EMTrackMatchBuilder (const std::string &type, const std::string &name, const IInterface *parent)
	Default constructor.
virtual	~EMTrackMatchBuilder ()=default
	Destructor.
StatusCode	initialize () override final
	Gaudi algorithm hooks.
virtual StatusCode	executeRec (const EventContext &ctx, EgammaRecContainer *egammas) const override final
	execute method
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

Static Public Member Functions
static const InterfaceID &	interfaceID ()
	AlgTool interface methods.

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
StatusCode	trackExecute (const EventContext &ctx, egammaRec *eg, const xAOD::TrackParticleContainer *trackPC, const CaloDetDescrManager &caloDD) const
	execute method
bool	inBroadWindow (const EventContext &ctx, std::vector< TrackMatch > &trackMatches, const xAOD::CaloCluster &cluster, int trackNumber, const xAOD::TrackParticle &trkPB, const CaloDetDescrManager &caloDD) const
	Compute for tracks passing the loose matching the distance between track extrapolated to 2nd sampling and cluster.
bool	isCandidateMatch (const xAOD::CaloCluster *cluster, const xAOD::TrackParticle *track, bool flip) const
	Loose track-cluster matching.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
SG::ReadHandleKey< xAOD::TrackParticleContainer >	m_TrackParticlesKey
	name of TrackParticle container in TDS
SG::ReadCondHandleKey< CaloDetDescrManager >	m_caloDetDescrMgrKey
Gaudi::Property< double >	m_broadDeltaEta
	broad cut on deltaEta
Gaudi::Property< double >	m_broadDeltaPhi
	broad cut on deltaPhi
Gaudi::Property< double >	m_narrowDeltaEta
	narrow cut on deltaEta
Gaudi::Property< double >	m_narrowDeltaPhi
	narrow cut on deltaPhiRescale
Gaudi::Property< double >	m_narrowDeltaPhiBrem
	narrow cut on deltaPhi for electrons
Gaudi::Property< double >	m_narrowDeltaPhiRescale
	narrow cut on deltaPhiRescale
Gaudi::Property< double >	m_narrowDeltaPhiRescaleBrem
	narrow cut on deltaPhiRescale for electrons
Gaudi::Property< double >	m_MaxDeltaPhiRescale
	@Maximum deltaPhi (Res) allowed for a match
Gaudi::Property< bool >	m_useCandidateMatch
	flag to turn on/off use of isCandidateMatch
Gaudi::Property< bool >	m_useScoring
	Boolean to apply heuristic when tracks have close deltaR.
Gaudi::Property< bool >	m_useRescaleMetric
	Boolean to use Rescale in the metric.
Gaudi::Property< bool >	m_SecondPassRescale
	Boolean to do second pass with Rescale.
Gaudi::Property< float >	m_deltaEtaResolution
	The resolutions: might be good to split in barrel/end-cap in the future.
Gaudi::Property< float >	m_deltaPhiResolution
Gaudi::Property< float >	m_deltaPhiRescaleResolution
Gaudi::Property< float >	m_distanceForScore
	The distance from which one goes from using better deltaR to using score.
ToolHandle< IEMExtrapolationTools >	m_extrapolationTool
Gaudi::Property< bool >	m_isCosmics
double	m_deltaEtaWeight {}
double	m_deltaPhiWeight {}
double	m_deltaPhiRescaleWeight {}
TrackMatchSorter	m_sorter
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

EMTrackMatch data object builder.

Author

H. Ma

RD schaffer

Thomas Koffas

Christos Anastopoulos The matching of a track to a cluster is driven by the EMTrackMatchBuilder tool located in the Reconstruction/egamma/egammaTools package.

Definition at line 39 of file EMTrackMatchBuilder.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 376 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

EMTrackMatchBuilder()

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

Default constructor.

Definition at line 26 of file EMTrackMatchBuilder.cxx.

  : AthAlgTool(type, name, parent)
{
  // declare interface
  declareInterface<IEMTrackMatchBuilder>(this);
}

~EMTrackMatchBuilder()

virtual EMTrackMatchBuilder::~EMTrackMatchBuilder ( )

virtualdefault

Destructor.

Member Function Documentation

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

executeRec()

StatusCode EMTrackMatchBuilder::executeRec ( const EventContext & ctx, EgammaRecContainer * egammas ) const

finaloverridevirtual

execute method

Implements IEMTrackMatchBuilder.

Definition at line 53 of file EMTrackMatchBuilder.cxx.

{
  // protection against bad pointers
  if (egammas == nullptr) {
    return StatusCode::SUCCESS;
  }
  // retrieve the trackparticle container
  SG::ReadHandle<xAOD::TrackParticleContainer> trackPC(m_TrackParticlesKey,
                                                       ctx);
 
  SG::ReadCondHandle<CaloDetDescrManager> caloDetDescrMgrHandle{
    m_caloDetDescrMgrKey, ctx
  };
  ATH_CHECK(caloDetDescrMgrHandle.isValid());
 
  const CaloDetDescrManager* caloDD = *caloDetDescrMgrHandle;
 
  // check is only used for serial running; remove when MT scheduler used
  ATH_CHECK(trackPC.isValid());
  // Loop over calling the trackExecute method
  for (egammaRec* eg : *egammas) {
    // retrieve the cluster
    ATH_CHECK(trackExecute(ctx, eg, trackPC.cptr(), *caloDD));
  }
  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

inBroadWindow()

bool EMTrackMatchBuilder::inBroadWindow ( const EventContext & ctx, std::vector< TrackMatch > & trackMatches, const xAOD::CaloCluster & cluster, int trackNumber, const xAOD::TrackParticle & trkPB, const CaloDetDescrManager & caloDD ) const

private

Compute for tracks passing the loose matching the distance between track extrapolated to 2nd sampling and cluster.

Definition at line 153 of file EMTrackMatchBuilder.cxx.

{
 
  IEMExtrapolationTools::TrkExtrapDef extrapFrom =
    IEMExtrapolationTools::fromPerigee;
 
  // Now get the delta eta/phi and eta correction at the calorimeter
  // final arrays that we will write
  // Save the value of deltaPhiRescale. If we do not use rescaled
  // perigee, we recalculate deltaPhi using rescaled momentum. This
  // will be saved in EMTrackMatch
  std::array<double, 4> eta = { -999.0, -999.0, -999.0, -999.0 };
  std::array<double, 4> phi = { -999.0, -999.0, -999.0, -999.0 };
  std::array<double, 4> deltaEta = { -999.0, -999.0, -999.0, -999.0 };
  std::array<double, 4> deltaPhi = { -999.0, -999.0, -999.0, -999.0 };
 
  /*
   * Try both from perigee
   * and from perigee Rescale.
   *
   * We need anyhow both to be there at the end.
   */
  std::pair<std::vector<CaloSampling::CaloSample>,
            std::vector<std::unique_ptr<Trk::Surface>>>
    layersAndSurfaces =
      m_extrapolationTool->getClusterLayerSurfaces(cluster, caloDD);
  if (m_extrapolationTool
        ->getMatchAtCalo(ctx,
                         cluster,
                         trkPB,
                         layersAndSurfaces.first,
                         layersAndSurfaces.second,
                         eta,
                         phi,
                         deltaEta,
                         deltaPhi,
                         extrapFrom)
        .isFailure()) {
    return false;
  }
 
  IEMExtrapolationTools::TrkExtrapDef extrapFromRes =
    IEMExtrapolationTools::fromPerigeeRescaled;
  std::array<double, 4> etaRes = { -999.0, -999.0, -999.0, -999.0 };
  std::array<double, 4> phiRes = { -999.0, -999.0, -999.0, -999.0 };
  std::array<double, 4> deltaEtaRes = { -999.0, -999.0, -999.0, -999.0 };
  std::array<double, 4> deltaPhiRes = { -999.0, -999.0, -999.0, -999.0 };
 
  if (m_extrapolationTool
        ->getMatchAtCalo(ctx,
                         cluster,
                         trkPB,
                         layersAndSurfaces.first,
                         layersAndSurfaces.second,
                         etaRes,
                         phiRes,
                         deltaEtaRes,
                         deltaPhiRes,
                         extrapFromRes)
        .isFailure()) {
    return false;
  }
 
  double deltaPhiRescale = deltaPhiRes[2];
  /*
   * Sanity check for very far away matches
   * The assumption is when we rescale we should be in the
   * correct neighborhood for a valid track-cluster pair.
   */
  if (std::abs(deltaPhiRes[2]) > m_MaxDeltaPhiRescale) {
    ATH_MSG_DEBUG("DeltaPhiRescaled above maximum: "
                  << deltaPhiRes[2] << " (max: " << m_MaxDeltaPhiRescale
                  << ")");
    return false;
  }
  /*
   * Try to match : First standard way.
   * If this fails and the cluster Et is larger than the track Pt
   * it might get matched only under the rescaled assumption that
   * should be less sensitive to radiative losses.
   */
  if (std::abs(deltaEta[2]) < m_narrowDeltaEta && deltaPhi[2] < m_narrowDeltaPhi &&
      deltaPhi[2] > -m_narrowDeltaPhiBrem) {
    ATH_MSG_DEBUG("Matched with Perigee");
  } else if (m_SecondPassRescale && cluster.et() > trkPB.pt() &&
             std::abs(deltaEtaRes[2]) < m_narrowDeltaEta &&
             deltaPhiRes[2] < m_narrowDeltaPhiRescale &&
             deltaPhiRes[2] > -m_narrowDeltaPhiRescaleBrem) {
    ATH_MSG_DEBUG("Not Perigee but matched with Rescale");
  } else {
    ATH_MSG_DEBUG("Normal matched Failed deltaPhi/deltaEta "
                  << deltaPhi[2] << " / " << deltaEta[2]);
    ATH_MSG_DEBUG("Rescaled matched Failed deltaPhi/deltaEta "
                  << deltaPhiRes[2] << " / " << deltaEtaRes[2]);
    return false;
  }
 
  // Always the deltaPhiLast will be from the last measurement
  IEMExtrapolationTools::TrkExtrapDef extrapFrom1 =
    IEMExtrapolationTools::fromLastMeasurement;
  std::array<double, 4> eta1 = { -999.0, -999.0, -999.0, -999.0 };
  std::array<double, 4> phi1 = { -999.0, -999.0, -999.0, -999.0 };
  std::array<double, 4> deltaEta1 = { -999.0, -999.0, -999.0, -999.0 };
  std::array<double, 4> deltaPhi1 = { -999.0, -999.0, -999.0, -999.0 };
 
  if (m_extrapolationTool
        ->getMatchAtCalo(ctx,
                         cluster,
                         trkPB,
                         layersAndSurfaces.first,
                         layersAndSurfaces.second,
                         eta1,
                         phi1,
                         deltaEta1,
                         deltaPhi1,
                         extrapFrom1)
        .isFailure()) {
    ATH_MSG_DEBUG("Extrapolation from last measurement failed");
    return false;
  }
  double deltaPhiLast = deltaPhi1[2];
  ATH_MSG_DEBUG("Rescale dPhi " << deltaPhiRescale);
  ATH_MSG_DEBUG("dPhi Last measurement " << deltaPhiLast);
  /*
   * Done with extrapolation
   * Lets do the matching logic
   */
  TrackMatch trkmatch{};
  // Add the matching variable to the TrackMAtch
  trkmatch.deltaEta = deltaEta;
  trkmatch.deltaPhi = deltaPhi;
  trkmatch.deltaPhiRescaled = deltaPhiRes;
  trkmatch.deltaPhiLast = deltaPhiLast;
 
  // Variables used for the sorting. Note both dPhi's will be used.
  trkmatch.trackNumber = trackNumber;
  if (m_useRescaleMetric) {
    trkmatch.dR = sqrt(std::pow(m_deltaEtaWeight * deltaEta[2], 2) +
                       std::pow(m_deltaPhiRescaleWeight * deltaPhiRescale, 2));
    trkmatch.seconddR = sqrt(std::pow(m_deltaEtaWeight * deltaEta[2], 2) +
                             std::pow(m_deltaPhiWeight * deltaPhi[2], 2));
  } else {
    trkmatch.dR = sqrt(std::pow(m_deltaEtaWeight * deltaEta[2], 2) +
                       std::pow(m_deltaPhiWeight * deltaPhi[2], 2));
    trkmatch.seconddR =
      sqrt(std::pow(m_deltaEtaWeight * deltaEta[2], 2) +
           std::pow(m_deltaPhiRescaleWeight * deltaPhiRescale, 2));
  }
  ATH_MSG_DEBUG(" DR " << trkmatch.dR << " deltaPhi " << deltaPhi[2]
                       << " deltaEta " << deltaEta[2]);
  /*
   * The first thing is
   * Prefer pixel over SCT only
   */
  // Check number of pixel hits
  int nPixel = summaryValueInt(trkPB, xAOD::numberOfPixelDeadSensors, 0);
  nPixel += summaryValueInt(trkPB, xAOD::numberOfPixelHits, 0);
  trkmatch.hasPix = (nPixel > 0);
 
  /*
   * Seconday hitsScore score based on hits to be used
   * for track that are very close
   * to each other at the calo i.e similar dR with cluster,
   * pick the longest possible one
   */
  trkmatch.hitsScore = 0;
  if (m_useScoring) {
    // Check the 2 innermost layers
    int nInnerMost = summaryValueInt(trkPB, xAOD::numberOfInnermostPixelLayerHits, 0);
    int expectInnermostPixelLayerHit = summaryValueInt(trkPB, xAOD::expectInnermostPixelLayerHit, 0);
    int nNextToInnerMost = summaryValueInt(trkPB, xAOD::numberOfNextToInnermostPixelLayerHits, 0);
    int expectNextToInnermostPixelLayerHit = summaryValueInt(trkPB, xAOD::expectNextToInnermostPixelLayerHit, 0);
 
    // Secondary score , find the longest track possible,
    // i.e the one with the most inner hists  in the pixel
    // npixel*5
    trkmatch.hitsScore += (nPixel * 5);
    // Extra points for NextToInnermost
    if (!expectNextToInnermostPixelLayerHit || nNextToInnerMost > 0) {
      trkmatch.hitsScore += 5;
    }
    // Extra points for Innermost
    if (!expectInnermostPixelLayerHit || nInnerMost > 0) {
      trkmatch.hitsScore += 10;
    }
  }
  ATH_MSG_DEBUG("hasPix : " << trkmatch.hasPix
                            << " hitsScore : " << trkmatch.hitsScore);
 
  trackMatches.push_back(trkmatch);
  return true;
}

initialize()

StatusCode EMTrackMatchBuilder::initialize ( )

finaloverridevirtual

Gaudi algorithm hooks.

Implements IEMTrackMatchBuilder.

Definition at line 36 of file EMTrackMatchBuilder.cxx.

{
  ATH_CHECK(m_TrackParticlesKey.initialize());
  ATH_CHECK(m_caloDetDescrMgrKey.initialize());
  // the extrapolation tool
  ATH_CHECK(m_extrapolationTool.retrieve());
 
  // set things up for the sorting
  m_sorter = TrackMatchSorter(m_distanceForScore);
  m_deltaEtaWeight = 1.0 / m_deltaEtaResolution;
  m_deltaPhiWeight = 1.0 / m_deltaPhiResolution;
  m_deltaPhiRescaleWeight = 1.0 / m_deltaPhiRescaleResolution;
 
  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.

interfaceID()

const InterfaceID & IEMTrackMatchBuilder::interfaceID ( )

inlinestaticinherited

AlgTool interface methods.

Definition at line 50 of file IEMTrackMatchBuilder.h.

{
  return IID_IEMTrackMatchBuilder;
}

isCandidateMatch()

bool EMTrackMatchBuilder::isCandidateMatch ( const xAOD::CaloCluster * cluster, const xAOD::TrackParticle * track, bool flip ) const

private

Loose track-cluster matching.

Definition at line 352 of file EMTrackMatchBuilder.cxx.

{
  // loose cluster-track matching
  if (!m_useCandidateMatch) {
    return true;
  }
 
  // Tracking
  const Trk::Perigee& candidatePerigee = track->perigeeParameters();
  // Decide whether to try the opposite direction (cosmics)
  const double trkPhi = (!flip) ? candidatePerigee.parameters()[Trk::phi]
                                : -candidatePerigee.parameters()[Trk::phi];
  const double trkEta =
    (!flip) ? candidatePerigee.eta() : -candidatePerigee.eta();
  const double z_perigee = candidatePerigee.position().z();
  const double r_perigee = candidatePerigee.position().perp();
  const Amg::Vector3D PerigeeXYZPosition(candidatePerigee.position().x(),
                                         candidatePerigee.position().y(),
                                         z_perigee);
  // Cluster variables
  const double clusterEta = cluster->eta();
  const bool isEndCap = !xAOD::EgammaHelpers::isBarrel(cluster);
  const double Et = cluster->e() / cosh(trkEta);
  const double clusterPhi = cluster->phi();
 
  // Avoid clusters with |eta| > 10 or Et less than 10 MeV
  if (std::abs(clusterEta) > 10.0 || Et < 10) {
    return false;
  }
  // Calculate the eta/phi of the cluster as would be seen from the perigee
  // position of the Track
  const Amg::Vector3D XYZClusterWrtTrackPerigee =
    CandidateMatchHelpers::approxXYZwrtPoint(
      *cluster, PerigeeXYZPosition, isEndCap);
 
  const double clusterEtaCorrected = XYZClusterWrtTrackPerigee.eta();
  // check eta match . Both metrics need to fail in order to disgard the track
  if ((std::abs(clusterEta - trkEta) > 2. * m_broadDeltaEta) &&
      (std::abs(clusterEtaCorrected - trkEta) > 2. * m_broadDeltaEta)) {
    ATH_MSG_DEBUG(" Fails broad window eta match (track eta, cluster eta, "
                  "cluster eta corrected): ( "
                  << trkEta << ", " << clusterEta << ", " << clusterEtaCorrected
                  << ")");
    return false;
  }
  // Calculate the possible rotation of the track
  // Once assuming the cluster Et being the better estimate (e.g big brem)
  const double phiRotRescaled = CandidateMatchHelpers::PhiROT(
    Et, trkEta, track->charge(), r_perigee, isEndCap);
  // And also assuming the track Pt being correct
  const double phiRotTrack = CandidateMatchHelpers::PhiROT(
    track->pt(), trkEta, track->charge(), r_perigee, isEndCap);
  //
  const double clusterPhiCorrected = XYZClusterWrtTrackPerigee.phi();
  // deltaPhi between the track and the cluster
  const double deltaPhiStd = P4Helpers::deltaPhi(clusterPhiCorrected, trkPhi);
  // deltaPhi between the track and the cluster accounting for rotation assuming
  // cluster Et is a better estimator
  const double trkPhiRescaled = P4Helpers::deltaPhi(trkPhi, phiRotRescaled);
  const double deltaPhiRescaled =
    P4Helpers::deltaPhi(clusterPhiCorrected, trkPhiRescaled);
  // deltaPhi between the track and the cluster accounting for rotation
  const double trkPhiCorrTrack = P4Helpers::deltaPhi(trkPhi, phiRotTrack);
  const double deltaPhiTrack =
    P4Helpers::deltaPhi(clusterPhiCorrected, trkPhiCorrTrack);
 
  // It has to fail all phi metrics in order to be disgarded
  if ((std::abs(deltaPhiRescaled) > 2. * m_broadDeltaPhi) &&
      (std::abs(deltaPhiTrack) > 2. * m_broadDeltaPhi) &&
      (std::abs(deltaPhiStd) > 2. * m_broadDeltaPhi)) {
 
    ATH_MSG_DEBUG(
      "FAILS broad window phi match (track phi, phirotCluster , phiRotTrack , "
      << "cluster phi corrected, cluster phi): ( " << trkPhi << ", "
      << phiRotRescaled << ", " << phiRotTrack << ", " << clusterPhiCorrected
      << ", " << clusterPhi << ")");
 
    return false;
  }
  // if not false returned we end up here
  return true;
}

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

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.

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 368 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 352 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 >, and AthCheckedComponent<::AthAlgTool >.

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.

trackExecute()

StatusCode EMTrackMatchBuilder::trackExecute ( const EventContext & ctx, egammaRec * eg, const xAOD::TrackParticleContainer * trackPC, const CaloDetDescrManager & caloDD ) const

private

execute method

Definition at line 82 of file EMTrackMatchBuilder.cxx.

{
  if (!eg || !trackPC) {
    ATH_MSG_WARNING(
      "trackExecute: NULL pointer to egammaRec or TrackParticleContainer");
    return StatusCode::SUCCESS;
  }
  // retrieve corresponding cluster
  const xAOD::CaloCluster* cluster = eg->caloCluster();
  // check if the cluster is sane
  if (!cluster){
    ATH_MSG_WARNING("trackExecute: cluster ptr is null! Ignoring cluster.");
    return StatusCode::SUCCESS;
  }
  if (cluster->e() == 0.0) {
    ATH_MSG_WARNING("trackExecute: cluster energy is 0.0! Ignoring cluster.");
    return StatusCode::SUCCESS;
  }
 
  // Loop over tracks and fill TrackMatch vector
  std::vector<TrackMatch> trkMatches;
  xAOD::TrackParticleContainer::const_iterator trkIt = trackPC->begin();
  for (unsigned int trackNumber = 0; trkIt != trackPC->end();
       ++trkIt, ++trackNumber) {
    // Avoid TRT alone
    if (xAOD::EgammaHelpers::numberOfSiHits(*trkIt) < 4) {
      continue;
    }
    /*
     * Try with normal directions.
     * For cosmics allow a retry with inverted direction.
     */
    if (isCandidateMatch(cluster, (*trkIt), false)) {
      inBroadWindow(ctx, trkMatches, *cluster, trackNumber, (**trkIt), caloDD);
    }
  }
 
  if (!trkMatches.empty()) {
    // sort the track matches
    std::sort(trkMatches.begin(), trkMatches.end(), m_sorter);
    // set the matching values
    TrackMatch bestTrkMatch = trkMatches.at(0);
    eg->setDeltaEta(bestTrkMatch.deltaEta);
    eg->setDeltaPhi(bestTrkMatch.deltaPhi);
    eg->setDeltaPhiRescaled(bestTrkMatch.deltaPhiRescaled);
    eg->setDeltaPhiLast(bestTrkMatch.deltaPhiLast);
 
    // set the element Links
    using EL = ElementLink<xAOD::TrackParticleContainer>;
    std::vector<EL> trackParticleLinks;
    trackParticleLinks.reserve(trkMatches.size());
    const std::string key = EL(*trackPC, 0, ctx).dataID();
    for (const TrackMatch& m : trkMatches) {
      ATH_MSG_DEBUG("Match  dR: " << m.dR << " second  dR: " << m.seconddR
                                  << " hasPix: " << m.hasPix
                                  << " hitsScore: " << m.hitsScore);
      if (key.empty()) {
        trackParticleLinks.emplace_back(*trackPC, m.trackNumber, ctx);
      } else {
        trackParticleLinks.emplace_back(key, m.trackNumber, ctx);
      }
    }
    eg->setTrackParticles(trackParticleLinks);
  }
  return StatusCode::SUCCESS;
}

updateVHKA()

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

inlineinherited

Definition at line 298 of file AthCommonDataStore.h.

                                               {
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_broadDeltaEta

Gaudi::Property<double> EMTrackMatchBuilder::m_broadDeltaEta

private

Initial value:

{ this,
                                           "broadDeltaEta",
                                           0.1,
                                           "Value of broad cut for delta eta" }

broad cut on deltaEta

Definition at line 125 of file EMTrackMatchBuilder.h.

                                       { this,
                                           "broadDeltaEta",
                                           0.1,
                                           "Value of broad cut for delta eta" };

m_broadDeltaPhi

Gaudi::Property<double> EMTrackMatchBuilder::m_broadDeltaPhi

private

Initial value:

{ this,
                                           "broadDeltaPhi",
                                           0.1,
                                           "Value of broad cut for delta phi" }

broad cut on deltaPhi

Definition at line 131 of file EMTrackMatchBuilder.h.

                                       { this,
                                           "broadDeltaPhi",
                                           0.1,
                                           "Value of broad cut for delta phi" };

m_caloDetDescrMgrKey

SG::ReadCondHandleKey<CaloDetDescrManager> EMTrackMatchBuilder::m_caloDetDescrMgrKey

private

Initial value:

{
    this,
    "CaloDetDescrManager",
    "CaloDetDescrManager",
    "SG Key for CaloDetDescrManager in the Condition Store"
  }

Definition at line 117 of file EMTrackMatchBuilder.h.

                                                               {
    this,
    "CaloDetDescrManager",
    "CaloDetDescrManager",
    "SG Key for CaloDetDescrManager in the Condition Store"
  };

m_deltaEtaResolution

Gaudi::Property<float> EMTrackMatchBuilder::m_deltaEtaResolution

private

Initial value:

{ this,
                                               "DeltaEtaResolution",
                                               1.0,
                                               "The deltaEta resolution" }

The resolutions: might be good to split in barrel/end-cap in the future.

Definition at line 213 of file EMTrackMatchBuilder.h.

                                           { this,
                                               "DeltaEtaResolution",
                                               1.0,
                                               "The deltaEta resolution" };

m_deltaEtaWeight

double EMTrackMatchBuilder::m_deltaEtaWeight {}

private

Definition at line 256 of file EMTrackMatchBuilder.h.

{};

m_deltaPhiRescaleResolution

Gaudi::Property<float> EMTrackMatchBuilder::m_deltaPhiRescaleResolution

private

Initial value:

{
    this,
    "DeltaPhiRescaleResolution",
    1.0,
    "The deltaPhiRescale resolution"
  }

Definition at line 223 of file EMTrackMatchBuilder.h.

                                                  {
    this,
    "DeltaPhiRescaleResolution",
    1.0,
    "The deltaPhiRescale resolution"
  };

m_deltaPhiRescaleWeight

double EMTrackMatchBuilder::m_deltaPhiRescaleWeight {}

private

Definition at line 258 of file EMTrackMatchBuilder.h.

{};

m_deltaPhiResolution

Gaudi::Property<float> EMTrackMatchBuilder::m_deltaPhiResolution

private

Initial value:

{ this,
                                               "DeltaPhiResolution",
                                               1.0,
                                               "The deltaPhi resolution" }

Definition at line 218 of file EMTrackMatchBuilder.h.

                                           { this,
                                               "DeltaPhiResolution",
                                               1.0,
                                               "The deltaPhi resolution" };

m_deltaPhiWeight

double EMTrackMatchBuilder::m_deltaPhiWeight {}

private

Definition at line 257 of file EMTrackMatchBuilder.h.

{};

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 381 of file AthCommonDataStore.h.

m_distanceForScore

Gaudi::Property<float> EMTrackMatchBuilder::m_distanceForScore

private

Initial value:

{
    this,
    "DistanceForScore",
    0.01,
    "The distance from which one goes from using better deltaR to using score."
  }

The distance from which one goes from using better deltaR to using score.

Note that this distance varies depending on the resolutions entered above. If you don't use resolutions (resolution = 1.0) this becomes deltaR distance.

Definition at line 235 of file EMTrackMatchBuilder.h.

                                         {
    this,
    "DistanceForScore",
    0.01,
    "The distance from which one goes from using better deltaR to using score."
  };

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 378 of file AthCommonDataStore.h.

m_extrapolationTool

ToolHandle<IEMExtrapolationTools> EMTrackMatchBuilder::m_extrapolationTool

private

Initial value:

{
    this,
    "ExtrapolationTool",
    "EMExtrapolationTools",
    "Name of the extrapolation tool"
  }

Definition at line 242 of file EMTrackMatchBuilder.h.

                                                       {
    this,
    "ExtrapolationTool",
    "EMExtrapolationTools",
    "Name of the extrapolation tool"
  };

m_isCosmics

Gaudi::Property<bool> EMTrackMatchBuilder::m_isCosmics

private

Initial value:

{ this,
                                     "isCosmics",
                                     false,
                                     "Boolean for use of cosmics" }

Definition at line 250 of file EMTrackMatchBuilder.h.

                                 { this,
                                     "isCosmics",
                                     false,
                                     "Boolean for use of cosmics" };

m_MaxDeltaPhiRescale

Gaudi::Property<double> EMTrackMatchBuilder::m_MaxDeltaPhiRescale

private

Initial value:

{
    this,
    "MaxDeltaPhiRescale",
    0.25,
    "Maximum Value of the deltaPhi rescale"
  }

@Maximum deltaPhi (Res) allowed for a match

Definition at line 177 of file EMTrackMatchBuilder.h.

                                            {
    this,
    "MaxDeltaPhiRescale",
    0.25,
    "Maximum Value of the deltaPhi rescale"
  };

m_narrowDeltaEta

Gaudi::Property<double> EMTrackMatchBuilder::m_narrowDeltaEta

private

Initial value:

{
    this,
    "narrowDeltaEta",
    0.05,
    "Value of narrow cut for delta eta"
  }

narrow cut on deltaEta

Definition at line 137 of file EMTrackMatchBuilder.h.

                                        {
    this,
    "narrowDeltaEta",
    0.05,
    "Value of narrow cut for delta eta"
  };

m_narrowDeltaPhi

Gaudi::Property<double> EMTrackMatchBuilder::m_narrowDeltaPhi

private

Initial value:

{
    this,
    "narrowDeltaPhi",
    0.05,
    "Value of the narrowd cut for delta phi"
  }

narrow cut on deltaPhiRescale

Definition at line 145 of file EMTrackMatchBuilder.h.

                                        {
    this,
    "narrowDeltaPhi",
    0.05,
    "Value of the narrowd cut for delta phi"
  };

m_narrowDeltaPhiBrem

Gaudi::Property<double> EMTrackMatchBuilder::m_narrowDeltaPhiBrem

private

Initial value:

{
    this,
    "narrowDeltaPhiBrem",
    0.1,
    "Value of the narrow cut for delta phi  Brem"
  }

narrow cut on deltaPhi for electrons

Definition at line 153 of file EMTrackMatchBuilder.h.

                                            {
    this,
    "narrowDeltaPhiBrem",
    0.1,
    "Value of the narrow cut for delta phi  Brem"
  };

m_narrowDeltaPhiRescale

Gaudi::Property<double> EMTrackMatchBuilder::m_narrowDeltaPhiRescale

private

Initial value:

{
    this,
    "narrowDeltaPhiRescale",
    0.05,
    "Value of the narrow cut for delta phi Rescale"
  }

narrow cut on deltaPhiRescale

Definition at line 161 of file EMTrackMatchBuilder.h.

                                               {
    this,
    "narrowDeltaPhiRescale",
    0.05,
    "Value of the narrow cut for delta phi Rescale"
  };

m_narrowDeltaPhiRescaleBrem

Gaudi::Property<double> EMTrackMatchBuilder::m_narrowDeltaPhiRescaleBrem

private

Initial value:

{
    this,
    "narrowDeltaPhiRescaleBrem",
    0.1,
    "Value of the narrow cut for delta phi Rescale Brem"
  }

narrow cut on deltaPhiRescale for electrons

Definition at line 169 of file EMTrackMatchBuilder.h.

                                                   {
    this,
    "narrowDeltaPhiRescaleBrem",
    0.1,
    "Value of the narrow cut for delta phi Rescale Brem"
  };

m_SecondPassRescale

Gaudi::Property<bool> EMTrackMatchBuilder::m_SecondPassRescale

private

Initial value:

{ this,
                                             "SecondPassRescale",
                                             true,
                                             "Do second pass with rescale" }

Boolean to do second pass with Rescale.

Definition at line 207 of file EMTrackMatchBuilder.h.

                                         { this,
                                             "SecondPassRescale",
                                             true,
                                             "Do second pass with rescale" };

m_sorter

TrackMatchSorter EMTrackMatchBuilder::m_sorter

private

Definition at line 260 of file EMTrackMatchBuilder.h.

m_TrackParticlesKey

SG::ReadHandleKey<xAOD::TrackParticleContainer> EMTrackMatchBuilder::m_TrackParticlesKey

private

Initial value:

{
    this,
    "TrackParticlesName",
    "",
    "Name of the input track particle container"
  }

name of TrackParticle container in TDS

Definition at line 110 of file EMTrackMatchBuilder.h.

                                                                 {
    this,
    "TrackParticlesName",
    "",
    "Name of the input track particle container"
  };

m_useCandidateMatch

Gaudi::Property<bool> EMTrackMatchBuilder::m_useCandidateMatch

private

Initial value:

{
    this,
    "useCandidateMatch",
    true,
    "Boolean to use candidate matching"
  }

flag to turn on/off use of isCandidateMatch

Definition at line 185 of file EMTrackMatchBuilder.h.

                                         {
    this,
    "useCandidateMatch",
    true,
    "Boolean to use candidate matching"
  };

m_useRescaleMetric

Gaudi::Property<bool> EMTrackMatchBuilder::m_useRescaleMetric

private

Initial value:

{ this,
                                            "UseRescaleMetric",
                                            true,
                                            "Use Rescale Metric" }

Boolean to use Rescale in the metric.

Definition at line 201 of file EMTrackMatchBuilder.h.

                                        { this,
                                            "UseRescaleMetric",
                                            true,
                                            "Use Rescale Metric" };

m_useScoring

Gaudi::Property<bool> EMTrackMatchBuilder::m_useScoring

private

Initial value:

{
    this,
    "useScoring",
    true,
    "Boolean to apply heuristic when tracks have close deltaR"
  }

Boolean to apply heuristic when tracks have close deltaR.

Definition at line 193 of file EMTrackMatchBuilder.h.

                                  {
    this,
    "useScoring",
    true,
    "Boolean to apply heuristic when tracks have close deltaR"
  };

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 387 of file AthCommonDataStore.h.

m_vhka

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

privateinherited

Definition at line 386 of file AthCommonDataStore.h.

---

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

• EMTrackMatchBuilder.h
• EMTrackMatchBuilder.cxx