CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
List of all members | Public Types | Public Member Functions | Private Member Functions | Private Attributes
TopDiLeptonOffline::MonitorEnsemble Class Reference

#include <TopDiLeptonOfflineDQM.h>

Public Types

enum  DecayChannel {
  NONE, DIMUON, DIELEC, ELECMU,
  NONE, DIMUON, DIELEC, ELECMU
}
 different decay channels More...
 
enum  DecayChannel {
  NONE, DIMUON, DIELEC, ELECMU,
  NONE, DIMUON, DIELEC, ELECMU
}
 different decay channels More...
 
enum  Level {
  STANDARD, VERBOSE, DEBUG, STANDARD,
  VERBOSE, DEBUG
}
 different verbosity levels More...
 
enum  Level {
  STANDARD, VERBOSE, DEBUG, STANDARD,
  VERBOSE, DEBUG
}
 different verbosity levels More...
 
typedef
reco::LeafCandidate::LorentzVector 		LorentzVector
 
typedef
reco::LeafCandidate::LorentzVector 		LorentzVector
 

Public Member Functions

void book (std::string directory)
 book histograms in subdirectory directory More...
 
void book (std::string directory)
 book histograms in subdirectory directory More...
 
void fill (const edm::Event &event, const edm::EventSetup &setup)
 fill monitor histograms with electronId and jetCorrections More...
 
void fill (const edm::Event &event, const edm::EventSetup &setup, edm::Handle< edm::TriggerResults > triggerTable, edm::Handle< edm::View< reco::Muon > > muons, edm::Handle< edm::ValueMap< float > > electronId, edm::Handle< edm::View< reco::GsfElectron > > elecs, edm::Handle< edm::View< reco::Jet > > jets, edm::Handle< reco::JetIDValueMap > jetID, std::vector< edm::Handle< edm::View< reco::MET > > > mets)
 fill monitor histograms with electronId and jetCorrections More...
 
 MonitorEnsemble (const char *label, const edm::ParameterSet &cfg, edm::ConsumesCollector &&iC)
 default contructor More...
 
 MonitorEnsemble (const char *label, const edm::ParameterSet &cfg)
 default contructor More...
 
 ~MonitorEnsemble ()
 default destructor More...
 
 ~MonitorEnsemble ()
 default destructor More...
 

Private Member Functions

bool booked (const std::string histName) const
 check if histogram was booked More...
 
bool booked (const std::string histName) const
 check if histogram was booked More...
 
DecayChannel decayChannel (const std::vector< const reco::Muon * > &muons, const std::vector< const reco::GsfElectron * > &elecs) const
 determine dileptonic decay channel More...
 
DecayChannel decayChannel (const std::vector< const reco::Muon * > &muons, const std::vector< const reco::GsfElectron * > &elecs) const
 determine dileptonic decay channel More...
 
void fill (const edm::Event &event, const edm::TriggerResults &triggerTable, std::string channel, const std::vector< std::string > labels) const
 fill trigger monitoring histograms More...
 
void fill (const edm::Event &event, const edm::TriggerResults &triggerTable, std::string channel, const std::vector< std::string > &labels) const
 fill trigger monitoring histograms More...
 
void fill (const std::string histName, double value) const
 fill histogram if it had been booked before More...
 
void fill (const std::string histName, double xValue, double yValue) const
 fill histogram if it had been booked before (2-dim version) More...
 
void fill (const std::string histName, double value) const
 fill histogram if it had been booked before More...
 
void fill (const std::string histName, double xValue, double yValue, double zValue) const
 fill histogram if it had been booked before (2-dim version) More...
 
void fill (const std::string histName, double xValue, double yValue) const
 fill histogram if it had been booked before (2-dim version) More...
 
void fill (const std::string histName, double xValue, double yValue, double zValue) const
 fill histogram if it had been booked before (2-dim version) More...
 
void loggerBinLabels (std::string hist)
 set labels for event logging histograms More...
 
void loggerBinLabels (std::string hist)
 set labels for event logging histograms More...
 
std::string monitorPath (const std::string &label) const
 
std::string monitorPath (const std::string &label) const
 
std::string selectionPath (const std::string &label) const
 
std::string selectionPath (const std::string &label) const
 
void triggerBinLabels (std::string channel, const std::vector< std::string > labels)
 set configurable labels for trigger monitoring histograms More...
 
void triggerBinLabels (std::string channel, const std::vector< std::string > &labels)
 set configurable labels for trigger monitoring histograms More...
 

Private Attributes

int diElecLogged_
 
int diMuonLogged_
 
std::vector< std::string > diMuonPaths_
 trigger paths for di muon channel More...
 
int eidPattern_
 
StringCutObjectSelector
< reco::GsfElectron > * 		elecIso_
 extra isolation criterion on electron More...
 
int elecMuLogged_
 number of logged interesting events More...
 
std::vector< std::string > elecMuPaths_
 
edm::EDGetTokenT< edm::View
< reco::GsfElectron > > 		elecs_
 
edm::InputTag elecs_
 input sources for monitoring More...
 
StringCutObjectSelector
< reco::GsfElectron > * 		elecSelect_
 extra selection on electrons More...
 
edm::InputTag electronId_
 electronId label More...
 
edm::EDGetTokenT
< edm::ValueMap< float > > 		electronId_
 electronId label More...
 
std::map< std::string,
MonitorElement * > 		hists_
 histogram container More...
 
std::string jetCorrector_
 jetCorrector More...
 
edm::InputTag jetIDLabel_
 jetID as an extra selection type More...
 
edm::EDGetTokenT
< reco::JetIDValueMap > 		jetIDLabel_
 jetID as an extra selection type More...
 
StringCutObjectSelector
< reco::JetID > * 		jetIDSelect_
 extra jetID selection on calo jets More...
 
edm::EDGetTokenT< edm::View
< reco::Jet > > 		jets_
 input sources for monitoring More...
 
edm::InputTag jets_
 
std::string jetSelect_
 
std::string label_
 instance label More...
 
double lowerEdge_
 mass window upper and lower edge More...
 
std::vector< edm::EDGetTokenT
< edm::View< reco::MET > > > 		mets_
 considers a vector of METs More...
 
std::vector< edm::InputTag > mets_
 considers a vector of METs More...
 
StringCutObjectSelector
< reco::Muon > * 		muonIso_
 extra isolation criterion on muon More...
 
edm::EDGetTokenT< edm::View
< reco::Muon > > 		muons_
 
edm::InputTag muons_
 
StringCutObjectSelector
< reco::Muon > * 		muonSelect_
 extra selection on muons More...
 
DQMStore * store_
 storage manager More...
 
edm::InputTag triggerTable_
 trigger table More...
 
edm::EDGetTokenT
< edm::TriggerResults > 		triggerTable_
 trigger table More...
 
double upperEdge_
 
Level verbosity_
 verbosity level for booking More...
 

Detailed Description

Definition at line 41 of file TopDiLeptonOfflineDQM.h.

Member Typedef Documentation

typedef reco::LeafCandidate::LorentzVector TopDiLeptonOffline::MonitorEnsemble::LorentzVector

make clear which LorentzVector to use for jet, electrons and muon buffering

Definition at line 47 of file TopDiLeptonOfflineDQM.h.

typedef reco::LeafCandidate::LorentzVector TopDiLeptonOffline::MonitorEnsemble::LorentzVector

make clear which LorentzVector to use for jet, electrons and muon buffering

Definition at line 51 of file TopHLTDiLeptonOfflineDQM.h.

Member Enumeration Documentation

enum TopDiLeptonOffline::MonitorEnsemble::DecayChannel

different decay channels

Enumerator
NONE 
DIMUON 
DIELEC 
ELECMU 
NONE 
DIMUON 
DIELEC 
ELECMU 

Definition at line 49 of file TopDiLeptonOfflineDQM.h.

49 { NONE, DIMUON, DIELEC, ELECMU };
enum TopDiLeptonOffline::MonitorEnsemble::DecayChannel

different decay channels

Enumerator
NONE 
DIMUON 
DIELEC 
ELECMU 
NONE 
DIMUON 
DIELEC 
ELECMU 

Definition at line 53 of file TopHLTDiLeptonOfflineDQM.h.

53 { NONE, DIMUON, DIELEC, ELECMU };
enum TopDiLeptonOffline::MonitorEnsemble::Level

different verbosity levels

Enumerator
STANDARD 
VERBOSE 
DEBUG 
STANDARD 
VERBOSE 
DEBUG 

Definition at line 44 of file TopDiLeptonOfflineDQM.h.

44 { STANDARD, VERBOSE, DEBUG };
enum TopDiLeptonOffline::MonitorEnsemble::Level

different verbosity levels

Enumerator
STANDARD 
VERBOSE 
DEBUG 
STANDARD 
VERBOSE 
DEBUG 

Definition at line 48 of file TopHLTDiLeptonOfflineDQM.h.

48 { STANDARD, VERBOSE, DEBUG };

Constructor & Destructor Documentation

MonitorEnsemble::MonitorEnsemble ( const char *  label,
const edm::ParameterSet &  cfg,
edm::ConsumesCollector &&  iC 
)

default contructor

Definition at line 13 of file TopDiLeptonOfflineDQM.cc.

References book(), DEBUG, diMuonPaths_, eidPattern_, elecIso_, elecMuPaths_, elecs_, elecSelect_, electronId_, edm::ParameterSet::existsAs(), edm::ParameterSet::getParameter(), jetCorrector_, bTagSequences_cff::jetID, jetIDLabel_, jetIDSelect_, jets_, jetSelect_, lowerEdge_, mets_, muonIso_, muons_, muonSelect_, STANDARD, AlCaHLTBitMon_QueryRunRegistry::string, GlobalPosition_Frontier_DevDB_cff::tag, triggerTable_, upperEdge_, VERBOSE, and verbosity_.

13  :
14  label_(label), eidPattern_(0), elecIso_(0), elecSelect_(0), muonIso_(0), muonSelect_(0), jetIDSelect_(0),
15  lowerEdge_(-1.), upperEdge_(-1.), elecMuLogged_(0), diMuonLogged_(0), diElecLogged_(0)
16  {
17  // sources have to be given; this PSet is not optional
18  edm::ParameterSet sources=cfg.getParameter<edm::ParameterSet>("sources");
19  muons_ = iC.consumes<edm::View<reco::Muon> >(sources.getParameter<edm::InputTag>("muons"));
20  elecs_ = iC.consumes<edm::View<reco::GsfElectron> >(sources.getParameter<edm::InputTag>("elecs"));
21  jets_ = iC.consumes<edm::View<reco::Jet> >(sources.getParameter<edm::InputTag>("jets"));
22  for (edm::InputTag const & tag : sources.getParameter<std::vector<edm::InputTag> >("mets"))
23  mets_.push_back( iC.consumes<edm::View<reco::MET> >(tag) );
24 
25  // elecExtras are optional; they may be omitted or empty
26  if( cfg.existsAs<edm::ParameterSet>("elecExtras") ){
27  edm::ParameterSet elecExtras=cfg.getParameter<edm::ParameterSet>("elecExtras");
28  // select is optional; in case it's not found no
29  // selection will be applied
30  if( elecExtras.existsAs<std::string>("select") ){
31  elecSelect_= new StringCutObjectSelector<reco::GsfElectron>(elecExtras.getParameter<std::string>("select"));
32  }
33  // isolation is optional; in case it's not found no
34  // isolation will be applied
35  if( elecExtras.existsAs<std::string>("isolation") ){
36  elecIso_= new StringCutObjectSelector<reco::GsfElectron>(elecExtras.getParameter<std::string>("isolation"));
37  }
38  // electronId is optional; in case it's not found the
39  // InputTag will remain empty
40  if( elecExtras.existsAs<edm::ParameterSet>("electronId") ){
41  edm::ParameterSet elecId=elecExtras.getParameter<edm::ParameterSet>("electronId");
42  electronId_= iC.consumes<edm::ValueMap<float> >(elecId.getParameter<edm::InputTag>("src"));
43  eidPattern_= elecId.getParameter<int>("pattern");
44  }
45  }
46  // muonExtras are optional; they may be omitted or empty
47  if( cfg.existsAs<edm::ParameterSet>("muonExtras") ){
48  edm::ParameterSet muonExtras=cfg.getParameter<edm::ParameterSet>("muonExtras");
49  // select is optional; in case it's not found no
50  // selection will be applied
51  if( muonExtras.existsAs<std::string>("select") ){
52  muonSelect_= new StringCutObjectSelector<reco::Muon>(muonExtras.getParameter<std::string>("select"));
53  }
54  // isolation is optional; in case it's not found no
55  // isolation will be applied
56  if( muonExtras.existsAs<std::string>("isolation") ){
57  muonIso_= new StringCutObjectSelector<reco::Muon>(muonExtras.getParameter<std::string>("isolation"));
58  }
59  }
60  // jetExtras are optional; they may be omitted or empty
61  if( cfg.existsAs<edm::ParameterSet>("jetExtras") ){
62  edm::ParameterSet jetExtras=cfg.getParameter<edm::ParameterSet>("jetExtras");
63  // jetCorrector is optional; in case it's not found
64  // the InputTag will remain empty
65  if( jetExtras.existsAs<std::string>("jetCorrector") ){
66  jetCorrector_= jetExtras.getParameter<std::string>("jetCorrector");
67  }
68  // read jetID information if it exists
69  if(jetExtras.existsAs<edm::ParameterSet>("jetID")){
70  edm::ParameterSet jetID=jetExtras.getParameter<edm::ParameterSet>("jetID");
71  jetIDLabel_ = iC.consumes<reco::JetIDValueMap>(jetID.getParameter<edm::InputTag>("label"));
72  jetIDSelect_= new StringCutObjectSelector<reco::JetID>(jetID.getParameter<std::string>("select"));
73  }
74  // select is optional; in case it's not found no
75  // selection will be applied (only implemented for
76  // CaloJets at the moment)
77  if( jetExtras.existsAs<std::string>("select") ){
78  jetSelect_= jetExtras.getParameter<std::string>("select");
79  }
80  }
81  // triggerExtras are optional; they may be omitted or empty
82  if( cfg.existsAs<edm::ParameterSet>("triggerExtras") ){
83  edm::ParameterSet triggerExtras=cfg.getParameter<edm::ParameterSet>("triggerExtras");
84  triggerTable_=iC.consumes<edm::TriggerResults>(triggerExtras.getParameter<edm::InputTag>("src"));
85  elecMuPaths_ =triggerExtras.getParameter<std::vector<std::string> >("pathsELECMU");
86  diMuonPaths_ =triggerExtras.getParameter<std::vector<std::string> >("pathsDIMUON");
87  }
88  // massExtras is optional; in case it's not found no mass
89  // window cuts are applied for the same flavor monitor
90  // histograms
91  if( cfg.existsAs<edm::ParameterSet>("massExtras") ){
92  edm::ParameterSet massExtras=cfg.getParameter<edm::ParameterSet>("massExtras");
93  lowerEdge_= massExtras.getParameter<double>("lowerEdge");
94  upperEdge_= massExtras.getParameter<double>("upperEdge");
95  }
96 
97  // setup the verbosity level for booking histograms;
98  // per default the verbosity level will be set to
99  // STANDARD. This will also be the chosen level in
100  // the case when the monitoring PSet is not found
101  verbosity_=STANDARD;
102  if( cfg.existsAs<edm::ParameterSet>("monitoring") ){
103  edm::ParameterSet monitoring=cfg.getParameter<edm::ParameterSet>("monitoring");
104  if(monitoring.getParameter<std::string>("verbosity") == "DEBUG" )
105  verbosity_= DEBUG;
106  if(monitoring.getParameter<std::string>("verbosity") == "VERBOSE" )
107  verbosity_= VERBOSE;
108  if(monitoring.getParameter<std::string>("verbosity") == "STANDARD")
109  verbosity_= STANDARD;
110  }
111  // and don't forget to do the histogram booking
112  book(cfg.getParameter<std::string>("directory"));
113  }
edm::ConsumesCollector::consumes
EDGetTokenT< ProductType > consumes(edm::InputTag const &tag)
Definition: ConsumesCollector.h:41
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
TopDiLeptonOffline::MonitorEnsemble::jetIDSelect_
StringCutObjectSelector< reco::JetID > * jetIDSelect_
extra jetID selection on calo jets
Definition: TopDiLeptonOfflineDQM.h:143
edm::ParameterSet::existsAs
bool existsAs(std::string const &parameterName, bool trackiness=true) const
checks if a parameter exists as a given type
Definition: ParameterSet.h:184
TopDiLeptonOffline::MonitorEnsemble::jetIDLabel_
edm::EDGetTokenT< reco::JetIDValueMap > jetIDLabel_
jetID as an extra selection type
Definition: TopDiLeptonOfflineDQM.h:141
TopDiLeptonOffline::MonitorEnsemble::elecIso_
StringCutObjectSelector< reco::GsfElectron > * elecIso_
extra isolation criterion on electron
Definition: TopDiLeptonOfflineDQM.h:128
TopDiLeptonOffline::MonitorEnsemble::muons_
edm::EDGetTokenT< edm::View< reco::Muon > > muons_
Definition: TopDiLeptonOfflineDQM.h:97
TopDiLeptonOffline::MonitorEnsemble::elecMuLogged_
int elecMuLogged_
number of logged interesting events
Definition: TopDiLeptonOfflineDQM.h:151
TopDiLeptonOffline::MonitorEnsemble::elecs_
edm::EDGetTokenT< edm::View< reco::GsfElectron > > elecs_
Definition: TopDiLeptonOfflineDQM.h:98
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
TopDiLeptonOffline::MonitorEnsemble::jets_
edm::EDGetTokenT< edm::View< reco::Jet > > jets_
input sources for monitoring
Definition: TopDiLeptonOfflineDQM.h:96
bTagSequences_cff.jetID
tuple jetID
Definition: bTagSequences_cff.py:4
TopDiLeptonOffline::MonitorEnsemble::muonIso_
StringCutObjectSelector< reco::Muon > * muonIso_
extra isolation criterion on muon
Definition: TopDiLeptonOfflineDQM.h:133
GlobalPosition_Frontier_DevDB_cff.tag
tuple tag
Definition: GlobalPosition_Frontier_DevDB_cff.py:11
TopDiLeptonOffline::MonitorEnsemble::muonSelect_
StringCutObjectSelector< reco::Muon > * muonSelect_
extra selection on muons
Definition: TopDiLeptonOfflineDQM.h:135
TopDiLeptonOffline::MonitorEnsemble::mets_
std::vector< edm::EDGetTokenT< edm::View< reco::MET > > > mets_
considers a vector of METs
Definition: TopDiLeptonOfflineDQM.h:102
TopDiLeptonOffline::MonitorEnsemble::book
void book(std::string directory)
book histograms in subdirectory directory
Definition: TopDiLeptonOfflineDQM.cc:116
TopDiLeptonOffline::MonitorEnsemble::diMuonPaths_
std::vector< std::string > diMuonPaths_
trigger paths for di muon channel
Definition: TopDiLeptonOfflineDQM.h:111
TopDiLeptonOffline::MonitorEnsemble::lowerEdge_
double lowerEdge_
mass window upper and lower edge
Definition: TopDiLeptonOfflineDQM.h:148
TopDiLeptonOffline::MonitorEnsemble::verbosity_
Level verbosity_
verbosity level for booking
Definition: TopDiLeptonOfflineDQM.h:87
TopDiLeptonOffline::MonitorEnsemble::triggerTable_
edm::EDGetTokenT< edm::TriggerResults > triggerTable_
trigger table
Definition: TopDiLeptonOfflineDQM.h:106
TopDiLeptonOffline::MonitorEnsemble::elecSelect_
StringCutObjectSelector< reco::GsfElectron > * elecSelect_
extra selection on electrons
Definition: TopDiLeptonOfflineDQM.h:130
TopDiLeptonOffline::MonitorEnsemble::elecMuPaths_
std::vector< std::string > elecMuPaths_
Definition: TopDiLeptonOfflineDQM.h:109
TopDiLeptonOffline::MonitorEnsemble::electronId_
edm::EDGetTokenT< edm::ValueMap< float > > electronId_
electronId label
Definition: TopDiLeptonOfflineDQM.h:115
TopDiLeptonOffline::MonitorEnsemble::~MonitorEnsemble ( )
inline

