Inheritance diagram for CTPPSProtonProducer:

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

	~CTPPSProtonProducer () override=default

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

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

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

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

Private Attributes
ProtonReconstructionAlgorithm	algorithm_

double	default_time_

bool	doMultiRPReconstruction_

bool	doSingleRPReconstruction_

const edm::ESGetToken< CTPPSGeometry, VeryForwardRealGeometryRecord >	geometryToken_

const std::string	lhcInfoLabel_

const std::string	lhcInfoPerFillLabel_

const edm::ESGetToken< LHCInfoPerFill, LHCInfoPerFillRcd >	lhcInfoPerFillToken_

const std::string	lhcInfoPerLSLabel_

const edm::ESGetToken< LHCInfoPerLS, LHCInfoPerLSRcd >	lhcInfoPerLSToken_

const edm::ESGetToken< LHCInfo, LHCInfoRcd >	lhcInfoToken_

double	localAngleXMax_

double	localAngleXMin_

double	localAngleYMax_

double	localAngleYMin_

unsigned int	max_n_timing_tracks_

std::string	multiRPReconstructionLabel_

const edm::ESGetToken< LHCInterpolatedOpticalFunctionsSetCollection, CTPPSInterpolatedOpticsRcd >	opticalFunctionsToken_

const std::string	opticsLabel_

bool	opticsValid_

edm::ESWatcher< CTPPSInterpolatedOpticsRcd >	opticsWatcher_

bool	pixelDiscardBXShiftedTracks_

const std::string	ppsAssociationCutsLabel_

const edm::ESGetToken< PPSAssociationCuts, PPSAssociationCutsRcd >	ppsAssociationCutsToken_

std::string	singleRPReconstructionLabel_

edm::EDGetTokenT< CTPPSLocalTrackLiteCollection >	tracksToken_

const bool	useNewLHCInfo_

unsigned int	verbosity_

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

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

Definition at line 45 of file CTPPSProtonProducer.cc.

Constructor & Destructor Documentation

◆ CTPPSProtonProducer()

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

explicit

Definition at line 94 of file CTPPSProtonProducer.cc.

References doMultiRPReconstruction_, doSingleRPReconstruction_, multiRPReconstructionLabel_, and singleRPReconstructionLabel_.

     : tracksToken_(consumes<CTPPSLocalTrackLiteCollection>(iConfig.getParameter<edm::InputTag>("tagLocalTrackLite"))),
 
       pixelDiscardBXShiftedTracks_(iConfig.getParameter<bool>("pixelDiscardBXShiftedTracks")),
 
       lhcInfoPerLSLabel_(iConfig.getParameter<std::string>("lhcInfoPerLSLabel")),
       lhcInfoPerFillLabel_(iConfig.getParameter<std::string>("lhcInfoPerFillLabel")),
       lhcInfoLabel_(iConfig.getParameter<std::string>("lhcInfoLabel")),
       opticsLabel_(iConfig.getParameter<std::string>("opticsLabel")),
       ppsAssociationCutsLabel_(iConfig.getParameter<std::string>("ppsAssociationCutsLabel")),
       useNewLHCInfo_(iConfig.getParameter<bool>("useNewLHCInfo")),
       verbosity_(iConfig.getUntrackedParameter<unsigned int>("verbosity", 0)),
       doSingleRPReconstruction_(iConfig.getParameter<bool>("doSingleRPReconstruction")),
       doMultiRPReconstruction_(iConfig.getParameter<bool>("doMultiRPReconstruction")),
       singleRPReconstructionLabel_(iConfig.getParameter<std::string>("singleRPReconstructionLabel")),
       multiRPReconstructionLabel_(iConfig.getParameter<std::string>("multiRPReconstructionLabel")),
 
       localAngleXMin_(iConfig.getParameter<double>("localAngleXMin")),
       localAngleXMax_(iConfig.getParameter<double>("localAngleXMax")),
       localAngleYMin_(iConfig.getParameter<double>("localAngleYMin")),
       localAngleYMax_(iConfig.getParameter<double>("localAngleYMax")),
 
       max_n_timing_tracks_(iConfig.getParameter<unsigned int>("max_n_timing_tracks")),
       default_time_(iConfig.getParameter<double>("default_time")),
 
       algorithm_(iConfig.getParameter<bool>("fitVtxY"),
                  iConfig.getParameter<bool>("useImprovedInitialEstimate"),
                  iConfig.getParameter<std::string>("multiRPAlgorithm"),
                  verbosity_),
       opticsValid_(false),
       lhcInfoPerLSToken_(esConsumes<LHCInfoPerLS, LHCInfoPerLSRcd>(edm::ESInputTag("", lhcInfoPerLSLabel_))),
       lhcInfoPerFillToken_(esConsumes<LHCInfoPerFill, LHCInfoPerFillRcd>(edm::ESInputTag("", lhcInfoPerFillLabel_))),
       lhcInfoToken_(esConsumes<LHCInfo, LHCInfoRcd>(edm::ESInputTag("", lhcInfoLabel_))),
       opticalFunctionsToken_(esConsumes<LHCInterpolatedOpticalFunctionsSetCollection, CTPPSInterpolatedOpticsRcd>(
           edm::ESInputTag("", opticsLabel_))),
       geometryToken_(esConsumes<CTPPSGeometry, VeryForwardRealGeometryRecord>()),
       ppsAssociationCutsToken_(
           esConsumes<PPSAssociationCuts, PPSAssociationCutsRcd>(edm::ESInputTag("", ppsAssociationCutsLabel_))) {
   if (doSingleRPReconstruction_)
     produces<reco::ForwardProtonCollection>(singleRPReconstructionLabel_);
 
   if (doMultiRPReconstruction_)
     produces<reco::ForwardProtonCollection>(multiRPReconstructionLabel_);
 }

