ActsEgammaSelectedTrackCopy Class Reference

ACTS-specific algorithm for selecting tracks to be GSF refitted. More...

#include <ActsEgammaSelectedTrackCopy.h>

Inheritance diagram for ActsEgammaSelectedTrackCopy:

Collaboration diagram for ActsEgammaSelectedTrackCopy:

Classes
struct	CaloMatch

Public Member Functions
	ActsEgammaSelectedTrackCopy (const std::string &name, ISvcLocator *pSvcLocator)
	Default constructor.
virtual	~ActsEgammaSelectedTrackCopy () override=default
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

Static Public Attributes
static constexpr double	s_calorimeterEtaCoverage = 1.5
static constexpr double	s_maxExtrapolationRadius = 2250.0

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	matchWithExtrapolation (const EventContext &ctx, const xAOD::CaloCluster &cluster, const xAOD::TrackParticle &track, const std::shared_ptr< const Acts::Surface > &perigeeSurface) const
	Track selection method.
bool	checkBroadCriteria (const xAOD::CaloCluster &cluster, const xAOD::TrackParticle &track) const
std::array< std::optional< CaloMatch >, 4 >	extrapolateToCalo (const Acts::BoundTrackParameters &parameters, const xAOD::CaloCluster &cluster, const EventContext &ctx) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
PublicToolHandle< ActsTrk::ITrackingGeometryTool >	m_trackingGeometryTool {this, "TrackingGeometryTool", ""}
ToolHandle< ActsTrk::IExtrapolationTool >	m_extrapolationTool
ToolHandle< IegammaCaloClusterSelector >	m_egammaCaloClusterSelector
	Tool to filter the calo clusters.
SG::ReadHandleKey< xAOD::CaloClusterContainer >	m_clusterContainerKey
	Names of 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
std::array< Acts::GeometryIdentifier, 4 >	m_barrelCaloGeoIds
Gaudi::Accumulators::Counter	m_AllClusters {}
Gaudi::Accumulators::Counter	m_SelectedClusters {}
Gaudi::Accumulators::Counter	m_AllTracks {}
Gaudi::Accumulators::Counter	m_SelectedTracks {}
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

ACTS-specific algorithm for selecting tracks to be GSF refitted.

This is a variant of egammaSelectedTrackCopy with modified selection logic for ACTS track extrapolation to the calorimeter.

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

Definition at line 46 of file ActsEgammaSelectedTrackCopy.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

ActsEgammaSelectedTrackCopy()

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

Default constructor.

Definition at line 32 of file ActsEgammaSelectedTrackCopy.cxx.

  : AthReentrantAlgorithm(name, pSvcLocator)
{}

~ActsEgammaSelectedTrackCopy()

virtual ActsEgammaSelectedTrackCopy::~ActsEgammaSelectedTrackCopy ( )

overridevirtualdefault

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

checkBroadCriteria()

bool ActsEgammaSelectedTrackCopy::checkBroadCriteria ( const xAOD::CaloCluster & cluster, const xAOD::TrackParticle & track ) const

private

Definition at line 299 of file ActsEgammaSelectedTrackCopy.cxx.

