HGTD::ExpertTrackTimeFromClustersTool Class Reference

#include <ExpertTrackTimeFromClustersTool.h>

Inheritance diagram for HGTD::ExpertTrackTimeFromClustersTool:

Classes
struct	Hit

Public Member Functions
	ExpertTrackTimeFromClustersTool (const std::string &, const std::string &, const IInterface *)
virtual	~ExpertTrackTimeFromClustersTool ()=default
virtual StatusCode	initialize () override final
virtual bool	expertHasTime (const xAOD::TrackParticle &track_particle) const override final
virtual float	expertTime (const xAOD::TrackParticle &track_particle) const override final
virtual float	expertTimeRes (const xAOD::TrackParticle &track_particle) const override final
virtual float	fracPrimaryHits (const xAOD::TrackParticle &track_particle) const override final
virtual int	numberPotentialPrimaryHits (const xAOD::TrackParticle &track_particle) const override final

Private Types
using	HitVec_t = std::vector<Hit>
using	FloatVec_t = std::vector<float>

Private Member Functions
int	nHits (const xAOD::TrackParticle &track_particle) const
	Number of hits that were used to build the track time.
int	nPrimaryHits (const xAOD::TrackParticle &track_particle) const
	Number of hits used for the track time that were left by a primary particle.
HitVec_t	getValidHits (const xAOD::TrackParticle &track_particle) const
	Retrieve the hit information from the decorators and build a vector of hits.
HitVec_t	getTimeCompatibleHits (const xAOD::TrackParticle &track_particle) const
	Retrieve the hit information from the decorators and build a vector of hits for those hits that survive the time compatibility checks.
TVector3	getLastMeasurement (const xAOD::TrackParticle &track) const
	In the samples used for HGTD studies the last hit on track in ITk is written to file and can be used for the cleaning procedure.
bool	lastHitIsOnLastSurface (const xAOD::TrackParticle &track) const
	Check wheather the last hit on track is on a surface close to HGTD.
float	calculateMean (const HitVec_t &hits) const
	Returns the arithmetic average mean of the hit times.
bool	passesDeltaT (const HitVec_t &hits) const
	Tests if a given set of exactly 2 Hit objects passes the set time difference cut, which is defined in units of the combined resolution.
float	calculateChi2 (const HitVec_t &vals) const
float	calculateTrackResolution (const HitVec_t &vals) const
int	numberOfPrimaryHits (const HitVec_t &vals) const

Private Attributes
Gaudi::Property< bool >	m_do_last_hit
Gaudi::Property< bool >	m_do_time_cons
Gaudi::Property< float >	m_deltat_cut {this, "DeltaTCut", 2.0, "Default value"}
Gaudi::Property< float >	m_chi2_threshold
Gaudi::Property< bool >	m_do_min_nhits
Gaudi::Property< float >	m_min_eta {this, "MinEta", 3.5, "Default value"}
Gaudi::Property< float >	m_max_eta {this, "MaxEta", 3.9, "Default value"}
Gaudi::Property< bool >	m_do_smearing
std::string	m_dec_prefix
	Prefix of the decorations this tool writes.
std::unique_ptr< SG::AuxElement::Decorator< bool > >	m_dec_isset
std::unique_ptr< SG::AuxElement::Decorator< bool > >	m_dec_hastime
std::unique_ptr< SG::AuxElement::Decorator< float > >	m_dec_time
std::unique_ptr< SG::AuxElement::Decorator< int > >	m_dec_nhits
std::unique_ptr< SG::AuxElement::Decorator< int > >	m_dec_nprimehits
std::unique_ptr< SG::AuxElement::Decorator< float > >	m_dec_resolution
std::unique_ptr< SG::ConstAccessor< bool > >	m_acc_isset
std::unique_ptr< SG::ConstAccessor< bool > >	m_acc_hastime
std::unique_ptr< SG::ConstAccessor< float > >	m_acc_time
std::unique_ptr< SG::ConstAccessor< int > >	m_acc_nhits
std::unique_ptr< SG::ConstAccessor< int > >	m_acc_nprimehits
std::unique_ptr< SG::ConstAccessor< float > >	m_acc_resolution
SG::ConstAccessor< std::vector< bool > >	m_acc_perLayer_hasCluster
	Input decorations produced by the HGTD track extension, read with fixed names.
