CMS 3D CMS Logo

 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
List of all members | Public Member Functions | Private Types | Private Member Functions | Private Attributes | Static Private Attributes
MuonIsolationDQM Class Reference

#include <MuonIsolationDQM.h>

Inheritance diagram for MuonIsolationDQM:
edm::EDAnalyzer edm::EDConsumerBase

Public Member Functions

 MuonIsolationDQM (const edm::ParameterSet &)
 
 ~MuonIsolationDQM ()
 
- Public Member Functions inherited from edm::EDAnalyzer
void callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
 
 EDAnalyzer ()
 
ModuleDescription const & moduleDescription () const
 
std::string workerType () const
 
virtual ~EDAnalyzer ()
 
- Public Member Functions inherited from edm::EDConsumerBase
 EDConsumerBase ()
 
ProductHolderIndexAndSkipBit indexFrom (EDGetToken, BranchType, TypeID const &) const
 
void itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const
 
void itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const
 
std::vector
< ProductHolderIndexAndSkipBit >
const & 
itemsToGetFromEvent () const
 
void labelsForToken (EDGetToken iToken, Labels &oLabels) const
 
bool registeredToConsume (ProductHolderIndex, bool, BranchType) const
 
bool registeredToConsumeMany (TypeID const &, BranchType) const
 
void updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)
 
virtual ~EDConsumerBase ()
 

Private Types

enum  { NOAXIS, XAXIS, YAXIS, ZAXIS }
 
typedef edm::Handle
< reco::IsoDepositMap
MuIsoDepHandle
 
typedef const reco::IsoDeposit MuIsoDepRef
 
typedef edm::RefToBase
< reco::Muon
MuonBaseRef
 
typedef edm::View< reco::Muon >
::const_iterator 
MuonIterator
 

Private Member Functions

virtual void analyze (const edm::Event &, const edm::EventSetup &)
 
virtual void beginJob (void)
 
virtual void beginRun (void)
 
virtual void endJob ()
 
void FillHistos (int)
 
void FillNVtxHistos (int)
 
int GetNVtxBin (int)
 
TH1 * GetTH1FromMonitorElement (MonitorElement *me)
 
void InitHistos ()
 
void InitStatics ()
 
void NormalizeHistos ()
 
void RecordData (const reco::Muon &muon)
 

Private Attributes

std::vector< std::string > axis_titles
 
std::vector< std::string > axis_titles_NVtxs
 
DQMStoredbe
 
std::string dirName
 
std::vector< MonitorElement * > h_1D
 
std::vector< MonitorElement * > h_1D_NVTX
 
std::vector< MonitorElement * > h_2D
 
MonitorElementh_nMuons
 
std::vector< int > isContinuous
 
double L_BIN_WIDTH
 
int LOG_BINNING_ENABLED
 
double LOG_BINNING_RATIO
 
std::vector< std::string > main_titles
 
std::vector< std::string > main_titles_NVtxs
 
std::vector< std::string > names
 
std::vector< std::string > names_2D
 
std::vector< std::string > names_NVtxs
 
int nEvents
 
int nGLBMuons
 
int nSTAMuons
 
int nTRKMuons
 
int NUM_LOG_BINS
 
std::vector< std::vector
< double > > 
param
 
bool requireGLBMuon
 
bool requireSTAMuon
 
bool requireTRKMuon
 
std::string rootfilename
 
double S_BIN_WIDTH
 
double theData [NUM_VARS]
 
double theData2D [NUM_VARS_2D]
 
double theDataNVtx [NUM_VARS_NVTX]
 
edm::EDGetTokenT
< reco::MuonCollection
theMuonCollectionLabel_
 
edm::EDGetTokenT
< reco::VertexCollection
theVertexCollectionLabel_
 
std::string title_cone
 
std::string title_sam
 
std::vector< std::string > titles_2D
 

Static Private Attributes

static const int NUM_VARS = 48
 
static const int NUM_VARS_2D = 10
 
static const int NUM_VARS_NVTX = 6
 

Additional Inherited Members

- Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer ModuleType
 
- Static Public Member Functions inherited from edm::EDAnalyzer
static const std::string & baseType ()
 
static void fillDescriptions (ConfigurationDescriptions &descriptions)
 
static void prevalidate (ConfigurationDescriptions &)
 
- Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType > consumes (edm::InputTag const &tag)
 
EDGetToken consumes (const TypeToGet &id, edm::InputTag const &tag)
 
template<BranchType B>
EDGetToken consumes (TypeToGet const &id, edm::InputTag const &tag)
 
ConsumesCollector consumesCollector ()
 Use a ConsumesCollector to gather consumes information from helper functions. More...
 
template<typename ProductType , BranchType B = InEvent>
void consumesMany ()
 
void consumesMany (const TypeToGet &id)
 
template<BranchType B>
void consumesMany (const TypeToGet &id)
 
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType > mayConsume (edm::InputTag const &tag)
 
EDGetToken mayConsume (const TypeToGet &id, edm::InputTag const &tag)
 
template<BranchType B>
EDGetToken mayConsume (const TypeToGet &id, edm::InputTag const &tag)
 

Detailed Description

Definition at line 60 of file MuonIsolationDQM.h.

Member Typedef Documentation

Definition at line 64 of file MuonIsolationDQM.h.

Definition at line 65 of file MuonIsolationDQM.h.

Definition at line 63 of file MuonIsolationDQM.h.

typedef edm::View<reco::Muon>::const_iterator MuonIsolationDQM::MuonIterator
private

Definition at line 62 of file MuonIsolationDQM.h.

Member Enumeration Documentation

anonymous enum
private

Constructor & Destructor Documentation

MuonIsolationDQM::MuonIsolationDQM ( const edm::ParameterSet iConfig)
explicit

Definition at line 55 of file MuonIsolationDQM.cc.

References gather_cfg::cout, TrackerOfflineValidation_Dqm_cff::dirName, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), nEvents, cppFunctionSkipper::operator, and AlCaHLTBitMon_QueryRunRegistry::string.

55  {
56 #ifdef DEBUG
57  cout << " Initialise Constructor " << endl;
58 #endif
59  requireSTAMuon = iConfig.getUntrackedParameter<bool>("requireSTAMuon");
60  requireTRKMuon = iConfig.getUntrackedParameter<bool>("requireTRKMuon");
61  requireGLBMuon = iConfig.getUntrackedParameter<bool>("requireGLBMuon");
62  dirName = iConfig.getParameter<std::string>("directory");
63 
64  //--------Initialize tags-------
65  theMuonCollectionLabel_ = consumes<reco::MuonCollection>(iConfig.getUntrackedParameter<edm::InputTag>("Global_Muon_Label"));
66  theVertexCollectionLabel_ = consumes<reco::VertexCollection>(iConfig.getUntrackedParameter<edm::InputTag>("vertexLabel"));
67 
68  //-------Initialize Counterse----------------
69  nEvents = 0;
70  nSTAMuons = 0;
71  nTRKMuons = 0;
72  nGLBMuons = 0;
73 
74  InitStatics();
75 
76  //Set up DAQ
77  dbe = 0;
79  dbe->setCurrentFolder(dirName.c_str());
80  dbe->cd();
81 
82  //------"allocate" space for the data vectors-------
83 
84  h_1D.resize(NUM_VARS);
85  h_2D.resize(NUM_VARS_2D);
86  h_1D_NVTX.resize(NUM_VARS_NVTX);
87 
88  dbe->cd();
89 }
std::vector< MonitorElement * > h_2D
T getParameter(std::string const &) const
T getUntrackedParameter(std::string const &, T const &) const
static const int NUM_VARS_NVTX
void cd(void)
go to top directory (ie. root)
Definition: DQMStore.cc:561
std::vector< MonitorElement * > h_1D
std::vector< MonitorElement * > h_1D_NVTX
static const int NUM_VARS_2D
static const int NUM_VARS
tuple cout
Definition: gather_cfg.py:121
edm::EDGetTokenT< reco::MuonCollection > theMuonCollectionLabel_
edm::EDGetTokenT< reco::VertexCollection > theVertexCollectionLabel_
void setCurrentFolder(const std::string &fullpath)
Definition: DQMStore.cc:584
MuonIsolationDQM::~MuonIsolationDQM ( )

