ViewVC Help
View File | Revision Log | Show Annotations | Root Listing
root/cvsroot/UserCode/VHbbAnalysis/VHbbDataFormats/bin/Ntupler.cc
Revision: 1.89
Committed: Fri Jun 1 08:23:06 2012 UTC (12 years, 11 months ago) by arizzi
Content type: text/plain
Branch: MAIN
CVS Tags: Step2ForV32_v0
Changes since 1.88: +41 -3 lines
Log Message: 
Update of step2 for V32 new PU recipe. Add 2012A trigger weights from Seth (preliminary, still sorting out the dZ ineff)

File Contents

# Content
1 #include <TH1F.h>
2 #include <TH3F.h>
3 #include "PhysicsTools/Utilities/interface/LumiReWeighting.h"
4 #include "PhysicsTools/Utilities/interface/Lumi3DReWeighting.h"
5 #include <TH2F.h>
6 #include <TROOT.h>
7 #include <TFile.h>
8 #include <TTree.h>
9 #include <TSystem.h>
10 #include "DataFormats/FWLite/interface/Event.h"
11 #include "DataFormats/FWLite/interface/Handle.h"
12 #include "FWCore/FWLite/interface/AutoLibraryLoader.h"
13 #include "DataFormats/MuonReco/interface/Muon.h"
14 #include "DataFormats/PatCandidates/interface/Muon.h"
15 #include "PhysicsTools/FWLite/interface/TFileService.h"
16 #include "FWCore/ParameterSet/interface/ProcessDesc.h"
17 #include "FWCore/PythonParameterSet/interface/PythonProcessDesc.h"
18 #include "DataFormats/Math/interface/deltaR.h"
19 #include "DataFormats/Math/interface/deltaPhi.h"
20
21 #include "DataFormats/FWLite/interface/LuminosityBlock.h"
22 #include "DataFormats/FWLite/interface/Run.h"
23 #include "DataFormats/Luminosity/interface/LumiSummary.h"
24
25 #include "VHbbAnalysis/VHbbDataFormats/interface/HbbCandidateFinderAlgo.h"
26 #include "VHbbAnalysis/VHbbDataFormats/src/HbbCandidateFinderAlgo.cc"
27
28 #include "VHbbAnalysis/VHbbDataFormats/interface/VHbbEvent.h"
29 #include "VHbbAnalysis/VHbbDataFormats/interface/VHbbEventAuxInfo.h"
30 #include "VHbbAnalysis/VHbbDataFormats/interface/VHbbCandidate.h"
31 #include "VHbbAnalysis/VHbbDataFormats/interface/TriggerReader.h"
32 #include "VHbbAnalysis/VHbbDataFormats/interface/TopMassReco.h"
33
34 //for IVF
35 #include "RecoBTag/SecondaryVertex/interface/SecondaryVertex.h"
36 #include "DataFormats/GeometryCommonDetAlgo/interface/Measurement1D.h"
37 #include "DataFormats/GeometryVector/interface/GlobalVector.h"
38 #include "DataFormats/GeometryVector/interface/VectorUtil.h"
39 #include <DataFormats/GeometrySurface/interface/Surface.h>
40 #include "Math/SMatrix.h"
41
42 //for LHE info
43 #include "SimDataFormats/GeneratorProducts/interface/LHEEventProduct.h"
44
45 //Move class definition to Ntupler.h ?
46 //#include "VHbbAnalysis/VHbbDataFormats/interface/Ntupler.h"
47
48 #include "ZSV/BAnalysis/interface/SimBHadron.h"
49 //btagging
50 #include "VHbbAnalysis/VHbbDataFormats/interface/BTagWeight.h"
51 //trigger
52 #include "VHbbAnalysis/VHbbDataFormats/interface/TriggerWeight.h"
53
54 #include <sstream>
55 #include <string>
56
57 #define MAXJ 130
58 #define MAXL 110
59 #define MAXB 110
60 #define MAXT 160
61 #define nMetUnc 24
62 //eleEnDown/Up, muEn, tauEn, JES, JER, Unclustered for type1 MET [0-11] and than type1p2 MET [12-23]
63
64 struct CompareDeltaR {
65 CompareDeltaR(TLorentzVector p4dir_): p4dir(p4dir_) {}
66 bool operator()( const VHbbEvent::SimpleJet& j1, const VHbbEvent::SimpleJet& j2 ) const {
67 return j1.p4.DeltaR(p4dir) > j2.p4.DeltaR(p4dir);
68 }
69 TLorentzVector p4dir;
70 };
71
72 const GlobalVector flightDirection(const TVector3 pv, const reco::Vertex &sv){
73 GlobalVector fdir(sv.position().X() - pv.X(),
74 sv.position().Y() - pv.Y(),
75 sv.position().Z() - pv.Z());
76 return fdir;
77 }
78
79 bool jsonContainsEvent (const std::vector< edm::LuminosityBlockRange > &jsonVec,
80 const edm::EventBase &event)
81 {
82 // if the jsonVec is empty, then no JSON file was provided so all
83 // events should pass
84 if (jsonVec.empty())
85 {
86 return true;
87 }
88 bool (* funcPtr) (edm::LuminosityBlockRange const &,
89 edm::LuminosityBlockID const &) = &edm::contains;
90 edm::LuminosityBlockID lumiID (event.id().run(),
91 event.id().luminosityBlock());
92 std::vector< edm::LuminosityBlockRange >::const_iterator iter =
93 std::find_if (jsonVec.begin(), jsonVec.end(),
94 boost::bind(funcPtr, _1, lumiID) );
95 return jsonVec.end() != iter;
96
97 }
98
99 float resolutionBias(float eta)
100 {
101 // return 0;//Nominal!
102 if(eta< 1.1) return 0.05;
103 if(eta< 2.5) return 0.10;
104 if(eta< 5) return 0.30;
105 return 0;
106 }
107
108
109 typedef struct
110 {
111 void set(const SimBHadron & sbhc, int i){
112 mass[i] = sbhc.mass();
113 pt[i] = sbhc.pt();
114 eta[i] = sbhc.eta();
115 phi[i] = sbhc.phi();
116 vtx_x[i] = sbhc.decPosition.x();
117 vtx_y[i] = sbhc.decPosition.y();
118 vtx_z[i] = sbhc.decPosition.z();
119 pdgId[i] = sbhc.pdgId();
120 status[i] = sbhc.status();
121 };
122 void reset(){
123 for(int i=0; i < MAXB; ++i){
124 mass[i] = -99; pt[i] = -99; eta[i] = -99; phi[i] = -99; vtx_x[i] = -99; vtx_y[i] = -99; vtx_z[i] = -99; pdgId[i] = -99; status[i] = -99;
125 }
126 };
127 float mass[MAXB];
128 float pt[MAXB];
129 float eta[MAXB];
130 float phi[MAXB];
131 float vtx_x[MAXB];
132 float vtx_y[MAXB];
133 float vtx_z[MAXB];
134 int pdgId[MAXB];
135 int status[MAXB];
136 // int quarkStatus[MAXB];
137 // int brotherStatus[MAXB];
138 // int otherId[MAXB];
139 // bool etaOk[MAXB];
140 // bool simOk[MAXB];
141 // bool trackOk[MAXB];
142 // bool cutOk[MAXB];
143 // bool cutNewOk[MAXB];
144 // bool mcMatchOk[MAXB];
145 // bool matchOk[MAXB];
146 } SimBHadronInfo;
147
148
149 typedef struct
150 {
151 void set( const reco::SecondaryVertex & recoSv, const TVector3 recoPv, int isv){
152 pt[isv] = recoSv.p4().Pt();
153 eta[isv] = flightDirection(recoPv,recoSv).eta();
154 phi[isv] = flightDirection(recoPv,recoSv).phi();
155 massBcand[isv] = recoSv.p4().M();
156 massSv[isv] = recoSv.p4().M();
157 dist3D[isv] = recoSv.dist3d().value();
158 distSig3D[isv] = recoSv.dist3d().significance();
159 dist2D[isv] = recoSv.dist2d().value();
160 distSig2D[isv] = recoSv.dist2d().significance();
161 dist3D_norm[isv] = recoSv.dist3d().value()/recoSv.p4().Gamma();
162 };
163 void reset(){
164 for(int i = 0; i < MAXB; ++i){
165 massBcand[i] = -99; massSv[i]= -99; pt[i] = -99; eta[i] = -99; phi[i] = -99; dist3D[i] = -99; distSig3D[i] = -99; dist2D[i] = -99; distSig2D[i] = -99; dist3D_norm[i] = -99;
166 }
167 };
168 float massBcand[MAXB];
169 float massSv[MAXB];
170 float pt[MAXB];
171 float eta[MAXB];
172 float phi[MAXB];
173 float dist3D[MAXB];
174 float distSig3D[MAXB];
175 float dist2D[MAXB];
176 float distSig2D[MAXB];
177 float dist3D_norm[MAXB];
178 } IVFInfo;
179
180
181 typedef struct
182 {
183 int HiggsFlag;
184 float mass;
185 float pt;
186 float eta;
187 float phi;
188 float dR;
189 float dPhi;
190 float dEta;
191 } HiggsInfo;
192
193 typedef struct
194 {
195 int FatHiggsFlag;
196 float mass;
197 float pt;
198 float eta;
199 float phi;
200 float filteredmass;
201 float filteredpt;
202 float filteredeta;
203 float filteredphi;
204 // float dR;
205 // float dPhi;
206 // float dEta;
207 } FatHiggsInfo;
208
209
210
211 typedef struct
212 {
213 float mass;
214 float pt;
215 float eta;
216 float phi;
217 float status;
218 float charge;
219 float momid;
220 } genParticleInfo;
221
222
223
224 typedef struct
225
226 {
227 float bmass;
228 float bpt;
229 float beta;
230 float bphi;
231 float bstatus;
232 float wdau1mass;
233 float wdau1pt;
234 float wdau1eta;
235 float wdau1phi;
236 float wdau1id;
237 float wdau2mass;
238 float wdau2pt;
239 float wdau2eta;
240 float wdau2phi;
241 float wdau2id;
242
243
244 } genTopInfo;
245
246
247
248
249 typedef struct
250 {
251 bool HiggsCSVtkSharing;
252 bool HiggsIPtkSharing;
253 bool HiggsSVtkSharing;
254 bool FatHiggsCSVtkSharing;
255 bool FatHiggsIPtkSharing;
256 bool FatHiggsSVtkSharing;
257 } TrackSharingInfo;
258
259 typedef struct
260 {
261 float mass; //MT in case of W
262 float pt;
263 float eta;
264 float phi;
265 } TrackInfo;
266
267
268 struct LeptonInfo
269 {
270 void reset()
271 {
272 for(int i =0; i < MAXL;i++){
273 mass[i]=-99; pt[i]=-99; eta[i]=-99; phi[i]=-99; aodCombRelIso[i]=-99; pfCombRelIso[i]=-99; photonIso[i]=-99; neutralHadIso[i]=-99; chargedHadIso[i]=-99; chargedPUIso[i]=-99; particleIso[i]=-99; dxy[i]=-99; dz[i]=-99; type[i]=-99; genPt[i]=-99; genEta[i]=-99; genPhi[i]=-99;
274 id80[i]=-99; id95[i]=-99; vbtf[i]=-99; id80NoIso[i]=-99;
275 charge[i]=-99;wp70[i]=-99; wp80[i]=-99;wp85[i]=-99;wp90[i]=-99;wp95[i]=-99;wpHWW[i]=-99;
276 pfCorrIso[i]=-99.; id2012tight[i]=-99; idMVAnotrig[i]=-99; idMVAtrig[i]=-99;innerHits[i]=-99.;
277
278 }
279 }
280
281 template <class Input> void set(const Input & i, int j,int t,const VHbbEventAuxInfo & aux)
282 {
283 type[j]=t;
284 pt[j]=i.p4.Pt();
285 mass[j]=i.p4.M();
286 eta[j]=i.p4.Eta();
287 phi[j]=i.p4.Phi();
288 aodCombRelIso[j]=(i.hIso+i.eIso+i.tIso)/i.p4.Pt();
289 pfCombRelIso[j]=(i.pfChaIso+i.pfPhoIso+i.pfNeuIso)/i.p4.Pt();
290 photonIso[j]=i.pfPhoIso;
291 neutralHadIso[j]=i.pfNeuIso;
292 chargedHadIso[j]=i.pfChaIso;
293 chargedPUIso[j]=i.pfChaPUIso;
294 charge[j]=i.charge;
295 if(i.mcFourMomentum.Pt() > 0)
296 {
297 genPt[j]=i.mcFourMomentum.Pt();
298 genEta[j]=i.mcFourMomentum.Eta();
299 genPhi[j]=i.mcFourMomentum.Phi();
300 }
301 setSpecific(i,j,aux);
302 }
303 template <class Input> void setSpecific(const Input & i, int j,const VHbbEventAuxInfo & aux)
304 {
305 }
306
307
308
309
310 float mass[MAXL]; //MT in case of W
311 float pt[MAXL];
312 float eta[MAXL];
313 float phi[MAXL];
314 float aodCombRelIso[MAXL];
315 float pfCombRelIso[MAXL];
316 float photonIso[MAXL];
317 float neutralHadIso[MAXL];
318 float chargedHadIso[MAXL];
319 float chargedPUIso[MAXL];
320 float particleIso[MAXL];
321 float genPt[MAXL];
322 float genEta[MAXL];
323 float genPhi[MAXL];
324 float dxy[MAXL];
325 float dz[MAXL];
326 int type[MAXL];
327 float id80[MAXL];
328 float id95[MAXL];
329 float vbtf[MAXL];
330 float id80NoIso[MAXL];
331 float charge[MAXL];
332 float pfCorrIso[MAXL];
333 float id2012tight[MAXL];
334 float idMVAnotrig[MAXL];
335 float idMVAtrig[MAXL];
336 float wp70[MAXL];
337 float wp80[MAXL];
338 float wp85[MAXL];
339 float wp90[MAXL];
340 float wp95[MAXL];
341 float wpHWW[MAXL];
342 float innerHits[MAXL];
343 float photonIsoDoubleCount[MAXL];
344 };
345
346 template <> void LeptonInfo::setSpecific<VHbbEvent::ElectronInfo>(const VHbbEvent::ElectronInfo & i, int j,const VHbbEventAuxInfo & aux){
347 photonIsoDoubleCount[j]=i.pfPhoIsoDoubleCounted;
348 id80[j]=i.id80;
349 id95[j]=i.id95;
350 id80NoIso[j]=(i.innerHits ==0 && !(fabs(i.convDist)<0.02 && fabs(i.convDcot)<0.02) &&
351 ((i.isEB && i.sihih<0.01 && fabs(i.Dphi)<0.06 && fabs(i.Deta)<0.004) || (i.isEE && i.sihih<0.03 && fabs(i.Dphi)<0.03 && fabs(i.Deta)<0.007)));
352 innerHits[j]=i.innerHits;
353 float mincor=0.0;
354 float minrho=0.0;
355 float rhoN = std::max(aux.puInfo.rhoNeutral,minrho);
356 float eta=i.p4.Eta();
357 float areagamma=0.5;
358 float areaNH=0.5;
359 float areaComb=0.5;
360 if(fabs(eta) <= 1.0 ) {areagamma=0.081; areaNH=0.024; areaComb=0.10;}
361 if(fabs(eta) > 1.0 && fabs(eta) <= 1.479 ) {areagamma=0.084; areaNH=0.037; areaComb=0.12;}
362 if(fabs(eta) > 1.479 && fabs(eta) <= 2.0 ) {areagamma=0.048; areaNH=0.037; areaComb=0.085;}
363 if(fabs(eta) > 2.0 && fabs(eta) <= 2.2 ) {areagamma=0.089; areaNH=0.023; areaComb=0.11;}
364 if(fabs(eta) > 2.2 && fabs(eta) <= 2.3 ) {areagamma=0.092; areaNH=0.023; areaComb=0.12;}
365 if(fabs(eta) > 2.3 && fabs(eta) <= 2.4 ) {areagamma=0.097; areaNH=0.021; areaComb=0.12;}
366 if(fabs(eta) > 2.4 ) {areagamma=0.11; areaNH=0.021; areaComb=0.13;}
367
368 float pho=i.pfPhoIso;
369 if(i.innerHits>0)
370 {
371 pho-=i.pfPhoIsoDoubleCounted;
372 }
373
374 pfCorrIso[j] = (i.pfChaIso+ std::max(pho-rhoN*areagamma,mincor )+std::max(i.pfNeuIso-rhoN*areaNH,mincor))/i.p4.Pt();
375
376 id2012tight[j] = fabs(i.dxy) < 0.02 &&fabs(i.dz) < 0.1 &&(
377 (i.isEE &&fabs(i.Deta) < 0.005 &&fabs(i.Dphi) < 0.02 &&i.sihih < 0.03 &&i.HoE < 0.10 &&fabs(i.fMVAVar_IoEmIoP) < 0.05
378 ) ||
379 (i.isEB &&fabs(i.Deta) < 0.004 &&fabs(i.Dphi) < 0.03 &&i.sihih < 0.01 &&i.HoE < 0.12 &&fabs(i.fMVAVar_IoEmIoP) < 0.05
380 ));
381 float id=i.mvaOutTrig;
382 float iso=pfCorrIso[j];
383 wp70[j]=((fabs(eta) < 0.8 && id>0.977 && iso < 0.093) || (fabs(eta) >= 0.8 && fabs(eta) < 1.479 && id>0.956 && iso < 0.095) || (fabs(eta) >= 1.479 && fabs(eta) < 2.5 && id>0.966 && iso < 0.171));
384 wp80[j]=((fabs(eta) < 0.8 && id>0.913 && iso < 0.105) || (fabs(eta) >= 0.8 && fabs(eta) < 1.479 && id>0.964 && iso < 0.178) || (fabs(eta) >= 1.479 && fabs(eta) < 2.5 && id>0.899 && iso < 0.150));
385 wp85[j]=((fabs(eta) < 0.8 && id>0.929 && iso < 0.135) || (fabs(eta) >= 0.8 && fabs(eta) < 1.479 && id>0.931 && iso < 0.159) || (fabs(eta) >= 1.479 && fabs(eta) < 2.5 && id>0.805 && iso < 0.155));
386 wp90[j]=((fabs(eta) < 0.8 && id>0.877 && iso < 0.177) || (fabs(eta) >= 0.8 && fabs(eta) < 1.479 && id>0.794 && iso < 0.180) || (fabs(eta) >= 1.479 && fabs(eta) < 2.5 && id>0.846 && iso < 0.244));
387 wp95[j]=((fabs(eta) < 0.8 && id>0.858 && iso < 0.253) || (fabs(eta) >= 0.8 && fabs(eta) < 1.479 && id>0.425 && iso < 0.225) || (fabs(eta) >= 1.479 && fabs(eta) < 2.5 && id>0.759 && iso < 0.308));
388 wpHWW[j]=((fabs(eta) < 0.8 && id>0.94 && iso < 0.15) || (fabs(eta) >= 0.8 && fabs(eta) < 1.479 && id>0.85 && iso < 0.15) || (fabs(eta) >= 1.479 && fabs(eta) < 2.5 && id>0.92 && iso < 0.15));
389
390 idMVAnotrig[j]=i.mvaOut;
391 idMVAtrig[j]=i.mvaOutTrig;
392
393
394 }
395 template <> void LeptonInfo::setSpecific<VHbbEvent::MuonInfo>(const VHbbEvent::MuonInfo & i, int j,const VHbbEventAuxInfo & aux){
396 dxy[j]=i.ipDb;
397 dz[j]=i.zPVPt;
398 vbtf[j]=( i.globChi2<10 && i.nPixelHits>= 1 && i.globNHits != 0 && i.nHits > 10 && i.cat & 0x1 && i.cat & 0x2 && i.nMatches >=2 && i.ipDb<.2 &&
399 (i.pfChaIso+i.pfPhoIso+i.pfNeuIso)/i.p4.Pt()<.15 && fabs(i.p4.Eta())<2.4 && i.p4.Pt()>20 ) ;
400 float mincor=0.0;
401 float minrho=0.0;
402 float rhoN = std::max(aux.puInfo.rhoNeutral,minrho);
403 float eta=i.p4.Eta();
404 float area=0.5;
405 if(fabs(eta)>0.0 && fabs(eta) <= 1.0) {area=0.674;}
406 if(fabs(eta)>1.0 && fabs(eta) <= 1.5) {area=0.565;}
407 if(fabs(eta)>1.5 && fabs(eta) <= 2.0) {area=0.442;}
408 if(fabs(eta)>2.0 && fabs(eta) <= 2.2) {area=0.515;}
409 if(fabs(eta)>2.2 && fabs(eta) <= 2.3) {area=0.821;}
410 if(fabs(eta)>2.3 && fabs(eta) <= 2.4) {area=0.660;}
411 pfCorrIso[j] = (i.pfChaIso+ std::max(i.pfPhoIso+i.pfNeuIso-rhoN*area,mincor))/i.p4.Pt();
412 id2012tight[j]= i.isPF && i. globChi2<10 && i.nPixelHits>= 1 && i.globNHits != 0 && i.nValidLayers > 5 && (i.cat & 0x2) && i.nMatches >=2 && i.ipDb<.2;
413
414
415 }
416
417
418 typedef struct
419 {
420 float et;
421 float sumet;
422 float sig;
423 float phi;
424 } METInfo;
425
426
427 typedef struct
428 {
429
430 float et[nMetUnc]; float phi[nMetUnc]; float sumet[nMetUnc];
431 template <class Input> void set(const Input & i, int j)
432 {
433 et[j]=i.p4.Pt();
434 phi[j]=i.p4.Phi();
435 sumet[j]=i.sumEt;
436
437 }
438 } METUncInfo ;
439
440
441 typedef struct
442 {
443 float mht;
444 float ht;
445 float sig;
446 float phi;
447 } MHTInfo;
448
449 typedef struct
450 {
451 float mass;
452 float pt;
453 float wMass;
454 } TopInfo;
455
456 typedef struct
457 {
458 int run;
459 int lumi;
460 int event;
461 int json;
462 } EventInfo;
463
464 typedef struct
465 {
466 void set(const VHbbEvent::SimpleJet & j, int i)
467 {
468 pt[i]=j.p4.Pt();
469 eta[i]=j.p4.Eta();
470 phi[i]=j.p4.Phi();
471 e[i]=j.p4.E();
472 csv[i]=j.csv;
473 csvivf[i]=j.csvivf;
474 cmva[i]=j.cmva;
475 numTracksSV[i] = j.vtxNTracks;
476 vtxMass[i]= j.vtxMass;
477 vtxPt[i]= j.vtxP4.Pt();
478 vtxEta[i]= j.vtxP4.Eta();
479 vtxPhi[i]= j.vtxP4.Phi();
480 vtxE[i]= j.vtxP4.E();
481 vtx3dL[i] = j.vtx3dL;
482 vtx3deL[i] = j.vtx3deL;
483 chf[i]=j.chargedHadronEFraction;
484 nhf[i] =j.neutralHadronEFraction;
485 cef[i] =j.chargedEmEFraction;
486 nef[i] =j.neutralEmEFraction;
487 nconstituents[i] =j.nConstituents;
488 nch[i]=j.ntracks;
489 SF_CSVL[i]=j.SF_CSVL;
490 SF_CSVM[i]=j.SF_CSVM;
491 SF_CSVT[i]=j.SF_CSVT;
492 SF_CSVLerr[i]=j.SF_CSVLerr;
493 SF_CSVMerr[i]=j.SF_CSVMerr;
494 SF_CSVTerr[i]=j.SF_CSVTerr;
495
496 flavour[i]=j.flavour;
497 isSemiLeptMCtruth[i]=j.isSemiLeptMCtruth;
498 isSemiLept[i]=j.isSemiLept;
499 SoftLeptpdgId[i] = j.SoftLeptpdgId;
500 SoftLeptIdlooseMu[i] = j.SoftLeptIdlooseMu;
501 SoftLeptId95[i] = j.SoftLeptId95;
502 SoftLeptPt[i] = j.SoftLeptPt;
503 SoftLeptdR[i] = j.SoftLeptdR;
504 SoftLeptptRel[i] = j.SoftLeptptRel;
505 SoftLeptRelCombIso[i] = j.SoftLeptRelCombIso;
506 if(j.bestMCp4.Pt() > 0)
507 {
508 genPt[i]=j.bestMCp4.Pt();
509 genEta[i]=j.bestMCp4.Eta();
510 genPhi[i]=j.bestMCp4.Phi();
511 }
512 JECUnc[i]=j.jecunc;
513 id[i]=jetId(i);
514 ptRaw[i]=j.ptRaw;
515 ptLeadTrack[i]=j.ptLeadTrack;
516 puJetIdL[i]=j.puJetIdL;
517 puJetIdM[i]=j.puJetIdM;
518 puJetIdT[i]=j.puJetIdT;
519 puJetIdMva[i]=j.puJetIdMva;
520
521
522 }
523 bool jetId(int i)
524 {
525 if(nhf[i] > 0.99) return false;
526 if(nef[i] > 0.99) return false;
527 if(nconstituents[i] <= 1) return false;
528 if(fabs(eta[i])<2.5) {
529 if(cef[i] > 0.99) return false;
530 if(chf[i] == 0) return false;
531 if(nch[i]== 0) return false;
532 }
533 return true;
534 }
535 void reset()
536 {
537 for(int i=0;i<MAXJ;i++) {
538 pt[i]=-99; eta[i]=-99; phi[i]=-99;e[i]=-99;csv[i]=-99;
539 csvivf[i]=-99; cmva[i]=-99;
540 cosTheta[i]=-99; numTracksSV[i]=-99; chf[i]=-99; nhf[i]=-99; cef[i]=-99; nef[i]=-99; nch[i]=-99; nconstituents[i]=-99; flavour[i]=-99; isSemiLeptMCtruth[i]=-99; isSemiLept[i]=-99;
541 SoftLeptpdgId[i] = -99; SoftLeptIdlooseMu[i] = -99; SoftLeptId95[i] = -99; SoftLeptPt[i] = -99; SoftLeptdR[i] = -99; SoftLeptptRel[i] = -99; SoftLeptRelCombIso[i] = -99;
542 genPt[i]=-99; genEta[i]=-99; genPhi[i]=-99; JECUnc[i]=-99; ptRaw[i]=-99.; ptLeadTrack[i]=-99.; puJetIdL[i]=-99; puJetIdM[i]=-99; puJetIdT[i]=-99; puJetIdMva[i]=-99;
543 }
544 }
545 float pt[MAXJ];
546 float eta[MAXJ];
547 float phi[MAXJ];
548 float e[MAXJ];
549 float csv[MAXJ];
550 float csvivf[MAXJ];
551 float cmva[MAXJ];
552 float cosTheta[MAXJ];
553 int numTracksSV[MAXJ];
554 float chf[MAXJ];
555 float nhf[MAXJ];
556 float cef[MAXJ];
557 float nef[MAXJ];
558 float nch[MAXJ];
559 float nconstituents[MAXJ];
560 float flavour[MAXJ];
561 int isSemiLept[MAXJ];
562 int isSemiLeptMCtruth[MAXJ];
563 int SoftLeptpdgId[MAXJ] ;
564 int SoftLeptIdlooseMu[MAXJ] ;
565 int SoftLeptId95[MAXJ] ;
566 float SoftLeptPt[MAXJ] ;
567 float SoftLeptdR[MAXJ] ;
568 float SoftLeptptRel[MAXJ] ;
569 float SoftLeptRelCombIso[MAXJ];
570 float genPt[MAXJ];
571 float genEta[MAXJ];
572 float genPhi[MAXJ];
573 float JECUnc[MAXJ];
574 float vtxMass[MAXJ];
575 float vtxPt[MAXJ];
576 float vtxEta[MAXJ];
577 float vtxPhi[MAXJ];
578 float vtxE[MAXJ];
579 float vtx3dL [MAXJ];
580 float vtx3deL[MAXJ];
581 bool id[MAXJ];
582 float SF_CSVL[MAXJ];
583 float SF_CSVM[MAXJ];
584 float SF_CSVT[MAXJ];
585 float SF_CSVLerr[MAXJ];
586 float SF_CSVMerr[MAXJ];
587 float SF_CSVTerr[MAXJ];
588 float ptRaw[MAXJ];
589 float ptLeadTrack[MAXJ];
590 float puJetIdL[MAXJ];
591 float puJetIdM[MAXJ];
592 float puJetIdT[MAXJ];
593 float puJetIdMva[MAXJ];
594
595 } JetInfo;
596
597 int main(int argc, char* argv[])
598 {
599 gROOT->Reset();
600
601
602
603 TTree *_outTree;
604 IVFInfo IVF;
605 SimBHadronInfo SimBs;
606 float rho,rho25,rhoN;
607 int nPVs;
608 METInfo MET;
609 METInfo fakeMET;
610 METInfo METnoPU;
611 METInfo METnoPUCh;
612 METInfo METtype1corr;
613 METInfo METtype1p2corr;
614 METInfo METnoPUtype1corr;
615 METInfo METnoPUtype1p2corr;
616
617 MHTInfo MHT;
618
619 METUncInfo metUnc;
620
621
622 TopInfo top;
623 EventInfo EVENT;
624 // JetInfo jet1,jet2, addJet1, addJet2;
625 // lepton1,lepton2;
626 JetInfo hJets, aJets, fathFilterJets, aJetsFat;
627 LeptonInfo vLeptons, aLeptons;
628 int naJets=0, nhJets=0, nfathFilterJets=0, naJetsFat=0;
629 HiggsInfo H,SVH,SimBsH;
630 FatHiggsInfo FatH;
631 genParticleInfo genZ, genZstar, genWstar, genW, genH, genB, genBbar; //add here the fatjet higgs
632 genTopInfo genTop, genTbar;
633 TrackInfo V;
634 int nvlep=0,nalep=0;
635 float lheV_pt=0; //for the Madgraph sample stitching
636 TrackSharingInfo TkSharing; // track sharing info;
637
638 float HVdPhi,HVMass,HMETdPhi,VMt,deltaPullAngle,deltaPullAngleAK7,deltaPullAngle2,deltaPullAngle2AK7,gendrcc,gendrbb, genZpt, genWpt, genHpt, weightTrig, weightTrigMay,weightTrigV4, weightTrigMET, weightTrigOrMu30, minDeltaPhijetMET, jetPt_minDeltaPhijetMET , PUweight, PUweight2011B,PUweight1DObs;
639 float PU0,PUp1,PUm1;
640
641 float weightEleRecoAndId,weightEleTrigJetMETPart, weightEleTrigElePart,weightEleTrigEleAugPart;
642 float weightTrigMET80, weightTrigMET100, weightTrig2CJet20 , weightTrigMET150 , weightTrigMET802CJet, weightTrigMET1002CJet, weightTrigMETLP ;
643
644 float weightTrig2012A, weightTrig2012ADiMuon, weightTrig2012ADiEle, weightTrig2012ASingleMuon, weightTrig2012AMuonPlusWCandPt, weightTrig2012ASingleEle;
645
646 int WplusMode,WminusMode;
647 int Vtype,nSvs=0;
648 int nSimBs=0;
649 int numJets,numBJets,eventFlav;
650 // bool isMET80_CJ80, ispfMHT150, isMET80_2CJ20,isMET65_2CJ20, isJETID,isIsoMu17;
651 bool triggerFlags[500],hbhe,ecalFlag,totalKinematics, cschaloFlag, hcallaserFlag, trackingfailureFlag ;
652
653
654 float btag1T2CSF=1.,btag2TSF=1.,btag1TSF=1.,btagA0CSF=1., btagA0TSF=1., btag2CSF=1., btag1TA1C=1.;
655 // ----------------------------------------------------------------------
656 // First Part:
657 //
658 // * enable the AutoLibraryLoader
659 // * book the histograms of interest
660 // * open the input file
661 // ----------------------------------------------------------------------
662
663 // load framework libraries
664 gSystem->Load("libFWCoreFWLite");
665 gSystem->Load("libDataFormatsFWLite");
666 AutoLibraryLoader::enable();
667
668 // parse arguments
669 if ( argc < 2 ) {
670 return 0;
671 }
672
673 std::vector<VHbbCandidate> * candZlocal = new std::vector<VHbbCandidate>;
674 std::vector<VHbbCandidate> * candWlocal = new std::vector<VHbbCandidate>;
675
676 // get the python configuration
677 PythonProcessDesc builder(argv[1]);
678 const edm::ParameterSet& in = builder.processDesc()->getProcessPSet()->getParameter<edm::ParameterSet>("fwliteInput" );
679 const edm::ParameterSet& out = builder.processDesc()->getProcessPSet()->getParameter<edm::ParameterSet>("fwliteOutput");
680 const edm::ParameterSet& ana = builder.processDesc()->getProcessPSet()->getParameter<edm::ParameterSet>("Analyzer");
681
682 std::vector<edm::LuminosityBlockRange> jsonVector;
683 if ( in.exists("lumisToProcess") )
684 {
685 std::vector<edm::LuminosityBlockRange> const & lumisTemp =
686 in.getUntrackedParameter<std::vector<edm::LuminosityBlockRange> > ("lumisToProcess");
687 jsonVector.resize( lumisTemp.size() );
688 copy( lumisTemp.begin(), lumisTemp.end(), jsonVector.begin() );
689 }
690
691 // now get each parameter
692 int maxEvents_( in.getParameter<int>("maxEvents") );
693 int skipEvents_( in.getParameter<int>("skipEvents") );
694 int runMin_( in.getParameter<int>("runMin") );
695 int runMax_( in.getParameter<int>("runMax") );
696 unsigned int outputEvery_( in.getParameter<unsigned int>("outputEvery") );
697 std::string outputFile_( out.getParameter<std::string>("fileName" ) );
698 std::vector<std::string> triggers( ana.getParameter<std::vector<std::string> >("triggers") );
699 double btagThr = ana.getParameter<double>("bJetCountThreshold" );
700 bool fromCandidate = ana.getParameter<bool>("readFromCandidates");
701 bool useHighestPtHiggsZ = ana.getParameter<bool>("useHighestPtHiggsZ");
702 bool useHighestPtHiggsW = ana.getParameter<bool>("useHighestPtHiggsW");
703 HbbCandidateFinderAlgo * algoZ = new HbbCandidateFinderAlgo(ana.getParameter<bool>("verbose"), ana.getParameter<double>("jetPtThresholdZ"),useHighestPtHiggsZ);
704 HbbCandidateFinderAlgo * algoW = new HbbCandidateFinderAlgo(ana.getParameter<bool>("verbose"), ana.getParameter<double>("jetPtThresholdW"),useHighestPtHiggsW );
705 HbbCandidateFinderAlgo * algoRecoverLowPt = new HbbCandidateFinderAlgo(ana.getParameter<bool>("verbose"), 15, true);
706
707 TriggerWeight triggerWeight(ana);
708 BTagWeight btag(2); // 2 operating points "Custom" = 0.5 and "Tight = 0.898"
709 BTagSampleEfficiency btagEff( ana.getParameter<std::string>("btagEffFileName" ).c_str() );
710
711 std::vector<std::string> inputFiles_( in.getParameter<std::vector<std::string> >("fileNames") );
712 // std::string inputFile( in.getParameter<std::string> ("fileName") );
713
714 std::string PUmcfileName_ = in.getParameter<std::string> ("PUmcfileName") ;
715 std::string PUmcfileName2011B_ = in.getParameter<std::string> ("PUmcfileName2011B") ;
716
717 std::string PUdatafileName_ = in.getParameter<std::string> ("PUdatafileName") ;
718 std::string PUdatafileName2011B_ = in.getParameter<std::string> ("PUdatafileName2011B") ;
719 std::string Weight3DfileName_ = in.getParameter<std::string> ("Weight3DfileName") ;
720
721
722
723 bool isMC_( ana.getParameter<bool>("isMC") );
724 TriggerReader trigger(isMC_);
725 TriggerReader patFilters(false);
726
727 edm::LumiReWeighting lumiWeights;
728 edm::LumiReWeighting lumiWeights1DObs;
729 edm::Lumi3DReWeighting lumiWeights2011B;
730 if(isMC_)
731 {
732 lumiWeights = edm::LumiReWeighting(PUmcfileName_,PUdatafileName_ , "pileup", "pileup");
733 lumiWeights1DObs = edm::LumiReWeighting(PUmcfileName2011B_,PUdatafileName2011B_ , "pileup", "pileup");
734
735 lumiWeights2011B = edm::Lumi3DReWeighting(PUmcfileName2011B_,PUdatafileName2011B_ , "pileup", "pileup");
736 if(Weight3DfileName_!="")
737 { lumiWeights2011B.weight3D_init(Weight3DfileName_.c_str()); }
738 else
739 {
740 lumiWeights2011B.weight3D_init(1.0); // generate the weights the fisrt time;
741 }
742
743 }
744
745 // TFile *_outPUFile = new TFile((outputFile_+"_PU").c_str(), "recreate");
746 TFile *_outFile = new TFile(outputFile_.c_str(), "recreate");
747 TH1F * count = new TH1F("Count","Count", 1,0,2 );
748 TH1F * countWithPU = new TH1F("CountWithPU","CountWithPU", 1,0,2 );
749 TH1F * countWithPU2011B = new TH1F("CountWithPU2011B","CountWithPU2011B", 1,0,2 );
750 TH3F * input3DPU = new TH3F("Input3DPU","Input3DPU", 36,-0.5,35.5,36,-0.5,35.5, 36,-0.5,35.5 );
751
752 TH1F * pu = new TH1F("pileup","",51,-0.5,50.5);
753 _outTree = new TTree("tree", "myTree");
754
755 _outTree->Branch("H" , &H , "HiggsFlag/I:mass/F:pt/F:eta:phi/F:dR/F:dPhi/F:dEta/F");
756 _outTree->Branch("V" , &V , "mass/F:pt/F:eta:phi/F");
757 _outTree->Branch("FatH" , &FatH , "FatHiggsFlag/I:mass/F:pt/F:eta:phi/F:filteredmass/F:filteredpt/F:filteredeta/F:filteredphi/F");
758 _outTree->Branch("lheV_pt" , &lheV_pt , "lheV_pt/F");
759 _outTree->Branch("genZ" , &genZ , "mass/F:pt/F:eta:phi/F:status/F:charge:momid/F");
760 _outTree->Branch("genZstar" , &genZstar , "mass/F:pt/F:eta:phi/F:status/F:charge:momid/F");
761 _outTree->Branch("genW" , &genW , "mass/F:pt/F:eta:phi/F:status/F:charge:momid/F");
762 _outTree->Branch("genWstar" , &genWstar , "mass/F:pt/F:eta:phi/F:status/F:charge:momid/F");
763 _outTree->Branch("genH" , &genH , "mass/F:pt/F:eta:phi/F:status/F:charge:momid/F");
764 _outTree->Branch("genB" , &genB , "mass/F:pt/F:eta:phi/F:status/F:charge:momid/F");
765 _outTree->Branch("genBbar" , &genBbar , "mass/F:pt/F:eta:phi/F:status/F:charge:momid/F");
766
767 _outTree->Branch("genTop" , &genTop , "bmass/F:bpt/F:beta:bphi/F:bstatus/F:wdau1mass/F:wdau1pt/F:wdau1eta:wdau1phi/F:wdau1id/F:wdau2mass/F:wdau2pt/F:wdau2eta:wdau2phi/F:wdau2id/F");
768 _outTree->Branch("genTbar" , &genTbar , "bmass/F:bpt/F:beta:bphi/F:bstatus/F:wdau1mass/F:wdau1pt/F:wdau1eta:wdau1phi/F:wdau1id/F:wdau2mass/F:wdau2pt/F:wdau2eta:wdau2phi/F:wdau2id/F");
769
770 _outTree->Branch("TkSharing", &TkSharing, "HiggsCSVtkSharing/b:HiggsIPtkSharing:HiggsSVtkSharing:FatHiggsCSVtkSharing:FatHiggsIPtkSharing:FatHiggsSVtkSharing");
771
772 _outTree->Branch("nhJets" , &nhJets , "nhJets/I");
773 _outTree->Branch("nfathFilterJets", &nfathFilterJets, "nfathFilterJets/I");
774 _outTree->Branch("naJets" , &naJets , "naJets/I");
775
776
777
778 _outTree->Branch("hJet_pt",hJets.pt ,"pt[nhJets]/F");
779 _outTree->Branch("hJet_eta",hJets.eta ,"eta[nhJets]/F");
780 _outTree->Branch("hJet_phi",hJets.phi ,"phi[nhJets]/F");
781 _outTree->Branch("hJet_e",hJets.e ,"e[nhJets]/F");
782 _outTree->Branch("hJet_csv",hJets.csv ,"csv[nhJets]/F");
783 _outTree->Branch("hJet_csvivf",hJets.csvivf ,"csvivf[nhJets]/F");
784 _outTree->Branch("hJet_cmva",hJets.cmva ,"cmva[nhJets]/F");
785 _outTree->Branch("hJet_cosTheta",hJets.cosTheta ,"cosTheta[nhJets]/F");
786 _outTree->Branch("hJet_numTracksSV",hJets.numTracksSV ,"numTracksSV[nhJets]/I");
787 _outTree->Branch("hJet_chf",hJets.chf ,"chf[nhJets]/F");
788 _outTree->Branch("hJet_nhf",hJets.nhf ,"nhf[nhJets]/F");
789 _outTree->Branch("hJet_cef",hJets.cef ,"cef[nhJets]/F");
790 _outTree->Branch("hJet_nef",hJets.nef ,"nef[nhJets]/F");
791 _outTree->Branch("hJet_nch",hJets.nch ,"nch[nhJets]/F");
792 _outTree->Branch("hJet_nconstituents",hJets.nconstituents ,"nconstituents[nhJets]");
793 _outTree->Branch("hJet_flavour",hJets.flavour ,"flavour[nhJets]/F");
794 _outTree->Branch("hJet_isSemiLept",hJets.isSemiLept ,"isSemiLept[nhJets]/I");
795 _outTree->Branch("hJet_isSemiLeptMCtruth",hJets.isSemiLeptMCtruth ,"isSemiLeptMCtruth[nhJets]/I");
796 _outTree->Branch("hJet_SoftLeptpdgId", hJets.SoftLeptpdgId , "SoftLeptpdgId[nhJets]/I");
797 _outTree->Branch("hJet_SoftLeptIdlooseMu", hJets.SoftLeptIdlooseMu , "SoftLeptIdlooseMu[nhJets]/I");
798 _outTree->Branch("hJet_SoftLeptId95", hJets.SoftLeptId95 , "SoftLeptId95[nhJets]/I");
799 _outTree->Branch("hJet_SoftLeptPt", hJets.SoftLeptPt , "SoftLeptPt[nhJets]/F");
800 _outTree->Branch("hJet_SoftLeptdR", hJets.SoftLeptdR , "SoftLeptdR[nhJets]/F");
801 _outTree->Branch("hJet_SoftLeptptRel", hJets.SoftLeptptRel , "SoftLeptptRel[nhJets]/F");
802 _outTree->Branch("hJet_SoftLeptRelCombIso", hJets.SoftLeptRelCombIso , "SoftLeptRelCombIso[nhJets]/F");
803 _outTree->Branch("hJet_genPt",hJets.genPt ,"genPt[nhJets]/F");
804 _outTree->Branch("hJet_genEta",hJets.genEta ,"genEta[nhJets]/F");
805 _outTree->Branch("hJet_genPhi",hJets.genPhi ,"genPhi[nhJets]/F");
806 _outTree->Branch("hJet_JECUnc",hJets.JECUnc ,"JECUnc[nhJets]/F");
807 _outTree->Branch("hJet_vtxMass",hJets.vtxMass ,"vtxMass[nhJets]/F");
808 _outTree->Branch("hJet_vtxPt",hJets.vtxPt ,"vtxPt[nhJets]/F");
809 _outTree->Branch("hJet_vtxEta",hJets.vtxEta ,"vtxEta[nhJets]/F");
810 _outTree->Branch("hJet_vtxPhi",hJets.vtxPhi ,"vtxPhi[nhJets]/F");
811 _outTree->Branch("hJet_vtxE",hJets.vtxE ,"vtxE[nhJets]/F");
812 _outTree->Branch("hJet_vtx3dL",hJets.vtx3dL ,"vtx3dL[nhJets]/F");
813 _outTree->Branch("hJet_vtx3deL",hJets.vtx3deL ,"vtx3deL[nhJets]/F");
814 _outTree->Branch("hJet_id",hJets.id ,"id[nhJets]/b");
815 _outTree->Branch("hJet_SF_CSVL",hJets.SF_CSVL ,"SF_CSVL[nhJets]/b");
816 _outTree->Branch("hJet_SF_CSVM",hJets.SF_CSVM ,"SF_CSVM[nhJets]/b");
817 _outTree->Branch("hJet_SF_CSVT",hJets.SF_CSVT ,"SF_CSVT[nhJets]/b");
818 _outTree->Branch("hJet_SF_CSVLerr",hJets.SF_CSVLerr ,"SF_CSVLerr[nhJets]/b");
819 _outTree->Branch("hJet_SF_CSVMerr",hJets.SF_CSVMerr ,"SF_CSVMerr[nhJets]/b");
820 _outTree->Branch("hJet_SF_CSVTerr",hJets.SF_CSVTerr ,"SF_CSVTerr[nhJets]/b");
821 _outTree->Branch("hJet_ptRaw",hJets.ptRaw ,"ptRaw[nhJets]/F");
822 _outTree->Branch("hJet_ptLeadTrack",hJets.ptLeadTrack ,"ptLeadTrack[nhJets]/F");
823 _outTree->Branch("hJet_puJetIdL",hJets.puJetIdL ,"puJetIdL[nhJets]/F");
824 _outTree->Branch("hJet_puJetIdM",hJets.puJetIdM ,"puJetIdM[nhJets]/F");
825 _outTree->Branch("hJet_puJetIdT",hJets.puJetIdT ,"puJetIdT[nhJets]/F");
826 _outTree->Branch("hJet_puJetIdMva",hJets.puJetIdMva ,"puJetIdMva[nhJets]/F");
827
828 _outTree->Branch("fathFilterJets_pt",fathFilterJets.pt ,"pt[nfathFilterJets]/F");
829 _outTree->Branch("fathFilterJets_eta",fathFilterJets.eta ,"eta[nfathFilterJets]/F");
830 _outTree->Branch("fathFilterJets_phi",fathFilterJets.phi ,"phi[nfathFilterJets]/F");
831 _outTree->Branch("fathFilterJets_e",fathFilterJets.e ,"e[nfathFilterJets]/F");
832 _outTree->Branch("fathFilterJets_csv",fathFilterJets.csv ,"csv[nfathFilterJets]/F");
833 _outTree->Branch("fathFilterJets_chf",fathFilterJets.chf ,"chf[nfathFilterJets]/F");
834 _outTree->Branch("fathFilterJets_ptRaw",fathFilterJets.ptRaw ,"ptRaw[nfathFilterJets]/F");
835 _outTree->Branch("fathFilterJets_ptLeadTrack",fathFilterJets.ptLeadTrack ,"ptLeadTrack[nfathFilterJets]/F");
836 _outTree->Branch("fathFilterJets_flavour",fathFilterJets.flavour ,"flavour[nfathFilterJets]/F");
837 _outTree->Branch("fathFilterJets_isSemiLept",fathFilterJets.isSemiLept ,"isSemiLept[nfathFilterJets]/F");
838 _outTree->Branch("fathFilterJets_isSemiLeptMCtruth",fathFilterJets.isSemiLeptMCtruth ,"isSemiLeptMCtruth[nfathFilterJets]/F");
839 _outTree->Branch("fathFilterJets_genPt",fathFilterJets.genPt ,"genPt[nfathFilterJets]/F");
840 _outTree->Branch("fathFilterJets_genEta",fathFilterJets.genEta ,"genEta[nfathFilterJets]/F");
841 _outTree->Branch("fathFilterJets_genPhi",fathFilterJets.genPhi ,"genPhi[nfathFilterJets]/F");
842 _outTree->Branch("fathFilterJets_vtxMass",fathFilterJets.vtxMass ,"vtxMass[nfathFilterJets]/F");
843 _outTree->Branch("fathFilterJets_vtx3dL",fathFilterJets.vtx3dL ,"vtx3dL[nfathFilterJets]/F");
844 _outTree->Branch("fathFilterJets_vtx3deL",fathFilterJets.vtx3deL ,"vtx3deL[nfathFilterJets]/F");
845 _outTree->Branch("fathFilterJets_vtxPt",fathFilterJets.vtxPt ,"vtxPt[nfathFilterJets]/F");
846 _outTree->Branch("fathFilterJets_vtxEta",fathFilterJets.vtxEta ,"vtxEta[nfathFilterJets]/F");
847 _outTree->Branch("fathFilterJets_vtxPhi",fathFilterJets.vtxPhi ,"vtxPhi[nfathFilterJets]/F");
848 _outTree->Branch("fathFilterJets_vtxE",fathFilterJets.vtxE ,"vtxE[nfathFilterJets]/F");
849
850
851 // _outTree->Branch("fathFilterJets_pt",fathFilterJets.pt ,"pt[nfathFilterJets]/F");
852 // _outTree->Branch("fathFilterJets_eta",fathFilterJets.eta ,"eta[nfathFilterJets]/F");
853 // _outTree->Branch("fathFilterJets_phi",fathFilterJets.phi ,"phi[nfathFilterJets]/F");
854 // _outTree->Branch("fathFilterJets_e",fathFilterJets.e ,"e[nfathFilterJets]/F");
855 // _outTree->Branch("fathFilterJets_csv",fathFilterJets.csv ,"csv[nfathFilterJets]/F");
856 _outTree->Branch("fathFilterJets_csvivf",fathFilterJets.csvivf ,"csvivf[nfathFilterJets]/F");
857 _outTree->Branch("fathFilterJets_cmva",fathFilterJets.cmva ,"cmva[nfathFilterJets]/F");
858 // _outTree->Branch("fathFilterJets_flavour",fathFilterJets.flavour ,"flavour[nfathFilterJets]/F");
859
860
861 _outTree->Branch("aJet_pt",aJets.pt ,"pt[naJets]/F");
862 _outTree->Branch("aJet_eta",aJets.eta ,"eta[naJets]/F");
863 _outTree->Branch("aJet_phi",aJets.phi ,"phi[naJets]/F");
864 _outTree->Branch("aJet_e",aJets.e ,"e[naJets]/F");
865 _outTree->Branch("aJet_csv",aJets.csv ,"csv[naJets]/F");
866 _outTree->Branch("aJet_csvivf",aJets.csvivf ,"csvivf[naJets]/F");
867 _outTree->Branch("aJet_cmva",aJets.cmva ,"cmva[naJets]/F");
868 _outTree->Branch("aJet_cosTheta",aJets.cosTheta ,"cosTheta[naJets]/F");
869 _outTree->Branch("aJet_numTracksSV",aJets.numTracksSV ,"numTracksSV[naJets]/I");
870 _outTree->Branch("aJet_chf",aJets.chf ,"chf[naJets]/F");
871 _outTree->Branch("aJet_nhf",aJets.nhf ,"nhf[naJets]/F");
872 _outTree->Branch("aJet_cef",aJets.cef ,"cef[naJets]/F");
873 _outTree->Branch("aJet_nef",aJets.nef ,"nef[naJets]/F");
874 _outTree->Branch("aJet_nch",aJets.nch ,"nch[naJets]/F");
875 _outTree->Branch("aJet_nconstituents",aJets.nconstituents ,"nconstituents[naJets]");
876 _outTree->Branch("aJet_flavour",aJets.flavour ,"flavour[naJets]/F");
877 _outTree->Branch("aJet_isSemiLept",aJets.isSemiLept ,"isSemiLept[naJets]/I");
878 _outTree->Branch("aJet_isSemiLeptMCtruth",aJets.isSemiLeptMCtruth ,"isSemiLeptMCtruth[naJets]/I");
879 _outTree->Branch("aJet_SoftLeptpdgId",aJets.SoftLeptpdgId , "SoftLeptpdgId[naJets]/I");
880 _outTree->Branch("aJet_SoftLeptIdlooseMu", aJets.SoftLeptIdlooseMu , "SoftLeptIdlooseMu[naJets]/I");
881 _outTree->Branch("aJet_SoftLeptId95", aJets.SoftLeptId95 , "SoftLeptId95[naJets]/I");
882 _outTree->Branch("aJet_SoftLeptPt", aJets.SoftLeptPt , "SoftLeptPt[naJets]/F");
883 _outTree->Branch("aJet_SoftLeptdR", aJets.SoftLeptdR , "SoftLeptdR[naJets]/F");
884 _outTree->Branch("aJet_SoftLeptptRel", aJets.SoftLeptptRel , "SoftLeptptRel[naJets]/F");
885 _outTree->Branch("aJet_SoftLeptRelCombIso", aJets.SoftLeptRelCombIso , "SoftLeptRelCombIso[naJets]/F");
886 _outTree->Branch("aJet_puJetIdL", aJets.puJetIdL , "puJetIdL[naJets]/F");
887 _outTree->Branch("aJet_puJetIdM", aJets.puJetIdM , "puJetIdM[naJets]/F");
888 _outTree->Branch("aJet_puJetIdT", aJets.puJetIdT , "puJetIdT[naJets]/F");
889 _outTree->Branch("aJet_puJetIdMva", aJets.puJetIdMva , "puJetIdMva[naJets]/F");
890
891 _outTree->Branch("aJet_genPt",aJets.genPt ,"genPt[naJets]/F");
892 _outTree->Branch("aJet_genEta",aJets.genEta ,"genEta[naJets]/F");
893 _outTree->Branch("aJet_genPhi",aJets.genPhi ,"genPhi[naJets]/F");
894 _outTree->Branch("aJet_JECUnc",aJets.JECUnc ,"JECUnc[naJets]/F");
895 _outTree->Branch("aJet_vtxMass",aJets.vtxMass ,"vtxMass[naJets]/F");
896 _outTree->Branch("aJet_vtx3dL",aJets.vtx3dL ,"vtx3dL[naJets]/F");
897 _outTree->Branch("aJet_vtx3deL",aJets.vtx3deL ,"vtx3deL[naJets]/F");
898 _outTree->Branch("aJet_id",aJets.id ,"id[naJets]/b");
899 _outTree->Branch("aJet_SF_CSVL",aJets.SF_CSVL ,"SF_CSVL[naJets]/b");
900 _outTree->Branch("aJet_SF_CSVM",aJets.SF_CSVM ,"SF_CSVM[naJets]/b");
901 _outTree->Branch("aJet_SF_CSVT",aJets.SF_CSVT ,"SF_CSVT[naJets]/b");
902 _outTree->Branch("aJet_SF_CSVLerr",aJets.SF_CSVLerr ,"SF_CSVLerr[naJets]/b");
903 _outTree->Branch("aJet_SF_CSVMerr",aJets.SF_CSVMerr ,"SF_CSVMerr[naJets]/b");
904 _outTree->Branch("aJet_SF_CSVTerr",aJets.SF_CSVTerr ,"SF_CSVTerr[naJets]/b");
905
906 _outTree->Branch("naJetsFat" , &naJetsFat , "naJetsFat/I");
907 _outTree->Branch("aJetFat_pt",aJetsFat.pt ,"pt[naJetsFat]/F");
908 _outTree->Branch("aJetFat_eta",aJetsFat.eta ,"eta[naJetsFat]/F");
909 _outTree->Branch("aJetFat_phi",aJetsFat.phi ,"phi[naJetsFat]/F");
910 _outTree->Branch("aJetFat_e",aJetsFat.e ,"e[naJetsFat]/F");
911 _outTree->Branch("aJetFat_csv",aJetsFat.csv ,"csv[naJetsFat]/F");
912
913
914 _outTree->Branch("numJets" , &numJets , "numJets/I" );
915 _outTree->Branch("numBJets" , &numBJets , "numBJets/I" );
916 _outTree->Branch("deltaPullAngle", &deltaPullAngle , "deltaPullAngle/F");
917 _outTree->Branch("deltaPullAngle2", &deltaPullAngle2 , "deltaPullAngle2/F");
918 _outTree->Branch("gendrcc" , &gendrcc , "gendrcc/F");
919 _outTree->Branch("gendrbb" , &gendrbb , "gendrbb/F");
920 _outTree->Branch("genZpt" , &genZpt , "genZpt/F");
921 _outTree->Branch("genWpt" , &genWpt , "genWpt/F");
922 _outTree->Branch("genHpt" , &genHpt , "genHpt/F");
923 _outTree->Branch("weightTrig" , &weightTrig , "weightTrig/F");
924 _outTree->Branch("weightTrigMay" , &weightTrigMay , "weightTrigMay/F");
925 _outTree->Branch("weightTrigV4" , &weightTrigV4 , "weightTrigV4/F");
926 _outTree->Branch("weightTrigMET" , &weightTrigMET , "weightTrigMET/F");
927 _outTree->Branch("weightTrigOrMu30" , &weightTrigOrMu30 , "weightTrigOrMu30/F");
928 _outTree->Branch("weightEleRecoAndId" , &weightEleRecoAndId , "weightEleRecoAndId/F");
929 _outTree->Branch("weightEleTrigJetMETPart" , &weightEleTrigJetMETPart , "weightEleTrigJetMETPart/F");
930 _outTree->Branch("weightEleTrigElePart" , &weightEleTrigElePart , "weightEleTrigElePart/F");
931 _outTree->Branch("weightEleTrigEleAugPart" , &weightEleTrigEleAugPart , "weightEleTrigEleAugPart/F");
932
933
934 _outTree->Branch("weightTrigMET80" , &weightTrigMET80 , "weightTrigMET80/F");
935 _outTree->Branch("weightTrigMET100" , &weightTrigMET100 , "weightTrigMET100/F");
936 _outTree->Branch("weightTrig2CJet20" , &weightTrig2CJet20 , "weightTrig2CJet20/F");
937 _outTree->Branch("weightTrigMET150" , &weightTrigMET150 , "weightTrigMET150/F");
938 _outTree->Branch("weightTrigMET802CJet" , &weightTrigMET802CJet , "weightTrigMET802CJet/F");
939 _outTree->Branch("weightTrigMET1002CJet" , &weightTrigMET1002CJet , "weightTrigMET1002CJet/F");
940 _outTree->Branch("weightTrigMETLP" , &weightTrigMETLP , "weightTrigMETLP/F");
941
942 _outTree->Branch("weightTrig2012A", &weightTrig2012A,"weightTrig2012A/F");
943 _outTree->Branch("weightTrig2012ADiMuon", &weightTrig2012ADiMuon,"weightTrig2012ADiMuon/F");
944 _outTree->Branch("weightTrig2012ADiEle", &weightTrig2012ADiEle,"weightTrig2012ADiEle/F");
945 _outTree->Branch("weightTrig2012ASingleMuon", &weightTrig2012ASingleMuon,"weightTrig2012ASingleMuon/F");
946 _outTree->Branch("weightTrig2012ASingleEle", &weightTrig2012ASingleEle,"weightTrig2012ASingleEle/F");
947 _outTree->Branch("weightTrig2012AMuonPlusWCandPt", &weightTrig2012AMuonPlusWCandPt,"weightTrig2012AMuonPlusWCandPt/F");
948
949
950 _outTree->Branch("deltaPullAngleAK7", &deltaPullAngleAK7 , "deltaPullAngleAK7/F");
951 _outTree->Branch("deltaPullAngle2AK7", &deltaPullAngle2AK7 , "deltaPullAngle2AK7/F");
952 _outTree->Branch("PU0", &PU0 , "PU0/F");
953 _outTree->Branch("PUm1", &PUm1 , "PUm1/F");
954 _outTree->Branch("PUp1", &PUp1 , "PUp1/F");
955 _outTree->Branch("PUweight", &PUweight , "PUweight/F");
956 _outTree->Branch("PUweight2011B", &PUweight2011B , "PUweight2011B/F");
957 _outTree->Branch("PUweight1DObs", &PUweight1DObs , "PUweight1DObs/F");
958 _outTree->Branch("eventFlav", &eventFlav , "eventFlav/I");
959
960
961
962
963 _outTree->Branch("Vtype" , &Vtype , "Vtype/I" );
964 _outTree->Branch("HVdPhi" , &HVdPhi , "HVdPhi/F" );
965 _outTree->Branch("HVMass" , &HVMass , "HVMass/F" );
966 _outTree->Branch("HMETdPhi" , &HMETdPhi , "HMETdPhi/F" );
967 _outTree->Branch("VMt" , &VMt , "VMt/F" );
968
969 _outTree->Branch("nvlep" , &nvlep , "nvlep/I");
970 _outTree->Branch("nalep" , &nalep , "nalep/I");
971
972 _outTree->Branch("vLepton_mass",vLeptons.mass ,"mass[nvlep]/F");
973 _outTree->Branch("vLepton_pt",vLeptons.pt ,"pt[nvlep]/F");
974 _outTree->Branch("vLepton_eta",vLeptons.eta ,"eta[nvlep]");
975 _outTree->Branch("vLepton_phi",vLeptons.phi ,"phi[nvlep]/F");
976 _outTree->Branch("vLepton_aodCombRelIso",vLeptons.aodCombRelIso ,"aodCombRelIso[nvlep]/F");
977 _outTree->Branch("vLepton_pfCombRelIso",vLeptons.pfCombRelIso ,"pfCombRelIso[nvlep]/F");
978 _outTree->Branch("vLepton_photonIso",vLeptons.photonIso ,"photonIso[nvlep]/F");
979 _outTree->Branch("vLepton_neutralHadIso",vLeptons.neutralHadIso ,"neutralHadIso[nvlep]/F");
980 _outTree->Branch("vLepton_chargedHadIso",vLeptons.chargedHadIso ,"chargedHadIso[nvlep]/F");
981 _outTree->Branch("vLepton_chargedPUIso",vLeptons.chargedPUIso ,"chargedPUIso[nvlep]/F");
982 _outTree->Branch("vLepton_particleIso",vLeptons.particleIso ,"particleIso[nvlep]/F");
983 _outTree->Branch("vLepton_dxy",vLeptons.dxy ,"dxy[nvlep]/F");
984 _outTree->Branch("vLepton_dz",vLeptons.dz ,"dz[nvlep]/F");
985 _outTree->Branch("vLepton_type",vLeptons.type ,"type[nvlep]/I");
986 _outTree->Branch("vLepton_id80",vLeptons.id80 ,"id80[nvlep]/F");
987 _outTree->Branch("vLepton_id95",vLeptons.id95 ,"id95[nvlep]/F");
988 _outTree->Branch("vLepton_vbtf",vLeptons.vbtf ,"vbtf[nvlep]/F");
989 _outTree->Branch("vLepton_id80NoIso",vLeptons.id80NoIso ,"id80NoIso[nvlep]/F");
990 _outTree->Branch("vLepton_genPt",vLeptons.genPt ,"genPt[nvlep]/F");
991 _outTree->Branch("vLepton_genEta",vLeptons.genEta ,"genEta[nvlep]");
992 _outTree->Branch("vLepton_genPhi",vLeptons.genPhi ,"genPhi[nvlep]/F");
993 _outTree->Branch("vLepton_charge",vLeptons.charge ,"charge[nvlep]/F");
994 _outTree->Branch("vLepton_pfCorrIso",vLeptons.pfCorrIso,"pfCorrIso[nvlep]/F");
995 _outTree->Branch("vLepton_id2012tight",vLeptons.id2012tight,"id2012tight[nvlep]/F");
996 _outTree->Branch("vLepton_idMVAnotrig",vLeptons.idMVAnotrig,"idMVAnotrig[nvlep]/F");
997 _outTree->Branch("vLepton_idMVAtrig",vLeptons.idMVAtrig,"idMVAtrig[nvlep]/F");
998 _outTree->Branch("vLepton_innerHits",vLeptons.innerHits,"innerHits[nvlep]/F");
999 _outTree->Branch("vLepton_photonIsoDoubleCount",vLeptons.photonIsoDoubleCount,"photonIsoDoubleCount[nvlep]/F");
1000 _outTree->Branch("vLepton_wp95",vLeptons.wp95,"wp95[nvlep]/F");
1001 _outTree->Branch("vLepton_wp90",vLeptons.wp90,"wp90[nvlep]/F");
1002 _outTree->Branch("vLepton_wp85",vLeptons.wp85,"wp85[nvlep]/F");
1003 _outTree->Branch("vLepton_wp80",vLeptons.wp80,"wp80[nvlep]/F");
1004 _outTree->Branch("vLepton_wp70",vLeptons.wp70,"wp70[nvlep]/F");
1005
1006 _outTree->Branch("aLepton_mass",aLeptons.mass ,"mass[nalep]/F");
1007 _outTree->Branch("aLepton_pt",aLeptons.pt ,"pt[nalep]/F");
1008 _outTree->Branch("aLepton_eta",aLeptons.eta ,"eta[nalep]");
1009 _outTree->Branch("aLepton_phi",aLeptons.phi ,"phi[nalep]/F");
1010 _outTree->Branch("aLepton_aodCombRelIso",aLeptons.aodCombRelIso ,"aodCombRelIso[nalep]/F");
1011 _outTree->Branch("aLepton_pfCombRelIso",aLeptons.pfCombRelIso ,"pfCombRelIso[nalep]/F");
1012 _outTree->Branch("aLepton_photonIso",aLeptons.photonIso ,"photonIso[nalep]/F");
1013 _outTree->Branch("aLepton_neutralHadIso",aLeptons.neutralHadIso ,"neutralHadIso[nalep]/F");
1014 _outTree->Branch("aLepton_chargedHadIso",aLeptons.chargedHadIso ,"chargedHadIso[nalep]/F");
1015 _outTree->Branch("aLepton_chargedPUIso",aLeptons.chargedPUIso ,"chargedPUIso[nalep]/F");
1016 _outTree->Branch("aLepton_particleIso",aLeptons.particleIso ,"particleIso[nalep]/F");
1017 _outTree->Branch("aLepton_dxy",aLeptons.dxy ,"dxy[nalep]/F");
1018 _outTree->Branch("aLepton_dz",aLeptons.dz ,"dz[nalep]/F");
1019 _outTree->Branch("aLepton_type",aLeptons.type ,"type[nalep]/I");
1020 _outTree->Branch("aLepton_id80",aLeptons.id80 ,"id80[nalep]/F");
1021 _outTree->Branch("aLepton_id95",aLeptons.id95 ,"id95[nalep]/F");
1022 _outTree->Branch("aLepton_vbtf",aLeptons.vbtf ,"vbtf[nalep]/F");
1023 _outTree->Branch("aLepton_id80NoIso",aLeptons.id80NoIso ,"id80NoIso[nalep]/F");
1024 _outTree->Branch("aLepton_genPt",aLeptons.genPt ,"genPt[nalep]/F");
1025 _outTree->Branch("aLepton_genEta",aLeptons.genEta ,"genEta[nalep]");
1026 _outTree->Branch("aLepton_genPhi",aLeptons.genPhi ,"genPhi[nalep]/F");
1027 _outTree->Branch("aLepton_charge",aLeptons.charge ,"charge[nalep]/F");
1028 _outTree->Branch("aLepton_pfCorrIso",aLeptons.pfCorrIso,"pfCorrIso[nalep]/F");
1029 _outTree->Branch("aLepton_id2012tight",aLeptons.id2012tight,"id2012tight[nalep]/F");
1030 _outTree->Branch("aLepton_idMVAnotrig",aLeptons.idMVAnotrig,"idMVAnotrig[nalep]/F");
1031 _outTree->Branch("aLepton_idMVAtrig",aLeptons.idMVAtrig,"idMVAtrig[nalep]/F");
1032 _outTree->Branch("aLepton_innerHits",aLeptons.innerHits,"innerHits[nalep]/F");
1033 _outTree->Branch("aLepton_photonIsoDoubleCount",aLeptons.photonIsoDoubleCount,"photonIsoDoubleCount[nalep]/F");
1034 _outTree->Branch("aLepton_wp95",aLeptons.wp95,"wp95[nalep]/F");
1035 _outTree->Branch("aLepton_wp90",aLeptons.wp90,"wp90[nalep]/F");
1036 _outTree->Branch("aLepton_wp85",aLeptons.wp85,"wp85[nalep]/F");
1037 _outTree->Branch("aLepton_wp80",aLeptons.wp80,"wp80[nalep]/F");
1038 _outTree->Branch("aLepton_wp70",aLeptons.wp70,"wp70[nalep]/F");
1039
1040
1041 _outTree->Branch("top" , &top , "mass/F:pt/F:wMass/F");
1042 _outTree->Branch("WplusMode" , &WplusMode , "WplusMode/I");
1043 _outTree->Branch("WminusMode" , &WminusMode , "WminusMode/I");
1044
1045 //IVF
1046 _outTree->Branch("nSvs",&nSvs ,"nSvs/I");
1047 _outTree->Branch("Sv_massBCand", &IVF.massBcand,"massBcand[nSvs]/F");
1048 _outTree->Branch("Sv_massSv", &IVF.massSv,"massSv[nSvs]/F");
1049 _outTree->Branch("Sv_pt", &IVF.pt,"pt[nSvs]/F");
1050 _outTree->Branch("Sv_eta", &IVF.eta,"eta[nSvs]/F");
1051 _outTree->Branch("Sv_phi", &IVF.phi,"phi[nSvs]/F");
1052 _outTree->Branch("Sv_dist3D", &IVF.dist3D,"dist3D[nSvs]/F");
1053 _outTree->Branch("Sv_dist2D", &IVF.dist2D,"dist2D[nSvs]/F");
1054 _outTree->Branch("Sv_distSim2D", &IVF.distSig2D,"distSig2D[nSvs]/F");
1055 _outTree->Branch("Sv_distSig3D", &IVF.distSig3D,"distSig3D[nSvs]/F");
1056 _outTree->Branch("Sv_dist3D_norm", &IVF.dist3D_norm,"dist3D_norm[nSvs]/F");
1057 //IVF higgs candidate
1058 _outTree->Branch("SVH" , &SVH , "mass/F:pt/F:eta:phi/F:dR/F:dPhi/F:dEta/F");
1059
1060
1061
1062 // //SimBHadron
1063 _outTree->Branch("nSimBs",&nSimBs ,"nSimBs/I");
1064 _outTree->Branch("SimBs_mass", &SimBs.mass,"mass[nSimBs]/F");
1065 _outTree->Branch("SimBs_pt", &SimBs.pt,"pt[nSimBs]/F");
1066 _outTree->Branch("SimBs_eta", &SimBs.eta,"eta[nSimBs]/F");
1067 _outTree->Branch("SimBs_phi", &SimBs.phi,"phi[nSimBs]/F");
1068 _outTree->Branch("SimBs_vtx_x", &SimBs.vtx_x,"vtx_x[nSimBs]/F");
1069 _outTree->Branch("SimBs_vtx_y", &SimBs.vtx_y,"vtx_y[nSimBs]/F");
1070 _outTree->Branch("SimBs_vtx_z", &SimBs.vtx_z,"vtx_z[nSimBs]/F");
1071 _outTree->Branch("SimBs_pdgId", &SimBs.pdgId,"pdgId[nSimBs]/F");
1072 _outTree->Branch("SimBs_status", &SimBs.status,"status[nSimBs]/F");
1073 //SimBHadron Higgs Candidate
1074 _outTree->Branch("SimBsH" , &SimBsH , "mass/F:pt/F:eta:phi/F:dR/F:dPhi/F:dEta/F");
1075
1076 _outTree->Branch("rho" , &rho , "rho/F");
1077 _outTree->Branch("rho25" , &rho25 , "rho25/F");
1078 _outTree->Branch("rhoN" , &rhoN , "rhoN/F");
1079 _outTree->Branch("nPVs" , &nPVs , "nPVs/I");
1080 _outTree->Branch("METnoPU" , &METnoPU , "et/F:sumet:sig/F:phi/F");
1081 _outTree->Branch("METnoPUCh" , &METnoPUCh , "et/F:sumet:sig/F:phi/F");
1082 _outTree->Branch("MET" , &MET , "et/F:sumet:sig/F:phi/F");
1083 _outTree->Branch("METtype1corr" , &METtype1corr , "et/F:sumet:sig/F:phi/F");
1084 _outTree->Branch("METtype1p2corr" , &METtype1p2corr , "et/F:sumet:sig/F:phi/F");
1085 _outTree->Branch("METnoPUtype1corr" , &METnoPUtype1corr , "et/F:sumet:sig/F:phi/F");
1086 _outTree->Branch("METnoPUtype1p2corr" , &METnoPUtype1p2corr , "et/F:sumet:sig/F:phi/F");
1087
1088 _outTree->Branch("metUnc_et",&metUnc.et ,"et[24]/F");
1089 _outTree->Branch("metUnc_phi",&metUnc.phi ,"phi[24]/F");
1090 _outTree->Branch("metUnc_sumet",&metUnc.sumet ,"sumet[24]/F");
1091
1092
1093
1094 _outTree->Branch("fakeMET" , &fakeMET , "et/F:sumet:sig/F:phi/F");
1095 _outTree->Branch("MHT" , &MHT , "mht/F:ht:sig/F:phi/F");
1096 _outTree->Branch("minDeltaPhijetMET" , &minDeltaPhijetMET , "minDeltaPhijetMET/F");
1097 _outTree->Branch("jetPt_minDeltaPhijetMET" , &jetPt_minDeltaPhijetMET , "jetPt_minDeltaPhijetMET/F");
1098
1099 std::stringstream s;
1100 s << "triggerFlags[" << triggers.size() << "]/b";
1101 _outTree->Branch("triggerFlags", triggerFlags, s.str().c_str());
1102
1103 _outTree->Branch("EVENT" , &EVENT , "run/I:lumi/I:event/I:json/I");
1104 _outTree->Branch("hbhe" , &hbhe , "hbhe/b");
1105 _outTree->Branch("totalKinematics" , &totalKinematics , "totalKinematics/b");
1106 _outTree->Branch("ecalFlag" , &ecalFlag , "ecalFlag/b");
1107 _outTree->Branch("cschaloFlag" , &cschaloFlag , "cschaloFlag/b");
1108 _outTree->Branch("hcallaserFlag" , &hcallaserFlag , "hcallaserFlag/b");
1109 _outTree->Branch("trackingfailureFlag" , &trackingfailureFlag , "trackingfailureFlag/b");
1110 _outTree->Branch("btag1TSF" , &btag1TSF , "btag1TSF/F");
1111 _outTree->Branch("btag2TSF" , &btag2TSF , "btag2TSF/F");
1112 _outTree->Branch("btag1T2CSF" , &btag1T2CSF , "btag1T2CSF/F");
1113 _outTree->Branch("btag2CSF" , &btag2CSF , "btag2CSF/F");
1114 _outTree->Branch("btagA0CSF" , &btagA0CSF , "btagA0CSF/F");
1115 _outTree->Branch("btagA0TSF" , &btagA0TSF , "btagA0TSF/F");
1116 _outTree->Branch("btag1TA1C" , &btag1TA1C , "btag1TA1C/F");
1117
1118 int ievt=0;
1119 int totalcount=0;
1120
1121 // TFile* inFile = new TFile(inputFile.c_str(), "read");
1122 for(unsigned int iFile=0; iFile<inputFiles_.size(); ++iFile) {
1123 std::cout << iFile << std::endl;
1124 TFile* inFile = TFile::Open(inputFiles_[iFile].c_str());
1125 if(inFile==0) { std::cout << "FAILED " << inputFiles_[iFile] << std::endl; continue; }
1126
1127 // loop the events
1128
1129 fwlite::Event ev(inFile);
1130 fwlite::Handle< VHbbEventAuxInfo > vhbbAuxHandle;
1131 for(ev.toBegin(); !ev.atEnd() ; ++ev, ++ievt)
1132 {
1133 if (ievt <= skipEvents_) continue;
1134 if (maxEvents_ >= 0){
1135 if (ievt > maxEvents_ + skipEvents_) break;
1136 }
1137 const char * lab = "HbbAnalyzerNew";
1138 vhbbAuxHandle.getByLabel(ev,lab,0,0);
1139 const VHbbEventAuxInfo & aux = *vhbbAuxHandle.product();
1140 EVENT.run = ev.id().run();
1141 EVENT.lumi = ev.id().luminosityBlock();
1142 EVENT.event = ev.id().event();
1143 EVENT.json = jsonContainsEvent (jsonVector, ev);
1144
1145 if(EVENT.run < runMin_ && runMin_ > 0) continue;
1146 if(EVENT.run > runMax_ && runMax_ > 0) continue;
1147
1148 count->Fill(1.);
1149
1150
1151
1152 /*
1153 Handle<std::vector< PileupSummaryInfo > > PupInfo;
1154 event.getByLabel(edm::InputTag("addPileupInfo"), PupInfo);
1155 std::vector<PileupSummaryInfo>::const_iterator PVI;
1156 float Tnpv = -1;
1157 for(PVI = PupInfo->begin(); PVI != PupInfo->end(); ++PVI) {
1158 int BX = PVI->getBunchCrossing();
1159 if(BX == 0) {
1160 Tnpv = PVI->getTrueNumInteractions();
1161 continue;
1162 }
1163
1164 }
1165 double MyWeight = LumiWeights_.weight( Tnpv );
1166 double MyWeight = LumiWeights_.weight( (*iEventB) );
1167 */
1168
1169
1170 PUweight=1.;
1171 PUweight2011B=1.;
1172 PUweight1DObs=1.;
1173 if(isMC_){
1174
1175 // PU weights // Run2011A
1176 std::map<int, unsigned int>::const_iterator puit = aux.puInfo.pus.find(0);
1177 int npu =puit->second ;
1178 PUweight = lumiWeights.weight( (int) aux.puInfo.truePU ); //use new method with "true PU"
1179 pu->Fill(puit->second);
1180 // PU weight Run2011B
1181 // PU weight Run2011B
1182 std::map<int, unsigned int>::const_iterator puit0 = aux.puInfo.pus.find(0);
1183 std::map<int, unsigned int>::const_iterator puitm1 = aux.puInfo.pus.find(-1);
1184 std::map<int, unsigned int>::const_iterator puitp1 = aux.puInfo.pus.find(+1);
1185 PU0=puit0->second;
1186 PUp1=puitp1->second;
1187 PUm1=puitm1->second;
1188 input3DPU->Fill(PUm1,PU0,PUp1);
1189 PUweight2011B = lumiWeights2011B.weight3D( puitm1->second, puit0->second,puitp1->second);
1190 PUweight1DObs = lumiWeights1DObs.weight( npu);
1191
1192 }
1193 countWithPU->Fill(1,PUweight);
1194 countWithPU2011B->Fill(1,PUweight2011B);
1195
1196 //LHE Infos
1197 fwlite::Handle<LHEEventProduct> evt;
1198
1199 // std::cout << "Label for lhe = " << evt.getBranchNameFor(ev,"source") << std::endl;
1200 if( !((evt.getBranchNameFor(ev,"source")).empty()) ){
1201 evt.getByLabel(ev,"source");
1202 //std::cout << "LHEEventProduct found!" << std::endl;
1203 bool lCheck=false;
1204 bool lbarCheck=false;
1205 bool vlCheck=false;
1206 bool vlbarCheck=false;
1207 int idl, idlbar;
1208 TLorentzVector l,lbar,vl,vlbar,V_tlv;
1209 const lhef::HEPEUP hepeup_ = evt->hepeup();
1210 const std::vector<lhef::HEPEUP::FiveVector> pup_ = hepeup_.PUP; // px, py, pz, E, M
1211 for(unsigned int i=0; i<pup_.size(); ++i){
1212 int id=hepeup_.IDUP[i]; //pdgId
1213
1214 if(id==11){ l.SetPxPyPzE(hepeup_.PUP[i][0],hepeup_.PUP[i][1],hepeup_.PUP[i][2],hepeup_.PUP[i][3]); lCheck=true;}
1215 if(id==-11){ lbar.SetPxPyPzE(hepeup_.PUP[i][0],hepeup_.PUP[i][1],hepeup_.PUP[i][2],hepeup_.PUP[i][3]); lbarCheck=true;}
1216 if(id==12){ vl.SetPxPyPzE(hepeup_.PUP[i][0],hepeup_.PUP[i][1],hepeup_.PUP[i][2],hepeup_.PUP[i][3]); vlCheck=true;}
1217 if(id==-12){ vlbar.SetPxPyPzE(hepeup_.PUP[i][0],hepeup_.PUP[i][1],hepeup_.PUP[i][2],hepeup_.PUP[i][3]); vlbarCheck=true;}
1218
1219 if(id==13){ l.SetPxPyPzE(hepeup_.PUP[i][0],hepeup_.PUP[i][1],hepeup_.PUP[i][2],hepeup_.PUP[i][3]); lCheck=true;}
1220 if(id==-13){ lbar.SetPxPyPzE(hepeup_.PUP[i][0],hepeup_.PUP[i][1],hepeup_.PUP[i][2],hepeup_.PUP[i][3]); lbarCheck=true;}
1221 if(id==14){ vl.SetPxPyPzE(hepeup_.PUP[i][0],hepeup_.PUP[i][1],hepeup_.PUP[i][2],hepeup_.PUP[i][3]); vlCheck=true;}
1222 if(id==-14){ vlbar.SetPxPyPzE(hepeup_.PUP[i][0],hepeup_.PUP[i][1],hepeup_.PUP[i][2],hepeup_.PUP[i][3]); vlbarCheck=true;}
1223
1224 if(id==15){ l.SetPxPyPzE(hepeup_.PUP[i][0],hepeup_.PUP[i][1],hepeup_.PUP[i][2],hepeup_.PUP[i][3]); lCheck=true;}
1225 if(id==-15){ lbar.SetPxPyPzE(hepeup_.PUP[i][0],hepeup_.PUP[i][1],hepeup_.PUP[i][2],hepeup_.PUP[i][3]); lbarCheck=true;}
1226 if(id==16){ vl.SetPxPyPzE(hepeup_.PUP[i][0],hepeup_.PUP[i][1],hepeup_.PUP[i][2],hepeup_.PUP[i][3]); vlCheck=true;}
1227 if(id==-16){ vlbar.SetPxPyPzE(hepeup_.PUP[i][0],hepeup_.PUP[i][1],hepeup_.PUP[i][2],hepeup_.PUP[i][3]); vlbarCheck=true;}
1228
1229 }
1230 if( lCheck && lbarCheck ) V_tlv = l + lbar; // ZtoLL
1231 if( vlCheck && vlbarCheck ) V_tlv = vl + vlbar; // ZtoNuNu
1232 if( lCheck && vlbarCheck ) V_tlv = l + vlbar; // WToLNu
1233 if( lbarCheck && vlCheck ) V_tlv = lbar + vl; // WToLNu
1234 lheV_pt = V_tlv.Pt();
1235 }
1236
1237 //std::cout << "lhe V pt = " << lheV_pt << std::endl;
1238
1239 //Write event info
1240
1241 // simBHadrons
1242 const SimBHadronCollection *sbhc;
1243 if(isMC_){
1244 fwlite::Handle<SimBHadronCollection> SBHC;
1245 SBHC.getByLabel(ev, "bhadrons");
1246 sbhc = SBHC.product();
1247 }
1248
1249 const std::vector<VHbbCandidate> * candZ ;
1250 const std::vector<VHbbCandidate> * candW ;
1251 VHbbEvent modifiedEvent;;
1252 const VHbbEvent * iEvent =0;
1253 if(fromCandidate)
1254 {
1255 fwlite::Handle< std::vector<VHbbCandidate> > vhbbCandHandleZ;
1256 vhbbCandHandleZ.getByLabel(ev,"hbbBestCSVPt20Candidates");
1257 candZ = vhbbCandHandleZ.product();
1258
1259 fwlite::Handle< std::vector<VHbbCandidate> > vhbbCandHandle;
1260 vhbbCandHandle.getByLabel(ev,"hbbHighestPtHiggsPt30Candidates");
1261 candW = vhbbCandHandle.product();
1262 }
1263 else
1264 {
1265 candZlocal->clear();
1266 candWlocal->clear();
1267 fwlite::Handle< VHbbEvent > vhbbHandle;
1268 vhbbHandle.getByLabel(ev,"HbbAnalyzerNew");
1269 modifiedEvent = *vhbbHandle.product();
1270 if(isMC_)
1271 {
1272 iEvent= &modifiedEvent;
1273
1274 for(size_t j=0; j< modifiedEvent.simpleJets2.size() ; j++)
1275 {
1276 TLorentzVector & p4 = modifiedEvent.simpleJets2[j].p4;
1277 TLorentzVector & mcp4 = modifiedEvent.simpleJets2[j].bestMCp4;
1278 if ((fabs(p4.Pt() - mcp4.Pt())/ p4.Pt())<0.5) { //Limit the effect to the core
1279 float cor = (p4.Pt()+resolutionBias(fabs(p4.Eta()))*(p4.Pt()-mcp4.Pt()))/p4.Pt();
1280 p4.SetPtEtaPhiE(p4.Pt()*cor,p4.Eta(), p4.Phi(), p4.E()*cor);
1281 }
1282 }
1283 } else
1284 {
1285 iEvent = vhbbHandle.product();
1286 }
1287
1288 algoZ->run(iEvent,*candZlocal,aux);
1289 algoW->run(iEvent,*candWlocal,aux);
1290
1291
1292 if(candZlocal->size() == 0 or candZlocal->at(0).H.jets.size() < 2) //recover low pt
1293 {
1294 candZlocal->clear();
1295 candWlocal->clear();
1296 algoRecoverLowPt->run(iEvent,*candZlocal,aux);
1297 algoRecoverLowPt->run(iEvent,*candWlocal,aux);
1298 }
1299
1300 candZ= candZlocal;
1301 candW= candWlocal;
1302 /* for(size_t m=0;m<iEvent->muInfo.size();m++)
1303 {
1304
1305 if( fabs(iEvent->muInfo[m].p4.Pt()-28.118684) < 0.0001 ||
1306 fabs(iEvent->muInfo[m].p4.Pt()-34.853199) < 0.0001 )
1307 {
1308 std::cout << "FOUND " << iEvent->muInfo[m].p4.Pt() << " " << EVENT.event << " " << candW->size() << " " << candZ->size() << std::endl;
1309 }
1310 }
1311 */
1312
1313 }
1314
1315 const std::vector<VHbbCandidate> * cand = candZ;
1316
1317
1318
1319 /* fwlite::Handle< VHbbEvent > vhbbHandle;
1320 vhbbHandle.getByLabel(ev,"HbbAnalyzerNew");
1321 const VHbbEvent iEvent = *vhbbHandle.product();
1322 */
1323
1324 // std::clog << "Filling tree "<< std::endl;
1325 bool isW=false;
1326
1327 // to check how much we gain with jets subtraction
1328
1329
1330
1331 genHpt=aux.mcH.size() > 0 ? aux.mcH[0].p4.Pt():-99;
1332
1333 if(cand->size() == 0 or cand->at(0).H.jets.size() < 2) continue;
1334 //if(cand->size() == 0 ) continue;
1335 //std::cout << "cand->size() " << cand->size() << std::endl;
1336 //std::cout << "cand->at(0).H.jets.size() " << cand->at(0).H.jets.size() << std::endl;
1337 if(cand->size() > 1 )
1338 {
1339 std::cout << "MULTIPLE CANDIDATES: " << cand->size() << std::endl;
1340 }
1341 if(cand->at(0).candidateType == VHbbCandidate::Wmun || cand->at(0).candidateType == VHbbCandidate::Wen ) { cand=candW; isW=true; }
1342 if(cand->size() == 0)
1343 {
1344 // std::cout << "W event loss due to tigther cuts" << std::endl;
1345 continue;
1346 }
1347
1348
1349 // secondary vtxs
1350 fwlite::Handle<std::vector<reco::Vertex> > SVC;
1351 SVC.getByLabel(ev,"bcandidates");
1352 const std::vector<reco::Vertex> svc = *(SVC.product());
1353
1354 const VHbbCandidate & vhCand = cand->at(0);
1355 patFilters.setEvent(&ev,"VH");
1356 hbhe = patFilters.accept("hbhe");
1357 ecalFlag = patFilters.accept("ecalFilter");
1358 totalKinematics = patFilters.accept("totalKinematics");
1359 cschaloFlag = patFilters.accept("cschaloFilter");
1360 hcallaserFlag = patFilters.accept("hcallaserFilter");
1361 trackingfailureFlag = patFilters.accept("trackingfailureFilter");
1362
1363 trigger.setEvent(&ev);
1364 for(size_t j=0;j < triggers.size();j++)
1365 triggerFlags[j]=trigger.accept(triggers[j]);
1366
1367 eventFlav=0;
1368
1369
1370
1371 if(aux.mcBbar.size() > 0 || aux.mcB.size() > 0) eventFlav=5;
1372 else if(aux.mcC.size() > 0) eventFlav=4;
1373
1374
1375 Vtype = vhCand.candidateType;
1376
1377 if(vhCand.H.HiggsFlag) H.HiggsFlag=1; else H.HiggsFlag=0;
1378
1379 if(vhCand.H.HiggsFlag){
1380 H.mass = vhCand.H.p4.M();
1381 H.pt = vhCand.H.p4.Pt();
1382
1383
1384 H.eta = vhCand.H.p4.Eta();
1385 H.phi = vhCand.H.p4.Phi();
1386 }
1387
1388 if(vhCand.FatH.FatHiggsFlag) FatH.FatHiggsFlag =1; else FatH.FatHiggsFlag=0;
1389 fathFilterJets.reset();
1390 aJetsFat.reset();
1391 if(vhCand.FatH.FatHiggsFlag){
1392 FatH.mass= vhCand.FatH.p4.M();
1393 FatH.pt = vhCand.FatH.p4.Pt();
1394 if(FatH.pt!=0)
1395 {
1396 FatH.eta = vhCand.FatH.p4.Eta();
1397 }
1398 else {
1399 FatH.eta = -99.;
1400 }
1401 FatH.phi = vhCand.FatH.p4.Phi();
1402
1403
1404 // if(vhCand.FatH.FatHiggsFlag) vhCand.FatH.subjetsSize;
1405 nfathFilterJets=vhCand.FatH.subjetsSize;
1406 for( int j=0; j < nfathFilterJets; j++ ){
1407 fathFilterJets.set(vhCand.FatH.jets[j],j);
1408 }
1409
1410 if(nfathFilterJets==2){
1411 FatH.filteredmass=(vhCand.FatH.jets[0].p4+vhCand.FatH.jets[1].p4).M();
1412 FatH.filteredpt=(vhCand.FatH.jets[0].p4+vhCand.FatH.jets[1].p4).Pt();
1413 FatH.filteredeta=(vhCand.FatH.jets[0].p4+vhCand.FatH.jets[1].p4).Eta();
1414 FatH.filteredphi=(vhCand.FatH.jets[0].p4+vhCand.FatH.jets[1].p4).Phi();
1415 }
1416 else if(nfathFilterJets==3){
1417 FatH.filteredmass=(vhCand.FatH.jets[0].p4+vhCand.FatH.jets[1].p4+vhCand.FatH.jets[2].p4).M();
1418 FatH.filteredpt=(vhCand.FatH.jets[0].p4+vhCand.FatH.jets[1].p4+vhCand.FatH.jets[2].p4).Pt();
1419 FatH.filteredeta=(vhCand.FatH.jets[0].p4+vhCand.FatH.jets[1].p4+vhCand.FatH.jets[2].p4).Eta();
1420 FatH.filteredphi=(vhCand.FatH.jets[0].p4+vhCand.FatH.jets[1].p4+vhCand.FatH.jets[2].p4).Phi();
1421 }
1422
1423 naJetsFat=vhCand.additionalJetsFat.size();
1424 for( int j=0; j < naJetsFat && j < MAXJ; j++ )
1425 {
1426 aJetsFat.set(vhCand.additionalJetsFat[j],j);
1427 }
1428
1429
1430 } // FatHiggsFlag
1431
1432 hJets.reset();
1433 aJets.reset();
1434 if(vhCand.H.HiggsFlag){
1435
1436 nhJets=2;
1437 hJets.set(vhCand.H.jets[0],0);
1438 hJets.set(vhCand.H.jets[1],1);
1439
1440
1441 aJets.reset();
1442
1443 naJets=vhCand.additionalJets.size();
1444 numBJets=0;
1445 if(vhCand.H.jets[0].csv> btagThr) numBJets++;
1446 if(vhCand.H.jets[1].csv> btagThr) numBJets++;
1447 for( int j=0; j < naJets && j < MAXJ; j++ )
1448 {
1449 aJets.set(vhCand.additionalJets[j],j);
1450 if(vhCand.additionalJets[j].csv> btagThr) numBJets++;
1451 }
1452 numJets = vhCand.additionalJets.size()+2;
1453 H.dR = deltaR(vhCand.H.jets[0].p4.Eta(),vhCand.H.jets[0].p4.Phi(),vhCand.H.jets[1].p4.Eta(),vhCand.H.jets[1].p4.Phi());
1454 H.dPhi = deltaPhi(vhCand.H.jets[0].p4.Phi(),vhCand.H.jets[1].p4.Phi());
1455 H.dEta= TMath::Abs( vhCand.H.jets[0].p4.Eta() - vhCand.H.jets[1].p4.Eta() );
1456 HVdPhi = fabs( deltaPhi(vhCand.H.p4.Phi(),vhCand.V.p4.Phi()) ) ;
1457 HVMass = (vhCand.H.p4 + vhCand.V.p4).M() ;
1458 HMETdPhi = fabs( deltaPhi(vhCand.H.p4.Phi(),vhCand.V.mets.at(0).p4.Phi()) ) ;
1459 //eltaPullAngle = vhCand.H.deltaTheta;
1460
1461 deltaPullAngle = VHbbCandidateTools::getDeltaTheta(vhCand.H.jets[0],vhCand.H.jets[1]);
1462 deltaPullAngle2 = VHbbCandidateTools::getDeltaTheta(vhCand.H.jets[1],vhCand.H.jets[0]);
1463 hJets.cosTheta[0]= vhCand.H.helicities[0];
1464 hJets.cosTheta[1]= vhCand.H.helicities[1];
1465 } // Higgs Flag
1466
1467 V.mass = vhCand.V.p4.M();
1468 if(isW) V.mass = vhCand.Mt();
1469 V.pt = vhCand.V.p4.Pt();
1470 V.eta = vhCand.V.p4.Eta();
1471 V.phi = vhCand.V.p4.Phi();
1472 VMt = vhCand.Mt() ;
1473
1474
1475 // METInfo calomet; METInfo tcmet; METInfo pfmet; METInfo mht; METInfo metNoPU
1476 MET.et = vhCand.V.mets.at(0).p4.Pt();
1477 MET.phi = vhCand.V.mets.at(0).p4.Phi();
1478 MET.sumet = vhCand.V.mets.at(0).sumEt;
1479 MET.sig = vhCand.V.mets.at(0).metSig;
1480
1481
1482 fakeMET.sumet = 0;
1483 fakeMET.sig = 0;
1484 fakeMET.et = 0;
1485 fakeMET.phi = 0;
1486 if( Vtype == VHbbCandidate::Zmumu) {
1487 TVector3 mu1 = vhCand.V.muons[0].p4.Vect();
1488 TVector3 mu2 = vhCand.V.muons[1].p4.Vect();
1489 // Not needed with PFMET
1490 // mu1.SetMag( mu1.Mag() - vhCand.V.muons[0].emEnergy - vhCand.V.muons[0].hadEnergy);
1491 // mu2.SetMag( mu2.Mag() - vhCand.V.muons[1].emEnergy - vhCand.V.muons[1].hadEnergy);
1492 TVector3 sum = vhCand.V.mets.at(0).p4.Vect() + mu1 + mu2;
1493 fakeMET.et = sum.Pt();
1494 fakeMET.phi = sum.Phi();
1495 fakeMET.sumet = vhCand.V.mets.at(0).sumEt - mu1.Pt() - mu2.Pt();
1496 }
1497
1498
1499
1500 METnoPU.et = iEvent->metNoPU.p4.Pt();
1501 METnoPU.phi = iEvent->metNoPU.p4.Phi();
1502 METnoPU.sumet = iEvent->metNoPU.sumEt;
1503 METnoPU.sig = iEvent->metNoPU.metSig;
1504 METnoPUCh.et = iEvent->metCh.p4.Pt();
1505 METnoPUCh.phi = iEvent->metCh.p4.Phi();
1506 METnoPUCh.sumet = iEvent->metCh.sumEt;
1507 METnoPUCh.sig = iEvent->metCh.metSig;
1508
1509 METnoPUCh.et = iEvent->metCh.p4.Pt();
1510 METnoPUCh.phi = iEvent->metCh.p4.Phi();
1511 METnoPUCh.sumet = iEvent->metCh.sumEt;
1512 METnoPUCh.sig = iEvent->metCh.metSig;
1513
1514
1515 METtype1corr.et = iEvent->pfmetType1corr.p4.Pt();
1516 METtype1corr.phi = iEvent->pfmetType1corr.p4.Phi();
1517 METtype1corr.sumet = iEvent->pfmetType1corr.sumEt;
1518 METtype1corr.sig = iEvent->pfmetType1corr.metSig;
1519
1520
1521 METtype1p2corr.et = iEvent->pfmetType1p2corr.p4.Pt();
1522 METtype1p2corr.phi = iEvent->pfmetType1p2corr.p4.Phi();
1523 METtype1p2corr.sumet = iEvent->pfmetType1p2corr.sumEt;
1524 METtype1p2corr.sig = iEvent->pfmetType1p2corr.metSig;
1525
1526
1527 METnoPUtype1corr.et = iEvent->pfmetNoPUType1corr.p4.Pt();
1528 METnoPUtype1corr.phi = iEvent->pfmetNoPUType1corr.p4.Phi();
1529 METnoPUtype1corr.sumet = iEvent->pfmetNoPUType1corr.sumEt;
1530 METnoPUtype1corr.sig = iEvent->pfmetNoPUType1corr.metSig;
1531
1532
1533 METnoPUtype1p2corr.et = iEvent->pfmetNoPUType1p2corr.p4.Pt();
1534 METnoPUtype1p2corr.phi = iEvent->pfmetNoPUType1p2corr.p4.Phi();
1535 METnoPUtype1p2corr.sumet = iEvent->pfmetNoPUType1p2corr.sumEt;
1536 METnoPUtype1p2corr.sig = iEvent->pfmetNoPUType1p2corr.metSig;
1537
1538 // std::cout << " iEvent->metUncInfo.size() " << iEvent->metUncInfo.size() << std::endl;
1539 for(size_t m=0;m<iEvent->metUncInfo.size();m++)
1540 {
1541 metUnc.set(iEvent->metUncInfo[m], m );
1542 // std::cout << "metUncInfo[" << m <<" ].et = " << metUnc.et[m] << std::endl;
1543 }
1544
1545
1546 rho = aux.puInfo.rho;
1547 rho25 = aux.puInfo.rho25;
1548 rhoN = aux.puInfo.rhoNeutral;
1549 nPVs=aux.pvInfo.nVertices;
1550
1551 if(!fromCandidate) {
1552 MHT.mht = iEvent->mht.p4.Pt();
1553 MHT.phi = iEvent->mht.p4.Phi();
1554 MHT.ht = iEvent->mht.sumEt;
1555 MHT.sig = iEvent->mht.metSig;
1556 }
1557
1558
1559 /////////
1560 // track sharing flags:
1561 ////////
1562 TkSharing.HiggsCSVtkSharing = TkSharing.HiggsIPtkSharing = TkSharing.HiggsSVtkSharing = TkSharing.FatHiggsCSVtkSharing = TkSharing.FatHiggsIPtkSharing = TkSharing.FatHiggsSVtkSharing = false;
1563
1564 // csv tracks
1565 if(vhCand.H.HiggsFlag){
1566
1567 if (vhCand.H.jets[0].csvNTracks > 0 && vhCand.H.jets[1].csvNTracks > 0){
1568 for (int t=0;t!=vhCand.H.jets[0].csvNTracks;t++){
1569 for (int ti=0;ti!=vhCand.H.jets[1].csvNTracks;ti++){
1570 if ((int)vhCand.H.jets[0].csvTrackIds[t] == (int)vhCand.H.jets[1].csvTrackIds[ti]){
1571 TkSharing.HiggsCSVtkSharing = true;
1572 }// same trackID
1573 }// loop tracks in second hjet
1574 }// loop tracks in first hjet
1575 }// if tracks in jet
1576
1577 // ip tracks
1578 if (vhCand.H.jets[0].btagNTracks > 0 && vhCand.H.jets[1].btagNTracks > 0){
1579 for (int t=0;t!=vhCand.H.jets[0].btagNTracks;t++){
1580 for (int ti=0;ti!=vhCand.H.jets[1].btagNTracks;ti++){
1581 if ((int)vhCand.H.jets[0].btagTrackIds[t] == (int)vhCand.H.jets[1].btagTrackIds[ti]){
1582 TkSharing.HiggsIPtkSharing = true;
1583 }// same trackID
1584 }// loop tracks in second hjet
1585 }// loop tracks in first hjet
1586 }// if tracks in jet
1587
1588 // sv tracks
1589 if (vhCand.H.jets[0].vtxNTracks > 0 && vhCand.H.jets[1].vtxNTracks > 0){
1590 for (int t=0;t!=vhCand.H.jets[0].vtxNTracks;t++){
1591 for (int ti=0;ti!=vhCand.H.jets[1].vtxNTracks;ti++){
1592 if ((int)vhCand.H.jets[0].vtxTrackIds[t] == (int)vhCand.H.jets[1].vtxTrackIds[ti]){
1593 TkSharing.HiggsSVtkSharing = true;
1594 }// same trackID
1595 }// loop tracks in second hjet
1596 }// loop tracks in first hjet
1597 }// if tracks in jet
1598
1599 } // Di-jet Higgs Flag
1600
1601 // tracksharing for Filtered jets:
1602 if(vhCand.FatH.FatHiggsFlag && nfathFilterJets > 1){
1603
1604 // csv tracks
1605 if (vhCand.FatH.jets[0].csvNTracks > 0 && vhCand.FatH.jets[1].csvNTracks > 0){
1606 for (int t=0;t!=vhCand.FatH.jets[0].csvNTracks;t++){
1607 for (int ti=0;ti!=vhCand.FatH.jets[1].csvNTracks;ti++){
1608 if ((int)vhCand.FatH.jets[0].csvTrackIds[t] == (int)vhCand.FatH.jets[1].csvTrackIds[ti]){
1609 TkSharing.FatHiggsCSVtkSharing = true;
1610 }// same trackID
1611 }// loop tracks in second hjet
1612 }// loop tracks in first hjet
1613 }// if tracks in jet
1614
1615 // ip tracks
1616 if (vhCand.FatH.jets[0].btagNTracks > 0 && vhCand.FatH.jets[1].btagNTracks > 0){
1617 for (int t=0;t!=vhCand.FatH.jets[0].btagNTracks;t++){
1618 for (int ti=0;ti!=vhCand.FatH.jets[1].btagNTracks;ti++){
1619 if ((int)vhCand.FatH.jets[0].btagTrackIds[t] == (int)vhCand.FatH.jets[1].btagTrackIds[ti]){
1620 TkSharing.FatHiggsIPtkSharing = true;
1621 }// same trackID
1622 }// loop tracks in second hjet
1623 }// loop tracks in first hjet
1624 }// if tracks in jet
1625
1626 // sv tracks
1627 if (vhCand.FatH.jets[0].vtxNTracks > 0 && vhCand.FatH.jets[1].vtxNTracks > 0){
1628 for (int t=0;t!=vhCand.FatH.jets[0].vtxNTracks;t++){
1629 for (int ti=0;ti!=vhCand.FatH.jets[1].vtxNTracks;ti++){
1630 if ((int)vhCand.FatH.jets[0].vtxTrackIds[t] == (int)vhCand.FatH.jets[1].vtxTrackIds[ti]){
1631 TkSharing.FatHiggsSVtkSharing = true;
1632 }// same trackID
1633 }// loop tracks in second hjet
1634 }// loop tracks in first hjet
1635 }// if tracks in jet
1636
1637 }// fatH
1638
1639 ////////
1640 ////////
1641
1642 //Secondary Vertices
1643 IVF.reset();
1644 nSvs = svc.size();
1645 const TVector3 recoPv = aux.pvInfo.firstPVInPT2;
1646 const math::XYZPoint myPv(recoPv);
1647
1648 //FAKE ERROR MATRIX
1649 // //look here for Matrix filling info http://project-mathlibs.web.cern.ch/project-mathlibs/sw/html/SMatrixDoc.html
1650 // std::vector<double> fillMatrix(6);
1651 // for (int i = 0; i<6; ++i) fillMatrix[i] = 0.;
1652 // fillMatrix[0] = TMath::Power(0.002,2);
1653 // fillMatrix[2] = TMath::Power(0.002,2);
1654 // fillMatrix[5] = TMath::Power(0.002,2);
1655 // const ROOT::Math::SMatrix<double, 3, 3, ROOT::Math::MatRepSym<double, 3> > myFakeMatrixError(fillMatrix.begin(),fillMatrix.end());
1656 // const reco::Vertex recoVtxPv(myPv, myFakeMatrixError);
1657
1658 // REAL ERROR MATRIX
1659 const reco::Vertex recoVtxPv(myPv, aux.pvInfo.efirstPVInPT2);
1660 for( int j=0; j < nSvs && j < MAXB; ++j ) {
1661 const GlobalVector flightDir = flightDirection(recoPv,svc[j]);
1662 reco::SecondaryVertex recoSv(recoVtxPv, svc[j], flightDir ,true);
1663 IVF.set( recoSv, recoPv ,j);
1664 }
1665 if(nSvs > 1){
1666 TLorentzVector BCands_H1, BCands_H2, BCands_H;
1667 BCands_H1.SetPtEtaPhiM(IVF.pt[0], IVF.eta[0], IVF.phi[0], IVF.massBcand[0]);
1668 BCands_H2.SetPtEtaPhiM(IVF.pt[1], IVF.eta[1], IVF.phi[1], IVF.massBcand[1]);
1669 BCands_H = BCands_H1 + BCands_H2;
1670 SVH.dR = deltaR(IVF.eta[0], IVF.phi[0], IVF.eta[1], IVF.phi[1] );
1671 SVH.dPhi = deltaPhi(IVF.phi[0], IVF.phi[1] );
1672 SVH.dEta = TMath::Abs(IVF.eta[0] - IVF.eta[1] );
1673 SVH.mass = BCands_H.M();
1674 SVH.pt = BCands_H.Pt();
1675 SVH.eta = BCands_H.Eta();
1676 SVH.phi = BCands_H.Phi();
1677 }
1678
1679 //SimBhadron
1680 SimBs.reset();
1681 if(isMC_){
1682 nSimBs = sbhc->size();
1683 for( int j=0; j < nSimBs && j < MAXB; ++j )
1684 SimBs.set( sbhc->at(j), j);
1685 if(nSimBs > 1){
1686 TLorentzVector SimBs_H1, SimBs_H2, SimBs_H;
1687 SimBs_H1.SetPtEtaPhiM(SimBs.pt[0], SimBs.eta[0], SimBs.phi[0], SimBs.mass[0]);
1688 SimBs_H2.SetPtEtaPhiM(SimBs.pt[1], SimBs.eta[1], SimBs.phi[1], SimBs.mass[1]);
1689 SimBs_H = SimBs_H1 + SimBs_H2;
1690 SimBsH.dR = deltaR(SimBs.eta[0], SimBs.phi[0], SimBs.eta[1], SimBs.phi[1] );
1691 SimBsH.dPhi = deltaPhi(SimBs.phi[0], SimBs.phi[1] );
1692 SimBsH.dEta = TMath::Abs(SimBs.eta[0] - SimBs.eta[1] );
1693 SimBsH.mass = SimBs_H.M();
1694 SimBsH.pt = SimBs_H.Pt();
1695 SimBsH.eta = SimBs_H.Eta();
1696 SimBsH.phi = SimBs_H.Phi();
1697 }
1698 }
1699
1700 //Loop on jets
1701 double maxBtag=-99999;
1702 minDeltaPhijetMET = 999;
1703 TLorentzVector bJet;
1704 std::vector<std::vector<BTagWeight::JetInfo> > btagJetInfos;
1705 std::vector<float> jet10eta;
1706 std::vector<float> jet10pt;
1707 std::vector<float> jet30eta;
1708 std::vector<float> jet30pt;
1709 if(fromCandidate)
1710 {
1711 //Loop on Higgs Jets
1712 for(unsigned int j=0; j < vhCand.H.jets.size(); j++ ){
1713 if (vhCand.H.jets[j].csv > maxBtag) { bJet=vhCand.H.jets[j].p4 ; maxBtag =vhCand.H.jets[j].csv; }
1714 if (fabs(deltaPhi( vhCand.V.mets.at(0).p4.Phi(), vhCand.H.jets[j].p4.Phi())) < minDeltaPhijetMET)
1715 {
1716 minDeltaPhijetMET=fabs(deltaPhi( vhCand.V.mets.at(0).p4.Phi(), vhCand.H.jets[j].p4.Phi()));
1717 jetPt_minDeltaPhijetMET=vhCand.H.jets[j].p4.Pt();
1718 }
1719 btagJetInfos.push_back(btagEff.jetInfo(vhCand.H.jets[j]));
1720 }
1721 //Loop on Additional Jets
1722 for(unsigned int j=0; j < vhCand.additionalJets.size(); j++ ){
1723 if (vhCand.additionalJets[j].csv > maxBtag) { bJet=vhCand.additionalJets[j].p4 ; maxBtag =vhCand.additionalJets[j].csv; }
1724 /* if (fabs(deltaPhi( vhCand.V.mets.at(0).p4.Phi(), vhCand.additionalJets[j].p4.Phi())) < minDeltaPhijetMET)
1725 {
1726 minDeltaPhijetMET=fabs(deltaPhi( vhCand.V.mets.at(0).p4.Phi(), vhCand.additionalJets[j].p4.Phi()));
1727 jetPt_minDeltaPhijetMET=vhCand.additionalJets[j].p4.Pt();
1728 }*/
1729 if( ( isW && ! useHighestPtHiggsW ) || ( ! isW && ! useHighestPtHiggsZ ) ) // btag SF computed using only H-jets if best-H made with dijetPt rather than best CSV
1730 {
1731 if(vhCand.additionalJets[j].p4.Pt() > 20)
1732 btagJetInfos.push_back(btagEff.jetInfo(vhCand.additionalJets[j]));
1733 }
1734 }
1735 }
1736 else
1737 {
1738 //Loop on all jets
1739 for(unsigned int j=0; j < iEvent->simpleJets2.size(); j++ ){
1740 if (iEvent->simpleJets2[j].csv > maxBtag) { bJet=iEvent->simpleJets2[j].p4 ; maxBtag =iEvent->simpleJets2[j].csv; }
1741 if ( iEvent->simpleJets2[j].p4.Pt() > 20 && fabs(iEvent->simpleJets2[j].p4.Eta()) < 2.5&& fabs(deltaPhi( vhCand.V.mets.at(0).p4.Phi(), iEvent->simpleJets2[j].p4.Phi())) < minDeltaPhijetMET)
1742 {
1743 minDeltaPhijetMET=fabs(deltaPhi( vhCand.V.mets.at(0).p4.Phi(), iEvent->simpleJets2[j].p4.Phi()));
1744 jetPt_minDeltaPhijetMET=iEvent->simpleJets2[j].p4.Pt();
1745 }
1746 if(iEvent->simpleJets2[j].p4.Pt() > 10)
1747 {
1748 jet10eta.push_back(iEvent->simpleJets2[j].p4.Eta());
1749 jet10pt.push_back(iEvent->simpleJets2[j].p4.Pt());
1750 }
1751 if(iEvent->simpleJets2[j].p4.Pt() > 30)
1752 {
1753 jet30eta.push_back(iEvent->simpleJets2[j].p4.Eta());
1754 jet30pt.push_back(iEvent->simpleJets2[j].p4.Pt());
1755 }
1756
1757 //For events made with highest CSV, all jets in the event should be taken into account for "tagging" SF (anti tagging is a mess)
1758 // because for example a light jet not used for the Higgs can have in reality a higher CSV due to SF > 1 and become a higgs jet
1759 if( ( isW && ! useHighestPtHiggsW ) || ( ! isW && ! useHighestPtHiggsZ ) )
1760 {
1761 if(iEvent->simpleJets2[j].p4.Pt() > 20 && fabs(iEvent->simpleJets2[j].p4.Eta()) < 2.5)
1762 btagJetInfos.push_back(btagEff.jetInfo(iEvent->simpleJets2[j]));
1763 }
1764 }
1765
1766 //Loop on Higgs jets
1767
1768 if(vhCand.H.HiggsFlag){
1769 for(unsigned int j=0; j < vhCand.H.jets.size(); j++ ) {
1770
1771 //if we use the highest pt pair, only the two higgs jet should be used to compute the SF because the other jets are excluded
1772 // by a criteria (pt of the dijet) that is not btag SF dependent
1773 if(!( ( isW && ! useHighestPtHiggsW ) || ( ! isW && ! useHighestPtHiggsZ ) )) {
1774 btagJetInfos.push_back(btagEff.jetInfo(vhCand.H.jets[j]));
1775 }
1776 }
1777 }// HiggsFlag
1778
1779 }
1780 vLeptons.reset();
1781 weightTrig = 1.; // better to default to 1
1782 weightTrigMay = -1.;
1783 weightTrigV4 = -1.;
1784 weightTrigOrMu30 = 1.;
1785 TLorentzVector leptonForTop;
1786 size_t firstAddMu=0;
1787 size_t firstAddEle=0;
1788 if(Vtype == VHbbCandidate::Zmumu ){
1789 vLeptons.set(vhCand.V.muons[0],0,13,aux);
1790 vLeptons.set(vhCand.V.muons[1],1,13,aux);
1791 float cweightID = triggerWeight.scaleMuID(vLeptons.pt[0],vLeptons.eta[0]) * triggerWeight.scaleMuID(vLeptons.pt[1],vLeptons.eta[1]) ;
1792 float weightTrig1 = triggerWeight.scaleMuIsoHLT(vLeptons.pt[0],vLeptons.eta[0]);
1793 float weightTrig2 = triggerWeight.scaleMuIsoHLT(vLeptons.pt[1],vLeptons.eta[1]);
1794 float cweightTrig = weightTrig1 + weightTrig2 - weightTrig1*weightTrig2;
1795 //2011
1796 weightTrig = cweightID * cweightTrig;
1797
1798 weightTrig2012ADiMuon = triggerWeight.doubleMuon2012A(vLeptons.pt[0],vLeptons.eta[0],vLeptons.pt[1],vLeptons.eta[1]);
1799 float weightTrig2012ASingleMuonMu1 = triggerWeight.singleMuon2012A(vLeptons.pt[0],vLeptons.eta[0]);
1800 float weightTrig2012ASingleMuonMu2 = triggerWeight.singleMuon2012A(vLeptons.pt[1],vLeptons.eta[1]);
1801 weightTrig2012ASingleMuon = weightTrig2012ASingleMuonMu1+weightTrig2012ASingleMuonMu2-weightTrig2012ASingleMuonMu1*weightTrig2012ASingleMuonMu2;
1802 weightTrig2012A = weightTrig2012ASingleMuon * cweightID; // FIXME: should use 2012 SF for MuID
1803
1804 nvlep=2;
1805 firstAddMu=2;
1806 }
1807 if( Vtype == VHbbCandidate::Zee ){
1808 vLeptons.set(vhCand.V.electrons[0],0,11,aux);
1809 vLeptons.set(vhCand.V.electrons[1],1,11,aux);
1810 nvlep=2;
1811 firstAddEle=2;
1812 std::vector<float> pt,eta;
1813 pt.push_back(vLeptons.pt[0]); eta.push_back(vLeptons.eta[0]);
1814 pt.push_back(vLeptons.pt[1]); eta.push_back(vLeptons.eta[1]);
1815 weightEleRecoAndId=triggerWeight.scaleID95Ele(vLeptons.pt[0],vLeptons.eta[0]) * triggerWeight.scaleRecoEle(vLeptons.pt[0],vLeptons.eta[0]) *
1816 triggerWeight.scaleID95Ele(vLeptons.pt[1],vLeptons.eta[1]) * triggerWeight.scaleRecoEle(vLeptons.pt[1],vLeptons.eta[1]);
1817 weightEleTrigElePart = triggerWeight.scaleDoubleEle17Ele8(pt,eta);
1818 weightEleTrigEleAugPart = triggerWeight.scaleDoubleEle17Ele8Aug(pt,eta);
1819 weightTrig = (weightEleTrigElePart*1.14+weightEleTrigEleAugPart*0.98 )/2.12 * weightEleRecoAndId;
1820
1821 weightTrig2012ADiEle = triggerWeight.doubleEle2012A(vLeptons.pt[0],vLeptons.eta[0],vLeptons.pt[1],vLeptons.eta[1]);
1822 float weightTrig2012ASingleEle1 = triggerWeight.singleEle2012Awp95(vLeptons.pt[0],vLeptons.eta[0]);
1823 float weightTrig2012ASingleEle2 = triggerWeight.singleEle2012Awp95(vLeptons.pt[1],vLeptons.eta[1]);
1824 weightTrig2012ASingleEle = weightTrig2012ASingleEle1+weightTrig2012ASingleEle2-weightTrig2012ASingleEle1*weightTrig2012ASingleEle2;
1825 weightTrig2012A = weightTrig2012ADiEle * weightEleRecoAndId; // FIXME: should use 2012 SF for Ele Reco and ID
1826
1827
1828 }
1829 if(Vtype == VHbbCandidate::Wmun ){
1830 leptonForTop=vhCand.V.muons[0].p4;
1831 vLeptons.set(vhCand.V.muons[0],0,13,aux);
1832 float cweightID = triggerWeight.scaleMuID(vLeptons.pt[0],vLeptons.eta[0]);
1833 float weightTrig1 = triggerWeight.scaleMuIsoHLT(vLeptons.pt[0],vLeptons.eta[0]);
1834 float cweightTrig = weightTrig1;
1835 weightTrig = cweightID * cweightTrig;
1836 float weightTrig1OrMu30 = triggerWeight.scaleMuOr30IsoHLT(vLeptons.pt[0],vLeptons.eta[0]);
1837 weightTrigOrMu30 = cweightID*weightTrig1OrMu30;
1838 weightTrig2012ASingleMuon = triggerWeight.singleMuon2012A(vLeptons.pt[0],vLeptons.eta[0]);
1839 weightTrig2012AMuonPlusWCandPt = weightTrig2012ASingleMuon +
1840 triggerWeight.muPlusWCandPt2012A_legMu(vLeptons.pt[0],vLeptons.eta[0])*triggerWeight.muPlusWCandPt2012A_legW(vhCand.V.p4.Pt(),0);
1841 weightTrig2012A = cweightID * weightTrig2012ASingleMuon; // FIXME: should use 2012 SF for mu ID
1842
1843 nvlep=1;
1844 firstAddMu=1;
1845 }
1846 if( Vtype == VHbbCandidate::Wen ){
1847 leptonForTop=vhCand.V.electrons[0].p4;
1848 vLeptons.set(vhCand.V.electrons[0],0,11,aux);
1849 nvlep=1;
1850 firstAddEle=1;
1851 weightTrigMay = triggerWeight.scaleSingleEleMay(vLeptons.pt[0],vLeptons.eta[0]);
1852 weightTrigV4 = triggerWeight.scaleSingleEleV4(vLeptons.pt[0],vLeptons.eta[0]);
1853 weightEleRecoAndId=triggerWeight.scaleID80Ele(vLeptons.pt[0],vLeptons.eta[0]) * triggerWeight.scaleRecoEle(vLeptons.pt[0],vLeptons.eta[0]);
1854 weightEleTrigJetMETPart=triggerWeight.scaleJet30Jet25(jet30pt,jet30eta)*triggerWeight.scalePFMHTEle(MET.et);
1855 weightEleTrigElePart= weightTrigV4; //this is for debugging only, checking only the V4 part
1856
1857 weightTrigMay*=weightEleRecoAndId;
1858 weightTrigV4*=weightEleRecoAndId;
1859 weightTrigV4*=weightEleTrigJetMETPart;
1860 // weightTrig = weightTrigMay * 0.187 + weightTrigV4 * (1.-0.187); //FIXME: use proper lumi if we reload 2.fb
1861 weightTrig = (weightTrigMay * 0.215 + weightTrigV4 * 1.915)/ 2.13; //FIXME: use proper lumi if we reload 2.fb
1862
1863 weightTrig2012ASingleEle = triggerWeight.singleEle2012Awp80(vLeptons.pt[0],vLeptons.eta[0]);
1864 weightTrig2012A = weightEleRecoAndId * weightTrig2012ASingleEle; // FIXME: should use 2012 SF for ele reco and ID
1865
1866
1867 }
1868
1869 if(isMC_)
1870 {
1871 weightTrigMET80 = triggerWeight.scaleMET80(MET.et);
1872 weightTrigMET100 = triggerWeight.scaleMET80(MET.et);
1873 weightTrig2CJet20 = triggerWeight.scale2CentralJet( jet10pt, jet10eta);
1874 weightTrigMET150 = triggerWeight.scaleMET150(MET.et);
1875 weightTrigMET802CJet= weightTrigMET80 * weightTrig2CJet20;
1876 weightTrigMET1002CJet= weightTrigMET100 * weightTrig2CJet20;
1877 }
1878 if( Vtype == VHbbCandidate::Znn ){
1879 nvlep=0;
1880 float weightTrig1 = triggerWeight.scaleMetHLT(vhCand.V.mets.at(0).p4.Pt());
1881 weightTrigMETLP = weightTrig1;
1882 weightTrig = weightTrigMET150 + weightTrigMET802CJet - weightTrigMET802CJet*weightTrigMET150;
1883 }
1884
1885 if(weightTrigMay < 0) weightTrigMay=weightTrig;
1886 if(weightTrigV4 < 0) weightTrigV4=weightTrig;
1887 if(!isMC_)
1888 {
1889 weightTrig = 1.;
1890 weightTrigMay = 1.;
1891 weightTrigV4 = 1.;
1892 weightEleRecoAndId= 1.;
1893 weightEleTrigJetMETPart= 1.;
1894 weightEleTrigElePart= 1.;
1895 weightEleTrigEleAugPart=1.;
1896 weightTrigMET80= 1.;
1897 weightTrigMET100= 1.;
1898 weightTrig2CJet20= 1.;
1899 weightTrigMET150= 1.;
1900 weightTrigMET802CJet= 1.;
1901 weightTrigMET1002CJet= 1.;
1902 weightTrigMETLP = 1.;
1903
1904 }
1905 aLeptons.reset();
1906 nalep=0;
1907 if(fromCandidate)
1908 {
1909 for(size_t j=firstAddMu;j< vhCand.V.muons.size();j++) aLeptons.set(vhCand.V.muons[j],nalep++,13,aux);
1910 for(size_t j=firstAddEle;j< vhCand.V.electrons.size();j++) aLeptons.set(vhCand.V.electrons[j],nalep++,11,aux);
1911 }
1912 else
1913 {
1914 for(size_t j=0;j< iEvent->muInfo.size();j++)
1915 {
1916 if((j!= vhCand.V.firstLepton && j!= vhCand.V.secondLepton) || ((Vtype != VHbbCandidate::Wmun ) && (Vtype != VHbbCandidate::Zmumu )) )
1917 aLeptons.set(iEvent->muInfo[j],nalep++,13,aux);
1918 }
1919 for(size_t j=0;j< iEvent->eleInfo.size();j++)
1920 {
1921 if((j!= vhCand.V.firstLepton && j!= vhCand.V.secondLepton) || ((Vtype != VHbbCandidate::Wen ) && (Vtype != VHbbCandidate::Zee )))
1922 aLeptons.set(iEvent->eleInfo[j],nalep++,11,aux);
1923 }
1924
1925 }
1926
1927
1928 if(isMC_)
1929 {
1930 //std::cout << "BTAGSF " << btagJetInfos.size() << " " << btag.weight<BTag1Tight2CustomFilter>(btagJetInfos) << std::endl;
1931 if ( btagJetInfos.size()< 10)
1932 {
1933 btag1T2CSF = btag.weight<BTag1Tight2CustomFilter>(btagJetInfos);
1934 btag2TSF = btag.weight<BTag2TightFilter>(btagJetInfos);
1935 btag1TSF = btag.weight<BTag1TightFilter>(btagJetInfos);
1936 btagA0CSF = btag.weight<BTagAntiMax0CustomFilter>(btagJetInfos);
1937 btagA0TSF = btag.weight<BTagAntiMax0TightFilter>(btagJetInfos);
1938 btag2CSF = btag.weight<BTag2CustomFilter>(btagJetInfos);
1939 btag1TA1C = btag.weight<BTag1TightAndMax1CustomFilter>(btagJetInfos);
1940 }
1941 else
1942 {
1943 std::cout << "WARNING: combinatorics for " << btagJetInfos.size() << " jets is too high (>=10). use SF=1 " << std::endl;
1944 //TODO: revert to random throw for this cases
1945 btag1T2CSF = 1.;
1946 btag2TSF = 1.;
1947 btag1TSF = 1.;
1948 btagA0CSF = 1.;
1949 btagA0TSF = 1.;
1950 btag2CSF = 1.;
1951 btag1TA1C = 1.;
1952 }
1953 }
1954
1955 if(maxBtag > -99999)
1956 {
1957 TopHypo topQuark = TopMassReco::topMass(leptonForTop,bJet,vhCand.V.mets.at(0).p4);
1958 top.mass = topQuark.p4.M();
1959 top.pt = topQuark.p4.Pt();
1960 top.wMass = topQuark.p4W.M();
1961 } else {
1962 top.mass = -99;
1963 top.pt = -99;
1964 top.wMass = -99;
1965 }
1966
1967
1968
1969 //FIXME: too much warnings... figure out why
1970 // gendrcc=aux.genCCDeltaR();
1971 // gendrbb=aux.genBBDeltaR();
1972
1973
1974
1975 genZpt=aux.mcZ.size() > 0 ? aux.mcZ[0].p4.Pt():-99;
1976 genWpt=aux.mcW.size() > 0 ? aux.mcW[0].p4.Pt():-99;
1977
1978 // Z* is status=3 and Nmother=2 (q and qbar)
1979 // Z is status=2 and Ndau=2 (mup and mum)
1980 for (unsigned int i=0; i<aux.mcZ.size(); i++){
1981 if (aux.mcZ[i].status==3) {
1982 genZstar.mass = aux.mcZ[i].p4.M();
1983 genZstar.pt = aux.mcZ[i].p4.Pt();
1984 genZstar.eta = aux.mcZ[i].p4.Eta();
1985 genZstar.phi = aux.mcZ[i].p4.Phi();
1986 genZstar.status = aux.mcZ[i].status;
1987 genZstar.charge = aux.mcZ[i].charge;
1988 if (aux.mcZ[i].momid!=-99) genZstar.momid = aux.mcZ[i].momid ;
1989 }
1990
1991
1992
1993 if (aux.mcZ[i].dauid.size()>1) {
1994 if ( abs(aux.mcZ[i].dauid[0])==13 || abs(aux.mcZ[i].dauid[0])==11 ) {
1995 genZ.mass = aux.mcZ[i].p4.M();
1996 genZ.pt = aux.mcZ[i].p4.Pt();
1997 genZ.eta = aux.mcZ[i].p4.Eta();
1998 genZ.phi = aux.mcZ[i].p4.Phi();
1999 genZ.status = aux.mcZ[i].status;
2000 genZ.charge = aux.mcZ[i].charge;
2001 if ( aux.mcZ[i].momid!=-99) genZ.momid = aux.mcZ[i].momid;
2002 }
2003 }
2004 }
2005
2006
2007
2008 for (unsigned int i=0; i<aux.mcW.size(); i++){
2009 if ( aux.mcW[i].momid==6 && aux.mcW[i].dauid.size()>1 ){
2010 genTop.wdau1mass= aux.mcW[i].dauFourMomentum[0].M();
2011 genTop.wdau1pt= aux.mcW[i].dauFourMomentum[0].Pt();
2012 genTop.wdau1eta= aux.mcW[i].dauFourMomentum[0].Eta();
2013 genTop.wdau1phi= aux.mcW[i].dauFourMomentum[0].Phi();
2014 genTop.wdau1id= aux.mcW[i].dauid[0];
2015
2016 genTop.wdau2mass= aux.mcW[i].dauFourMomentum[1].M();
2017 genTop.wdau2pt= aux.mcW[i].dauFourMomentum[1].Pt();
2018 genTop.wdau2eta= aux.mcW[i].dauFourMomentum[1].Eta();
2019 genTop.wdau2phi= aux.mcW[i].dauFourMomentum[1].Phi();
2020 genTop.wdau2id= aux.mcW[i].dauid[1];
2021
2022 }
2023
2024
2025 if ( aux.mcW[i].momid==-6 && aux.mcW[i].dauid.size()>1 ){
2026 genTbar.wdau1mass= aux.mcW[i].dauFourMomentum[0].M();
2027 genTbar.wdau1pt= aux.mcW[i].dauFourMomentum[0].Pt();
2028 genTbar.wdau1eta= aux.mcW[i].dauFourMomentum[0].Eta();
2029 genTbar.wdau1phi= aux.mcW[i].dauFourMomentum[0].Phi();
2030 genTbar.wdau1id= aux.mcW[i].dauid[0];
2031
2032 genTbar.wdau2mass= aux.mcW[i].dauFourMomentum[1].M();
2033 genTbar.wdau2pt= aux.mcW[i].dauFourMomentum[1].Pt();
2034 genTbar.wdau2eta= aux.mcW[i].dauFourMomentum[1].Eta();
2035 genTbar.wdau2phi= aux.mcW[i].dauFourMomentum[1].Phi();
2036 genTbar.wdau2id= aux.mcW[i].dauid[1];
2037
2038 }
2039
2040 if (aux.mcW[i].status==3 ) {
2041 genWstar.mass = aux.mcW[i].p4.M();
2042 genWstar.pt = aux.mcW[i].p4.Pt();
2043 genWstar.eta = aux.mcW[i].p4.Eta();
2044 genWstar.phi = aux.mcW[i].p4.Phi();
2045 genWstar.status = aux.mcW[i].status;
2046 genWstar.charge = aux.mcW[i].charge;
2047 if ( aux.mcW[i].momid!=-99) genWstar.momid = aux.mcW[i].momid;
2048 }
2049 if (aux.mcW[i].dauid.size()>1 && (abs(aux.mcW[i].dauid[0])==13 || abs(aux.mcW[i].dauid[0])==11 )) {
2050 genW.mass = aux.mcW[i].p4.M();
2051 genW.pt = aux.mcW[i].p4.Pt();
2052 genW.eta = aux.mcW[i].p4.Eta();
2053 genW.phi = aux.mcW[i].p4.Phi();
2054 genW.status = aux.mcW[i].status;
2055 genW.charge = aux.mcW[i].charge;
2056 if (aux.mcW[i].momid!=-99) genW.momid = aux.mcW[i].momid;
2057 }
2058 }
2059 // b coming from Higgs
2060 for (unsigned int i=0; i<aux.mcB.size(); i++){
2061 if (abs(aux.mcB[i].momid)!=5) {
2062 genB.mass = aux.mcB[i].p4.M();
2063 genB.pt = aux.mcB[i].p4.Pt();
2064 genB.eta = aux.mcB[i].p4.Eta();
2065 genB.phi = aux.mcB[i].p4.Phi();
2066 genB.status = aux.mcB[i].status;
2067 genB.charge = aux.mcB[i].charge;
2068 if (aux.mcB[i].momid!=-99) genB.momid = aux.mcB[i].momid;
2069 }
2070
2071 if ( aux.mcB[i].momid==6 ){
2072 genTop.bmass = aux.mcB[i].p4.M();
2073 genTop.bpt = aux.mcB[i].p4.Pt();
2074 genTop.beta = aux.mcB[i].p4.Eta();
2075 genTop.bphi = aux.mcB[i].p4.Phi();
2076 genTop.bstatus = aux.mcB[i].status;
2077
2078 }
2079 }
2080
2081 for (unsigned int i=0; i<aux.mcBbar.size(); i++){
2082 if (abs(aux.mcBbar[i].momid)!=5 ) {
2083 genBbar.mass = aux.mcBbar[i].p4.M();
2084 genBbar.pt = aux.mcBbar[i].p4.Pt();
2085 genBbar.eta = aux.mcBbar[i].p4.Eta();
2086 genBbar.phi = aux.mcBbar[i].p4.Phi();
2087 genBbar.status = aux.mcBbar[i].status;
2088 if (aux.mcBbar[i].momid!=-99) genBbar.momid = aux.mcBbar[i].momid;
2089 }
2090 if ( aux.mcBbar[i].momid==-6 ){
2091 genTbar.bmass = aux.mcBbar[i].p4.M();
2092 genTbar.bpt = aux.mcBbar[i].p4.Pt();
2093 genTbar.beta = aux.mcBbar[i].p4.Eta();
2094 genTbar.bphi = aux.mcBbar[i].p4.Phi();
2095 genTbar.bstatus = aux.mcBbar[i].status;
2096
2097
2098 }
2099
2100 }
2101
2102
2103
2104
2105 if (aux.mcH.size()>0) {
2106 genH.mass = aux.mcH[0].p4.M();
2107 genH.pt = aux.mcH[0].p4.Pt();
2108 genH.eta = aux.mcH[0].p4.Eta();
2109 genH.phi = aux.mcH[0].p4.Phi();
2110 genH.status = aux.mcH[0].status;
2111 genH.charge = aux.mcH[0].charge;
2112 if (aux.mcH[0].momid!=-99) genH.momid = aux.mcH[0].momid;
2113 }
2114
2115
2116
2117
2118 WminusMode=-99;
2119 WplusMode=-99;
2120 for(unsigned int j=0; j< aux.mcW.size();j++)
2121 {
2122 for(unsigned int k=0;k< aux.mcW[j].dauid.size();k++)
2123 {
2124 int idd=abs(aux.mcW[j].dauid[k]);
2125 if(idd==11 || idd==13 || idd==15|| (idd<=5 && idd >=1))
2126 {
2127 if(WminusMode==-99 && aux.mcW[j].charge ==-1) WminusMode = idd;
2128 if(WplusMode==-99 && aux.mcW[j].charge ==+1) WplusMode = idd;
2129 }
2130 }
2131 /*
2132 /// now check if a semileptonic W is also in a bjets....
2133 if ( ( (WminusMode==11 || WminusMode==13 || WminusMode==15 ) || (WplusMode==11 || WplusMode==13 || WplusMode==15 )) && deltaR(vhCand.H.jets[0].p4.Eta(),vhCand.H.jets[0].p4.Phi(), aux.mcW[j].p4.Eta(), aux.mcW[j].p4.Phi())<0.3 ) hJets.isSemiLeptMCtruth[0]=1;
2134 if ( ( (WminusMode==11 || WminusMode==13 || WminusMode==15 ) || (WplusMode==11 || WplusMode==13 || WplusMode==15 )) && deltaR(vhCand.H.jets[1].p4.Eta(),vhCand.H.jets[1].p4.Phi(), aux.mcW[j].p4.Eta(), aux.mcW[j].p4.Phi())<0.3 ) hJets.isSemiLeptMCtruth[1]=1;
2135
2136 for( int j=0; j < naJets && j < MAXJ; j++ )
2137 {
2138 if ((idd==11 || idd==13 || idd==15 ) && deltaR(vhCand.additionalJets[j].p4.Eta(),vhCand.additionalJets[j].p4.Phi(), aux.mcW[j].p4.Eta(), aux.mcW[j].p4.Phi()) <0.3) aJets.isSemiLept[j]=1;
2139
2140 }
2141 */
2142
2143 }
2144 /// Compute pull angle from AK7
2145 if(vhCand.H.HiggsFlag){
2146 if(!fromCandidate){
2147 std::vector<VHbbEvent::SimpleJet> ak7wrt1(iEvent->simpleJets3);
2148 std::vector<VHbbEvent::SimpleJet> ak7wrt2(iEvent->simpleJets3);
2149 if(ak7wrt1.size() > 1){
2150 CompareDeltaR deltaRComparatorJ1(vhCand.H.jets[0].p4);
2151 CompareDeltaR deltaRComparatorJ2(vhCand.H.jets[1].p4);
2152 std::sort( ak7wrt1.begin(),ak7wrt1.end(),deltaRComparatorJ1 );
2153 std::sort( ak7wrt2.begin(),ak7wrt2.end(),deltaRComparatorJ2 );
2154 std::vector<VHbbEvent::SimpleJet> ak7_matched;
2155 // if the matched are different save them
2156 if(ak7wrt1[0].p4.DeltaR(ak7wrt2[0].p4) > 0.1) {
2157 ak7_matched.push_back(ak7wrt1[0]);
2158 ak7_matched.push_back(ak7wrt2[0]);
2159 }
2160 // else look at the second best
2161 else{
2162 // ak7wrt1 is best
2163 if( ak7wrt1[1].p4.DeltaR(vhCand.H.jets[0].p4) < ak7wrt2[1].p4.DeltaR(vhCand.H.jets[1].p4))
2164 {
2165 ak7_matched.push_back(ak7wrt1[1]);
2166 ak7_matched.push_back(ak7wrt2[0]);
2167 }
2168 else
2169 {
2170 ak7_matched.push_back(ak7wrt1[0]);
2171 ak7_matched.push_back(ak7wrt2[1]);
2172 }
2173 }
2174 CompareJetPt ptComparator;
2175 std::sort( ak7_matched.begin(),ak7_matched.end(),ptComparator );
2176 if(ak7_matched[0].p4.DeltaR(vhCand.H.jets[0].p4) < 0.5
2177 and ak7_matched[1].p4.DeltaR(vhCand.H.jets[1].p4) < 0.5)
2178 {
2179 deltaPullAngleAK7 = VHbbCandidateTools::getDeltaTheta(ak7_matched[0],ak7_matched[1]);
2180 deltaPullAngle2AK7 = VHbbCandidateTools::getDeltaTheta(ak7_matched[1],ak7_matched[0]);
2181 }
2182 }
2183 }
2184 }//HiggsFlag
2185
2186 _outTree->Fill();
2187
2188 }// closed event loop
2189
2190 std::cout << "closing the file: " << inputFiles_[iFile] << std::endl;
2191 inFile->Close();
2192 // close input file
2193 } // loop on files
2194
2195
2196 std::cout << "Events: " << ievt <<std::endl;
2197 std::cout << "TotalCount: " << totalcount <<std::endl;
2198
2199
2200
2201 _outFile->cd();
2202
2203 _outTree->Write();
2204 _outFile->Write();
2205 _outFile->Close();
2206 return 0;
2207 }
2208
2209