Trk::ParticleCaloExtensionTool Class Reference

#include <ParticleCaloExtensionTool.h>

Inheritance diagram for Trk::ParticleCaloExtensionTool:

Collaboration diagram for Trk::ParticleCaloExtensionTool:

Public Types
typedef std::unordered_map< size_t, std::unique_ptr< Trk::CaloExtension > >	Cache

Public Member Functions
	ParticleCaloExtensionTool (const std::string &, const std::string &, const IInterface *)
virtual	~ParticleCaloExtensionTool ()
virtual StatusCode	initialize () override final
virtual std::unique_ptr< Trk::CaloExtension >	caloExtension (const EventContext &ctx, const xAOD::IParticle &particle) const override final
	Method returning the calo layers crossed by the IParticle track or the IParticle itself if it is neutral/TruthParticle The memory ownership is handled by the unique_ptr.
virtual const Trk::CaloExtension *	caloExtension (const EventContext &ctx, const xAOD::IParticle &particle, IParticleCaloExtensionTool::Cache &cache) const override final
	Method to return the calo layers crossed (CaloExtension) by the IParticle track or the IParticle itself if it is neutral/TruthParticle.
virtual const Trk::CaloExtension *	caloExtension (const xAOD::IParticle &particle, const CaloExtensionCollection &cache) const override final
	Method to return the calo layers crossed (CaloExtension) by the IParticle track or the IParticle itself if it is neutral/TruthParticle It returns the result stored in the CaloExtensionCollection created by the caloExtensionCollection method below.
virtual StatusCode	caloExtensionCollection (const EventContext &ctx, const xAOD::IParticleContainer &particles, const std::vector< bool > &mask, CaloExtensionCollection &caloextensions) const override final
	Method that can be used by algorithms that : A.
virtual std::unique_ptr< Trk::CaloExtension >	caloExtension (const EventContext &ctx, const TrackParameters &startPars, PropDirection propDir, ParticleHypothesis particleType) const override final
	Method returning a unique_ptr to the caloExtension given the relevant starting point parameters , direction and particle hypothesis.
std::vector< std::unique_ptr< Trk::Surface > >	caloSurfacesFromLayers (const std::vector< CaloSampling::CaloSample > &clusterLayers, double eta, const CaloDetDescrManager &caloDD) const override final
	Method returning a vector of calo surfaces give calo layers/samplings.
virtual std::vector< std::pair< CaloSampling::CaloSample, std::unique_ptr< const Trk::TrackParameters > > >	surfaceCaloExtension (const EventContext &ctx, const TrackParameters &startPars, const std::vector< CaloSampling::CaloSample > &clusterLayers, const std::vector< std::unique_ptr< Trk::Surface > > &caloSurfaces, ParticleHypothesis particleType) const override final
	Method returning a vector of the Track Parameters at layers/samplings.
virtual std::vector< std::pair< CaloSampling::CaloSample, std::unique_ptr< const Trk::TrackParameters > > >	layersCaloExtension (const EventContext &ctx, const TrackParameters &startPars, const std::vector< CaloSampling::CaloSample > &clusterLayers, double eta, const CaloDetDescrManager &caloDD, ParticleHypothesis particleType) const override final
	Method returning a vector of the Track Parameters at layers/samplings.
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 ()

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
std::unique_ptr< Trk::CaloExtension >	caloExtension (const EventContext &ctx, const xAOD::TruthParticle &particle) const
std::unique_ptr< Trk::CaloExtension >	caloExtension (const EventContext &ctx, const xAOD::NeutralParticle &particle) const
std::unique_ptr< Trk::CaloExtension >	caloExtension (const EventContext &ctx, const xAOD::TrackParticle &particle) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
ToolHandle< Trk::IExtrapolator >	m_extrapolator { this, "Extrapolator", "" }
ToolHandle< ICaloSurfaceBuilder >	m_calosurf
	Tool to build calorimeter layer surfaces.