Definition at line 94 of file MuonIsolationDQM.cc.

References gather_cfg::cout.

94  {
95 #ifdef DEBUG
96  cout << "Calling destructor" << endl;
97 #endif
98  //Deallocate memory
99 
100 }
tuple cout
Definition: gather_cfg.py:121

Member Function Documentation

void MuonIsolationDQM::analyze ( const edm::Event iEvent,
const edm::EventSetup iSetup 
)
privatevirtual

Implements edm::EDAnalyzer.

Definition at line 522 of file MuonIsolationDQM.cc.

References gather_cfg::cout, TrackerOfflineValidation_Dqm_cff::dirName, edm::Event::getByToken(), edm::HandleBase::isValid(), metsig::muon, patZpeak::muons, nEvents, edm::Handle< T >::product(), and findQualityFiles::v.

522  {
523 
524  ++nEvents;
525  edm::LogInfo("Tutorial") << "\nInvestigating event #" << nEvents<<"\n";
526 #ifdef DEBUG
527  cout << "[MuonIsolationDQM]: analyze()"<<endl;
528 #endif
529 
530  // Get Muon Collection
532  iEvent.getByToken(theMuonCollectionLabel_,muons);
533 
534 #ifdef DEBUG
535  cout << "[MuonIsolationDQM]: Number of muons -> " << muons->size() << endl;
536 #endif
537 
538  int theMuonData = muons->size();
539  h_nMuons->Fill(theMuonData);
540 #ifdef DEBUG
541  cout << "[MuonIsolationDQM]: Vertex is Valid" << endl;
542 #endif
543 
544  //Get Vertex Information
545  int _numPV = 0;
547  iEvent.getByToken(theVertexCollectionLabel_, vertexHandle);
548 
549  if (vertexHandle.isValid()){
550  reco::VertexCollection vertex = *(vertexHandle.product());
551  for (reco::VertexCollection::const_iterator v = vertex.begin(); v!=vertex.end(); ++v){
552  if (v->isFake()) continue;
553  if (v->ndof() < 4) continue;
554  if (fabs(v->z()) > 24.0) continue;
555  ++_numPV;
556  }
557  }
558 
559 #ifdef DEBUG
560  cout << "[MuonIsolationDQM]: Vertex is Valid" << endl;
561 #endif
562  // Get Muon Collection
563 
564  //Fill historgams concerning muon isolation
565  dbe->setCurrentFolder(dirName.c_str());
566  for (reco::MuonCollection::const_iterator muon = muons->begin(); muon!=muons->end(); ++muon){
567  if (requireSTAMuon && muon->isStandAloneMuon()) {
568  ++nSTAMuons;
569  RecordData(*muon);
570  FillHistos(_numPV);
571  }
572  else if (requireTRKMuon && muon->isTrackerMuon()) {
573  ++nTRKMuons;
574  RecordData(*muon);
575  FillHistos(_numPV);
576  }
577  else if (requireGLBMuon && muon->isGlobalMuon()) {
578  ++nGLBMuons;
579  RecordData(*muon);
580  FillHistos(_numPV);
581  FillNVtxHistos(_numPV);
582  }
583  }
584  dbe->cd();
585 
586 }
MonitorElement * h_nMuons
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:434
void cd(void)
go to top directory (ie. root)
Definition: DQMStore.cc:561
std::vector< Vertex > VertexCollection
collection of Vertex objects
Definition: VertexFwd.h:9
void Fill(long long x)
void RecordData(const reco::Muon &muon)
bool isValid() const
Definition: HandleBase.h:76
T const * product() const
Definition: Handle.h:81
tuple muons
Definition: patZpeak.py:38
tuple cout
Definition: gather_cfg.py:121
edm::EDGetTokenT< reco::MuonCollection > theMuonCollectionLabel_
edm::EDGetTokenT< reco::VertexCollection > theVertexCollectionLabel_
void setCurrentFolder(const std::string &fullpath)
Definition: DQMStore.cc:584
void MuonIsolationDQM::beginJob ( void  )
privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 686 of file MuonIsolationDQM.cc.

References gather_cfg::cout, and TrackerOfflineValidation_Dqm_cff::dirName.

686  {
687  edm::LogInfo("Tutorial") << "\n#########################################\n\n"
688  << "Lets get started! "
689  << "\n\n#########################################\n";
690 #ifdef DEBUG
691  cout << "[MuonIsolationDQM]: beginJob" << endl;
692 #endif
693  dbe->setCurrentFolder(dirName.c_str());
694  InitHistos();
695  dbe->cd();
696 }
void cd(void)
go to top directory (ie. root)
Definition: DQMStore.cc:561
tuple cout
Definition: gather_cfg.py:121
void setCurrentFolder(const std::string &fullpath)
Definition: DQMStore.cc:584
void MuonIsolationDQM::beginRun ( void  )
privatevirtual

Definition at line 699 of file MuonIsolationDQM.cc.

References gather_cfg::cout.

699  {
700 #ifdef DEBUG
701  cout << "[MuonIsolationDQM]: beginRun" << endl;
702 #endif
703  // InitHistos();
704 }
tuple cout
Definition: gather_cfg.py:121
void MuonIsolationDQM::endJob ( void  )
privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 707 of file MuonIsolationDQM.cc.

References TrackerOfflineValidation_Dqm_cff::dirName, and nEvents.

707  {
708  // check if ME still there (and not killed by MEtoEDM for memory saving)
709  if( dbe ) {
710  // check existence of first histo in the list
711  if (! dbe->get(dirName+"/nMuons")) return;
712  }
713  else
714  return;
715 
716  edm::LogInfo("Tutorial") << "\n#########################################\n\n"
717  << "Total Number of Events: " << nEvents
718  << "\n\n#########################################\n"
719  << "\nInitializing Histograms...\n";
720 
721  edm::LogInfo("Tutorial") << "\nIntializing Finished. Filling...\n";
722  //NormalizeHistos();
723  edm::LogInfo("Tutorial") << "\nFilled. Saving...\n";
724  // dbe->save(rootfilename); // comment out for incorporation
725  edm::LogInfo("Tutorial") << "\nSaved. Peace, homie, I'm out.\n";
726 }
MonitorElement * get(const std::string &path) const
get ME from full pathname (e.g. &quot;my/long/dir/my_histo&quot;)
Definition: DQMStore.cc:1623
void MuonIsolationDQM::FillHistos ( int  numPV)
private

Definition at line 769 of file MuonIsolationDQM.cc.

References gather_cfg::cout.

769  {
770 #ifdef DEBUG
771  cout << "FillHistos( "<< numPV <<" )"<< endl;
772 #endif
773 
774  //----------Fill 1D histograms---------------
775  for(int var=0; var<NUM_VARS; var++){
776  h_1D[var]->Fill(theData[var]);
777  // cd_plots[var]->Fill(theData[var]);//right now, this is a regular PDF (just like h_1D)
778  }//Finish 1D
779 
780  for (int var=0; var<NUM_VARS_2D; var++){
781  h_2D[var]->Fill(numPV,theData2D[var]);
782  }
783 
784 #ifdef DEBUG
785  cout << "FillHistos( "<< numPV <<" ): DONE"<< endl;
786 #endif
787 
788 }
std::vector< MonitorElement * > h_2D
std::vector< MonitorElement * > h_1D
static const int NUM_VARS_2D
static const int NUM_VARS
tuple cout
Definition: gather_cfg.py:121
double theData[NUM_VARS]
double theData2D[NUM_VARS_2D]
void MuonIsolationDQM::FillNVtxHistos ( int  PV)
private

