| 6 |
|
#include <string.h> |
| 7 |
|
#include <utility> |
| 8 |
|
#include <map> |
| 9 |
< |
#include <boost/regex.hpp> |
| 9 |
> |
// #include <boost/regex.hpp> |
| 10 |
|
|
| 11 |
|
#include "TFile.h" |
| 12 |
|
#include "TChain.h" |
| 16 |
|
#include "TBranch.h" |
| 17 |
|
|
| 18 |
|
#include "ZZMatrixElement/MELA/interface/Mela.h" |
| 19 |
+ |
#include "ZZMatrixElement/MELA/interface/PseudoMELA.h" |
| 20 |
+ |
|
| 21 |
+ |
#include "PwhgWrapper.h" |
| 22 |
|
|
| 23 |
|
#include "TMVA/Reader.h" |
| 24 |
|
#include "TMVA/Tools.h" |
| 27 |
|
|
| 28 |
|
#include "KinematicsStruct.h" |
| 29 |
|
#include "AngleTuple.h" |
| 30 |
+ |
#include "TH1F.h" |
| 31 |
|
#include "filestuff.h" |
| 32 |
|
#include "Angles.h" |
| 33 |
|
#include "WeightStruct.h" |
| 34 |
+ |
#include "GenInfoStruct.h" |
| 35 |
|
#include "SampleWeight.h" |
| 36 |
|
#include "varkeepter.h" |
| 37 |
|
|
| 41 |
|
|
| 42 |
|
using namespace std; |
| 43 |
|
|
| 44 |
+ |
pwhegwrapper *wrap; |
| 45 |
+ |
|
| 46 |
|
class CtrlFlags |
| 47 |
|
{ |
| 48 |
|
public : |
| 60 |
|
flattree(false), |
| 61 |
|
multisigs(false), |
| 62 |
|
era(-1), |
| 63 |
< |
withPtY(false) |
| 63 |
> |
withPtY(false), |
| 64 |
> |
mH(0), |
| 65 |
> |
hwidth(0) |
| 66 |
|
{ }; |
| 67 |
|
~CtrlFlags() {}; |
| 68 |
|
void dump(); |
| 80 |
|
bool multisigs; |
| 81 |
|
int era; |
| 82 |
|
bool withPtY; |
| 83 |
+ |
float mH; |
| 84 |
+ |
float hwidth; |
| 85 |
|
}; |
| 86 |
|
void CtrlFlags::dump() |
| 87 |
|
{ |
| 88 |
+ |
cout << "mH : " << mH << endl; |
| 89 |
|
cout << "inputfile : " << inputfile << endl; |
| 90 |
|
cout << "inputtree : " << inputtree << endl; |
| 91 |
|
cout << "weightfile : " << weightfile << endl; |
| 100 |
|
cout << "flattree : " << flattree << endl; |
| 101 |
|
cout << "multisigs : " << multisigs << endl; |
| 102 |
|
cout << "withPtY : " << withPtY << endl; |
| 103 |
+ |
cout << "hwidth : " << hwidth << endl; |
| 104 |
|
assert(era==2011 || era==2012); |
| 105 |
|
cout << "era : " << era << endl; |
| 106 |
|
} |
| 107 |
< |
|
| 107 |
> |
PseudoMELA *psMela; |
| 108 |
|
void parse_args( int, char**, CtrlFlags & ); |
| 109 |
|
void setFracs(float mH, float mH_lo, float mH_hi, float &wgt_lo, float &wgt_hi); |
| 97 |
– |
// void setMelaVals(varkeepter *melaOutput, filestuff *fs, TString cls, Mela *mela); |
| 110 |
|
void setZzntVals(CtrlFlags &flags, varkeepter *flatoutput, filestuff *fs, TString cls, TMVA::Reader *reader=0, Mela *mela=0, TMVA::Reader *spinReader=0); |
| 111 |
|
double getWeight(TH1F *hist, float val); |
| 112 |
|
void setPtWgtHists(TString cls, TString fname, Long_t mH, TFile *wgtFile); |
| 113 |
< |
TH1F *hLoWgts,*hHiWgts; |
| 113 |
> |
//---------------------------------------------------------------------------------------- |
| 114 |
> |
map<TString,TH1F*> wgtHists; |
| 115 |
|
|
| 116 |
|
//------------------------------------------------------------ |
| 117 |
|
int main(int argc, char ** argv) |
| 118 |
|
//------------------------------------------------------------ |
| 119 |
|
{ |
| 107 |
– |
|
| 120 |
|
CtrlFlags flags; |
| 121 |
|
parse_args( argc, argv, flags); |
| 122 |
|
flags.dump(); |
| 124 |
|
assert(fopen(flags.weightfile.c_str(), "r") || flags.makeMela); |
| 125 |
|
|
| 126 |
|
TFile *pt4lWgts = TFile::Open("data/pt4l/pt4l_weights.root"); |
| 127 |
+ |
wrap = new pwhegwrapper; |
| 128 |
|
|
| 129 |
|
TString cmsswpath(CMSSW_BASE + TString("/src")); |
| 130 |
|
string xspath = (string(cmsswpath)+"/MitPhysics/data/xs.dat"); |
| 156 |
|
continue; |
| 157 |
|
} |
| 158 |
|
|
| 159 |
< |
TString cls,fname; |
| 159 |
> |
TString cls,fname,type; |
| 160 |
|
double frac,fileMass; |
| 161 |
< |
ss >> cls >> frac >> fname >> fileMass; |
| 162 |
< |
assert(cls=="gfH" || cls=="qqH" || cls=="qqZZ" || cls=="ggZZ" || cls=="lljj" || cls=="data"); |
| 161 |
> |
ss >> cls >> type >> frac >> fname >> fileMass; |
| 162 |
> |
assert(cls=="gfH" || cls=="vbfH" || cls=="vttH" || cls=="qqH" || cls=="qqZZ" || cls=="ggZZ" || cls=="lljj" || cls=="data"); |
| 163 |
|
classes.push_back(cls); |
| 164 |
|
fileNames.push_back(/*ntupledir+"/"+*/fname); |
| 165 |
|
fileFracs.push_back(frac); |
| 173 |
|
ifs.close(); |
| 174 |
|
|
| 175 |
|
// mass cut based on weightfile name ... |
| 176 |
< |
float mH = 120; |
| 177 |
< |
boost::regex expression2(".*_mH(.*)_.*"); |
| 178 |
< |
boost::cmatch match2; |
| 179 |
< |
if(boost::regex_match(flags.weightfile.c_str(), match2, expression2)) |
| 180 |
< |
mH = std::strtof(match2[1].first,NULL); |
| 176 |
> |
float mH = flags.mH; |
| 177 |
> |
// boost::regex expression2(".*_mH(.*)_.*"); |
| 178 |
> |
// boost::cmatch match2; |
| 179 |
> |
// if(boost::regex_match(flags.weightfile.c_str(), match2, expression2)) |
| 180 |
> |
// mH = std::strtof(match2[1].first,NULL); |
| 181 |
|
|
| 182 |
|
// assert(flags.wL>=0 && flags.wL < 1000 && flags.wH >= 0 && flags.wH < 1000); |
| 183 |
|
char cutstr[512]; |
| 261 |
|
float f_bdt; |
| 262 |
|
TBranch *br_bdt=0; |
| 263 |
|
varkeepter *flatoutput=0; |
| 251 |
– |
// if(flags.makeMela) { |
| 252 |
– |
// flatoutput = new varkeepter("Angles/data/melavars.txt","w",flags.output.c_str(),42,"zznt"); |
| 253 |
– |
// } else if(flags.flattree) { |
| 264 |
|
TString varfname("zzntvars"); |
| 265 |
|
if(flags.multisigs) varfname += "-multisigs"; |
| 266 |
|
flatoutput = new varkeepter("Angles/data/"+varfname+".txt","w",flags.output.c_str(),42,"zznt"); |
| 257 |
– |
// } else { |
| 258 |
– |
// fs.makeOutputFile(flags.output.c_str(),false); // don't make the fo tree |
| 259 |
– |
// br_bdt = fs.outtuple->getTree()->Branch("BDT", &f_bdt); |
| 260 |
– |
// } |
| 267 |
|
|
| 268 |
|
// |
| 269 |
|
// setup TMVA |
| 279 |
|
varmap[string(dovar)]=true; |
| 280 |
|
} |
| 281 |
|
|
| 282 |
+ |
int run,lumi,evt; |
| 283 |
|
TMVA::Reader *reader=0,*spinReader=0; |
| 284 |
|
Mela *mela=0; |
| 285 |
+ |
psMela=0; |
| 286 |
|
if(!flags.makeMela) { |
| 287 |
|
reader = new TMVA::Reader( "V" ); |
| 288 |
|
if(varmap[string("costheta1")]) reader->AddVariable( "costheta1", &fs.angles->costheta1); |
| 312 |
|
if(varmap[string("Phi1")]) spinReader->AddVariable( "Phi1", &fs.angles->Phi1); |
| 313 |
|
if(varmap[string("mZ1")]) spinReader->AddVariable( "mZ1", &reduced_mZ1); |
| 314 |
|
if(varmap[string("mZ2")]) spinReader->AddVariable( "mZ2", &reduced_mZ2); |
| 315 |
< |
if(varmap[string("pt4l")]) spinReader->AddVariable( "ZZpt/m4l", &reduced_ZZpt); |
| 316 |
< |
if(varmap[string("zzdotz1")]) spinReader->AddVariable( "ZZdotZ1/(m4l*mZ1)", &reduced_zzdotz1 ); |
| 317 |
< |
if(varmap[string("zzdotz2")]) spinReader->AddVariable( "ZZdotZ2/(m4l*mZ2)", &reduced_zzdotz2 ); |
| 318 |
< |
if(varmap[string("dphi1")]) spinReader->AddVariable( "ZZptCosDphiZ1pt", &fs.kine->ZZptZ1ptCosDphi ); |
| 319 |
< |
if(varmap[string("dphi2")]) spinReader->AddVariable( "ZZptCosDphiZ2pt", &fs.kine->ZZptZ2ptCosDphi ); |
| 320 |
< |
if(varmap[string("Z1pt")]) spinReader->AddVariable( "Z1pt/m4l", &reduced_Z1pt ); |
| 321 |
< |
if(varmap[string("Z2pt")]) spinReader->AddVariable( "Z2pt/m4l", &reduced_Z2pt ); |
| 322 |
< |
if(varmap[string("y4l")]) spinReader->AddVariable( "ZZy", &fs.kine->ZZy); |
| 315 |
> |
// if(varmap[string("pt4l")]) spinReader->AddVariable( "ZZpt/m4l", &reduced_ZZpt); |
| 316 |
> |
// if(varmap[string("zzdotz1")]) spinReader->AddVariable( "ZZdotZ1/(m4l*mZ1)", &reduced_zzdotz1 ); |
| 317 |
> |
// if(varmap[string("zzdotz2")]) spinReader->AddVariable( "ZZdotZ2/(m4l*mZ2)", &reduced_zzdotz2 ); |
| 318 |
> |
// if(varmap[string("dphi1")]) spinReader->AddVariable( "ZZptCosDphiZ1pt", &fs.kine->ZZptZ1ptCosDphi ); |
| 319 |
> |
// if(varmap[string("dphi2")]) spinReader->AddVariable( "ZZptCosDphiZ2pt", &fs.kine->ZZptZ2ptCosDphi ); |
| 320 |
> |
// if(varmap[string("Z1pt")]) spinReader->AddVariable( "Z1pt/m4l", &reduced_Z1pt ); |
| 321 |
> |
// if(varmap[string("Z2pt")]) spinReader->AddVariable( "Z2pt/m4l", &reduced_Z2pt ); |
| 322 |
> |
// if(varmap[string("y4l")]) spinReader->AddVariable( "ZZy", &fs.kine->ZZy); |
| 323 |
|
if(varmap[string("m4l")]) spinReader->AddVariable( "m4l", &fs.kine->m4l); |
| 324 |
|
else spinReader->AddSpectator("m4l", &fs.kine->m4l); |
| 325 |
+ |
spinReader->AddSpectator("run", &run); |
| 326 |
+ |
spinReader->AddSpectator("lumi", &lumi); |
| 327 |
+ |
spinReader->AddSpectator("evt", &evt); |
| 328 |
|
spinReader->BookMVA("BDTG", spinWeightFile); |
| 329 |
|
} |
| 330 |
|
} else { |
| 331 |
|
// mela = new Mela::Mela(bool usePowhegTemplate=false, int LHCsqrts=8); |
| 332 |
|
mela = new Mela(false, flags.era==2011 ? 7 : 8); |
| 333 |
+ |
if(flags.multisigs) |
| 334 |
+ |
psMela = new PseudoMELA(); |
| 335 |
|
} |
| 336 |
|
|
| 337 |
|
// |
| 364 |
|
if(ifile+1 < (int)nActuallyAddedCumulative.size() && i >= nActuallyAddedCumulative[ifile+1]) { |
| 365 |
|
ifile++; |
| 366 |
|
cout << " ientry: " << i << ", switching file to (" << classes[ifile] << "): " << fileMasses[ifile] |
| 367 |
< |
<< " so weight multiplies by: " << ((classes[ifile]=="gfH" || classes[ifile]=="qqH") ? mH_fracs[fileMasses[ifile]] : 1) << endl; |
| 367 |
> |
<< " so weight multiplies by: " << ((classes[ifile]=="gfH" || classes[ifile]=="vbfH" || classes[ifile]=="qqH") ? mH_fracs[fileMasses[ifile]] : 1) << endl; |
| 368 |
|
if(classes[ifile]=="gfH" || classes[ifile]=="qqZZ") |
| 369 |
|
setPtWgtHists(classes[ifile],fileNames[ifile],mH,pt4lWgts); |
| 370 |
|
} |
| 371 |
|
|
| 372 |
|
if( fs.kine->m4l>flags.wH || fs.kine->m4l<flags.wL ) { cout << "ERROR! shouldn't be here (already applied the cut): " << fs.kine->m4l << endl; continue; } |
| 373 |
|
|
| 374 |
< |
reduced_mZ1 = fs.kine->mZ1;//fs.kine->m4l; |
| 375 |
< |
reduced_mZ2 = fs.kine->mZ2;///fs.kine->m4l; |
| 374 |
> |
reduced_mZ1 = fs.kine->mZ1; |
| 375 |
> |
reduced_mZ2 = fs.kine->mZ2; |
| 376 |
|
reduced_ZZpt = fs.kine->ZZpt/fs.kine->m4l; |
| 377 |
|
reduced_Z1pt = fs.kine->Z1pt/fs.kine->m4l; |
| 378 |
|
reduced_Z2pt = fs.kine->Z2pt/fs.kine->m4l; |
| 379 |
|
reduced_zzdotz1 = fs.kine->ZZdotZ1/(fs.kine->m4l*fs.kine->mZ1); |
| 380 |
|
reduced_zzdotz2 = fs.kine->ZZdotZ2/(fs.kine->m4l*fs.kine->mZ2); |
| 381 |
|
|
| 382 |
< |
// if(!flags.makeMela) { |
| 370 |
< |
// f_bdt = flags.multiclass ? (reader->EvaluateMulticlass("BDTG"))[0] : reader->EvaluateMVA("BDTG"); |
| 371 |
< |
// fs.angles->bdt = f_bdt; |
| 372 |
< |
// } |
| 373 |
< |
|
| 374 |
< |
if(classes[ifile]=="gfH" || classes[ifile]=="qqH") |
| 382 |
> |
if(classes[ifile]=="gfH" || classes[ifile]=="vbfH" || classes[ifile]=="qqH") |
| 383 |
|
fs.weights->w *= mH_fracs[fileMasses[ifile]]; |
| 384 |
|
|
| 385 |
|
if(!flags.makeMela && !flags.flattree) { // shouldn't ever use this at the point |
| 386 |
+ |
assert(0); |
| 387 |
|
fs.outtuple->Fill(); |
| 388 |
|
} else { |
| 380 |
– |
// if(flags.makeMela) setMelaVals(flatoutput, &fs, classes[ifile], mela); |
| 381 |
– |
// if(flags.flattree) |
| 389 |
|
setZzntVals(flags, flatoutput, &fs, classes[ifile], reader, mela, spinReader); |
| 390 |
|
flatoutput->fill(); |
| 391 |
|
} |
| 425 |
|
{"multisigs", 0, 0, 'm'}, |
| 426 |
|
{"era", 1, 0, 'n'}, |
| 427 |
|
{"withPtY", 0, 0, 'o'}, |
| 428 |
+ |
{"mH", 1, 0, 'p'}, |
| 429 |
+ |
{"hwidth", 1, 0, 'q'}, |
| 430 |
|
{0, 0, 0, 0} |
| 431 |
|
}; |
| 432 |
|
|
| 489 |
|
case 'o': |
| 490 |
|
flags.withPtY = true; |
| 491 |
|
break; |
| 492 |
+ |
case 'p': |
| 493 |
+ |
flags.mH = strtof(optarg,NULL); |
| 494 |
+ |
break; |
| 495 |
+ |
case 'q': |
| 496 |
+ |
flags.hwidth = strtof(optarg,NULL); |
| 497 |
+ |
break; |
| 498 |
|
case '2': |
| 499 |
|
if (digit_optind != 0 && digit_optind != this_option_optind) |
| 500 |
|
printf ("digits occur in two different argv-elements.\n"); |
| 542 |
|
flatoutput->setval("won", (Double_t)fs->weights->won); |
| 543 |
|
flatoutput->setval("woff", (Double_t)fs->weights->woff); |
| 544 |
|
flatoutput->setval("npuw", (Double_t)fs->weights->npuw); |
| 545 |
< |
if(cls=="qqZZ" || cls=="gfH") { |
| 545 |
> |
|
| 546 |
> |
// set pt4l up/down weights |
| 547 |
> |
Double_t pt4lDown(1),pt4lUp(1),pt4lPdfDown(1),pt4lPdfUp(1),pt4lHresDown(1),pt4lHresUp(1); |
| 548 |
> |
if(cls=="qqZZ" || (cls=="gfH" && !fs->fname_.Contains(TRegexp("[02][mp]")))) { |
| 549 |
> |
assert(fs->get_zz_chain()->FindBranch("geninfo")); |
| 550 |
> |
assert(wgtHists["renfac_Lo"]); |
| 551 |
> |
assert(wgtHists["renfac_Hi"]); |
| 552 |
> |
assert(wgtHists["pdf_Lo"]); |
| 553 |
> |
assert(wgtHists["pdf_Hi"]); |
| 554 |
> |
pt4lDown = getWeight(wgtHists["renfac_Lo"], fs->gen->pt_zz); |
| 555 |
> |
pt4lUp = getWeight(wgtHists["renfac_Hi"], fs->gen->pt_zz); |
| 556 |
> |
pt4lPdfDown = getWeight(wgtHists["pdf_Lo"], fs->gen->pt_zz); |
| 557 |
> |
pt4lPdfUp = getWeight(wgtHists["pdf_Hi"], fs->gen->pt_zz); |
| 558 |
> |
// cout << "pt4l: " << fs->gen->pt_zz << " renfac: " << pt4lDown << " " << pt4lUp << " pdf: " << pt4lPdfDown << " " << pt4lUp; |
| 559 |
> |
if(cls != "qqZZ" ) { |
| 560 |
> |
assert(wgtHists["hres_Lo"]); |
| 561 |
> |
assert(wgtHists["hres_Hi"]); |
| 562 |
> |
pt4lHresDown = getWeight(wgtHists["hres_Lo"], fs->gen->pt_zz); |
| 563 |
> |
pt4lHresUp = getWeight(wgtHists["hres_Hi"], fs->gen->pt_zz); |
| 564 |
> |
// cout << " hres: " << pt4lHresDown << " " << pt4lHresUp; |
| 565 |
> |
} |
| 566 |
> |
// cout << endl; |
| 567 |
> |
} |
| 568 |
> |
flatoutput->setval("pt4lDown", (Double_t)pt4lDown); |
| 569 |
> |
flatoutput->setval("pt4lUp", (Double_t)pt4lUp); |
| 570 |
> |
flatoutput->setval("pt4lPdfDown", (Double_t)pt4lPdfDown); |
| 571 |
> |
flatoutput->setval("pt4lPdfUp", (Double_t)pt4lPdfUp); |
| 572 |
> |
flatoutput->setval("pt4lHresDown", (Double_t)pt4lHresDown); |
| 573 |
> |
flatoutput->setval("pt4lHresUp", (Double_t)pt4lHresUp); |
| 574 |
> |
|
| 575 |
> |
// set mH weights |
| 576 |
> |
Double_t wmH(1); |
| 577 |
> |
if((cls=="gfH" && !fs->fname_.Contains(TRegexp("[02][mp]"))) || cls=="vbfH") { |
| 578 |
|
assert(fs->get_zz_chain()->FindBranch("geninfo")); |
| 579 |
< |
flatoutput->setval("pt4lDown", (Double_t)getWeight(hLoWgts,fs->gen->pt_zz)); |
| 580 |
< |
cout << "setting pt4lDown to: " << flatoutput->getval("pt4lDown") << endl; |
| 581 |
< |
flatoutput->setval("pt4lUp", (Double_t)getWeight(hHiWgts,fs->gen->pt_zz)); |
| 582 |
< |
cout << "setting pt4lUp to: " << flatoutput->getval("pt4lUp") << endl; |
| 583 |
< |
} |
| 584 |
< |
if(flags.multisigs) { |
| 585 |
< |
assert(spinReader); |
| 539 |
< |
flatoutput->setval("SpinBDT", (Float_t)spinReader->EvaluateMVA("BDTG")); |
| 579 |
> |
GenInfoStruct gen(*fs->gen); |
| 580 |
> |
TLorentzVector genZ1,genZ2; |
| 581 |
> |
genZ1.SetPtEtaPhiM( gen.vpt_a, gen.veta_a, gen.vphi_a, gen.vmass_a); |
| 582 |
> |
genZ2.SetPtEtaPhiM( gen.vpt_b, gen.veta_b, gen.vphi_b, gen.vmass_b); |
| 583 |
> |
double genM4l = (genZ1 + genZ2).M(); |
| 584 |
> |
wmH = wrap->getweight(flags.mH, flags.hwidth, 172.5, genM4l, 1); |
| 585 |
> |
// cout << "m4l weights: " << genM4l << " " << flatoutput->getval("wmH") << endl; |
| 586 |
|
} |
| 587 |
+ |
flatoutput->setval("wmH", (Double_t)wmH); |
| 588 |
+ |
|
| 589 |
|
if(flags.makeMela) { |
| 590 |
|
assert(mela); |
| 591 |
|
TLorentzVector Z1_lept1, Z1_lept2, Z2_lept1, Z2_lept2; |
| 598 |
|
|
| 599 |
|
// NOTE: it's p.d.g. ID, so opposite sign to the charge |
| 600 |
|
int Z1_lept1Id(-1*kine.l1q*kine.l1type),Z1_lept2Id(-1*kine.l2q*kine.l2type),Z2_lept1Id(-1*kine.l3q*kine.l3type),Z2_lept2Id(-1*kine.l4q*kine.l4type); |
| 601 |
< |
float costhetastar,costheta1,costheta2,phi,phistar1,kd,psig,pbkg; |
| 554 |
< |
// cout |
| 555 |
< |
// << setw(12) << Z1_lept1.Pt() << setw(12) << Z1_lept1.Eta() << setw(12) << Z1_lept1.Phi() << setw(12) << Z1_lept1.M() << setw(12) << Z1_lept1Id << endl |
| 556 |
< |
// << setw(12) << Z1_lept2.Pt() << setw(12) << Z1_lept2.Eta() << setw(12) << Z1_lept2.Phi() << setw(12) << Z1_lept2.M() << setw(12) << Z1_lept2Id << endl |
| 557 |
< |
// << setw(12) << Z2_lept1.Pt() << setw(12) << Z2_lept1.Eta() << setw(12) << Z2_lept1.Phi() << setw(12) << Z2_lept1.M() << setw(12) << Z2_lept1Id << endl |
| 558 |
< |
// << setw(12) << Z2_lept2.Pt() << setw(12) << Z2_lept2.Eta() << setw(12) << Z2_lept2.Phi() << setw(12) << Z2_lept2.M() << setw(12) << Z2_lept2Id << endl; |
| 601 |
> |
float costhetastar,costheta1,costheta2,phi,phistar1,kd,psig,pbkg,spinKd; |
| 602 |
|
mela->computeKD(Z1_lept1, Z1_lept1Id, Z1_lept2, Z1_lept2Id, Z2_lept1, Z2_lept1Id, Z2_lept2, Z2_lept2Id, |
| 603 |
|
costhetastar, costheta1, costheta2, phi, phistar1, kd, psig, pbkg, flags.withPtY, flags.withPtY); |
| 604 |
|
|
| 605 |
|
flatoutput->setval("melaLD", (Float_t)kd); |
| 606 |
+ |
|
| 607 |
+ |
if(flags.multisigs) { |
| 608 |
+ |
assert(psMela); |
| 609 |
+ |
psMela->computeKD(Z1_lept1, Z1_lept1Id, Z1_lept2, Z1_lept2Id, Z2_lept1, Z2_lept1Id, Z2_lept2, Z2_lept2Id, |
| 610 |
+ |
spinKd, psig, pbkg); |
| 611 |
+ |
flatoutput->setval("SpinBDT", (Float_t)spinKd); |
| 612 |
+ |
} |
| 613 |
|
} else { |
| 614 |
|
assert(reader); |
| 615 |
< |
flatoutput->setval("BDT", (Float_t)(flags.multiclass ? (reader->EvaluateMulticlass("BDTG"))[0] : reader->EvaluateMVA("BDTG"))); |
| 615 |
> |
if(flags.multiclass) { |
| 616 |
> |
flatoutput->setval("BDT", (Float_t)((reader->EvaluateMulticlass("BDTG"))[0])); // signal component |
| 617 |
> |
flatoutput->setval("bkgBDT", (Float_t)((reader->EvaluateMulticlass("BDTG"))[1])); // bkg (ZZ) component |
| 618 |
> |
flatoutput->setval("bkg2BDT", (Float_t)((reader->EvaluateMulticlass("BDTG"))[2])); // bkg2 (Z+jets) component |
| 619 |
> |
} else { |
| 620 |
> |
flatoutput->setval("BDT", (Float_t)(reader->EvaluateMVA("BDTG"))); |
| 621 |
> |
} |
| 622 |
> |
if(flags.multisigs) { |
| 623 |
> |
assert(spinReader); |
| 624 |
> |
flatoutput->setval("SpinBDT", (Float_t)spinReader->EvaluateMVA("BDTG")); |
| 625 |
> |
} |
| 626 |
|
} |
| 627 |
|
} |
| 628 |
|
//---------------------------------------------------------------------------------------- |
| 635 |
|
return hist->GetBinContent(bin); |
| 636 |
|
} |
| 637 |
|
//---------------------------------------------------------------------------------------- |
| 638 |
< |
TString findClosestPtWgts(TFile *wgtFile, int mH) |
| 638 |
> |
TString findClosestPtWgts(TFile *wgtFile, int mH, TString scaleType) // scaleType is renfac, pdf, or hres |
| 639 |
|
{ |
| 640 |
|
Long_t closestMass(-1); |
| 641 |
|
TString closestMassStr; |
| 642 |
|
TList *keys = wgtFile->GetListOfKeys(); |
| 643 |
|
for(unsigned ikey=0; ikey<keys->GetEntries(); ikey++) { |
| 644 |
|
TString name(keys->At(ikey)->GetName()); |
| 645 |
< |
cout << " name: " << name << endl; |
| 586 |
< |
TString tmpName(name(TRegexp("h[0-9][0-9]*zz4l"))); |
| 587 |
< |
cout << " tmpName: " << tmpName << endl; |
| 645 |
> |
TString tmpName(name(TRegexp("h[0-9][0-9]*zz4l_"+scaleType))); |
| 646 |
|
TString massStr(tmpName(TRegexp("[0-9][0-9]*"))); |
| 589 |
– |
cout << " massStr: " << massStr << endl; |
| 647 |
|
int mass = atoi(massStr); |
| 648 |
|
if(mass<100 || mass > 1200) continue; |
| 592 |
– |
cout << " mass: " << mass << endl; |
| 649 |
|
if(abs(mass - mH) < abs(closestMass - mH)) { |
| 650 |
|
closestMass = mass; |
| 651 |
|
closestMassStr = massStr; |
| 652 |
|
} |
| 653 |
|
} |
| 654 |
|
|
| 655 |
< |
cout << "using closest mass of: " << closestMassStr << endl; |
| 655 |
> |
cout << " using closest mass of: " << closestMassStr << endl; |
| 656 |
|
return closestMassStr; |
| 657 |
|
} |
| 658 |
|
//---------------------------------------------------------------------------------------- |
| 659 |
< |
void setPtWgtHists(TString cls, TString fname, Long_t mH, TFile *wgtFile) |
| 659 |
> |
void findHist(TString cls, Long_t mH, TString fname, TFile *wgtFile, TString scaleType, TString hiLo) |
| 660 |
|
{ |
| 661 |
< |
assert(wgtFile->IsOpen()); |
| 606 |
< |
|
| 661 |
> |
assert(hiLo=="Lo" || hiLo=="Hi"); |
| 662 |
|
TString procStr; |
| 663 |
|
if(cls=="gfH") { |
| 664 |
|
procStr = TString("h")+mH+"zz4l"; |
| 669 |
|
} else assert(0); |
| 670 |
|
assert(procStr!=""); |
| 671 |
|
|
| 672 |
< |
TH1F *htest = (TH1F*)wgtFile->Get("LoWgts_"+procStr); |
| 672 |
> |
TString histName(hiLo+"Wgts_"+procStr+"_"+scaleType); |
| 673 |
> |
TH1F *htest = (TH1F*)wgtFile->Get(histName); |
| 674 |
|
TString closestMass; |
| 675 |
|
if(!htest) { |
| 676 |
< |
closestMass = findClosestPtWgts(wgtFile, mH); |
| 677 |
< |
stringstream ss; |
| 678 |
< |
ss << mH; |
| 679 |
< |
TString mHstr(ss.str()); |
| 680 |
< |
procStr.ReplaceAll(mHstr,closestMass); |
| 681 |
< |
cout << "hist name replaced with: " << procStr << endl; |
| 676 |
> |
cout << " hist name " << histName << " not found" << endl; |
| 677 |
> |
if(cls=="gfH") { |
| 678 |
> |
closestMass = findClosestPtWgts(wgtFile, mH, scaleType); |
| 679 |
> |
histName.ReplaceAll(TString("")+mH, closestMass); |
| 680 |
> |
} else { |
| 681 |
> |
histName.ReplaceAll("zz4e","zz2e2m"); // only made 2e2m for a few of them |
| 682 |
> |
histName.ReplaceAll("zz4m","zz2e2m"); |
| 683 |
> |
} |
| 684 |
> |
cout << " trying with " << histName << endl; |
| 685 |
|
} |
| 686 |
|
|
| 687 |
< |
hLoWgts = (TH1F*)wgtFile->Get("LoWgts_"+procStr); assert(hLoWgts); |
| 688 |
< |
hHiWgts = (TH1F*)wgtFile->Get("HiWgts_"+procStr); assert(hHiWgts); |
| 687 |
> |
wgtHists[scaleType+"_"+hiLo] = (TH1F*)wgtFile->Get(histName); assert(wgtHists[scaleType+"_"+hiLo]); |
| 688 |
> |
} |
| 689 |
> |
//---------------------------------------------------------------------------------------- |
| 690 |
> |
void setPtWgtHists(TString cls, TString fname, Long_t mH, TFile *wgtFile) |
| 691 |
> |
{ |
| 692 |
> |
assert(wgtFile->IsOpen()); |
| 693 |
> |
|
| 694 |
> |
findHist(cls, mH, fname, wgtFile, "renfac", "Lo"); |
| 695 |
> |
findHist(cls, mH, fname, wgtFile, "renfac", "Hi"); |
| 696 |
> |
findHist(cls, mH, fname, wgtFile, "pdf", "Lo"); |
| 697 |
> |
findHist(cls, mH, fname, wgtFile, "pdf", "Hi"); |
| 698 |
> |
if(cls=="gfH") { |
| 699 |
> |
findHist(cls, mH, fname, wgtFile, "hres", "Lo"); |
| 700 |
> |
findHist(cls, mH, fname, wgtFile, "hres", "Hi"); |
| 701 |
> |
} |
| 702 |
|
} |
