egammaSelectedTrackCopy Class Reference

Algorithm which selects tracks to be GSF refitted later on. More...

#include <egammaSelectedTrackCopy.h>

Inheritance diagram for egammaSelectedTrackCopy:

Collaboration diagram for egammaSelectedTrackCopy:

Public Member Functions
	egammaSelectedTrackCopy (const std::string &name, ISvcLocator *pSvcLocator)
	Default constructor.
virtual StatusCode	initialize () override final
virtual StatusCode	finalize () override final
virtual StatusCode	execute (const EventContext &ctx) const override final
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual bool	isClonable () const override
	Specify if the algorithm is clonable.
virtual unsigned int	cardinality () const override
	Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.
virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
virtual bool	filterPassed (const EventContext &ctx) const
virtual void	setFilterPassed (bool state, const EventContext &ctx) const
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	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

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
bool	selectTrack (const EventContext &ctx, const xAOD::CaloCluster *cluster, const xAOD::TrackParticle *track, bool trkTRT, const CaloDetDescrManager &caloDD) const
	Broad track selection.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
ToolHandle< IEMExtrapolationTools >	m_extrapolationTool
	Tool for extrapolation.
ToolHandle< IegammaCaloClusterSelector >	m_egammaCaloClusterSelector
	Tool to filter the calo clusters.
SG::ReadHandleKey< xAOD::CaloClusterContainer >	m_clusterContainerKey
	Names of input output collections.
SG::ReadHandleKey< xAOD::CaloClusterContainer >	m_fwdClusterContainerKey
	Names of forward input output collections.
SG::ReadHandleKey< xAOD::TrackParticleContainer >	m_trackParticleContainerKey
SG::ReadDecorHandleKey< xAOD::TrackParticleContainer >	m_trackParticleTimeDecorKey
SG::ReadCondHandleKey< CaloDetDescrManager >	m_caloDetDescrMgrKey
SG::WriteHandleKey< ConstDataVector< xAOD::TrackParticleContainer > >	m_OutputTrkPartContainerKey
Gaudi::Property< double >	m_broadDeltaEta
	Broad windows.
Gaudi::Property< double >	m_broadDeltaPhi
Gaudi::Property< double >	m_narrowDeltaEta
	Narrow windows.
Gaudi::Property< double >	m_narrowDeltaPhi
Gaudi::Property< double >	m_narrowDeltaPhiBrem
Gaudi::Property< double >	m_narrowRescale
Gaudi::Property< double >	m_narrowRescaleBrem
Gaudi::Property< bool >	m_doForwardTracks
	Private member flag to select forward tracks.
Gaudi::Accumulators::Counter	m_AllClusters {}
Gaudi::Accumulators::Counter	m_AllFwdClusters {}
Gaudi::Accumulators::Counter	m_SelectedClusters {}
Gaudi::Accumulators::Counter	m_AllTracks {}
Gaudi::Accumulators::Counter	m_SelectedTracks {}
Gaudi::Accumulators::Counter	m_SelectedFwdTracks {}
Gaudi::Accumulators::Counter	m_AllSiTracks {}
Gaudi::Accumulators::Counter	m_SelectedSiTracks {}
Gaudi::Accumulators::Counter	m_AllTRTTracks {}
Gaudi::Accumulators::Counter	m_SelectedTRTTracks {}
DataObjIDColl	m_extendedExtraObjects
	Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
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

Algorithm which selects tracks to be GSF refitted later on.

The algorithm select tracks that are matched to cluster using eta and phi. Si-track/cluster pairs with Et (computed with eta from the track) less than 10 MeV are not considered. Non-Si-track/cluster pair with Et (from the cluster) less than 10 MeV are not considered.

The eta/phi matching is done in two steps. In the first step a broad matching is done. Then a narrower match is done using extrapolated tracks to the second layer. For TRT tracks only broad phi-matching is tried.

• Input container xAOD::CaloClusterContainer: ClusterContainerName
• Input container xAOD::TrackParticleContainer: TrackParticleContainerName
• Output container xAOD::TrackParticleContainer: OutputTrkPartContainerName

The heavy work is done directly inside the algorithm, without the usage of any particular external tool (see selectTrack private method).

Definition at line 53 of file egammaSelectedTrackCopy.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

egammaSelectedTrackCopy()

egammaSelectedTrackCopy::egammaSelectedTrackCopy	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Default constructor.

