Class performing smart reconstruction for CTPPS Diamond Detectors. More...

#include <CTPPSDiamondTrackRecognition.h>

Classes
struct	HitParameters

Public Member Functions
void	addHit (const CTPPSDiamondRecHit &recHit)
	Feed a new hit to the tracks recognition algorithm. More...

void	clear ()
	Reset the list of hits. More...

	CTPPSDiamondTrackRecognition (const edm::ParameterSet &)

int	produceTracks (edm::DetSet< CTPPSDiamondLocalTrack > &tracks)
	Produce a collection of tracks for the current station, given its hits collection. More...

	~CTPPSDiamondTrackRecognition ()

Private Types
typedef std::vector< HitParameters >	HitParametersVector

typedef std::unordered_map< int, HitParametersVector >	HitParametersVectorMap

Private Attributes
TF1	hit_f_
	Function for pad efficiency. More...

HitParametersVectorMap	hitParametersVectorMap_

std::unordered_map< int, int >	mhMap_

const float	resolution_

const float	sigma_

const float	startFromX_

const float	stopAtX_

const float	threshold_

const float	thresholdFromMaximum_

float	yPosition_

float	yPositionInitial_

float	yWidth_

float	yWidthInitial_

Static Private Attributes
static const std::string	pixelEfficiencyDefaultFunction_ = "(x>[0]-0.5[1])(x<[0]+0.5*[1])"
	Default hit function accounting for the pad spatial efficiency. More...

Detailed Description

Class performing smart reconstruction for CTPPS Diamond Detectors.

Date: Jan 2017

Definition at line 29 of file CTPPSDiamondTrackRecognition.h.

Member Typedef Documentation

typedef std::vector<HitParameters> CTPPSDiamondTrackRecognition::HitParametersVector

private

Definition at line 51 of file CTPPSDiamondTrackRecognition.h.

typedef std::unordered_map<int,HitParametersVector> CTPPSDiamondTrackRecognition::HitParametersVectorMap

private

Definition at line 52 of file CTPPSDiamondTrackRecognition.h.

Constructor & Destructor Documentation

CTPPSDiamondTrackRecognition::CTPPSDiamondTrackRecognition ( const edm::ParameterSet & iConfig )

Definition at line 20 of file CTPPSDiamondTrackRecognition.cc.

References hit_f_, pixelEfficiencyDefaultFunction_, sigma_, startFromX_, and stopAtX_.

                                                                                            :
   threshold_           ( iConfig.getParameter<double>( "threshold" ) ),
   thresholdFromMaximum_( iConfig.getParameter<double>( "thresholdFromMaximum" ) ),
   resolution_          ( iConfig.getParameter<double>( "resolution" ) ),
   sigma_               ( iConfig.getParameter<double>( "sigma" ) ),
   startFromX_          ( iConfig.getParameter<double>( "startFromX" ) ),
   stopAtX_             ( iConfig.getParameter<double>( "stopAtX" ) ),
   yPositionInitial_    ( iConfig.getParameter<double>( "yPosition" ) ),
   yWidthInitial_       ( iConfig.getParameter<double>( "yWidth" ) ),
   hit_f_( "hit_TF1_CTPPS", iConfig.getParameter<std::string>( "pixelEfficiencyFunction" ).c_str(), startFromX_, stopAtX_ )
 {
   if (sigma_==0.0) {
     hit_f_ = TF1( "hit_TF1_CTPPS", pixelEfficiencyDefaultFunction_.c_str(), startFromX_, stopAtX_ ); // simple step function
   }
 }

CTPPSDiamondTrackRecognition::~CTPPSDiamondTrackRecognition ( )

Definition at line 38 of file CTPPSDiamondTrackRecognition.cc.

39 {}

Member Function Documentation

void CTPPSDiamondTrackRecognition::addHit ( const CTPPSDiamondRecHit & recHit )

Feed a new hit to the tracks recognition algorithm.

Definition at line 55 of file CTPPSDiamondTrackRecognition.cc.

References CTPPSDiamondRecHit::getMultipleHits(), CTPPSDiamondRecHit::getOOTIndex(), CTPPSDiamondRecHit::getX(), CTPPSDiamondRecHit::getXWidth(), CTPPSDiamondRecHit::getY(), CTPPSDiamondRecHit::getYWidth(), hitParametersVectorMap_, mhMap_, yPosition_, yPositionInitial_, yWidth_, and yWidthInitial_.