SG::ConstAccessor< std::vector< float > >	m_acc_perLayer_clusterTime
SG::ConstAccessor< std::vector< int > >	m_acc_perLayer_clusterTruthClass
SG::ConstAccessor< std::vector< bool > >	m_acc_perLayer_expectCluster

Detailed Description

Definition at line 40 of file ExpertTrackTimeFromClustersTool.h.

Member Typedef Documentation

FloatVec_t

using HGTD::ExpertTrackTimeFromClustersTool::FloatVec_t = std::vector<float>

private

Definition at line 51 of file ExpertTrackTimeFromClustersTool.h.

HitVec_t

using HGTD::ExpertTrackTimeFromClustersTool::HitVec_t = std::vector<Hit>

private

Definition at line 50 of file ExpertTrackTimeFromClustersTool.h.

Constructor & Destructor Documentation

ExpertTrackTimeFromClustersTool()

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

Definition at line 16 of file ExpertTrackTimeFromClustersTool.cxx.

    : base_class(t, n, p), m_dec_prefix(n) {
  // aux variable names may not contain a '.', but the instance name of a
  // private tool does
  std::replace(m_dec_prefix.begin(), m_dec_prefix.end(), '.', '_');
}

~ExpertTrackTimeFromClustersTool()

virtual HGTD::ExpertTrackTimeFromClustersTool::~ExpertTrackTimeFromClustersTool ( )

virtualdefault

Member Function Documentation

calculateChi2()

float ExpertTrackTimeFromClustersTool::calculateChi2 ( const HitVec_t & vals ) const

private

Definition at line 242 of file ExpertTrackTimeFromClustersTool.cxx.

                                                                               {
  float mean = calculateMean(hits);
 
  float chi2 = 0.;
  for (size_t i = 0; i < hits.size(); i++) {
 
    chi2 += (hits.at(i).time - mean) * (hits.at(i).time - mean) /
            (hits.at(i).resolution * hits.at(i).resolution);
  }
  // TODO should I better use chi2/ndof, where ndof = hits.size() - 1 (due to
  // mean)?
  return chi2;
}

calculateMean()

float ExpertTrackTimeFromClustersTool::calculateMean ( const HitVec_t & hits ) const

private

Returns the arithmetic average mean of the hit times.

Definition at line 256 of file ExpertTrackTimeFromClustersTool.cxx.

                                                                               {
  // FIXME improve this
  if (hits.size() == 0) {
    return -999.;
  }
  float sum = 0.;
  for (const Hit& hit : hits) {
    sum += hit.time;
  }
  return sum / (float)hits.size();
}

calculateTrackResolution()

float ExpertTrackTimeFromClustersTool::calculateTrackResolution ( const HitVec_t & vals ) const

private

Definition at line 344 of file ExpertTrackTimeFromClustersTool.cxx.

                                {
  // should never happen
  if (hits.size() == 0) {
    return -999.;
  }
  float sum = 0;
  for (const Hit& hit : hits) {
    sum += 1. / (hit.resolution * hit.resolution);
  }
  return std::sqrt(1. / sum);
}

expertHasTime()

bool ExpertTrackTimeFromClustersTool::expertHasTime ( const xAOD::TrackParticle & track_particle ) const

finaloverridevirtual

