#include <HGTD_IterativeExtensionTool.h>

Inheritance diagram for HGTD_IterativeExtensionTool:

Collaboration diagram for HGTD_IterativeExtensionTool:

Public Member Functions
	HGTD_IterativeExtensionTool (const std::string &, const std::string &, const IInterface *)
virtual StatusCode	initialize () override final
virtual HGTD::ExtensionObject	extendTrackToHGTD (const EventContext &ctx, const xAOD::TrackParticle &track_ptkl, const HGTD_ClusterContainer container, const HepMC::GenEvent hs_event=nullptr, const InDetSimDataCollection *sim_data=nullptr) const override final
	Finds the (up to) four measurements in HGTD that can be associated to the track.

Private Member Functions
const Trk::TrackStateOnSurface *	getLastHitOnTrack (const Trk::Track &track) const
	Retrieve the last hit on track stored in the Trk::Track.
std::vector< std::unique_ptr< const Trk::TrackParameters > >	extrapolateToSurfaces (const EventContext &ctx, const Trk::TrackParameters &param, const std::vector< const Trk::Surface * > &surfaces) const
	After the compatible surfaces have been selected, the extrapolation is repeated to each of them.
std::unique_ptr< const Trk::TrackStateOnSurface >	updateStateWithBestFittingCluster (const Trk::Track track, const std::vector< std::unique_ptr< const Trk::TrackParameters > > &params, const HGTD_ClusterContainer container) const
	Finds the overall best fitting cluster by keeping the one that gave the lowest chi2 after testing each surface and returning it.
std::unique_ptr< const Trk::TrackStateOnSurface >	findBestCompatibleCluster (const Trk::Track track, const Trk::TrackParameters param, const HGTD_ClusterContainer *container) const
	Find the cluster on a given surface that has the best chi2 passing the cut.
std::unique_ptr< const Trk::TrackStateOnSurface >	updateState (const Trk::Track track, const Trk::TrackParameters param, const HGTD_Cluster *cluster) const
	Calls the TOF correction tool to build an HGTD_ClusterOnTrack with a calibrated time and resolution and then calls the Kalman updator tools to update the track state.
std::pair< const HGTD_Cluster *, HGTD::ClusterTruthInfo >	getTruthMatchedCluster (const std::vector< const Trk::Surface * > &surfaces, const HGTD_ClusterContainer container, const xAOD::TruthParticle truth_ptkl, const HepMC::GenEvent hs_event, const InDetSimDataCollection sim_data) const

Static Private Member Functions
static std::vector< const Trk::Surface * >	getCompatibleSurfaces (const Trk::TrackParameters &param, const Trk::Layer *layer)
	Select all within the vincinity of the point of extrapolation.

Private Attributes
ToolHandle< Trk::IExtrapolator >	m_extrapolator
ToolHandle< Trk::IUpdator >	m_updator
ToolHandle< IHGTD_TOFcorrectionTool >	m_tof_corr_tool
ToolHandle< IHGTD_ClusterTruthTool >	m_truth_tool
const HGTD_DetectorManager *	m_hgtd_det_mgr {nullptr}
const HGTD_ID *	m_hgtd_id_helper {nullptr}
FloatProperty	m_chi2_cut
	Track extensions are only kept if the chi2/ndof is lower than the defined cut.
IntegerProperty	m_particle_hypot
	Particle hypothesis used for the extrapolation.

Detailed Description

Definition at line 42 of file HGTD_IterativeExtensionTool.h.

Constructor & Destructor Documentation

◆ HGTD_IterativeExtensionTool()

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

Definition at line 29 of file HGTD_IterativeExtensionTool.cxx.

32 : base_class(t, n, p) {}

Member Function Documentation

◆ extendTrackToHGTD()

HGTD::ExtensionObject HGTD_IterativeExtensionTool::extendTrackToHGTD	(	const EventContext &	ctx,
		const xAOD::TrackParticle &	track_ptkl,
		const HGTD_ClusterContainer *	container,
		const HepMC::GenEvent *	hs_event = nullptr,
		const InDetSimDataCollection *	sim_data = nullptr ) const