Definition at line 789 of file MuonIsolationDQM.cc.

789  {
790  if (PV < 15) { h_1D_NVTX[0]->Fill(theDataNVtx[0]); h_1D_NVTX[3]->Fill(theDataNVtx[3]); }
791  if (PV >= 15 && PV < 30) { h_1D_NVTX[1]->Fill(theDataNVtx[1]); h_1D_NVTX[4]->Fill(theDataNVtx[4]); }
792  if (PV >= 30) { h_1D_NVTX[2]->Fill(theDataNVtx[2]); h_1D_NVTX[5]->Fill(theDataNVtx[5]); }
793 }
std::vector< MonitorElement * > h_1D_NVTX
double theDataNVtx[NUM_VARS_NVTX]
int MuonIsolationDQM::GetNVtxBin ( int  )
private
TH1 * MuonIsolationDQM::GetTH1FromMonitorElement ( MonitorElement me)
private

Definition at line 795 of file MuonIsolationDQM.cc.

References MonitorElement::getTH1().

795  {
796  return me->getTH1();
797 }
TH1 * getTH1(void) const
void MuonIsolationDQM::InitHistos ( )
private

Definition at line 727 of file MuonIsolationDQM.cc.

References cscdqm::h::names.

727  {
728  //---initialize number of muons histogram---
729  h_nMuons = dbe->book1D("nMuons", title_sam + "Number of Muons", 20, 0., 20.);
730  h_nMuons->setAxisTitle("Number of Muons",XAXIS);
731  h_nMuons->setAxisTitle("Fraction of Events",YAXIS);
732 
733  //---Initialize 1D Histograms---
734  for(int var = 0; var < NUM_VARS; var++){
735  h_1D[var] = dbe->book1D(names[var],
736  title_sam + main_titles[var] + title_cone,
737  (int)param[var][0],
738  param[var][1],
739  param[var][2]
740  );
741  h_1D[var]->setAxisTitle(axis_titles[var],XAXIS);
742  GetTH1FromMonitorElement(h_1D[var])->Sumw2();
743  }//Finish 1D
744 
745  //----Initialize 2D Histograms
746  for (int var = 0; var<NUM_VARS_2D; var++){
747  h_2D[var] = dbe->bookProfile(names_2D[var] + "_VsPV", titles_2D[var] + " Vs PV", 50, 0.5, 50.5, 20, 0.0, 20.0);
748 
749  h_2D[var]->setAxisTitle("Number of PV", XAXIS);
750  h_2D[var]->setAxisTitle(titles_2D[var] + " (GeV)" ,YAXIS);
751  h_2D[var]->getTH1()->Sumw2();
752  }
753 
754  //-----Initialise PU-Binned histograms
755  for (int var=0; var<NUM_VARS_NVTX; var++){
756  h_1D_NVTX[var] = dbe->book1D(names_NVtxs[var], main_titles_NVtxs[var], 50, 0.0, 10.0);
757  h_1D_NVTX[var]->setAxisTitle(axis_titles_NVtxs[var],XAXIS);
758  GetTH1FromMonitorElement(h_1D_NVTX[var])->Sumw2();
759  }
760 }
std::vector< MonitorElement * > h_2D
static const int NUM_VARS_NVTX
MonitorElement * book1D(const char *name, const char *title, int nchX, double lowX, double highX)
Book 1D histogram.
Definition: DQMStore.cc:872
MonitorElement * h_nMuons
std::vector< MonitorElement * > h_1D
std::vector< std::string > main_titles
std::vector< std::string > names
std::vector< std::string > names_2D
std::vector< std::vector< double > > param
std::vector< MonitorElement * > h_1D_NVTX
static const int NUM_VARS_2D
std::string title_sam
std::vector< std::string > names_NVtxs
std::string title_cone
MonitorElement * bookProfile(const char *name, const char *title, int nchX, double lowX, double highX, int nchY, double lowY, double highY, const char *option="s")
Definition: DQMStore.cc:1186
std::vector< std::string > titles_2D
std::vector< std::string > axis_titles
std::vector< std::string > axis_titles_NVtxs
static const int NUM_VARS
void setAxisTitle(const std::string &title, int axis=1)
set x-, y- or z-axis title (axis=1, 2, 3 respectively)
std::vector< std::string > main_titles_NVtxs
TH1 * GetTH1FromMonitorElement(MonitorElement *me)
void MuonIsolationDQM::InitStatics ( )
private

Definition at line 105 of file MuonIsolationDQM.cc.

References gather_cfg::cout, and cscdqm::h::names.