default destructor

Definition at line 56 of file TopDiLeptonOfflineDQM.h.

56 {};
MonitorEnsemble::MonitorEnsemble ( const char *  label,
const edm::ParameterSet &  cfg 
)

default contructor

Definition at line 13 of file TopHLTDiLeptonOfflineDQM.cc.

References book(), DEBUG, diMuonPaths_, eidPattern_, elecIso_, elecMuPaths_, elecs_, elecSelect_, electronId_, edm::ParameterSet::existsAs(), edm::ParameterSet::getParameter(), jetCorrector_, bTagSequences_cff::jetID, jetIDLabel_, jetIDSelect_, jets_, jetSelect_, lowerEdge_, mets_, muonIso_, muons_, muonSelect_, STANDARD, AlCaHLTBitMon_QueryRunRegistry::string, triggerTable_, upperEdge_, VERBOSE, and verbosity_.

13  :
14  label_(label), eidPattern_(0), elecIso_(0), elecSelect_(0), muonIso_(0), muonSelect_(0), jetIDSelect_(0),
15  lowerEdge_(-1.), upperEdge_(-1.), elecMuLogged_(0), diMuonLogged_(0), diElecLogged_(0)
16  {
17  // sources have to be given; this PSet is not optional
18  edm::ParameterSet sources=cfg.getParameter<edm::ParameterSet>("sources");
19  muons_= sources.getParameter<edm::InputTag>("muons");
20  elecs_= sources.getParameter<edm::InputTag>("elecs");
21  jets_ = sources.getParameter<edm::InputTag>("jets" );
22  mets_ = sources.getParameter<std::vector<edm::InputTag> >("mets" );
23 
24  // elecExtras are optional; they may be omitted or empty
25  if( cfg.existsAs<edm::ParameterSet>("elecExtras") ){
26  edm::ParameterSet elecExtras=cfg.getParameter<edm::ParameterSet>("elecExtras");
27  // select is optional; in case it's not found no
28  // selection will be applied
29  if( elecExtras.existsAs<std::string>("select") ){
30  elecSelect_= new StringCutObjectSelector<reco::GsfElectron>(elecExtras.getParameter<std::string>("select"));
31  }
32  // isolation is optional; in case it's not found no
33  // isolation will be applied
34  if( elecExtras.existsAs<std::string>("isolation") ){
35  elecIso_= new StringCutObjectSelector<reco::GsfElectron>(elecExtras.getParameter<std::string>("isolation"));
36  }
37  // electronId is optional; in case it's not found the
38  // InputTag will remain empty
39  if( elecExtras.existsAs<edm::ParameterSet>("electronId") ){
40  edm::ParameterSet elecId=elecExtras.getParameter<edm::ParameterSet>("electronId");
41  electronId_= elecId.getParameter<edm::InputTag>("src");
42  eidPattern_= elecId.getParameter<int>("pattern");
43  }
44  }
45  // muonExtras are optional; they may be omitted or empty
46  if( cfg.existsAs<edm::ParameterSet>("muonExtras") ){
47  edm::ParameterSet muonExtras=cfg.getParameter<edm::ParameterSet>("muonExtras");
48  // select is optional; in case it's not found no
49  // selection will be applied
50  if( muonExtras.existsAs<std::string>("select") ){
51  muonSelect_= new StringCutObjectSelector<reco::Muon>(muonExtras.getParameter<std::string>("select"));
52  }
53  // isolation is optional; in case it's not found no
54  // isolation will be applied
55  if( muonExtras.existsAs<std::string>("isolation") ){
56  muonIso_= new StringCutObjectSelector<reco::Muon>(muonExtras.getParameter<std::string>("isolation"));
57  }
58  }
59  // jetExtras are optional; they may be omitted or empty
60  if( cfg.existsAs<edm::ParameterSet>("jetExtras") ){
61  edm::ParameterSet jetExtras=cfg.getParameter<edm::ParameterSet>("jetExtras");
62  // jetCorrector is optional; in case it's not found
63  // the InputTag will remain empty
64  if( jetExtras.existsAs<std::string>("jetCorrector") ){
65  jetCorrector_= jetExtras.getParameter<std::string>("jetCorrector");
66  }
67  // read jetID information if it exists
68  if(jetExtras.existsAs<edm::ParameterSet>("jetID")){
69  edm::ParameterSet jetID=jetExtras.getParameter<edm::ParameterSet>("jetID");
70  jetIDLabel_ =jetID.getParameter<edm::InputTag>("label");
71  jetIDSelect_= new StringCutObjectSelector<reco::JetID>(jetID.getParameter<std::string>("select"));
72  }
73  // select is optional; in case it's not found no
74  // selection will be applied (only implemented for
75  // CaloJets at the moment)
76  if( jetExtras.existsAs<std::string>("select") ){
77  jetSelect_= jetExtras.getParameter<std::string>("select");
78  }
79  }
80  // triggerExtras are optional; they may be omitted or empty
81  if( cfg.existsAs<edm::ParameterSet>("triggerExtras") ){
82  edm::ParameterSet triggerExtras=cfg.getParameter<edm::ParameterSet>("triggerExtras");
83  triggerTable_=triggerExtras.getParameter<edm::InputTag>("src");
84  elecMuPaths_ =triggerExtras.getParameter<std::vector<std::string> >("pathsELECMU");
85  diMuonPaths_ =triggerExtras.getParameter<std::vector<std::string> >("pathsDIMUON");
86  }
87  // massExtras is optional; in case it's not found no mass
88  // window cuts are applied for the same flavor monitor
89  // histograms
90  if( cfg.existsAs<edm::ParameterSet>("massExtras") ){
91  edm::ParameterSet massExtras=cfg.getParameter<edm::ParameterSet>("massExtras");
92  lowerEdge_= massExtras.getParameter<double>("lowerEdge");
93  upperEdge_= massExtras.getParameter<double>("upperEdge");
94  }
95 
96  // setup the verbosity level for booking histograms;
97  // per default the verbosity level will be set to
98  // STANDARD. This will also be the chosen level in
99  // the case when the monitoring PSet is not found
100  verbosity_=STANDARD;
101  if( cfg.existsAs<edm::ParameterSet>("monitoring") ){
102  edm::ParameterSet monitoring=cfg.getParameter<edm::ParameterSet>("monitoring");
103  if(monitoring.getParameter<std::string>("verbosity") == "DEBUG" )
104  verbosity_= DEBUG;
105  if(monitoring.getParameter<std::string>("verbosity") == "VERBOSE" )
106  verbosity_= VERBOSE;
107  if(monitoring.getParameter<std::string>("verbosity") == "STANDARD")
108  verbosity_= STANDARD;
109  }
110  // and don't forget to do the histogram booking
111  book(cfg.getParameter<std::string>("directory"));
112  }
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
TopDiLeptonOffline::MonitorEnsemble::jetIDSelect_
StringCutObjectSelector< reco::JetID > * jetIDSelect_
extra jetID selection on calo jets
Definition: TopDiLeptonOfflineDQM.h:143
edm::ParameterSet::existsAs
bool existsAs(std::string const &parameterName, bool trackiness=true) const
checks if a parameter exists as a given type
Definition: ParameterSet.h:184
TopDiLeptonOffline::MonitorEnsemble::jetIDLabel_
edm::EDGetTokenT< reco::JetIDValueMap > jetIDLabel_
jetID as an extra selection type
Definition: TopDiLeptonOfflineDQM.h:141
TopDiLeptonOffline::MonitorEnsemble::elecIso_
StringCutObjectSelector< reco::GsfElectron > * elecIso_
extra isolation criterion on electron
Definition: TopDiLeptonOfflineDQM.h:128
TopDiLeptonOffline::MonitorEnsemble::muons_
edm::EDGetTokenT< edm::View< reco::Muon > > muons_
Definition: TopDiLeptonOfflineDQM.h:97
TopDiLeptonOffline::MonitorEnsemble::elecMuLogged_
int elecMuLogged_
number of logged interesting events
Definition: TopDiLeptonOfflineDQM.h:151
TopDiLeptonOffline::MonitorEnsemble::elecs_
edm::EDGetTokenT< edm::View< reco::GsfElectron > > elecs_
Definition: TopDiLeptonOfflineDQM.h:98
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
TopDiLeptonOffline::MonitorEnsemble::jets_
edm::EDGetTokenT< edm::View< reco::Jet > > jets_
input sources for monitoring
Definition: TopDiLeptonOfflineDQM.h:96
bTagSequences_cff.jetID
tuple jetID
Definition: bTagSequences_cff.py:4
TopDiLeptonOffline::MonitorEnsemble::muonIso_
StringCutObjectSelector< reco::Muon > * muonIso_
extra isolation criterion on muon
Definition: TopDiLeptonOfflineDQM.h:133
TopDiLeptonOffline::MonitorEnsemble::muonSelect_
StringCutObjectSelector< reco::Muon > * muonSelect_
extra selection on muons
Definition: TopDiLeptonOfflineDQM.h:135
TopDiLeptonOffline::MonitorEnsemble::mets_
std::vector< edm::EDGetTokenT< edm::View< reco::MET > > > mets_
considers a vector of METs
Definition: TopDiLeptonOfflineDQM.h:102
TopDiLeptonOffline::MonitorEnsemble::book
void book(std::string directory)
book histograms in subdirectory directory
Definition: TopDiLeptonOfflineDQM.cc:116
TopDiLeptonOffline::MonitorEnsemble::diMuonPaths_
std::vector< std::string > diMuonPaths_
trigger paths for di muon channel
Definition: TopDiLeptonOfflineDQM.h:111
TopDiLeptonOffline::MonitorEnsemble::lowerEdge_
double lowerEdge_
mass window upper and lower edge
Definition: TopDiLeptonOfflineDQM.h:148
TopDiLeptonOffline::MonitorEnsemble::verbosity_
Level verbosity_
verbosity level for booking
Definition: TopDiLeptonOfflineDQM.h:87
TopDiLeptonOffline::MonitorEnsemble::triggerTable_
edm::EDGetTokenT< edm::TriggerResults > triggerTable_
trigger table
Definition: TopDiLeptonOfflineDQM.h:106
TopDiLeptonOffline::MonitorEnsemble::elecSelect_
StringCutObjectSelector< reco::GsfElectron > * elecSelect_
extra selection on electrons
Definition: TopDiLeptonOfflineDQM.h:130
TopDiLeptonOffline::MonitorEnsemble::elecMuPaths_
std::vector< std::string > elecMuPaths_
Definition: TopDiLeptonOfflineDQM.h:109
TopDiLeptonOffline::MonitorEnsemble::electronId_
edm::EDGetTokenT< edm::ValueMap< float > > electronId_
electronId label
Definition: TopDiLeptonOfflineDQM.h:115
TopDiLeptonOffline::MonitorEnsemble::~MonitorEnsemble ( )
inline

default destructor

Definition at line 59 of file TopHLTDiLeptonOfflineDQM.h.

59 {};

Member Function Documentation

void MonitorEnsemble::book ( std::string  directory)

book histograms in subdirectory directory

