ViewVC Help
View File | Revision Log | Show Annotations | Root Listing
root/cvsroot/UserCode/yangyong/zSelection/RecoAnalyzer.h
Revision: 1.1
Committed: Fri Sep 30 15:23:48 2011 UTC (13 years, 7 months ago) by yangyong
Content type: text/plain
Branch: MAIN
CVS Tags: V01-00-01, V01-00-00, HEAD
Error occurred while calculating annotation data.
Log Message: 
z selection code

File Contents

# Content
1
2 /* // system include files */
3 /* #include <memory> */
4
5 /* // user include files */
6 /* #include "FWCore/Framework/interface/Frameworkfwd.h" */
7 /* #include "FWCore/Framework/interface/EDAnalyzer.h" */
8
9 /* #include "FWCore/Framework/interface/Event.h" */
10 /* #include "FWCore/Framework/interface/MakerMacros.h" */
11
12 /* #include "FWCore/ParameterSet/interface/ParameterSet.h" */
13 /* // */
14 /* // class declaration */
15 /* // */
16
17
18 /* //GEN */
19 /* #include "SimDataFormats/GeneratorProducts/interface/GenEventInfoProduct.h" */
20 /* #include "SimDataFormats/GeneratorProducts/interface/HepMCProduct.h" */
21 /* #include "DataFormats/HepMCCandidate/interface/GenParticle.h" */
22 /* #include "SimDataFormats/GeneratorProducts/interface/PdfInfo.h" */
23
24
25 /* ////SimTrack */
26 /* #include "SimDataFormats/Track/interface/SimTrack.h" */
27 /* #include "SimDataFormats/Track/interface/SimTrackContainer.h" */
28 /* #include "SimDataFormats/Vertex/interface/SimVertexContainer.h" */
29
30
31 /* //BEamSpot */
32 /* #include "DataFormats/BeamSpot/interface/BeamSpot.h" */
33
34
35 /* //Track */
36 /* #include "DataFormats/TrackReco/interface/Track.h" */
37 /* #include "DataFormats/TrackCandidate/interface/TrackCandidateCollection.h" */
38 /* #include "DataFormats/TrackCandidate/interface/TrackCandidate.h" */
39 /* #include "DataFormats/TrackReco/interface/Track.h" */
40 /* #include "DataFormats/TrackReco/interface/TrackFwd.h" */
41
42 /* //HLT */
43 /* #include "DataFormats/HLTReco/interface/TriggerEvent.h" */
44 /* #include "DataFormats/HLTReco/interface/TriggerObject.h" */
45 /* #include "DataFormats/Common/interface/TriggerResults.h" */
46 /* #include "DataFormats/HLTReco/interface/TriggerTypeDefs.h" */
47 /* #include "DataFormats/HLTReco/interface/TriggerEventWithRefs.h" */
48 /* #include "HLTrigger/HLTcore/interface/HLTConfigProvider.h" */
49
50
51 /* //L1 Trigger */
52 /* #include "DataFormats/L1Trigger/interface/L1EmParticle.h" */
53 /* #include "DataFormats/L1Trigger/interface/L1JetParticle.h" */
54 /* #include "DataFormats/L1Trigger/interface/L1MuonParticle.h" */
55 /* #include "DataFormats/L1Trigger/interface/L1EtMissParticle.h" */
56 /* #include "DataFormats/L1Trigger/interface/L1ParticleMapFwd.h" */
57 /* #include "DataFormats/L1Trigger/interface/L1ParticleMap.h" */
58 /* #include "L1Trigger/L1ExtraFromDigis/interface/L1ExtraParticleMapProd.h" */
59 /* #include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerReadoutRecord.h" */
60 /* #include "DataFormats/L1GlobalTrigger/interface/L1GtFdlWord.h" */
61
62
63
64 /* ///MET */
65 /* #include "DataFormats/METReco/interface/CaloMET.h" */
66 /* #include "DataFormats/METReco/interface/CaloMETFwd.h" */
67 /* #include "DataFormats/METReco/interface/MET.h" */
68 /* #include "DataFormats/METReco/interface/METFwd.h" */
69 /* #include "DataFormats/METReco/interface/PFMET.h" */
70 /* #include "DataFormats/METReco/interface/PFMETFwd.h" */
71
72 /* ///muon */
73 /* #include "DataFormats/MuonReco/interface/MuonCocktails.h" */
74 /* #include "RecoMuon/TrackingTools/interface/MuonServiceProxy.h" */
75 /* #include "DataFormats/MuonReco/interface/Muon.h" */
76 /* #include "DataFormats/MuonReco/interface/MuonFwd.h" */
77 /* #include "DataFormats/MuonReco/interface/MuonSelectors.h" */
78 /* #include "DataFormats/MuonReco/interface/MuonTime.h" */
79 /* #include "DataFormats/MuonReco/interface/MuonTimeExtra.h" */
80 /* #include "DataFormats/MuonReco/interface/MuonTimeExtraMap.h" */
81 /* #include "DataFormats/MuonReco/interface/MuonCosmicCompatibility.h" */
82
83 /* ///ECAL */
84 /* #include "RecoLocalCalo/EcalRecAlgos/interface/EcalSeverityLevelAlgo.h" */
85 /* #include "RecoEcal/EgammaCoreTools/interface/EcalClusterLazyTools.h" */
86 /* #include "CondFormats/DataRecord/interface/EcalChannelStatusRcd.h" */
87 /* #include "CondFormats/EcalObjects/interface/EcalTimeCalibConstants.h" */
88 /* #include "CalibCalorimetry/EcalLaserCorrection/interface/EcalLaserDbRecord.h" */
89 /* #include "CondFormats/EcalObjects/interface/EcalIntercalibConstants.h" */
90 /* #include "CondFormats/EcalObjects/interface/EcalTimeCalibConstants.h" */
91 /* #include "CondFormats/EcalObjects/interface/EcalADCToGeVConstant.h" */
92 /* #include "CondFormats/EcalObjects/interface/EcalChannelStatus.h" */
93 /* #include "CalibCalorimetry/EcalLaserCorrection/interface/EcalLaserDbService.h" */
94 /* #include "RecoLocalCalo/EcalRecAlgos/interface/EcalSeverityLevelAlgo.h" */
95 /* #include "RecoLocalCalo/EcalRecAlgos/interface/EcalSeverityLevelAlgoRcd.h" */
96 /* #include "RecoEcal/EgammaCoreTools/interface/EcalTools.h" */
97 /* #include "DataFormats/CaloRecHit/interface/CaloCluster.h" */
98
99
100 /* //IsoDep */
101 /* #include "DataFormats/RecoCandidate/interface/IsoDeposit.h" */
102 /* #include "DataFormats/RecoCandidate/interface/IsoDepositFwd.h" */
103 /* #include "DataFormats/RecoCandidate/interface/IsoDepositDirection.h" */
104
105
106 /* ///vertex */
107 /* #include "DataFormats/VertexReco/interface/Vertex.h" */
108 /* #include "DataFormats/VertexReco/interface/VertexFwd.h" */
109
110
111 /* ///caloCluster */
112 /* #include "DataFormats/CaloRecHit/interface/CaloCluster.h" */
113 /* #include "DataFormats/CaloRecHit/interface/CaloClusterFwd.h" */
114
115
116 /* //covnersion */
117 /* #include "DataFormats/EgammaCandidates/interface/Conversion.h" */
118 /* #include "DataFormats/EgammaCandidates/interface/ConversionFwd.h" */
119 /* #include "RecoEgamma/EgammaTools/interface/ConversionTools.h" */
120
121
122 /* ///Egamma */
123 /* #include "DataFormats/EgammaCandidates/interface/PhotonFwd.h" */
124 /* #include "DataFormats/EgammaCandidates/interface/Photon.h" */
125 /* #include "DataFormats/EgammaCandidates/interface/GsfElectronFwd.h" */
126 /* #include "DataFormats/EgammaCandidates/interface/GsfElectron.h" */
127 /* #include "DataFormats/GsfTrackReco/interface/GsfTrackFwd.h" */
128 /* #include "DataFormats/GsfTrackReco/interface/GsfTrack.h" */
129
130
131 /* //PU */
132 /* #include "SimDataFormats/PileupSummaryInfo/interface/PileupSummaryInfo.h" */
133
134 /* //Jet */
135 /* #include "DataFormats/JetReco/interface/Jet.h" */
136 /* #include "DataFormats/JetReco/interface/CaloJetCollection.h" */
137 /* #include "DataFormats/JetReco/interface/GenJet.h" */
138 /* #include "RecoJets/JetProducers/interface/JetIDHelper.h" */
139 /* #include "JetMETCorrections/Objects/interface/JetCorrector.h" */
140 /* #include "DataFormats/JetReco/interface/PFJetCollection.h" */
141
142
143 /* ///CommonTools */
144 /* #include "CommonTools/Statistics/interface/ChiSquaredProbability.h" */
145
146 /* ///ROOT */
147 /* #include "TROOT.h" */
148 /* #include "TFile.h" */
149 /* #include "TTree.h" */
150 /* #include "TBranch.h" */
151 /* #include "TLorentzVector.h" */
152 /* #include "TClonesArray.h" */
153
154 /* #include "TMatrixDSym.h" */
155 /* #include "TMatrixDSymEigen.h" */
156 /* #include "TVectorD.h" */
157
158 /* ///c++ */
159 /* #include <boost/foreach.hpp> */
160 /* #include <vector> */
161 /* #include <ext/algorithm> */
162 /* #include <numeric> */
163 /* #include <iterator> */
164 /* #include <algorithm> */
165
166
167 /* using namespace std; */
168 /* using namespace edm; */
169
170
171 /* class RecoAnalyzer : public edm::EDAnalyzer { */
172 /* public: */
173 /* explicit RecoAnalyzer(const edm::ParameterSet&); */
174 /* ~RecoAnalyzer(); */
175
176 /* static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); */
177
178
179
180
181 /* private: */
182 /* virtual void beginJob() ; */
183 /* virtual void analyze(const edm::Event&, const edm::EventSetup&); */
184 /* virtual void endJob() ; */
185
186 /* virtual void beginRun(edm::Run const&, edm::EventSetup const&); */
187 /* virtual void endRun(edm::Run const&, edm::EventSetup const&); */
188 /* virtual void beginLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&); */
189 /* virtual void endLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&); */
190
191 /* // ----------member data --------------------------- */
192 /* double DeltaPhi(double v1, double v2); */
193 /* double GetDeltaR(double eta1, double eta2, double phi1, double phi2); */
194 /* int indexofParticle(float px, float pz, int status); */
195 /* int getMotherIndex(int ); */
196 /* void MatchToGenMuon(float eta, float phi, float res[]); */
197 /* void MatchToGenElectron(float eta, float phi, float res[]); */
198 /* void MatchToGenPhoton(float eta, float phi, float res[]); */
199 /* int partonMatchingAlgo(float,float,float); */
200 /* int partonMatchingPhys(float,float); */
201 /* int findIndexofSC(float en,float eta,float phi); */
202 /* int findIndexofTRK(float, float, float); */
203 /* double mye2overe9( const DetId id, const EcalRecHitCollection & recHits); */
204 /* float recHitE( const DetId id, const EcalRecHitCollection &recHits ); */
205 /* float recHitE( const DetId id, const EcalRecHitCollection & recHits,int di, int dj ); */
206 /* float recHitApproxEt( const DetId id, const EcalRecHitCollection &recHits ); */
207 /* TLorentzVector photonp4wrtvertex(int, int); */
208 /* double etaTransformation( float EtaParticle , float Zvertex); */
209 /* int matchPhotonToConversion( int lpho); */
210 /* void higgsVertexAnalysis(int, int); */
211 /* double HggVertexFromConversionsvtxZ(int j); */
212 /* double HggVertexFromConversionsvtxdZ(int j); */
213 /* bool filter(const edm::Event& iEvent, const edm::EventSetup& iSetup); */
214
215 /* struct LessById { */
216 /* bool operator()(const SimTrack &tk1, const SimTrack &tk2) const { return tk1.trackId() < tk2.trackId(); } */
217 /* bool operator()(const SimTrack &tk1, unsigned int id ) const { return tk1.trackId() < id; } */
218 /* bool operator()(unsigned int id, const SimTrack &tk2) const { return id < tk2.trackId(); } */
219 /* }; */
220
221
222 /* edm::InputTag trigResultTag_; */
223 /* edm::InputTag trigSummaryTag_; */
224 /* int debug_; */
225 /* HLTConfigProvider configProvider; */
226
227
228
229 /* ///all inuptTag start with "m_xxx" */
230 /* edm::InputTag m_vertexSrc; //offlinePV */
231 /* edm::InputTag m_vertexSrc2; //offlinwPVwithBS */
232 /* edm::InputTag m_tracksSrc; ///general track */
233 /* edm::InputTag m_beamSpot; ///beamSpot */
234 /* edm::InputTag m_muonSrc; ///muon */
235 /* edm::InputTag m_ecalRecHitBarrel; //ecalrechit barrel */
236 /* edm::InputTag m_ecalRecHitEndcap; //endcap */
237
238 /* edm::InputTag m_barrelSC; */
239 /* edm::InputTag m_endcapSC; */
240 /* edm::InputTag m_photonSrc; */
241 /* edm::InputTag m_electronSrc; */
242 /* edm::InputTag m_PileupSrc; */
243 /* edm::InputTag m_rhoCollection; */
244 /* edm::InputTag m_rhoCollection2; */
245 /* edm::InputTag m_allConversionsColl; */
246 /* edm::InputTag m_l1GtRecordInputTag; */
247 /* edm::InputTag m_l1IsolatedTag; */
248 /* edm::InputTag m_l1NonIsolatedTag; */
249 /* edm::InputTag m_l1MuTag; */
250
251
252 /* InputTag muIsoTrkMap_; */
253 /* InputTag muIsoEcalMap_; */
254 /* InputTag muIsoHcalMap_; */
255 /* InputTag muIsoHoMap_; */
256
257 /* bool m_dataFormat; */
258
259
260 /* //OUTPUT */
261 /* TFile* rootFile_; */
262 /* TTree *Analysis; */
263 /* std::string outputFile_; */
264
265
266
267
268 //Event info
269 int lumiBlock;
270 int runNumber;
271 int evtNumber;
272 int bunchX;
273 int orbitNumber;
274 int evtTime;
275 int isRealData;
276
277 //HLT
278 static const int MAXHLTbits = 500;
279
280
281 static const int MAX_HLT = 5000;
282
283 std::vector<unsigned short>* hlt_bitFired;
284
285 // MAX_HLT hlt objects pt/eta/phi/energy
286
287 //Int_t hlt_n;
288 //float hlt_pt[MAX_HLT];
289 //float hlt_eta[MAX_HLT];
290 //float hlt_phi[MAX_HLT];
291 //float hlt_en[MAX_HLT];
292
293 vector<float> *hlt_pt;
294 vector<float> *hlt_eta;
295 vector<float> *hlt_phi;
296 vector<float> *hlt_en;
297
298
299
300 std::vector<std::vector<unsigned short> >* hlt_candpath;
301 std::vector<std::vector<unsigned short> >* hltfilter_candpath;
302 std::vector<std::string> *hlt_pathName;
303 std::vector<std::string> *hlt_path_names_HLT2;
304 ///std::vector<edm::InputTag> theHLTLabels;
305 TClonesArray* hlt_p4;
306
307
308
309
310 std::vector<std::string> *hlt_label_names;
311
312 static const int MAXSC= 300;
313 int nSC;
314 float ptSC[MAXSC];
315 float eSC[MAXSC];
316 float eRawSC[MAXSC];
317 float etaSC[MAXSC];
318 float phiSC[MAXSC];
319 int flagSC[MAXSC];
320
321 ///anlaysis objects
322
323 static const int nPhotonMAX = 100;
324 int nPhoton;
325 float photonsigmaIetaIeta[nPhotonMAX];
326 int photonhasPixelSeed[nPhotonMAX];
327 float photonenergy[nPhotonMAX];
328 float photonpt[nPhotonMAX];
329 float photoneta[nPhotonMAX];
330 float photonphi[nPhotonMAX];
331 float photonvertexx[nPhotonMAX];
332 float photonvertexy[nPhotonMAX];
333 float photonvertexz[nPhotonMAX];
334 int photonhasConversionTracks[nPhotonMAX];
335 float photonscrawEnergy[nPhotonMAX];
336 float photonsceta[nPhotonMAX];
337 float photonscphi[nPhotonMAX];
338 float photoncaloPositionx[nPhotonMAX];
339 float photoncaloPositiony[nPhotonMAX];
340 float photoncaloPositionz[nPhotonMAX];
341 float photonscenergy[nPhotonMAX];
342 float photone3x3[nPhotonMAX];
343 float photone1x5[nPhotonMAX];
344 float photone2x5[nPhotonMAX];
345 float photone5x5[nPhotonMAX];
346 float photonmaxEnergyXtal[nPhotonMAX];
347 float photonr9[nPhotonMAX];
348
349
350
351 //more
352 float photonscpreshowerEnergy[nPhotonMAX];
353 float photonscphiWidth[nPhotonMAX];
354 float photonscetaWidth[nPhotonMAX];
355 int photonscclusterSize[nPhotonMAX];
356 std::vector<std::vector<float> >* photonscbclusterenergy;
357
358 int photonscnhits[nPhotonMAX];
359 float photoneLeft[nPhotonMAX];
360 float photoneRight[nPhotonMAX];
361 float photoneBottom[nPhotonMAX];
362 float photoneTop[nPhotonMAX];
363
364 float photone1x3[nPhotonMAX];
365 float photone3x1[nPhotonMAX];
366 float photone2x2[nPhotonMAX];
367 float photone3x2[nPhotonMAX];
368 float photone4x4[nPhotonMAX];
369 float photone2x5Right[nPhotonMAX];
370 float photone2x5Left[nPhotonMAX];
371 float photone2x5Top[nPhotonMAX];
372 float photone2x5Bottom[nPhotonMAX];
373 float photone2x5Max[nPhotonMAX];
374 ///float photonenergyBasketFractionEta[nPhotonMAX];
375 //float photonenergyBasketFractionPhi[nPhotonMAX];
376
377 float photonlat[nPhotonMAX][3];
378 float photonCovEtaEta[nPhotonMAX];
379 float photonCovEtaPhi[nPhotonMAX];
380 float photonCovPhiPhi[nPhotonMAX];
381
382 float photonCovIEtaIEta[nPhotonMAX];
383 float photonCovIEtaIPhi[nPhotonMAX];
384 float photonCovIPhiIPhi[nPhotonMAX];
385 float photonscCovIEtaIEta[nPhotonMAX];
386 float photonscCovIEtaIPhi[nPhotonMAX];
387 float photonscCovIPhiIPhi[nPhotonMAX];
388 float photonzernike20[nPhotonMAX];
389 float photonzernike42[nPhotonMAX];
390
391
392
393
394
395 //isolation
396 float photonhadronicOverEm[nPhotonMAX];
397 float photonecalRecHitSumEtConeDR03[nPhotonMAX];
398 float photonhcalDepth1TowerSumEtConeDR03[nPhotonMAX];
399 float photonhcalDepth2TowerSumEtConeDR03[nPhotonMAX];
400 float photonhcalTowerSumEtConeDR03[nPhotonMAX];
401 float photontrkSumPtHollowConeDR03[nPhotonMAX];
402 float photontrkSumPtSolidConeDR03[nPhotonMAX];
403 int photonnTrkHollowConeDR03[nPhotonMAX];
404 int photonnTrkSolidConeDR03[nPhotonMAX];
405 float photonecalRecHitSumEtConeDR04[nPhotonMAX];
406 float photonhcalDepth1TowerSumEtConeDR04[nPhotonMAX];
407 float photonhcalDepth2TowerSumEtConeDR04[nPhotonMAX];
408 float photonhcalTowerSumEtConeDR04[nPhotonMAX];
409 float photontrkSumPtHollowConeDR04[nPhotonMAX];
410 float photontrkSumPtSolidConeDR04[nPhotonMAX];
411 int photonnTrkHollowConeDR04[nPhotonMAX];
412 int photonnTrkSolidConeDR04[nPhotonMAX];
413
414 int photonconversionsize[nPhotonMAX];
415 float photonconversionVertexx[nPhotonMAX];
416 float photonconversionVertexy[nPhotonMAX];
417 float photonconversionVertexz[nPhotonMAX];
418 float photonconversionrefittedPairMomentumx[nPhotonMAX];
419 float photonconversionrefittedPairMomentumy[nPhotonMAX];
420 float photonconversionrefittedPairMomentumz[nPhotonMAX];
421
422 float photonconversionpairInvariantMass[nPhotonMAX];
423 float photonconversionpairCotThetaSeparation[nPhotonMAX];
424 float photonconversionEoverPrefittedTracks[nPhotonMAX];
425 float photonconversionzOfPrimaryVertexFromTracks[nPhotonMAX];
426 float photonconversiondistOfMinimumApproach[nPhotonMAX];
427 float photonconversiondPhiTracksAtVtx[nPhotonMAX];
428 float photonconversiondPhiTracksAtEcal[nPhotonMAX];
429 float photonconversiondEtaTracksAtEcal[nPhotonMAX];
430 int photonconversionnTracks[nPhotonMAX];
431 float photonconversionMVAout[nPhotonMAX];
432 int photonconversionVertexisValid[nPhotonMAX];
433 float photonconversionVertexchi2[nPhotonMAX];
434 float photonconversionChiSquaredProbability[nPhotonMAX];
435 float photonconversion_track1_dz[nPhotonMAX];
436 float photonconversion_track1_dzError[nPhotonMAX];
437 int photonconversion_track1_charge[nPhotonMAX];
438 float photonconversion_track1_d0[nPhotonMAX];
439 float photonconversion_track1_tracksPout[nPhotonMAX];
440 float photonconversion_track1_tracksPin[nPhotonMAX];
441 int photonconversion_track1_algo[nPhotonMAX];
442 float photonconversion_track2_dz[nPhotonMAX];
443 float photonconversion_track2_dzError[nPhotonMAX];
444 int photonconversion_track2_charge[nPhotonMAX];
445 int photonconversion_track2_algo[nPhotonMAX];
446 float photonconversion_track2_d0[nPhotonMAX];
447 float photonconversion_track2_tracksPout[nPhotonMAX];
448 float photonconversion_track2_tracksPin[nPhotonMAX];
449
450
451
452 float photonseedtime[nPhotonMAX];
453 float photonseedoutOfTimeChi2[nPhotonMAX];
454 float photonseedchi2[nPhotonMAX];
455 int photonseedrecoFlag[nPhotonMAX];
456 int photonseedseverityLevel[nPhotonMAX];
457 int photonfiducialFlag[nPhotonMAX];
458 int photonscindex[nPhotonMAX];
459 float photonswissCross[nPhotonMAX];
460 int photonieta[nPhotonMAX];
461 int photoniphi[nPhotonMAX];
462
463 float photonE2overE9[nPhotonMAX];
464 int photonmatchToallConv[nPhotonMAX];
465
466 float photongenphtmatch[nPhotonMAX][3];
467 float photongenelematch[nPhotonMAX][3];
468 float photongenphtconv[nPhotonMAX][4];
469 float photonPartonmatch[nPhotonMAX][6];
470 float photonPartonmatchp[nPhotonMAX][3];
471
472 int photonhasMatchedPromptElectron[nPhotonMAX];
473
474
475 TClonesArray *photonp4;
476
477 int nEventsProcessed;
478
479 float genhiggsm;
480 float genhiggspt;
481 float genhiggseta;
482 float genhiggsphi;
483 int genhiggsstatus;
484 float genhiggsvx;
485 float genhiggsvy;
486 float genhiggsvz;
487
488
489 static const int nConvMAX = 1000;
490 int nConv;
491 float convrefittedPair4Momentumeta[nConvMAX];
492 float convrefittedPair4Momentumphi[nConvMAX];
493 float convrefittedPair4Momentumpt[nConvMAX];
494 float convrefittedPair4Momentumenergy[nConvMAX];
495 int convnTracks[nConvMAX];
496 int convcaloClustersize[nConvMAX];
497 float convcaloCluster0eta[nConvMAX];
498 float convcaloCluster0x[nConvMAX];
499 float convcaloCluster0y[nConvMAX];
500 float convcaloCluster0z[nConvMAX];
501 float convcaloCluster0phi[nConvMAX];
502 int convconversionVertexisValid[nConvMAX];
503 float convpairMomentumx[nConvMAX];
504 float convpairMomentumy[nConvMAX];
505 float convpairMomentumz[nConvMAX];
506 float convrefittedPairMomentumx[nConvMAX];
507 float convrefittedPairMomentumy[nConvMAX];
508 float convrefittedPairMomentumz[nConvMAX];
509 float convconversionVertexx[nConvMAX];
510 float convconversionVertexy[nConvMAX];
511 float convconversionVertexz[nConvMAX];
512 float convconversionVertexchi2[nConvMAX];
513 float convconversionVertexChiSquaredProbability[nConvMAX];
514 float convconversionVertexxError[nConvMAX];
515 float convconversionVertexyError[nConvMAX];
516 float convconversionVertexzError[nConvMAX];
517 float convconversionVertexnTracks[nConvMAX];
518 float convconversionVertexMVAout[nConvMAX];
519 float conv_track1_dz[nConvMAX];
520 float conv_track1_dzError[nConvMAX];
521 int conv_track1_charge[nConvMAX];
522 int conv_track1_algo[nConvMAX];
523
524 float conv_track2_dz[nConvMAX];
525 float conv_track2_dzError[nConvMAX];
526 int conv_track2_charge[nConvMAX];
527 int conv_track2_algo[nConvMAX];
528
529 float convpairInvariantMass[nConvMAX];
530 float convpairCotThetaSeparation[nConvMAX];
531 // will work in 420 conv_eoverp[nConvMAX]=localConv.EoverPrefittedTracks();
532 float convEoverPrefittedTracks[nConvMAX];
533 float convzOfPrimaryVertexFromTracks[nConvMAX];
534 float convdistOfMinimumApproach[nConvMAX];
535 float convdPhiTracksAtVtx[nConvMAX];
536 float convdPhiTracksAtEcal[nConvMAX];
537 float convdEtaTracksAtEcal[nConvMAX];
538
539 int convnSharedHits[nConvMAX];
540 float conv_track1_d0[nConvMAX];
541 float conv_track1_pout[nConvMAX];
542 float conv_track1_pin[nConvMAX];
543 float conv_track2_d0[nConvMAX];
544 float conv_track2_pout[nConvMAX];
545 float conv_track2_pin[nConvMAX];
546
547 float conv_track1_pt[nConvMAX];
548 float conv_track1_eta[nConvMAX];
549 float conv_track1_phi[nConvMAX];
550 float conv_track2_pt[nConvMAX];
551 float conv_track2_eta[nConvMAX];
552 float conv_track2_phi[nConvMAX];
553
554
555
556 std::vector<std::vector<unsigned short> >* convnHitsBeforeVtx;
557
558
559 int nElectron;
560 static const int nElectronMAX = 100;
561
562 float electronpt[nElectronMAX];
563 float electroneta[nElectronMAX];
564 float electronphi[nElectronMAX];
565 int electroncharge[nElectronMAX];
566 float electronvertexx[nElectronMAX];
567 float electronvertexy[nElectronMAX];
568 float electronvertexz[nElectronMAX];
569 float electronscrawEnergy[nElectronMAX];
570 float electronsceta[nElectronMAX];
571 float electronscphi[nElectronMAX];
572 float electroncaloPositionx[nElectronMAX];
573 float electroncaloPositiony[nElectronMAX];
574 float electroncaloPositionz[nElectronMAX];
575
576 float electronscpreshowerEnergy[nElectronMAX];
577 float electronscphiWidth[nElectronMAX];
578 float electronscetaWidth[nElectronMAX];
579 int electronscclusterSize[nElectronMAX];
580 std::vector<std::vector<float> >* electronscbclusterenergy;
581
582 std::vector<std::vector<float> >* electronscrechitenergy;
583 std::vector<std::vector<float> >* electronscrechitfraction;
584 std::vector<std::vector<float> >* electronscrechitlaserCorr;
585 std::vector<std::vector<short> >* electronscrechitieta;
586 std::vector<std::vector<short> >* electronscrechitiphi;
587
588
589 int electronscnhits[nElectronMAX];
590 float electroneLeft[nElectronMAX];
591 float electroneRight[nElectronMAX];
592 float electroneBottom[nElectronMAX];
593 float electroneTop[nElectronMAX];
594
595 float electrone1x3[nElectronMAX];
596 float electrone3x1[nElectronMAX];
597 float electrone2x2[nElectronMAX];
598 float electrone3x2[nElectronMAX];
599 float electrone4x4[nElectronMAX];
600 float electrone2x5Right[nElectronMAX];
601 float electrone2x5Left[nElectronMAX];
602 float electrone2x5Top[nElectronMAX];
603 float electrone2x5Bottom[nElectronMAX];
604 ///float electrone2x5Max[nElectronMAX];
605 ///float electronenergyBasketFractionEta[nElectronMAX];
606 //float electronenergyBasketFractionPhi[nElectronMAX];
607 float electronlat[nElectronMAX][3];
608 float electronCovEtaEta[nElectronMAX];
609 float electronCovEtaPhi[nElectronMAX];
610 float electronCovPhiPhi[nElectronMAX];
611
612 float electronCovIEtaIEta[nElectronMAX];
613 float electronCovIEtaIPhi[nElectronMAX];
614 float electronCovIPhiIPhi[nElectronMAX];
615 float electronscCovIEtaIEta[nElectronMAX];
616 float electronscCovIEtaIPhi[nElectronMAX];
617 float electronscCovIPhiIPhi[nElectronMAX];
618 float electronzernike20[nElectronMAX];
619 float electronzernike42[nElectronMAX];
620
621
622
623 float electronscenergy[nElectronMAX];
624 int electronfiduficalFlag[nElectronMAX];
625 int electrontrackerDrivenSeed[nElectronMAX];
626 int electronecalDrivenSeed[nElectronMAX];
627 float electronfbrem[nElectronMAX];
628 int electronnumberOfBrems[nElectronMAX];
629 float electrondr03TkSumPt[nElectronMAX];
630 float electrondr03EcalRecHitSumEt[nElectronMAX];
631 float electrondr03HcalDepth1TowerSumEt[nElectronMAX];
632 float electrondr03HcalDepth2TowerSumEt[nElectronMAX];
633 float electrondr03HcalTowerSumEt[nElectronMAX];
634 float electrondr04EcalRecHitSumEt[nElectronMAX];
635 float electrondr04HcalDepth1TowerSumEt[nElectronMAX];
636 float electrondr04HcalDepth2TowerSumEt[nElectronMAX];
637 float electrondr04HcalTowerSumEt[nElectronMAX];
638 float electrondr04TkSumPt[nElectronMAX];
639 float electronhcalDepth1OverEcal[nElectronMAX];
640 float electronhcalDepth2OverEcal[nElectronMAX];
641 float electronhcalOverEcal[nElectronMAX];
642 float electroneSuperClusterOverP[nElectronMAX];
643 float electroneSeedClusterOverP[nElectronMAX];
644 float electroneSeedClusterOverPout[nElectronMAX];
645 float electroneEleClusterOverPout[nElectronMAX];
646 float electrondeltaEtaSuperClusterTrackAtVtx[nElectronMAX];
647 float electrondeltaEtaSeedClusterTrackAtCalo[nElectronMAX];
648 float electrondeltaEtaEleClusterTrackAtCalo[nElectronMAX];
649 float electrondeltaPhiSuperClusterTrackAtVtx[nElectronMAX];
650 float electrondeltaPhiSeedClusterTrackAtCalo[nElectronMAX];
651 float electrondeltaPhiEleClusterTrackAtCalo[nElectronMAX];
652 int electronclassification[nElectronMAX];
653 float electronmva[nElectronMAX];
654 int electronnumberOfTracks[nElectronMAX];
655 float electronconvDist[nElectronMAX];
656 float electronconvDcot[nElectronMAX];
657 float electronconvRadius[nElectronMAX];
658 int electronconvFlags[nElectronMAX];
659
660 // int electronExpectednumberOfHits[nElectronMAX];
661 int electronExpectedHitsInnernumberOfHits[nElectronMAX];
662 int electronExpectedHitsOuternumberOfHits[nElectronMAX];
663
664 float electrongsfTrackvx[nElectronMAX];
665 float electrongsfTrackvy[nElectronMAX];
666 float electrongsfTrackvz[nElectronMAX];
667 float electrongsfTracknormalizedChi2[nElectronMAX];
668 float electrongsfTrackdxybeamSpot[nElectronMAX];
669 float electrongsfTrackdzbeamSpot[nElectronMAX];
670 int electrongsfTracknumberOfValidHits[nElectronMAX];
671 int electrongsfTracknumberOfLostHits[nElectronMAX];
672 int electrongsfTracknumberOfValidPixelHits[nElectronMAX];
673 int electrongsfTracknumberOfValidTrackerHits[nElectronMAX];
674 float electrongsfTrackpt[nElectronMAX];
675 float electrongsfTracketa[nElectronMAX];
676 float electrongsfTrackphi[nElectronMAX];
677
678 float electronseedtime[nElectronMAX];
679 float electronseedoutOfTimeChi2[nElectronMAX];
680 float electronseedchi2[nElectronMAX];
681 int electronseedrecoFlag[nElectronMAX];
682 int electronseedseverityLevel[nElectronMAX];
683 float electronseedlaserCorr[nElectronMAX];
684
685
686 float electrone1x5[nElectronMAX];
687 float electrone2x5Max[nElectronMAX];
688 float electrone5x5[nElectronMAX];
689 float electronsigmaIetaIeta[nElectronMAX];
690 float electrone3x3[nElectronMAX];
691 float electroneMax[nElectronMAX];
692 int electronscindex[nElectronMAX];
693 float electronswissCross[nElectronMAX];
694 int electronieta[nElectronMAX];
695 int electroniphi[nElectronMAX];
696 float electronE2overE9[nElectronMAX];
697 float electrongenelematch[nElectronMAX][4];
698 float electrongentrkmatch[nElectronMAX][4];
699 float electronsimelematch[nElectronMAX][7];
700 float electronPartonmatch[nElectronMAX][6];
701
702
703 static const int nMuonMAX = 50;
704 ///muon
705 int nMuon;
706 TClonesArray *muonp4;
707 int muonRecoAlgo[nMuonMAX];
708 int muonisGoodMuon[nMuonMAX];
709
710 float muonpt[nMuonMAX];
711 int muoncharge[nMuonMAX];
712 float muoneta[nMuonMAX];
713 float muonphi[nMuonMAX];
714
715 float muonvx[nMuonMAX];
716 float muonvy[nMuonMAX];
717 float muonvz[nMuonMAX];
718 int muonnumberOfMatches[nMuonMAX];
719 int muonnumberOfChambers[nMuonMAX];
720 float muonglobalTrackvx[nMuonMAX];
721 float muonglobalTrackvy[nMuonMAX];
722 float muonglobalTrackvz[nMuonMAX];
723 float muonglobalTrackdzbeamSpot[nMuonMAX];
724 float muonglobalTrackdxybeamSpot[nMuonMAX];
725 int muonglobalTracknumberOfValidPixelHits[nMuonMAX];
726 int muonglobalTracknumberOfValidTrackerHits[nMuonMAX];
727 float muonglobalTracknormalizedChi2[nMuonMAX];
728 int muonglobalTracknumberOfValidMuonHits[nMuonMAX];
729 float muonisolationR03sumPt[nMuonMAX];
730 float muonisolationR03emEt[nMuonMAX];
731 float muonisolationR03hadEt[nMuonMAX];
732 float muonisolationR03hoEt[nMuonMAX];
733 float muonisolationR04sumPt[nMuonMAX];
734 float muonisolationR04emEt[nMuonMAX];
735 float muonisolationR04hadEt[nMuonMAX];
736 float muonisolationR04hoEt[nMuonMAX];
737 float muonisolationR05sumPt[nMuonMAX];
738 float muonisolationR05emEt[nMuonMAX];
739 float muonisolationR05hadEt[nMuonMAX];
740 float muonisolationR05hoEt[nMuonMAX];
741 float muonGenmumatch[nMuonMAX][4];
742 float muonGentrkmatch[nMuonMAX][4];
743 float muonSimmumatch[nMuonMAX][7];
744 float muonPartonmatch[nMuonMAX][6];
745
746 int muoninnerTracknumberOfValidPixelHits[nMuonMAX];
747 int muoninnerTracknumberOfValidTrackerHits[nMuonMAX];
748 float muoninnerTrackpt[nMuonMAX];
749 float muoninnerTracketa[nMuonMAX];
750 float muoninnerTrackphi[nMuonMAX];
751
752 int muonouterTracknumberOfValidMuonHits[nMuonMAX];
753 float muonouterTrackpt[nMuonMAX];
754 float muonouterTracketa[nMuonMAX];
755 float muonouterTrackphi[nMuonMAX];
756
757 //vertex
758 int nVertex;
759 static const int MAXVX = 100;
760 float vertexx[MAXVX];
761 float vertexy[MAXVX];
762 float vertexz[MAXVX];
763 float vertexchi2[MAXVX];
764 float vertexndof[MAXVX];
765 float vertexnormalizedChi2[MAXVX];
766 int vertextrackSize[MAXVX];
767 int vertexisFake[MAXVX];
768 int vertexisValid[MAXVX];
769 float vertexsumtrackspt[MAXVX];
770 float vertexsumtracksptSquare[MAXVX];
771 float vertexsumRefittedtrackspt[MAXVX];
772 float vertexsumRefittedtracksptSquare[MAXVX];
773
774
775
776
777
778 int nVertexNoBS;
779 /// static const int MAXVX = 100;
780 float vertexNoBSx[MAXVX];
781 float vertexNoBSy[MAXVX];
782 float vertexNoBSz[MAXVX];
783 float vertexNoBSchi2[MAXVX];
784 float vertexNoBSndof[MAXVX];
785 float vertexNoBSnormalizedChi2[MAXVX];
786 int vertexNoBStrackSize[MAXVX];
787 int vertexNoBSisFake[MAXVX];
788 int vertexNoBSisValid[MAXVX];
789
790
791 int phyDeclared;
792
793
794
795 float rho;
796 float rhoEtaMax44;
797
798
799 static const int nTrackMAX = 50000;
800 //track
801 int nTrack;
802 float trackhighPurityFraction;
803 float trackd0[nTrackMAX];
804 float trackd0Error[nTrackMAX];
805 float trackdz[nTrackMAX];
806 float trackdzError[nTrackMAX];
807 int trackcharge[nTrackMAX];
808 float trackpt[nTrackMAX];
809 float trackpx[nTrackMAX];
810 float trackpy[nTrackMAX];
811 float trackpz[nTrackMAX];
812 float trackptError[nTrackMAX];
813 float tracketa[nTrackMAX];
814 float trackphi[nTrackMAX];
815 float trackvx[nTrackMAX];
816 float trackvy[nTrackMAX];
817 float trackvz[nTrackMAX];
818 float tracknormalizedChi2[nTrackMAX];
819 int tracknumberOfValidHits[nTrackMAX];
820 int trackndof[nTrackMAX];
821 int tracknumberOfValidPixelHits[nTrackMAX];
822 int tracknumberOfValidStripHits[nTrackMAX];
823 int tracknumberOfValidTrackerHits[nTrackMAX];
824 int trackalgo[nTrackMAX];
825 int trackqualityFlagTracks[nTrackMAX];
826
827
828 ///beamspont
829 float beamSpotX;
830 float beamSpotY;
831 float beamSpotZ;
832
833
834 ////MET
835 float caloMETet;
836 float caloMETsumEt;
837 float caloMETphi;
838 float caloMETeta;
839 float caloMETsig;
840
841
842 float muCorrMETsumEt;
843 float muCorrMETet;
844 float muCorrMETphi;
845 float muCorrMETeta;
846 float muCorrMETsig;
847
848
849 float tcMETsumEt;
850 float tcMETet;
851 float tcMETphi;
852 float tcMETeta;
853 float tcMETsig;
854
855
856 float pfMETsumEt;
857 float pfMETet;
858 float pfMETphi;
859 float pfMETeta;
860 float pfMETsig;
861
862
863
864 std::vector<std::vector<short> >* vertex_trkind;
865 std::vector<std::vector<float> >* vertex_trkWeight;
866
867
868
869
870
871 static const int nCJetMAX = 50;
872 int nak5CaloJet;
873
874 float ak5CaloJetet[nCJetMAX];
875 float ak5CaloJeteta[nCJetMAX];
876 float ak5CaloJetphi[nCJetMAX];
877 float ak5CaloJetenergyFractionHadronic[nCJetMAX];
878 float ak5CaloJetn90[nCJetMAX];
879 float ak5CaloJetn60[nCJetMAX];
880 float ak5CaloJettowersArea[nCJetMAX];
881 int ak5CaloJetCalosize[nCJetMAX];
882 float ak5CaloJetfHPD[nCJetMAX];
883 float ak5CaloJetfRBX[nCJetMAX];
884 float ak5CaloJetn90Hits[nCJetMAX];
885 float ak5CaloJetrestrictedEMF[nCJetMAX];
886 float ak5CaloJetcorrection[nCJetMAX];
887 float ak5CaloJetPartonmatch[nCJetMAX][6];
888 float ak5CaloJetmaxEInEmTowers[nCJetMAX];
889 float ak5CaloJetmaxEInHadTowers[nCJetMAX];
890
891
892 int nak7CaloJet;
893
894 float ak7CaloJetet[nCJetMAX];
895 float ak7CaloJeteta[nCJetMAX];
896 float ak7CaloJetphi[nCJetMAX];
897 float ak7CaloJetenergyFractionHadronic[nCJetMAX];
898 float ak7CaloJetn90[nCJetMAX];
899 float ak7CaloJetn60[nCJetMAX];
900 float ak7CaloJettowersArea[nCJetMAX];
901 int ak7CaloJetCalosize[nCJetMAX];
902 float ak7CaloJetfHPD[nCJetMAX];
903 float ak7CaloJetfRBX[nCJetMAX];
904 float ak7CaloJetn90Hits[nCJetMAX];
905 float ak7CaloJetrestrictedEMF[nCJetMAX];
906 float ak7CaloJetcorrection[nCJetMAX];
907 float ak7CaloJetPartonmatch[nCJetMAX][6];
908 float ak7CaloJetmaxEInEmTowers[nCJetMAX];
909 float ak7CaloJetmaxEInHadTowers[nCJetMAX];
910
911 /// reco::helper::JetIDHelper jetIDHelper;
912
913 int nak5PFJet;
914
915 float ak5PFJetet[nCJetMAX];
916 float ak5PFJeteta[nCJetMAX];
917 float ak5PFJetphi[nCJetMAX];
918
919 float ak5PFJetchargedHadronEnergyFraction[nCJetMAX];
920 float ak5PFJetchargedMuEnergyFraction[nCJetMAX];
921 float ak5PFJetneutralEmEnergyFraction[nCJetMAX];
922 int ak5PFJetchargedMultiplicity[nCJetMAX];
923 int ak5PFJetneutralMultiplicity[nCJetMAX];
924 int ak5PFJetPFsize[nCJetMAX];
925 float ak5PFJetfHPD[nCJetMAX];
926 float ak5PFJetfRBX[nCJetMAX];
927 float ak5PFJetn90Hits[nCJetMAX];
928 float ak5PFJetrestrictedEMF[nCJetMAX];
929 float ak5PFJetcorrection[nCJetMAX];
930 float ak5PFJetPartonmatch[nCJetMAX][6];
931
932
933 int nak7PFJet;
934
935 float ak7PFJetet[nCJetMAX];
936 float ak7PFJeteta[nCJetMAX];
937 float ak7PFJetphi[nCJetMAX];
938
939 float ak7PFJetchargedHadronEnergyFraction[nCJetMAX];
940 float ak7PFJetchargedMuEnergyFraction[nCJetMAX];
941 float ak7PFJetneutralEmEnergyFraction[nCJetMAX];
942 int ak7PFJetchargedMultiplicity[nCJetMAX];
943 int ak7PFJetneutralMultiplicity[nCJetMAX];
944 int ak7PFJetPFsize[nCJetMAX];
945 float ak7PFJetfHPD[nCJetMAX];
946 float ak7PFJetfRBX[nCJetMAX];
947 float ak7PFJetn90Hits[nCJetMAX];
948 float ak7PFJetrestrictedEMF[nCJetMAX];
949 float ak7PFJetcorrection[nCJetMAX];
950 float ak7PFJetPartonmatch[nCJetMAX][6];
951 ///below only for MC
952
953 vector<short> *pileupBunchX;
954 vector<short> *pileupNInteraction;
955
956
957 //PDF
958 int pdfidfirst;
959 int pdfidsecond;
960 float pdfxfirst;
961 float pdfxsecond;
962 float xPDFfirst;
963 float xPDFsecond;
964 float pdfscalePDF;
965
966 ///signalID qscale
967 int signalProcessID;
968 float qScale;
969
970
971
972 static const int MAXGenSaved = 1000;
973 //gen-leve phton
974 int nGenPht;
975 float etaGenPht[MAXGenSaved];
976 float phiGenPht[MAXGenSaved];
977 float ptGenPht[MAXGenSaved];
978 int pidmomGenPht[MAXGenSaved];
979 int pidmom2GenPht[MAXGenSaved];
980 int pidmom3GenPht[MAXGenSaved];
981 int statusGenPht[MAXGenSaved];
982 float vxGenPht[MAXGenSaved];
983 float vyGenPht[MAXGenSaved];
984 float vzGenPht[MAXGenSaved];
985
986 //gen Muon
987 int nGenMu;
988 float etaGenMu[MAXGenSaved];
989 float phiGenMu[MAXGenSaved];
990 float ptGenMu[MAXGenSaved];
991 int pidmomGenMu[MAXGenSaved];
992 int pidmom2GenMu[MAXGenSaved];
993 int pidmom3GenMu[MAXGenSaved];
994 int statusGenMu[MAXGenSaved];
995 int pidGenMu[MAXGenSaved];
996 float vxGenMu[MAXGenSaved];
997 float vyGenMu[MAXGenSaved];
998 float vzGenMu[MAXGenSaved];
999
1000 //gen electron
1001 int nGenEle;
1002 float etaGenEle[MAXGenSaved];
1003 float phiGenEle[MAXGenSaved];
1004 float ptGenEle[MAXGenSaved];
1005 int pidmomGenEle[MAXGenSaved];
1006 int pidmom2GenEle[MAXGenSaved];
1007 int pidmom3GenEle[MAXGenSaved];
1008 int statusGenEle[MAXGenSaved];
1009 int pidGenEle[MAXGenSaved];
1010 float vxGenEle[MAXGenSaved];
1011 float vyGenEle[MAXGenSaved];
1012 float vzGenEle[MAXGenSaved];
1013
1014
1015
1016 static const int MAXMC = 100000;
1017 int nMCpart;
1018 float pxMCpart[MAXMC];
1019 float pyMCpart[MAXMC];
1020 float pzMCpart[MAXMC];
1021 float ptotMCpart[MAXMC];
1022 float ptMCpart[MAXMC];
1023 float eMCpart[MAXMC];
1024 float etMCpart[MAXMC];
1025 float etaMCpart[MAXMC];
1026 float phiMCpart[MAXMC];
1027 float mMCpart[MAXMC];
1028 int chargeMCpart[MAXMC];
1029 int pidMCpart[MAXMC];
1030 int pidmomMCpart[MAXMC];
1031 int barcodemomMCpart[MAXMC];
1032 int nDauMCpart[MAXMC];
1033 int pidFDauMCpart[MAXMC]; ///pid of first daughter, mainly for checking if is 91 or 92.
1034
1035
1036
1037 static const int MAXDAU = 100;
1038 int barcodeDauMCpart[MAXMC][MAXDAU];
1039 int statusMCpart[MAXMC];
1040 float vtxXMCpart[MAXMC];
1041 float vtxYMCpart[MAXMC];
1042 float vtxZMCpart[MAXMC];
1043 int convPhtMCpart[MAXMC][3]; //only for status==1 Gen photon, and the two index to the two electrons
1044
1045 vector<int> partonList;
1046
1047
1048 // L1 objects
1049 static const int MAXL1OBJ = 100;
1050 // static const int MAXL1BITS = 128;
1051 // L1 EM isolated objects
1052 int nL1EMIso;
1053 float L1EMIso_e[MAXL1OBJ];
1054 float L1EMIso_et[MAXL1OBJ];
1055 float L1EMIso_eta[MAXL1OBJ];
1056 float L1EMIso_phi[MAXL1OBJ];
1057 // L1 EM non-isolated objects
1058 int nL1EMnonIso;
1059 float L1EMnonIso_e[MAXL1OBJ];
1060 float L1EMnonIso_et[MAXL1OBJ];
1061 float L1EMnonIso_eta[MAXL1OBJ];
1062 float L1EMnonIso_phi[MAXL1OBJ];
1063
1064 int nL1Muon;
1065 float L1Muon_e[MAXL1OBJ];
1066 float L1Muon_et[MAXL1OBJ];
1067 float L1Muon_pt[MAXL1OBJ];
1068 float L1Muon_eta[MAXL1OBJ];
1069 float L1Muon_phi[MAXL1OBJ];
1070
1071 bool saveTrk_;
1072 bool saveLaserCorrSeedCrystal_;
1073 /* edm::ESHandle<EcalLaserDbService> laser; */
1074
1075
1076 /* }; */