105  {
106 #ifdef DEBUG
107  cout<< " InitStatistics() " << endl;
108 #endif
109  //-----------Initialize primitives-----------
110  S_BIN_WIDTH = 1.0;//in GeV
111  L_BIN_WIDTH = 2.0;//in GeV
113  NUM_LOG_BINS = 15;
114  LOG_BINNING_RATIO = 1.1;
115  //ratio by which each bin is wider than the last for log binning
116  //i.e. bin widths are (x), (r*x), (r^2*x), ..., (r^(nbins)*x)
117 
118  //-------Initialize Titles---------
119  title_sam = "";//"[Sample b-jet events] ";
120  title_cone = "";//" [in R=0.3 IsoDeposit Cone]";
121  //The above two pieces of info will be printed on the title of the whole page,
122  //not for each individual histogram
123  // title_cd = "C.D. of ";
124 
125  //-------"Allocate" memory for vectors
126  main_titles.resize(NUM_VARS);
127  axis_titles.resize(NUM_VARS);
128  names.resize(NUM_VARS);
129  param.resize(NUM_VARS, vector<double>(3) );
130  isContinuous.resize(NUM_VARS);
131 
132  titles_2D.resize(NUM_VARS_2D);
133  names_2D.resize(NUM_VARS_2D);
134 
137  names_NVtxs.resize(NUM_VARS_NVTX);
138 
139 #ifdef DEBUG
140  cout << "InitStatistics(): vectors resized " << endl;
141 #endif
142  //-----Titles of the plots-----------
143  main_titles[0 ] = "Total Tracker Momentum, #Delta R = 0.3";
144  main_titles[1 ] = "Total EM Cal Energy, #Delta R = 0.3";
145  main_titles[2 ] = "Total Had Cal Energy, #Delta R = 0.3";
146  main_titles[3 ] = "Total HO Cal Energy, #Delta R = 0.3";
147  main_titles[4 ] = "Number of Tracker Tracks, #Delta R = 0.3";
148  main_titles[5 ] = "Number of Jets around Muon, #Delta R = 0.3";
149  main_titles[6 ] = "Tracker p_{T} within veto cone, #Delta R = 0.3";
150  main_titles[7 ] = "EM E_{T} within veto cone, #Delta R = 0.3";
151  main_titles[8 ] = "Had E_{T} within veto cone, #Delta R = 0.3";
152  main_titles[9 ] = "HO E_{T} within veto cone, #Delta R = 0.3";
153  main_titles[10] = "Average Momentum per Track, #Delta R = 0.3";
154  main_titles[11] = "Weighted Energy, #Delta R = 0.3";
155 
156  main_titles[12] = "Total Tracker Momentum, #Delta R = 0.5";
157  main_titles[13] = "Total EM Cal Energy, #Delta R = 0.5";
158  main_titles[14] = "Total Had Cal Energy, #Delta R = 0.5";
159  main_titles[15] = "Total HO Cal Energy, #Delta R = 0.5";
160  main_titles[16] = "Number of Tracker Tracks, #Delta R = 0.5";
161  main_titles[17] = "Number of Jets around Muon, #Delta R = 0.5";
162  main_titles[18] = "Tracker p_{T} within veto cone, #Delta R = 0.5";
163  main_titles[19] = "EM E_{T} within veto cone, #Delta R = 0.5";
164  main_titles[20] = "Had E_{T} within veto cone, #Delta R = 0.5";
165  main_titles[21] = "HO E_{T} within veto cone, #Delta R = 0.5";
166  main_titles[22] = "Average Momentum per Track, #Delta R = 0.5";
167  main_titles[23] = "Weighted Energy, #Delta R = 0.5";
168 
169 
170  main_titles[24 ] = "Relative Detector-Based Isolation, #Delta R = 0.3";
171  main_titles[25 ] = "Relative Detector-Based Isolation, #Delta R = 0.5";
172 
173  //-----Titles of the plots-----------
174  main_titles[26 ] = "Sum PF Charged Hadron Pt, #Delta R = 0.3";
175  main_titles[27 ] = "Sum PF Neutral Hadron Pt, #Delta R = 0.3";
176  main_titles[28 ] = "Sum PF Photon Et, #Delta R = 0.3";
177  main_titles[29 ] = "Sum PF Neutral Hadron Pt (Higher Pt threshold), #Delta R = 0.3";
178  main_titles[30 ] = "Sum PF Photon Et (Higher Pt threshold), #Delta R = 0.3";
179  main_titles[31 ] = "Sum PF Charged Particles Pt not from PV (for Pu corrections), #Delta R = 0.3";
180 
181  //-----Titles of the plots-----------
182  main_titles[32 ] = "Sum PF Charged Hadron Pt, #Delta R = 0.4";
183  main_titles[33 ] = "Sum PF Neutral Hadron Pt, #Delta R = 0.4";
184  main_titles[34 ] = "Sum PF Photon Et, #Delta R = 0.4";
185  main_titles[35 ] = "Sum PF Neutral Hadron Pt (Higher Pt threshold), #Delta R = 0.4";
186  main_titles[36 ] = "Sum PF Photon Et (Higher Pt threshold), #Delta R = 0.4";
187  main_titles[37 ] = "Sum PF Charged Particles Pt not from PV (for Pu corrections), #Delta R = 0.4";
188 
189  main_titles[38 ] = "Relative PF Isolation, #Delta R = 0.3";
190  main_titles[39 ] = "Relative PF Isolation, #Delta R = 0.4";
191 
192  main_titles[40 ] = "Relative PF Isolation (Higher Pt threshold), #Delta R = 0.3";
193  main_titles[41 ] = "Relative PF Isolation (Higher Pt threshold), #Delta R = 0.4";
194 
195  main_titles[42 ] = "Sum DR Isolation Profile for Charged Hadron, #Delta R = 0.4";
196 
197  main_titles[43 ] = "Sum DR Isolation Profile for Neutral Hadron, #Delta R = 0.4";
198 
199  main_titles[44 ] = "Sum DR Isolation Profile for Photon, #Delta R = 0.4";
200 
201  main_titles[45 ] = "Mean DR Isolation Profile for Charged Hadron, #Delta R = 0.4";
202 
203  main_titles[46 ] = "Mean DR Isolation Profile for Neutral Hadron, #Delta R = 0.4";
204 
205  main_titles[47 ] = "Mean DR Isolation Profile for Photon, #Delta R = 0.4";
206 
207 
208 
209 
210 #ifdef DEBUG
211  cout << "InitStatistics(): main titles 1D DONE " << endl;
212 #endif
213  titles_2D[0] = "Total Tracker Momentum, #Delta R = 0.3";
214  titles_2D[1] = "Total EM Cal Energy, #Delta R = 0.3";
215  titles_2D[2] = "Total Had Cal Energy, #Delta R = 0.3";
216  titles_2D[3] = "Total HO Cal Energy, #Delta R = 0.3";
217  titles_2D[4] = "Sum PF Charged Hadron Pt, #Delta R = 0.4";
218  titles_2D[5] = "Sum PF Neutral Hadron Pt, #Delta R = 0.4";
219  titles_2D[6] = "Sum PF Photon Et, #Delta R = 0.4";
220  titles_2D[7] = "Sum PF Charged Pt Not from PV, #Delta R = 0.4";
221  titles_2D[8] = "Relative Detector-Based Isolation, #Delta R = 0.4";
222  titles_2D[9] = "Relative PF Isolation, #Delta R = 0.4";
223 
224 
225  main_titles_NVtxs[0] = "Sum PF Neutral Hadron Pt, #DeltaR = 0.4 ( 0 < N_{Vtx} < 15)";
226  main_titles_NVtxs[1] = "Sum PF Neutral Hadron Pt, #DeltaR = 0.4 (15 < N_{Vtx} < 30)";
227  main_titles_NVtxs[2] = "Sum PF Neutral Hadron Pt, #DeltaR = 0.4 (30 < N_{Vtx})";
228  main_titles_NVtxs[3] = "Sum PF Photon Et, #DeltaR = 0.4 ( 0 < N_{Vtx} < 15)";
229  main_titles_NVtxs[4] = "Sum PF Photon Et, #DeltaR = 0.4 (15 < N_{Vtx} < 30)";
230  main_titles_NVtxs[5] = "Sum PF Photon Et, #DeltaR = 0.4 (30 < N_{Vtx})";
231 
232 
233 #ifdef DEBUG
234  cout << "InitStatistics(): main titles 2D DONE " << endl;
235 #endif
236 
237  //------Titles on the X or Y axis------------
238  axis_titles[0 ] = "#Sigma p_{T} (GeV)";
239  axis_titles[1 ] = "#Sigma E_{T}^{EM} (GeV)";
240  axis_titles[2 ] = "#Sigma E_{T}^{Had} (GeV)";
241  axis_titles[3 ] = "#Sigma E_{T}^{HO} (GeV)";
242  axis_titles[4 ] = "N_{Tracks}";
243  axis_titles[5 ] = "N_{Jets}";
244  axis_titles[6 ] = "#Sigma p_{T,veto} (GeV)";
245  axis_titles[7 ] = "#Sigma E_{T,veto}^{EM} (GeV)";
246  axis_titles[8 ] = "#Sigma E_{T,veto}^{Had} (GeV)";
247  axis_titles[9 ] = "#Sigma E_{T,veto}^{HO} (GeV)";
248  axis_titles[10] = "#Sigma p_{T} / N_{Tracks} (GeV)";
249  axis_titles[11] = "(1.5) X #Sigma E_{T}^{EM} + #Sigma E_{T}^{Had}";
250 
251  axis_titles[12] = "#Sigma p_{T} (GeV)";
252  axis_titles[13] = "#Sigma E_{T}^{EM} (GeV)";
253  axis_titles[14] = "#Sigma E_{T}^{Had} (GeV)";
254  axis_titles[15] = "#Sigma E_{T}^{HO} (GeV)";
255  axis_titles[16] = "N_{Tracks}";
256  axis_titles[17] = "N_{Jets}";
257  axis_titles[18] = "#Sigma p_{T,veto} (GeV)";
258  axis_titles[19] = "#Sigma E_{T,veto}^{EM} (GeV)";
259  axis_titles[20] = "#Sigma E_{T,veto}^{Had} (GeV)";
260  axis_titles[21] = "#Sigma E_{T,veto}^{HO} (GeV)";
261  axis_titles[22] = "#Sigma p_{T} / N_{Tracks} (GeV)";
262  axis_titles[23] = "(1.5) X #Sigma E_{T}^{EM} + #Sigma E_{T}^{Had}";
263 
264  axis_titles[24] = "(#Sigma Tk p_{T} + #Sigma ECAL p_{T} + #Sigma HCAL p_{T})/ Mu p_{T} (GeV)";
265  axis_titles[25] = "(#Sigma Tk p_{T} + #Sigma ECAL p_{T} + #Sigma HCAL p_{T})/ Mu p_{T} (GeV)";
266 
267  axis_titles[26] = "#Sigma PFCharged p_{T}";
268  axis_titles[27] = "#Sigma PFNeutral p_{T}";
269  axis_titles[28] = "#Sigma PFPhoton p_{T}";
270  axis_titles[29] = "#Sigma PFNeutral p_{T}";
271  axis_titles[30] = "#Sigma PFPhoton p_{T}";
272  axis_titles[31] = "#Sigma PFCharged p_{T}";
273 
274  axis_titles[32] = "#Sigma PFCharged p_{T}";
275  axis_titles[33] = "#Sigma PFNeutral p_{T}";
276  axis_titles[34] = "#Sigma PFPhoton p_{T}";
277  axis_titles[35] = "#Sigma PFNeutral p_{T}";
278  axis_titles[36] = "#Sigma PFPhoton p_{T}";
279  axis_titles[37] = "#Sigma PFCharged p_{T}";
280 
281  axis_titles[38] = "(#Sigma PFCharged p_{T} + #Sigma PFNeutral p_{T} + #Sigma PFPhoton p_{T}) Mu p_{T} (GeV)";
282  axis_titles[39] = "(#Sigma PFCharged p_{T} + #Sigma PFNeutral p_{T} + #Sigma PFPhoton p_{T}) Mu p_{T} (GeV)";
283  axis_titles[40] = "(#Sigma PFCharged p_{T} + #Sigma PFNeutral p_{T} + #Sigma PFPhoton p_{T}) Mu p_{T} (GeV)";
284  axis_titles[41] = "(#Sigma PFCharged p_{T} + #Sigma PFNeutral p_{T} + #Sigma PFPhoton p_{T}) Mu p_{T} (GeV)";
285 
286  axis_titles[42] = "#Sigma DR PFCharged";
287  axis_titles[43] = "#Sigma DR PFNeutral";
288  axis_titles[44] = "#Sigma DR PFPhoton";
289 
290  axis_titles[45] = "Mean DR PFCharged";
291  axis_titles[46] = "Mean DR PFNeutral";
292  axis_titles[47] = "Mean DR PFPhoton";
293 
294 
295 
296 
297  axis_titles_NVtxs[0] = "#Sigma PFNeutral p_{T}";
298  axis_titles_NVtxs[1] = "#Sigma PFNeutral p_{T}";
299  axis_titles_NVtxs[2] = "#Sigma PFNeutral p_{T}";
300  axis_titles_NVtxs[3] = "#Sigma PFPhoton p_{T}";
301  axis_titles_NVtxs[4] = "#Sigma PFPhoton p_{T}";
302  axis_titles_NVtxs[5] = "#Sigma PFPhoton p_{T}";
303 
304 #ifdef DEBUG
305  cout << "InitStatistics(): main titles 1D DONE " << endl;
306 #endif
307 
308  //-----------Names given for the root file----------
309  names[0 ] = "sumPt_R03";
310  names[1 ] = "emEt_R03";
311  names[2 ] = "hadEt_R03";
312  names[3 ] = "hoEt_R03";
313  names[4 ] = "nTracks_R03";
314  names[5 ] = "nJets_R03";
315  names[6 ] = "trackerVetoPt_R03";
316  names[7 ] = "emVetoEt_R03";
317  names[8 ] = "hadVetoEt_R03";
318  names[9 ] = "hoVetoEt_R03";
319  names[10] = "avgPt_R03";
320  names[11] = "weightedEt_R03";
321 
322  names[12] = "sumPt_R05";
323  names[13] = "emEt_R05";
324  names[14] = "hadEt_R05";
325  names[15] = "hoEt_R05";
326  names[16] = "nTracks_R05";
327  names[17] = "nJets_R05";
328  names[18] = "trackerVetoPt_R05";
329  names[19] = "emVetoEt_R05";
330  names[20] = "hadVetoEt_R05";
331  names[21] = "hoVetoEt_R05";
332  names[22] = "avgPt_R05";
333  names[23] = "weightedEt_R05";
334 
335  names[24] = "relDetIso_R03";
336  names[25] = "relDetIso_R05";
337 
338  names[26] = "pfChargedPt_R03";
339  names[27] = "pfNeutralPt_R03";
340  names[28] = "pfPhotonPt_R03";
341  names[29] = "pfNeutralPt_HT_R03";
342  names[30] = "pfPhotonPt_HT_R03";
343  names[31] = "pfChargedPt_PU_R03";
344 
345  names[32] = "pfChargedPt_R04";
346  names[33] = "pfNeutralPt_R04";
347  names[34] = "pfPhotonPt_R04";
348  names[35] = "pfNeutralPt_HT_R04";
349  names[36] = "pfPhotonPt_HT_R04";
350  names[37] = "pfChargedPt_PU_R04";
351 
352  names[38] = "relPFIso_R03";
353  names[39] = "relPFIso_R04";
354 
355  names[40] = "relPFIso_HT_R03";
356  names[41] = "relPFIso_HT_R04";
357 
358  names[42] = "SumDR_PFCharged_R04";
359  names[43] = "SumDR_PFNeutral_R04";
360  names[44] = "SumDR_PFPhoton_R04";
361 
362  names[45] = "MeanDR_PFCharged_R04";
363  names[46] = "MeanDR_PFNeutral_R04";
364  names[47] = "MeanDR_PFPhoton_R04";
365 
366 
367 
368 #ifdef DEBUG
369  cout << "InitStatistics(): names 1D DONE " << endl;
370 #endif
371 
372  names_2D[0] = "SumPt_R03" ;
373  names_2D[1] = "emEt_R03" ;
374  names_2D[2] = "hadEt_R03" ;
375  names_2D[3] = "hoEt_R03" ;
376  names_2D[4] = "pfChargedPt_R04" ;
377  names_2D[5] = "pfNeutralPt_R04" ;
378  names_2D[6] = "pfPhotonPt_R04" ;
379  names_2D[7] = "pfChargedPUPt_R04" ;
380  names_2D[8] = "relDetIso_R03" ;
381  names_2D[9] = "relPFIso_R04" ;
382 
383 #ifdef DEBUG
384  cout << "InitStatistics(): names 2D DONE " << endl;
385 #endif
386 
387  names_NVtxs[0] = "pfNeutralPt_R04_PV0to15";
388  names_NVtxs[1] = "pfNeutralPt_R04_PV15to30";
389  names_NVtxs[2] = "pfNeutralPt_R04_PV30toInf";
390  names_NVtxs[3] = "pfPhotonPt_R04_PV0to15";
391  names_NVtxs[4] = "pfPhotonPt_R04_PV15to30";
392  names_NVtxs[5] = "pfPhotonPt_R04_PV30toInf";
393 
394  //----------Parameters for binning of histograms---------
395  //param[var][0] is the number of bins
396  //param[var][1] is the low edge of the low bin
397  //param[var][2] is the high edge of the high bin
398  //
399  // maximum value------,
400  // |
401  // V
402  param[0 ][0]= (int)( 20.0/S_BIN_WIDTH); param[0 ][1]= 0.0; param[0 ][2]= param[0 ][0]*S_BIN_WIDTH;
403  param[1 ][0]= (int)( 20.0/S_BIN_WIDTH); param[1 ][1]= 0.0; param[1 ][2]= param[1 ][0]*S_BIN_WIDTH;
404  param[2 ][0]= (int)( 20.0/S_BIN_WIDTH); param[2 ][1]= 0.0; param[2 ][2]= param[2 ][0]*S_BIN_WIDTH;
405  param[3 ][0]= 20; param[3 ][1]= 0.0; param[3 ][2]= 2.0;
406  param[4 ][0]= 16; param[4 ][1]= -0.5; param[4 ][2]= param[4 ][0]-0.5;
407  param[5 ][0]= 4; param[5 ][1]= -0.5; param[5 ][2]= param[5 ][0]-0.5;
408  param[6 ][0]= (int)( 40.0/S_BIN_WIDTH); param[6 ][1]= 0.0; param[6 ][2]= param[6 ][0]*S_BIN_WIDTH;
409  param[7 ][0]= 20; param[7 ][1]= 0.0; param[7 ][2]= 10.0;
410  param[8 ][0]= (int)( 20.0/S_BIN_WIDTH); param[8 ][1]= 0.0; param[8 ][2]= param[8 ][0]*S_BIN_WIDTH;
411  param[9 ][0]= 20; param[9 ][1]= 0.0; param[9 ][2]= 5.0;
412  param[10][0]= (int)( 15.0/S_BIN_WIDTH); param[10][1]= 0.0; param[10][2]= param[10][0]*S_BIN_WIDTH;
413  param[11][0]= (int)( 20.0/S_BIN_WIDTH); param[11][1]= 0.0; param[11][2]= param[11][0]*S_BIN_WIDTH;
414 
415  param[12][0]= (int)( 20.0/S_BIN_WIDTH); param[12][1]= 0.0; param[12][2]= param[12][0]*S_BIN_WIDTH;
416  param[13][0]= (int)( 20.0/S_BIN_WIDTH); param[13][1]= 0.0; param[13][2]= param[13][0]*S_BIN_WIDTH;
417  param[14][0]= (int)( 20.0/S_BIN_WIDTH); param[14][1]= 0.0; param[14][2]= param[14][0]*S_BIN_WIDTH;
418  param[15][0]= 20; param[15][1]= 0.0; param[15][2]= 2.0;
419  param[16][0]= 16; param[16][1]= -0.5; param[16][2]= param[16][0]-0.5;
420  param[17][0]= 4; param[17][1]= -0.5; param[17][2]= param[17][0]-0.5;
421  param[18][0]= (int)( 40.0/S_BIN_WIDTH); param[18][1]= 0.0; param[18][2]= param[18][0]*S_BIN_WIDTH;
422  param[19][0]= 20; param[19][1]= 0.0; param[19][2]= 10.0;
423  param[20][0]= (int)( 20.0/S_BIN_WIDTH); param[20][1]= 0.0; param[20][2]= param[20][0]*S_BIN_WIDTH;
424  param[21][0]= 20; param[21][1]= 0.0; param[21][2]= 5.0;
425  param[22][0]= (int)( 15.0/S_BIN_WIDTH); param[22][1]= 0.0; param[22][2]= param[22][0]*S_BIN_WIDTH;
426  param[23][0]= (int)( 20.0/S_BIN_WIDTH); param[23][1]= 0.0; param[23][2]= param[23][0]*S_BIN_WIDTH;
427 
428  param[24][0]= 50; param[24][1]= 0.0; param[24][2]= 1.0;
429  param[25][0]= 50; param[25][1]= 0.0; param[25][2]= 1.0;
430 
431 
432  param[26 ][0]= (int)( 20.0/S_BIN_WIDTH); param[26 ][1]= 0.0; param[26 ][2]= param[26 ][0]*S_BIN_WIDTH;
433  param[27 ][0]= (int)( 20.0/S_BIN_WIDTH); param[27 ][1]= 0.0; param[27 ][2]= param[27 ][0]*S_BIN_WIDTH;
434  param[28 ][0]= (int)( 20.0/S_BIN_WIDTH); param[28 ][1]= 0.0; param[28 ][2]= param[28 ][0]*S_BIN_WIDTH;
435  param[29 ][0]= (int)( 20.0/S_BIN_WIDTH); param[29 ][1]= 0.0; param[29 ][2]= param[29 ][0]*S_BIN_WIDTH;
436  param[30 ][0]= (int)( 20.0/S_BIN_WIDTH); param[30 ][1]= 0.0; param[30 ][2]= param[30 ][0]*S_BIN_WIDTH;
437  param[31 ][0]= (int)( 20.0/S_BIN_WIDTH); param[31 ][1]= 0.0; param[31 ][2]= param[31 ][0]*S_BIN_WIDTH;
438 
439  param[32 ][0]= (int)( 20.0/S_BIN_WIDTH); param[32 ][1]= 0.0; param[32 ][2]= param[32 ][0]*S_BIN_WIDTH;
440  param[33 ][0]= (int)( 20.0/S_BIN_WIDTH); param[33 ][1]= 0.0; param[33 ][2]= param[33 ][0]*S_BIN_WIDTH;
441  param[34 ][0]= (int)( 20.0/S_BIN_WIDTH); param[34 ][1]= 0.0; param[34 ][2]= param[34 ][0]*S_BIN_WIDTH;
442  param[35 ][0]= (int)( 20.0/S_BIN_WIDTH); param[35 ][1]= 0.0; param[35 ][2]= param[35 ][0]*S_BIN_WIDTH;
443  param[36 ][0]= (int)( 20.0/S_BIN_WIDTH); param[36 ][1]= 0.0; param[36 ][2]= param[36 ][0]*S_BIN_WIDTH;
444  param[37 ][0]= (int)( 20.0/S_BIN_WIDTH); param[37 ][1]= 0.0; param[37 ][2]= param[37 ][0]*S_BIN_WIDTH;
445 
446  param[38][0]= 50; param[38][1]= 0.0; param[38][2]= 1.0;
447  param[39][0]= 50; param[39][1]= 0.0; param[39][2]= 1.0;
448 
449  param[40][0]= 50; param[40][1]= 0.0; param[40][2]= 1.0;
450  param[41][0]= 50; param[41][1]= 0.0; param[41][2]= 1.0;
451 
452  param[42][0]= 50; param[42][1]= 0.0; param[42][2]= 5;
453  param[43][0]= 50; param[43][1]= 0.0; param[43][2]= 5;
454  param[44][0]= 50; param[44][1]= 0.0; param[44][2]= 5;
455 
456  param[45][0]= 50; param[45][1]= 0.0; param[45][2]= 0.4;
457  param[46][0]= 50; param[46][1]= 0.0; param[46][2]= 0.4;
458  param[47][0]= 50; param[47][1]= 0.0; param[47][2]= 0.4;
459 
460 
461  //--------------Is the variable continuous (i.e. non-integer)?-------------
462  //---------(Log binning will only be used for continuous variables)--------
463  isContinuous[0 ] = 1;
464  isContinuous[1 ] = 1;
465  isContinuous[2 ] = 1;
466  isContinuous[3 ] = 1;
467  isContinuous[4 ] = 0;
468  isContinuous[5 ] = 0;
469  isContinuous[6 ] = 1;
470  isContinuous[7 ] = 1;
471  isContinuous[8 ] = 1;
472  isContinuous[9 ] = 1;
473  isContinuous[10] = 1;
474  isContinuous[11] = 1;
475 
476  isContinuous[12] = 1;
477  isContinuous[13] = 1;
478  isContinuous[14] = 1;
479  isContinuous[15] = 1;
480  isContinuous[16] = 0;
481  isContinuous[17] = 0;
482  isContinuous[18] = 1;
483  isContinuous[19] = 1;
484  isContinuous[20] = 1;
485  isContinuous[21] = 1;
486  isContinuous[22] = 1;
487  isContinuous[23] = 1;
488 
489  isContinuous[24] = 1;
490  isContinuous[25] = 1;
491  isContinuous[26] = 1;
492  isContinuous[27] = 1;
493  isContinuous[28] = 1;
494  isContinuous[29] = 1;
495  isContinuous[30] = 1;
496  isContinuous[31] = 1;
497  isContinuous[32] = 1;
498  isContinuous[33] = 1;
499  isContinuous[34] = 1;
500  isContinuous[35] = 1;
501  isContinuous[36] = 1;
502  isContinuous[37] = 1;
503  isContinuous[38] = 1;
504  isContinuous[39] = 1;
505  isContinuous[40] = 1;
506  isContinuous[41] = 1;
507  isContinuous[42] = 1;
508  isContinuous[43] = 1;
509  isContinuous[44] = 1;
510  isContinuous[45] = 1;
511  isContinuous[46] = 1;
512  isContinuous[47] = 1;
513 
514 
515 #ifdef DEBUG
516  cout << "InitStatistics(): DONE " << endl;
517 #endif
518 }
static const int NUM_VARS_NVTX
std::vector< std::string > main_titles
std::vector< std::string > names
std::vector< std::string > names_2D
std::vector< std::vector< double > > param
static const int NUM_VARS_2D
std::string title_sam
std::vector< std::string > names_NVtxs
std::string title_cone
std::vector< int > isContinuous
std::vector< std::string > titles_2D
std::vector< std::string > axis_titles
std::vector< std::string > axis_titles_NVtxs
static const int NUM_VARS
tuple cout
Definition: gather_cfg.py:121
std::vector< std::string > main_titles_NVtxs
void MuonIsolationDQM::NormalizeHistos ( )
private