finaloverridevirtual

Finds the (up to) four measurements in HGTD that can be associated to the track.

The Track itself is not altered during this process. Since HGTD contains four active layers per endcap, four hits is the maximum. An extension can be of hole-type

Parameters

[in] track Track reconstructed in ITk.

Returns: Array of compatible HGTD hits in the form of HGTD_ClusterOnTrack.

Definition at line 52 of file HGTD_IterativeExtensionTool.cxx.

                                                  {
 
  ATH_MSG_DEBUG("Start extending");
 
  const Trk::Track* track = track_ptkl.track();
 
  HGTD::ExtensionObject result;
 
  // get last hit on track in ITk as a starting point for the extrapolation
  const Trk::TrackStateOnSurface* last_hit = getLastHitOnTrack(*track);
  const Trk::TrackParameters* last_param = last_hit->trackParameters();
 
  ATH_MSG_DEBUG("last param  x: " << last_param->position().x()
                                  << ", y: " << last_param->position().y()
                                  << ", z: " << last_param->position().z());
  ATH_MSG_DEBUG("last param  px: " << last_param->momentum().x()
                                   << ", py: " << last_param->momentum().y()
                                   << ", pz: " << last_param->momentum().z());
 
  const xAOD::TruthParticle* truth_ptkl =
      xAOD::TruthHelpers::getTruthParticle(track_ptkl);
 
  // get the tracking geometry
  const Trk::TrackingGeometry* trk_geom = m_extrapolator->trackingGeometry();
  if (not trk_geom) {
    ATH_MSG_DEBUG("trackingGeometry returns null");
    return result;
  }
 
  bool is_pos_endcap = last_param->eta() > 0;
 
  // get the target volume
  const Trk::TrackingVolume* hgtd_trk_volume = trk_geom->trackingVolume(
      is_pos_endcap ? "HGTD::PositiveEndcap" : "HGTD::NegativeEndcap");
 
  if (not hgtd_trk_volume) {
    ATH_MSG_DEBUG("trackingVolume returns null");
    return result;
  }
 
  const Trk::BinnedArray<Trk::Layer>* confined_layers =
      hgtd_trk_volume->confinedLayers();
  // careful, this array is not ordered from inside out (only in pos endcap)
  if (not confined_layers) {
    ATH_MSG_DEBUG("confinedLayers returns null");
    return result;
  }
 
  // get the layers, traverse depending on endcap used
  // since they are not in ascending z order!!
  std::span<Trk::Layer const * const> layers = confined_layers->arrayObjects();
  size_t layer_size = layers.size();
 
  short position = is_pos_endcap ? 0 : layer_size - 1;
  short step = is_pos_endcap ? 1 : -1;
  short hgtd_layer_i = -1; // start at -1 since the ++ happens at the beginning
  for (size_t i = 0; i < layer_size - 1; i++, position = position + step) {
 
    const Trk::Layer* layer = layers[position];
    // only use it, if it is an active one
    if (layer->layerType() != 1) {
      continue;
    }
    hgtd_layer_i++;
 
    const Trk::Surface& surf_obj = layer->surfaceRepresentation();
    ATH_MSG_DEBUG("extrapolation surface z: " << surf_obj.center().z());
 
    // if it is a good surface, extrapolate to this surface
    // uses same particle hypothesis used for the track itself
    // TODO: BoundaryCheck set to false as in 20.20 -> what does this do?
    std::unique_ptr<const Trk::TrackParameters> extrap_result = nullptr;
 
    Trk::ParticleHypothesis part = track->info().particleHypothesis();
    if (part == Trk::undefined) {
      part = static_cast<Trk::ParticleHypothesis>(m_particle_hypot.value());
    }
    extrap_result = m_extrapolator->extrapolate(
        ctx, *last_param, surf_obj, Trk::PropDirection::alongMomentum, false,
        part);
 
    //
    if (not extrap_result) {
      ATH_MSG_WARNING("Extrapolator returned null");
      result.m_hits.at(hgtd_layer_i) = nullptr;
      result.m_truth_primary_hits.at(hgtd_layer_i) = nullptr;
      result.m_truth_primary_info.at(hgtd_layer_i) = HGTD::ClusterTruthInfo();
      continue;
    }
 
    // get the extrapolation position info only on the first layer
    if (hgtd_layer_i == 0) {
      result.m_extrap_x = extrap_result->position().x();
      result.m_extrap_y = extrap_result->position().y();
    }
 
    ATH_MSG_DEBUG("extrap. params  x: "
                  << extrap_result->position().x()
                  << ", y: " << extrap_result->position().y()
                  << ", z: " << extrap_result->position().z());
    ATH_MSG_DEBUG("extrap. params  px: "
                  << extrap_result->momentum().x()
                  << ", py: " << extrap_result->momentum().y()
                  << ", pz: " << extrap_result->momentum().z());
 
    // find active surfaces in the vincinity
    auto compatible_surfaces = getCompatibleSurfaces(*extrap_result, layer);
 
    if (compatible_surfaces.empty()) {
      ATH_MSG_WARNING("No compatible surfaces for position");
      result.m_hits.at(hgtd_layer_i) = nullptr;
      result.m_truth_primary_hits.at(hgtd_layer_i) = nullptr;
      result.m_truth_primary_info.at(hgtd_layer_i) = HGTD::ClusterTruthInfo();
      continue;
    }
 
    auto extrapolated_params =
        extrapolateToSurfaces(ctx, *last_param, compatible_surfaces);
 
    std::unique_ptr<const Trk::TrackStateOnSurface> updated_state =
        updateStateWithBestFittingCluster(track, extrapolated_params,
                                          container);
 
    if (not updated_state) {
      result.m_hits.at(hgtd_layer_i) = nullptr;
      result.m_truth_primary_hits.at(hgtd_layer_i) = nullptr;
      result.m_truth_primary_info.at(hgtd_layer_i) = HGTD::ClusterTruthInfo();
      continue;
    }
    // if the state was updated with a measurement, the it becomes the new last
    // parameter
    last_param = updated_state->trackParameters();
    // store the last track state to be returned
 
    std::pair<const HGTD_Cluster*, HGTD::ClusterTruthInfo> truth_info =
        getTruthMatchedCluster(compatible_surfaces, container, truth_ptkl,
                               hs_event, sim_data);
 
    result.m_hits.at(hgtd_layer_i) = std::move(updated_state);
    result.m_truth_primary_hits.at(hgtd_layer_i) = truth_info.first;
    result.m_truth_primary_info.at(hgtd_layer_i) = truth_info.second;
  }
 
  return result;
}

