CMS 3D CMS Logo
PFProducer.cc
Go to the documentation of this file.
1 #include "FWCore/Framework/interface/stream/EDProducer.h"
2 #include "FWCore/Framework/interface/Event.h"
3 #include "FWCore/Utilities/interface/EDPutToken.h"
4 #include "FWCore/Framework/interface/MakerMacros.h"
5 #include "FWCore/ParameterSet/interface/ParameterSet.h"
6 #include "DataFormats/EgammaCandidates/interface/GsfElectron.h"
7 #include "DataFormats/ParticleFlowReco/interface/PFRecHit.h"
8 #include "DataFormats/ParticleFlowReco/interface/PFBlockElementSuperCluster.h"
9 #include "DataFormats/Common/interface/ValueMap.h"
10 #include "RecoParticleFlow/PFProducer/interface/PFEGammaFilters.h"
11 #include "RecoParticleFlow/PFProducer/interface/PFAlgo.h"
12 #include "FWCore/Framework/interface/MakerMacros.h"
13 #include "FWCore/Framework/interface/ESHandle.h"
14 #include "FWCore/Framework/interface/EventSetup.h"
15 #include "FWCore/MessageLogger/interface/MessageLogger.h"
16 #include "RecoParticleFlow/PFClusterTools/interface/PFEnergyCalibration.h"
17 #include "RecoParticleFlow/PFClusterTools/interface/PFEnergyCalibrationHF.h"
18 #include "CondFormats/PhysicsToolsObjects/interface/PerformancePayloadFromTFormula.h"
19 #include "CondFormats/DataRecord/interface/PFCalibrationRcd.h"
20 #include "CondFormats/DataRecord/interface/GBRWrapperRcd.h"
21 
22 #include <sstream>
23 #include <string>
24 
25 #include "TFile.h"
26 
36 class PFProducer : public edm::stream::EDProducer<> {
37 public:
38  explicit PFProducer(const edm::ParameterSet&);
39 
40  void produce(edm::Event&, const edm::EventSetup&) override;
41  void beginRun(const edm::Run&, const edm::EventSetup&) override;
42 
43  static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
44 
45 private:
46  const edm::EDPutTokenT<reco::PFCandidateCollection> pfCandidatesToken_;
47  const edm::EDPutTokenT<reco::PFCandidateCollection> pfCleanedCandidatesToken_;
48 
49  const edm::EDGetTokenT<reco::PFBlockCollection> inputTagBlocks_;
50  edm::EDGetTokenT<reco::MuonCollection> inputTagMuons_;
51  edm::EDGetTokenT<reco::VertexCollection> vertices_;
52  edm::EDGetTokenT<reco::GsfElectronCollection> inputTagEgammaElectrons_;
53 
54  std::vector<edm::EDGetTokenT<reco::PFRecHitCollection>> inputTagCleanedHF_;
55  std::string electronExtraOutputCol_;
56  std::string photonExtraOutputCol_;
57 
58  // NEW EGamma Filters
59  edm::EDGetTokenT<edm::ValueMap<reco::GsfElectronRef>> inputTagValueMapGedElectrons_;
60  edm::EDGetTokenT<edm::ValueMap<reco::PhotonRef>> inputTagValueMapGedPhotons_;
61  edm::EDGetTokenT<edm::View<reco::PFCandidate>> inputTagPFEGammaCandidates_;
62 
63  bool use_EGammaFilters_;
64  std::unique_ptr<PFEGammaFilters> pfegamma_ = nullptr;
65 
66  //Use of HO clusters and links in PF Reconstruction
67  bool useHO_;
68 
70  bool verbose_;
71 
72  // Post muon cleaning ?
73  bool postMuonCleaning_;
74 
75  // what about e/g electrons ?
76  bool useEGammaElectrons_;
77 
78  // Use vertices for Neutral particles ?
79  bool useVerticesForNeutral_;
80 
81  // Take PF cluster calibrations from Global Tag ?
82  bool useCalibrationsFromDB_;
83  std::string calibrationsLabel_;
84 
85  bool postHFCleaning_;
86  // Name of the calibration functions to read from the database
87  // std::vector<std::string> fToRead;
88 
89  // calibrations
90  PFEnergyCalibration pfEnergyCalibration_;
91  PFEnergyCalibrationHF pfEnergyCalibrationHF_;
92 
94  PFAlgo pfAlgo_;
95 };
96 
97 DEFINE_FWK_MODULE(PFProducer);
98 
99 using namespace std;
100 using namespace edm;
101 
102 PFProducer::PFProducer(const edm::ParameterSet& iConfig)
103  : pfCandidatesToken_{produces<reco::PFCandidateCollection>()},
104  pfCleanedCandidatesToken_{produces<reco::PFCandidateCollection>("CleanedHF")},
105  inputTagBlocks_(consumes<reco::PFBlockCollection>(iConfig.getParameter<InputTag>("blocks"))),
106  pfEnergyCalibrationHF_(iConfig.getParameter<bool>("calibHF_use"),
107  iConfig.getParameter<std::vector<double>>("calibHF_eta_step"),
108  iConfig.getParameter<std::vector<double>>("calibHF_a_EMonly"),
109  iConfig.getParameter<std::vector<double>>("calibHF_b_HADonly"),
110  iConfig.getParameter<std::vector<double>>("calibHF_a_EMHAD"),
111  iConfig.getParameter<std::vector<double>>("calibHF_b_EMHAD")),
112  pfAlgo_(iConfig.getParameter<double>("pf_nsigma_ECAL"),
113  iConfig.getParameter<double>("pf_nsigma_HCAL"),
114  iConfig.getParameter<double>("pf_nsigma_HFEM"),
115  iConfig.getParameter<double>("pf_nsigma_HFHAD"),
116  iConfig.getParameter<std::vector<double>>("resolHF_square"),
117  pfEnergyCalibration_,
118  pfEnergyCalibrationHF_,
119  iConfig) {
120  //Post cleaning of the muons
121  inputTagMuons_ = consumes<reco::MuonCollection>(iConfig.getParameter<InputTag>("muons"));
122  postMuonCleaning_ = iConfig.getParameter<bool>("postMuonCleaning");
123 
124  if (iConfig.existsAs<bool>("useEGammaFilters")) {
125  use_EGammaFilters_ = iConfig.getParameter<bool>("useEGammaFilters");
126  } else {
127  use_EGammaFilters_ = false;
128  }
129 
130  useEGammaElectrons_ = iConfig.getParameter<bool>("useEGammaElectrons");
131 
132  if (useEGammaElectrons_) {
133  inputTagEgammaElectrons_ =
134  consumes<reco::GsfElectronCollection>(iConfig.getParameter<edm::InputTag>("egammaElectrons"));
135  }
136 
137  // register products
138  produces<reco::PFCandidateCollection>("CleanedCosmicsMuons");
139  produces<reco::PFCandidateCollection>("CleanedTrackerAndGlobalMuons");
140  produces<reco::PFCandidateCollection>("CleanedFakeMuons");
141  produces<reco::PFCandidateCollection>("CleanedPunchThroughMuons");
142  produces<reco::PFCandidateCollection>("CleanedPunchThroughNeutralHadrons");
143  produces<reco::PFCandidateCollection>("AddedMuonsAndHadrons");
144 
145  // Reading new EGamma selection cuts
146  bool useProtectionsForJetMET(false);
147  // Reading new EGamma ubiased collections and value maps
148  if (use_EGammaFilters_) {
149  inputTagPFEGammaCandidates_ =
150  consumes<edm::View<reco::PFCandidate>>((iConfig.getParameter<edm::InputTag>("PFEGammaCandidates")));
151  inputTagValueMapGedElectrons_ =
152  consumes<edm::ValueMap<reco::GsfElectronRef>>(iConfig.getParameter<edm::InputTag>("GedElectronValueMap"));
153  inputTagValueMapGedPhotons_ =
154  consumes<edm::ValueMap<reco::PhotonRef>>(iConfig.getParameter<edm::InputTag>("GedPhotonValueMap"));
155  useProtectionsForJetMET = iConfig.getParameter<bool>("useProtectionsForJetMET");
156  }
157 
158  //Secondary tracks and displaced vertices parameters
159 
160  bool rejectTracks_Bad = iConfig.getParameter<bool>("rejectTracks_Bad");
161 
162  bool rejectTracks_Step45 = iConfig.getParameter<bool>("rejectTracks_Step45");
163 
164  bool usePFNuclearInteractions = iConfig.getParameter<bool>("usePFNuclearInteractions");
165 
166  bool usePFConversions = iConfig.getParameter<bool>("usePFConversions");
167 
168  bool usePFDecays = iConfig.getParameter<bool>("usePFDecays");
169 
170  double dptRel_DispVtx = iConfig.getParameter<double>("dptRel_DispVtx");
171 
172  useCalibrationsFromDB_ = iConfig.getParameter<bool>("useCalibrationsFromDB");
173 
174  if (useCalibrationsFromDB_)
175  calibrationsLabel_ = iConfig.getParameter<std::string>("calibrationsLabel");
176 
177  // EGamma filters
178  pfAlgo_.setEGammaParameters(use_EGammaFilters_, useProtectionsForJetMET);
179 
180  if (use_EGammaFilters_) {
181  const edm::ParameterSet pfEGammaFiltersParams =
182  iConfig.getParameter<edm::ParameterSet>("PFEGammaFiltersParameters");
183  pfegamma_ = std::make_unique<PFEGammaFilters>(pfEGammaFiltersParams);
184  }
185 
186  // Secondary tracks and displaced vertices parameters
187  pfAlgo_.setDisplacedVerticesParameters(
188  rejectTracks_Bad, rejectTracks_Step45, usePFNuclearInteractions, usePFConversions, usePFDecays, dptRel_DispVtx);
189 
190  if (usePFNuclearInteractions)
191  pfAlgo_.setCandConnectorParameters(iConfig.getParameter<edm::ParameterSet>("iCfgCandConnector"));
192 
193  // Post cleaning of the HF
194  postHFCleaning_ = iConfig.getParameter<bool>("postHFCleaning");
195  const edm::ParameterSet pfHFCleaningParams = iConfig.getParameter<edm::ParameterSet>("PFHFCleaningParameters");
196 
197  // Set post HF cleaning muon parameters
198  pfAlgo_.setPostHFCleaningParameters(postHFCleaning_, pfHFCleaningParams);
199 
200  // Input tags for HF cleaned rechits
201  std::vector<edm::InputTag> tags = iConfig.getParameter<std::vector<edm::InputTag>>("cleanedHF");
202  for (unsigned int i = 0; i < tags.size(); ++i)
203  inputTagCleanedHF_.push_back(consumes<reco::PFRecHitCollection>(tags[i]));
204  //MIKE: Vertex Parameters
205  vertices_ = consumes<reco::VertexCollection>(iConfig.getParameter<edm::InputTag>("vertexCollection"));
206  useVerticesForNeutral_ = iConfig.getParameter<bool>("useVerticesForNeutral");
207 
208  // Use HO clusters and links in the PF reconstruction
209  useHO_ = iConfig.getParameter<bool>("useHO");
210  pfAlgo_.setHOTag(useHO_);
211 
212  verbose_ = iConfig.getUntrackedParameter<bool>("verbose", false);
213 }
214 
215 void PFProducer::beginRun(const edm::Run& run, const edm::EventSetup& es) {
216  if (useCalibrationsFromDB_) {
217  // read the PFCalibration functions from the global tags
218  edm::ESHandle<PerformancePayload> perfH;
219  es.get<PFCalibrationRcd>().get(calibrationsLabel_, perfH);
220 
221  PerformancePayloadFromTFormula const* pfCalibrations =
222  static_cast<const PerformancePayloadFromTFormula*>(perfH.product());
223 
224  pfEnergyCalibration_.setCalibrationFunctions(pfCalibrations);
225  }
226 }
227 
228 void PFProducer::produce(Event& iEvent, const EventSetup& iSetup) {
229  LogDebug("PFProducer") << "START event: " << iEvent.id().event() << " in run " << iEvent.id().run() << endl;
230 
231  //Assign the PFAlgo Parameters
232  pfAlgo_.setPFVertexParameters(useVerticesForNeutral_, iEvent.get(vertices_));
233 
234  // get the collection of blocks
235  auto blocks = iEvent.getHandle(inputTagBlocks_);
236  assert(blocks.isValid());
237 
238  // get the collection of muons
239  if (postMuonCleaning_)
240  pfAlgo_.setMuonHandle(iEvent.getHandle(inputTagMuons_));
241 
242  if (use_EGammaFilters_)
243  pfAlgo_.setEGammaCollections(iEvent.get(inputTagPFEGammaCandidates_),
244  iEvent.get(inputTagValueMapGedElectrons_),
245  iEvent.get(inputTagValueMapGedPhotons_));
246 
247  LogDebug("PFProducer") << "particle flow is starting" << endl;
248 
249  pfAlgo_.reconstructParticles(blocks, pfegamma_.get());
250 
251  if (verbose_) {
252  ostringstream str;
253  str << pfAlgo_ << endl;
254  LogInfo("PFProducer") << str.str() << endl;
255  }
256 
257  // Check HF overcleaning
258  if (postHFCleaning_) {
259  reco::PFRecHitCollection hfCopy;
260  for (unsigned ihf = 0; ihf < inputTagCleanedHF_.size(); ++ihf) {
261  Handle<reco::PFRecHitCollection> hfCleaned;
262  bool foundHF = iEvent.getByToken(inputTagCleanedHF_[ihf], hfCleaned);
263  if (!foundHF)
264  continue;
265  for (unsigned jhf = 0; jhf < (*hfCleaned).size(); ++jhf) {
266  hfCopy.push_back((*hfCleaned)[jhf]);
267  }
268  }
269  pfAlgo_.checkCleaning(hfCopy);
270  }
271 
272  // Save the final PFCandidate collection
273  auto pOutputCandidateCollection = pfAlgo_.makeConnectedCandidates();
274 
275  LogDebug("PFProducer") << "particle flow: putting products in the event";
276  if (verbose_) {
277  int nC = 0;
278  ostringstream ss;
279  for (auto const& cand : pOutputCandidateCollection) {
280  nC++;
281  ss << " " << nC << ") pid=" << cand.particleId() << " pt=" << cand.pt() << endl;
282  }
283  LogDebug("PFProducer") << "Here the full list:" << endl << ss.str();
284  }
285 
286  // Write in the event
287  iEvent.emplace(pfCandidatesToken_, pOutputCandidateCollection);
288  iEvent.emplace(pfCleanedCandidatesToken_, pfAlgo_.getCleanedCandidates());
289 
290  if (postMuonCleaning_) {
291  auto& muAlgo = *pfAlgo_.getPFMuonAlgo();
292  // Save cosmic cleaned muon candidates
293  iEvent.put(muAlgo.transferCleanedCosmicCandidates(), "CleanedCosmicsMuons");
294  // Save tracker/global cleaned muon candidates
295  iEvent.put(muAlgo.transferCleanedTrackerAndGlobalCandidates(), "CleanedTrackerAndGlobalMuons");
296  // Save fake cleaned muon candidates
297  iEvent.put(muAlgo.transferCleanedFakeCandidates(), "CleanedFakeMuons");
298  // Save punch-through cleaned muon candidates
299  iEvent.put(muAlgo.transferPunchThroughCleanedMuonCandidates(), "CleanedPunchThroughMuons");
300  // Save punch-through cleaned neutral hadron candidates
301  iEvent.put(muAlgo.transferPunchThroughCleanedHadronCandidates(), "CleanedPunchThroughNeutralHadrons");
302  // Save added muon candidates
303  iEvent.put(muAlgo.transferAddedMuonCandidates(), "AddedMuonsAndHadrons");
304  }
305 }
306 
307 void PFProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
308  edm::ParameterSetDescription desc;
309 
310  // Verbosity and debug flags
311  desc.addUntracked<bool>("verbose", false);
312  desc.addUntracked<bool>("debug", false);
313 
314  // PF Blocks label
315  desc.add<edm::InputTag>("blocks", edm::InputTag("particleFlowBlock"));
316 
317  // reco::muons label and Post Muon cleaning
318  desc.add<edm::InputTag>("muons", edm::InputTag("muons1stStep"));
319  desc.add<bool>("postMuonCleaning", true);
320 
321  // Vertices label
322  desc.add<edm::InputTag>("vertexCollection", edm::InputTag("offlinePrimaryVertices"));
323  desc.add<bool>("useVerticesForNeutral", true);
324 
325  // Use HO clusters in PF hadron reconstruction
326  desc.add<bool>("useHO", true);
327 
328  // EGamma-related
329  desc.add<edm::InputTag>("PFEGammaCandidates", edm::InputTag("particleFlowEGamma"));
330  desc.add<edm::InputTag>("GedElectronValueMap", {"gedGsfElectronValueMapsTmp"});
331  desc.add<edm::InputTag>("GedPhotonValueMap", edm::InputTag("gedPhotonsTmp", "valMapPFEgammaCandToPhoton"));
332 
333  desc.add<bool>("useEGammaElectrons", true);
334  desc.add<edm::InputTag>("egammaElectrons", edm::InputTag("mvaElectrons"));
335 
336  desc.add<bool>("useEGammaFilters", true);
337  desc.add<bool>("useProtectionsForJetMET", true); // Propagated to PFEGammaFilters
338 
339  // For PFEGammaFilters
340  edm::ParameterSetDescription psd_PFEGammaFilters;
341  PFEGammaFilters::fillPSetDescription(psd_PFEGammaFilters);
342  desc.add<edm::ParameterSetDescription>("PFEGammaFiltersParameters", psd_PFEGammaFilters);
343 
344  // Treatment of muons :
345  // Expected energy in ECAL and HCAL, and RMS
346  desc.add<std::vector<double>>("muon_HCAL", {3.0, 3.0});
347  desc.add<std::vector<double>>("muon_ECAL", {0.5, 0.5});
348  desc.add<std::vector<double>>("muon_HO", {0.9, 0.9});
349 
350  // For PFMuonAlgo
351  edm::ParameterSetDescription psd_PFMuonAlgo;
352  PFEGammaFilters::fillPSetDescription(psd_PFMuonAlgo);
353  desc.add<edm::ParameterSetDescription>("PFMuonAlgoParameters", psd_PFMuonAlgo);
354 
355  // Input displaced vertices
356  // It is strongly adviced to keep usePFNuclearInteractions = bCorrect
357  desc.add<bool>("rejectTracks_Bad", true);
358  desc.add<bool>("rejectTracks_Step45", true);
359 
360  desc.add<bool>("usePFNuclearInteractions", true);
361  desc.add<bool>("usePFConversions", true);
362  desc.add<bool>("usePFDecays", false);
363 
364  desc.add<double>("dptRel_DispVtx", 10.0);
365 
366  // PFCandConnector
367  edm::ParameterSetDescription psd_CandConnector;
368  PFCandConnector::fillPSetDescription(psd_CandConnector);
369  desc.add<edm::ParameterSetDescription>("iCfgCandConnector", psd_CandConnector);
370 
371  // Treatment of potential fake tracks
372  desc.add<double>("nsigma_TRACK", 1.0)->setComment("Number of sigmas for fake track detection");
373  // pt_Error: dont forget to modify also ptErrorSecondary if you modify this parameter
374  desc.add<double>("pt_Error", 1.0)
375  ->setComment("Absolute pt error to detect fake tracks in the first three iterations");
376  desc.add<std::vector<double>>("factors_45", {10.0, 100.0})
377  ->setComment("Factors to be applied in the four and fifth steps to the pt error");
378 
379  // Treatment of tracks in region of bad HCal
380  desc.add<double>("goodTrackDeadHcal_ptErrRel", 0.2)->setComment("trackRef->ptError()/trackRef->pt() < X");
381  desc.add<double>("goodTrackDeadHcal_chi2n", 5)->setComment("trackRef->normalizedChi2() < X");
382  desc.add<unsigned int>("goodTrackDeadHcal_layers", 4)
383  ->setComment("trackRef->hitPattern().trackerLayersWithMeasurement() >= X");
384  desc.add<double>("goodTrackDeadHcal_validFr", 0.5)->setComment("trackRef->validFraction() > X");
385  desc.add<double>("goodTrackDeadHcal_dxy", 0.5)->setComment("abs(trackRef->dxy(primaryVertex_.position())) < X [cm]");
386 
387  desc.add<double>("goodPixelTrackDeadHcal_minEta", 2.3)->setComment("abs(trackRef->eta()) > X");
388  desc.add<double>("goodPixelTrackDeadHcal_maxPt", 50.0)->setComment("trackRef->ptError()/trackRef->pt() < X");
389  desc.add<double>("goodPixelTrackDeadHcal_ptErrRel", 1.0)->setComment("trackRef->ptError()/trackRef->pt() < X");
390  desc.add<double>("goodPixelTrackDeadHcal_chi2n", 2)->setComment("trackRef->normalizedChi2() < X");
391  desc.add<int>("goodPixelTrackDeadHcal_maxLost3Hit", 0)
392  ->setComment(
393  "max missing outer hits for a track with 3 valid pixel layers (can set to -1 to reject all these tracks)");
394  desc.add<int>("goodPixelTrackDeadHcal_maxLost4Hit", 1)
395  ->setComment("max missing outer hits for a track with >= 4 valid pixel layers");
396  desc.add<double>("goodPixelTrackDeadHcal_dxy", 0.02)
397  ->setComment("abs(trackRef->dxy(primaryVertex_.position())) < X [cm] ");
398  desc.add<double>("goodPixelTrackDeadHcal_dz", 0.05)
399  ->setComment("abs(trackRef->dz(primaryVertex_.position())) < X [cm]");
400 
401  // number of sigmas for neutral energy detection
402  desc.add<double>("pf_nsigma_ECAL", 0.0);
403  desc.add<double>("pf_nsigma_HCAL", 1.0);
404  desc.add<double>("pf_nsigma_HFEM", 1.0);
405  desc.add<double>("pf_nsigma_HFHAD", 1.0);
406 
407  // ECAL/HCAL PF cluster calibration : take it from global tag ?
408  desc.add<bool>("useCalibrationsFromDB", true);
409  desc.add<std::string>("calibrationsLabel", "");
410 
411  // Post HF cleaning
412  desc.add<bool>("postHFCleaning", false);
413  {
414  edm::ParameterSetDescription psd_PFHFCleaning;
415  psd_PFHFCleaning.add<double>("minHFCleaningPt", 5.0)
416  ->setComment("Clean only objects with pt larger than this value");
417  psd_PFHFCleaning.add<double>("maxSignificance", 2.5)
418  ->setComment("Clean only if the initial MET/sqrt(sumet) is larger than this value");
419  psd_PFHFCleaning.add<double>("minSignificance", 2.5)
420  ->setComment("Clean only if the final MET/sqrt(sumet) is smaller than this value");
421  psd_PFHFCleaning.add<double>("minSignificanceReduction", 1.4)
422  ->setComment("Clean only if the significance reduction is larger than this value");
423  psd_PFHFCleaning.add<double>("maxDeltaPhiPt", 7.0)
424  ->setComment("Clean only if the MET and the to-be-cleaned object satisfy this DeltaPhi * Pt cut");
425  // (the MET angular resoution is in 1/MET)
426  psd_PFHFCleaning.add<double>("minDeltaMet", 0.4)
427  ->setComment(
428  "Clean only if the MET relative reduction from the to-be-cleaned object is larger than this value");
429  desc.add<edm::ParameterSetDescription>("PFHFCleaningParameters", psd_PFHFCleaning);
430  }
431 
432  // Check HF cleaning
433  desc.add<std::vector<edm::InputTag>>("cleanedHF",
434  {
435  edm::InputTag("particleFlowRecHitHF", "Cleaned"),
436  edm::InputTag("particleFlowClusterHF", "Cleaned"),
437  });
438 
439  // calibration parameters for HF:
440  desc.add<bool>("calibHF_use", false);
441  desc.add<std::vector<double>>("calibHF_eta_step", {0.0, 2.9, 3.0, 3.2, 4.2, 4.4, 4.6, 4.8, 5.2, 5.4});
442  desc.add<std::vector<double>>("calibHF_a_EMonly", {1., 1., 1., 1., 1., 1., 1., 1., 1., 1.});
443  desc.add<std::vector<double>>("calibHF_a_EMHAD", {1., 1., 1., 1., 1., 1., 1., 1., 1., 1.});
444  desc.add<std::vector<double>>("calibHF_b_HADonly", {1., 1., 1., 1., 1., 1., 1., 1., 1., 1.});
445  desc.add<std::vector<double>>("calibHF_b_EMHAD", {1., 1., 1., 1., 1., 1., 1., 1., 1., 1.});
446 
447  // resolution parameters for HF: EPJC 53(2008)139, doi:10.1140/epjc/s10052-007-0459-4
448  desc.add<std::vector<double>>("resolHF_square", {2.799 * 2.799, 0.114 * 0.114, 0.0 * 0.0})
449  ->setComment("HF resolution - stochastic, constant, noise term squares");
450 
451  descriptions.add("particleFlow", desc);
452 }
PerformancePayloadFromTFormula
Definition: PerformancePayloadFromTFormula.h:17
edm::ESHandle::product
T const * product() const
Definition: ESHandle.h:86
PFProducer::pfCandidatesToken_
const edm::EDPutTokenT< reco::PFCandidateCollection > pfCandidatesToken_
Definition: PFProducer.cc:46
PFProducer::useVerticesForNeutral_
bool useVerticesForNeutral_
Definition: PFProducer.cc:79
PFProducer::inputTagValueMapGedPhotons_
edm::EDGetTokenT< edm::ValueMap< reco::PhotonRef > > inputTagValueMapGedPhotons_
Definition: PFProducer.cc:60
mps_fire.i
i
Definition: mps_fire.py:355
edm::ParameterSetDescription::add
ParameterDescriptionBase * add(U const &iLabel, T const &value)
Definition: ParameterSetDescription.h:95
PFAlgo::reconstructParticles
void reconstructParticles(const reco::PFBlockHandle &blockHandle, PFEGammaFilters const *pfegamma)
reconstruct particles
Definition: PFAlgo.cc:132
MessageLogger.h
PFProducer::electronExtraOutputCol_
std::string electronExtraOutputCol_
Definition: PFProducer.cc:55
PFCalibrationRcd.h
ESHandle.h
PFProducer
Producer for particle flow reconstructed particles (PFCandidates)
Definition: PFProducer.cc:36
edm::Run
Definition: Run.h:45
edm::EDGetTokenT< reco::PFBlockCollection >
edm
HLT enums.
Definition: AlignableModifier.h:19
edm::EDPutTokenT< reco::PFCandidateCollection >
GBRWrapperRcd.h
edm::LogInfo
Definition: MessageLogger.h:254
edm::ParameterSetDescription
Definition: ParameterSetDescription.h:52
cms::cuda::assert
assert(be >=bs)
HLT_2018_cff.useProtectionsForJetMET
useProtectionsForJetMET
Definition: HLT_2018_cff.py:12406
EDProducer.h
PFAlgo.h
PFAlgo::makeConnectedCandidates
reco::PFCandidateCollection makeConnectedCandidates()
Definition: PFAlgo.h:115
edm::Handle
Definition: AssociativeIterator.h:50
PFAlgo::getCleanedCandidates
reco::PFCandidateCollection & getCleanedCandidates()
Definition: PFAlgo.h:112
PFEGammaFilters.h
ihf
int ihf
Definition: CascadeWrapper.h:27
PFRecHit.h
contentValuesCheck.ss
ss
Definition: contentValuesCheck.py:33
PFEnergyCalibration.h
MakerMacros.h
reco::PFRecHitCollection
std::vector< PFRecHit > PFRecHitCollection
collection of PFRecHit objects
Definition: PFRecHitFwd.h:9
edm::EventSetup::get
T get() const
Definition: EventSetup.h:73
DEFINE_FWK_MODULE
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:16
edm::ConfigurationDescriptions::add
void add(std::string const &label, ParameterSetDescription const &psetDescription)
Definition: ConfigurationDescriptions.cc:57
PFEnergyCalibration
Definition: PFEnergyCalibration.h:42
HLT_2018_cff.dptRel_DispVtx
dptRel_DispVtx
Definition: HLT_2018_cff.py:12325
str
#define str(s)
Definition: TestProcessor.cc:48
edm::ESHandle
Definition: DTSurvey.h:22
PFAlgo::checkCleaning
void checkCleaning(const reco::PFRecHitCollection &cleanedHF)
Check HF Cleaning.
Definition: PFAlgo.cc:3589
GsfElectron.h
edm::ConfigurationDescriptions
Definition: ConfigurationDescriptions.h:28
PFProducer::inputTagEgammaElectrons_
edm::EDGetTokenT< reco::GsfElectronCollection > inputTagEgammaElectrons_
Definition: PFProducer.cc:52
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
PFProducer::pfCleanedCandidatesToken_
const edm::EDPutTokenT< reco::PFCandidateCollection > pfCleanedCandidatesToken_
Definition: PFProducer.cc:47
HLT_2018_cff.usePFDecays
usePFDecays
Definition: HLT_2018_cff.py:12392
edm::ParameterSetDescription::addUntracked
ParameterDescriptionBase * addUntracked(U const &iLabel, T const &value)
Definition: ParameterSetDescription.h:100
PFProducer::verbose_
bool verbose_
verbose ?
Definition: PFProducer.cc:70
PFProducer::calibrationsLabel_
std::string calibrationsLabel_
Definition: PFProducer.cc:83
HLT_2018_cff.InputTag
InputTag
Definition: HLT_2018_cff.py:79016
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:670
edm::ParameterSet
Definition: ParameterSet.h:36
PFAlgo::setPFVertexParameters
void setPFVertexParameters(bool useVertex, reco::VertexCollection const &primaryVertices)
Definition: PFAlgo.cc:112
Event.h
PFProducer::PFProducer
PFProducer(const edm::ParameterSet &)
Definition: PFProducer.cc:102
EDPutToken.h
PFCalibrationRcd
Definition: PFCalibrationRcd.h:6
PFProducer::inputTagValueMapGedElectrons_
edm::EDGetTokenT< edm::ValueMap< reco::GsfElectronRef > > inputTagValueMapGedElectrons_
Definition: PFProducer.cc:59
cand
Definition: decayParser.h:34
iEvent
int iEvent
Definition: GenABIO.cc:224
HLT_2018_cff.usePFNuclearInteractions
usePFNuclearInteractions
Definition: HLT_2018_cff.py:12399
PFBlockElementSuperCluster.h
PFAlgo::setEGammaCollections
void setEGammaCollections(const edm::View< reco::PFCandidate > &pfEgammaCandidates, const edm::ValueMap< reco::GsfElectronRef > &valueMapGedElectrons, const edm::ValueMap< reco::PhotonRef > &valueMapGedPhotons)
Definition: PFAlgo.cc:76
edm::stream::EDProducer
Definition: EDProducer.h:38
PFEnergyCalibration::setCalibrationFunctions
void setCalibrationFunctions(const PerformancePayloadFromTFormula *thePFCal)
Definition: PFEnergyCalibration.h:65
edm::EventSetup
Definition: EventSetup.h:57
PFProducer::useCalibrationsFromDB_
bool useCalibrationsFromDB_
Definition: PFProducer.cc:82
get
#define get
PFProducer::produce
void produce(edm::Event &, const edm::EventSetup &) override
Definition: PFProducer.cc:228
PFAlgo::setMuonHandle
void setMuonHandle(const edm::Handle< reco::MuonCollection > &)
Definition: PFAlgo.cc:86
PFProducer::pfEnergyCalibration_
PFEnergyCalibration pfEnergyCalibration_
Definition: PFProducer.cc:90
ValueMap.h
PerformancePayloadFromTFormula.h
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
PFProducer::inputTagPFEGammaCandidates_
edm::EDGetTokenT< edm::View< reco::PFCandidate > > inputTagPFEGammaCandidates_
Definition: PFProducer.cc:61
PFProducer::inputTagCleanedHF_
std::vector< edm::EDGetTokenT< reco::PFRecHitCollection > > inputTagCleanedHF_
Definition: PFProducer.cc:54
std
Definition: JetResolutionObject.h:76
writedatasetfile.run
run
Definition: writedatasetfile.py:27
PFProducer::use_EGammaFilters_
bool use_EGammaFilters_
Definition: PFProducer.cc:63
PFAlgo
Definition: PFAlgo.h:53
PFEnergyCalibrationHF
Definition: PFEnergyCalibrationHF.h:24
PFProducer::fillDescriptions
static void fillDescriptions(edm::ConfigurationDescriptions &descriptions)
Definition: PFProducer.cc:307
PFProducer::postHFCleaning_
bool postHFCleaning_
Definition: PFProducer.cc:85
EventSetup.h
HLT_2018_cff.usePFConversions
usePFConversions
Definition: HLT_2018_cff.py:12304
PFEnergyCalibrationHF.h
triggerMatcherToHLTDebug_cfi.tags
tags
Definition: triggerMatcherToHLTDebug_cfi.py:9
HLT_2018_cff.rejectTracks_Step45
rejectTracks_Step45
Definition: HLT_2018_cff.py:12394
PFProducer::photonExtraOutputCol_
std::string photonExtraOutputCol_
Definition: PFProducer.cc:56
PFProducer::useHO_
bool useHO_
Definition: PFProducer.cc:67
ParameterSet.h
edm::ParameterDescriptionNode::setComment
void setComment(std::string const &value)
Definition: ParameterDescriptionNode.cc:106
PFProducer::inputTagMuons_
edm::EDGetTokenT< reco::MuonCollection > inputTagMuons_
Definition: PFProducer.cc:50
HLT_2018_cff.rejectTracks_Bad
rejectTracks_Bad
Definition: HLT_2018_cff.py:12321
PFProducer::pfAlgo_
PFAlgo pfAlgo_
particle flow algorithm
Definition: PFProducer.cc:94
edm::Event
Definition: Event.h:73
PFProducer::postMuonCleaning_
bool postMuonCleaning_
Definition: PFProducer.cc:73
PFProducer::beginRun
void beginRun(const edm::Run &, const edm::EventSetup &) override
Definition: PFProducer.cc:215
PFProducer::pfEnergyCalibrationHF_
PFEnergyCalibrationHF pfEnergyCalibrationHF_
Definition: PFProducer.cc:91
gather_cfg.blocks
blocks
Definition: gather_cfg.py:90
edm::InputTag
Definition: InputTag.h:15
PFProducer::vertices_
edm::EDGetTokenT< reco::VertexCollection > vertices_
Definition: PFProducer.cc:51
PFCandConnector::fillPSetDescription
static void fillPSetDescription(edm::ParameterSetDescription &iDesc)
Definition: PFCandConnector.cc:554
PFProducer::useEGammaElectrons_
bool useEGammaElectrons_
Definition: PFProducer.cc:76
PFProducer::pfegamma_
std::unique_ptr< PFEGammaFilters > pfegamma_
Definition: PFProducer.cc:64
PFProducer::inputTagBlocks_
const edm::EDGetTokenT< reco::PFBlockCollection > inputTagBlocks_
Definition: PFProducer.cc:49
PFEGammaFilters::fillPSetDescription
static void fillPSetDescription(edm::ParameterSetDescription &iDesc)
Definition: PFEGammaFilters.cc:408
PFAlgo::getPFMuonAlgo
PFMuonAlgo * getPFMuonAlgo()
Definition: PFAlgo.cc:66
Generated for CMSSW Reference Manual by doxygen 1.8.16