CTPPSProtonProducer Class Reference

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(), DMR_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("ctppsProtons", 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_, TtSemiLepJetCombMVATrainer_cfi::matching, 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().