{
  const Trk::Perigee& perigee = track.perigeeParameters();
  
  // Get Perigee Parameters.
  const double trkPhi = perigee.parameters()[Trk::phi];
  const double z_perigee = perigee.position().z();
  const Amg::Vector3D PerigeeXYZPosition(perigee.position().x(),
                                         perigee.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 perigee.eta() only if sufficient hits in the Si.
  const double Et = cluster.e() / std::cosh(perigee.eta());
 
  ATH_MSG_VERBOSE("clusterEta: " << clusterEta);
  ATH_MSG_VERBOSE("perigee.eta(): " << perigee.eta());
  ATH_MSG_VERBOSE("Et: " << Et);
  ATH_MSG_VERBOSE("isEndCap: " << std::boolalpha << isEndCap);
 
  // Calculate the eta/phi of the cluster as would be seen from the perigee
  // position of the Track.
  const Amg::Vector3D globalClusterPosWrtPerigee = CandidateMatchHelpers::approxXYZwrtPoint(
    cluster, perigee.position(), 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, perigee.eta(), track.charge(), perigee.position().perp(), isEndCap);
 
  // And also assuming the track Pt being correct.
  const double phiRotTrack = CandidateMatchHelpers::PhiROT(
    track.pt(), perigee.eta(), track.charge(), perigee.position().perp(), isEndCap);
 
  const double clusterPhiCorrected = globalClusterPosWrtPerigee.phi();
 
  // DeltaPhi between the track and the cluster.
  const double deltaPhiStd = P4Helpers::deltaPhi(clusterPhiCorrected, trkPhi);
  const bool failPhiStd = std::abs(deltaPhiStd) > m_broadDeltaPhi;
 
  // 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);
  const bool failPhiRescalded = std::abs(deltaPhiRescaled) > m_broadDeltaPhi;
 
  // DeltaPhi between the track and the cluster accounting for rotation.
  const double trkPhiCorrTrack = P4Helpers::deltaPhi(trkPhi, phiRotTrack);
  const double deltaPhiTrack = P4Helpers::deltaPhi(clusterPhiCorrected, trkPhiCorrTrack);
  const bool failPhiTrack = std::abs(deltaPhiTrack) > m_broadDeltaPhi;
 
  // Broad phi check.
  if (failPhiRescalded && failPhiTrack && failPhiStd) {
    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;
  }
 
  // Broad eta check.
  const double clusterEtaCorrected = globalClusterPosWrtPerigee.eta();
  const bool failEta = std::abs(cluster.eta() - perigee.eta()) > m_broadDeltaEta;
  const bool failEtaCorrected = std::abs(globalClusterPosWrtPerigee.eta() - perigee.eta()) > m_broadDeltaEta;
  
  if (failEta && failEtaCorrected) {
    ATH_MSG_DEBUG(
      "FAILS broad window eta match (track eta, cluster eta, cluster eta corrected): ( " <<
      perigee.eta() << ", " <<
      cluster.eta() << ", " <<
      clusterEtaCorrected << " )"
    );
    return false;
  }
 
  return true;
}

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 ActsEgammaSelectedTrackCopy::execute ( const EventContext & ctx ) const

finaloverridevirtual

Definition at line 104 of file ActsEgammaSelectedTrackCopy.cxx.

{
  SG::ReadHandle<xAOD::CaloClusterContainer> clusterTES = SG::makeHandle(m_clusterContainerKey, ctx);
  ATH_CHECK(clusterTES.isValid());
  m_AllClusters += clusterTES->size();
 
  SG::ReadHandle<xAOD::TrackParticleContainer> trackTES = SG::makeHandle(m_trackParticleContainerKey, ctx);
  ATH_CHECK(trackTES.isValid());
  m_AllTracks += trackTES->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.
  using output_collection_t = ConstDataVector<xAOD::TrackParticleContainer>;
  SG::WriteHandle< output_collection_t > outputTrkPartContainer = SG::makeHandle(m_OutputTrkPartContainerKey, ctx);
  ATH_CHECK( outputTrkPartContainer.record( std::make_unique<output_collection_t>(SG::VIEW_ELEMENTS) ) );
  output_collection_t *viewCopy = outputTrkPartContainer.ptr();
 
  SG::ReadCondHandle<CaloDetDescrManager> caloDetDescrMgrHandle = SG::makeHandle(m_caloDetDescrMgrKey, ctx);
  ATH_CHECK(caloDetDescrMgrHandle.isValid());
 
  const CaloDetDescrManager* calodetdescrmgr = caloDetDescrMgrHandle.cptr();
 
  // Perigee surface at the origin. TODO: use beamspot conditions data.
  auto perigeeSurface = Acts::Surface::makeShared<Acts::PerigeeSurface>(Acts::Vector3::Zero());
 
  // Check which clusters to seed on.
  std::vector<const xAOD::CaloCluster*> passingClusters;
  passingClusters.reserve(clusterTES->size());
  for (const xAOD::CaloCluster* cluster : *clusterTES) {
    if (m_egammaCaloClusterSelector->passSelection(cluster, *calodetdescrmgr)) {
      passingClusters.push_back(cluster);
    }
  }
 
  if( passingClusters.empty() ) {
    ATH_MSG_DEBUG("No cluster left after selection");
    return StatusCode::SUCCESS;
  }
 
  m_SelectedClusters += passingClusters.size();
 
  for (const xAOD::TrackParticle* track : *trackTES) {
    // For now only barrel
    if( std::abs(track->eta()) > s_calorimeterEtaCoverage ) {
      ATH_MSG_DEBUG("Track eta " << track->eta() << " outside coverage " <<
                    "|" << s_calorimeterEtaCoverage << "|");
      continue;
    }
 
 
    for (const xAOD::CaloCluster* cluster : passingClusters) {
      // 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.
      if( !checkBroadCriteria(*cluster, *track) ) {
        ATH_MSG_DEBUG("Track fails broad criteria");
        continue;
      }
 
      if (matchWithExtrapolation(ctx, *cluster, *track, perigeeSurface)) {
        viewCopy->push_back(track);
        break;
      }
    }
  }
 
  m_SelectedTracks += viewCopy->size(); 
 
  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();
}

extrapolateToCalo()

std::array< std::optional< ActsEgammaSelectedTrackCopy::CaloMatch >, 4 > ActsEgammaSelectedTrackCopy::extrapolateToCalo ( const Acts::BoundTrackParameters & parameters, const xAOD::CaloCluster & cluster, const EventContext & ctx ) const

private

Definition at line 386 of file ActsEgammaSelectedTrackCopy.cxx.

{
  auto res = m_extrapolationTool.get()->propagationSteps(ctx, parameters);
  if( !res.ok() ) {
    ATH_MSG_DEBUG("Error during extrapolation: " << res.error().message());
    return {};
  }
 
  const auto &[steps, _] = res.value();
 
  std::array<std::optional<CaloMatch>, 4> matches{};
  for(const auto &step : steps) {
    if( step.surface == nullptr || step.surface->geometryId().sensitive() == 0 ) {
      continue;
    }
    const auto &p = step.position;
    if ( std::hypot(p.x(), p.y()) > s_maxExtrapolationRadius ) {
      ATH_MSG_DEBUG("Extrapolated beyond calo radius, stopping.");
      break;
    }
 
    ATH_MSG_VERBOSE("Extrapolated step at pos [r,z]: " << std::hypot(p.x(), p.y())
                  << ", " << p.z() << " - : " << step.geoID);
 
    auto found = std::ranges::find_if(m_barrelCaloGeoIds, [&](const Acts::GeometryIdentifier &id){
      return id.volume() == step.geoID.volume();
    });
 
    if( found == m_barrelCaloGeoIds.end() ) {
      ATH_MSG_VERBOSE("Step not in barrel calo layers");
      continue;
    }
    int layerIdx = std::distance(m_barrelCaloGeoIds.begin(), found);
    assert(layerIdx >= 0 && layerIdx < 4);
 
    if( matches.at(layerIdx).has_value() ) { 
      ATH_MSG_VERBOSE("Step in calo layer already visited");
      continue;
    }
 
    auto eta = Acts::VectorHelpers::eta(p);
    auto phi = Acts::VectorHelpers::phi(p);
 
    double deltaEta = eta - cluster.etaBE(layerIdx);
    double deltaPhi = P4Helpers::deltaPhi(phi, cluster.phiBE(layerIdx));
 
    ATH_MSG_DEBUG("Step at pos [r,z]: " << std::hypot(p.x(), p.y()) <<
                  ", layerIdx: " << layerIdx <<
                  ", " << p.z() << " - : " << step.geoID <<
                  ", dEta: " << deltaEta << ", dPhi: " << deltaPhi);
 
    matches.at(layerIdx) = CaloMatch{
      layerIdx,
      eta,
      phi,
      deltaEta,
      deltaPhi
    };
  }
 
  return matches;
}

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

StatusCode ActsEgammaSelectedTrackCopy::finalize ( )

finaloverridevirtual

Definition at line 91 of file ActsEgammaSelectedTrackCopy.cxx.

{
  ATH_MSG_INFO("===> ACTS egamma Selected Tracks Statistics ======");
  ATH_MSG_INFO("--- All Central Clusters: " << m_AllClusters);
  ATH_MSG_INFO("--- Selected Central Clusters: " << m_SelectedClusters);
  ATH_MSG_INFO("--- All Tracks: " << m_AllTracks);
  ATH_MSG_INFO("--- Selected Central Tracks: " << m_SelectedTracks);
  ATH_MSG_INFO("<=================================================");
 
  return StatusCode::SUCCESS;
}

initialize()

StatusCode ActsEgammaSelectedTrackCopy::initialize ( )

finaloverridevirtual

Definition at line 38 of file ActsEgammaSelectedTrackCopy.cxx.

{
  ATH_CHECK(m_trackParticleContainerKey.initialize());
  ATH_CHECK(m_clusterContainerKey.initialize());
  ATH_CHECK(m_OutputTrkPartContainerKey.initialize());
  ATH_CHECK(m_egammaCaloClusterSelector.retrieve());
  ATH_CHECK(m_caloDetDescrMgrKey.initialize());
  ATH_CHECK(m_extrapolationTool->initialize());
  ATH_CHECK(m_trackingGeometryTool.retrieve());
 
  // Here we extract the geometry identifiers of the 4 calo volumes in the ACTS geometry
  // It seems more robust to do the matching with the volume name, since the geometry ID
  // can change if details of the geometry change.
  const static std::map<std::string, std::size_t> volIndex = {
    {"PreSamplerB_Layer", 0},
    {"EMB1_Layer", 1},
    {"EMB2_Layer", 2},
    {"EMB3_Layer", 3}
  };
 
  // Debug info in case volume matching fails
  std::vector<std::string> unmatchedVolumes;
 
  m_trackingGeometryTool->trackingGeometry()->visitVolumes([&](const Acts::TrackingVolume *vol) {
    auto name = vol->volumeName();
    if( volIndex.contains(name) ) {
      ATH_MSG_DEBUG(vol->volumeName() << " - " << vol->geometryId() << " - surfaces: " << vol->surfaces().size());
      m_barrelCaloGeoIds.at(volIndex.at(name)) = vol->geometryId();
    } else {
      unmatchedVolumes.push_back(name);
    }
  });
 
  // Check that all geoIds were found
  for(const auto &[geoId, layerInfo] : Acts::zip(m_barrelCaloGeoIds, volIndex)) {
    if( geoId == Acts::GeometryIdentifier{} ) {
      ATH_MSG_ERROR("Could not find geometry ID for barrel calo layer '" << layerInfo.first << "'");
 
      ATH_MSG_ERROR("List of unmatched volumes:");
      std::stringstream ss;
      for( const auto &name : unmatchedVolumes ) {
        ss << name << ", ";
      }
      ATH_MSG_ERROR(ss.str());
 
      return StatusCode::FAILURE;
    }
  }
 
  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 HiveAlgBase, 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;
}

matchWithExtrapolation()

bool ActsEgammaSelectedTrackCopy::matchWithExtrapolation ( const EventContext & ctx, const xAOD::CaloCluster & cluster, const xAOD::TrackParticle & track, const std::shared_ptr< const Acts::Surface > & perigeeSurface ) const

private

Track selection method.

Definition at line 177 of file ActsEgammaSelectedTrackCopy.cxx.

{
  using namespace Acts::UnitLiterals;
 
  ATH_MSG_VERBOSE("Extrapolating track to calo cluster at position: "
                  << cluster.eta() << ", " << cluster.phi());
 
  // Extrapolate from last measurement to the four EM layers.
  unsigned int lastMeasIdx = 0;
  if (!track.indexOfParameterAtPosition(lastMeasIdx, xAOD::LastMeasurement)) {
    ATH_MSG_WARNING("TrackParticle has no last measurement parameters");
    return false;
  }
 
  Acts::Vector3 lastPos{track.parameterX(lastMeasIdx),
                        track.parameterY(lastMeasIdx),
                        track.parameterZ(lastMeasIdx)};
  Acts::Vector3 lastMom{track.parameterPX(lastMeasIdx),
                        track.parameterPY(lastMeasIdx),
                        track.parameterPZ(lastMeasIdx)};
  lastMom *= Acts::UnitConstants::MeV;
 
  ATH_MSG_DEBUG("Last measurement global position: " << lastPos.transpose());
 
  Acts::BoundVector lastBoundParams = Acts::BoundVector::Zero();
  lastBoundParams[Acts::eBoundPhi]    = Acts::VectorHelpers::phi(lastMom);
  lastBoundParams[Acts::eBoundTheta]  = Acts::VectorHelpers::theta(lastMom);
  lastBoundParams[Acts::eBoundQOverP] = track.charge() / lastMom.norm();
 
  std::shared_ptr<const Acts::Surface> lastSurface =
    Acts::CurvilinearSurface(lastPos, lastMom.normalized()).planeSurface()->getSharedPtr();
  Acts::BoundTrackParameters boundPars{
    lastSurface,
    lastBoundParams,
    std::nullopt,
    Acts::ParticleHypothesis::electron()
  };
 
  // First try the EMB2, if this does not match, print a message and try any other calo layer
  auto extractCaloMatch = [&](const auto &caloMatches) {
    if( caloMatches.at(2).has_value() ) {
      return caloMatches.at(2);;
    }
    ATH_MSG_DEBUG("No calo match at EM2, trying any other layer");
    for( const auto &matchOpt : caloMatches ) {
      if( matchOpt.has_value() ) {
        ATH_MSG_DEBUG("Using calo match at layer " << matchOpt->layer);
        return matchOpt;
      }
    }
    return std::optional<CaloMatch>{};
  };
 
  auto caloMatches = extrapolateToCalo(boundPars, cluster, ctx);
  auto caloMatch = extractCaloMatch(caloMatches);
  if( !caloMatch.has_value() ) {
    ATH_MSG_DEBUG("Could not extrapolate to calo from last measurement");
    return false;
  }
 
  // Get the calo match at EM2.
  ATH_MSG_DEBUG("Calo match from last measurement at " << caloMatch->layer
                << ", dEta: " << caloMatch->deltaEta
                << ", dPhi: " << caloMatch->deltaPhi);
 
  // First check if delta eta is OK, fail if not (rescaling should not affect eta).
  if (std::abs(caloMatch->deltaEta) > m_narrowDeltaEta) {
    ATH_MSG_DEBUG("Fails narrow window eta match, deta=" << caloMatch->deltaEta);
    return false;
  }
 
  // Selection in narrow phi window from last measurement.
  if ( caloMatch->deltaPhi >= -m_narrowDeltaPhiBrem &&
       caloMatch->deltaPhi <= m_narrowDeltaPhi ) {
    ATH_MSG_DEBUG("Match from Last measurement is successful, deta=" << caloMatch->deltaEta
                  << " , dphi=" << caloMatch->deltaPhi);
    return true;
  }
 
  // Now try the rescale from perigee
  Acts::BoundVector paramsAtPerigee = Acts::BoundVector::Zero();
  paramsAtPerigee[Acts::eBoundLoc0]  = track.d0();
  paramsAtPerigee[Acts::eBoundLoc1]  = track.z0();
  paramsAtPerigee[Acts::eBoundPhi]   = track.phi0();
  paramsAtPerigee[Acts::eBoundTheta] = track.theta();
  paramsAtPerigee[Acts::eBoundQOverP] = track.charge() / (cluster.e() * Acts::UnitConstants::MeV);
 
  Acts::BoundTrackParameters rescaledParsPerigee{
    perigeeSurface,
    paramsAtPerigee,
    std::nullopt,
    Acts::ParticleHypothesis::electron()
  };
 
  const auto caloMatchesRescaled = extrapolateToCalo(rescaledParsPerigee, cluster, ctx);
  auto caloMatchRescaled = extractCaloMatch(caloMatchesRescaled);
 
  if( !caloMatchRescaled.has_value() ) {
    ATH_MSG_DEBUG("Could not extrapolate to calo from rescaled perigee");
    return false;
  }
 
  // Get the calo match at EM2.
  ATH_MSG_DEBUG("Calo match from perigee rescaled at " << caloMatchRescaled->layer
                << ", dEta: " << caloMatchRescaled->deltaEta
                << ", dPhi: " << caloMatchRescaled->deltaPhi);
 
  // Selection in narrow phi window
  if ( caloMatchRescaled->deltaPhi >= -m_narrowRescaleBrem &&
       caloMatchRescaled->deltaPhi <= m_narrowRescale ) {
    ATH_MSG_DEBUG("Match from Perigee Rescaled is successful, dphi=" << caloMatchRescaled->deltaPhi);
    return true;
  }
 
  ATH_MSG_DEBUG("Match not successful");
  return false;
}

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

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 ActsEgammaSelectedTrackCopy::m_AllClusters {}

mutableprivate

Definition at line 185 of file ActsEgammaSelectedTrackCopy.h.

{};

m_AllTracks

Gaudi::Accumulators::Counter ActsEgammaSelectedTrackCopy::m_AllTracks {}

mutableprivate

Definition at line 187 of file ActsEgammaSelectedTrackCopy.h.

{};

m_barrelCaloGeoIds

std::array<Acts::GeometryIdentifier, 4> ActsEgammaSelectedTrackCopy::m_barrelCaloGeoIds

private

Definition at line 183 of file ActsEgammaSelectedTrackCopy.h.

m_broadDeltaEta

Gaudi::Property<double> ActsEgammaSelectedTrackCopy::m_broadDeltaEta

private

Initial value:

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

Broad windows.

Definition at line 133 of file ActsEgammaSelectedTrackCopy.h.

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

m_broadDeltaPhi

Gaudi::Property<double> ActsEgammaSelectedTrackCopy::m_broadDeltaPhi

private

Initial value:

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

Definition at line 140 of file ActsEgammaSelectedTrackCopy.h.

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

m_caloDetDescrMgrKey

SG::ReadCondHandleKey<CaloDetDescrManager> ActsEgammaSelectedTrackCopy::m_caloDetDescrMgrKey

private

Initial value:

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

Definition at line 118 of file ActsEgammaSelectedTrackCopy.h.

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

m_clusterContainerKey

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

private

Initial value:

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

Names of input output collections.

Definition at line 98 of file ActsEgammaSelectedTrackCopy.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_egammaCaloClusterSelector

ToolHandle<IegammaCaloClusterSelector> ActsEgammaSelectedTrackCopy::m_egammaCaloClusterSelector

private

Initial value:

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

Tool to filter the calo clusters.

Definition at line 90 of file ActsEgammaSelectedTrackCopy.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<ActsTrk::IExtrapolationTool> ActsEgammaSelectedTrackCopy::m_extrapolationTool

private

Initial value:

{
    this,
    "ExtrapolationTool",
    "ExtrapolationTool",
    "Tool to run propagation in an ACTS trackign geometry"
  }

Definition at line 82 of file ActsEgammaSelectedTrackCopy.h.

                                                            {
    this,
    "ExtrapolationTool",
    "ExtrapolationTool",
    "Tool to run propagation in an ACTS trackign geometry"
  };

m_narrowDeltaEta

Gaudi::Property<double> ActsEgammaSelectedTrackCopy::m_narrowDeltaEta

private

Initial value:

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

Narrow windows.

Definition at line 148 of file ActsEgammaSelectedTrackCopy.h.

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

m_narrowDeltaPhi

Gaudi::Property<double> ActsEgammaSelectedTrackCopy::m_narrowDeltaPhi

private

Initial value:

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

Definition at line 155 of file ActsEgammaSelectedTrackCopy.h.

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

m_narrowDeltaPhiBrem

Gaudi::Property<double> ActsEgammaSelectedTrackCopy::m_narrowDeltaPhiBrem

private

Initial value:

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

Definition at line 162 of file ActsEgammaSelectedTrackCopy.h.

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

m_narrowRescale

Gaudi::Property<double> ActsEgammaSelectedTrackCopy::m_narrowRescale

private

Initial value:

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

Definition at line 169 of file ActsEgammaSelectedTrackCopy.h.

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

m_narrowRescaleBrem

Gaudi::Property<double> ActsEgammaSelectedTrackCopy::m_narrowRescaleBrem

private

Initial value:

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

Definition at line 176 of file ActsEgammaSelectedTrackCopy.h.

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

m_OutputTrkPartContainerKey

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

private

Initial value:

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

Definition at line 125 of file ActsEgammaSelectedTrackCopy.h.

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

m_SelectedClusters

Gaudi::Accumulators::Counter ActsEgammaSelectedTrackCopy::m_SelectedClusters {}

mutableprivate

Definition at line 186 of file ActsEgammaSelectedTrackCopy.h.

{};

m_SelectedTracks

Gaudi::Accumulators::Counter ActsEgammaSelectedTrackCopy::m_SelectedTracks {}

mutableprivate

Definition at line 188 of file ActsEgammaSelectedTrackCopy.h.

{};

m_trackingGeometryTool

PublicToolHandle<ActsTrk::ITrackingGeometryTool> ActsEgammaSelectedTrackCopy::m_trackingGeometryTool {this, "TrackingGeometryTool", ""}

private

Definition at line 80 of file ActsEgammaSelectedTrackCopy.h.

{this, "TrackingGeometryTool", ""};

m_trackParticleContainerKey

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

private

Initial value:

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

Definition at line 105 of file ActsEgammaSelectedTrackCopy.h.

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

m_trackParticleTimeDecorKey

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

private

Initial value:

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

Definition at line 112 of file ActsEgammaSelectedTrackCopy.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.

s_calorimeterEtaCoverage

double ActsEgammaSelectedTrackCopy::s_calorimeterEtaCoverage = 1.5

staticconstexpr

Definition at line 57 of file ActsEgammaSelectedTrackCopy.h.

s_maxExtrapolationRadius

double ActsEgammaSelectedTrackCopy::s_maxExtrapolationRadius = 2250.0

staticconstexpr

Definition at line 58 of file ActsEgammaSelectedTrackCopy.h.

---

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

• ActsEgammaSelectedTrackCopy.h
• ActsEgammaSelectedTrackCopy.cxx