Definition at line 56 of file ExpertTrackTimeFromClustersTool.cxx.

                                                   {
  // if the track has been used before, access the decoration instead of
  // recalculating
  if (m_acc_hastime->isAvailable(track_particle) and
      m_acc_isset->operator()(track_particle)) {
    return m_acc_hastime->operator()(track_particle);
  }
 
  // check if the last measurement is close to HGTD
  if (m_do_last_hit and not lastHitIsOnLastSurface(track_particle)) {
    m_dec_isset->set(track_particle, true);
    m_dec_hastime->set(track_particle, false);
    m_dec_time->set(track_particle, -999.);
    m_dec_nhits->set(track_particle, 0);
    m_dec_nprimehits->set(track_particle, 0);
    m_dec_resolution->set(track_particle, -999.);
    return false;
  }
 
  HitVec_t used_hits;
  if (m_do_time_cons) {
    // retrieve the hits that survive the preset cuts
    used_hits = getTimeCompatibleHits(track_particle);
  } else {
    // retrieve all hits, no time compatibility check was required
    used_hits = getValidHits(track_particle);
  }
 
  if (m_do_min_nhits and used_hits.size() == 1) {
    // if a 2 hit minimum is required, reject the case of a single associated
    // hit if the track falls into the defined eta region
    float fabs_eta = std::abs(track_particle.eta());
    if (fabs_eta > m_min_eta and fabs_eta < m_max_eta) {
      m_dec_isset->set(track_particle, true);
      m_dec_hastime->set(track_particle, false);
      m_dec_time->set(track_particle, -999.);
      m_dec_nhits->set(track_particle, 0);
      m_dec_nprimehits->set(track_particle, 0);
      m_dec_resolution->set(track_particle, -999.);
      return false;
    }
  }
 
  m_dec_isset->set(track_particle, true);
  m_dec_hastime->set(track_particle, used_hits.size() > 0);
  m_dec_time->set(track_particle, calculateMean(used_hits));
  m_dec_nhits->set(track_particle, used_hits.size());
  m_dec_nprimehits->set(track_particle, numberOfPrimaryHits(used_hits));
  m_dec_resolution->set(track_particle, calculateTrackResolution(used_hits));
 
  return used_hits.size() > 0;
}

expertTime()

float ExpertTrackTimeFromClustersTool::expertTime ( const xAOD::TrackParticle & track_particle ) const

finaloverridevirtual

Definition at line 110 of file ExpertTrackTimeFromClustersTool.cxx.

                                                   {
  if (m_acc_time->isAvailable(track_particle) and
      m_acc_isset->operator()(track_particle)) {
    return m_acc_time->operator()(track_particle);
  } else {
    throw std::runtime_error(
        "[ExpertTrackTimeFromClustersTool::expertTime] ERROR, always call "
        "expertHasTime on a track fist!");
  }
}

expertTimeRes()

float ExpertTrackTimeFromClustersTool::expertTimeRes ( const xAOD::TrackParticle & track_particle ) const

finaloverridevirtual

Definition at line 122 of file ExpertTrackTimeFromClustersTool.cxx.

                                                   {
  if (m_acc_resolution->isAvailable(track_particle) and
      m_acc_isset->operator()(track_particle)) {
    return m_acc_resolution->operator()(track_particle);
  } else {
    throw std::runtime_error(
        "[ExpertTrackTimeFromClustersTool::expertTimeRes] ERROR, always call "
        "expertHasTime on a track fist!");
  }
}

fracPrimaryHits()

float ExpertTrackTimeFromClustersTool::fracPrimaryHits ( const xAOD::TrackParticle & track_particle ) const

finaloverridevirtual

Definition at line 332 of file ExpertTrackTimeFromClustersTool.cxx.

                                                   {
  if (not expertHasTime(track_particle)) {
    ATH_MSG_WARNING("[ExpertTrackTimeFromClustersTool::fracPrimaryHits]"
                    "No available hits, returning -999.");
    return -999.;
  }
  int n_primaries = nPrimaryHits(track_particle);
  int n_assigned = nHits(track_particle);
  return (float)n_primaries / (float)n_assigned;
}

getLastMeasurement()

TVector3 ExpertTrackTimeFromClustersTool::getLastMeasurement ( const xAOD::TrackParticle & track ) const

private

In the samples used for HGTD studies the last hit on track in ITk is written to file and can be used for the cleaning procedure.

It is returned as a TVector3 object.

Definition at line 357 of file ExpertTrackTimeFromClustersTool.cxx.

                                          {
 
  unsigned int index = 0;
 
  if (not track.indexOfParameterAtPosition(index, xAOD::LastMeasurement)) {
    return TVector3(0, 0, 0);
  }
 
  return TVector3(track.parameterX(index), track.parameterY(index),
                  track.parameterZ(index));
}

getTimeCompatibleHits()

std::vector< ExpertTrackTimeFromClustersTool::Hit > ExpertTrackTimeFromClustersTool::getTimeCompatibleHits ( const xAOD::TrackParticle & track_particle ) const

private

Retrieve the hit information from the decorators and build a vector of hits for those hits that survive the time compatibility checks.

