CMS 3D CMS Logo

List of all members | Public Member Functions | Protected Member Functions | Private Member Functions | Private Attributes
TopDiLeptonDQM Class Reference

#include <TopDiLeptonDQM.h>

Inheritance diagram for TopDiLeptonDQM:
DQMEDAnalyzer edm::one::EDProducer< edm::EndRunProducer, edm::one::WatchRuns, edm::EndLuminosityBlockProducer, edm::one::WatchLuminosityBlocks, edm::Accumulator > edm::one::EDProducerBase edm::ProducerBase edm::EDConsumerBase edm::ProductRegistryHelper

Public Member Functions

 TopDiLeptonDQM (const edm::ParameterSet &)
 
 ~TopDiLeptonDQM () override
 
- Public Member Functions inherited from DQMEDAnalyzer
void accumulate (edm::Event const &event, edm::EventSetup const &setup) final
 
virtual void analyze (edm::Event const &, edm::EventSetup const &)
 
void beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final
 
void beginRun (edm::Run const &run, edm::EventSetup const &setup) final
 
virtual void dqmBeginLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &)
 
virtual void dqmBeginRun (edm::Run const &, edm::EventSetup const &)
 
 DQMEDAnalyzer ()
 
virtual void dqmEndLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &)
 
virtual void dqmEndRun (edm::Run const &, edm::EventSetup const &)
 
void endLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &) final
 
void endLuminosityBlockProduce (edm::LuminosityBlock &lumi, edm::EventSetup const &setup) final
 
void endRun (edm::Run const &, edm::EventSetup const &) final
 
void endRunProduce (edm::Run &run, edm::EventSetup const &setup) final
 
virtual bool getCanSaveByLumi ()
 
- Public Member Functions inherited from edm::one::EDProducer< edm::EndRunProducer, edm::one::WatchRuns, edm::EndLuminosityBlockProducer, edm::one::WatchLuminosityBlocks, edm::Accumulator >
 EDProducer ()=default
 
SerialTaskQueueglobalLuminosityBlocksQueue () final
 
SerialTaskQueueglobalRunsQueue () final
 
bool hasAbilityToProduceInBeginLumis () const final
 
bool hasAbilityToProduceInBeginRuns () const final
 
bool hasAbilityToProduceInEndLumis () const final
 
bool hasAbilityToProduceInEndRuns () const final
 
bool wantsGlobalLuminosityBlocks () const final
 
bool wantsGlobalRuns () const final
 
- Public Member Functions inherited from edm::one::EDProducerBase
 EDProducerBase ()
 
ModuleDescription const & moduleDescription () const
 
bool wantsStreamLuminosityBlocks () const
 
bool wantsStreamRuns () const
 
 ~EDProducerBase () override
 
- Public Member Functions inherited from edm::ProducerBase
void callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
 
std::vector< edm::ProductResolverIndex > const & indiciesForPutProducts (BranchType iBranchType) const
 
 ProducerBase ()
 
std::vector< edm::ProductResolverIndex > const & putTokenIndexToProductResolverIndex () const
 
void registerProducts (ProducerBase *, ProductRegistry *, ModuleDescription const &)
 
std::function< void(BranchDescription const &)> registrationCallback () const
 used by the fwk to register list of products More...
 
void resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)
 
 ~ProducerBase () noexcept(false) override
 
- Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfoconsumesInfo () const
 
void convertCurrentProcessAlias (std::string const &processName)
 Convert "@currentProcess" in InputTag process names to the actual current process name. More...
 
 EDConsumerBase ()
 
 EDConsumerBase (EDConsumerBase const &)=delete
 
 EDConsumerBase (EDConsumerBase &&)=default
 
ESProxyIndex const * esGetTokenIndices (edm::Transition iTrans) const
 
ProductResolverIndexAndSkipBit indexFrom (EDGetToken, BranchType, TypeID const &) const
 
void itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
 
void itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
 
std::vector< ProductResolverIndexAndSkipBit > const & itemsToGetFrom (BranchType iType) const
 
void labelsForToken (EDGetToken iToken, Labels &oLabels) const
 
void modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const
 
EDConsumerBase const & operator= (EDConsumerBase const &)=delete
 
EDConsumerBaseoperator= (EDConsumerBase &&)=default
 
bool registeredToConsume (ProductResolverIndex, bool, BranchType) const
 
bool registeredToConsumeMany (TypeID const &, BranchType) const
 
ProductResolverIndexAndSkipBit uncheckedIndexFrom (EDGetToken) const
 
void updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)
 
void updateLookup (eventsetup::ESRecordsToProxyIndices const &)
 
virtual ~EDConsumerBase () noexcept(false)
 

Protected Member Functions

