CTPPSTimingTrackRecognition< TRACK_TYPE, HIT_TYPE > Class Template Reference

#include <CTPPSTimingTrackRecognition.h>

Classes
struct	DimensionParameters
struct	SpatialRange
	Structure representing a 3D range in space. More...

Public Member Functions
virtual void	addHit (const HIT_TYPE &recHit)=0
	Add new hit to the set from which the tracks are reconstructed. More...
virtual void	clear ()
	Reset internal state of a class instance. More...
	CTPPSTimingTrackRecognition (const edm::ParameterSet &iConfig)
virtual int	produceTracks (edm::DetSet< TRACK_TYPE > &tracks)=0
	Produce a collection of tracks, given its hits collection. More...
virtual	~CTPPSTimingTrackRecognition ()=default

Protected Types
typedef std::vector< HIT_TYPE >	HitVector
typedef std::unordered_map< int, HitVector >	HitVectorMap
typedef std::vector< TRACK_TYPE >	TrackVector

Protected Member Functions
SpatialRange	getHitSpatialRange (const HitVector &hits)
void	producePartialTracks (const HitVector &hits, const DimensionParameters &param, float(*getHitCenter)(const HIT_TYPE &), float(*getHitRangeWidth)(const HIT_TYPE &), void(*setTrackCenter)(TRACK_TYPE &, float), void(*setTrackSigma)(TRACK_TYPE &, float), TrackVector &result)
bool	timeEval (const HitVector &hits, float &meanTime, float &timeSigma) const

Protected Attributes
HitVectorMap	hitVectorMap_
	RecHit vectors that should be processed separately while reconstructing tracks. More...
reco::FormulaEvaluator	pixelEfficiencyFunction_
const float	resolution_
const float	sigma_
const float	threshold_
const float	thresholdFromMaximum_
const float	tolerance_

Detailed Description

template<typename TRACK_TYPE, typename HIT_TYPE>
class CTPPSTimingTrackRecognition< TRACK_TYPE, HIT_TYPE >

Class intended to perform general CTPPS timing detectors track recognition, as well as construction of specialized classes (for now CTPPSDiamond and TotemTiming local tracks).

Definition at line 31 of file CTPPSTimingTrackRecognition.h.

Member Typedef Documentation

HitVector

template<typename TRACK_TYPE, typename HIT_TYPE>

typedef std::vector<HIT_TYPE> CTPPSTimingTrackRecognition< TRACK_TYPE, HIT_TYPE >::HitVector

protected

Definition at line 66 of file CTPPSTimingTrackRecognition.h.

HitVectorMap

template<typename TRACK_TYPE, typename HIT_TYPE>

typedef std::unordered_map<int, HitVector> CTPPSTimingTrackRecognition< TRACK_TYPE, HIT_TYPE >::HitVectorMap

protected

Definition at line 67 of file CTPPSTimingTrackRecognition.h.

TrackVector

template<typename TRACK_TYPE, typename HIT_TYPE>

typedef std::vector<TRACK_TYPE> CTPPSTimingTrackRecognition< TRACK_TYPE, HIT_TYPE >::TrackVector

protected

Definition at line 65 of file CTPPSTimingTrackRecognition.h.

Constructor & Destructor Documentation

CTPPSTimingTrackRecognition()

template<typename TRACK_TYPE, typename HIT_TYPE>

CTPPSTimingTrackRecognition< TRACK_TYPE, HIT_TYPE >::CTPPSTimingTrackRecognition ( const edm::ParameterSet &  iConfig )

inline

Definition at line 33 of file CTPPSTimingTrackRecognition.h.

      : threshold_(iConfig.getParameter<double>("threshold")),
        thresholdFromMaximum_(iConfig.getParameter<double>("thresholdFromMaximum")),
        resolution_(iConfig.getParameter<double>("resolution")),
        sigma_(iConfig.getParameter<double>("sigma")),
        tolerance_(iConfig.getParameter<double>("tolerance")),
        pixelEfficiencyFunction_(iConfig.getParameter<std::string>("pixelEfficiencyFunction")) {
    if (pixelEfficiencyFunction_.numberOfParameters() != 3)
      throw cms::Exception("CTPPSTimingTrackRecognition")
          << "Invalid number of parameters to the pixel efficiency function! "
          << pixelEfficiencyFunction_.numberOfParameters() << " != 3.";
  }

~CTPPSTimingTrackRecognition()

template<typename TRACK_TYPE, typename HIT_TYPE>

virtual CTPPSTimingTrackRecognition< TRACK_TYPE, HIT_TYPE >::~CTPPSTimingTrackRecognition ( )

virtualdefault

Member Function Documentation

addHit()

template<typename TRACK_TYPE, typename HIT_TYPE>

virtual void CTPPSTimingTrackRecognition< TRACK_TYPE, HIT_TYPE >::addHit ( const HIT_TYPE &  recHit )

pure virtual

Add new hit to the set from which the tracks are reconstructed.

Implemented in CTPPSDiamondTrackRecognition, and TotemTimingTrackRecognition.

clear()