Definition at line 46 of file egammaSelectedTrackCopy.cxx.

  : AthReentrantAlgorithm(name, pSvcLocator)
{}

Member Function Documentation

cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::cardinality ( ) const

overridevirtualinherited

Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.

Override this to return 0 for reentrant algorithms.

Definition at line 75 of file AthCommonReentrantAlgorithm.cxx.

{
  return 0;
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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 egammaSelectedTrackCopy::execute ( const EventContext & ctx ) const

finaloverridevirtual

Definition at line 91 of file egammaSelectedTrackCopy.cxx.

{
  SG::ReadHandle<xAOD::CaloClusterContainer> clusterTES(m_clusterContainerKey, ctx);
  ATH_CHECK(clusterTES.isValid());
 
  SG::ReadHandle<xAOD::TrackParticleContainer> trackTES(m_trackParticleContainerKey, ctx);
  ATH_CHECK(trackTES.isValid());
 
  SG::WriteHandle<ConstDataVector<xAOD::TrackParticleContainer>> outputTrkPartContainer(
    m_OutputTrkPartContainerKey,
    ctx
  );
 
  SG::ReadHandle<xAOD::CaloClusterContainer> fwdClusterTES;
  SG::WriteHandle<ConstDataVector<xAOD::TrackParticleContainer>> outputFwdTrkPartContainer;
  if (m_doForwardTracks) {
    fwdClusterTES = SG::ReadHandle<xAOD::CaloClusterContainer>(
      m_fwdClusterContainerKey,
      ctx
    );
 
    ATH_CHECK(fwdClusterTES.isValid());
    m_AllFwdClusters += fwdClusterTES->size();
  }
 
  // Here it just needs to be a view copy , i.e the collection of selected
  // trackParticles we create does not really own its elements.
  auto viewCopy = std::make_unique<ConstDataVector<xAOD::TrackParticleContainer>>(SG::VIEW_ELEMENTS);
  // Local counters.
  auto selectedTracks = m_SelectedTracks.buffer();
  auto selectedFwdTracks = m_SelectedFwdTracks.buffer();
  auto allSiTracks = m_AllSiTracks.buffer();
  auto selectedSiTracks = m_SelectedSiTracks.buffer();
  auto allTRTTracks = m_AllTRTTracks.buffer();
  auto selectedTRTTracks = m_SelectedTRTTracks.buffer();
 
  SG::ReadCondHandle<CaloDetDescrManager> caloDetDescrMgrHandle{m_caloDetDescrMgrKey, ctx};
  ATH_CHECK(caloDetDescrMgrHandle.isValid());
 
  const CaloDetDescrManager* calodetdescrmgr = *caloDetDescrMgrHandle;
 
  // Check which clusters to seed on.
  std::vector<const xAOD::CaloCluster*> passingClusters;
  for (const xAOD::CaloCluster* cluster : *clusterTES) {
    if (m_egammaCaloClusterSelector->passSelection(cluster, *calodetdescrmgr)) {
      passingClusters.push_back(cluster);
    }
  }
 
  m_AllTracks += trackTES->size();
  m_AllClusters += clusterTES->size();
  m_SelectedClusters += passingClusters.size();
 
  // Extrapolation cache.
  for (const xAOD::TrackParticle* track : *trackTES) {
    bool isNotValidForRefit = !checkIfValidForRefit(track);
    if (isNotValidForRefit) {
      ++allTRTTracks;
    } else {
      ++allSiTracks;
    }
 
    // Check if the track is selected for a central electron
    // due to a central cluster
    for (const xAOD::CaloCluster* cluster : passingClusters) {
      if (selectTrack(ctx, cluster, track, isNotValidForRefit, *calodetdescrmgr)) {
        viewCopy->push_back(track);
        ++selectedTracks;
        if (isNotValidForRefit) {
          ++selectedTRTTracks;
        } else {
          ++selectedSiTracks;
        }
        break;
      }
    } // Loop on clusters.
 
    // Check if the track is selected for a forwand  electron
    // due to a forwand cluster
    if (m_doForwardTracks) {
      for (const xAOD::CaloCluster* cluster : *fwdClusterTES) {
        if (selectTrack(ctx, cluster, track, isNotValidForRefit, *calodetdescrmgr)) {
          viewCopy->push_back(track);
          ++selectedFwdTracks;
          break;
        }
      }  // Loop on fwd cluster
    }
  }// Loop on tracks.
 
  ATH_CHECK(outputTrkPartContainer.record(std::move(viewCopy)));
 
  return StatusCode::SUCCESS;
}

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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

extraOutputDeps()

const DataObjIDColl & AthCommonReentrantAlgorithm< Gaudi::Algorithm >::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 94 of file AthCommonReentrantAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return BaseAlg::extraOutputDeps();
}