void bookHistograms (DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override
 
- Protected Member Functions inherited from edm::ProducerBase
ProducesCollector producesCollector ()
 
- Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType > consumes (edm::InputTag const &tag)
 
EDGetToken consumes (const TypeToGet &id, edm::InputTag const &tag)
 
template<BranchType B>
EDGetToken consumes (TypeToGet const &id, edm::InputTag const &tag)
 
ConsumesCollector consumesCollector ()
 Use a ConsumesCollector to gather consumes information from helper functions. More...
 
template<typename ProductType , BranchType B = InEvent>
void consumesMany ()
 
void consumesMany (const TypeToGet &id)
 
template<BranchType B>
void consumesMany (const TypeToGet &id)
 
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto esConsumes ()
 
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto esConsumes (ESInputTag const &tag)
 
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType > mayConsume (edm::InputTag const &tag)
 
EDGetToken mayConsume (const TypeToGet &id, edm::InputTag const &tag)
 
template<BranchType B>
EDGetToken mayConsume (const TypeToGet &id, edm::InputTag const &tag)
 

Private Member Functions

void analyze (const edm::Event &, const edm::EventSetup &) override
 

Private Attributes

MonitorElementD_eta_elecs_
 
MonitorElementD_eta_lepts_
 
MonitorElementD_eta_muons_
 
MonitorElementD_phi_elecs_
 
MonitorElementD_phi_lepts_
 
MonitorElementD_phi_muons_
 
MonitorElementdimassRC_
 
MonitorElementdimassRC_LOG10_
 
MonitorElementdimassRC_LOGX_
 
MonitorElementdimassWC_
 
MonitorElementdimassWC_LOG10_
 
MonitorElementdimassWC_LOGX_
 
float Eff [100]
 
double elec_emf_cut_
 
double elec_eta_cut_
 
double elec_iso_cut_
 
double elec_pT_cut_
 
MonitorElementElecIso_cal_
 
MonitorElementElecIso_CombRelIso_
 
MonitorElementElecIso_trk_
 
edm::EDGetTokenT< reco::GsfElectronCollectionelecs_
 
MonitorElementeta_elecs_
 
MonitorElementeta_muons_
 
MonitorElementEvents_
 
std::vector< std::string > hltPaths_
 
std::vector< std::string > hltPaths_sig_
 
std::vector< std::string > hltPaths_trig_
 
MonitorElementHoverE_elecs_
 
double MassWindow_down_
 
double MassWindow_up_
 
std::string moduleName_
 
MonitorElementMuIso_CombRelIso03_
 
MonitorElementMuIso_emEt03_
 
MonitorElementMuIso_hadEt03_
 
MonitorElementMuIso_hoEt03_
 
MonitorElementMuIso_nJets03_
 
MonitorElementMuIso_nTracks03_
 
MonitorElementMuIso_sumPt03_
 
double muon_eta_cut_
 
double muon_iso_cut_
 
double muon_pT_cut_
 
edm::EDGetTokenT< reco::MuonCollectionmuons_
 
int N_elel
 
int N_muel
 
int N_mumu
 
int N_sig [100]
 
int N_trig [100]
 
MonitorElementNelecs_
 
MonitorElementNelecs_charge_
 
MonitorElementNelecs_iso_
 
MonitorElementNmuons_
 
MonitorElementNmuons_charge_
 
MonitorElementNmuons_iso_
 
MonitorElementNtracks_
 
std::ofstream outfile
 
std::string outputFile_
 
MonitorElementphi_elecs_
 
MonitorElementphi_muons_
 
MonitorElementpT_elecs_
 
MonitorElementpT_muons_
 
MonitorElementTriggerEff_
 
edm::EDGetTokenT< edm::TriggerResultstriggerResults_
 
MonitorElementTrigs_
 
edm::EDGetTokenT< reco::VertexCollectionvertex_
 
double vertex_X_cut_
 
double vertex_Y_cut_
 
double vertex_Z_cut_
 
MonitorElementVxVy_muons_
 
MonitorElementVz_muons_
 

Additional Inherited Members

- Public Types inherited from DQMEDAnalyzer
typedef dqm::reco::DQMStore DQMStore
 
typedef dqm::reco::MonitorElement MonitorElement
 
- Public Types inherited from edm::one::EDProducerBase
typedef EDProducerBase ModuleType
 
- Public Types inherited from edm::ProducerBase
using ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const *, const char *, edm::ProductResolverIndex >>
 
typedef ProductRegistryHelper::TypeLabelList TypeLabelList
 
- Public Types inherited from edm::EDConsumerBase
typedef ProductLabels Labels
 
- Static Public Member Functions inherited from edm::one::EDProducerBase
static const std::string & baseType ()
 
static void fillDescriptions (ConfigurationDescriptions &descriptions)
 
static void prevalidate (ConfigurationDescriptions &descriptions)
 
- Protected Attributes inherited from DQMEDAnalyzer
edm::EDPutTokenT< DQMTokenlumiToken_
 
edm::EDPutTokenT< DQMTokenrunToken_
 

Detailed Description

Definition at line 38 of file TopDiLeptonDQM.h.

Constructor & Destructor Documentation

TopDiLeptonDQM::TopDiLeptonDQM ( const edm::ParameterSet ps)
explicit

Definition at line 16 of file TopDiLeptonDQM.cc.

References edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), mps_fire::i, and commonCuts_cff::triggerResults_.

16  {
17  moduleName_ = ps.getUntrackedParameter<string>("moduleName");
18  outputFile_ = ps.getUntrackedParameter<string>("outputFile");
19  triggerResults_ = consumes<TriggerResults>(ps.getParameter<edm::InputTag>("TriggerResults"));
20  hltPaths_ = ps.getParameter<vector<string> >("hltPaths");
21  hltPaths_sig_ = ps.getParameter<vector<string> >("hltPaths_sig");
22  hltPaths_trig_ = ps.getParameter<vector<string> >("hltPaths_trig");
23 
24  vertex_ = consumes<reco::VertexCollection>(ps.getParameter<edm::InputTag>("vertexCollection"));
25  vertex_X_cut_ = ps.getParameter<double>("vertex_X_cut");
26  vertex_Y_cut_ = ps.getParameter<double>("vertex_Y_cut");
27  vertex_Z_cut_ = ps.getParameter<double>("vertex_Z_cut");
28 
29  muons_ = consumes<reco::MuonCollection>(ps.getParameter<edm::InputTag>("muonCollection"));
30  muon_pT_cut_ = ps.getParameter<double>("muon_pT_cut");
31  muon_eta_cut_ = ps.getParameter<double>("muon_eta_cut");
32  muon_iso_cut_ = ps.getParameter<double>("muon_iso_cut");
33 
34  elecs_ = consumes<reco::GsfElectronCollection>(ps.getParameter<edm::InputTag>("elecCollection"));
35  elec_pT_cut_ = ps.getParameter<double>("elec_pT_cut");
36  elec_eta_cut_ = ps.getParameter<double>("elec_eta_cut");
37  elec_iso_cut_ = ps.getParameter<double>("elec_iso_cut");
38  elec_emf_cut_ = ps.getParameter<double>("elec_emf_cut");
39 
40  MassWindow_up_ = ps.getParameter<double>("MassWindow_up");
41  MassWindow_down_ = ps.getParameter<double>("MassWindow_down");
42 
43  for (int i = 0; i < 100; ++i) {
44  N_sig[i] = 0;
45  N_trig[i] = 0;
46  Eff[i] = 0.;
47  }
48 
49  N_mumu = 0;
50  N_muel = 0;
51  N_elel = 0;
52  Events_ = nullptr;
53  Trigs_ = nullptr;
54  TriggerEff_ = nullptr;
55  Ntracks_ = nullptr;
56  Nmuons_ = nullptr;
57  Nmuons_iso_ = nullptr;
58  Nmuons_charge_ = nullptr;
59  VxVy_muons_ = nullptr;
60  Vz_muons_ = nullptr;
61  pT_muons_ = nullptr;
62  eta_muons_ = nullptr;
63  phi_muons_ = nullptr;
64  Nelecs_ = nullptr;
65  Nelecs_iso_ = nullptr;
66  Nelecs_charge_ = nullptr;
67  HoverE_elecs_ = nullptr;
68  pT_elecs_ = nullptr;
69  eta_elecs_ = nullptr;
70  phi_elecs_ = nullptr;
71  MuIso_emEt03_ = nullptr;
72  MuIso_hadEt03_ = nullptr;
73  MuIso_hoEt03_ = nullptr;
74  MuIso_nJets03_ = nullptr;
75  MuIso_nTracks03_ = nullptr;
76  MuIso_sumPt03_ = nullptr;
77  MuIso_CombRelIso03_ = nullptr;
78  ElecIso_cal_ = nullptr;
79  ElecIso_trk_ = nullptr;
80  ElecIso_CombRelIso_ = nullptr;
81  dimassRC_ = nullptr;
82  dimassWC_ = nullptr;
83  dimassRC_LOGX_ = nullptr;
84  dimassWC_LOGX_ = nullptr;
85  dimassRC_LOG10_ = nullptr;
86  dimassWC_LOG10_ = nullptr;
87  D_eta_muons_ = nullptr;
88  D_phi_muons_ = nullptr;
89  D_eta_elecs_ = nullptr;
90  D_phi_elecs_ = nullptr;
91  D_eta_lepts_ = nullptr;
92  D_phi_lepts_ = nullptr;
93 }
double muon_iso_cut_
T getParameter(std::string const &) const
double vertex_Y_cut_
MonitorElement * Nelecs_charge_
T getUntrackedParameter(std::string const &, T const &) const
MonitorElement * dimassRC_
MonitorElement * D_phi_muons_
MonitorElement * D_phi_lepts_
std::string outputFile_
MonitorElement * dimassWC_LOG10_
double vertex_Z_cut_
MonitorElement * HoverE_elecs_
MonitorElement * D_eta_muons_
MonitorElement * D_phi_elecs_
std::vector< std::string > hltPaths_trig_
edm::EDGetTokenT< reco::GsfElectronCollection > elecs_
MonitorElement * phi_elecs_
MonitorElement * Nmuons_charge_
edm::EDGetTokenT< reco::VertexCollection > vertex_
MonitorElement * MuIso_sumPt03_
MonitorElement * eta_muons_
MonitorElement * ElecIso_cal_
double muon_eta_cut_
MonitorElement * MuIso_nTracks03_
MonitorElement * eta_elecs_
edm::EDGetTokenT< reco::MuonCollection > muons_
MonitorElement * dimassRC_LOGX_
MonitorElement * D_eta_elecs_
MonitorElement * TriggerEff_
MonitorElement * MuIso_hoEt03_
double MassWindow_up_
MonitorElement * Ntracks_
double elec_emf_cut_
MonitorElement * Nmuons_
MonitorElement * phi_muons_
MonitorElement * D_eta_lepts_
MonitorElement * Nmuons_iso_
MonitorElement * VxVy_muons_
float Eff[100]
double MassWindow_down_
MonitorElement * ElecIso_trk_
MonitorElement * pT_elecs_
MonitorElement * Vz_muons_
double elec_eta_cut_
MonitorElement * ElecIso_CombRelIso_
MonitorElement * Events_
std::vector< std::string > hltPaths_
double elec_iso_cut_
MonitorElement * dimassWC_
MonitorElement * dimassWC_LOGX_
std::string moduleName_
edm::EDGetTokenT< edm::TriggerResults > triggerResults_
MonitorElement * MuIso_nJets03_
std::vector< std::string > hltPaths_sig_
MonitorElement * Trigs_
MonitorElement * dimassRC_LOG10_
MonitorElement * MuIso_emEt03_
MonitorElement * pT_muons_
MonitorElement * Nelecs_iso_
MonitorElement * Nelecs_
double vertex_X_cut_
MonitorElement * MuIso_hadEt03_
MonitorElement * MuIso_CombRelIso03_
TopDiLeptonDQM::~TopDiLeptonDQM ( )
override