◆ ~CTPPSProtonProducer()

CTPPSProtonProducer::~CTPPSProtonProducer ( )

overridedefault

Member Function Documentation

◆ fillDescriptions()

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

static

Definition at line 141 of file CTPPSProtonProducer.cc.

References edm::ConfigurationDescriptions::add(), DiMuonV_cfg::config, submitPVResolutionJobs::desc, ProducerED_cfi::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                      {
   edm::ParameterSetDescription desc;
 
   desc.add<edm::InputTag>("tagLocalTrackLite", edm::InputTag("ctppsLocalTrackLiteProducer"))
       ->setComment("specification of the input lite-track collection");
 
   desc.add<bool>("pixelDiscardBXShiftedTracks", false)
       ->setComment("whether to discard pixel tracks built from BX-shifted planes");
 
   desc.add<std::string>("lhcInfoPerFillLabel", "")->setComment("label of the LHCInfoPerFill record");
   desc.add<std::string>("lhcInfoPerLSLabel", "")->setComment("label of the LHCInfoPerLS record");
   desc.add<std::string>("lhcInfoLabel", "")->setComment("label of the LHCInfo record");
   desc.add<bool>("useNewLHCInfo", false)->setComment("flag whether to use new LHCInfoPer* records or old LHCInfo");
 
   desc.add<std::string>("opticsLabel", "")->setComment("label of the optics record");
   desc.add<std::string>("ppsAssociationCutsLabel", "")->setComment("label of the association cuts record");
 
   desc.addUntracked<unsigned int>("verbosity", 0)->setComment("verbosity level");
 
   desc.add<bool>("doSingleRPReconstruction", true)
       ->setComment("flag whether to apply single-RP reconstruction strategy");
 
   desc.add<bool>("doMultiRPReconstruction", true)->setComment("flag whether to apply multi-RP reconstruction strategy");
 
   desc.add<std::string>("singleRPReconstructionLabel", "singleRP")
       ->setComment("output label for single-RP reconstruction products");
 
   desc.add<std::string>("multiRPReconstructionLabel", "multiRP")
       ->setComment("output label for multi-RP reconstruction products");
 
   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)");
 
   std::vector<edm::ParameterSet> config;
 
   desc.add<unsigned int>("max_n_timing_tracks", 5)->setComment("maximum number of timing tracks per RP");
 
   desc.add<double>("default_time", 0.)->setComment("proton time to be used when no timing information available");
 
   desc.add<bool>("fitVtxY", true)
       ->setComment("for multi-RP reconstruction, flag whether y* should be free fit parameter");
 
   desc.add<bool>("useImprovedInitialEstimate", true)
       ->setComment(
           "for multi-RP reconstruction, flag whether a quadratic estimate of the initial point should be used");
 
   desc.add<std::string>("multiRPAlgorithm", "chi2")
       ->setComment("algorithm for multi-RP reco, options include chi2, newton, anal-iter");
 
   descriptions.add("ctppsProtonsDefault", desc);
 }