Definition at line 147 of file ExpertTrackTimeFromClustersTool.cxx.

                                                   {
 
  // get all available hits in a first step
  HitVec_t valid_hits = getValidHits(track_particle);
 
  size_t vts = valid_hits.size();
 
  // if there is only one hit, no time consistency check can be done
  // to improve efficiency, accept it
  if (vts <= 1) {
    return valid_hits;
  }
 
  // in case of two hits, check for time compatibility
  if (vts == 2) {
    if (passesDeltaT(valid_hits)) {
      return valid_hits;
    } else {
      // if times are too far away from each other, don't accept time
      return {};
    }
  }
  // if there are 3 or 4 hits, perform chi2 outlier removal
  // calculate the chi2 value of the available hits in a first step
  float chi2 = calculateChi2(valid_hits);
 
  // if the chi2 value doesn't surpass the set threshold, the hits are accepted
  // as compatible in time
  if (chi2 < m_chi2_threshold) {
    return valid_hits;
  }
 
  HitVec_t time_candidates_copy = valid_hits; // TODO do I need this copy?
  bool searching = true;
  while (searching) {
    // calculate chi2 contribution of each value
    FloatVec_t chi2_contributions(time_candidates_copy.size(), 0.0);
    for (size_t i = 0; i < time_candidates_copy.size(); i++) {
      HitVec_t buff = time_candidates_copy;
      buff.erase(buff.begin() + i);
 
      // calculate the chi2 value we would get when removing the i-th hit
      double local_chi2 = calculateChi2(buff);
 
      chi2_contributions.at(i) = local_chi2;
    }
    // if removing one of the hits gives a much smaller chi2, it should be
    // removed, so find the position where the "local chi2" is the smallest, and
    // this is the hit that should be removed (since it gave a big
    // contribution)]
 
    // find minimum local chi2
    int position = std::distance(
        chi2_contributions.begin(),
        std::min_element(chi2_contributions.begin(), chi2_contributions.end()));
 
    // and remove it from the hits
    time_candidates_copy.erase(time_candidates_copy.begin() + position);
 
    // recompute chi2 value
    chi2 = calculateChi2(time_candidates_copy);
 
    // check for accepted chi2
    if (chi2 < m_chi2_threshold) {
      // if the threshold is now fulfilled, break out of the while loop
      searching = false;
    }
    // if everything except 2 values has been removed, check again for
    // consistency
    if (time_candidates_copy.size() == 2) {
 
      if (passesDeltaT(time_candidates_copy)) {
        return time_candidates_copy;
      } else {
        // if times are too far away, don't accept any TODO maybe accept one,
        // can the spatial chi2 be used?
        return {};
      }
    }
  }
 
  return time_candidates_copy;
}

getValidHits()

std::vector< ExpertTrackTimeFromClustersTool::Hit > ExpertTrackTimeFromClustersTool::getValidHits ( const xAOD::TrackParticle & track_particle ) const

private

Retrieve the hit information from the decorators and build a vector of hits.

Definition at line 269 of file ExpertTrackTimeFromClustersTool.cxx.

                                                   {
 
  const std::vector<float>& times = m_acc_perLayer_clusterTime(track_particle);
  const std::vector<bool>& has_clusters =
      m_acc_perLayer_hasCluster(track_particle);
  const std::vector<int>& hit_classification =
      m_acc_perLayer_clusterTruthClass(track_particle);
 
  HitVec_t valid_hits;
  valid_hits.reserve(4);
 
  for (size_t i = 0; i < has_clusters.size(); i++) {
    if (not has_clusters.at(i)) {
      continue;
    }
    Hit newhit;
    newhit.time = times.at(i);
    newhit.resolution = 0.035; // nano seconds
    newhit.isprime = hit_classification.at(i) == 1;
 
    valid_hits.push_back(newhit);
  }
  return valid_hits;
}

initialize()

StatusCode ExpertTrackTimeFromClustersTool::initialize ( )

finaloverridevirtual