Definition at line 116 of file TopDiLeptonOfflineDQM.cc.

References DQMStore::book1D(), DQMStore::book2D(), cond::rpcobimon::current, diMuonPaths_, elecMuPaths_, hists_, label_, loggerBinLabels(), cppFunctionSkipper::operator, DQMStore::setCurrentFolder(), STANDARD, store_, AlCaHLTBitMon_QueryRunRegistry::string, triggerBinLabels(), VERBOSE, and verbosity_.

Referenced by MonitorEnsemble().

117  {
118  //set up the current directory path
119  std::string current(directory); current+=label_;
120  store_=edm::Service<DQMStore>().operator->();
121  store_->setCurrentFolder(current);
122 
123  // determine number of bins for trigger monitoring
124  unsigned int nElecMu=elecMuPaths_.size();
125  unsigned int nDiMuon=diMuonPaths_.size();
126 
127  // --- [STANDARD] --- //
128  //Run Number
129  hists_["RunNumb_" ] = store_->book1D("RunNumber" , "Run Nr." , 1.e4, 1.5e5, 3.e5);
130  // invariant mass of opposite charge lepton pair (only filled for same flavor)
131  hists_["invMass_" ] = store_->book1D("InvMass" , "M(lep1, lep2)" , 80, 0., 320.);
132  // invariant mass of opposite charge lepton pair (only filled for same flavor)
133  hists_["invMassLog_" ] = store_->book1D("InvMassLog" , "log_{10}(M(lep1, lep2))" , 80, .1, 2.5);
134  // invariant mass of same charge lepton pair (log10 for low mass region, only filled for same flavor)
135  hists_["invMassWC_" ] = store_->book1D("InvMassWC" , "M_{WC}(L1, L2)" , 80, 0., 320.);
136  // invariant mass of same charge lepton pair (log10 for low mass region, only filled for same flavor)
137  hists_["invMassWCLog_"] = store_->book1D("InvMassLogWC", "log_{10}(M_{WC})" , 80, .1, 2.5);
138  // decay channel [1]: muon/muon, [2]:elec/elec, [3]:elec/muon
139  hists_["decayChannel_"] = store_->book1D("DecayChannel", "Decay Channel" , 3, 0, 3);
140  // trigger efficiency estimates for the electron muon channel
141  hists_["elecMuEff_" ] = store_->book1D("ElecMuEff" , "Eff(e/#mu paths)" , nElecMu, 0., nElecMu);
142  // monitored trigger occupancy for the electron muon channel
143  hists_["elecMuMon_" ] = store_->book1D("ElecMuMon" , "Mon(e/#mu paths)" , nElecMu, 0., nElecMu);
144  // trigger efficiency estimates for the di muon channel
145  hists_["diMuonEff_" ] = store_->book1D("DiMuonEff" , "Eff(#mu/#mu paths)" , nDiMuon, 0., nDiMuon);
146  // monitored trigger occupancy for the di muon channel
147  hists_["diMuonMon_" ] = store_->book1D("DiMuonMon" , "Mon(#mu/#mu paths)" , nDiMuon, 0., nDiMuon);
148  // pt of the leading lepton
149  hists_["lep1Pt_" ] = store_->book1D("Lep1Pt" , "pt(lep1)" , 50, 0., 200.);
150  // pt of the 2. leading lepton
151  hists_["lep2Pt_" ] = store_->book1D("Lep2Pt" , "pt(lep2)" , 50, 0., 200.);
152  // multiplicity of jets with pt>30 (corrected to L2+L3)
153  hists_["jetMult_" ] = store_->book1D("JetMult" , "N_{30}(jet)" , 21, -0.5, 20.5);
154  // MET (calo)
155  hists_["metCalo_" ] = store_->book1D("METCalo" , "MET_{Calo}" , 50, 0., 200.);
156 
157  // set bin labels for trigger monitoring
158  triggerBinLabels(std::string("elecMu"), elecMuPaths_);
159  triggerBinLabels(std::string("diMuon"), diMuonPaths_);
160  // set bin labels for decayChannel_
161  hists_["decayChannel_"]->setBinLabel( 1, "#mu e" , 1);
162  hists_["decayChannel_"]->setBinLabel( 2, "#mu #mu", 1);
163  hists_["decayChannel_"]->setBinLabel( 3, "e e" , 1);
164 
165  if( verbosity_==STANDARD) return;
166 
167  // --- [VERBOSE] --- //
168  // mean eta of the candidate leptons
169  hists_["sumEtaL1L2_" ] = store_->book1D("SumEtaL1L2" , "<#eta>(lep1, lep2)" , 100, -5., 5.);
170  // deltaEta between the 2 candidate leptons
171  hists_["dEtaL1L2_" ] = store_->book1D("DEtaL1L2" , "#Delta#eta(lep1,lep2)" , 80, -4., 4.);
172  // deltaPhi between the 2 candidate leptons
173  hists_["dPhiL1L2_" ] = store_->book1D("DPhiL1L2" , "#Delta#phi(lep1,lep2)" , 64, -3.2, 3.2);
174  // pt of the candidate electron (depending on the decay channel)
175  hists_["elecPt_" ] = store_->book1D("ElecPt" , "pt(e)" , 50, 0., 200.);
176  // relative isolation of the candidate electron (depending on the decay channel)
177  hists_["elecRelIso_" ] = store_->book1D("ElecRelIso" , "Iso_{Rel}(e)" , 50, 0., 1.);
178  // pt of the canddiate muon (depending on the decay channel)
179  hists_["muonPt_" ] = store_->book1D("MuonPt" , "pt(#mu)" , 50, 0., 200.);
180  // relative isolation of the candidate muon (depending on the decay channel)
181  hists_["muonRelIso_" ] = store_->book1D("MuonRelIso" , "Iso_{Rel}(#mu)" , 50, 0., 1.);
182  // pt of the 1. leading jet (corrected to L2+L3)
183  hists_["jet1Pt_" ] = store_->book1D("Jet1Pt" , "pt_{L2L3}(jet1)" , 60, 0., 300.);
184  // pt of the 2. leading jet (corrected to L2+L3)
185  hists_["jet2Pt_" ] = store_->book1D("Jet2Pt" , "pt_{L2L3}(jet2)" , 60, 0., 300.);
186  // MET (PF)
187  hists_["metPflow_" ] = store_->book1D("METPflow" , "MET_{Pflow}" , 50, 0., 200.);
188  // MET (TC)
189  hists_["metTC_" ] = store_->book1D("METTC" , "MET_{TC}" , 50, 0., 200.);
190  // dz for muons (to suppress cosmis)
191  hists_["muonDelZ_" ] = store_->book1D("MuonDelZ" , "d_{z}(#mu)" , 50, -25., 25.);
192  // dxy for muons (to suppress cosmics)
193  hists_["muonDelXY_" ] = store_->book2D("MuonDelXY" , "d_{xy}(#mu)" , 50, -1., 1., 50, -1., 1.);
194  // lepton multiplicity after std isolation
195  hists_["lepMultIso_" ] = store_->book2D("LepMultIso" , "N_{Iso}(e) vs N_{Iso}(#mu)" , 5, 0., 5., 5, 0., 5.);
196 
197  // set axes titles for dxy for muons
198  hists_["muonDelXY_" ]->setAxisTitle( "x [cm]", 1); hists_["muonDelXY_" ]->setAxisTitle( "y [cm]", 2);
199  // set axes titles for lepton multiplicity after std isolation
200  hists_["lepMultIso_" ]->setAxisTitle( "N_{Iso}(#mu)", 1); hists_["lepMultIso_" ]->setAxisTitle( "N_{Iso}(elec)", 2);
201 
202  if( verbosity_==VERBOSE) return;
203 
204  // --- [DEBUG] --- //
205  // electron multiplicity after std isolation
206  hists_["elecMultIso_" ] = store_->book1D("ElecMultIso" , "N_{Iso}(e)" , 11, -0.5, 10.5);
207  // muon multiplicity after std isolation
208  hists_["muonMultIso_" ] = store_->book1D("MuonMultIso" , "N_{Iso}(#mu)" , 11, -0.5, 10.5);
209  // calo isolation of the candidate muon (depending on the decay channel)
210  hists_["muonCalIso_" ] = store_->book1D("MuonCalIso" , "Iso_{Cal}(#mu)" , 50, 0., 1.);
211  // track isolation of the candidate muon (depending on the decay channel)
212  hists_["muonTrkIso_" ] = store_->book1D("MuonTrkIso" , "Iso_{Trk}(#mu)" , 50, 0., 1.);
213  // calo isolation of the candidate electron (depending on the decay channel)
214  hists_["elecCalIso_" ] = store_->book1D("ElecCalIso" , "Iso_{Cal}(e)" , 50, 0., 1.);
215  // track isolation of the candidate electron (depending on the decay channel)
216  hists_["elecTrkIso_" ] = store_->book1D("ElecTrkIso" , "Iso_{Trk}(e)" , 50, 0., 1.);
217  // eta of the leading jet
218  hists_["jet1Eta_" ] = store_->book1D("Jet1Eta" , "#eta(jet1)" , 30, -5., 5.);
219  // eta of the 2. leading jet
220  hists_["jet2Eta_" ] = store_->book1D("Jet2Eta" , "#eta(jet2)" , 30, -5., 5.);
221  // pt of the 1. leading jet (not corrected)
222  hists_["jet1PtRaw_" ] = store_->book1D("Jet1PtRaw" , "pt_{Raw}(jet1)" , 60, 0., 300.);
223  // pt of the 2. leading jet (not corrected)
224  hists_["jet2PtRaw_" ] = store_->book1D("Jet2PtRaw" , "pt_{Raw}(jet2)" , 60, 0., 300.);
225  // deltaEta between the 2 leading jets
226  hists_["dEtaJet1Jet2_"] = store_->book1D("DEtaJet1Jet2", "#Delta#eta(jet1,jet2)" , 80, -4., 4.);
227  // deltaEta between the lepton and the leading jet
228  hists_["dEtaJet1Lep1_"] = store_->book1D("DEtaJet1Lep1", "#Delta#eta(jet1,lep1)" , 80, -4., 4.);
229  // deltaEta between the lepton and MET
230  hists_["dEtaLep1MET_" ] = store_->book1D("DEtaLep1MET" , "#Delta#eta(lep1,MET)" , 80, -4., 4.);
231  // deltaEta between leading jet and MET
232  hists_["dEtaJet1MET_" ] = store_->book1D("DEtaJet1MET" , "#Delta#eta(jet1,MET)" , 80, -4., 4.);
233  // deltaPhi of 2 leading jets
234  hists_["dPhiJet1Jet2_"] = store_->book1D("DPhiJet1Jet2", "#Delta#phi(jet1,jet2)" , 64, -3.2, 3.2);
235  // deltaPhi of 1. lepton and 1. jet
236  hists_["dPhiJet1Lep1_"] = store_->book1D("DPhiJet1Lep1", "#Delta#phi(jet1,lep1)" , 64, -3.2, 3.2);
237  // deltaPhi of 1. lepton and MET
238  hists_["dPhiLep1MET_" ] = store_->book1D("DPhiLep1MET" , "#Delta#phi(lep1,MET)" , 64, -3.2, 3.2);
239  // deltaPhi of 1. jet and MET
240  hists_["dPhiJet1MET_" ] = store_->book1D("DPhiJet1MET" , "#Delta#phi(jet1,MET)" , 64, -3.2, 3.2);
241  // selected dimuon events
242  hists_["diMuonLogger_"] = store_->book2D("DiMuonLogger", "Logged DiMuon Events" , 8, 0., 8., 10, 0., 10.);
243  // selected dielec events
244  hists_["diElecLogger_"] = store_->book2D("DiElecLogger", "Logged DiElec Events" , 8, 0., 8., 10, 0., 10.);
245  // selected elemu events
246  hists_["elecMuLogger_"] = store_->book2D("ElecMuLogger", "Logged ElecMu Events" , 8, 0., 8., 10, 0., 10.);
247 
248  // set bin labels for trigger monitoring
249  loggerBinLabels(std::string("diMuonLogger_"));
250  loggerBinLabels(std::string("diElecLogger_"));
251  loggerBinLabels(std::string("elecMuLogger_"));
252  return;
253  }
DQMStore::book1D
MonitorElement * book1D(const char *name, const char *title, int nchX, double lowX, double highX)
Book 1D histogram.
Definition: DQMStore.cc:872
TopDiLeptonOffline::MonitorEnsemble::loggerBinLabels
void loggerBinLabels(std::string hist)
set labels for event logging histograms
Definition: TopDiLeptonOfflineDQM.h:159
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
TopDiLeptonOffline::MonitorEnsemble::diMuonPaths_
std::vector< std::string > diMuonPaths_
trigger paths for di muon channel
Definition: TopDiLeptonOfflineDQM.h:111
TopDiLeptonOffline::MonitorEnsemble::verbosity_
Level verbosity_
verbosity level for booking
Definition: TopDiLeptonOfflineDQM.h:87
TopDiLeptonOffline::MonitorEnsemble::hists_
std::map< std::string, MonitorElement * > hists_
histogram container
Definition: TopDiLeptonOfflineDQM.h:155
TopDiLeptonOffline::MonitorEnsemble::elecMuPaths_
std::vector< std::string > elecMuPaths_
Definition: TopDiLeptonOfflineDQM.h:109
DQMStore::book2D
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:1000
DQMStore::setCurrentFolder
void setCurrentFolder(const std::string &fullpath)
Definition: DQMStore.cc:584
TopDiLeptonOffline::MonitorEnsemble::triggerBinLabels
void triggerBinLabels(std::string channel, const std::vector< std::string > labels)
set configurable labels for trigger monitoring histograms
Definition: TopDiLeptonOfflineDQM.h:186
void TopDiLeptonOffline::MonitorEnsemble::book ( std::string  directory)

book histograms in subdirectory directory

bool TopDiLeptonOffline::MonitorEnsemble::booked ( const std::string  histName) const
inlineprivate

check if histogram was booked

Definition at line 81 of file TopDiLeptonOfflineDQM.h.

References hists_.

Referenced by fill().

81 { return hists_.find(histName.c_str())!=hists_.end(); };
TopDiLeptonOffline::MonitorEnsemble::hists_
std::map< std::string, MonitorElement * > hists_
histogram container
Definition: TopDiLeptonOfflineDQM.h:155
bool TopDiLeptonOffline::MonitorEnsemble::booked ( const std::string  histName) const
inlineprivate

check if histogram was booked

Definition at line 85 of file TopHLTDiLeptonOfflineDQM.h.

References hists_.

85 { return hists_.find(histName.c_str())!=hists_.end(); };
TopDiLeptonOffline::MonitorEnsemble::hists_
std::map< std::string, MonitorElement * > hists_
histogram container
Definition: TopDiLeptonOfflineDQM.h:155
MonitorEnsemble::DecayChannel MonitorEnsemble::decayChannel ( const std::vector< const reco::Muon * > &  muons,
const std::vector< const reco::GsfElectron * > &  elecs 
) const
inlineprivate

determine dileptonic decay channel

Definition at line 209 of file TopDiLeptonOfflineDQM.h.

References DIELEC, DIMUON, ELECMU, and NONE.

Referenced by fill().

210  {
211  DecayChannel type=NONE;
212  if( muons.size()>1 ){ type=DIMUON; } else if( elecs.size()>1 ){ type=DIELEC; } else if( !elecs.empty() && !muons.empty() ){ type=ELECMU; }
213  return type;
214  }
type
type
Definition: HCALResponse.h:21
patZpeak.muons
tuple muons
Definition: patZpeak.py:38
DecayChannel TopDiLeptonOffline::MonitorEnsemble::decayChannel ( const std::vector< const reco::Muon * > &  muons,
const std::vector< const reco::GsfElectron * > &  elecs 
) const
private