Definition at line 95 of file TopDiLeptonDQM.cc.

95 {}

Member Function Documentation

void TopDiLeptonDQM::analyze ( const edm::Event evt,
const edm::EventSetup context 
)
overrideprivate

Definition at line 168 of file TopDiLeptonDQM.cc.

References funct::abs(), edm::HLTGlobalStatus::accept(), reco::GsfElectron::IsolationVariables::ecalRecHitSumEt, singleTopDQM_cfi::elecs, reco::MuonIsolation::emEt, edm::HandleBase::failedToGet(), edm::Event::getByToken(), reco::MuonIsolation::hadEt, reco::GsfElectron::IsolationVariables::hcalDepth1TowerSumEt, reco::MuonIsolation::hoEt, mps_fire::i, reco::Vertex::isFake(), dqmiolumiharvest::j, dqmdumpme::k, HLT_2018_cff::muon, PDWG_BPHSkim_cff::muons, reco::MuonIsolation::nJets, reco::MuonIsolation::nTracks, BeamMonitor_cff::primaryVertex, edm::Handle< T >::product(), edm::HLTGlobalStatus::size(), mathSSE::sqrt(), reco::MuonIsolation::sumPt, reco::GsfElectron::IsolationVariables::tkSumPt, HLT_2018_cff::track, reco::Vertex::tracksSize(), edm::TriggerNames::triggerName(), edm::Event::triggerNames(), commonCuts_cff::triggerResults_, EgHLTOffTrigSelection_cfi::trigName, reco::Vertex::x(), reco::Vertex::y(), and reco::Vertex::z().