◆ extrapolateToSurfaces()

std::vector< std::unique_ptr< const Trk::TrackParameters > > HGTD_IterativeExtensionTool::extrapolateToSurfaces	(	const EventContext &	ctx,
		const Trk::TrackParameters &	param,
		const std::vector< const Trk::Surface * > &	surfaces ) const

private

After the compatible surfaces have been selected, the extrapolation is repeated to each of them.

Parameters

[in]	param	The last track parameter before extrapolation.
[in]	surfaces	Target layer of the extrapolation.

Returns: Vector of the updated track parameters.

FIXME Is this really necessary to call the extrapolation on each target surface?

Definition at line 270 of file HGTD_IterativeExtensionTool.cxx.

                                                        {
 
  std::vector<std::unique_ptr<const Trk::TrackParameters>> params;
  params.reserve(surfaces.size());
 
  for (const auto* surface : surfaces) {
    std::unique_ptr<const Trk::TrackParameters> extrapolated_params = nullptr;
 
    extrapolated_params = m_extrapolator->extrapolate(
        ctx, param, *surface, Trk::alongMomentum, false,
        static_cast<Trk::ParticleHypothesis>(m_particle_hypot.value()));
    if (not extrapolated_params) {
      continue;
    }
    params.push_back(std::move(extrapolated_params));
  }
 
  return params;
}

◆ findBestCompatibleCluster()

std::unique_ptr< const Trk::TrackStateOnSurface > HGTD_IterativeExtensionTool::findBestCompatibleCluster	(	const Trk::Track *	track,
		const Trk::TrackParameters *	param,
		const HGTD_ClusterContainer *	container ) const

