CMS 3D CMS Logo
IsoTrig.cc
Go to the documentation of this file.
1 // -*- C++ -*-//
2 // Package: IsoTrig
3 // Class: IsoTrig
4 //
12 //
13 // Original Author: Ruchi Gupta
14 // Created: Fri May 25 12:02:48 CDT 2012
15 // $Id$
16 //
17 //
18 
19 // system include files
20 #include <memory>
21 #include <unordered_map>
22 
23 // Root objects
24 #include "TROOT.h"
25 #include "TH1.h"
26 #include "TH2.h"
27 #include "TSystem.h"
28 #include "TFile.h"
29 #include "TProfile.h"
30 #include "TDirectory.h"
31 #include "TTree.h"
32 #include "TMath.h"
33 
34 // user include files
35 #include "Calibration/IsolatedParticles/interface/CaloPropagateTrack.h"
36 #include "Calibration/IsolatedParticles/interface/ChargeIsolation.h"
37 #include "Calibration/IsolatedParticles/interface/eCone.h"
38 #include "Calibration/IsolatedParticles/interface/eECALMatrix.h"
39 #include "Calibration/IsolatedParticles/interface/TrackSelection.h"
40 
41 #include "CondFormats/DataRecord/interface/EcalChannelStatusRcd.h"
42 
43 #include "DataFormats/Common/interface/RefToBase.h"
44 #include "DataFormats/HLTReco/interface/TriggerFilterObjectWithRefs.h"
45 #include "DataFormats/HLTReco/interface/TriggerTypeDefs.h"
46 #include "DataFormats/Math/interface/LorentzVector.h"
47 #include "DataFormats/Math/interface/Point3D.h"
48 #include "DataFormats/HcalIsolatedTrack/interface/IsolatedPixelTrackCandidate.h"
49 #include "DataFormats/HcalRecHit/interface/HcalRecHitCollections.h"
50 #include "DataFormats/TrackerRecHit2D/interface/SiPixelRecHitCollection.h"
51 #include "DataFormats/TrackReco/interface/Track.h"
52 #include "DataFormats/TrackReco/interface/TrackFwd.h"
53 #include "DataFormats/TrackReco/interface/TrackBase.h"
54 //Tracks
55 #include "DataFormats/TrackReco/interface/HitPattern.h"
56 // Vertices
57 #include "DataFormats/VertexReco/interface/VertexFwd.h"
58 #include "DataFormats/VertexReco/interface/Vertex.h"
59 #include "DataFormats/BeamSpot/interface/BeamSpot.h"
60 //Triggers
61 #include "DataFormats/Common/interface/TriggerResults.h"
62 #include "DataFormats/HLTReco/interface/TriggerEvent.h"
63 #include "DataFormats/HLTReco/interface/TriggerObject.h"
64 #include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerReadoutRecord.h"
65 #include "DataFormats/Luminosity/interface/LumiDetails.h"
66 
67 #include "FWCore/Common/interface/TriggerNames.h"
68 #include "FWCore/Framework/interface/Frameworkfwd.h"
69 #include "FWCore/Framework/interface/one/EDAnalyzer.h"
70 #include "FWCore/Framework/interface/Event.h"
71 #include "FWCore/Framework/interface/MakerMacros.h"
72 #include "FWCore/MessageLogger/interface/MessageLogger.h"
73 #include "FWCore/ServiceRegistry/interface/Service.h"
74 #include "CommonTools/UtilAlgos/interface/TFileService.h"
75 #include "FWCore/ParameterSet/interface/ParameterSet.h"
76 
77 #include "Geometry/CaloGeometry/interface/CaloGeometry.h"
78 #include "Geometry/CaloGeometry/interface/CaloSubdetectorGeometry.h"
79 #include "Geometry/Records/interface/CaloTopologyRecord.h"
80 #include "Geometry/CaloTopology/interface/CaloSubdetectorTopology.h"
81 #include "Geometry/CaloTopology/interface/CaloTopology.h"
82 #include "Geometry/CaloTopology/interface/EcalTrigTowerConstituentsMap.h"
83 #include "Geometry/CaloTopology/interface/HcalTopology.h"
84 
85 #include "HLTrigger/HLTcore/interface/HLTPrescaleProvider.h"
86 #include "HLTrigger/HLTcore/interface/HLTConfigProvider.h"
87 
88 #include "MagneticField/Engine/interface/MagneticField.h"
89 #include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"
90 
91 #include "RecoLocalCalo/EcalRecAlgos/interface/EcalSeverityLevelAlgo.h"
92 #include "RecoLocalCalo/EcalRecAlgos/interface/EcalSeverityLevelAlgoRcd.h"
93 
94 #include "TrackingTools/TransientTrackingRecHit/interface/SeedingLayerSetsHits.h"
95 
96 class IsoTrig : public edm::one::EDAnalyzer<edm::one::WatchRuns, edm::one::SharedResources> {
97 public:
98  explicit IsoTrig(const edm::ParameterSet &);
99  ~IsoTrig() override;
100 
101  static void fillDescriptions(edm::ConfigurationDescriptions &descriptions);
102 
103 private:
104  void analyze(const edm::Event &, const edm::EventSetup &) override;
105  void beginJob() override;
106  void endJob() override;
107  void beginRun(edm::Run const &, edm::EventSetup const &) override;
108  void endRun(edm::Run const &, edm::EventSetup const &) override {}
109 
110  void clearMipCutTreeVectors();
111  void clearChgIsolnTreeVectors();
112  void pushChgIsolnTreeVecs(math::XYZTLorentzVector &Pixcand,
113  math::XYZTLorentzVector &Trkcand,
114  std::vector<double> &PixMaxP,
115  double &TrkMaxP,
116  bool &selTk);
117  void pushMipCutTreeVecs(math::XYZTLorentzVector &NFcand,
118  math::XYZTLorentzVector &Trkcand,
119  double &EmipNFcand,
120  double &EmipTrkcand,
121  double &mindR,
122  double &mindP1,
123  std::vector<bool> &Flags,
124  double hCone);
125  void StudyTrkEbyP(edm::Handle<reco::TrackCollection> &trkCollection);
126  void studyTiming(const edm::Event &theEvent);
127  void studyMipCut(edm::Handle<reco::TrackCollection> &trkCollection,
128  edm::Handle<reco::IsolatedPixelTrackCandidateCollection> &L2cands);
129  void studyTrigger(edm::Handle<reco::TrackCollection> &, std::vector<reco::TrackCollection::const_iterator> &);
130  void studyIsolation(edm::Handle<reco::TrackCollection> &, std::vector<reco::TrackCollection::const_iterator> &);
131  void chgIsolation(double &etaTriggered,
132  double &phiTriggered,
133  edm::Handle<reco::TrackCollection> &trkCollection,
134  const edm::Event &theEvent);
135  void getGoodTracks(const edm::Event &, edm::Handle<reco::TrackCollection> &);
136  void fillHist(int, math::XYZTLorentzVector &);
137  void fillDifferences(int, math::XYZTLorentzVector &, math::XYZTLorentzVector &, bool);
138  void fillCuts(int, double, double, double, math::XYZTLorentzVector &, int, bool);
139  void fillEnergy(int, int, double, double, math::XYZTLorentzVector &);
140  double dEta(math::XYZTLorentzVector &, math::XYZTLorentzVector &);
141  double dPhi(math::XYZTLorentzVector &, math::XYZTLorentzVector &);
142  double dR(math::XYZTLorentzVector &, math::XYZTLorentzVector &);
143  double dPt(math::XYZTLorentzVector &, math::XYZTLorentzVector &);
144  double dP(math::XYZTLorentzVector &, math::XYZTLorentzVector &);
145  double dinvPt(math::XYZTLorentzVector &, math::XYZTLorentzVector &);
146  std::pair<double, double> etaPhiTrigger();
147  std::pair<double, double> GetEtaPhiAtEcal(double etaIP, double phiIP, double pT, int charge, double vtxZ);
148  double getDistInCM(double eta1, double phi1, double eta2, double phi2);
149 
150  // ----------member data ---------------------------
151  HLTPrescaleProvider hltPrescaleProvider_;
152  const std::vector<std::string> trigNames_;
153  const edm::InputTag pixCandTag_, l1CandTag_, l2CandTag_;
154  const std::vector<edm::InputTag> pixelTracksSources_;
155  const bool doL2L3_, doTiming_, doMipCutTree_;
156  const bool doTrkResTree_, doChgIsolTree_, doStudyIsol_;
157  const int verbosity_;
158  const std::vector<double> pixelIsolationConeSizeAtEC_;
159  const double minPTrackValue_, vtxCutSeed_, vtxCutIsol_;
160  const double tauUnbiasCone_, prelimCone_;
161  std::string theTrackQuality_;
162  const std::string processName_;
163  double rEB_, zEE_, bfVal_;
164  spr::trackSelectionParameters selectionParameters_;
165  const double dr_L1_, a_coneR_, a_charIsoR_, a_neutIsoR_;
166  const double a_mipR_, a_neutR1_, a_neutR2_, cutMip_;
167  const double cutCharge_, cutNeutral_;
168  const int minRunNo_, maxRunNo_;
169  edm::EDGetTokenT<LumiDetails> tok_lumi_;
170  edm::EDGetTokenT<trigger::TriggerEvent> tok_trigEvt_;
171  edm::EDGetTokenT<edm::TriggerResults> tok_trigRes_;
172  edm::EDGetTokenT<trigger::TriggerFilterObjectWithRefs> tok_hlt_;
173  edm::EDGetTokenT<reco::TrackCollection> tok_genTrack_;
174  edm::EDGetTokenT<reco::VertexCollection> tok_recVtx_;
175  edm::EDGetTokenT<reco::BeamSpot> tok_bs_;
176  edm::EDGetTokenT<EcalRecHitCollection> tok_EB_;
177  edm::EDGetTokenT<EcalRecHitCollection> tok_EE_;
178  edm::EDGetTokenT<HBHERecHitCollection> tok_hbhe_;
179  edm::EDGetTokenT<reco::VertexCollection> tok_verthb_, tok_verthe_;
180  edm::EDGetTokenT<SeedingLayerSetsHits> tok_SeedingLayerHB_;
181  edm::EDGetTokenT<SeedingLayerSetsHits> tok_SeedingLayerHE_;
182  edm::EDGetTokenT<SiPixelRecHitCollection> tok_SiPixelRecHits_;
183  edm::EDGetTokenT<reco::IsolatedPixelTrackCandidateCollection> tok_pixtk_;
184  edm::EDGetTokenT<trigger::TriggerFilterObjectWithRefs> tok_l1cand_;
185  edm::EDGetTokenT<reco::IsolatedPixelTrackCandidateCollection> tok_l2cand_;
186  std::vector<edm::EDGetTokenT<reco::TrackCollection>> tok_pixtks_;
187 
188  edm::ESGetToken<CaloGeometry, CaloGeometryRecord> tok_geom_;
189  edm::ESGetToken<MagneticField, IdealMagneticFieldRecord> tok_magField_;
190 
191  std::vector<reco::TrackRef> pixelTrackRefsHB_, pixelTrackRefsHE_;
192  edm::Handle<HBHERecHitCollection> hbhe_;
193  edm::Handle<EcalRecHitCollection> barrelRecHitsHandle_;
194  edm::Handle<EcalRecHitCollection> endcapRecHitsHandle_;
195  edm::Handle<reco::BeamSpot> beamSpotH_;
196  edm::Handle<reco::VertexCollection> recVtxs_;
197 
198  const MagneticField *bField_;
199  const CaloGeometry *geo_;
200  math::XYZPoint leadPV_;
201 
202  std::unordered_map<unsigned int, unsigned int> trigList_;
203  std::unordered_map<unsigned int, const std::pair<double, double>> trigPreList_;
204  bool changed_;
205  double pLimits_[6];
206  edm::Service<TFileService> fs_;
207  TTree *MipCutTree_, *ChgIsolnTree_, *TrkResTree_, *TimingTree_;
208  std::vector<double> *t_timeL2Prod;
209  std::vector<int> *t_nPixCand;
210  std::vector<int> *t_nPixSeed;
211  std::vector<int> *t_nGoodTk;
212 
213  std::vector<double> *t_TrkhCone;
214  std::vector<double> *t_TrkP;
215  std::vector<bool> *t_TrkselTkFlag;
216  std::vector<bool> *t_TrkqltyFlag;
217  std::vector<bool> *t_TrkMissFlag;
218  std::vector<bool> *t_TrkPVFlag;
219  std::vector<bool> *t_TrkNuIsolFlag;
220 
221  std::vector<double> *t_PixcandP;
222  std::vector<double> *t_PixcandPt;
223  std::vector<double> *t_PixcandEta;
224  std::vector<double> *t_PixcandPhi;
225  std::vector<std::vector<double>> *t_PixcandMaxP;
226  std::vector<double> *t_PixTrkcandP;
227  std::vector<double> *t_PixTrkcandPt;
228  std::vector<double> *t_PixTrkcandEta;
229  std::vector<double> *t_PixTrkcandPhi;
230  std::vector<double> *t_PixTrkcandMaxP;
231  std::vector<bool> *t_PixTrkcandselTk;
232 
233  std::vector<double> *t_NFcandP;
234  std::vector<double> *t_NFcandPt;
235  std::vector<double> *t_NFcandEta;
236  std::vector<double> *t_NFcandPhi;
237  std::vector<double> *t_NFcandEmip;
238  std::vector<double> *t_NFTrkcandP;
239  std::vector<double> *t_NFTrkcandPt;
240  std::vector<double> *t_NFTrkcandEta;
241  std::vector<double> *t_NFTrkcandPhi;
242  std::vector<double> *t_NFTrkcandEmip;
243  std::vector<double> *t_NFTrkMinDR;
244  std::vector<double> *t_NFTrkMinDP1;
245  std::vector<bool> *t_NFTrkselTkFlag;
246  std::vector<bool> *t_NFTrkqltyFlag;
247  std::vector<bool> *t_NFTrkMissFlag;
248  std::vector<bool> *t_NFTrkPVFlag;
249  std::vector<bool> *t_NFTrkPropFlag;
250  std::vector<bool> *t_NFTrkChgIsoFlag;
251  std::vector<bool> *t_NFTrkNeuIsoFlag;
252  std::vector<bool> *t_NFTrkMipFlag;
253  std::vector<double> *t_ECone;
254 
255  TH1D *h_EnIn, *h_EnOut;
256  TH2D *h_MipEnMatch, *h_MipEnNoMatch;
257  TH1I *h_nHLT, *h_HLT, *h_PreL1, *h_PreHLT;
258  TH1I *h_Pre, *h_nL3Objs, *h_Filters;
259  TH1D *h_PreL1wt, *h_PreHLTwt, *h_L1ObjEnergy;
260  TH1D *h_p[20], *h_pt[20], *h_eta[20], *h_phi[20];
261  TH1D *h_dEtaL1[2], *h_dPhiL1[2], *h_dRL1[2];
262  TH1D *h_dEta[9], *h_dPhi[9], *h_dPt[9], *h_dP[9];
263  TH1D *h_dinvPt[9], *h_mindR[9], *h_eMip[2];
264  TH1D *h_eMaxNearP[2], *h_eNeutIso[2];
265  TH1D *h_etaCalibTracks[5][2][2], *h_etaMipTracks[5][2][2];
266  TH1D *h_eHcal[5][6][48], *h_eCalo[5][6][48];
267  TH1D *g_Pre, *g_PreL1, *g_PreHLT;
268  TH1I *g_Accepts;
269  std::vector<math::XYZTLorentzVector> vec_[3];
270 };
271 
272 IsoTrig::IsoTrig(const edm::ParameterSet &iConfig)
273  : hltPrescaleProvider_(iConfig, consumesCollector(), *this),
274  trigNames_(iConfig.getUntrackedParameter<std::vector<std::string>>("Triggers")),
275  pixCandTag_(iConfig.getUntrackedParameter<edm::InputTag>("pixCandTag")),
276  l1CandTag_(iConfig.getUntrackedParameter<edm::InputTag>("l1CandTag")),
277  l2CandTag_(iConfig.getUntrackedParameter<edm::InputTag>("l2CandTag")),
278  pixelTracksSources_(iConfig.getUntrackedParameter<std::vector<edm::InputTag>>("pixelTracksSources")),
279  doL2L3_(iConfig.getUntrackedParameter<bool>("doL2L3", true)),
280  doTiming_(iConfig.getUntrackedParameter<bool>("doTimingTree", true)),
281  doMipCutTree_(iConfig.getUntrackedParameter<bool>("doMipCutTree", true)),
282  doTrkResTree_(iConfig.getUntrackedParameter<bool>("doTrkResTree", true)),
283  doChgIsolTree_(iConfig.getUntrackedParameter<bool>("doChgIsolTree", true)),
284  doStudyIsol_(iConfig.getUntrackedParameter<bool>("doStudyIsol", true)),
285  verbosity_(iConfig.getUntrackedParameter<int>("verbosity", 0)),
286  pixelIsolationConeSizeAtEC_(iConfig.getUntrackedParameter<std::vector<double>>("pixelIsolationConeSizeAtEC")),
287  minPTrackValue_(iConfig.getUntrackedParameter<double>("minPTrackValue")),
288  vtxCutSeed_(iConfig.getUntrackedParameter<double>("vertexCutSeed")),
289  vtxCutIsol_(iConfig.getUntrackedParameter<double>("vertexCutIsol")),
290  tauUnbiasCone_(iConfig.getUntrackedParameter<double>("tauUnbiasCone")),
291  prelimCone_(iConfig.getUntrackedParameter<double>("prelimCone")),
292  theTrackQuality_(iConfig.getUntrackedParameter<std::string>("trackQuality", "highPurity")),
293  processName_(iConfig.getUntrackedParameter<std::string>("processName", "HLT")),
294  dr_L1_(iConfig.getUntrackedParameter<double>("isolationL1", 1.0)),
295  a_coneR_(iConfig.getUntrackedParameter<double>("coneRadius", 34.98)),
296  a_charIsoR_(a_coneR_ + 28.9),
297  a_neutIsoR_(a_charIsoR_ * 0.726),
298  a_mipR_(iConfig.getUntrackedParameter<double>("coneRadiusMIP", 14.0)),
299  a_neutR1_(iConfig.getUntrackedParameter<double>("coneRadiusNeut1", 21.0)),
300  a_neutR2_(iConfig.getUntrackedParameter<double>("coneRadiusNeut2", 29.0)),
301  cutMip_(iConfig.getUntrackedParameter<double>("cutMIP", 1.0)),
302  cutCharge_(iConfig.getUntrackedParameter<double>("chargeIsolation", 2.0)),
303  cutNeutral_(iConfig.getUntrackedParameter<double>("neutralIsolation", 2.0)),
304  minRunNo_(iConfig.getUntrackedParameter<int>("minRun")),
305  maxRunNo_(iConfig.getUntrackedParameter<int>("maxRun")),
306  changed_(false),
307  t_timeL2Prod(nullptr),
308  t_nPixCand(nullptr),
309  t_nPixSeed(nullptr),
310  t_nGoodTk(nullptr),
311  t_TrkhCone(nullptr),
312  t_TrkP(nullptr),
313  t_TrkselTkFlag(nullptr),
314  t_TrkqltyFlag(nullptr),
315  t_TrkMissFlag(nullptr),
316  t_TrkPVFlag(nullptr),
317  t_TrkNuIsolFlag(nullptr),
318  t_PixcandP(nullptr),
319  t_PixcandPt(nullptr),
320  t_PixcandEta(nullptr),
321  t_PixcandPhi(nullptr),
322  t_PixcandMaxP(nullptr),
323  t_PixTrkcandP(nullptr),
324  t_PixTrkcandPt(nullptr),
325  t_PixTrkcandEta(nullptr),
326  t_PixTrkcandPhi(nullptr),
327  t_PixTrkcandMaxP(nullptr),
328  t_PixTrkcandselTk(nullptr),
329  t_NFcandP(nullptr),
330  t_NFcandPt(nullptr),
331  t_NFcandEta(nullptr),
332  t_NFcandPhi(nullptr),
333  t_NFcandEmip(nullptr),
334  t_NFTrkcandP(nullptr),
335  t_NFTrkcandPt(nullptr),
336  t_NFTrkcandEta(nullptr),
337  t_NFTrkcandPhi(nullptr),
338  t_NFTrkcandEmip(nullptr),
339  t_NFTrkMinDR(nullptr),
340  t_NFTrkMinDP1(nullptr),
341  t_NFTrkselTkFlag(nullptr),
342  t_NFTrkqltyFlag(nullptr),
343  t_NFTrkMissFlag(nullptr),
344  t_NFTrkPVFlag(nullptr),
345  t_NFTrkPropFlag(nullptr),
346  t_NFTrkChgIsoFlag(nullptr),
347  t_NFTrkNeuIsoFlag(nullptr),
348  t_NFTrkMipFlag(nullptr),
349  t_ECone(nullptr) {
350  usesResource(TFileService::kSharedResource);
351 
352  //now do whatever initialization is needed
353  reco::TrackBase::TrackQuality trackQuality_ = reco::TrackBase::qualityByName(theTrackQuality_);
354  selectionParameters_.minPt = iConfig.getUntrackedParameter<double>("minTrackPt", 10.0);
355  selectionParameters_.minQuality = trackQuality_;
356  selectionParameters_.maxDxyPV = iConfig.getUntrackedParameter<double>("maxDxyPV", 0.2);
357  selectionParameters_.maxDzPV = iConfig.getUntrackedParameter<double>("maxDzPV", 5.0);
358  selectionParameters_.maxChi2 = iConfig.getUntrackedParameter<double>("maxChi2", 5.0);
359  selectionParameters_.maxDpOverP = iConfig.getUntrackedParameter<double>("maxDpOverP", 0.1);
360  selectionParameters_.minOuterHit = iConfig.getUntrackedParameter<int>("minOuterHit", 4);
361  selectionParameters_.minLayerCrossed = iConfig.getUntrackedParameter<int>("minLayerCrossed", 8);
362  selectionParameters_.maxInMiss = iConfig.getUntrackedParameter<int>("maxInMiss", 0);
363  selectionParameters_.maxOutMiss = iConfig.getUntrackedParameter<int>("maxOutMiss", 0);
364 
365  // define tokens for access
366  tok_lumi_ = consumes<LumiDetails, edm::InLumi>(edm::InputTag("lumiProducer"));
367  edm::InputTag triggerEvent_("hltTriggerSummaryAOD", "", processName_);
368  tok_trigEvt_ = consumes<trigger::TriggerEvent>(triggerEvent_);
369  edm::InputTag theTriggerResultsLabel("TriggerResults", "", processName_);
370  tok_trigRes_ = consumes<edm::TriggerResults>(theTriggerResultsLabel);
371  tok_genTrack_ = consumes<reco::TrackCollection>(edm::InputTag("generalTracks"));
372  tok_recVtx_ = consumes<reco::VertexCollection>(edm::InputTag("offlinePrimaryVertices"));
373  tok_bs_ = consumes<reco::BeamSpot>(edm::InputTag("offlineBeamSpot"));
374  tok_EB_ = consumes<EcalRecHitCollection>(edm::InputTag("ecalRecHit", "EcalRecHitsEB"));
375  tok_EE_ = consumes<EcalRecHitCollection>(edm::InputTag("ecalRecHit", "EcalRecHitsEE"));
376  tok_hbhe_ = consumes<HBHERecHitCollection>(edm::InputTag("hbhereco"));
377  tok_pixtk_ = consumes<reco::IsolatedPixelTrackCandidateCollection>(pixCandTag_);
378  tok_l1cand_ = consumes<trigger::TriggerFilterObjectWithRefs>(l1CandTag_);
379  tok_l2cand_ = consumes<reco::IsolatedPixelTrackCandidateCollection>(l2CandTag_);
380  if (doTiming_) {
381  tok_verthb_ = consumes<reco::VertexCollection>(edm::InputTag("hltHITPixelVerticesHB"));
382  tok_verthe_ = consumes<reco::VertexCollection>(edm::InputTag("hltHITPixelVerticesHB"));
383  tok_hlt_ = consumes<trigger::TriggerFilterObjectWithRefs>(edm::InputTag("hltL1sL1SingleJet68"));
384  tok_SeedingLayerHB_ = consumes<SeedingLayerSetsHits>(edm::InputTag("hltPixelLayerTripletsHITHB"));
385  tok_SeedingLayerHE_ = consumes<SeedingLayerSetsHits>(edm::InputTag("hltPixelLayerTripletsHITHE"));
386  tok_SiPixelRecHits_ = consumes<SiPixelRecHitCollection>(edm::InputTag("hltSiPixelRecHits"));
387  }
388  if (doChgIsolTree_) {
389  for (unsigned int k = 0; k < pixelTracksSources_.size(); ++k) {
390  // edm::InputTag pix (pixelTracksSources_[k],"",processName_);
391  // tok_pixtks_.push_back(consumes<reco::TrackCollection>(pix));
392  tok_pixtks_.push_back(consumes<reco::TrackCollection>(pixelTracksSources_[k]));
393  }
394  }
395  if (verbosity_ >= 0) {
396  edm::LogVerbatim("IsoTrack") << "Parameters read from config file \n"
397  << "\t minPt " << selectionParameters_.minPt << "\t theTrackQuality "
398  << theTrackQuality_ << "\t minQuality " << selectionParameters_.minQuality
399  << "\t maxDxyPV " << selectionParameters_.maxDxyPV << "\t maxDzPV "
400  << selectionParameters_.maxDzPV << "\t maxChi2 " << selectionParameters_.maxChi2
401  << "\t maxDpOverP " << selectionParameters_.maxDpOverP << "\t minOuterHit "
402  << selectionParameters_.minOuterHit << "\t minLayerCrossed "
403  << selectionParameters_.minLayerCrossed << "\t maxInMiss "
404  << selectionParameters_.maxInMiss << "\t maxOutMiss "
405  << selectionParameters_.maxOutMiss << "\t a_coneR " << a_coneR_ << "\t a_charIsoR "
406  << a_charIsoR_ << "\t a_neutIsoR " << a_neutIsoR_ << "\t a_mipR " << a_mipR_
407  << "\t a_neutR " << a_neutR1_ << ":" << a_neutR2_ << "\t cuts (MIP " << cutMip_
408  << " : Charge " << cutCharge_ << " : Neutral " << cutNeutral_ << ")";
409  edm::LogVerbatim("IsoTrack") << "Charge Isolation parameters:"
410  << "\t minPTrackValue " << minPTrackValue_ << "\t vtxCutSeed " << vtxCutSeed_
411  << "\t vtxCutIsol " << vtxCutIsol_ << "\t tauUnbiasCone " << tauUnbiasCone_
412  << "\t prelimCone " << prelimCone_ << "\t pixelIsolationConeSizeAtEC";
413  for (unsigned int k = 0; k < pixelIsolationConeSizeAtEC_.size(); ++k)
414  edm::LogVerbatim("IsoTrack") << "[" << k << "] " << pixelIsolationConeSizeAtEC_[k];
415  }
416  double pl[] = {20, 30, 40, 60, 80, 120};
417  for (int i = 0; i < 6; ++i)
418  pLimits_[i] = pl[i];
419  rEB_ = 123.8;
420  zEE_ = 317.0;
421 
422  tok_geom_ = esConsumes<CaloGeometry, CaloGeometryRecord>();
423  tok_magField_ = esConsumes<MagneticField, IdealMagneticFieldRecord>();
424 }
425 
426 IsoTrig::~IsoTrig() {
427  // do anything here that needs to be done at desctruction time
428  // (e.g. close files, deallocate resources etc.)
429  if (t_timeL2Prod)
430  delete t_timeL2Prod;
431  if (t_nPixCand)
432  delete t_nPixCand;
433  if (t_nPixSeed)
434  delete t_nPixSeed;
435  if (t_nGoodTk)
436  delete t_nGoodTk;
437  if (t_TrkhCone)
438  delete t_TrkhCone;
439  if (t_TrkP)
440  delete t_TrkP;
441  if (t_TrkselTkFlag)
442  delete t_TrkselTkFlag;
443  if (t_TrkqltyFlag)
444  delete t_TrkqltyFlag;
445  if (t_TrkMissFlag)
446  delete t_TrkMissFlag;
447  if (t_TrkPVFlag)
448  delete t_TrkPVFlag;
449  if (t_TrkNuIsolFlag)
450  delete t_TrkNuIsolFlag;
451  if (t_PixcandP)
452  delete t_PixcandP;
453  if (t_PixcandPt)
454  delete t_PixcandPt;
455  if (t_PixcandEta)
456  delete t_PixcandEta;
457  if (t_PixcandPhi)
458  delete t_PixcandPhi;
459  if (t_PixcandMaxP)
460  delete t_PixcandMaxP;
461  if (t_PixTrkcandP)
462  delete t_PixTrkcandP;
463  if (t_PixTrkcandPt)
464  delete t_PixTrkcandPt;
465  if (t_PixTrkcandEta)
466  delete t_PixTrkcandEta;
467  if (t_PixTrkcandPhi)
468  delete t_PixTrkcandPhi;
469  if (t_PixTrkcandMaxP)
470  delete t_PixTrkcandMaxP;
471  if (t_PixTrkcandselTk)
472  delete t_PixTrkcandselTk;
473  if (t_NFcandP)
474  delete t_NFcandP;
475  if (t_NFcandPt)
476  delete t_NFcandPt;
477  if (t_NFcandEta)
478  delete t_NFcandEta;
479  if (t_NFcandPhi)
480  delete t_NFcandPhi;
481  if (t_NFcandEmip)
482  delete t_NFcandEmip;
483  if (t_NFTrkcandP)
484  delete t_NFTrkcandP;
485  if (t_NFTrkcandPt)
486  delete t_NFTrkcandPt;
487  if (t_NFTrkcandEta)
488  delete t_NFTrkcandEta;
489  if (t_NFTrkcandPhi)
490  delete t_NFTrkcandPhi;
491  if (t_NFTrkcandEmip)
492  delete t_NFTrkcandEmip;
493  if (t_NFTrkMinDR)
494  delete t_NFTrkMinDR;
495  if (t_NFTrkMinDP1)
496  delete t_NFTrkMinDP1;
497  if (t_NFTrkselTkFlag)
498  delete t_NFTrkselTkFlag;
499  if (t_NFTrkqltyFlag)
500  delete t_NFTrkqltyFlag;
501  if (t_NFTrkMissFlag)
502  delete t_NFTrkMissFlag;
503  if (t_NFTrkPVFlag)
504  delete t_NFTrkPVFlag;
505  if (t_NFTrkPropFlag)
506  delete t_NFTrkPropFlag;
507  if (t_NFTrkChgIsoFlag)
508  delete t_NFTrkChgIsoFlag;
509  if (t_NFTrkNeuIsoFlag)
510  delete t_NFTrkNeuIsoFlag;
511  if (t_NFTrkMipFlag)
512  delete t_NFTrkMipFlag;
513  if (t_ECone)
514  delete t_ECone;
515 }
516 
517 void IsoTrig::fillDescriptions(edm::ConfigurationDescriptions &descriptions) {
518  std::vector<std::string> triggers = {"HLT_IsoTrackHB"};
519  std::vector<edm::InputTag> tags = {edm::InputTag("hltHITPixelTracksHB"), edm::InputTag("hltHITPixelTracksHE")};
520  std::vector<double> cones = {35.0, 40.0, 45.0, 50.0, 55.0, 60.0, 63.9, 70.0};
521  edm::ParameterSetDescription desc;
522  desc.addUntracked<std::vector<std::string>>("Triggers", triggers);
523  desc.addUntracked<edm::InputTag>("pixCandTag", edm::InputTag(" "));
524  desc.addUntracked<edm::InputTag>("l1CandTag", edm::InputTag("hltL1sV0SingleJet60"));
525  desc.addUntracked<edm::InputTag>("l2CandTag", edm::InputTag("isolEcalPixelTrackProd"));
526  desc.addUntracked<bool>("doL2L3", false);
527  desc.addUntracked<bool>("doTimingTree", false);
528  desc.addUntracked<bool>("doMipCutTree", false);
529  desc.addUntracked<bool>("doTrkResTree", true);
530  desc.addUntracked<bool>("doChgIsolTree", false);
531  desc.addUntracked<bool>("doStudyIsol", false);
532  desc.addUntracked<int>("verbosity", 0);
533  desc.addUntracked<std::string>("processName", "HLT");
534  desc.addUntracked<std::string>("trackQuality", "highPurity");
535  desc.addUntracked<double>("minTrackPt", 10.0);
536  desc.addUntracked<double>("maxDxyPV", 0.02);
537  desc.addUntracked<double>("maxDzPV", 0.02);
538  desc.addUntracked<double>("maxChi2", 5.0);
539  desc.addUntracked<double>("maxDpOverP", 0.1);
540  desc.addUntracked<int>("minOuterHit", 4);
541  desc.addUntracked<int>("minLayerCrossed", 8);
542  desc.addUntracked<int>("maxInMiss", 0);
543  desc.addUntracked<int>("maxOutMiss", 0);
544  desc.addUntracked<double>("isolationL1", 1.0);
545  desc.addUntracked<double>("coneRadius", 34.98);
546  desc.addUntracked<double>("coneRadiusMIP", 14.0);
547  desc.addUntracked<double>("coneRadiusNeut1", 21.0);
548  desc.addUntracked<double>("coneRadiusNeut2", 29.0);
549  desc.addUntracked<double>("cutMIP", 1.0);
550  desc.addUntracked<double>("chargeIsolation", 2.0);
551  desc.addUntracked<double>("neutralIsolation", 2.0);
552  desc.addUntracked<int>("minRun", 190456);
553  desc.addUntracked<int>("maxRun", 203002);
554  desc.addUntracked<std::vector<edm::InputTag>>("pixelTracksSources", tags);
555  desc.addUntracked<std::vector<double>>("pixelIsolationConeSizeAtEC", cones);
556  desc.addUntracked<double>("minPTrackValue", 0.0);
557  desc.addUntracked<double>("vertexCutSeed", 101.0);
558  desc.addUntracked<double>("vertexCutIsol", 101.0);
559  desc.addUntracked<double>("tauUnbiasCone", 1.2);
560  desc.addUntracked<double>("prelimCone", 1.0);
561  desc.add<unsigned int>("stageL1Trigger", 1);
562  descriptions.add("isoTrigDefault", desc);
563 }
564 
565 void IsoTrig::analyze(const edm::Event &iEvent, const edm::EventSetup &iSetup) {
566  if (verbosity_ % 10 > 0)
567  edm::LogVerbatim("IsoTrack") << "Event starts====================================";
568 
569  int RunNo = iEvent.id().run();
570 
571  HLTConfigProvider const &hltConfig = hltPrescaleProvider_.hltConfigProvider();
572 
573  bField_ = &iSetup.getData(tok_magField_);
574  geo_ = &iSetup.getData(tok_geom_);
575  GlobalVector BField = bField_->inTesla(GlobalPoint(0, 0, 0));
576  bfVal_ = BField.mag();
577 
578  trigger::TriggerEvent triggerEvent;
579  edm::Handle<trigger::TriggerEvent> triggerEventHandle;
580  iEvent.getByToken(tok_trigEvt_, triggerEventHandle);
581  if (!triggerEventHandle.isValid()) {
582  edm::LogWarning("IsoTrack") << "Error! Can't get the product hltTriggerSummaryAOD";
583 
584  } else {
585  triggerEvent = *(triggerEventHandle.product());
586  }
587  const trigger::TriggerObjectCollection &TOC(triggerEvent.getObjects());
589  edm::Handle<edm::TriggerResults> triggerResults;
590  iEvent.getByToken(tok_trigRes_, triggerResults);
591 
592  edm::Handle<reco::TrackCollection> trkCollection;
593  iEvent.getByToken(tok_genTrack_, trkCollection);
594 
595  iEvent.getByToken(tok_EB_, barrelRecHitsHandle_);
596  iEvent.getByToken(tok_EE_, endcapRecHitsHandle_);
597 
598  iEvent.getByToken(tok_hbhe_, hbhe_);
599 
600  iEvent.getByToken(tok_recVtx_, recVtxs_);
601  iEvent.getByToken(tok_bs_, beamSpotH_);
602  if (!recVtxs_->empty() && !((*recVtxs_)[0].isFake())) {
603  leadPV_ = math::XYZPoint((*recVtxs_)[0].x(), (*recVtxs_)[0].y(), (*recVtxs_)[0].z());
604  } else if (beamSpotH_.isValid()) {
605  leadPV_ = beamSpotH_->position();
606  }
607 
608  if ((verbosity_ / 100) % 10 > 0) {
609  edm::LogVerbatim("IsoTrack") << "Primary Vertex " << leadPV_;
610  if (beamSpotH_.isValid())
611  edm::LogVerbatim("IsoTrack") << "Beam Spot " << beamSpotH_->position();
612  }
613  pixelTrackRefsHE_.clear();
614  pixelTrackRefsHB_.clear();
615  for (unsigned int iPix = 0; iPix < pixelTracksSources_.size(); iPix++) {
616  edm::Handle<reco::TrackCollection> iPixCol;
617  iEvent.getByToken(tok_pixtks_[iPix], iPixCol);
618  if (iPixCol.isValid()) {
619  for (reco::TrackCollection::const_iterator pit = iPixCol->begin(); pit != iPixCol->end(); pit++) {
620  if (iPix == 0)
621  pixelTrackRefsHB_.push_back(reco::TrackRef(iPixCol, pit - iPixCol->begin()));
622  pixelTrackRefsHE_.push_back(reco::TrackRef(iPixCol, pit - iPixCol->begin()));
623  }
624  }
625  }
626  if (doTiming_)
627  getGoodTracks(iEvent, trkCollection);
628 
629  for (unsigned int ifilter = 0; ifilter < triggerEvent.sizeFilters(); ++ifilter) {
630  std::string FilterNames[7] = {"hltL1sL1SingleJet68",
631  "hltIsolPixelTrackL2FilterHE",
632  "ecalIsolPixelTrackFilterHE",
633  "hltIsolPixelTrackL3FilterHE",
634  "hltIsolPixelTrackL2FilterHB",
635  "ecalIsolPixelTrackFilterHB",
636  "hltIsolPixelTrackL3FilterHB"};
637  std::string label = triggerEvent.filterTag(ifilter).label();
638  for (int i = 0; i < 7; i++) {
639  if (label == FilterNames[i])
640  h_Filters->Fill(i);
641  }
642  }
643  edm::InputTag lumiProducer("LumiProducer", "", "RECO");
644  edm::Handle<LumiDetails> Lumid;
645  iEvent.getLuminosityBlock().getByToken(tok_lumi_, Lumid);
646  float mybxlumi = -1;
647  if (Lumid.isValid())
648  mybxlumi = Lumid->lumiValue(LumiDetails::kOCC1, iEvent.bunchCrossing()) * 6.37;
649  if (verbosity_ % 10 > 0)
650  edm::LogVerbatim("IsoTrack") << "RunNo " << RunNo << " EvtNo " << iEvent.id().event() << " Lumi "
651  << iEvent.luminosityBlock() << " Bunch " << iEvent.bunchCrossing() << " mybxlumi "
652  << mybxlumi;
653  if (!triggerResults.isValid()) {
654  edm::LogWarning("IsoTrack") << "Error! Can't get the product triggerResults";
655  // std::shared_ptr<cms::Exception> const & error = triggerResults.whyFailed();
656  // edm::LogWarning(error->category()) << error->what();
657  } else {
658  std::vector<std::string> modules;
659  h_nHLT->Fill(triggerResults->size());
660  const edm::TriggerNames &triggerNames = iEvent.triggerNames(*triggerResults);
661 
662  const std::vector<std::string> &triggerNames_ = triggerNames.triggerNames();
663  if (verbosity_ % 10 > 1)
664  edm::LogVerbatim("IsoTrack") << "number of HLTs " << triggerNames_.size();
665  double preL1(-1), preHLT(-1), prescale(-1);
666  int hlt(-1);
667  for (unsigned int i = 0; i < triggerResults->size(); i++) {
668  unsigned int triggerindx = hltConfig.triggerIndex(triggerNames_[i]);
669  const std::vector<std::string> &moduleLabels(hltConfig.moduleLabels(triggerindx));
670 
671  for (unsigned int in = 0; in < trigNames_.size(); ++in) {
672  // if (triggerNames_[i].find(trigNames_[in].c_str())!=std::string::npos || triggerNames_[i]==" ") {
673  if (triggerNames_[i].find(trigNames_[in]) != std::string::npos) {
674  if (verbosity_ % 10 > 0)
675  edm::LogVerbatim("IsoTrack") << "trigger that i want " << triggerNames_[i] << " accept "
676  << triggerResults->accept(i);
677  hlt = triggerResults->accept(i);
678  h_HLT->Fill(hlt);
679  // if (hlt>0 || triggerNames_[i]==" ") {
680  if (hlt > 0) {
681  edm::Handle<reco::IsolatedPixelTrackCandidateCollection> Pixcands;
682  iEvent.getByToken(tok_pixtk_, Pixcands);
683  edm::Handle<trigger::TriggerFilterObjectWithRefs> L1cands;
684  iEvent.getByToken(tok_l1cand_, L1cands);
685 
686  auto const prescales = hltPrescaleProvider_.prescaleValues<double>(iEvent, iSetup, triggerNames_[i]);
687  preL1 = prescales.first;
688  preHLT = prescales.second;
689  prescale = preL1 * preHLT;
690  if (verbosity_ % 10 > 0)
691  edm::LogVerbatim("IsoTrack")
692  << triggerNames_[i] << " accept " << hlt << " preL1 " << preL1 << " preHLT " << preHLT;
693  for (int iv = 0; iv < 3; ++iv)
694  vec_[iv].clear();
695  if (trigList_.find(RunNo) != trigList_.end()) {
696  trigList_[RunNo] += 1;
697  } else {
698  trigList_.insert({RunNo, 1});
699  trigPreList_.insert({RunNo, prescales});
700  }
701  //loop over all trigger filters in event (i.e. filters passed)
702  for (unsigned int ifilter = 0; ifilter < triggerEvent.sizeFilters(); ++ifilter) {
703  std::vector<int> Keys;
704  std::string label = triggerEvent.filterTag(ifilter).label();
705  //loop over keys to objects passing this filter
706  for (unsigned int imodule = 0; imodule < moduleLabels.size(); imodule++) {
707  if (label.find(moduleLabels[imodule]) != std::string::npos) {
708  if (verbosity_ % 10 > 0)
709  edm::LogVerbatim("IsoTrack") << "FILTERNAME " << label;
710  for (unsigned int ifiltrKey = 0; ifiltrKey < triggerEvent.filterKeys(ifilter).size(); ++ifiltrKey) {
711  Keys.push_back(triggerEvent.filterKeys(ifilter)[ifiltrKey]);
712  const trigger::TriggerObject &TO(TOC[Keys[ifiltrKey]]);
713  math::XYZTLorentzVector v4(TO.px(), TO.py(), TO.pz(), TO.energy());
714  if (label.find("L2Filter") != std::string::npos) {
715  vec_[1].push_back(v4);
716  } else if (label.find("L3Filter") != std::string::npos) {
717  vec_[2].push_back(v4);
718  } else {
719  vec_[0].push_back(v4);
720  h_L1ObjEnergy->Fill(TO.energy());
721  }
722  if (verbosity_ % 10 > 0)
723  edm::LogVerbatim("IsoTrack") << "key " << ifiltrKey << " : pt " << TO.pt() << " eta " << TO.eta()
724  << " phi " << TO.phi() << " mass " << TO.mass() << " Id " << TO.id();
725  }
726  }
727  }
728  }
729  std::vector<reco::TrackCollection::const_iterator> goodTks;
730  if (doL2L3_) {
731  h_nL3Objs->Fill(vec_[2].size());
732  studyTrigger(trkCollection, goodTks);
733  } else {
734  if (trkCollection.isValid()) {
735  reco::TrackCollection::const_iterator trkItr;
736  for (trkItr = trkCollection->begin(); trkItr != trkCollection->end(); trkItr++)
737  goodTks.push_back(trkItr);
738  }
739  }
740  // Now study isolation etc
741  if (doStudyIsol_)
742  studyIsolation(trkCollection, goodTks);
743  if (doTrkResTree_)
744  StudyTrkEbyP(trkCollection);
745 
746  std::pair<double, double> etaphi = etaPhiTrigger();
747  edm::Handle<reco::IsolatedPixelTrackCandidateCollection> L2cands;
748  iEvent.getByToken(tok_l2cand_, L2cands);
749  if (!L2cands.isValid()) {
750  if (verbosity_ % 10 > 0)
751  edm::LogVerbatim("IsoTrack") << " trigCand is not valid ";
752  } else {
753  if (doMipCutTree_)
754  studyMipCut(trkCollection, L2cands);
755  }
756  if (!pixelTracksSources_.empty())
757  if (doChgIsolTree_ && !pixelTrackRefsHE_.empty())
758  chgIsolation(etaphi.first, etaphi.second, trkCollection, iEvent);
759  }
760  break;
761  }
762  }
763  }
764  h_PreL1->Fill(preL1);
765  h_PreHLT->Fill(preHLT);
766  h_Pre->Fill(prescale);
767  h_PreL1wt->Fill(preL1, mybxlumi);
768  h_PreHLTwt->Fill(preHLT, mybxlumi);
769 
770  // check if trigger names in (new) config
771  // edm::LogVerbatim("IsoTrack") << "changed " << changed_;
772  if (changed_) {
773  changed_ = false;
774  if ((verbosity_ / 10) % 10 > 1) {
775  edm::LogVerbatim("IsoTrack") << "New trigger menu found !!!";
776  const unsigned int n(hltConfig.size());
777  for (unsigned itrig = 0; itrig < triggerNames_.size(); itrig++) {
778  unsigned int triggerindx = hltConfig.triggerIndex(triggerNames_[itrig]);
779  if (triggerindx >= n)
780  edm::LogVerbatim("IsoTrack") << triggerNames_[itrig] << " " << triggerindx << " does not exist in"
781  << " the current menu";
782  else
783  edm::LogVerbatim("IsoTrack") << triggerNames_[itrig] << " " << triggerindx << " exists";
784  }
785  }
786  }
787  }
788  if (doTiming_)
789  studyTiming(iEvent);
790 }
791 
792 void IsoTrig::clearChgIsolnTreeVectors() {
793  t_PixcandP->clear();
794  t_PixcandPt->clear();
795  t_PixcandEta->clear();
796  t_PixcandPhi->clear();
797  for (unsigned int i = 0; i < t_PixcandMaxP->size(); i++)
798  t_PixcandMaxP[i].clear();
799  t_PixcandMaxP->clear();
800  t_PixTrkcandP->clear();
801  t_PixTrkcandPt->clear();
802  t_PixTrkcandEta->clear();
803  t_PixTrkcandPhi->clear();
804  t_PixTrkcandMaxP->clear();
805  t_PixTrkcandselTk->clear();
806 }
807 
808 void IsoTrig::clearMipCutTreeVectors() {
809  t_NFcandP->clear();
810  t_NFcandPt->clear();
811  t_NFcandEta->clear();
812  t_NFcandPhi->clear();
813  t_NFcandEmip->clear();
814  t_NFTrkcandP->clear();
815  t_NFTrkcandPt->clear();
816  t_NFTrkcandEta->clear();
817  t_NFTrkcandPhi->clear();
818  t_NFTrkcandEmip->clear();
819  t_NFTrkMinDR->clear();
820  t_NFTrkMinDP1->clear();
821  t_NFTrkselTkFlag->clear();
822  t_NFTrkqltyFlag->clear();
823  t_NFTrkMissFlag->clear();
824  t_NFTrkPVFlag->clear();
825  t_NFTrkPropFlag->clear();
826  t_NFTrkChgIsoFlag->clear();
827  t_NFTrkNeuIsoFlag->clear();
828  t_NFTrkMipFlag->clear();
829  t_ECone->clear();
830 }
831 
832 void IsoTrig::pushChgIsolnTreeVecs(math::XYZTLorentzVector &Pixcand,
833  math::XYZTLorentzVector &Trkcand,
834  std::vector<double> &PixMaxP,
835  double &TrkMaxP,
836  bool &selTk) {
837  t_PixcandP->push_back(Pixcand.r());
838  t_PixcandPt->push_back(Pixcand.pt());
839  t_PixcandEta->push_back(Pixcand.eta());
840  t_PixcandPhi->push_back(Pixcand.phi());
841  t_PixcandMaxP->push_back(PixMaxP);
842  t_PixTrkcandP->push_back(Trkcand.r());
843  t_PixTrkcandPt->push_back(Trkcand.pt());
844  t_PixTrkcandEta->push_back(Trkcand.eta());
845  t_PixTrkcandPhi->push_back(Trkcand.phi());
846  t_PixTrkcandMaxP->push_back(TrkMaxP);
847  t_PixTrkcandselTk->push_back(selTk);
848 }
849 
850 void IsoTrig::pushMipCutTreeVecs(math::XYZTLorentzVector &NFcand,
851  math::XYZTLorentzVector &Trkcand,
852  double &EmipNFcand,
853  double &EmipTrkcand,
854  double &mindR,
855  double &mindP1,
856  std::vector<bool> &Flags,
857  double hCone) {
858  t_NFcandP->push_back(NFcand.r());
859  t_NFcandPt->push_back(NFcand.pt());
860  t_NFcandEta->push_back(NFcand.eta());
861  t_NFcandPhi->push_back(NFcand.phi());
862  t_NFcandEmip->push_back(EmipNFcand);
863  t_NFTrkcandP->push_back(Trkcand.r());
864  t_NFTrkcandPt->push_back(Trkcand.pt());
865  t_NFTrkcandEta->push_back(Trkcand.eta());
866  t_NFTrkcandPhi->push_back(Trkcand.phi());
867  t_NFTrkcandEmip->push_back(EmipTrkcand);
868  t_NFTrkMinDR->push_back(mindR);
869  t_NFTrkMinDP1->push_back(mindP1);
870  t_NFTrkselTkFlag->push_back(Flags[0]);
871  t_NFTrkqltyFlag->push_back(Flags[1]);
872  t_NFTrkMissFlag->push_back(Flags[2]);
873  t_NFTrkPVFlag->push_back(Flags[3]);
874  t_NFTrkPropFlag->push_back(Flags[4]);
875  t_NFTrkChgIsoFlag->push_back(Flags[5]);
876  t_NFTrkNeuIsoFlag->push_back(Flags[6]);
877  t_NFTrkMipFlag->push_back(Flags[7]);
878  t_ECone->push_back(hCone);
879 }
880 
881 void IsoTrig::beginJob() {
882  char hname[100], htit[100];
883  std::string levels[20] = {"L1", "L2", "L3", "Reco", "RecoMatch", "RecoNoMatch",
884  "L2Match", "L2NoMatch", "L3Match", "L3NoMatch", "HLTTrk", "HLTGoodTrk",
885  "HLTIsoTrk", "HLTMip", "HLTSelect", "nonHLTTrk", "nonHLTGoodTrk", "nonHLTIsoTrk",
886  "nonHLTMip", "nonHLTSelect"};
887  if (doTiming_) {
888  TimingTree_ = fs_->make<TTree>("TimingTree", "TimingTree");
889  t_timeL2Prod = new std::vector<double>();
890  t_nPixCand = new std::vector<int>();
891  t_nPixSeed = new std::vector<int>();
892  t_nGoodTk = new std::vector<int>();
893 
894  TimingTree_->Branch("t_timeL2Prod", "std::vector<double>", &t_timeL2Prod);
895  TimingTree_->Branch("t_nPixCand", "std::vector<int>", &t_nPixCand);
896  TimingTree_->Branch("t_nPixSeed", "std::vector<int>", &t_nPixSeed);
897  TimingTree_->Branch("t_nGoodTk", "std::vector<int>", &t_nGoodTk);
898  }
899  if (doTrkResTree_) {
900  TrkResTree_ = fs_->make<TTree>("TrkRestree", "TrkResTree");
901  t_TrkhCone = new std::vector<double>();
902  t_TrkP = new std::vector<double>();
903  t_TrkselTkFlag = new std::vector<bool>();
904  t_TrkqltyFlag = new std::vector<bool>();
905  t_TrkMissFlag = new std::vector<bool>();
906  t_TrkPVFlag = new std::vector<bool>();
907  t_TrkNuIsolFlag = new std::vector<bool>();
908 
909  TrkResTree_->Branch("t_TrkhCone", "std::vector<double>", &t_TrkhCone);
910  TrkResTree_->Branch("t_TrkP", "std::vector<double>", &t_TrkP);
911  TrkResTree_->Branch("t_TrkselTkFlag", "std::vector<bool>", &t_TrkselTkFlag);
912  TrkResTree_->Branch("t_TrkqltyFlag", "std::vector<bool>", &t_TrkqltyFlag);
913  TrkResTree_->Branch("t_TrkMissFlag", "std::vector<bool>", &t_TrkMissFlag);
914  TrkResTree_->Branch("t_TrkPVFlag", "std::vector<bool>", &t_TrkPVFlag);
915  TrkResTree_->Branch("t_TrkNuIsolFlag", "std::vector<bool>", &t_TrkNuIsolFlag);
916  }
917  if (doChgIsolTree_) {
918  ChgIsolnTree_ = fs_->make<TTree>("ChgIsolnTree", "ChgIsolnTree");
919  t_PixcandP = new std::vector<double>();
920  t_PixcandPt = new std::vector<double>();
921  t_PixcandEta = new std::vector<double>();
922  t_PixcandPhi = new std::vector<double>();
923  t_PixcandMaxP = new std::vector<std::vector<double>>();
924  t_PixTrkcandP = new std::vector<double>();
925  t_PixTrkcandPt = new std::vector<double>();
926  t_PixTrkcandEta = new std::vector<double>();
927  t_PixTrkcandPhi = new std::vector<double>();
928  t_PixTrkcandMaxP = new std::vector<double>();
929  t_PixTrkcandselTk = new std::vector<bool>();
930 
931  ChgIsolnTree_->Branch("t_PixcandP", "std::vector<double>", &t_PixcandP);
932  ChgIsolnTree_->Branch("t_PixcandPt", "std::vector<double>", &t_PixcandPt);
933  ChgIsolnTree_->Branch("t_PixcandEta", "std::vector<double>", &t_PixcandEta);
934  ChgIsolnTree_->Branch("t_PixcandPhi", "std::vector<double>", &t_PixcandPhi);
935  ChgIsolnTree_->Branch("t_PixcandMaxP", "std::vector<std::vector<double> >", &t_PixcandMaxP);
936  ChgIsolnTree_->Branch("t_PixTrkcandP", "std::vector<double>", &t_PixTrkcandP);
937  ChgIsolnTree_->Branch("t_PixTrkcandPt", "std::vector<double>", &t_PixTrkcandPt);
938  ChgIsolnTree_->Branch("t_PixTrkcandEta", "std::vector<double>", &t_PixTrkcandEta);
939  ChgIsolnTree_->Branch("t_PixTrkcandPhi", "std::vector<double>", &t_PixTrkcandPhi);
940  ChgIsolnTree_->Branch("t_PixTrkcandMaxP", "std::vector<double>", &t_PixTrkcandMaxP);
941  ChgIsolnTree_->Branch("t_PixTrkcandselTk", "std::vector<bool>", &t_PixTrkcandselTk);
942  }
943  if (doMipCutTree_) {
944  MipCutTree_ = fs_->make<TTree>("MipCutTree", "MipCutTree");
945  t_NFcandP = new std::vector<double>();
946  t_NFcandPt = new std::vector<double>();
947  t_NFcandEta = new std::vector<double>();
948  t_NFcandPhi = new std::vector<double>();
949  t_NFcandEmip = new std::vector<double>();
950  t_NFTrkcandP = new std::vector<double>();
951  t_NFTrkcandPt = new std::vector<double>();
952  t_NFTrkcandEta = new std::vector<double>();
953  t_NFTrkcandPhi = new std::vector<double>();
954  t_NFTrkcandEmip = new std::vector<double>();
955  t_NFTrkMinDR = new std::vector<double>();
956  t_NFTrkMinDP1 = new std::vector<double>();
957  t_NFTrkselTkFlag = new std::vector<bool>();
958  t_NFTrkqltyFlag = new std::vector<bool>();
959  t_NFTrkMissFlag = new std::vector<bool>();
960  t_NFTrkPVFlag = new std::vector<bool>();
961  t_NFTrkPropFlag = new std::vector<bool>();
962  t_NFTrkChgIsoFlag = new std::vector<bool>();
963  t_NFTrkNeuIsoFlag = new std::vector<bool>();
964  t_NFTrkMipFlag = new std::vector<bool>();
965  t_ECone = new std::vector<double>();
966 
967  MipCutTree_->Branch("t_NFcandP", "std::vector<double>", &t_NFcandP);
968  MipCutTree_->Branch("t_NFcandPt", "std::vector<double>", &t_NFcandPt);
969  MipCutTree_->Branch("t_NFcandEta", "std::vector<double>", &t_NFcandEta);
970  MipCutTree_->Branch("t_NFcandPhi", "std::vector<double>", &t_NFcandPhi);
971  MipCutTree_->Branch("t_NFcandEmip", "std::vector<double>", &t_NFcandEmip);
972  MipCutTree_->Branch("t_NFTrkcandP", "std::vector<double>", &t_NFTrkcandP);
973  MipCutTree_->Branch("t_NFTrkcandPt", "std::vector<double>", &t_NFTrkcandPt);
974  MipCutTree_->Branch("t_NFTrkcandEta", "std::vector<double>", &t_NFTrkcandEta);
975  MipCutTree_->Branch("t_NFTrkcandPhi", "std::vector<double>", &t_NFTrkcandPhi);
976  MipCutTree_->Branch("t_NFTrkcandEmip", "std::vector<double>", &t_NFTrkcandEmip);
977  MipCutTree_->Branch("t_NFTrkMinDR", "std::vector<double>", &t_NFTrkMinDR);
978  MipCutTree_->Branch("t_NFTrkMinDP1", "std::vector<double>", &t_NFTrkMinDP1);
979  MipCutTree_->Branch("t_NFTrkselTkFlag", "std::vector<bool>", &t_NFTrkselTkFlag);
980  MipCutTree_->Branch("t_NFTrkqltyFlag", "std::vector<bool>", &t_NFTrkqltyFlag);
981  MipCutTree_->Branch("t_NFTrkMissFlag", "std::vector<bool>", &t_NFTrkMissFlag);
982  MipCutTree_->Branch("t_NFTrkPVFlag", "std::vector<bool>", &t_NFTrkPVFlag);
983  MipCutTree_->Branch("t_NFTrkPropFlag", "std::vector<bool>", &t_NFTrkPropFlag);
984  MipCutTree_->Branch("t_NFTrkChgIsoFlag", "std::vector<bool>", &t_NFTrkChgIsoFlag);
985  MipCutTree_->Branch("t_NFTrkNeuIsoFlag", "std::vector<bool>", &t_NFTrkNeuIsoFlag);
986  MipCutTree_->Branch("t_NFTrkMipFlag", "std::vector<bool>", &t_NFTrkMipFlag);
987  MipCutTree_->Branch("t_ECone", "std::vector<double>", &t_ECone);
988  }
989  h_Filters = fs_->make<TH1I>("h_Filters", "Filter Accepts", 10, 0, 10);
990  std::string FilterNames[7] = {"hltL1sL1SingleJet68",
991  "hltIsolPixelTrackL2FilterHE",
992  "ecalIsolPixelTrackFilterHE",
993  "hltIsolPixelTrackL3FilterHE",
994  "hltIsolPixelTrackL2FilterHB",
995  "ecalIsolPixelTrackFilterHB",
996  "hltIsolPixelTrackL3FilterHB"};
997  for (int i = 0; i < 7; i++) {
998  h_Filters->GetXaxis()->SetBinLabel(i + 1, FilterNames[i].c_str());
999  }
1000 
1001  h_nHLT = fs_->make<TH1I>("h_nHLT", "Size of trigger Names", 1000, 1, 1000);
1002  h_HLT = fs_->make<TH1I>("h_HLT", "HLT accept", 3, -1, 2);
1003  h_PreL1 = fs_->make<TH1I>("h_PreL1", "L1 Prescale", 500, 0, 500);
1004  h_PreHLT = fs_->make<TH1I>("h_PreHLT", "HLT Prescale", 50, 0, 50);
1005  h_Pre = fs_->make<TH1I>("h_Pre", "Prescale", 3000, 0, 3000);
1006 
1007  h_PreL1wt = fs_->make<TH1D>("h_PreL1wt", "Weighted L1 Prescale", 500, 0, 500);
1008  h_PreHLTwt = fs_->make<TH1D>("h_PreHLTwt", "Weighted HLT Prescale", 500, 0, 100);
1009  h_L1ObjEnergy = fs_->make<TH1D>("h_L1ObjEnergy", "Energy of L1Object", 500, 0.0, 500.0);
1010 
1011  h_EnIn = fs_->make<TH1D>("h_EnInEcal", "EnergyIn Ecal", 200, 0.0, 20.0);
1012  h_EnOut = fs_->make<TH1D>("h_EnOutEcal", "EnergyOut Ecal", 200, 0.0, 20.0);
1013  h_MipEnMatch =
1014  fs_->make<TH2D>("h_MipEnMatch", "MipEn: HLT level vs Reco Level (Matched)", 200, 0.0, 20.0, 200, 0.0, 20.0);
1015  h_MipEnNoMatch = fs_->make<TH2D>(
1016  "h_MipEnNoMatch", "MipEn: HLT level vs Reco Level (No Match Found)", 200, 0.0, 20.0, 200, 0.0, 20.0);
1017 
1018  if (doL2L3_) {
1019  h_nL3Objs = fs_->make<TH1I>("h_nL3Objs", "Number of L3 objects", 10, 0, 10);
1020 
1021  std::string pairs[9] = {"L2L3",
1022  "L2L3Match",
1023  "L2L3NoMatch",
1024  "L3Reco",
1025  "L3RecoMatch",
1026  "L3RecoNoMatch",
1027  "NewFilterReco",
1028  "NewFilterRecoMatch",
1029  "NewFilterRecoNoMatch"};
1030  for (int ipair = 0; ipair < 9; ipair++) {
1031  sprintf(hname, "h_dEta%s", pairs[ipair].c_str());
1032  sprintf(htit, "#Delta#eta for %s", pairs[ipair].c_str());
1033  h_dEta[ipair] = fs_->make<TH1D>(hname, htit, 200, -10.0, 10.0);
1034  h_dEta[ipair]->GetXaxis()->SetTitle("d#eta");
1035 
1036  sprintf(hname, "h_dPhi%s", pairs[ipair].c_str());
1037  sprintf(htit, "#Delta#phi for %s", pairs[ipair].c_str());
1038  h_dPhi[ipair] = fs_->make<TH1D>(hname, htit, 140, -7.0, 7.0);
1039  h_dPhi[ipair]->GetXaxis()->SetTitle("d#phi");
1040 
1041  sprintf(hname, "h_dPt%s", pairs[ipair].c_str());
1042  sprintf(htit, "#Delta dp_{T} for %s objects", pairs[ipair].c_str());
1043  h_dPt[ipair] = fs_->make<TH1D>(hname, htit, 400, -200.0, 200.0);
1044  h_dPt[ipair]->GetXaxis()->SetTitle("dp_{T} (GeV)");
1045 
1046  sprintf(hname, "h_dP%s", pairs[ipair].c_str());
1047  sprintf(htit, "#Delta p for %s objects", pairs[ipair].c_str());
1048  h_dP[ipair] = fs_->make<TH1D>(hname, htit, 400, -200.0, 200.0);
1049  h_dP[ipair]->GetXaxis()->SetTitle("dP (GeV)");
1050 
1051  sprintf(hname, "h_dinvPt%s", pairs[ipair].c_str());
1052  sprintf(htit, "#Delta (1/p_{T}) for %s objects", pairs[ipair].c_str());
1053  h_dinvPt[ipair] = fs_->make<TH1D>(hname, htit, 500, -0.4, 0.1);
1054  h_dinvPt[ipair]->GetXaxis()->SetTitle("d(1/p_{T})");
1055  sprintf(hname, "h_mindR%s", pairs[ipair].c_str());
1056  sprintf(htit, "min(#Delta R) for %s objects", pairs[ipair].c_str());
1057  h_mindR[ipair] = fs_->make<TH1D>(hname, htit, 500, 0.0, 1.0);
1058  h_mindR[ipair]->GetXaxis()->SetTitle("dR");
1059  }
1060 
1061  for (int lvl = 0; lvl < 2; lvl++) {
1062  sprintf(hname, "h_dEtaL1%s", levels[lvl + 1].c_str());
1063  sprintf(htit, "#Delta#eta for L1 and %s objects", levels[lvl + 1].c_str());
1064  h_dEtaL1[lvl] = fs_->make<TH1D>(hname, htit, 400, -10.0, 10.0);
1065 
1066  sprintf(hname, "h_dPhiL1%s", levels[lvl + 1].c_str());
1067  sprintf(htit, "#Delta#phi for L1 and %s objects", levels[lvl + 1].c_str());
1068  h_dPhiL1[lvl] = fs_->make<TH1D>(hname, htit, 280, -7.0, 7.0);
1069 
1070  sprintf(hname, "h_dRL1%s", levels[lvl + 1].c_str());
1071  sprintf(htit, "#Delta R for L1 and %s objects", levels[lvl + 1].c_str());
1072  h_dRL1[lvl] = fs_->make<TH1D>(hname, htit, 100, 0.0, 10.0);
1073  }
1074  }
1075 
1076  int levmin = (doL2L3_ ? 0 : 10);
1077  for (int ilevel = levmin; ilevel < 20; ilevel++) {
1078  sprintf(hname, "h_p%s", levels[ilevel].c_str());
1079  sprintf(htit, "p for %s objects", levels[ilevel].c_str());
1080  h_p[ilevel] = fs_->make<TH1D>(hname, htit, 100, 0.0, 500.0);
1081  h_p[ilevel]->GetXaxis()->SetTitle("p (GeV)");
1082 
1083  sprintf(hname, "h_pt%s", levels[ilevel].c_str());
1084  sprintf(htit, "p_{T} for %s objects", levels[ilevel].c_str());
1085  h_pt[ilevel] = fs_->make<TH1D>(hname, htit, 100, 0.0, 500.0);
1086  h_pt[ilevel]->GetXaxis()->SetTitle("p_{T} (GeV)");
1087 
1088  sprintf(hname, "h_eta%s", levels[ilevel].c_str());
1089  sprintf(htit, "#eta for %s objects", levels[ilevel].c_str());
1090  h_eta[ilevel] = fs_->make<TH1D>(hname, htit, 100, -5.0, 5.0);
1091  h_eta[ilevel]->GetXaxis()->SetTitle("#eta");
1092 
1093  sprintf(hname, "h_phi%s", levels[ilevel].c_str());
1094  sprintf(htit, "#phi for %s objects", levels[ilevel].c_str());
1095  h_phi[ilevel] = fs_->make<TH1D>(hname, htit, 70, -3.5, 3.50);
1096  h_phi[ilevel]->GetXaxis()->SetTitle("#phi");
1097  }
1098 
1099  std::string cuts[2] = {"HLTMatched", "HLTNotMatched"};
1100  std::string cuts2[2] = {"All", "Away from L1"};
1101  for (int icut = 0; icut < 2; icut++) {
1102  sprintf(hname, "h_eMip%s", cuts[icut].c_str());
1103  sprintf(htit, "eMip for %s tracks", cuts[icut].c_str());
1104  h_eMip[icut] = fs_->make<TH1D>(hname, htit, 200, 0.0, 10.0);
1105  h_eMip[icut]->GetXaxis()->SetTitle("E_{Mip} (GeV)");
1106 
1107  sprintf(hname, "h_eMaxNearP%s", cuts[icut].c_str());
1108  sprintf(htit, "eMaxNearP for %s tracks", cuts[icut].c_str());
1109  h_eMaxNearP[icut] = fs_->make<TH1D>(hname, htit, 240, -2.0, 10.0);
1110  h_eMaxNearP[icut]->GetXaxis()->SetTitle("E_{MaxNearP} (GeV)");
1111 
1112  sprintf(hname, "h_eNeutIso%s", cuts[icut].c_str());
1113  sprintf(htit, "eNeutIso for %s ", cuts[icut].c_str());
1114  h_eNeutIso[icut] = fs_->make<TH1D>(hname, htit, 200, 0.0, 10.0);
1115  h_eNeutIso[icut]->GetXaxis()->SetTitle("E_{NeutIso} (GeV)");
1116 
1117  for (int kcut = 0; kcut < 2; ++kcut) {
1118  for (int lim = 0; lim < 5; ++lim) {
1119  sprintf(hname, "h_etaCalibTracks%sCut%dLim%d", cuts[icut].c_str(), kcut, lim);
1120  sprintf(htit,
1121  "#eta for %s isolated MIP tracks (%4.1f < p < %5.1f Gev/c %s)",
1122  cuts[icut].c_str(),
1123  pLimits_[lim],
1124  pLimits_[lim + 1],
1125  cuts2[kcut].c_str());
1126  h_etaCalibTracks[lim][icut][kcut] = fs_->make<TH1D>(hname, htit, 60, -30.0, 30.0);
1127  h_etaCalibTracks[lim][icut][kcut]->GetXaxis()->SetTitle("i#eta");
1128 
1129  sprintf(hname, "h_etaMipTracks%sCut%dLim%d", cuts[icut].c_str(), kcut, lim);
1130  sprintf(htit,
1131  "#eta for %s charge isolated MIP tracks (%4.1f < p < %5.1f Gev/c %s)",
1132  cuts[icut].c_str(),
1133  pLimits_[lim],
1134  pLimits_[lim + 1],
1135  cuts2[kcut].c_str());
1136  h_etaMipTracks[lim][icut][kcut] = fs_->make<TH1D>(hname, htit, 60, -30.0, 30.0);
1137  h_etaMipTracks[lim][icut][kcut]->GetXaxis()->SetTitle("i#eta");
1138  }
1139  }
1140  }
1141 
1142  std::string ecut1[3] = {"all", "HLTMatched", "HLTNotMatched"};
1143  std::string ecut2[2] = {"without", "with"};
1144  int etac[48] = {-1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15, -16,
1145  -17, -18, -19, -20, -21, -22, -23, -24, 1, 2, 3, 4, 5, 6, 7, 8,
1146  9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24};
1147  for (int icut = 0; icut < 6; icut++) {
1148  // int i1 = (icut>3 ? 1 : 0);
1149  int i1 = (icut > 2 ? 1 : 0);
1150  int i2 = icut - i1 * 3;
1151  for (int kcut = 0; kcut < 48; kcut++) {
1152  for (int lim = 0; lim < 5; ++lim) {
1153  sprintf(hname, "h_eta%dEnHcal%s%s%d", etac[kcut], ecut1[i2].c_str(), ecut2[i1].c_str(), lim);
1154  sprintf(htit,
1155  "HCAL energy for #eta=%d for %s tracks (p=%4.1f:%5.1f Gev) %s neutral isolation",
1156  etac[kcut],
1157  ecut1[i2].c_str(),
1158  pLimits_[lim],
1159  pLimits_[lim + 1],
1160  ecut2[i1].c_str());
1161  h_eHcal[lim][icut][kcut] = fs_->make<TH1D>(hname, htit, 750, 0.0, 150.0);
1162  h_eHcal[lim][icut][kcut]->GetXaxis()->SetTitle("Energy (GeV)");
1163  sprintf(hname, "h_eta%dEnCalo%s%s%d", etac[kcut], ecut1[i2].c_str(), ecut2[i1].c_str(), lim);
1164  sprintf(htit,
1165  "Calorimter energy for #eta=%d for %s tracks (p=%4.1f:%5.1f Gev) %s neutral isolation",
1166  etac[kcut],
1167  ecut1[i2].c_str(),
1168  pLimits_[lim],
1169  pLimits_[lim + 1],
1170  ecut2[i1].c_str());
1171  h_eCalo[lim][icut][kcut] = fs_->make<TH1D>(hname, htit, 750, 0.0, 150.0);
1172  h_eCalo[lim][icut][kcut]->GetXaxis()->SetTitle("Energy (GeV)");
1173  }
1174  }
1175  }
1176 }
1177 
1178 // ------------ method called once each job just after ending the event loop ------------
1179 void IsoTrig::endJob() {
1180  edm::LogWarning("IsoTrack") << trigNames_.size() << "Triggers were run. RunNo vs HLT accepts for";
1181  for (unsigned int i = 0; i < trigNames_.size(); ++i)
1182  edm::LogWarning("IsoTrack") << "[" << i << "]: " << trigNames_[i];
1183  unsigned int n = maxRunNo_ - minRunNo_ + 1;
1184  g_Pre = fs_->make<TH1D>("h_PrevsRN", "PreScale Vs Run Number", n, minRunNo_, maxRunNo_);
1185  g_PreL1 = fs_->make<TH1D>("h_PreL1vsRN", "L1 PreScale Vs Run Number", n, minRunNo_, maxRunNo_);
1186  g_PreHLT = fs_->make<TH1D>("h_PreHLTvsRN", "HLT PreScale Vs Run Number", n, minRunNo_, maxRunNo_);
1187  g_Accepts = fs_->make<TH1I>("h_HLTAcceptsvsRN", "HLT Accepts Vs Run Number", n, minRunNo_, maxRunNo_);
1188 
1189  for (auto const &[runNum, nAccept] : trigList_) {
1190  auto const &triggerPrescales = trigPreList_[runNum];
1191  auto const preL1 = triggerPrescales.first;
1192  auto const preHLT = triggerPrescales.second;
1193  edm::LogVerbatim("IsoTrack") << runNum << " " << nAccept << " " << preL1 << " " << preHLT;
1194  g_Accepts->Fill(runNum, nAccept);
1195  g_PreL1->Fill(runNum, preL1);
1196  g_PreHLT->Fill(runNum, preHLT);
1197  g_Pre->Fill(runNum, preL1 * preHLT);
1198  }
1199 }
1200 
1201 void IsoTrig::beginRun(edm::Run const &iRun, edm::EventSetup const &iSetup) {
1202  edm::LogWarning("IsoTrack") << "Run " << iRun.run() << " hltconfig.init "
1203  << hltPrescaleProvider_.init(iRun, iSetup, processName_, changed_);
1204 }
1205 
1206 void IsoTrig::StudyTrkEbyP(edm::Handle<reco::TrackCollection> &trkCollection) {
1207  t_TrkselTkFlag->clear();
1208  t_TrkqltyFlag->clear();
1209  t_TrkMissFlag->clear();
1210  t_TrkPVFlag->clear();
1211  t_TrkNuIsolFlag->clear();
1212  t_TrkhCone->clear();
1213  t_TrkP->clear();
1214 
1215  if (!trkCollection.isValid()) {
1216  edm::LogVerbatim("IsoTrack") << "trkCollection.isValid is false";
1217  } else {
1218  std::vector<spr::propagatedTrackDirection>::const_iterator trkDetItr;
1219  std::vector<spr::propagatedTrackDirection> trkCaloDirections1;
1220  spr::propagateCALO(
1221  trkCollection, geo_, bField_, theTrackQuality_, trkCaloDirections1, ((verbosity_ / 100) % 10 > 2));
1222  unsigned int nTracks = 0;
1223  int nRH_eMipDR = 0, nNearTRKs = 0;
1224  std::vector<bool> selFlags;
1225  for (trkDetItr = trkCaloDirections1.begin(); trkDetItr != trkCaloDirections1.end(); trkDetItr++, nTracks++) {
1226  double conehmaxNearP = 0, hCone = 0, eMipDR = 0.0;
1227  const reco::Track *pTrack = &(*(trkDetItr->trkItr));
1228  if (verbosity_ % 10 > 0)
1229  edm::LogVerbatim("IsoTrack") << "track no. " << nTracks << " p(): " << pTrack->p();
1230  if (pTrack->p() > 20) {
1231  math::XYZTLorentzVector v2(pTrack->px(), pTrack->py(), pTrack->pz(), pTrack->p());
1232  eMipDR = spr::eCone_ecal(geo_,
1233  barrelRecHitsHandle_,
1234  endcapRecHitsHandle_,
1235  trkDetItr->pointHCAL,
1236  trkDetItr->pointECAL,
1237  a_mipR_,
1238  trkDetItr->directionECAL,
1239  nRH_eMipDR);
1240  bool selectTk = spr::goodTrack(pTrack, leadPV_, selectionParameters_, ((verbosity_ / 100) % 10 > 1));
1241  spr::trackSelectionParameters oneCutParameters = selectionParameters_;
1242  oneCutParameters.maxDxyPV = 10;
1243  oneCutParameters.maxDzPV = 100;
1244  oneCutParameters.maxInMiss = 2;
1245  oneCutParameters.maxOutMiss = 2;
1246  bool qltyFlag = spr::goodTrack(pTrack, leadPV_, oneCutParameters, ((verbosity_ / 100) % 10 > 1));
1247  oneCutParameters = selectionParameters_;
1248  oneCutParameters.maxDxyPV = 10;
1249  oneCutParameters.maxDzPV = 100;
1250  bool qltyMissFlag = spr::goodTrack(pTrack, leadPV_, oneCutParameters, ((verbosity_ / 100) % 10 > 1));
1251  oneCutParameters = selectionParameters_;
1252  oneCutParameters.maxInMiss = 2;
1253  oneCutParameters.maxOutMiss = 2;
1254  bool qltyPVFlag = spr::goodTrack(pTrack, leadPV_, oneCutParameters, ((verbosity_ / 100) % 10 > 1));
1255  if ((verbosity_ / 1000) % 10 > 1)
1256  edm::LogVerbatim("IsoTrack") << "sel " << selectTk << "ntracks " << nTracks << " a_charIsoR " << a_charIsoR_
1257  << " nNearTRKs " << nNearTRKs;
1258  conehmaxNearP = spr::chargeIsolationCone(
1259  nTracks, trkCaloDirections1, a_charIsoR_, nNearTRKs, ((verbosity_ / 100) % 10 > 1));
1260  if ((verbosity_ / 1000) % 10 > 1)
1261  edm::LogVerbatim("IsoTrack") << "coneh " << conehmaxNearP << "ok " << trkDetItr->okECAL << " "
1262  << trkDetItr->okHCAL;
1263  double e1 = spr::eCone_ecal(geo_,
1264  barrelRecHitsHandle_,
1265  endcapRecHitsHandle_,
1266  trkDetItr->pointHCAL,
1267  trkDetItr->pointECAL,
1268  a_neutR1_,
1269  trkDetItr->directionECAL,
1270  nRH_eMipDR);
1271  double e2 = spr::eCone_ecal(geo_,
1272  barrelRecHitsHandle_,
1273  endcapRecHitsHandle_,
1274  trkDetItr->pointHCAL,
1275  trkDetItr->pointECAL,
1276  a_neutR2_,
1277  trkDetItr->directionECAL,
1278  nRH_eMipDR);
1279  double e_inCone = e2 - e1;
1280  bool chgIsolFlag = (conehmaxNearP < cutCharge_);
1281  bool mipFlag = (eMipDR < cutMip_);
1282  bool neuIsolFlag = (e_inCone < cutNeutral_);
1283  bool trkpropFlag = ((trkDetItr->okECAL) && (trkDetItr->okHCAL));
1284  selFlags.clear();
1285  selFlags.push_back(selectTk);
1286  selFlags.push_back(qltyFlag);
1287  selFlags.push_back(qltyMissFlag);
1288  selFlags.push_back(qltyPVFlag);
1289  if (verbosity_ % 10 > 0)
1290  edm::LogVerbatim("IsoTrack") << "emip: " << eMipDR << "<" << cutMip_ << "(" << mipFlag << ")"
1291  << " ; ok: " << trkDetItr->okECAL << "/" << trkDetItr->okHCAL
1292  << " ; chgiso: " << conehmaxNearP << "<" << cutCharge_ << "(" << chgIsolFlag
1293  << ")";
1294 
1295  if (chgIsolFlag && mipFlag && trkpropFlag) {
1296  double distFromHotCell = -99.0;
1297  int nRecHitsCone = -99, ietaHotCell = -99, iphiHotCell = -99;
1298  GlobalPoint gposHotCell(0., 0., 0.);
1299  std::vector<DetId> coneRecHitDetIds;
1300  hCone = spr::eCone_hcal(geo_,
1301  hbhe_,
1302  trkDetItr->pointHCAL,
1303  trkDetItr->pointECAL,
1304  a_coneR_,
1305  trkDetItr->directionHCAL,
1306  nRecHitsCone,
1307  coneRecHitDetIds,
1308  distFromHotCell,
1309  ietaHotCell,
1310  iphiHotCell,
1311  gposHotCell,
1312  -1);
1313  // push vectors into the Tree
1314  t_TrkselTkFlag->push_back(selFlags[0]);
1315  t_TrkqltyFlag->push_back(selFlags[1]);
1316  t_TrkMissFlag->push_back(selFlags[2]);
1317  t_TrkPVFlag->push_back(selFlags[3]);
1318  t_TrkNuIsolFlag->push_back(neuIsolFlag);
1319  t_TrkhCone->push_back(hCone);
1320  t_TrkP->push_back(pTrack->p());
1321  }
1322  }
1323  }
1324  if (verbosity_ % 10 > 0)
1325  edm::LogVerbatim("IsoTrack") << "Filling " << t_TrkP->size() << " tracks in TrkRestree out of " << nTracks;
1326  }
1327  TrkResTree_->Fill();
1328 }
1329 
1330 void IsoTrig::studyTiming(const edm::Event &theEvent) {
1331  t_timeL2Prod->clear();
1332  t_nPixCand->clear();
1333  t_nPixSeed->clear();
1334 
1335  if (verbosity_ % 10 > 0) {
1336  edm::Handle<SeedingLayerSetsHits> hblayers, helayers;
1337  theEvent.getByToken(tok_SeedingLayerHB_, hblayers);
1338  theEvent.getByToken(tok_SeedingLayerHE_, helayers);
1339  const SeedingLayerSetsHits *layershb = hblayers.product();
1340  const SeedingLayerSetsHits *layershe = helayers.product();
1341  edm::LogVerbatim("IsoTrack") << "size of Seeding TripletLayers hb/he " << layershb->size() << "/"
1342  << layershe->size();
1343  edm::Handle<SiPixelRecHitCollection> rchts;
1344  theEvent.getByToken(tok_SiPixelRecHits_, rchts);
1345  const SiPixelRecHitCollection *rechits = rchts.product();
1346  edm::LogVerbatim("IsoTrack") << "size of SiPixelRechits " << rechits->size();
1347  }
1348  int nCandHB = pixelTrackRefsHB_.size(), nCandHE = pixelTrackRefsHE_.size();
1349  int nSeedHB = 0, nSeedHE = 0;
1350 
1351  if (nCandHE > 0) {
1352  edm::Handle<reco::VertexCollection> pVertHB, pVertHE;
1353  theEvent.getByToken(tok_verthb_, pVertHB);
1354  theEvent.getByToken(tok_verthe_, pVertHE);
1355  edm::Handle<trigger::TriggerFilterObjectWithRefs> l1trigobj;
1356  theEvent.getByToken(tok_l1cand_, l1trigobj);
1357 
1358  std::vector<edm::Ref<l1extra::L1JetParticleCollection>> l1tauobjref;
1359  std::vector<edm::Ref<l1extra::L1JetParticleCollection>> l1jetobjref;
1360  std::vector<edm::Ref<l1extra::L1JetParticleCollection>> l1forjetobjref;
1361 
1362  l1trigobj->getObjects(trigger::TriggerL1TauJet, l1tauobjref);
1363  l1trigobj->getObjects(trigger::TriggerL1CenJet, l1jetobjref);
1364  l1trigobj->getObjects(trigger::TriggerL1ForJet, l1forjetobjref);
1365 
1366  double ptTriggered = -10;
1367  double etaTriggered = -100;
1368  double phiTriggered = -100;
1369  for (unsigned int p = 0; p < l1tauobjref.size(); p++) {
1370  if (l1tauobjref[p]->pt() > ptTriggered) {
1371  ptTriggered = l1tauobjref[p]->pt();
1372  phiTriggered = l1tauobjref[p]->phi();
1373  etaTriggered = l1tauobjref[p]->eta();
1374  }
1375  }
1376  for (unsigned int p = 0; p < l1jetobjref.size(); p++) {
1377  if (l1jetobjref[p]->pt() > ptTriggered) {
1378  ptTriggered = l1jetobjref[p]->pt();
1379  phiTriggered = l1jetobjref[p]->phi();
1380  etaTriggered = l1jetobjref[p]->eta();
1381  }
1382  }
1383  for (unsigned int p = 0; p < l1forjetobjref.size(); p++) {
1384  if (l1forjetobjref[p]->pt() > ptTriggered) {
1385  ptTriggered = l1forjetobjref[p]->pt();
1386  phiTriggered = l1forjetobjref[p]->phi();
1387  etaTriggered = l1forjetobjref[p]->eta();
1388  }
1389  }
1390  for (unsigned iS = 0; iS < pixelTrackRefsHE_.size(); iS++) {
1391  reco::VertexCollection::const_iterator vitSel;
1392  double minDZ = 100;
1393  bool vtxMatch;
1394  for (reco::VertexCollection::const_iterator vit = pVertHE->begin(); vit != pVertHE->end(); vit++) {
1395  if (fabs(pixelTrackRefsHE_[iS]->dz(vit->position())) < minDZ) {
1396  minDZ = fabs(pixelTrackRefsHE_[iS]->dz(vit->position()));
1397  vitSel = vit;
1398  }
1399  }
1400  //cut on dYX:
1401  if ((fabs(pixelTrackRefsHE_[iS]->dxy(vitSel->position())) < vtxCutSeed_) || (minDZ == 100))
1402  vtxMatch = true;
1403 
1404  //select tracks not matched to triggered L1 jet
1405  double R = deltaR(etaTriggered, phiTriggered, pixelTrackRefsHE_[iS]->eta(), pixelTrackRefsHE_[iS]->phi());
1406  if (R > tauUnbiasCone_ && vtxMatch)
1407  nSeedHE++;
1408  }
1409  for (unsigned iS = 0; iS < pixelTrackRefsHB_.size(); iS++) {
1410  reco::VertexCollection::const_iterator vitSel;
1411  double minDZ = 100;
1412  bool vtxMatch(false);
1413  for (reco::VertexCollection::const_iterator vit = pVertHB->begin(); vit != pVertHB->end(); vit++) {
1414  if (fabs(pixelTrackRefsHB_[iS]->dz(vit->position())) < minDZ) {
1415  minDZ = fabs(pixelTrackRefsHB_[iS]->dz(vit->position()));
1416  vitSel = vit;
1417  }
1418  }
1419  //cut on dYX:
1420  if ((fabs(pixelTrackRefsHB_[iS]->dxy(vitSel->position())) < 101.0) || (minDZ == 100))
1421  vtxMatch = true;
1422 
1423  //select tracks not matched to triggered L1 jet
1424  double R = deltaR(etaTriggered, phiTriggered, pixelTrackRefsHB_[iS]->eta(), pixelTrackRefsHB_[iS]->phi());
1425  if (R > 1.2 && vtxMatch)
1426  nSeedHB++;
1427  }
1428 
1429  if (verbosity_ % 10 > 0) {
1430  edm::LogVerbatim("IsoTrack") << "(HB/HE) nCand: " << nCandHB << "/" << nCandHE << "nSeed: " << nSeedHB << "/"
1431  << nSeedHE;
1432  }
1433  }
1434  t_nPixSeed->push_back(nSeedHB);
1435  t_nPixSeed->push_back(nSeedHE);
1436  t_nPixCand->push_back(nCandHB);
1437  t_nPixCand->push_back(nCandHE);
1438 
1439  TimingTree_->Fill();
1440 }
1441 void IsoTrig::studyMipCut(edm::Handle<reco::TrackCollection> &trkCollection,
1442  edm::Handle<reco::IsolatedPixelTrackCandidateCollection> &L2cands) {
1443  clearMipCutTreeVectors();
1444  if (verbosity_ % 10 > 0)
1445  edm::LogVerbatim("IsoTrack") << "inside studymipcut";
1446  if (!trkCollection.isValid()) {
1447  edm::LogWarning("IsoTrack") << "trkCollection.isValid is false";
1448  } else {
1449  std::vector<spr::propagatedTrackDirection>::const_iterator trkDetItr;
1450  std::vector<spr::propagatedTrackDirection> trkCaloDirections1;
1451  spr::propagateCALO(
1452  trkCollection, geo_, bField_, theTrackQuality_, trkCaloDirections1, ((verbosity_ / 100) % 10 > 2));
1453  if (verbosity_ % 10 > 0)
1454  edm::LogVerbatim("IsoTrack") << "Number of L2cands:" << L2cands->size() << " to be matched to something out of "
1455  << trkCaloDirections1.size() << " reco tracks";
1456  for (unsigned int i = 0; i < L2cands->size(); i++) {
1457  edm::Ref<reco::IsolatedPixelTrackCandidateCollection> candref =
1458  edm::Ref<reco::IsolatedPixelTrackCandidateCollection>(L2cands, i);
1459  double enIn = candref->energyIn();
1460  h_EnIn->Fill(candref->energyIn());
1461  h_EnOut->Fill(candref->energyOut());
1462  math::XYZTLorentzVector v1(
1463  candref->track()->px(), candref->track()->py(), candref->track()->pz(), candref->track()->p());
1464  if (verbosity_ % 10 > 1)
1465  edm::LogVerbatim("IsoTrack") << "HLT Level Candidate eta/phi/pt/enIn:" << candref->track()->eta() << "/"
1466  << candref->track()->phi() << "/" << candref->track()->pt() << "/"
1467  << candref->energyIn();
1468  math::XYZTLorentzVector mindRvec;
1469  double mindR = 999.9, mindP1 = 999.9, eMipDR = 0.0;
1470  std::vector<bool> selFlags;
1471  unsigned int nTracks = 0;
1472  double conehmaxNearP = 0, hCone = 0;
1473  for (trkDetItr = trkCaloDirections1.begin(); trkDetItr != trkCaloDirections1.end(); trkDetItr++, nTracks++) {
1474  const reco::Track *pTrack = &(*(trkDetItr->trkItr));
1475  math::XYZTLorentzVector v2(pTrack->px(), pTrack->py(), pTrack->pz(), pTrack->p());
1476  double dr = dR(v1, v2);
1477  double dp1 = std::abs(1. / v1.r() - 1. / v2.r());
1478  if (verbosity_ % 1000 > 0)
1479  edm::LogVerbatim("IsoTrack") << "This recotrack(eta/phi/pt) " << pTrack->eta() << "/" << pTrack->phi() << "/"
1480  << pTrack->pt() << " has dr/dp= " << dr << "/" << dp1;
1481  if (dr < mindR) {
1482  mindR = dr;
1483  mindP1 = dp1;
1484  mindRvec = v2;
1485  int nRH_eMipDR = 0, nNearTRKs = 0;
1486  eMipDR = spr::eCone_ecal(geo_,
1487  barrelRecHitsHandle_,
1488  endcapRecHitsHandle_,
1489  trkDetItr->pointHCAL,
1490  trkDetItr->pointECAL,
1491  a_mipR_,
1492  trkDetItr->directionECAL,
1493  nRH_eMipDR);
1494  bool selectTk = spr::goodTrack(pTrack, leadPV_, selectionParameters_, ((verbosity_ / 100) % 10 > 1));
1495  spr::trackSelectionParameters oneCutParameters = selectionParameters_;
1496  oneCutParameters.maxDxyPV = 10;
1497  oneCutParameters.maxDzPV = 100;
1498  oneCutParameters.maxInMiss = 2;
1499  oneCutParameters.maxOutMiss = 2;
1500  bool qltyFlag = spr::goodTrack(pTrack, leadPV_, oneCutParameters, ((verbosity_ / 100) % 10 > 1));
1501  oneCutParameters = selectionParameters_;
1502  oneCutParameters.maxDxyPV = 10;
1503  oneCutParameters.maxDzPV = 100;
1504  bool qltyMissFlag = spr::goodTrack(pTrack, leadPV_, oneCutParameters, ((verbosity_ / 100) % 10 > 1));
1505  oneCutParameters = selectionParameters_;
1506  oneCutParameters.maxInMiss = 2;
1507  oneCutParameters.maxOutMiss = 2;
1508  bool qltyPVFlag = spr::goodTrack(pTrack, leadPV_, oneCutParameters, ((verbosity_ / 100) % 10 > 1));
1509  conehmaxNearP = spr::chargeIsolationCone(
1510  nTracks, trkCaloDirections1, a_charIsoR_, nNearTRKs, ((verbosity_ / 100) % 10 > 1));
1511  double e1 = spr::eCone_ecal(geo_,
1512  barrelRecHitsHandle_,
1513  endcapRecHitsHandle_,
1514  trkDetItr->pointHCAL,
1515  trkDetItr->pointECAL,
1516  a_neutR1_,
1517  trkDetItr->directionECAL,
1518  nRH_eMipDR);
1519  double e2 = spr::eCone_ecal(geo_,
1520  barrelRecHitsHandle_,
1521  endcapRecHitsHandle_,
1522  trkDetItr->pointHCAL,
1523  trkDetItr->pointECAL,
1524  a_neutR2_,
1525  trkDetItr->directionECAL,
1526  nRH_eMipDR);
1527  double e_inCone = e2 - e1;
1528  bool chgIsolFlag = (conehmaxNearP < cutCharge_);
1529  bool mipFlag = (eMipDR < cutMip_);
1530  bool neuIsolFlag = (e_inCone < cutNeutral_);
1531  bool trkpropFlag = ((trkDetItr->okECAL) && (trkDetItr->okHCAL));
1532  selFlags.clear();
1533  selFlags.push_back(selectTk);
1534  selFlags.push_back(qltyFlag);
1535  selFlags.push_back(qltyMissFlag);
1536  selFlags.push_back(qltyPVFlag);
1537  selFlags.push_back(trkpropFlag);
1538  selFlags.push_back(chgIsolFlag);
1539  selFlags.push_back(neuIsolFlag);
1540  selFlags.push_back(mipFlag);
1541  double distFromHotCell = -99.0;
1542  int nRecHitsCone = -99, ietaHotCell = -99, iphiHotCell = -99;
1543  GlobalPoint gposHotCell(0., 0., 0.);
1544  std::vector<DetId> coneRecHitDetIds;
1545  hCone = spr::eCone_hcal(geo_,
1546  hbhe_,
1547  trkDetItr->pointHCAL,
1548  trkDetItr->pointECAL,
1549  a_coneR_,
1550  trkDetItr->directionHCAL,
1551  nRecHitsCone,
1552  coneRecHitDetIds,
1553  distFromHotCell,
1554  ietaHotCell,
1555  iphiHotCell,
1556  gposHotCell,
1557  -1);
1558  }
1559  }
1560  pushMipCutTreeVecs(v1, mindRvec, enIn, eMipDR, mindR, mindP1, selFlags, hCone);
1561  fillDifferences(6, v1, mindRvec, (verbosity_ % 10 > 0));
1562  if (mindR >= 0.05) {
1563  fillDifferences(8, v1, mindRvec, (verbosity_ % 10 > 0));
1564  h_MipEnNoMatch->Fill(candref->energyIn(), eMipDR);
1565  } else {
1566  fillDifferences(7, v1, mindRvec, (verbosity_ % 10 > 0));
1567  h_MipEnMatch->Fill(candref->energyIn(), eMipDR);
1568  }
1569  }
1570  }
1571  MipCutTree_->Fill();
1572 }
1573 
1574 void IsoTrig::studyTrigger(edm::Handle<reco::TrackCollection> &trkCollection,
1575  std::vector<reco::TrackCollection::const_iterator> &goodTks) {
1576  if (verbosity_ % 10 > 0)
1577  edm::LogVerbatim("IsoTrack") << "Inside StudyTrigger";
1579  for (int j = 0; j < 3; j++) {
1580  for (unsigned int k = 0; k < vec_[j].size(); k++) {
1581  if (verbosity_ % 10 > 0)
1582  edm::LogVerbatim("IsoTrack") << "vec[" << j << "][" << k << "] pt " << vec_[j][k].pt() << " eta "
1583  << vec_[j][k].eta() << " phi " << vec_[j][k].phi();
1584  fillHist(j, vec_[j][k]);
1585  }
1586  }
1587 
1588  double deta, dphi, dr;
1590  for (int lvl = 1; lvl < 3; lvl++) {
1591  for (unsigned int i = 0; i < vec_[lvl].size(); i++) {
1592  deta = dEta(vec_[0][0], vec_[lvl][i]);
1593  dphi = dPhi(vec_[0][0], vec_[lvl][i]);
1594  dr = dR(vec_[0][0], vec_[lvl][i]);
1595  if (verbosity_ % 10 > 1)
1596  edm::LogVerbatim("IsoTrack") << "lvl " << lvl << " i " << i << " deta " << deta << " dphi " << dphi << " dR "
1597  << dr;
1598  h_dEtaL1[lvl - 1]->Fill(deta);
1599  h_dPhiL1[lvl - 1]->Fill(dphi);
1600  h_dRL1[lvl - 1]->Fill(std::sqrt(dr));
1601  }
1602  }
1603 
1604  math::XYZTLorentzVector mindRvec;
1605  double mindR;
1606  for (unsigned int k = 0; k < vec_[2].size(); ++k) {
1608  mindR = 999.9;
1609  if (verbosity_ % 10 > 1)
1610  edm::LogVerbatim("IsoTrack") << "L3obj: pt " << vec_[2][k].pt() << " eta " << vec_[2][k].eta() << " phi "
1611  << vec_[2][k].phi();
1612  for (unsigned int j = 0; j < vec_[1].size(); j++) {
1613  dr = dR(vec_[2][k], vec_[1][j]);
1614  if (dr < mindR) {
1615  mindR = dr;
1616  mindRvec = vec_[1][j];
1617  }
1618  }
1619  fillDifferences(0, vec_[2][k], mindRvec, (verbosity_ % 10 > 0));
1620  if (mindR < 0.03) {
1621  fillDifferences(1, vec_[2][k], mindRvec, (verbosity_ % 10 > 0));
1622  fillHist(6, mindRvec);
1623  fillHist(8, vec_[2][k]);
1624  } else {
1625  fillDifferences(2, vec_[2][k], mindRvec, (verbosity_ % 10 > 0));
1626  fillHist(7, mindRvec);
1627  fillHist(9, vec_[2][k]);
1628  }
1629 
1631  mindR = 999.9;
1632  if (verbosity_ % 10 > 0)
1633  edm::LogVerbatim("IsoTrack") << "Now Matching L3 track with reco: L3 Track (eta, phi) " << vec_[2][k].eta() << ":"
1634  << vec_[2][k].phi() << " L2 Track " << mindRvec.eta() << ":" << mindRvec.phi()
1635  << " dR " << mindR;
1636  reco::TrackCollection::const_iterator goodTk = trkCollection->end();
1637  if (trkCollection.isValid()) {
1638  double mindP(9999.9);
1639  reco::TrackCollection::const_iterator trkItr;
1640  for (trkItr = trkCollection->begin(); trkItr != trkCollection->end(); trkItr++) {
1641  math::XYZTLorentzVector v4(trkItr->px(), trkItr->py(), trkItr->pz(), trkItr->p());
1642  double deltaR = dR(v4, vec_[2][k]);
1643  double dp = std::abs(v4.r() / vec_[2][k].r() - 1.0);
1644  if (deltaR < mindR) {
1645  mindR = deltaR;
1646  mindP = dp;
1647  mindRvec = v4;
1648  goodTk = trkItr;
1649  }
1650  if ((verbosity_ / 10) % 10 > 1 && deltaR < 1.0)
1651  edm::LogVerbatim("IsoTrack") << "reco track: pt " << v4.pt() << " eta " << v4.eta() << " phi " << v4.phi()
1652  << " DR " << deltaR;
1653  }
1654  if (verbosity_ % 10 > 0)
1655  edm::LogVerbatim("IsoTrack") << "Now Matching at Reco level in step 1 DR: " << mindR << ":" << mindP
1656  << " eta:phi " << mindRvec.eta() << ":" << mindRvec.phi();
1657  if (mindR < 0.03 && mindP > 0.1) {
1658  for (trkItr = trkCollection->begin(); trkItr != trkCollection->end(); trkItr++) {
1659  math::XYZTLorentzVector v4(trkItr->px(), trkItr->py(), trkItr->pz(), trkItr->p());
1660  double deltaR = dR(v4, vec_[2][k]);
1661  double dp = std::abs(v4.r() / vec_[2][k].r() - 1.0);
1662  if (dp < mindP && deltaR < 0.03) {
1663  mindR = deltaR;
1664  mindP = dp;
1665  mindRvec = v4;
1666  goodTk = trkItr;
1667  }
1668  }
1669  if (verbosity_ % 10 > 0)
1670  edm::LogVerbatim("IsoTrack") << "Now Matching at Reco level in step 2 DR: " << mindR << ":" << mindP
1671  << " eta:phi " << mindRvec.eta() << ":" << mindRvec.phi();
1672  }
1673  fillDifferences(3, vec_[2][k], mindRvec, (verbosity_ % 10 > 0));
1674  fillHist(3, mindRvec);
1675  if (mindR < 0.03) {
1676  fillDifferences(4, vec_[2][k], mindRvec, (verbosity_ % 10 > 0));
1677  fillHist(4, mindRvec);
1678  } else {
1679  fillDifferences(5, vec_[2][k], mindRvec, (verbosity_ % 10 > 0));
1680  fillHist(5, mindRvec);
1681  }
1682  if (goodTk != trkCollection->end())
1683  goodTks.push_back(goodTk);
1684  }
1685  }
1686 }
1687 
1688 void IsoTrig::studyIsolation(edm::Handle<reco::TrackCollection> &trkCollection,
1689  std::vector<reco::TrackCollection::const_iterator> &goodTks) {
1690  if (trkCollection.isValid()) {
1691  std::vector<spr::propagatedTrackDirection> trkCaloDirections;
1692  spr::propagateCALO(
1693  trkCollection, geo_, bField_, theTrackQuality_, trkCaloDirections, ((verbosity_ / 100) % 10 > 2));
1694 
1695  std::vector<spr::propagatedTrackDirection>::const_iterator trkDetItr;
1696  if ((verbosity_ / 1000) % 10 > 1) {
1697  edm::LogVerbatim("IsoTrack") << "n of barrelRecHitsHandle " << barrelRecHitsHandle_->size();
1698  for (EcalRecHitCollection::const_iterator hit = barrelRecHitsHandle_->begin(); hit != barrelRecHitsHandle_->end();
1699  ++hit) {
1700  edm::LogVerbatim("IsoTrack") << "hit : detid(ieta,iphi) " << (EBDetId)(hit->id()) << " time " << hit->time()
1701  << " energy " << hit->energy();
1702  }
1703  edm::LogVerbatim("IsoTrack") << "n of endcapRecHitsHandle " << endcapRecHitsHandle_->size();
1704  for (EcalRecHitCollection::const_iterator hit = endcapRecHitsHandle_->begin(); hit != endcapRecHitsHandle_->end();
1705  ++hit) {
1706  edm::LogVerbatim("IsoTrack") << "hit : detid(ieta,iphi) " << (EEDetId)(hit->id()) << " time " << hit->time()
1707  << " energy " << hit->energy();
1708  }
1709  edm::LogVerbatim("IsoTrack") << "n of hbhe " << hbhe_->size();
1710  for (HBHERecHitCollection::const_iterator hit = hbhe_->begin(); hit != hbhe_->end(); ++hit) {
1711  edm::LogVerbatim("IsoTrack") << "hit : detid(ieta,iphi) " << hit->id() << " time " << hit->time() << " energy "
1712  << hit->energy();
1713  }
1714  }
1715  unsigned int nTracks = 0, ngoodTk = 0, nselTk = 0;
1716  int ieta = 999;
1717  for (trkDetItr = trkCaloDirections.begin(); trkDetItr != trkCaloDirections.end(); trkDetItr++, nTracks++) {
1718  bool l3Track = (std::find(goodTks.begin(), goodTks.end(), trkDetItr->trkItr) != goodTks.end());
1719  const reco::Track *pTrack = &(*(trkDetItr->trkItr));
1720  math::XYZTLorentzVector v4(pTrack->px(), pTrack->py(), pTrack->pz(), pTrack->p());
1721  bool selectTk = spr::goodTrack(pTrack, leadPV_, selectionParameters_, ((verbosity_ / 100) % 10 > 1));
1722  double eMipDR = 9999., e_inCone = 0, conehmaxNearP = 0, mindR = 999.9, hCone = 0;
1723  if (trkDetItr->okHCAL) {
1724  HcalDetId detId = (HcalDetId)(trkDetItr->detIdHCAL);
1725  ieta = detId.ieta();
1726  }
1727  for (unsigned k = 0; k < vec_[0].size(); ++k) {
1728  double deltaR = dR(v4, vec_[0][k]);
1729  if (deltaR < mindR)
1730  mindR = deltaR;
1731  }
1732  if ((verbosity_ / 100) % 10 > 1)
1733  edm::LogVerbatim("IsoTrack") << "Track ECAL " << trkDetItr->okECAL << " HCAL " << trkDetItr->okHCAL << " Flag "
1734  << selectTk;
1735  if (selectTk && trkDetItr->okECAL && trkDetItr->okHCAL) {
1736  ngoodTk++;
1737  int nRH_eMipDR = 0, nNearTRKs = 0;
1738  double e1 = spr::eCone_ecal(geo_,
1739  barrelRecHitsHandle_,
1740  endcapRecHitsHandle_,
1741  trkDetItr->pointHCAL,
1742  trkDetItr->pointECAL,
1743  a_neutR1_,
1744  trkDetItr->directionECAL,
1745  nRH_eMipDR);
1746  double e2 = spr::eCone_ecal(geo_,
1747  barrelRecHitsHandle_,
1748  endcapRecHitsHandle_,
1749  trkDetItr->pointHCAL,
1750  trkDetItr->pointECAL,
1751  a_neutR2_,
1752  trkDetItr->directionECAL,
1753  nRH_eMipDR);
1754  eMipDR = spr::eCone_ecal(geo_,
1755  barrelRecHitsHandle_,
1756  endcapRecHitsHandle_,
1757  trkDetItr->pointHCAL,
1758  trkDetItr->pointECAL,
1759  a_mipR_,
1760  trkDetItr->directionECAL,
1761  nRH_eMipDR);
1762  conehmaxNearP =
1763  spr::chargeIsolationCone(nTracks, trkCaloDirections, a_charIsoR_, nNearTRKs, ((verbosity_ / 100) % 10 > 1));
1764  e_inCone = e2 - e1;
1765  double distFromHotCell = -99.0;
1766  int nRecHitsCone = -99, ietaHotCell = -99, iphiHotCell = -99;
1767  GlobalPoint gposHotCell(0., 0., 0.);
1768  std::vector<DetId> coneRecHitDetIds;
1769  hCone = spr::eCone_hcal(geo_,
1770  hbhe_,
1771  trkDetItr->pointHCAL,
1772  trkDetItr->pointECAL,
1773  a_coneR_,
1774  trkDetItr->directionHCAL,
1775  nRecHitsCone,
1776  coneRecHitDetIds,
1777  distFromHotCell,
1778  ietaHotCell,
1779  iphiHotCell,
1780  gposHotCell,
1781  -1);
1782  if (eMipDR < 1.0)
1783  nselTk++;
1784  }
1785  if (l3Track) {
1786  fillHist(10, v4);
1787  if (selectTk) {
1788  fillHist(11, v4);
1789  fillCuts(0, eMipDR, conehmaxNearP, e_inCone, v4, ieta, (mindR > dr_L1_));
1790  if (conehmaxNearP < cutCharge_) {
1791  fillHist(12, v4);
1792  if (eMipDR < cutMip_) {
1793  fillHist(13, v4);
1794  fillEnergy(1, ieta, hCone, eMipDR, v4);
1795  fillEnergy(0, ieta, hCone, eMipDR, v4);
1796  if (e_inCone < cutNeutral_) {
1797  fillHist(14, v4);
1798  fillEnergy(4, ieta, hCone, eMipDR, v4);
1799  fillEnergy(3, ieta, hCone, eMipDR, v4);
1800  }
1801  }
1802  }
1803  }
1804  } else if (doL2L3_) {
1805  fillHist(15, v4);
1806  if (selectTk) {
1807  fillHist(16, v4);
1808  fillCuts(1, eMipDR, conehmaxNearP, e_inCone, v4, ieta, (mindR > dr_L1_));
1809  if (conehmaxNearP < cutCharge_) {
1810  fillHist(17, v4);
1811  if (eMipDR < cutMip_) {
1812  fillHist(18, v4);
1813  fillEnergy(2, ieta, hCone, eMipDR, v4);
1814  fillEnergy(0, ieta, hCone, eMipDR, v4);
1815  if (e_inCone < cutNeutral_) {
1816  fillHist(19, v4);
1817  fillEnergy(5, ieta, hCone, eMipDR, v4);
1818  fillEnergy(3, ieta, hCone, eMipDR, v4);
1819  }
1820  }
1821  }
1822  }
1823  }
1824  }
1825  // edm::LogVerbatim("IsoTrack") << "Number of tracks selected offline " << nselTk;
1826  }
1827 }
1828 
1829 void IsoTrig::chgIsolation(double &etaTriggered,
1830  double &phiTriggered,
1831  edm::Handle<reco::TrackCollection> &trkCollection,
1832  const edm::Event &theEvent) {
1833  clearChgIsolnTreeVectors();
1834  if (verbosity_ % 10 > 0)
1835  edm::LogVerbatim("IsoTrack") << "Inside chgIsolation() with eta/phi Triggered: " << etaTriggered << "/"
1836  << phiTriggered;
1837  std::vector<double> maxP;
1838 
1839  std::vector<spr::propagatedTrackDirection>::const_iterator trkDetItr;
1840  std::vector<spr::propagatedTrackDirection> trkCaloDirections1;
1841  spr::propagateCALO(trkCollection, geo_, bField_, theTrackQuality_, trkCaloDirections1, ((verbosity_ / 100) % 10 > 2));
1842  if (verbosity_ % 10 > 0)
1843  edm::LogVerbatim("IsoTrack") << "Propagated TrkCollection";
1844  for (unsigned int k = 0; k < pixelIsolationConeSizeAtEC_.size(); ++k)
1845  maxP.push_back(0);
1846  unsigned i = pixelTrackRefsHE_.size();
1847  std::vector<std::pair<unsigned int, std::pair<double, double>>> VecSeedsatEC;
1848  //loop to select isolated tracks
1849  for (unsigned iS = 0; iS < pixelTrackRefsHE_.size(); iS++) {
1850  if (pixelTrackRefsHE_[iS]->p() > minPTrackValue_) {
1851  bool vtxMatch = false;
1852  //associate to vertex (in Z)
1853  unsigned int ivSel = recVtxs_->size();
1854  double minDZ = 100;
1855  for (unsigned int iv = 0; iv < recVtxs_->size(); ++iv) {
1856  if (fabs(pixelTrackRefsHE_[iS]->dz((*recVtxs_)[iv].position())) < minDZ) {
1857  minDZ = fabs(pixelTrackRefsHE_[iS]->dz((*recVtxs_)[iv].position()));
1858  ivSel = iv;
1859  }
1860  }
1861  //cut on dYX:
1862  if (ivSel == recVtxs_->size()) {
1863  vtxMatch = true;
1864  } else if (fabs(pixelTrackRefsHE_[iS]->dxy((*recVtxs_)[ivSel].position())) < vtxCutSeed_) {
1865  vtxMatch = true;
1866  }
1867  //select tracks not matched to triggered L1 jet
1868  double R = deltaR(etaTriggered, phiTriggered, pixelTrackRefsHE_[iS]->eta(), pixelTrackRefsHE_[iS]->phi());
1869  if (R > tauUnbiasCone_ && vtxMatch) {
1870  //propagate seed track to ECAL surface:
1871  std::pair<double, double> seedCooAtEC;
1872  // in case vertex is found:
1873  if (minDZ != 100)
1874  seedCooAtEC = GetEtaPhiAtEcal(pixelTrackRefsHE_[iS]->eta(),
1875  pixelTrackRefsHE_[iS]->phi(),
1876  pixelTrackRefsHE_[iS]->pt(),
1877  pixelTrackRefsHE_[iS]->charge(),
1878  (*recVtxs_)[ivSel].z());
1879  //in case vertex is not found:
1880  else
1881  seedCooAtEC = GetEtaPhiAtEcal(pixelTrackRefsHE_[iS]->eta(),
1882  pixelTrackRefsHE_[iS]->phi(),
1883  pixelTrackRefsHE_[iS]->pt(),
1884  pixelTrackRefsHE_[iS]->charge(),
1885  0);
1886  VecSeedsatEC.push_back(std::make_pair(iS, seedCooAtEC));
1887  }
1888  }
1889  }
1890  for (unsigned int l = 0; l < VecSeedsatEC.size(); l++) {
1891  unsigned int iSeed = VecSeedsatEC[l].first;
1892  math::XYZTLorentzVector v1(pixelTrackRefsHE_[iSeed]->px(),
1893  pixelTrackRefsHE_[iSeed]->py(),
1894  pixelTrackRefsHE_[iSeed]->pz(),
1895  pixelTrackRefsHE_[iSeed]->p());
1896 
1897  for (unsigned int j = 0; j < VecSeedsatEC.size(); j++) {
1898  unsigned int iSurr = VecSeedsatEC[j].first;
1899  if (iSeed != iSurr) {
1900  //define preliminary cone around seed track impact point from which tracks will be extrapolated:
1901  // edm::Ref<reco::IsolatedPixelTrackCandidateCollection> cand2ref =
1902  // edm::Ref<reco::IsolatedPixelTrackCandidateCollection>(L2cands, iSurr);
1903  if (deltaR(pixelTrackRefsHE_[iSeed]->eta(),
1904  pixelTrackRefsHE_[iSeed]->phi(),
1905  pixelTrackRefsHE_[iSurr]->eta(),
1906  pixelTrackRefsHE_[iSurr]->phi()) < prelimCone_) {
1907  unsigned int ivSel = recVtxs_->size();
1908  double minDZ2 = 100;
1909  for (unsigned int iv = 0; iv < recVtxs_->size(); ++iv) {
1910  if (fabs(pixelTrackRefsHE_[iSurr]->dz((*recVtxs_)[iv].position())) < minDZ2) {
1911  minDZ2 = fabs(pixelTrackRefsHE_[iSurr]->dz((*recVtxs_)[iv].position()));
1912  ivSel = iv;
1913  }
1914  }
1915  //cut ot dXY:
1916  if (minDZ2 == 100 || fabs(pixelTrackRefsHE_[iSurr]->dxy((*recVtxs_)[ivSel].position())) < vtxCutIsol_) {
1917  //calculate distance at ECAL surface and update isolation:
1918  double dist = getDistInCM(VecSeedsatEC[i].second.first,
1919  VecSeedsatEC[i].second.second,
1920  VecSeedsatEC[j].second.first,
1921  VecSeedsatEC[j].second.second);
1922  for (unsigned int k = 0; k < pixelIsolationConeSizeAtEC_.size(); ++k) {
1923  if (dist < pixelIsolationConeSizeAtEC_[k]) {
1924  if (pixelTrackRefsHE_[iSurr]->p() > maxP[k])
1925  maxP[k] = pixelTrackRefsHE_[iSurr]->p();
1926  }
1927  }
1928  }
1929  }
1930  }
1931  }
1932 
1933  double conehmaxNearP = -1;
1934  bool selectTk = false;
1935  double mindR = 999.9;
1936  int nTracks = 0;
1937  math::XYZTLorentzVector mindRvec;
1938  for (trkDetItr = trkCaloDirections1.begin(); trkDetItr != trkCaloDirections1.end(); trkDetItr++, nTracks++) {
1939  int nNearTRKs = 0;
1940  const reco::Track *pTrack = &(*(trkDetItr->trkItr));
1941  math::XYZTLorentzVector v2(pTrack->px(), pTrack->py(), pTrack->pz(), pTrack->p());
1942  double dr = dR(v1, v2);
1943  if (dr < mindR) {
1944  selectTk = spr::goodTrack(pTrack, leadPV_, selectionParameters_, ((verbosity_ / 100) % 10 > 1));
1945  conehmaxNearP = spr::chargeIsolationCone(
1946  nTracks, trkCaloDirections1, a_charIsoR_, nNearTRKs, ((verbosity_ / 100) % 10 > 1));
1947  mindR = dr;
1948  mindRvec = v2;
1949  }
1950  }
1951  pushChgIsolnTreeVecs(v1, mindRvec, maxP, conehmaxNearP, selectTk);
1952  }
1953  ChgIsolnTree_->Fill();
1954 }
1955 
1956 void IsoTrig::getGoodTracks(const edm::Event &iEvent, edm::Handle<reco::TrackCollection> &trkCollection) {
1957  t_nGoodTk->clear();
1958  std::vector<int> nGood(4, 0);
1959  if (trkCollection.isValid()) {
1960  std::vector<spr::propagatedTrackDirection> trkCaloDirections;
1961  spr::propagateCALO(
1962  trkCollection, geo_, bField_, theTrackQuality_, trkCaloDirections, ((verbosity_ / 100) % 10 > 2));
1963 
1964  // get the trigger jet
1965  edm::Handle<trigger::TriggerFilterObjectWithRefs> l1trigobj;
1966  iEvent.getByToken(tok_l1cand_, l1trigobj);
1967 
1968  std::vector<edm::Ref<l1extra::L1JetParticleCollection>> l1tauobjref;
1969  l1trigobj->getObjects(trigger::TriggerL1TauJet, l1tauobjref);
1970  std::vector<edm::Ref<l1extra::L1JetParticleCollection>> l1jetobjref;
1971  l1trigobj->getObjects(trigger::TriggerL1CenJet, l1jetobjref);
1972  std::vector<edm::Ref<l1extra::L1JetParticleCollection>> l1forjetobjref;
1973  l1trigobj->getObjects(trigger::TriggerL1ForJet, l1forjetobjref);
1974 
1975  double ptTriggered(-10), etaTriggered(-100), phiTriggered(-100);
1976  for (unsigned int p = 0; p < l1tauobjref.size(); p++) {
1977  if (l1tauobjref[p]->pt() > ptTriggered) {
1978  ptTriggered = l1tauobjref[p]->pt();
1979  phiTriggered = l1tauobjref[p]->phi();
1980  etaTriggered = l1tauobjref[p]->eta();
1981  }
1982  }
1983  for (unsigned int p = 0; p < l1jetobjref.size(); p++) {
1984  if (l1jetobjref[p]->pt() > ptTriggered) {
1985  ptTriggered = l1jetobjref[p]->pt();
1986  phiTriggered = l1jetobjref[p]->phi();
1987  etaTriggered = l1jetobjref[p]->eta();
1988  }
1989  }
1990  for (unsigned int p = 0; p < l1forjetobjref.size(); p++) {
1991  if (l1forjetobjref[p]->pt() > ptTriggered) {
1992  ptTriggered = l1forjetobjref[p]->pt();
1993  phiTriggered = l1forjetobjref[p]->phi();
1994  etaTriggered = l1forjetobjref[p]->eta();
1995  }
1996  }
1997  double pTriggered = ptTriggered * cosh(etaTriggered);
1998  math::XYZTLorentzVector pTrigger(
1999  ptTriggered * cos(phiTriggered), ptTriggered * sin(phiTriggered), pTriggered * tanh(etaTriggered), pTriggered);
2000 
2001  std::vector<spr::propagatedTrackDirection>::const_iterator trkDetItr;
2002  unsigned int nTracks(0);
2003  for (trkDetItr = trkCaloDirections.begin(); trkDetItr != trkCaloDirections.end(); trkDetItr++, nTracks++) {
2004  const reco::Track *pTrack = &(*(trkDetItr->trkItr));
2005  math::XYZTLorentzVector v4(pTrack->px(), pTrack->py(), pTrack->pz(), pTrack->p());
2006  bool selectTk = spr::goodTrack(pTrack, leadPV_, selectionParameters_, ((verbosity_ / 100) % 10 > 1));
2007  double mindR = dR(v4, pTrigger);
2008  if ((verbosity_ / 100) % 10 > 1)
2009  edm::LogVerbatim("IsoTrack") << "Track ECAL " << trkDetItr->okECAL << " HCAL " << trkDetItr->okHCAL << " Flag "
2010  << selectTk;
2011  if (selectTk && trkDetItr->okECAL && trkDetItr->okHCAL && mindR > 1.0) {
2012  int nRH_eMipDR(0), nNearTRKs(0);
2013  double eMipDR = spr::eCone_ecal(geo_,
2014  barrelRecHitsHandle_,
2015  endcapRecHitsHandle_,
2016  trkDetItr->pointHCAL,
2017  trkDetItr->pointECAL,
2018  a_mipR_,
2019  trkDetItr->directionECAL,
2020  nRH_eMipDR);
2021  double conehmaxNearP =
2022  spr::chargeIsolationCone(nTracks, trkCaloDirections, a_charIsoR_, nNearTRKs, ((verbosity_ / 100) % 10 > 1));
2023  if (conehmaxNearP < 2.0 && eMipDR < 1.0) {
2024  if (pTrack->p() >= 20 && pTrack->p() < 30) {
2025  ++nGood[0];
2026  } else if (pTrack->p() >= 30 && pTrack->p() < 40) {
2027  ++nGood[1];
2028  } else if (pTrack->p() >= 40 && pTrack->p() < 60) {
2029  ++nGood[2];
2030  } else if (pTrack->p() >= 60 && pTrack->p() < 100) {
2031  ++nGood[3];
2032  }
2033  }
2034  }
2035  }
2036  }
2037 
2038  for (unsigned int ii = 0; ii < nGood.size(); ++ii)
2039  t_nGoodTk->push_back(nGood[ii]);
2040 }
2041 
2042 void IsoTrig::fillHist(int indx, math::XYZTLorentzVector &vec) {
2043  h_p[indx]->Fill(vec.r());
2044  h_pt[indx]->Fill(vec.pt());
2045  h_eta[indx]->Fill(vec.eta());
2046  h_phi[indx]->Fill(vec.phi());
2047 }
2048 
2049 void IsoTrig::fillDifferences(int indx, math::XYZTLorentzVector &vec1, math::XYZTLorentzVector &vec2, bool debug) {
2050  double dr = dR(vec1, vec2);
2051  double deta = dEta(vec1, vec2);
2052  double dphi = dPhi(vec1, vec2);
2053  double dpt = dPt(vec1, vec2);
2054  double dp = dP(vec1, vec2);
2055  double dinvpt = dinvPt(vec1, vec2);
2056  h_dEta[indx]->Fill(deta);
2057  h_dPhi[indx]->Fill(dphi);
2058  h_dPt[indx]->Fill(dpt);
2059  h_dP[indx]->Fill(dp);
2060  h_dinvPt[indx]->Fill(dinvpt);
2061  h_mindR[indx]->Fill(dr);
2062  if (debug)
2063  edm::LogVerbatim("IsoTrack") << "mindR for index " << indx << " is " << dr << " deta " << deta << " dphi " << dphi
2064  << " dpt " << dpt << " dinvpt " << dinvpt;
2065 }
2066 
2067 void IsoTrig::fillCuts(
2068  int indx, double eMipDR, double conehmaxNearP, double e_inCone, math::XYZTLorentzVector &vec, int ieta, bool cut) {
2069  h_eMip[indx]->Fill(eMipDR);
2070  h_eMaxNearP[indx]->Fill(conehmaxNearP);
2071  h_eNeutIso[indx]->Fill(e_inCone);
2072  if ((conehmaxNearP < cutCharge_) && (eMipDR < cutMip_)) {
2073  for (int lim = 0; lim < 5; ++lim) {
2074  if ((vec.r() > pLimits_[lim]) && (vec.r() <= pLimits_[lim + 1])) {
2075  h_etaMipTracks[lim][indx][0]->Fill((double)(ieta));
2076  if (cut)
2077  h_etaMipTracks[lim][indx][1]->Fill((double)(ieta));
2078  if (e_inCone < cutNeutral_) {
2079  h_etaCalibTracks[lim][indx][0]->Fill((double)(ieta));
2080  if (cut)
2081  h_etaCalibTracks[lim][indx][1]->Fill((double)(ieta));
2082  }
2083  }
2084  }
2085  }
2086 }
2087 
2088 void IsoTrig::fillEnergy(int indx, int ieta, double hCone, double eMipDR, math::XYZTLorentzVector &vec) {
2089  int kk(-1);
2090  if (ieta > 0 && ieta < 25)
2091  kk = 23 + ieta;
2092  else if (ieta > -25 && ieta < 0)
2093  kk = -(ieta + 1);
2094  if (kk >= 0 && eMipDR > 0.01 && hCone > 1.0) {
2095  for (int lim = 0; lim < 5; ++lim) {
2096  if ((vec.r() > pLimits_[lim]) && (vec.r() <= pLimits_[lim + 1])) {
2097  h_eHcal[lim][indx][kk]->Fill(hCone);
2098  h_eCalo[lim][indx][kk]->Fill(hCone + eMipDR);
2099  }
2100  }
2101  }
2102 }
2103 
2104 double IsoTrig::dEta(math::XYZTLorentzVector &vec1, math::XYZTLorentzVector &vec2) { return (vec1.eta() - vec2.eta()); }
2105 
2106 double IsoTrig::dPhi(math::XYZTLorentzVector &vec1, math::XYZTLorentzVector &vec2) {
2107  double phi1 = vec1.phi();
2108  if (phi1 < 0)
2109  phi1 += 2.0 * M_PI;
2110  double phi2 = vec2.phi();
2111  if (phi2 < 0)
2112  phi2 += 2.0 * M_PI;
2113  double dphi = phi1 - phi2;
2114  if (dphi > M_PI)
2115  dphi -= 2. * M_PI;
2116  else if (dphi < -M_PI)
2117  dphi += 2. * M_PI;
2118  return dphi;
2119 }
2120 
2121 double IsoTrig::dR(math::XYZTLorentzVector &vec1, math::XYZTLorentzVector &vec2) {
2122  double deta = dEta(vec1, vec2);
2123  double dphi = dPhi(vec1, vec2);
2124  return std::sqrt(deta * deta + dphi * dphi);
2125 }
2126 
2127 double IsoTrig::dPt(math::XYZTLorentzVector &vec1, math::XYZTLorentzVector &vec2) { return (vec1.pt() - vec2.pt()); }
2128 
2129 double IsoTrig::dP(math::XYZTLorentzVector &vec1, math::XYZTLorentzVector &vec2) {
2130  return (std::abs(vec1.r() - vec2.r()));
2131 }
2132 
2133 double IsoTrig::dinvPt(math::XYZTLorentzVector &vec1, math::XYZTLorentzVector &vec2) {
2134  return ((1 / vec1.pt()) - (1 / vec2.pt()));
2135 }
2136 
2137 std::pair<double, double> IsoTrig::etaPhiTrigger() {
2138  double eta(0), phi(0), ptmax(0);
2139  for (unsigned int k = 0; k < vec_[0].size(); ++k) {
2140  if (k == 0) {
2141  eta = vec_[0][k].eta();
2142  phi = vec_[0][k].phi();
2143  ptmax = vec_[0][k].pt();
2144  } else if (vec_[0][k].pt() > ptmax) {
2145  eta = vec_[0][k].eta();
2146  phi = vec_[0][k].phi();
2147  ptmax = vec_[0][k].pt();
2148  }
2149  }
2150  return std::pair<double, double>(eta, phi);
2151 }
2152 
2153 std::pair<double, double> IsoTrig::GetEtaPhiAtEcal(double etaIP, double phiIP, double pT, int charge, double vtxZ) {
2154  double deltaPhi = 0;
2155  double etaEC = 100;
2156  double phiEC = 100;
2157 
2158  double Rcurv = 9999999;
2159  if (bfVal_ != 0)
2160  Rcurv = pT * 33.3 * 100 / (bfVal_ * 10); //r(m)=pT(GeV)*33.3/B(kG)
2161 
2162  double ecDist = zEE_;
2163  double ecRad = rEB_; //radius of ECAL barrel (cm)
2164  double theta = 2 * atan(exp(-etaIP));
2165  double zNew = 0;
2166  if (theta > 0.5 * M_PI)
2167  theta = M_PI - theta;
2168  if (fabs(etaIP) < 1.479) {
2169  if ((0.5 * ecRad / Rcurv) > 1) {
2170  etaEC = 10000;
2171  deltaPhi = 0;
2172  } else {
2173  deltaPhi = -charge * asin(0.5 * ecRad / Rcurv);
2174  double alpha1 = 2 * asin(0.5 * ecRad / Rcurv);
2175  double z = ecRad / tan(theta);
2176  if (etaIP > 0)
2177  zNew = z * (Rcurv * alpha1) / ecRad + vtxZ; //new z-coordinate of track
2178  else
2179  zNew = -z * (Rcurv * alpha1) / ecRad + vtxZ; //new z-coordinate of track
2180  double zAbs = fabs(zNew);
2181  if (zAbs < ecDist) {
2182  etaEC = -log(tan(0.5 * atan(ecRad / zAbs)));
2183  deltaPhi = -charge * asin(0.5 * ecRad / Rcurv);
2184  }
2185  if (zAbs > ecDist) {
2186  zAbs = (fabs(etaIP) / etaIP) * ecDist;
2187  double Zflight = fabs(zAbs - vtxZ);
2188  double alpha = (Zflight * ecRad) / (z * Rcurv);
2189  double Rec = 2 * Rcurv * sin(alpha / 2);
2190  deltaPhi = -charge * alpha / 2;
2191  etaEC = -log(tan(0.5 * atan(Rec / ecDist)));
2192  }
2193  }
2194  } else {
2195  zNew = (fabs(etaIP) / etaIP) * ecDist;
2196  double Zflight = fabs(zNew - vtxZ);
2197  double Rvirt = fabs(Zflight * tan(theta));
2198  double Rec = 2 * Rcurv * sin(Rvirt / (2 * Rcurv));
2199  deltaPhi = -(charge) * (Rvirt / (2 * Rcurv));
2200  etaEC = -log(tan(0.5 * atan(Rec / ecDist)));
2201  }
2202 
2203  if (zNew < 0)
2204  etaEC = -etaEC;
2205  phiEC = phiIP + deltaPhi;
2206 
2207  if (phiEC < -M_PI)
2208  phiEC += 2 * M_PI;
2209  if (phiEC > M_PI)
2210  phiEC -= 2 * M_PI;
2211 
2212  std::pair<double, double> retVal(etaEC, phiEC);
2213  return retVal;
2214 }
2215 
2216 double IsoTrig::getDistInCM(double eta1, double phi1, double eta2, double phi2) {
2217  double Rec;
2218  double theta1 = 2 * atan(exp(-eta1));
2219  double theta2 = 2 * atan(exp(-eta2));
2220  if (fabs(eta1) < 1.479)
2221  Rec = rEB_; //radius of ECAL barrel
2222  else if (fabs(eta1) > 1.479 && fabs(eta1) < 7.0)
2223  Rec = tan(theta1) * zEE_; //distance from IP to ECAL endcap
2224  else
2225  return 1000;
2226 
2227  //|vect| times tg of acos(scalar product)
2228  double angle =
2229  acos((sin(theta1) * sin(theta2) * (sin(phi1) * sin(phi2) + cos(phi1) * cos(phi2)) + cos(theta1) * cos(theta2)));
2230  if (angle < 0.5 * M_PI)
2231  return fabs((Rec / sin(theta1)) * tan(angle));
2232  else
2233  return 1000;
2234 }
2235 
2236 //define this as a plug-in
2237 DEFINE_FWK_MODULE(IsoTrig);
findQualityFiles.size
size
Write out results.
Definition: findQualityFiles.py:443
fastmath::etaphi
std::pair< T, T > etaphi(T x, T y, T z)
Definition: FastMath.h:162
IsoTrig::changed_
bool changed_
Definition: IsoTrig.cc:204
TFileService::kSharedResource
static const std::string kSharedResource
Definition: TFileService.h:76
spr::eCone_hcal
double eCone_hcal(const CaloGeometry *geo, edm::Handle< T > &hits, const GlobalPoint &hpoint1, const GlobalPoint &point1, double dR, const GlobalVector &trackMom, int &nRecHits, double hbThr=-100, double heThr=-100, double hfThr=-100, double hoThr=-100, double tMin=-500, double tMax=500, int detOnly=-1, int useRaw=0, bool debug=false)
edm::LogVerbatim
Log< level::Info, true > LogVerbatim
Definition: MessageLogger.h:128
IsoTrig::t_NFTrkPVFlag
std::vector< bool > * t_NFTrkPVFlag
Definition: IsoTrig.cc:248
IsoTrig::t_PixTrkcandPhi
std::vector< double > * t_PixTrkcandPhi
Definition: IsoTrig.cc:229
HI_PhotonSkim_cff.rechits
rechits
Definition: HI_PhotonSkim_cff.py:76
IsoTrig::t_PixTrkcandP
std::vector< double > * t_PixTrkcandP
Definition: IsoTrig.cc:226
IsoTrig::a_coneR_
const double a_coneR_
Definition: IsoTrig.cc:165
trigger::TriggerRefsCollections::getObjects
void getObjects(Vids &ids, VRphoton &refs) const
various physics-level getters:
Definition: TriggerRefsCollections.h:627
IsoTrig::g_PreHLT
TH1D * g_PreHLT
Definition: IsoTrig.cc:267
IsoTrig::endRun
void endRun(edm::Run const &, edm::EventSetup const &) override
Definition: IsoTrig.cc:108
IsoTrig::theTrackQuality_
std::string theTrackQuality_
Definition: IsoTrig.cc:161
IsoTrig::tok_l2cand_
edm::EDGetTokenT< reco::IsolatedPixelTrackCandidateCollection > tok_l2cand_
Definition: IsoTrig.cc:185
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:130
ProducerED_cfi.InputTag
InputTag
Definition: ProducerED_cfi.py:5
alpha
float alpha
Definition: AMPTWrapper.h:105
IsoTrig::fs_
edm::Service< TFileService > fs_
Definition: IsoTrig.cc:206
IsoTrig::l2CandTag_
const edm::InputTag l2CandTag_
Definition: IsoTrig.cc:153
mps_fire.i
i
Definition: mps_fire.py:429
IsoTrig::endcapRecHitsHandle_
edm::Handle< EcalRecHitCollection > endcapRecHitsHandle_
Definition: IsoTrig.cc:194
IsoTrig::t_NFTrkMinDR
std::vector< double > * t_NFTrkMinDR
Definition: IsoTrig.cc:243
nnet::tanh
void tanh(data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_in])
Definition: nnet_activation.h:227
IsoTrig::beginRun
void beginRun(edm::Run const &, edm::EventSetup const &) override
Definition: IsoTrig.cc:1201
edm::EventSetup::getData
T const & getData(const ESGetToken< T, R > &iToken) const noexcept(false)
Definition: EventSetup.h:119
gpuVertexFinder::iv
int32_t *__restrict__ iv
Definition: gpuClusterTracksByDensity.h:46
trigger::TriggerEvent
The single EDProduct to be saved for each event (AOD case)
Definition: TriggerEvent.h:25
L1TEGammaOffline_cfi.triggerNames
triggerNames
Definition: L1TEGammaOffline_cfi.py:40
IsoTrig::chgIsolation
void chgIsolation(double &etaTriggered, double &phiTriggered, edm::Handle< reco::TrackCollection > &trkCollection, const edm::Event &theEvent)
Definition: IsoTrig.cc:1829
IsoTrig::t_NFTrkMissFlag
std::vector< bool > * t_NFTrkMissFlag
Definition: IsoTrig.cc:247
IsoTrig::~IsoTrig
~IsoTrig() override
Definition: IsoTrig.cc:426
reco::BeamSpot::position
const Point & position() const
position
Definition: BeamSpot.h:59
IsoTrig::doChgIsolTree_
const bool doChgIsolTree_
Definition: IsoTrig.cc:156
IsoTrig::h_phi
TH1D * h_phi[20]
Definition: IsoTrig.cc:260
IsoTrig::tok_lumi_
edm::EDGetTokenT< LumiDetails > tok_lumi_
Definition: IsoTrig.cc:169
IsoTrig::hbhe_
edm::Handle< HBHERecHitCollection > hbhe_
Definition: IsoTrig.cc:192
IsoTrig::t_PixTrkcandselTk
std::vector< bool > * t_PixTrkcandselTk
Definition: IsoTrig.cc:231
IsoTrig::h_EnIn
TH1D * h_EnIn
Definition: IsoTrig.cc:255
IsoTrig::trigList_
std::unordered_map< unsigned int, unsigned int > trigList_
Definition: IsoTrig.cc:202
IsoTrig::pixelTrackRefsHB_
std::vector< reco::TrackRef > pixelTrackRefsHB_
Definition: IsoTrig.cc:191
IsoTrig::a_charIsoR_
const double a_charIsoR_
Definition: IsoTrig.cc:165
IsoTrig::h_dEta
TH1D * h_dEta[9]
Definition: IsoTrig.cc:262
IsoTrig::a_neutR2_
const double a_neutR2_
Definition: IsoTrig.cc:166
reco::TrackBase::TrackQuality
TrackQuality
track quality
Definition: TrackBase.h:150
IsoTrig::studyIsolation
void studyIsolation(edm::Handle< reco::TrackCollection > &, std::vector< reco::TrackCollection::const_iterator > &)
Definition: IsoTrig.cc:1688
MagneticField::inTesla
virtual GlobalVector inTesla(const GlobalPoint &gp) const =0
Field value ad specified global point, in Tesla.
IsoTrig::t_NFTrkcandEta
std::vector< double > * t_NFTrkcandEta
Definition: IsoTrig.cc:240
reco::TrackBase::px
double px() const
x coordinate of momentum vector
Definition: TrackBase.h:640
IsoTrig::t_NFcandP
std::vector< double > * t_NFcandP
Definition: IsoTrig.cc:233
Calorimetry_cff.dp
dp
Definition: Calorimetry_cff.py:158
reco::TrackBase::p
double p() const
momentum vector magnitude
Definition: TrackBase.h:631
HLT_2023v12_cff.eta2
eta2
Definition: HLT_2023v12_cff.py:14159
IsoTrig::endJob
void endJob() override
Definition: IsoTrig.cc:1179
IsoTrig::verbosity_
const int verbosity_
Definition: IsoTrig.cc:157
IsoTrig::h_dEtaL1
TH1D * h_dEtaL1[2]
Definition: IsoTrig.cc:261
funct::sin
Sin< T >::type sin(const T &t)
Definition: Sin.h:22
IsoTrig::trigPreList_
std::unordered_map< unsigned int, const std::pair< double, double > > trigPreList_
Definition: IsoTrig.cc:203
IsoTrig::maxRunNo_
const int maxRunNo_
Definition: IsoTrig.cc:168
IsoTrig::tok_EB_
edm::EDGetTokenT< EcalRecHitCollection > tok_EB_
Definition: IsoTrig.cc:176
edm::Handle::product
T const * product() const
Definition: Handle.h:70
GlobalPoint
Global3DPoint GlobalPoint
Definition: GlobalPoint.h:10
testProducerWithPsetDescEmpty_cfi.i2
i2
Definition: testProducerWithPsetDescEmpty_cfi.py:46
edm::SortedCollection< EcalRecHit >::const_iterator
std::vector< EcalRecHit >::const_iterator const_iterator
Definition: SortedCollection.h:80
SiPixelRawToDigiRegional_cfi.deltaPhi
deltaPhi
Definition: SiPixelRawToDigiRegional_cfi.py:9
IsoTrig::g_Pre
TH1D * g_Pre
Definition: IsoTrig.cc:267
PbPb_ZMuSkimMuonDPG_cff.deltaR
deltaR
Definition: PbPb_ZMuSkimMuonDPG_cff.py:63
IsoTrig::barrelRecHitsHandle_
edm::Handle< EcalRecHitCollection > barrelRecHitsHandle_
Definition: IsoTrig.cc:193
reco::TrackBase::py
double py() const
y coordinate of momentum vector
Definition: TrackBase.h:643
IsoTrig::a_neutIsoR_
const double a_neutIsoR_
Definition: IsoTrig.cc:165
IsoTrig::t_nPixSeed
std::vector< int > * t_nPixSeed
Definition: IsoTrig.cc:210
IsoTrig::t_TrkhCone
std::vector< double > * t_TrkhCone
Definition: IsoTrig.cc:213
IsoTrig::rEB_
double rEB_
Definition: IsoTrig.cc:163
IsoTrig::tok_pixtk_
edm::EDGetTokenT< reco::IsolatedPixelTrackCandidateCollection > tok_pixtk_
Definition: IsoTrig.cc:183
SeedingLayerSetsHits::size
unsigned short size() const
Get the number of SeedingLayerSets.
Definition: SeedingLayerSetsHits.h:199
IsoTrig::t_NFTrkqltyFlag
std::vector< bool > * t_NFTrkqltyFlag
Definition: IsoTrig.cc:246
IsoTrig::GetEtaPhiAtEcal
std::pair< double, double > GetEtaPhiAtEcal(double etaIP, double phiIP, double pT, int charge, double vtxZ)
Definition: IsoTrig.cc:2153
IsoTrig::t_PixTrkcandMaxP
std::vector< double > * t_PixTrkcandMaxP
Definition: IsoTrig.cc:230
HLTPrescaleProvider::hltConfigProvider
HLTConfigProvider const & hltConfigProvider() const
Definition: HLTPrescaleProvider.h:53
edm::Event::getByToken
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:540
IsoTrig::minPTrackValue_
const double minPTrackValue_
Definition: IsoTrig.cc:159
IsoTrig::beamSpotH_
edm::Handle< reco::BeamSpot > beamSpotH_
Definition: IsoTrig.cc:195
muonTiming_cfi.ptmax
ptmax
Definition: muonTiming_cfi.py:22
IsoTrig::vec_
std::vector< math::XYZTLorentzVector > vec_[3]
Definition: IsoTrig.cc:269
spr::chargeIsolationCone
double chargeIsolationCone(unsigned int trkIndex, std::vector< spr::propagatedTrackDirection > &trkDirs, double dR, int &nNearTRKs, bool debug=false)
Definition: ChargeIsolation.cc:306
IsoTrig::t_NFTrkselTkFlag
std::vector< bool > * t_NFTrkselTkFlag
Definition: IsoTrig.cc:245
IsoTrig::h_HLT
TH1I * h_HLT
Definition: IsoTrig.cc:257
spr::find
void find(edm::Handle< EcalRecHitCollection > &hits, DetId thisDet, std::vector< EcalRecHitCollection::const_iterator > &hit, bool debug=false)
Definition: FindCaloHit.cc:19
IsoTrig::dP
double dP(math::XYZTLorentzVector &, math::XYZTLorentzVector &)
Definition: IsoTrig.cc:2129
IsoTrig::a_mipR_
const double a_mipR_
Definition: IsoTrig.cc:166
IsoTrig::t_PixcandP
std::vector< double > * t_PixcandP
Definition: IsoTrig.cc:221
trigger::TriggerObject::energy
float energy() const
Definition: TriggerObject.h:61
IsoTrig::etaPhiTrigger
std::pair< double, double > etaPhiTrigger()
Definition: IsoTrig.cc:2137
IsoTrig::tok_trigEvt_
edm::EDGetTokenT< trigger::TriggerEvent > tok_trigEvt_
Definition: IsoTrig.cc:170
IsoTrig::h_dP
TH1D * h_dP[9]
Definition: IsoTrig.cc:262
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
IsoTrig::tauUnbiasCone_
const double tauUnbiasCone_
Definition: IsoTrig.cc:160
DiDispStaMuonMonitor_cfi.pt
pt
Definition: DiDispStaMuonMonitor_cfi.py:39
IsoTrig::t_NFTrkMipFlag
std::vector< bool > * t_NFTrkMipFlag
Definition: IsoTrig.cc:252
IsoTrig::dr_L1_
const double dr_L1_
Definition: IsoTrig.cc:165
spclusmultlumicorr_cfi.lumiProducer
lumiProducer
Definition: spclusmultlumicorr_cfi.py:11
edm::ParameterSet::getUntrackedParameter
T getUntrackedParameter(std::string const &, T const &) const
IsoTrig::pushMipCutTreeVecs
void pushMipCutTreeVecs(math::XYZTLorentzVector &NFcand, math::XYZTLorentzVector &Trkcand, double &EmipNFcand, double &EmipTrkcand, double &mindR, double &mindP1, std::vector< bool > &Flags, double hCone)
Definition: IsoTrig.cc:850
trigger::TriggerObject
Single trigger physics object (e.g., an isolated muon)
Definition: TriggerObject.h:21
edm::second
U second(std::pair< T, U > const &p)
Definition: ParameterSet.cc:222
IsoTrig::t_NFTrkMinDP1
std::vector< double > * t_NFTrkMinDP1
Definition: IsoTrig.cc:244
IsoTrig::h_EnOut
TH1D * h_EnOut
Definition: IsoTrig.cc:255
IsoTrig::h_dPhiL1
TH1D * h_dPhiL1[2]
Definition: IsoTrig.cc:261
IsoTrig::h_L1ObjEnergy
TH1D * h_L1ObjEnergy
Definition: IsoTrig.cc:259
IsoTrig::analyze
void analyze(const edm::Event &, const edm::EventSetup &) override
Definition: IsoTrig.cc:565
math::XYZTLorentzVector
XYZTLorentzVectorD XYZTLorentzVector
Lorentz vector with cylindrical internal representation using pseudorapidity.
Definition: LorentzVector.h:29
IsoTrig::pixelTracksSources_
const std::vector< edm::InputTag > pixelTracksSources_
Definition: IsoTrig.cc:154
IsoTrig::studyMipCut
void studyMipCut(edm::Handle< reco::TrackCollection > &trkCollection, edm::Handle< reco::IsolatedPixelTrackCandidateCollection > &L2cands)
Definition: IsoTrig.cc:1441
reco::TrackBase::pt
double pt() const
track transverse momentum
Definition: TrackBase.h:637
label
char const * label
Definition: PFTauDecayModeTools.cc:11
IsoTrig::hltPrescaleProvider_
HLTPrescaleProvider hltPrescaleProvider_
Definition: IsoTrig.cc:151
IsoTrig::dinvPt
double dinvPt(math::XYZTLorentzVector &, math::XYZTLorentzVector &)
Definition: IsoTrig.cc:2133
IsoTrig::doMipCutTree_
const bool doMipCutTree_
Definition: IsoTrig.cc:155
IsoTrig::h_dPhi
TH1D * h_dPhi[9]
Definition: IsoTrig.cc:262
GCP_tree_cfg.levels
levels
Definition: GCP_tree_cfg.py:87
iEvent
int iEvent
Definition: GenABIO.cc:224
RecoMuonValidator_cfi.maxP
maxP
Definition: RecoMuonValidator_cfi.py:35
IsoTrig::tok_trigRes_
edm::EDGetTokenT< edm::TriggerResults > tok_trigRes_
Definition: IsoTrig.cc:171
edm::RunBase::run
RunNumber_t run() const
Definition: RunBase.h:40
IsoTrig::studyTrigger
void studyTrigger(edm::Handle< reco::TrackCollection > &, std::vector< reco::TrackCollection::const_iterator > &)
Definition: IsoTrig.cc:1574
IsoTrig::fillHist
void fillHist(int, math::XYZTLorentzVector &)
Definition: IsoTrig.cc:2042
IsoTrig::t_NFTrkcandP
std::vector< double > * t_NFTrkcandP
Definition: IsoTrig.cc:238
IsoTrig::tok_SeedingLayerHB_
edm::EDGetTokenT< SeedingLayerSetsHits > tok_SeedingLayerHB_
Definition: IsoTrig.cc:180
IsoTrig::t_TrkNuIsolFlag
std::vector< bool > * t_TrkNuIsolFlag
Definition: IsoTrig.cc:219
IsoTrig::h_nHLT
TH1I * h_nHLT
Definition: IsoTrig.cc:257
LogMessageMonitor_cff.modules
modules
Definition: LogMessageMonitor_cff.py:7
IsoTrig::tok_magField_
edm::ESGetToken< MagneticField, IdealMagneticFieldRecord > tok_magField_
Definition: IsoTrig.cc:189
DMR_cfg.cut
cut
Definition: DMR_cfg.py:131
IsoTrig::tok_bs_
edm::EDGetTokenT< reco::BeamSpot > tok_bs_
Definition: IsoTrig.cc:175
spr::goodTrack
bool goodTrack(const reco::Track *pTrack, math::XYZPoint leadPV, trackSelectionParameters parameters, bool debug=false)
Definition: TrackSelection.cc:9
IsoTrig::prelimCone_
const double prelimCone_
Definition: IsoTrig.cc:160
IsoTrig::t_TrkPVFlag
std::vector< bool > * t_TrkPVFlag
Definition: IsoTrig.cc:218
HLTPrescaleProvider::prescaleValues
std::pair< TL1, THLT > prescaleValues(const edm::Event &iEvent, const edm::EventSetup &iSetup, const std::string &trigger)
Combined L1T (pair.first) and HLT (pair.second) prescales per HLT path.
Definition: HLTPrescaleProvider.h:73
IsoTrig::t_ECone
std::vector< double > * t_ECone
Definition: IsoTrig.cc:253
vec1
std::vector< double > vec1
Definition: HCALResponse.h:15
HcalDetId::ieta
constexpr int ieta() const
get the cell ieta
Definition: HcalDetId.h:155
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
IsoTrig::tok_genTrack_
edm::EDGetTokenT< reco::TrackCollection > tok_genTrack_
Definition: IsoTrig.cc:173
IsoTrig::a_neutR1_
const double a_neutR1_
Definition: IsoTrig.cc:166
IsoTrig::h_Pre
TH1I * h_Pre
Definition: IsoTrig.cc:258
IsoTrig::h_PreHLT
TH1I * h_PreHLT
Definition: IsoTrig.cc:257
IsoTrig::h_dinvPt
TH1D * h_dinvPt[9]
Definition: IsoTrig.cc:263
IsoTrig::fillEnergy
void fillEnergy(int, int, double, double, math::XYZTLorentzVector &)
Definition: IsoTrig.cc:2088
IsoTrig::zEE_
double zEE_
Definition: IsoTrig.cc:163
funct::cos
Cos< T >::type cos(const T &t)
Definition: Cos.h:22
IsoTrig::t_NFTrkChgIsoFlag
std::vector< bool > * t_NFTrkChgIsoFlag
Definition: IsoTrig.cc:250
IsoTrig::tok_pixtks_
std::vector< edm::EDGetTokenT< reco::TrackCollection > > tok_pixtks_
Definition: IsoTrig.cc:186
IsoTrig::t_TrkP
std::vector< double > * t_TrkP
Definition: IsoTrig.cc:214
IsoTrig::h_eta
TH1D * h_eta[20]
Definition: IsoTrig.cc:260
funct::tan
Tan< T >::type tan(const T &t)
Definition: Tan.h:22
IsoTrig::h_Filters
TH1I * h_Filters
Definition: IsoTrig.cc:258
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
IsoTrig::selectionParameters_
spr::trackSelectionParameters selectionParameters_
Definition: IsoTrig.cc:164
IsoTrig::t_NFcandEta
std::vector< double > * t_NFcandEta
Definition: IsoTrig.cc:235
IsoTrig::tok_SeedingLayerHE_
edm::EDGetTokenT< SeedingLayerSetsHits > tok_SeedingLayerHE_
Definition: IsoTrig.cc:181
trigger::TriggerObject::id
int id() const
getters
Definition: TriggerObject.h:51
IsoTrig::t_timeL2Prod
std::vector< double > * t_timeL2Prod
Definition: IsoTrig.cc:208
reco::TrackBase::phi
double phi() const
azimuthal angle of momentum vector
Definition: TrackBase.h:649
IsoTrig::beginJob
void beginJob() override
Definition: IsoTrig.cc:881
spr::eCone_ecal
double eCone_ecal(const CaloGeometry *geo, edm::Handle< T > &barrelhits, edm::Handle< T > &endcaphits, const GlobalPoint &hpoint1, const GlobalPoint &point1, double dR, const GlobalVector &trackMom, int &nRecHits, double ebThr=-100, double eeThr=-100, double tMin=-500, double tMax=500, bool debug=false)
hltrates_dqm_sourceclient-live_cfg.prescales
prescales
Definition: hltrates_dqm_sourceclient-live_cfg.py:91
DEFINE_FWK_MODULE
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:16
IsoTrig::h_eHcal
TH1D * h_eHcal[5][6][48]
Definition: IsoTrig.cc:266
IsoTrig::tok_EE_
edm::EDGetTokenT< EcalRecHitCollection > tok_EE_
Definition: IsoTrig.cc:177
triggerResults
static std::string const triggerResults
Definition: EdmProvDump.cc:47
IsoTrig::IsoTrig
IsoTrig(const edm::ParameterSet &)
Definition: IsoTrig.cc:272
IsoTrig::t_PixcandPt
std::vector< double > * t_PixcandPt
Definition: IsoTrig.cc:222
ALCARECOTkAlJpsiMuMu_cff.charge
charge
Definition: ALCARECOTkAlJpsiMuMu_cff.py:47
IsoTrig::geo_
const CaloGeometry * geo_
Definition: IsoTrig.cc:199
IsoTrig::h_PreL1wt
TH1D * h_PreL1wt
Definition: IsoTrig.cc:259
IsoTrig::t_NFcandEmip
std::vector< double > * t_NFcandEmip
Definition: IsoTrig.cc:237
LumiDetails::lumiValue
float lumiValue(AlgoType algo, unsigned int bx) const
Definition: LumiDetails.cc:72
IsoTrig::h_eMaxNearP
TH1D * h_eMaxNearP[2]
Definition: IsoTrig.cc:264
IsoTrig::dPhi
double dPhi(math::XYZTLorentzVector &, math::XYZTLorentzVector &)
Definition: IsoTrig.cc:2106
IsoTrig::studyTiming
void studyTiming(const edm::Event &theEvent)
Definition: IsoTrig.cc:1330
IsoTrig::doTrkResTree_
const bool doTrkResTree_
Definition: IsoTrig.cc:156
IsoTrig::clearChgIsolnTreeVectors
void clearChgIsolnTreeVectors()
Definition: IsoTrig.cc:792
cuy.ii
ii
Definition: cuy.py:589
M_PI
#define M_PI
Definition: BXVectorInputProducer.cc:50
IsoTrig::t_NFTrkPropFlag
std::vector< bool > * t_NFTrkPropFlag
Definition: IsoTrig.cc:249
IsoTrig::pixelTrackRefsHE_
std::vector< reco::TrackRef > pixelTrackRefsHE_
Definition: IsoTrig.cc:191
IsoTrig::t_NFTrkcandPhi
std::vector< double > * t_NFTrkcandPhi
Definition: IsoTrig.cc:241
IsoTrig::g_PreL1
TH1D * g_PreL1
Definition: IsoTrig.cc:267
hit::id
unsigned int id
Definition: SiStripHitEffFromCalibTree.cc:92
IsoTrig::h_MipEnMatch
TH2D * h_MipEnMatch
Definition: IsoTrig.cc:256
PDWG_DiPhoton_SD_cff.triggerEvent
triggerEvent
Definition: PDWG_DiPhoton_SD_cff.py:39
IsoTrig::h_p
TH1D * h_p[20]
Definition: IsoTrig.cc:260
IsoTrig::h_eNeutIso
TH1D * h_eNeutIso[2]
Definition: IsoTrig.cc:264
IsoTrig::h_PreL1
TH1I * h_PreL1
Definition: IsoTrig.cc:257
electrons_cff.bool
bool
Definition: electrons_cff.py:315
trigger::TriggerObjectCollection
std::vector< TriggerObject > TriggerObjectCollection
collection of trigger physics objects (e.g., all isolated muons)
Definition: TriggerObject.h:75
IsoTrig::cutCharge_
const double cutCharge_
Definition: IsoTrig.cc:167
reco::TrackBase::eta
double eta() const
pseudorapidity of momentum vector
Definition: TrackBase.h:652
IsoTrig::t_TrkMissFlag
std::vector< bool > * t_TrkMissFlag
Definition: IsoTrig.cc:217
IsoTrig::getDistInCM
double getDistInCM(double eta1, double phi1, double eta2, double phi2)
Definition: IsoTrig.cc:2216
IsoTrig::tok_recVtx_
edm::EDGetTokenT< reco::VertexCollection > tok_recVtx_
Definition: IsoTrig.cc:174
IsoTrig::ChgIsolnTree_
TTree * ChgIsolnTree_
Definition: IsoTrig.cc:207
IsoTrig::t_nPixCand
std::vector< int > * t_nPixCand
Definition: IsoTrig.cc:209
reco::TrackBase::qualityByName
static TrackQuality qualityByName(const std::string &name)
Definition: TrackBase.cc:126
debug
#define debug
Definition: HDRShower.cc:19
IsoTrig::StudyTrkEbyP
void StudyTrkEbyP(edm::Handle< reco::TrackCollection > &trkCollection)
Definition: IsoTrig.cc:1206
IsoTrig::t_NFTrkcandPt
std::vector< double > * t_NFTrkcandPt
Definition: IsoTrig.cc:239
IsoTrig::h_eCalo
TH1D * h_eCalo[5][6][48]
Definition: IsoTrig.cc:266
IsoTrig::doStudyIsol_
const bool doStudyIsol_
Definition: IsoTrig.cc:156
IsoTrig::pixCandTag_
const edm::InputTag pixCandTag_
Definition: IsoTrig.cc:153
math::XYZPoint
XYZPointD XYZPoint
point in space with cartesian internal representation
Definition: Point3D.h:12
trigger::Keys
std::vector< size_type > Keys
Definition: TriggerTypeDefs.h:19
IsoTrig::t_PixTrkcandPt
std::vector< double > * t_PixTrkcandPt
Definition: IsoTrig.cc:227
IsoTrig::dEta
double dEta(math::XYZTLorentzVector &, math::XYZTLorentzVector &)
Definition: IsoTrig.cc:2104
reco::TrackBase::pz
double pz() const
z coordinate of momentum vector
Definition: TrackBase.h:646
IsoTrig::tok_verthb_
edm::EDGetTokenT< reco::VertexCollection > tok_verthb_
Definition: IsoTrig.cc:179
StorageManager_cfg.e1
e1
Definition: StorageManager_cfg.py:16
edm::ConfigurationDescriptions::add
void add(std::string const &label, ParameterSetDescription const &psetDescription)
Definition: ConfigurationDescriptions.cc:57
IsoTrig::t_NFcandPt
std::vector< double > * t_NFcandPt
Definition: IsoTrig.cc:234
IsoTrig::fillDescriptions
static void fillDescriptions(edm::ConfigurationDescriptions &descriptions)
Definition: IsoTrig.cc:517
IsoTrig::g_Accepts
TH1I * g_Accepts
Definition: IsoTrig.cc:268
IsoTrig::recVtxs_
edm::Handle< reco::VertexCollection > recVtxs_
Definition: IsoTrig.cc:196
testProducerWithPsetDescEmpty_cfi.i1
i1
Definition: testProducerWithPsetDescEmpty_cfi.py:45
multPhiCorr_741_25nsDY_cfi.py
py
Definition: multPhiCorr_741_25nsDY_cfi.py:12
IsoTrig::minRunNo_
const int minRunNo_
Definition: IsoTrig.cc:168
l1ctLayer1_cff.dr
dr
Definition: l1ctLayer1_cff.py:87
IsoTrig::h_pt
TH1D * h_pt[20]
Definition: IsoTrig.cc:260
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:70
IsoTrig::t_TrkqltyFlag
std::vector< bool > * t_TrkqltyFlag
Definition: IsoTrig.cc:216
IsoTrig::h_etaMipTracks
TH1D * h_etaMipTracks[5][2][2]
Definition: IsoTrig.cc:265
IsoTrig::processName_
const std::string processName_
Definition: IsoTrig.cc:162
GetRecoTauVFromDQM_MC_cff.kk
kk
Definition: GetRecoTauVFromDQM_MC_cff.py:84
multPhiCorr_741_25nsDY_cfi.px
px
Definition: multPhiCorr_741_25nsDY_cfi.py:10
IsoTrig::t_PixcandMaxP
std::vector< std::vector< double > > * t_PixcandMaxP
Definition: IsoTrig.cc:225
IsoTrig::t_NFTrkcandEmip
std::vector< double > * t_NFTrkcandEmip
Definition: IsoTrig.cc:242
IsoTrig::tok_l1cand_
edm::EDGetTokenT< trigger::TriggerFilterObjectWithRefs > tok_l1cand_
Definition: IsoTrig.cc:184
IsoTrig::vtxCutIsol_
const double vtxCutIsol_
Definition: IsoTrig.cc:159
edm
HLT enums.
Definition: AlignableModifier.h:19
IsoTrig::dR
double dR(math::XYZTLorentzVector &, math::XYZTLorentzVector &)
Definition: IsoTrig.cc:2121
IsoTrig::MipCutTree_
TTree * MipCutTree_
Definition: IsoTrig.cc:207
IsoTrig::l1CandTag_
const edm::InputTag l1CandTag_
Definition: IsoTrig.cc:153
IsoTrig::h_mindR
TH1D * h_mindR[9]
Definition: IsoTrig.cc:263
HLT_2023v12_cff.eta1
eta1
Definition: HLT_2023v12_cff.py:14158
IsoTrig::clearMipCutTreeVectors
void clearMipCutTreeVectors()
Definition: IsoTrig.cc:808
IsoTrig::tok_SiPixelRecHits_
edm::EDGetTokenT< SiPixelRecHitCollection > tok_SiPixelRecHits_
Definition: IsoTrig.cc:182
IsoTrig::t_PixcandEta
std::vector< double > * t_PixcandEta
Definition: IsoTrig.cc:223
IsoTrig::tok_hbhe_
edm::EDGetTokenT< HBHERecHitCollection > tok_hbhe_
Definition: IsoTrig.cc:178
position
static int position[264][3]
Definition: ReadPGInfo.cc:289
IsoTrig::TrkResTree_
TTree * TrkResTree_
Definition: IsoTrig.cc:207
spr::trackSelectionParameters::minQuality
reco::TrackBase::TrackQuality minQuality
Definition: TrackSelection.h:21
ProducerSetup_cfi.BField
BField
Definition: ProducerSetup_cfi.py:97
IsoTrig::fillDifferences
void fillDifferences(int, math::XYZTLorentzVector &, math::XYZTLorentzVector &, bool)
Definition: IsoTrig.cc:2049
IsoTrig::h_dPt
TH1D * h_dPt[9]
Definition: IsoTrig.cc:262
IsoTrig::bField_
const MagneticField * bField_
Definition: IsoTrig.cc:198
IsoTrig::h_MipEnNoMatch
TH2D * h_MipEnNoMatch
Definition: IsoTrig.cc:256
IsoTrig::dPt
double dPt(math::XYZTLorentzVector &, math::XYZTLorentzVector &)
Definition: IsoTrig.cc:2127
IsoTrig::t_NFTrkNeuIsoFlag
std::vector< bool > * t_NFTrkNeuIsoFlag
Definition: IsoTrig.cc:251
TFileService::make
T * make(const Args &...args) const
make new ROOT object
Definition: TFileService.h:64
IsoTrig::t_PixcandPhi
std::vector< double > * t_PixcandPhi
Definition: IsoTrig.cc:224
IsoTrig::doTiming_
const bool doTiming_
Definition: IsoTrig.cc:155
IsoTrig::t_PixTrkcandEta
std::vector< double > * t_PixTrkcandEta
Definition: IsoTrig.cc:228
IsoTrig::t_nGoodTk
std::vector< int > * t_nGoodTk
Definition: IsoTrig.cc:211
l1ct::clear
void clear(EGIsoObj &c)
Definition: egamma.h:82
JetChargeProducer_cfi.exp
exp
Definition: JetChargeProducer_cfi.py:6
triggerMatcherToHLTDebug_cfi.tags
tags
Definition: triggerMatcherToHLTDebug_cfi.py:9
edm::LogWarning
Log< level::Warning, false > LogWarning
Definition: MessageLogger.h:122
IsoTrig::tok_verthe_
edm::EDGetTokenT< reco::VertexCollection > tok_verthe_
Definition: IsoTrig.cc:179
IsoTrig::leadPV_
math::XYZPoint leadPV_
Definition: IsoTrig.cc:200
IsoTrig::pixelIsolationConeSizeAtEC_
const std::vector< double > pixelIsolationConeSizeAtEC_
Definition: IsoTrig.cc:158
IsoTrig::cutMip_
const double cutMip_
Definition: IsoTrig.cc:166
IsoTrig::h_nL3Objs
TH1I * h_nL3Objs
Definition: IsoTrig.cc:258
IsoTrig::tok_hlt_
edm::EDGetTokenT< trigger::TriggerFilterObjectWithRefs > tok_hlt_
Definition: IsoTrig.cc:172
IsoTrig::getGoodTracks
void getGoodTracks(const edm::Event &, edm::Handle< reco::TrackCollection > &)
Definition: IsoTrig.cc:1956
vec2
std::vector< vec1 > vec2
Definition: HCALResponse.h:16
IsoTrig::h_dRL1
TH1D * h_dRL1[2]
Definition: IsoTrig.cc:261
IsoTrig::cutNeutral_
const double cutNeutral_
Definition: IsoTrig.cc:167
IsoTrig::pLimits_
double pLimits_[6]
Definition: IsoTrig.cc:205
IsoTrig::h_etaCalibTracks
TH1D * h_etaCalibTracks[5][2][2]
Definition: IsoTrig.cc:265
IsoTrig::t_TrkselTkFlag
std::vector< bool > * t_TrkselTkFlag
Definition: IsoTrig.cc:215
theta
Geom::Theta< T > theta() const
Definition: Basic3DVectorLD.h:150
IsoTrig::trigNames_
const std::vector< std::string > trigNames_
Definition: IsoTrig.cc:152
IsoTrig::vtxCutSeed_
const double vtxCutSeed_
Definition: IsoTrig.cc:159
HLTPrescaleProvider::init
bool init(const edm::Run &iRun, const edm::EventSetup &iSetup, const std::string &processName, bool &changed)
Definition: HLTPrescaleProvider.cc:22
AlCaHLTBitMon_ParallelJobs.p
def p
Definition: AlCaHLTBitMon_ParallelJobs.py:153
IsoTrig::fillCuts
void fillCuts(int, double, double, double, math::XYZTLorentzVector &, int, bool)
Definition: IsoTrig.cc:2067
edm::Run
Definition: Run.h:45
IsoTrig::bfVal_
double bfVal_
Definition: IsoTrig.cc:163
IsoTrig::h_PreHLTwt
TH1D * h_PreHLTwt
Definition: IsoTrig.cc:259
DeadROC_duringRun.runNum
runNum
Definition: DeadROC_duringRun.py:21
IsoTrig::pushChgIsolnTreeVecs
void pushChgIsolnTreeVecs(math::XYZTLorentzVector &Pixcand, math::XYZTLorentzVector &Trkcand, std::vector< double > &PixMaxP, double &TrkMaxP, bool &selTk)
Definition: IsoTrig.cc:832
IsoTrig::TimingTree_
TTree * TimingTree_
Definition: IsoTrig.cc:207
IsoTrig::doL2L3_
const bool doL2L3_
Definition: IsoTrig.cc:155
angle
T angle(T x1, T y1, T z1, T x2, T y2, T z2)
Definition: angle.h:11
IsoTrig::h_eMip
TH1D * h_eMip[2]
Definition: IsoTrig.cc:263
IsoTrig::t_NFcandPhi
std::vector< double > * t_NFcandPhi
Definition: IsoTrig.cc:236
IsoTrig::tok_geom_
edm::ESGetToken< CaloGeometry, CaloGeometryRecord > tok_geom_
Definition: IsoTrig.cc:188
Generated for CMSSW Reference Manual by doxygen 1.8.14