168  {
169  // ------------------------
170  // Global Event Variables
171  // ------------------------
172 
173  const int N_TriggerPaths = hltPaths_.size();
174  const int N_SignalPaths = hltPaths_sig_.size();
175  const int N_ControlPaths = hltPaths_trig_.size();
176 
177  bool Fired_Signal_Trigger[100] = {false};
178  bool Fired_Control_Trigger[100] = {false};
179 
180  int N_leptons = 0;
181  int N_iso_mu = 0;
182  int N_iso_el = 0;
183 
184  double DilepMass = 0.;
185 
186  double vertex_X = 100.;
187  double vertex_Y = 100.;
188  double vertex_Z = 100.;
189 
190  // ------------------------
191  // Analyze Primary Vertex
192  // ------------------------
193 
195  evt.getByToken(vertex_, vertexs);
196 
197  if (!vertexs.failedToGet()) {
198  reco::Vertex primaryVertex = vertexs->front();
199 
200  int numberTracks = primaryVertex.tracksSize();
201  // double ndof = primaryVertex.ndof();
202  bool fake = primaryVertex.isFake();
203 
204  Ntracks_->Fill(numberTracks);
205 
206  if (!fake && numberTracks > 3) {
207  vertex_X = primaryVertex.x();
208  vertex_Y = primaryVertex.y();
209  vertex_Z = primaryVertex.z();
210  }
211  }
212 
213  // -------------------------
214  // Analyze Trigger Results
215  // -------------------------
216 
217  edm::Handle<TriggerResults> trigResults;
218  evt.getByToken(triggerResults_, trigResults);
219 
220  if (!trigResults.failedToGet()) {
221  int N_Triggers = trigResults->size();
222 
223  const edm::TriggerNames& trigName = evt.triggerNames(*trigResults);
224 
225  for (int i_Trig = 0; i_Trig < N_Triggers; ++i_Trig) {
226  if (trigResults.product()->accept(i_Trig)) {
227  // Check for all trigger paths
228 
229  for (int i = 0; i < N_TriggerPaths; i++) {
230  if (trigName.triggerName(i_Trig) == hltPaths_[i]) {
231  Trigs_->Fill(i);
232  Trigs_->setBinLabel(i + 1, hltPaths_[i], 1);
233  }
234  }
235 
236  // Check for signal & control trigger paths
237 
238  for (int j = 0; j < N_SignalPaths; ++j) {
239  if (trigName.triggerName(i_Trig) == hltPaths_sig_[j])
240  Fired_Signal_Trigger[j] = true;
241  }
242 
243  for (int k = 0; k < N_ControlPaths; ++k) {
244  if (trigName.triggerName(i_Trig) == hltPaths_trig_[k])
245  Fired_Control_Trigger[k] = true;
246  }
247  }
248  }
249  }
250 
251  // ------------------------
252  // Analyze Muon Isolation
253  // ------------------------
254 
256  evt.getByToken(muons_, muons);
257 
258  reco::MuonCollection::const_iterator muon;
259 
260  if (!muons.failedToGet()) {
261  Nmuons_->Fill(muons->size());
262 
263  N_leptons = N_leptons + muons->size();
264 
265  for (muon = muons->begin(); muon != muons->end(); ++muon) {
266  float N_muons = muons->size();
267  float Q_muon = muon->charge();
268 
269  Nmuons_charge_->Fill(N_muons * Q_muon);
270 
271  double track_X = 100.;
272  double track_Y = 100.;
273  double track_Z = 100.;
274 
275  if (muon->isGlobalMuon()) {
276  reco::TrackRef track = muon->globalTrack();
277 
278  track_X = track->vx();
279  track_Y = track->vy();
280  track_Z = track->vz();
281 
282  VxVy_muons_->Fill(track_X, track_Y);
283  Vz_muons_->Fill(track_Z);
284  }
285 
286  // Vertex and kinematic cuts
287 
288  if (track_X > vertex_X_cut_)
289  continue;
290  if (track_Y > vertex_Y_cut_)
291  continue;
292  if (track_Z > vertex_Z_cut_)
293  continue;
294  if (muon->pt() < muon_pT_cut_)
295  continue;
296  if (abs(muon->eta()) > muon_eta_cut_)
297  continue;
298 
299  reco::MuonIsolation muIso03 = muon->isolationR03();
300 
301  double muonCombRelIso = 1.;
302 
303  if (muon->pt() != 0.)
304  muonCombRelIso = (muIso03.emEt + muIso03.hadEt + muIso03.hoEt + muIso03.sumPt) / muon->pt();
305 
306  MuIso_CombRelIso03_->Fill(muonCombRelIso);
307 
308  MuIso_emEt03_->Fill(muIso03.emEt);
309  MuIso_hadEt03_->Fill(muIso03.hadEt);
310  MuIso_hoEt03_->Fill(muIso03.hoEt);
311  MuIso_nJets03_->Fill(muIso03.nJets);
312  MuIso_nTracks03_->Fill(muIso03.nTracks);
313  MuIso_sumPt03_->Fill(muIso03.sumPt);
314 
315  if (muonCombRelIso < muon_iso_cut_)
316  ++N_iso_mu;
317  }
318 
319  Nmuons_iso_->Fill(N_iso_mu);
320  }
321 
322  // ----------------------------
323  // Analyze Electron Isolation
324  // ----------------------------
325 
327  evt.getByToken(elecs_, elecs);
328 
329  reco::GsfElectronCollection::const_iterator elec;
330 
331  if (!elecs.failedToGet()) {
332  Nelecs_->Fill(elecs->size());
333 
334  N_leptons = N_leptons + elecs->size();
335 
336  for (elec = elecs->begin(); elec != elecs->end(); ++elec) {
337  float N_elecs = elecs->size();
338  float Q_elec = elec->charge();
339  float HoverE = elec->hcalOverEcal();
340 
341  HoverE_elecs_->Fill(HoverE);
342 
343  Nelecs_charge_->Fill(N_elecs * Q_elec);
344 
345  double track_X = 100.;
346  double track_Y = 100.;
347  double track_Z = 100.;
348 
349  reco::GsfTrackRef track = elec->gsfTrack();
350 
351  track_X = track->vx();
352  track_Y = track->vy();
353  track_Z = track->vz();
354 
355  // Vertex and kinematic cuts
356 
357  if (track_X > vertex_X_cut_)
358  continue;
359  if (track_Y > vertex_Y_cut_)
360  continue;
361  if (track_Z > vertex_Z_cut_)
362  continue;
363  if (elec->pt() < elec_pT_cut_)
364  continue;
365  if (abs(elec->eta()) > elec_eta_cut_)
366  continue;
367  if (HoverE > elec_emf_cut_)
368  continue;
369 
370  reco::GsfElectron::IsolationVariables elecIso = elec->dr03IsolationVariables();
371 
372  double elecCombRelIso = 1.;
373 
374  if (elec->et() != 0.)
375  elecCombRelIso = (elecIso.ecalRecHitSumEt + elecIso.hcalDepth1TowerSumEt + elecIso.tkSumPt) / elec->et();
376 
377  ElecIso_CombRelIso_->Fill(elecCombRelIso);
378 
380  ElecIso_trk_->Fill(elecIso.tkSumPt);
381 
382  if (elecCombRelIso < elec_iso_cut_)
383  ++N_iso_el;
384  }
385 
386  Nelecs_iso_->Fill(N_iso_el);
387  }
388 
389  // --------------------
390  // TWO Isolated MUONS
391  // --------------------
392 
393  if (N_iso_mu > 1) {
394  // Vertex cut
395 
396  if (vertex_X < vertex_X_cut_ && vertex_Y < vertex_Y_cut_ && vertex_Z < vertex_Z_cut_) {
397  ++N_mumu;
398 
399  Events_->Fill(1.);
400 
401  reco::MuonCollection::const_reference mu1 = muons->at(0);
402  reco::MuonCollection::const_reference mu2 = muons->at(1);
403 
404  DilepMass = sqrt((mu1.energy() + mu2.energy()) * (mu1.energy() + mu2.energy()) -
405  (mu1.px() + mu2.px()) * (mu1.px() + mu2.px()) - (mu1.py() + mu2.py()) * (mu1.py() + mu2.py()) -
406  (mu1.pz() + mu2.pz()) * (mu1.pz() + mu2.pz()));
407 
408  // Opposite muon charges -> Right Charge (RC)
409 
410  if (mu1.charge() * mu2.charge() < 0.) {
411  dimassRC_LOG10_->Fill(log10(DilepMass));
412  dimassRC_->Fill(DilepMass);
413  dimassRC_LOGX_->Fill(DilepMass);
414 
415  if (DilepMass > MassWindow_down_ && DilepMass < MassWindow_up_) {
416  for (muon = muons->begin(); muon != muons->end(); ++muon) {
417  pT_muons_->Fill(muon->pt());
418  eta_muons_->Fill(muon->eta());
419  phi_muons_->Fill(muon->phi());
420  }
421 
422  D_eta_muons_->Fill(mu1.eta() - mu2.eta());
423  D_phi_muons_->Fill(mu1.phi() - mu2.phi());
424 
425  // Determinating trigger efficiencies
426 
427  for (int k = 0; k < N_SignalPaths; ++k) {
428  if (Fired_Signal_Trigger[k] && Fired_Control_Trigger[k])
429  ++N_sig[k];
430 
431  if (Fired_Control_Trigger[k])
432  ++N_trig[k];
433 
434  if (N_trig[k] != 0)
435  Eff[k] = N_sig[k] / static_cast<float>(N_trig[k]);
436 
437  TriggerEff_->setBinContent(k + 1, Eff[k]);
438  TriggerEff_->setBinLabel(k + 1, "#frac{[" + hltPaths_sig_[k] + "]}{vs. [" + hltPaths_trig_[k] + "]}", 1);
439  }
440  }
441  }
442 
443  // Same muon charges -> Wrong Charge (WC)
444 
445  if (mu1.charge() * mu2.charge() > 0.) {
446  dimassWC_LOG10_->Fill(log10(DilepMass));
447  dimassWC_->Fill(DilepMass);
448  dimassWC_LOGX_->Fill(DilepMass);
449  }
450  }
451  }
452 
453  // -----------------------------
454  // TWO Isolated LEPTONS (mu/e)
455  // -----------------------------
456 
457  if (N_iso_el > 0 && N_iso_mu > 0) {
458  // Vertex cut
459 
460  if (vertex_X < vertex_X_cut_ && vertex_Y < vertex_Y_cut_ && vertex_Z < vertex_Z_cut_) {
461  ++N_muel;
462 
463  Events_->Fill(2.);
464 
465  reco::MuonCollection::const_reference mu1 = muons->at(0);
466  reco::GsfElectronCollection::const_reference el1 = elecs->at(0);
467 
468  DilepMass = sqrt((mu1.energy() + el1.energy()) * (mu1.energy() + el1.energy()) -
469  (mu1.px() + el1.px()) * (mu1.px() + el1.px()) - (mu1.py() + el1.py()) * (mu1.py() + el1.py()) -
470  (mu1.pz() + el1.pz()) * (mu1.pz() + el1.pz()));
471 
472  // Opposite lepton charges -> Right Charge (RC)
473 
474  if (mu1.charge() * el1.charge() < 0.) {
475  dimassRC_LOG10_->Fill(log10(DilepMass));
476  dimassRC_->Fill(DilepMass);
477  dimassRC_LOGX_->Fill(DilepMass);
478 
479  if (DilepMass > MassWindow_down_ && DilepMass < MassWindow_up_) {
480  for (muon = muons->begin(); muon != muons->end(); ++muon) {
481  pT_muons_->Fill(muon->pt());
482  eta_muons_->Fill(muon->eta());
483  phi_muons_->Fill(muon->phi());
484  }
485 
486  for (elec = elecs->begin(); elec != elecs->end(); ++elec) {
487  pT_elecs_->Fill(elec->pt());
488  eta_elecs_->Fill(elec->eta());
489  phi_elecs_->Fill(elec->phi());
490  }
491 
492  D_eta_lepts_->Fill(mu1.eta() - el1.eta());
493  D_phi_lepts_->Fill(mu1.phi() - el1.phi());
494 
495  // Determinating trigger efficiencies
496 
497  for (int k = 0; k < N_SignalPaths; ++k) {
498  if (Fired_Signal_Trigger[k] && Fired_Control_Trigger[k])
499  ++N_sig[k];
500 
501  if (Fired_Control_Trigger[k])
502  ++N_trig[k];
503 
504  if (N_trig[k] != 0)
505  Eff[k] = N_sig[k] / static_cast<float>(N_trig[k]);
506 
507  TriggerEff_->setBinContent(k + 1, Eff[k]);
508  TriggerEff_->setBinLabel(k + 1, "#frac{[" + hltPaths_sig_[k] + "]}{vs. [" + hltPaths_trig_[k] + "]}", 1);
509  }
510  }
511  }
512 
513  // Same muon charges -> Wrong Charge (WC)
514 
515  if (mu1.charge() * el1.charge() > 0.) {
516  dimassWC_LOG10_->Fill(log10(DilepMass));
517  dimassWC_->Fill(DilepMass);
518  dimassWC_LOGX_->Fill(DilepMass);
519  }
520  }
521  }
522 
523  // ------------------------
524  // TWO Isolated ELECTRONS
525  // ------------------------
526 
527  if (N_iso_el > 1) {
528  // Vertex cut
529 
530  if (vertex_X < vertex_X_cut_ && vertex_Y < vertex_Y_cut_ && vertex_Z < vertex_Z_cut_) {
531  ++N_elel;
532 
533  Events_->Fill(3.);
534 
535  reco::GsfElectronCollection::const_reference el1 = elecs->at(0);
536  reco::GsfElectronCollection::const_reference el2 = elecs->at(1);
537 
538  DilepMass = sqrt((el1.energy() + el2.energy()) * (el1.energy() + el2.energy()) -
539  (el1.px() + el2.px()) * (el1.px() + el2.px()) - (el1.py() + el2.py()) * (el1.py() + el2.py()) -
540  (el1.pz() + el2.pz()) * (el1.pz() + el2.pz()));
541 
542  // Opposite lepton charges -> Right Charge (RC)
543 
544  if (el1.charge() * el2.charge() < 0.) {
545  dimassRC_LOG10_->Fill(log10(DilepMass));
546  dimassRC_->Fill(DilepMass);
547  dimassRC_LOGX_->Fill(DilepMass);
548 
549  if (DilepMass > MassWindow_down_ && DilepMass < MassWindow_up_) {
550  for (elec = elecs->begin(); elec != elecs->end(); ++elec) {
551  pT_elecs_->Fill(elec->pt());
552  eta_elecs_->Fill(elec->eta());
553  phi_elecs_->Fill(elec->phi());
554  }
555 
556  D_eta_elecs_->Fill(el1.eta() - el2.eta());
557  D_phi_elecs_->Fill(el1.phi() - el2.phi());
558 
559  // Determinating trigger efficiencies
560 
561  for (int k = 0; k < N_SignalPaths; ++k) {
562  if (Fired_Signal_Trigger[k] && Fired_Control_Trigger[k])
563  ++N_sig[k];
564 
565  if (Fired_Control_Trigger[k])
566  ++N_trig[k];
567 
568  if (N_trig[k] != 0)
569  Eff[k] = N_sig[k] / static_cast<float>(N_trig[k]);
570 
571  TriggerEff_->setBinContent(k + 1, Eff[k]);
572  TriggerEff_->setBinLabel(k + 1, "#frac{[" + hltPaths_sig_[k] + "]}{vs. [" + hltPaths_trig_[k] + "]}", 1);
573  }
574  }
575  }
576 
577  // Same muon charges -> Wrong Charge (WC)
578 
579  if (el1.charge() * el2.charge() > 0.) {
580  dimassWC_LOG10_->Fill(log10(DilepMass));
581  dimassWC_->Fill(DilepMass);
582  dimassWC_LOGX_->Fill(DilepMass);
583  }
584  }
585  }
586 }
double muon_iso_cut_
float hadEt
hcal sum-Et
Definition: MuonIsolation.h:8
double vertex_Y_cut_
MonitorElement * Nelecs_charge_
MonitorElement * dimassRC_
MonitorElement * D_phi_muons_
MonitorElement * D_phi_lepts_
MonitorElement * dimassWC_LOG10_
double vertex_Z_cut_
float sumPt
sum-pt of tracks
Definition: MuonIsolation.h:6
MonitorElement * HoverE_elecs_
MonitorElement * D_eta_muons_
MonitorElement * D_phi_elecs_
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:525
std::vector< std::string > hltPaths_trig_
edm::EDGetTokenT< reco::GsfElectronCollection > elecs_
double y() const
y coordinate
Definition: Vertex.h:117
MonitorElement * phi_elecs_
MonitorElement * Nmuons_charge_
edm::EDGetTokenT< reco::VertexCollection > vertex_
MonitorElement * MuIso_sumPt03_
bool accept() const
Has at least one path accepted the event?
MonitorElement * eta_muons_
MonitorElement * ElecIso_cal_
double muon_eta_cut_
MonitorElement * MuIso_nTracks03_
MonitorElement * eta_elecs_
edm::EDGetTokenT< reco::MuonCollection > muons_
MonitorElement * dimassRC_LOGX_
MonitorElement * D_eta_elecs_
MonitorElement * TriggerEff_
MonitorElement * MuIso_hoEt03_
double MassWindow_up_
void Fill(long long x)
MonitorElement * Ntracks_
double elec_emf_cut_
MonitorElement * Nmuons_
T sqrt(T t)
Definition: SSEVec.h:19
unsigned int size() const
Get number of paths stored.
MonitorElement * phi_muons_
float emEt
ecal sum-Et
Definition: MuonIsolation.h:7
int nJets
number of jets in the cone
Definition: MuonIsolation.h:11
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
double z() const
z coordinate
Definition: Vertex.h:119
MonitorElement * D_eta_lepts_
float hoEt
ho sum-Et
Definition: MuonIsolation.h:9
MonitorElement * Nmuons_iso_
MonitorElement * VxVy_muons_
float Eff[100]
double MassWindow_down_
virtual void setBinLabel(int bin, const std::string &label, int axis=1)
set bin label for x, y or z axis (axis=1, 2, 3 respectively)
MonitorElement * ElecIso_trk_
int nTracks
number of tracks in the cone (excluding veto region)
Definition: MuonIsolation.h:10
MonitorElement * pT_elecs_
bool failedToGet() const
Definition: HandleBase.h:72
double x() const
x coordinate
Definition: Vertex.h:115
bool isFake() const
Definition: Vertex.h:75
T const * product() const
Definition: Handle.h:69
MonitorElement * Vz_muons_
virtual void setBinContent(int binx, double content)
set content of bin (1-D)
std::string const & triggerName(unsigned int index) const
Definition: TriggerNames.cc:22
double elec_eta_cut_
MonitorElement * ElecIso_CombRelIso_
MonitorElement * Events_
std::vector< std::string > hltPaths_
double elec_iso_cut_
MonitorElement * dimassWC_
MonitorElement * dimassWC_LOGX_
edm::EDGetTokenT< edm::TriggerResults > triggerResults_
MonitorElement * MuIso_nJets03_
std::vector< std::string > hltPaths_sig_
MonitorElement * Trigs_
MonitorElement * dimassRC_LOG10_
MonitorElement * MuIso_emEt03_
MonitorElement * pT_muons_
primaryVertex
hltOfflineBeamSpot for HLTMON
edm::TriggerNames const & triggerNames(edm::TriggerResults const &triggerResults) const override
Definition: Event.cc:265
size_t tracksSize() const
number of tracks
Definition: Vertex.cc:69
MonitorElement * Nelecs_iso_
MonitorElement * Nelecs_
double vertex_X_cut_
MonitorElement * MuIso_hadEt03_
MonitorElement * MuIso_CombRelIso03_
void TopDiLeptonDQM::bookHistograms ( DQMStore::IBooker iBooker,
edm::Run const &  ,
edm::EventSetup const &   
)
overrideprotectedvirtual