◆ produce()

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

overrideprivate

Definition at line 197 of file CTPPSProtonProducer.cc.

References funct::abs(), algorithm_, allShiftedPlanes, edm::ESWatcher< T >::check(), LHCInfoCombined::crossingAngle(), alignCSCRings::de_x, default_time_, doMultiRPReconstruction_, doSingleRPReconstruction_, LHCInfoCombined::energy, geometryToken_, PPSAssociationCuts::getAssociationCuts(), edm::EventSetup::getHandle(), mps_fire::i, heavyIonCSV_trainingSettings::idx, iEvent, dqmdumpme::indices, ProtonReconstructionAlgorithm::init(), dqmiolumiharvest::j, lhcInfoPerFillToken_, lhcInfoPerLSToken_, lhcInfoToken_, localAngleXMax_, localAngleXMin_, localAngleYMax_, localAngleYMin_, max_n_timing_tracks_, mixedPlanes, eostools::move(), multiRPReconstructionLabel_, opticalFunctionsToken_, opticsValid_, opticsWatcher_, AlCaHLTBitMon_ParallelJobs::p, pixelDiscardBXShiftedTracks_, ppsAssociationCutsToken_, edm::RefVector< C, T, F >::push_back(), alignCSCRings::r, ProtonReconstructionAlgorithm::reconstructFromMultiRP(), ProtonReconstructionAlgorithm::reconstructFromSingleRP(), ProtonReconstructionAlgorithm::release(), simPPS2016_cfi::rpIds, CTPPSGeometry::rpTranslation(), CTPPSDetId::sdTrackingPixel, CTPPSDetId::sdTrackingStrip, reco::ForwardProton::setContributingLocalTracks(), reco::ForwardProton::setTime(), reco::ForwardProton::setTimeError(), singleRPReconstructionLabel_, mathSSE::sqrt(), hcalRecHitTable_cff::time, tracksToken_, useNewLHCInfo_, verbosity_, w(), and z.

                                                                                {
   // get input
   edm::Handle<CTPPSLocalTrackLiteCollection> hTracks;
   iEvent.getByToken(tracksToken_, hTracks);
 
   // book output
   std::unique_ptr<reco::ForwardProtonCollection> pOutSingleRP(new reco::ForwardProtonCollection);
   std::unique_ptr<reco::ForwardProtonCollection> pOutMultiRP(new reco::ForwardProtonCollection);
 
   // continue only if there is something to process
   // NB: this avoids loading (possibly non-existing) conditions in workflows without proton data
   if (!hTracks->empty()) {
     // get conditions
     LHCInfoCombined lhcInfoCombined(iSetup, lhcInfoPerLSToken_, lhcInfoPerFillToken_, lhcInfoToken_, useNewLHCInfo_);
 
     edm::ESHandle<LHCInterpolatedOpticalFunctionsSetCollection> hOpticalFunctions =
         iSetup.getHandle(opticalFunctionsToken_);
 
     edm::ESHandle<CTPPSGeometry> hGeometry = iSetup.getHandle(geometryToken_);
 
     edm::ESHandle<PPSAssociationCuts> ppsAssociationCuts = iSetup.getHandle(ppsAssociationCutsToken_);
 
     // re-initialise algorithm upon crossing-angle change
     if (opticsWatcher_.check(iSetup)) {
       if (hOpticalFunctions->empty()) {
         edm::LogInfo("CTPPSProtonProducer") << "No optical functions available, reconstruction disabled.";
         algorithm_.release();
         opticsValid_ = false;
       } else {
         algorithm_.init(*hOpticalFunctions);
         opticsValid_ = true;
       }
     }
 
     // do reconstruction only if optics is valid
     if (opticsValid_) {
       // prepare log
       std::ostringstream ssLog;
       if (verbosity_)
         ssLog << "* input tracks:" << std::endl;
 
       // select tracks with small local angles, split them by LHC sector and tracker/timing RPs
       std::map<unsigned int, std::vector<unsigned int>> trackingSelection, timingSelection;
 
       for (unsigned int idx = 0; idx < hTracks->size(); ++idx) {
         const auto &tr = hTracks->at(idx);
 
         if (tr.tx() < localAngleXMin_ || tr.tx() > localAngleXMax_ || tr.ty() < localAngleYMin_ ||
             tr.ty() > localAngleYMax_)
           continue;
 
         if (pixelDiscardBXShiftedTracks_) {
           if (tr.pixelTrackRecoInfo() == CTPPSpixelLocalTrackReconstructionInfo::allShiftedPlanes ||
               tr.pixelTrackRecoInfo() == CTPPSpixelLocalTrackReconstructionInfo::mixedPlanes)
             continue;
         }
 
         const CTPPSDetId rpId(tr.rpId());
 
         if (verbosity_)
           ssLog << "\t"
                 << "[" << idx << "] " << tr.rpId() << " (" << (rpId.arm() * 100 + rpId.station() * 10 + rpId.rp())
                 << "): "
                 << "x=" << tr.x() << " +- " << tr.xUnc() << " mm, "
                 << "y=" << tr.y() << " +- " << tr.yUnc() << " mm" << std::endl;
 
         const bool trackerRP =
             (rpId.subdetId() == CTPPSDetId::sdTrackingStrip || rpId.subdetId() == CTPPSDetId::sdTrackingPixel);
 
         if (trackerRP)
           trackingSelection[rpId.arm()].push_back(idx);
         else
           timingSelection[rpId.arm()].push_back(idx);
       }
 
       // process each arm
       for (const auto &arm_it : trackingSelection) {
         const auto &indices = arm_it.second;
 
         const auto &ac = ppsAssociationCuts->getAssociationCuts(arm_it.first);
 
         // do single-RP reco if needed
         std::map<unsigned int, reco::ForwardProton> singleRPResultsIndexed;
         if (doSingleRPReconstruction_ || ac.isApplied(ac.qXi) || ac.isApplied(ac.qThetaY)) {
           for (const auto &idx : indices) {
             if (verbosity_)
               ssLog << std::endl << "* reconstruction from track " << idx << std::endl;
 
             singleRPResultsIndexed[idx] =
                 algorithm_.reconstructFromSingleRP(CTPPSLocalTrackLiteRef(hTracks, idx), lhcInfoCombined.energy, ssLog);
           }
         }
 
         // check that exactly two tracking RPs are involved
         //    - 1 is insufficient for multi-RP reconstruction
         //    - PPS did not use more than 2 tracking RPs per arm -> algorithms are tuned to this
         std::set<unsigned int> rpIds;
         for (const auto &idx : indices)
           rpIds.insert(hTracks->at(idx).rpId());
 
         // do multi-RP reco if chosen
         if (doMultiRPReconstruction_ && rpIds.size() == 2) {
           // find matching track pairs from different tracking RPs, ordered: i=near, j=far RP
           std::vector<std::pair<unsigned int, unsigned int>> idx_pairs;
           std::map<unsigned int, unsigned int> idx_pair_multiplicity;
           for (const auto &i : indices) {
             for (const auto &j : indices) {
               const auto &tr_i = hTracks->at(i);
               const auto &tr_j = hTracks->at(j);
 
               const double z_i = hGeometry->rpTranslation(tr_i.rpId()).z();
               const double z_j = hGeometry->rpTranslation(tr_j.rpId()).z();
 
               const auto &pr_i = singleRPResultsIndexed[i];
               const auto &pr_j = singleRPResultsIndexed[j];
 
               if (tr_i.rpId() == tr_j.rpId())
                 continue;
 
               if (std::abs(z_i) >= std::abs(z_j))
                 continue;
 
               bool matching = true;
 
               if (!ac.isSatisfied(ac.qX, tr_i.x(), tr_i.y(), lhcInfoCombined.crossingAngle(), tr_i.x() - tr_j.x()))
                 matching = false;
               else if (!ac.isSatisfied(ac.qY, tr_i.x(), tr_i.y(), lhcInfoCombined.crossingAngle(), tr_i.y() - tr_j.y()))
                 matching = false;
               else if (!ac.isSatisfied(
                            ac.qXi, tr_i.x(), tr_i.y(), lhcInfoCombined.crossingAngle(), pr_i.xi() - pr_j.xi()))
                 matching = false;
               else if (!ac.isSatisfied(ac.qThetaY,
                                        tr_i.x(),
                                        tr_i.y(),
                                        lhcInfoCombined.crossingAngle(),
                                        pr_i.thetaY() - pr_j.thetaY()))
                 matching = false;
 
               if (!matching)
                 continue;
 
               idx_pairs.emplace_back(i, j);
               idx_pair_multiplicity[i]++;
               idx_pair_multiplicity[j]++;
             }
           }
 
           // evaluate track multiplicity in each timing RP
           std::map<unsigned int, unsigned int> timing_RP_track_multiplicity;
           for (const auto &ti : timingSelection[arm_it.first]) {
             const auto &tr = hTracks->at(ti);
             timing_RP_track_multiplicity[tr.rpId()]++;
           }
 
           // associate tracking-RP pairs with timing-RP tracks
           std::map<unsigned int, std::vector<unsigned int>> matched_timing_track_indices;
           std::map<unsigned int, unsigned int> matched_timing_track_multiplicity;
           for (unsigned int pr_idx = 0; pr_idx < idx_pairs.size(); ++pr_idx) {
             const auto &i = idx_pairs[pr_idx].first;
             const auto &j = idx_pairs[pr_idx].second;
 
             // skip non-unique associations
             if (idx_pair_multiplicity[i] > 1 || idx_pair_multiplicity[j] > 1)
               continue;
 
             const auto &tr_i = hTracks->at(i);
             const auto &tr_j = hTracks->at(j);
 
             const double z_i = hGeometry->rpTranslation(tr_i.rpId()).z();
             const double z_j = hGeometry->rpTranslation(tr_j.rpId()).z();
 
             for (const auto &ti : timingSelection[arm_it.first]) {
               const auto &tr_ti = hTracks->at(ti);
 
               // skip if timing RP saturated (high track multiplicity)
               if (timing_RP_track_multiplicity[tr_ti.rpId()] > max_n_timing_tracks_)
                 continue;
 
               // interpolation from tracking RPs
               const double z_ti = hGeometry->rpTranslation(tr_ti.rpId()).z();
               const double f_i = (z_ti - z_j) / (z_i - z_j), f_j = (z_i - z_ti) / (z_i - z_j);
               const double x_inter = f_i * tr_i.x() + f_j * tr_j.x();
               const double x_inter_unc_sq =
                   f_i * f_i * tr_i.xUnc() * tr_i.xUnc() + f_j * f_j * tr_j.xUnc() * tr_j.xUnc();
 
               const double de_x = tr_ti.x() - x_inter;
               const double de_x_unc = sqrt(tr_ti.xUnc() * tr_ti.xUnc() + x_inter_unc_sq);
               const double r = (de_x_unc > 0.) ? de_x / de_x_unc : 1E100;
 
               const bool matching = (ac.getTiTrMin() < r && r < ac.getTiTrMax());
 
               if (verbosity_)
                 ssLog << "ti=" << ti << ", i=" << i << ", j=" << j << " | z_ti=" << z_ti << ", z_i=" << z_i
                       << ", z_j=" << z_j << " | x_ti=" << tr_ti.x() << ", x_inter=" << x_inter << ", de_x=" << de_x
                       << ", de_x_unc=" << de_x_unc << ", matching=" << matching << std::endl;
 
               if (!matching)
                 continue;
 
               matched_timing_track_indices[pr_idx].push_back(ti);
               matched_timing_track_multiplicity[ti]++;
             }
           }
 
           // process associated tracks
           for (unsigned int pr_idx = 0; pr_idx < idx_pairs.size(); ++pr_idx) {
             const auto &i = idx_pairs[pr_idx].first;
             const auto &j = idx_pairs[pr_idx].second;
 
             // skip non-unique associations of tracking-RP tracks
             if (idx_pair_multiplicity[i] > 1 || idx_pair_multiplicity[j] > 1)
               continue;
 
             if (verbosity_)
               ssLog << std::endl
                     << "* reconstruction from tracking-RP tracks: " << i << ", " << j << " and timing-RP tracks: ";
 
             // buffer contributing tracks
             CTPPSLocalTrackLiteRefVector sel_tracks;
             sel_tracks.push_back(CTPPSLocalTrackLiteRef(hTracks, i));
             sel_tracks.push_back(CTPPSLocalTrackLiteRef(hTracks, j));
 
             CTPPSLocalTrackLiteRefVector sel_track_for_kin_reco = sel_tracks;
 
             // process timing-RP data
             double sw = 0., swt = 0.;
             for (const auto &ti : matched_timing_track_indices[pr_idx]) {
               // skip non-unique associations of timing-RP tracks
               if (matched_timing_track_multiplicity[ti] > 1)
                 continue;
 
               sel_tracks.push_back(CTPPSLocalTrackLiteRef(hTracks, ti));
 
               if (verbosity_)
                 ssLog << ti << ", ";
 
               const auto &tr = hTracks->at(ti);
               const double t_unc = tr.timeUnc();
               const double w = (t_unc > 0.) ? 1. / t_unc / t_unc : 1.;
               sw += w;
               swt += w * tr.time();
             }
 
             float time = default_time_, time_unc = 0.;
             if (sw > 0.) {
               time = swt / sw;
               time_unc = 1. / sqrt(sw);
             }
 
             if (verbosity_)
               ssLog << std::endl << "    time = " << time << " +- " << time_unc << std::endl;
 
             // process tracking-RP data
             reco::ForwardProton proton =
                 algorithm_.reconstructFromMultiRP(sel_track_for_kin_reco, lhcInfoCombined.energy, ssLog);
 
             // save combined output
             proton.setContributingLocalTracks(sel_tracks);
             proton.setTime(time);
             proton.setTimeError(time_unc);
 
             pOutMultiRP->emplace_back(proton);
           }
         }
 
         // save single-RP results (un-indexed)
         for (const auto &p : singleRPResultsIndexed)
           pOutSingleRP->emplace_back(p.second);
       }
 
       // dump log
       if (verbosity_)
         edm::LogInfo("CTPPSProtonProducer") << ssLog.str();
     }
   }
 
   // save output
   if (doSingleRPReconstruction_)
     iEvent.put(std::move(pOutSingleRP), singleRPReconstructionLabel_);
 
   if (doMultiRPReconstruction_)
     iEvent.put(std::move(pOutMultiRP), multiRPReconstructionLabel_);
 }

