diff --git a/DataFormats/CTPPSReco/interface/CTPPSDiamondLocalTrack.h b/DataFormats/CTPPSReco/interface/CTPPSDiamondLocalTrack.h new file mode 100644 index 0000000000000..66308ed17dffc --- /dev/null +++ b/DataFormats/CTPPSReco/interface/CTPPSDiamondLocalTrack.h @@ -0,0 +1,101 @@ +/**************************************************************************** + * + * This is a part of CTPPS offline software. + * Authors: + * Laurent Forthomme (laurent.forthomme@cern.ch) + * Nicola Minafra nicola.minafra@cern.ch) + * + ****************************************************************************/ + +#ifndef DataFormats_CTPPSReco_CTPPSDiamondLocalTrack +#define DataFormats_CTPPSReco_CTPPSDiamondLocalTrack + +#include "DataFormats/Math/interface/Point3D.h" +#include "DataFormats/CTPPSReco/interface/CTPPSDiamondRecHit.h" + +//---------------------------------------------------------------------------------------------------- + +class CTPPSDiamondLocalTrack +{ + public: + CTPPSDiamondLocalTrack() : + chi_squared_( 0. ), valid_( true ), t_( 0. ), t_sigma_( 0. ), ts_index_( 0 ), mh_( 0 ) {} + CTPPSDiamondLocalTrack( const math::XYZPoint& pos0, const math::XYZPoint& pos0_sigma, float chisq, float t, float t_sigma, int oot_idx, int mult_hits ) : + pos0_( pos0 ), pos0_sigma_( pos0_sigma ), + chi_squared_( chisq ), valid_( false ), + t_( t ), t_sigma_( t_sigma ), ts_index_( oot_idx ), mh_( mult_hits ) {} + virtual ~CTPPSDiamondLocalTrack() {} + + //--- spatial get'ters + + inline float getX0() const { return pos0_.x(); } + inline float getX0Sigma() const { return pos0_sigma_.x(); } + + inline float getY0() const { return pos0_.y(); } + inline float getY0Sigma() const { return pos0_sigma_.y(); } + + inline float getZ0() const { return pos0_.z(); } + + inline float getChiSquared() const { return chi_squared_; } + + //--- spatial set'ters + + inline void setPosition( const math::XYZPoint& pos0 ) { pos0_ = pos0; } + inline void setPositionSigma( const math::XYZPoint& pos0_sigma ) { pos0_sigma_ = pos0_sigma; } + + inline void setChiSquared( const float chisq ) { chi_squared_ = chisq; } + + inline bool isValid() const { return valid_; } + inline void setValid( bool valid ) { valid_ = valid; } + + //--- temporal get'ters + + inline float getT() const { return t_; } + inline float getTSigma() const { return t_sigma_; } + + //--- temporal set'ters + + inline void setT( const float t ) { t_ = t; } + inline void setTSigma( const float t_sigma ) { t_sigma_ = t_sigma; } + + inline void setOOTIndex( const int i ) { ts_index_ = i; } + inline int getOOTIndex() const { return ts_index_; } + + inline void setMultipleHits( const int i ) { mh_ = i; } + inline int getMultipleHits() const { return mh_; } + + private: + //--- spatial information + + /// initial track position + math::XYZPoint pos0_; + /// error on the initial track position + math::XYZPoint pos0_sigma_; + + /// fit chi^2 + float chi_squared_; + + /// fit valid? + bool valid_; + + //--- timing information + + float t_; + float t_sigma_; + /// Time slice index + int ts_index_; + /// Multiple hits counter + int mh_; + +}; + +inline bool operator<( const CTPPSDiamondLocalTrack& lhs, const CTPPSDiamondLocalTrack& rhs ) +{ + // start to sort by temporal coordinate + if ( lhs.getT() < rhs.getT() ) return true; + if ( lhs.getT() > rhs.getT() ) return false; + // then sort by x-position + return ( lhs.getX0() < rhs.getX0() ); +} + +#endif diff --git a/DataFormats/CTPPSReco/interface/CTPPSDiamondRecHit.h b/DataFormats/CTPPSReco/interface/CTPPSDiamondRecHit.h index c4459b48cfe81..74ebb310470f3 100644 --- a/DataFormats/CTPPSReco/interface/CTPPSDiamondRecHit.h +++ b/DataFormats/CTPPSReco/interface/CTPPSDiamondRecHit.h @@ -19,12 +19,12 @@ class CTPPSDiamondRecHit CTPPSDiamondRecHit() : x_( 0. ), x_width_( 0. ), y_( 0. ), y_width_( 0. ), t_( 0. ), tot_( 0. ), - ts_index_( 0 ), hptdc_err_( 0 ) + ts_index_( 0 ), hptdc_err_( 0 ), mh_( false ) {} - CTPPSDiamondRecHit( float x, float x_width, float y, float y_width, float t, float tot, int oot_idx, const HPTDCErrorFlags& hptdc_err ) : + CTPPSDiamondRecHit( float x, float x_width, float y, float y_width, float t, float tot, int oot_idx, const HPTDCErrorFlags& hptdc_err, const bool mh ) : x_( x ), x_width_( x_width ), y_( y ), y_width_( y_width ), t_( t ), tot_( tot ), - ts_index_( oot_idx ), hptdc_err_( hptdc_err ) + ts_index_( oot_idx ), hptdc_err_( hptdc_err ), mh_( mh ) {} inline void setX( const float& x ) { x_ = x; } @@ -47,6 +47,9 @@ class CTPPSDiamondRecHit inline void setOOTIndex( const int& i ) { ts_index_ = i; } inline int getOOTIndex() const { return ts_index_; } + + inline void setMultipleHits( const bool mh ) { mh_ = mh; } + inline bool getMultipleHits() const { return mh_; } inline void setHPTDCErrorFlags( const HPTDCErrorFlags& err ) { hptdc_err_ = err; } inline HPTDCErrorFlags getHPTDCErrorFlags() const { return hptdc_err_; } @@ -58,6 +61,7 @@ class CTPPSDiamondRecHit /// Time slice index int ts_index_; HPTDCErrorFlags hptdc_err_; + bool mh_; }; //---------------------------------------------------------------------------------------------------- diff --git a/DataFormats/CTPPSReco/src/classes.h b/DataFormats/CTPPSReco/src/classes.h index 95ca909f68a0d..f5c14c29fc65e 100644 --- a/DataFormats/CTPPSReco/src/classes.h +++ b/DataFormats/CTPPSReco/src/classes.h @@ -10,6 +10,7 @@ #include "DataFormats/CTPPSReco/interface/TotemRPLocalTrack.h" #include "DataFormats/CTPPSReco/interface/CTPPSDiamondRecHit.h" +#include "DataFormats/CTPPSReco/interface/CTPPSDiamondLocalTrack.h" #include "DataFormats/CTPPSReco/interface/CTPPSLocalTrackLite.h" @@ -52,11 +53,22 @@ namespace DataFormats_CTPPSReco { CTPPSDiamondRecHit ctd_rh; edm::Ptr ptr_ctd_rh; edm::Wrapper wrp_ctd_rh; - std::vector vec_rh; - std::vector< edm::DetSet > vec_ds_rh; - edm::DetSet ds_rh; + std::vector vec_ctd_rh; + std::vector< edm::DetSet > vec_ds_ctd_rh; + edm::DetSet ds_ctd_rh; edm::DetSetVector dsv_ctd_rh; edm::Wrapper< edm::DetSetVector > wrp_dsv_ctd_rh; + edm::Wrapper< std::vector > wrp_vec_ctd_rh; + + CTPPSDiamondLocalTrack ctd_lt; + edm::Ptr ptr_ctd_lt; + edm::Wrapper wrp_ctd_lt; + std::vector vec_ctd_lt; + edm::DetSet ds_ctd_lt; + std::vector< edm::DetSet > vec_ds_ctd_lt; + edm::Wrapper< std::vector > wrp_vec_ctd_lt; + edm::DetSetVector dsv_ctd_lt; + edm::Wrapper > wrp_dsv_ctd_lt; //--- common objects diff --git a/DataFormats/CTPPSReco/src/classes_def.xml b/DataFormats/CTPPSReco/src/classes_def.xml index 58d4de5901377..b0375f06f4344 100644 --- a/DataFormats/CTPPSReco/src/classes_def.xml +++ b/DataFormats/CTPPSReco/src/classes_def.xml @@ -45,8 +45,9 @@ - + + @@ -55,6 +56,19 @@ + + + + + + + + + + + + + diff --git a/RecoCTPPS/Configuration/python/RecoCTPPS_EventContent_cff.py b/RecoCTPPS/Configuration/python/RecoCTPPS_EventContent_cff.py index 8f81f100b289d..cf7bef8a85b01 100644 --- a/RecoCTPPS/Configuration/python/RecoCTPPS_EventContent_cff.py +++ b/RecoCTPPS/Configuration/python/RecoCTPPS_EventContent_cff.py @@ -19,6 +19,7 @@ 'keep CTPPSDiamondDigiedmDetSetVector_ctppsDiamondRawToDigi_*_*', 'keep TotemVFATStatusedmDetSetVector_ctppsDiamondRawToDigi_*_*', 'keep CTPPSDiamondRecHitedmDetSetVector_ctppsDiamondRecHits_*_*', + 'keep CTPPSDiamondLocalTrackedmDetSetVector_ctppsDiamondLocalTracks_*_*', # CTPPS common 'keep CTPPSLocalTrackLites_ctppsLocalTrackLiteProducer_*_*' @@ -45,6 +46,7 @@ 'keep CTPPSDiamondDigiedmDetSetVector_ctppsDiamondRawToDigi_*_*', 'keep TotemVFATStatusedmDetSetVector_ctppsDiamondRawToDigi_*_*', 'keep CTPPSDiamondRecHitedmDetSetVector_ctppsDiamondRecHits_*_*', + 'keep CTPPSDiamondLocalTrackedmDetSetVector_ctppsDiamondLocalTracks_*_*', # CTPPS common 'keep CTPPSLocalTrackLites_ctppsLocalTrackLiteProducer_*_*' @@ -71,6 +73,7 @@ 'keep CTPPSDiamondDigiedmDetSetVector_ctppsDiamondRawToDigi_*_*', 'keep TotemVFATStatusedmDetSetVector_ctppsDiamondRawToDigi_*_*', 'keep CTPPSDiamondRecHitedmDetSetVector_ctppsDiamondRecHits_*_*', + 'keep CTPPSDiamondLocalTrackedmDetSetVector_ctppsDiamondLocalTracks_*_*', # CTPPS common 'keep CTPPSLocalTrackLites_ctppsLocalTrackLiteProducer_*_*' diff --git a/RecoCTPPS/TotemRPLocal/interface/CTPPSDiamondTrackRecognition.h b/RecoCTPPS/TotemRPLocal/interface/CTPPSDiamondTrackRecognition.h new file mode 100644 index 0000000000000..df5522e92bb7d --- /dev/null +++ b/RecoCTPPS/TotemRPLocal/interface/CTPPSDiamondTrackRecognition.h @@ -0,0 +1,73 @@ +/**************************************************************************** + * + * This is a part of CTPPS offline software. + * Authors: + * Laurent Forthomme (laurent.forthomme@cern.ch) + * Nicola Minafra (nicola.minafra@cern.ch) + * + ****************************************************************************/ + +#ifndef RecoCTPPS_TotemRPLocal_CTPPSDiamondTrackRecognition +#define RecoCTPPS_TotemRPLocal_CTPPSDiamondTrackRecognition + +#include "FWCore/ParameterSet/interface/ParameterSet.h" + +#include "DataFormats/Common/interface/DetSet.h" +#include "DataFormats/Common/interface/DetSetVector.h" + +#include "DataFormats/CTPPSReco/interface/CTPPSDiamondRecHit.h" +#include "DataFormats/CTPPSReco/interface/CTPPSDiamondLocalTrack.h" + +#include +#include +#include "TF1.h" + +/** + * \brief Class performing smart reconstruction for CTPPS Diamond Detectors. + * \date Jan 2017 +**/ +class CTPPSDiamondTrackRecognition +{ + public: + CTPPSDiamondTrackRecognition( const edm::ParameterSet& ); + ~CTPPSDiamondTrackRecognition(); + + /// Reset the list of hits + void clear(); + + /// Feed a new hit to the tracks recognition algorithm + void addHit( const CTPPSDiamondRecHit& recHit ); + + /// Produce a collection of tracks for the current station, given its hits collection + int produceTracks( edm::DetSet& tracks ); + + private: + struct HitParameters { + HitParameters( const float center, const float width ) : + center( center ), width( width ) {} + float center; + float width; + }; + typedef std::vector HitParametersVector; + typedef std::unordered_map HitParametersVectorMap; + + /// Default hit function accounting for the pad spatial efficiency + static const std::string pixelEfficiencyDefaultFunction_; + + const float threshold_; + const float thresholdFromMaximum_; + const float resolution_; + const float sigma_; + const float startFromX_; + const float stopAtX_; + + float yPosition_; + float yWidth_; + + /// Function for pad efficiency + TF1 hit_f_; + HitParametersVectorMap hitParametersVectorMap_; + std::unordered_map mhMap_; +}; + +#endif diff --git a/RecoCTPPS/TotemRPLocal/plugins/CTPPSDiamondLocalTrackFitter.cc b/RecoCTPPS/TotemRPLocal/plugins/CTPPSDiamondLocalTrackFitter.cc new file mode 100644 index 0000000000000..ea9faa595a345 --- /dev/null +++ b/RecoCTPPS/TotemRPLocal/plugins/CTPPSDiamondLocalTrackFitter.cc @@ -0,0 +1,112 @@ +/**************************************************************************** + * + * This is a part of CTPPS offline software. + * Authors: + * Laurent Forthomme (laurent.forthomme@cern.ch) + * Nicola Minafra (nicola.minafra@cern.ch) + * + ****************************************************************************/ + +#include + +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/MakerMacros.h" + +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/Utilities/interface/StreamID.h" + +#include "DataFormats/Common/interface/DetSetVector.h" + +#include "DataFormats/CTPPSDetId/interface/CTPPSDiamondDetId.h" +#include "DataFormats/CTPPSReco/interface/CTPPSDiamondRecHit.h" +#include "DataFormats/CTPPSReco/interface/CTPPSDiamondLocalTrack.h" + +#include "RecoCTPPS/TotemRPLocal/interface/CTPPSDiamondTrackRecognition.h" + +class CTPPSDiamondLocalTrackFitter : public edm::stream::EDProducer<> +{ + public: + explicit CTPPSDiamondLocalTrackFitter( const edm::ParameterSet& ); + ~CTPPSDiamondLocalTrackFitter(); + + static void fillDescriptions( edm::ConfigurationDescriptions& ); + + private: + virtual void produce( edm::Event&, const edm::EventSetup& ) override; + + edm::EDGetTokenT< edm::DetSetVector > recHitsToken_; + CTPPSDiamondTrackRecognition trk_algo_45_; + CTPPSDiamondTrackRecognition trk_algo_56_; +}; + +CTPPSDiamondLocalTrackFitter::CTPPSDiamondLocalTrackFitter( const edm::ParameterSet& iConfig ) : + recHitsToken_( consumes< edm::DetSetVector >( iConfig.getParameter( "recHitsTag" ) ) ), + trk_algo_45_ ( iConfig.getParameter( "trackingAlgorithmParams" ) ), + trk_algo_56_ ( iConfig.getParameter( "trackingAlgorithmParams" ) ) +{ + produces< edm::DetSetVector >(); +} + +CTPPSDiamondLocalTrackFitter::~CTPPSDiamondLocalTrackFitter() +{} + +void +CTPPSDiamondLocalTrackFitter::produce( edm::Event& iEvent, const edm::EventSetup& iSetup ) +{ + std::unique_ptr< edm::DetSetVector > pOut( new edm::DetSetVector ); + + edm::Handle< edm::DetSetVector > recHits; + iEvent.getByToken( recHitsToken_, recHits ); + + const CTPPSDiamondDetId id_45( 0, 1, 6, 0, 0 ), id_56( 1, 1, 6, 0, 0 ); + + pOut->find_or_insert( id_45 ); // tracks in 4-5 + edm::DetSet& tracks56 = pOut->find_or_insert( id_56 ); // tracks in 5-6 + + // workaround to retrieve the detset for 4-5 without losing the reference + edm::DetSet& tracks45 = pOut->operator[]( id_45 ); + + // feed hits to the track producers + for ( edm::DetSetVector::const_iterator vec = recHits->begin(); vec != recHits->end(); ++vec ) + { + const CTPPSDiamondDetId detid( vec->detId() ); + + if (detid.arm()==0) + { + for ( edm::DetSet::const_iterator hit = vec->begin(); hit != vec->end(); ++hit ) + { + trk_algo_45_.addHit( *hit ); + } + } else + { + for ( edm::DetSet::const_iterator hit = vec->begin(); hit != vec->end(); ++hit ) + { + trk_algo_56_.addHit( *hit ); + } + } + } + + // retrieve the tracks for both arms + trk_algo_45_.produceTracks( tracks45 ); + trk_algo_56_.produceTracks( tracks56 ); + + iEvent.put( std::move( pOut ) ); + + // remove all hits from the track producers to prepare for the next event + trk_algo_45_.clear(); + trk_algo_56_.clear(); +} + +void +CTPPSDiamondLocalTrackFitter::fillDescriptions( edm::ConfigurationDescriptions& descr ) +{ + // The following says we do not know what parameters are allowed so do no validation + // Please change this to state exactly what you do use, even if it is no parameters + edm::ParameterSetDescription desc; + desc.setUnknown(); + descr.addDefault( desc ); +} + +DEFINE_FWK_MODULE( CTPPSDiamondLocalTrackFitter ); diff --git a/RecoCTPPS/TotemRPLocal/python/ctppsDiamondLocalReconstruction_cff.py b/RecoCTPPS/TotemRPLocal/python/ctppsDiamondLocalReconstruction_cff.py index 6234a63fdc2c0..64909bb4228a7 100644 --- a/RecoCTPPS/TotemRPLocal/python/ctppsDiamondLocalReconstruction_cff.py +++ b/RecoCTPPS/TotemRPLocal/python/ctppsDiamondLocalReconstruction_cff.py @@ -7,9 +7,9 @@ from RecoCTPPS.TotemRPLocal.ctppsDiamondRecHits_cfi import ctppsDiamondRecHits # local track fitting -#from RecoCTPPS.TotemRPLocal.ctppsDiamondLocalTracks_cfi import ctppsDiamondLocalTracks +from RecoCTPPS.TotemRPLocal.ctppsDiamondLocalTracks_cfi import ctppsDiamondLocalTracks ctppsDiamondLocalReconstruction = cms.Sequence( - ctppsDiamondRecHits - #* ctppsDiamondLocalTracks + ctppsDiamondRecHits * + ctppsDiamondLocalTracks ) diff --git a/RecoCTPPS/TotemRPLocal/python/ctppsDiamondLocalTracks_cfi.py b/RecoCTPPS/TotemRPLocal/python/ctppsDiamondLocalTracks_cfi.py new file mode 100644 index 0000000000000..b4bcb2aeeeaa9 --- /dev/null +++ b/RecoCTPPS/TotemRPLocal/python/ctppsDiamondLocalTracks_cfi.py @@ -0,0 +1,33 @@ +import FWCore.ParameterSet.Config as cms + +ctppsDiamondLocalTracks = cms.EDProducer("CTPPSDiamondLocalTrackFitter", + verbosity = cms.int32(0), + recHitsTag = cms.InputTag("ctppsDiamondRecHits"), + trackingAlgorithmParams = cms.PSet( + threshold = cms.double(1.5), + thresholdFromMaximum = cms.double(0.5), + resolution = cms.double(0.01), # in mm + sigma = cms.double(0.1), # see below + startFromX = cms.double(-0.5), # in mm + stopAtX = cms.double(19.5), # in mm + pixelEfficiencyFunction = cms.string("(TMath::Erf((x-[0]+0.5*[1])/([2]/4)+2)+1)*TMath::Erfc((x-[0]-0.5*[1])/([2]/4)-2)/4"), + yPosition = cms.double(0.0), + yWidth = cms.double(0.0), + ), +) + +# +# NOTE: pixelEfficiencyFunction can be defined as following: +# +# Precise: +# "(TMath::Erf((x-[0]+0.5*[1])/([2]/4)+2)+1)*TMath::Erfc((x-[0]-0.5*[1])/([2]/4)-2)/4" +# Fast: +# "(x>[0]-0.5*[1])*(x<[0]+0.5*[1])+((x-[0]+0.5*[1]+[2])/[2])*(x>[0]-0.5*[1]-[2])*(x<[0]-0.5*[1])+(2-(x-[0]-0.5*[1]+[2])/[2])*(x>[0]+0.5*[1])*(x<[0]+0.5*[1]+[2])" +# Legacy: +# "(1/(1+exp(-(x-[0]+0.5*[1])/[2])))*(1/(1+exp((x-[0]-0.5*[1])/[2])))" +# +# with: +# [0]: centre of pad +# [1]: width of pad +# [2]: sigma: distance between efficiency ~100 -> 0 outside width +# diff --git a/RecoCTPPS/TotemRPLocal/src/CTPPSDiamondRecHitProducerAlgorithm.cc b/RecoCTPPS/TotemRPLocal/src/CTPPSDiamondRecHitProducerAlgorithm.cc index 6583b00eabdf3..32bd9cd49ab43 100644 --- a/RecoCTPPS/TotemRPLocal/src/CTPPSDiamondRecHitProducerAlgorithm.cc +++ b/RecoCTPPS/TotemRPLocal/src/CTPPSDiamondRecHitProducerAlgorithm.cc @@ -42,7 +42,8 @@ CTPPSDiamondRecHitProducerAlgorithm::build( const TotemRPGeometry* geom, const e ( t0 * ts_to_ns_ ), ( digi->getTrailingEdge()-t0 ) * ts_to_ns_, time_slice, - digi->getHPTDCErrorFlags() ) ); + digi->getHPTDCErrorFlags(), + digi->getMultipleHit() ) ); } } } diff --git a/RecoCTPPS/TotemRPLocal/src/CTPPSDiamondTrackRecognition.cc b/RecoCTPPS/TotemRPLocal/src/CTPPSDiamondTrackRecognition.cc new file mode 100644 index 0000000000000..b816479666c3f --- /dev/null +++ b/RecoCTPPS/TotemRPLocal/src/CTPPSDiamondTrackRecognition.cc @@ -0,0 +1,135 @@ +/**************************************************************************** + * + * This is a part of CTPPS offline software. + * Authors: + * Laurent Forthomme (laurent.forthomme@cern.ch) + * Nicola Minafra (nicola.minafra@cern.ch) + * + ****************************************************************************/ + +#include "RecoCTPPS/TotemRPLocal/interface/CTPPSDiamondTrackRecognition.h" + +#include +#include +#include + +//---------------------------------------------------------------------------------------------------- + +const std::string CTPPSDiamondTrackRecognition::pixelEfficiencyDefaultFunction_ = "(x>[0]-0.5*[1])*(x<[0]+0.5*[1])"; + +CTPPSDiamondTrackRecognition::CTPPSDiamondTrackRecognition( const edm::ParameterSet& iConfig ) : + threshold_ ( iConfig.getParameter( "threshold" ) ), + thresholdFromMaximum_( iConfig.getParameter( "thresholdFromMaximum" ) ), + resolution_ ( iConfig.getParameter( "resolution" ) ), + sigma_ ( iConfig.getParameter( "sigma" ) ), + startFromX_ ( iConfig.getParameter( "startFromX" ) ), + stopAtX_ ( iConfig.getParameter( "stopAtX" ) ), + yPosition_ ( iConfig.getParameter( "yPosition" ) ), + yWidth_ ( iConfig.getParameter( "yWidth" ) ), + hit_f_( "hit_TF1_CTPPS", iConfig.getParameter( "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() +{} + +//---------------------------------------------------------------------------------------------------- + +void +CTPPSDiamondTrackRecognition::clear() +{ + hitParametersVectorMap_.clear(); + mhMap_.clear(); +} + +//---------------------------------------------------------------------------------------------------- + +void +CTPPSDiamondTrackRecognition::addHit( const CTPPSDiamondRecHit& recHit ) +{ + // store hit parameters + hitParametersVectorMap_[recHit.getOOTIndex()].emplace_back( recHit.getX(), recHit.getXWidth() ); + + // Check vertical coordinates + if ( yPosition_ == 0.0 and yWidth_ == 0.0 ) { + 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()] ); + } + } +} + +//---------------------------------------------------------------------------------------------------- + +int +CTPPSDiamondTrackRecognition::produceTracks( edm::DetSet& tracks ) +{ + int number_of_tracks = 0; + for ( auto const& oot : hitParametersVectorMap_ ) { + std::vector 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= 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; +} diff --git a/RecoCTPPS/TotemRPLocal/test/diamonds_reco_cfg.py b/RecoCTPPS/TotemRPLocal/test/diamonds_reco_cfg.py index 1b45062e9f894..5b98c0d7e5acf 100644 --- a/RecoCTPPS/TotemRPLocal/test/diamonds_reco_cfg.py +++ b/RecoCTPPS/TotemRPLocal/test/diamonds_reco_cfg.py @@ -54,6 +54,13 @@ process.load('Geometry.VeryForwardGeometry.geometryRP_cfi') process.load('RecoCTPPS.TotemRPLocal.ctppsDiamondRecHits_cfi') +# local tracks fitter +process.load('RecoCTPPS.TotemRPLocal.ctppsDiamondLocalTracks_cfi') +#process.ctppsDiamondLocalTracks.trackingAlgorithmParams.threshold = cms.double(1.5) +#process.ctppsDiamondLocalTracks.trackingAlgorithmParams.sigma = cms.double(0) +#process.ctppsDiamondLocalTracks.trackingAlgorithmParams.resolution = cms.double(0.025) # in mm +#process.ctppsDiamondLocalTracks.trackingAlgorithmParams.pixel_efficiency_function = cms.string("(TMath::Erf((x-[0]+0.5*[1])/([2]/4)+2)+1)*TMath::Erfc((x-[0]-0.5*[1])/([2]/4)-2)/4") + process.output = cms.OutputModule("PoolOutputModule", fileName = cms.untracked.string("file:AOD.root"), outputCommands = cms.untracked.vstring( @@ -65,7 +72,8 @@ # execution configuration process.p = cms.Path( process.ctppsDiamondRawToDigi * - process.ctppsDiamondRecHits + process.ctppsDiamondRecHits * + process.ctppsDiamondLocalTracks ) process.outpath = cms.EndPath(process.output)