private

Find the cluster on a given surface that has the best chi2 passing the cut.

Is called within updateStateWithBestFittingCluster.

Definition at line 329 of file HGTD_IterativeExtensionTool.cxx.

                                                  {
 
  ATH_MSG_DEBUG("[findBestCompatibleCluster] start");
 
  std::unique_ptr<const Trk::TrackStateOnSurface> tsos = nullptr;
 
  double lowest_chi2 = -1;
  for (const auto* collection : *container) {
    // find the one collection that can be associated to the surface
    if (collection->identify() !=
        param->associatedSurface().associatedDetectorElementIdentifier()) {
      continue;
    }
    ATH_MSG_DEBUG(
        "[findBestCompatibleCluster] found collection of given surface");
    // test the clusters on this surface for compatibility, keep the best
    for (const auto* cluster : *collection) {
      // update the track parameters with the found cluster
      std::unique_ptr<const Trk::TrackStateOnSurface> candidate =
          updateState(track, param, cluster);
 
      if (not candidate) {
        continue;
      }
      if (not candidate->measurementOnTrack() and
          not candidate->fitQualityOnSurface()) {
        continue;
      }
      double chi2 = candidate->fitQualityOnSurface().chiSquared() /
                    candidate->fitQualityOnSurface().doubleNumberDoF();
      ATH_MSG_DEBUG("found cluster with chi2 of " << chi2);
      // apply cut on the chi2
      if (chi2 > m_chi2_cut) {
        continue;
      }
      // make sure only one TSOS is kept
      if (not tsos or chi2 < lowest_chi2) {
        tsos.swap(candidate);
        lowest_chi2 = chi2;
      }
    }
    // per trackparameter, there is only one fitting surface
    // break after having found it
    break;
  }
 
  return tsos; // no need to std::move thanks to Return Value Optimization (RVO)
}

◆ getCompatibleSurfaces()

std::vector< const Trk::Surface * > HGTD_IterativeExtensionTool::getCompatibleSurfaces	(	const Trk::TrackParameters &	param,
		const Trk::Layer *	layer )

staticprivate

Select all within the vincinity of the point of extrapolation.

Parameters

[in]	param	The already extrapolated track parameter.
[in]	layer	Target layer of the extrapolation.

Returns: Vector of compatible surfaces that represent modules.

FIXME exchange the loop with the neighbour functionality (wherever that is)

Definition at line 227 of file HGTD_IterativeExtensionTool.cxx.

                                                            {
 
  std::vector<const Trk::Surface*> surfaces;
 
  // point of extrapolation as global position
  const Amg::Vector3D& position = param.position();
  // get the surface at the point of extrapolation
  const auto* surface_arr = layer->surfaceArray(); // these are the modules
  if (!surface_arr) {
    return surfaces;
  }
  const Trk::Surface* module_surface = surface_arr->object(
      position); // from this binned object, get the module closeby
  if (!module_surface) {
    return surfaces;
  }
  surfaces.push_back(module_surface);
 
  // pick up additional surfaces in a 4cm radius
  // TODO REPLACE THIS BY NEIGHBOUR FUNCTIONALITY IN FUTURE!!
  short steps = 16;
  float delta_angle = 6.2831853 / (float)steps;
  float angle = 0.;
  float radius = 20.0;
  for (short i = 0; i < steps; i++, angle = angle + delta_angle) {
    Amg::Vector3D delta(radius * std::cos(angle), radius * std::sin(angle), 0);
    Amg::Vector3D result = position + delta;
    const Trk::Surface* additional_surface = surface_arr->object(result);
    if (!additional_surface) {
      continue;
    }
    // check if surface was added to avoid duplicates
    if (std::find(surfaces.begin(), surfaces.end(), additional_surface) ==
        surfaces.end()) {
      surfaces.push_back(additional_surface);
    }
  }
 
  return surfaces;
}

◆ getLastHitOnTrack()

const Trk::TrackStateOnSurface * HGTD_IterativeExtensionTool::getLastHitOnTrack ( const Trk::Track & track ) const

