CMS 3D CMS Logo

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
TopSingleLeptonDQM.cc
Go to the documentation of this file.
7 
8 namespace TopSingleLepton {
9 
10  // maximal number of leading jets
11  // to be used for top mass estimate
12  static const unsigned int MAXJETS = 4;
13  // nominal mass of the W boson to
14  // be used for the top mass estimate
15  static const double WMASS = 80.4;
16 
18  label_(label), elecIso_(0), elecSelect_(0), muonIso_(0), muonSelect_(0), jetIDSelect_(0), includeBTag_(false), lowerEdge_(-1.), upperEdge_(-1.), logged_(0)
19  {
20  // sources have to be given; this PSet is not optional
21  edm::ParameterSet sources=cfg.getParameter<edm::ParameterSet>("sources");
22  muons_= sources.getParameter<edm::InputTag>("muons");
23  elecs_= sources.getParameter<edm::InputTag>("elecs");
24  jets_ = sources.getParameter<edm::InputTag>("jets" );
25  mets_ = sources.getParameter<std::vector<edm::InputTag> >("mets" );
26 
27  // electronExtras are optional; they may be omitted or
28  // empty
29  if( cfg.existsAs<edm::ParameterSet>("elecExtras") ){
30  edm::ParameterSet elecExtras=cfg.getParameter<edm::ParameterSet>("elecExtras");
31  // select is optional; in case it's not found no
32  // selection will be applied
33  if( elecExtras.existsAs<std::string>("select") ){
34  elecSelect_= new StringCutObjectSelector<reco::GsfElectron>(elecExtras.getParameter<std::string>("select"));
35  }
36  // isolation is optional; in case it's not found no
37  // isolation will be applied
38  if( elecExtras.existsAs<std::string>("isolation") ){
39  elecIso_= new StringCutObjectSelector<reco::GsfElectron>(elecExtras.getParameter<std::string>("isolation"));
40  }
41  // electronId is optional; in case it's not found the
42  // InputTag will remain empty
43  if( elecExtras.existsAs<edm::InputTag>("electronId") ){
44  electronId_= elecExtras.getParameter<edm::InputTag>("electronId");
45  }
46  }
47 
48  // muonExtras are optional; they may be omitted or empty
49  if( cfg.existsAs<edm::ParameterSet>("muonExtras") ){
50  edm::ParameterSet muonExtras=cfg.getParameter<edm::ParameterSet>("muonExtras");
51  // select is optional; in case it's not found no
52  // selection will be applied
53  if( muonExtras.existsAs<std::string>("select") ){
54  muonSelect_= new StringCutObjectSelector<reco::Muon>(muonExtras.getParameter<std::string>("select"));
55  }
56  // isolation is optional; in case it's not found no
57  // isolation will be applied
58  if( muonExtras.existsAs<std::string>("isolation") ){
59  muonIso_= new StringCutObjectSelector<reco::Muon>(muonExtras.getParameter<std::string>("isolation"));
60  }
61  }
62 
63  // jetExtras are optional; they may be omitted or
64  // empty
65  if( cfg.existsAs<edm::ParameterSet>("jetExtras") ){
66  edm::ParameterSet jetExtras=cfg.getParameter<edm::ParameterSet>("jetExtras");
67  // jetCorrector is optional; in case it's not found
68  // the InputTag will remain empty
69  if( jetExtras.existsAs<std::string>("jetCorrector") ){
70  jetCorrector_= jetExtras.getParameter<std::string>("jetCorrector");
71  }
72  // read jetID information if it exists
73  if(jetExtras.existsAs<edm::ParameterSet>("jetID")){
74  edm::ParameterSet jetID=jetExtras.getParameter<edm::ParameterSet>("jetID");
75  jetIDLabel_ =jetID.getParameter<edm::InputTag>("label");
76  jetIDSelect_= new StringCutObjectSelector<reco::JetID>(jetID.getParameter<std::string>("select"));
77  }
78  // select is optional; in case it's not found no
79  // selection will be applied (only implemented for
80  // CaloJets at the moment)
81  if( jetExtras.existsAs<std::string>("select") ){
82  jetSelect_= jetExtras.getParameter<std::string>("select");
83  }
84  // jetBDiscriminators are optional; in case they are
85  // not found the InputTag will remain empty; they
86  // consist of pairs of edm::JetFlavorAssociation's &
87  // corresponding working points
88  includeBTag_=jetExtras.existsAs<edm::ParameterSet>("jetBTaggers");
89  if( includeBTag_ ){
90  edm::ParameterSet btagEff=jetExtras.getParameter<edm::ParameterSet>("jetBTaggers").getParameter<edm::ParameterSet>("trackCountingEff");
91  btagEff_= btagEff.getParameter<edm::InputTag>("label"); btagEffWP_= btagEff.getParameter<double>("workingPoint");
92  edm::ParameterSet btagPur=jetExtras.getParameter<edm::ParameterSet>("jetBTaggers").getParameter<edm::ParameterSet>("trackCountingPur");
93  btagPur_= btagPur.getParameter<edm::InputTag>("label"); btagPurWP_= btagPur.getParameter<double>("workingPoint");
94  edm::ParameterSet btagVtx=jetExtras.getParameter<edm::ParameterSet>("jetBTaggers").getParameter<edm::ParameterSet>("secondaryVertex" );
95  btagVtx_= btagVtx.getParameter<edm::InputTag>("label"); btagVtxWP_= btagVtx.getParameter<double>("workingPoint");
96  }
97  }
98 
99  // triggerExtras are optional; they may be omitted or empty
100  if( cfg.existsAs<edm::ParameterSet>("triggerExtras") ){
101  edm::ParameterSet triggerExtras=cfg.getParameter<edm::ParameterSet>("triggerExtras");
102  triggerTable_=triggerExtras.getParameter<edm::InputTag>("src");
103  triggerPaths_=triggerExtras.getParameter<std::vector<std::string> >("paths");
104  }
105 
106  // massExtras is optional; in case it's not found no mass
107  // window cuts are applied for the same flavor monitor
108  // histograms
109  if( cfg.existsAs<edm::ParameterSet>("massExtras") ){
110  edm::ParameterSet massExtras=cfg.getParameter<edm::ParameterSet>("massExtras");
111  lowerEdge_= massExtras.getParameter<double>("lowerEdge");
112  upperEdge_= massExtras.getParameter<double>("upperEdge");
113  }
114 
115  // setup the verbosity level for booking histograms;
116  // per default the verbosity level will be set to
117  // STANDARD. This will also be the chosen level in
118  // the case when the monitoring PSet is not found
120  if( cfg.existsAs<edm::ParameterSet>("monitoring") ){
121  edm::ParameterSet monitoring=cfg.getParameter<edm::ParameterSet>("monitoring");
122  if(monitoring.getParameter<std::string>("verbosity") == "DEBUG" )
123  verbosity_= DEBUG;
124  if(monitoring.getParameter<std::string>("verbosity") == "VERBOSE" )
126  if(monitoring.getParameter<std::string>("verbosity") == "STANDARD")
128  }
129  // and don't forget to do the histogram booking
130  book(cfg.getParameter<std::string>("directory"));
131  }
132 
133  void
135  {
136  //set up the current directory path
137  std::string current(directory); current+=label_;
139  store_->setCurrentFolder(current);
140 
141  // determine number of bins for trigger monitoring
142  unsigned int nPaths=triggerPaths_.size();
143 
144  // --- [STANDARD] --- //
145  // pt of the leading muon
146  hists_["muonPt_" ] = store_->book1D("MuonPt" , "pt(#mu)" , 50, 0., 250.);
147  // muon multiplicity before std isolation
148  hists_["muonMult_" ] = store_->book1D("MuonMult" , "N_{All}(#mu)" , 10, 0., 10.);
149  // muon multiplicity after std isolation
150  hists_["muonMultIso_"] = store_->book1D("MuonMultIso", "N_{Iso}(#mu)" , 10, 0., 10.);
151  // pt of the leading electron
152  hists_["elecPt_" ] = store_->book1D("ElecPt" , "pt(e)" , 50, 0., 250.);
153  // electron multiplicity before std isolation
154  hists_["elecMult_" ] = store_->book1D("ElecMult" , "N_{All}(e)" , 10, 0., 10.);
155  // electron multiplicity after std isolation
156  hists_["elecMultIso_"] = store_->book1D("ElecMultIso", "N_{Iso}(e)" , 10, 0., 10.);
157  // multiplicity of jets with pt>20 (corrected to L2+L3)
158  hists_["jetMult_" ] = store_->book1D("JetMult" , "N_{30}(jet)" , 10, 0., 10.);
159  // trigger efficiency estimates for single lepton triggers
160  hists_["triggerEff_" ] = store_->book1D("TriggerEff" , "Eff(trigger)" , nPaths, 0., nPaths);
161  // monitored trigger occupancy for single lepton triggers
162  hists_["triggerMon_" ] = store_->book1D("TriggerMon" , "Mon(trigger)" , nPaths, 0., nPaths);
163  // MET (calo)
164  hists_["metCalo_" ] = store_->book1D("METCalo" , "MET_{Calo}" , 50, 0., 200.);
165  // W mass estimate
166  hists_["massW_" ] = store_->book1D("MassW" , "M(W)" , 60, 0., 300.);
167  // Top mass estimate
168  hists_["massTop_" ] = store_->book1D("MassTop" , "M(Top)" , 50, 0., 500.);
169 
170  // set bin labels for trigger monitoring
171  triggerBinLabels(std::string("trigger"), triggerPaths_);
172 
173  if( verbosity_==STANDARD) return;
174 
175  // --- [VERBOSE] --- //
176  // eta of the leading muon
177  hists_["muonEta_" ] = store_->book1D("MuonEta" , "#eta(#mu)" , 30, -3., 3.);
178  // std isolation variable of the leading muon
179  hists_["muonRelIso_" ] = store_->book1D("MuonRelIso" , "Iso_{Rel}(#mu)" , 50, 0., 1.);
180  // eta of the leading electron
181  hists_["elecEta_" ] = store_->book1D("ElecEta" , "#eta(e)" , 30, -3., 3.);
182  // std isolation variable of the leading electron
183  hists_["elecRelIso_" ] = store_->book1D("ElecRelIso" , "Iso_{Rel}(e)" , 50, 0., 1.);
184  // multiplicity of btagged jets (for track counting high efficiency) with pt(L2L3)>30
185  hists_["jetMultBEff_"] = store_->book1D("JetMultBEff", "N_{30}(b/eff)" , 10, 0., 10.);
186  // btag discriminator for track counting high efficiency for jets with pt(L2L3)>30
187  hists_["jetBDiscEff_"] = store_->book1D("JetBDiscEff", "Disc_{b/eff}(jet)", 100, 0., 10.);
188  // pt of the 1. leading jet (corrected to L2+L3)
189  hists_["jet1Pt_" ] = store_->book1D("Jet1Pt" , "pt_{L2L3}(jet1)" , 60, 0., 300.);
190  // pt of the 2. leading jet (corrected to L2+L3)
191  hists_["jet2Pt_" ] = store_->book1D("Jet2Pt" , "pt_{L2L3}(jet2)" , 60, 0., 300.);
192  // pt of the 3. leading jet (corrected to L2+L3)
193  hists_["jet3Pt_" ] = store_->book1D("Jet3Pt" , "pt_{L2L3}(jet3)" , 60, 0., 300.);
194  // pt of the 4. leading jet (corrected to L2+L3)
195  hists_["jet4Pt_" ] = store_->book1D("Jet4Pt" , "pt_{L2L3}(jet4)" , 60, 0., 300.);
196  // MET (tc)
197  hists_["metTC_" ] = store_->book1D("METTC" , "MET_{TC}" , 50, 0., 200.);
198  // MET (pflow)
199  hists_["metPflow_" ] = store_->book1D("METPflow" , "MET_{Pflow}" , 50, 0., 200.);
200  // dz for muons (to suppress cosmis)
201  hists_["muonDelZ_" ] = store_->book1D("MuonDelZ" , "d_{z}(#mu)" , 50, -25., 25.);
202  // dxy for muons (to suppress cosmics)
203  hists_["muonDelXY_" ] = store_->book2D("MuonDelXY" , "d_{xy}(#mu)" , 50, -0.1, 0.1, 50, -0.1, 0.1);
204 
205  // set axes titles for dxy for muons
206  hists_["muonDelXY_" ]->setAxisTitle( "x [cm]", 1); hists_["muonDelXY_" ]->setAxisTitle( "y [cm]", 2);
207 
208  if( verbosity_==VERBOSE) return;
209 
210  // --- [DEBUG] --- //
211  // relative muon isolation in tracker for the leading muon
212  hists_["muonTrkIso_" ] = store_->book1D("MuonTrkIso" , "Iso_{Trk}(#mu)" , 50, 0., 1.);
213  // relative muon isolation in ecal+hcal for the leading muon
214  hists_["muonCalIso_" ] = store_->book1D("MuonCalIso" , "Iso_{Ecal}(#mu)" , 50, 0., 1.);
215  // relative electron isolation in tracker for the leading electron
216  hists_["elecTrkIso_" ] = store_->book1D("ElecTrkIso" , "Iso_{Trk}(e)" , 50, 0., 1.);
217  // relative electron isolation in ecal+hcal for the leading electron
218  hists_["elecCalIso_" ] = store_->book1D("ElecCalIso" , "Iso_{Ecal}(e)" , 50, 0., 1.);
219  // multiplicity of btagged jets (for track counting high purity) with pt(L2L3)>30
220  hists_["jetMultBPur_"] = store_->book1D("JetMultBPur", "N_{30}(b/pur)" , 10, 0., 10.);
221  // btag discriminator for track counting high purity
222  hists_["jetBDiscPur_"] = store_->book1D("JetBDiscPur", "Disc_{b/pur}(Jet)", 100, 0., 10.);
223  // multiplicity of btagged jets (for simple secondary vertex) with pt(L2L3)>30
224  hists_["jetMultBVtx_"] = store_->book1D("JetMultBVtx", "N_{30}(b/vtx)" , 10, 0., 10.);
225  // btag discriminator for simple secondary vertex
226  hists_["jetBDiscVtx_"] = store_->book1D("JetBDiscVtx", "Disc_{b/vtx}(Jet)", 35, -1., 6.);
227  // pt of the 1. leading jet (uncorrected)
228  hists_["jet1PtRaw_" ] = store_->book1D("Jet1PtRaw" , "pt_{Raw}(jet1)" , 60, 0., 300.);
229  // pt of the 2. leading jet (uncorrected)
230  hists_["jet2PtRaw_" ] = store_->book1D("Jet2PtRaw" , "pt_{Raw}(jet2)" , 60, 0., 300.);
231  // pt of the 3. leading jet (uncorrected)
232  hists_["jet3PtRaw_" ] = store_->book1D("Jet3PtRaw" , "pt_{Raw}(jet3)" , 60, 0., 300.);
233  // pt of the 4. leading jet (uncorrected)
234  hists_["jet4PtRaw_" ] = store_->book1D("Jet4PtRaw" , "pt_{Raw}(jet4)" , 60, 0., 300.);
235  // selected events
236  hists_["eventLogger_"] = store_->book2D("EventLogger", "Logged Events" , 9, 0., 9., 10, 0., 10.);
237 
238  // set axes titles for selected events
239  hists_["eventLogger_"]->getTH1()->SetOption("TEXT");
240  hists_["eventLogger_"]->setBinLabel( 1 , "Run" , 1);
241  hists_["eventLogger_"]->setBinLabel( 2 , "Block" , 1);
242  hists_["eventLogger_"]->setBinLabel( 3 , "Event" , 1);
243  hists_["eventLogger_"]->setBinLabel( 4 , "pt_{L2L3}(jet1)" , 1);
244  hists_["eventLogger_"]->setBinLabel( 5 , "pt_{L2L3}(jet2)" , 1);
245  hists_["eventLogger_"]->setBinLabel( 6 , "pt_{L2L3}(jet3)" , 1);
246  hists_["eventLogger_"]->setBinLabel( 7 , "pt_{L2L3}(jet4)" , 1);
247  hists_["eventLogger_"]->setBinLabel( 8 , "M_{W}" , 1);
248  hists_["eventLogger_"]->setBinLabel( 9 , "M_{Top}" , 1);
249  hists_["eventLogger_"]->setAxisTitle("logged evts" , 2);
250  return;
251  }
252 
253  void
255  {
256  // fetch trigger event if configured such
258  if(!triggerTable_.label().empty()) {
259  if( !event.getByLabel(triggerTable_, triggerTable) ) return;
260  }
261 
262  /*
263  ------------------------------------------------------------
264 
265  Electron Monitoring
266 
267  ------------------------------------------------------------
268  */
269 
270  // fill monitoring plots for electrons
272  if( !event.getByLabel(elecs_, elecs) ) return;
273 
274  // check availability of electron id
275  edm::Handle<edm::ValueMap<float> > electronId;
276  if(!electronId_.label().empty()) {
277  if( !event.getByLabel(electronId_, electronId) ) return;
278  }
279 
280  // loop electron collection
281  unsigned int eMult=0, eMultIso=0;
282  std::vector<const reco::GsfElectron*> isoElecs;
283  for(edm::View<reco::GsfElectron>::const_iterator elec=elecs->begin(); elec!=elecs->end(); ++elec){
284  unsigned int idx = elec-elecs->begin();
285  // restrict to electrons with good electronId
286  if( electronId_.label().empty() ? true : (*electronId)[elecs->refAt(idx)]>0.99 ){
287  if(!elecSelect_ || (*elecSelect_)(*elec)){
288  double isolationTrk = elec->pt()/(elec->pt()+elec->dr03TkSumPt());
289  double isolationCal = elec->pt()/(elec->pt()+elec->dr03EcalRecHitSumEt()+elec->dr03HcalTowerSumEt());
290  double isolationRel = (elec->dr03TkSumPt()+elec->dr03EcalRecHitSumEt()+elec->dr03HcalTowerSumEt())/elec->pt();
291  if( eMult==0 ){
292  // restrict to the leading electron
293  fill("elecPt_" , elec->pt() );
294  fill("elecEta_", elec->eta());
295  fill("elecRelIso_" , isolationRel );
296  fill("elecTrkIso_" , isolationTrk );
297  fill("elecCalIso_" , isolationCal );
298  }
299  // in addition to the multiplicity counter buffer the iso
300  // electron candidates for later overlap check with jets
301  ++eMult; if(!elecIso_ || (*elecIso_)(*elec)){ isoElecs.push_back(&(*elec)); ++eMultIso;}
302  }
303  }
304  }
305  fill("elecMult_", eMult );
306  fill("elecMultIso_", eMultIso);
307 
308  /*
309  ------------------------------------------------------------
310 
311  Muon Monitoring
312 
313  ------------------------------------------------------------
314  */
315 
316  // fill monitoring plots for muons
317  unsigned int mMult=0, mMultIso=0;
318 
320  if( !event.getByLabel(muons_, muons) ) return;
321 
322  for(edm::View<reco::Muon>::const_iterator muon=muons->begin(); muon!=muons->end(); ++muon){
323  // restrict to globalMuons
324  if( muon->isGlobalMuon() ){
325  fill("muonDelZ_" , muon->globalTrack()->vz());
326  fill("muonDelXY_", muon->globalTrack()->vx(), muon->globalTrack()->vy());
327  // apply preselection
328  if(!muonSelect_ || (*muonSelect_)(*muon)){
329  double isolationTrk = muon->pt()/(muon->pt()+muon->isolationR03().sumPt);
330  double isolationCal = muon->pt()/(muon->pt()+muon->isolationR03().emEt+muon->isolationR03().hadEt);
331  double isolationRel = (muon->isolationR03().sumPt+muon->isolationR03().emEt+muon->isolationR03().hadEt)/muon->pt();
332  if( mMult==0 ){
333  // restrict to leading muon
334  fill("muonPt_" , muon->pt() );
335  fill("muonEta_" , muon->eta());
336  fill("muonRelIso_" , isolationRel );
337  fill("muonTrkIso_" , isolationTrk );
338  fill("muonCalIso_" , isolationCal );
339  }
340  ++mMult; if(!muonIso_ || (*muonIso_)(*muon)) ++mMultIso;
341  }
342  }
343  }
344  fill("muonMult_", mMult );
345  fill("muonMultIso_", mMultIso);
346 
347  /*
348  ------------------------------------------------------------
349 
350  Jet Monitoring
351 
352  ------------------------------------------------------------
353  */
354 
355  // check availability of the btaggers
356  edm::Handle<reco::JetTagCollection> btagEff, btagPur, btagVtx;
357  if( includeBTag_ ){
358  if( !event.getByLabel(btagEff_, btagEff) ) return;
359  if( !event.getByLabel(btagPur_, btagPur) ) return;
360  if( !event.getByLabel(btagVtx_, btagVtx) ) return;
361  }
362  // load jet corrector if configured such
363  const JetCorrector* corrector=0;
364  if(!jetCorrector_.empty()){
365  // check whether a jet correcto is in the event setup or not
366  if(setup.find( edm::eventsetup::EventSetupRecordKey::makeKey<JetCorrectionsRecord>() )){
367  corrector = JetCorrector::getJetCorrector(jetCorrector_, setup);
368  }
369  else{
370  edm::LogVerbatim( "TopSingleLeptonDQM" )
371  << "\n"
372  << "------------------------------------------------------------------------------------- \n"
373  << " No JetCorrectionsRecord available from EventSetup: \n"
374  << " - Jets will not be corrected. \n"
375  << " - If you want to change this add the following lines to your cfg file: \n"
376  << " \n"
377  << " ## load jet corrections \n"
378  << " process.load(\"JetMETCorrections.Configuration.JetCorrectionServicesAllAlgos_cff\") \n"
379  << " process.prefer(\"ak5CaloL2L3\") \n"
380  << " \n"
381  << "------------------------------------------------------------------------------------- \n";
382  }
383  }
384 
385  // loop jet collection
386  std::vector<reco::Jet> correctedJets;
387  unsigned int mult=0, multBEff=0, multBPur=0, multBVtx=0;
388 
389 
391  if( !event.getByLabel(jets_, jets) ) return;
392 
394  if(jetIDSelect_){
395  if( !event.getByLabel(jetIDLabel_, jetID) ) return;
396  }
397 
398  for(edm::View<reco::Jet>::const_iterator jet=jets->begin(); jet!=jets->end(); ++jet){
399  // check jetID for calo jets
400  unsigned int idx = jet-jets->begin();
401  if( jetIDSelect_ && dynamic_cast<const reco::CaloJet*>(jets->refAt(idx).get())){
402  if(!(*jetIDSelect_)((*jetID)[jets->refAt(idx)])) continue;
403  }
404  // chekc additional jet selection for calo, pf and bare reco jets
405  if(dynamic_cast<const reco::CaloJet*>(&*jet)){
406  reco::CaloJet sel = dynamic_cast<const reco::CaloJet&>(*jet); sel.scaleEnergy(corrector ? corrector->correction(*jet) : 1.);
407  StringCutObjectSelector<reco::CaloJet> jetSelect(jetSelect_); if(!jetSelect(sel)){ continue;}
408  }
409  else if(dynamic_cast<const reco::PFJet*>(&*jet)){
410  reco::PFJet sel= dynamic_cast<const reco::PFJet&>(*jet); sel.scaleEnergy(corrector ? corrector->correction(*jet) : 1.);
411  StringCutObjectSelector<reco::PFJet> jetSelect(jetSelect_); if(!jetSelect(sel)) continue;
412  }
413  else{
414  reco::Jet sel = *jet; sel.scaleEnergy(corrector ? corrector->correction(*jet) : 1.);
415  StringCutObjectSelector<reco::Jet> jetSelect(jetSelect_); if(!jetSelect(sel)) continue;
416  }
417  // check for overlaps
418  bool overlap=false;
419  for(std::vector<const reco::GsfElectron*>::const_iterator elec=isoElecs.begin(); elec!=isoElecs.end(); ++elec){
420  if(reco::deltaR((*elec)->eta(), (*elec)->phi(), jet->eta(), jet->phi())<0.4){overlap=true; break;}
421  } if(overlap){continue;}
422  // prepare jet to fill monitor histograms
423  reco::Jet monitorJet = *jet; monitorJet.scaleEnergy(corrector ? corrector->correction(*jet) : 1.);
424  correctedJets.push_back(monitorJet);
425  ++mult; // determine jet multiplicity
426  if( includeBTag_ ){
427  // fill b-discriminators
428  edm::RefToBase<reco::Jet> jetRef = jets->refAt(idx);
429  fill("jetBDiscEff_", (*btagEff)[jetRef]); if( (*btagEff)[jetRef]>btagEffWP_ ) ++multBEff;
430  fill("jetBDiscPur_", (*btagPur)[jetRef]); if( (*btagPur)[jetRef]>btagPurWP_ ) ++multBPur;
431  fill("jetBDiscVtx_", (*btagVtx)[jetRef]); if( (*btagVtx)[jetRef]>btagVtxWP_ ) ++multBVtx;
432  }
433  // fill pt (raw or L2L3) for the leading four jets
434  if(idx==0) {fill("jet1Pt_" , monitorJet.pt()); fill("jet1PtRaw_", jet->pt() );}
435  if(idx==1) {fill("jet2Pt_" , monitorJet.pt()); fill("jet2PtRaw_", jet->pt() );}
436  if(idx==2) {fill("jet3Pt_" , monitorJet.pt()); fill("jet3PtRaw_", jet->pt() );}
437  if(idx==3) {fill("jet4Pt_" , monitorJet.pt()); fill("jet4PtRaw_", jet->pt() );}
438  }
439  fill("jetMult_" , mult );
440  fill("jetMultBEff_", multBEff);
441  fill("jetMultBPur_", multBPur);
442  fill("jetMultBVtx_", multBVtx);
443 
444  /*
445  ------------------------------------------------------------
446 
447  MET Monitoring
448 
449  ------------------------------------------------------------
450  */
451 
452  // fill monitoring histograms for met
453  for(std::vector<edm::InputTag>::const_iterator met_=mets_.begin(); met_!=mets_.end(); ++met_){
455  if( !event.getByLabel(*met_, met) ) continue;
456  if(met->begin()!=met->end()){
457  unsigned int idx=met_-mets_.begin();
458  if(idx==0) fill("metCalo_" , met->begin()->et());
459  if(idx==1) fill("metTC_" , met->begin()->et());
460  if(idx==2) fill("metPflow_", met->begin()->et());
461  }
462  }
463 
464  /*
465  ------------------------------------------------------------
466 
467  Event Monitoring
468 
469  ------------------------------------------------------------
470  */
471 
472  // fill W boson and top mass estimates
473  Calculate eventKinematics(MAXJETS, WMASS);
474  double wMass = eventKinematics.massWBoson (correctedJets);
475  double topMass = eventKinematics.massTopQuark(correctedJets);
476  if(wMass>=0 && topMass>=0) {fill("massW_" , wMass ); fill("massTop_" , topMass);}
477  // fill plots for trigger monitoring
478  if((lowerEdge_==-1. && upperEdge_==-1.) || (lowerEdge_<wMass && wMass<upperEdge_) ){
479  if(!triggerTable_.label().empty()) fill(event, *triggerTable, "trigger", triggerPaths_);
480  if(logged_<=hists_.find("eventLogger_")->second->getNbinsY()){
481  // log runnumber, lumi block, event number & some
482  // more pysics infomation for interesting events
483  fill("eventLogger_", 0.5, logged_+0.5, event.eventAuxiliary().run());
484  fill("eventLogger_", 1.5, logged_+0.5, event.eventAuxiliary().luminosityBlock());
485  fill("eventLogger_", 2.5, logged_+0.5, event.eventAuxiliary().event());
486  if(correctedJets.size()>0) fill("eventLogger_", 3.5, logged_+0.5, correctedJets[0].pt());
487  if(correctedJets.size()>1) fill("eventLogger_", 4.5, logged_+0.5, correctedJets[1].pt());
488  if(correctedJets.size()>2) fill("eventLogger_", 5.5, logged_+0.5, correctedJets[2].pt());
489  if(correctedJets.size()>3) fill("eventLogger_", 6.5, logged_+0.5, correctedJets[3].pt());
490  fill("eventLogger_", 7.5, logged_+0.5, wMass );
491  fill("eventLogger_", 8.5, logged_+0.5, topMass);
492  ++logged_;
493  }
494  }
495  }
496 
497 }
498 
499 
500 TopSingleLeptonDQM::TopSingleLeptonDQM(const edm::ParameterSet& cfg): triggerTable_(""), beamspot_("")
501 {
502  // configure preselection
503  edm::ParameterSet presel=cfg.getParameter<edm::ParameterSet>("preselection");
504  if( presel.existsAs<edm::ParameterSet>("trigger") ){
505  edm::ParameterSet trigger=presel.getParameter<edm::ParameterSet>("trigger");
506  triggerTable_=trigger.getParameter<edm::InputTag>("src");
507  triggerPaths_=trigger.getParameter<std::vector<std::string> >("select");
508  }
509  if( presel.existsAs<edm::ParameterSet>("vertex" ) ){
510  edm::ParameterSet vertex=presel.getParameter<edm::ParameterSet>("vertex");
511  vertex_= vertex.getParameter<edm::InputTag>("src");
512  vertexSelect_= new StringCutObjectSelector<reco::Vertex>(vertex.getParameter<std::string>("select"));
513  }
514  if( presel.existsAs<edm::ParameterSet>("beamspot" ) ){
516  beamspot_= beamspot.getParameter<edm::InputTag>("src");
517  beamspotSelect_= new StringCutObjectSelector<reco::BeamSpot>(beamspot.getParameter<std::string>("select"));
518  }
519 
520  // conifgure the selection
521  std::vector<edm::ParameterSet> sel=cfg.getParameter<std::vector<edm::ParameterSet> >("selection");
522  for(unsigned int i=0; i<sel.size(); ++i){
523  selectionOrder_.push_back(sel.at(i).getParameter<std::string>("label"));
524  selection_[selectionStep(selectionOrder_.back())] = std::make_pair(sel.at(i), new TopSingleLepton::MonitorEnsemble(selectionStep(selectionOrder_.back()).c_str(), cfg.getParameter<edm::ParameterSet>("setup")));
525  }
526 }
527 
528 void
530 {
531  if(!triggerTable_.label().empty()){
533  if( !event.getByLabel(triggerTable_, triggerTable) ) return;
534  if(!accept(event, *triggerTable, triggerPaths_)) return;
535  }
536  if(!beamspot_.label().empty()){
538  if( !event.getByLabel(beamspot_, beamspot) ) return;
539  if(!(*beamspotSelect_)(*beamspot)) return;
540  }
541  // apply selection steps
542  unsigned int passed=0;
543  for(std::vector<std::string>::const_iterator selIt=selectionOrder_.begin(); selIt!=selectionOrder_.end(); ++selIt){
544  std::string key = selectionStep(*selIt), type = objectType(*selIt);
545  if(selection_.find(key)!=selection_.end()){
546  if(type=="empty"){
547  selection_[key].second->fill(event, setup);
548  }
549  if(type=="muons"){
551  if(step.select(event)){ ++passed;
552  selection_[key].second->fill(event, setup);
553  } else break;
554  }
555  if(type=="elecs"){
557  if(step.select(event)){ ++passed;
558  selection_[key].second->fill(event, setup);
559  } else break;
560  }
561  if(type=="jets" ){
563  if(step.select(event, setup)){ ++passed;
564  selection_[key].second->fill(event, setup);
565  } else break;
566  }
567  if(type=="jets/pf" ){
569  if(step.select(event, setup)){ ++passed;
570  selection_[key].second->fill(event, setup);
571  } else break;
572  }
573  if(type=="jets/calo" ){
575  if(step.select(event, setup)){ ++passed;
576  selection_[key].second->fill(event, setup);
577  } else break;
578  }
579  if(type=="met" ){
581  if(step.select(event)){ ++passed;
582  selection_[key].second->fill(event, setup);
583  } else break;
584  }
585  }
586  }
587 }
588 
589 
std::map< std::string, MonitorElement * > hists_
histogram container
type
Definition: HCALResponse.h:22
T getParameter(std::string const &) const
int logged_
number of logged interesting events
int i
Definition: DBlmapReader.cc:9
double btagEffWP_
btag working points
boost::indirect_iterator< typename seq_t::const_iterator > const_iterator
Definition: View.h:86
bool existsAs(std::string const &parameterName, bool trackiness=true) const
checks if a parameter exists as a given type
Definition: ParameterSet.h:180
Jets made from CaloTowers.
Definition: CaloJet.h:30
bool select(const edm::Event &event)
apply selection
const std::string & label
Definition: MVAComputer.cc:186
edm::InputTag elecs_
input sources for monitoring
MonitorElement * book1D(const char *name, const char *title, int nchX, double lowX, double highX)
Book 1D histogram.
Definition: DQMStore.cc:519
edm::InputTag triggerTable_
trigger table
std::vector< edm::InputTag > mets_
considers a vector of METs
std::vector< std::string > triggerPaths_
virtual double correction(const LorentzVector &fJet) const =0
get correction using Jet information only
Base class for all types of Jets.
Definition: Jet.h:21
double massTopQuark(const std::vector< reco::Jet > &jets)
calculate W boson mass estimate
RunNumber_t run() const
StringCutObjectSelector< reco::BeamSpot > * beamspotSelect_
string cut selector
TopSingleLeptonDQM(const edm::ParameterSet &cfg)
default constructor
virtual void scaleEnergy(double fScale)
scale energy of the jet
Definition: Jet.cc:386
bool accept(const edm::Event &event, const edm::TriggerResults &triggerTable, const std::string &triggerPath)
Definition: TopDQMHelpers.h:21
Jets made from PFObjects.
Definition: PFJet.h:22
std::vector< std::string > triggerPaths_
trigger paths
double massWBoson(const std::vector< reco::Jet > &jets)
calculate W boson mass estimate
Definition: TopDQMHelpers.cc:9
std::vector< std::string > selectionOrder_
std::string selectionStep(const std::string &label)
LuminosityBlockNumber_t luminosityBlock() const
const eventsetup::EventSetupRecord * find(const eventsetup::EventSetupRecordKey &) const
Definition: EventSetup.cc:82
double deltaR(double eta1, double phi1, double eta2, double phi2)
Definition: deltaR.h:19
Level verbosity_
verbosity level for booking
bool overlap(const reco::Muon &muon1, const reco::Muon &muon2, double pullX=1.0, double pullY=1.0, bool checkAdjacentChambers=false)
edm::InputTag vertex_
primary vertex
static const double WMASS
double lowerEdge_
mass window upper and lower edge
edm::InputTag btagEff_
btag discriminator labels
Helper class for the calculation of a top and a W boson mass estime.
Definition: TopDQMHelpers.h:64
std::map< std::string, std::pair< edm::ParameterSet, TopSingleLepton::MonitorEnsemble * > > selection_
edm::InputTag beamspot_
beamspot
StringCutObjectSelector< reco::Muon > * muonSelect_
extra selection on muons
void book(std::string directory)
book histograms in subdirectory directory
edm::InputTag triggerTable_
trigger table
StringCutObjectSelector< reco::GsfElectron > * elecIso_
extra isolation criterion on electron
How EventSelector::AcceptEvent() decides whether to accept an event for output otherwise it is excluding the probing of A single or multiple positive and the trigger will pass if any such matching triggers are PASS or EXCEPTION[A criterion thatmatches no triggers at all is detected and causes a throw.] A single negative with an expectation of appropriate bit checking in the decision and the trigger will pass if any such matching triggers are FAIL or EXCEPTION A wildcarded negative criterion that matches more than one trigger in the trigger but the state exists so we define the behavior If all triggers are the negative crieriion will lead to accepting the event(this again matches the behavior of"!*"before the partial wildcard feature was incorporated).The per-event"cost"of each negative criterion with multiple relevant triggers is about the same as!*was in the past
bool first
Definition: L1TdeRCT.cc:79
bool getByLabel(InputTag const &tag, Handle< PROD > &result) const
Definition: Event.h:359
EventAuxiliary const & eventAuxiliary() const
Definition: Event.h:55
edm::InputTag jetIDLabel_
jetID as an extra selection type
std::string label_
instance label
virtual double pt() const
transverse momentum
static const JetCorrector * getJetCorrector(const std::string &fName, const edm::EventSetup &fSetup)
retrieve corrector from the event setup. troughs exception if something is missing ...
Definition: JetCorrector.cc:40
StringCutObjectSelector< reco::GsfElectron > * elecSelect_
extra selection on electrons
Templated helper class to allow a selection on a certain object collection.
std::string const & label() const
Definition: InputTag.h:25
std::string objectType(const std::string &label)
StringCutObjectSelector< reco::Muon > * muonIso_
extra isolation criterion on muon
list key
Definition: combine.py:13
void fill(const edm::Event &event, const edm::EventSetup &setup)
fill monitor histograms with electronId and jetCorrections
edm::InputTag electronId_
electronId
void triggerBinLabels(std::string channel, const std::vector< std::string > labels)
set configurable labels for trigger monitoring histograms
std::string jetCorrector_
jetCorrector
static const unsigned int MAXJETS
MonitorElement * book2D(const char *name, const char *title, int nchX, double lowX, double highX, int nchY, double lowY, double highY)
Book 2D histogram.
Definition: DQMStore.cc:647
MonitorEnsemble(const char *label, const edm::ParameterSet &cfg)
default contructor
EventNumber_t event() const
StringCutObjectSelector< reco::JetID > * jetIDSelect_
extra jetID selection on calo jets
void setCurrentFolder(const std::string &fullpath)
Definition: DQMStore.cc:237
virtual void analyze(const edm::Event &event, const edm::EventSetup &setup)
do this during the event loop
StringCutObjectSelector< reco::Vertex > * vertexSelect_
string cut selector
DQMStore * store_
storage manager