Implements DQMEDAnalyzer.

Definition at line 97 of file TopDiLeptonDQM.cc.

References trigObjTnPSource_cfi::bins, dqm::dqmstoreimpl::DQMStore::IBooker::book1D(), dqm::dqmstoreimpl::DQMStore::IBooker::book2D(), mps_fire::i, dqm-mbProfile::log, LaserClient_cfi::nbins, funct::pow(), dqm::impl::MonitorElement::setBinLabel(), dqm::dqmstoreimpl::DQMStore::IBooker::setCurrentFolder(), and dqm::impl::MonitorElement::setTitle().

97  {
98  iBooker.setCurrentFolder(moduleName_);
99 
100  Events_ = iBooker.book1D("00_Events", "Isolated dilepton events", 5, 0., 5.);
101  Events_->setBinLabel(2, "#mu #mu", 1);
102  Events_->setBinLabel(3, "#mu e", 1);
103  Events_->setBinLabel(4, "e e", 1);
104 
105  Trigs_ = iBooker.book1D("01_Trigs", "Fired muon/electron triggers", 15, 0., 15.);
106  TriggerEff_ = iBooker.book1D("02_TriggerEff", "HL Trigger Efficiencies", 10, 0., 10.);
108  "HL Trigger Efficiencies #epsilon_{signal} = #frac{[signal] && "
109  "[control]}{[control]}");
110  Ntracks_ = iBooker.book1D("Ntracks", "Number of tracks", 50, 0., 50.);
111 
112  Nmuons_ = iBooker.book1D("03_Nmuons", "Number of muons", 20, 0., 10.);
113  Nmuons_iso_ = iBooker.book1D("04_Nmuons_iso", "Number of isolated muons", 20, 0., 10.);
114  Nmuons_charge_ = iBooker.book1D("Nmuons_charge", "Number of muons * moun charge", 19, -10., 10.);
115  VxVy_muons_ = iBooker.book2D("VxVy_muons", "Vertex x-y-positon (global)", 40, -1., 1., 40, -1., 1.);
116  Vz_muons_ = iBooker.book1D("Vz_muons", "Vertex z-positon (global)", 40, -20., 20.);
117  pT_muons_ = iBooker.book1D("pT_muons", "P_T of muons", 40, 0., 200.);
118  eta_muons_ = iBooker.book1D("eta_muons", "Eta of muons", 50, -5., 5.);
119  phi_muons_ = iBooker.book1D("phi_muons", "Phi of muons", 40, -4., 4.);
120 
121  Nelecs_ = iBooker.book1D("05_Nelecs", "Number of electrons", 20, 0., 10.);
122  Nelecs_iso_ = iBooker.book1D("06_Nelecs_iso", "Number of isolated electrons", 20, 0., 10.);
123  Nelecs_charge_ = iBooker.book1D("Nelecs_charge", "Number of elecs * elec charge", 19, -10., 10.);
124  HoverE_elecs_ = iBooker.book1D("HoverE_elecs", "Hadronic over Ecal energy", 50, 0., 1.);
125  pT_elecs_ = iBooker.book1D("pT_elecs", "P_T of electrons", 40, 0., 200.);
126  eta_elecs_ = iBooker.book1D("eta_elecs", "Eta of electrons", 50, -5., 5.);
127  phi_elecs_ = iBooker.book1D("phi_elecs", "Phi of electrons", 40, -4., 4.);
128 
129  MuIso_emEt03_ = iBooker.book1D("MuIso_emEt03", "Muon emEt03", 20, 0., 20.);
130  MuIso_hadEt03_ = iBooker.book1D("MuIso_hadEt03", "Muon hadEt03", 20, 0., 20.);
131  MuIso_hoEt03_ = iBooker.book1D("MuIso_hoEt03", "Muon hoEt03", 20, 0., 20.);
132  MuIso_nJets03_ = iBooker.book1D("MuIso_nJets03", "Muon nJets03", 10, 0., 10.);
133  MuIso_nTracks03_ = iBooker.book1D("MuIso_nTracks03", "Muon nTracks03", 20, 0., 20.);
134  MuIso_sumPt03_ = iBooker.book1D("MuIso_sumPt03", "Muon sumPt03", 20, 0., 40.);
135  MuIso_CombRelIso03_ = iBooker.book1D("07_MuIso_CombRelIso03", "Muon CombRelIso03", 20, 0., 1.);
136 
137  ElecIso_cal_ = iBooker.book1D("ElecIso_cal", "Electron Iso_cal", 21, -1., 20.);
138  ElecIso_trk_ = iBooker.book1D("ElecIso_trk", "Electron Iso_trk", 21, -2., 40.);
139  ElecIso_CombRelIso_ = iBooker.book1D("08_ElecIso_CombRelIso", "Electron CombRelIso", 20, 0., 1.);
140 
141  const int nbins = 200;
142 
143  double logmin = 0.;
144  double logmax = 3.; // 10^(3.)=1000
145 
146  float bins[nbins + 1];
147 
148  for (int i = 0; i <= nbins; i++) {
149  double log = logmin + (logmax - logmin) * i / nbins;
150  bins[i] = std::pow(10.0, log);
151  }
152 
153  dimassRC_ = iBooker.book1D("09_dimassRC", "Dilepton mass RC", 50, 0., 200.);
154  dimassWC_ = iBooker.book1D("11_dimassWC", "Dilepton mass WC", 50, 0., 200.);
155  dimassRC_LOGX_ = iBooker.book1D("10_dimassRC_LOGX", "Dilepton mass RC LOG", nbins, &bins[0]);
156  dimassWC_LOGX_ = iBooker.book1D("12_dimassWC_LOGX", "Dilepton mass WC LOG", nbins, &bins[0]);
157  dimassRC_LOG10_ = iBooker.book1D("dimassRC_LOG10", "Dilepton mass RC LOG", 50, 0., 2.5);
158  dimassWC_LOG10_ = iBooker.book1D("dimassWC_LOG10", "Dilepton mass WC LOG", 50, 0., 2.5);
159 
160  D_eta_muons_ = iBooker.book1D("13_D_eta_muons", "#Delta eta_muons", 20, -5., 5.);
161  D_phi_muons_ = iBooker.book1D("14_D_phi_muons", "#Delta phi_muons", 20, -5., 5.);
162  D_eta_elecs_ = iBooker.book1D("D_eta_elecs", "#Delta eta_elecs", 20, -5., 5.);
163  D_phi_elecs_ = iBooker.book1D("D_phi_elecs", "#Delta phi_elecs", 20, -5., 5.);
164  D_eta_lepts_ = iBooker.book1D("D_eta_lepts", "#Delta eta_lepts", 20, -5., 5.);
165  D_phi_lepts_ = iBooker.book1D("D_phi_lepts", "#Delta phi_lepts", 20, -5., 5.);
166 }
MonitorElement * Nelecs_charge_
virtual void setTitle(const std::string &title)
set (ie. change) histogram/profile title
MonitorElement * dimassRC_
MonitorElement * D_phi_muons_
MonitorElement * D_phi_lepts_
MonitorElement * dimassWC_LOG10_
MonitorElement * HoverE_elecs_
MonitorElement * D_eta_muons_
MonitorElement * D_phi_elecs_
MonitorElement * phi_elecs_
MonitorElement * Nmuons_charge_
MonitorElement * MuIso_sumPt03_
MonitorElement * eta_muons_
MonitorElement * ElecIso_cal_
MonitorElement * MuIso_nTracks03_
MonitorElement * eta_elecs_
MonitorElement * dimassRC_LOGX_
MonitorElement * D_eta_elecs_
MonitorElement * TriggerEff_
MonitorElement * MuIso_hoEt03_
MonitorElement * Ntracks_
MonitorElement * Nmuons_
MonitorElement * phi_muons_
MonitorElement * D_eta_lepts_
MonitorElement * Nmuons_iso_
MonitorElement * VxVy_muons_
virtual void setBinLabel(int bin, const std::string &label, int axis=1)
set bin label for x, y or z axis (axis=1, 2, 3 respectively)
MonitorElement * ElecIso_trk_
MonitorElement * pT_elecs_
MonitorElement * Vz_muons_
MonitorElement * ElecIso_CombRelIso_
MonitorElement * Events_
MonitorElement * dimassWC_
MonitorElement * dimassWC_LOGX_
std::string moduleName_
MonitorElement * MuIso_nJets03_
MonitorElement * Trigs_
MonitorElement * dimassRC_LOG10_
MonitorElement * MuIso_emEt03_
MonitorElement * pT_muons_
Power< A, B >::type pow(const A &a, const B &b)
Definition: Power.h:30
MonitorElement * Nelecs_iso_
MonitorElement * Nelecs_
MonitorElement * MuIso_hadEt03_
MonitorElement * MuIso_CombRelIso03_