filterPassed()

virtual bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext & ctx ) const

inlinevirtualinherited

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

                                                           {
    return execState( ctx ).filterPassed();
  }

finalize()

virtual StatusCode egammaSelectedTrackCopy::finalize ( )

finaloverridevirtual

initialize()

StatusCode egammaSelectedTrackCopy::initialize ( )

finaloverridevirtual

Definition at line 52 of file egammaSelectedTrackCopy.cxx.

{
  ATH_CHECK(m_clusterContainerKey.initialize());
  ATH_CHECK(m_fwdClusterContainerKey.initialize(m_doForwardTracks));
  ATH_CHECK(m_trackParticleContainerKey.initialize());
  // Needed to declare proper input dependency with scheduler
  ATH_CHECK(m_trackParticleTimeDecorKey.initialize
        (!m_trackParticleTimeDecorKey.empty()));
 
  ATH_CHECK(m_OutputTrkPartContainerKey.initialize());
  ATH_CHECK(m_extrapolationTool.retrieve());
  ATH_CHECK(m_egammaCaloClusterSelector.retrieve());
  ATH_CHECK(m_caloDetDescrMgrKey.initialize());
 
  return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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.

isClonable()

bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::isClonable ( ) const

overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Reimplemented in InDet::GNNSeedingTrackMaker, InDet::SCT_Clusterization, InDet::SiSPGNNTrackMaker, InDet::SiSPSeededTrackFinder, InDet::SiTrackerSpacePointFinder, ITkPixelCablingAlg, ITkStripCablingAlg, RoIBResultToxAOD, SCT_ByteStreamErrorsTestAlg, SCT_CablingCondAlgFromCoraCool, SCT_CablingCondAlgFromText, SCT_ConditionsParameterTestAlg, SCT_ConditionsSummaryTestAlg, SCT_ConfigurationConditionsTestAlg, SCT_FlaggedConditionTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_PrepDataToxAOD, SCT_RawDataToxAOD, SCT_ReadCalibChipDataTestAlg, SCT_ReadCalibDataTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_SiliconConditionsTestAlg, SCT_StripVetoTestAlg, SCT_TdaqEnabledTestAlg, SCT_TestCablingAlg, SCTEventFlagWriter, SCTRawDataProvider, SCTSiLorentzAngleTestAlg, SCTSiPropertiesTestAlg, and Simulation::BeamEffectsAlg.

Definition at line 68 of file AthCommonReentrantAlgorithm.cxx.

{
  // Reentrant algorithms are clonable.
  return true;
}

msg()

MsgStream & AthCommonMsg< Gaudi::Algorithm >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< Gaudi::Algorithm >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

selectTrack()

bool egammaSelectedTrackCopy::selectTrack ( const EventContext & ctx, const xAOD::CaloCluster * cluster, const xAOD::TrackParticle * track, bool trkTRT, const CaloDetDescrManager & caloDD ) const

private

Broad track selection.

Definition at line 187 of file egammaSelectedTrackCopy.cxx.

{
 
  if (cluster == nullptr || track == nullptr) {
    return false;
  }
 
  const Trk::Perigee& candidatePerigee = track->perigeeParameters();
 
  // Get Perigee Parameters.
  const double trkPhi = candidatePerigee.parameters()[Trk::phi];
  const double trkEta = 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);
 
  // Get Cluster parameters.
  const double clusterEta = xAOD::EgammaHelpers::isFCAL(cluster) ? cluster->eta() : cluster->etaBE(2);
  const bool isEndCap = !xAOD::EgammaHelpers::isBarrel(cluster);
 
  // Use trkEta only if sufficient hits in the Si.
  const double Et = trkTRT ? cluster->et() : cluster->e() / cosh(trkEta);
 
  // A few sanity checks.
  if (std::abs(clusterEta) > 10.0 || std::abs(trkEta) > 10.0 || Et < 10.0) {
    ATH_MSG_DEBUG(
      "FAILS sanity checks :  Track Eta : " << trkEta <<
      ", Cluster Eta " << clusterEta
    );
 
    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
  );
 
  // 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);
 
  // First we will see if it fails the quick match.
  // Then if it passed it will get 2 chances to be selected.
  // One if it matches from last measurement.
  // The second if it matched from Perigee rescales.
  // Broad phi check.
  if (
    (std::abs(deltaPhiRescaled) > m_broadDeltaPhi) &&
    (std::abs(deltaPhiTrack) > m_broadDeltaPhi) &&
    (std::abs(deltaPhiStd) > m_broadDeltaPhi)
  ) {
    ATH_MSG_DEBUG(
      "FAILS broad window phi match (track phi, phirotCluster , phiRotTrack , " <<
      "cluster phi corrected, cluster phi): ( " <<
      trkPhi << ", " <<
      phiRotRescaled << ", " <<
      phiRotTrack << ", " <<
      clusterPhiCorrected << ", " <<
      cluster->phi() << ")"
    );
 
    return false;
  }
 
  // if TRT we can stop here , we can not check much in eta really.
  if (trkTRT) { return true; }
 
  const double clusterEtaCorrected = XYZClusterWrtTrackPerigee.eta();
 
  // Broad eta check.
  if (
    std::abs(cluster->eta() - trkEta) > m_broadDeltaEta &&
    std::abs(clusterEtaCorrected - trkEta) > m_broadDeltaEta
  ) {
    ATH_MSG_DEBUG(
      "FAILS broad window eta match (track eta, cluster eta, cluster eta corrected): ( " <<
      trkEta << ", " <<
      cluster->etaBE(2) << ", " <<
      clusterEtaCorrected << " )"
    );
 
    return false;
  }
 
  std::pair<
    std::vector<CaloSampling::CaloSample>,
    std::vector<std::unique_ptr<Trk::Surface>>
  > layersAndSurfaces = m_extrapolationTool->getClusterLayerSurfaces(*cluster, caloDD);
 
  // Extrapolate from last measurement to the four EM layers.
  // Since this is before brem fit last measurement is OK.
  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 };
  if (m_extrapolationTool ->getMatchAtCalo(
    ctx,
    *cluster,
    *track,
    layersAndSurfaces.first,
    layersAndSurfaces.second,
    eta,
    phi,
    deltaEta,
    deltaPhi,
    IEMExtrapolationTools::fromLastMeasurement
  ).isFailure()) {
    return false;
  }
 
  // Selection in narrow eta/phi window from last measurement.
  if (
    std::abs(deltaEta[2]) < m_narrowDeltaEta &&
    deltaPhi[2] < m_narrowDeltaPhi &&
    deltaPhi[2] > -m_narrowDeltaPhiBrem
  ) {
    ATH_MSG_DEBUG("Match from Last measurement is successful :  " << deltaPhi[2]);
    return true;
  }
 
  // Cases where:
  // - It passes deltaEta[2] from last measurement (rescaling should not affect the eta side).
  // - and we have a cluster with higher Et.
  // Rescale up the track to account for radiative loses and retry.
  if (
    std::abs(deltaEta[2]) < m_narrowDeltaEta &&
    cluster->et() > track->pt()
  ) {
    // Extrapolate from Perigee Rescaled.
    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,
      *track,
      layersAndSurfaces.first,
      layersAndSurfaces.second,
      etaRes,
      phiRes,
      deltaEtaRes,
      deltaPhiRes,
      IEMExtrapolationTools::fromPerigeeRescaled
    ).isFailure()) {
      return false;
    }
 
    // Redo the check with rescale.
    if (
      std::abs(deltaEtaRes[2]) < m_narrowDeltaEta &&
      deltaPhiRes[2] < m_narrowRescale &&
      deltaPhiRes[2] > -m_narrowRescaleBrem
    ) {
      ATH_MSG_DEBUG("Rescale Match success " << deltaPhiRes[2]);
      return true;
    }
  }
 
  // Default is fail.
  return false;
}