Definition at line 762 of file MuonIsolationDQM.cc.

References python.tagInventory::entries.

762  {
763  for(int var=0; var<NUM_VARS; var++){
764  double entries = GetTH1FromMonitorElement(h_1D[var])->GetEntries();
765  GetTH1FromMonitorElement(h_1D[var])->Scale(1./entries);
766  }
767 }
std::vector< MonitorElement * > h_1D
static const int NUM_VARS
TH1 * GetTH1FromMonitorElement(MonitorElement *me)
void MuonIsolationDQM::RecordData ( const reco::Muon muon)
private

Definition at line 589 of file MuonIsolationDQM.cc.

References gather_cfg::cout, reco::MuonIsolation::emEt, reco::MuonIsolation::emVetoEt, reco::MuonIsolation::hadEt, reco::MuonIsolation::hadVetoEt, reco::MuonIsolation::hoEt, reco::MuonIsolation::hoVetoEt, reco::Muon::isolationR03(), reco::Muon::isolationR05(), reco::MuonIsolation::nJets, reco::MuonIsolation::nTracks, reco::Muon::pfIsolationR03(), reco::Muon::pfIsolationR04(), reco::Muon::pfMeanDRIsoProfileR04(), reco::Muon::pfSumDRIsoProfileR04(), reco::LeafCandidate::pt(), reco::MuonPFIsolation::sumChargedHadronPt, reco::MuonPFIsolation::sumNeutralHadronEt, reco::MuonPFIsolation::sumNeutralHadronEtHighThreshold, reco::MuonPFIsolation::sumPhotonEt, reco::MuonPFIsolation::sumPhotonEtHighThreshold, reco::MuonIsolation::sumPt, reco::MuonPFIsolation::sumPUPt, and reco::MuonIsolation::trackerVetoPt.