Member Data Documentation

◆ algorithm_

ProtonReconstructionAlgorithm CTPPSProtonProducer::algorithm_

private

Definition at line 79 of file CTPPSProtonProducer.cc.

Referenced by produce().

◆ default_time_

double CTPPSProtonProducer::default_time_

private

Definition at line 77 of file CTPPSProtonProducer.cc.

Referenced by produce().

◆ doMultiRPReconstruction_

bool CTPPSProtonProducer::doMultiRPReconstruction_

private

Definition at line 69 of file CTPPSProtonProducer.cc.

Referenced by CTPPSProtonProducer(), and produce().

◆ doSingleRPReconstruction_

bool CTPPSProtonProducer::doSingleRPReconstruction_

private

Definition at line 68 of file CTPPSProtonProducer.cc.

Referenced by CTPPSProtonProducer(), and produce().

◆ geometryToken_

const edm::ESGetToken<CTPPSGeometry, VeryForwardRealGeometryRecord> CTPPSProtonProducer::geometryToken_

private

Definition at line 88 of file CTPPSProtonProducer.cc.

Referenced by produce().

◆ lhcInfoLabel_

const std::string CTPPSProtonProducer::lhcInfoLabel_

private

Definition at line 61 of file CTPPSProtonProducer.cc.

◆ lhcInfoPerFillLabel_