Gaudi::Property< std::string >	m_particleTypeName
Gaudi::Property< bool >	m_startFromPerigee
const AtlasDetectorID *	m_detID
ParticleHypothesis	m_particleStrategy
Gaudi::Property< unsigned int >	m_extrapolDetectorID
ToolHandle< GenericMonitoringTool >	m_monTool {this,"MonTool","","Monitoring tool"}
	Monitoring tool for recording histograms of the alg in action.
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

Definition at line 44 of file ParticleCaloExtensionTool.h.

Member Typedef Documentation

Cache

typedef std::unordered_map<size_t, std::unique_ptr<Trk::CaloExtension> > Trk::IParticleCaloExtensionTool::Cache

inherited

Definition at line 98 of file IParticleCaloExtensionTool.h.

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

ParticleCaloExtensionTool()

Trk::ParticleCaloExtensionTool::ParticleCaloExtensionTool	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p )

Definition at line 20 of file ParticleCaloExtensionTool.cxx.

  : AthAlgTool(t, n, p)
  , m_detID(nullptr)
  , m_particleStrategy(muon)
{
  declareInterface<IParticleCaloExtensionTool>(this);
}

~ParticleCaloExtensionTool()

Trk::ParticleCaloExtensionTool::~ParticleCaloExtensionTool ( )

virtualdefault

Member Function Documentation

caloExtension() [1/7]

std::unique_ptr< Trk::CaloExtension > Trk::ParticleCaloExtensionTool::caloExtension ( const EventContext & ctx, const TrackParameters & startPars, PropDirection propDir, ParticleHypothesis particleType ) const

finaloverridevirtual

Method returning a unique_ptr to the caloExtension given the relevant starting point parameters , direction and particle hypothesis.

Parameters

ctx	event context needed for multithreading
startPars	the starting track parameters
propDir	extrapolation direction
particleType	type of particle

Implements Trk::IParticleCaloExtensionTool.

Definition at line 257 of file ParticleCaloExtensionTool.cxx.

{
  ATH_MSG_DEBUG("looking up calo states: r "
                << startPars.position().perp() << " z "
                << startPars.position().z() << " momentum "
                << startPars.momentum().mag());
 
  auto extrapolation_timer = Monitored::Timer<std::chrono::microseconds>( "TIME_extrapolation" );
  auto group = Monitored::Group(m_monTool, extrapolation_timer);
  // Start monitoring timer
  extrapolation_timer.start();
  /* The last argument to the extrapolate  overload
   * corresponds  to a GeometrySignature value from
   * TrkDetDescrUtils/GeometrySignature.h
   * The extrapolation stop at the indicated subdetector exit
   */
  std::unique_ptr<
      std::vector<std::pair<std::unique_ptr<Trk::TrackParameters>, int>>>
      caloParameters = m_extrapolator->collectIntersections(
          ctx, startPars, propDir, particleType, m_extrapolDetectorID);
 
  // Stop monitoring timer
  extrapolation_timer.stop();
 
  if (!caloParameters) {
    return nullptr;
  }
 
  TrackParametersIdHelper parsIdHelper;
 
  // create final object
  std::unique_ptr<TrackParameters> caloEntry = nullptr;
  std::unique_ptr<TrackParameters> muonEntry = nullptr;
  std::vector<CurvilinearParameters> caloLayers;
  caloLayers.reserve(caloParameters->size() - 1);
  ATH_MSG_DEBUG(" Found calo parameters: " << caloParameters->size()
                                           << "  extrapolation exit ID="
                                           << m_extrapolDetectorID);
 
  for (auto& p : *caloParameters) {
    if (!p.first) {
      continue;
    }
    // assign parameters
    // calo aentry muon entry and the crossed calo layers
    if (p.second == 1 && propDir == Trk::alongMomentum) {
      caloEntry = std::move(p.first);
    } else if (p.second == 3 && propDir == Trk::oppositeMomentum) {
      caloEntry = std::move(p.first);
    } else if (p.second == 3 && propDir == Trk::alongMomentum) {
      muonEntry = std::move(p.first);
    } else if (p.second == 4 && propDir == Trk::oppositeMomentum) {
      muonEntry = std::move(p.first);
    } else {
      bool isEntry = p.second > 0;
      TrackParametersIdentifier id = parsIdHelper.encode(
        AtlasDetDescr::fFirstAtlasCaloTechnology,
        static_cast<CaloSampling::CaloSample>(abs(p.second) % 1000),
        isEntry);
      /*
       * We construct curvilinear parameters which we push
       * back to the caloLayers.
       * curvillinear.
       */
      if (p.first->type() != Trk::Curvilinear) {
        caloLayers.emplace_back(p.first->position(),
                                p.first->momentum(),
                                p.first->charge(),
                                std::nullopt,
                                id);
      } else {
        std::optional<AmgSymMatrix(5)> covariance(std::nullopt);
        if (p.first->covariance()) {
          covariance = AmgSymMatrix(5)(*(p.first->covariance()));
        }
        caloLayers.emplace_back(p.first->position(),
                                p.first->momentum(),
                                p.first->charge(),
                                std::move(covariance),
                                id);
      }
    }
  }
 
  if (!muonEntry && propDir == Trk::oppositeMomentum &&
      std::abs(startPars.position().perp() - 4255.) < 1.) {
    // muonEntry is right at the startPars position
    muonEntry = startPars.uniqueClone();
  }
 
  return std::make_unique<Trk::CaloExtension>(
      std::move(caloEntry), std::move(muonEntry), std::move(caloLayers));
}

