Inheritance diagram for CTPPSDiamondLocalTrackFitter:

Public Member Functions
	CTPPSDiamondLocalTrackFitter (const edm::ParameterSet &)

	~CTPPSDiamondLocalTrackFitter () override

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &)

Private Member Functions
void	produce (edm::Event &, const edm::EventSetup &) override

Private Attributes
edm::EDGetTokenT< edm::DetSetVector< CTPPSDiamondRecHit > >	recHitsToken_

CTPPSDiamondTrackRecognition	trk_algo_45_

CTPPSDiamondTrackRecognition	trk_algo_56_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
typedef CacheContexts< T... >	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Detailed Description

Definition at line 28 of file CTPPSDiamondLocalTrackFitter.cc.

Constructor & Destructor Documentation

◆ CTPPSDiamondLocalTrackFitter()

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

explicit

Definition at line 43 of file CTPPSDiamondLocalTrackFitter.cc.

     : recHitsToken_(
           consumes<edm::DetSetVector<CTPPSDiamondRecHit> >(iConfig.getParameter<edm::InputTag>("recHitsTag"))),
       trk_algo_45_(iConfig.getParameter<edm::ParameterSet>("trackingAlgorithmParams")),
       trk_algo_56_(iConfig.getParameter<edm::ParameterSet>("trackingAlgorithmParams")) {
   produces<edm::DetSetVector<CTPPSDiamondLocalTrack> >();
 }

◆ ~CTPPSDiamondLocalTrackFitter()

CTPPSDiamondLocalTrackFitter::~CTPPSDiamondLocalTrackFitter ( )

override

Definition at line 51 of file CTPPSDiamondLocalTrackFitter.cc.

51 {}

Member Function Documentation

◆ fillDescriptions()

void CTPPSDiamondLocalTrackFitter::fillDescriptions ( edm::ConfigurationDescriptions & descr )

static

Definition at line 100 of file CTPPSDiamondLocalTrackFitter.cc.

                                                                                        {
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("recHitsTag", edm::InputTag("ctppsDiamondRecHits"))
       ->setComment("input rechits collection to retrieve");
  
   edm::ParameterSetDescription trackingAlgoParams;
   trackingAlgoParams.add<double>("threshold", 1.5)
       ->setComment("minimal number of rechits to be observed before launching the track recognition algorithm");
   trackingAlgoParams.add<double>("thresholdFromMaximum", 0.5);
   trackingAlgoParams.add<double>("resolution", 0.01 /* mm */)
       ->setComment("spatial resolution on the horizontal coordinate (in mm)");
   trackingAlgoParams.add<double>("sigma", 0.1);
   trackingAlgoParams.add<double>("startFromX", -0.5 /* mm */)
       ->setComment("starting horizontal coordinate of rechits for the track recognition");
   trackingAlgoParams.add<double>("stopAtX", 19.5 /* mm */)
       ->setComment("ending horizontal coordinate of rechits for the track recognition");
   trackingAlgoParams.add<double>("tolerance", 0.1 /* mm */)
       ->setComment("tolerance used for checking if the track contains certain hit");
  
   trackingAlgoParams.add<std::string>("pixelEfficiencyFunction", "(x>[0]-0.5*[1])*(x<[0]+0.5*[1])+0*[2]")
       ->setComment(
           "efficiency function for single pixel\n"
           "can be defined as:\n"
           " * Precise: (TMath::Erf((x-[0]+0.5*[1])/([2]/4)+2)+1)*TMath::Erfc((x-[0]-0.5*[1])/([2]/4)-2)/4\n"
           " * 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])\n"
           " * Legacy: (1/(1+exp(-(x-[0]+0.5*[1])/[2])))*(1/(1+exp((x-[0]-0.5*[1])/[2])))\n"
           " * Default (sigma ignored): (x>[0]-0.5*[1])*(x<[0]+0.5*[1])+0*[2]\n"
           "with:\n"
           "  [0]: centre of pad\n"
           "  [1]: width of pad\n"
           "  [2]: sigma: distance between efficiency ~100 -> 0 outside width");
  
   trackingAlgoParams.add<double>("yPosition", 0.0)->setComment("vertical offset of the outcoming track centre");
   trackingAlgoParams.add<double>("yWidth", 0.0)->setComment("vertical track width");
   trackingAlgoParams.add<bool>("excludeSingleEdgeHits", true)
       ->setComment("exclude rechits with missing leading/trailing edge");
  
   desc.add<edm::ParameterSetDescription>("trackingAlgorithmParams", trackingAlgoParams)
       ->setComment("list of parameters associated to the track recognition algorithm");
  
   descr.add("ctppsDiamondLocalTracks", desc);
 }

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), HLT_2018_cff::InputTag, edm::ParameterDescriptionNode::setComment(), and AlCaHLTBitMon_QueryRunRegistry::string.

◆ produce()

void CTPPSDiamondLocalTrackFitter::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Definition at line 53 of file CTPPSDiamondLocalTrackFitter.cc.

                                                                                         {
   auto pOut = std::make_unique<edm::DetSetVector<CTPPSDiamondLocalTrack> >();
  
   edm::Handle<edm::DetSetVector<CTPPSDiamondRecHit> > 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<CTPPSDiamondLocalTrack>& 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<CTPPSDiamondLocalTrack>& tracks45 = pOut->operator[](id_45);
  
   // feed hits to the track producers
   for (const auto& vec : *recHits) {
     const CTPPSDiamondDetId detid(vec.detId());
     for (const auto& hit : vec) {
       // skip hits without a leading edge
       if (hit.ootIndex() == CTPPSDiamondRecHit::TIMESLICE_WITHOUT_LEADING)
         continue;
  
       switch (detid.arm()) {
         case 0: {
           trk_algo_45_.addHit(hit);
         } break;
         case 1: {
           trk_algo_56_.addHit(hit);
         } break;
         default:
           edm::LogWarning("CTPPSDiamondLocalTrackFitter") << "Invalid arm for rechit: " << detid.arm();
           break;
       }
     }
   }
  
   // 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();
 }