589  {
590 #ifdef DEBUG
591  std::cout << "RecordData()" << endl;
592 #endif
593  float MuPt = muon.pt();
594 
595  theData[0] = muon.isolationR03().sumPt;
596  theData[1] = muon.isolationR03().emEt;
597  theData[2] = muon.isolationR03().hadEt;
598  theData[3] = muon.isolationR03().hoEt;
599 
600  theData[4] = muon.isolationR03().nTracks;
601  theData[5] = muon.isolationR03().nJets;
602  theData[6] = muon.isolationR03().trackerVetoPt;
603  theData[7] = muon.isolationR03().emVetoEt;
604  theData[8] = muon.isolationR03().hadVetoEt;
605  theData[9] = muon.isolationR03().hoVetoEt;
606 
607  // make sure nTracks != 0 before filling this one
608  if (theData[4] != 0) theData[10] = (double)theData[0] / (double)theData[4];
609  else theData[10] = -99;
610 
611  theData[11] = 1.5 * theData[1] + theData[2];
612 
613  theData[12] = muon.isolationR05().sumPt;
614  theData[13] = muon.isolationR05().emEt;
615  theData[14] = muon.isolationR05().hadEt;
616  theData[15] = muon.isolationR05().hoEt;
617 
618  theData[16] = muon.isolationR05().nTracks;
619  theData[17] = muon.isolationR05().nJets;
620  theData[18] = muon.isolationR05().trackerVetoPt;
621  theData[19] = muon.isolationR05().emVetoEt;
622  theData[20] = muon.isolationR05().hadVetoEt;
623  theData[21] = muon.isolationR05().hoVetoEt;
624 
625  // make sure nTracks != 0 before filling this one
626  if (theData[16] != 0) theData[22] = (double)theData[12] / (double)theData[16];
627  else theData[22] = -99;
628 
629  theData[23] = 1.5 * theData[13] + theData[14];
630 
631  theData[24] = (theData[0]+theData[1]+theData[2]) / MuPt;
632  theData[25] = (theData[12]+theData[13]+theData[14]) / MuPt;
633 
634  theData[26] = muon.pfIsolationR03().sumChargedHadronPt;
635  theData[27] = muon.pfIsolationR03().sumNeutralHadronEt;
636  theData[28] = muon.pfIsolationR03().sumPhotonEt;
637  theData[29] = muon.pfIsolationR03().sumNeutralHadronEtHighThreshold;
638  theData[30] = muon.pfIsolationR03().sumPhotonEtHighThreshold;
639  theData[31] = muon.pfIsolationR03().sumPUPt;
640 
641  theData[32] = muon.pfIsolationR04().sumChargedHadronPt;
642  theData[33] = muon.pfIsolationR04().sumNeutralHadronEt;
643  theData[34] = muon.pfIsolationR04().sumPhotonEt;
644  theData[35] = muon.pfIsolationR04().sumNeutralHadronEtHighThreshold;
645  theData[36] = muon.pfIsolationR04().sumPhotonEtHighThreshold;
646  theData[37] = muon.pfIsolationR04().sumPUPt;
647 
648  theData[38] = (theData[26] + theData[27] + theData[28]) / MuPt;
649  theData[39] = (theData[32] + theData[33] + theData[34]) / MuPt;
650 
651  theData[40] = (theData[26] + theData[29] + theData[30]) / MuPt;
652  theData[41] = (theData[32] + theData[35] + theData[36]) / MuPt;
653 
654  theData[42] = muon.pfSumDRIsoProfileR04().sumChargedHadronPt;
655  theData[43] = muon.pfSumDRIsoProfileR04().sumNeutralHadronEt;
656  theData[44] = muon.pfSumDRIsoProfileR04().sumPhotonEt;
657  theData[45] = muon.pfMeanDRIsoProfileR04().sumChargedHadronPt;
658  theData[46] = muon.pfMeanDRIsoProfileR04().sumNeutralHadronEt;
659  theData[47] = muon.pfMeanDRIsoProfileR04().sumPhotonEt;
660 
661  //--------------Filling the 2D Histos Data -------- //
662  theData2D[0] = muon.isolationR03().sumPt;
663  theData2D[1] = muon.isolationR03().emEt;
664  theData2D[2] = muon.isolationR03().hadEt;
665  theData2D[3] = muon.isolationR03().hoEt;
666 
670  theData2D[7] = muon.pfIsolationR04().sumPUPt;
671 
672  theData2D[8] = theData2D[0] + theData2D[1] + theData2D[2] + theData2D[3] / MuPt; //Det RelIso;
673  theData2D[9] = theData2D[4] + theData2D[5] + theData2D[6] / MuPt; //PF RelIso;
674 
675  //-----------Filling the NVTX 1D HISTOS DATA ------------- //
677  theDataNVtx[1] = theDataNVtx[0];
678  theDataNVtx[2] = theDataNVtx[0];
679 
681  theDataNVtx[4] = theDataNVtx[3];
682  theDataNVtx[5] = theDataNVtx[3];
683 }
float hadEt
hcal sum-Et
Definition: MuonIsolation.h:9
float sumPt
sum-pt of tracks
Definition: MuonIsolation.h:7
float sumNeutralHadronEtHighThreshold
sum pt of neutral hadrons with a higher threshold
const MuonPFIsolation & pfSumDRIsoProfileR04() const
Definition: Muon.h:166
const MuonPFIsolation & pfMeanDRIsoProfileR04() const
Definition: Muon.h:165
float hadVetoEt
hcal sum-et in the veto region in r-phi
Definition: MuonIsolation.h:15
float sumPhotonEt
sum pt of PF photons
const MuonIsolation & isolationR05() const
Definition: Muon.h:159
float sumNeutralHadronEt
sum pt of neutral hadrons
float sumPUPt
sum pt of charged Particles not from PV (for Pu corrections)
const MuonPFIsolation & pfIsolationR03() const
Definition: Muon.h:161
float emEt
ecal sum-Et
Definition: MuonIsolation.h:8
int nJets
number of jets in the cone
Definition: MuonIsolation.h:12
float hoEt
ho sum-Et
Definition: MuonIsolation.h:10
float hoVetoEt
ho sum-et in the veto region in r-phi
Definition: MuonIsolation.h:16
int nTracks
number of tracks in the cone (excluding veto region)
Definition: MuonIsolation.h:11
float emVetoEt
ecal sum-et in the veto region in r-phi
Definition: MuonIsolation.h:14
const MuonPFIsolation & pfIsolationR04() const
Definition: Muon.h:164
double theDataNVtx[NUM_VARS_NVTX]
tuple cout
Definition: gather_cfg.py:121
float sumPhotonEtHighThreshold
sum pt of PF photons with a higher threshold
double theData[NUM_VARS]
virtual float pt() const GCC11_FINAL
transverse momentum
double theData2D[NUM_VARS_2D]
float trackerVetoPt
(sum-)pt inside the veto region in r-phi
Definition: MuonIsolation.h:13
const MuonIsolation & isolationR03() const
Definition: Muon.h:158
float sumChargedHadronPt
sum-pt of charged Hadron