caloExtension() [2/7]

std::unique_ptr< Trk::CaloExtension > Trk::ParticleCaloExtensionTool::caloExtension ( const EventContext & ctx, const xAOD::IParticle & particle ) const

finaloverridevirtual

Method returning the calo layers crossed by the IParticle track or the IParticle itself if it is neutral/TruthParticle The memory ownership is handled by the unique_ptr.

Parameters

ctx	event context needed for multithreading
particle	reference to the Particle

Returns

unique_ptr to a CaloExtension

Implements Trk::IParticleCaloExtensionTool.

Definition at line 63 of file ParticleCaloExtensionTool.cxx.

{
  if (particle.type() == xAOD::Type::TrackParticle) {
    const xAOD::TrackParticle* trackParticle = static_cast<const xAOD::TrackParticle*>(&particle);
    return caloExtension(ctx, *trackParticle);
  }
  if (particle.type() == xAOD::Type::TruthParticle) {
    const xAOD::TruthParticle* truthParticle = static_cast<const xAOD::TruthParticle*>(&particle);
    return caloExtension(ctx, *truthParticle);
  } else if (particle.type() == xAOD::Type::Electron) {
    const xAOD::Electron* el = static_cast<const xAOD::Electron*>(&particle);
    if (el->trackParticle()) {
      return caloExtension(ctx, *(el->trackParticle()));
    }
  } else if (particle.type() == xAOD::Type::Muon) {
    const xAOD::Muon* muon = static_cast<const xAOD::Muon*>(&particle);
    if (muon->primaryTrackParticle()) {
      return caloExtension(ctx, *(muon->primaryTrackParticle()));
    }
  } else if (particle.type() == xAOD::Type::NeutralParticle) {
    const xAOD::NeutralParticle* neutralParticle = static_cast<const xAOD::NeutralParticle*>(&particle);
    return caloExtension(ctx, *neutralParticle);
  }
  ATH_MSG_WARNING("Unsupported IParticle type");
  return nullptr;
}

caloExtension() [3/7]

const Trk::CaloExtension * Trk::ParticleCaloExtensionTool::caloExtension ( const EventContext & ctx, const xAOD::IParticle & particle, IParticleCaloExtensionTool::Cache & cache ) const

finaloverridevirtual

Method to return the calo layers crossed (CaloExtension) by the IParticle track or the IParticle itself if it is neutral/TruthParticle.

An alg looping over a single collection of IParticles re-using them multiple times can use a local cache of the form std::unordered_map<size_t,std::unique_ptr<Trk::CaloExtension>>. The key is the value of IParticle::index()

This method adds the relevant extension to the cache look-up table which retains ownership.

Parameters

ctx	event context needed for multithreading
particle	reference to the Particle
cache	the look-up table cache

Returns

ptr to a const CaloExtension (owned by the cache)

Implements Trk::IParticleCaloExtensionTool.