setFilterPassed()

virtual void AthCommonReentrantAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool state, const EventContext & ctx ) const

inlinevirtualinherited

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

                                                                            {
    execState( ctx ).setFilterPassed( state );
  }

sysExecute()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysExecute ( const EventContext & ctx )

overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Definition at line 85 of file AthCommonReentrantAlgorithm.cxx.

{
  return BaseAlg::sysExecute (ctx);
}

sysInitialize()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >.

Reimplemented in HypoBase, and InputMakerBase.

Definition at line 61 of file AthCommonReentrantAlgorithm.cxx.

                                                               {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<BaseAlg>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }      
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;  
}

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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_AllClusters

Gaudi::Accumulators::Counter egammaSelectedTrackCopy::m_AllClusters {}

mutableprivate

Definition at line 189 of file egammaSelectedTrackCopy.h.

{};

m_AllFwdClusters

Gaudi::Accumulators::Counter egammaSelectedTrackCopy::m_AllFwdClusters {}

mutableprivate

Definition at line 190 of file egammaSelectedTrackCopy.h.

{};

m_AllSiTracks

Gaudi::Accumulators::Counter egammaSelectedTrackCopy::m_AllSiTracks {}

mutableprivate

Definition at line 195 of file egammaSelectedTrackCopy.h.