Member Data Documentation

MonitorElement* TopDiLeptonDQM::D_eta_elecs_
private

Definition at line 128 of file TopDiLeptonDQM.h.

MonitorElement* TopDiLeptonDQM::D_eta_lepts_
private

Definition at line 130 of file TopDiLeptonDQM.h.

MonitorElement* TopDiLeptonDQM::D_eta_muons_
private

Definition at line 126 of file TopDiLeptonDQM.h.

MonitorElement* TopDiLeptonDQM::D_phi_elecs_
private

Definition at line 129 of file TopDiLeptonDQM.h.

MonitorElement* TopDiLeptonDQM::D_phi_lepts_
private

Definition at line 131 of file TopDiLeptonDQM.h.

MonitorElement* TopDiLeptonDQM::D_phi_muons_
private

Definition at line 127 of file TopDiLeptonDQM.h.

MonitorElement* TopDiLeptonDQM::dimassRC_
private

Definition at line 119 of file TopDiLeptonDQM.h.

MonitorElement* TopDiLeptonDQM::dimassRC_LOG10_
private

Definition at line 123 of file TopDiLeptonDQM.h.

MonitorElement* TopDiLeptonDQM::dimassRC_LOGX_
private

Definition at line 121 of file TopDiLeptonDQM.h.