Definition at line 92 of file ParticleCaloExtensionTool.cxx.

{
  /*if not there , default ctor for unique_ptr (nullptr)*/
  std::unique_ptr<Trk::CaloExtension>& extension = cache[particle.index()];
  if (extension == nullptr) {
    extension = caloExtension(ctx, particle);
  }
  return extension.get();
}

caloExtension() [4/7]

std::unique_ptr< Trk::CaloExtension > Trk::ParticleCaloExtensionTool::caloExtension ( const EventContext & ctx, const xAOD::NeutralParticle & particle ) const

private

Definition at line 173 of file ParticleCaloExtensionTool.cxx.

{
  ParticleHypothesis particleType = m_particleStrategy;
  // create start parameters
  const Trk::NeutralPerigee& perigee = particle.perigeeParameters();
  double charge = 1.;
  const Amg::Vector3D& pos(perigee.position());
  Amg::Vector3D mom(perigee.momentum());
  // Aproximate neutral particles as charged with infinite momentum
  mom.normalize();
  mom *= 1e10;
  Trk::CurvilinearParameters startPars(pos, mom, charge);
  // get extension
  return caloExtension(ctx, startPars, alongMomentum, particleType);
}

caloExtension() [5/7]

std::unique_ptr< Trk::CaloExtension > Trk::ParticleCaloExtensionTool::caloExtension ( const EventContext & ctx, const xAOD::TrackParticle & particle ) const

private

Definition at line 192 of file ParticleCaloExtensionTool.cxx.

{
  // Start with what the user opted as strategy
  ParticleHypothesis particleType = m_particleStrategy;
 
  // wee extrapolate either from the perigee or
  // from the last measurement.
  if (m_startFromPerigee || !particle.track()) {
    bool idExit = true;
    // Muon Entry is around z 6783 and r  4255
    if (std::abs(particle.perigeeParameters().position().z()) > 6700.)
      idExit = false;
    if (particle.perigeeParameters().position().perp() > 4200.)
      idExit = false;
    PropDirection propDir = idExit ? alongMomentum : oppositeMomentum;
    return caloExtension(
      ctx, particle.perigeeParameters(), propDir, particleType);
  }
 
  // Extrapolation from last track parameters
  const Track& track = *particle.track();
  // Look-up the parameters closest to the calorimeter in
  // ID and muon system
  ATH_MSG_DEBUG("trying to add calo layers");
  const TrackParameters* idExitParamers = nullptr;
  const TrackParameters* muonEntryParamers = nullptr;
  Trk::TrackStates::const_iterator itTSoS =
    track.trackStateOnSurfaces()->begin();
  for (; itTSoS != track.trackStateOnSurfaces()->end(); ++itTSoS) {
    // select state with track parameters on a measurement
    if (!(**itTSoS).trackParameters() ||
        !(**itTSoS).type(TrackStateOnSurface::Measurement) ||
        (**itTSoS).type(TrackStateOnSurface::Outlier)) {
      continue;
    }
 
    const Identifier& id = (**itTSoS)
                             .trackParameters()
                             ->associatedSurface()
                             .associatedDetectorElementIdentifier();
    if (m_detID->is_indet(id))
      idExitParamers = (**itTSoS).trackParameters();
    if (m_detID->is_muon(id) && !muonEntryParamers)
      muonEntryParamers = (**itTSoS).trackParameters();
  }
  // require at least one of them
  if (!idExitParamers && !muonEntryParamers) {
    idExitParamers = track.perigeeParameters();
  }
  // pick start parameters, start in ID if possible
  const TrackParameters* startPars =
    idExitParamers ? idExitParamers : muonEntryParamers;
 
  if (!startPars) {
    ATH_MSG_WARNING("Failed to find  start parameters");
    return nullptr;
  }
  PropDirection propDir = idExitParamers ? alongMomentum : oppositeMomentum;
 
  return caloExtension(ctx, *startPars, propDir, particleType);
}

caloExtension() [6/7]

std::unique_ptr< Trk::CaloExtension > Trk::ParticleCaloExtensionTool::caloExtension ( const EventContext & ctx, const xAOD::TruthParticle & particle ) const

