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