Referenced by CTPPSDiamondLocalTrackFitter::produce().

 {
   // store hit parameters
   hitParametersVectorMap_[recHit.getOOTIndex()].emplace_back( recHit.getX(), recHit.getXWidth() );
 
   // Check vertical coordinates
   if ( yPosition_ == yPositionInitial_ and yWidth_ == yWidthInitial_ ) {
     yPosition_ = recHit.getY();
     yWidth_ = recHit.getYWidth();
   }
 
   //Multiple hits in the RP
   if ( recHit.getMultipleHits() ) {
     if ( mhMap_.find( recHit.getOOTIndex() ) == mhMap_.end() ) {
       mhMap_[recHit.getOOTIndex()] = 1;
     }
     else {
       ++( mhMap_[recHit.getOOTIndex()] );
     }
   }
 }

void CTPPSDiamondTrackRecognition::clear ( void )

Reset the list of hits.

Definition at line 44 of file CTPPSDiamondTrackRecognition.cc.

References hitParametersVectorMap_, mhMap_, yPosition_, yPositionInitial_, yWidth_, and yWidthInitial_.

Referenced by CTPPSDiamondLocalTrackFitter::produce().

 {
   hitParametersVectorMap_.clear();
   mhMap_.clear();
   yPosition_ = yPositionInitial_;
   yWidth_ = yWidthInitial_;
 }

int CTPPSDiamondTrackRecognition::produceTracks ( edm::DetSet< CTPPSDiamondLocalTrack > & tracks )

Produce a collection of tracks for the current station, given its hits collection.

Definition at line 80 of file CTPPSDiamondTrackRecognition.cc.

References hit_f_, hitParametersVectorMap_, mps_fire::i, mhMap_, edm::DetSet< T >::push_back(), resolution_, sigma_, startFromX_, stopAtX_, ctppsDiamondLocalTracks_cfi::threshold, threshold_, thresholdFromMaximum_, HiIsolationCommonParameters_cff::track, yPosition_, and yWidth_.

Referenced by CTPPSDiamondLocalTrackFitter::produce().

 {
   int number_of_tracks = 0;
   for ( auto const& oot : hitParametersVectorMap_ ) {
     std::vector<float> hit_profile( ( stopAtX_-startFromX_ )/resolution_, 0. );
     for ( auto const& param : oot.second ) {
       hit_f_.SetParameters( param.center, param.width, sigma_ );
       for ( unsigned int i=0; i<hit_profile.size(); ++i ) {
         hit_profile[i] += hit_f_.Eval( startFromX_ + i*resolution_ );
       }
     }
 
     float maximum = 0.;
     bool below = true; // start below the threshold
     int track_start_n = 0;
 
     for ( unsigned int i=0; i<hit_profile.size(); ++i ) {
       if ( below && hit_profile[i] >= threshold_ ) { // going above the threshold
         track_start_n = i;
         maximum=0;
         below = false;
       }
       if ( !below ) {
         if ( hit_profile[i] > maximum ) {
           maximum = hit_profile[i];
         }
         if ( hit_profile[i] < threshold_ ) { // going back below the threshold
           below = true;
 
           // go back and use new threshold
           const float threshold = maximum - thresholdFromMaximum_;
           for ( unsigned int j=track_start_n; j<=i; ++j ) {
             if ( below && hit_profile[j] >= threshold ) { // going above the threshold
               track_start_n = j;
               below = false;
             }
             if ( !below && hit_profile[j] < threshold ) { // going back below the threshold
               below = true;
 
               //store track
               math::XYZPoint pos0_sigma( ( j-track_start_n )*resolution_*0.5, yWidth_ * 0.5, 0. );
               math::XYZPoint pos0( startFromX_ + track_start_n*resolution_ + pos0_sigma.X(), yPosition_, 0. );
               int mult_hits = 0;
               if ( mhMap_.find( oot.first ) != mhMap_.end() ) mult_hits = mhMap_[oot.first];
 
               CTPPSDiamondLocalTrack track( pos0, pos0_sigma, 0., 0., 0., oot.first, mult_hits );
               track.setValid( true );
               tracks.push_back( track );
               ++number_of_tracks;
             }
           }
         }
       }
     }
   }
 
   return number_of_tracks;
 }