const std::string CTPPSProtonProducer::lhcInfoPerFillLabel_

private

Definition at line 60 of file CTPPSProtonProducer.cc.

◆ lhcInfoPerFillToken_

const edm::ESGetToken<LHCInfoPerFill, LHCInfoPerFillRcd> CTPPSProtonProducer::lhcInfoPerFillToken_

private

Definition at line 85 of file CTPPSProtonProducer.cc.

Referenced by produce().

◆ lhcInfoPerLSLabel_

const std::string CTPPSProtonProducer::lhcInfoPerLSLabel_

private

Definition at line 59 of file CTPPSProtonProducer.cc.

◆ lhcInfoPerLSToken_

const edm::ESGetToken<LHCInfoPerLS, LHCInfoPerLSRcd> CTPPSProtonProducer::lhcInfoPerLSToken_

private

Definition at line 84 of file CTPPSProtonProducer.cc.

Referenced by produce().

◆ lhcInfoToken_

const edm::ESGetToken<LHCInfo, LHCInfoRcd> CTPPSProtonProducer::lhcInfoToken_

private

Definition at line 86 of file CTPPSProtonProducer.cc.

Referenced by produce().

◆ localAngleXMax_

double CTPPSProtonProducer::localAngleXMax_

private

Definition at line 74 of file CTPPSProtonProducer.cc.