template<typename TRACK_TYPE, typename HIT_TYPE>

virtual void CTPPSTimingTrackRecognition< TRACK_TYPE, HIT_TYPE >::clear ( void  )

inlinevirtual

Reset internal state of a class instance.

Reimplemented in CTPPSDiamondTrackRecognition.

Definition at line 50 of file CTPPSTimingTrackRecognition.h.

Referenced by CTPPSDiamondTrackRecognition::clear().

{ hitVectorMap_.clear(); }

getHitSpatialRange()

template<class TRACK_TYPE , class HIT_TYPE >

CTPPSTimingTrackRecognition< TRACK_TYPE, HIT_TYPE >::SpatialRange CTPPSTimingTrackRecognition< TRACK_TYPE, HIT_TYPE >::getHitSpatialRange ( const HitVector &  hits )

inlineprotected

Retrieve the bounds of a 3D range in which all hits from given collection are contained.

Parameters

[in]

hits

hits collection to retrieve the range from

Definition at line 198 of file CTPPSTimingTrackRecognition.h.

                                                                                           {
  bool initialized = false;
  SpatialRange result = {};

  for (const auto& hit : hits) {
    const float xBegin = hit.x() - 0.5f * hit.xWidth(), xEnd = hit.x() + 0.5f * hit.xWidth();
    const float yBegin = hit.y() - 0.5f * hit.yWidth(), yEnd = hit.y() + 0.5f * hit.yWidth();
    const float zBegin = hit.z() - 0.5f * hit.zWidth(), zEnd = hit.z() + 0.5f * hit.zWidth();

    if (!initialized) {
      result.xBegin = xBegin;
      result.xEnd = xEnd;
      result.yBegin = yBegin;
      result.yEnd = yEnd;
      result.zBegin = zBegin;
      result.zEnd = zEnd;
      initialized = true;
      continue;
    }
    result.xBegin = std::min(result.xBegin, xBegin);
    result.xEnd = std::max(result.xEnd, xEnd);
    result.yBegin = std::min(result.yBegin, yBegin);
    result.yEnd = std::max(result.yEnd, yEnd);
    result.zBegin = std::min(result.zBegin, zBegin);
    result.zEnd = std::max(result.zEnd, zEnd);
  }

  return result;
}

producePartialTracks()

template<class TRACK_TYPE, class HIT_TYPE>

void CTPPSTimingTrackRecognition< TRACK_TYPE, HIT_TYPE >::producePartialTracks ( const HitVector &  hits, const DimensionParameters &  param, float(*)(const HIT_TYPE &)  getHitCenter, float(*)(const HIT_TYPE &)  getHitRangeWidth, void(*)(TRACK_TYPE &, float)  setTrackCenter, void(*)(TRACK_TYPE &, float)  setTrackSigma, TrackVector &  result  )

inlineprotected

Produce all partial tracks from given set with regard to single dimension.

Parameters

[in]	hits	vector of hits from which the tracks are created
[in]	param	describe all parameters used by 1D track recognition algorithm
[in]	getHitCenter	function extracting hit's center in the dimension that the partial tracks relate to
[in]	getHitRangeWidth	analogue to getHitCenter, but extracts hit's width in specific dimension
[in]	setTrackCenter	function used to set track's position in considered dimension
[in]	setTrackSigma	function used to set track's sigma in considered dimension
[out]	result	vector to which produced tracks are appended

Definition at line 119 of file CTPPSTimingTrackRecognition.h.

                         {
  int numberOfTracks = 0;
  const float invResolution = 1. / resolution_;
  const float profileRangeMargin = sigma_ * 3.;
  const float profileRangeBegin = param.rangeBegin - profileRangeMargin;
  const float profileRangeEnd = param.rangeEnd + profileRangeMargin;

  std::vector<float> hitProfile((profileRangeEnd - profileRangeBegin) * invResolution + 1, 0.);
  // extra component to make sure that the profile drops below the threshold at range's end
  *hitProfile.rbegin() = -1.f;

  // Creates hit profile
  for (auto const& hit : hits) {
    const float center = getHitCenter(hit), rangeWidth = getHitRangeWidth(hit);
    std::vector<double> params{center, rangeWidth, sigma_};
    for (unsigned int i = 0; i < hitProfile.size(); ++i)
      hitProfile[i] +=
          pixelEfficiencyFunction_.evaluate(std::vector<double>{profileRangeBegin + i * resolution_}, params);
  }

  bool underThreshold = true;
  float rangeMaximum = -1.0f;
  bool trackRangeFound = false;
  int trackRangeBegin = 0, trackRangeEnd = 0;

  // Searches for tracks in the hit profile
  for (unsigned int i = 0; i < hitProfile.size(); i++) {
    if (hitProfile[i] > rangeMaximum)
      rangeMaximum = hitProfile[i];

    // Going above the threshold
    if (underThreshold && hitProfile[i] > threshold_) {
      underThreshold = false;
      trackRangeBegin = i;
      rangeMaximum = hitProfile[i];
    }

    // Going under the threshold
    else if (!underThreshold && hitProfile[i] <= threshold_) {
      underThreshold = true;
      trackRangeEnd = i;
      trackRangeFound = true;
    }

    // Finds all tracks within the track range
    if (trackRangeFound) {
      float trackThreshold = rangeMaximum - thresholdFromMaximum_;
      int trackBegin;
      bool underTrackThreshold = true;

      for (int j = trackRangeBegin; j <= trackRangeEnd; j++) {
        if (underTrackThreshold && hitProfile[j] > trackThreshold) {
          underTrackThreshold = false;
          trackBegin = j;
        } else if (!underTrackThreshold && hitProfile[j] <= trackThreshold) {
          underTrackThreshold = true;
          TRACK_TYPE track;
          float leftMargin = profileRangeBegin + resolution_ * trackBegin;
          float rightMargin = profileRangeBegin + resolution_ * j;
          setTrackCenter(track, 0.5f * (leftMargin + rightMargin));
          setTrackSigma(track, 0.5f * (rightMargin - leftMargin));
          result.push_back(track);
          numberOfTracks++;
        }
      }
      trackRangeFound = false;
    }
  }
}