private

Retrieve the last hit on track stored in the Trk::Track.

Parameters

[in] track Track reconstructed in ITk.

Returns: The last hit on track, i.e. the closest one to HGTD.

FIXME: returns a const*, but the Track manages this TSOS. Could I return rather const&? But: I want to check if type is OK... should I return an "empty" TSOS if nothing passes the requirements?

Definition at line 202 of file HGTD_IterativeExtensionTool.cxx.

                                                                          {
 
  const Trk::TrackStates* tsos =
      track.trackStateOnSurfaces();
  if (not tsos) {
    ATH_MSG_ERROR("Failed to retrieve track state on surfaces");
    return nullptr;
  }
  // loop over the associated hits in ITk in reverse order, since we want to
  // select the one closest to HGTD to start the extrapolation
  for (auto i = tsos->rbegin(); i != tsos->rend(); ++i) {
    const auto* curr_last_tsos = *i;
    if (not curr_last_tsos) {
      continue;
    }
    if (curr_last_tsos->type(Trk::TrackStateOnSurface::Measurement) and
        curr_last_tsos->trackParameters() and
        curr_last_tsos->measurementOnTrack()) {
      return curr_last_tsos;
    }
  }
  return nullptr;
}

◆ getTruthMatchedCluster()

std::pair< const HGTD_Cluster *, HGTD::ClusterTruthInfo > HGTD_IterativeExtensionTool::getTruthMatchedCluster	(	const std::vector< const Trk::Surface * > &	surfaces,
		const HGTD_ClusterContainer *	container,
		const xAOD::TruthParticle *	truth_ptkl,
		const HepMC::GenEvent *	hs_event,
		const InDetSimDataCollection *	sim_data ) const

private

Definition at line 414 of file HGTD_IterativeExtensionTool.cxx.

                                                  {
 
  if (not truth_ptkl or not sim_data) {
    if (not truth_ptkl)
      ATH_MSG_DEBUG("truth_ptkl is null");
    if (not sim_data)
      ATH_MSG_DEBUG("sim_data is null");
 
    return {nullptr, HGTD::ClusterTruthInfo()};
  }
 
  std::vector<Identifier> ids;
  std::for_each(surfaces.begin(), surfaces.end(),
                [&](const Trk::Surface* surf) {
                  ids.push_back(surf->associatedDetectorElementIdentifier());
                });
 
  for (const auto *const collection : *container) {
    // if the ID corresponding to this collection is not in the list, skip
 
    if (std::find(ids.begin(), ids.end(), collection->identify()) ==
        ids.end()) {
      continue;
    }
    for (const auto* cluster : *collection) {
 
      HGTD::ClusterTruthInfo truth_info = m_truth_tool->classifyCluster(
          cluster, truth_ptkl, sim_data, hs_event);
      // return cluster and truth info if the hit is matched to the truth
      // particle
      if (truth_info.origin == HGTD::ClusterTruthOrigin::TRUTH_PARTICLE) {
        return {cluster, truth_info};
      }
    }
  }
  // no matched cluster found
  return {nullptr, HGTD::ClusterTruthInfo()};
}

◆ initialize()

StatusCode HGTD_IterativeExtensionTool::initialize ( )

finaloverridevirtual

Definition at line 34 of file HGTD_IterativeExtensionTool.cxx.

                                                   {
  StatusCode sc = AthAlgTool::initialize();
 
  ATH_CHECK(m_extrapolator.retrieve());
 
  ATH_CHECK(m_updator.retrieve());
 
  ATH_CHECK(m_tof_corr_tool.retrieve());
 
  ATH_CHECK(m_truth_tool.retrieve());
 
  // get HGTD Detector Description Manager and HGTD Helper
  ATH_CHECK(detStore()->retrieve(m_hgtd_det_mgr, "HGTD"));
  ATH_CHECK(detStore()->retrieve(m_hgtd_id_helper, "HGTD_ID"));
 
  return sc;
}

◆ updateState()

