CMS 3D CMS Logo
PFAnalysisNtuplizer.cc
Go to the documentation of this file.
1 // Based on RecoNtuple/HGCalAnalysis with modifications for PF
2 //
3 // user include files
4 #include "FWCore/Framework/interface/Frameworkfwd.h"
5 #include "FWCore/Framework/interface/one/EDAnalyzer.h"
6 
7 #include "FWCore/Framework/interface/ESHandle.h"
8 #include "FWCore/Framework/interface/Event.h"
9 #include "FWCore/Framework/interface/MakerMacros.h"
10 
11 #include "FWCore/ParameterSet/interface/ParameterSet.h"
12 
13 #include "DataFormats/CaloRecHit/interface/CaloClusterFwd.h"
14 #include "DataFormats/EgammaCandidates/interface/GsfElectron.h"
15 #include "DataFormats/GsfTrackReco/interface/GsfTrack.h"
16 #include "DataFormats/HcalRecHit/interface/HFRecHit.h"
17 #include "DataFormats/HcalRecHit/interface/HcalRecHitCollections.h"
18 #include "Geometry/HcalCommonData/interface/HcalHitRelabeller.h"
19 #include "DataFormats/HcalDetId/interface/HcalDetId.h"
20 #include "DataFormats/EcalDetId/interface/EcalSubdetector.h"
21 #include "DataFormats/ParticleFlowReco/interface/PFCluster.h"
22 #include "DataFormats/VertexReco/interface/Vertex.h"
23 #include "DataFormats/ParticleFlowCandidate/interface/PFCandidate.h"
24 #include "DataFormats/ParticleFlowReco/interface/PFBlockElementSuperCluster.h"
25 #include "DataFormats/ParticleFlowReco/interface/PFBlockElementGsfTrack.h"
26 #include "DataFormats/ParticleFlowReco/interface/PFBlockElementTrack.h"
27 #include "DataFormats/ParticleFlowReco/interface/PFBlockElementBrem.h"
28 #include "DataFormats/ParticleFlowReco/interface/PFBlockElementCluster.h"
29 #include "Geometry/HcalTowerAlgo/interface/HcalGeometry.h"
30 #include "SimDataFormats/CaloAnalysis/interface/CaloParticle.h"
31 #include "SimDataFormats/CaloAnalysis/interface/SimCluster.h"
32 #include "SimDataFormats/GeneratorProducts/interface/HepMCProduct.h"
33 #include "SimDataFormats/TrackingAnalysis/interface/TrackingParticle.h"
34 #include "SimDataFormats/Associations/interface/TrackAssociation.h"
35 #include "DataFormats/ParticleFlowReco/interface/PFBlock.h"
36 
37 #include "DataFormats/Math/interface/deltaPhi.h"
38 #include "DataFormats/TrackReco/interface/Track.h"
39 #include "DataFormats/DetId/interface/DetId.h"
40 
41 #include "DataFormats/GeometrySurface/interface/PlaneBuilder.h"
42 #include "Geometry/CaloGeometry/interface/CaloCellGeometry.h"
43 #include "Geometry/CaloGeometry/interface/CaloGeometry.h"
44 #include "Geometry/CaloGeometry/interface/CaloSubdetectorGeometry.h"
45 #include "Geometry/Records/interface/CaloGeometryRecord.h"
46 
47 #include "CommonTools/BaseParticlePropagator/interface/BaseParticlePropagator.h"
48 #include "Math/Transform3D.h"
49 #include "MagneticField/Engine/interface/MagneticField.h"
50 #include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"
51 #include "MagneticField/VolumeGeometry/interface/MagVolumeOutsideValidity.h"
52 #include "RecoParticleFlow/PFProducer/interface/MLPFModel.h"
53 
54 #include "CommonTools/UtilAlgos/interface/TFileService.h"
55 #include "FWCore/ServiceRegistry/interface/Service.h"
56 #include "TH1F.h"
57 #include "TVector2.h"
58 #include "TTree.h"
59 
60 #include <map>
61 #include <set>
62 #include <string>
63 #include <vector>
64 #include <set>
65 
66 using namespace std;
67 
68 class ElementWithIndex {
69 public:
70  const reco::PFBlockElement& orig;
71  size_t idx_block;
72  size_t idx_elem;
73  ElementWithIndex(const reco::PFBlockElement& _orig, size_t _idx_block, size_t _idx_elem)
74  : orig(_orig), idx_block(_idx_block), idx_elem(_idx_elem){};
75 };
76 
77 vector<int> find_element_ref(const vector<ElementWithIndex>& vec, const edm::RefToBase<reco::Track>& r) {
78  vector<int> ret;
79  for (unsigned int i = 0; i < vec.size(); i++) {
80  const auto& elem = vec.at(i);
81  if (elem.orig.type() == reco::PFBlockElement::TRACK) {
82  const auto& ref = elem.orig.trackRef();
83  if (ref.isNonnull() && ref->extra().isNonnull()) {
84  if (ref.key() == r.key()) {
85  ret.push_back(i);
86  }
87  }
88  }
89  }
90  return ret;
91 }
92 
93 double detid_compare(const map<uint64_t, double>& rechits, const map<uint64_t, double>& simhits) {
94  double ret = 0.0;
95 
96  for (const auto& rh : rechits) {
97  for (const auto& sh : simhits) {
98  if (rh.first == sh.first) {
99  //rechit energy times simhit fraction
100  ret += rh.second * sh.second;
101  break;
102  }
103  }
104  }
105  return ret;
106 }
107 
108 class PFAnalysis : public edm::one::EDAnalyzer<edm::one::WatchRuns, edm::one::SharedResources> {
109 public:
110  typedef ROOT::Math::Transform3D::Point Point;
111 
112  PFAnalysis();
113  explicit PFAnalysis(const edm::ParameterSet&);
114  ~PFAnalysis() override;
115 
116  static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
117  void beginRun(edm::Run const& iEvent, edm::EventSetup const&) override;
118  void endRun(edm::Run const& iEvent, edm::EventSetup const&) override;
119 
120 private:
121  void beginJob() override;
122  void analyze(const edm::Event&, const edm::EventSetup&) override;
123  void endJob() override;
124 
125  void processTrackingParticles(const edm::View<TrackingParticle>& trackingParticles,
126  edm::Handle<edm::View<TrackingParticle>>& trackingParticlesHandle);
127 
128  pair<vector<ElementWithIndex>, vector<tuple<int, int, float>>> processBlocks(
129  const std::vector<reco::PFBlock>& pfBlocks);
130 
131  void associateClusterToSimCluster(const vector<ElementWithIndex>& all_elements);
132 
133  void clearVariables();
134 
135  GlobalPoint getHitPosition(const DetId& id);
136  // ----------member data ---------------------------
137 
138  edm::EDGetTokenT<std::vector<reco::GenParticle>> genParticles_;
139  edm::EDGetTokenT<edm::View<TrackingParticle>> trackingParticles_;
140  edm::EDGetTokenT<edm::View<CaloParticle>> caloParticles_;
141  edm::EDGetTokenT<edm::View<reco::Track>> tracks_;
142  edm::EDGetTokenT<std::vector<reco::PFBlock>> pfBlocks_;
143  edm::EDGetTokenT<std::vector<reco::PFCandidate>> pfCandidates_;
144  edm::EDGetTokenT<reco::RecoToSimCollection> tracks_recotosim_;
145 
146  TTree* t_;
147 
148  edm::RunNumber_t ev_run_;
149  edm::LuminosityBlockNumber_t ev_lumi_;
150  edm::EventNumber_t ev_event_;
151 
152  vector<float> trackingparticle_eta_;
153  vector<float> trackingparticle_phi_;
154  vector<float> trackingparticle_pt_;
155  vector<float> trackingparticle_px_;
156  vector<float> trackingparticle_py_;
157  vector<float> trackingparticle_pz_;
158  vector<float> trackingparticle_energy_;
159  vector<float> trackingparticle_dvx_;
160  vector<float> trackingparticle_dvy_;
161  vector<float> trackingparticle_dvz_;
162  vector<int> trackingparticle_bx_;
163  vector<int> trackingparticle_ev_;
164  vector<float> trackingparticle_ovx_;
165  vector<float> trackingparticle_ovy_;
166  vector<float> trackingparticle_ovz_;
167  vector<float> trackingparticle_exx_;
168  vector<float> trackingparticle_exy_;
169  vector<int> trackingparticle_mother_;
170  vector<int> trackingparticle_pid_;
171 
172  vector<float> simcluster_eta_;
173  vector<float> simcluster_phi_;
174  vector<float> simcluster_pt_;
175  vector<float> simcluster_energy_;
176  vector<float> simcluster_px_;
177  vector<float> simcluster_py_;
178  vector<float> simcluster_pz_;
179  vector<int> simcluster_bx_;
180  vector<int> simcluster_ev_;
181  vector<int> simcluster_pid_;
182  vector<int> simcluster_idx_trackingparticle_;
183  vector<int> simcluster_nhits_;
184  vector<std::map<uint64_t, double>> simcluster_detids_;
185 
186  vector<float> simhit_frac_;
187  vector<float> simhit_x_;
188  vector<float> simhit_y_;
189  vector<float> simhit_z_;
190  vector<float> simhit_eta_;
191  vector<float> simhit_phi_;
192  vector<int> simhit_det_;
193  vector<int> simhit_subdet_;
194  vector<int> simhit_idx_simcluster_;
195  vector<uint64_t> simhit_detid_;
196 
197  vector<float> rechit_e_;
198  vector<float> rechit_x_;
199  vector<float> rechit_y_;
200  vector<float> rechit_z_;
201  vector<float> rechit_det_;
202  vector<float> rechit_subdet_;
203  vector<float> rechit_eta_;
204  vector<float> rechit_phi_;
205  vector<int> rechit_idx_element_;
206  vector<uint64_t> rechit_detid_;
207 
208  vector<float> simtrack_x_;
209  vector<float> simtrack_y_;
210  vector<float> simtrack_z_;
211  vector<int> simtrack_idx_simcluster_;
212  vector<int> simtrack_pid_;
213 
214  vector<float> gen_eta_;
215  vector<float> gen_phi_;
216  vector<float> gen_pt_;
217  vector<float> gen_px_;
218  vector<float> gen_py_;
219  vector<float> gen_pz_;
220  vector<float> gen_energy_;
221  vector<int> gen_charge_;
222  vector<int> gen_pdgid_;
223  vector<int> gen_status_;
224  vector<vector<int>> gen_daughters_;
225 
226  vector<float> element_pt_;
227  vector<float> element_px_;
228  vector<float> element_py_;
229  vector<float> element_pz_;
230  vector<float> element_deltap_;
231  vector<float> element_sigmadeltap_;
232  vector<float> element_eta_;
233  vector<float> element_phi_;
234  vector<float> element_energy_;
235  vector<float> element_eta_ecal_;
236  vector<float> element_phi_ecal_;
237  vector<float> element_eta_hcal_;
238  vector<float> element_phi_hcal_;
239  vector<int> element_charge_;
240  vector<int> element_type_;
241  vector<int> element_layer_;
242  vector<float> element_depth_;
243  vector<float> element_trajpoint_;
244  vector<float> element_muon_dt_hits_;
245  vector<float> element_muon_csc_hits_;
246 
247  vector<int> element_distance_i_;
248  vector<int> element_distance_j_;
249  vector<float> element_distance_d_;
250 
251  vector<float> pfcandidate_eta_;
252  vector<float> pfcandidate_phi_;
253  vector<float> pfcandidate_pt_;
254  vector<float> pfcandidate_px_;
255  vector<float> pfcandidate_py_;
256  vector<float> pfcandidate_pz_;
257  vector<float> pfcandidate_energy_;
258  vector<int> pfcandidate_pdgid_;
259 
260  vector<pair<int, int>> trackingparticle_to_element;
261  vector<pair<int, int>> simcluster_to_element;
262  vector<float> simcluster_to_element_cmp;
263  vector<pair<int, int>> element_to_candidate;
264 
265  // and also the magnetic field
266  MagneticField const* aField_;
267 
268  edm::ESGetToken<CaloGeometry, CaloGeometryRecord> geometryToken_;
269  edm::ESGetToken<HcalTopology, HcalRecNumberingRecord> topologyToken_;
270  edm::ESGetToken<MagneticField, IdealMagneticFieldRecord> magFieldToken_;
271  edm::ESGetToken<HcalDDDRecConstants, HcalRecNumberingRecord> hcalDDDrecToken_;
272 
273  CaloGeometry* geom;
274  HcalTopology* hcal_topo;
275  const HcalDDDRecConstants* hcons;
276 
277  bool saveHits;
278 };
279 
280 PFAnalysis::PFAnalysis() { ; }
281 
282 PFAnalysis::PFAnalysis(const edm::ParameterSet& iConfig) {
283  tracks_recotosim_ = consumes<reco::RecoToSimCollection>(edm::InputTag("trackingParticleRecoTrackAsssociation"));
284  trackingParticles_ = consumes<edm::View<TrackingParticle>>(edm::InputTag("mix", "MergedTrackTruth"));
285  caloParticles_ = consumes<edm::View<CaloParticle>>(edm::InputTag("mix", "MergedCaloTruth"));
286  genParticles_ = consumes<std::vector<reco::GenParticle>>(edm::InputTag("genParticles"));
287  pfBlocks_ = consumes<std::vector<reco::PFBlock>>(edm::InputTag("particleFlowBlock"));
288  pfCandidates_ = consumes<std::vector<reco::PFCandidate>>(edm::InputTag("particleFlow"));
289  tracks_ = consumes<edm::View<reco::Track>>(edm::InputTag("generalTracks"));
290  saveHits = iConfig.getUntrackedParameter<bool>("saveHits", false);
291 
292  geometryToken_ = esConsumes<CaloGeometry, CaloGeometryRecord>(edm::ESInputTag{});
293  topologyToken_ = esConsumes<HcalTopology, HcalRecNumberingRecord>(edm::ESInputTag{});
294  magFieldToken_ = esConsumes<edm::Transition::BeginRun>();
295  hcalDDDrecToken_ = esConsumes<edm::Transition::BeginRun>();
296 
297  usesResource(TFileService::kSharedResource);
298  edm::Service<TFileService> fs;
299  fs->make<TH1F>("total", "total", 100, 0, 5.);
300 
301  t_ = fs->make<TTree>("pftree", "pftree");
302 
303  // event info
304  t_->Branch("event", &ev_event_);
305  t_->Branch("lumi", &ev_lumi_);
306  t_->Branch("run", &ev_run_);
307 
308  t_->Branch("trackingparticle_eta", &trackingparticle_eta_);
309  t_->Branch("trackingparticle_phi", &trackingparticle_phi_);
310  t_->Branch("trackingparticle_pt", &trackingparticle_pt_);
311  t_->Branch("trackingparticle_px", &trackingparticle_px_);
312  t_->Branch("trackingparticle_py", &trackingparticle_py_);
313  t_->Branch("trackingparticle_pz", &trackingparticle_pz_);
314  t_->Branch("trackingparticle_energy", &trackingparticle_energy_);
315  t_->Branch("trackingparticle_dvx", &trackingparticle_dvx_);
316  t_->Branch("trackingparticle_dvy", &trackingparticle_dvy_);
317  t_->Branch("trackingparticle_dvz", &trackingparticle_dvz_);
318  t_->Branch("trackingparticle_bx", &trackingparticle_bx_);
319  t_->Branch("trackingparticle_ev", &trackingparticle_ev_);
320  t_->Branch("trackingparticle_pid", &trackingparticle_pid_);
321 
322  t_->Branch("simcluster_eta", &simcluster_eta_);
323  t_->Branch("simcluster_phi", &simcluster_phi_);
324  t_->Branch("simcluster_pt", &simcluster_pt_);
325  t_->Branch("simcluster_px", &simcluster_px_);
326  t_->Branch("simcluster_py", &simcluster_py_);
327  t_->Branch("simcluster_pz", &simcluster_pz_);
328  t_->Branch("simcluster_energy", &simcluster_energy_);
329  t_->Branch("simcluster_bx", &simcluster_bx_);
330  t_->Branch("simcluster_ev", &simcluster_ev_);
331  t_->Branch("simcluster_pid", &simcluster_pid_);
332  t_->Branch("simcluster_idx_trackingparticle", &simcluster_idx_trackingparticle_);
333  t_->Branch("simcluster_nhits", &simcluster_nhits_);
334 
335  if (saveHits) {
336  t_->Branch("simhit_frac", &simhit_frac_);
337  t_->Branch("simhit_x", &simhit_x_);
338  t_->Branch("simhit_y", &simhit_y_);
339  t_->Branch("simhit_z", &simhit_z_);
340  t_->Branch("simhit_det", &simhit_det_);
341  t_->Branch("simhit_subdet", &simhit_subdet_);
342  t_->Branch("simhit_eta", &simhit_eta_);
343  t_->Branch("simhit_phi", &simhit_phi_);
344  t_->Branch("simhit_idx_simcluster", &simhit_idx_simcluster_);
345  t_->Branch("simhit_detid", &simhit_detid_);
346 
347  t_->Branch("rechit_e", &rechit_e_);
348  t_->Branch("rechit_x", &rechit_x_);
349  t_->Branch("rechit_y", &rechit_y_);
350  t_->Branch("rechit_z", &rechit_z_);
351  t_->Branch("rechit_det", &rechit_det_);
352  t_->Branch("rechit_subdet", &rechit_subdet_);
353  t_->Branch("rechit_eta", &rechit_eta_);
354  t_->Branch("rechit_phi", &rechit_phi_);
355  t_->Branch("rechit_idx_element", &rechit_idx_element_);
356  t_->Branch("rechit_detid", &rechit_detid_);
357  }
358 
359  t_->Branch("simtrack_x", &simtrack_x_);
360  t_->Branch("simtrack_y", &simtrack_y_);
361  t_->Branch("simtrack_z", &simtrack_z_);
362  t_->Branch("simtrack_idx_simcluster_", &simtrack_idx_simcluster_);
363  t_->Branch("simtrack_pid", &simtrack_pid_);
364 
365  t_->Branch("gen_eta", &gen_eta_);
366  t_->Branch("gen_phi", &gen_phi_);
367  t_->Branch("gen_pt", &gen_pt_);
368  t_->Branch("gen_px", &gen_px_);
369  t_->Branch("gen_py", &gen_py_);
370  t_->Branch("gen_pz", &gen_pz_);
371  t_->Branch("gen_energy", &gen_energy_);
372  t_->Branch("gen_charge", &gen_charge_);
373  t_->Branch("gen_pdgid", &gen_pdgid_);
374  t_->Branch("gen_status", &gen_status_);
375  t_->Branch("gen_daughters", &gen_daughters_);
376 
377  //PF Elements
378  t_->Branch("element_pt", &element_pt_);
379  t_->Branch("element_px", &element_px_);
380  t_->Branch("element_py", &element_py_);
381  t_->Branch("element_pz", &element_pz_);
382  t_->Branch("element_deltap", &element_deltap_);
383  t_->Branch("element_sigmadeltap", &element_sigmadeltap_);
384  t_->Branch("element_eta", &element_eta_);
385  t_->Branch("element_phi", &element_phi_);
386  t_->Branch("element_energy", &element_energy_);
387  t_->Branch("element_eta_ecal", &element_eta_ecal_);
388  t_->Branch("element_phi_ecal", &element_phi_ecal_);
389  t_->Branch("element_eta_hcal", &element_eta_hcal_);
390  t_->Branch("element_phi_hcal", &element_phi_hcal_);
391  t_->Branch("element_charge", &element_charge_);
392  t_->Branch("element_type", &element_type_);
393  t_->Branch("element_layer", &element_layer_);
394  t_->Branch("element_depth", &element_depth_);
395  t_->Branch("element_trajpoint", &element_trajpoint_);
396  t_->Branch("element_muon_dt_hits", &element_muon_dt_hits_);
397  t_->Branch("element_muon_csc_hits", &element_muon_csc_hits_);
398 
399  //Distance matrix between PF elements
400  t_->Branch("element_distance_i", &element_distance_i_);
401  t_->Branch("element_distance_j", &element_distance_j_);
402  t_->Branch("element_distance_d", &element_distance_d_);
403 
404  t_->Branch("pfcandidate_eta", &pfcandidate_eta_);
405  t_->Branch("pfcandidate_phi", &pfcandidate_phi_);
406  t_->Branch("pfcandidate_pt", &pfcandidate_pt_);
407  t_->Branch("pfcandidate_px", &pfcandidate_px_);
408  t_->Branch("pfcandidate_py", &pfcandidate_py_);
409  t_->Branch("pfcandidate_pz", &pfcandidate_pz_);
410  t_->Branch("pfcandidate_energy", &pfcandidate_energy_);
411  t_->Branch("pfcandidate_pdgid", &pfcandidate_pdgid_);
412 
413  //Links between reco, gen and PFCandidate objects
414  t_->Branch("trackingparticle_to_element", &trackingparticle_to_element);
415  t_->Branch("simcluster_to_element", &simcluster_to_element);
416  t_->Branch("simcluster_to_element_cmp", &simcluster_to_element_cmp);
417  t_->Branch("element_to_candidate", &element_to_candidate);
418 } // constructor
419 
420 PFAnalysis::~PFAnalysis() {}
421 
422 void PFAnalysis::clearVariables() {
423  ev_run_ = 0;
424  ev_lumi_ = 0;
425  ev_event_ = 0;
426 
427  trackingparticle_to_element.clear();
428  simcluster_to_element.clear();
429  simcluster_to_element_cmp.clear();
430  element_to_candidate.clear();
431 
432  trackingparticle_eta_.clear();
433  trackingparticle_phi_.clear();
434  trackingparticle_pt_.clear();
435  trackingparticle_px_.clear();
436  trackingparticle_py_.clear();
437  trackingparticle_pz_.clear();
438  trackingparticle_energy_.clear();
439  trackingparticle_dvx_.clear();
440  trackingparticle_dvy_.clear();
441  trackingparticle_dvz_.clear();
442  trackingparticle_bx_.clear();
443  trackingparticle_ev_.clear();
444  trackingparticle_ovx_.clear();
445  trackingparticle_ovy_.clear();
446  trackingparticle_ovz_.clear();
447  trackingparticle_exx_.clear();
448  trackingparticle_exy_.clear();
449  trackingparticle_mother_.clear();
450  trackingparticle_pid_.clear();
451 
452  simcluster_eta_.clear();
453  simcluster_phi_.clear();
454  simcluster_pt_.clear();
455  simcluster_energy_.clear();
456  simcluster_pid_.clear();
457  simcluster_detids_.clear();
458  simcluster_bx_.clear();
459  simcluster_ev_.clear();
460  simcluster_px_.clear();
461  simcluster_py_.clear();
462  simcluster_pz_.clear();
463  simcluster_idx_trackingparticle_.clear();
464  simcluster_nhits_.clear();
465 
466  if (saveHits) {
467  simhit_frac_.clear();
468  simhit_x_.clear();
469  simhit_y_.clear();
470  simhit_z_.clear();
471  simhit_det_.clear();
472  simhit_subdet_.clear();
473  simhit_eta_.clear();
474  simhit_phi_.clear();
475  simhit_idx_simcluster_.clear();
476  simhit_detid_.clear();
477 
478  rechit_e_.clear();
479  rechit_x_.clear();
480  rechit_y_.clear();
481  rechit_z_.clear();
482  rechit_det_.clear();
483  rechit_subdet_.clear();
484  rechit_eta_.clear();
485  rechit_phi_.clear();
486  rechit_idx_element_.clear();
487  rechit_detid_.clear();
488  }
489 
490  simtrack_x_.clear();
491  simtrack_y_.clear();
492  simtrack_z_.clear();
493  simtrack_idx_simcluster_.clear();
494  simtrack_pid_.clear();
495 
496  gen_eta_.clear();
497  gen_phi_.clear();
498  gen_pt_.clear();
499  gen_px_.clear();
500  gen_py_.clear();
501  gen_pz_.clear();
502  gen_energy_.clear();
503  gen_charge_.clear();
504  gen_pdgid_.clear();
505  gen_status_.clear();
506  gen_daughters_.clear();
507 
508  element_pt_.clear();
509  element_px_.clear();
510  element_py_.clear();
511  element_pz_.clear();
512  element_deltap_.clear();
513  element_sigmadeltap_.clear();
514  element_eta_.clear();
515  element_phi_.clear();
516  element_energy_.clear();
517  element_eta_ecal_.clear();
518  element_phi_ecal_.clear();
519  element_eta_hcal_.clear();
520  element_phi_hcal_.clear();
521  element_charge_.clear();
522  element_type_.clear();
523  element_layer_.clear();
524  element_depth_.clear();
525  element_trajpoint_.clear();
526  element_muon_dt_hits_.clear();
527  element_muon_csc_hits_.clear();
528 
529  element_distance_i_.clear();
530  element_distance_j_.clear();
531  element_distance_d_.clear();
532 
533  pfcandidate_eta_.clear();
534  pfcandidate_phi_.clear();
535  pfcandidate_pt_.clear();
536  pfcandidate_px_.clear();
537  pfcandidate_py_.clear();
538  pfcandidate_pz_.clear();
539  pfcandidate_energy_.clear();
540  pfcandidate_pdgid_.clear();
541 
542 } //clearVariables
543 
544 GlobalPoint PFAnalysis::getHitPosition(const DetId& id) {
545  GlobalPoint ret;
546 
547  bool present = false;
548  if (((id.det() == DetId::Ecal &&
549  (id.subdetId() == EcalBarrel || id.subdetId() == EcalEndcap || id.subdetId() == EcalPreshower)) ||
550  (id.det() == DetId::Hcal && (id.subdetId() == HcalBarrel || id.subdetId() == HcalEndcap ||
551  id.subdetId() == HcalForward || id.subdetId() == HcalOuter)))) {
552  const CaloSubdetectorGeometry* geom_sd(geom->getSubdetectorGeometry(id.det(), id.subdetId()));
553  present = geom_sd->present(id);
554  if (present) {
555  const auto& cell = geom_sd->getGeometry(id);
556  ret = GlobalPoint(cell->getPosition());
557  }
558  }
559  return ret;
560 }
561 
562 void PFAnalysis::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) {
563  clearVariables();
564 
565  auto& pG = iSetup.getData(geometryToken_);
566  geom = (CaloGeometry*)&pG;
567  auto& pT = iSetup.getData(topologyToken_);
568  hcal_topo = (HcalTopology*)&pT;
569 
570  //Simulated tracks, cleaned up by TrackingTruthAccumulator
571  edm::Handle<edm::View<TrackingParticle>> trackingParticlesHandle;
572  iEvent.getByToken(trackingParticles_, trackingParticlesHandle);
573  const edm::View<TrackingParticle>& trackingParticles = *trackingParticlesHandle;
574 
575  edm::Handle<edm::View<CaloParticle>> caloParticlesHandle;
576  iEvent.getByToken(caloParticles_, caloParticlesHandle);
577  const edm::View<CaloParticle>& caloParticles = *caloParticlesHandle;
578 
579  //Matches reco tracks to sim tracks (TrackingParticle)
580  edm::Handle<reco::RecoToSimCollection> recotosimCollection;
581  iEvent.getByToken(tracks_recotosim_, recotosimCollection);
582  const auto recotosim = *recotosimCollection;
583 
584  edm::Handle<edm::View<reco::Track>> trackHandle;
585  iEvent.getByToken(tracks_, trackHandle);
586  const edm::View<reco::Track>& tracks = *trackHandle;
587 
588  edm::Handle<std::vector<reco::GenParticle>> genParticlesHandle;
589  iEvent.getByToken(genParticles_, genParticlesHandle);
590  for (std::vector<reco::GenParticle>::const_iterator it_p = genParticlesHandle->begin();
591  it_p != genParticlesHandle->end();
592  ++it_p) {
593  gen_eta_.push_back(it_p->eta());
594  gen_phi_.push_back(it_p->phi());
595  gen_pt_.push_back(it_p->pt());
596  gen_px_.push_back(it_p->px());
597  gen_py_.push_back(it_p->py());
598  gen_pz_.push_back(it_p->pz());
599  gen_energy_.push_back(it_p->energy());
600  gen_charge_.push_back(it_p->charge());
601  gen_pdgid_.push_back(it_p->pdgId());
602  gen_status_.push_back(it_p->status());
603  std::vector<int> daughters(it_p->daughterRefVector().size(), 0);
604  for (unsigned j = 0; j < it_p->daughterRefVector().size(); ++j) {
605  daughters[j] = static_cast<int>(it_p->daughterRefVector().at(j).key());
606  }
607  gen_daughters_.push_back(daughters);
608  }
609 
610  edm::Handle<std::vector<reco::PFCandidate>> pfCandidatesHandle;
611  iEvent.getByToken(pfCandidates_, pfCandidatesHandle);
612  std::vector<reco::PFCandidate> pfCandidates = *pfCandidatesHandle;
613 
614  edm::Handle<std::vector<reco::PFBlock>> pfBlocksHandle;
615  iEvent.getByToken(pfBlocks_, pfBlocksHandle);
616  std::vector<reco::PFBlock> pfBlocks = *pfBlocksHandle;
617 
618  //Collect all clusters, tracks and superclusters
619  const auto& all_elements_distances = processBlocks(pfBlocks);
620  const auto& all_elements = all_elements_distances.first;
621  const auto& all_distances = all_elements_distances.second;
622  assert(!all_elements.empty());
623  //assert(all_distances.size() > 0);
624  for (const auto& d : all_distances) {
625  element_distance_i_.push_back(get<0>(d));
626  element_distance_j_.push_back(get<1>(d));
627  element_distance_d_.push_back(get<2>(d));
628  }
629 
630  //We need to use the original reco::Track collection for track association
631  for (unsigned long ntrack = 0; ntrack < tracks.size(); ntrack++) {
632  edm::RefToBase<reco::Track> trackref(trackHandle, ntrack);
633  const auto vec_idx_in_all_elements = find_element_ref(all_elements, trackref);
634 
635  //track was not used by PF, we skip as well
636  if (vec_idx_in_all_elements.empty()) {
637  continue;
638  }
639 
640  if (recotosim.find(trackref) != recotosim.end()) {
641  const auto& tps = recotosim[trackref];
642  for (const auto& tp : tps) {
643  edm::Ref<std::vector<TrackingParticle>> tpr = tp.first;
644  for (auto idx_in_all_elements : vec_idx_in_all_elements) {
645  trackingparticle_to_element.emplace_back(tpr.key(), idx_in_all_elements);
646  }
647  }
648  }
649  }
650 
651  processTrackingParticles(trackingParticles, trackingParticlesHandle);
652 
653  int idx_simcluster = 0;
654  //Fill genparticles from calorimeter hits
655  for (unsigned long ncaloparticle = 0; ncaloparticle < caloParticles.size(); ncaloparticle++) {
656  const auto& cp = caloParticles.at(ncaloparticle);
657  edm::RefToBase<CaloParticle> cpref(caloParticlesHandle, ncaloparticle);
658 
659  int nhits = 0;
660  for (const auto& simcluster : cp.simClusters()) {
661  //create a map of detId->energy of all the rechits in all the clusters of this SimCluster
662  map<uint64_t, double> detid_energy;
663 
664  simcluster_nhits_.push_back(nhits);
665  simcluster_eta_.push_back(simcluster->p4().eta());
666  simcluster_phi_.push_back(simcluster->p4().phi());
667  simcluster_pt_.push_back(simcluster->p4().pt());
668  simcluster_energy_.push_back(simcluster->energy());
669  simcluster_pid_.push_back(simcluster->pdgId());
670  simcluster_bx_.push_back(simcluster->eventId().bunchCrossing());
671  simcluster_ev_.push_back(simcluster->eventId().event());
672 
673  simcluster_px_.push_back(simcluster->p4().x());
674  simcluster_py_.push_back(simcluster->p4().y());
675  simcluster_pz_.push_back(simcluster->p4().z());
676 
677  for (const auto& hf : simcluster->hits_and_fractions()) {
678  DetId id(hf.first);
679 
680  if (id.det() == DetId::Hcal || id.det() == DetId::Ecal) {
681  const auto& pos = getHitPosition(id);
682  nhits += 1;
683 
684  const float x = pos.x();
685  const float y = pos.y();
686  const float z = pos.z();
687  const float eta = pos.eta();
688  const float phi = pos.phi();
689 
690  simhit_frac_.push_back(hf.second);
691  simhit_x_.push_back(x);
692  simhit_y_.push_back(y);
693  simhit_z_.push_back(z);
694  simhit_det_.push_back(id.det());
695  simhit_subdet_.push_back(id.subdetId());
696  simhit_eta_.push_back(eta);
697  simhit_phi_.push_back(phi);
698  simhit_idx_simcluster_.push_back(idx_simcluster);
699  simhit_detid_.push_back(id.rawId());
700  detid_energy[id.rawId()] += hf.second;
701  }
702  }
703 
704  int simcluster_to_trackingparticle = -1;
705  for (const auto& simtrack : simcluster->g4Tracks()) {
706  simtrack_x_.push_back(simtrack.trackerSurfacePosition().x());
707  simtrack_y_.push_back(simtrack.trackerSurfacePosition().y());
708  simtrack_z_.push_back(simtrack.trackerSurfacePosition().z());
709  simtrack_idx_simcluster_.push_back(idx_simcluster);
710  simtrack_pid_.push_back(simtrack.type());
711 
712  for (unsigned int itp = 0; itp < trackingParticles.size(); itp++) {
713  const auto& simtrack2 = trackingParticles.at(itp).g4Tracks().at(0);
714  //compare the two tracks, taking into account that both eventId and trackId need to be compared due to pileup
715  if (simtrack.eventId() == simtrack2.eventId() && simtrack.trackId() == simtrack2.trackId()) {
716  simcluster_to_trackingparticle = itp;
717  //we are satisfied with the first match, in practice there should not be more
718  break;
719  }
720  } //trackingParticles
721  } //simcluster tracks
722 
723  simcluster_detids_.push_back(detid_energy);
724  simcluster_idx_trackingparticle_.push_back(simcluster_to_trackingparticle);
725 
726  idx_simcluster += 1;
727  } //simclusters
728  } //caloParticles
729 
730  associateClusterToSimCluster(all_elements);
731 
732  //fill elements
733  for (unsigned int ielem = 0; ielem < all_elements.size(); ielem++) {
734  const auto& elem = all_elements.at(ielem);
735  const auto& orig = elem.orig;
736  reco::PFBlockElement::Type type = orig.type();
737 
738  float pt = 0.0;
739  float deltap = 0.0;
740  float sigmadeltap = 0.0;
741  float px = 0.0;
742  float py = 0.0;
743  float pz = 0.0;
744  float eta = 0.0;
745  float phi = 0.0;
746  float energy = 0.0;
747  float trajpoint = 0.0;
748  float eta_ecal = 0.0;
749  float phi_ecal = 0.0;
750  float eta_hcal = 0.0;
751  float phi_hcal = 0.0;
752  int charge = 0;
753  int layer = 0;
754  float depth = 0;
755  float muon_dt_hits = 0.0;
756  float muon_csc_hits = 0.0;
757 
758  if (type == reco::PFBlockElement::TRACK) {
759  const auto& matched_pftrack = orig.trackRefPF();
760  if (matched_pftrack.isNonnull()) {
761  const auto& atECAL = matched_pftrack->extrapolatedPoint(reco::PFTrajectoryPoint::ECALShowerMax);
762  const auto& atHCAL = matched_pftrack->extrapolatedPoint(reco::PFTrajectoryPoint::HCALEntrance);
763  if (atHCAL.isValid()) {
764  eta_hcal = atHCAL.positionREP().eta();
765  phi_hcal = atHCAL.positionREP().phi();
766  }
767  if (atECAL.isValid()) {
768  eta_ecal = atECAL.positionREP().eta();
769  phi_ecal = atECAL.positionREP().phi();
770  }
771  }
772  const auto& ref = ((const reco::PFBlockElementTrack*)&orig)->trackRef();
773  pt = ref->pt();
774  px = ref->px();
775  py = ref->py();
776  pz = ref->pz();
777  eta = ref->eta();
778  phi = ref->phi();
779  energy = ref->p();
780  charge = ref->charge();
781 
782  reco::MuonRef muonRef = orig.muonRef();
783  if (muonRef.isNonnull()) {
784  reco::TrackRef standAloneMu = muonRef->standAloneMuon();
785  if (standAloneMu.isNonnull()) {
786  muon_dt_hits = standAloneMu->hitPattern().numberOfValidMuonDTHits();
787  muon_csc_hits = standAloneMu->hitPattern().numberOfValidMuonCSCHits();
788  }
789  }
790 
791  } else if (type == reco::PFBlockElement::BREM) {
792  const auto* orig2 = (const reco::PFBlockElementBrem*)&orig;
793  const auto& ref = orig2->GsftrackRef();
794  if (ref.isNonnull()) {
795  deltap = orig2->DeltaP();
796  sigmadeltap = orig2->SigmaDeltaP();
797  pt = ref->pt();
798  px = ref->px();
799  py = ref->py();
800  pz = ref->pz();
801  eta = ref->eta();
802  phi = ref->phi();
803  energy = ref->p();
804  trajpoint = orig2->indTrajPoint();
805  charge = ref->charge();
806  }
807  } else if (type == reco::PFBlockElement::GSF) {
808  //requires to keep GsfPFRecTracks
809  const auto* orig2 = (const reco::PFBlockElementGsfTrack*)&orig;
810  const auto& vec = orig2->Pin();
811  pt = vec.pt();
812  px = vec.px();
813  py = vec.py();
814  pz = vec.pz();
815  eta = vec.eta();
816  phi = vec.phi();
817  energy = vec.energy();
818  if (!orig2->GsftrackRefPF().isNull()) {
819  charge = orig2->GsftrackRefPF()->charge();
820  }
821  } else if (type == reco::PFBlockElement::ECAL || type == reco::PFBlockElement::PS1 ||
822  type == reco::PFBlockElement::PS2 || type == reco::PFBlockElement::HCAL ||
823  type == reco::PFBlockElement::HO || type == reco::PFBlockElement::HFHAD ||
824  type == reco::PFBlockElement::HFEM) {
825  const auto& ref = ((const reco::PFBlockElementCluster*)&orig)->clusterRef();
826  if (ref.isNonnull()) {
827  eta = ref->eta();
828  phi = ref->phi();
829  px = ref->position().x();
830  py = ref->position().y();
831  pz = ref->position().z();
832  energy = ref->energy();
833  layer = ref->layer();
834  depth = ref->depth();
835  }
836  } else if (type == reco::PFBlockElement::SC) {
837  const auto& clref = ((const reco::PFBlockElementSuperCluster*)&orig)->superClusterRef();
838  if (clref.isNonnull()) {
839  eta = clref->eta();
840  phi = clref->phi();
841  px = clref->position().x();
842  py = clref->position().y();
843  pz = clref->position().z();
844  energy = clref->energy();
845  }
846  }
847  vector<int> tps;
848  for (const auto& t : trackingparticle_to_element) {
849  if (t.second == (int)ielem) {
850  tps.push_back(t.first);
851  }
852  }
853  vector<int> scs;
854  for (const auto& t : simcluster_to_element) {
855  if (t.second == (int)ielem) {
856  scs.push_back(t.first);
857  }
858  }
859 
860  element_pt_.push_back(pt);
861  element_px_.push_back(px);
862  element_py_.push_back(py);
863  element_pz_.push_back(pz);
864  element_deltap_.push_back(deltap);
865  element_sigmadeltap_.push_back(sigmadeltap);
866  element_eta_.push_back(eta);
867  element_phi_.push_back(phi);
868  element_energy_.push_back(energy);
869  element_eta_ecal_.push_back(eta_ecal);
870  element_phi_ecal_.push_back(phi_ecal);
871  element_eta_hcal_.push_back(eta_hcal);
872  element_phi_hcal_.push_back(phi_hcal);
873  element_charge_.push_back(charge);
874  element_type_.push_back(type);
875  element_layer_.push_back(layer);
876  element_depth_.push_back(depth);
877  element_trajpoint_.push_back(trajpoint);
878  element_muon_dt_hits_.push_back(muon_dt_hits);
879  element_muon_csc_hits_.push_back(muon_csc_hits);
880  }
881 
882  //associate candidates to elements
883  int icandidate = 0;
884  for (const auto& cand : pfCandidates) {
885  pfcandidate_eta_.push_back(cand.eta());
886  pfcandidate_phi_.push_back(cand.phi());
887  pfcandidate_pt_.push_back(cand.pt());
888  pfcandidate_px_.push_back(cand.px());
889  pfcandidate_py_.push_back(cand.py());
890  pfcandidate_pz_.push_back(cand.pz());
891  pfcandidate_energy_.push_back(cand.energy());
892  pfcandidate_pdgid_.push_back(cand.pdgId());
893 
894  for (const auto& el : cand.elementsInBlocks()) {
895  const auto idx_block = el.first.index();
896  unsigned idx_element_in_block = el.second;
897 
898  int ielem = -1;
899  for (const auto& elem_with_index : all_elements) {
900  ielem += 1;
901  if (elem_with_index.idx_block == idx_block && elem_with_index.idx_elem == idx_element_in_block) {
902  break;
903  }
904  }
905  assert(ielem != -1);
906  element_to_candidate.push_back(make_pair(ielem, icandidate));
907  } //elements
908 
909  icandidate += 1;
910  } //pfCandidates
911 
912  ev_event_ = iEvent.id().event();
913  ev_lumi_ = iEvent.id().luminosityBlock();
914  ev_run_ = iEvent.id().run();
915 
916  t_->Fill();
917 } //analyze
918 
919 void PFAnalysis::processTrackingParticles(const edm::View<TrackingParticle>& trackingParticles,
920  edm::Handle<edm::View<TrackingParticle>>& trackingParticlesHandle) {
921  for (unsigned long ntrackingparticle = 0; ntrackingparticle < trackingParticles.size(); ntrackingparticle++) {
922  const auto& tp = trackingParticles.at(ntrackingparticle);
923  edm::RefToBase<TrackingParticle> tpref(trackingParticlesHandle, ntrackingparticle);
924 
925  math::XYZTLorentzVectorD vtx(0, 0, 0, 0);
926 
927  if (!tp.decayVertices().empty()) {
928  vtx = tp.decayVertices().at(0)->position();
929  }
930  auto orig_vtx = tp.vertex();
931 
932  // fill branches
933  trackingparticle_eta_.push_back(tp.p4().eta());
934  trackingparticle_phi_.push_back(tp.p4().phi());
935  trackingparticle_pt_.push_back(tp.p4().pt());
936  trackingparticle_px_.push_back(tp.p4().px());
937  trackingparticle_py_.push_back(tp.p4().py());
938  trackingparticle_pz_.push_back(tp.p4().pz());
939  trackingparticle_energy_.push_back(tp.p4().energy());
940  trackingparticle_dvx_.push_back(vtx.x());
941  trackingparticle_dvy_.push_back(vtx.y());
942  trackingparticle_dvz_.push_back(vtx.z());
943  trackingparticle_bx_.push_back(tp.eventId().bunchCrossing());
944  trackingparticle_ev_.push_back(tp.eventId().event());
945 
946  trackingparticle_ovx_.push_back(orig_vtx.x());
947  trackingparticle_ovy_.push_back(orig_vtx.y());
948  trackingparticle_ovz_.push_back(orig_vtx.z());
949 
950  trackingparticle_pid_.push_back(tp.pdgId());
951  }
952 }
953 
954 //https://stackoverflow.com/questions/27086195/linear-index-upper-triangular-matrix/27088560
955 int get_index_triu_vector(int i, int j, int n) {
956  int k = (n * (n - 1) / 2) - (n - i) * ((n - i) - 1) / 2 + j - i - 1;
957  return k;
958 }
959 
960 pair<int, int> get_triu_vector_index(int k, int n) {
961  int i = n - 2 - floor(sqrt(-8 * k + 4 * n * (n - 1) - 7) / 2.0 - 0.5);
962  int j = k + i + 1 - n * (n - 1) / 2 + (n - i) * ((n - i) - 1) / 2;
963  return make_pair(i, j);
964 }
965 
966 pair<vector<ElementWithIndex>, vector<tuple<int, int, float>>> PFAnalysis::processBlocks(
967  const std::vector<reco::PFBlock>& pfBlocks) {
968  vector<ElementWithIndex> ret;
969  vector<tuple<int, int, float>> distances;
970 
971  //Collect all the elements
972  int iblock = 0;
973  for (const auto& block : pfBlocks) {
974  int ielem = 0;
975  const auto& linkdata = block.linkData();
976 
977  //create a list of global element indices with distances
978  for (const auto& link : linkdata) {
979  const auto vecidx = link.first;
980  const auto dist = link.second.distance;
981  const auto& ij = get_triu_vector_index(vecidx, block.elements().size());
982  auto globalindex_i = ij.first + ret.size();
983  auto globalindex_j = ij.second + ret.size();
984  distances.push_back(make_tuple(globalindex_i, globalindex_j, dist));
985  }
986 
987  for (const auto& elem : block.elements()) {
988  ElementWithIndex elem_index(elem, iblock, ielem);
989  ret.push_back(elem_index);
990  ielem += 1;
991  } //elements
992  iblock += 1;
993  } //blocks
994  return make_pair(ret, distances);
995 
996 } //processBlocks
997 
998 void PFAnalysis::associateClusterToSimCluster(const vector<ElementWithIndex>& all_elements) {
999  vector<map<uint64_t, double>> detids_elements;
1000  map<uint64_t, double> rechits_energy_all;
1001 
1002  int idx_element = 0;
1003  for (const auto& elem : all_elements) {
1004  map<uint64_t, double> detids;
1005  const auto& type = elem.orig.type();
1006 
1007  if (type == reco::PFBlockElement::ECAL || type == reco::PFBlockElement::HCAL || type == reco::PFBlockElement::PS1 ||
1008  type == reco::PFBlockElement::PS2 || type == reco::PFBlockElement::HO || type == reco::PFBlockElement::HFHAD ||
1009  type == reco::PFBlockElement::HFEM) {
1010  const auto& clref = elem.orig.clusterRef();
1011  assert(clref.isNonnull());
1012  const auto& cluster = *clref;
1013 
1014  //all rechits and the energy fractions in this cluster
1015  const vector<reco::PFRecHitFraction>& rechit_fracs = cluster.recHitFractions();
1016  for (const auto& rh : rechit_fracs) {
1017  const reco::PFRecHit pfrh = *rh.recHitRef();
1018  if (detids.find(pfrh.detId()) != detids.end()) {
1019  continue;
1020  }
1021  detids[pfrh.detId()] += pfrh.energy() * rh.fraction();
1022  const auto id = DetId(pfrh.detId());
1023  float x = 0;
1024  float y = 0;
1025  float z = 0;
1026  float eta = 0;
1027  float phi = 0;
1028 
1029  const auto& pos = getHitPosition(id);
1030  x = pos.x();
1031  y = pos.y();
1032  z = pos.z();
1033  eta = pos.eta();
1034  phi = pos.phi();
1035 
1036  rechit_x_.push_back(x);
1037  rechit_y_.push_back(y);
1038  rechit_z_.push_back(z);
1039  rechit_det_.push_back(id.det());
1040  rechit_subdet_.push_back(id.subdetId());
1041  rechit_eta_.push_back(eta);
1042  rechit_phi_.push_back(phi);
1043  rechit_e_.push_back(pfrh.energy() * rh.fraction());
1044  rechit_idx_element_.push_back(idx_element);
1045  rechit_detid_.push_back(id.rawId());
1046  rechits_energy_all[id.rawId()] += pfrh.energy() * rh.fraction();
1047  } //rechit_fracs
1048  } else if (type == reco::PFBlockElement::SC) {
1049  const auto& clref = ((const reco::PFBlockElementSuperCluster*)&(elem.orig))->superClusterRef();
1050  assert(clref.isNonnull());
1051  const auto& cluster = *clref;
1052 
1053  //all rechits and the energy fractions in this cluster
1054  const auto& rechit_fracs = cluster.hitsAndFractions();
1055  for (const auto& rh : rechit_fracs) {
1056  if (detids.find(rh.first.rawId()) != detids.end()) {
1057  continue;
1058  }
1059  detids[rh.first.rawId()] += cluster.energy() * rh.second;
1060  const auto id = rh.first;
1061  float x = 0;
1062  float y = 0;
1063  float z = 0;
1064  float eta = 0;
1065  float phi = 0;
1066 
1067  const auto& pos = getHitPosition(id);
1068  x = pos.x();
1069  y = pos.y();
1070  z = pos.z();
1071  eta = pos.eta();
1072  phi = pos.phi();
1073 
1074  rechit_x_.push_back(x);
1075  rechit_y_.push_back(y);
1076  rechit_z_.push_back(z);
1077  rechit_det_.push_back(id.det());
1078  rechit_subdet_.push_back(id.subdetId());
1079  rechit_eta_.push_back(eta);
1080  rechit_phi_.push_back(phi);
1081  rechit_e_.push_back(rh.second);
1082  rechit_idx_element_.push_back(idx_element);
1083  rechit_detid_.push_back(id.rawId());
1084  rechits_energy_all[id.rawId()] += cluster.energy() * rh.second;
1085  } //rechit_fracs
1086  }
1087  detids_elements.push_back(detids);
1088  idx_element += 1;
1089  } //all_elements
1090 
1091  //associate elements (reco clusters) to simclusters
1092  int ielement = 0;
1093  for (const auto& detids : detids_elements) {
1094  int isimcluster = 0;
1095  if (!detids.empty()) {
1096  double sum_e_tot = 0.0;
1097  for (const auto& c : detids) {
1098  sum_e_tot += c.second;
1099  }
1100 
1101  for (const auto& simcluster_detids : simcluster_detids_) {
1102  double sum_e_tot_sc = 0.0;
1103  for (const auto& c : simcluster_detids) {
1104  sum_e_tot_sc += c.second;
1105  }
1106 
1107  //get the energy of the simcluster hits that matches detids of the rechits
1108  double cmp = detid_compare(detids, simcluster_detids);
1109  if (cmp > 0) {
1110  simcluster_to_element.push_back(make_pair(isimcluster, ielement));
1111  simcluster_to_element_cmp.push_back((float)cmp);
1112  }
1113  isimcluster += 1;
1114  }
1115  } //element had rechits
1116  ielement += 1;
1117  } //rechit clusters
1118 }
1119 
1120 void PFAnalysis::beginRun(edm::Run const& iEvent, edm::EventSetup const& es) {
1121  hcons = &es.getData(hcalDDDrecToken_);
1122  aField_ = &es.getData(magFieldToken_);
1123 }
1124 
1125 void PFAnalysis::endRun(edm::Run const& iEvent, edm::EventSetup const&) {}
1126 
1127 void PFAnalysis::beginJob() { ; }
1128 
1129 void PFAnalysis::endJob() {}
1130 
1131 void PFAnalysis::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
1132  edm::ParameterSetDescription desc;
1133  desc.setUnknown();
1134  descriptions.addDefault(desc);
1135 }
1136 
1137 DEFINE_FWK_MODULE(PFAnalysis);
runTheMatrix.ret
ret
prodAgent to be discontinued
Definition: runTheMatrix.py:543
PFAnalysis::element_to_candidate
vector< pair< int, int > > element_to_candidate
Definition: PFAnalysisNtuplizer.cc:263
PFAnalysis::analyze
void analyze(const edm::Event &, const edm::EventSetup &) override
Definition: PFAnalysisNtuplizer.cc:562
ntrack
#define ntrack
PFAnalysis::pfCandidates_
edm::EDGetTokenT< std::vector< reco::PFCandidate > > pfCandidates_
Definition: PFAnalysisNtuplizer.cc:143
Ecal2004TBTDCRanges_v1_cff.endRun
endRun
Definition: Ecal2004TBTDCRanges_v1_cff.py:4
edm::RunNumber_t
unsigned int RunNumber_t
Definition: RunLumiEventNumber.h:14
bk::beginJob
void beginJob()
Definition: Breakpoints.cc:14
PFAnalysis::trackingparticle_bx_
vector< int > trackingparticle_bx_
Definition: PFAnalysisNtuplizer.cc:162
reco::PFBlockElement::HO
Definition: PFBlockElement.h:42
zmumugammaAnalyzer_cfi.pfCandidates
pfCandidates
Definition: zmumugammaAnalyzer_cfi.py:11
PFAnalysis::clearVariables
void clearVariables()
Definition: PFAnalysisNtuplizer.cc:422
PFAnalysis::trackingparticle_dvx_
vector< float > trackingparticle_dvx_
Definition: PFAnalysisNtuplizer.cc:159
PFAnalysis::simcluster_phi_
vector< float > simcluster_phi_
Definition: PFAnalysisNtuplizer.cc:173
EDAnalyzer.h
PFAnalysis::element_energy_
vector< float > element_energy_
Definition: PFAnalysisNtuplizer.cc:234
mps_fire.i
i
Definition: mps_fire.py:428
edm::ESInputTag
Definition: ESInputTag.h:87
PFAnalysis::pfcandidate_py_
vector< float > pfcandidate_py_
Definition: PFAnalysisNtuplizer.cc:255
ElementWithIndex
Definition: PFAnalysisNtuplizer.cc:68
PFAnalysis::getHitPosition
GlobalPoint getHitPosition(const DetId &id)
Definition: PFAnalysisNtuplizer.cc:544
dqmiodumpmetadata.n
n
Definition: dqmiodumpmetadata.py:28
PFAnalysis::gen_eta_
vector< float > gen_eta_
Definition: PFAnalysisNtuplizer.cc:214
MainPageGenerator.link
link
Definition: MainPageGenerator.py:271
PFAnalysis::trackingparticle_exy_
vector< float > trackingparticle_exy_
Definition: PFAnalysisNtuplizer.cc:168
PFAnalysis::genParticles_
edm::EDGetTokenT< std::vector< reco::GenParticle > > genParticles_
Definition: PFAnalysisNtuplizer.cc:138
PFAnalysis::simtrack_x_
vector< float > simtrack_x_
Definition: PFAnalysisNtuplizer.cc:208
PFAnalysis::trackingParticles_
edm::EDGetTokenT< edm::View< TrackingParticle > > trackingParticles_
Definition: PFAnalysisNtuplizer.cc:139
ESHandle.h
PFAnalysis::element_deltap_
vector< float > element_deltap_
Definition: PFAnalysisNtuplizer.cc:230
PFAnalysis::caloParticles_
edm::EDGetTokenT< edm::View< CaloParticle > > caloParticles_
Definition: PFAnalysisNtuplizer.cc:140
PFAnalysis::gen_pdgid_
vector< int > gen_pdgid_
Definition: PFAnalysisNtuplizer.cc:222
PFBlockElementCluster.h
reco::PFRecHit::energy
float energy() const
rechit energy
Definition: PFRecHit.h:99
PFCandidate.h
PFAnalysis::gen_px_
vector< float > gen_px_
Definition: PFAnalysisNtuplizer.cc:217
PFAnalysis::trackingparticle_py_
vector< float > trackingparticle_py_
Definition: PFAnalysisNtuplizer.cc:156
DiDispStaMuonMonitor_cfi.pt
pt
Definition: DiDispStaMuonMonitor_cfi.py:39
PFAnalysis::simhit_y_
vector< float > simhit_y_
Definition: PFAnalysisNtuplizer.cc:188
edm::Run
Definition: Run.h:45
deltaPhi.h
PFAnalysis::gen_pt_
vector< float > gen_pt_
Definition: PFAnalysisNtuplizer.cc:216
edm::EDGetTokenT
Definition: EDGetToken.h:33
PFAnalysis::element_depth_
vector< float > element_depth_
Definition: PFAnalysisNtuplizer.cc:242
PFAnalysis::trackingparticle_dvz_
vector< float > trackingparticle_dvz_
Definition: PFAnalysisNtuplizer.cc:161
multPhiCorr_741_25nsDY_cfi.py
py
Definition: multPhiCorr_741_25nsDY_cfi.py:12
PFAnalysis::simcluster_energy_
vector< float > simcluster_energy_
Definition: PFAnalysisNtuplizer.cc:175
PFAnalysis::pfcandidate_pt_
vector< float > pfcandidate_pt_
Definition: PFAnalysisNtuplizer.cc:253
PFAnalysis::ev_run_
edm::RunNumber_t ev_run_
Definition: PFAnalysisNtuplizer.cc:148
reco::PFBlockElementSuperCluster
Cluster Element.
Definition: PFBlockElementSuperCluster.h:15
PFAnalysis::Point
ROOT::Math::Transform3D::Point Point
Definition: PFAnalysisNtuplizer.cc:110
math::XYZTLorentzVectorD
ROOT::Math::LorentzVector< ROOT::Math::PxPyPzE4D< double > > XYZTLorentzVectorD
Lorentz vector with cylindrical internal representation using pseudorapidity.
Definition: LorentzVector.h:14
pos
Definition: PixelAliasList.h:18
HcalTopology
Definition: HcalTopology.h:26
DetId::Hcal
Definition: DetId.h:28
reco::PFBlockElement::SC
Definition: PFBlockElement.h:41
HLT_FULL_cff.InputTag
InputTag
Definition: HLT_FULL_cff.py:89301
TrackAssociation.h
PFAnalysis::simcluster_detids_
vector< std::map< uint64_t, double > > simcluster_detids_
Definition: PFAnalysisNtuplizer.cc:184
edm::ParameterSetDescription
Definition: ParameterSetDescription.h:52
find_element_ref
vector< int > find_element_ref(const vector< ElementWithIndex > &vec, const edm::RefToBase< reco::Track > &r)
Definition: PFAnalysisNtuplizer.cc:77
PFAnalysis::element_px_
vector< float > element_px_
Definition: PFAnalysisNtuplizer.cc:227
BaseParticlePropagator.h
cms::cuda::assert
assert(be >=bs)
PFAnalysis::gen_status_
vector< int > gen_status_
Definition: PFAnalysisNtuplizer.cc:223
PFAnalysis::simcluster_pid_
vector< int > simcluster_pid_
Definition: PFAnalysisNtuplizer.cc:181
PFAnalysis::trackingparticle_dvy_
vector< float > trackingparticle_dvy_
Definition: PFAnalysisNtuplizer.cc:160
PFAnalysis::simhit_det_
vector< int > simhit_det_
Definition: PFAnalysisNtuplizer.cc:192
reco::PFBlockElement::HCAL
Definition: PFBlockElement.h:36
PFAnalysis::rechit_x_
vector< float > rechit_x_
Definition: PFAnalysisNtuplizer.cc:198
PFAnalysis::simhit_subdet_
vector< int > simhit_subdet_
Definition: PFAnalysisNtuplizer.cc:193
edm::ParameterSet::getUntrackedParameter
T getUntrackedParameter(std::string const &, T const &) const
hgcal_conditions::parameters
Definition: HGCConditions.h:86
PFAnalysis::magFieldToken_
edm::ESGetToken< MagneticField, IdealMagneticFieldRecord > magFieldToken_
Definition: PFAnalysisNtuplizer.cc:270
PFAnalysis::tracks_recotosim_
edm::EDGetTokenT< reco::RecoToSimCollection > tracks_recotosim_
Definition: PFAnalysisNtuplizer.cc:144
edm::one::EDAnalyzer
Definition: EDAnalyzer.h:30
PFAnalysis::simhit_eta_
vector< float > simhit_eta_
Definition: PFAnalysisNtuplizer.cc:190
HcalBarrel
Definition: HcalAssistant.h:33
PFAnalysis::ev_event_
edm::EventNumber_t ev_event_
Definition: PFAnalysisNtuplizer.cc:150
PFAnalysis::topologyToken_
edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > topologyToken_
Definition: PFAnalysisNtuplizer.cc:269
PFBlockElementBrem.h
edm::Handle
Definition: AssociativeIterator.h:50
edm::LuminosityBlockNumber_t
unsigned int LuminosityBlockNumber_t
Definition: RunLumiEventNumber.h:13
PFAnalysis::element_distance_i_
vector< int > element_distance_i_
Definition: PFAnalysisNtuplizer.cc:247
MLPFModel.h
PFAnalysis::trackingparticle_exx_
vector< float > trackingparticle_exx_
Definition: PFAnalysisNtuplizer.cc:167
PFAnalysis::element_muon_csc_hits_
vector< float > element_muon_csc_hits_
Definition: PFAnalysisNtuplizer.cc:245
EcalBarrel
Definition: EcalSubdetector.h:10
PFAnalysis::hcons
const HcalDDDRecConstants * hcons
Definition: PFAnalysisNtuplizer.cc:275
HcalGeometry.h
PFAnalysis::simcluster_pz_
vector< float > simcluster_pz_
Definition: PFAnalysisNtuplizer.cc:178
edm::Ref
Definition: AssociativeIterator.h:58
PFAnalysis::trackingparticle_pid_
vector< int > trackingparticle_pid_
Definition: PFAnalysisNtuplizer.cc:170
reco::PFBlockElement::Type
Type
Definition: PFBlockElement.h:30
ElementWithIndex::idx_elem
size_t idx_elem
Definition: PFAnalysisNtuplizer.cc:72
PFAnalysis::rechit_idx_element_
vector< int > rechit_idx_element_
Definition: PFAnalysisNtuplizer.cc:205
DetId
Definition: DetId.h:17
PFAnalysis::trackingparticle_px_
vector< float > trackingparticle_px_
Definition: PFAnalysisNtuplizer.cc:155
PFAnalysis::trackingparticle_ev_
vector< int > trackingparticle_ev_
Definition: PFAnalysisNtuplizer.cc:163
MakerMacros.h
Point
math::XYZPoint Point
Definition: TrackerDpgAnalysis.cc:106
CaloGeometry
Definition: CaloGeometry.h:21
PlaneBuilder.h
PFAnalysis::element_charge_
vector< int > element_charge_
Definition: PFAnalysisNtuplizer.cc:239
SimCluster.h
photonIsolationHIProducer_cfi.hf
hf
Definition: photonIsolationHIProducer_cfi.py:9
Track.h
PFAnalysis::pfcandidate_pz_
vector< float > pfcandidate_pz_
Definition: PFAnalysisNtuplizer.cc:256
PFAnalysis::element_type_
vector< int > element_type_
Definition: PFAnalysisNtuplizer.cc:240
DEFINE_FWK_MODULE
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:16
HFRecHit.h
PFAnalysis::ev_lumi_
edm::LuminosityBlockNumber_t ev_lumi_
Definition: PFAnalysisNtuplizer.cc:149
BPhysicsValidation_cfi.daughters
daughters
Definition: BPhysicsValidation_cfi.py:11
PFAnalysis::hcalDDDrecToken_
edm::ESGetToken< HcalDDDRecConstants, HcalRecNumberingRecord > hcalDDDrecToken_
Definition: PFAnalysisNtuplizer.cc:271
PFAnalysis::rechit_z_
vector< float > rechit_z_
Definition: PFAnalysisNtuplizer.cc:200
PFAnalysis::simtrack_z_
vector< float > simtrack_z_
Definition: PFAnalysisNtuplizer.cc:210
PFAnalysis::processTrackingParticles
void processTrackingParticles(const edm::View< TrackingParticle > &trackingParticles, edm::Handle< edm::View< TrackingParticle >> &trackingParticlesHandle)
Definition: PFAnalysisNtuplizer.cc:919
PFAnalysis::simhit_frac_
vector< float > simhit_frac_
Definition: PFAnalysisNtuplizer.cc:186
reco::PFBlockElement::TRACK
Definition: PFBlockElement.h:32
Service.h
PVValHelper::eta
Definition: PVValidationHelpers.h:70
PFAnalysis::trackingparticle_pz_
vector< float > trackingparticle_pz_
Definition: PFAnalysisNtuplizer.cc:157
PVValHelper::pT
Definition: PVValidationHelpers.h:71
PFAnalysis::simtrack_pid_
vector< int > simtrack_pid_
Definition: PFAnalysisNtuplizer.cc:212
get_index_triu_vector
int get_index_triu_vector(int i, int j, int n)
Definition: PFAnalysisNtuplizer.cc:955
ElementWithIndex::idx_block
size_t idx_block
Definition: PFAnalysisNtuplizer.cc:71
PFAnalysis::simtrack_y_
vector< float > simtrack_y_
Definition: PFAnalysisNtuplizer.cc:209
reco::PFTrajectoryPoint::ECALShowerMax
Definition: PFTrajectoryPoint.h:46
caloTruthCellsProducer_cfi.caloParticles
caloParticles
Definition: caloTruthCellsProducer_cfi.py:6
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
PFAnalysis::simcluster_idx_trackingparticle_
vector< int > simcluster_idx_trackingparticle_
Definition: PFAnalysisNtuplizer.cc:182
fillDescriptions
static void fillDescriptions(edm::ConfigurationDescriptions &descriptions)
PFAnalysis::element_phi_hcal_
vector< float > element_phi_hcal_
Definition: PFAnalysisNtuplizer.cc:238
IdealMagneticFieldRecord.h
PFCluster.h
relativeConstraints.geom
geom
Definition: relativeConstraints.py:72
CaloClusterFwd.h
HcalOuter
Definition: HcalAssistant.h:35
PFAnalysis::simcluster_ev_
vector< int > simcluster_ev_
Definition: PFAnalysisNtuplizer.cc:180
reco::PFBlockElementBrem
Track Element.
Definition: PFBlockElementBrem.h:17
PFAnalysis::simhit_detid_
vector< uint64_t > simhit_detid_
Definition: PFAnalysisNtuplizer.cc:195
edm::EventNumber_t
unsigned long long EventNumber_t
Definition: RunLumiEventNumber.h:12
HCALHighEnergyHPDFilter_cfi.energy
energy
Definition: HCALHighEnergyHPDFilter_cfi.py:5
PFAnalysis::~PFAnalysis
~PFAnalysis() override
Definition: PFAnalysisNtuplizer.cc:420
HI_PhotonSkim_cff.rechits
rechits
Definition: HI_PhotonSkim_cff.py:76
get_triu_vector_index
pair< int, int > get_triu_vector_index(int k, int n)
Definition: PFAnalysisNtuplizer.cc:960
GlobalPoint
Global3DPoint GlobalPoint
Definition: GlobalPoint.h:10
dqmdumpme.k
k
Definition: dqmdumpme.py:60
PFAnalysis::rechit_detid_
vector< uint64_t > rechit_detid_
Definition: PFAnalysisNtuplizer.cc:206
PFAnalysis::beginJob
void beginJob() override
Definition: PFAnalysisNtuplizer.cc:1127
PFAnalysis::trackingparticle_to_element
vector< pair< int, int > > trackingparticle_to_element
Definition: PFAnalysisNtuplizer.cc:260
Point3DBase< float, GlobalTag >
GsfElectron.h
nhits
Definition: HIMultiTrackSelector.h:42
PFAnalysis::trackingparticle_ovx_
vector< float > trackingparticle_ovx_
Definition: PFAnalysisNtuplizer.cc:164
PFAnalysis::endRun
void endRun(edm::Run const &iEvent, edm::EventSetup const &) override
Definition: PFAnalysisNtuplizer.cc:1125
LEDCalibrationChannels.depth
depth
Definition: LEDCalibrationChannels.py:65
cmsswSequenceInfo.tp
tp
Definition: cmsswSequenceInfo.py:17
PFAnalysis::gen_phi_
vector< float > gen_phi_
Definition: PFAnalysisNtuplizer.cc:215
PFAnalysis::simcluster_to_element
vector< pair< int, int > > simcluster_to_element
Definition: PFAnalysisNtuplizer.cc:261
PFAnalysis::simcluster_pt_
vector< float > simcluster_pt_
Definition: PFAnalysisNtuplizer.cc:174
CaloGeometryRecord.h
edm::ConfigurationDescriptions
Definition: ConfigurationDescriptions.h:28
phase1PixelTopology::layer
constexpr std::array< uint8_t, layerIndexSize > layer
Definition: phase1PixelTopology.h:99
PFAnalysis::pfcandidate_pdgid_
vector< int > pfcandidate_pdgid_
Definition: PFAnalysisNtuplizer.cc:258
EcalSubdetector.h
EcalEndcap
Definition: EcalSubdetector.h:10
PFAnalysis::pfcandidate_energy_
vector< float > pfcandidate_energy_
Definition: PFAnalysisNtuplizer.cc:257
TFileService.h
PFAnalysis::simcluster_nhits_
vector< int > simcluster_nhits_
Definition: PFAnalysisNtuplizer.cc:183
PFAnalysis::rechit_subdet_
vector< float > rechit_subdet_
Definition: PFAnalysisNtuplizer.cc:202
PFAnalysis::simhit_phi_
vector< float > simhit_phi_
Definition: PFAnalysisNtuplizer.cc:191
ALCARECOTkAlJpsiMuMu_cff.charge
charge
Definition: ALCARECOTkAlJpsiMuMu_cff.py:47
edm::View
Definition: CaloClusterFwd.h:14
PFAnalysis::simcluster_px_
vector< float > simcluster_px_
Definition: PFAnalysisNtuplizer.cc:176
PFAnalysis::associateClusterToSimCluster
void associateClusterToSimCluster(const vector< ElementWithIndex > &all_elements)
Definition: PFAnalysisNtuplizer.cc:998
CaloSubdetectorGeometry.h
PFAnalysis::element_eta_hcal_
vector< float > element_eta_hcal_
Definition: PFAnalysisNtuplizer.cc:237
HLTBitAnalyser_cfi.simhits
simhits
SIM objects.
Definition: HLTBitAnalyser_cfi.py:21
PFAnalysis::element_muon_dt_hits_
vector< float > element_muon_dt_hits_
Definition: PFAnalysisNtuplizer.cc:244
edm::ParameterSet
Definition: ParameterSet.h:47
reco::PFBlockElement::HFEM
Definition: PFBlockElement.h:39
PFAnalysis::element_phi_
vector< float > element_phi_
Definition: PFAnalysisNtuplizer.cc:233
reco::PFBlockElement::GSF
Definition: PFBlockElement.h:37
Event.h
tracks
const uint32_t *__restrict__ const HitContainer *__restrict__ TkSoA *__restrict__ tracks
Definition: CAHitNtupletGeneratorKernelsImpl.h:176
PFAnalysis::rechit_e_
vector< float > rechit_e_
Definition: PFAnalysisNtuplizer.cc:197
CaloSubdetectorGeometry::present
virtual bool present(const DetId &id) const
is this detid present in the geometry?
Definition: CaloSubdetectorGeometry.cc:40
PFAnalysis::element_phi_ecal_
vector< float > element_phi_ecal_
Definition: PFAnalysisNtuplizer.cc:236
PFAnalysis::gen_py_
vector< float > gen_py_
Definition: PFAnalysisNtuplizer.cc:218
type
type
Definition: SiPixelVCal_PayloadInspector.cc:39
PFAnalysis::fillDescriptions
static void fillDescriptions(edm::ConfigurationDescriptions &descriptions)
Definition: PFAnalysisNtuplizer.cc:1131
HcalDetId.h
edm::Ref::isNonnull
bool isNonnull() const
Checks for non-null.
Definition: Ref.h:238
PFAnalysis::processBlocks
pair< vector< ElementWithIndex >, vector< tuple< int, int, float > > > processBlocks(const std::vector< reco::PFBlock > &pfBlocks)
Definition: PFAnalysisNtuplizer.cc:966
CaloParticle.h
muonClassificationByHits_cfi.trackingParticles
trackingParticles
Definition: muonClassificationByHits_cfi.py:28
PFAnalysis::simcluster_to_element_cmp
vector< float > simcluster_to_element_cmp
Definition: PFAnalysisNtuplizer.cc:262
PFAnalysis::rechit_eta_
vector< float > rechit_eta_
Definition: PFAnalysisNtuplizer.cc:203
HcalHitRelabeller.h
PFAnalysis::beginRun
void beginRun(edm::Run const &iEvent, edm::EventSetup const &) override
Definition: PFAnalysisNtuplizer.cc:1120
reco::PFBlockElement::ECAL
Definition: PFBlockElement.h:35
reco::PFTrajectoryPoint::HCALEntrance
HCAL front face.
Definition: PFTrajectoryPoint.h:48
cand
Definition: decayParser.h:32
edm::Service< TFileService >
reco::PFBlockElement::BREM
Definition: PFBlockElement.h:38
PFAnalysis::element_trajpoint_
vector< float > element_trajpoint_
Definition: PFAnalysisNtuplizer.cc:243
iEvent
int iEvent
Definition: GenABIO.cc:224
PFBlockElementSuperCluster.h
PFAnalysis::element_distance_j_
vector< int > element_distance_j_
Definition: PFAnalysisNtuplizer.cc:248
GsfTrack.h
PFAnalysis::simhit_idx_simcluster_
vector< int > simhit_idx_simcluster_
Definition: PFAnalysisNtuplizer.cc:194
PFAnalysis::gen_energy_
vector< float > gen_energy_
Definition: PFAnalysisNtuplizer.cc:220
PFAnalysis::simtrack_idx_simcluster_
vector< int > simtrack_idx_simcluster_
Definition: PFAnalysisNtuplizer.cc:211
PFAnalysis::element_distance_d_
vector< float > element_distance_d_
Definition: PFAnalysisNtuplizer.cc:249
analyze
example_stream void analyze(const edm::Event &, const edm::EventSetup &) override
groupFilesInBlocks.block
block
Definition: groupFilesInBlocks.py:150
MagneticField.h
PFAnalysis::gen_pz_
vector< float > gen_pz_
Definition: PFAnalysisNtuplizer.cc:219
CaloSubdetectorGeometry::getGeometry
virtual std::shared_ptr< const CaloCellGeometry > getGeometry(const DetId &id) const
Get the cell geometry of a given detector id. Should return false if not found.
Definition: CaloSubdetectorGeometry.cc:36
edm::EventSetup
Definition: EventSetup.h:58
reco::PFBlockElement::HFHAD
Definition: PFBlockElement.h:40
PFAnalysis::pfcandidate_px_
vector< float > pfcandidate_px_
Definition: PFAnalysisNtuplizer.cc:254
DetId::Ecal
Definition: DetId.h:27
PFAnalysis::element_sigmadeltap_
vector< float > element_sigmadeltap_
Definition: PFAnalysisNtuplizer.cc:231
PFAnalysis::element_eta_
vector< float > element_eta_
Definition: PFAnalysisNtuplizer.cc:232
PFAnalysis::simcluster_py_
vector< float > simcluster_py_
Definition: PFAnalysisNtuplizer.cc:177
TFileService::make
T * make(const Args &...args) const
make new ROOT object
Definition: TFileService.h:64
edm::ESGetToken< CaloGeometry, CaloGeometryRecord >
detid_compare
double detid_compare(const map< uint64_t, double > &rechits, const map< uint64_t, double > &simhits)
Definition: PFAnalysisNtuplizer.cc:93
PFAnalysis::simcluster_bx_
vector< int > simcluster_bx_
Definition: PFAnalysisNtuplizer.cc:179
reco::PFBlockElement
Abstract base class for a PFBlock element (track, cluster...)
Definition: PFBlockElement.h:26
edm::EventSetup::getData
bool getData(T &iHolder) const
Definition: EventSetup.h:127
alignCSCRings.r
r
Definition: alignCSCRings.py:93
reco::PFRecHit::detId
unsigned detId() const
rechit detId
Definition: PFRecHit.h:93
PFBlock.h
HcalForward
Definition: HcalAssistant.h:36
MagVolumeOutsideValidity.h
PFAnalysis::element_pz_
vector< float > element_pz_
Definition: PFAnalysisNtuplizer.cc:229
EcalPreshower
Definition: EcalSubdetector.h:10
multPhiCorr_741_25nsDY_cfi.px
px
Definition: multPhiCorr_741_25nsDY_cfi.py:10
TrackingParticle.h
CaloCellGeometry.h
reco::PFBlockElementGsfTrack
Track Element.
Definition: PFBlockElementGsfTrack.h:18
submitPVResolutionJobs.desc
string desc
Definition: submitPVResolutionJobs.py:251
std
Definition: JetResolutionObject.h:76
PFAnalysis::simcluster_eta_
vector< float > simcluster_eta_
Definition: PFAnalysisNtuplizer.cc:172
PFAnalysis::trackingparticle_phi_
vector< float > trackingparticle_phi_
Definition: PFAnalysisNtuplizer.cc:153
PFAnalysis::element_pt_
vector< float > element_pt_
Definition: PFAnalysisNtuplizer.cc:226
PFAnalysis::element_py_
vector< float > element_py_
Definition: PFAnalysisNtuplizer.cc:228
extraflags_cff.vtx
vtx
Definition: extraflags_cff.py:19
PFAnalysis::simhit_z_
vector< float > simhit_z_
Definition: PFAnalysisNtuplizer.cc:189
ElementWithIndex::ElementWithIndex
ElementWithIndex(const reco::PFBlockElement &_orig, size_t _idx_block, size_t _idx_elem)
Definition: PFAnalysisNtuplizer.cc:73
PFAnalysis::PFAnalysis
PFAnalysis()
Definition: PFAnalysisNtuplizer.cc:280
HcalEndcap
Definition: HcalAssistant.h:34
fileCollector.cmp
cmp
Definition: fileCollector.py:125
Vertex.h
DetId.h
Frameworkfwd.h
PFAnalysis::trackingparticle_ovz_
vector< float > trackingparticle_ovz_
Definition: PFAnalysisNtuplizer.cc:166
PFAnalysis::gen_charge_
vector< int > gen_charge_
Definition: PFAnalysisNtuplizer.cc:221
triggerObjects_cff.id
id
Definition: triggerObjects_cff.py:29
reco::PFBlockElementCluster
Cluster Element.
Definition: PFBlockElementCluster.h:16
CaloGeometry.h
PFAnalysis::saveHits
bool saveHits
Definition: PFAnalysisNtuplizer.cc:277
TFileService::kSharedResource
static const std::string kSharedResource
Definition: TFileService.h:76
PFAnalysis::endJob
void endJob() override
Definition: PFAnalysisNtuplizer.cc:1129
reco::PFBlockElementTrack
Track Element.
Definition: PFBlockElementTrack.h:17
PFAnalysis::aField_
MagneticField const * aField_
Definition: PFAnalysisNtuplizer.cc:266
CaloSubdetectorGeometry
Definition: CaloSubdetectorGeometry.h:22
edm::RefToBase< reco::Track >
HcalRecHitCollections.h
PFAnalysis::trackingparticle_eta_
vector< float > trackingparticle_eta_
Definition: PFAnalysisNtuplizer.cc:152
PFAnalysis::element_layer_
vector< int > element_layer_
Definition: PFAnalysisNtuplizer.cc:241
HcalDDDRecConstants
Definition: HcalDDDRecConstants.h:23
reco::PFRecHit
Particle flow rechit (rechit + geometry and topology information). See clustering algorithm in PFClus...
Definition: PFRecHit.h:31
PFAnalysis::hcal_topo
HcalTopology * hcal_topo
Definition: PFAnalysisNtuplizer.cc:274
edm::Ref::key
key_type key() const
Accessor for product key.
Definition: Ref.h:250
PFAnalysis::geom
CaloGeometry * geom
Definition: PFAnalysisNtuplizer.cc:273
ztail.d
d
Definition: ztail.py:151
PFAnalysis::geometryToken_
edm::ESGetToken< CaloGeometry, CaloGeometryRecord > geometryToken_
Definition: PFAnalysisNtuplizer.cc:268
ElementWithIndex::orig
const reco::PFBlockElement & orig
Definition: PFAnalysisNtuplizer.cc:70
reco::PFBlockElement::PS1
Definition: PFBlockElement.h:33
PFAnalysis::pfBlocks_
edm::EDGetTokenT< std::vector< reco::PFBlock > > pfBlocks_
Definition: PFAnalysisNtuplizer.cc:142
PFAnalysis::pfcandidate_phi_
vector< float > pfcandidate_phi_
Definition: PFAnalysisNtuplizer.cc:252
ParameterSet.h
HepMCProduct.h
c
auto & c
Definition: CAHitNtupletGeneratorKernelsImpl.h:56
dqmiolumiharvest.j
j
Definition: dqmiolumiharvest.py:66
PFAnalysis::gen_daughters_
vector< vector< int > > gen_daughters_
Definition: PFAnalysisNtuplizer.cc:224
edm::Event
Definition: Event.h:73
PFAnalysis::pfcandidate_eta_
vector< float > pfcandidate_eta_
Definition: PFAnalysisNtuplizer.cc:251
PFAnalysis::trackingparticle_pt_
vector< float > trackingparticle_pt_
Definition: PFAnalysisNtuplizer.cc:154
submitPVValidationJobs.t
string t
Definition: submitPVValidationJobs.py:644
edm::ConfigurationDescriptions::addDefault
void addDefault(ParameterSetDescription const &psetDescription)
Definition: ConfigurationDescriptions.cc:99
MagneticField
Definition: MagneticField.h:19
PFAnalysis::trackingparticle_energy_
vector< float > trackingparticle_energy_
Definition: PFAnalysisNtuplizer.cc:158
PFAnalysis
Definition: PFAnalysisNtuplizer.cc:108
PFBlockElementGsfTrack.h
PFAnalysis::element_eta_ecal_
vector< float > element_eta_ecal_
Definition: PFAnalysisNtuplizer.cc:235
edm::InputTag
Definition: InputTag.h:15
PFAnalysis::rechit_det_
vector< float > rechit_det_
Definition: PFAnalysisNtuplizer.cc:201
PFBlockElementTrack.h
PFAnalysis::t_
TTree * t_
Definition: PFAnalysisNtuplizer.cc:146
reco::PFBlockElement::PS2
Definition: PFBlockElement.h:34
PFAnalysis::trackingparticle_mother_
vector< int > trackingparticle_mother_
Definition: PFAnalysisNtuplizer.cc:169
PFAnalysis::rechit_y_
vector< float > rechit_y_
Definition: PFAnalysisNtuplizer.cc:199
PFAnalysis::tracks_
edm::EDGetTokenT< edm::View< reco::Track > > tracks_
Definition: PFAnalysisNtuplizer.cc:141
PFAnalysis::trackingparticle_ovy_
vector< float > trackingparticle_ovy_
Definition: PFAnalysisNtuplizer.cc:165
PFAnalysis::rechit_phi_
vector< float > rechit_phi_
Definition: PFAnalysisNtuplizer.cc:204
PFAnalysis::simhit_x_
vector< float > simhit_x_
Definition: PFAnalysisNtuplizer.cc:187
Generated for CMSSW Reference Manual by doxygen 1.8.16