{};

m_AllTracks

Gaudi::Accumulators::Counter egammaSelectedTrackCopy::m_AllTracks {}

mutableprivate

Definition at line 192 of file egammaSelectedTrackCopy.h.

{};

m_AllTRTTracks

Gaudi::Accumulators::Counter egammaSelectedTrackCopy::m_AllTRTTracks {}

mutableprivate

Definition at line 197 of file egammaSelectedTrackCopy.h.

{};

m_broadDeltaEta

Gaudi::Property<double> egammaSelectedTrackCopy::m_broadDeltaEta

private

Initial value:

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

Broad windows.

Definition at line 131 of file egammaSelectedTrackCopy.h.

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

m_broadDeltaPhi

Gaudi::Property<double> egammaSelectedTrackCopy::m_broadDeltaPhi

private

Initial value:

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

Definition at line 138 of file egammaSelectedTrackCopy.h.

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

m_caloDetDescrMgrKey

SG::ReadCondHandleKey<CaloDetDescrManager> egammaSelectedTrackCopy::m_caloDetDescrMgrKey

private

Initial value:

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

Definition at line 116 of file egammaSelectedTrackCopy.h.

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

m_clusterContainerKey

SG::ReadHandleKey<xAOD::CaloClusterContainer> egammaSelectedTrackCopy::m_clusterContainerKey

private

Initial value:

{
    this,
    "ClusterContainerName",
    "egammaTopoCluster",
    "Input calo cluster for seeding"
  }

Names of input output collections.

Definition at line 88 of file egammaSelectedTrackCopy.h.

                                                                  {
    this,
    "ClusterContainerName",
    "egammaTopoCluster",
    "Input calo cluster for seeding"
  };

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_doForwardTracks

Gaudi::Property<bool> egammaSelectedTrackCopy::m_doForwardTracks

private

Initial value:

{ 
    this,
    "doFwdTracks",
    false,
    "Boolean to select tracks in the forward region"
  }

Private member flag to select forward tracks.

Definition at line 182 of file egammaSelectedTrackCopy.h.

                                        { 
    this,
    "doFwdTracks",
    false,
    "Boolean to select tracks in the forward region"
  };

m_egammaCaloClusterSelector

ToolHandle<IegammaCaloClusterSelector> egammaSelectedTrackCopy::m_egammaCaloClusterSelector

private

Initial value:

{
    this,
    "egammaCaloClusterSelector",
    "egammaCaloClusterSelector",
    "Tool that makes the cluster selection"
  }

Tool to filter the calo clusters.

Definition at line 80 of file egammaSelectedTrackCopy.h.

                                                                     {
    this,
    "egammaCaloClusterSelector",
    "egammaCaloClusterSelector",
    "Tool that makes the cluster selection"
  };

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_extendedExtraObjects

DataObjIDColl AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects

privateinherited

Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.

Empty if no symlinks were found.

Definition at line 114 of file AthCommonReentrantAlgorithm.h.

m_extrapolationTool

ToolHandle<IEMExtrapolationTools> egammaSelectedTrackCopy::m_extrapolationTool

private

Initial value:

{
    this,
    "ExtrapolationTool",
    "EMExtrapolationTools",
    "Extrapolation tool"
  }

Tool for extrapolation.

Definition at line 72 of file egammaSelectedTrackCopy.h.

                                                        {
    this,
    "ExtrapolationTool",
    "EMExtrapolationTools",
    "Extrapolation tool"
  };

m_fwdClusterContainerKey

SG::ReadHandleKey<xAOD::CaloClusterContainer> egammaSelectedTrackCopy::m_fwdClusterContainerKey

private

Initial value:

{
    this,
    "FwdClusterContainerName",
    "",
    "Input calo cluster for seeding"
  }

Names of forward input output collections.