Member Data Documentation

std::vector<std::string> MuonIsolationDQM::axis_titles
private

Definition at line 121 of file MuonIsolationDQM.h.

std::vector<std::string> MuonIsolationDQM::axis_titles_NVtxs
private

Definition at line 131 of file MuonIsolationDQM.h.

DQMStore* MuonIsolationDQM::dbe
private

Definition at line 135 of file MuonIsolationDQM.h.

std::string MuonIsolationDQM::dirName
private

Definition at line 100 of file MuonIsolationDQM.h.

Referenced by addOnTests.testit::run().

std::vector<MonitorElement*> MuonIsolationDQM::h_1D
private

Definition at line 144 of file MuonIsolationDQM.h.

std::vector<MonitorElement*> MuonIsolationDQM::h_1D_NVTX
private

Definition at line 146 of file MuonIsolationDQM.h.

std::vector<MonitorElement*> MuonIsolationDQM::h_2D
private

Definition at line 145 of file MuonIsolationDQM.h.

MonitorElement* MuonIsolationDQM::h_nMuons
private

Definition at line 143 of file MuonIsolationDQM.h.

std::vector<int> MuonIsolationDQM::isContinuous
private

Definition at line 124 of file MuonIsolationDQM.h.

double MuonIsolationDQM::L_BIN_WIDTH
private