determine dileptonic decay channel

void MonitorEnsemble::fill ( const edm::Event &  event,
const edm::EventSetup &  setup 
)

fill monitor histograms with electronId and jetCorrections

Definition at line 256 of file TopDiLeptonOfflineDQM.cc.

References DeDxDiscriminatorTools::charge(), decayChannel(), reco::deltaPhi(), reco::deltaR(), DIELEC, diElecLogged_, DIMUON, diMuonLogged_, diMuonPaths_, eidPattern_, elecIso_, ELECMU, elecMuLogged_, elecMuPaths_, elecs_, elecSelect_, electronId_, reco::LeafCandidate::et(), eta(), edm::EventAuxiliary::event(), edm::Event::eventAuxiliary(), edm::EventSetup::find(), edm::Event::getByToken(), JetCorrector::getJetCorrector(), hists_, customizeTrackingMonitorSeedNumber::idx, edm::EDGetTokenT< T >::isUninitialized(), metsig::jet, jetCorrector_, bTagSequences_cff::jetID, jetIDLabel_, jetIDSelect_, fwrapper::jets, jets_, jetSelect_, lowerEdge_, edm::EventAuxiliary::luminosityBlock(), CaloMET_cfi::met, mets_, VarParsing::mult, metsig::muon, muonIso_, patZpeak::muons, muons_, muonSelect_, muon::overlap(), phi, RecoTauCleanerPlugins::pt, reco::LeafCandidate::pt(), edm::EventAuxiliary::run(), reco::Jet::scaleEnergy(), EgammaValidation_Wenu_cff::sel, triggerTable_, and upperEdge_.

Referenced by fill().

257  {
258  // fetch trigger event if configured such
259  edm::Handle<edm::TriggerResults> triggerTable;
260  if(!triggerTable_.isUninitialized()) {
261  if( !event.getByToken(triggerTable_, triggerTable) ) return;
262  }
263  /*
264  ------------------------------------------------------------
265 
266  Run and Inst. Luminosity information (Inst. Lumi. filled now with a dummy value=5.0)
267 
268  ------------------------------------------------------------
269  */
270 
271  if (!event.eventAuxiliary().run()) return;
272  fill("RunNumb_", event.eventAuxiliary().run());
273 
274  double dummy=5.; fill("InstLumi_", dummy);
275 
276 
277  /*
278  ------------------------------------------------------------
279 
280  Muon Selection
281 
282  ------------------------------------------------------------
283  */
284 
285  // buffer isolated muons
286  std::vector<const reco::Muon*> isoMuons;
287 
288  edm::Handle<edm::View<reco::Muon> > muons;
289  if( !event.getByToken(muons_, muons) ) return;
290 
291  for(edm::View<reco::Muon>::const_iterator muon=muons->begin(); muon!=muons->end(); ++muon){
292  // restrict to globalMuons
293  if( muon->isGlobalMuon() ){
294  fill("muonDelZ_" , muon->globalTrack()->vz());
295  fill("muonDelXY_", muon->globalTrack()->vx(), muon->globalTrack()->vy());
296  // apply preselection
297  if(!muonSelect_ || (*muonSelect_)(*muon)){
298  double isolationTrk = muon->pt()/(muon->pt()+muon->isolationR03().sumPt);
299  double isolationCal = muon->pt()/(muon->pt()+muon->isolationR03().emEt+muon->isolationR03().hadEt);
300  double isolationRel = (muon->isolationR03().sumPt+muon->isolationR03().emEt+muon->isolationR03().hadEt)/muon->pt();
301  fill("muonTrkIso_" , isolationTrk); fill("muonCalIso_" , isolationCal); fill("muonRelIso_" , isolationRel);
302  if(!muonIso_ || (*muonIso_)(*muon)) isoMuons.push_back(&(*muon));
303  }
304  }
305  }
306  fill("muonMultIso_", isoMuons.size());
307 
308  /*
309  ------------------------------------------------------------
310 
311  Electron Selection
312 
313  ------------------------------------------------------------
314  */
315 
316  // buffer isolated electronss
317  std::vector<const reco::GsfElectron*> isoElecs;
318  edm::Handle<edm::ValueMap<float> > electronId;
319  if(!electronId_.isUninitialized()) {
320  if( !event.getByToken(electronId_, electronId) ) return;
321  }
322  edm::Handle<edm::View<reco::GsfElectron> > elecs;
323  if( !event.getByToken(elecs_, elecs) ) return;
324 
325  for(edm::View<reco::GsfElectron>::const_iterator elec=elecs->begin(); elec!=elecs->end(); ++elec){
326  // restrict to electrons with good electronId
327  int idx = elec-elecs->begin();
328  if( electronId_.isUninitialized() ? true : ((int)(*electronId)[elecs->refAt(idx)] & eidPattern_) ){
329  // apply preselection
330  if(!elecSelect_ || (*elecSelect_)(*elec)){
331  double isolationTrk = elec->pt()/(elec->pt()+elec->dr03TkSumPt());
332  double isolationCal = elec->pt()/(elec->pt()+elec->dr03EcalRecHitSumEt()+elec->dr03HcalTowerSumEt());
333  double isolationRel = (elec->dr03TkSumPt()+elec->dr03EcalRecHitSumEt()+elec->dr03HcalTowerSumEt())/elec->pt();
334  fill("elecTrkIso_" , isolationTrk); fill("elecCalIso_" , isolationCal); fill("elecRelIso_" , isolationRel);
335  if(!elecIso_ || (*elecIso_)(*elec)) isoElecs.push_back(&(*elec));
336  }
337  }
338  }
339  fill("elecMultIso_", isoElecs.size());
340 
341  /*
342  ------------------------------------------------------------
343 
344  Jet Selection
345 
346  ------------------------------------------------------------
347  */
348 
349  const JetCorrector* corrector=0;
350  if(!jetCorrector_.empty()){
351  // check whether a jet correcto is in the event setup or not
352  if(setup.find( edm::eventsetup::EventSetupRecordKey::makeKey<JetCorrectionsRecord>() )){
353  corrector = JetCorrector::getJetCorrector(jetCorrector_, setup);
354  }
355  else{
356  edm::LogVerbatim( "TopDiLeptonOfflineDQM" )
357  << "\n"
358  << "------------------------------------------------------------------------------------- \n"
359  << " No JetCorrectionsRecord available from EventSetup: \n"
360  << " - Jets will not be corrected. \n"
361  << " - If you want to change this add the following lines to your cfg file: \n"
362  << " \n"
363  << " ## load jet corrections \n"
364  << " process.load(\"JetMETCorrections.Configuration.JetCorrectionServicesAllAlgos_cff\") \n"
365  << " process.prefer(\"ak5CaloL2L3\") \n"
366  << " \n"
367  << "------------------------------------------------------------------------------------- \n";
368  }
369  }
370 
371  unsigned int mult=0;
372  // buffer leadingJets
373  std::vector<reco::Jet> leadingJets;
374  edm::Handle<edm::View<reco::Jet> > jets;
375  if( !event.getByToken(jets_, jets) ) return;
376 
377  edm::Handle<reco::JetIDValueMap> jetID;
378  if(jetIDSelect_){
379  if( !event.getByToken(jetIDLabel_, jetID) ) return;
380  }
381 
382  for(edm::View<reco::Jet>::const_iterator jet=jets->begin(); jet!=jets->end(); ++jet){
383  unsigned int idx=jet-jets->begin();
384  if( jetIDSelect_ && dynamic_cast<const reco::CaloJet*>(jets->refAt(idx).get())){
385  if(!(*jetIDSelect_)((*jetID)[jets->refAt(idx)])) continue;
386  }
387  // chekc additional jet selection for calo, pf and bare reco jets
388  if(dynamic_cast<const reco::CaloJet*>(&*jet)){
389  reco::CaloJet sel = dynamic_cast<const reco::CaloJet&>(*jet); sel.scaleEnergy(corrector ? corrector->correction(*jet) : 1.);
390  StringCutObjectSelector<reco::CaloJet> jetSelect(jetSelect_); if(!jetSelect(sel)){ continue;}
391  }
392  else if(dynamic_cast<const reco::PFJet*>(&*jet)){
393  reco::PFJet sel= dynamic_cast<const reco::PFJet&>(*jet); sel.scaleEnergy(corrector ? corrector->correction(*jet) : 1.);
394  StringCutObjectSelector<reco::PFJet> jetSelect(jetSelect_); if(!jetSelect(sel)) continue;
395  }
396  else{
397  reco::Jet sel = *jet; sel.scaleEnergy(corrector ? corrector->correction(*jet) : 1.);
398  StringCutObjectSelector<reco::Jet> jetSelect(jetSelect_); if(!jetSelect(sel)) continue;
399  }
400  // check for overlaps
401  bool overlap=false;
402  for(std::vector<const reco::GsfElectron*>::const_iterator elec=isoElecs.begin(); elec!=isoElecs.end(); ++elec){
403  if(reco::deltaR((*elec)->eta(), (*elec)->phi(), jet->eta(), jet->phi())<0.4){overlap=true; break;}
404  } if(overlap){continue;}
405  // prepare jet to fill monitor histograms
406  reco::Jet monitorJet=*jet; monitorJet.scaleEnergy(corrector ? corrector->correction(*jet) : 1.);
407  ++mult; // determine jet multiplicity
408  if(idx==0) {
409  leadingJets.push_back(monitorJet);
410  fill("jet1Pt_" , monitorJet.pt());
411  fill("jet1PtRaw_" , jet->pt() );
412  fill("jet1Eta_" , jet->eta());
413  }
414  if(idx==1) {
415  leadingJets.push_back(monitorJet);
416  fill("jet2Pt_" , monitorJet.pt());
417  fill("jet2PtRaw_" , jet->pt() );
418  fill("jet2Eta_" , jet->eta());
419  }
420  }
421  if(leadingJets.size()>1){
422  fill("dEtaJet1Jet2_" , leadingJets[0].eta()-leadingJets[1].eta());
423  fill("dPhiJet1Jet2_" , reco::deltaPhi(leadingJets[0].phi(), leadingJets[1].phi()));
424  if( !isoMuons.empty() ){
425  if( isoElecs.empty() || isoMuons[0]->pt()>isoElecs[0]->pt() ){
426  fill("dEtaJet1Lep1_" , isoMuons[0]->eta()-leadingJets[0].eta());
427  fill("dPhiJet1Lep1_" , reco::deltaPhi(isoMuons[0]->phi() , leadingJets[0].phi()));
428  }
429  }
430  if( !isoElecs.empty() ){
431  if( isoMuons.empty() || isoElecs[0]->pt()>isoMuons[0]->pt() ){
432  fill("dEtaJet1Lep1_" , isoElecs[0]->eta()-leadingJets[0].eta());
433  fill("dPhiJet1Lep1_" , reco::deltaPhi(isoElecs[0]->phi() , leadingJets[0].phi()));
434  }
435  }
436  }
437  fill("jetMult_", mult);
438 
439  /*
440  ------------------------------------------------------------
441 
442  MET Selection
443 
444  ------------------------------------------------------------
445  */
446 
447  // buffer for event logging
448  reco::MET caloMET;
449  //for(std::vector<edm::InputTag>::const_iterator met_=mets_.begin(); met_!=mets_.end(); ++met_){
450  for(std::vector<edm::EDGetTokenT<edm::View<reco::MET> > >::const_iterator met_=mets_.begin(); met_!=mets_.end(); ++met_){
451 
452  edm::Handle<edm::View<reco::MET> > met;
453  if( !event.getByToken(*met_, met) ) continue;
454 
455  if(met->begin()!=met->end()){
456  unsigned int idx=met_-mets_.begin();
457  if(idx==0){
458  caloMET=*met->begin();
459  fill("metCalo_", met->begin()->et());
460  if(!leadingJets.empty()){
461  fill("dEtaJet1MET_" , leadingJets[0].eta()-met->begin()->eta());
462  fill("dPhiJet1MET_" , reco::deltaPhi(leadingJets[0].phi(), met->begin()->phi()));
463  }
464  if( !isoMuons.empty() ){
465  if( isoElecs.empty() || isoMuons[0]->pt()>isoElecs[0]->pt() ){
466  fill("dEtaLep1MET_" , isoMuons[0]->eta()-met->begin()->eta());
467  fill("dPhiLep1MET_" , reco::deltaPhi(isoMuons[0]->phi(), met->begin()->phi()));
468  }
469  }
470  if( !isoElecs.empty() ){
471  if( isoMuons.empty() || isoElecs[0]->pt()>isoMuons[0]->pt() ){
472  fill("dEtaLep1MET_" , isoElecs[0]->eta()-met->begin()->eta());
473  fill("dPhiLep1MET_" , reco::deltaPhi(isoElecs[0]->phi(), met->begin()->phi()));
474  }
475  }
476  }
477  if(idx==1){ fill("metTC_" , met->begin()->et());}
478  if(idx==2){ fill("metPflow_", met->begin()->et());}
479  }
480  }
481 
482 
483  /*
484  ------------------------------------------------------------
485 
486  Event Monitoring
487 
488  ------------------------------------------------------------
489  */
490 
491  // check number of isolated leptons
492  fill("lepMultIso_", isoMuons.size(), isoElecs.size());
493  // ELECMU channel
494  if( decayChannel(isoMuons, isoElecs) == ELECMU ){
495  fill("decayChannel_", 0.5);
496  double mass = (isoElecs[0]->p4()+isoMuons[0]->p4()).mass();
497  if( (lowerEdge_==-1. && upperEdge_==-1.) || (lowerEdge_<mass && mass<upperEdge_) ){
498 
499  fill("dEtaL1L2_" , isoElecs[0]->eta()-isoMuons[0]->eta());
500  fill("sumEtaL1L2_", (isoElecs[0]->eta()+isoMuons[0]->eta())/2);
501  fill("dPhiL1L2_" , reco::deltaPhi(isoElecs[0]->phi(), isoMuons[0]->eta()));
502  fill("elecPt_", isoElecs[0]->pt()); fill("muonPt_", isoMuons[0]->pt());
503  fill("lep1Pt_", isoElecs[0]->pt()>isoMuons[0]->pt() ? isoElecs[0]->pt() : isoMuons[0]->pt());
504  fill("lep2Pt_", isoElecs[0]->pt()>isoMuons[0]->pt() ? isoMuons[0]->pt() : isoElecs[0]->pt());
505  // fill plots for trigger monitoring
506  if(!triggerTable_.isUninitialized()) fill(event, *triggerTable, "elecMu", elecMuPaths_);
507  if(elecMuLogged_<=hists_.find("elecMuLogger_")->second->getNbinsY()){
508  // log runnumber, lumi block, event number & some
509  // more pysics infomation for interesting events
510  fill("elecMuLogger_", 0.5, elecMuLogged_+0.5, event.eventAuxiliary().run());
511  fill("elecMuLogger_", 1.5, elecMuLogged_+0.5, event.eventAuxiliary().luminosityBlock());
512  fill("elecMuLogger_", 2.5, elecMuLogged_+0.5, event.eventAuxiliary().event());
513  fill("elecMuLogger_", 3.5, elecMuLogged_+0.5, isoMuons[0]->pt());
514  fill("elecMuLogger_", 4.5, elecMuLogged_+0.5, isoElecs[0]->pt());
515  if(leadingJets.size()>0) fill("elecMuLogger_", 5.5, elecMuLogged_+0.5, leadingJets[0].pt());
516  if(leadingJets.size()>1) fill("elecMuLogger_", 6.5, elecMuLogged_+0.5, leadingJets[1].pt());
517  fill("elecMuLogger_", 7.5, elecMuLogged_+0.5, caloMET.et());
518  ++elecMuLogged_;
519  }
520  }
521  }
522 
523  // DIMUON channel
524  if( decayChannel(isoMuons, isoElecs) == DIMUON ){
525  fill("decayChannel_", 1.5);
526  int charge = isoMuons[0]->charge()*isoMuons[1]->charge();
527  double mass = (isoMuons[0]->p4()+isoMuons[1]->p4()).mass();
528 
529  fill(charge<0 ? "invMass_" : "invMassWC_" , mass );
530  fill(charge<0 ? "invMassLog_" : "invMassWCLog_" , log10(mass));
531  if((lowerEdge_==-1. && upperEdge_==-1.) || (lowerEdge_<mass && mass<upperEdge_) ){
532  fill("dEtaL1L2_" , isoMuons[0]->eta()-isoMuons[1]->eta() );
533  fill("sumEtaL1L2_", (isoMuons[0]->eta()+isoMuons[1]->eta())/2);
534  fill("dPhiL1L2_", reco::deltaPhi(isoMuons[0]->phi(),isoMuons[1]->phi()) );
535  fill("muonPt_", isoMuons[0]->pt()); fill("muonPt_", isoMuons[1]->pt());
536  fill("lep1Pt_", isoMuons[0]->pt()); fill("lep2Pt_", isoMuons[1]->pt());
537  // fill plots for trigger monitoring
538  if(!triggerTable_.isUninitialized()) fill(event, *triggerTable, "diMuon", diMuonPaths_);
539  if(diMuonLogged_<=hists_.find("diMuonLogger_")->second->getNbinsY()){
540  // log runnumber, lumi block, event number & some
541  // more pysics infomation for interesting events
542  fill("diMuonLogger_", 0.5, diMuonLogged_+0.5, event.eventAuxiliary().run());
543  fill("diMuonLogger_", 1.5, diMuonLogged_+0.5, event.eventAuxiliary().luminosityBlock());
544  fill("diMuonLogger_", 2.5, diMuonLogged_+0.5, event.eventAuxiliary().event());
545  fill("diMuonLogger_", 3.5, diMuonLogged_+0.5, isoMuons[0]->pt());
546  fill("diMuonLogger_", 4.5, diMuonLogged_+0.5, isoMuons[1]->pt());
547  if(leadingJets.size()>0) fill("diMuonLogger_", 5.5, diMuonLogged_+0.5, leadingJets[0].pt());
548  if(leadingJets.size()>1) fill("diMuonLogger_", 6.5, diMuonLogged_+0.5, leadingJets[1].pt());
549  fill("diMuonLogger_", 7.5, diMuonLogged_+0.5, caloMET.et());
550  ++diMuonLogged_;
551  }
552  }
553  }
554 
555  // DIELEC channel
556  if( decayChannel(isoMuons, isoElecs) == DIELEC ){
557  fill("decayChannel_", 2.5);
558  int charge = isoElecs[0]->charge()*isoElecs[1]->charge();
559  double mass = (isoElecs[0]->p4()+isoElecs[1]->p4()).mass();
560  fill(charge<0 ? "invMass_" : "invMassWC_" , mass );
561  fill(charge<0 ? "invMassLog_" : "invMassWCLog_" , log10(mass));
562  if((lowerEdge_==-1. && upperEdge_==-1.) || (lowerEdge_<mass && mass<upperEdge_) ){
563  fill("dEtaL1L2_" , isoElecs[0]->eta()-isoElecs[1]->eta() );
564  fill("sumEtaL1L2_", (isoElecs[0]->eta()+isoElecs[1]->eta())/2);
565  fill("dPhiL1L2_" , reco::deltaPhi(isoElecs[0]->phi(),isoElecs[1]->phi()) );
566  fill("elecPt_", isoElecs[0]->pt()); fill("elecPt_", isoElecs[1]->pt());
567  fill("lep1Pt_", isoElecs[0]->pt()); fill("lep2Pt_", isoElecs[1]->pt());
568  if(diElecLogged_<=hists_.find("diElecLogger_")->second->getNbinsY()){
569  // log runnumber, lumi block, event number & some
570  // more pysics infomation for interesting events
571  fill("diElecLogger_", 0.5, diElecLogged_+0.5, event.eventAuxiliary().run());
572  fill("diElecLogger_", 1.5, diElecLogged_+0.5, event.eventAuxiliary().luminosityBlock());
573  fill("diElecLogger_", 2.5, diElecLogged_+0.5, event.eventAuxiliary().event());
574  fill("diElecLogger_", 3.5, diElecLogged_+0.5, isoElecs[0]->pt());
575  fill("diElecLogger_", 4.5, diElecLogged_+0.5, isoElecs[1]->pt());
576  if(leadingJets.size()>0) fill("diElecLogger_", 5.5, diElecLogged_+0.5, leadingJets[0].pt());
577  if(leadingJets.size()>1) fill("diElecLogger_", 6.5, diElecLogged_+0.5, leadingJets[1].pt());
578  fill("diElecLogger_", 7.5, diElecLogged_+0.5, caloMET.et());
579  ++diElecLogged_;
580  }
581  }
582  }
583  }
TopDiLeptonOffline::MonitorEnsemble::jetIDSelect_
StringCutObjectSelector< reco::JetID > * jetIDSelect_
extra jetID selection on calo jets
Definition: TopDiLeptonOfflineDQM.h:143
reco::LeafCandidate::et
virtual double et() const GCC11_FINAL
transverse energy
Definition: LeafCandidate.h:136
edm::View::const_iterator
boost::indirect_iterator< typename seq_t::const_iterator > const_iterator
Definition: View.h:81
CaloMET_cfi.met
tuple met
____________________________________________________________________________||
Definition: CaloMET_cfi.py:7
reco::CaloJet
Jets made from CaloTowers.
Definition: CaloJet.h:29
TopDiLeptonOffline::MonitorEnsemble::jetIDLabel_
edm::EDGetTokenT< reco::JetIDValueMap > jetIDLabel_
jetID as an extra selection type
Definition: TopDiLeptonOfflineDQM.h:141
TopDiLeptonOffline::MonitorEnsemble::elecIso_
StringCutObjectSelector< reco::GsfElectron > * elecIso_
extra isolation criterion on electron
Definition: TopDiLeptonOfflineDQM.h:128
edm::Event::getByToken
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:434
TopDiLeptonOffline::MonitorEnsemble::muons_
edm::EDGetTokenT< edm::View< reco::Muon > > muons_
Definition: TopDiLeptonOfflineDQM.h:97
reco::Jet
Base class for all types of Jets.
Definition: Jet.h:20
TopDiLeptonOffline::MonitorEnsemble::decayChannel
DecayChannel decayChannel(const std::vector< const reco::Muon * > &muons, const std::vector< const reco::GsfElectron * > &elecs) const
determine dileptonic decay channel
Definition: TopDiLeptonOfflineDQM.h:209
edm::EventAuxiliary::run
RunNumber_t run() const
Definition: EventAuxiliary.h:67
EgammaValidation_Wenu_cff.sel
tuple sel
Definition: EgammaValidation_Wenu_cff.py:33
TopDiLeptonOffline::MonitorEnsemble::elecMuLogged_
int elecMuLogged_
number of logged interesting events
Definition: TopDiLeptonOfflineDQM.h:151
reco::Jet::scaleEnergy
virtual void scaleEnergy(double fScale)
scale energy of the jet
Definition: Jet.cc:444
eta
T eta() const
Definition: Basic3DVectorLD.h:179
DeDxDiscriminatorTools::charge
double charge(const std::vector< uint8_t > &Ampls)
Definition: DeDxDiscriminatorTools.cc:43
TopDiLeptonOffline::MonitorEnsemble::fill
void fill(const edm::Event &event, const edm::EventSetup &setup)
fill monitor histograms with electronId and jetCorrections
Definition: TopDiLeptonOfflineDQM.cc:256
reco::PFJet
Jets made from PFObjects.
Definition: PFJet.h:21
TopDiLeptonOffline::MonitorEnsemble::elecs_
edm::EDGetTokenT< edm::View< reco::GsfElectron > > elecs_
Definition: TopDiLeptonOfflineDQM.h:98
TopDiLeptonOffline::MonitorEnsemble::jets_
edm::EDGetTokenT< edm::View< reco::Jet > > jets_
input sources for monitoring
Definition: TopDiLeptonOfflineDQM.h:96
edm::EventAuxiliary::luminosityBlock
LuminosityBlockNumber_t luminosityBlock() const
Definition: EventAuxiliary.h:63
edm::EventSetup::find
const eventsetup::EventSetupRecord * find(const eventsetup::EventSetupRecordKey &) const
Definition: EventSetup.cc:90
muon::overlap
bool overlap(const reco::Muon &muon1, const reco::Muon &muon2, double pullX=1.0, double pullY=1.0, bool checkAdjacentChambers=false)
Definition: MuonSelectors.cc:676
bTagSequences_cff.jetID
tuple jetID
Definition: bTagSequences_cff.py:4
TopDiLeptonOffline::MonitorEnsemble::muonIso_
StringCutObjectSelector< reco::Muon > * muonIso_
extra isolation criterion on muon
Definition: TopDiLeptonOfflineDQM.h:133
reco::MET
Definition: MET.h:32
fwrapper::jets
vector< PseudoJet > jets
Definition: fastjetfortran_madfks.cc:42
TopDiLeptonOffline::MonitorEnsemble::muonSelect_
StringCutObjectSelector< reco::Muon > * muonSelect_
extra selection on muons
Definition: TopDiLeptonOfflineDQM.h:135
TopDiLeptonOffline::MonitorEnsemble::mets_
std::vector< edm::EDGetTokenT< edm::View< reco::MET > > > mets_
considers a vector of METs
Definition: TopDiLeptonOfflineDQM.h:102
reco::deltaR
auto deltaR(const T1 &t1, const T2 &t2) -> decltype(t1.eta())
Definition: deltaR.h:30
reco::deltaPhi
double deltaPhi(double phi1, double phi2)
Definition: deltaPhi.h:12
edm::Event::eventAuxiliary
EventAuxiliary const & eventAuxiliary() const
Definition: Event.h:72
TopDiLeptonOffline::MonitorEnsemble::diMuonPaths_
std::vector< std::string > diMuonPaths_
trigger paths for di muon channel
Definition: TopDiLeptonOfflineDQM.h:111
customizeTrackingMonitorSeedNumber.idx
tuple idx
DEBUGGING if hasattr(process,&quot;trackMonIterativeTracking2012&quot;): print &quot;trackMonIterativeTracking2012 D...
Definition: customizeTrackingMonitorSeedNumber.py:15
JetCorrector::getJetCorrector
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:50
TopDiLeptonOffline::MonitorEnsemble::lowerEdge_
double lowerEdge_
mass window upper and lower edge
Definition: TopDiLeptonOfflineDQM.h:148
TopDiLeptonOffline::MonitorEnsemble::triggerTable_
edm::EDGetTokenT< edm::TriggerResults > triggerTable_
trigger table
Definition: TopDiLeptonOfflineDQM.h:106
TopDiLeptonOffline::MonitorEnsemble::hists_
std::map< std::string, MonitorElement * > hists_
histogram container
Definition: TopDiLeptonOfflineDQM.h:155
TopDiLeptonOffline::MonitorEnsemble::elecSelect_
StringCutObjectSelector< reco::GsfElectron > * elecSelect_
extra selection on electrons
Definition: TopDiLeptonOfflineDQM.h:130
patZpeak.muons
tuple muons
Definition: patZpeak.py:38
TopDiLeptonOffline::MonitorEnsemble::elecMuPaths_
std::vector< std::string > elecMuPaths_
Definition: TopDiLeptonOfflineDQM.h:109
edm::EDGetTokenT::isUninitialized
bool isUninitialized() const
Definition: EDGetToken.h:71
reco::LeafCandidate::pt
virtual float pt() const GCC11_FINAL
transverse momentum
Definition: LeafCandidate.h:153
TopDiLeptonOffline::MonitorEnsemble::electronId_
edm::EDGetTokenT< edm::ValueMap< float > > electronId_
electronId label
Definition: TopDiLeptonOfflineDQM.h:115
edm::EventAuxiliary::event
EventNumber_t event() const
Definition: EventAuxiliary.h:66
phi
Definition: DDAxes.h:10
void MonitorEnsemble::fill ( const edm::Event &  event,
const edm::EventSetup &  setup,
edm::Handle< edm::TriggerResults >  triggerTable,
edm::Handle< edm::View< reco::Muon > >  muons,
edm::Handle< edm::ValueMap< float > >  electronId,
edm::Handle< edm::View< reco::GsfElectron > >  elecs,
edm::Handle< edm::View< reco::Jet > >  jets,
edm::Handle< reco::JetIDValueMap >  jetID,
std::vector< edm::Handle< edm::View< reco::MET > > >  mets 
)