Definition at line 96 of file egammaSelectedTrackCopy.h.

                                                                     {
    this,
    "FwdClusterContainerName",
    "",
    "Input calo cluster for seeding"
  };

m_narrowDeltaEta

Gaudi::Property<double> egammaSelectedTrackCopy::m_narrowDeltaEta

private

Initial value:

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

Narrow windows.

Definition at line 146 of file egammaSelectedTrackCopy.h.

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

m_narrowDeltaPhi

Gaudi::Property<double> egammaSelectedTrackCopy::m_narrowDeltaPhi

private

Initial value:

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

Definition at line 153 of file egammaSelectedTrackCopy.h.

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

m_narrowDeltaPhiBrem

Gaudi::Property<double> egammaSelectedTrackCopy::m_narrowDeltaPhiBrem

private

Initial value:

{
    this,
    "narrowDeltaPhiBrem",
    0.2,
    "Value of the narrow cut for delta phi in the brem direction"
  }

Definition at line 160 of file egammaSelectedTrackCopy.h.

                                            {
    this,
    "narrowDeltaPhiBrem",
    0.2,
    "Value of the narrow cut for delta phi in the brem direction"
  };

m_narrowRescale

Gaudi::Property<double> egammaSelectedTrackCopy::m_narrowRescale

private

Initial value:

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

Definition at line 167 of file egammaSelectedTrackCopy.h.

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

m_narrowRescaleBrem

Gaudi::Property<double> egammaSelectedTrackCopy::m_narrowRescaleBrem

private

Initial value:

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

Definition at line 174 of file egammaSelectedTrackCopy.h.

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

m_OutputTrkPartContainerKey

SG::WriteHandleKey<ConstDataVector<xAOD::TrackParticleContainer> > egammaSelectedTrackCopy::m_OutputTrkPartContainerKey

private

Initial value:

{
    this,
    "OutputTrkPartContainerName",
    "egammaSelectedTrackParticles",
    "Output selected TrackParticles"
  }

Definition at line 123 of file egammaSelectedTrackCopy.h.

                                                                                            {
    this,
    "OutputTrkPartContainerName",
    "egammaSelectedTrackParticles",
    "Output selected TrackParticles"
  };

m_SelectedClusters

Gaudi::Accumulators::Counter egammaSelectedTrackCopy::m_SelectedClusters {}

mutableprivate

Definition at line 191 of file egammaSelectedTrackCopy.h.

{};

m_SelectedFwdTracks

Gaudi::Accumulators::Counter egammaSelectedTrackCopy::m_SelectedFwdTracks {}

mutableprivate

Definition at line 194 of file egammaSelectedTrackCopy.h.

{};

m_SelectedSiTracks

Gaudi::Accumulators::Counter egammaSelectedTrackCopy::m_SelectedSiTracks {}

mutableprivate

Definition at line 196 of file egammaSelectedTrackCopy.h.

{};

m_SelectedTracks

Gaudi::Accumulators::Counter egammaSelectedTrackCopy::m_SelectedTracks {}

mutableprivate

Definition at line 193 of file egammaSelectedTrackCopy.h.

{};

m_SelectedTRTTracks

Gaudi::Accumulators::Counter egammaSelectedTrackCopy::m_SelectedTRTTracks {}

mutableprivate

Definition at line 198 of file egammaSelectedTrackCopy.h.

{};

m_trackParticleContainerKey

SG::ReadHandleKey<xAOD::TrackParticleContainer> egammaSelectedTrackCopy::m_trackParticleContainerKey

private

Initial value:

{
    this,
    "TrackParticleContainerName",
    "InDetTrackParticles",
    "Input TrackParticles to select from"
  }

Definition at line 103 of file egammaSelectedTrackCopy.h.

                                                                          {
    this,
    "TrackParticleContainerName",
    "InDetTrackParticles",
    "Input TrackParticles to select from"
  };

m_trackParticleTimeDecorKey

SG::ReadDecorHandleKey<xAOD::TrackParticleContainer> egammaSelectedTrackCopy::m_trackParticleTimeDecorKey

private

Initial value:

{
    this,
    "TrackParticleTimeDecoration",
    "",
    "Time assigned to this track"}

Definition at line 110 of file egammaSelectedTrackCopy.h.

                                                                              {
    this,
    "TrackParticleTimeDecoration",
    "",
    "Time assigned to this track"};

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• egammaSelectedTrackCopy.h
• egammaSelectedTrackCopy.cxx