MonitorElement* TopDiLeptonDQM::dimassWC_
private

Definition at line 120 of file TopDiLeptonDQM.h.

MonitorElement* TopDiLeptonDQM::dimassWC_LOG10_
private

Definition at line 124 of file TopDiLeptonDQM.h.

MonitorElement* TopDiLeptonDQM::dimassWC_LOGX_
private

Definition at line 122 of file TopDiLeptonDQM.h.

float TopDiLeptonDQM::Eff[100]
private

Definition at line 60 of file TopDiLeptonDQM.h.

double TopDiLeptonDQM::elec_emf_cut_
private

Definition at line 80 of file TopDiLeptonDQM.h.

double TopDiLeptonDQM::elec_eta_cut_
private

Definition at line 78 of file TopDiLeptonDQM.h.

double TopDiLeptonDQM::elec_iso_cut_
private

Definition at line 79 of file TopDiLeptonDQM.h.

double TopDiLeptonDQM::elec_pT_cut_
private

Definition at line 77 of file TopDiLeptonDQM.h.

MonitorElement* TopDiLeptonDQM::ElecIso_cal_
private

Definition at line 115 of file TopDiLeptonDQM.h.

MonitorElement* TopDiLeptonDQM::ElecIso_CombRelIso_
private

Definition at line 117 of file TopDiLeptonDQM.h.