Definition at line 107 of file MuonIsolationDQM.h.

int MuonIsolationDQM::LOG_BINNING_ENABLED
private

Definition at line 109 of file MuonIsolationDQM.h.

double MuonIsolationDQM::LOG_BINNING_RATIO
private

Definition at line 111 of file MuonIsolationDQM.h.

std::vector<std::string> MuonIsolationDQM::main_titles
private

Definition at line 120 of file MuonIsolationDQM.h.

std::vector<std::string> MuonIsolationDQM::main_titles_NVtxs
private

Definition at line 129 of file MuonIsolationDQM.h.

std::vector<std::string> MuonIsolationDQM::names
private

Definition at line 122 of file MuonIsolationDQM.h.

std::vector<std::string> MuonIsolationDQM::names_2D
private

Definition at line 127 of file MuonIsolationDQM.h.

std::vector<std::string> MuonIsolationDQM::names_NVtxs
private

Definition at line 130 of file MuonIsolationDQM.h.

int MuonIsolationDQM::nEvents
private

Definition at line 151 of file MuonIsolationDQM.h.

int MuonIsolationDQM::nGLBMuons
private

Definition at line 153 of file MuonIsolationDQM.h.

int MuonIsolationDQM::nSTAMuons
private

Definition at line 152 of file MuonIsolationDQM.h.

int MuonIsolationDQM::nTRKMuons
private

Definition at line 154 of file MuonIsolationDQM.h.

int MuonIsolationDQM::NUM_LOG_BINS
private

Definition at line 110 of file MuonIsolationDQM.h.

const int MuonIsolationDQM::NUM_VARS = 48
staticprivate

Definition at line 103 of file MuonIsolationDQM.h.

const int MuonIsolationDQM::NUM_VARS_2D = 10
staticprivate

Definition at line 104 of file MuonIsolationDQM.h.

const int MuonIsolationDQM::NUM_VARS_NVTX = 6
staticprivate

Definition at line 105 of file MuonIsolationDQM.h.

std::vector< std::vector<double> > MuonIsolationDQM::param
private

Definition at line 123 of file MuonIsolationDQM.h.

bool MuonIsolationDQM::requireGLBMuon
private

Definition at line 112 of file MuonIsolationDQM.h.

bool MuonIsolationDQM::requireSTAMuon
private

Definition at line 113 of file MuonIsolationDQM.h.

bool MuonIsolationDQM::requireTRKMuon
private

Definition at line 114 of file MuonIsolationDQM.h.

std::string MuonIsolationDQM::rootfilename
private

Definition at line 98 of file MuonIsolationDQM.h.

double MuonIsolationDQM::S_BIN_WIDTH
private

Definition at line 108 of file MuonIsolationDQM.h.

double MuonIsolationDQM::theData[NUM_VARS]
private

Definition at line 138 of file MuonIsolationDQM.h.

double MuonIsolationDQM::theData2D[NUM_VARS_2D]
private

Definition at line 139 of file MuonIsolationDQM.h.

double MuonIsolationDQM::theDataNVtx[NUM_VARS_NVTX]
private

Definition at line 140 of file MuonIsolationDQM.h.

edm::EDGetTokenT<reco::MuonCollection> MuonIsolationDQM::theMuonCollectionLabel_
private

Definition at line 95 of file MuonIsolationDQM.h.

edm::EDGetTokenT<reco::VertexCollection> MuonIsolationDQM::theVertexCollectionLabel_
private

Definition at line 94 of file MuonIsolationDQM.h.

std::string MuonIsolationDQM::title_cone
private

Definition at line 117 of file MuonIsolationDQM.h.

std::string MuonIsolationDQM::title_sam
private

Definition at line 116 of file MuonIsolationDQM.h.

std::vector<std::string> MuonIsolationDQM::titles_2D
private

Definition at line 126 of file MuonIsolationDQM.h.