CMS 3D CMS Logo
PhotonAnalyzer.cc
Go to the documentation of this file.
1 #include <iostream>
2 #include <iomanip>
3 //
4 
5 #include "DQMOffline/EGamma/plugins/PhotonAnalyzer.h"
6 
7 
18 using namespace std;
19 
20 PhotonAnalyzer::PhotonAnalyzer( const edm::ParameterSet& pset )
21 {
22  fName_ = pset.getParameter<string>("analyzerName");
23  prescaleFactor_ = pset.getUntrackedParameter<int>("prescaleFactor",1);
24 
25  photon_token_ = consumes<vector<reco::Photon> >(pset.getParameter<edm::InputTag>("phoProducer"));
26  barrelRecHit_token_ = consumes<edm::SortedCollection<EcalRecHit,edm::StrictWeakOrdering<EcalRecHit> > >(pset.getParameter<edm::InputTag>("barrelRecHitProducer"));
27  PhotonIDLoose_token_ = consumes<edm::ValueMap<bool> >(pset.getParameter<edm::InputTag>("photonIDLoose"));
28  PhotonIDTight_token_ = consumes<edm::ValueMap<bool> >(pset.getParameter<edm::InputTag>("photonIDTight"));
29  endcapRecHit_token_ = consumes<edm::SortedCollection<EcalRecHit,edm::StrictWeakOrdering<EcalRecHit> > >(pset.getParameter<edm::InputTag>("endcapRecHitProducer"));
30  triggerEvent_token_ = consumes<trigger::TriggerEvent>(pset.getParameter<edm::InputTag>("triggerEvent"));
31  offline_pvToken_ = consumes<reco::VertexCollection>(pset.getUntrackedParameter<edm::InputTag>("offlinePV", edm::InputTag("offlinePrimaryVertices")));
32 
33  minPhoEtCut_ = pset.getParameter<double>("minPhoEtCut");
34  photonMaxEta_ = pset.getParameter<double>("maxPhoEta");
35  invMassEtCut_ = pset.getParameter<double>("invMassEtCut");
36  cutStep_ = pset.getParameter<double>("cutStep");
37  numberOfSteps_ = pset.getParameter<int>("numberOfSteps");
38  useBinning_ = pset.getParameter<bool>("useBinning");
39  useTriggerFiltering_ = pset.getParameter<bool>("useTriggerFiltering");
40  minimalSetOfHistos_ = pset.getParameter<bool>("minimalSetOfHistos");
41  excludeBkgHistos_ = pset.getParameter<bool>("excludeBkgHistos");
42  standAlone_ = pset.getParameter<bool>("standAlone");
43  isolationStrength_ = pset.getParameter<int>("isolationStrength");
44  isHeavyIon_ = pset.getUntrackedParameter<bool>("isHeavyIon",false);
45 
46  histo_index_photons_ = 0;
47  histo_index_conversions_ = 0;
48  histo_index_efficiency_ = 0;
49  histo_index_invMass_ = 0;
50 
51  nEvt_=0;
52 
53  // Determining parts...
54  parts_.push_back("AllEcal");
55  parts_.push_back("Barrel");
56  parts_.push_back("Endcaps");
57  // ...and types
58  types_.push_back("All");
59  types_.push_back("GoodCandidate");
60  if (!excludeBkgHistos_)
61  {
62  types_.push_back("Background");
63  }
64 
65  // Histogram parameters
66  etaBin_ = pset.getParameter<int>("etaBin");
67  etaMin_ = pset.getParameter<double>("etaMin");
68  etaMax_ = pset.getParameter<double>("etaMax");
69 
70  etBin_ = pset.getParameter<int>("etBin");
71  etMin_ = pset.getParameter<double>("etMin");
72  etMax_ = pset.getParameter<double>("etMax");
73 
74  phiBin_ = pset.getParameter<int>("phiBin");
75  phiMin_ = pset.getParameter<double>("phiMin");
76  phiMax_ = pset.getParameter<double>("phiMax");
77 
78  eBin_ = pset.getParameter<int>("eBin");
79  eMin_ = pset.getParameter<double>("eMin");
80  eMax_ = pset.getParameter<double>("eMax");
81 
82  numberBin_ = pset.getParameter<int>("numberBin");
83  numberMin_ = pset.getParameter<double>("numberMin");
84  numberMax_ = pset.getParameter<double>("numberMax");
85 
86  r9Bin_ = pset.getParameter<int>("r9Bin");
87  r9Min_ = pset.getParameter<double>("r9Min");
88  r9Max_ = pset.getParameter<double>("r9Max");
89 
90  sigmaIetaBin_ = pset.getParameter<int>("sigmaIetaBin");
91  sigmaIetaMin_ = pset.getParameter<double>("sigmaIetaMin");
92  sigmaIetaMax_ = pset.getParameter<double>("sigmaIetaMax");
93 
94  sumBin_ = pset.getParameter<int>("sumBin");
95  sumMin_ = pset.getParameter<double>("sumMin");
96  sumMax_ = pset.getParameter<double>("sumMax");
97 
98  hOverEBin_ = pset.getParameter<int>("hOverEBin");
99  hOverEMin_ = pset.getParameter<double>("hOverEMin");
100  hOverEMax_ = pset.getParameter<double>("hOverEMax");
101 
102  eOverPBin_ = pset.getParameter<int>("eOverPBin");
103  eOverPMin_ = pset.getParameter<double>("eOverPMin");
104  eOverPMax_ = pset.getParameter<double>("eOverPMax");
105 
106  dPhiTracksBin_ = pset.getParameter<int>("dPhiTracksBin");
107  dPhiTracksMin_ = pset.getParameter<double>("dPhiTracksMin");
108  dPhiTracksMax_ = pset.getParameter<double>("dPhiTracksMax");
109 
110  dEtaTracksBin_ = pset.getParameter<int>("dEtaTracksBin");
111  dEtaTracksMin_ = pset.getParameter<double>("dEtaTracksMin");
112  dEtaTracksMax_ = pset.getParameter<double>("dEtaTracksMax");
113 
114  chi2Bin_ = pset.getParameter<int>("chi2Bin");
115  chi2Min_ = pset.getParameter<double>("chi2Min");
116  chi2Max_ = pset.getParameter<double>("chi2Max");
117 
118  zBin_ = pset.getParameter<int>("zBin");
119  zMin_ = pset.getParameter<double>("zMin");
120  zMax_ = pset.getParameter<double>("zMax");
121 
122  rBin_ = pset.getParameter<int>("rBin");
123  rMin_ = pset.getParameter<double>("rMin");
124  rMax_ = pset.getParameter<double>("rMax");
125 
126  xBin_ = pset.getParameter<int>("xBin");
127  xMin_ = pset.getParameter<double>("xMin");
128  xMax_ = pset.getParameter<double>("xMax");
129 
130  yBin_ = pset.getParameter<int>("yBin");
131  yMin_ = pset.getParameter<double>("yMin");
132  yMax_ = pset.getParameter<double>("yMax");
133 
134  reducedEtBin_ = etBin_/4;
135  reducedEtaBin_ = etaBin_/4;
136  reducedR9Bin_ = r9Bin_/4;
137  reducedSumBin_ = sumBin_/4;
138 }
139 
140 PhotonAnalyzer::~PhotonAnalyzer()
141 {
142 }
143 
144 void PhotonAnalyzer::bookHistograms(DQMStore::IBooker & iBooker,
145  edm::Run const & /* iRun */,
146  edm::EventSetup const & /* iSetup */)
147 {
148  bookHistogramsForHistogramCounts(iBooker);
149 
150  bookHistogramsEfficiency(iBooker);
151  bookHistogramsInvMass(iBooker);
152  bookHistogramsPhotons(iBooker);
153  bookHistogramsConversions(iBooker);
154 
155  fillHistogramsForHistogramCounts(iBooker);
156 }
157 
158 void PhotonAnalyzer::bookHistogramsForHistogramCounts(DQMStore::IBooker & iBooker)
159 {
160  iBooker.setCurrentFolder("Egamma/"+fName_+"/");
161  // Int values stored in MEs to keep track of how many histograms are in each folder
162  totalNumberOfHistos_efficiencyFolder = iBooker.bookInt("numberOfHistogramsInEfficiencyFolder");
163  totalNumberOfHistos_invMassFolder = iBooker.bookInt("numberOfHistogramsInInvMassFolder");
164  totalNumberOfHistos_photonsFolder = iBooker.bookInt("numberOfHistogramsInPhotonsFolder");
165  totalNumberOfHistos_conversionsFolder = iBooker.bookInt("numberOfHistogramsInConversionsFolder");
166 }
167 
168 void PhotonAnalyzer::fillHistogramsForHistogramCounts(DQMStore::IBooker & iBooker)
169 {
170  iBooker.setCurrentFolder("Egamma/"+fName_+"/");
171  totalNumberOfHistos_efficiencyFolder->Fill(histo_index_efficiency_);
172  totalNumberOfHistos_invMassFolder->Fill(histo_index_invMass_);
173  totalNumberOfHistos_photonsFolder->Fill(histo_index_photons_);
174  totalNumberOfHistos_conversionsFolder->Fill(histo_index_conversions_);
175 }
176 
177 void PhotonAnalyzer::bookHistogramsEfficiency(DQMStore::IBooker & iBooker)
178 {
179  // Set folder
180  iBooker.setCurrentFolder("Egamma/"+fName_+"/Efficiencies");
181 
182  // Don't number these histograms with the "bookHisto" method, since they'll be erased in the offline client
183  h_phoEta_Loose_ = iBooker.book1D("phoEtaLoose", "Loose Photon #eta", etaBin_, etaMin_, etaMax_);
184  h_phoEta_Tight_ = iBooker.book1D("phoEtaTight", "Tight Photon #eta", etaBin_, etaMin_, etaMax_);
185 
186  h_phoEt_Loose_ = iBooker.book1D("phoEtLoose", "Loose Photon E_{T}", etBin_, etMin_, etMax_);
187  h_phoEt_Tight_ = iBooker.book1D("phoEtTight", "Tight Photon E_{T}", etBin_, etMin_, etMax_);
188 
189  h_phoEta_preHLT_ = iBooker.book1D("phoEtaPreHLT", "Photon #eta: before HLT", etaBin_, etaMin_, etaMax_);
190  h_phoEta_postHLT_ = iBooker.book1D("phoEtaPostHLT", "Photon #eta: after HLT", etaBin_, etaMin_, etaMax_);
191  h_phoEt_preHLT_ = iBooker.book1D("phoEtPreHLT", "Photon E_{T}: before HLT", etBin_, etMin_, etMax_);
192  h_phoEt_postHLT_ = iBooker.book1D("phoEtPostHLT", "Photon E_{T}: after HLT", etBin_, etMin_, etMax_);
193 
194  h_convEta_Loose_ = iBooker.book1D("convEtaLoose", "Converted Loose Photon #eta", etaBin_, etaMin_, etaMax_);
195  h_convEta_Tight_ = iBooker.book1D("convEtaTight", "Converted Tight Photon #eta", etaBin_, etaMin_, etaMax_);
196  h_convEt_Loose_ = iBooker.book1D("convEtLoose", "Converted Loose Photon E_{T}", etBin_, etMin_, etMax_);
197  h_convEt_Tight_ = iBooker.book1D("convEtTight", "Converted Tight Photon E_{T}", etBin_, etMin_, etMax_);
198 
199  h_phoEta_Vertex_ = iBooker.book1D("phoEtaVertex", "Converted Photons before valid vertex cut: #eta", etaBin_, etaMin_, etaMax_);
200 
201  // Some temporary vectors
202  vector<MonitorElement*> temp1DVectorEta;
203  vector<MonitorElement*> temp1DVectorPhi;
204  vector<vector<MonitorElement*> > temp2DVectorPhi;
205 
206  for(int cut = 0; cut != numberOfSteps_; ++cut){ //looping over Et cut values
207  for(uint type=0;type!=types_.size();++type){ //looping over isolation type
208  currentFolder_.str("");
209  currentFolder_ << "Egamma/"+fName_+"/" << types_[type] << "Photons/Et above " << (cut+1)*cutStep_ << " GeV/Conversions";
210  iBooker.setCurrentFolder(currentFolder_.str());
211 
212  temp1DVectorEta.push_back(iBooker.book1D("phoConvEtaForEfficiency","Converted Photon #eta;#eta",etaBin_,etaMin_,etaMax_));
213  for(uint part=0;part!=parts_.size();++part){
214  temp1DVectorPhi.push_back(iBooker.book1D("phoConvPhiForEfficiency"+parts_[part],"Converted Photon #phi;#phi",phiBin_,phiMin_,phiMax_));
215  }
216  temp2DVectorPhi.push_back(temp1DVectorPhi);
217  temp1DVectorPhi.clear();
218  }
219  h_phoConvEtaForEfficiency_.push_back(temp1DVectorEta);
220  temp1DVectorEta.clear();
221  h_phoConvPhiForEfficiency_.push_back(temp2DVectorPhi);
222  temp2DVectorPhi.clear();
223  }
224 }
225 
226 void PhotonAnalyzer::bookHistogramsInvMass(DQMStore::IBooker & iBooker)
227 {
228  // Set folder
229  iBooker.setCurrentFolder("Egamma/"+fName_+"/InvMass");
230 
231  h_invMassAllPhotons_ = bookHisto(iBooker, "invMassAllIsolatedPhotons", "Two photon invariant mass: All isolated photons;M (GeV)", etBin_, etMin_, etMax_);
232  h_invMassPhotonsEBarrel_ = bookHisto(iBooker, "invMassIsoPhotonsEBarrel", "Two photon invariant mass: isolated photons in barrel; M (GeV)", etBin_, etMin_, etMax_);
233  h_invMassPhotonsEEndcap_ = bookHisto(iBooker, "invMassIsoPhotonsEEndcap", "Two photon invariant mass: isolated photons in endcap; M (GeV)", etBin_, etMin_, etMax_);
234 
235  h_invMassZeroWithTracks_ = bookHisto(iBooker, "invMassZeroWithTracks", "Two photon invariant mass: Neither has tracks;M (GeV)", etBin_, etMin_, etMax_);
236  h_invMassOneWithTracks_ = bookHisto(iBooker, "invMassOneWithTracks", "Two photon invariant mass: Only one has tracks;M (GeV)", etBin_, etMin_, etMax_);
237  h_invMassTwoWithTracks_ = bookHisto(iBooker, "invMassTwoWithTracks", "Two photon invariant mass: Both have tracks;M (GeV)", etBin_, etMin_, etMax_);
238 
239  h_nRecoVtx_ = bookHisto(iBooker, "nOfflineVtx", "# of Offline Vertices", 80, -0.5, 79.5);
240 }
241 
242 void PhotonAnalyzer::bookHistogramsPhotons(DQMStore::IBooker & iBooker)
243 {
244  // Set folder
245  // Folder is set by the book2DHistoVector and book3DHistoVector methods
246 
247  //ENERGY VARIABLES
248  book3DHistoVector(iBooker, h_phoE_, "1D","phoE","Energy;E (GeV)",eBin_,eMin_,eMax_);
249  book3DHistoVector(iBooker, h_phoSigmaEoverE_, "1D","phoSigmaEoverE","#sigma_{E}/E; #sigma_{E}/E", 100,0.,0.08);
250  book3DHistoVector(iBooker, p_phoSigmaEoverEvsNVtx_, "Profile","phoSigmaEoverEvsNVtx","#sigma_{E}/E vs NVtx; N_{vtx}; #sigma_{E}/E",80, -0.5, 79.5, 100,0., 0.08);
251  book3DHistoVector(iBooker, h_phoEt_, "1D","phoEt","E_{T};E_{T} (GeV)", etBin_,etMin_,etMax_);
252 
253  //NUMBER OF PHOTONS
254  book3DHistoVector(iBooker, h_nPho_, "1D","nPho","Number of Photons per Event;# #gamma",numberBin_,numberMin_,numberMax_);
255 
256  //GEOMETRICAL VARIABLES
257  //photon eta/phi
258  book2DHistoVector(iBooker, h_phoEta_, "1D","phoEta","#eta;#eta",etaBin_,etaMin_,etaMax_) ;
259  book3DHistoVector(iBooker, h_phoPhi_, "1D","phoPhi","#phi;#phi",phiBin_,phiMin_,phiMax_) ;
260 
261  //supercluster eta/phi
262  book2DHistoVector(iBooker, h_scEta_, "1D","scEta","SuperCluster #eta;#eta",etaBin_,etaMin_,etaMax_) ;
263  book3DHistoVector(iBooker, h_scPhi_, "1D","scPhi","SuperCluster #phi;#phi",phiBin_,phiMin_,phiMax_) ;
264 
265  //SHOWER SHAPE VARIABLES
266  //r9
267  book3DHistoVector(iBooker, h_r9_, "1D","r9","R9;R9",r9Bin_,r9Min_, r9Max_);
268  if (standAlone_) {
269  book2DHistoVector(iBooker, h_r9VsEt_, "2D","r9VsEt2D","R9 vs E_{T};E_{T} (GeV);R9",reducedEtBin_,etMin_,etMax_,reducedR9Bin_,r9Min_,r9Max_);
270  }
271  book2DHistoVector(iBooker, p_r9VsEt_, "Profile","r9VsEt","Avg R9 vs E_{T};E_{T} (GeV);R9",etBin_,etMin_,etMax_,r9Bin_,r9Min_,r9Max_);
272  if (standAlone_) {
273  book2DHistoVector(iBooker, h_r9VsEta_, "2D","r9VsEta2D","R9 vs #eta;#eta;R9",reducedEtaBin_,etaMin_,etaMax_,reducedR9Bin_,r9Min_,r9Max_);
274  }
275  book2DHistoVector(iBooker, p_r9VsEta_, "Profile","r9VsEta","Avg R9 vs #eta;#eta;R9",etaBin_,etaMin_,etaMax_,r9Bin_,r9Min_,r9Max_);
276 
277  //sigma ieta ieta
278  book3DHistoVector(iBooker, h_phoSigmaIetaIeta_, "1D","phoSigmaIetaIeta","#sigma_{i#etai#eta};#sigma_{i#etai#eta}",sigmaIetaBin_,sigmaIetaMin_,sigmaIetaMax_);
279  if (standAlone_) {
280  book2DHistoVector(iBooker, h_sigmaIetaIetaVsEta_, "2D","sigmaIetaIetaVsEta2D","#sigma_{i#etai#eta} vs #eta;#eta;#sigma_{i#etai#eta}",reducedEtaBin_,etaMin_,etaMax_,sigmaIetaBin_,sigmaIetaMin_,sigmaIetaMax_);
281  }
282  book2DHistoVector(iBooker, p_sigmaIetaIetaVsEta_, "Profile","sigmaIetaIetaVsEta","Avg #sigma_{i#etai#eta} vs #eta;#eta;#sigma_{i#etai#eta}",etaBin_,etaMin_,etaMax_,sigmaIetaBin_,sigmaIetaMin_,sigmaIetaMax_);
283 
284  //e1x5
285  if (standAlone_) {
286  book2DHistoVector(iBooker, h_e1x5VsEt_, "2D","e1x5VsEt2D","E1x5 vs E_{T};E_{T} (GeV);E1X5 (GeV)",reducedEtBin_,etMin_,etMax_,reducedEtBin_,etMin_,etMax_);
287  }
288  book2DHistoVector(iBooker, p_e1x5VsEt_, "Profile","e1x5VsEt","Avg E1x5 vs E_{T};E_{T} (GeV);E1X5 (GeV)",etBin_,etMin_,etMax_,etBin_,etMin_,etMax_);
289  if (standAlone_) {
290  book2DHistoVector(iBooker, h_e1x5VsEta_, "2D","e1x5VsEta2D","E1x5 vs #eta;#eta;E1X5 (GeV)",reducedEtaBin_,etaMin_,etaMax_,reducedEtBin_,etMin_,etMax_);
291  }
292  book2DHistoVector(iBooker, p_e1x5VsEta_, "Profile","e1x5VsEta","Avg E1x5 vs #eta;#eta;E1X5 (GeV)",etaBin_,etaMin_,etaMax_,etBin_,etMin_,etMax_);
293 
294  //e2x5
295  if (standAlone_) {
296  book2DHistoVector(iBooker, h_e2x5VsEt_, "2D","e2x5VsEt2D","E2x5 vs E_{T};E_{T} (GeV);E2X5 (GeV)",reducedEtBin_,etMin_,etMax_,reducedEtBin_,etMin_,etMax_);
297  }
298  book2DHistoVector(iBooker, p_e2x5VsEt_, "Profile","e2x5VsEt","Avg E2x5 vs E_{T};E_{T} (GeV);E2X5 (GeV)",etBin_,etMin_,etMax_,etBin_,etMin_,etMax_);
299  if (standAlone_) {
300  book2DHistoVector(iBooker, h_e2x5VsEta_, "2D","e2x5VsEta2D","E2x5 vs #eta;#eta;E2X5 (GeV)",reducedEtaBin_,etaMin_,etaMax_,reducedEtBin_,etMin_,etMax_);
301  }
302  book2DHistoVector(iBooker, p_e2x5VsEta_, "Profile","e2x5VsEta","Avg E2x5 vs #eta;#eta;E2X5 (GeV)",etaBin_,etaMin_,etaMax_,etBin_,etMin_,etMax_);
303 
304  //r1x5
305  if (standAlone_) {
306  book2DHistoVector(iBooker, h_r1x5VsEt_, "2D","r1x5VsEt2D","R1x5 vs E_{T};E_{T} (GeV);R1X5",reducedEtBin_,etMin_,etMax_,reducedR9Bin_,r9Min_,r9Max_);
307  }
308  book2DHistoVector(iBooker, p_r1x5VsEt_, "Profile","r1x5VsEt","Avg R1x5 vs E_{T};E_{T} (GeV);R1X5",etBin_,etMin_,etMax_,r9Bin_,r9Min_,r9Max_);
309  if (standAlone_) {
310  book2DHistoVector(iBooker, h_r1x5VsEta_, "2D","r1x5VsEta2D","R1x5 vs #eta;#eta;R1X5",reducedEtaBin_,etaMin_,etaMax_,reducedR9Bin_,r9Min_,r9Max_);
311  }
312  book2DHistoVector(iBooker, p_r1x5VsEta_, "Profile","r1x5VsEta","Avg R1x5 vs #eta;#eta;R1X5",etaBin_,etaMin_,etaMax_,r9Bin_,r9Min_,r9Max_);
313 
314  //r2x5
315  if (standAlone_) {
316  book2DHistoVector(iBooker, h_r2x5VsEt_ ,"2D","r2x5VsEt2D","R2x5 vs E_{T};E_{T} (GeV);R2X5",reducedEtBin_,etMin_,etMax_,reducedR9Bin_,r9Min_,r9Max_);
317  }
318  book2DHistoVector(iBooker, p_r2x5VsEt_ ,"Profile","r2x5VsEt","Avg R2x5 vs E_{T};E_{T} (GeV);R2X5",etBin_,etMin_,etMax_,r9Bin_,r9Min_,r9Max_);
319  if (standAlone_) {
320  book2DHistoVector(iBooker, h_r2x5VsEta_ ,"2D","r2x5VsEta2D","R2x5 vs #eta;#eta;R2X5",reducedEtaBin_,etaMin_,etaMax_,reducedR9Bin_,r9Min_,r9Max_);
321  }
322  book2DHistoVector(iBooker, p_r2x5VsEta_ ,"Profile","r2x5VsEta","Avg R2x5 vs #eta;#eta;R2X5",etaBin_,etaMin_,etaMax_,r9Bin_,r9Min_,r9Max_);
323 
324  //maxEXtalOver3x3
325  if (standAlone_) {
326  book2DHistoVector(iBooker, h_maxEXtalOver3x3VsEt_ ,"2D","maxEXtalOver3x3VsEt2D","(Max Xtal E)/E3x3 vs E_{T};E_{T} (GeV);(Max Xtal E)/E3x3",reducedEtBin_,etMin_,etMax_,r9Bin_,r9Min_,r9Max_);
327  }
328  book2DHistoVector(iBooker, p_maxEXtalOver3x3VsEt_ ,"Profile","maxEXtalOver3x3VsEt","Avg (Max Xtal E)/E3x3 vs E_{T};E_{T} (GeV);(Max Xtal E)/E3x3",etBin_,etMin_,etMax_,r9Bin_,r9Min_,r9Max_);
329  if (standAlone_) {
330  book2DHistoVector(iBooker, h_maxEXtalOver3x3VsEta_ ,"2D","maxEXtalOver3x3VsEta2D","(Max Xtal E)/E3x3 vs #eta;#eta;(Max Xtal E)/E3x3",reducedEtaBin_,etaMin_,etaMax_,r9Bin_,r9Min_,r9Max_);
331  }
332  book2DHistoVector(iBooker, p_maxEXtalOver3x3VsEta_ ,"Profile","maxEXtalOver3x3VsEta","Avg (Max Xtal E)/E3x3 vs #eta;#eta;(Max Xtal E)/E3x3",etaBin_,etaMin_,etaMax_,r9Bin_,r9Min_,r9Max_);
333 
334  //TRACK ISOLATION VARIABLES
335  //nTrackIsolSolid
336  book2DHistoVector(iBooker, h_nTrackIsolSolid_ ,"1D","nIsoTracksSolid","Number Of Tracks in the Solid Iso Cone;# tracks",numberBin_,numberMin_,numberMax_);
337  if (standAlone_) {
338  book2DHistoVector(iBooker, h_nTrackIsolSolidVsEt_ ,"2D","nIsoTracksSolidVsEt2D","Number Of Tracks in the Solid Iso Cone vs E_{T};E_{T};# tracks",reducedEtBin_,etMin_, etMax_,numberBin_,numberMin_,numberMax_);
339  }
340  book2DHistoVector(iBooker, p_nTrackIsolSolidVsEt_ ,"Profile","nIsoTracksSolidVsEt","Avg Number Of Tracks in the Solid Iso Cone vs E_{T};E_{T};# tracks",etBin_,etMin_,etMax_,numberBin_,numberMin_,numberMax_);
341  if (standAlone_) {
342  book2DHistoVector(iBooker, h_nTrackIsolSolidVsEta_ ,"2D","nIsoTracksSolidVsEta2D","Number Of Tracks in the Solid Iso Cone vs #eta;#eta;# tracks",reducedEtaBin_,etaMin_, etaMax_,numberBin_,numberMin_,numberMax_);
343  }
344  book2DHistoVector(iBooker, p_nTrackIsolSolidVsEta_ ,"Profile","nIsoTracksSolidVsEta","Avg Number Of Tracks in the Solid Iso Cone vs #eta;#eta;# tracks",etaBin_,etaMin_, etaMax_,numberBin_,numberMin_,numberMax_);
345 
346  //nTrackIsolHollow
347  book2DHistoVector(iBooker, h_nTrackIsolHollow_ ,"1D","nIsoTracksHollow","Number Of Tracks in the Hollow Iso Cone;# tracks",numberBin_,numberMin_,numberMax_);
348  if (standAlone_) {
349  book2DHistoVector(iBooker, h_nTrackIsolHollowVsEt_ ,"2D","nIsoTracksHollowVsEt2D","Number Of Tracks in the Hollow Iso Cone vs E_{T};E_{T};# tracks",reducedEtBin_,etMin_, etMax_,numberBin_,numberMin_,numberMax_);
350  }
351  book2DHistoVector(iBooker, p_nTrackIsolHollowVsEt_ ,"Profile","nIsoTracksHollowVsEt","Avg Number Of Tracks in the Hollow Iso Cone vs E_{T};E_{T};# tracks",etBin_,etMin_,etMax_,numberBin_,numberMin_,numberMax_);
352  if (standAlone_) {
353  book2DHistoVector(iBooker, h_nTrackIsolHollowVsEta_ ,"2D","nIsoTracksHollowVsEta2D","Number Of Tracks in the Hollow Iso Cone vs #eta;#eta;# tracks",reducedEtaBin_,etaMin_, etaMax_,numberBin_,numberMin_,numberMax_);
354  }
355  book2DHistoVector(iBooker, p_nTrackIsolHollowVsEta_ ,"Profile","nIsoTracksHollowVsEta","Avg Number Of Tracks in the Hollow Iso Cone vs #eta;#eta;# tracks",etaBin_,etaMin_, etaMax_,numberBin_,numberMin_,numberMax_);
356 
357  //trackPtSumSolid
358  book2DHistoVector(iBooker, h_trackPtSumSolid_ ,"1D","isoPtSumSolid","Track P_{T} Sum in the Solid Iso Cone;P_{T} (GeV)",sumBin_,sumMin_,sumMax_);
359  if (standAlone_) {
360  book2DHistoVector(iBooker, h_trackPtSumSolidVsEt_ ,"2D","isoPtSumSolidVsEt2D","Track P_{T} Sum in the Solid Iso Cone;E_{T} (GeV);P_{T} (GeV)",reducedEtBin_,etMin_, etMax_,reducedSumBin_,sumMin_,sumMax_);
361  }
362  book2DHistoVector(iBooker, p_trackPtSumSolidVsEt_ ,"Profile","isoPtSumSolidVsEt","Avg Track P_{T} Sum in the Solid Iso Cone vs E_{T};E_{T} (GeV);P_{T} (GeV)",etBin_,etMin_,etMax_,sumBin_,sumMin_,sumMax_);
363  if (standAlone_) {
364  book2DHistoVector(iBooker, h_trackPtSumSolidVsEta_ ,"2D","isoPtSumSolidVsEta2D","Track P_{T} Sum in the Solid Iso Cone;#eta;P_{T} (GeV)",reducedEtaBin_,etaMin_, etaMax_,reducedSumBin_,sumMin_,sumMax_);
365  }
366  book2DHistoVector(iBooker, p_trackPtSumSolidVsEta_ ,"Profile","isoPtSumSolidVsEta","Avg Track P_{T} Sum in the Solid Iso Cone vs #eta;#eta;P_{T} (GeV)",etaBin_,etaMin_, etaMax_,sumBin_,sumMin_,sumMax_);
367 
368  //trackPtSumHollow
369  book2DHistoVector(iBooker, h_trackPtSumHollow_ ,"1D","isoPtSumHollow","Track P_{T} Sum in the Hollow Iso Cone;P_{T} (GeV)",sumBin_,sumMin_,sumMax_);
370  if (standAlone_) {
371  book2DHistoVector(iBooker, h_trackPtSumHollowVsEt_ ,"2D","isoPtSumHollowVsEt2D","Track P_{T} Sum in the Hollow Iso Cone;E_{T} (GeV);P_{T} (GeV)",reducedEtBin_,etMin_, etMax_,reducedSumBin_,sumMin_,sumMax_);
372  }
373  book2DHistoVector(iBooker, p_trackPtSumHollowVsEt_ ,"Profile","isoPtSumHollowVsEt","Avg Track P_{T} Sum in the Hollow Iso Cone vs E_{T};E_{T} (GeV);P_{T} (GeV)",etBin_,etMin_,etMax_,sumBin_,sumMin_,sumMax_);
374  if (standAlone_) {
375  book2DHistoVector(iBooker, h_trackPtSumHollowVsEta_ ,"2D","isoPtSumHollowVsEta2D","Track P_{T} Sum in the Hollow Iso Cone;#eta;P_{T} (GeV)",reducedEtaBin_,etaMin_, etaMax_,reducedSumBin_,sumMin_,sumMax_);
376  }
377  book2DHistoVector(iBooker, p_trackPtSumHollowVsEta_ ,"Profile","isoPtSumHollowVsEta","Avg Track P_{T} Sum in the Hollow Iso Cone vs #eta;#eta;P_{T} (GeV)",etaBin_,etaMin_, etaMax_,sumBin_,sumMin_,sumMax_);
378 
379  //CALORIMETER ISOLATION VARIABLES
380  //ecal sum
381  book2DHistoVector(iBooker, h_ecalSum_, "1D","ecalSum","Ecal Sum in the Iso Cone;E (GeV)",sumBin_,sumMin_,sumMax_);
382  book2DHistoVector(iBooker, h_ecalSumEBarrel_, "1D","ecalSumEBarrel","Ecal Sum in the IsoCone for Barrel;E (GeV)",sumBin_,sumMin_,sumMax_);
383  book2DHistoVector(iBooker, h_ecalSumEEndcap_, "1D","ecalSumEEndcap","Ecal Sum in the IsoCone for Endcap;E (GeV)",sumBin_,sumMin_,sumMax_);
384  if (standAlone_) {
385  book2DHistoVector(iBooker, h_ecalSumVsEt_, "2D","ecalSumVsEt2D","Ecal Sum in the Iso Cone;E_{T} (GeV);E (GeV)",reducedEtBin_,etMin_, etMax_,reducedSumBin_,sumMin_,sumMax_);
386  }
387  book3DHistoVector(iBooker, p_ecalSumVsEt_, "Profile","ecalSumVsEt","Avg Ecal Sum in the Iso Cone vs E_{T};E_{T} (GeV);E (GeV)",etBin_,etMin_, etMax_,sumBin_,sumMin_,sumMax_);
388  if (standAlone_) {
389  book2DHistoVector(iBooker, h_ecalSumVsEta_, "2D","ecalSumVsEta2D","Ecal Sum in the Iso Cone;#eta;E (GeV)",reducedEtaBin_,etaMin_, etaMax_,reducedSumBin_,sumMin_,sumMax_);
390  }
391  book2DHistoVector(iBooker, p_ecalSumVsEta_, "Profile","ecalSumVsEta","Avg Ecal Sum in the Iso Cone vs #eta;#eta;E (GeV)",etaBin_,etaMin_, etaMax_,sumBin_,sumMin_,sumMax_);
392 
393  //hcal sum
394  book2DHistoVector(iBooker, h_hcalSum_, "1D","hcalSum","Hcal Sum in the Iso Cone;E (GeV)",sumBin_,sumMin_,sumMax_);
395  book2DHistoVector(iBooker, h_hcalSumEBarrel_, "1D","hcalSumEBarrel","Hcal Sum in the IsoCone for Barrel;E (GeV)",sumBin_,sumMin_,sumMax_);
396  book2DHistoVector(iBooker, h_hcalSumEEndcap_, "1D","hcalSumEEndcap","Hcal Sum in the IsoCone for Endcap;E (GeV)",sumBin_,sumMin_,sumMax_);
397  if (standAlone_) {
398  book2DHistoVector(iBooker, h_hcalSumVsEt_, "2D","hcalSumVsEt2D","Hcal Sum in the Iso Cone;E_{T} (GeV);E (GeV)",reducedEtBin_,etMin_, etMax_,reducedSumBin_,sumMin_,sumMax_);
399  }
400  book3DHistoVector(iBooker, p_hcalSumVsEt_, "Profile","hcalSumVsEt","Avg Hcal Sum in the Iso Cone vs E_{T};E_{T} (GeV);E (GeV)",etBin_,etMin_, etMax_,sumBin_,sumMin_,sumMax_);
401  if (standAlone_) {
402  book2DHistoVector(iBooker, h_hcalSumVsEta_, "2D","hcalSumVsEta2D","Hcal Sum in the Iso Cone;#eta;E (GeV)",reducedEtaBin_,etaMin_, etaMax_,reducedSumBin_,sumMin_,sumMax_);
403  }
404  book2DHistoVector(iBooker, p_hcalSumVsEta_, "Profile","hcalSumVsEta","Avg Hcal Sum in the Iso Cone vs #eta;#eta;E (GeV)",etaBin_,etaMin_, etaMax_,sumBin_,sumMin_,sumMax_);
405 
406  //h over e
407  book3DHistoVector(iBooker, h_hOverE_, "1D","hOverE","H/E;H/E",hOverEBin_,hOverEMin_,hOverEMax_);
408  book2DHistoVector(iBooker, p_hOverEVsEt_, "Profile","hOverEVsEt","Avg H/E vs Et;E_{T} (GeV);H/E",etBin_,etMin_,etMax_,hOverEBin_,hOverEMin_,hOverEMax_);
409  book2DHistoVector(iBooker, p_hOverEVsEta_, "Profile","hOverEVsEta","Avg H/E vs #eta;#eta;H/E",etaBin_,etaMin_,etaMax_,hOverEBin_,hOverEMin_,hOverEMax_);
410  book3DHistoVector(iBooker, h_h1OverE_, "1D","h1OverE","H/E for Depth 1;H/E",hOverEBin_,hOverEMin_,hOverEMax_);
411  book3DHistoVector(iBooker, h_h2OverE_, "1D","h2OverE","H/E for Depth 2;H/E",hOverEBin_,hOverEMin_,hOverEMax_);
412 
413  // pf isolation
414  book2DHistoVector(iBooker, h_phoIsoBarrel_, "1D","phoIsoBarrel","PF photon iso Barrel;E (GeV)",reducedEtBin_,etMin_,25.);
415  book2DHistoVector(iBooker, h_phoIsoEndcap_, "1D","phoIsoEndcap","PF photon iso Endcap;E (GeV)",reducedEtBin_,etMin_,25.);
416  book2DHistoVector(iBooker, h_chHadIsoBarrel_, "1D","chHadIsoBarrel","PF charged Had iso Barrel;E (GeV)",reducedEtBin_,etMin_,25.);
417  book2DHistoVector(iBooker, h_chHadIsoEndcap_, "1D","chHadIsoEndcap","PF charged Had iso Endcap;E (GeV)",reducedEtBin_,etMin_,25.);
418  book2DHistoVector(iBooker, h_nHadIsoBarrel_, "1D","neutralHadIsoBarrel","PF neutral Had iso Barrel;E (GeV)",reducedEtBin_,etMin_,25.);
419  book2DHistoVector(iBooker, h_nHadIsoEndcap_, "1D","neutralHadIsoEndcap","PF neutral Had iso Endcap;E (GeV)",reducedEtBin_,etMin_,25.);
420 
421  //OTHER VARIABLES
422  //bad channel histograms
423  book2DHistoVector(iBooker, h_phoEt_BadChannels_ , "1D","phoEtBadChannels", "Fraction Containing Bad Channels: E_{T};E_{T} (GeV)",etBin_,etMin_,etMax_);
424  book2DHistoVector(iBooker, h_phoEta_BadChannels_ , "1D","phoEtaBadChannels","Fraction Containing Bad Channels: #eta;#eta",etaBin_,etaMin_,etaMax_);
425  book2DHistoVector(iBooker, h_phoPhi_BadChannels_ , "1D","phoPhiBadChannels","Fraction Containing Bad Channels: #phi;#phi",phiBin_,phiMin_,phiMax_);
426 }
427 
428 void PhotonAnalyzer::bookHistogramsConversions(DQMStore::IBooker & iBooker)
429 {
430  // Set folder
431  iBooker.setCurrentFolder("Egamma/"+fName_+"/AllPhotons/Et Above 0 GeV/Conversions");
432 
433  //ENERGY VARIABLES
434  book3DHistoVector(iBooker, h_phoConvE_ , "1D", "phoConvE","E;E (GeV)",eBin_,eMin_,eMax_);
435  book3DHistoVector(iBooker, h_phoConvEt_ , "1D", "phoConvEt","E_{T};E_{T} (GeV)",etBin_,etMin_,etMax_);
436 
437  //GEOMETRICAL VARIABLES
438  book2DHistoVector(iBooker, h_phoConvEta_ , "1D", "phoConvEta","#eta;#eta",etaBin_,etaMin_,etaMax_);
439  book3DHistoVector(iBooker, h_phoConvPhi_ , "1D", "phoConvPhi","#phi;#phi",phiBin_,phiMin_,phiMax_);
440 
441  //NUMBER OF PHOTONS
442  book3DHistoVector(iBooker, h_nConv_ , "1D", "nConv","Number Of Conversions per Event ;# conversions",numberBin_,numberMin_,numberMax_);
443 
444  //SHOWER SHAPE VARIABLES
445  book3DHistoVector(iBooker, h_phoConvR9_ , "1D", "phoConvR9","R9;R9",r9Bin_,r9Min_,r9Max_);
446 
447  //TRACK RELATED VARIABLES
448  book3DHistoVector(iBooker, h_eOverPTracks_ , "1D", "eOverPTracks","E/P;E/P",eOverPBin_,eOverPMin_,eOverPMax_);
449  book3DHistoVector(iBooker, h_pOverETracks_ , "1D", "pOverETracks","P/E;P/E",eOverPBin_,eOverPMin_,eOverPMax_);
450  book3DHistoVector(iBooker, h_dPhiTracksAtVtx_ , "1D", "dPhiTracksAtVtx", "#Delta#phi of Tracks at Vertex;#Delta#phi",dPhiTracksBin_,dPhiTracksMin_,dPhiTracksMax_);
451  book3DHistoVector(iBooker, h_dPhiTracksAtEcal_, "1D", "dPhiTracksAtEcal", "Abs(#Delta#phi) of Tracks at Ecal;#Delta#phi",dPhiTracksBin_,0.,dPhiTracksMax_);
452  book3DHistoVector(iBooker, h_dEtaTracksAtEcal_, "1D", "dEtaTracksAtEcal", "#Delta#eta of Tracks at Ecal;#Delta#eta",dEtaTracksBin_,dEtaTracksMin_,dEtaTracksMax_);
453  book3DHistoVector(iBooker, h_dCotTracks_ , "1D", "dCotTracks","#Deltacot(#theta) of Tracks;#Deltacot(#theta)",dEtaTracksBin_,dEtaTracksMin_,dEtaTracksMax_);
454  book2DHistoVector(iBooker, p_dCotTracksVsEta_ , "Profile", "dCotTracksVsEta","Avg #Deltacot(#theta) of Tracks vs #eta;#eta;#Deltacot(#theta)",etaBin_,etaMin_,etaMax_,dEtaTracksBin_,dEtaTracksMin_,dEtaTracksMax_);
455  book2DHistoVector(iBooker, p_nHitsVsEta_ , "Profile", "nHitsVsEta","Avg Number of Hits per Track vs #eta;#eta;# hits",etaBin_,etaMin_,etaMax_,etaBin_,0,16);
456  book2DHistoVector(iBooker, h_tkChi2_ , "1D", "tkChi2","#chi^{2} of Track Fitting;#chi^{2}",chi2Bin_,chi2Min_,chi2Max_);
457  book2DHistoVector(iBooker, p_tkChi2VsEta_ , "Profile", "tkChi2VsEta","Avg #chi^{2} of Track Fitting vs #eta;#eta;#chi^{2}",etaBin_,etaMin_,etaMax_,chi2Bin_,chi2Min_,chi2Max_);
458 
459  //VERTEX RELATED VARIABLES
460  book2DHistoVector(iBooker, h_convVtxRvsZ_ , "2D", "convVtxRvsZ","Vertex Position;Z (cm);R (cm)",500,zMin_,zMax_,rBin_,rMin_,rMax_);
461  book2DHistoVector(iBooker, h_convVtxZEndcap_ , "1D", "convVtxZEndcap", "Vertex Position: #eta > 1.5;Z (cm)",zBin_,zMin_,zMax_);
462  book2DHistoVector(iBooker, h_convVtxZ_ , "1D", "convVtxZ", "Vertex Position;Z (cm)",zBin_,zMin_,zMax_);
463  book2DHistoVector(iBooker, h_convVtxR_ , "1D", "convVtxR", "Vertex Position: #eta < 1;R (cm)",rBin_,rMin_,rMax_);
464  book2DHistoVector(iBooker, h_convVtxYvsX_ , "2D", "convVtxYvsX","Vertex Position: #eta < 1;X (cm);Y (cm)",xBin_,xMin_,xMax_,yBin_,yMin_,yMax_);
465  book2DHistoVector(iBooker, h_vertexChi2Prob_ , "1D", "vertexChi2Prob","#chi^{2} Probability of Vertex Fitting;#chi^{2}",100,0.,1.0);
466 }
467 
468 // Booking helper methods:
469 
470 MonitorElement* PhotonAnalyzer::bookHisto(DQMStore::IBooker & iBooker,
471  string histoName, string title,
472  int bin, double min, double max)
473 {
474  int histo_index = 0;
475  stringstream histo_number_stream;
476 
477  //determining which folder we're in
478  if(iBooker.pwd().find( "InvMass" ) != string::npos){
479  histo_index_invMass_++;
480  histo_index = histo_index_invMass_;
481  }
482  if(iBooker.pwd().find( "Efficiencies" ) != string::npos){
483  histo_index_efficiency_++;
484  histo_index = histo_index_efficiency_;
485  }
486 
487  histo_number_stream << "h_";
488  if(histo_index<10) histo_number_stream << "0";
489  histo_number_stream << histo_index;
490 
491  return iBooker.book1D(histo_number_stream.str() + "_" + histoName,title,bin,min,max);
492 }
493 
494 void PhotonAnalyzer::book2DHistoVector(DQMStore::IBooker & iBooker,
495  vector<vector<MonitorElement*> > &temp2DVector,
496  string histoType, string histoName, string title,
497  int xbin, double xmin, double xmax,
498  int ybin, double ymin, double ymax)
499 {
500  int histo_index = 0;
501 
502  vector<MonitorElement*> temp1DVector;
503 
504  //determining which folder we're in
505  bool conversionPlot = false;
506  if(iBooker.pwd().find( "Conversions" ) != string::npos) conversionPlot = true;
507  bool TwoDPlot = false;
508  if(histoName.find( "2D" ) != string::npos) TwoDPlot = true;
509 
510  if(conversionPlot){
511  histo_index_conversions_++;
512  histo_index = histo_index_conversions_;
513  }
514  else{
515  histo_index_photons_++;
516  histo_index = histo_index_photons_;
517  }
518 
519  stringstream histo_number_stream;
520  histo_number_stream << "h_";
521  if(histo_index<10) histo_number_stream << "0";
522  histo_number_stream << histo_index << "_";
523 
524  for(int cut = 0; cut != numberOfSteps_; ++cut){ //looping over Et cut values
525  for(uint type=0;type!=types_.size();++type){ //looping over isolation type
526  currentFolder_.str("");
527  currentFolder_ << "Egamma/"+fName_+"/" << types_[type] << "Photons/Et above " << (cut+1)*cutStep_ << " GeV";
528  if(conversionPlot) currentFolder_ << "/Conversions";
529 
530  iBooker.setCurrentFolder(currentFolder_.str());
531 
532  string kind;
533  if(conversionPlot) kind = " Conversions: ";
534  else kind = " Photons: ";
535 
536  if(histoType=="1D") temp1DVector.push_back(iBooker.book1D( histo_number_stream.str()+histoName,types_[type]+kind+title,xbin,xmin,xmax));
537  else if(histoType=="2D"){
538  if((TwoDPlot && type==0) || !TwoDPlot){//only book the 2D plots in the "AllPhotons" folder
539  temp1DVector.push_back(iBooker.book2D( histo_number_stream.str()+histoName,types_[type]+kind+title,xbin,xmin,xmax,ybin,ymin,ymax));
540  }
541  }
542  else if(histoType=="Profile") temp1DVector.push_back(iBooker.bookProfile( histo_number_stream.str()+histoName,types_[type]+kind+title,xbin,xmin,xmax,ybin,ymin,ymax,""));
543  else cout << "bad histoType\n";
544  }
545 
546  temp2DVector.push_back(temp1DVector);
547  temp1DVector.clear();
548  }
549 }
550 
551 void PhotonAnalyzer::book3DHistoVector(DQMStore::IBooker & iBooker,
552  vector<vector<vector<MonitorElement*> > > &temp3DVector,
553  string histoType, string histoName, string title,
554  int xbin, double xmin,double xmax,
555  int ybin, double ymin, double ymax)
556 {
557  int histo_index = 0;
558 
559  vector<MonitorElement*> temp1DVector;
560  vector<vector<MonitorElement*> > temp2DVector;
561 
562  //determining which folder we're in
563  bool conversionPlot = false;
564  if(iBooker.pwd().find( "Conversions" ) != string::npos) conversionPlot = true;
565 
566  if(conversionPlot){
567  histo_index_conversions_++;
568  histo_index = histo_index_conversions_;
569  }
570  else{
571  histo_index_photons_++;
572  histo_index = histo_index_photons_;
573  }
574 
575  stringstream histo_number_stream;
576  histo_number_stream << "h_";
577  if(histo_index<10) histo_number_stream << "0";
578  histo_number_stream << histo_index << "_";
579 
580  for(int cut = 0; cut != numberOfSteps_; ++cut){ //looping over Et cut values
581  for(uint type=0;type!=types_.size();++type){ //looping over isolation type
582  for(uint part=0;part!=parts_.size();++part){ //looping over different parts of the ecal
583  currentFolder_.str("");
584  currentFolder_ << "Egamma/"+fName_+"/" << types_[type] << "Photons/Et above " << (cut+1)*cutStep_ << " GeV";
585  if(conversionPlot) currentFolder_ << "/Conversions";
586  iBooker.setCurrentFolder(currentFolder_.str());
587 
588  string kind;
589  if(conversionPlot) kind = " Conversions: ";
590  else kind = " Photons: ";
591 
592  if(histoType=="1D") temp1DVector.push_back(iBooker.book1D( histo_number_stream.str()+histoName+parts_[part],types_[type]+kind+parts_[part]+": "+title,xbin,xmin,xmax));
593  else if(histoType=="2D") temp1DVector.push_back(iBooker.book2D( histo_number_stream.str()+histoName+parts_[part],types_[type]+kind+parts_[part]+": "+title,xbin,xmin,xmax,ybin,ymin,ymax));
594  else if(histoType=="Profile") temp1DVector.push_back(iBooker.bookProfile( histo_number_stream.str()+histoName+parts_[part],types_[type]+kind+parts_[part]+": "+title,xbin,xmin,xmax,ybin,ymin,ymax,""));
595  else cout << "bad histoType\n";
596  }
597  temp2DVector.push_back(temp1DVector);
598  temp1DVector.clear();
599  }
600  temp3DVector.push_back(temp2DVector);
601  temp2DVector.clear();
602  }
603 }
604 
605 // Analysis:
606 
607 void PhotonAnalyzer::analyze( const edm::Event& e, const edm::EventSetup& esup )
608 {
609  using namespace edm;
610 
611  if (nEvt_% prescaleFactor_ ) return;
612  nEvt_++;
613  LogInfo(fName_) << "PhotonAnalyzer Analyzing event number: " << e.id() << " Global Counter " << nEvt_ <<"\n";
614 
615  // Get the trigger results
616  bool validTriggerEvent=true;
617  edm::Handle<trigger::TriggerEvent> triggerEventHandle;
618  const trigger::TriggerEvent dummyTE;
619  e.getByToken(triggerEvent_token_,triggerEventHandle);
620  if(!triggerEventHandle.isValid()) {
621  edm::LogInfo(fName_) << "Error! Can't get the product: triggerEvent_" << endl;
622  validTriggerEvent=false;
623  }
624  const trigger::TriggerEvent& triggerEvent(validTriggerEvent? *(triggerEventHandle.product()) : dummyTE);
625 
626  // Get the reconstructed photons
627  // bool validPhotons=true;
628  Handle<reco::PhotonCollection> photonHandle;
629  e.getByToken(photon_token_ , photonHandle);
630  if ( !photonHandle.isValid()) {
631  edm::LogInfo(fName_) << "Error! Can't get the product: photon_token_" << endl;
632  // validPhotons=false;
633  }
634  const reco::PhotonCollection& photonCollection(*(photonHandle.product()));
635 
636 
637  // Get the PhotonId objects
638  // bool validloosePhotonID=true;
639  Handle<edm::ValueMap<bool> > loosePhotonFlag;
640  e.getByToken(PhotonIDLoose_token_, loosePhotonFlag);
641  if ( !loosePhotonFlag.isValid()) {
642  edm::LogInfo(fName_) << "Error! Can't get the product: PhotonIDLoose_token_" << endl;
643  // validloosePhotonID=false;
644  }
645  // edm::ValueMap<bool> dummyLPID;
646  // const edm::ValueMap<bool>& loosePhotonID(validloosePhotonID? *(loosePhotonFlag.product()) : dummyLPID);
647 
648  // bool validtightPhotonID=true;
649  Handle<edm::ValueMap<bool> > tightPhotonFlag;
650  e.getByToken(PhotonIDTight_token_, tightPhotonFlag);
651  if ( !tightPhotonFlag.isValid()) {
652  edm::LogInfo(fName_) << "Error! Can't get the product: PhotonIDTight_token_" << endl;
653  // validtightPhotonID=false;
654  }
655  // edm::ValueMap<bool> dummyTPI;
656  // const edm::ValueMap<bool>& tightPhotonID(validtightPhotonID ? *(tightPhotonFlag.product()) : dummyTPI);
657 
658 
659  edm::Handle<reco::VertexCollection> vtxH;
660  if ( !isHeavyIon_) {
661  e.getByToken(offline_pvToken_, vtxH);
662  h_nRecoVtx_ ->Fill (float(vtxH->size()));
663  }
664 
665  // Create array to hold #photons/event information
666  int nPho[100][3][3];
667 
668  for (int cut=0; cut!=100; ++cut){
669  for (unsigned int type=0; type!=types_.size(); ++type){
670  for (unsigned int part=0; part!=parts_.size(); ++part){
671  nPho[cut][type][part] = 0;
672  }
673  }
674  }
675  // Create array to hold #conversions/event information
676  int nConv[100][3][3];
677 
678  for (int cut=0; cut!=100; ++cut){
679  for (unsigned int type=0; type!=types_.size(); ++type){
680  for (unsigned int part=0; part!=parts_.size(); ++part){
681  nConv[cut][type][part] = 0;
682  }
683  }
684  }
685 
686  //Prepare list of photon-related HLT filter names
687  vector<int> Keys;
688 
689  for(uint filterIndex=0;filterIndex<triggerEvent.sizeFilters();++filterIndex){ //loop over all trigger filters in event (i.e. filters passed)
690  string label = triggerEvent.filterTag(filterIndex).label();
691  if(label.find( "Photon" ) != string::npos ) { //get photon-related filters
692  for(uint filterKeyIndex=0;filterKeyIndex<triggerEvent.filterKeys(filterIndex).size();++filterKeyIndex){ //loop over keys to objects passing this filter
693  Keys.push_back(triggerEvent.filterKeys(filterIndex)[filterKeyIndex]); //add keys to a vector for later reference
694  }
695  }
696  }
697 
698  // sort Keys vector in ascending order
699  // and erases duplicate entries from the vector
700  sort(Keys.begin(),Keys.end());
701  for ( uint i=0 ; i<Keys.size() ; )
702  {
703  if (i!=(Keys.size()-1))
704  {
705  if (Keys[i]==Keys[i+1]) Keys.erase(Keys.begin()+i+1) ;
706  else ++i ;
707  }
708  else ++i ;
709  }
710 
711  //We now have a vector of unique keys to TriggerObjects passing a photon-related filter
712 
713  // old int photonCounter = 0;
714 
716  for(unsigned int iPho=0; iPho < photonHandle->size(); iPho++) {
717  const reco::Photon* aPho = &photonCollection[iPho];
718  // for( reco::PhotonCollection::const_iterator iPho = photonCollection.begin(); iPho != photonCollection.end(); iPho++) {
719 
720  //for HLT efficiency plots
721 
722  h_phoEta_preHLT_->Fill(aPho->eta());
723  h_phoEt_preHLT_->Fill( aPho->et());
724 
725  double deltaR=1000.;
726  double deltaRMin=1000.;
727  double deltaRMax=0.05;//sets deltaR threshold for matching photons to trigger objects
728 
729  for (vector<int>::const_iterator objectKey=Keys.begin();objectKey!=Keys.end();objectKey++){ //loop over keys to objects that fired photon triggers
730 
731  deltaR = reco::deltaR(triggerEvent.getObjects()[(*objectKey)].eta(),triggerEvent.getObjects()[(*objectKey)].phi(),aPho->superCluster()->eta(),aPho->superCluster()->phi());
732  if(deltaR < deltaRMin) deltaRMin = deltaR;
733 
734  }
735 
736  if(deltaRMin > deltaRMax) { //photon fails delta R cut
737  if(useTriggerFiltering_) continue; //throw away photons that haven't passed any photon filters
738  }
739 
740  if(deltaRMin <= deltaRMax) { //photon passes delta R cut
741  h_phoEta_postHLT_->Fill(aPho->eta() );
742  h_phoEt_postHLT_->Fill( aPho->et() );
743  }
744 
745  // if (aPho->et() < minPhoEtCut_) continue;
746  bool isLoosePhoton(false), isTightPhoton(false);
747  if ( photonSelection (aPho) ) isLoosePhoton=true ;
748 
749  //find out which part of the Ecal contains the photon
750  bool phoIsInBarrel=false;
751  bool phoIsInEndcap=false;
752  float etaPho = aPho->superCluster()->eta();
753  if ( fabs(etaPho) < 1.479 )
754  phoIsInBarrel=true;
755  else {
756  phoIsInEndcap=true;
757  }
758 
759  int part = 0;
760  if ( phoIsInBarrel ) part = 1;
761  if ( phoIsInEndcap ) part = 2;
762 
764  bool isIsolated=false;
765  if ( isolationStrength_ == 0) isIsolated = isLoosePhoton;
766  if ( isolationStrength_ == 1) isIsolated = isTightPhoton;
767 
768  int type=0;
769  if ( isIsolated ) type=1;
770  if ( !excludeBkgHistos_ && !isIsolated ) type=2;
771 
772  //get rechit collection containing this photon
773  bool validEcalRecHits=true;
774  edm::Handle<EcalRecHitCollection> ecalRecHitHandle;
775  EcalRecHitCollection ecalRecHitCollection;
776  if ( phoIsInBarrel ) {
777  // Get handle to barrel rec hits
778  e.getByToken(barrelRecHit_token_, ecalRecHitHandle);
779  if (!ecalRecHitHandle.isValid()) {
780  edm::LogError(fName_) << "Error! Can't get the product: barrelRecHit_token_";
781  validEcalRecHits=false;
782  }
783  }
784  else if ( phoIsInEndcap ) {
785  // Get handle to endcap rec hits
786  e.getByToken(endcapRecHit_token_, ecalRecHitHandle);
787  if (!ecalRecHitHandle.isValid()) {
788  edm::LogError(fName_) << "Error! Can't get the product: endcapRecHit_token";
789  validEcalRecHits=false;
790  }
791  }
792  if (validEcalRecHits) ecalRecHitCollection = *(ecalRecHitHandle.product());
793 
794  //if (aPho->isEBEEGap()) continue; //cut out gap photons
795 
796  //filling histograms to make isolation efficiencies
797  if(isLoosePhoton){
798  h_phoEta_Loose_->Fill(aPho->eta());
799  h_phoEt_Loose_->Fill( aPho->et() );
800  }
801  if(isTightPhoton){
802  h_phoEta_Tight_->Fill(aPho->eta());
803  h_phoEt_Tight_->Fill( aPho->et() );
804  }
805 
806  for (int cut = 0; cut !=numberOfSteps_; ++cut) { //loop over different transverse energy cuts
807  double Et = aPho->et();
808  bool passesCuts = false;
809 
810  //sorting the photon into the right Et-dependant folder
811  if ( useBinning_ && Et > (cut+1)*cutStep_ && ( (Et < (cut+2)*cutStep_) | (cut == numberOfSteps_-1) ) ){
812  passesCuts = true;
813  }
814  else if ( !useBinning_ && Et > (cut+1)*cutStep_ ){
815  passesCuts = true;
816  }
817 
818  if (passesCuts){
819  //filling isolation variable histograms
820 
821  //tracker isolation variables
822  fill2DHistoVector(h_nTrackIsolSolid_, aPho->nTrkSolidConeDR04(), cut,type);
823  fill2DHistoVector(h_nTrackIsolHollow_,aPho->nTrkHollowConeDR04(),cut,type);
824 
825  if (standAlone_) fill2DHistoVector(h_nTrackIsolSolidVsEta_, aPho->eta(),aPho->nTrkSolidConeDR04(), cut,type);
826  fill2DHistoVector(p_nTrackIsolSolidVsEta_, aPho->eta(),aPho->nTrkSolidConeDR04(), cut,type);
827  if (standAlone_) fill2DHistoVector(h_nTrackIsolHollowVsEta_,aPho->eta(),aPho->nTrkHollowConeDR04(),cut,type);
828  fill2DHistoVector(p_nTrackIsolHollowVsEta_,aPho->eta(),aPho->nTrkHollowConeDR04(),cut,type);
829 
830  if (standAlone_) fill2DHistoVector(h_nTrackIsolSolidVsEt_, aPho->et(), aPho->nTrkSolidConeDR04(), cut,type);
831  fill2DHistoVector(p_nTrackIsolSolidVsEt_, aPho->et(), aPho->nTrkSolidConeDR04(), cut,type);
832  if (standAlone_) fill2DHistoVector(h_nTrackIsolHollowVsEt_, aPho->et(), aPho->nTrkHollowConeDR04(),cut,type);
833  fill2DHistoVector(p_nTrackIsolHollowVsEt_, aPho->et(), aPho->nTrkHollowConeDR04(),cut,type);
834 
836  fill2DHistoVector(h_trackPtSumSolid_, aPho->trkSumPtSolidConeDR04(),cut,type);
837  fill2DHistoVector(h_trackPtSumHollow_,aPho->trkSumPtSolidConeDR04(),cut,type);
838 
839  if (standAlone_) fill2DHistoVector(h_trackPtSumSolidVsEta_, aPho->eta(),aPho->trkSumPtSolidConeDR04(), cut,type);
840  fill2DHistoVector(p_trackPtSumSolidVsEta_, aPho->eta(),aPho->trkSumPtSolidConeDR04(), cut,type);
841  if (standAlone_) fill2DHistoVector(h_trackPtSumHollowVsEta_,aPho->eta(),aPho->trkSumPtHollowConeDR04(),cut,type);
842  fill2DHistoVector(p_trackPtSumHollowVsEta_,aPho->eta(),aPho->trkSumPtHollowConeDR04(),cut,type);
843 
844  if (standAlone_) fill2DHistoVector(h_trackPtSumSolidVsEt_, aPho->et(), aPho->trkSumPtSolidConeDR04(), cut,type);
845  fill2DHistoVector(p_trackPtSumSolidVsEt_, aPho->et(), aPho->trkSumPtSolidConeDR04(), cut,type);
846  if (standAlone_) fill2DHistoVector(h_trackPtSumHollowVsEt_, aPho->et(), aPho->trkSumPtHollowConeDR04(),cut,type);
847  fill2DHistoVector(p_trackPtSumHollowVsEt_, aPho->et(), aPho->trkSumPtHollowConeDR04(),cut,type);
848  //calorimeter isolation variables
849 
850  fill2DHistoVector(h_ecalSum_,aPho->ecalRecHitSumEtConeDR04(),cut,type);
851  if(aPho->isEB()){fill2DHistoVector(h_ecalSumEBarrel_,aPho->ecalRecHitSumEtConeDR04(),cut,type);}
852  if(aPho->isEE()){fill2DHistoVector(h_ecalSumEEndcap_,aPho->ecalRecHitSumEtConeDR04(),cut,type);}
853  if (standAlone_) fill2DHistoVector(h_ecalSumVsEta_,aPho->eta(),aPho->ecalRecHitSumEtConeDR04(),cut,type);
854  fill2DHistoVector(p_ecalSumVsEta_,aPho->eta(),aPho->ecalRecHitSumEtConeDR04(),cut,type);
855  if (standAlone_) fill2DHistoVector(h_ecalSumVsEt_, aPho->et(), aPho->ecalRecHitSumEtConeDR04(),cut,type);
856  fill3DHistoVector(p_ecalSumVsEt_, aPho->et(), aPho->ecalRecHitSumEtConeDR04(),cut,type,part);
857 
859 
860  fill2DHistoVector(h_hcalSum_,aPho->hcalTowerSumEtConeDR04(),cut,type);
861  if(aPho->isEB()){fill2DHistoVector(h_hcalSumEBarrel_,aPho->hcalTowerSumEtConeDR04(),cut,type);}
862  if(aPho->isEE()){fill2DHistoVector(h_hcalSumEEndcap_,aPho->hcalTowerSumEtConeDR04(),cut,type);}
863  if (standAlone_) fill2DHistoVector(h_hcalSumVsEta_,aPho->eta(),aPho->hcalTowerSumEtConeDR04(),cut,type);
864  fill2DHistoVector(p_hcalSumVsEta_,aPho->eta(),aPho->hcalTowerSumEtConeDR04(),cut,type);
865  if (standAlone_) fill2DHistoVector(h_hcalSumVsEt_, aPho->et(), aPho->hcalTowerSumEtConeDR04(),cut,type);
866  fill3DHistoVector(p_hcalSumVsEt_, aPho->et(), aPho->hcalTowerSumEtConeDR04(),cut,type,part);
867 
868  fill3DHistoVector(h_hOverE_,aPho->hadronicOverEm(),cut,type,part);
869  fill2DHistoVector(p_hOverEVsEta_,aPho->eta(),aPho->hadronicOverEm(),cut,type);
870  fill2DHistoVector(p_hOverEVsEt_, aPho->et(), aPho->hadronicOverEm(),cut,type);
871 
872  fill3DHistoVector(h_h1OverE_,aPho->hadronicDepth1OverEm(),cut,type,part);
873  fill3DHistoVector(h_h2OverE_,aPho->hadronicDepth2OverEm(),cut,type,part);
874 
875  // filling pf isolation variables
876  if(aPho->isEB()) {
877  fill2DHistoVector( h_phoIsoBarrel_, aPho->photonIso(),cut,type);
878  fill2DHistoVector( h_chHadIsoBarrel_, aPho->chargedHadronIso(),cut,type);
879  fill2DHistoVector( h_nHadIsoBarrel_, aPho->neutralHadronIso(),cut,type);
880  }
881  if(aPho->isEE()) {
882  fill2DHistoVector( h_phoIsoEndcap_, aPho->photonIso(),cut,type);
883  fill2DHistoVector( h_chHadIsoEndcap_, aPho->chargedHadronIso(),cut,type);
884  fill2DHistoVector( h_nHadIsoEndcap_, aPho->neutralHadronIso(),cut,type);
885  }
886 
887  //filling photon histograms
888  nPho[cut][0][0]++;
889  nPho[cut][0][part]++;
890  if(type != 0)
891  {
892  nPho[cut][type][0]++;
893  nPho[cut][type][part]++;
894  }
895 
896  //energy variables
897 
898  fill3DHistoVector(h_phoE_, aPho->energy(),cut,type,part);
899  fill3DHistoVector(h_phoSigmaEoverE_, aPho->getCorrectedEnergyError(aPho->getCandidateP4type())/aPho->energy(),cut,type,part);
900 
901  if ( !isHeavyIon_) fill3DHistoVector(p_phoSigmaEoverEvsNVtx_, float(vtxH->size()), aPho->getCorrectedEnergyError(aPho->getCandidateP4type())/aPho->energy(),cut,type,part);
902 
903  fill3DHistoVector(h_phoEt_,aPho->et(), cut,type,part);
904 
905  //geometrical variables
906 
907  fill2DHistoVector(h_phoEta_,aPho->eta(),cut,type);
908  fill2DHistoVector(h_scEta_, aPho->superCluster()->eta(),cut,type);
909 
910  fill3DHistoVector(h_phoPhi_,aPho->phi(),cut,type,part);
911  fill3DHistoVector(h_scPhi_, aPho->superCluster()->phi(),cut,type,part);
912 
913  //shower shape variables
914 
915  fill3DHistoVector(h_r9_,aPho->r9(),cut,type,part);
916  if (standAlone_) fill2DHistoVector(h_r9VsEta_,aPho->eta(),aPho->r9(),cut,type);
917  fill2DHistoVector(p_r9VsEta_,aPho->eta(),aPho->r9(),cut,type);
918  if (standAlone_) fill2DHistoVector(h_r9VsEt_, aPho->et(), aPho->r9(),cut,type);
919  fill2DHistoVector(p_r9VsEt_, aPho->et(), aPho->r9(),cut,type);
920 
921  if (standAlone_) fill2DHistoVector(h_e1x5VsEta_,aPho->eta(),aPho->e1x5(),cut,type);
922  fill2DHistoVector(p_e1x5VsEta_,aPho->eta(),aPho->e1x5(),cut,type);
923  if (standAlone_) fill2DHistoVector(h_e1x5VsEt_, aPho->et(), aPho->e1x5(),cut,type);
924  fill2DHistoVector(p_e1x5VsEt_, aPho->et(), aPho->e1x5(),cut,type);
925 
926  if (standAlone_) fill2DHistoVector(h_e2x5VsEta_,aPho->eta(),aPho->e2x5(),cut,type);
927  fill2DHistoVector(p_e2x5VsEta_,aPho->eta(),aPho->e2x5(),cut,type);
928  if (standAlone_) fill2DHistoVector(h_e2x5VsEt_, aPho->et(), aPho->e2x5(),cut,type);
929  fill2DHistoVector(p_e2x5VsEt_, aPho->et(), aPho->e2x5(),cut,type);
930 
931  if (standAlone_) fill2DHistoVector(h_maxEXtalOver3x3VsEta_,aPho->eta(),aPho->maxEnergyXtal()/aPho->e3x3(),cut,type);
932  fill2DHistoVector(p_maxEXtalOver3x3VsEta_,aPho->eta(),aPho->maxEnergyXtal()/aPho->e3x3(),cut,type);
933  if (standAlone_) fill2DHistoVector(h_maxEXtalOver3x3VsEt_, aPho->et(), aPho->maxEnergyXtal()/aPho->e3x3(),cut,type);
934  fill2DHistoVector(p_maxEXtalOver3x3VsEt_, aPho->et(), aPho->maxEnergyXtal()/aPho->e3x3(),cut,type);
935 
936  if (standAlone_) fill2DHistoVector(h_r1x5VsEta_,aPho->eta(),aPho->r1x5(),cut,type);
937  fill2DHistoVector(p_r1x5VsEta_,aPho->eta(),aPho->r1x5(),cut,type);
938  if (standAlone_) fill2DHistoVector(h_r1x5VsEt_, aPho->et(), aPho->r1x5(),cut,type);
939  fill2DHistoVector(p_r1x5VsEt_, aPho->et(), aPho->r1x5(),cut,type);
940 
941  if (standAlone_) fill2DHistoVector(h_r2x5VsEta_,aPho->eta(),aPho->r2x5(),cut,type);
942  fill2DHistoVector(p_r2x5VsEta_,aPho->eta(),aPho->r2x5(),cut,type);
943  if (standAlone_) fill2DHistoVector(h_r2x5VsEt_, aPho->et(), aPho->r2x5(),cut,type);
944  fill2DHistoVector(p_r2x5VsEt_, aPho->et(), aPho->r2x5(),cut,type);
945 
946  fill3DHistoVector(h_phoSigmaIetaIeta_,aPho->sigmaIetaIeta(),cut,type,part);
947  if (standAlone_) fill2DHistoVector(h_sigmaIetaIetaVsEta_,aPho->eta(),aPho->sigmaIetaIeta(),cut,type);
948  fill2DHistoVector(p_sigmaIetaIetaVsEta_,aPho->eta(),aPho->sigmaIetaIeta(),cut,type);
949 
950  //filling histograms for photons containing a bad ECAL channel
951  bool atLeastOneDeadChannel=false;
952  for(reco::CaloCluster_iterator bcIt = aPho->superCluster()->clustersBegin();bcIt != aPho->superCluster()->clustersEnd(); ++bcIt) { //loop over basic clusters in SC
953  for(vector< pair<DetId, float> >::const_iterator rhIt = (*bcIt)->hitsAndFractions().begin();rhIt != (*bcIt)->hitsAndFractions().end(); ++rhIt) { //loop over rec hits in basic cluster
954 
955  for(EcalRecHitCollection::const_iterator it = ecalRecHitCollection.begin(); it != ecalRecHitCollection.end(); ++it) { //loop over all rec hits to find the right ones
956  if (rhIt->first == (*it).id() ) { //found the matching rechit
957  if ( (*it).recoFlag() == 9 ) { //has a bad channel
958  atLeastOneDeadChannel=true;
959  break;
960  }
961  }
962  }
963  }
964  }
965  if ( atLeastOneDeadChannel ) {
966  fill2DHistoVector(h_phoPhi_BadChannels_,aPho->phi(),cut,type);
967  fill2DHistoVector(h_phoEta_BadChannels_,aPho->eta(),cut,type);
968  fill2DHistoVector(h_phoEt_BadChannels_, aPho->et(), cut,type);
969  }
970 
971  // filling conversion-related histograms
972  if(aPho->hasConversionTracks()){
973  nConv[cut][0][0]++;
974  nConv[cut][0][part]++;
975  nConv[cut][type][0]++;
976  nConv[cut][type][part]++;
977  }
978 
979  //loop over conversions (don't forget, we're still inside the photon loop,
980  // i.e. these are all the conversions for this ONE photon, not for all the photons in the event)
981  reco::ConversionRefVector conversions = aPho->conversions();
982  for (unsigned int iConv=0; iConv<conversions.size(); iConv++) {
983 
984  reco::ConversionRef aConv=conversions[iConv];
985 
986  if ( aConv->nTracks() <2 ) continue;
987 
988  //fill histogram for denominator of vertex reconstruction efficiency plot
989  if(cut==0) h_phoEta_Vertex_->Fill(aConv->refittedPairMomentum().eta());
990 
991  if ( !(aConv->conversionVertex().isValid()) ) continue;
992 
993  float chi2Prob = ChiSquaredProbability( aConv->conversionVertex().chi2(), aConv->conversionVertex().ndof() );
994 
995  if(chi2Prob<0.0005) continue;
996 
997  fill2DHistoVector(h_vertexChi2Prob_,chi2Prob,cut,type);
998 
999  fill3DHistoVector(h_phoConvE_, aPho->energy(),cut,type,part);
1000  fill3DHistoVector(h_phoConvEt_,aPho->et(),cut,type,part);
1001  fill3DHistoVector(h_phoConvR9_,aPho->r9(),cut,type,part);
1002 
1003  if (cut==0 && isLoosePhoton){
1004  h_convEta_Loose_->Fill(aPho->eta());
1005  h_convEt_Loose_->Fill( aPho->et() );
1006  }
1007  if (cut==0 && isTightPhoton){
1008  h_convEta_Tight_->Fill(aPho->eta());
1009  h_convEt_Tight_->Fill( aPho->et() );
1010  }
1011 
1012  fill2DHistoVector(h_phoConvEta_,aConv->refittedPairMomentum().eta(),cut,type);
1013  fill3DHistoVector(h_phoConvPhi_,aConv->refittedPairMomentum().phi(),cut,type,part);
1014 
1015  //we use the photon position because we'll be dividing it by a photon histogram (not a conversion histogram)
1016  fill2DHistoVector(h_phoConvEtaForEfficiency_,aPho->eta(),cut,type);
1017  fill3DHistoVector(h_phoConvPhiForEfficiency_,aPho->phi(),cut,type,part);
1018 
1019  //vertex histograms
1020  double convR= sqrt(aConv->conversionVertex().position().perp2());
1021  double scalar = aConv->conversionVertex().position().x()*aConv->refittedPairMomentum().x() + aConv->conversionVertex().position().y()*aConv->refittedPairMomentum().y();
1022  if ( scalar < 0 ) convR= -convR;
1023 
1024  fill2DHistoVector(h_convVtxRvsZ_,aConv->conversionVertex().position().z(), convR,cut,type);//trying to "see" R-Z view of tracker
1025  fill2DHistoVector(h_convVtxZ_,aConv->conversionVertex().position().z(), cut,type);
1026 
1027 
1028  if( fabs(aPho->eta()) > 1.5){//trying to "see" tracker endcaps
1029  fill2DHistoVector(h_convVtxZEndcap_,aConv->conversionVertex().position().z(), cut,type);
1030  }
1031  else if(fabs(aPho->eta()) < 1){//trying to "see" tracker barrel
1032  fill2DHistoVector(h_convVtxR_,convR,cut,type);
1033  fill2DHistoVector(h_convVtxYvsX_,aConv->conversionVertex().position().x(),aConv->conversionVertex().position().y(),cut,type);
1034  }
1035 
1036 
1037  const std::vector<edm::RefToBase<reco::Track> > tracks = aConv->tracks();
1038 
1039 
1040  for (unsigned int i=0; i<tracks.size(); i++) {
1041  fill2DHistoVector(h_tkChi2_,tracks[i]->normalizedChi2(),cut,type);
1042  fill2DHistoVector(p_tkChi2VsEta_,aPho->eta(),tracks[i]->normalizedChi2(),cut,type);
1043  fill2DHistoVector(p_dCotTracksVsEta_,aPho->eta(),aConv->pairCotThetaSeparation(),cut,type);
1044  fill2DHistoVector(p_nHitsVsEta_,aPho->eta(),float(tracks[i]->numberOfValidHits()),cut,type);
1045  }
1046 
1047  //calculating delta eta and delta phi of the two tracks
1048 
1049  float DPhiTracksAtVtx = -99;
1050  float dPhiTracksAtEcal= -99;
1051  float dEtaTracksAtEcal= -99;
1052 
1053  float phiTk1= aConv->tracksPin()[0].phi();
1054  float phiTk2= aConv->tracksPin()[1].phi();
1055  DPhiTracksAtVtx = phiTk1-phiTk2;
1056  DPhiTracksAtVtx = phiNormalization( DPhiTracksAtVtx );
1057 
1058  if (aConv->bcMatchingWithTracks().size() > 0 && aConv->bcMatchingWithTracks()[0].isNonnull() && aConv->bcMatchingWithTracks()[1].isNonnull() ) {
1059  float recoPhi1 = aConv->ecalImpactPosition()[0].phi();
1060  float recoPhi2 = aConv->ecalImpactPosition()[1].phi();
1061  float recoEta1 = aConv->ecalImpactPosition()[0].eta();
1062  float recoEta2 = aConv->ecalImpactPosition()[1].eta();
1063 
1064  recoPhi1 = phiNormalization(recoPhi1);
1065  recoPhi2 = phiNormalization(recoPhi2);
1066 
1067  dPhiTracksAtEcal = recoPhi1 -recoPhi2;
1068  dPhiTracksAtEcal = phiNormalization( dPhiTracksAtEcal );
1069  dEtaTracksAtEcal = recoEta1 -recoEta2;
1070  }
1071 
1072  fill3DHistoVector(h_dPhiTracksAtVtx_,DPhiTracksAtVtx,cut,type,part);
1073  fill3DHistoVector(h_dPhiTracksAtEcal_,fabs(dPhiTracksAtEcal),cut,type,part);
1074  fill3DHistoVector(h_dEtaTracksAtEcal_, dEtaTracksAtEcal,cut,type,part);
1075  fill3DHistoVector(h_eOverPTracks_,aConv->EoverPrefittedTracks(),cut,type,part);
1076  fill3DHistoVector(h_pOverETracks_,1./aConv->EoverPrefittedTracks(),cut,type,part);
1077  fill3DHistoVector(h_dCotTracks_,aConv->pairCotThetaSeparation(),cut,type,part);
1078  }//end loop over conversions
1079  }//end loop over photons passing cuts
1080  }//end loop over transverse energy cuts
1081 
1082  //make invariant mass plots
1083 
1084  if (isIsolated && aPho->et()>=invMassEtCut_){
1085  for(unsigned int iPho2=iPho+1; iPho2 < photonHandle->size(); iPho2++) {
1086  const reco::Photon* aPho2 = &photonCollection[iPho2];
1087 
1088  // for (reco::PhotonCollection::const_iterator iPho2=iPho+1; iPho2!=photonCollection.end(); iPho2++){
1089 
1090  // edm::Ref<reco::PhotonCollection> photonref2(photonHandle, photonCounter); //note: it's correct to use photonCounter and not photonCounter+1
1091  //since it has already been incremented earlier
1092 
1093  bool isTightPhoton2(false), isLoosePhoton2(false);
1094  if ( photonSelection (aPho2) ) isLoosePhoton2=true;
1095 
1096  // Old if ( !isHeavyIon_ ) {
1097  // isTightPhoton2 = (tightPhotonID)[aPho2];
1098  // isLoosePhoton2 = (loosePhotonID)[aPho2];
1099  // }
1100 
1101  bool isIsolated2=false;
1102  if ( isolationStrength_ == 0) isIsolated2 = isLoosePhoton2;
1103  if ( isolationStrength_ == 1) isIsolated2 = isTightPhoton2;
1104 
1105  reco::ConversionRefVector conversions = aPho->conversions();
1106  reco::ConversionRefVector conversions2 = aPho2->conversions();
1107 
1108  if(isIsolated2 && aPho2->et()>=invMassEtCut_){
1109 
1110  math::XYZTLorentzVector p12 = aPho->p4()+aPho2->p4();
1111  float gamgamMass2 = p12.Dot(p12);
1112 
1113 
1114  h_invMassAllPhotons_ -> Fill(sqrt( gamgamMass2 ));
1115  if(aPho->isEB() && aPho2->isEB()){h_invMassPhotonsEBarrel_ -> Fill(sqrt( gamgamMass2 ));}
1116  if(aPho->isEE() || aPho2->isEE()){h_invMassPhotonsEEndcap_ -> Fill(sqrt( gamgamMass2 ));}
1117 
1118  if(conversions.size()!=0 && conversions[0]->nTracks() >= 2){
1119  if(conversions2.size()!=0 && conversions2[0]->nTracks() >= 2) h_invMassTwoWithTracks_ -> Fill(sqrt( gamgamMass2 ));
1120  else h_invMassOneWithTracks_ -> Fill(sqrt( gamgamMass2 ));
1121  }
1122  else if(conversions2.size()!=0 && conversions2[0]->nTracks() >= 2) h_invMassOneWithTracks_ -> Fill(sqrt( gamgamMass2 ));
1123  else h_invMassZeroWithTracks_ -> Fill(sqrt( gamgamMass2 ));
1124  }
1125  }
1126  }
1127  }
1128 
1129  //filling number of photons/conversions per event histograms
1130  for (int cut = 0; cut !=numberOfSteps_; ++cut) {
1131  for(uint type=0;type!=types_.size();++type){
1132  for(uint part=0;part!=parts_.size();++part){
1133  h_nPho_[cut][type][part]-> Fill (float(nPho[cut][type][part]));
1134  h_nConv_[cut][type][part]-> Fill (float(nConv[cut][type][part]));
1135  }
1136  }
1137  }
1138 }//End of Analyze method
1139 
1141 
1142 float PhotonAnalyzer::phiNormalization(float & phi)
1143 {
1144  const float PI = 3.1415927;
1145  const float TWOPI = 2.0*PI;
1146 
1147  if(phi > PI) {phi = phi - TWOPI;}
1148  if(phi < -PI) {phi = phi + TWOPI;}
1149 
1150  return phi;
1151 }
1152 
1153 void PhotonAnalyzer::fill2DHistoVector(vector<vector<MonitorElement*> >& histoVector,double x, double y, int cut, int type)
1154 {
1155  histoVector[cut][0]->Fill(x,y);
1156  if(histoVector[cut].size()>1) histoVector[cut][type]->Fill(x,y); //don't try to fill 2D histos that are only in the "AllPhotons" folder
1157 }
1158 
1159 void PhotonAnalyzer::fill2DHistoVector(vector<vector<MonitorElement*> >& histoVector, double x, int cut, int type)
1160 {
1161  histoVector[cut][0]->Fill(x);
1162  histoVector[cut][type]->Fill(x);
1163 }
1164 
1165 void PhotonAnalyzer::fill3DHistoVector(vector<vector<vector<MonitorElement*> > >& histoVector,double x, int cut, int type, int part)
1166 {
1167  histoVector[cut][0][0]->Fill(x);
1168  histoVector[cut][0][part]->Fill(x);
1169  histoVector[cut][type][0]->Fill(x);
1170  histoVector[cut][type][part]->Fill(x);
1171 }
1172 
1173 void PhotonAnalyzer::fill3DHistoVector(vector<vector<vector<MonitorElement*> > >& histoVector,double x, double y, int cut, int type, int part)
1174 {
1175  histoVector[cut][0][0]->Fill(x,y);
1176  histoVector[cut][0][part]->Fill(x,y);
1177  histoVector[cut][type][0]->Fill(x,y);
1178  histoVector[cut][type][part]->Fill(x,y);
1179 }
1180 
1181 bool PhotonAnalyzer::photonSelection(const reco::Photon* pho)
1182 {
1183  bool result=true;
1184  if ( pho->pt() < minPhoEtCut_ ) result=false;
1185  if ( fabs(pho->eta()) > photonMaxEta_ ) result=false;
1186  if ( pho->isEBEEGap() ) result=false;
1187 
1188  double EtCorrHcalIso = pho->hcalTowerSumEtConeDR03() - 0.005*pho->pt();
1189  double EtCorrTrkIso = pho->trkSumPtHollowConeDR03() - 0.002*pho->pt();
1190 
1191  if (pho->r9() <=0.9) {
1192  if (pho->isEB() && (pho->hadTowOverEm()>0.075 || pho->sigmaIetaIeta() > 0.014)) result=false;
1193  if (pho->isEE() && (pho->hadTowOverEm()>0.075 || pho->sigmaIetaIeta() > 0.034)) result=false;
1195  if (EtCorrHcalIso>4.0) result=false;
1196  if (EtCorrTrkIso>4.0) result=false ;
1197  if ( pho->chargedHadronIso() > 4 ) result=false;
1198  } else {
1199  if (pho->isEB() && (pho->hadTowOverEm()>0.082 || pho->sigmaIetaIeta() > 0.014)) result=false;
1200  if (pho->isEE() && (pho->hadTowOverEm()>0.075 || pho->sigmaIetaIeta() > 0.034)) result=false;
1202  if (EtCorrHcalIso>50.0) result=false;
1203  if (EtCorrTrkIso>50.0) result=false;
1204  if ( pho->chargedHadronIso() > 4 ) result=false;
1205  }
1206  return result;
1207 }
findQualityFiles.size
size
Write out results.
Definition: findQualityFiles.py:442
PhotonAnalyzer::photonSelection
bool photonSelection(const reco::Photon *p)
Definition: PhotonAnalyzer.cc:1181
type
type
Definition: HCALResponse.h:21
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
reco::LeafCandidate::pt
virtual double pt() const final
transverse momentum
Definition: LeafCandidate.h:131
edm::ParameterSet::getUntrackedParameter
T getUntrackedParameter(std::string const &, T const &) const
PhotonAnalyzer::bookHistogramsPhotons
void bookHistogramsPhotons(DQMStore::IBooker &)
Definition: PhotonAnalyzer.cc:242
reco::Photon::hcalTowerSumEtConeDR04
float hcalTowerSumEtConeDR04() const
Hcal isolation sum.
Definition: Photon.h:406
edm::Ref::isNonnull
bool isNonnull() const
Checks for non-null.
Definition: Ref.h:252
mps_fire.i
i
Definition: mps_fire.py:156
reco::Photon::isEE
bool isEE() const
Definition: Photon.h:123
trigger::TriggerEvent
The single EDProduct to be saved for each event (AOD case)
Definition: TriggerEvent.h:25
trigger::TriggerEvent::sizeFilters
trigger::size_type sizeFilters() const
Definition: TriggerEvent.h:135
reco::Photon::chargedHadronIso
float chargedHadronIso() const
Accessors for Particle Flow Isolation variables.
Definition: Photon.h:484
reco::Photon::superCluster
reco::SuperClusterRef superCluster() const
Ref to SuperCluster.
mps_fire.result
result
Definition: mps_fire.py:113
reco::Photon::neutralHadronIso
float neutralHadronIso() const
Definition: Photon.h:486
reco::Photon::hcalTowerSumEtConeDR03
float hcalTowerSumEtConeDR03() const
Hcal isolation sum.
Definition: Photon.h:429
DQMStore::IBooker::bookProfile
MonitorElement * bookProfile(Args &&...args)
Definition: DQMStore.h:157
deltaRMax
double deltaRMax
Definition: PFJetBenchmarkAnalyzer.cc:75
reco::LeafCandidate::eta
virtual double eta() const final
momentum pseudorapidity
Definition: LeafCandidate.h:137
edm::Event::getByToken
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:457
TrackerOfflineValidation_Dqm_cff.xmin
xmin
Definition: TrackerOfflineValidation_Dqm_cff.py:10
hpstanc_transforms.max
max
Definition: hpstanc_transforms.py:5
DQMStore::IBooker::pwd
const std::string & pwd(void)
Definition: DQMStore.cc:285
reco::Photon::trkSumPtSolidConeDR04
float trkSumPtSolidConeDR04() const
Definition: Photon.h:418
trigger::TriggerEvent::filterKeys
const Keys & filterKeys(trigger::size_type index) const
Definition: TriggerEvent.h:111
DQMStore::IBooker::bookInt
MonitorElement * bookInt(Args &&...args)
Definition: DQMStore.h:103
edm::SortedCollection< EcalRecHit >::const_iterator
std::vector< EcalRecHit >::const_iterator const_iterator
Definition: SortedCollection.h:82
reco::Photon::e1x5
float e1x5() const
Shower shape variables.
Definition: Photon.h:219
reco::Photon::isEBEEGap
bool isEBEEGap() const
true if photon is in boundary between EB and EE
Definition: Photon.h:133
muonDTDigis_cfi.pset
pset
Definition: muonDTDigis_cfi.py:27
reco::Photon::ecalRecHitSumEtConeDR04
float ecalRecHitSumEtConeDR04() const
Definition: Photon.h:404
Phase2TrackerMonitorDigi_cff.ymin
ymin
Definition: Phase2TrackerMonitorDigi_cff.py:21
MillePedeFileConverter_cfg.e
e
Definition: MillePedeFileConverter_cfg.py:37
reco::Photon::trkSumPtHollowConeDR03
float trkSumPtHollowConeDR03() const
Definition: Photon.h:443
PhotonAnalyzer::fill3DHistoVector
void fill3DHistoVector(std::vector< std::vector< std::vector< MonitorElement * > > > &histoVector, double x, int cut, int type, int part)
correctedPhotons_cfi.photonCollection
photonCollection
Definition: correctedPhotons_cfi.py:12
PhotonAnalyzer::bookHistogramsConversions
void bookHistogramsConversions(DQMStore::IBooker &)
Definition: PhotonAnalyzer.cc:428
conversions_cfi.conversions
conversions
Definition: conversions_cfi.py:8
reco::Photon::photonIso
float photonIso() const
Definition: Photon.h:487
reco::Photon::hadronicDepth2OverEm
float hadronicDepth2OverEm() const
the hadronic release in depth2 over electromagnetic fraction
Definition: Photon.h:208
reco::LeafCandidate::phi
virtual double phi() const final
momentum azimuthal angle
Definition: LeafCandidate.h:133
math::XYZTLorentzVector
XYZTLorentzVectorD XYZTLorentzVector
Lorentz vector with cylindrical internal representation using pseudorapidity.
Definition: LorentzVector.h:29
x
T x() const
Cartesian x coordinate.
Definition: Basic3DVectorLD.h:127
reco::LeafCandidate::et
virtual double et() const final
transverse energy
Definition: LeafCandidate.h:112
PhotonAnalyzer::bookHisto
MonitorElement * bookHisto(DQMStore::IBooker &, std::string histoName, std::string title, int bin, double min, double max)
Definition: PhotonAnalyzer.cc:470
PhotonAnalyzer::fill2DHistoVector
void fill2DHistoVector(std::vector< std::vector< MonitorElement * > > &histoVector, double x, int cut, int type)
PhotonAnalyzer::fillHistogramsForHistogramCounts
void fillHistogramsForHistogramCounts(DQMStore::IBooker &)
Definition: PhotonAnalyzer.cc:168
PhotonAnalyzer::analyze
virtual void analyze(const edm::Event &, const edm::EventSetup &) override
Definition: PhotonAnalyzer.cc:607
reco::Photon::conversions
reco::ConversionRefVector conversions() const
vector of references to Conversion&#39;s
Definition: Photon.h:64
trigger::TriggerEvent::getObjects
const TriggerObjectCollection & getObjects() const
Definition: TriggerEvent.h:98
HcalObjRepresent::Fill
void Fill(HcalDetId &id, double val, std::vector< TH2F > &depth)
Definition: HcalObjRepresent.h:611
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:18
reco::Photon::sigmaIetaIeta
float sigmaIetaIeta() const
Definition: Photon.h:225
reco::LeafCandidate::energy
virtual double energy() const final
energy
Definition: LeafCandidate.h:110
DQMStore::IBooker::book1D
MonitorElement * book1D(Args &&...args)
Definition: DQMStore.h:115
TWOPI
#define TWOPI
EgammaCoreTools.
Definition: DQMSourcePi0.cc:40
reco::deltaR
auto deltaR(const T1 &t1, const T2 &t2) -> decltype(t1.eta())
Definition: deltaR.h:28
reco::Photon::e2x5
float e2x5() const
Definition: Photon.h:220
ChiSquaredProbability
float ChiSquaredProbability(double chiSquared, double nrDOF)
Definition: ChiSquaredProbability.cc:13
reco::Photon::hadTowOverEm
float hadTowOverEm() const
the ration of hadronic energy in towers behind the BCs in the SC and the SC energy ...
Definition: Photon.h:211
reco::Photon::nTrkHollowConeDR04
int nTrkHollowConeDR04() const
Definition: Photon.h:424
min
T min(T a, T b)
Definition: MathUtil.h:58
reco::Photon::hadronicOverEm
float hadronicOverEm() const
the total hadronic over electromagnetic fraction
Definition: Photon.h:204
Phase2TrackerMonitorDigi_cff.ymax
ymax
Definition: Phase2TrackerMonitorDigi_cff.py:22
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:74
PI
#define PI
Definition: QcdUeDQM.h:36
PhotonAnalyzer::bookHistogramsInvMass
void bookHistogramsInvMass(DQMStore::IBooker &)
Definition: PhotonAnalyzer.cc:226
reco::Photon::r1x5
float r1x5() const
Definition: Photon.h:226
PhotonAnalyzer::phiNormalization
float phiNormalization(float &a)
Definition: PhotonAnalyzer.cc:1142
reco::Photon::getCorrectedEnergyError
float getCorrectedEnergyError(P4type type) const
reco::Photon::getCandidateP4type
P4type getCandidateP4type() const
Definition: Photon.h:306
stringResolutionProvider_cfi.bin
bin
set the eta bin as selection string.
Definition: stringResolutionProvider_cfi.py:11
edm::SortedCollection::end
const_iterator end() const
Definition: SortedCollection.h:310
deltaR
double deltaR(double eta1, double eta2, double phi1, double phi2)
Definition: TreeUtility.cc:17
reco::Photon::hadronicDepth1OverEm
float hadronicDepth1OverEm() const
the hadronic release in depth1 over electromagnetic fraction
Definition: Photon.h:206
PhotonAnalyzer::~PhotonAnalyzer
virtual ~PhotonAnalyzer()
Definition: PhotonAnalyzer.cc:140
reco::Photon::hasConversionTracks
bool hasConversionTracks() const
Bool flagging photons with a vector of refereces to conversions with size >0.
Definition: Photon.h:72
trigger::TriggerEvent::filterTag
const edm::InputTag filterTag(trigger::size_type index) const
Definition: TriggerEvent.h:103
PhotonAnalyzer::book3DHistoVector
void book3DHistoVector(DQMStore::IBooker &, std::vector< std::vector< std::vector< MonitorElement * > > > &toFill, std::string histoType, std::string histoName, std::string title, int xbin, double xmin, double xmax, int ybin=1, double ymin=1, double ymax=2)
Definition: PhotonAnalyzer.cc:551
reco::Photon::e3x3
float e3x3() const
Definition: Photon.h:221
DQMStore::IBooker::setCurrentFolder
void setCurrentFolder(const std::string &fullpath)
Definition: DQMStore.cc:277
TrackerOfflineValidation_Dqm_cff.xmax
xmax
Definition: TrackerOfflineValidation_Dqm_cff.py:11
edm::Handle::product
T const * product() const
Definition: Handle.h:81
DQMStore::IBooker::book2D
MonitorElement * book2D(Args &&...args)
Definition: DQMStore.h:133
trigger::Keys
std::vector< size_type > Keys
Definition: TriggerTypeDefs.h:20
part
part
Definition: HCALResponse.h:20
reco::PhotonCollection
std::vector< Photon > PhotonCollection
collectin of Photon objects
Definition: PhotonFwd.h:9
PhotonAnalyzer::bookHistograms
void bookHistograms(DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override
Definition: PhotonAnalyzer.cc:144
reco::Photon::nTrkSolidConeDR04
int nTrkSolidConeDR04() const
Definition: Photon.h:422
reco::Photon::p4
const LorentzVector & p4(P4type type) const
edm::InputTag::label
std::string const & label() const
Definition: InputTag.h:36
reco::Photon::isEB
bool isEB() const
Definition: Photon.h:121
reco::Photon::trkSumPtHollowConeDR04
float trkSumPtHollowConeDR04() const
Definition: Photon.h:420
reco::Photon::r2x5
float r2x5() const
Definition: Photon.h:227
fftjetcommon_cfi.title
title
Definition: fftjetcommon_cfi.py:32
edm::EventBase::id
edm::EventID id() const
Definition: EventBase.h:58
edm
HLT enums.
Definition: AlignableModifier.h:17
PhotonAnalyzer::bookHistogramsForHistogramCounts
void bookHistogramsForHistogramCounts(DQMStore::IBooker &)
Definition: PhotonAnalyzer.cc:158
reco::Photon::r9
float r9() const
Definition: Photon.h:228
TkAlMuonSelectors_cfi.cut
cut
Definition: TkAlMuonSelectors_cfi.py:5
PFJetFilter_cfi.deltaRMin
deltaRMin
Definition: PFJetFilter_cfi.py:16
edm::RefVector::size
size_type size() const
Size of the RefVector.
Definition: RefVector.h:107
gather_cfg.cout
cout
Definition: gather_cfg.py:145
PhotonAnalyzer::book2DHistoVector
void book2DHistoVector(DQMStore::IBooker &, std::vector< std::vector< MonitorElement * > > &toFill, std::string histoType, std::string histoName, std::string title, int xbin, double xmin, double xmax, int ybin=1, double ymin=1, double ymax=2)
Definition: PhotonAnalyzer.cc:494
PhotonAnalyzer::bookHistogramsEfficiency
void bookHistogramsEfficiency(DQMStore::IBooker &)
Definition: PhotonAnalyzer.cc:177
PhotonAnalyzer::PhotonAnalyzer
PhotonAnalyzer(const edm::ParameterSet &)
Definition: PhotonAnalyzer.cc:20
edm::SortedCollection::begin
const_iterator begin() const
Definition: SortedCollection.h:303
edm::Run
Definition: Run.h:42
hitfit::scalar
double scalar(const CLHEP::HepGenMatrix &m)
Return the matrix as a scalar. Raise an assertion if the matris is not .
Definition: matutil.cc:183
reco::Photon::maxEnergyXtal
float maxEnergyXtal() const
Definition: Photon.h:223
Generated for CMSSW Reference Manual by doxygen 1.8.11