fill monitor histograms with electronId and jetCorrections

Definition at line 255 of file TopHLTDiLeptonOfflineDQM.cc.

References DeDxDiscriminatorTools::charge(), decayChannel(), reco::deltaPhi(), reco::deltaR(), DIELEC, diElecLogged_, DIMUON, diMuonLogged_, diMuonPaths_, eidPattern_, elecIso_, ELECMU, elecMuLogged_, elecMuPaths_, elecSelect_, electronId_, reco::LeafCandidate::et(), eta(), edm::EventAuxiliary::event(), edm::Event::eventAuxiliary(), fill(), edm::EventSetup::find(), JetCorrector::getJetCorrector(), hists_, i, customizeTrackingMonitorSeedNumber::idx, edm::HandleBase::isValid(), metsig::jet, jetCorrector_, jetIDSelect_, fwrapper::jets, jetSelect_, lowerEdge_, edm::EventAuxiliary::luminosityBlock(), CaloMET_cfi::met, VarParsing::mult, metsig::muon, muonIso_, patZpeak::muons, muonSelect_, muon::overlap(), phi, RecoTauCleanerPlugins::pt, reco::LeafCandidate::pt(), edm::EventAuxiliary::run(), reco::Jet::scaleEnergy(), EgammaValidation_Wenu_cff::sel, triggerTable_, and upperEdge_.

