Inheritance diagram for CTPPSProtonReconstructionEfficiencyEstimatorData:

Classes
struct	ArmData

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

Public Member Functions inherited from edm::one::EDAnalyzer<>
	EDAnalyzer ()=default

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

Public Member Functions inherited from edm::one::EDAnalyzerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

bool	wantsStreamLuminosityBlocks () const

bool	wantsStreamRuns () const

	~EDAnalyzerBase () override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

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

Static Public Member Functions inherited from edm::one::EDAnalyzerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

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

void	endJob () override

Private Attributes
std::map< unsigned int, ArmData >	data_

std::unique_ptr< TF1 >	ff_

double	localAngleXMax_

double	localAngleXMin_

double	localAngleYMax_

double	localAngleYMin_

unsigned int	n_exp_prot_max_

unsigned int	n_prep_events_

std::vector< double >	n_sigmas_

std::string	opticsLabel_

edm::ESWatcher< CTPPSInterpolatedOpticsRcd >	opticsWatcher_

std::string	outputFile_

bool	pixelDiscardBXShiftedTracks_

edm::EDGetTokenT< reco::ForwardProtonCollection >	tokenRecoProtonsMultiRP_

edm::EDGetTokenT< CTPPSLocalTrackLiteCollection >	tokenTracks_

unsigned int	verbosity_

Additional Inherited Members
Public Types inherited from edm::one::EDAnalyzerBase
typedef EDAnalyzerBase	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

Definition at line 38 of file CTPPSProtonReconstructionEfficiencyEstimatorData.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 214 of file CTPPSProtonReconstructionEfficiencyEstimatorData.cc.

References data_, edm::ParameterSet::getParameter(), n_exp_prot_max_, and n_sigmas_.

     : tokenTracks_(consumes<CTPPSLocalTrackLiteCollection>(iConfig.getParameter<edm::InputTag>("tagTracks"))),
 
       tokenRecoProtonsMultiRP_(
           consumes<reco::ForwardProtonCollection>(iConfig.getParameter<InputTag>("tagRecoProtonsMultiRP"))),
 
       pixelDiscardBXShiftedTracks_(iConfig.getParameter<bool>("pixelDiscardBXShiftedTracks")),
 
       localAngleXMin_(iConfig.getParameter<double>("localAngleXMin")),
       localAngleXMax_(iConfig.getParameter<double>("localAngleXMax")),
       localAngleYMin_(iConfig.getParameter<double>("localAngleYMin")),
       localAngleYMax_(iConfig.getParameter<double>("localAngleYMax")),
 
       opticsLabel_(iConfig.getParameter<std::string>("opticsLabel")),
       n_prep_events_(iConfig.getParameter<unsigned int>("n_prep_events")),
       n_exp_prot_max_(iConfig.getParameter<unsigned int>("n_exp_prot_max")),
       n_sigmas_(iConfig.getParameter<std::vector<double>>("n_sigmas")),
 
       outputFile_(iConfig.getParameter<string>("outputFile")),
 
       verbosity_(iConfig.getUntrackedParameter<unsigned int>("verbosity")),
 
       ff_(new TF1("ff", "[0] * exp(- (x-[1])*(x-[1]) / 2 / [2]/[2]) + [4]")) {
   data_[0].n_exp_prot_max = n_exp_prot_max_;
   data_[0].n_sigmas = n_sigmas_;
   data_[0].rpId_N = iConfig.getParameter<unsigned int>("rpId_45_N");
   data_[0].rpId_F = iConfig.getParameter<unsigned int>("rpId_45_F");
 
   data_[1].n_exp_prot_max = n_exp_prot_max_;
   data_[1].n_sigmas = n_sigmas_;
   data_[1].rpId_N = iConfig.getParameter<unsigned int>("rpId_56_N");
   data_[1].rpId_F = iConfig.getParameter<unsigned int>("rpId_56_F");
 }

Member Function Documentation

void CTPPSProtonReconstructionEfficiencyEstimatorData::analyze	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Definition at line 288 of file CTPPSProtonReconstructionEfficiencyEstimatorData.cc.