std::unique_ptr< const Trk::TrackStateOnSurface > HGTD_IterativeExtensionTool::updateState	(	const Trk::Track *	track,
		const Trk::TrackParameters *	param,
		const HGTD_Cluster *	cluster ) const

private

Calls the TOF correction tool to build an HGTD_ClusterOnTrack with a calibrated time and resolution and then calls the Kalman updator tools to update the track state.

Definition at line 381 of file HGTD_IterativeExtensionTool.cxx.

                                                                            {
  ATH_MSG_DEBUG("[updateState] calling the updator");
 
  // FIXME: the HGTD_Cluster should know its detector element here. needs
  // to be set up in the converter at some point!!
  const auto* det_el = m_hgtd_det_mgr->getDetectorElement(cluster->identify());
 
  // apply the time of flight correction before setting the time and resolution
  // in the HGTD_ClusterOnTrack
  std::pair<float, float> corr_time_and_res =
      m_tof_corr_tool->correctTimeAndResolution(
          *track, *cluster, cluster->time(), cluster->timeResolution());
 
  std::unique_ptr<HGTD_ClusterOnTrack> cot =
      std::make_unique<HGTD_ClusterOnTrack>(
          cluster, Trk::LocalParameters(cluster->localPosition()),
          Amg::MatrixX(cluster->localCovariance()), corr_time_and_res.first,
          corr_time_and_res.second, det_el->identifyHash());
 
  Trk::FitQualityOnSurface* quality = nullptr;
 
  std::unique_ptr<Trk::TrackParameters> pars = m_updator->addToState(
      *param, cot->localParameters(), cot->localCovariance(), quality);
  //Here one could  fix the addToState intefaces to
  //avoid them allocating memory for  Fit Quality On Surface
  auto uniqueQuality= std::unique_ptr<Trk::FitQualityOnSurface>(quality);
  auto QoS = uniqueQuality? *uniqueQuality : Trk::FitQualityOnSurface{};
  return std::make_unique<const Trk::TrackStateOnSurface>(QoS, std::move(cot),
                                                          std::move(pars));
}

◆ updateStateWithBestFittingCluster()

std::unique_ptr< const Trk::TrackStateOnSurface > HGTD_IterativeExtensionTool::updateStateWithBestFittingCluster	(	const Trk::Track *	track,
		const std::vector< std::unique_ptr< const Trk::TrackParameters > > &	params,
		const HGTD_ClusterContainer *	container ) const

private

Finds the overall best fitting cluster by keeping the one that gave the lowest chi2 after testing each surface and returning it.

Definition at line 293 of file HGTD_IterativeExtensionTool.cxx.

                                                  {
  ATH_MSG_DEBUG("[updateStateWithBestFittingCluster] start updating");
 
  std::unique_ptr<const Trk::TrackStateOnSurface> updated_state = nullptr;
 
  double lowest_chi2 = -1.;
  // all compatible surfaces are tested for the best fitting cluster
  for (const auto& param : params) {
    std::unique_ptr<const Trk::TrackStateOnSurface> best_tsos =
        findBestCompatibleCluster(track, param.get(), container);
    if (not best_tsos) {
      ATH_MSG_DEBUG("[updateStateWithBestFittingCluster] tsos is null");
      continue;
    }
    ATH_MSG_DEBUG("[updateStateWithBestFittingCluster] tsos found");
 
    double chi2 = best_tsos->fitQualityOnSurface().chiSquared() /
                  best_tsos->fitQualityOnSurface().doubleNumberDoF();
    ATH_MSG_DEBUG(
        "[updateStateWithBestFittingCluster] found state with chi2 of "
        << chi2);
    // make sure only one TSOS is kept
    if (!updated_state or chi2 < lowest_chi2) {
      updated_state.swap(best_tsos);
      lowest_chi2 = chi2;
    }
  }
 
  return updated_state; // no need to std::move thanks to Return Value
                        // Optimization (RVO)
}

Member Data Documentation

◆ m_chi2_cut

FloatProperty HGTD_IterativeExtensionTool::m_chi2_cut

private

Initial value:

{this, "Chi2Cut", 5.0,

"Quality cut for decision to keep track extension"}

Track extensions are only kept if the chi2/ndof is lower than the defined cut.