260  {
261  // fetch trigger event if configured such
262  if(!triggerTable_.label().empty()) {
263  if( !triggerTable.isValid() ) return;
264  }
265 
266  /*
267  ------------------------------------------------------------
268 
269  Run and Inst. Luminosity information (Inst. Lumi. filled now with a dummy value=5.0)
270 
271  ------------------------------------------------------------
272  */
273 
274  if (!event.eventAuxiliary().run()) return;
275  fill("RunNumb_", event.eventAuxiliary().run());
276 
277  double dummy=5.; fill("InstLumi_", dummy);
278 
279 
280  /*
281  ------------------------------------------------------------
282 
283  Muon Selection
284 
285  ------------------------------------------------------------
286  */
287 
288  // buffer isolated muons
289  std::vector<const reco::Muon*> isoMuons;
290 
291  if( !muons.isValid() ) return;
292 
293  for(edm::View<reco::Muon>::const_iterator muon=muons->begin(); muon!=muons->end(); ++muon){
294  // restrict to globalMuons
295  if( muon->isGlobalMuon() ){
296  fill("muonDelZ_" , muon->globalTrack()->vz());
297  fill("muonDelXY_", muon->globalTrack()->vx(), muon->globalTrack()->vy());
298  // apply preselection
299  if(!muonSelect_ || (*muonSelect_)(*muon)){
300  double isolationTrk = muon->pt()/(muon->pt()+muon->isolationR03().sumPt);
301  double isolationCal = muon->pt()/(muon->pt()+muon->isolationR03().emEt+muon->isolationR03().hadEt);
302  double isolationRel = (muon->isolationR03().sumPt+muon->isolationR03().emEt+muon->isolationR03().hadEt)/muon->pt();
303  fill("muonTrkIso_" , isolationTrk); fill("muonCalIso_" , isolationCal); fill("muonRelIso_" , isolationRel);
304  if(!muonIso_ || (*muonIso_)(*muon)) isoMuons.push_back(&(*muon));
305  }
306  }
307  }
308  fill("muonMultIso_", isoMuons.size());
309 
310  /*
311  ------------------------------------------------------------
312 
313  Electron Selection
314 
315  ------------------------------------------------------------
316  */
317 
318  // buffer isolated electronss
319  std::vector<const reco::GsfElectron*> isoElecs;
320  if(!electronId_.label().empty()) {
321  if( !electronId.isValid() ) return;
322  }
323 
324  if( !elecs.isValid() ) return;
325 
326  for(edm::View<reco::GsfElectron>::const_iterator elec=elecs->begin(); elec!=elecs->end(); ++elec){
327  // restrict to electrons with good electronId
328  int idx = elec-elecs->begin();
329  if( electronId_.label().empty() ? true : ((int)(*electronId)[elecs->refAt(idx)] & eidPattern_) ){
330  // apply preselection
331  if(!elecSelect_ || (*elecSelect_)(*elec)){
332  double isolationTrk = elec->pt()/(elec->pt()+elec->dr03TkSumPt());
333  double isolationCal = elec->pt()/(elec->pt()+elec->dr03EcalRecHitSumEt()+elec->dr03HcalTowerSumEt());
334  double isolationRel = (elec->dr03TkSumPt()+elec->dr03EcalRecHitSumEt()+elec->dr03HcalTowerSumEt())/elec->pt();
335  fill("elecTrkIso_" , isolationTrk); fill("elecCalIso_" , isolationCal); fill("elecRelIso_" , isolationRel);
336  if(!elecIso_ || (*elecIso_)(*elec)) isoElecs.push_back(&(*elec));
337  }
338  }
339  }
340  fill("elecMultIso_", isoElecs.size());
341 
342  /*
343  ------------------------------------------------------------
344 
345  Jet Selection
346 
347  ------------------------------------------------------------
348  */
349 
350  const JetCorrector* corrector=0;
351  if(!jetCorrector_.empty()){
352  // check whether a jet correcto is in the event setup or not
353  if(setup.find( edm::eventsetup::EventSetupRecordKey::makeKey<JetCorrectionsRecord>() )){
354  corrector = JetCorrector::getJetCorrector(jetCorrector_, setup);
355  }
356  else{
357  edm::LogVerbatim( "TopHLTDiLeptonOfflineDQM" )
358  << "\n"
359  << "------------------------------------------------------------------------------------- \n"
360  << " No JetCorrectionsRecord available from EventSetup: \n"
361  << " - Jets will not be corrected. \n"
362  << " - If you want to change this add the following lines to your cfg file: \n"
363  << " \n"
364  << " ## load jet corrections \n"
365  << " process.load(\"JetMETCorrections.Configuration.JetCorrectionServicesAllAlgos_cff\") \n"
366  << " process.prefer(\"ak5CaloL2L3\") \n"
367  << " \n"
368  << "------------------------------------------------------------------------------------- \n";
369  }
370  }
371 
372  unsigned int mult=0;
373  // buffer leadingJets
374  std::vector<reco::Jet> leadingJets;
375  if( !jets.isValid() ) return;
376 
377  if(jetIDSelect_){
378  if( !jetID.isValid() ) return;
379  }
380 
381  for(edm::View<reco::Jet>::const_iterator jet=jets->begin(); jet!=jets->end(); ++jet){
382  unsigned int idx=jet-jets->begin();
383  if( jetIDSelect_ && dynamic_cast<const reco::CaloJet*>(jets->refAt(idx).get())){
384  if(!(*jetIDSelect_)((*jetID)[jets->refAt(idx)])) continue;
385  }
386  // chekc additional jet selection for calo, pf and bare reco jets
387  if(dynamic_cast<const reco::CaloJet*>(&*jet)){
388  reco::CaloJet sel = dynamic_cast<const reco::CaloJet&>(*jet); sel.scaleEnergy(corrector ? corrector->correction(*jet) : 1.);
389  StringCutObjectSelector<reco::CaloJet> jetSelect(jetSelect_); if(!jetSelect(sel)){ continue;}
390  }
391  else if(dynamic_cast<const reco::PFJet*>(&*jet)){
392  reco::PFJet sel= dynamic_cast<const reco::PFJet&>(*jet); sel.scaleEnergy(corrector ? corrector->correction(*jet) : 1.);
393  StringCutObjectSelector<reco::PFJet> jetSelect(jetSelect_); if(!jetSelect(sel)) continue;
394  }
395  else{
396  reco::Jet sel = *jet; sel.scaleEnergy(corrector ? corrector->correction(*jet) : 1.);
397  StringCutObjectSelector<reco::Jet> jetSelect(jetSelect_); if(!jetSelect(sel)) continue;
398  }
399  // check for overlaps
400  bool overlap=false;
401  for(std::vector<const reco::GsfElectron*>::const_iterator elec=isoElecs.begin(); elec!=isoElecs.end(); ++elec){
402  if(reco::deltaR((*elec)->eta(), (*elec)->phi(), jet->eta(), jet->phi())<0.4){overlap=true; break;}
403  } if(overlap){continue;}
404  // prepare jet to fill monitor histograms
405  reco::Jet monitorJet=*jet; monitorJet.scaleEnergy(corrector ? corrector->correction(*jet) : 1.);
406  ++mult; // determine jet multiplicity
407  if(idx==0) {
408  leadingJets.push_back(monitorJet);
409  fill("jet1Pt_" , monitorJet.pt());
410  fill("jet1PtRaw_" , jet->pt() );
411  fill("jet1Eta_" , jet->eta());
412  }
413  if(idx==1) {
414  leadingJets.push_back(monitorJet);
415  fill("jet2Pt_" , monitorJet.pt());
416  fill("jet2PtRaw_" , jet->pt() );
417  fill("jet2Eta_" , jet->eta());
418  }
419  }
420  if(leadingJets.size()>1){
421  fill("dEtaJet1Jet2_" , leadingJets[0].eta()-leadingJets[1].eta());
422  fill("dPhiJet1Jet2_" , reco::deltaPhi(leadingJets[0].phi(), leadingJets[1].phi()));
423  if( !isoMuons.empty() ){
424  if( isoElecs.empty() || isoMuons[0]->pt()>isoElecs[0]->pt() ){
425  fill("dEtaJet1Lep1_" , isoMuons[0]->eta()-leadingJets[0].eta());
426  fill("dPhiJet1Lep1_" , reco::deltaPhi(isoMuons[0]->phi() , leadingJets[0].phi()));
427  }
428  }
429  if( !isoElecs.empty() ){
430  if( isoMuons.empty() || isoElecs[0]->pt()>isoMuons[0]->pt() ){
431  fill("dEtaJet1Lep1_" , isoElecs[0]->eta()-leadingJets[0].eta());
432  fill("dPhiJet1Lep1_" , reco::deltaPhi(isoElecs[0]->phi() , leadingJets[0].phi()));
433  }
434  }
435  }
436  fill("jetMult_", mult);
437 
438  /*
439  ------------------------------------------------------------
440 
441  MET Selection
442 
443  ------------------------------------------------------------
444  */
445 
446  // buffer for event logging
447  reco::MET caloMET;
448  //for(std::vector<edm::InputTag>::const_iterator met_=mets_.begin(); met_!=mets_.end(); ++met_){
449  //for( met_=mets_.begin(); met_!=mets_.end(); ++met_){
450  for( int i=0; i<int(mets.size()); i++ ){
451  edm::Handle<edm::View<reco::MET> > met = mets[i];
452  if( !met.isValid() ) continue;
453 
454  if(met->begin()!=met->end()){
455  unsigned int idx=i;
456  if(idx==0){
457  caloMET=*met->begin();
458  fill("metCalo_", met->begin()->et());
459  if(!leadingJets.empty()){
460  fill("dEtaJet1MET_" , leadingJets[0].eta()-met->begin()->eta());
461  fill("dPhiJet1MET_" , reco::deltaPhi(leadingJets[0].phi(), met->begin()->phi()));
462  }
463  if( !isoMuons.empty() ){
464  if( isoElecs.empty() || isoMuons[0]->pt()>isoElecs[0]->pt() ){
465  fill("dEtaLep1MET_" , isoMuons[0]->eta()-met->begin()->eta());
466  fill("dPhiLep1MET_" , reco::deltaPhi(isoMuons[0]->phi(), met->begin()->phi()));
467  }
468  }
469  if( !isoElecs.empty() ){
470  if( isoMuons.empty() || isoElecs[0]->pt()>isoMuons[0]->pt() ){
471  fill("dEtaLep1MET_" , isoElecs[0]->eta()-met->begin()->eta());
472  fill("dPhiLep1MET_" , reco::deltaPhi(isoElecs[0]->phi(), met->begin()->phi()));
473  }
474  }
475  }
476  if(idx==1){ fill("metTC_" , met->begin()->et());}
477  if(idx==2){ fill("metPflow_", met->begin()->et());}
478  }
479  }
480 
481 
482  /*
483  ------------------------------------------------------------
484 
485  Event Monitoring
486 
487  ------------------------------------------------------------
488  */
489 
490  // check number of isolated leptons
491  fill("lepMultIso_", isoMuons.size(), isoElecs.size());
492  // ELECMU channel
493  if( decayChannel(isoMuons, isoElecs) == ELECMU ){
494  fill("decayChannel_", 0.5);
495  double mass = (isoElecs[0]->p4()+isoMuons[0]->p4()).mass();
496  if( (lowerEdge_==-1. && upperEdge_==-1.) || (lowerEdge_<mass && mass<upperEdge_) ){
497 
498  fill("dEtaL1L2_" , isoElecs[0]->eta()-isoMuons[0]->eta());
499  fill("sumEtaL1L2_", (isoElecs[0]->eta()+isoMuons[0]->eta())/2);
500  fill("dPhiL1L2_" , reco::deltaPhi(isoElecs[0]->phi(), isoMuons[0]->eta()));
501  fill("elecPt_", isoElecs[0]->pt()); fill("muonPt_", isoMuons[0]->pt());
502  fill("lep1Pt_", isoElecs[0]->pt()>isoMuons[0]->pt() ? isoElecs[0]->pt() : isoMuons[0]->pt());
503  fill("lep2Pt_", isoElecs[0]->pt()>isoMuons[0]->pt() ? isoMuons[0]->pt() : isoElecs[0]->pt());
504  // fill plots for trigger monitoring
505  if(!triggerTable_.label().empty()) fill(event, *triggerTable, "elecMu", elecMuPaths_);
506  if(elecMuLogged_<=hists_.find("elecMuLogger_")->second->getNbinsY()){
507  // log runnumber, lumi block, event number & some
508  // more pysics infomation for interesting events
509  fill("elecMuLogger_", 0.5, elecMuLogged_+0.5, event.eventAuxiliary().run());
510  fill("elecMuLogger_", 1.5, elecMuLogged_+0.5, event.eventAuxiliary().luminosityBlock());
511  fill("elecMuLogger_", 2.5, elecMuLogged_+0.5, event.eventAuxiliary().event());
512  fill("elecMuLogger_", 3.5, elecMuLogged_+0.5, isoMuons[0]->pt());
513  fill("elecMuLogger_", 4.5, elecMuLogged_+0.5, isoElecs[0]->pt());
514  if(leadingJets.size()>0) fill("elecMuLogger_", 5.5, elecMuLogged_+0.5, leadingJets[0].pt());
515  if(leadingJets.size()>1) fill("elecMuLogger_", 6.5, elecMuLogged_+0.5, leadingJets[1].pt());
516  fill("elecMuLogger_", 7.5, elecMuLogged_+0.5, caloMET.et());
517  ++elecMuLogged_;
518  }
519  }
520  }
521 
522  // DIMUON channel
523  if( decayChannel(isoMuons, isoElecs) == DIMUON ){
524  fill("decayChannel_", 1.5);
525  int charge = isoMuons[0]->charge()*isoMuons[1]->charge();
526  double mass = (isoMuons[0]->p4()+isoMuons[1]->p4()).mass();
527 
528  fill(charge<0 ? "invMass_" : "invMassWC_" , mass );
529  fill(charge<0 ? "invMassLog_" : "invMassWCLog_" , log10(mass));
530  if((lowerEdge_==-1. && upperEdge_==-1.) || (lowerEdge_<mass && mass<upperEdge_) ){
531  fill("dEtaL1L2_" , isoMuons[0]->eta()-isoMuons[1]->eta() );
532  fill("sumEtaL1L2_", (isoMuons[0]->eta()+isoMuons[1]->eta())/2);
533  fill("dPhiL1L2_", reco::deltaPhi(isoMuons[0]->phi(),isoMuons[1]->phi()) );
534  fill("muonPt_", isoMuons[0]->pt()); fill("muonPt_", isoMuons[1]->pt());
535  fill("lep1Pt_", isoMuons[0]->pt()); fill("lep2Pt_", isoMuons[1]->pt());
536  // fill plots for trigger monitoring
537  if(!triggerTable_.label().empty()) fill(event, *triggerTable, "diMuon", diMuonPaths_);
538  if(diMuonLogged_<=hists_.find("diMuonLogger_")->second->getNbinsY()){
539  // log runnumber, lumi block, event number & some
540  // more pysics infomation for interesting events
541  fill("diMuonLogger_", 0.5, diMuonLogged_+0.5, event.eventAuxiliary().run());
542  fill("diMuonLogger_", 1.5, diMuonLogged_+0.5, event.eventAuxiliary().luminosityBlock());
543  fill("diMuonLogger_", 2.5, diMuonLogged_+0.5, event.eventAuxiliary().event());
544  fill("diMuonLogger_", 3.5, diMuonLogged_+0.5, isoMuons[0]->pt());
545  fill("diMuonLogger_", 4.5, diMuonLogged_+0.5, isoMuons[1]->pt());
546  if(leadingJets.size()>0) fill("diMuonLogger_", 5.5, diMuonLogged_+0.5, leadingJets[0].pt());
547  if(leadingJets.size()>1) fill("diMuonLogger_", 6.5, diMuonLogged_+0.5, leadingJets[1].pt());
548  fill("diMuonLogger_", 7.5, diMuonLogged_+0.5, caloMET.et());
549  ++diMuonLogged_;
550  }
551  }
552  }
553 
554  // DIELEC channel
555  if( decayChannel(isoMuons, isoElecs) == DIELEC ){
556  fill("decayChannel_", 2.5);
557  int charge = isoElecs[0]->charge()*isoElecs[1]->charge();
558  double mass = (isoElecs[0]->p4()+isoElecs[1]->p4()).mass();
559  fill(charge<0 ? "invMass_" : "invMassWC_" , mass );
560  fill(charge<0 ? "invMassLog_" : "invMassWCLog_" , log10(mass));
561  if((lowerEdge_==-1. && upperEdge_==-1.) || (lowerEdge_<mass && mass<upperEdge_) ){
562  fill("dEtaL1L2_" , isoElecs[0]->eta()-isoElecs[1]->eta() );
563  fill("sumEtaL1L2_", (isoElecs[0]->eta()+isoElecs[1]->eta())/2);
564  fill("dPhiL1L2_" , reco::deltaPhi(isoElecs[0]->phi(),isoElecs[1]->phi()) );
565  fill("elecPt_", isoElecs[0]->pt()); fill("elecPt_", isoElecs[1]->pt());
566  fill("lep1Pt_", isoElecs[0]->pt()); fill("lep2Pt_", isoElecs[1]->pt());
567  if(diElecLogged_<=hists_.find("diElecLogger_")->second->getNbinsY()){
568  // log runnumber, lumi block, event number & some
569  // more pysics infomation for interesting events
570  fill("diElecLogger_", 0.5, diElecLogged_+0.5, event.eventAuxiliary().run());
571  fill("diElecLogger_", 1.5, diElecLogged_+0.5, event.eventAuxiliary().luminosityBlock());
572  fill("diElecLogger_", 2.5, diElecLogged_+0.5, event.eventAuxiliary().event());
573  fill("diElecLogger_", 3.5, diElecLogged_+0.5, isoElecs[0]->pt());
574  fill("diElecLogger_", 4.5, diElecLogged_+0.5, isoElecs[1]->pt());
575  if(leadingJets.size()>0) fill("diElecLogger_", 5.5, diElecLogged_+0.5, leadingJets[0].pt());
576  if(leadingJets.size()>1) fill("diElecLogger_", 6.5, diElecLogged_+0.5, leadingJets[1].pt());
577  fill("diElecLogger_", 7.5, diElecLogged_+0.5, caloMET.et());
578  ++diElecLogged_;
579  }
580  }
581  }
582  }
TopDiLeptonOffline::MonitorEnsemble::jetIDSelect_
StringCutObjectSelector< reco::JetID > * jetIDSelect_
extra jetID selection on calo jets
Definition: TopDiLeptonOfflineDQM.h:143
reco::LeafCandidate::et
virtual double et() const GCC11_FINAL
transverse energy
Definition: LeafCandidate.h:136
i
int i
Definition: DBlmapReader.cc:9
edm::View::const_iterator
boost::indirect_iterator< typename seq_t::const_iterator > const_iterator
Definition: View.h:81
CaloMET_cfi.met
tuple met
____________________________________________________________________________||
Definition: CaloMET_cfi.py:7
reco::CaloJet
Jets made from CaloTowers.
Definition: CaloJet.h:29
TopDiLeptonOffline::MonitorEnsemble::elecIso_
StringCutObjectSelector< reco::GsfElectron > * elecIso_
extra isolation criterion on electron
Definition: TopDiLeptonOfflineDQM.h:128
reco::Jet
Base class for all types of Jets.
Definition: Jet.h:20
TopDiLeptonOffline::MonitorEnsemble::decayChannel
DecayChannel decayChannel(const std::vector< const reco::Muon * > &muons, const std::vector< const reco::GsfElectron * > &elecs) const
determine dileptonic decay channel
Definition: TopDiLeptonOfflineDQM.h:209
edm::EventAuxiliary::run
RunNumber_t run() const
Definition: EventAuxiliary.h:67
EgammaValidation_Wenu_cff.sel
tuple sel
Definition: EgammaValidation_Wenu_cff.py:33
TopDiLeptonOffline::MonitorEnsemble::elecMuLogged_
int elecMuLogged_
number of logged interesting events
Definition: TopDiLeptonOfflineDQM.h:151
reco::Jet::scaleEnergy
virtual void scaleEnergy(double fScale)
scale energy of the jet
Definition: Jet.cc:444
edm::View::refAt
RefToBase< value_type > refAt(size_type i) const
eta
T eta() const
Definition: Basic3DVectorLD.h:179
DeDxDiscriminatorTools::charge
double charge(const std::vector< uint8_t > &Ampls)
Definition: DeDxDiscriminatorTools.cc:43
TopDiLeptonOffline::MonitorEnsemble::fill
void fill(const edm::Event &event, const edm::EventSetup &setup)
fill monitor histograms with electronId and jetCorrections
Definition: TopDiLeptonOfflineDQM.cc:256
reco::PFJet
Jets made from PFObjects.
Definition: PFJet.h:21
edm::EventAuxiliary::luminosityBlock
LuminosityBlockNumber_t luminosityBlock() const
Definition: EventAuxiliary.h:63
edm::EventSetup::find
const eventsetup::EventSetupRecord * find(const eventsetup::EventSetupRecordKey &) const
Definition: EventSetup.cc:90
muon::overlap
bool overlap(const reco::Muon &muon1, const reco::Muon &muon2, double pullX=1.0, double pullY=1.0, bool checkAdjacentChambers=false)
Definition: MuonSelectors.cc:676
TopDiLeptonOffline::MonitorEnsemble::muonIso_
StringCutObjectSelector< reco::Muon > * muonIso_
extra isolation criterion on muon
Definition: TopDiLeptonOfflineDQM.h:133
reco::MET
Definition: MET.h:32
TopDiLeptonOffline::MonitorEnsemble::muonSelect_
StringCutObjectSelector< reco::Muon > * muonSelect_
extra selection on muons
Definition: TopDiLeptonOfflineDQM.h:135
reco::deltaR
auto deltaR(const T1 &t1, const T2 &t2) -> decltype(t1.eta())
Definition: deltaR.h:30
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:76
reco::deltaPhi
double deltaPhi(double phi1, double phi2)
Definition: deltaPhi.h:12
edm::Event::eventAuxiliary
EventAuxiliary const & eventAuxiliary() const
Definition: Event.h:72
TopDiLeptonOffline::MonitorEnsemble::diMuonPaths_
std::vector< std::string > diMuonPaths_
trigger paths for di muon channel
Definition: TopDiLeptonOfflineDQM.h:111
customizeTrackingMonitorSeedNumber.idx
tuple idx
DEBUGGING if hasattr(process,&quot;trackMonIterativeTracking2012&quot;): print &quot;trackMonIterativeTracking2012 D...
Definition: customizeTrackingMonitorSeedNumber.py:15
JetCorrector::getJetCorrector
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:50
TopDiLeptonOffline::MonitorEnsemble::lowerEdge_
double lowerEdge_
mass window upper and lower edge
Definition: TopDiLeptonOfflineDQM.h:148
TopDiLeptonOffline::MonitorEnsemble::triggerTable_
edm::EDGetTokenT< edm::TriggerResults > triggerTable_
trigger table
Definition: TopDiLeptonOfflineDQM.h:106
TopDiLeptonOffline::MonitorEnsemble::hists_
std::map< std::string, MonitorElement * > hists_
histogram container
Definition: TopDiLeptonOfflineDQM.h:155
TopDiLeptonOffline::MonitorEnsemble::elecSelect_
StringCutObjectSelector< reco::GsfElectron > * elecSelect_
extra selection on electrons
Definition: TopDiLeptonOfflineDQM.h:130
TopDiLeptonOffline::MonitorEnsemble::elecMuPaths_
std::vector< std::string > elecMuPaths_
Definition: TopDiLeptonOfflineDQM.h:109
edm::View::begin
const_iterator begin() const
edm::View::end
const_iterator end() const
reco::LeafCandidate::pt
virtual float pt() const GCC11_FINAL
transverse momentum
Definition: LeafCandidate.h:153
TopDiLeptonOffline::MonitorEnsemble::electronId_
edm::EDGetTokenT< edm::ValueMap< float > > electronId_
electronId label
Definition: TopDiLeptonOfflineDQM.h:115
edm::EventAuxiliary::event
EventNumber_t event() const
Definition: EventAuxiliary.h:66
phi
Definition: DDAxes.h:10
void MonitorEnsemble::fill ( const edm::Event &  event,
const edm::TriggerResults &  triggerTable,
std::string  channel,
const std::vector< std::string >  labels 
) const
inlineprivate

