#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

template<typename TRACK_TYPE, typename HIT_TYPE>

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

protected

Definition at line 67 of file CTPPSTimingTrackRecognition.h.

template<typename TRACK_TYPE, typename HIT_TYPE>

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

protected

Definition at line 68 of file CTPPSTimingTrackRecognition.h.

template<typename TRACK_TYPE, typename HIT_TYPE>

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

protected

Definition at line 66 of file CTPPSTimingTrackRecognition.h.

Constructor & Destructor Documentation

template<typename TRACK_TYPE, typename HIT_TYPE>

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

inline

Definition at line 34 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.";
     }

template<typename TRACK_TYPE, typename HIT_TYPE>

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

virtualdefault

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

Member Function Documentation

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.

Referenced by CTPPSTimingTrackRecognition< CTPPSDiamondLocalTrack, CTPPSDiamondRecHit >::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 51 of file CTPPSTimingTrackRecognition.h.

Referenced by CTPPSDiamondTrackRecognition::clear().

51 { hitVectorMap_.clear(); }

CTPPSTimingTrackRecognition::hitVectorMap_

HitVectorMap hitVectorMap_

RecHit vectors that should be processed separately while reconstructing tracks.

Definition: CTPPSTimingTrackRecognition.h:71

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.

References SiStripPI::max, min(), mps_fire::result, CTPPSTimingTrackRecognition< TRACK_TYPE, HIT_TYPE >::SpatialRange::xBegin, CTPPSTimingTrackRecognition< TRACK_TYPE, HIT_TYPE >::SpatialRange::xEnd, CTPPSTimingTrackRecognition< TRACK_TYPE, HIT_TYPE >::SpatialRange::yBegin, CTPPSTimingTrackRecognition< TRACK_TYPE, HIT_TYPE >::SpatialRange::yEnd, CTPPSTimingTrackRecognition< TRACK_TYPE, HIT_TYPE >::SpatialRange::zBegin, and CTPPSTimingTrackRecognition< TRACK_TYPE, HIT_TYPE >::SpatialRange::zEnd.

 {
   bool initialized = false;
   SpatialRange result;
 
   for (const auto& hit : hits) {
     const float xBegin = hit.getX() - 0.5f*hit.getXWidth(), xEnd = hit.getX() + 0.5f*hit.getXWidth();
     const float yBegin = hit.getY() - 0.5f*hit.getYWidth(), yEnd = hit.getY() + 0.5f*hit.getYWidth();
     const float zBegin = hit.getZ() - 0.5f*hit.getZWidth(), zEnd = hit.getZ() + 0.5f*hit.getZWidth();
 
     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;
 }

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.

References reco::FormulaEvaluator::evaluate(), f, mps_fire::i, CTPPSTimingTrackRecognition< TRACK_TYPE, HIT_TYPE >::DimensionParameters::rangeBegin, CTPPSTimingTrackRecognition< TRACK_TYPE, HIT_TYPE >::DimensionParameters::rangeEnd, CTPPSTimingTrackRecognition< TRACK_TYPE, HIT_TYPE >::resolution_, CTPPSTimingTrackRecognition< TRACK_TYPE, HIT_TYPE >::thresholdFromMaximum_, and HiIsolationCommonParameters_cff::track.

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

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.

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

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 231 of file CTPPSTimingTrackRecognition.h.

References f, funct::pow(), mathSSE::sqrt(), and mps_merge::weight.

 {
   float mean_num = 0.f, mean_denom = 0.f;
   bool valid_hits = false;
   for (const auto& hit : hits) {
     if (hit.getTPrecision() <= 0.)
       continue;
     const float weight = std::pow(hit.getTPrecision(), -2);
     mean_num += weight*hit.getT();
     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;
 }