Referenced by produce().

◆ localAngleXMin_

double CTPPSProtonProducer::localAngleXMin_

private

Definition at line 74 of file CTPPSProtonProducer.cc.

Referenced by produce().

◆ localAngleYMax_

double CTPPSProtonProducer::localAngleYMax_

private

Definition at line 74 of file CTPPSProtonProducer.cc.

Referenced by produce().

◆ localAngleYMin_

double CTPPSProtonProducer::localAngleYMin_

private

Definition at line 74 of file CTPPSProtonProducer.cc.

Referenced by produce().

◆ max_n_timing_tracks_

unsigned int CTPPSProtonProducer::max_n_timing_tracks_

private

Definition at line 76 of file CTPPSProtonProducer.cc.

Referenced by produce().

◆ multiRPReconstructionLabel_

std::string CTPPSProtonProducer::multiRPReconstructionLabel_

private

Definition at line 72 of file CTPPSProtonProducer.cc.

Referenced by CTPPSProtonProducer(), and produce().

◆ opticalFunctionsToken_

const edm::ESGetToken<LHCInterpolatedOpticalFunctionsSetCollection, CTPPSInterpolatedOpticsRcd> CTPPSProtonProducer::opticalFunctionsToken_

private

Definition at line 87 of file CTPPSProtonProducer.cc.