fill trigger monitoring histograms

Definition at line 195 of file TopDiLeptonOfflineDQM.h.

References accept(), fill(), hists_, customizeTrackingMonitorSeedNumber::idx, monitorPath(), selectionPath(), and relativeConstraints::value.

196  {
197  for(unsigned int idx=0; idx<labels.size(); ++idx){
198  if( accept(event, triggerTable, monitorPath(labels[idx])) ){
199  fill((channel+"Mon_").c_str(), idx+0.5 );
200  // take care to fill triggerMon_ before evts is being called
201  int evts = hists_.find((channel+"Mon_").c_str())->second->getBinContent(idx+1);
202  double value = hists_.find((channel+"Eff_").c_str())->second->getBinContent(idx+1);
203  fill((channel+"Eff_").c_str(), idx+0.5, 1./evts*(accept(event, triggerTable, selectionPath(labels[idx]))-value));
204  }
205  }
206  }
TopDiLeptonOffline::MonitorEnsemble::selectionPath
std::string selectionPath(const std::string &label) const
Definition: TopDiLeptonOfflineDQM.h:69
TopDiLeptonOffline::MonitorEnsemble::monitorPath
std::string monitorPath(const std::string &label) const
Definition: TopDiLeptonOfflineDQM.h:66
accept
bool accept(const edm::Event &event, const edm::TriggerResults &triggerTable, const std::string &triggerPath)
Definition: TopDQMHelpers.h:26
TopDiLeptonOffline::MonitorEnsemble::fill
void fill(const edm::Event &event, const edm::EventSetup &setup)
fill monitor histograms with electronId and jetCorrections
Definition: TopDiLeptonOfflineDQM.cc:256
customizeTrackingMonitorSeedNumber.idx
tuple idx
DEBUGGING if hasattr(process,&quot;trackMonIterativeTracking2012&quot;): print &quot;trackMonIterativeTracking2012 D...
Definition: customizeTrackingMonitorSeedNumber.py:15
TopDiLeptonOffline::MonitorEnsemble::hists_
std::map< std::string, MonitorElement * > hists_
histogram container
Definition: TopDiLeptonOfflineDQM.h:155
void MonitorEnsemble::fill ( const edm::Event &  event,
const edm::TriggerResults &  triggerTable,
std::string  channel,
const std::vector< std::string > &  labels 
) const
inlineprivate

fill trigger monitoring histograms

Definition at line 192 of file TopHLTDiLeptonOfflineDQM.h.

References acceptHLT(), fill(), hists_, customizeTrackingMonitorSeedNumber::idx, monitorPath(), selectionPath(), and relativeConstraints::value.

193  {
194  for(unsigned int idx=0; idx<labels.size(); ++idx){
195  if( acceptHLT(event, triggerTable, monitorPath(labels[idx])) ){
196  fill((channel+"Mon_").c_str(), idx+0.5 );
197  // take care to fill triggerMon_ before evts is being called
198  int evts = hists_.find((channel+"Mon_").c_str())->second->getBinContent(idx+1);
199  double value = hists_.find((channel+"Eff_").c_str())->second->getBinContent(idx+1);
200  fill((channel+"Eff_").c_str(), idx+0.5, 1./evts*(acceptHLT(event, triggerTable, selectionPath(labels[idx]))-value));
201  }
202  }
203  }
TopDiLeptonOffline::MonitorEnsemble::selectionPath
std::string selectionPath(const std::string &label) const
Definition: TopDiLeptonOfflineDQM.h:69
acceptHLT
bool acceptHLT(const edm::Event &event, const edm::TriggerResults &triggerTable, const std::string &triggerPath)
Definition: TopHLTDQMHelper.h:27
TopDiLeptonOffline::MonitorEnsemble::monitorPath
std::string monitorPath(const std::string &label) const
Definition: TopDiLeptonOfflineDQM.h:66
TopDiLeptonOffline::MonitorEnsemble::fill
void fill(const edm::Event &event, const edm::EventSetup &setup)
fill monitor histograms with electronId and jetCorrections
Definition: TopDiLeptonOfflineDQM.cc:256
customizeTrackingMonitorSeedNumber.idx
tuple idx
DEBUGGING if hasattr(process,&quot;trackMonIterativeTracking2012&quot;): print &quot;trackMonIterativeTracking2012 D...
Definition: customizeTrackingMonitorSeedNumber.py:15
TopDiLeptonOffline::MonitorEnsemble::hists_
std::map< std::string, MonitorElement * > hists_
histogram container
Definition: TopDiLeptonOfflineDQM.h:155
void TopDiLeptonOffline::MonitorEnsemble::fill ( const std::string  histName,
double  value 
) const
inlineprivate

fill histogram if it had been booked before

Definition at line 83 of file TopDiLeptonOfflineDQM.h.

References booked(), hists_, and edm::second().

83 { if(booked(histName.c_str())) hists_.find(histName.c_str())->second->Fill(value); };
TopDiLeptonOffline::MonitorEnsemble::booked
bool booked(const std::string histName) const
check if histogram was booked
Definition: TopDiLeptonOfflineDQM.h:81
edm::second
U second(std::pair< T, U > const &p)
Definition: ParameterSet.cc:250
TopDiLeptonOffline::MonitorEnsemble::hists_
std::map< std::string, MonitorElement * > hists_
histogram container
Definition: TopDiLeptonOfflineDQM.h:155
void TopDiLeptonOffline::MonitorEnsemble::fill ( const std::string  histName,
double  xValue,
double  yValue 
) const
inlineprivate

fill histogram if it had been booked before (2-dim version)

Definition at line 85 of file TopDiLeptonOfflineDQM.h.

References booked(), hists_, and edm::second().

85 { if(booked(histName.c_str())) hists_.find(histName.c_str())->second->Fill(xValue, yValue); };
TopDiLeptonOffline::MonitorEnsemble::booked
bool booked(const std::string histName) const
check if histogram was booked
Definition: TopDiLeptonOfflineDQM.h:81
edm::second
U second(std::pair< T, U > const &p)
Definition: ParameterSet.cc:250
TopDiLeptonOffline::MonitorEnsemble::hists_
std::map< std::string, MonitorElement * > hists_
histogram container
Definition: TopDiLeptonOfflineDQM.h:155
void TopDiLeptonOffline::MonitorEnsemble::fill ( const std::string  histName,
double  value 
) const
inlineprivate

fill histogram if it had been booked before

Definition at line 87 of file TopHLTDiLeptonOfflineDQM.h.

References booked(), hists_, and edm::second().

87 { if(booked(histName.c_str())) hists_.find(histName.c_str())->second->Fill(value); };
TopDiLeptonOffline::MonitorEnsemble::booked
bool booked(const std::string histName) const
check if histogram was booked
Definition: TopDiLeptonOfflineDQM.h:81
edm::second
U second(std::pair< T, U > const &p)
Definition: ParameterSet.cc:250
TopDiLeptonOffline::MonitorEnsemble::hists_
std::map< std::string, MonitorElement * > hists_
histogram container
Definition: TopDiLeptonOfflineDQM.h:155
void TopDiLeptonOffline::MonitorEnsemble::fill ( const std::string  histName,
double  xValue,
double  yValue,
double  zValue 
) const
inlineprivate

fill histogram if it had been booked before (2-dim version)

Definition at line 87 of file TopDiLeptonOfflineDQM.h.

87 { if(booked(histName.c_str())) hists_.find(histName.c_str())->second->Fill(xValue, yValue, zValue); };
TopDiLeptonOffline::MonitorEnsemble::booked
bool booked(const std::string histName) const
check if histogram was booked
Definition: TopDiLeptonOfflineDQM.h:81
edm::second
U second(std::pair< T, U > const &p)
Definition: ParameterSet.cc:250
TopDiLeptonOffline::MonitorEnsemble::hists_
std::map< std::string, MonitorElement * > hists_
histogram container
Definition: TopDiLeptonOfflineDQM.h:155
void TopDiLeptonOffline::MonitorEnsemble::fill ( const std::string  histName,
double  xValue,
double  yValue 
) const
inlineprivate

fill histogram if it had been booked before (2-dim version)

Definition at line 89 of file TopHLTDiLeptonOfflineDQM.h.

References booked(), hists_, and edm::second().