Definition at line 24 of file ExpertTrackTimeFromClustersTool.cxx.

                                                       {
  ATH_CHECK(AthAlgTool::initialize());
 
  m_dec_isset = std::make_unique<SG::AuxElement::Decorator<bool>>(
      m_dec_prefix + "_isset");
  m_dec_hastime = std::make_unique<SG::AuxElement::Decorator<bool>>(
      m_dec_prefix + "_hastime");
  m_dec_time = std::make_unique<SG::AuxElement::Decorator<float>>(
      m_dec_prefix + "_time");
  m_dec_nhits = std::make_unique<SG::AuxElement::Decorator<int>>(
      m_dec_prefix + "_nhits");
  m_dec_nprimehits = std::make_unique<SG::AuxElement::Decorator<int>>(
      m_dec_prefix + "_nprimehits");
  m_dec_resolution = std::make_unique<SG::AuxElement::Decorator<float>>(
      m_dec_prefix + "_resolution");
 
  m_acc_isset =
      std::make_unique<SG::ConstAccessor<bool>>(m_dec_prefix + "_isset");
  m_acc_hastime =
      std::make_unique<SG::ConstAccessor<bool>>(m_dec_prefix + "_hastime");
  m_acc_time =
      std::make_unique<SG::ConstAccessor<float>>(m_dec_prefix + "_time");
  m_acc_nhits =
      std::make_unique<SG::ConstAccessor<int>>(m_dec_prefix + "_nhits");
  m_acc_nprimehits =
      std::make_unique<SG::ConstAccessor<int>>(m_dec_prefix + "_nprimehits");
  m_acc_resolution =
      std::make_unique<SG::ConstAccessor<float>>(m_dec_prefix + "_resolution");
 
  return StatusCode::SUCCESS;
}

lastHitIsOnLastSurface()

bool ExpertTrackTimeFromClustersTool::lastHitIsOnLastSurface ( const xAOD::TrackParticle & track ) const

private

Check wheather the last hit on track is on a surface close to HGTD.

The hardcoded values correspond to ITk Step3.1 layout and define where in z and r the last hit position is accepted as close enough to HGTD.

Definition at line 295 of file ExpertTrackTimeFromClustersTool.cxx.

                                          {
 
  TVector3 last_hit = this->getLastMeasurement(track);
  double radius = std::hypot(last_hit.X(), last_hit.Y());
  double abs_z = std::abs(last_hit.Z());
 
  // 21.9 numbers
  bool is_last = abs_z > 2700;
  is_last = is_last || (radius < 350 and abs_z > 2400);
  is_last = is_last || (radius > 205 and radius < 350 and abs_z > 2100);
  is_last = is_last || (radius < 220 and abs_z > 2200);
  is_last = is_last || (radius < 140 and abs_z > 1890);
  return is_last;
}

nHits()

int ExpertTrackTimeFromClustersTool::nHits ( const xAOD::TrackParticle & track_particle ) const

private

Number of hits that were used to build the track time.

Kept private on purpose: a caller that needs it should declare the dependency on the decoration itself, e.g. SG::ConstAccessor<int> nhit_acc(<toolname> + "_nhits");

Definition at line 134 of file ExpertTrackTimeFromClustersTool.cxx.

                                                   {
  if (m_acc_nhits->isAvailable(track_particle) and
      m_acc_isset->operator()(track_particle)) {
    return m_acc_nhits->operator()(track_particle);
  } else {
    throw std::runtime_error(
        "[ExpertTrackTimeFromClustersTool::nHits] ERROR, always call "
        "expertHasTime on a track fist!");
  }
}

nPrimaryHits()

int ExpertTrackTimeFromClustersTool::nPrimaryHits ( const xAOD::TrackParticle & track_particle ) const

private

Number of hits used for the track time that were left by a primary particle.

Private for the same reason as nHits.

Definition at line 322 of file ExpertTrackTimeFromClustersTool.cxx.

                                                   {
  if (m_acc_nprimehits->isAvailable(track_particle) and
      m_acc_isset->operator()(track_particle)) {
    return m_acc_nprimehits->operator()(track_particle);
  } else {
    return 0;
  }
}

numberOfPrimaryHits()

int ExpertTrackTimeFromClustersTool::numberOfPrimaryHits ( const HitVec_t & vals ) const

private

Definition at line 311 of file ExpertTrackTimeFromClustersTool.cxx.

                                {
  int n = 0;
  for (const Hit& hit : hits) {
    if (hit.isprime) {
      n++;
    }
  }
  return n;
}

numberPotentialPrimaryHits()

int ExpertTrackTimeFromClustersTool::numberPotentialPrimaryHits ( const xAOD::TrackParticle & track_particle ) const

finaloverridevirtual

Definition at line 370 of file ExpertTrackTimeFromClustersTool.cxx.

                                                   {
  const std::vector<bool>& expected_hits =
      m_acc_perLayer_expectCluster(track_particle);
  return std::count(expected_hits.begin(), expected_hits.end(), true);
}