private

Definition at line 148 of file ParticleCaloExtensionTool.cxx.

{
  ParticleHypothesis particleType = m_particleStrategy;
  // get start parameters
  const xAOD::TruthVertex* pvtx = particle.prodVtx();
  if (pvtx == nullptr) {
    return nullptr;
  }
  double charge = particle.charge();
  Amg::Vector3D pos(pvtx->x(), pvtx->y(), pvtx->z());
  Amg::Vector3D mom(particle.px(), particle.py(), particle.pz());
  // Aproximate neutral particles as charged with infinite momentum
  if (particle.isNeutral()) {
    charge = 1.;
    mom.normalize();
    mom *= 1e10;
  }
  Trk::CurvilinearParameters startPars(pos, mom, charge);
  // get extension
  return caloExtension(ctx, startPars, alongMomentum, particleType);
}

caloExtension() [7/7]

const Trk::CaloExtension * Trk::ParticleCaloExtensionTool::caloExtension ( const xAOD::IParticle & particle, const CaloExtensionCollection & cache ) const

finaloverridevirtual

Method to return the calo layers crossed (CaloExtension) by the IParticle track or the IParticle itself if it is neutral/TruthParticle It returns the result stored in the CaloExtensionCollection created by the caloExtensionCollection method below.

In this case, the CaloExtensionCollection (DataVector<CaloExtension>) owns the caloExtension.

Parameters

particle	reference to the Particle
cache	The CaloExtensionCollections

Returns

ptr to a const CaloExtension (owned by the cache)

Implements Trk::IParticleCaloExtensionTool.

Definition at line 106 of file ParticleCaloExtensionTool.cxx.

{
  size_t index = particle.index();
  if (index < cache.size()) {
    return cache[index];
  }
  ATH_MSG_WARNING("cache size smaller than particle index");
  return nullptr;
}

caloExtensionCollection()

StatusCode Trk::ParticleCaloExtensionTool::caloExtensionCollection ( const EventContext & ctx, const xAOD::IParticleContainer & particles, const std::vector< bool > & mask, CaloExtensionCollection & caloextensions ) const

finaloverridevirtual

Method that can be used by algorithms that : A.

Have an IParticleCollection B. Define a mask of the size of that collection C. Want back a Calo Extension Collection alligned with the input collection i.e 1 to 1 correspondance with the input collection. The Collection can then be used as such to retrieve the extensions or manipulated and written to StoreGate.

Parameters

ctx	event context needed for multithreading
particles	The input collection
mask	contains true for the elements for which to permorm an extension, false otherwise

Returns

caloextension Output to be filled, will contain unfilled CaloExtension where the mask was false, otherwise it contains the relevant result.

Implements Trk::IParticleCaloExtensionTool.

Definition at line 119 of file ParticleCaloExtensionTool.cxx.

{
  const size_t numparticles = particles.size();
 
  if (mask.size() != numparticles) {
    ATH_MSG_ERROR("mask does not have the same size as in input collection");
    return StatusCode::FAILURE;
  }
  caloextensions.reserve(numparticles);
  /* Either create a proper CaloExtension or otherwise a dummy one
   * i.e one with no intersections
   */
  for (size_t i = 0; i < numparticles; ++i) {
    if (mask[i]) {
      std::unique_ptr<Trk::CaloExtension> extension =
        caloExtension(ctx, *(particles[i]));
      caloextensions.push_back(std::move(extension));
    } else {
      caloextensions.push_back(nullptr);
    }
  }
  return StatusCode::SUCCESS;
}

caloSurfacesFromLayers()

std::vector< std::unique_ptr< Trk::Surface > > Trk::ParticleCaloExtensionTool::caloSurfacesFromLayers ( const std::vector< CaloSampling::CaloSample > & clusterLayers, double eta, const CaloDetDescrManager & caloDD ) const

finaloverridevirtual

Method returning a vector of calo surfaces give calo layers/samplings.

Parameters

ctx	event context needed for multithreading
clusterLayers	the layers (should be ordered) we aim to
eta	eta used for the depth

Implements Trk::IParticleCaloExtensionTool.