produceTracks()

template<typename TRACK_TYPE, typename HIT_TYPE>

virtual int CTPPSTimingTrackRecognition< TRACK_TYPE, HIT_TYPE >::produceTracks ( edm::DetSet< TRACK_TYPE > &  tracks )

pure virtual

Produce a collection of tracks, given its hits collection.

Implemented in CTPPSDiamondTrackRecognition, and TotemTimingTrackRecognition.

timeEval()

template<class TRACK_TYPE , class HIT_TYPE >

bool CTPPSTimingTrackRecognition< TRACK_TYPE, HIT_TYPE >::timeEval ( const HitVector &  hits, float &  meanTime, float &  timeSigma  ) const

inlineprotected

Evaluate the time + associated uncertainty for a given track

Note

General remarks:

• track's time = weighted mean of all hit times with time precision as weight,
• track's time sigma = uncertainty of the weighted mean
• hit is ignored if the time precision is equal to 0

Definition at line 229 of file CTPPSTimingTrackRecognition.h.

                                                                                                 {
  float mean_num = 0.f, mean_denom = 0.f;
  bool valid_hits = false;
  for (const auto& hit : hits) {
    if (hit.tPrecision() <= 0.)
      continue;
    const float weight = std::pow(hit.tPrecision(), -2);
    mean_num += weight * hit.time();
    mean_denom += weight;
    valid_hits = true;  // at least one valid hit to account for
  }
  mean_time = valid_hits ? (mean_num / mean_denom) : 0.f;
  time_sigma = valid_hits ? std::sqrt(1.f / mean_denom) : 0.f;
  return valid_hits;
}

Member Data Documentation

hitVectorMap_

template<typename TRACK_TYPE, typename HIT_TYPE>

HitVectorMap CTPPSTimingTrackRecognition< TRACK_TYPE, HIT_TYPE >::hitVectorMap_

protected

RecHit vectors that should be processed separately while reconstructing tracks.

Definition at line 70 of file CTPPSTimingTrackRecognition.h.

Referenced by CTPPSTimingTrackRecognition< CTPPSDiamondLocalTrack, CTPPSDiamondRecHit >::clear().

pixelEfficiencyFunction_

template<typename TRACK_TYPE, typename HIT_TYPE>

reco::FormulaEvaluator CTPPSTimingTrackRecognition< TRACK_TYPE, HIT_TYPE >::pixelEfficiencyFunction_

protected

Definition at line 63 of file CTPPSTimingTrackRecognition.h.

Referenced by CTPPSTimingTrackRecognition< CTPPSDiamondLocalTrack, CTPPSDiamondRecHit >::CTPPSTimingTrackRecognition().

resolution_

template<typename TRACK_TYPE, typename HIT_TYPE>

const float CTPPSTimingTrackRecognition< TRACK_TYPE, HIT_TYPE >::resolution_

protected

Definition at line 60 of file CTPPSTimingTrackRecognition.h.

sigma_

template<typename TRACK_TYPE, typename HIT_TYPE>

const float CTPPSTimingTrackRecognition< TRACK_TYPE, HIT_TYPE >::sigma_

protected

Definition at line 61 of file CTPPSTimingTrackRecognition.h.

threshold_

template<typename TRACK_TYPE, typename HIT_TYPE>

const float CTPPSTimingTrackRecognition< TRACK_TYPE, HIT_TYPE >::threshold_

protected

Definition at line 58 of file CTPPSTimingTrackRecognition.h.

thresholdFromMaximum_

template<typename TRACK_TYPE, typename HIT_TYPE>

const float CTPPSTimingTrackRecognition< TRACK_TYPE, HIT_TYPE >::thresholdFromMaximum_

protected

Definition at line 59 of file CTPPSTimingTrackRecognition.h.

tolerance_

template<typename TRACK_TYPE, typename HIT_TYPE>

const float CTPPSTimingTrackRecognition< TRACK_TYPE, HIT_TYPE >::tolerance_

protected

Definition at line 62 of file CTPPSTimingTrackRecognition.h.