passesDeltaT()

bool ExpertTrackTimeFromClustersTool::passesDeltaT ( const HitVec_t & hits ) const

private

Tests if a given set of exactly 2 Hit objects passes the set time difference cut, which is defined in units of the combined resolution.

Definition at line 232 of file ExpertTrackTimeFromClustersTool.cxx.

                                                                             {
  // WARNING I don't check it here, but the vector has to be of size 2!!!
  // pass if the distance in units of the resolution passes the cut
  if (std::abs(hits.at(0).time - hits.at(1).time) <
      m_deltat_cut * std::hypot(hits.at(0).resolution, hits.at(1).resolution)) {
    return true;
  }
  return false;
}

Member Data Documentation

m_acc_hastime

std::unique_ptr<SG::ConstAccessor<bool> > HGTD::ExpertTrackTimeFromClustersTool::m_acc_hastime

private

Definition at line 168 of file ExpertTrackTimeFromClustersTool.h.

m_acc_isset

std::unique_ptr<SG::ConstAccessor<bool> > HGTD::ExpertTrackTimeFromClustersTool::m_acc_isset

private

Definition at line 167 of file ExpertTrackTimeFromClustersTool.h.

m_acc_nhits

std::unique_ptr<SG::ConstAccessor<int> > HGTD::ExpertTrackTimeFromClustersTool::m_acc_nhits

private

Definition at line 170 of file ExpertTrackTimeFromClustersTool.h.

m_acc_nprimehits

std::unique_ptr<SG::ConstAccessor<int> > HGTD::ExpertTrackTimeFromClustersTool::m_acc_nprimehits

private

Definition at line 171 of file ExpertTrackTimeFromClustersTool.h.

m_acc_perLayer_clusterTime

SG::ConstAccessor<std::vector<float> > HGTD::ExpertTrackTimeFromClustersTool::m_acc_perLayer_clusterTime

private

Initial value:

{
      "HGTD_cluster_time"}

Definition at line 178 of file ExpertTrackTimeFromClustersTool.h.

                                                              {
      "HGTD_cluster_time"};

m_acc_perLayer_clusterTruthClass

SG::ConstAccessor<std::vector<int> > HGTD::ExpertTrackTimeFromClustersTool::m_acc_perLayer_clusterTruthClass

private

Initial value:

{
      "HGTD_cluster_truth_class"}

Definition at line 180 of file ExpertTrackTimeFromClustersTool.h.

                                                                  {
      "HGTD_cluster_truth_class"};

m_acc_perLayer_expectCluster

SG::ConstAccessor<std::vector<bool> > HGTD::ExpertTrackTimeFromClustersTool::m_acc_perLayer_expectCluster

private

Initial value:

{
      "HGTD_primary_expected"}

Definition at line 182 of file ExpertTrackTimeFromClustersTool.h.

                                                               {
      "HGTD_primary_expected"};

m_acc_perLayer_hasCluster

SG::ConstAccessor<std::vector<bool> > HGTD::ExpertTrackTimeFromClustersTool::m_acc_perLayer_hasCluster

private

Initial value:

{
      "HGTD_has_extension"}

Input decorations produced by the HGTD track extension, read with fixed names.

Definition at line 176 of file ExpertTrackTimeFromClustersTool.h.

                                                            {
      "HGTD_has_extension"};

m_acc_resolution

std::unique_ptr<SG::ConstAccessor<float> > HGTD::ExpertTrackTimeFromClustersTool::m_acc_resolution

private

Definition at line 172 of file ExpertTrackTimeFromClustersTool.h.

m_acc_time

std::unique_ptr<SG::ConstAccessor<float> > HGTD::ExpertTrackTimeFromClustersTool::m_acc_time

private

Definition at line 169 of file ExpertTrackTimeFromClustersTool.h.

m_chi2_threshold

Gaudi::Property<float> HGTD::ExpertTrackTimeFromClustersTool::m_chi2_threshold

private

Initial value:

{this, "TimeChi2Cut", 1.5,
                                          "Default value"}

Definition at line 145 of file ExpertTrackTimeFromClustersTool.h.

                                       {this, "TimeChi2Cut", 1.5,
                                          "Default value"};

m_dec_hastime

std::unique_ptr<SG::AuxElement::Decorator<bool> > HGTD::ExpertTrackTimeFromClustersTool::m_dec_hastime