Definition at line 355 of file ParticleCaloExtensionTool.cxx.

{
  // Create surfaces at the layers
  std::vector<std::unique_ptr<Trk::Surface>> caloSurfaces;
  caloSurfaces.reserve(clusterLayers.size());
  for (CaloSampling::CaloSample lay : clusterLayers) {
    auto* surf = m_calosurf->CreateUserSurface(lay, 0., eta, &caloDD);
    if (surf) {
      caloSurfaces.emplace_back(surf);
    }
  }
 
  return caloSurfaces;
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

extraDeps_update_handler()

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

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

initialize()

StatusCode Trk::ParticleCaloExtensionTool::initialize ( )

finaloverridevirtual

Definition at line 33 of file ParticleCaloExtensionTool.cxx.

{
  /* Retrieve track extrapolator from ToolService */
  ATH_CHECK(m_extrapolator.retrieve());
  // Retrieve the calo surface builder
  /* Retrieve the Atlas detector ID */
  ATH_CHECK(detStore()->retrieve(m_detID, "AtlasID"));
  /* convert string to proper particle type enum*/
  if (m_particleTypeName == "nonInteracting") {
    m_particleStrategy = nonInteracting;
  } else if (m_particleTypeName == "muon") {
    m_particleStrategy = muon;
  } else if (m_particleTypeName == "pion") {
    m_particleStrategy = pion;
  } else {
    ATH_MSG_WARNING("Unsupported particle type, using strategy based on type "
                    << m_particleTypeName);
  }
  if (!m_calosurf.empty()) {
    ATH_CHECK(m_calosurf.retrieve());
  } else {
    m_calosurf.disable();
  }
  if (!m_monTool.empty()) {
    ATH_CHECK(m_monTool.retrieve());
  }
  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 & Trk::IParticleCaloExtensionTool::interfaceID ( )

inlinestaticinherited

Definition at line 247 of file IParticleCaloExtensionTool.h.

{
  return IID_IParticleCaloExtensionTool;
}

layersCaloExtension()

std::vector< std::pair< CaloSampling::CaloSample, std::unique_ptr< const Trk::TrackParameters > > > Trk::ParticleCaloExtensionTool::layersCaloExtension ( const EventContext & ctx, const TrackParameters & startPars, const std::vector< CaloSampling::CaloSample > & clusterLayers, double eta, const CaloDetDescrManager & caloDD, ParticleHypothesis particleType ) const

finaloverridevirtual

Method returning a vector of the Track Parameters at layers/samplings.

Parameters

ctx	event context needed for multithreading
startPars	the starting track parameters
clusterLayers	the layers (should be ordered) we aim to
eta	eta used for the depth
particleType	type of particle

Implements Trk::IParticleCaloExtensionTool.

Definition at line 407 of file ParticleCaloExtensionTool.cxx.

{
 
  // Create surfaces at the layers
  std::vector<std::unique_ptr<Trk::Surface>> caloSurfaces =
    caloSurfacesFromLayers(clusterLayers, eta, caloDD);
 
  return surfaceCaloExtension(
    ctx, startPars, clusterLayers, caloSurfaces, particleType);
}

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 380 of file AthCommonDataStore.h.

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

renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

surfaceCaloExtension()

std::vector< std::pair< CaloSampling::CaloSample, std::unique_ptr< const Trk::TrackParameters > > > Trk::ParticleCaloExtensionTool::surfaceCaloExtension ( const EventContext & ctx, const TrackParameters & startPars, const std::vector< CaloSampling::CaloSample > & clusterLayers, const std::vector< std::unique_ptr< Trk::Surface > > & caloSurfaces, ParticleHypothesis particleType ) const

finaloverridevirtual

Method returning a vector of the Track Parameters at layers/samplings.

Parameters

ctx	event context needed for multithreading
startPars	the starting track parameters
clusterLayers	the layers (should be ordered) we aim to
clusterSurfaces	the surfaces for each layer
particleType	type of particle

The clusterLayers and clusterSurfaces need to be 1-1 this can be done via the caloSurfacesFromLayers method above.

Implements Trk::IParticleCaloExtensionTool.

Definition at line 375 of file ParticleCaloExtensionTool.cxx.

{
  const auto* lastImpact = &startPars;
  // Go into steps from layer to layer
  size_t numSteps = caloSurfaces.size();
  std::vector<std::pair<CaloSampling::CaloSample,
                        std::unique_ptr<const Trk::TrackParameters>>>
    caloParameters{};
  caloParameters.reserve(numSteps);
  for (size_t i = 0; i < numSteps; ++i) {
    std::unique_ptr<const Trk::TrackParameters> nextImpact =
      m_extrapolator->extrapolateDirectly(ctx,
                                          *lastImpact,
                                          *(caloSurfaces[i]),
                                          alongMomentum,
                                          false,
                                          particleType);
    if (nextImpact) {
      caloParameters.emplace_back(clusterLayers[i], std::move(nextImpact));
      lastImpact = caloParameters.back().second.get();
    }
  }
  return caloParameters;
}

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

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

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_calosurf

ToolHandle<ICaloSurfaceBuilder> Trk::ParticleCaloExtensionTool::m_calosurf

private

Initial value:

{
    this,
    "CaloSurfaceBuilder",
    "",
    "Tool to build calorimeter layer surfaces"
  }

Tool to build calorimeter layer surfaces.

Definition at line 127 of file ParticleCaloExtensionTool.h.

                                            {
    this,
    "CaloSurfaceBuilder",
    "",
    "Tool to build calorimeter layer surfaces"
  };

m_detID

const AtlasDetectorID* Trk::ParticleCaloExtensionTool::m_detID

private

Definition at line 144 of file ParticleCaloExtensionTool.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_extrapolator

ToolHandle<Trk::IExtrapolator> Trk::ParticleCaloExtensionTool::m_extrapolator { this, "Extrapolator", "" }

private

Definition at line 124 of file ParticleCaloExtensionTool.h.

{ this, "Extrapolator", "" };

m_extrapolDetectorID

Gaudi::Property<unsigned int> Trk::ParticleCaloExtensionTool::m_extrapolDetectorID

private

Initial value:

{
    this,
    "ExtrapolationDetectorID",
    Trk::Calo,
    "The detector this tool should extrapolate through. Expects a "
    "Trk::GeometrySignature enum value."
  }

Definition at line 147 of file ParticleCaloExtensionTool.h.

                                                  {
    this,
    "ExtrapolationDetectorID",
    Trk::Calo,
    "The detector this tool should extrapolate through. Expects a "
    "Trk::GeometrySignature enum value."
  };

m_monTool

ToolHandle<GenericMonitoringTool> Trk::ParticleCaloExtensionTool::m_monTool {this,"MonTool","","Monitoring tool"}

private

Monitoring tool for recording histograms of the alg in action.

Definition at line 156 of file ParticleCaloExtensionTool.h.

{this,"MonTool","","Monitoring tool"};

m_particleStrategy

ParticleHypothesis Trk::ParticleCaloExtensionTool::m_particleStrategy

private

Definition at line 145 of file ParticleCaloExtensionTool.h.

m_particleTypeName

Gaudi::Property<std::string> Trk::ParticleCaloExtensionTool::m_particleTypeName

private

Initial value:

{
      this, "ParticleType", "muon",
      "The particle type used during extrapolation when not passed via the "
      "method interfaces"
      ": muon, pion, nonInteracting"}

Definition at line 134 of file ParticleCaloExtensionTool.h.

                                             {
      this, "ParticleType", "muon",
      "The particle type used during extrapolation when not passed via the "
      "method interfaces"
      ": muon, pion, nonInteracting"};

m_startFromPerigee

Gaudi::Property<bool> Trk::ParticleCaloExtensionTool::m_startFromPerigee

private

Initial value:

{ this,
                                            "StartFromPerigee",
                                            false,
                                            "Start from Perigee" }

Definition at line 140 of file ParticleCaloExtensionTool.h.

                                        { this,
                                            "StartFromPerigee",
                                            false,
                                            "Start from Perigee" };

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• ParticleCaloExtensionTool.h
• ParticleCaloExtensionTool.cxx