References allShiftedPlanes, CTPPSDetId::arm(), edm::ESWatcher< T >::check(), data_, alignCSCRings::de_x, alignCSCRings::de_y, ff_, edm::EventSetup::get(), edm::Event::getByToken(), mps_fire::i, training_settings::idx, localAngleXMax_, localAngleXMin_, localAngleYMax_, localAngleYMin_, funct::m, match(), mixedPlanes, n_prep_events_, opticsLabel_, opticsWatcher_, AlCaHLTBitMon_ParallelJobs::p, pixelDiscardBXShiftedTracks_, year_2016_postTS2_cff::rpId, tokenRecoProtonsMultiRP_, tokenTracks_, HiIsolationCommonParameters_cff::track, heppy_batch::val, verbosity_, x, and y.

                                                                                             {
   std::ostringstream os;
 
   // get conditions
   edm::ESHandle<LHCInterpolatedOpticalFunctionsSetCollection> hOpticalFunctions;
   iSetup.get<CTPPSInterpolatedOpticsRcd>().get(opticsLabel_, hOpticalFunctions);
 
   // check optics change
   if (opticsWatcher_.check(iSetup)) {
     data_[0].UpdateOptics(*hOpticalFunctions);
     data_[1].UpdateOptics(*hOpticalFunctions);
   }
 
   // get input
   edm::Handle<CTPPSLocalTrackLiteCollection> hTracks;
   iEvent.getByToken(tokenTracks_, hTracks);
 
   Handle<reco::ForwardProtonCollection> hRecoProtonsMultiRP;
   iEvent.getByToken(tokenRecoProtonsMultiRP_, hRecoProtonsMultiRP);
 
   // pre-selection of tracks
   std::vector<unsigned int> sel_track_idc;
   for (unsigned int idx = 0; idx < hTracks->size(); ++idx) {
     const auto &tr = hTracks->at(idx);
 
     if (tr.getTx() < localAngleXMin_ || tr.getTx() > localAngleXMax_ || tr.getTy() < localAngleYMin_ ||
         tr.getTy() > localAngleYMax_)
       continue;
 
     if (pixelDiscardBXShiftedTracks_) {
       if (tr.getPixelTrackRecoInfo() == CTPPSpixelLocalTrackReconstructionInfo::allShiftedPlanes ||
           tr.getPixelTrackRecoInfo() == CTPPSpixelLocalTrackReconstructionInfo::mixedPlanes)
         continue;
     }
 
     sel_track_idc.push_back(idx);
   }
 
   // debug print
   if (verbosity_ > 1) {
     os << "* tracks (pre-selected):" << std::endl;
 
     for (const auto idx : sel_track_idc) {
       const auto &tr = hTracks->at(idx);
       CTPPSDetId rpId(tr.getRPId());
       unsigned int decRPId = rpId.arm() * 100 + rpId.station() * 10 + rpId.rp();
 
       os << "    [" << idx << "] RP=" << decRPId << ", x=" << tr.getX() << ", y=" << tr.getY() << std::endl;
     }
 
     os << "* protons:" << std::endl;
     for (unsigned int i = 0; i < hRecoProtonsMultiRP->size(); ++i) {
       const auto &pr = (*hRecoProtonsMultiRP)[i];
       os << "    [" << i << "] track indices: ";
       for (const auto &trr : pr.contributingLocalTracks())
         os << trr.key() << ", ";
       os << std::endl;
     }
   }
 
   // make de_x and de_y plots
   map<unsigned int, bool> hasTracksInArm;
 
   for (const auto idx_i : sel_track_idc) {
     const auto &tr_i = hTracks->at(idx_i);
     CTPPSDetId rpId_i(tr_i.getRPId());
     unsigned int decRPId_i = rpId_i.arm() * 100 + rpId_i.station() * 10 + rpId_i.rp();
 
     for (const auto idx_j : sel_track_idc) {
       const auto &tr_j = hTracks->at(idx_j);
       CTPPSDetId rpId_j(tr_j.getRPId());
       unsigned int decRPId_j = rpId_j.arm() * 100 + rpId_j.station() * 10 + rpId_j.rp();
 
       // check whether desired RP combination
       unsigned int arm = 123;
       for (const auto &ap : data_) {
         if (ap.second.rpId_N == decRPId_i && ap.second.rpId_F == decRPId_j)
           arm = ap.first;
       }
 
       if (arm > 1)
         continue;
 
       // update flag
       hasTracksInArm[arm] = true;
 
       // update plots
       auto &ad = data_[arm];
       const double de_x = tr_j.getX() - tr_i.getX();
       const double de_y = tr_j.getY() - tr_i.getY();
 
       if (ad.n_events_with_tracks < n_prep_events_) {
         ad.h_de_x->Fill(de_x);
         ad.h_de_y->Fill(de_y);
       }
 
       ad.h2_de_y_vs_de_x->Fill(de_x, de_y);
     }
   }
 
   // update event counter
   for (auto &ap : data_) {
     if (hasTracksInArm[ap.first])
       ap.second.n_events_with_tracks++;
   }
 
   // if threshold reached do fits
   for (auto &ap : data_) {
     auto &ad = ap.second;
 
     if (ad.n_events_with_tracks == n_prep_events_) {
       if (ad.de_x_sigma > 0. && ad.de_y_sigma > 0.)
         continue;
 
       std::vector<std::pair<unsigned int, TH1D *>> m;
       m.emplace_back(0, ad.h_de_x.get());
       m.emplace_back(1, ad.h_de_y.get());
 
       for (const auto &p : m) {
         double max_pos = -1E100, max_val = -1.;
         for (int bi = 1; bi < p.second->GetNbinsX(); ++bi) {
           const double pos = p.second->GetBinCenter(bi);
           const double val = p.second->GetBinContent(bi);
 
           if (val > max_val) {
             max_val = val;
             max_pos = pos;
           }
         }
 
         const double sig = 0.2;
 
         ff_->SetParameters(max_val, max_pos, sig, 0.);
         p.second->Fit(ff_.get(), "Q", "", max_pos - 3. * sig, max_pos + 3. * sig);
         p.second->Fit(ff_.get(), "Q", "", max_pos - 3. * sig, max_pos + 3. * sig);
 
         if (p.first == 0) {
           ad.de_x_mean = ff_->GetParameter(1);
           ad.de_x_sigma = fabs(ff_->GetParameter(2));
         }
         if (p.first == 1) {
           ad.de_y_mean = ff_->GetParameter(1);
           ad.de_y_sigma = fabs(ff_->GetParameter(2));
         }
       }
 
       if (verbosity_) {
         os << "* fitting arm " << ap.first << std::endl
            << "    de_x: mean = " << ad.de_x_mean << ", sigma = " << ad.de_x_sigma << std::endl
            << "    de_y: mean = " << ad.de_y_mean << ", sigma = " << ad.de_y_sigma;
       }
     }
   }
 
   // data structures for efficiency analysis
   struct ArmEventData {
     std::map<unsigned int, std::set<unsigned int>> matched_track_idc;
 
     std::set<unsigned int> reco_proton_idc;
 
     std::map<unsigned int, std::set<unsigned int>> matched_track_with_prot_idc, matched_track_without_prot_idc;
   };
 
   std::map<unsigned int, ArmEventData> armEventData;
 
   // determine the number of expected protons
   for (const auto idx_i : sel_track_idc) {
     const auto &tr_i = hTracks->at(idx_i);
     CTPPSDetId rpId_i(tr_i.getRPId());
     unsigned int decRPId_i = rpId_i.arm() * 100 + rpId_i.station() * 10 + rpId_i.rp();
 
     for (const auto idx_j : sel_track_idc) {
       const auto &tr_j = hTracks->at(idx_j);
       CTPPSDetId rpId_j(tr_j.getRPId());
       unsigned int decRPId_j = rpId_j.arm() * 100 + rpId_j.station() * 10 + rpId_j.rp();
 
       // check whether desired RP combination
       unsigned int arm = 123;
       for (const auto &ap : data_) {
         if (ap.second.rpId_N == decRPId_i && ap.second.rpId_F == decRPId_j)
           arm = ap.first;
       }
 
       if (arm > 1)
         continue;
 
       // check near-far matching
       auto &ad = data_[arm];
       const double de_x = tr_j.getX() - tr_i.getX();
       const double de_y = tr_j.getY() - tr_i.getY();
 
       for (unsigned int nsi = 0; nsi < ad.n_sigmas.size(); ++nsi) {
         const double n_si = ad.n_sigmas[nsi];
         const bool match_x = fabs(de_x - ad.de_x_mean) < n_si * ad.de_x_sigma;
         const bool match_y = fabs(de_y - ad.de_y_mean) < n_si * ad.de_y_sigma;
         if (match_x && match_y)
           armEventData[arm].matched_track_idc[nsi].insert(idx_i);
       }
     }
   }
 
   // determine the number of reconstructed protons
   for (unsigned int i = 0; i < hRecoProtonsMultiRP->size(); ++i) {
     const auto &proton = (*hRecoProtonsMultiRP)[i];
 
     CTPPSDetId rpId((*proton.contributingLocalTracks().begin())->getRPId());
     unsigned int arm = rpId.arm();
 
     if (proton.validFit())
       armEventData[arm].reco_proton_idc.insert(i);
   }
 
   // compare matched tracks with reco protons
   if (verbosity_ > 1)
     os << "* cmp matched tracks vs. reco protons" << std::endl;
 
   for (auto &ap : armEventData) {
     auto &ad = data_[ap.first];
 
     if (verbosity_ > 1)
       os << "    arm " << ap.first << std::endl;
 
     for (unsigned int nsi = 0; nsi < ad.n_sigmas.size(); ++nsi) {
       if (verbosity_ > 1)
         os << "        nsi = " << nsi << std::endl;
 
       for (const auto &tri : ap.second.matched_track_idc[nsi]) {
         const auto &track = hTracks->at(tri);
 
         bool some_proton_matching = false;
 
         if (verbosity_ > 1)
           os << "            tri = " << tri << std::endl;
 
         for (const auto &pri : ap.second.reco_proton_idc) {
           const auto &proton = (*hRecoProtonsMultiRP)[pri];
 
           bool proton_matching = false;
 
           for (const auto &pr_tr : proton.contributingLocalTracks()) {
             CTPPSDetId rpId(pr_tr->getRPId());
             unsigned int decRPId = rpId.arm() * 100 + rpId.station() * 10 + rpId.rp();
 
             if (decRPId != ad.rpId_N)
               continue;
 
             const double x = pr_tr->getX();
             const double y = pr_tr->getY();
             const double th = 1E-3;  // 1 um
 
             const bool match = (fabs(x - track.getX()) < th) && (fabs(y - track.getY()) < th);
 
             if (verbosity_ > 1)
               os << "                pri = " << pri << ": x_tr = " << track.getX() << ", x_pr = " << x
                  << ", match = " << match << std::endl;
 
             if (match) {
               proton_matching = true;
               break;
             }
           }
 
           if (proton_matching) {
             some_proton_matching = true;
             break;
           }
         }
 
         if (verbosity_ > 1)
           os << "            --> some_proton_matching " << some_proton_matching << std::endl;
 
         if (some_proton_matching)
           ap.second.matched_track_with_prot_idc[nsi].insert(tri);
         else
           ap.second.matched_track_without_prot_idc[nsi].insert(tri);
       }
     }
   }
 
   // debug print
   if (verbosity_ > 1) {
     for (auto &ap : armEventData) {
       auto &ad = data_[ap.first];
 
       if (ad.de_x_sigma <= 0. && ad.de_y_sigma <= 0.)
         continue;
 
       os << "* results for arm " << ap.first << std::endl;
 
       os << "    reco_proton_idc: ";
       for (const auto &idx : ap.second.reco_proton_idc)
         os << idx << ", ";
       os << std::endl;
 
       for (unsigned int nsi = 0; nsi < ad.n_sigmas.size(); ++nsi) {
         os << "    n_si = " << ad.n_sigmas[nsi] << std::endl;
 
         os << "        matched_track_idc: ";
         for (const auto &idx : ap.second.matched_track_idc[nsi])
           os << idx << ", ";
         os << std::endl;
 
         os << "        matched_track_with_prot_idc: ";
         for (const auto &idx : ap.second.matched_track_with_prot_idc[nsi])
           os << idx << ", ";
         os << std::endl;
 
         os << "        matched_track_without_prot_idc: ";
         for (const auto &idx : ap.second.matched_track_without_prot_idc[nsi])
           os << idx << ", ";
         os << std::endl;
       }
     }
   }
 
   // update efficiency plots
   for (auto &ap : armEventData) {
     auto &ad = data_[ap.first];
 
     // stop if sigmas not yet determined
     if (ad.de_x_sigma <= 0. && ad.de_y_sigma <= 0.)
       continue;
 
     // loop over n_sigma choices
     for (unsigned int nsi = 0; nsi < ad.n_sigmas.size(); ++nsi) {
       const unsigned int n_exp_prot = ap.second.matched_track_idc[nsi].size();
       const unsigned int n_rec_prot = ap.second.reco_proton_idc.size();
 
       // stop if N(expected protons) out of range
       if (n_exp_prot < 1 || n_exp_prot > ad.n_exp_prot_max)
         continue;
 
       // update method 1 plots
       const double eff = double(n_rec_prot) / n_exp_prot;
 
       for (unsigned int tri : ap.second.matched_track_idc[nsi]) {
         const double x_N = hTracks->at(tri).getX();
         const double xi_N = ad.s_x_to_xi_N->Eval(x_N * 1E-1);  // conversion mm to cm
 
         ad.effPlots[0][nsi].p_eff1_vs_x_N->Fill(x_N, eff);
         ad.effPlots[0][nsi].p_eff1_vs_xi_N->Fill(xi_N, eff);
 
         ad.effPlots[n_exp_prot][nsi].p_eff1_vs_x_N->Fill(x_N, eff);
         ad.effPlots[n_exp_prot][nsi].p_eff1_vs_xi_N->Fill(xi_N, eff);
       }
 
       // update method 2 plots
       for (const auto &tri : ap.second.matched_track_with_prot_idc[nsi]) {
         const double x_N = hTracks->at(tri).getX();
         const double xi_N = ad.s_x_to_xi_N->Eval(x_N * 1E-1);  // conversion mm to cm
 
         ad.effPlots[0][nsi].p_eff2_vs_x_N->Fill(x_N, 1.);
         ad.effPlots[0][nsi].p_eff2_vs_xi_N->Fill(xi_N, 1.);
 
         ad.effPlots[n_exp_prot][nsi].p_eff2_vs_x_N->Fill(x_N, 1.);
         ad.effPlots[n_exp_prot][nsi].p_eff2_vs_xi_N->Fill(xi_N, 1.);
       }
 
       for (const auto &tri : ap.second.matched_track_without_prot_idc[nsi]) {
         const double x_N = hTracks->at(tri).getX();
         const double xi_N = ad.s_x_to_xi_N->Eval(x_N * 1E-1);  // conversion mm to cm
 
         ad.effPlots[0][nsi].p_eff2_vs_x_N->Fill(x_N, 0.);
         ad.effPlots[0][nsi].p_eff2_vs_xi_N->Fill(xi_N, 0.);
 
         ad.effPlots[n_exp_prot][nsi].p_eff2_vs_x_N->Fill(x_N, 0.);
         ad.effPlots[n_exp_prot][nsi].p_eff2_vs_xi_N->Fill(xi_N, 0.);
       }
     }
   }
 
   if (verbosity_)
     edm::LogInfo("CTPPSProtonReconstructionEfficiencyEstimatorData") << os.str();
 }