private

Definition at line 161 of file ExpertTrackTimeFromClustersTool.h.

m_dec_isset

std::unique_ptr<SG::AuxElement::Decorator<bool> > HGTD::ExpertTrackTimeFromClustersTool::m_dec_isset

private

Definition at line 160 of file ExpertTrackTimeFromClustersTool.h.

m_dec_nhits

std::unique_ptr<SG::AuxElement::Decorator<int> > HGTD::ExpertTrackTimeFromClustersTool::m_dec_nhits

private

Definition at line 163 of file ExpertTrackTimeFromClustersTool.h.

m_dec_nprimehits

std::unique_ptr<SG::AuxElement::Decorator<int> > HGTD::ExpertTrackTimeFromClustersTool::m_dec_nprimehits

private

Definition at line 164 of file ExpertTrackTimeFromClustersTool.h.

m_dec_prefix

std::string HGTD::ExpertTrackTimeFromClustersTool::m_dec_prefix

private

Prefix of the decorations this tool writes.

It is the tool instance name with '.' replaced by '_', since aux variable names may not contain a '.' (the instance name of a private tool does, e.g. HGTD_TrkTimePerformanceStudies.ExpertTrackTimeFromClusters).

Definition at line 158 of file ExpertTrackTimeFromClustersTool.h.

m_dec_resolution

std::unique_ptr<SG::AuxElement::Decorator<float> > HGTD::ExpertTrackTimeFromClustersTool::m_dec_resolution

private

Definition at line 165 of file ExpertTrackTimeFromClustersTool.h.

m_dec_time

std::unique_ptr<SG::AuxElement::Decorator<float> > HGTD::ExpertTrackTimeFromClustersTool::m_dec_time

private

Definition at line 162 of file ExpertTrackTimeFromClustersTool.h.

m_deltat_cut

Gaudi::Property<float> HGTD::ExpertTrackTimeFromClustersTool::m_deltat_cut {this, "DeltaTCut", 2.0, "Default value"}

private

Definition at line 144 of file ExpertTrackTimeFromClustersTool.h.

{this, "DeltaTCut", 2.0, "Default value"};

m_do_last_hit

Gaudi::Property<bool> HGTD::ExpertTrackTimeFromClustersTool::m_do_last_hit

private

Initial value:

{this, "UseLastHitCut", true,
                                      "Default value"}

Definition at line 140 of file ExpertTrackTimeFromClustersTool.h.

                                   {this, "UseLastHitCut", true,
                                      "Default value"};

m_do_min_nhits

Gaudi::Property<bool> HGTD::ExpertTrackTimeFromClustersTool::m_do_min_nhits

private

Initial value:

{this, "UseMinNHits", true,
                                       "Default value"}

Definition at line 147 of file ExpertTrackTimeFromClustersTool.h.

                                    {this, "UseMinNHits", true,
                                       "Default value"};

m_do_smearing

Gaudi::Property<bool> HGTD::ExpertTrackTimeFromClustersTool::m_do_smearing

private

Initial value:

{this, "DoSmearing", false,
                                      "Default value"}

Definition at line 151 of file ExpertTrackTimeFromClustersTool.h.

                                   {this, "DoSmearing", false,
                                      "Default value"};

m_do_time_cons

Gaudi::Property<bool> HGTD::ExpertTrackTimeFromClustersTool::m_do_time_cons

private

Initial value:

{this, "UseTimeConsistency", true,
                                       "Default value"}

Definition at line 142 of file ExpertTrackTimeFromClustersTool.h.

                                    {this, "UseTimeConsistency", true,
                                       "Default value"};

m_max_eta

Gaudi::Property<float> HGTD::ExpertTrackTimeFromClustersTool::m_max_eta {this, "MaxEta", 3.9, "Default value"}

private

Definition at line 150 of file ExpertTrackTimeFromClustersTool.h.

{this, "MaxEta", 3.9, "Default value"};

m_min_eta

Gaudi::Property<float> HGTD::ExpertTrackTimeFromClustersTool::m_min_eta {this, "MinEta", 3.5, "Default value"}

private

Definition at line 149 of file ExpertTrackTimeFromClustersTool.h.

{this, "MinEta", 3.5, "Default value"};

---

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

• ExpertTrackTimeFromClustersTool.h
• ExpertTrackTimeFromClustersTool.cxx