CMS 3D CMS Logo
HcalRaddamMuon.cc
Go to the documentation of this file.
1 #include <memory>
2 #include <iostream>
3 #include <vector>
4 
5 #include <TTree.h>
6 
7 // user include files
8 #include "FWCore/Framework/interface/Frameworkfwd.h"
9 #include "FWCore/Framework/interface/one/EDAnalyzer.h"
10 #include "FWCore/Framework/interface/Event.h"
11 #include "FWCore/Framework/interface/MakerMacros.h"
12 #include "FWCore/ParameterSet/interface/ParameterSet.h"
13 #include "FWCore/ServiceRegistry/interface/Service.h"
14 #include "FWCore/Common/interface/TriggerNames.h"
15 #include "CommonTools/UtilAlgos/interface/TFileService.h"
16 #include "DataFormats/EcalDetId/interface/EcalSubdetector.h"
17 #include "DataFormats/EcalDetId/interface/EBDetId.h"
18 #include "DataFormats/EcalDetId/interface/EEDetId.h"
19 #include "DataFormats/EcalDetId/interface/ESDetId.h"
20 #include "DataFormats/EcalRecHit/interface/EcalRecHitCollections.h"
21 #include "DataFormats/HcalRecHit/interface/HcalRecHitCollections.h"
22 #include "DataFormats/HcalDetId/interface/HcalDetId.h"
23 #include "DataFormats/MuonReco/interface/Muon.h"
24 #include "DataFormats/MuonReco/interface/MuonFwd.h"
25 #include "DataFormats/VertexReco/interface/Vertex.h"
26 #include "DataFormats/VertexReco/interface/VertexFwd.h"
27 #include "DataFormats/TrackReco/interface/Track.h"
28 #include "DataFormats/Common/interface/TriggerResults.h"
29 #include "DataFormats/HLTReco/interface/TriggerObject.h"
30 #include "DataFormats/HLTReco/interface/TriggerEvent.h"
31 #include "HLTrigger/HLTcore/interface/HLTConfigProvider.h"
32 #include "HLTrigger/HLTcore/interface/HLTConfigData.h"
33 
34 #include "CondFormats/DataRecord/interface/EcalChannelStatusRcd.h"
35 #include "RecoLocalCalo/EcalRecAlgos/interface/EcalSeverityLevelAlgo.h"
36 #include "RecoLocalCalo/EcalRecAlgos/interface/EcalSeverityLevelAlgoRcd.h"
37 
38 #include "Calibration/IsolatedParticles/interface/CaloPropagateTrack.h"
39 #include "Calibration/IsolatedParticles/interface/eECALMatrix.h"
40 #include "Calibration/IsolatedParticles/interface/eHCALMatrix.h"
41 
42 #include "Geometry/CaloGeometry/interface/CaloGeometry.h"
43 #include "Geometry/Records/interface/CaloGeometryRecord.h"
44 #include "Geometry/CaloGeometry/interface/CaloSubdetectorGeometry.h"
45 #include "Geometry/CaloEventSetup/interface/CaloTopologyRecord.h"
46 #include "Geometry/CaloTopology/interface/CaloSubdetectorTopology.h"
47 #include "Geometry/CaloTopology/interface/HcalTopology.h"
48 #include "Geometry/CaloTopology/interface/CaloTopology.h"
49 #include "Geometry/HcalCommonData/interface/HcalDDDRecConstants.h"
50 #include "MagneticField/Engine/interface/MagneticField.h"
51 #include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"
52 #include "SimDataFormats/CaloHit/interface/PCaloHitContainer.h"
53 
54 class HcalRaddamMuon : public edm::one::EDAnalyzer<edm::one::WatchRuns, edm::one::SharedResources> {
55 public:
56  explicit HcalRaddamMuon(const edm::ParameterSet&);
57  ~HcalRaddamMuon() override;
58 
59  static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
60 
61 private:
62  void beginJob() override;
63  void analyze(const edm::Event&, const edm::EventSetup&) override;
64  void endJob() override;
65  void beginRun(edm::Run const&, edm::EventSetup const&) override;
66  void endRun(edm::Run const&, edm::EventSetup const&) override;
67  void clearVectors();
68  int matchId(const HcalDetId&, const HcalDetId&);
69  double activeLength(const DetId&);
70 
71  // ----------member data ---------------------------
72  std::vector<double> PtGlob, track_cosmic_positionIX, track_cosmic_positionIY, track_cosmic_positionIZ,
73  track_cosmic_positionOX, track_cosmic_positionOY, track_cosmic_positionOZ;
74 
75  std::vector<double> track_cosmic_momentumOX, track_cosmic_momentumOY, track_cosmic_momentumOZ,
76  track_cosmic_momentumIX, track_cosmic_momentumIY, track_cosmic_momentumIZ, track_cosmic_detIDinner,
77  track_cosmic_detIDouter;
78  std::vector<double> EtaGlob;
79  std::vector<double> PhiGlob, chiGlobal, GlobalMuonHits, MatchedStat, GlobalTrckPt, GlobalTrckEta, GlobalTrckPhi;
80  std::vector<double> TrackerLayer, innerTrackpt, innerTracketa, innerTrackphi;
81  std::vector<double> NumPixelLayers, chiTracker, DxyTracker, DzTracker;
82  std::vector<double> OuterTrackPt, OuterTrackEta, OuterTrackPhi, OuterTrackChi, OuterTrackHits, OuterTrackRHits;
83  std::vector<double> trackerlayer_hits, No_pixelLayers, NormChi2, ImpactParameter;
84  std::vector<double> Tight_GlobalMuonTrkFit, Tight_MuonHits, Tight_MatchedStations, Tight_LongPara, Tight_PixelHits,
85  Tight_TrkerLayers, Tight_TransImpara, High_TrackLayers;
86  std::vector<bool> innerTrack, OuterTrack, GlobalTrack;
87  std::vector<double> IsolationR04, IsolationR03;
88  std::vector<double> Energy, MuonHcalEnergy, MuonEcalEnergy, MuonHOEnergy, MuonEcal3x3Energy, MuonHcal1x1Energy, Pmuon;
89  std::vector<unsigned int> MuonEcalDetId, MuonHcalDetId, MuonEHcalDetId, MuonHcalHot, MuonHcalHotCalo;
90  std::vector<double> MuonHcalDepth1Energy, MuonHcalDepth2Energy, MuonHcalDepth3Energy, MuonHcalDepth4Energy,
91  MuonHcalDepth5Energy, MuonHcalDepth6Energy, MuonHcalDepth7Energy;
92  std::vector<double> MuonHcalDepth1HotEnergy, MuonHcalDepth2HotEnergy, MuonHcalDepth3HotEnergy,
93  MuonHcalDepth4HotEnergy, MuonHcalDepth5HotEnergy, MuonHcalDepth6HotEnergy, MuonHcalDepth7HotEnergy;
94 
95  //
96  std::vector<double> MuonHcalDepth1EnergyCalo, MuonHcalDepth2EnergyCalo, MuonHcalDepth3EnergyCalo,
97  MuonHcalDepth4EnergyCalo, MuonHcalDepth5EnergyCalo, MuonHcalDepth6EnergyCalo, MuonHcalDepth7EnergyCalo;
98  std::vector<double> MuonHcalDepth1HotEnergyCalo, MuonHcalDepth2HotEnergyCalo, MuonHcalDepth3HotEnergyCalo,
99  MuonHcalDepth4HotEnergyCalo, MuonHcalDepth5HotEnergyCalo, MuonHcalDepth6HotEnergyCalo,
100  MuonHcalDepth7HotEnergyCalo;
101 
102  //
103  std::vector<double> MuonHcalActiveLength;
104  std::vector<HcalDDDRecConstants::HcalActiveLength> actHB, actHE;
105  int maxDepth_, type;
106  edm::Service<TFileService> fs;
108  HLTConfigProvider hltConfig_;
109  const edm::InputTag hlTriggerResults_, muonsrc_;
110  const int verbosity_, useRaw_;
111  const bool isAOD_;
112  std::string hltlabel_;
113  std::vector<std::string> all_triggers, all_triggers1, all_triggers2, all_triggers3, all_triggers4, all_triggers5;
115 
116  std::vector<bool> isHB, isHE;
117  TTree* TREE;
118  std::vector<bool> all_ifTriggerpassed;
119  std::vector<bool> muon_is_good, muon_global, muon_tracker, Trk_match_MuStat;
120  std::vector<int> hltresults;
121  std::vector<float> energy_hb, time_hb;
122  std::vector<std::string> hltpaths, TrigName_;
123  std::vector<int> v_RH_h3x3_ieta;
124  std::vector<int> v_RH_h3x3_iphi;
125  std::vector<double> v_RH_h3x3_ene, PxGlob, PyGlob, PzGlob, Pthetha;
126  std::vector<double> PCharge, PChi2, PD0, PD0Error, dxyWithBS, dzWithBS, PdxyTrack, PdzTrack, PNormalizedChi2, PNDoF,
127  PValidHits, PLostHits, NPvx, NPvy, NPvz, NQOverP, NQOverPError, NTrkMomentum, NRefPointX, NRefPointY, NRefPointZ;
128  double h3x3, h3x3Calo;
129  unsigned int RunNumber, EventNumber, LumiNumber, BXNumber;
130  double _RecoMuon1TrackIsoSumPtMaxCutValue_03, _RecoMuon1TrackIsoSumPtMaxCutValue_04;
131  int ntriggers;
132  std::vector<double> track_cosmic_xposition, track_cosmic_yposition, track_cosmic_zposition, track_cosmic_xmomentum,
133  track_cosmic_ymomentum, track_cosmic_zmomentum, track_cosmic_rad, track_cosmic_detid;
134 
135  edm::EDGetTokenT<edm::PCaloHitContainer> tok_hcal_;
136  edm::EDGetTokenT<edm::TriggerResults> tok_trigRes_;
137  edm::EDGetTokenT<reco::VertexCollection> tok_recVtx_;
138  edm::EDGetTokenT<reco::BeamSpot> tok_bs_;
139  edm::EDGetTokenT<EcalRecHitCollection> tok_EB_;
140  edm::EDGetTokenT<EcalRecHitCollection> tok_EE_;
141  edm::EDGetTokenT<HBHERecHitCollection> tok_hbhe_;
142  edm::EDGetTokenT<reco::MuonCollection> tok_muon_;
143 
144  edm::ESGetToken<HcalDDDRecConstants, HcalRecNumberingRecord> tok_ddrec_;
145  edm::ESGetToken<CaloGeometry, CaloGeometryRecord> tok_geom_;
146  edm::ESGetToken<CaloTopology, CaloTopologyRecord> tok_caloTopology_;
147  edm::ESGetToken<HcalTopology, HcalRecNumberingRecord> tok_topo_;
148  edm::ESGetToken<MagneticField, IdealMagneticFieldRecord> tok_magField_;
149  edm::ESGetToken<EcalChannelStatus, EcalChannelStatusRcd> tok_ecalChStatus_;
150  edm::ESGetToken<EcalSeverityLevelAlgo, EcalSeverityLevelAlgoRcd> tok_sevlv_;
151 };
152 
153 HcalRaddamMuon::HcalRaddamMuon(const edm::ParameterSet& iConfig)
154  : hlTriggerResults_(iConfig.getUntrackedParameter<edm::InputTag>("hlTriggerResults_")),
155  muonsrc_(iConfig.getUntrackedParameter<edm::InputTag>("muonSource")),
156  verbosity_(iConfig.getUntrackedParameter<int>("verbosity", 0)),
157  useRaw_(iConfig.getUntrackedParameter<int>("UseRaw", 0)),
158  isAOD_(iConfig.getUntrackedParameter<bool>("IsAOD", false)) {
159  usesResource(TFileService::kSharedResource);
160 
161  //now do what ever initialization is needed
162  maxDepth_ = iConfig.getUntrackedParameter<int>("MaxDepth", 4);
163  if (maxDepth_ > 7)
164  maxDepth_ = 7;
165  else if (maxDepth_ < 1)
166  maxDepth_ = 4;
167 
168  tok_hcal_ = consumes<edm::PCaloHitContainer>(edm::InputTag("g4SimHits", "HcalHits"));
169  tok_trigRes_ = consumes<edm::TriggerResults>(hlTriggerResults_);
170  tok_recVtx_ = consumes<reco::VertexCollection>(edm::InputTag("offlinePrimaryVertices"));
171  tok_bs_ = consumes<reco::BeamSpot>(edm::InputTag("offlineBeamSpot"));
172  if (isAOD_) {
173  tok_EB_ = consumes<EcalRecHitCollection>(edm::InputTag("reducedEcalRecHitsEB"));
174  tok_EE_ = consumes<EcalRecHitCollection>(edm::InputTag("reducedEcalRecHitsEE"));
175  tok_hbhe_ = consumes<HBHERecHitCollection>(edm::InputTag("reducedHcalRecHits", "hbhereco"));
176  } else {
177  tok_EB_ = consumes<EcalRecHitCollection>(edm::InputTag("ecalRecHit", "EcalRecHitsEB"));
178  tok_EE_ = consumes<EcalRecHitCollection>(edm::InputTag("ecalRecHit", "EcalRecHitsEE"));
179  tok_hbhe_ = consumes<HBHERecHitCollection>(edm::InputTag("hbhereco"));
180  }
181  tok_muon_ = consumes<reco::MuonCollection>(muonsrc_);
182 
183  tok_ddrec_ = esConsumes<HcalDDDRecConstants, HcalRecNumberingRecord, edm::Transition::BeginRun>();
184  tok_geom_ = esConsumes<CaloGeometry, CaloGeometryRecord>();
185  tok_caloTopology_ = esConsumes<CaloTopology, CaloTopologyRecord>();
186  tok_topo_ = esConsumes<HcalTopology, HcalRecNumberingRecord>();
187  tok_magField_ = esConsumes<MagneticField, IdealMagneticFieldRecord>();
188  tok_ecalChStatus_ = esConsumes<EcalChannelStatus, EcalChannelStatusRcd>();
189  tok_sevlv_ = esConsumes<EcalSeverityLevelAlgo, EcalSeverityLevelAlgoRcd>();
190 }
191 
192 HcalRaddamMuon::~HcalRaddamMuon() {
193  // do anything here that needs to be done at desctruction time
194  // (e.g. close files, deallocate resources etc.)
195 }
196 
197 //
198 // member functions
199 //
200 
201 // ------------ method called for each event ------------
202 void HcalRaddamMuon::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) {
203  clearVectors();
204  RunNumber = iEvent.id().run();
205  EventNumber = iEvent.id().event();
206  LumiNumber = iEvent.id().luminosityBlock();
207  BXNumber = iEvent.bunchCrossing();
208 
209  edm::Handle<edm::PCaloHitContainer> calosimhits;
210  iEvent.getByToken(tok_hcal_, calosimhits);
211 
212  edm::Handle<edm::TriggerResults> _Triggers;
213  iEvent.getByToken(tok_trigRes_, _Triggers);
214 
215  if ((verbosity_ % 10) > 1)
216  edm::LogVerbatim("HBHEMuon") << "size of all triggers " << all_triggers.size();
217  int Ntriggers = all_triggers.size();
218 
219  if ((verbosity_ % 10) > 1)
220  edm::LogVerbatim("HBHEMuon") << "size of HLT MENU: " << _Triggers->size();
221 
222  if (_Triggers.isValid()) {
223  const edm::TriggerNames& triggerNames_ = iEvent.triggerNames(*_Triggers);
224 
225  std::vector<int> index;
226  for (int i = 0; i < Ntriggers; i++) {
227  index.push_back(triggerNames_.triggerIndex(all_triggers[i]));
228  int triggerSize = int(_Triggers->size());
229  if ((verbosity_ % 10) > 2)
230  edm::LogVerbatim("HBHEMuon") << "outside loop " << index[i] << "\ntriggerSize " << triggerSize;
231  if (index[i] < triggerSize) {
232  hltresults.push_back(_Triggers->accept(index[i]));
233  if ((verbosity_ % 10) > 2)
234  edm::LogVerbatim("HBHEMuon") << "trigger_info " << triggerSize << " triggerSize " << index[i]
235  << " trigger_index " << hltresults.at(i) << " hltresult ";
236  } else {
237  edm::LogVerbatim("HBHEMuon") << "Requested HLT path \""
238  << "\" does not exist";
239  }
240  }
241  }
242 
243  // get handles to calogeometry and calotopology
244  const CaloGeometry* geo = &iSetup.getData(tok_geom_);
245  const MagneticField* bField = &iSetup.getData(tok_magField_);
246  const EcalChannelStatus* theEcalChStatus = &iSetup.getData(tok_ecalChStatus_);
247  const EcalSeverityLevelAlgo* sevlv = &iSetup.getData(tok_sevlv_);
248  const CaloTopology* caloTopology = &iSetup.getData(tok_caloTopology_);
249  const HcalTopology* theHBHETopology = &iSetup.getData(tok_topo_);
250 
251  edm::Handle<reco::BeamSpot> bmspot;
252  iEvent.getByToken(tok_bs_, bmspot);
253 
254  edm::Handle<reco::VertexCollection> vtx;
255  iEvent.getByToken(tok_recVtx_, vtx);
256 
257  edm::Handle<EcalRecHitCollection> barrelRecHitsHandle;
258  edm::Handle<EcalRecHitCollection> endcapRecHitsHandle;
259  iEvent.getByToken(tok_EB_, barrelRecHitsHandle);
260  iEvent.getByToken(tok_EE_, endcapRecHitsHandle);
261 
262  edm::Handle<HBHERecHitCollection> hbhe;
263  iEvent.getByToken(tok_hbhe_, hbhe);
264 
265  edm::Handle<reco::MuonCollection> _Muon;
266  iEvent.getByToken(tok_muon_, _Muon);
267  const reco::Vertex& vertex = (*(vtx)->begin());
268 
269  math::XYZPoint bspot;
270  bspot = (bmspot.isValid()) ? bmspot->position() : math::XYZPoint(0, 0, 0);
271 
272  if (_Muon.isValid()) {
273  for (reco::MuonCollection::const_iterator RecMuon = _Muon->begin(); RecMuon != _Muon->end(); ++RecMuon) {
274  muon_is_good.push_back(RecMuon->isPFMuon());
275  muon_global.push_back(RecMuon->isGlobalMuon());
276  muon_tracker.push_back(RecMuon->isTrackerMuon());
277  PtGlob.push_back((RecMuon)->pt());
278  EtaGlob.push_back(RecMuon->eta());
279  PhiGlob.push_back(RecMuon->phi());
280  Energy.push_back(RecMuon->energy());
281  Pmuon.push_back(RecMuon->p());
282  // if (RecMuon->isPFMuon()) goodEvent = true;
283  // acessing tracker hits info
284  if (RecMuon->track().isNonnull()) {
285  TrackerLayer.push_back(RecMuon->track()->hitPattern().trackerLayersWithMeasurement());
286  } else {
287  TrackerLayer.push_back(-1);
288  }
289  if (RecMuon->innerTrack().isNonnull()) {
290  innerTrack.push_back(true);
291  NumPixelLayers.push_back(RecMuon->innerTrack()->hitPattern().pixelLayersWithMeasurement());
292  chiTracker.push_back(RecMuon->innerTrack()->normalizedChi2());
293  DxyTracker.push_back(fabs(RecMuon->innerTrack()->dxy((vertex).position())));
294  DzTracker.push_back(fabs(RecMuon->innerTrack()->dz((vertex).position())));
295  innerTrackpt.push_back(RecMuon->innerTrack()->pt());
296  innerTracketa.push_back(RecMuon->innerTrack()->eta());
297  innerTrackphi.push_back(RecMuon->innerTrack()->phi());
298  Tight_PixelHits.push_back(RecMuon->innerTrack()->hitPattern().numberOfValidPixelHits());
299  } else {
300  innerTrack.push_back(false);
301  NumPixelLayers.push_back(0);
302  chiTracker.push_back(0);
303  DxyTracker.push_back(0);
304  DzTracker.push_back(0);
305  innerTrackpt.push_back(0);
306  innerTracketa.push_back(0);
307  innerTrackphi.push_back(0);
308  Tight_PixelHits.push_back(0);
309  }
310  // outer track info
311 
312  if (RecMuon->outerTrack().isNonnull()) {
313  OuterTrack.push_back(true);
314  OuterTrackPt.push_back(RecMuon->outerTrack()->pt());
315  OuterTrackEta.push_back(RecMuon->outerTrack()->eta());
316  OuterTrackPhi.push_back(RecMuon->outerTrack()->phi());
317  OuterTrackChi.push_back(RecMuon->outerTrack()->normalizedChi2());
318  OuterTrackHits.push_back(RecMuon->outerTrack()->numberOfValidHits());
319  OuterTrackRHits.push_back(RecMuon->outerTrack()->recHitsSize());
320  } else {
321  OuterTrack.push_back(false);
322  OuterTrackPt.push_back(0);
323  OuterTrackEta.push_back(0);
324  OuterTrackPhi.push_back(0);
325  OuterTrackChi.push_back(0);
326  OuterTrackHits.push_back(0);
327  OuterTrackRHits.push_back(0);
328  }
329  // Tight Muon cuts
330  if (RecMuon->globalTrack().isNonnull()) {
331  GlobalTrack.push_back(true);
332  chiGlobal.push_back(RecMuon->globalTrack()->normalizedChi2());
333  GlobalMuonHits.push_back(RecMuon->globalTrack()->hitPattern().numberOfValidMuonHits());
334  MatchedStat.push_back(RecMuon->numberOfMatchedStations());
335  GlobalTrckPt.push_back(RecMuon->globalTrack()->pt());
336  GlobalTrckEta.push_back(RecMuon->globalTrack()->eta());
337  GlobalTrckPhi.push_back(RecMuon->globalTrack()->phi());
338  Tight_TransImpara.push_back(fabs(RecMuon->muonBestTrack()->dxy(vertex.position())));
339  Tight_LongPara.push_back(fabs(RecMuon->muonBestTrack()->dz(vertex.position())));
340  } else {
341  GlobalTrack.push_back(false);
342  chiGlobal.push_back(0);
343  GlobalMuonHits.push_back(0);
344  MatchedStat.push_back(0);
345  GlobalTrckPt.push_back(0);
346  GlobalTrckEta.push_back(0);
347  GlobalTrckPhi.push_back(0);
348  Tight_TransImpara.push_back(0);
349  Tight_LongPara.push_back(0);
350  }
351 
352  IsolationR04.push_back(
353  ((RecMuon->pfIsolationR04().sumChargedHadronPt +
354  std::max(0.,
355  RecMuon->pfIsolationR04().sumNeutralHadronEt + RecMuon->pfIsolationR04().sumPhotonEt -
356  (0.5 * RecMuon->pfIsolationR04().sumPUPt))) /
357  RecMuon->pt()));
358 
359  IsolationR03.push_back(
360  ((RecMuon->pfIsolationR03().sumChargedHadronPt +
361  std::max(0.,
362  RecMuon->pfIsolationR03().sumNeutralHadronEt + RecMuon->pfIsolationR03().sumPhotonEt -
363  (0.5 * RecMuon->pfIsolationR03().sumPUPt))) /
364  RecMuon->pt()));
365 
366  MuonEcalEnergy.push_back(RecMuon->calEnergy().emS9);
367  MuonHcalEnergy.push_back(RecMuon->calEnergy().hadS9);
368  MuonHOEnergy.push_back(RecMuon->calEnergy().hoS9);
369 
370  double eEcal(0), eHcal(0), activeL(0), eHcalDepth[7], eHcalDepthHot[7], eHcalDepthCalo[7], eHcalDepthHotCalo[7];
371  unsigned int isHot = 0;
372  unsigned int isHotCalo = 0;
373 
374  for (int i = 0; i < 7; ++i)
375  eHcalDepth[i] = eHcalDepthHot[i] = eHcalDepthCalo[i] = eHcalDepthHotCalo[i] = -10000;
376 
377  if (RecMuon->innerTrack().isNonnull()) {
378  const reco::Track* pTrack = (RecMuon->innerTrack()).get();
379  spr::propagatedTrackID trackID = spr::propagateCALO(pTrack, geo, bField, (((verbosity_ / 100) % 10 > 0)));
380 
381  MuonEcalDetId.push_back((trackID.detIdECAL)());
382  MuonHcalDetId.push_back((trackID.detIdHCAL)());
383  MuonEHcalDetId.push_back((trackID.detIdEHCAL)());
384 
385  if (trackID.okECAL) {
386  const DetId isoCell(trackID.detIdECAL);
387  std::pair<double, bool> e3x3 = spr::eECALmatrix(isoCell,
388  barrelRecHitsHandle,
389  endcapRecHitsHandle,
390  *theEcalChStatus,
391  geo,
392  caloTopology,
393  sevlv,
394  1,
395  1,
396  -100.0,
397  -100.0,
398  -500.0,
399  500.0,
400  false);
401 
402  eEcal = e3x3.first;
403  if (((verbosity_ / 10) % 10) > 1)
404  edm::LogVerbatim("HBHEMuon") << "eEcal" << eEcal;
405  }
406 
407  if (trackID.okHCAL) {
408  const DetId closestCell(trackID.detIdHCAL);
409  eHcal = spr::eHCALmatrix(theHBHETopology,
410  closestCell,
411  hbhe,
412  0,
413  0,
414  false,
415  true,
416  -100.0,
417  -100.0,
418  -100.0,
419  -100.0,
420  -500.,
421  500.,
422  useRaw_);
423 
424  int iphi = ((HcalDetId)(closestCell)).iphi();
425  int zside = ((HcalDetId)(closestCell)).iphi();
426  int depthHE = theHBHETopology->dddConstants()->getMinDepth(1, 16, iphi, zside);
427  if (((verbosity_ / 10) % 10) > 1)
428  edm::LogVerbatim("HBHEMuon") << "eHcal " << eHcal;
429  std::vector<std::pair<double, int> > ehdepth;
430  spr::energyHCALCell((HcalDetId)closestCell,
431  hbhe,
432  ehdepth,
433  maxDepth_,
434  -100.0,
435  -100.0,
436  -100.0,
437  -100.0,
438  -500.0,
439  500.0,
440  useRaw_,
441  depthHE,
442  (((verbosity_ / 1000) % 10) > 0));
443  for (unsigned int i = 0; i < ehdepth.size(); ++i) {
444  eHcalDepth[ehdepth[i].second - 1] = ehdepth[i].first;
445  if (((verbosity_ / 10) % 10) > 1)
446  edm::LogVerbatim("HBHEMuon")
447  << "eHcalDepth " << i << ":" << (ehdepth[i].second - 1) << ":" << eHcalDepth[ehdepth[i].second - 1];
448  }
449 
450  eHcal = spr::eHCALmatrix(theHBHETopology,
451  closestCell,
452  calosimhits,
453  0,
454  0,
455  false,
456  true,
457  -100.0,
458  -100.0,
459  -100.0,
460  -100.0,
461  -500.,
462  500.,
463  useRaw_);
464 
465  if (((verbosity_ / 10) % 10) > 1)
466  edm::LogVerbatim("HBHEMuon") << "eHcal " << eHcal;
467  const DetId closestCellCalo(trackID.detIdHCAL);
468  iphi = ((HcalDetId)(closestCellCalo)).iphi();
469  zside = ((HcalDetId)(closestCellCalo)).iphi();
470  depthHE = theHBHETopology->dddConstants()->getMinDepth(1, 16, iphi, zside);
471  std::vector<std::pair<double, int> > ehdepthCalo;
472  spr::energyHCALCell((HcalDetId)closestCellCalo,
473  calosimhits,
474  ehdepthCalo,
475  maxDepth_,
476  -100.0,
477  -100.0,
478  -100.0,
479  -100.0,
480  -500.0,
481  500.0,
482  useRaw_,
483  depthHE,
484  (((verbosity_ / 1000) % 10) > 0));
485  for (unsigned int i = 0; i < ehdepthCalo.size(); ++i) {
486  eHcalDepthCalo[ehdepthCalo[i].second - 1] = ehdepthCalo[i].first;
487  if (((verbosity_ / 10) % 10) > 1)
488  edm::LogVerbatim("HBHEMuon") << "eHcalDepthCalo " << i << ":" << (ehdepth[i].second - 1) << ":"
489  << eHcalDepth[ehdepth[i].second - 1];
490  }
491 
492  HcalDetId hcid0(closestCell.rawId());
493  activeL = activeLength(trackID.detIdHCAL);
494 
495  if (((verbosity_ / 10) % 10) > 0)
496  edm::LogVerbatim("HBHEMuon") << "activeL " << activeL;
497  HcalDetId hotCell, hotCellCalo;
498  h3x3 = spr::eHCALmatrix(geo, theHBHETopology, closestCell, hbhe, 1, 1, hotCell, false, useRaw_, false);
499  h3x3Calo = spr::eHCALmatrix(
500  geo, theHBHETopology, closestCellCalo, calosimhits, 1, 1, hotCellCalo, false, useRaw_, false);
501 
502  isHot = matchId(closestCell, hotCell);
503  isHotCalo = matchId(closestCellCalo, hotCellCalo);
504 
505  if (((verbosity_ / 10) % 10) > 1)
506  edm::LogVerbatim("HBHEMuon") << "hcal 3X3 < " << h3x3 << ">"
507  << " ClosestCell <" << (HcalDetId)(closestCell) << "> hotCell id < " << hotCell
508  << "> isHot" << isHot;
509  if (hotCell != HcalDetId()) {
510  iphi = ((HcalDetId)(hotCell)).iphi();
511  zside = ((HcalDetId)(hotCell)).iphi();
512  depthHE = theHBHETopology->dddConstants()->getMinDepth(1, 16, iphi, zside);
513  std::vector<std::pair<double, int> > ehdepth;
514  spr::energyHCALCell(hotCell,
515  hbhe,
516  ehdepth,
517  maxDepth_,
518  -100.0,
519  -100.0,
520  -100.0,
521  -100.0,
522  -500.0,
523  500.0,
524  depthHE,
525  false); //(((verbosity_/1000)%10)>0));
526  for (unsigned int i = 0; i < ehdepth.size(); ++i) {
527  eHcalDepthHot[ehdepth[i].second - 1] = ehdepth[i].first;
528  if (((verbosity_ / 10) % 10) > 1)
529  edm::LogVerbatim("HBHEMuon") << "eHcalDepthHot " << i << ":" << (ehdepth[i].second - 1) << ":"
530  << eHcalDepthHot[ehdepth[i].second - 1];
531  }
532  }
533 
534  if (hotCellCalo != HcalDetId()) {
535  iphi = ((HcalDetId)(hotCellCalo)).iphi();
536  zside = ((HcalDetId)(hotCellCalo)).iphi();
537  depthHE = theHBHETopology->dddConstants()->getMinDepth(1, 16, iphi, zside);
538  std::vector<std::pair<double, int> > ehdepthCalo;
539 
540  spr::energyHCALCell(hotCellCalo,
541  calosimhits,
542  ehdepthCalo,
543  maxDepth_,
544  -100.0,
545  -100.0,
546  -100.0,
547  -100.0,
548  -500.0,
549  500.0,
550  useRaw_,
551  depthHE,
552  false);
553  for (unsigned int i = 0; i < ehdepthCalo.size(); ++i) {
554  eHcalDepthHotCalo[ehdepthCalo[i].second - 1] = ehdepthCalo[i].first;
555  if (((verbosity_ / 10) % 10) > 1)
556  edm::LogVerbatim("HBHEMuon") << "eHcalDepthHotCalo " << i << ":" << (ehdepth[i].second - 1) << ":"
557  << eHcalDepthHot[ehdepth[i].second - 1];
558  }
559  }
560  }
561  } else {
562  MuonEcalDetId.push_back(0);
563  MuonHcalDetId.push_back(0);
564  MuonEHcalDetId.push_back(0);
565  }
566 
567  MuonEcal3x3Energy.push_back(eEcal);
568  MuonHcal1x1Energy.push_back(eHcal);
569  MuonHcalDepth1Energy.push_back(eHcalDepth[0]);
570  MuonHcalDepth2Energy.push_back(eHcalDepth[1]);
571  MuonHcalDepth3Energy.push_back(eHcalDepth[2]);
572  MuonHcalDepth4Energy.push_back(eHcalDepth[3]);
573  MuonHcalDepth5Energy.push_back(eHcalDepth[4]);
574  MuonHcalDepth6Energy.push_back(eHcalDepth[5]);
575  MuonHcalDepth7Energy.push_back(eHcalDepth[6]);
576  MuonHcalDepth1HotEnergy.push_back(eHcalDepthHot[0]);
577  MuonHcalDepth2HotEnergy.push_back(eHcalDepthHot[1]);
578  MuonHcalDepth3HotEnergy.push_back(eHcalDepthHot[2]);
579  MuonHcalDepth4HotEnergy.push_back(eHcalDepthHot[3]);
580  MuonHcalDepth5HotEnergy.push_back(eHcalDepthHot[4]);
581  MuonHcalDepth6HotEnergy.push_back(eHcalDepthHot[5]);
582  MuonHcalDepth7HotEnergy.push_back(eHcalDepthHot[6]);
583  MuonHcalHot.push_back(isHot);
584 
585  //
586  MuonHcalDepth1EnergyCalo.push_back(eHcalDepthCalo[0]);
587  MuonHcalDepth2EnergyCalo.push_back(eHcalDepthCalo[1]);
588  MuonHcalDepth3EnergyCalo.push_back(eHcalDepthCalo[2]);
589  MuonHcalDepth4EnergyCalo.push_back(eHcalDepthCalo[3]);
590  MuonHcalDepth5EnergyCalo.push_back(eHcalDepthCalo[4]);
591  MuonHcalDepth6EnergyCalo.push_back(eHcalDepthCalo[5]);
592  MuonHcalDepth7EnergyCalo.push_back(eHcalDepthCalo[6]);
593  MuonHcalDepth1HotEnergyCalo.push_back(eHcalDepthHotCalo[0]);
594  MuonHcalDepth2HotEnergyCalo.push_back(eHcalDepthHotCalo[1]);
595  MuonHcalDepth3HotEnergyCalo.push_back(eHcalDepthHotCalo[2]);
596  MuonHcalDepth4HotEnergyCalo.push_back(eHcalDepthHotCalo[3]);
597  MuonHcalDepth5HotEnergyCalo.push_back(eHcalDepthHotCalo[4]);
598  MuonHcalDepth6HotEnergyCalo.push_back(eHcalDepthHotCalo[5]);
599  MuonHcalDepth7HotEnergyCalo.push_back(eHcalDepthHotCalo[6]);
600  MuonHcalHotCalo.push_back(isHotCalo);
601 
602  //
603  MuonHcalActiveLength.push_back(activeL);
604  }
605  }
606  TREE->Fill();
607 }
608 
609 // ------------ method called once each job just before starting event loop ------------
610 void HcalRaddamMuon::beginJob() {
611  TREE = fs->make<TTree>("TREE", "TREE");
612  TREE->Branch("Event_No", &EventNumber);
613  TREE->Branch("Run_No", &RunNumber);
614  TREE->Branch("LumiNumber", &LumiNumber);
615  TREE->Branch("BXNumber", &BXNumber);
616  TREE->Branch("pt_of_muon", &PtGlob);
617  TREE->Branch("eta_of_muon", &EtaGlob);
618  TREE->Branch("phi_of_muon", &PhiGlob);
619  TREE->Branch("energy_of_muon", &Energy);
620  TREE->Branch("p_of_muon", &Pmuon);
621  TREE->Branch("PF_Muon", &muon_is_good);
622  TREE->Branch("Global_Muon", &muon_global);
623  TREE->Branch("Tracker_muon", &muon_tracker);
624 
625  TREE->Branch("hcal_3into3", &MuonHcalEnergy);
626  TREE->Branch("hcal_1x1", &MuonHcal1x1Energy);
627  TREE->Branch("hcal_detID", &MuonHcalDetId);
628  TREE->Branch("hcal_edepth1", &MuonHcalDepth1Energy);
629  TREE->Branch("hcal_edepth2", &MuonHcalDepth2Energy);
630  TREE->Branch("hcal_edepth3", &MuonHcalDepth3Energy);
631  TREE->Branch("hcal_edepth4", &MuonHcalDepth4Energy);
632  TREE->Branch("hcal_edepthHot1", &MuonHcalDepth1HotEnergy);
633  TREE->Branch("hcal_edepthHot2", &MuonHcalDepth2HotEnergy);
634  TREE->Branch("hcal_edepthHot3", &MuonHcalDepth3HotEnergy);
635  TREE->Branch("hcal_edepthHot4", &MuonHcalDepth4HotEnergy);
636 
637  TREE->Branch("hcal_edepth1PSim", &MuonHcalDepth1EnergyCalo);
638  TREE->Branch("hcal_edepth2PSim", &MuonHcalDepth2EnergyCalo);
639  TREE->Branch("hcal_edepth3PSim", &MuonHcalDepth3EnergyCalo);
640  TREE->Branch("hcal_edepth4PSim", &MuonHcalDepth4EnergyCalo);
641  TREE->Branch("hcal_edepthHot1PSim", &MuonHcalDepth1HotEnergyCalo);
642  TREE->Branch("hcal_edepthHot2PSim", &MuonHcalDepth2HotEnergyCalo);
643  TREE->Branch("hcal_edepthHot3PSim", &MuonHcalDepth3HotEnergyCalo);
644  TREE->Branch("hcal_edepthHot4PSim", &MuonHcalDepth4HotEnergyCalo);
645 
646  if (maxDepth_ > 4) {
647  TREE->Branch("hcal_edepth5PSim", &MuonHcalDepth5EnergyCalo);
648  TREE->Branch("hcal_edepthHot5PSim", &MuonHcalDepth5HotEnergyCalo);
649  if (maxDepth_ > 5) {
650  TREE->Branch("hcal_edepth6PSim", &MuonHcalDepth6EnergyCalo);
651  TREE->Branch("hcal_edepthHot6PSim", &MuonHcalDepth6HotEnergyCalo);
652  if (maxDepth_ > 6) {
653  TREE->Branch("hcal_edepth7PSim", &MuonHcalDepth7EnergyCalo);
654  TREE->Branch("hcal_edepthHot7PSim", &MuonHcalDepth7HotEnergyCalo);
655  }
656  }
657  }
658 
659  TREE->Branch("TrackerLayer", &TrackerLayer);
660  TREE->Branch("innerTrack", &innerTrack);
661  TREE->Branch("innerTrackpt", &innerTrackpt);
662  TREE->Branch("innerTracketa", &innerTracketa);
663  TREE->Branch("innerTrackphi", &innerTrackphi);
664  TREE->Branch("MatchedStat", &MatchedStat);
665  TREE->Branch("GlobalTrckPt", &GlobalTrckPt);
666  TREE->Branch("GlobalTrckEta", &GlobalTrckEta);
667  TREE->Branch("GlobalTrckPhi", &GlobalTrckPhi);
668  TREE->Branch("NumPixelLayers", &NumPixelLayers);
669  TREE->Branch("chiTracker", &chiTracker);
670  TREE->Branch("DxyTracker", &DxyTracker);
671  TREE->Branch("DzTracker", &DzTracker);
672  TREE->Branch("OuterTrack", &OuterTrack);
673  TREE->Branch("OuterTrackPt", &OuterTrackPt);
674  TREE->Branch("OuterTrackEta", &OuterTrackEta);
675  TREE->Branch("OuterTrackPhi", &OuterTrackPhi);
676  TREE->Branch("OuterTrackHits", &OuterTrackHits);
677  TREE->Branch("OuterTrackRHits", &OuterTrackRHits);
678  TREE->Branch("OuterTrackChi", &OuterTrackChi);
679  TREE->Branch("GlobalTrack", &GlobalTrack);
680  TREE->Branch("GlobTrack_Chi", &chiGlobal);
681  TREE->Branch("Global_Muon_Hits", &GlobalMuonHits);
682  TREE->Branch("MatchedStations", &MatchedStat);
683  TREE->Branch("Global_Track_Pt", &GlobalTrckPt);
684  TREE->Branch("Global_Track_Eta", &GlobalTrckEta);
685  TREE->Branch("Global_Track_Phi", &GlobalTrckPhi);
687  TREE->Branch("Tight_LongitudinalImpactparameter", &Tight_LongPara);
688  TREE->Branch("Tight_TransImpactparameter", &Tight_TransImpara);
689  TREE->Branch("InnerTrackPixelHits", &Tight_PixelHits);
690  TREE->Branch("IsolationR04", &IsolationR04);
691  TREE->Branch("IsolationR03", &IsolationR03);
692 
693  TREE->Branch("hcal_cellHot", &MuonHcalHot);
694  TREE->Branch("hcal_cellHotPSim", &MuonHcalHotCalo);
695 
696  TREE->Branch("ecal_3into3", &MuonEcalEnergy);
697  TREE->Branch("ecal_3x3", &MuonEcal3x3Energy);
698  TREE->Branch("ecal_detID", &MuonEcalDetId);
699  TREE->Branch("ehcal_detID", &MuonEHcalDetId);
700  TREE->Branch("tracker_3into3", &MuonHOEnergy);
701  TREE->Branch("activeLength", &MuonHcalActiveLength);
702 
704  TREE->Branch("hltresults", &hltresults);
705  TREE->Branch("all_triggers", &all_triggers);
706  TREE->Branch("rechit_energy", &energy_hb);
707  TREE->Branch("rechit_time", &time_hb);
708 }
709 
710 // ------------ method called once each job just after ending the event loop ------------
711 void HcalRaddamMuon::endJob() {}
712 
713 // ------------ method called when starting to processes a run ------------
714 void HcalRaddamMuon::beginRun(edm::Run const& iRun, edm::EventSetup const& iSetup) {
715  const HcalDDDRecConstants* hdc = &iSetup.getData(tok_ddrec_);
716  actHB.clear();
717  actHE.clear();
718  actHB = hdc->getThickActive(0);
719  actHE = hdc->getThickActive(1);
720 
721  bool changed = true;
722  all_triggers.clear();
723  if (hltConfig_.init(iRun, iSetup, "HLT", changed)) {
724  // if init returns TRUE, initialisation has succeeded!
725  edm::LogVerbatim("HBHEMuon") << "HLT config with process name 'HLT' successfully extracted";
726  std::string string_search[5] = {"HLT_IsoMu_", "HLT_L1SingleMu_", "HLT_L2Mu", "HLT_Mu", "HLT_RelIso1p0Mu"};
727  unsigned int ntriggers = hltConfig_.size();
728  for (unsigned int t = 0; t < ntriggers; ++t) {
729  std::string hltname(hltConfig_.triggerName(t));
730  for (unsigned int ik = 0; ik < 5; ++ik) {
731  if (hltname.find(string_search[ik]) != std::string::npos) {
732  all_triggers.push_back(hltname);
733  break;
734  }
735  }
736  } //loop over ntriggers
737  edm::LogVerbatim("HBHEMuon") << "All triggers size in begin run" << all_triggers.size();
738  } else {
739  edm::LogError("HBHEMuon") << "Error! HLT config extraction with process name 'HLT' failed";
740  }
741 
742 } //firstmethod
743 
744 // ------------ method called when ending the processing of a run ------------
745 void HcalRaddamMuon::endRun(edm::Run const&, edm::EventSetup const&) {}
746 
747 void HcalRaddamMuon::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
748  edm::ParameterSetDescription desc;
749  desc.addUntracked<edm::InputTag>("hlTriggerResults", edm::InputTag("TriggerResults", "", "HLT"));
750  desc.addUntracked<edm::InputTag>("muonSource", edm::InputTag("muons"));
751  desc.addUntracked<int>("verbosity", 0);
752  desc.addUntracked<int>("useRaw", 0);
753  desc.add<bool>("isAOD", false);
754  desc.addUntracked<int>("maxDepth", 4);
755  descriptions.add("hcalRaddamMuon", desc);
756 }
757 
758 void HcalRaddamMuon::clearVectors() {
760  EventNumber = -99999;
761  RunNumber = -99999;
762  LumiNumber = -99999;
763  BXNumber = -99999;
764  energy_hb.clear();
765  time_hb.clear();
766  muon_is_good.clear();
767  muon_global.clear();
768  muon_tracker.clear();
769  PtGlob.clear();
770  EtaGlob.clear();
771  PhiGlob.clear();
772  Energy.clear();
773  Pmuon.clear();
774  TrackerLayer.clear();
775  innerTrack.clear();
776  NumPixelLayers.clear();
777  chiTracker.clear();
778  DxyTracker.clear();
779  DzTracker.clear();
780  innerTrackpt.clear();
781  innerTracketa.clear();
782  innerTrackphi.clear();
783  Tight_PixelHits.clear();
784  OuterTrack.clear();
785  OuterTrackPt.clear();
786  OuterTrackEta.clear();
787  OuterTrackPhi.clear();
788  OuterTrackHits.clear();
789  OuterTrackRHits.clear();
790  OuterTrackChi.clear();
791  GlobalTrack.clear();
792  chiGlobal.clear();
793  GlobalMuonHits.clear();
794  MatchedStat.clear();
795  GlobalTrckPt.clear();
796  GlobalTrckEta.clear();
797  GlobalTrckPhi.clear();
798  Tight_TransImpara.clear();
799  Tight_LongPara.clear();
800 
801  IsolationR04.clear();
802  IsolationR03.clear();
803  MuonEcalEnergy.clear();
804  MuonHcalEnergy.clear();
805  MuonHOEnergy.clear();
806  MuonEcalDetId.clear();
807  MuonHcalDetId.clear();
808  MuonEHcalDetId.clear();
809  MuonEcal3x3Energy.clear();
810  MuonHcal1x1Energy.clear();
811  MuonHcalDepth1Energy.clear();
812  MuonHcalDepth2Energy.clear();
813  MuonHcalDepth3Energy.clear();
814  MuonHcalDepth4Energy.clear();
815  MuonHcalDepth5Energy.clear();
816  MuonHcalDepth6Energy.clear();
817  MuonHcalDepth7Energy.clear();
818 
819  MuonHcalDepth1HotEnergy.clear();
820  MuonHcalDepth2HotEnergy.clear();
821  MuonHcalDepth3HotEnergy.clear();
822  MuonHcalDepth4HotEnergy.clear();
823  MuonHcalDepth5HotEnergy.clear();
824  MuonHcalDepth6HotEnergy.clear();
825  MuonHcalDepth7HotEnergy.clear();
826  MuonHcalHot.clear();
827  MuonHcalActiveLength.clear();
828  hltresults.clear();
829 }
830 
831 int HcalRaddamMuon::matchId(const HcalDetId& id1, const HcalDetId& id2) {
832  HcalDetId kd1(id1.subdet(), id1.ieta(), id1.iphi(), 1);
833  HcalDetId kd2(id2.subdet(), id2.ieta(), id2.iphi(), 1);
834  int match = ((kd1 == kd2) ? 1 : 0);
835  return match;
836 }
837 
838 double HcalRaddamMuon::activeLength(const DetId& id_) {
839  HcalDetId id(id_);
840  int ieta = id.ietaAbs();
841  int depth = id.depth();
842  double lx(0);
843  if (id.subdet() == HcalBarrel) {
844  if (((verbosity_ / 10) % 10) > 2)
845  edm::LogVerbatim("HBHEMuon") << "actHB.size() " << actHB.size();
846  for (unsigned int i = 0; i < actHB.size(); ++i) {
847  if (ieta == actHB[i].ieta && depth == actHB[i].depth) {
848  lx = actHB[i].thick;
849  break;
850  }
851  }
852  } else {
853  if (((verbosity_ / 10) % 10) > 2)
854  edm::LogVerbatim("HBHEMuon") << "actHE.size() " << actHE.size();
855  for (unsigned int i = 0; i < actHE.size(); ++i) {
856  if (ieta == actHE[i].ieta && depth == actHE[i].depth) {
857  lx = actHE[i].thick;
858  break;
859  }
860  }
861  }
862  if (((verbosity_ / 10) % 10) > 2)
863  edm::LogVerbatim("HBHEMuon") << "active thick " << lx;
864  return lx;
865 }
866 
867 //define this as a plug-in
868 DEFINE_FWK_MODULE(HcalRaddamMuon);
HcalRaddamMuon::PD0
std::vector< double > PD0
Definition: HcalRaddamMuon.cc:126
HcalRaddamMuon::ImpactParameter
std::vector< double > ImpactParameter
Definition: HcalRaddamMuon.cc:83
HcalRaddamMuon::beginJob
void beginJob() override
Definition: HcalRaddamMuon.cc:610
HcalRaddamMuon::EtaGlob
std::vector< double > EtaGlob
Definition: HcalRaddamMuon.cc:78
EcalSeverityLevelAlgo
Definition: EcalSeverityLevelAlgo.h:33
HcalRaddamMuon::Pthetha
std::vector< double > Pthetha
Definition: HcalRaddamMuon.cc:125
HcalRaddamMuon::actHE
std::vector< HcalDDDRecConstants::HcalActiveLength > actHE
Definition: HcalRaddamMuon.cc:104
HcalRaddamMuon::analyze
void analyze(const edm::Event &, const edm::EventSetup &) override
Definition: HcalRaddamMuon.cc:202
HcalRaddamMuon::innerTrackphi
std::vector< double > innerTrackphi
Definition: HcalRaddamMuon.cc:80
HcalRaddamMuon::NRefPointY
std::vector< double > NRefPointY
Definition: HcalRaddamMuon.cc:126
electrons_cff.bool
bool
Definition: electrons_cff.py:366
EDAnalyzer.h
HcalRaddamMuon::Tight_TransImpara
std::vector< double > Tight_TransImpara
Definition: HcalRaddamMuon.cc:84
mps_fire.i
i
Definition: mps_fire.py:428
HcalRaddamMuon::NumPixelLayers
std::vector< double > NumPixelLayers
Definition: HcalRaddamMuon.cc:81
HcalRaddamMuon::OuterTrackPhi
std::vector< double > OuterTrackPhi
Definition: HcalRaddamMuon.cc:82
HcalRaddamMuon::tok_bs_
edm::EDGetTokenT< reco::BeamSpot > tok_bs_
Definition: HcalRaddamMuon.cc:138
Muon.h
HcalRaddamMuon::OuterTrack
std::vector< bool > OuterTrack
Definition: HcalRaddamMuon.cc:86
HcalRaddamMuon::MuonHcalDepth5EnergyCalo
std::vector< double > MuonHcalDepth5EnergyCalo
Definition: HcalRaddamMuon.cc:96
HcalRaddamMuon::chiTracker
std::vector< double > chiTracker
Definition: HcalRaddamMuon.cc:81
HcalRaddamMuon::BXNumber
unsigned int BXNumber
Definition: HcalRaddamMuon.cc:129
HcalRaddamMuon::muonsrc_
const edm::InputTag muonsrc_
Definition: HcalRaddamMuon.cc:109
funct::false
false
Definition: Factorize.h:29
HcalRaddamMuon::matchId
int matchId(const HcalDetId &, const HcalDetId &)
Definition: HcalRaddamMuon.cc:831
HcalRaddamMuon::dzWithBS
std::vector< double > dzWithBS
Definition: HcalRaddamMuon.cc:126
HcalRaddamMuon::dxyWithBS
std::vector< double > dxyWithBS
Definition: HcalRaddamMuon.cc:126
HcalRaddamMuon::isHB
std::vector< bool > isHB
Definition: HcalRaddamMuon.cc:116
HcalRaddamMuon::MuonHcalDepth6EnergyCalo
std::vector< double > MuonHcalDepth6EnergyCalo
Definition: HcalRaddamMuon.cc:96
HcalRaddamMuon::PtGlob
std::vector< double > PtGlob
Definition: HcalRaddamMuon.cc:72
HcalRaddamMuon::MuonHcalDepth6HotEnergy
std::vector< double > MuonHcalDepth6HotEnergy
Definition: HcalRaddamMuon.cc:92
spr::propagatedTrackID::detIdEHCAL
DetId detIdEHCAL
Definition: CaloPropagateTrack.h:45
TriggerResults.h
HcalRaddamMuon::PLostHits
std::vector< double > PLostHits
Definition: HcalRaddamMuon.cc:126
HcalRaddamMuon::hltresults
std::vector< int > hltresults
Definition: HcalRaddamMuon.cc:120
HcalRaddamMuon::track_cosmic_momentumIX
std::vector< double > track_cosmic_momentumIX
Definition: HcalRaddamMuon.cc:75
HcalRaddamMuon::MuonEHcalDetId
std::vector< unsigned int > MuonEHcalDetId
Definition: HcalRaddamMuon.cc:89
HcalRaddamMuon::_RecoMuon1TrackIsoSumPtMaxCutValue_04
double _RecoMuon1TrackIsoSumPtMaxCutValue_04
Definition: HcalRaddamMuon.cc:130
HcalRaddamMuon::MuonHcalDepth7HotEnergyCalo
std::vector< double > MuonHcalDepth7HotEnergyCalo
Definition: HcalRaddamMuon.cc:98
HcalRaddamMuon::actHB
std::vector< HcalDDDRecConstants::HcalActiveLength > actHB
Definition: HcalRaddamMuon.cc:104
HcalRaddamMuon
Definition: HcalRaddamMuon.cc:54
HcalRaddamMuon::MuonHcalDepth3EnergyCalo
std::vector< double > MuonHcalDepth3EnergyCalo
Definition: HcalRaddamMuon.cc:96
DiDispStaMuonMonitor_cfi.pt
pt
Definition: DiDispStaMuonMonitor_cfi.py:39
EcalSeverityLevelAlgoRcd.h
HcalDDDRecConstants::getThickActive
std::vector< HcalActiveLength > getThickActive(const int &type) const
Definition: HcalDDDRecConstants.cc:465
edm::Run
Definition: Run.h:45
HcalRaddamMuon::fs
edm::Service< TFileService > fs
Definition: HcalRaddamMuon.cc:106
ecaldqm::zside
int zside(DetId const &)
Definition: EcalDQMCommonUtils.cc:189
HcalRaddamMuon::_RecoMuon1TrackIsoSumPtMaxCutValue_03
double _RecoMuon1TrackIsoSumPtMaxCutValue_03
Definition: HcalRaddamMuon.cc:130
TriggerEvent.h
HcalRaddamMuon::track_cosmic_yposition
std::vector< double > track_cosmic_yposition
Definition: HcalRaddamMuon.cc:132
edm::EDGetTokenT< edm::PCaloHitContainer >
HcalRaddamMuon::MuonHcalDepth1HotEnergy
std::vector< double > MuonHcalDepth1HotEnergy
Definition: HcalRaddamMuon.cc:92
edm
HLT enums.
Definition: AlignableModifier.h:19
globals_cff.id1
id1
Definition: globals_cff.py:33
HcalTopology
Definition: HcalTopology.h:26
HcalRaddamMuon::TrackerLayer
std::vector< double > TrackerLayer
Definition: HcalRaddamMuon.cc:80
HcalRaddamMuon::MuonHOEnergy
std::vector< double > MuonHOEnergy
Definition: HcalRaddamMuon.cc:88
EBDetId.h
EEDetId.h
HLT_FULL_cff.InputTag
InputTag
Definition: HLT_FULL_cff.py:89285
edm::ParameterSetDescription
Definition: ParameterSetDescription.h:52
HcalRaddamMuon::IsolationR03
std::vector< double > IsolationR03
Definition: HcalRaddamMuon.cc:87
HcalRaddamMuon::MuonHcalDepth3HotEnergy
std::vector< double > MuonHcalDepth3HotEnergy
Definition: HcalRaddamMuon.cc:92
HcalRaddamMuon::track_cosmic_zmomentum
std::vector< double > track_cosmic_zmomentum
Definition: HcalRaddamMuon.cc:132
HcalRaddamMuon::MuonHcalDepth1HotEnergyCalo
std::vector< double > MuonHcalDepth1HotEnergyCalo
Definition: HcalRaddamMuon.cc:98
HcalRaddamMuon::track_cosmic_positionOZ
std::vector< double > track_cosmic_positionOZ
Definition: HcalRaddamMuon.cc:72
edm::second
U second(std::pair< T, U > const &p)
Definition: ParameterSet.cc:222
HcalRaddamMuon::Tight_MuonHits
std::vector< double > Tight_MuonHits
Definition: HcalRaddamMuon.cc:84
edm::ParameterSet::getUntrackedParameter
T getUntrackedParameter(std::string const &, T const &) const
HcalRaddamMuon::PhiGlob
std::vector< double > PhiGlob
Definition: HcalRaddamMuon.cc:79
HcalRaddamMuon::tok_trigRes_
edm::EDGetTokenT< edm::TriggerResults > tok_trigRes_
Definition: HcalRaddamMuon.cc:136
HcalRaddamMuon::v_RH_h3x3_ene
std::vector< double > v_RH_h3x3_ene
Definition: HcalRaddamMuon.cc:125
ESDetId.h
HcalRaddamMuon::PNDoF
std::vector< double > PNDoF
Definition: HcalRaddamMuon.cc:126
HcalRaddamMuon::all_triggers2
std::vector< std::string > all_triggers2
Definition: HcalRaddamMuon.cc:113
HcalRaddamMuon::tok_sevlv_
edm::ESGetToken< EcalSeverityLevelAlgo, EcalSeverityLevelAlgoRcd > tok_sevlv_
Definition: HcalRaddamMuon.cc:150
edm::one::EDAnalyzer
Definition: EDAnalyzer.h:30
HcalRaddamMuon::hltpaths
std::vector< std::string > hltpaths
Definition: HcalRaddamMuon.cc:122
HcalBarrel
Definition: HcalAssistant.h:33
HcalRaddamMuon::Tight_PixelHits
std::vector< double > Tight_PixelHits
Definition: HcalRaddamMuon.cc:84
HcalRaddamMuon::hltConfig_
HLTConfigProvider hltConfig_
Definition: HcalRaddamMuon.cc:108
HcalRaddamMuon::track_cosmic_zposition
std::vector< double > track_cosmic_zposition
Definition: HcalRaddamMuon.cc:132
HcalRaddamMuon::DzTracker
std::vector< double > DzTracker
Definition: HcalRaddamMuon.cc:81
EcalCondObjectContainer
Definition: EcalCondObjectContainer.h:13
edm::Handle
Definition: AssociativeIterator.h:50
HcalRaddamMuon::track_cosmic_positionOY
std::vector< double > track_cosmic_positionOY
Definition: HcalRaddamMuon.cc:72
HcalRaddamMuon::MuonHcalEnergy
std::vector< double > MuonHcalEnergy
Definition: HcalRaddamMuon.cc:88
HcalRaddamMuon::MuonHcalDepth7Energy
std::vector< double > MuonHcalDepth7Energy
Definition: HcalRaddamMuon.cc:90
HcalRaddamMuon::MuonHcalDepth2Energy
std::vector< double > MuonHcalDepth2Energy
Definition: HcalRaddamMuon.cc:90
HcalRaddamMuon::track_cosmic_momentumOZ
std::vector< double > track_cosmic_momentumOZ
Definition: HcalRaddamMuon.cc:75
HcalRaddamMuon::OuterTrackHits
std::vector< double > OuterTrackHits
Definition: HcalRaddamMuon.cc:82
CaloTopology
Definition: CaloTopology.h:19
HcalRaddamMuon::track_cosmic_positionOX
std::vector< double > track_cosmic_positionOX
Definition: HcalRaddamMuon.cc:72
HcalRaddamMuon::MuonHcalDepth5HotEnergy
std::vector< double > MuonHcalDepth5HotEnergy
Definition: HcalRaddamMuon.cc:92
EcalRecHitCollections.h
HcalRaddamMuon::track_cosmic_detIDouter
std::vector< double > track_cosmic_detIDouter
Definition: HcalRaddamMuon.cc:75
HcalRaddamMuon::tok_topo_
edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > tok_topo_
Definition: HcalRaddamMuon.cc:147
HcalRaddamMuon::MuonHcal1x1Energy
std::vector< double > MuonHcal1x1Energy
Definition: HcalRaddamMuon.cc:88
HcalRaddamMuon::muon_global
std::vector< bool > muon_global
Definition: HcalRaddamMuon.cc:119
LEDCalibrationChannels.iphi
iphi
Definition: LEDCalibrationChannels.py:64
HcalRaddamMuon::PyGlob
std::vector< double > PyGlob
Definition: HcalRaddamMuon.cc:125
HcalRaddamMuon::PChi2
std::vector< double > PChi2
Definition: HcalRaddamMuon.cc:126
HcalRaddamMuon::MuonHcalDetId
std::vector< unsigned int > MuonHcalDetId
Definition: HcalRaddamMuon.cc:89
HcalRaddamMuon::PxGlob
std::vector< double > PxGlob
Definition: HcalRaddamMuon.cc:125
DetId
Definition: DetId.h:17
HcalRaddamMuon::MuonHcalDepth6Energy
std::vector< double > MuonHcalDepth6Energy
Definition: HcalRaddamMuon.cc:90
HcalRaddamMuon::MuonHcalDepth2EnergyCalo
std::vector< double > MuonHcalDepth2EnergyCalo
Definition: HcalRaddamMuon.cc:96
HcalRaddamMuon::PdxyTrack
std::vector< double > PdxyTrack
Definition: HcalRaddamMuon.cc:126
MakerMacros.h
HcalRaddamMuon::endRun
void endRun(edm::Run const &, edm::EventSetup const &) override
Definition: HcalRaddamMuon.cc:745
CaloGeometry
Definition: CaloGeometry.h:21
spr::energyHCALCell
void energyHCALCell(HcalDetId detId, edm::Handle< T > &hits, std::vector< std::pair< double, int > > &energyCell, int maxDepth=1, double hbThr=-100, double heThr=-100, double hfThr=-100, double hoThr=-100, double tMin=-500, double tMax=500, int useRaw=0, int depthHE=3, bool debug=false)
HcalRaddamMuon::MuonHcalHotCalo
std::vector< unsigned int > MuonHcalHotCalo
Definition: HcalRaddamMuon.cc:89
HcalRaddamMuon::IsolationR04
std::vector< double > IsolationR04
Definition: HcalRaddamMuon.cc:87
Track.h
HcalRaddamMuon::track_cosmic_momentumIZ
std::vector< double > track_cosmic_momentumIZ
Definition: HcalRaddamMuon.cc:75
DEFINE_FWK_MODULE
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:16
spr::eECALmatrix
double eECALmatrix(const DetId &detId, edm::Handle< T > &hitsEB, edm::Handle< T > &hitsEE, const CaloGeometry *geo, const CaloTopology *caloTopology, int ieta, int iphi, double ebThr=-100, double eeThr=-100, double tMin=-500, double tMax=500, bool debug=false)
edm::ConfigurationDescriptions::add
void add(std::string const &label, ParameterSetDescription const &psetDescription)
Definition: ConfigurationDescriptions.cc:57
HcalRaddamMuon::Tight_GlobalMuonTrkFit
std::vector< double > Tight_GlobalMuonTrkFit
Definition: HcalRaddamMuon.cc:84
HcalRaddamMuon::Tight_TrkerLayers
std::vector< double > Tight_TrkerLayers
Definition: HcalRaddamMuon.cc:84
HcalRaddamMuon::muon_tracker
std::vector< bool > muon_tracker
Definition: HcalRaddamMuon.cc:119
HcalRaddamMuon::NPvy
std::vector< double > NPvy
Definition: HcalRaddamMuon.cc:126
HcalRaddamMuon::clearVectors
void clearVectors()
Definition: HcalRaddamMuon.cc:758
edm::HLTGlobalStatus::size
unsigned int size() const
Get number of paths stored.
Definition: HLTGlobalStatus.h:35
HcalRaddamMuon::GlobalMuonHits
std::vector< double > GlobalMuonHits
Definition: HcalRaddamMuon.cc:79
HcalRaddamMuon::ntriggers
int ntriggers
Definition: HcalRaddamMuon.cc:131
HcalRaddamMuon::MuonHcalDepth2HotEnergyCalo
std::vector< double > MuonHcalDepth2HotEnergyCalo
Definition: HcalRaddamMuon.cc:98
Service.h
HcalRaddamMuon::OuterTrackPt
std::vector< double > OuterTrackPt
Definition: HcalRaddamMuon.cc:82
spr::propagatedTrackID::okECAL
bool okECAL
Definition: CaloPropagateTrack.h:44
MuonFwd.h
HcalRaddamMuon::tok_EE_
edm::EDGetTokenT< EcalRecHitCollection > tok_EE_
Definition: HcalRaddamMuon.cc:140
eHCALMatrix.h
HcalRaddamMuon::innerTrack
std::vector< bool > innerTrack
Definition: HcalRaddamMuon.cc:86
reco::Track
Definition: Track.h:27
IdealMagneticFieldRecord.h
HcalRaddamMuon::NPvx
std::vector< double > NPvx
Definition: HcalRaddamMuon.cc:126
HcalRaddamMuon::NQOverP
std::vector< double > NQOverP
Definition: HcalRaddamMuon.cc:126
HcalRaddamMuon::~HcalRaddamMuon
~HcalRaddamMuon() override
Definition: HcalRaddamMuon.cc:192
HcalRaddamMuon::EventNumber
unsigned int EventNumber
Definition: HcalRaddamMuon.cc:129
HcalRaddamMuon::NormChi2
std::vector< double > NormChi2
Definition: HcalRaddamMuon.cc:83
HcalRaddamMuon::MuonHcalDepth7HotEnergy
std::vector< double > MuonHcalDepth7HotEnergy
Definition: HcalRaddamMuon.cc:92
reco::BeamSpot::position
const Point & position() const
position
Definition: BeamSpot.h:59
HcalRaddamMuon::all_ifTriggerpassed
std::vector< bool > all_ifTriggerpassed
Definition: HcalRaddamMuon.cc:118
HcalRaddamMuon::OuterTrackEta
std::vector< double > OuterTrackEta
Definition: HcalRaddamMuon.cc:82
eECALMatrix.h
HcalRaddamMuon::type
int type
Definition: HcalRaddamMuon.cc:105
EcalSeverityLevelAlgo.h
HcalRaddamMuon::isAOD_
const bool isAOD_
Definition: HcalRaddamMuon.cc:111
LEDCalibrationChannels.depth
depth
Definition: LEDCalibrationChannels.py:65
HcalDDDRecConstants::getMinDepth
int getMinDepth(const int &itype, const int &ieta, const int &iphi, const int &zside) const
Definition: HcalDDDRecConstants.cc:353
HcalRaddamMuon::chiGlobal
std::vector< double > chiGlobal
Definition: HcalRaddamMuon.cc:79
HcalRaddamMuon::fillDescriptions
static void fillDescriptions(edm::ConfigurationDescriptions &descriptions)
Definition: HcalRaddamMuon.cc:747
CaloGeometryRecord.h
edm::ConfigurationDescriptions
Definition: ConfigurationDescriptions.h:28
HcalRaddamMuon::tok_muon_
edm::EDGetTokenT< reco::MuonCollection > tok_muon_
Definition: HcalRaddamMuon.cc:142
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
Vertex.h
EcalSubdetector.h
HLTConfigProvider::size
unsigned int size() const
number of trigger paths in trigger table
Definition: HLTConfigProvider.h:63
HcalRaddamMuon::MuonHcalDepth5Energy
std::vector< double > MuonHcalDepth5Energy
Definition: HcalRaddamMuon.cc:90
TFileService.h
HcalRaddamMuon::track_cosmic_momentumIY
std::vector< double > track_cosmic_momentumIY
Definition: HcalRaddamMuon.cc:75
HcalRaddamMuon::MuonHcalDepth4EnergyCalo
std::vector< double > MuonHcalDepth4EnergyCalo
Definition: HcalRaddamMuon.cc:96
HcalRaddamMuon::MuonHcalDepth1EnergyCalo
std::vector< double > MuonHcalDepth1EnergyCalo
Definition: HcalRaddamMuon.cc:96
HcalRaddamMuon::tok_magField_
edm::ESGetToken< MagneticField, IdealMagneticFieldRecord > tok_magField_
Definition: HcalRaddamMuon.cc:148
HcalRaddamMuon::MuonHcalDepth4HotEnergy
std::vector< double > MuonHcalDepth4HotEnergy
Definition: HcalRaddamMuon.cc:92
LEDCalibrationChannels.ieta
ieta
Definition: LEDCalibrationChannels.py:63
CaloSubdetectorGeometry.h
HcalRaddamMuon::track_cosmic_momentumOY
std::vector< double > track_cosmic_momentumOY
Definition: HcalRaddamMuon.cc:75
bphysicsOniaDQM_cfi.vertex
vertex
Definition: bphysicsOniaDQM_cfi.py:7
spr::propagatedTrackID::detIdHCAL
DetId detIdHCAL
Definition: CaloPropagateTrack.h:45
HcalRaddamMuon::MuonHcalHot
std::vector< unsigned int > MuonHcalHot
Definition: HcalRaddamMuon.cc:89
edm::ParameterSet
Definition: ParameterSet.h:47
math::XYZPoint
XYZPointD XYZPoint
point in space with cartesian internal representation
Definition: Point3D.h:12
HcalRaddamMuon::useRaw_
const int useRaw_
Definition: HcalRaddamMuon.cc:110
HcalRaddamMuon::NRefPointZ
std::vector< double > NRefPointZ
Definition: HcalRaddamMuon.cc:126
spr::propagatedTrackID::detIdECAL
DetId detIdECAL
Definition: CaloPropagateTrack.h:45
HcalRaddamMuon::hltlabel_
std::string hltlabel_
Definition: HcalRaddamMuon.cc:112
Event.h
SiStripPI::max
Definition: SiStripPayloadInspectorHelper.h:169
HcalRaddamMuon::MuonEcalEnergy
std::vector< double > MuonEcalEnergy
Definition: HcalRaddamMuon.cc:88
HcalRaddamMuon::track_cosmic_detid
std::vector< double > track_cosmic_detid
Definition: HcalRaddamMuon.cc:132
HcalRaddamMuon::MuonEcal3x3Energy
std::vector< double > MuonEcal3x3Energy
Definition: HcalRaddamMuon.cc:88
HcalDetId.h
HcalRaddamMuon::track_cosmic_ymomentum
std::vector< double > track_cosmic_ymomentum
Definition: HcalRaddamMuon.cc:132
HcalTopology::dddConstants
const HcalDDDRecConstants * dddConstants() const
Definition: HcalTopology.h:164
match
std::pair< typename Association::data_type::first_type, double > match(Reference key, Association association, bool bestMatchByMaxValue)
Generic matching function.
Definition: Utils.h:10
HcalRaddamMuon::Tight_MatchedStations
std::vector< double > Tight_MatchedStations
Definition: HcalRaddamMuon.cc:84
TrackerLayer
Definition: TrackerLayer.h:13
CaloTopologyRecord.h
position
static int position[264][3]
Definition: ReadPGInfo.cc:289
HcalRaddamMuon::tok_recVtx_
edm::EDGetTokenT< reco::VertexCollection > tok_recVtx_
Definition: HcalRaddamMuon.cc:137
HcalRaddamMuon::MuonHcalDepth5HotEnergyCalo
std::vector< double > MuonHcalDepth5HotEnergyCalo
Definition: HcalRaddamMuon.cc:98
HcalDetId
Definition: HcalDetId.h:12
edm::Service< TFileService >
createfilelist.int
int
Definition: createfilelist.py:10
TriggerNames.h
HcalRaddamMuon::DxyTracker
std::vector< double > DxyTracker
Definition: HcalRaddamMuon.cc:81
iEvent
int iEvent
Definition: GenABIO.cc:224
HcalRaddamMuon::NQOverPError
std::vector< double > NQOverPError
Definition: HcalRaddamMuon.cc:126
MagneticField.h
HcalRaddamMuon::PNormalizedChi2
std::vector< double > PNormalizedChi2
Definition: HcalRaddamMuon.cc:126
edm::EventSetup
Definition: EventSetup.h:58
HcalRaddamMuon::OuterTrackRHits
std::vector< double > OuterTrackRHits
Definition: HcalRaddamMuon.cc:82
HcalRaddamMuon::LumiNumber
unsigned int LumiNumber
Definition: HcalRaddamMuon.cc:129
HcalRaddamMuon::GlobalTrckPhi
std::vector< double > GlobalTrckPhi
Definition: HcalRaddamMuon.cc:79
edm::LogError
Log< level::Error, false > LogError
Definition: MessageLogger.h:123
HcalRaddamMuon::MuonHcalDepth4HotEnergyCalo
std::vector< double > MuonHcalDepth4HotEnergyCalo
Definition: HcalRaddamMuon.cc:98
HLTConfigProvider.h
get
#define get
HcalRaddamMuon::PdzTrack
std::vector< double > PdzTrack
Definition: HcalRaddamMuon.cc:126
HcalRaddamMuon::TREE
TTree * TREE
Definition: HcalRaddamMuon.cc:117
edm::TriggerNames::triggerIndex
unsigned int triggerIndex(std::string_view name) const
Definition: TriggerNames.cc:52
edm::ESGetToken< HcalDDDRecConstants, HcalRecNumberingRecord >
spr::propagatedTrackID::okHCAL
bool okHCAL
Definition: CaloPropagateTrack.h:44
TriggerObject.h
HcalRaddamMuon::PValidHits
std::vector< double > PValidHits
Definition: HcalRaddamMuon.cc:126
HcalRaddamMuon::v_RH_h3x3_iphi
std::vector< int > v_RH_h3x3_iphi
Definition: HcalRaddamMuon.cc:124
HcalRaddamMuon::trackerlayer_hits
std::vector< double > trackerlayer_hits
Definition: HcalRaddamMuon.cc:83
HcalRaddamMuon::beginRun
void beginRun(edm::Run const &, edm::EventSetup const &) override
Definition: HcalRaddamMuon.cc:714
edm::EventSetup::getData
bool getData(T &iHolder) const
Definition: EventSetup.h:127
CaloTopology.h
HcalRaddamMuon::MuonHcalDepth7EnergyCalo
std::vector< double > MuonHcalDepth7EnergyCalo
Definition: HcalRaddamMuon.cc:96
photonIsolationHIProducer_cfi.hbhe
hbhe
Definition: photonIsolationHIProducer_cfi.py:8
spr::propagateCALO
std::vector< spr::propagatedTrackID > propagateCALO(edm::Handle< reco::TrackCollection > &trkCollection, const CaloGeometry *geo, const MagneticField *bField, const std::string &theTrackQuality, bool debug=false)
Definition: CaloPropagateTrack.cc:141
HcalRaddamMuon::time_hb
std::vector< float > time_hb
Definition: HcalRaddamMuon.cc:121
HcalRaddamMuon::endJob
void endJob() override
Definition: HcalRaddamMuon.cc:711
VertexFwd.h
CaloSubdetectorTopology.h
HcalRaddamMuon::MuonHcalDepth6HotEnergyCalo
std::vector< double > MuonHcalDepth6HotEnergyCalo
Definition: HcalRaddamMuon.cc:98
HcalRaddamMuon::MuonHcalDepth1Energy
std::vector< double > MuonHcalDepth1Energy
Definition: HcalRaddamMuon.cc:90
HcalTopology.h
HcalRaddamMuon::all_triggers1
std::vector< std::string > all_triggers1
Definition: HcalRaddamMuon.cc:113
submitPVResolutionJobs.desc
string desc
Definition: submitPVResolutionJobs.py:251
HLTConfigProvider
Definition: HLTConfigProvider.h:29
HcalRaddamMuon::PD0Error
std::vector< double > PD0Error
Definition: HcalRaddamMuon.cc:126
DetId::rawId
constexpr uint32_t rawId() const
get the raw id
Definition: DetId.h:57
HcalRaddamMuon::MuonHcalDepth2HotEnergy
std::vector< double > MuonHcalDepth2HotEnergy
Definition: HcalRaddamMuon.cc:92
HcalRaddamMuon::innerTrackpt
std::vector< double > innerTrackpt
Definition: HcalRaddamMuon.cc:80
HcalRaddamMuon::tok_hbhe_
edm::EDGetTokenT< HBHERecHitCollection > tok_hbhe_
Definition: HcalRaddamMuon.cc:141
HLTConfigProvider::init
bool init(const edm::Run &iRun, const edm::EventSetup &iSetup, const std::string &processName, bool &changed)
d'tor
Definition: HLTConfigProvider.cc:36
HcalRaddamMuon::tok_geom_
edm::ESGetToken< CaloGeometry, CaloGeometryRecord > tok_geom_
Definition: HcalRaddamMuon.cc:145
HcalRaddamMuon::High_TrackLayers
std::vector< double > High_TrackLayers
Definition: HcalRaddamMuon.cc:84
extraflags_cff.vtx
vtx
Definition: extraflags_cff.py:18
Calorimetry_cff.bField
bField
Definition: Calorimetry_cff.py:284
HcalRaddamMuon::RunNumber
unsigned int RunNumber
Definition: HcalRaddamMuon.cc:129
Frameworkfwd.h
HcalRaddamMuon::GlobalTrckPt
std::vector< double > GlobalTrckPt
Definition: HcalRaddamMuon.cc:79
HcalRaddamMuon::Pmuon
std::vector< double > Pmuon
Definition: HcalRaddamMuon.cc:88
HcalRaddamMuon::h3x3Calo
double h3x3Calo
Definition: HcalRaddamMuon.cc:128
edm::LogVerbatim
Log< level::Info, true > LogVerbatim
Definition: MessageLogger.h:128
CaloPropagateTrack.h
triggerObjects_cff.id
id
Definition: triggerObjects_cff.py:29
HLTConfigData.h
CaloGeometry.h
TFileService::kSharedResource
static const std::string kSharedResource
Definition: TFileService.h:76
HcalRaddamMuon::all_triggers3
std::vector< std::string > all_triggers3
Definition: HcalRaddamMuon.cc:113
HcalRaddamMuon::muon_is_good
std::vector< bool > muon_is_good
Definition: HcalRaddamMuon.cc:119
edm::TriggerNames
Definition: TriggerNames.h:55
HcalRaddamMuon::PzGlob
std::vector< double > PzGlob
Definition: HcalRaddamMuon.cc:125
HcalRaddamMuon::hlTriggerResults_
const edm::InputTag hlTriggerResults_
Definition: HcalRaddamMuon.cc:109
HcalRaddamMuon::TrigName_
std::vector< std::string > TrigName_
Definition: HcalRaddamMuon.cc:122
HcalDDDRecConstants.h
spr::propagatedTrackID
Definition: CaloPropagateTrack.h:38
HcalRaddamMuon::maxDepth_
int maxDepth_
Definition: HcalRaddamMuon.cc:105
HcalRecHitCollections.h
PCaloHitContainer.h
spr::eHCALmatrix
double eHCALmatrix(const HcalTopology *topology, const DetId &det, edm::Handle< T > &hits, int ieta, int iphi, bool includeHO=false, bool algoNew=true, double hbThr=-100, double heThr=-100, double hfThr=-100, double hoThr=-100, double tMin=-500, double tMax=500, int useRaw=0, bool debug=false)
edm::HLTGlobalStatus::accept
bool accept() const
Has at least one path accepted the event?
Definition: HLTGlobalStatus.h:49
AlignmentPI::index
index
Definition: AlignmentPayloadInspectorHelper.h:46
HcalRaddamMuon::OuterTrackChi
std::vector< double > OuterTrackChi
Definition: HcalRaddamMuon.cc:82
HcalRaddamMuon::tok_EB_
edm::EDGetTokenT< EcalRecHitCollection > tok_EB_
Definition: HcalRaddamMuon.cc:139
HcalRaddamMuon::tok_ddrec_
edm::ESGetToken< HcalDDDRecConstants, HcalRecNumberingRecord > tok_ddrec_
Definition: HcalRaddamMuon.cc:144
HcalRaddamMuon::track_cosmic_detIDinner
std::vector< double > track_cosmic_detIDinner
Definition: HcalRaddamMuon.cc:75
HcalDDDRecConstants
Definition: HcalDDDRecConstants.h:23
HcalRaddamMuon::innerTracketa
std::vector< double > innerTracketa
Definition: HcalRaddamMuon.cc:80
HLTConfigProvider::triggerName
const std::string & triggerName(unsigned int triggerIndex) const
Definition: HLTConfigProvider.h:70
HcalRaddamMuon::Tight_LongPara
std::vector< double > Tight_LongPara
Definition: HcalRaddamMuon.cc:84
HcalRaddamMuon::MuonHcalDepth4Energy
std::vector< double > MuonHcalDepth4Energy
Definition: HcalRaddamMuon.cc:90
HcalRaddamMuon::No_pixelLayers
std::vector< double > No_pixelLayers
Definition: HcalRaddamMuon.cc:83
HcalRaddamMuon::NRefPointX
std::vector< double > NRefPointX
Definition: HcalRaddamMuon.cc:126
HcalRaddamMuon::track_cosmic_rad
std::vector< double > track_cosmic_rad
Definition: HcalRaddamMuon.cc:132
HcalRaddamMuon::MuonHcalActiveLength
std::vector< double > MuonHcalActiveLength
Definition: HcalRaddamMuon.cc:103
HcalRaddamMuon::NPvz
std::vector< double > NPvz
Definition: HcalRaddamMuon.cc:126
HcalRaddamMuon::energy_hb
std::vector< float > energy_hb
Definition: HcalRaddamMuon.cc:121
HcalRaddamMuon::track_cosmic_momentumOX
std::vector< double > track_cosmic_momentumOX
Definition: HcalRaddamMuon.cc:75
ParameterSet.h
HcalRaddamMuon::GlobalTrack
std::vector< bool > GlobalTrack
Definition: HcalRaddamMuon.cc:86
HcalRaddamMuon::Trk_match_MuStat
std::vector< bool > Trk_match_MuStat
Definition: HcalRaddamMuon.cc:119
HcalRaddamMuon::isHE
std::vector< bool > isHE
Definition: HcalRaddamMuon.cc:116
HcalRaddamMuon::tok_ecalChStatus_
edm::ESGetToken< EcalChannelStatus, EcalChannelStatusRcd > tok_ecalChStatus_
Definition: HcalRaddamMuon.cc:149
globals_cff.id2
id2
Definition: globals_cff.py:34
HcalRaddamMuon::h3x3
double h3x3
Definition: HcalRaddamMuon.cc:128
HcalRaddamMuon::tok_hcal_
edm::EDGetTokenT< edm::PCaloHitContainer > tok_hcal_
Definition: HcalRaddamMuon.cc:135
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:70
HcalRaddamMuon::v_RH_h3x3_ieta
std::vector< int > v_RH_h3x3_ieta
Definition: HcalRaddamMuon.cc:123
HcalRaddamMuon::MuonHcalDepth3Energy
std::vector< double > MuonHcalDepth3Energy
Definition: HcalRaddamMuon.cc:90
HcalRaddamMuon::MatchedStat
std::vector< double > MatchedStat
Definition: HcalRaddamMuon.cc:79
edm::Event
Definition: Event.h:73
HcalRaddamMuon::track_cosmic_positionIX
std::vector< double > track_cosmic_positionIX
Definition: HcalRaddamMuon.cc:72
submitPVValidationJobs.t
string t
Definition: submitPVValidationJobs.py:644
MagneticField
Definition: MagneticField.h:19
edm::Log
Definition: MessageLogger.h:70
HcalRaddamMuon::track_cosmic_positionIZ
std::vector< double > track_cosmic_positionIZ
Definition: HcalRaddamMuon.cc:72
HcalRaddamMuon::PCharge
std::vector< double > PCharge
Definition: HcalRaddamMuon.cc:126
HcalRaddamMuon::GlobalTrckEta
std::vector< double > GlobalTrckEta
Definition: HcalRaddamMuon.cc:79
HcalRaddamMuon::NTrkMomentum
std::vector< double > NTrkMomentum
Definition: HcalRaddamMuon.cc:126
HcalRaddamMuon::verbosity_
const int verbosity_
Definition: HcalRaddamMuon.cc:110
HcalRaddamMuon::track_cosmic_xmomentum
std::vector< double > track_cosmic_xmomentum
Definition: HcalRaddamMuon.cc:132
HcalRaddamMuon::all_triggers4
std::vector< std::string > all_triggers4
Definition: HcalRaddamMuon.cc:113
HcalRaddamMuon::tok_caloTopology_
edm::ESGetToken< CaloTopology, CaloTopologyRecord > tok_caloTopology_
Definition: HcalRaddamMuon.cc:146
edm::InputTag
Definition: InputTag.h:15
HcalRaddamMuon::MuonEcalDetId
std::vector< unsigned int > MuonEcalDetId
Definition: HcalRaddamMuon.cc:89
HcalRaddamMuon::activeLength
double activeLength(const DetId &)
Definition: HcalRaddamMuon.cc:838
HcalRaddamMuon::all_triggers5
std::vector< std::string > all_triggers5
Definition: HcalRaddamMuon.cc:113
HcalRaddamMuon::MuonHcalDepth3HotEnergyCalo
std::vector< double > MuonHcalDepth3HotEnergyCalo
Definition: HcalRaddamMuon.cc:98
HcalRaddamMuon::Energy
std::vector< double > Energy
Definition: HcalRaddamMuon.cc:88
reco::Vertex
Definition: Vertex.h:35
EcalChannelStatusRcd.h
HcalRaddamMuon::HcalRaddamMuon
HcalRaddamMuon(const edm::ParameterSet &)
Definition: HcalRaddamMuon.cc:153
TFileService::make
T * make(const Args &... args) const
make new ROOT object
Definition: TFileService.h:64
HcalRaddamMuon::all_triggers
std::vector< std::string > all_triggers
Definition: HcalRaddamMuon.cc:113
HcalRaddamMuon::track_cosmic_positionIY
std::vector< double > track_cosmic_positionIY
Definition: HcalRaddamMuon.cc:72
HcalRaddamMuon::track_cosmic_xposition
std::vector< double > track_cosmic_xposition
Definition: HcalRaddamMuon.cc:132
Generated for CMSSW Reference Manual by doxygen 1.8.16