Definition at line 172 of file HGTD_IterativeExtensionTool.h.

172 {this, "Chi2Cut", 5.0,

173 "Quality cut for decision to keep track extension"};

◆ m_extrapolator

ToolHandle<Trk::IExtrapolator> HGTD_IterativeExtensionTool::m_extrapolator

private

Initial value:

{
      this, "ExtrapolatorTool", "Trk::Extrapolator/AtlasExtrapolator",
      "Tool for extrapolating the track to the HGTD surfaces"}

Definition at line 149 of file HGTD_IterativeExtensionTool.h.

                                             {
      this, "ExtrapolatorTool", "Trk::Extrapolator/AtlasExtrapolator",
      "Tool for extrapolating the track to the HGTD surfaces"};

◆ m_hgtd_det_mgr

const HGTD_DetectorManager* HGTD_IterativeExtensionTool::m_hgtd_det_mgr {nullptr}

private

Definition at line 165 of file HGTD_IterativeExtensionTool.h.

165{nullptr};

◆ m_hgtd_id_helper

const HGTD_ID* HGTD_IterativeExtensionTool::m_hgtd_id_helper {nullptr}

private

Definition at line 166 of file HGTD_IterativeExtensionTool.h.

166{nullptr};

◆ m_particle_hypot

IntegerProperty HGTD_IterativeExtensionTool::m_particle_hypot

private

Initial value:

{
      this, "ParticleHypothesis", Trk::ParticleHypothesis::pion,
      "The hypothesis of the track's particle type"}

Particle hypothesis used for the extrapolation.

Definition at line 178 of file HGTD_IterativeExtensionTool.h.

                                  {
      this, "ParticleHypothesis", Trk::ParticleHypothesis::pion,
      "The hypothesis of the track's particle type"};

◆ m_tof_corr_tool

ToolHandle<IHGTD_TOFcorrectionTool> HGTD_IterativeExtensionTool::m_tof_corr_tool

private

Initial value:

{
      this, "TOFCorrTool", "StraightLineTOFcorrectionTool",
      "Tool for correcting for time of flight"}

Definition at line 157 of file HGTD_IterativeExtensionTool.h.

                                                     {
      this, "TOFCorrTool", "StraightLineTOFcorrectionTool",
      "Tool for correcting for time of flight"};

◆ m_truth_tool

ToolHandle<IHGTD_ClusterTruthTool> HGTD_IterativeExtensionTool::m_truth_tool

private

Initial value:

{
      this, "ClusterTruthTool", "HGTD::ClusterTruthTool/ClusterTruthTool",
      "Tool for classifying HGTD clusters with truth information"}

Definition at line 161 of file HGTD_IterativeExtensionTool.h.

                                                 {
      this, "ClusterTruthTool", "HGTD::ClusterTruthTool/ClusterTruthTool",
      "Tool for classifying HGTD clusters with truth information"};

◆ m_updator

ToolHandle<Trk::IUpdator> HGTD_IterativeExtensionTool::m_updator

private

Initial value:

{
      this, "UpdatorTool", "Trk::KalmanUpdator/KalmanUpdator",
      "Tool for updating the track parameters accounting for new measurements"}

Definition at line 153 of file HGTD_IterativeExtensionTool.h.

                                   {
      this, "UpdatorTool", "Trk::KalmanUpdator/KalmanUpdator",
      "Tool for updating the track parameters accounting for new measurements"};

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

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ HGTD_IterativeExtensionTool()

Member Function Documentation

◆ extendTrackToHGTD()

◆ extrapolateToSurfaces()

◆ findBestCompatibleCluster()

◆ getCompatibleSurfaces()

◆ getLastHitOnTrack()

◆ getTruthMatchedCluster()

◆ initialize()

◆ updateState()

◆ updateStateWithBestFittingCluster()

Member Data Documentation

◆ m_chi2_cut

◆ m_extrapolator

◆ m_hgtd_det_mgr

◆ m_hgtd_id_helper

◆ m_particle_hypot

◆ m_tof_corr_tool

◆ m_truth_tool

◆ m_updator