Referenced by produce().

◆ opticsLabel_

const std::string CTPPSProtonProducer::opticsLabel_

private

Definition at line 62 of file CTPPSProtonProducer.cc.

◆ opticsValid_

bool CTPPSProtonProducer::opticsValid_

private

Definition at line 81 of file CTPPSProtonProducer.cc.

Referenced by produce().

◆ opticsWatcher_

edm::ESWatcher<CTPPSInterpolatedOpticsRcd> CTPPSProtonProducer::opticsWatcher_

private

Definition at line 82 of file CTPPSProtonProducer.cc.

Referenced by produce().

◆ pixelDiscardBXShiftedTracks_

bool CTPPSProtonProducer::pixelDiscardBXShiftedTracks_

private

Definition at line 57 of file CTPPSProtonProducer.cc.

Referenced by produce().

◆ ppsAssociationCutsLabel_

const std::string CTPPSProtonProducer::ppsAssociationCutsLabel_

private

Definition at line 63 of file CTPPSProtonProducer.cc.

◆ ppsAssociationCutsToken_

const edm::ESGetToken<PPSAssociationCuts, PPSAssociationCutsRcd> CTPPSProtonProducer::ppsAssociationCutsToken_

private

Definition at line 89 of file CTPPSProtonProducer.cc.

Referenced by produce().

◆ singleRPReconstructionLabel_

std::string CTPPSProtonProducer::singleRPReconstructionLabel_

private

Definition at line 71 of file CTPPSProtonProducer.cc.

Referenced by CTPPSProtonProducer(), and produce().

◆ tracksToken_

edm::EDGetTokenT<CTPPSLocalTrackLiteCollection> CTPPSProtonProducer::tracksToken_

private

Definition at line 55 of file CTPPSProtonProducer.cc.

Referenced by produce().

◆ useNewLHCInfo_

const bool CTPPSProtonProducer::useNewLHCInfo_

private

Definition at line 64 of file CTPPSProtonProducer.cc.

Referenced by produce().

◆ verbosity_

unsigned int CTPPSProtonProducer::verbosity_

private

Definition at line 66 of file CTPPSProtonProducer.cc.

Referenced by produce().

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ CTPPSProtonProducer()

◆ ~CTPPSProtonProducer()

Member Function Documentation

◆ fillDescriptions()

◆ produce()

Member Data Documentation

◆ algorithm_

◆ default_time_

◆ doMultiRPReconstruction_

◆ doSingleRPReconstruction_

◆ geometryToken_

◆ lhcInfoLabel_

◆ lhcInfoPerFillLabel_

◆ lhcInfoPerFillToken_

◆ lhcInfoPerLSLabel_

◆ lhcInfoPerLSToken_

◆ lhcInfoToken_

◆ localAngleXMax_

◆ localAngleXMin_

◆ localAngleYMax_

◆ localAngleYMin_

◆ max_n_timing_tracks_

◆ multiRPReconstructionLabel_

◆ opticalFunctionsToken_

◆ opticsLabel_

◆ opticsValid_

◆ opticsWatcher_

◆ pixelDiscardBXShiftedTracks_

◆ ppsAssociationCutsLabel_

◆ ppsAssociationCutsToken_

◆ singleRPReconstructionLabel_

◆ tracksToken_

◆ useNewLHCInfo_

◆ verbosity_