MonitorElement* TopDiLeptonDQM::ElecIso_trk_
private

Definition at line 116 of file TopDiLeptonDQM.h.

edm::EDGetTokenT<reco::GsfElectronCollection> TopDiLeptonDQM::elecs_
private

Definition at line 76 of file TopDiLeptonDQM.h.

MonitorElement* TopDiLeptonDQM::eta_elecs_
private

Definition at line 104 of file TopDiLeptonDQM.h.

MonitorElement* TopDiLeptonDQM::eta_muons_
private

Definition at line 96 of file TopDiLeptonDQM.h.

MonitorElement* TopDiLeptonDQM::Events_
private

Definition at line 85 of file TopDiLeptonDQM.h.

std::vector<std::string> TopDiLeptonDQM::hltPaths_
private

Definition at line 52 of file TopDiLeptonDQM.h.

std::vector<std::string> TopDiLeptonDQM::hltPaths_sig_
private

Definition at line 53 of file TopDiLeptonDQM.h.

std::vector<std::string> TopDiLeptonDQM::hltPaths_trig_
private

Definition at line 54 of file TopDiLeptonDQM.h.

MonitorElement* TopDiLeptonDQM::HoverE_elecs_
private

Definition at line 102 of file TopDiLeptonDQM.h.

double TopDiLeptonDQM::MassWindow_down_
private

Definition at line 83 of file TopDiLeptonDQM.h.

double TopDiLeptonDQM::MassWindow_up_
private

Definition at line 82 of file TopDiLeptonDQM.h.

std::string TopDiLeptonDQM::moduleName_
private

Definition at line 49 of file TopDiLeptonDQM.h.

MonitorElement* TopDiLeptonDQM::MuIso_CombRelIso03_
private

Definition at line 113 of file TopDiLeptonDQM.h.

MonitorElement* TopDiLeptonDQM::MuIso_emEt03_
private

Definition at line 107 of file TopDiLeptonDQM.h.

MonitorElement* TopDiLeptonDQM::MuIso_hadEt03_
private

Definition at line 108 of file TopDiLeptonDQM.h.

MonitorElement* TopDiLeptonDQM::MuIso_hoEt03_
private

Definition at line 109 of file TopDiLeptonDQM.h.

MonitorElement* TopDiLeptonDQM::MuIso_nJets03_
private

Definition at line 110 of file TopDiLeptonDQM.h.

MonitorElement* TopDiLeptonDQM::MuIso_nTracks03_
private

Definition at line 111 of file TopDiLeptonDQM.h.

MonitorElement* TopDiLeptonDQM::MuIso_sumPt03_
private

Definition at line 112 of file TopDiLeptonDQM.h.

double TopDiLeptonDQM::muon_eta_cut_
private

Definition at line 73 of file TopDiLeptonDQM.h.

double TopDiLeptonDQM::muon_iso_cut_
private

Definition at line 74 of file TopDiLeptonDQM.h.

double TopDiLeptonDQM::muon_pT_cut_
private

Definition at line 72 of file TopDiLeptonDQM.h.

edm::EDGetTokenT<reco::MuonCollection> TopDiLeptonDQM::muons_
private

Definition at line 71 of file TopDiLeptonDQM.h.

int TopDiLeptonDQM::N_elel
private

Definition at line 64 of file TopDiLeptonDQM.h.

int TopDiLeptonDQM::N_muel
private

Definition at line 63 of file TopDiLeptonDQM.h.

int TopDiLeptonDQM::N_mumu
private

Definition at line 62 of file TopDiLeptonDQM.h.

int TopDiLeptonDQM::N_sig[100]
private

Definition at line 58 of file TopDiLeptonDQM.h.

int TopDiLeptonDQM::N_trig[100]
private

Definition at line 59 of file TopDiLeptonDQM.h.

MonitorElement* TopDiLeptonDQM::Nelecs_
private

Definition at line 99 of file TopDiLeptonDQM.h.

MonitorElement* TopDiLeptonDQM::Nelecs_charge_
private

Definition at line 101 of file TopDiLeptonDQM.h.

MonitorElement* TopDiLeptonDQM::Nelecs_iso_
private

Definition at line 100 of file TopDiLeptonDQM.h.

MonitorElement* TopDiLeptonDQM::Nmuons_
private

Definition at line 90 of file TopDiLeptonDQM.h.

MonitorElement* TopDiLeptonDQM::Nmuons_charge_
private

Definition at line 92 of file TopDiLeptonDQM.h.

MonitorElement* TopDiLeptonDQM::Nmuons_iso_
private

Definition at line 91 of file TopDiLeptonDQM.h.

MonitorElement* TopDiLeptonDQM::Ntracks_
private

Definition at line 88 of file TopDiLeptonDQM.h.

std::ofstream TopDiLeptonDQM::outfile
private

Definition at line 56 of file TopDiLeptonDQM.h.

std::string TopDiLeptonDQM::outputFile_
private

Definition at line 50 of file TopDiLeptonDQM.h.

MonitorElement* TopDiLeptonDQM::phi_elecs_
private

Definition at line 105 of file TopDiLeptonDQM.h.

MonitorElement* TopDiLeptonDQM::phi_muons_
private

Definition at line 97 of file TopDiLeptonDQM.h.

MonitorElement* TopDiLeptonDQM::pT_elecs_
private

Definition at line 103 of file TopDiLeptonDQM.h.

MonitorElement* TopDiLeptonDQM::pT_muons_
private

Definition at line 95 of file TopDiLeptonDQM.h.

MonitorElement* TopDiLeptonDQM::TriggerEff_
private

Definition at line 87 of file TopDiLeptonDQM.h.

edm::EDGetTokenT<edm::TriggerResults> TopDiLeptonDQM::triggerResults_
private

Definition at line 51 of file TopDiLeptonDQM.h.

MonitorElement* TopDiLeptonDQM::Trigs_
private

Definition at line 86 of file TopDiLeptonDQM.h.

edm::EDGetTokenT<reco::VertexCollection> TopDiLeptonDQM::vertex_
private

Definition at line 66 of file TopDiLeptonDQM.h.

double TopDiLeptonDQM::vertex_X_cut_
private

Definition at line 67 of file TopDiLeptonDQM.h.

double TopDiLeptonDQM::vertex_Y_cut_
private

Definition at line 68 of file TopDiLeptonDQM.h.

double TopDiLeptonDQM::vertex_Z_cut_
private

Definition at line 69 of file TopDiLeptonDQM.h.

MonitorElement* TopDiLeptonDQM::VxVy_muons_
private

Definition at line 93 of file TopDiLeptonDQM.h.

MonitorElement* TopDiLeptonDQM::Vz_muons_
private

Definition at line 94 of file TopDiLeptonDQM.h.