void CTPPSProtonReconstructionEfficiencyEstimatorData::endJob ( void )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 666 of file CTPPSProtonReconstructionEfficiencyEstimatorData.cc.

References data_, DEFINE_FWK_MODULE, and outputFile_.

                                                               {
   auto f_out = std::make_unique<TFile>(outputFile_.c_str(), "recreate");
 
   for (const auto &ait : data_) {
     char buf[100];
     sprintf(buf, "arm %u", ait.first);
     TDirectory *d_arm = f_out->mkdir(buf);
     gDirectory = d_arm;
 
     ait.second.write();
   }
 }

void CTPPSProtonReconstructionEfficiencyEstimatorData::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 251 of file CTPPSProtonReconstructionEfficiencyEstimatorData.cc.

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

                                                                                                                   {
   edm::ParameterSetDescription desc;
 
   desc.add<edm::InputTag>("tagTracks", edm::InputTag())->setComment("input tag for local lite tracks");
   desc.add<edm::InputTag>("tagRecoProtonsMultiRP", edm::InputTag())->setComment("input tag for multi-RP reco protons");
 
   desc.add<bool>("pixelDiscardBXShiftedTracks", false)
       ->setComment("whether to discard pixel tracks built from BX-shifted planes");
 
   desc.add<double>("localAngleXMin", -0.03)->setComment("minimal accepted value of local horizontal angle (rad)");
   desc.add<double>("localAngleXMax", +0.03)->setComment("maximal accepted value of local horizontal angle (rad)");
   desc.add<double>("localAngleYMin", -0.04)->setComment("minimal accepted value of local vertical angle (rad)");
   desc.add<double>("localAngleYMax", +0.04)->setComment("maximal accepted value of local vertical angle (rad)");
 
   desc.add<std::string>("opticsLabel", "")->setComment("label of the optics records");
 
   desc.add<unsigned int>("n_prep_events", 1000)
       ->setComment("number of preparatory events (to determine de x and de y window)");
 
   desc.add<unsigned int>("n_exp_prot_max", 5)->setComment("maximum number of expected protons per event and per arm");
 
   desc.add<std::vector<double>>("n_sigmas", {3., 5., 7.})->setComment("list of n_sigma values");
 
   desc.add<unsigned int>("rpId_45_N", 0)->setComment("decimal RP id for 45 near");
   desc.add<unsigned int>("rpId_45_F", 0)->setComment("decimal RP id for 45 far");
   desc.add<unsigned int>("rpId_56_N", 0)->setComment("decimal RP id for 56 near");
   desc.add<unsigned int>("rpId_56_F", 0)->setComment("decimal RP id for 56 far");
 
   desc.add<std::string>("outputFile", "output.root")->setComment("output file name");
 
   desc.addUntracked<unsigned int>("verbosity", 0)->setComment("verbosity level");
 
   descriptions.add("ctppsProtonReconstructionEfficiencyEstimatorData", desc);
 }