89 { if(booked(histName.c_str())) hists_.find(histName.c_str())->second->Fill(xValue, yValue); };
TopDiLeptonOffline::MonitorEnsemble::booked
bool booked(const std::string histName) const
check if histogram was booked
Definition: TopDiLeptonOfflineDQM.h:81
edm::second
U second(std::pair< T, U > const &p)
Definition: ParameterSet.cc:250
TopDiLeptonOffline::MonitorEnsemble::hists_
std::map< std::string, MonitorElement * > hists_
histogram container
Definition: TopDiLeptonOfflineDQM.h:155
void TopDiLeptonOffline::MonitorEnsemble::fill ( const std::string  histName,
double  xValue,
double  yValue,
double  zValue 
) const
inlineprivate

fill histogram if it had been booked before (2-dim version)

Definition at line 91 of file TopHLTDiLeptonOfflineDQM.h.

References booked(), hists_, and edm::second().

91 { if(booked(histName.c_str())) hists_.find(histName.c_str())->second->Fill(xValue, yValue, zValue); };
TopDiLeptonOffline::MonitorEnsemble::booked
bool booked(const std::string histName) const
check if histogram was booked
Definition: TopDiLeptonOfflineDQM.h:81
edm::second
U second(std::pair< T, U > const &p)
Definition: ParameterSet.cc:250
TopDiLeptonOffline::MonitorEnsemble::hists_
std::map< std::string, MonitorElement * > hists_
histogram container
Definition: TopDiLeptonOfflineDQM.h:155
void MonitorEnsemble::loggerBinLabels ( std::string  hist)
inlineprivate

set labels for event logging histograms

Definition at line 159 of file TopDiLeptonOfflineDQM.h.

References hists_.

Referenced by book().

160  {
161  // set axes titles for selected events
162  hists_[hist.c_str()]->getTH1()->SetOption("TEXT");
163  hists_[hist.c_str()]->setBinLabel( 1 , "Run" , 1);
164  hists_[hist.c_str()]->setBinLabel( 2 , "Block" , 1);
165  hists_[hist.c_str()]->setBinLabel( 3 , "Event" , 1);
166  hists_[hist.c_str()]->setBinLabel( 6 , "pt_{L2L3}(jet1)" , 1);
167  hists_[hist.c_str()]->setBinLabel( 7 , "pt_{L2L3}(jet2)" , 1);
168  hists_[hist.c_str()]->setBinLabel( 8 , "MET_{Calo}" , 1);
169  hists_[hist.c_str()]->setAxisTitle("logged evts" , 2);
170 
171  if(hist=="diMuonLogger_"){
172  hists_[hist.c_str()]->setBinLabel( 4 , "pt(muon)" , 1);
173  hists_[hist.c_str()]->setBinLabel( 5 , "pt(muon)" , 1);
174  }
175  if(hist=="diElecLogger_"){
176  hists_[hist.c_str()]->setBinLabel( 4 , "pt(elec)" , 1);
177  hists_[hist.c_str()]->setBinLabel( 5 , "pt(elec)" , 1);
178  }
179  if(hist=="elecMuLogger_"){
180  hists_[hist.c_str()]->setBinLabel( 4 , "pt(elec)" , 1);
181  hists_[hist.c_str()]->setBinLabel( 5 , "pt(muon)" , 1);
182  }
183  }
TopDiLeptonOffline::MonitorEnsemble::hists_
std::map< std::string, MonitorElement * > hists_
histogram container
Definition: TopDiLeptonOfflineDQM.h:155
void TopDiLeptonOffline::MonitorEnsemble::loggerBinLabels ( std::string  hist)
private

set labels for event logging histograms

std::string TopDiLeptonOffline::MonitorEnsemble::monitorPath ( const std::string &  label) const
inlineprivate

deduce monitorPath from label, the label is expected to be of type 'selectionPath:monitorPath'

Definition at line 66 of file TopDiLeptonOfflineDQM.h.

Referenced by fill(), and triggerBinLabels().

66 { return label.substr(label.find(':')+1); };
std::string TopDiLeptonOffline::MonitorEnsemble::monitorPath ( const std::string &  label) const
inlineprivate

deduce monitorPath from label, the label is expected to be of type 'selectionPath:monitorPath'

Definition at line 70 of file TopHLTDiLeptonOfflineDQM.h.

70 { return label.substr(label.find(':')+1); };
std::string TopDiLeptonOffline::MonitorEnsemble::selectionPath ( const std::string &  label) const
inlineprivate

deduce selectionPath from label, the label is expected to be of type 'selectionPath:monitorPath'

Definition at line 69 of file TopDiLeptonOfflineDQM.h.

Referenced by fill(), and triggerBinLabels().

69 { return label.substr(0, label.find(':')); };
std::string TopDiLeptonOffline::MonitorEnsemble::selectionPath ( const std::string &  label) const
inlineprivate

deduce selectionPath from label, the label is expected to be of type 'selectionPath:monitorPath'

Definition at line 73 of file TopHLTDiLeptonOfflineDQM.h.

73 { return label.substr(0, label.find(':')); };
void MonitorEnsemble::triggerBinLabels ( std::string  channel,
const std::vector< std::string >  labels 
)
inlineprivate

set configurable labels for trigger monitoring histograms

Definition at line 186 of file TopDiLeptonOfflineDQM.h.

References hists_, customizeTrackingMonitorSeedNumber::idx, monitorPath(), and selectionPath().

Referenced by book().

187  {
188  for(unsigned int idx=0; idx<labels.size(); ++idx){
189  hists_[(channel+"Mon_").c_str()]->setBinLabel( idx+1, "["+monitorPath(labels[idx])+"]", 1);
190  hists_[(channel+"Eff_").c_str()]->setBinLabel( idx+1, "["+selectionPath(labels[idx])+"]|["+monitorPath(labels[idx])+"]", 1);
191  }
192  }
TopDiLeptonOffline::MonitorEnsemble::selectionPath
std::string selectionPath(const std::string &label) const
Definition: TopDiLeptonOfflineDQM.h:69
TopDiLeptonOffline::MonitorEnsemble::monitorPath
std::string monitorPath(const std::string &label) const
Definition: TopDiLeptonOfflineDQM.h:66
customizeTrackingMonitorSeedNumber.idx
tuple idx
DEBUGGING if hasattr(process,&quot;trackMonIterativeTracking2012&quot;): print &quot;trackMonIterativeTracking2012 D...
Definition: customizeTrackingMonitorSeedNumber.py:15
TopDiLeptonOffline::MonitorEnsemble::hists_
std::map< std::string, MonitorElement * > hists_
histogram container
Definition: TopDiLeptonOfflineDQM.h:155
void MonitorEnsemble::triggerBinLabels ( std::string  channel,
const std::vector< std::string > &  labels 
)
inlineprivate

set configurable labels for trigger monitoring histograms

Definition at line 183 of file TopHLTDiLeptonOfflineDQM.h.

References hists_, customizeTrackingMonitorSeedNumber::idx, monitorPath(), and selectionPath().

184  {
185  for(unsigned int idx=0; idx<labels.size(); ++idx){
186  hists_[(channel+"Mon_").c_str()]->setBinLabel( idx+1, "["+monitorPath(labels[idx])+"]", 1);
187  hists_[(channel+"Eff_").c_str()]->setBinLabel( idx+1, "["+selectionPath(labels[idx])+"]|["+monitorPath(labels[idx])+"]", 1);
188  }
189  }
TopDiLeptonOffline::MonitorEnsemble::selectionPath
std::string selectionPath(const std::string &label) const
Definition: TopDiLeptonOfflineDQM.h:69
TopDiLeptonOffline::MonitorEnsemble::monitorPath
std::string monitorPath(const std::string &label) const
Definition: TopDiLeptonOfflineDQM.h:66
customizeTrackingMonitorSeedNumber.idx
tuple idx
DEBUGGING if hasattr(process,&quot;trackMonIterativeTracking2012&quot;): print &quot;trackMonIterativeTracking2012 D...
Definition: customizeTrackingMonitorSeedNumber.py:15
TopDiLeptonOffline::MonitorEnsemble::hists_
std::map< std::string, MonitorElement * > hists_
histogram container
Definition: TopDiLeptonOfflineDQM.h:155

Member Data Documentation

int MonitorEnsemble::diElecLogged_
private

Definition at line 151 of file TopDiLeptonOfflineDQM.h.

Referenced by fill().

int MonitorEnsemble::diMuonLogged_
private

Definition at line 151 of file TopDiLeptonOfflineDQM.h.

Referenced by fill().

std::vector< std::string > MonitorEnsemble::diMuonPaths_
private

trigger paths for di muon channel

Definition at line 111 of file TopDiLeptonOfflineDQM.h.

Referenced by book(), fill(), and MonitorEnsemble().

int MonitorEnsemble::eidPattern_
private

electronId pattern we expect the following pattern: 0: fails 1: passes electron ID only 2: passes electron Isolation only 3: passes electron ID and Isolation only 4: passes conversion rejection 5: passes conversion rejection and ID 6: passes conversion rejection and Isolation 7: passes the whole selection As described on https://twiki.cern.ch/twiki/bin/view/CMS/SimpleCutBasedEleID

Definition at line 126 of file TopDiLeptonOfflineDQM.h.

Referenced by fill(), and MonitorEnsemble().

StringCutObjectSelector< reco::GsfElectron > * MonitorEnsemble::elecIso_
private

extra isolation criterion on electron

Definition at line 128 of file TopDiLeptonOfflineDQM.h.

Referenced by fill(), and MonitorEnsemble().

int MonitorEnsemble::elecMuLogged_
private

number of logged interesting events

Definition at line 151 of file TopDiLeptonOfflineDQM.h.

Referenced by fill().

std::vector< std::string > MonitorEnsemble::elecMuPaths_
private

trigger paths for monitoring, expected to be of form signalPath:MonitorPath

Definition at line 109 of file TopDiLeptonOfflineDQM.h.

Referenced by book(), fill(), and MonitorEnsemble().

edm::EDGetTokenT<edm::View<reco::GsfElectron> > TopDiLeptonOffline::MonitorEnsemble::elecs_
private

Definition at line 98 of file TopDiLeptonOfflineDQM.h.

Referenced by fill(), and MonitorEnsemble().

edm::InputTag TopDiLeptonOffline::MonitorEnsemble::elecs_
private

input sources for monitoring

Definition at line 99 of file TopHLTDiLeptonOfflineDQM.h.

StringCutObjectSelector< reco::GsfElectron > * MonitorEnsemble::elecSelect_
private

extra selection on electrons

Definition at line 130 of file TopDiLeptonOfflineDQM.h.

Referenced by fill(), and MonitorEnsemble().

edm::InputTag TopDiLeptonOffline::MonitorEnsemble::electronId_
private

electronId label

Definition at line 113 of file TopHLTDiLeptonOfflineDQM.h.

edm::EDGetTokenT<edm::ValueMap<float> > TopDiLeptonOffline::MonitorEnsemble::electronId_
private

electronId label

Definition at line 115 of file TopDiLeptonOfflineDQM.h.

Referenced by fill(), and MonitorEnsemble().

std::map< std::string, MonitorElement * > MonitorEnsemble::hists_
private

histogram container

Definition at line 155 of file TopDiLeptonOfflineDQM.h.

Referenced by book(), booked(), fill(), loggerBinLabels(), and triggerBinLabels().

std::string MonitorEnsemble::jetCorrector_
private

jetCorrector

Definition at line 138 of file TopDiLeptonOfflineDQM.h.

Referenced by fill(), and MonitorEnsemble().

edm::InputTag TopDiLeptonOffline::MonitorEnsemble::jetIDLabel_
private

jetID as an extra selection type

Definition at line 138 of file TopHLTDiLeptonOfflineDQM.h.

edm::EDGetTokenT<reco::JetIDValueMap> TopDiLeptonOffline::MonitorEnsemble::jetIDLabel_
private

jetID as an extra selection type

Definition at line 141 of file TopDiLeptonOfflineDQM.h.

Referenced by fill(), and MonitorEnsemble().

StringCutObjectSelector< reco::JetID > * MonitorEnsemble::jetIDSelect_
private

extra jetID selection on calo jets

Definition at line 143 of file TopDiLeptonOfflineDQM.h.

Referenced by fill(), and MonitorEnsemble().

edm::EDGetTokenT<edm::View<reco::Jet> > TopDiLeptonOffline::MonitorEnsemble::jets_
private

input sources for monitoring

Definition at line 96 of file TopDiLeptonOfflineDQM.h.

Referenced by fill(), and MonitorEnsemble().

edm::InputTag TopDiLeptonOffline::MonitorEnsemble::jets_
private

Definition at line 99 of file TopHLTDiLeptonOfflineDQM.h.

std::string MonitorEnsemble::jetSelect_
private

extra selection on jets (here given as std::string as it depends on the the jet type, which selections are valid and which not)

Definition at line 146 of file TopDiLeptonOfflineDQM.h.

Referenced by fill(), and MonitorEnsemble().

std::string MonitorEnsemble::label_
private

instance label

Definition at line 93 of file TopDiLeptonOfflineDQM.h.

Referenced by Mixins._Labelable::_findDependencies(), book(), Mixins._TypedParameterizable::dumpPython(), and Mixins._Labelable::setLabel().

double MonitorEnsemble::lowerEdge_
private

mass window upper and lower edge

Definition at line 148 of file TopDiLeptonOfflineDQM.h.

Referenced by fill(), and MonitorEnsemble().

std::vector<edm::EDGetTokenT<edm::View<reco::MET> > > TopDiLeptonOffline::MonitorEnsemble::mets_
private

considers a vector of METs

Definition at line 102 of file TopDiLeptonOfflineDQM.h.

Referenced by fill(), and MonitorEnsemble().

std::vector<edm::InputTag> TopDiLeptonOffline::MonitorEnsemble::mets_
private

considers a vector of METs

Definition at line 102 of file TopHLTDiLeptonOfflineDQM.h.

StringCutObjectSelector< reco::Muon > * MonitorEnsemble::muonIso_
private

extra isolation criterion on muon

Definition at line 133 of file TopDiLeptonOfflineDQM.h.

Referenced by fill(), and MonitorEnsemble().

edm::EDGetTokenT<edm::View<reco::Muon> > TopDiLeptonOffline::MonitorEnsemble::muons_
private

Definition at line 97 of file TopDiLeptonOfflineDQM.h.

Referenced by fill(), and MonitorEnsemble().

edm::InputTag TopDiLeptonOffline::MonitorEnsemble::muons_
private

Definition at line 99 of file TopHLTDiLeptonOfflineDQM.h.

StringCutObjectSelector< reco::Muon > * MonitorEnsemble::muonSelect_
private

extra selection on muons

Definition at line 135 of file TopDiLeptonOfflineDQM.h.

Referenced by fill(), and MonitorEnsemble().

DQMStore * MonitorEnsemble::store_
private

storage manager

Definition at line 153 of file TopDiLeptonOfflineDQM.h.

Referenced by book().

edm::InputTag TopDiLeptonOffline::MonitorEnsemble::triggerTable_
private

trigger table

Definition at line 105 of file TopHLTDiLeptonOfflineDQM.h.

edm::EDGetTokenT<edm::TriggerResults> TopDiLeptonOffline::MonitorEnsemble::triggerTable_
private

trigger table

Definition at line 106 of file TopDiLeptonOfflineDQM.h.

Referenced by fill(), and MonitorEnsemble().

double MonitorEnsemble::upperEdge_
private

Definition at line 148 of file TopDiLeptonOfflineDQM.h.

Referenced by fill(), and MonitorEnsemble().

Level MonitorEnsemble::verbosity_
private

verbosity level for booking

Definition at line 87 of file TopDiLeptonOfflineDQM.h.

Referenced by book(), and MonitorEnsemble().

Generated for CMSSW Reference Manual by doxygen 1.8.5