LjmetEventContent::~LjmetEventContent(){
// save tree
mpTree->Write();
// save histograms
std::map<std::string,std::map<std::string,LjmetEventContent::HistMetadata> >::iterator iMod;
std::map<std::string,LjmetEventContent::HistMetadata>::iterator iHist;
TDirectory * rootDir = mpTree->GetDirectory();
for (iMod=mDoubleHist.begin();iMod!=mDoubleHist.end();++iMod){
TDirectory * _dir = 0;
_dir = rootDir->mkdir( iMod->first.c_str() );
if (!_dir) rootDir->GetDirectory( iMod->first.c_str() );
for (iHist=iMod->second.begin();iHist!=iMod->second.end();++iHist){
std::cout << mLegend
<< "Saving " << iMod->first << "/"
<< iHist->second.GetName() << std::endl;
_dir->cd();
iHist->second.GetHist( )->SetDirectory(_dir);
iHist->second.GetHist( )->Print();
iHist->second.GetHist( )->Write();
}
}
}
void CopyDir(TDirectory *source) {
//copy all objects and subdirs of directory source as a subdir of the current directory
source->ls();
TDirectory *savdir = gDirectory;
TDirectory *adir = savdir->mkdir(source->GetName());
adir->cd();
//loop on all entries of this directory
TKey *key;
TIter nextkey(source->GetListOfKeys());
while ((key = (TKey*)nextkey())) {
const char *classname = key->GetClassName();
TClass *cl = gROOT->GetClass(classname);
if (!cl) continue;
if (cl->InheritsFrom(TDirectory::Class())) {
source->cd(key->GetName());
TDirectory *subdir = gDirectory;
adir->cd();
CopyDir(subdir);
adir->cd();
} else if (cl->InheritsFrom(TTree::Class())) {
TTree *T = (TTree*)source->Get(key->GetName());
adir->cd();
TTree *newT = T->CloneTree(-1,"fast");
newT->Write();
} else {
source->cd();
TObject *obj = key->ReadObj();
adir->cd();
obj->Write();
delete obj;
}
}
adir->SaveSelf(kTRUE);
savdir->cd();
}
/**
* @brief Write all TObjects from a given TCollection into a certain directory structure in the file
*
* @param col pointer to a TCollection-based container
* @param dirname name of a directory inside the output file to which the objects should be written
* @param subdirname optional name of a subdirectory inside dirname to which the objects should be written
*
* This method whites all TObject-based objects contained in the TCollection-based container (see ROOT documentation)
* into a directory whose name is given by dirname inside the output file. If dirname does not exist
* in the output file, it will be created. Otherwise, contents of the col collection will be appended to an existing
* directory.
*
* If the optional subdirectory name is specified (subdirname parameter, defaults to empty string) then the
* contents of the collection will be written to "dirname/subdirname". If the "subdirname" directory does not
* exist inside the "dirname" directory, it will be created.
*
*/
void JPetWriter::writeCollection(const TCollection* col, const char* dirname, const char* subdirname)
{
TDirectory* current = fFile->GetDirectory(dirname);
if (!current) {
current = fFile->mkdir(dirname);
}
assert(current);
// use a subdirectory if requested by user
if (!std::string(subdirname).empty()) {
if (current->GetDirectory(subdirname)) {
current = current->GetDirectory(subdirname);
} else {
current = current->mkdir(subdirname);
}
}
assert(current);
current->cd();
TIterator* it = col->MakeIterator();
TObject* obj;
while ((obj = it->Next())) {
obj->Write();
}
fFile->cd();
}
void store(){
if (!TClass::GetDict("NBD")) {
gROOT->ProcessLine(".L /afs/cern.ch/user/q/qixu/CMSSW_6_2_5/src/Centrality/NBD_Glauber_fit/NBD/NBDclass.C+");
}
TH1::AddDirectory(kFALSE);
int Gth=atoi(getenv("GTH"));
int sth=atoi(getenv("STH"));
NBD *l;
struct para1 var;
if(sth==0){TString dirname = "std"; var = var1; if(Gth<nGlau) l = new NBD(datafile,stdGlaulist[Gth],histoname);else l = new NBD(datafile,stdGlaulist[0],histoname);}
else if(sth==1){TString dirname ="Gri055"; var = var2; if(Gth<nGlau) l = new NBD(datafile,Gri055Glaulist[Gth],histoname);else l = new NBD(datafile,Gri055Glaulist[0],histoname);}
else {TString dirname ="Gri101"; var = var3; if(Gth<nGlau) l = new NBD(datafile,Gri101Glaulist[Gth],histoname);else l = new NBD(datafile,Gri101Glaulist[0],histoname);}
l->initmu(var.mumin,var.mumax,var.mustep);
l->initk(var.kmin,var.kmax,var.kstep);
if(Gth<nGlau)
l->initx(var.xmin,var.xmax);
else if(Gth-nGlau==0)
l->initx(var.xmin-binshift,var.xmax);
else
l->initx(var.xmin+binshift,var.xmax);
// l->fit();
if(sth==0) l->assign(bestlist1[Gth].mubest,bestlist1[Gth].kbest);
else if(sth==1) l->assign(bestlist2[Gth].mubest,bestlist2[Gth].kbest);
else l->assign(bestlist3[Gth].mubest,bestlist3[Gth].kbest);
l->initN(bin,N,method);
l->calcvar();
TFile *outfile = new TFile(outG,"Update");
if(Gth==0 && sth==0){
l->dataname.Write("dataname",TObject::kOverwrite);
l->histoname.Write("histoname",TObject::kOverwrite);
}
TDirectory *dir = outfile->GetDirectory(dirname);
if (!dir) {outfile->mkdir(dirname); TDirectory *dir = outfile->GetDirectory(dirname);}
dir->cd();
TString name;
if(Gth==0)
name = "G0";
else if(Gth<nGlau)
name = Form("Glau_%d",Gth);
else
name = Form("bin_%d",Gth-nGlau+1);
TDirectory *subdir = dir->GetDirectory(name);
if(!subdir) {dir->mkdir(name); TDirectory *subdir = dir->GetDirectory(name);}
subdir->cd();
l->method.Write("method",TObject::kOverwrite);
l->Glaubername.Write("Glaubername",TObject::kOverwrite);
l->xmin.Write("xmin",TObject::kOverwrite);l->xmax.Write("xmax",TObject::kOverwrite);
l->mubest.Write("mubest",TObject::kOverwrite);l->kbest.Write("kbest",TObject::kOverwrite);
l->chis.Write("chis",TObject::kOverwrite);l->Ndf.Write("Ndf",TObject::kOverwrite);
l->NcollAver.Write("NcollAver",TObject::kOverwrite);l->NpartAver.Write("NpartAver",TObject::kOverwrite);l->BAver.Write("BAver",TObject::kOverwrite);
l->centbin.Write("centbin",TObject::kOverwrite); l->kpoint.Write("kpoint",TObject::kOverwrite);
l->centbin_.Write("centbin_",TObject::kOverwrite); l->kpoint_.Write("kpoint_",TObject::kOverwrite);
l->Npartdis->Write();
l->Grgrid->Write("Grgrid",TObject::kOverwrite);
outfile->Close();
}
void drift_efficiency()
{
TDirectory *rootdir = gDirectory;
TFile f(gSystem->Getenv("EPECUR_ROOTFILE2"), "READ");
TTree *events = (TTree*)f.Get("events");
rootdir->cd();
c2.Divide(2, 2);
c3.Divide(2, 2);
rootdir->mkdir("lx")->cd();
make_drift_efficiency_hist('l', 'X', events);
rootdir->mkdir("ly")->cd();
make_drift_efficiency_hist('l', 'Y', events);
rootdir->mkdir("rx")->cd();
make_drift_efficiency_hist('r', 'X', events);
rootdir->mkdir("ry")->cd();
make_drift_efficiency_hist('r', 'Y', events);
c1.Show();
c2.Show();
c3.Show();
}
void copy(const std::string& src_file, const std::string& src_obj, const std::string& des_file, const std::string& des_path, const std::string& des_obj) {
gStyle->SetPalette(1,0);
TFile *old_file = new TFile(src_file.c_str());
if (!old_file) {
std::cerr << "Can not open file: " << src_file << std::endl;
return;
}
TObject* old_obj = old_file->Get(src_obj.c_str());
if (!old_obj) {
std::cerr << "Can not open object: " << src_obj << " in file " << src_file << std::endl;
return;
}
TFile *new_file = new TFile(des_file.c_str(), "RECREATE");
TDirectory *cdto = 0;
std::vector<std::string> tokens;
splitString(des_path, "/", tokens);
for (unsigned int i = 0; i < tokens.size(); i++) {
if (cdto == 0) {
cdto = new_file->mkdir(tokens.at(i).c_str());
} else {
cdto = cdto->mkdir(tokens.at(i).c_str());
}
cdto->cd();
}
TObject *new_obj = dynamic_cast<TObject*> (old_obj->Clone(des_obj.c_str()));
if (new_obj->IsA()->InheritsFrom("TH2")) {
TH2* h2 = (TH2*) new_obj;
if (h2) {
if(h2->GetXaxis()->GetXmin() <= 1 && h2->GetXaxis()->GetXmax() >= 36 &&
h2->GetYaxis()->GetXmin() <= 1 && h2->GetYaxis()->GetXmax() >= 18) {
//fillCellsWithRowNeighbourAverage(h2);
fillCellsWithRowAverage(h2);
h2->Draw("colz");
}
}
}
new_file->Write();
}
void importdir(const char *dirname) {
//Example of script showing how to create a ROOT file with subdirectories.
//The script scans a given directory tree and recreates the
//same structure in the ROOT file.
//All source files of type .h,cxx,c,dat,py are imported as TMacro objects
//see also other tutorial readCode.C
//Author: Rene Brun
char *slash = (char*)strrchr(dirname,'/');
char *locdir;
if (slash) locdir = slash+1;
else locdir = (char*)dirname;
printf("processing dir %s\n",dirname);
TDirectory *savdir = gDirectory;
TDirectory *adir = savdir->mkdir(locdir);
adir->cd();
void *dirp = gSystem->OpenDirectory(dirname);
if (!dirp) return;
char *direntry;
Long_t id, size,flags,modtime;
//loop on all entries of this directory
while ((direntry=(char*)gSystem->GetDirEntry(dirp))) {
TString afile = Form("%s/%s",dirname,direntry);
gSystem->GetPathInfo(afile,&id,&size,&flags,&modtime);
if (direntry[0] == '.') continue; //forget the "." and ".." special cases
if (!strcmp(direntry,"CVS")) continue; //forget some special directories
if (!strcmp(direntry,"htmldoc")) continue;
if (strstr(dirname,"root/include")) continue;
if (strstr(direntry,"G__")) continue;
if (strstr(direntry,".c") ||
strstr(direntry,".h") ||
strstr(direntry,".dat") ||
strstr(direntry,".py") ||
strstr(direntry,".C")) {
TMacro *m = new TMacro(afile);
m->Write(direntry);
delete m;
} else {
if (flags != 3) continue; //must be a directory
//we have found a valid sub-directory. Process it
importdir(afile);
}
}
gSystem->FreeDirectory(dirp);
savdir->cd();
}
void make(TDirectory & out, TObject * o) {
TDirectory * dir;
TH1F * th1f;
TH1D * th1d;
TH2F * th2f;
TH2D * th2d;
out.cd();
if((dir = dynamic_cast<TDirectory*>(o)) != 0) {
TDirectory * outDir = out.mkdir(dir->GetName(), dir->GetTitle());
TIter next(dir->GetListOfKeys());
TKey *key;
while( (key = dynamic_cast<TKey*>(next())) ) {
string className(key->GetClassName());
string name(key->GetName());
TObject * obj = dir->Get(name.c_str());
if(obj == 0) {
cerr <<"error: key " << name << " not found in directory " << dir->GetName() << endl;
exit(-1);
}
make(*outDir, obj);
}
} else if((th1f = dynamic_cast<TH1F*>(o)) != 0) {
TH1F *h = (TH1F*) th1f->Clone();
h->Reset();
h->Sumw2();
h->SetDirectory(&out);
} else if((th1d = dynamic_cast<TH1D*>(o)) != 0) {
TH1D *h = (TH1D*) th1d->Clone();
h->Reset();
h->Sumw2();
h->SetDirectory(&out);
} else if((th2f = dynamic_cast<TH2F*>(o)) != 0) {
TH2F *h = (TH2F*) th2f->Clone();
h->Reset();
h->Sumw2();
h->SetDirectory(&out);
} else if((th2d = dynamic_cast<TH2D*>(o)) != 0) {
TH2D *h = (TH2D*) th2d->Clone();
h->Reset();
h->Sumw2();
h->SetDirectory(&out);
}
}
void setPath(string& path, TDirectory* topDir) {
TDirectory* cdir = dynamic_cast<TDirectory*> (topDir->GetDirectory(path.c_str()));
if (!cdir) {
vector<string> names;
string tag = "/";
split(path, names, tag);
cdir = topDir;
for (unsigned int it = 0; it < names.size(); it++) {
string name = names[it];
if (name.size() != 0) {
TDirectory* td = dynamic_cast<TDirectory*> (cdir->Get(name.c_str()));
if (!td) td = cdir->mkdir(name.c_str());
cdir = td;
}
}
}
cdir->cd();
//cdir->pwd();
}
void doit()
{
TFile* base = new TFile("f.db","recreate");
TDirectory* a = base->mkdir("a","First Level Dir");
a->cd();
TH1D* ha = new TH1D("ha","ha",10,0,1);
TDirectory* aa = a->mkdir("aa","Second Level Dira");
aa->cd();
TH1D* haa = new TH1D("haa","haa",10,0,1);
a->ls();
printf(" a: created@ %p found@ %p\n", a,base->FindObjectAny("a"));
printf("ha: created@ %p found@ %p\n",ha,base->FindObjectAny("ha"));
printf("ha: created@ %p --found@ %p\n",ha,base->FindObjectAny("a/ha"));
#ifdef ClingWorkAroundMissingImplicitAuto
TDirectory *k = (TDirectory*)base->FindObjectAny("a");
#else
k = (TDirectory*)base->FindObjectAny("a");
#endif
printf("ha: created@ %p found@ %p\n",ha,k->FindObjectAny("ha"));
printf("aa: created@ %p found@ %p\n",aa,base->FindObjectAny("aa"));
printf("aa: created@ %p --found@ %p\n",aa,base->FindObjectAny("a/aa"));
printf("aa: created@ %p found@ %p\n",aa,k->FindObjectAny("aa"));
printf("haa: created@ %p found@ %p\n",haa,base->FindObjectAny("haa"));
printf("haa: created@ %p --found@ %p\n",haa,base->FindObjectAny("aa/haa"));
printf("haa: created@ %p --found@ %p\n",haa,base->FindObjectAny("a/aa/haa"));
printf("haa: created@ %p found@ %p\n",haa,k->FindObjectAny("haa"));
printf("haa: created@ %p --found@ %p\n",haa,k->FindObjectAny("aa/haa"));
#ifdef ClingWorkAroundMissingImplicitAuto
TDirectory *kk = (TDirectory*)k->FindObjectAny("aa");
#else
kk = (TDirectory*)k->FindObjectAny("aa");
#endif
printf("haa: created@ %p found@ %p\n",haa,kk->FindObjectAny("haa"));
base->Write();
}
void ProcYields::Proc_hYW(){
Info("Proc_hYW()", "");
TDirectory* dirhYW = _fout->mkdir("hYW");
TH1F* hYW[nVARSET];
TDirectory* dirVarset=NULL;
for(Int_t iVarset=0;iVarset<nVARSET;iVarset++){
Info("Proc_hYW()","Varset = Varset%d", iVarset+1);
dirVarset=dirhYW->mkdir(TString::Format("Varset%d",iVarset+1));
dirVarset->cd();
hYW[iVarset] = new TH1F("hYW","hYW", _user.nWbins, _user.Wmin, _user.Wmax);
hYW[iVarset]->SetXTitle("W[GeV]");
//!Loop over Q2W dirs, get h5Ds and their yields
TIter nextkey(_fout->GetListOfKeys());
TKey *key;
while (key = (TKey*)nextkey()) {
TString Q2Wdirname = key->GetName();
if(Q2Wdirname.EqualTo("hYW_Dir") || Q2Wdirname.EqualTo("hYW"))continue;
Info("Proc_hYW()","Q2Wdir = %s", Q2Wdirname.Data());
TString wrange = Q2Wdirname.Tokenize("_")->At(1)->GetName();
TString wlow = wrange.Tokenize(",")->At(0)->GetName();
wlow.Remove(0,1); //remove "["
//Float_t w = wlow.Atof();
Double_t w = wlow.Atof();
sprintf(_hname, "%s/hY5D/Varset%d/hY5D_FULL", Q2Wdirname.Data(),iVarset+1);
THnSparse* hY5D_FULL = (THnSparse*)_fout->Get(_hname);
if (hY5D_FULL == NULL) cout <<"could not get h5D" << endl;
//Float_t yield = getIntegral(hY5D_FULL);
Double_t yield = getIntegral(hY5D_FULL);
//hYW[iVarset]->Fill(w, yield);
hYW[iVarset]->SetBinContent(hYW[iVarset]->FindBin(w+_intrinsic.Wbinw), yield);
Info("Proc_hYW()","W = %f, bin# = %d, yield = %f\n", w, hYW[iVarset]->FindBin(w+_intrinsic.Wbinw), yield);
}
}
Info("Proc_hYW()", "done\n");
}
//Clone the file excluding the histogram (code stolen from Rene Brun)
void copyDir(TDirectory *source,std::string iSkipHist,bool iFirst=true) {
//copy all objects and subdirs of directory source as a subdir of the current directory
TDirectory *savdir = gDirectory;
TDirectory *adir = savdir;
if(!iFirst) adir = savdir->mkdir(source->GetName());
if(!iFirst) adir->cd();
//loop on all entries of this directory
TKey *key;
TIter nextkey(source->GetListOfKeys());
while ((key = (TKey*)nextkey())) {
const char *classname = key->GetClassName();
TClass *cl = gROOT->GetClass(classname);
if (!cl) continue;
if (cl->InheritsFrom(TDirectory::Class())) {
source->cd(key->GetName());
TDirectory *subdir = gDirectory;
adir->cd();
copyDir(subdir,iSkipHist,false);
adir->cd();
} else {
source->cd();
TObject *obj = key->ReadObj();
std::string pFullName = std::string(adir->GetName())+"/"+std::string(obj->GetName());
std::string iSkipHist2 = iSkipHist;
std::string fine_binning = "_fine_binning";
iSkipHist2.replace(iSkipHist2.find(fine_binning), fine_binning.length(),"");
if(pFullName.find(iSkipHist) != std::string::npos || pFullName.find(iSkipHist2) != std::string::npos) {
continue;
}
adir->cd();
obj->Write();
delete obj;
}
}
adir->SaveSelf(kTRUE);
savdir->cd();
}
void Write(TDirectory * dir){
TDirectory * inDir = dir->mkdir(Name.c_str());
inDir->cd();
cosTheta->Write();
Wmass->Write();
topMass->Write();
cosThetaII->Write();
WmassII->Write();
topMassII->Write();
cosTheta2D->Write();
cosTheta2DII->Write();
(inDir->mkdir("ttDecayModes"))->cd();
semiEcosTheta->Write();
semiTaucosTheta->Write();
diTaucosTheta->Write();
diEcosTheta->Write();
diMucosTheta->Write();
MuEcosTheta->Write();
TauEcosTheta->Write();
MuTaucosTheta->Write();
fullHadcosTheta->Write();
inDir->cd();
dir->cd();
}
//________________________________________________________________________________
void MergeComplexHistogramFile( const Char_t *TargetName=0, const Char_t *inputFilesPattern=0)
{
if (TargetName && TargetName[0] && inputFilesPattern && inputFilesPattern[0] ) {
printf(" An experimental version of macro.\n");
TStopwatch time;
Int_t fileCounter = 0;
Int_t dirCounter = 0;
Int_t treeCounter = 0;
Int_t histogramCounter = 0;
// Create the output file
TFile *outFile = TFile::Open(TargetName,"RECREATE");
TDirectory *outDir = outFile;
TDirIter listOfFiles(inputFilesPattern);
const char *fileName = 0;
while ( (fileName = listOfFiles.NextFile() ) ) {
Int_t currentDirDepth = 0;
printf(".");
fileCounter++;
StFileIter file(fileName);
TObject *obj = 0;
while ( (obj = *file) ) {
Int_t depth = file.GetDepth();
while (depth < currentDirDepth) {
outDir = outDir->GetMotherDir();
currentDirDepth--;
}
if ( obj->IsA()->InheritsFrom(TH1::Class()) ) {
// descendant of TH1 -> merge it
// printf("Merging histogram: %s\n",obj->GetName() );
// std::cout << "Merging histogram " << obj->GetName() << std::endl;
TH1 *h1 = (TH1*)obj;
TH1 *dstHistogram = 0;
// Check whether we found the new histogram
if ( (dstHistogram = (TH1 *)outDir->FindObject(h1->GetName()))) {
// Accumulate the histogram
dstHistogram->Add(h1);
delete h1; // Optional, to reduce the memory consumption
printf("h");
} else {
// First time - move the histogram
h1->SetDirectory(outDir);
printf(" The new Histogram found: %s \n", h1->GetName() );
histogramCounter++;
}
} else if ( obj->IsA()->InheritsFrom(TTree::Class()) ) {
// descendant of TTree -> merge it
// printf("Merging Tree %p:%s\n",obj, obj->GetName() );
TTree *tree = (TTree*)obj;
TTree *dstTree = 0;
// Check whether we found the new histogram
if ( (dstTree = (TTree *)outDir->FindObject(tree->GetName()))) {
// printf("Merging %p:%s with the existing Tree %p:%s\n"
// ,tree,tree->GetName(),dstTree, dstTree->GetName() );
// Merge the tree
TList *nextTree = new TList(); nextTree->Add(tree);
dstTree->Merge(nextTree);
delete tree; // Optional, to reduce the memory consumption
delete nextTree;
printf("t");
} else {
// First time - move the TTree
TDirectory *saveDir = 0;
if (outDir != gDirectory) {
saveDir = gDirectory;
outDir->cd();
}
TList *nextTree = new TList(); nextTree->Add(tree);
dstTree = TTree::MergeTrees(nextTree);
if (saveDir) saveDir->cd();
// printf(" The new TTree found: %p:%s \n",tree, tree->GetName() );
// printf(" Create the destination Tree %p:%s\n\n",dstTree, dstTree->GetName() );
delete tree; // Optional, to reduce the memory consumption
delete nextTree;
treeCounter++;
}
} else if ( obj->IsA()->InheritsFrom(TDirectory::Class()) ) {
printf("The input sub-TDirectory object: %s depth=%d\n",obj->GetName(), depth);
TDirectory *d = (TDirectory *)outDir->FindObject(obj->GetName());
if (!d) {
d = outDir->mkdir(obj->GetName());
dirCounter++;
printf("The new TDirectory object: %s depth=%d\n",d->GetPathStatic(), depth);
}
if (d) {
outDir = d;
printf("The output sub-TDirectory object: %s depth=%d\n",outDir->GetPathStatic(), depth);
}
} else {
printf("I have no idea how to merge the %s objects of the %s class. Skipping .... \n",obj->GetName(), obj->ClassName() );
}
++file;
}
}
printf("\n Finishing . . . \n");
outFile->Write(); // this creates a second copy of the TTree ???
outFile->Close();
delete outFile;
if (fileCounter) printf(" Total files merged: %d \n", fileCounter);
if (dirCounter) printf(" Total TDirectory objects merged: %d \n", dirCounter);
if (histogramCounter) printf(" Total histograms merged: %d \n", histogramCounter);
if (treeCounter) printf(" Total TTree\'s merged: %d \n",treeCounter);
if (dirCounter || treeCounter) printf(" You have used the experimental version of the program. Please check the output file\n");
time.Print("Merge");
} else {
printf("\nUsage: root MergeHistogramFile.C(\"DestinationFileName\",\"InputFilesPattern\")\n");
printf("------ where InputFilesPattern ::= <regexp_pattern_for_the_input_files>|@indirect_file_list\n");
printf(" indirect_file_list ::= a text file with the list of the files\n");
printf(" indirect_file_list can be create by the shell command:\n");
printf(" ls -1 *.root>indirect_file_list \n\n");
}
}
void getResVsub(){
string SumorProd = getenv("SUMORPROD");
//------------------------Deal with the number and get the output stored in txt files and root files
double Vmax[nbin], eps[nbin];
string dir = getenv("DIR");
for(int ibin=0; ibin<nbin ;ibin++){
Vmax[ibin]=0.065*(trkbin[ibin]+30);
eps[ibin]=0.00025*(trkbin[ibin]+30);
}
ofstream fstrV;
double theta[ntheta];
TVectorD Nevent[nbin], totmultall[nbin];
TVectorD avgmult[nbin], avgpt[nbin], totmult[nbin], totpt[nbin];
TVectorD Qx1[nbin], Qy1[nbin], Q2[nbin];
TVectorD Gmod2[nbin][nptV][ntheta];
TVectorD sigma2[nbin][nptV],deltaV[nbin][nptV];
TVectorD sigma2_[nbin],chi_[nbin];
TVectorD deltaVmean[nbin], Vmean[nbin];
TVectorD Vmeanmean, deltaVmeanmean, sigmaVmeanmean;
TVectorD r[nbin];
TVectorD r0[nbin][nptV], r01[nbin][nptV], V[nbin][nptV], chi[nbin][nptV];
TVectorD GRe[nbin][nptV][ntheta]; TVectorD* GRe_t[nbin][nptV][ntheta];
TVectorD GIm[nbin][nptV][ntheta]; TVectorD* GIm_t[nbin][nptV][ntheta];
TVectorD IFILE[nbin];
TComplex G[nbin][nptV][ntheta][nstepr];
if(SumorProd=="Sum") fstrV.open("V_Sum_sub.txt");
else fstrV.open("V_Prod_sub.txt");
if(SumorProd=="Sum") TString outname = "mergedV_Sum_sub.root";
else TString outname="mergedV_Prod_sub.root";
TFile *outf = new TFile(outname,"Recreate");
TFile *f[nFileAll];
TVectorD Nevent_; Nevent_.ResizeTo(nbin); Nevent_.Zero();
Vmeanmean.ResizeTo(nbin); Vmeanmean.Zero();
deltaVmeanmean.ResizeTo(nbin); deltaVmeanmean.Zero();
sigmaVmeanmean.ResizeTo(nbin); sigmaVmeanmean.Zero();
for(int ibin=0; ibin<nbin; ibin++){
r[ibin].ResizeTo(nstepr);
for(int ir=0; ir<nstepr; ir++){
if(isSimple==0) r[ibin][ir]=j01/(Vmax[ibin]-eps[ibin]*ir);
else r[ibin][ir]=0.00025*20*(ir+1);
}
for(int ifile=0; ifile<nFileAll; ifile++){
if(SumorProd=="Sum") f[ifile] = TFile::Open(Form("/scratch/xuq7/flow/pbsjoboutput/tracknormcpt03to6/%s/AnaV_Sum_%d.root",dir.c_str(),ifile));
else f[ifile] = TFile::Open(Form("/scratch/xuq7/flow/pbsjoboutput/tracknormcpt03to6/%s/AnaV_Prod_%d.root",dir.c_str(),ifile));
TVectorD* Nevent_t = (TVectorD*)f[ifile]->Get(Form("Nevent"));
Nevent_[ibin]+=(*Nevent_t)[ibin];
f[ifile]->Close();
}
IFILE[ibin].ResizeTo(nsamples);
Nevent[ibin].ResizeTo(nsamples); Nevent[ibin].Zero();
totmultall[ibin].ResizeTo(nsamples); totmultall[ibin].Zero();
TDirectory *dir0 = outf->mkdir(Form("D_%d",ibin));
for(int isample=0;isample<nsamples;isample++){
TVectorD Nevent0; Nevent0.ResizeTo(nbin); Nevent0.Zero();
for(int itheta=0;itheta<ntheta;itheta++)
theta[itheta]=itheta*TMath::Pi()/ntheta/nn;
for(int iptbin=0;iptbin<nptV;iptbin++){
r0[ibin][iptbin].ResizeTo(ntheta);
r01[ibin][iptbin].ResizeTo(ntheta);
sigma2[ibin][iptbin].ResizeTo(ntheta);
V[ibin][iptbin].ResizeTo(ntheta);
deltaV[ibin][iptbin].ResizeTo(ntheta);
chi[ibin][iptbin].ResizeTo(ntheta);
for(int itheta=0;itheta<ntheta;itheta++){
Gmod2[ibin][iptbin][itheta].ResizeTo(nstepr);
GRe[ibin][iptbin][itheta].ResizeTo(nstepr);
GRe[ibin][iptbin][itheta].Zero();
GIm[ibin][iptbin][itheta].ResizeTo(nstepr);
GIm[ibin][iptbin][itheta].Zero();
}
}
avgmult[ibin].ResizeTo(nptV); deltaVmean[ibin].ResizeTo(nptV); Vmean[ibin].ResizeTo(nptV);
deltaVmean[ibin].Zero(); Vmean[ibin].Zero();
Vmean[ibin].Zero(); deltaVmean[ibin].Zero();
totpt[ibin].ResizeTo(nptV); totpt[ibin].Zero();
totmult[ibin].ResizeTo(nptV); totmult[ibin].Zero();
avgpt[ibin].ResizeTo(nptV);
Qx1[ibin].ResizeTo(nptV); Qx1[ibin].Zero();
Qy1[ibin].ResizeTo(nptV); Qy1[ibin].Zero();
Q2[ibin].ResizeTo(nptV); Q2[ibin].Zero();
sigma2_[ibin].ResizeTo(nptV);sigma2_[ibin].Zero();
chi_[ibin].ResizeTo(nptV);chi_[ibin].Zero();
for(int ifile=0; ifile<nFileAll; ifile++){
if(SumorProd=="Sum") f[ifile] = TFile::Open(Form("/scratch/xuq7/flow/pbsjoboutput/tracknormcpt03to6/%s/AnaV_Sum_%d.root",dir.c_str(),ifile));
else f[ifile] = TFile::Open(Form("/scratch/xuq7/flow/pbsjoboutput/tracknormcpt03to6/%s/AnaV_Prod_%d.root",dir.c_str(),ifile));
TVectorD* Nevent_t = (TVectorD*)f[ifile]->Get(Form("Nevent"));
TVectorD* totmultall_t = (TVectorD*)f[ifile]->Get(Form("totmultall"));
Nevent0[ibin] += (*Nevent_t)[ibin];
double start=isample*Nevent_[ibin]/nsamples;
double end=(isample+1)*Nevent_[ibin]/nsamples;
if(Nevent0[ibin]>start && Nevent0[ibin]<=end){
IFILE[ibin][isample]=(double)ifile;
Nevent[ibin][isample] += (*Nevent_t)[ibin];
for(int iptbin=0;iptbin<nptV;iptbin++){
for(int itheta=0;itheta<ntheta;itheta++){
GRe_t[ibin][iptbin][itheta] = (TVectorD*)f[ifile]->Get(Form("GRe_%d_%d_%d",ibin,iptbin,itheta));
GIm_t[ibin][iptbin][itheta] = (TVectorD*)f[ifile]->Get(Form("GIm_%d_%d_%d",ibin,iptbin,itheta));
for(ir=0; ir<nstepr; ir++){
GRe[ibin][iptbin][itheta][ir] += (*GRe_t[ibin][iptbin][itheta])[ir];
GIm[ibin][iptbin][itheta][ir] += (*GIm_t[ibin][iptbin][itheta])[ir];
}
}
}
TVectorD* Qx1_t = (TVectorD*)f[ifile]->Get(Form("Qx1_%d",ibin));
TVectorD* Qy1_t = (TVectorD*)f[ifile]->Get(Form("Qy1_%d",ibin));
TVectorD* Q2_t = (TVectorD*)f[ifile]->Get(Form("Q2_%d",ibin));
TVectorD* totmult_t = (TVectorD*)f[ifile]->Get(Form("totmult_%d",ibin));
TVectorD* totpt_t = (TVectorD*)f[ifile]->Get(Form("totpt_%d",ibin));
for(int iptbin=0;iptbin<nptV;iptbin++){
Qx1[ibin][iptbin] += (*Qx1_t)[iptbin];
Qy1[ibin][iptbin] += (*Qy1_t)[iptbin];
Q2[ibin][iptbin] += (*Q2_t)[iptbin];
totmult[ibin][iptbin] += (*totmult_t)[iptbin];
totpt[ibin][iptbin] += (*totpt_t)[iptbin];
}
totmultall[ibin][isample] += (*totmultall_t)[ibin];
}
f[ifile]->Close();
}//file loop
fstrV<<setprecision(4)<<fixed;
fstrV<<"ibin"<<"\t"<<"iptbin"<<"\t"<<"itheta"<<"\t"<<"r0"<<"\t"<<"V"<<"\t"<<"sigma2"<<"\t"<<"chi"<<"\t"<<"Vn Errors"<<endl;
for(int iptbin=0;iptbin<nptV;iptbin++){
for(int itheta=0;itheta<ntheta;itheta++){
for(ir=0; ir<nstepr; ir++){
G[ibin][iptbin][itheta][ir]=TComplex(GRe[ibin][iptbin][itheta][ir],GIm[ibin][iptbin][itheta][ir]);
G[ibin][iptbin][itheta][ir]/=Nevent[ibin][isample];
Gmod2[ibin][iptbin][itheta][ir]=TMath::Power(TComplex::Abs(G[ibin][iptbin][itheta][ir]),2);
}
for(ir=0; ir<nstepr-1; ir++)
if(ir!=0 && Gmod2[ibin][iptbin][itheta][ir]<=Gmod2[ibin][iptbin][itheta][ir-1] && Gmod2[ibin][iptbin][itheta][ir]<=Gmod2[ibin][iptbin][itheta][ir+1]) break;
if(ir!=0 && ir<nstepr-1) r01[ibin][iptbin][itheta]=r[ibin][ir];
else if(ir==0) {cout<<"ibin="<<ibin<<"\t"<<"iptbin="<<iptbin<<"\t"<<"itheta="<<itheta<<"\tminimum lies on ir = 0, please select proper range!"<<endl; continue;}
else {cout<<"ibin="<<ibin<<"\t"<<"iptbin="<<iptbin<<"\t"<<"itheta="<<itheta<<"\tminimum lies on ir = maximum "<<nstepr-1<<", please select proper range!"<<endl; continue;}
avgmult[ibin][iptbin]=1.0*totmult[ibin][iptbin]/Nevent[ibin][isample];
avgpt[ibin][iptbin]=1.0*totpt[ibin][iptbin]/totmult[ibin][iptbin];
if(isSimple==0) V[ibin][iptbin][itheta]=Vmax[ibin]-ir*eps[ibin]+eps[ibin]*(Gmod2[ibin][iptbin][itheta][ir+1]-Gmod2[ibin][iptbin][itheta][ir-1])/2./(Gmod2[ibin][iptbin][itheta][ir-1]-2*Gmod2[ibin][iptbin][itheta][ir]+Gmod2[ibin][iptbin][itheta][ir+1]);
else V[ibin][iptbin][itheta]=j01/r0[ibin][iptbin][itheta]; //simple method
r0[ibin][iptbin][itheta]=j01/V[ibin][iptbin][itheta];
V[ibin][iptbin][itheta]/=avgmult[ibin][iptbin];
//sigma2[ibin][iptbin][itheta]=Q2[ibin][iptbin]/Nevent[ibin]-(Qx1[ibin][iptbin]/Nevent[ibin])*(Qx1[ibin][iptbin]/Nevent[ibin])-(Qy1[ibin][iptbin]/Nevent[ibin])*(Qy1[ibin][iptbin]/Nevent[ibin])-(V[ibin][iptbin][itheta]*avgmult[ibin][iptbin])*(V[ibin][iptbin][itheta]*avgmult[ibin][iptbin]);
sigma2[ibin][iptbin][itheta]=Q2[ibin][iptbin]/Nevent[ibin][isample]-(Qx1[ibin][iptbin]/Nevent[ibin][isample])*(Qx1[ibin][iptbin]/Nevent[ibin][isample])-(Qy1[ibin][iptbin]/Nevent[ibin][isample])*(Qy1[ibin][iptbin]/Nevent[ibin][isample]);
sigma2_[ibin][iptbin]+=sigma2[ibin][iptbin][itheta];
Vmean[ibin][iptbin]+=V[ibin][iptbin][itheta];
chi[ibin][iptbin][itheta]=V[ibin][iptbin][itheta]*avgmult[ibin][iptbin]/TMath::Sqrt(sigma2[ibin][iptbin][itheta]);
//deltaV[ibin][iptbin][itheta]=V[ibin][iptbin][itheta]/j01/TMath::BesselJ1(j01)*TMath::Sqrt((TMath::Exp(j01*j01/2./chi[ibin][iptbin][itheta]/chi[ibin][iptbin][itheta])+TMath::Exp(-j01*j01/2./chi[ibin][iptbin][itheta]/chi[ibin][iptbin][itheta])*TMath::BesselJ0(2*j01))/2./Nevent[ibin]);
}
sigma2_[ibin][iptbin]/=ntheta;
Vmean[ibin][iptbin]/=ntheta;
sigma2_[ibin][iptbin]-=TMath::Power(Vmean[ibin][iptbin]*avgmult[ibin][iptbin],2);
chi_[ibin][iptbin]=Vmean[ibin][iptbin]*avgmult[ibin][iptbin]/TMath::Sqrt(sigma2_[ibin][iptbin]);
//deltaVmean[ibin][iptbin]+=TMath::Exp(j01*j01/2./chi[ibin][iptbin][itheta]/chi[ibin][iptbin][itheta]*TMath::Cos(nn*theta[itheta]))*TMath::BesselJ0(2*j01*TMath::Sin(nn*theta[itheta]/2.))+TMath::Exp(-j01*j01/2./chi[ibin][iptbin][itheta]/chi[ibin][iptbin][itheta]*TMath::Cos(nn*theta[itheta]))*TMath::BesselJ0(2*j01*TMath::Cos(nn*theta[itheta]/2.));
for(int itheta=0;itheta<ntheta;itheta++){
deltaV[ibin][iptbin][itheta]=V[ibin][iptbin][itheta]/j01/TMath::BesselJ1(j01)*TMath::Sqrt((TMath::Exp(j01*j01/2./chi_[ibin][iptbin]/chi_[ibin][iptbin])+TMath::Exp(-j01*j01/2./chi_[ibin][iptbin]/chi_[ibin][iptbin])*TMath::BesselJ0(2*j01))/2./Nevent[ibin][isample]);
deltaVmean[ibin][iptbin]+=TMath::Exp(j01*j01/2./chi_[ibin][iptbin]/chi_[ibin][iptbin]*TMath::Cos(nn*theta[itheta]))*TMath::BesselJ0(2*j01*TMath::Sin(nn*theta[itheta]/2.))+TMath::Exp(-j01*j01/2./chi_[ibin][iptbin]/chi_[ibin][iptbin]*TMath::Cos(nn*theta[itheta]))*TMath::BesselJ0(2*j01*TMath::Cos(nn*theta[itheta]/2.));
fstrV<<ibin<<"\t"<<iptbin<<"\t"<<itheta<<"\t"<<r0[ibin][iptbin][itheta]<<"\t"<<V[ibin][iptbin][itheta]<<"\t"<<sigma2[ibin][iptbin][itheta]<<"\t"<<chi[ibin][iptbin][itheta]<<"\t"<<deltaV[ibin][iptbin][itheta]<<endl;
}
fstrV<<endl;
deltaVmean[ibin][iptbin]=Vmean[ibin][iptbin]/j01/TMath::BesselJ1(j01)*TMath::Sqrt(deltaVmean[ibin][iptbin]/ntheta/2./Nevent[ibin][isample]);
}
fstrV<<endl;
fstrV<<"ibin"<<"\t"<<"iptbin"<<"\t"<<"avgmult"<<"\t"<<"avgpt"<<"\t"<<"Vn mean"<<"\t"<<"Vn mean Error"<<endl;
for(int iptbin=0;iptbin<nptV;iptbin++){
fstrV<<ibin<<"\t"<<iptbin<<"\t"<<avgmult[ibin][iptbin]<<"\t"<<avgpt[ibin][iptbin]<<"\t"<<Vmean[ibin][iptbin]<<"\t"<<deltaVmean[ibin][iptbin]<<endl;
}
fstrV<<endl;
TDirectory *dirsample = dir0->mkdir(Form("s_%d",isample)); dirsample->cd();
r[ibin].Write("r");
Qx1[ibin].Write("Qx1");
Qy1[ibin].Write("Qy1");
Q2[ibin].Write("Q2");
totmult[ibin].Write("totmult");
totpt[ibin].Write("totpt");
avgmult[ibin].Write("avgmult");
avgpt[ibin].Write("avgpt");
Vmean[ibin].Write("Vmean");
deltaVmean[ibin].Write("deltaVmean");
Vmeanmean[ibin]+=Vmean[ibin][0]/nsamples;
deltaVmeanmean[ibin]+=deltaVmean[ibin][0]/nsamples;
sigmaVmeanmean[ibin]+=TMath::Power(Vmean[ibin][0]/nsamples,2);
chi_[ibin].Write("chi");
for(int iptbin=0;iptbin<nptV;iptbin++){
TDirectory *dir1 = dirsample->mkdir(Form("D_%d",iptbin));dir1->cd();
sigma2[ibin][iptbin].Write("sigma2"); chi[ibin][iptbin].Write("chi0"); deltaV[ibin][iptbin].Write("deltaV");
r0[ibin][iptbin].Write("r0"); r01[ibin][iptbin].Write("r01"); V[ibin][iptbin].Write("V");
for(int itheta=0;itheta<ntheta;itheta++){
TDirectory *dir2 = dir1->mkdir(Form("D_%d",itheta));dir2->cd();
GRe[ibin][iptbin][itheta].Write(Form("GRe"));
GIm[ibin][iptbin][itheta].Write(Form("GIm"));
Gmod2[ibin][iptbin][itheta].Write(Form("G2"));
}
}
}//subsample loop
dir0->cd();
IFILE[ibin].Write("IFILE");
Nevent[ibin].Write("Nevent");
totmultall[ibin].Write("totmultall");
sigmaVmeanmean[ibin]=TMath::Sqrt(sigmaVmeanmean[ibin]*nsamples-Vmeanmean[ibin]*Vmeanmean[ibin])/TMath::Sqrt(nsamples);
}//ntrk bin loop
outf->cd();
Vmeanmean.Write("Vmeanmean");
deltaVmeanmean.Write("deltaVmeanmean");
sigmaVmeanmean.Write("sigmaVmeanmean");
outf->Close();
}
int MakeHistos(int iSample = 0, int iSR = 6){
TH1::SetDefaultSumw2(true);
if(pcp)cout<<"going to set inputs"<<endl;
TString mainDir = "/home/fcostanz/Bonsai/ControlPlots/";
TFile* cutFile = new TFile( "Optimization-2Step.root", "READ");
TTree* cutTree;
cutFile->GetObject( "Optimization", cutTree);
Float_t mtCut = 0.;
Float_t nJetCut = 0.;
Float_t topnessCut = 0.;
Float_t mt2wCut = 0.;
Float_t yCut = 0.;
Float_t dphiCut = 0.;
Float_t drlblCut = 0.;
Float_t drlbgCut = 0.;
Float_t chi2Cut = 0.;
Float_t metCut = 0.;
Float_t m3Cut = 0.;
Float_t centralityCut = 0.;
Float_t mlbCut = 0.;
cutTree->SetBranchAddress( "mtCut", &mtCut);
cutTree->SetBranchAddress( "njetCut", &nJetCut);
cutTree->SetBranchAddress( "topnessCut", &topnessCut);
cutTree->SetBranchAddress( "mt2wCut", &mt2wCut);
cutTree->SetBranchAddress( "yCut", &yCut);
cutTree->SetBranchAddress( "dphiCut", &dphiCut);
cutTree->SetBranchAddress( "drlblCut", &drlblCut);
cutTree->SetBranchAddress( "drlbgCut", &drlbgCut);
cutTree->SetBranchAddress( "chi2Cut", &chi2Cut);
cutTree->SetBranchAddress( "metCut", &metCut);
cutTree->SetBranchAddress( "m3Cut", &m3Cut);
cutTree->SetBranchAddress( "centralityCut", ¢ralityCut);
cutTree->SetBranchAddress( "mlbCut", &mlbCut);
cutTree->GetEntry(iSR);
/*
mtCut = 120.;
nJetCut = 3;
topnessCut = -20;
mt2wCut = 200;
yCut = 0.;
dphiCut = 1.;
drlblCut = 5.;
drlbgCut = 0.;
chi2Cut = 9999999999.;
metCut = 250.;
m3Cut = 0.;
centralityCut = 0.6;
mlbCut =9999999999. ;*/
cout<<"mtCut = "<<mtCut<<endl;
cout<<"nJetCut = "<<nJetCut<<endl;
cout<<"topnessCut = "<<topnessCut<<endl;
cout<<"mt2wCut = "<<mt2wCut<<endl;
cout<<"yCut = "<<yCut<<endl;
cout<<"dphiCut = "<<dphiCut<<endl;
cout<<"drlblCut = "<<drlblCut<<endl;
cout<<"drlbgCut = "<<drlbgCut<<endl;
cout<<"chi2Cut = "<<chi2Cut<<endl;
cout<<"metCut = "<<metCut<<endl;
cout<<"m3Cut = "<<m3Cut<<endl;
cout<<"centralityCut = "<<centralityCut<<endl;
cout<<"mlbCut = "<<mlbCut<<endl;
const int NSamples = 11;
const int NSignals = 4;
const int NControlRegions = 6;
const int NLeps = 3;
const int NDirs = NControlRegions * NLeps;
TString sample[NSamples];
sample[0] = "Data";
sample[1] = "DiLep";
sample[2] = "OneLep";
sample[3] = "WJets";
sample[4] = "Rare";
sample[5] = "QCD";
sample[6] = "DrellYan";
sample[7] = "T2tb-mStop175mLSP50";
sample[8] = "T2tb-mStop200mLSP25";
sample[9] = "T2tb-mStop325mLSP100";
sample[10] = "T2tb-mStop550mLSP1";
double lumi=19500.;
double weight = 1.;
bool lepFlag;
TString lep[NLeps];
lep[0] = "El";
lep[1] = "Mu";
lep[2] = "ElAndMu";
TString controlRegion[NControlRegions];
controlRegion[0] = "Preselection";
controlRegion[1] = "SearchRegionPreIsoTrackVeto";
controlRegion[2] = "SearchRegionPostIsoTrackVeto";
controlRegion[3] = "CR1";
controlRegion[4] = "CR4";
controlRegion[5] = "CR5";
bool flag[NDirs];
TString controlDirName[NDirs];
TDirectory* controlDir[NDirs];
for (int ilep = 0; ilep < NLeps; ilep++){
for ( int iControlRegion = 0; iControlRegion < NControlRegions; iControlRegion++){
controlDirName[ilep * NControlRegions + iControlRegion ] = lep[ilep];
controlDirName[ilep * NControlRegions + iControlRegion ] += "-";
controlDirName[ilep * NControlRegions + iControlRegion ] += controlRegion[iControlRegion];
}
}
/////////////////////////////////////////////////////
// Input Definition
/////////////////////////////////////////////////////
std::cout<<"Running over Sample "<<sample[iSample]<<std::endl;
TString inFileName = mainDir; inFileName += sample[iSample]; inFileName +=".root";
TFile* inFile = new TFile(inFileName,"READ");
if (!inFile->IsOpen()){
std::cout<<"not open"<<std::endl;
}
/////////////////////////////////////////////////////
// Tree Definition
/////////////////////////////////////////////////////
TTree* tree;
tree= (TTree*)inFile->Get("NoSystematic/bonsai");
int N = tree->GetEntries(); cout<<"THERE ARE "<<N<<" EVENTS IN "<<inFileName<<endl;
Float_t globalWeight = 0.;
Float_t triggerWeight = 0.;
Float_t npv = 0.;
Float_t ngoodpv = 0.;
Float_t puWeight = 0.;
Float_t isrWeight = 0.;
Float_t topPtWeight = 0.;
Float_t lepFromTop = 0.;
Float_t charginos = 0.;
Float_t njets = 0.;
Float_t jet1 = 0.;
Float_t jet2 = 0.;
Float_t jet3 = 0.;
Float_t jet4 = 0.;
Float_t nbjets = 0.;
Float_t bjet1 = 0.;
Float_t bjetHighestDisc = 0.;
Float_t bdiscH = 0.;
Float_t lPt = 0.;
Float_t lEta = 0.;
Float_t lRelIso = 0.;
Float_t isoTrack = 0.;
Float_t tauVeto = 0.;
Float_t rawmet = 0.;
Float_t typeImet = 0.;
Float_t phiCorrMet = 0.;
Float_t ht = 0.;
Float_t ht3 = 0.;
Float_t ht4 = 0.;
Float_t ht5 = 0.;
Float_t htRatio = 0.;
Float_t meff = 0.;
Float_t y = 0.;
Float_t mt = 0.;
Float_t mlb1 = 0.;
Float_t mlb = 0.;
Float_t m3b = 0.;
Float_t m3 = 0.;
Float_t centrality = 0.;
Float_t mt2w = 0.;
Float_t hadChi2 = 0.;
Float_t topness = 0.;
Float_t dphimin = 0.;
Float_t drlb1 = 0.;
Float_t drlbmin = 0.;
Int_t pdgIdLep1 = 0;
Int_t pdgIdLep2 = 0;
Char_t kinRegion = false;
Char_t searchRegionPre = false;
Char_t searchRegionPost = false;
Char_t CR1 = false;
Char_t CR4 = false;
Char_t CR5 = false;
tree->SetBranchAddress( "GlobalWeight", &globalWeight);
tree->SetBranchAddress( "TriggerWeight", &triggerWeight);
tree->SetBranchAddress( "NPV", &npv);
tree->SetBranchAddress( "NgoodPV", &ngoodpv);
tree->SetBranchAddress( "PUWeight", &puWeight);
tree->SetBranchAddress( "isrWeight", &isrWeight);
tree->SetBranchAddress( "topPtWeight", &topPtWeight);
tree->SetBranchAddress( "LepFromTop", &lepFromTop);
tree->SetBranchAddress( "Charginos", &charginos);
tree->SetBranchAddress( "njets", &njets);
tree->SetBranchAddress( "jet1", &jet1);
tree->SetBranchAddress( "jet2", &jet2);
tree->SetBranchAddress( "jet3", &jet3);
tree->SetBranchAddress( "jet4", &jet4);
tree->SetBranchAddress( "nbjets", &nbjets);
tree->SetBranchAddress( "bjet1", &bjet1);
tree->SetBranchAddress( "bjetHighestDisc", &bjetHighestDisc);
tree->SetBranchAddress( "discH", &bdiscH);
tree->SetBranchAddress( "lPt", &lPt);
tree->SetBranchAddress( "lEta", &lEta);
tree->SetBranchAddress( "lRelIso", &lRelIso);
tree->SetBranchAddress( "phiCorrMet", &phiCorrMet);
tree->SetBranchAddress( "ht", &ht);
tree->SetBranchAddress( "ht3", &ht3);
tree->SetBranchAddress( "ht4", &ht4);
tree->SetBranchAddress( "ht5", &ht5);
tree->SetBranchAddress( "htRatio", &htRatio);
tree->SetBranchAddress( "meff", &meff);
tree->SetBranchAddress( "y", &y);
tree->SetBranchAddress( "mt", &mt);
tree->SetBranchAddress( "mlb1", &mlb1);
tree->SetBranchAddress( "mlb", &mlb);
tree->SetBranchAddress( "m3b", &m3b);
tree->SetBranchAddress( "m3", &m3);
tree->SetBranchAddress( "centrality", ¢rality);
tree->SetBranchAddress( "mt2w", &mt2w);
tree->SetBranchAddress( "hadChi2", &hadChi2);
tree->SetBranchAddress( "topness", &topness);
tree->SetBranchAddress( "dphimin", &dphimin);
tree->SetBranchAddress( "drlb1", &drlb1);
tree->SetBranchAddress( "drlbmin", &drlbmin);
tree->SetBranchAddress("pdgIdLep1",&pdgIdLep1);
tree->SetBranchAddress("pdgIdLep2",&pdgIdLep2);
tree->SetBranchAddress("kinRegion",&kinRegion);
tree->SetBranchAddress("searchRegionPre",&searchRegionPre);
tree->SetBranchAddress("searchRegionPost",&searchRegionPost);
tree->SetBranchAddress("CR1",&CR1);
tree->SetBranchAddress("CR4",&CR4);
tree->SetBranchAddress("CR5",&CR5);
/////////////////////////////////////////////////////
// Output Definition
/////////////////////////////////////////////////////
//Branching Ratio
TFile* outFile = new TFile( "./MakeHistos/"+sample[iSample]+".root", "Update");
outFile->cd();
TH1D* npvh[NDirs];
TH1D* ngoodpvh[NDirs];
TH1D* lpth[NDirs];
TH1D* letah[NDirs];
TH1D* lrelisoh[NDirs];
TH1D* njetsh[NDirs];
TH1D* jet1h[NDirs];
TH1D* jet2h[NDirs];
TH1D* jet3h[NDirs];
TH1D* jet4h[NDirs];
TH1D* nbjetsh[NDirs];
TH1D* bjet1h[NDirs];
TH1D* bjetHighDh[NDirs];
TH1D* bdiscHh[NDirs];
TH1D* hth[NDirs];
TH1D* ht3h[NDirs];
TH1D* ht4h[NDirs];
TH1D* ht5h[NDirs];
TH1D* htratioh[NDirs];
TH1D* meth[NDirs];
TH1D* meffh[NDirs];
TH1D* yh[NDirs];
TH1D* mth[NDirs];
TH1D* mlb1h[NDirs];
TH1D* mlbh[NDirs];
TH1D* m3bh[NDirs];
TH1D* m3h[NDirs];
TH1D* centralityh[NDirs];
TH1D* mt2wh[NDirs];
TH1D* hadchi2h[NDirs];
TH1D* topnessh[NDirs];
TH1D* dphiminh[NDirs];
TH1D* drlb1h[NDirs];
TH1D* drlbminh[NDirs];
TString dirName = ""; dirName += iSR;
if (outFile->GetDirectory(dirName)) outFile->Delete(dirName + ";*");
outFile->mkdir( dirName);
TDirectory* SRDir = outFile->GetDirectory( dirName);
SRDir->cd();
for ( int iDir = 0; iDir < NDirs; iDir++){
SRDir->mkdir( controlDirName[iDir]);
controlDir[iDir] = SRDir->GetDirectory( controlDirName[iDir]);
controlDir[iDir]->cd();
npvh[iDir] = new TH1D( "npv", "NPV", 51, -0.5, 50.5);
ngoodpvh[iDir] = new TH1D( "ngoodpv", "NgoodPV", 51, -0.5, 50.5);
lpth[iDir] = new TH1D( "lpt", "lep p_{T} [GeV]", 12, 25., 500.);
letah[iDir] = new TH1D( "leta", "lep #Eta", 30, -3., 3.);
lrelisoh[iDir] = new TH1D( "lRelIso", "lep RelIso", 30, 0., 1.);
njetsh[iDir] = new TH1D( "njets", "jets multiplicity", 10, -0.5, 9.5);
jet1h[iDir] = new TH1D( "jet1", "1st jet p_{T} [GeV]", 25, 0., 500.);
jet2h[iDir] = new TH1D( "jet2", "2nd jet p_{T} [GeV]", 25, 0., 500.);
jet3h[iDir] = new TH1D( "jet3", "3rd jet p_{T} [GeV]", 25, 0., 500.);
jet4h[iDir] = new TH1D( "jet4", "4th jet p_{T} [GeV]", 25, 0., 500.);
nbjetsh[iDir] = new TH1D( "nbjets", "b jets multiplicity", 6, -0.5, 5.5);
bjet1h[iDir] = new TH1D( "bjet1", "Leading b jet p_{T} [GeV]", 25, 0., 500.);
bjetHighDh[iDir] = new TH1D( "bjetHighD", "p_{T} of the highest b disc jet [GeV]", 12, 0., 500.);
bdiscHh[iDir] = new TH1D( "bdisc", "bdisc", 20, 0., 1.);
meth[iDir] = new TH1D( "MET", "MET [GeV]", 12, 0., 400.);
hth[iDir] = new TH1D( "Ht", "Ht [GeV]", 20, 0., 1000.);
ht3h[iDir] = new TH1D( "Ht3", "Ht3 [GeV]", 20, 0., 1000.);
ht4h[iDir] = new TH1D( "Ht4", "Ht4 [GeV]", 20, 0., 1000.);
ht5h[iDir] = new TH1D( "Ht5", "Ht5 [GeV]", 20, 0., 1000.);
htratioh[iDir] = new TH1D( "HtRatio", "HtRatio", 20, 0., 1.);
meffh[iDir] = new TH1D( "Meff", "Meff [GeV]", 40, 0., 1000.);
yh[iDir] = new TH1D( "Y", "Y [GeV^{1/2}]", 15, 0., 30.);
mth[iDir] = new TH1D( "Mt", "Mt [GeV]", 30, 0., 300.);
mlb1h[iDir] = new TH1D( "mlb1", "Mlb1 [GeV]", 10, 0., 500.);
mlbh[iDir] = new TH1D( "mlb", "Mlb [GeV]", 10, 0., 500.);
m3bh[iDir] = new TH1D( "m3b", "M3b [GeV]", 15, 0., 500.);
m3h[iDir] = new TH1D( "m3", "M3 [GeV]", 15, 0., 500.);
centralityh[iDir] = new TH1D( "centrality", "centrality", 10, 0., 1.);
mt2wh[iDir] = new TH1D( "mt2w", "MT2W [GeV]", 15, 0., 500.);
hadchi2h[iDir] = new TH1D( "hadChi2", "hadChi2 [GeV]", 20, 0., 10.);
topnessh[iDir] = new TH1D( "topness", "topness [GeV]", 30, -15., 15.);
dphiminh[iDir] = new TH1D( "dphimin", "min dPhi (MET, jet1/2)", 17, 0., TMath::Pi() * 17./16.);
drlb1h[iDir] = new TH1D( "drlb1", "dR(lep, bjet1)", 20, 0., 5.);
drlbminh[iDir] = new TH1D( "drlbmin", "min dR(lep, bjet)", 20, 0., 5.);
}
outFile->cd();
for (int ievt=0;ievt<N;++ievt){
tree->GetEntry(ievt);
//if (ievt%13453 == 0) cout<<"Event number "<<ievt<<"\r"<<flush;
if (iSample == 0) weight = 1.;
else weight = globalWeight * triggerWeight * puWeight * topPtWeight * lumi;
if ( (iSample - NSamples + NSignals) > -0.01 ) weight *= isrWeight;
if (lRelIso > 0.1) continue;
for (int ilep = 0; ilep < NLeps; ilep++){
lepFlag = true;
if (ilep == 0) lepFlag = (abs(pdgIdLep1) == 11);
if (ilep == 1) lepFlag = (abs(pdgIdLep1) == 13);
flag[ilep * NControlRegions + 0] = (searchRegionPost || CR1) && lepFlag;
flag[ilep * NControlRegions + 1] = searchRegionPre && lepFlag;
flag[ilep * NControlRegions + 2] = searchRegionPost && lepFlag;
flag[ilep * NControlRegions + 3] = CR1 && lepFlag;
flag[ilep * NControlRegions + 4] = CR4 && lepFlag;
flag[ilep * NControlRegions + 5] = CR5 && lepFlag;
}
for ( int iDir = 0; iDir < NDirs; iDir++){
if (!flag[iDir])
continue;
/////////////////////////////////////////////////////
// Histo Filling
/////////////////////////////////////////////////////
bool allCuts = (njets - nJetCut) > -0.0001 && mt2w > mt2wCut && y > yCut && dphimin > dphiCut && drlb1 < drlblCut && phiCorrMet > metCut && m3 > m3Cut;
bool allButMt2w = (njets - nJetCut) > -0.0001 && y > yCut && dphimin > dphiCut && drlb1 < drlblCut && phiCorrMet > metCut && m3 > m3Cut;
bool allButY = (njets - nJetCut) > -0.0001 && mt2w > mt2wCut && dphimin > dphiCut && drlb1 < drlblCut && phiCorrMet > metCut && m3 > m3Cut;
bool allButDphi = (njets - nJetCut) > -0.0001 && mt2w > mt2wCut && y > yCut && drlb1 < drlblCut && phiCorrMet > metCut && m3 > m3Cut;
bool allButDrlb = (njets - nJetCut) > -0.0001 && mt2w > mt2wCut && y > yCut && dphimin > dphiCut && phiCorrMet > metCut && m3 > m3Cut;
bool allButMet = (njets - nJetCut) > -0.0001 && mt2w > mt2wCut && y > yCut && dphimin > dphiCut && drlb1 < drlblCut && m3 > m3Cut;
bool allButM3 = (njets - nJetCut) > -0.0001 && mt2w > mt2wCut && y > yCut && dphimin > dphiCut && drlb1 < drlblCut && phiCorrMet > metCut ;
bool allButCentrality = allCuts && mlb1 < mlbCut;
bool allButMlb = allCuts && centrality > centralityCut;
allCuts &= centrality > centralityCut && mlb1 < mlbCut;
allButMt2w &= centrality > centralityCut && mlb1 < mlbCut;
allButY &= centrality > centralityCut && mlb1 < mlbCut;
allButDphi &= centrality > centralityCut && mlb1 < mlbCut;
allButDrlb &= centrality > centralityCut && mlb1 < mlbCut;
allButMet &= centrality > centralityCut && mlb1 < mlbCut;
allButM3 &= centrality > centralityCut && mlb1 < mlbCut;
if (iDir%NControlRegions == 0 || iDir%NControlRegions == 1 || iDir%NControlRegions == 2 ){
if ( mt > 80.){
if (iSample != 0 && allCuts) mth[iDir]->Fill( mt, weight);
continue;
}
if (mt < 50.) {
if (allCuts) mth[iDir]->Fill( mt, weight);
continue;
}
}
if (allButMt2w) mt2wh[iDir]->Fill( mt2w, weight);
if (allButY) yh[iDir]->Fill( y, weight);
if (allButDphi) dphiminh[iDir]->Fill( dphimin, weight);
if (allButDrlb) drlb1h[iDir]->Fill( drlb1, weight);
if (allButMet) meth[iDir]->Fill( phiCorrMet, weight);
if (allButM3) m3h[iDir]->Fill( m3, weight);
if (allButCentrality) centralityh[iDir]->Fill( centrality, weight);
if (allButMlb) mlb1h[iDir]->Fill( mlb1, weight);
if (allCuts) {
npvh[iDir]->Fill( npv, weight);
ngoodpvh[iDir]->Fill( ngoodpv, weight);
lpth[iDir]->Fill( lPt, weight);
letah[iDir]->Fill( lEta, weight);
lrelisoh[iDir]->Fill( lRelIso, weight);
njetsh[iDir]->Fill( njets, weight);
jet1h[iDir]->Fill( jet1, weight);
jet2h[iDir]->Fill( jet2, weight);
jet3h[iDir]->Fill( jet3, weight);
jet4h[iDir]->Fill( jet4, weight);
nbjetsh[iDir]->Fill( nbjets, weight);
bjet1h[iDir]->Fill( bjet1, weight);
bjetHighDh[iDir]->Fill( bjetHighestDisc, weight);
bdiscHh[iDir]->Fill( bdiscH, weight);
hth[iDir]->Fill( ht, weight);
ht3h[iDir]->Fill( ht3, weight);
ht4h[iDir]->Fill( ht4, weight);
ht5h[iDir]->Fill( ht5, weight);
htratioh[iDir]->Fill( htRatio, weight);
meffh[iDir]->Fill( meff, weight);
mth[iDir]->Fill( mt, weight);
mlb1h[iDir]->Fill( mlb1, weight);
m3bh[iDir]->Fill( m3b, weight);
hadchi2h[iDir]->Fill( hadChi2, weight);
topnessh[iDir]->Fill( topness, weight);
drlbminh[iDir]->Fill( drlbmin, weight);
}
}
}
outFile->Write();
outFile->Close();
inFile->Close();
return 0;
}
void store(int type, int sth=0, int Gth=0){
TH1::AddDirectory(kFALSE);
NBD *l;
struct para1 var;
TString dirname;
double sss=0.1;
if(sth==0){
dirname = "std";
if(Gth<nGlau)
l = new NBD(datafile,stdGlaulist[Gth],histoname);
else
l = new NBD(datafile,stdGlaulist[0],histoname);
var = var1[Gth];
l->initmu(bestlist1[Gth].mubest-sss,bestlist1[Gth].mubest+sss,sss/5);
l->initk(bestlist1[Gth].kbest-sss,bestlist1[Gth].kbest+sss,sss/5);
l->initf(bestlist1[Gth].fbest-sss,bestlist1[Gth].fbest+sss,sss/5);
}
else if(sth==1){
dirname ="Gri055";
if(Gth<nGlau)
l = new NBD(datafile,Gri055Glaulist[Gth],histoname);
else
l = new NBD(datafile,Gri055Glaulist[0],histoname);
var = var2[Gth];
l->initmu(bestlist2[Gth].mubest-sss,bestlist2[Gth].mubest+sss,sss/5);
l->initk(bestlist2[Gth].kbest-sss,bestlist2[Gth].kbest+sss,sss/5);
l->initf(bestlist2[Gth].fbest-sss,bestlist2[Gth].fbest+sss,sss/5);
}
else {
dirname ="Gri101";
if(Gth<nGlau)
l = new NBD(datafile,Gri101Glaulist[Gth],histoname);
else
l = new NBD(datafile,Gri101Glaulist[0],histoname);
var = var3[Gth];
l->initmu(bestlist3[Gth].mubest-sss,bestlist3[Gth].mubest+sss,sss/5);
l->initk(bestlist3[Gth].kbest-sss,bestlist3[Gth].kbest+sss,sss/5);
l->initf(bestlist3[Gth].fbest-sss,bestlist3[Gth].fbest+sss,sss/5);
}
//l->initmu(var.mumin,var.mumax,var.mustep);
//l->initk(var.kmin,var.kmax,var.kstep);
//l->initf(var.fmin,var.fmax,var.fstep);
if(Gth<nGlau)
l->initx(var.xmin,var.xmax);
else if(Gth-nGlau==0)
l->initx(var.xmin-binshift,var.xmax);
else
l->initx(var.xmin+binshift,var.xmax);
if(type==0)
l->fit();
if(type==1){
if(sth==0) l->assign(bestlist1[Gth].mubest,bestlist1[Gth].kbest,bestlist1[Gth].fbest);
else if(sth==1) l->assign(bestlist2[Gth].mubest,bestlist2[Gth].kbest,bestlist2[Gth].fbest);
else l->assign(bestlist3[Gth].mubest,bestlist3[Gth].kbest,bestlist3[Gth].fbest);
l->initN(bin,N,method);
l->calcvar();
TFile *outfile = new TFile(outG,"Update");
if(Gth==0 && sth==0){
l->dataname.Write("dataname",TObject::kOverwrite);
l->histoname.Write("histoname",TObject::kOverwrite);
}
TDirectory *dir = (TDirectory*)outfile->GetDirectory(dirname);
if (!dir) {outfile->mkdir(dirname); dir = (TDirectory*)outfile->GetDirectory(dirname);}
dir->cd();
TString name;
if(Gth==0)
name = "G0";
else if(Gth<nGlau)
name = Form("Glau_%d",Gth);
else
name = Form("bin_%d",Gth-nGlau+1);
TDirectory *subdir = (TDirectory*)dir->GetDirectory(name);
if(!subdir) {dir->mkdir(name); subdir = (TDirectory*)dir->GetDirectory(name);}
subdir->cd();
l->method.Write("method",TObject::kOverwrite);
l->Glaubername.Write("Glaubername",TObject::kOverwrite);
l->xmin.Write("xmin",TObject::kOverwrite);l->xmax.Write("xmax",TObject::kOverwrite);
l->mubest.Write("mubest",TObject::kOverwrite);l->kbest.Write("kbest",TObject::kOverwrite);l->fbest.Write("fbest",TObject::kOverwrite);
l->chis.Write("chis",TObject::kOverwrite);l->Ndf.Write("Ndf",TObject::kOverwrite);
l->NcollAver.Write("NcollAver",TObject::kOverwrite);l->NpartAver.Write("NpartAver",TObject::kOverwrite);l->BAver.Write("BAver",TObject::kOverwrite);
l->centbin.Write("centbin",TObject::kOverwrite); l->kpoint.Write("kpoint",TObject::kOverwrite);
l->centbin_.Write("centbin_",TObject::kOverwrite); l->kpoint_.Write("kpoint_",TObject::kOverwrite);
l->Npartdis->Write("Npartdis",TObject::kSingleKey | TObject::kOverwrite);
l->Grgrid->Write("Grgrid",TObject::kOverwrite);
outfile->Close();
}
}
void SubtractBgndRuns(TDirectory *fbg,
TDirectory *fprod,
const Char_t *foutname="",
const std::string& bl_list="")
{
std::set<UInt_t> blacklist = GetBlackedChannels(bl_list);
string basename = FindBaseName(fprod->GetName());
vector<TH1*> histbg = ROOTUtils::GetAllTH1InDirectory(fbg);
ROOTUtils::EnforceProperOrdering(histbg);
//GetAllHists(*fbg, false);
FilterOutTDC(histbg);
vector<TH1*> histprod = ROOTUtils::GetAllTH1InDirectory(fprod,
Form("^((%s[0-9]+_shifted_norm_vclk)|(%s[0-9]+_norm_vclk_shifted))$",basename.data(),basename.data()));
ROOTUtils::EnforceProperOrdering(histprod);
//GetAllHists(*fprod, true);
// for_each(histprod.begin(), histprod.end(), InspectSingleHistErrors);
FilterOutTDC(histprod);
EnforceAxisRangeConsistency(histbg, histprod);
TDirectory *fout=0;
string foname = foutname;
if (foname.length()>0)
{
fout = TFile::Open(foname.data(),"UPDATE");
}
else
{
TDirectory *basedir = GetBaseDir(fprod);
if (dynamic_cast<TDirectoryFile*>(basedir)==0)
{
std::cerr << "Cannot identify the file" << std::endl;
return;
}
string dname = FormOutputSubDirName(fprod->GetName());
fout = basedir->GetDirectory(dname.data());
if (fout==0)
fout = basedir->mkdir(dname.data());
}
TH1 *hbg=0, *h=0, *h_cl=0;
for (UInt_t i=0; i<min(histbg.size(), histprod.size()); i++)
{
hbg = histbg.at(i);
h = histprod.at(i);
h_cl = static_cast<TH1*>(h->Clone(Form("normed_bgsubbed_%s%i",basename.data(), i)));
if (blacklist.find(i)==blacklist.end())
{
cout << histbg.at(i)->GetName() << " subbed from " << histprod.at(i)->GetName() << endl;
h_cl->SetTitle(Form("Overnight Bgnd Subtracted ADC%i",i));
h_cl->Add(hbg,-1.0);
// The next line is only valid if Sumw2 is not turned on
// CalcErrors(h_cl, hbg, h);
}
else
{
cout << histbg.at(i)->GetName() << " blacklisted ... no subtraction" << endl;
h_cl->SetTitle(Form("ADC%i Without Subtraction",i));
}
fout->cd();
h_cl->Write("",TObject::kOverwrite);
}
std::cout << "Results saved in " << fout->GetName() << std::endl;
if (foname.length()>0)
fout->Close();
}
int main(int argc, char *argv[]){
/////////////////////////////////////
if (argc != 6)
{
std::cout << "Please enter something like: ./run \"filelist_WJets_PU20bx25_100_200.txt\" \"WJets_PU20bx25_100_200\" \"Results\" \"00\" \"0\" " << std::endl;
return EXIT_FAILURE;
}
//get the inputs from user
const string InRootList = argv[1];
const string subSampleKey = argv[2];
const string Outdir = argv[3];
const string inputnumber = argv[4];
const string verbosity = argv[5];
//////////////////////////////////////
int verbose = atoi(verbosity.c_str());
//some varaibles
char filenames[500];
vector<string> filesVec;
ifstream fin(InRootList.c_str());
TChain *sample_AUX = new TChain("TreeMaker2/PreSelection");
char tempname[200];
vector<TH1D > vec;
map<int, string> eventType;
map<string , vector<TH1D> > cut_histvec_map;
map<string, map<string , vector<TH1D> > > map_map;
map<string, histClass> histobjmap;
histClass histObj;
//build a vector of histograms
TH1D weight_hist = TH1D("weight", "Weight Distribution", 5,0,5);
vec.push_back(weight_hist);
TH1D RA2HT_hist = TH1D("HT","HT Distribution",50,0,5000);
RA2HT_hist.Sumw2();
vec.push_back(RA2HT_hist);
TH1D RA2MHT_hist = TH1D("MHT","MHT Distribution",100,0,5000);
RA2MHT_hist.Sumw2();
vec.push_back(RA2MHT_hist);
TH1D RA2NJet_hist = TH1D("NJet","Number of Jets Distribution",20,0,20);
RA2NJet_hist.Sumw2();
vec.push_back(RA2NJet_hist);
TH1D RA2NBtag_hist = TH1D("NBtag","Number of Btag Distribution",20,0,20);
RA2NBtag_hist.Sumw2();
vec.push_back(RA2NBtag_hist);
int Nhists=((int)(vec.size())-1);//-1 is because weight shouldn't be counted.
///read the file names from the .txt files and load them to a vector.
while(fin.getline(filenames, 500) ){filesVec.push_back(filenames);}
cout<< "\nProcessing " << subSampleKey << " ... " << endl;
for(unsigned int in=0; in<filesVec.size(); in++){ sample_AUX->Add(filesVec.at(in).c_str()); }
// --- Analyse the events --------------------------------------------
// Interface to the event content
Events * evt = new Events(sample_AUX, subSampleKey,verbose);
// Get a pointer to the Selection class
Selection2 * sel = new Selection2();
// For each selection, cut, make a vector containing the same histograms as those in vec
for(int i=0; i<(int) sel->cutName().size();i++){
cut_histvec_map[sel->cutName()[i]]=vec;
}
// Define different event categories
eventType[0]="allEvents";
//initialize a map between string and maps. copy the map of histvecs into each
for(int i=0; i< eventType.size();i++){
map_map[eventType[i]]=cut_histvec_map;
}
//initialize histobjmap
for(map<string , vector<TH1D> >::iterator it=cut_histvec_map.begin(); it!=cut_histvec_map.end();it++){
histobjmap[it->first]=histObj;
}
TH1D* TauIDhist = new TH1D("yield_tauId","Yield after tau Id",200,0.,200.);
TH1D* TauIDhist_trk = new TH1D("yield_tauId_trk","Yield after trk veto and tau Id",200,0.,200.);
map <int,string> idMap;
int IdNum_=0;
for(int iPile=0;iPile<4;iPile++){
for(int iIso=0;iIso<4;iIso++){
for(int iMu=0;iMu<3;iMu++){
for(int iElec=0;iElec<4;iElec++){
IdNum_++;
ostringstream binS_;
binS_ << (1+iPile)+10*(1+iIso)+100*(1+iMu)+1000*(1+iElec);
idMap[IdNum_]=binS_.str();
TauIDhist->GetXaxis()->SetBinLabel(IdNum_,binS_.str().c_str());
TauIDhist_trk->GetXaxis()->SetBinLabel(IdNum_,binS_.str().c_str());
}
}
}
}
// Introduce cutflow histogram to monior event yields for early preselection
TH1D* cutflow_preselection = new TH1D("cutflow_preselection","cutflow_preselectoion",
11,0.,11.);
cutflow_preselection->GetXaxis()->SetBinLabel(1,"All Events");
cutflow_preselection->GetXaxis()->SetBinLabel(2,"Sample based gen-selection");
cutflow_preselection->GetXaxis()->SetBinLabel(3,"HBHEIsoNoiseFilter");
cutflow_preselection->GetXaxis()->SetBinLabel(4,"eeBadScFilter");
cutflow_preselection->GetXaxis()->SetBinLabel(5,"HBHENoiseFilter");
cutflow_preselection->GetXaxis()->SetBinLabel(6,"GoodVtx");
cutflow_preselection->GetXaxis()->SetBinLabel(7,"JetID Cleaning");
int sampletype=-1;
if(subSampleKey.find("TTbar_Inclusive")!=string::npos)sampletype=0; //TTbar_Inclusive
else if(subSampleKey.find("TTbar_Tbar_SingleLep")!=string::npos || subSampleKey.find("TTbar_T_SingleLep")!=string::npos)sampletype=1;
else if(subSampleKey.find("TTbar_DiLept")!=string::npos)sampletype=2;
else if(subSampleKey.find("TTbar_HT_600_800")!=string::npos)sampletype=3;
else if(subSampleKey.find("TTbar_HT_800_1200")!=string::npos)sampletype=4;
else if(subSampleKey.find("TTbar_HT_1200_2500")!=string::npos)sampletype=5;
else if(subSampleKey.find("TTbar_HT_2500_Inf")!=string::npos)sampletype=6;
else if(subSampleKey.find("TTbar")!=string::npos){
cout << " TT sample is not known. Please check the second input \n " ;
return 2;
}
int TotNEve_ = utils2::TotNEve(subSampleKey);
// Loop over the events (tree entries)
int eventN=0;
while( evt->loadNext() ){
//if(eventN>1000)break;
// Total weight
//double totWeight = evt->weight()*1.;
double totWeight = 10000.*evt->XS()/TotNEve_;
//printf(" XS: %g NEvents: %d weight: %g \n ",evt->XS(),TotNEve_,totWeight);
cutflow_preselection->Fill(0.,totWeight); // keep track of all events processed
if(!evt->DataBool_()){
if(sampletype==0){
if(evt->gen_ht()>600||evt->GenElecPtVec_().size()>0||evt->GenMuPtVec_().size()>0||evt->GenTauPtVec_().size()>0)continue;
}
if(sampletype==1){
if(evt->gen_ht()>600)continue;
}
if(sampletype==2){
if(evt->gen_ht()>600)continue;
}
}
cutflow_preselection->Fill(1.,totWeight);
if(evt->HBHEIsoNoiseFilter_()==0)continue;
cutflow_preselection->Fill(2.,totWeight);
if(evt->eeBadScFilter_()==0)continue;
cutflow_preselection->Fill(3.,totWeight);
if(evt->HBHENoiseFilter_()==0)continue;
cutflow_preselection->Fill(4.,totWeight);
if(!(evt->NVtx_() >0))continue;
cutflow_preselection->Fill(5.,totWeight);
// Through out an event that contains HTjets with bad id
if(evt->JetId()==0)continue;
cutflow_preselection->Fill(6.,totWeight); // events passing JetID event cleaning
vector<TLorentzVector> genTauJetLorVec;
for(int i=0;i<evt->GenTauLorVec()->size();i++){
TLorentzVector tempVec(evt->GenTauLorVec()->at(i).Px()-evt->GenTauNuLorVec()->at(i).Px(),
evt->GenTauLorVec()->at(i).Py()-evt->GenTauNuLorVec()->at(i).Py(),
evt->GenTauLorVec()->at(i).Pz()-evt->GenTauNuLorVec()->at(i).Pz(),
evt->GenTauLorVec()->at(i).Energy()-evt->GenTauNuLorVec()->at(i).Energy()
);
genTauJetLorVec.push_back(tempVec);
}
if(verbose!=0){
printf(" ############# \n Number of gen tau: %d \n ",evt->GenTauPtVec_().size());
for(int i=0; i < genTauJetLorVec.size(); i++){
if(evt->GenTauHadVec_()[i]==1 && genTauJetLorVec.at(i).Pt() > 18.){
printf(" genTauJet: Pt: %g Eta: %g Phi: %g \n ",genTauJetLorVec.at(i).Pt(),genTauJetLorVec.at(i).Eta(),genTauJetLorVec.at(i).Phi());
for(int i=0; i<evt->TauLorVec_()->size(); i++){
printf(" \n patTau: pt: %g eta: %g phi: %g \n ",evt->TauLorVec_()->at(i).Pt(),evt->TauLorVec_()->at(i).Eta(),evt->TauLorVec_()->at(i).Phi());
printf(" Tauid => id1: %g id2: %g id3: %g id4: %g id5: %g id6: %g id7: %g id8: %g id9: %g id10: %g id11: %g \n ",evt->tauId1()->at(i),evt->tauId2()->at(i),evt->tauId3()->at(i),evt->tauId4()->at(i),evt->tauId5()->at(i),evt->tauId6()->at(i),evt->tauId7()->at(i),evt->tauId8()->at(i),evt->tauId9()->at(i),evt->tauId10()->at(i),evt->tauId11()->at(i));
}
}
}
}
//printf("nTau=> 2233: %d 2243: %d 2333: %d 4333: %d 1333: %d \n ",evt->nTauMap()[2233],evt->nTauMap()[2243],evt->nTauMap()[2333],evt->nTauMap()[4333],evt->nTauMap()[1333]);
// Print out some information
if(verbose!=0){
printf(" ########################### \n event #: %d \n",eventN);
printf(" ht: %g mht: %g nJets: %d nBtags: %d nIsoElec: %d nIsoMu: %d nIsoPion: %d nLeptons: %d \n ",evt->ht(),evt->mht(),evt->nJets(),evt->nBtags(),evt->nIsoElec(),evt->nIsoMu(),evt->nIsoPion(),evt->nLeptons());
printf(" @@@@\n Jets section: \n Njets: %d \n ", evt->nJets());
for(int i=0;i<evt->JetsPtVec_().size();i++){
printf("jet#: %d pt: %g eta: %g phi: %g \n ",i+1,evt->JetsPtVec_()[i],evt->JetsEtaVec_()[i],evt->JetsPhiVec_()[i]);
}
printf(" @@@@\n Muons section: \n Nmuons: %d \n ", evt->MuPtVec_().size());
for(int i=0;i<evt->MuPtVec_().size();i++){
printf("Muon#: %d pt: %g eta: %g phi: %g \n ",i+1,evt->MuPtVec_()[i],evt->MuEtaVec_()[i],evt->MuPhiVec_()[i]);
}
}
//printf(" mu from tau: %d elec from tau : %d hadronicTau: %d \n ", evt->GenMu_GenMuFromTau_(), evt->GenElec_GenElecFromTau_(),evt->GenTau_GenTauHad_());
//printf(" #Mu: %d #Tau: %d \n ", evt->GenMuPtVec_().size(), evt->GenTauPtVec_().size());
// count the number of taus for all possible combinations of tau id s
vector<int> NtauVec(200,0);
// apply the baseline cuts here to study the tau id s
if(sel->nolep(evt->nLeptons())&&sel->Njet_4(evt->nJets())&&sel->ht_500(evt->ht())&&
sel->mht_200(evt->mht())&&sel->MuIsoTrk(evt->nIsoMu())&&sel->ElecIsoTrk(evt->nIsoElec())&&
sel->dphi(evt->deltaPhi1(),evt->deltaPhi2(),evt->deltaPhi3(),evt->deltaPhi4()))
{
for(int i=0; i<evt->TauLorVec_()->size(); i++){
// 4 categories of tau id. First is anti-elec which has 3 id's. We also insert a 1 which means non of them are applied.
// the following 4 lines correspond whith each of the categories in the tau id.
int tauIdElec[4]={1,(int)evt->tauId1()->at(i),(int)evt->tauId2()->at(i),(int)evt->tauId3()->at(i)};
int tauIdMu[3] ={1,(int)evt->tauId4()->at(i),(int)evt->tauId5()->at(i)};
int tauIdIso[4] ={1,(int)evt->tauId6()->at(i),(int)evt->tauId7()->at(i),(int)evt->tauId8()->at(i)};
int tauIdPile[4]={1,(int)evt->tauId9()->at(i),(int)evt->tauId10()->at(i),(int)evt->tauId11()->at(i)};
/*
printf(" id1: %d id2: %d id3: %d id4: %d id5: %d id6: %d id7: %d id8: %d id9: %d id10: %d id11: %d \n",
(int)evt->tauId1()->at(i),(int)evt->tauId2()->at(i),(int)evt->tauId3()->at(i),(int)evt->tauId4()->at(i),
(int)evt->tauId5()->at(i),(int)evt->tauId6()->at(i),(int)evt->tauId7()->at(i),(int)evt->tauId8()->at(i),
(int)evt->tauId9()->at(i),(int)evt->tauId10()->at(i),(int)evt->tauId11()->at(i));
*/
int IdNum=0;
for(int iPile=0;iPile<(sizeof(tauIdPile)/sizeof(tauIdPile[0]));iPile++){
for(int iIso=0;iIso<(sizeof(tauIdIso)/sizeof(tauIdIso[0]));iIso++){
for(int iMu=0;iMu<(sizeof(tauIdMu)/sizeof(tauIdMu[0]));iMu++){
for(int iElec=0;iElec<(sizeof(tauIdElec)/sizeof(tauIdElec[0]));iElec++){
IdNum++;
if(tauIdElec[iElec]==1&&tauIdMu[iMu]==1&&tauIdIso[iIso]==1&&tauIdPile[iPile]==1)NtauVec[IdNum]++;
//printf(" iPile: %d => %d iIso: %d => %d iMu: %d => %d iElec: %d => %d \n",iPile,tauIdPile[iPile],iIso,tauIdIso[iIso],iMu,tauIdMu[iMu],iElec,tauIdElec[iElec]);
//printf(" id #: %d nTau: %d \n ",IdNum,NtauVec[IdNum]);
}
}
}
}
}
for(int iId=0; iId<NtauVec.size();iId++){
//printf(" @ \n iId: %d -> %s \n ",iId,idMap[iId].c_str());
if(NtauVec[iId]==0){
TauIDhist->Fill(iId-1,totWeight);
//cout << " filled \n ";
if(sel->PionIsoTrk(evt->nIsoPion()))TauIDhist_trk->Fill(iId-1,totWeight);
}
}
}
// Build and array that contains the quantities we need a histogram for.
// Here order is important and must be the same as RA2nocutvec
double eveinfvec[] = {totWeight,(double) evt->ht(),(double) evt->mht() ,(double) evt->nJets(),(double) evt->nBtags()}; //the last one gives the RA2 defined number of jets.
//loop over all the different backgrounds: "allEvents", "Wlv", "Zvv"
for(map<string, map<string , vector<TH1D> > >::iterator itt=map_map.begin(); itt!=map_map.end();itt++){//this will be terminated after the cuts
////determine what type of background should pass
if(itt->first=="allEvents"){//all the cuts are inside this
//Cuts//Cuts//Cuts//Cuts//Cuts//Cuts//Cuts//Cuts//Cuts//Cuts//Cuts//Cuts//Cuts//Cuts//Cuts//Cuts//Cuts//Cuts//Cuts//Cuts
//////loop over cut names and fill the histograms
for(map<string , vector<TH1D> >::iterator ite=cut_histvec_map.begin(); ite!=cut_histvec_map.end();ite++){
if(sel->checkcut(ite->first,evt->ht(),evt->mht(),evt->deltaPhi1(),evt->deltaPhi2(),evt->deltaPhi3(),evt->deltaPhi4(),evt->nJets(),evt->nBtags(),evt->nLeptons(),evt->nIsoElec(),evt->nIsoMu(),evt->nIsoPion(),evt->nTauMap()[2233],evt->nTauMap()[2243],evt->nTauMap()[2333],evt->nTauMap()[4333],evt->nTauMap()[1333])==true){
histobjmap[ite->first].fill(Nhists,&eveinfvec[0] ,&itt->second[ite->first][0]);
}
}//end of loop over cut names
////EndOfCuts//EndOfCuts//EndOfCuts//EndOfCuts//EndOfCuts//EndOfCuts//EndOfCuts//EndOfCuts//EndOfCuts//EndOfCuts
}//end of bg_type determination
}//end of loop over all the different backgrounds: "allEvents", "Wlv", "Zvv"
eventN++;
} // End of loop over events
//open a file to write the histograms
sprintf(tempname,"%s/results_%s_%s.root",Outdir.c_str(),subSampleKey.c_str(),inputnumber.c_str());
TFile *resFile = new TFile(tempname, "RECREATE");
TDirectory *cdtoitt;
TDirectory *cdtoit;
cutflow_preselection->Write();
TauIDhist->Write();
TauIDhist_trk->Write();
// Loop over different event categories (e.g. "All events, Wlnu, Zll, Zvv, etc")
for(int iet=0;iet<(int)eventType.size();iet++){
for(map<string, map<string , vector<TH1D> > >::iterator itt=map_map.begin(); itt!=map_map.end();itt++){
if (eventType[iet]==itt->first){
//KH
////std::cout << (itt->first).c_str() << std::endl;
cdtoitt = resFile->mkdir((itt->first).c_str());
cdtoitt->cd();
for(int i=0; i< (int)sel->cutName().size();i++){
for(map<string , vector<TH1D> >::iterator it=itt->second.begin(); it!=itt->second.end();it++){
if (sel->cutName()[i]==it->first){
cdtoit = cdtoitt->mkdir((it->first).c_str());
cdtoit->cd();
int nHist = it->second.size();
for(int i=0; i<nHist; i++){//since we only have 4 type of histograms
sprintf(tempname,"%s_%s_%s",it->second[i].GetName(),(it->first).c_str(),(itt->first).c_str());
it->second[i].Write(tempname);
}
cdtoitt->cd();
}
}
}
}
}
}
}
//------------------------Deal with the number and get the output stored in txt files and root files
void getResVsub(){
double Vmax[nbin], eps[nbin];
for(int ibin=0; ibin<nbin ;ibin++){
Vmax[ibin]=0.065*(trkbin[ibin]+30);
eps[ibin]=0.00025*(trkbin[ibin]+30);
}
ofstream fstrV;
double theta[ntheta];
TVectorD avgmult[nbin], avgpt[nbin], totmult[nbin], totpt[nbin];
TVectorD Qx1[nbin], Qy1[nbin], Q2[nbin];
TVectorD Gmod2[nbin][nptV][ntheta];
TVectorD sigma2[nbin][nptV],deltaV[nbin][nptV];
TVectorD sigma2_[nbin],chi_[nbin];
TVectorD deltaVmean[nbin], Vmean[nbin];
TVectorD deltaVmeanmean, Vmeanmean, sigmaVmeanmean;
TVectorD r[nbin];
TVectorD r0[nbin][nptV], r01[nbin][nptV], V[nbin][nptV], chi[nbin][nptV];
TVectorD GRe[nbin][nptV][ntheta]; TVectorD* GRe_t[nbin][nptV][ntheta];
TVectorD GIm[nbin][nptV][ntheta]; TVectorD* GIm_t[nbin][nptV][ntheta];
TComplex G[nbin][nptV][ntheta][nstepr];
if(isSum) fstrV.open("V_Sum_sub.txt");
else fstrV.open("V_Prod_sub.txt");
if(isSum) TString outname = "mergedV_Sum_sub.root";
else TString outname="mergedV_Prod_sub.root";
TFile *outf = new TFile(outname,"Recreate");
int subsample = (int)(nFileAll/nsamples);
TFile *f[nFileAll];
for(int ibin=0; ibin<nbin; ibin++){
r[ibin].ResizeTo(nstepr);
for(int ir=0; ir<nstepr; ir++){
if(isSimple==0) r[ibin][ir]=j01/(Vmax[ibin]-eps[ibin]*ir);
else r[ibin][ir]=0.00025*20*(ir+1);
}
}
Vmeanmean.ResizeTo(nbin); Vmeanmean.Zero();
deltaVmeanmean.ResizeTo(nbin); deltaVmeanmean.Zero();
sigmaVmeanmean.ResizeTo(nbin); sigmaVmeanmean.Zero();
for(int isample=0;isample<nsamples;isample++){
cout<<"start with "<<isample<<"\t";
int start=isample*subsample;
int end=(isample+1)*subsample;
TVectorD Nevent; Nevent.ResizeTo(nbin); Nevent.Zero();
TVectorD totmultall; totmultall.ResizeTo(nbin); totmultall.Zero();
for(int itheta=0;itheta<ntheta;itheta++)
theta[itheta]=itheta*TMath::Pi()/ntheta/nn;
for(int ibin=0;ibin<nbin;ibin++){
for(int iptbin=0;iptbin<nptV;iptbin++){
r0[ibin][iptbin].ResizeTo(ntheta);
r01[ibin][iptbin].ResizeTo(ntheta);
sigma2[ibin][iptbin].ResizeTo(ntheta);
V[ibin][iptbin].ResizeTo(ntheta);
deltaV[ibin][iptbin].ResizeTo(ntheta);
chi[ibin][iptbin].ResizeTo(ntheta);
for(int itheta=0;itheta<ntheta;itheta++){
Gmod2[ibin][iptbin][itheta].ResizeTo(nstepr);
GRe[ibin][iptbin][itheta].ResizeTo(nstepr);
GRe[ibin][iptbin][itheta].Zero();
GIm[ibin][iptbin][itheta].ResizeTo(nstepr);
GIm[ibin][iptbin][itheta].Zero();
}
}
avgmult[ibin].ResizeTo(nptV); deltaVmean[ibin].ResizeTo(nptV); Vmean[ibin].ResizeTo(nptV);
deltaVmean[ibin].Zero(); Vmean[ibin].Zero();
Vmean[ibin].Zero(); deltaVmean[ibin].Zero();
totpt[ibin].ResizeTo(nptV); totpt[ibin].Zero();
totmult[ibin].ResizeTo(nptV); totmult[ibin].Zero();
avgpt[ibin].ResizeTo(nptV);
Qx1[ibin].ResizeTo(nptV); Qx1[ibin].Zero();
Qy1[ibin].ResizeTo(nptV); Qy1[ibin].Zero();
Q2[ibin].ResizeTo(nptV); Q2[ibin].Zero();
sigma2_[ibin].ResizeTo(nptV);sigma2_[ibin].Zero();
chi_[ibin].ResizeTo(nptV);chi_[ibin].Zero();
}
for(int ifile=start; ifile<end; ifile++){
if(isSum) f[ifile] = TFile::Open(Form("/lio/lfs/cms/store/user/qixu/flow/pbsjoboutput/pPbDataV205m185/AnaV_Sum_%d.root",ifile));
else f[ifile] = TFile::Open(Form("/lio/lfs/cms/store/user/qixu/flow/pbsjoboutput/pPbDataV205m185/AnaV_Prod_%d.root",ifile));
TVectorD* Nevent_t = (TVectorD*)f[ifile]->Get(Form("Nevent"));
TVectorD* totmultall_t = (TVectorD*)f[ifile]->Get(Form("totmultall"));
for(int ibin=0;ibin<nbin;ibin++){
for(int iptbin=0;iptbin<nptV;iptbin++){
for(int itheta=0;itheta<ntheta;itheta++){
GRe_t[ibin][iptbin][itheta] = (TVectorD*)f[ifile]->Get(Form("GRe_%d_%d_%d",ibin,iptbin,itheta));
GIm_t[ibin][iptbin][itheta] = (TVectorD*)f[ifile]->Get(Form("GIm_%d_%d_%d",ibin,iptbin,itheta));
for(ir=0; ir<nstepr; ir++){
GRe[ibin][iptbin][itheta][ir] += (*GRe_t[ibin][iptbin][itheta])[ir];
GIm[ibin][iptbin][itheta][ir] += (*GIm_t[ibin][iptbin][itheta])[ir];
}
}
}
TVectorD* Qx1_t = (TVectorD*)f[ifile]->Get(Form("Qx1_%d",ibin));
TVectorD* Qy1_t = (TVectorD*)f[ifile]->Get(Form("Qy1_%d",ibin));
TVectorD* Q2_t = (TVectorD*)f[ifile]->Get(Form("Q2_%d",ibin));
TVectorD* totmult_t = (TVectorD*)f[ifile]->Get(Form("totmult_%d",ibin));
TVectorD* totpt_t = (TVectorD*)f[ifile]->Get(Form("totpt_%d",ibin));
for(int iptbin=0;iptbin<nptV;iptbin++){
Qx1[ibin][iptbin] += (*Qx1_t)[iptbin];
Qy1[ibin][iptbin] += (*Qy1_t)[iptbin];
Q2[ibin][iptbin] += (*Q2_t)[iptbin];
totmult[ibin][iptbin] += (*totmult_t)[iptbin];
totpt[ibin][iptbin] += (*totpt_t)[iptbin];
}
Nevent[ibin] += (*Nevent_t)[ibin];
totmultall[ibin] += (*totmultall_t)[ibin];
}
f[ifile]->Close();
}
fstrV<<setprecision(4)<<fixed;
fstrV<<"ibin"<<"\t"<<"itheta"<<"\t"<<"r0"<<"\t"<<"V"<<"\t"<<"sigma2"<<"\t"<<"chi"<<"\t"<<"Vn Errors"<<endl;
for(int ibin=0;ibin<nbin;ibin++){
for(int iptbin=0;iptbin<nptV;iptbin++){
for(int itheta=0;itheta<ntheta;itheta++){
for(ir=0; ir<nstepr; ir++){
G[ibin][iptbin][itheta][ir]=TComplex(GRe[ibin][iptbin][itheta][ir],GIm[ibin][iptbin][itheta][ir]);
G[ibin][iptbin][itheta][ir]/=Nevent[ibin];
Gmod2[ibin][iptbin][itheta][ir]=TMath::Power(TComplex::Abs(G[ibin][iptbin][itheta][ir]),2);
}
for(ir=0; ir<nstepr-1; ir++)
if(ir!=0 && Gmod2[ibin][iptbin][itheta][ir]<=Gmod2[ibin][iptbin][itheta][ir-1] && Gmod2[ibin][iptbin][itheta][ir]<=Gmod2[ibin][iptbin][itheta][ir+1]) break;
if(ir!=0 && ir<nstepr-1) r01[ibin][iptbin][itheta]=r[ibin][ir];
else if(ir==0) {cout<<"ibin="<<ibin<<"\t"<<"iptbin="<<iptbin<<"\t"<<"itheta="<<itheta<<"\tminimum lies on ir = 0, please select proper range!"<<endl; continue;}
else {cout<<"ibin="<<ibin<<"\t"<<"iptbin="<<iptbin<<"\t"<<"itheta="<<itheta<<"\tminimum lies on ir = maximum "<<nstepr-1<<", please select proper range!"<<endl; continue;}
avgmult[ibin][iptbin]=1.0*totmult[ibin][iptbin]/Nevent[ibin];
avgpt[ibin][iptbin]=1.0*totpt[ibin][iptbin]/totmult[ibin][iptbin];
if(isSimple==0) V[ibin][iptbin][itheta]=Vmax[ibin]-ir*eps[ibin]+eps[ibin]*(Gmod2[ibin][iptbin][itheta][ir+1]-Gmod2[ibin][iptbin][itheta][ir-1])/2./(Gmod2[ibin][iptbin][itheta][ir-1]-2*Gmod2[ibin][iptbin][itheta][ir]+Gmod2[ibin][iptbin][itheta][ir+1]);
else V[ibin][iptbin][itheta]=j01/r0[ibin][iptbin][itheta]; //simple method
r0[ibin][iptbin][itheta]=j01/V[ibin][iptbin][itheta];
V[ibin][iptbin][itheta]/=avgmult[ibin][iptbin];
//sigma2[ibin][iptbin][itheta]=Q2[ibin][iptbin]/Nevent[ibin]-(Qx1[ibin][iptbin]/Nevent[ibin])*(Qx1[ibin][iptbin]/Nevent[ibin])-(Qy1[ibin][iptbin]/Nevent[ibin])*(Qy1[ibin][iptbin]/Nevent[ibin])-(V[ibin][iptbin][itheta]*avgmult[ibin][iptbin])*(V[ibin][iptbin][itheta]*avgmult[ibin][iptbin]);
sigma2[ibin][iptbin][itheta]=Q2[ibin][iptbin]/Nevent[ibin]-(Qx1[ibin][iptbin]/Nevent[ibin])*(Qx1[ibin][iptbin]/Nevent[ibin])-(Qy1[ibin][iptbin]/Nevent[ibin])*(Qy1[ibin][iptbin]/Nevent[ibin]);
sigma2_[ibin][iptbin]+=sigma2[ibin][iptbin][itheta];
Vmean[ibin][iptbin]+=V[ibin][iptbin][itheta];
chi[ibin][iptbin][itheta]=V[ibin][iptbin][itheta]*avgmult[ibin][iptbin]/TMath::Sqrt(sigma2[ibin][iptbin][itheta]);
//deltaV[ibin][iptbin][itheta]=V[ibin][iptbin][itheta]/j01/TMath::BesselJ1(j01)*TMath::Sqrt((TMath::Exp(j01*j01/2./chi[ibin][iptbin][itheta]/chi[ibin][iptbin][itheta])+TMath::Exp(-j01*j01/2./chi[ibin][iptbin][itheta]/chi[ibin][iptbin][itheta])*TMath::BesselJ0(2*j01))/2./Nevent[ibin]);
}
sigma2_[ibin][iptbin]/=ntheta;
Vmean[ibin][iptbin]/=ntheta;
sigma2_[ibin][iptbin]-=TMath::Power(Vmean[ibin][iptbin]*avgmult[ibin][iptbin],2);
chi_[ibin][iptbin]=Vmean[ibin][iptbin]*avgmult[ibin][iptbin]/TMath::Sqrt(sigma2_[ibin][iptbin]);
//deltaVmean[ibin][iptbin]+=TMath::Exp(j01*j01/2./chi[ibin][iptbin][itheta]/chi[ibin][iptbin][itheta]*TMath::Cos(nn*theta[itheta]))*TMath::BesselJ0(2*j01*TMath::Sin(nn*theta[itheta]/2.))+TMath::Exp(-j01*j01/2./chi[ibin][iptbin][itheta]/chi[ibin][iptbin][itheta]*TMath::Cos(nn*theta[itheta]))*TMath::BesselJ0(2*j01*TMath::Cos(nn*theta[itheta]/2.));
for(int itheta=0;itheta<ntheta;itheta++){
deltaV[ibin][iptbin][itheta]=V[ibin][iptbin][itheta]/j01/TMath::BesselJ1(j01)*TMath::Sqrt((TMath::Exp(j01*j01/2./chi_[ibin][iptbin]/chi_[ibin][iptbin])+TMath::Exp(-j01*j01/2./chi_[ibin][iptbin]/chi_[ibin][iptbin])*TMath::BesselJ0(2*j01))/2./Nevent[ibin]);
deltaVmean[ibin][iptbin]+=TMath::Exp(j01*j01/2./chi_[ibin][iptbin]/chi_[ibin][iptbin]*TMath::Cos(nn*theta[itheta]))*TMath::BesselJ0(2*j01*TMath::Sin(nn*theta[itheta]/2.))+TMath::Exp(-j01*j01/2./chi_[ibin][iptbin]/chi_[ibin][iptbin]*TMath::Cos(nn*theta[itheta]))*TMath::BesselJ0(2*j01*TMath::Cos(nn*theta[itheta]/2.));
fstrV<<ibin<<"\t"<<itheta<<"\t"<<r0[ibin][iptbin][itheta]<<"\t"<<V[ibin][iptbin][itheta]<<"\t"<<sigma2[ibin][iptbin][itheta]<<"\t"<<chi[ibin][iptbin][itheta]<<"\t"<<deltaV[ibin][iptbin][itheta]<<endl;
}
fstrV<<endl;
deltaVmean[ibin][iptbin]=Vmean[ibin][iptbin]/j01/TMath::BesselJ1(j01)*TMath::Sqrt(deltaVmean[ibin][iptbin]/ntheta/2./Nevent[ibin]);
}
fstrV<<endl;
}
fstrV<<"ibin"<<"\t"<<"avgmult"<<"\t"<<"avgpt"<<"\t"<<"Vn mean"<<"\t"<<"Vn mean Error"<<endl;
for(int ibin=0;ibin<nbin;ibin++){
for(int iptbin=0;iptbin<nptV;iptbin++){
fstrV<<ibin<<"\t"<<avgmult[ibin][iptbin]<<"\t"<<avgpt[ibin][iptbin]<<"\t"<<Vmean[ibin][iptbin]<<"\t"<<deltaVmean[ibin][iptbin]<<endl;
}
fstrV<<endl;
}
TDirectory *dirsample = outf->mkdir(Form("s_%d",isample));
dirsample->cd();
Nevent.Write("Nevent");
totmultall.Write("totmultall");
for(int ibin=0;ibin<nbin;ibin++){
TDirectory *dir0 = dirsample->mkdir(Form("D_%d",ibin));dir0->cd();
r[ibin].Write("r");
Qx1[ibin].Write("Qx1");
Qy1[ibin].Write("Qy1");
Q2[ibin].Write("Q2");
totmult[ibin].Write("totmult");
totpt[ibin].Write("totpt");
avgmult[ibin].Write("avgmult");
avgpt[ibin].Write("avgpt");
Vmean[ibin].Write("Vmean");
deltaVmean[ibin].Write("deltaVmean");
Vmeanmean[ibin]+=Vmean[ibin][0]/nsamples;
deltaVmeanmean[ibin]+=deltaVmean[ibin][0]/nsamples;
sigmaVmeanmean[ibin]+=TMath::Power(Vmean[ibin][0]/nsamples,2);
chi_[ibin].Write("chi");
for(int iptbin=0;iptbin<nptV;iptbin++){
TDirectory *dir1 = dir0->mkdir(Form("D_%d",iptbin));dir1->cd();
sigma2[ibin][iptbin].Write("sigma2"); chi[ibin][iptbin].Write("chi0"); deltaV[ibin][iptbin].Write("deltaV");
r0[ibin][iptbin].Write("r0"); r01[ibin][iptbin].Write("r01"); V[ibin][iptbin].Write("V");
for(int itheta=0;itheta<ntheta;itheta++){
TDirectory *dir2 = dir1->mkdir(Form("D_%d",itheta));dir2->cd();
GRe[ibin][iptbin][itheta].Write(Form("GRe"));
GIm[ibin][iptbin][itheta].Write(Form("GIm"));
Gmod2[ibin][iptbin][itheta].Write(Form("G2"));
}
}
}
}
fstrV<<"ibin"<<"\t"<<"Vn mean mean"<<"\t"<<"Vn mean mean Error"<<"\t"<<"Vn mean deviation"<<endl;
for(int ibin=0;ibin<nbin;ibin++){
sigmaVmeanmean[ibin]=TMath::Sqrt(sigmaVmeanmean[ibin]*nsamples-Vmeanmean[ibin]*Vmeanmean[ibin]);
fstrV<<endl<<ibin<<"\t"<<Vmeanmean[ibin]<<"\t"<<deltaVmeanmean[ibin]<<"\t"<<sigmaVmeanmean[ibin]<<endl;
}
outf->cd();
Vmeanmean.Write("Vmeanmean");
deltaVmeanmean.Write("deltaVmeanmean");
sigmaVmeanmean.Write("sigmaVmeanmean");
cout<<endl;
outf->Close();
}
mainClass(int luminosity=5000){ // luminosity is in /pb unit
cutname[0]="nocut";cutname[1]="Njet_4";cutname[2]="ht_500" ;cutname[3]="mht_200";
cutname[4]="delphi";cutname[5]="iso";
cutname[6]="CSVM_0";
cutname[7]="CSVM_1";
cutname[8]="CSVM_2";
cutname[9]="CSVM_3";
WJtype[0]="EventsWith_1RecoMuon_0RecoElectron";
TTbartype[0]="EventsWith_1RecoMuon_0RecoElectron";
// .....................................................................................................................................................//
// WJ Section
// .....................................................................................................................................................//
//build a vector of scale factors
//first load the cross sections into a vector
vector<double> WJ_xs_vec;
WJ_xs_vec.push_back(1817.0); // HT 100-200
WJ_xs_vec.push_back(471.6); // HT 200-400
WJ_xs_vec.push_back(55.61); // HT 400-600
WJ_xs_vec.push_back(18.81); // HT 600-Inf
const int wjnHT = (int) WJ_xs_vec.size(); // Total number of HT bin samples
for(int i=1; i<=wjnHT ; i++){
if(i==1)sprintf(tempname,"../Results/results_WJ_HT-100to200_.root");
else if(i==2)sprintf(tempname,"../Results/results_WJ_HT-200to400_.root");
else if(i==3)sprintf(tempname,"../Results/results_WJ_HT-400to600_.root");
else if(i==4)sprintf(tempname,"../Results/results_WJ_HT-600toInf_.root");
else{cout << " Error!! There are only 4 WJet ht binned sample " << endl;}
file = new TFile(tempname, "R");
sprintf(tempname,"allEvents/nocut/MHT_nocut_allEvents");
tempvalue = (luminosity*WJ_xs_vec[i-1])/((* (TH1D* ) file->Get(tempname)).GetEntries());
printf("Scale: %g, N: %g, Lum: %d, XS: %g \n ",tempvalue,((* (TH1D* ) file->Get(tempname)).GetEntries()),luminosity,WJ_xs_vec[i-1]);
WJ_scalevec.push_back(tempvalue);
}//end of loop over HTbins
std::cout << "WJ normalization scale factor determination done \n " << std::endl;
//..........................................//
// main histograms like HT, MHT, ...
//..........................................//
// Load the files to a vector
// These are the HT, MHT, .. variables
for(int i=1; i<=wjnHT ; i++){
if(i==1)sprintf(tempname,"HadTauEstimation_WJ_HT-100to200_.root");
else if(i==2)sprintf(tempname,"HadTauEstimation_WJ_HT-200to400_.root");
else if(i==3)sprintf(tempname,"HadTauEstimation_WJ_HT-400to600_.root");
else if(i==4)sprintf(tempname,"HadTauEstimation_WJ_HT-600toInf_.root");
else{cout << " Error!! There are only 4 WJet ht binned sample " << endl;}
WJ_inputfilevec.push_back(TFile::Open(tempname,"R"));
}//end of loop over HTbins
// Stack
tempstack = new THStack("stack","Binned Sample Stack");
sprintf(tempname,"HadTauEstimation_WJ_stacked.root");
file = new TFile(tempname,"RECREATE");
histname.clear();
histname[0]="weight";
histname[1]="HT";
histname[2]="MHT";
histname[3]="NJet";
histname[4]="NBtag";
histname[5]="MuonPt";
histname[6]="MtW";
for(map<int , string >::iterator itt=WJtype.begin(); itt!=WJtype.end();itt++){ // loop over different event types
cdtoitt = file->mkdir((itt->second).c_str());
cdtoitt->cd();
for(map<int , string >::iterator it=cutname.begin(); it!=cutname.end();it++){ // loop over different cutnames
cdtoit = cdtoitt->mkdir((it->second).c_str());
cdtoit->cd();
for(int j=0; j<histname.size(); j++){ // loop over different histograms
for(int i=0; i<wjnHT ; i++){ // loop over different HT bins
//cout << "================================" << endl;
//cout << "HT#: " <<i << ", WJtype: " << itt->second << ", cutname: " << it->second << ", hist#: " << j << endl;
sprintf(tempname,"%s/%s/%s_%s_%s",(itt->second).c_str(),(it->second).c_str(),(histname[j]).c_str(),(it->second).c_str(),(itt->second).c_str());
temphist = (TH1D *) WJ_inputfilevec.at(i)->Get(tempname)->Clone();
temphist->Scale(WJ_scalevec[i]);
temphist->SetFillColor(i+2);
tempstack->Add(temphist);
}//end of loop over HTbins 1..7
sprintf(tempname,"%s_%s_%s",histname[j].c_str(),(it->second).c_str(),(itt->second).c_str());
tempstack->Write(tempname);
delete tempstack;
tempstack = new THStack("stack","Binned Sample Stack");
}//end of loop over histograms
}//end of loop over cutnames
}//end of loop over event types
file->Close();
printf("WJ main histograms stacked \n ");
// .....................................................................................................................................................//
// TTbar Section
// .....................................................................................................................................................//
//build a vector of scale factors
//first load the cross sections into a vector
vector<double> TTbar_xs_vec;
TTbar_xs_vec.push_back(806.1); //
const int ttbarnHT = (int) TTbar_xs_vec.size(); // Total number of HT bin samples
for(int i=1; i<=ttbarnHT ; i++){
if(i==1)sprintf(tempname,"../Results/results_TTbar_.root");
else{cout << " Error!! There are only 1 TTbaret ht binned sample " << endl;}
file = new TFile(tempname, "R");
sprintf(tempname,"allEvents/nocut/MHT_nocut_allEvents");
tempvalue = (luminosity*TTbar_xs_vec[i-1])/((* (TH1D* ) file->Get(tempname)).GetEntries());
printf("Scale: %g, N: %g, Lum: %d, XS: %g \n ",tempvalue,((* (TH1D* ) file->Get(tempname)).GetEntries()),luminosity,TTbar_xs_vec[i-1]);
TTbar_scalevec.push_back(tempvalue);
}//end of loop over HTbins
std::cout << "TTbar normalization scale factor determination done \n " << std::endl;
//..........................................//
// main histograms like HT, MHT, ...
//..........................................//
// Load the files to a vector
// These are the HT, MHT, .. variables
for(int i=1; i<=ttbarnHT ; i++){
if(i==1)sprintf(tempname,"HadTauEstimation_TTbar_.root");
else{cout << " Error!! There are only 1 TTbaret ht binned sample " << endl;}
TTbar_inputfilevec.push_back(TFile::Open(tempname,"R"));
}//end of loop over HTbins
// Stack
tempstack = new THStack("stack","Binned Sample Stack");
sprintf(tempname,"HadTauEstimation_TTbar_stacked.root");
file = new TFile(tempname,"RECREATE");
histname.clear();
histname[0]="weight";
histname[1]="HT";
histname[2]="MHT";
histname[3]="NJet";
histname[4]="NBtag";
histname[5]="MuonPt";
histname[6]="MtW";
for(map<int , string >::iterator itt=TTbartype.begin(); itt!=TTbartype.end();itt++){ // loop over different event types
cdtoitt = file->mkdir((itt->second).c_str());
cdtoitt->cd();
for(map<int , string >::iterator it=cutname.begin(); it!=cutname.end();it++){ // loop over different cutnames
cdtoit = cdtoitt->mkdir((it->second).c_str());
cdtoit->cd();
for(int j=0; j<histname.size(); j++){ // loop over different histograms
for(int i=0; i<ttbarnHT ; i++){ // loop over different HT bins
//cout << "================================" << endl;
//cout << "HT#: " <<i << ", TTbartype: " << itt->second << ", cutname: " << it->second << ", hist#: " << j << endl;
sprintf(tempname,"%s/%s/%s_%s_%s",(itt->second).c_str(),(it->second).c_str(),(histname[j]).c_str(),(it->second).c_str(),(itt->second).c_str());
temphist = (TH1D *) TTbar_inputfilevec.at(i)->Get(tempname)->Clone();
temphist->Scale(TTbar_scalevec[i]);
temphist->SetFillColor(i+2);
tempstack->Add(temphist);
}//end of loop over HTbins 1..7
sprintf(tempname,"%s_%s_%s",histname[j].c_str(),(it->second).c_str(),(itt->second).c_str());
tempstack->Write(tempname);
delete tempstack;
tempstack = new THStack("stack","Binned Sample Stack");
}//end of loop over histograms
}//end of loop over cutnames
}//end of loop over event types
file->Close();
printf("TTbar main histograms stacked \n ");
// ..................................................................................................................................................... //
// Stack main histograms from TTbar and WJet
// ..................................................................................................................................................... //
// There are two contributors 1-TTbar and 2-WJ
int NSamples=2;
// A vector that contains all the samples
vector<TFile*> sample_inputfilevec;
THStack * tempstack2 = new THStack("stack","Binned Sample Stack");
// Load the files to a vector
// These are the HT, MHT, .. variables
for(int i=1; i<=NSamples ; i++){
if(i==1)sprintf(tempname,"HadTauEstimation_TTbar_stacked.root");
else if(i==2)sprintf(tempname,"HadTauEstimation_WJ_stacked.root");
else{cout << " Error!! There are only 2 contributors! " << endl;}
sample_inputfilevec.push_back(TFile::Open(tempname,"R"));
}//end of loop over HTbins
// Stack
delete tempstack;
tempstack = new THStack("stack","Binned Sample Stack");
sprintf(tempname,"HadTauEstimation_stacked.root");
file = new TFile(tempname,"RECREATE");
histname.clear();
histname[0]="weight";
histname[1]="HT";
histname[2]="MHT";
histname[3]="NJet";
histname[4]="NBtag";
histname[5]="MuonPt";
histname[6]="MtW";
for(map<int , string >::iterator itt=WJtype.begin(); itt!=WJtype.end();itt++){ // loop over different event types
cdtoitt = file->mkdir((itt->second).c_str());
cdtoitt->cd();
for(map<int , string >::iterator it=cutname.begin(); it!=cutname.end();it++){ // loop over different cutnames
cdtoit = cdtoitt->mkdir((it->second).c_str());
cdtoit->cd();
for(int j=0; j<histname.size(); j++){ // loop over different histograms
for(int i=0; i<NSamples ; i++){ // loop over different HT bins
//cout << "================================" << endl;
//cout << "HT#: " <<i << ", WJtype: " << itt->second << ", cutname: " << it->second << ", hist#: " << j << endl;
sprintf(tempname,"%s/%s/%s_%s_%s",(itt->second).c_str(),(it->second).c_str(),(histname[j]).c_str(),(it->second).c_str(),(itt->second).c_str());
tempstack2 = (THStack *) sample_inputfilevec.at(i)->Get(tempname)->Clone();
temphist = (TH1D*)tempstack2->GetStack()->Last();
temphist->SetFillColor(i+2);
tempstack->Add(temphist);
}//end of loop over HTbins 1..7
sprintf(tempname,"%s_%s_%s",histname[j].c_str(),(it->second).c_str(),(itt->second).c_str());
tempstack->Write(tempname);
delete tempstack;
tempstack = new THStack("stack","Binned Sample Stack");
}//end of loop over histograms
}//end of loop over cutnames
}//end of loop over event types
file->Close();
printf("All samples main histograms stacked \n ");
} // End of the constructor
void pixel_scurve() {
std::cout << "In pixel_scurve" << std::endl;
//Set the fed/channel ids you want to analyze
unsigned int fedmin = 33;
unsigned int fedmax = fedmin;
//to avoid memory problems do not run more than 12 channels per time
unsigned int fedchanmin[] = {13} ; //{fedchanmin(fedmin),...,fedchanmin(fedmax)}
unsigned int fedchanmax[] = {24} ; //{fedchanmax(fedmin),...,fedchanmax(fedmax)}
//set the rocs you want to analyze
unsigned int rocmin;
unsigned int rocmax;
rocmin=1;
rocmax=24;
//set the rows and cols you want to analyze
int rowmin = 35;
int rowmax = 44;
int colmin = 21;
int colmax = 30;
//open the data file (please edit it with the correct name)
std::ifstream in;
in.open("SCurve_283.dmp",ios::binary|ios::in);
assert(in.good());
//open the error log file
fstream out;
char errFileName[20];
if (fedmin==fedmax) sprintf(errFileName,"FED%d_Channel%d-%d_PixSCurvesErrors.txt",fedmin,fedchanmin[0],fedchanmax[0]) ;
else sprintf(errFileName,"FED%d-%d_PixSCurvesErrors.txt",fedmin,fedmax);
out.open(errFileName,fstream::out);
// for releases pos_2_4_3 and later
// first 64 bits of dmp file gives run number
uint64_t run_num;
in.read((char*)&run_num,8);
cout << "Run number=" << run_num<<endl;
//instance the PixelCalib class: it gets all info needed from calib.dat and translation.dat files (please edit them with the correct name)
PixelCalib calib("calib_SCurve_283.dat","translation.dat");
//get the list of panel types associated to the disk, blade, panel numbers and the fed and the channel (according to translation.dat)
std::vector<std::pair<vector<int>,std::string> > panelTypes;
panelTypes = calib.getPanelTypesAndFEDInfo() ;
int ntrig=calib.nTriggersPerPattern();
cout << " ntriggers per pattern=" << ntrig;
int nvcal=calib.nScanPoints("Vcal" );
cout << " # scan points=" << nvcal ;
int vcalmin=int(calib.scanValueMin("Vcal"));
int vcalmax=int(calib.scanValueMax("Vcal"));
cout << " min=" << vcalmin << " max=" << vcalmax << endl;
pixel::SLinkData pixeldata;
//compute the number of feds, channel and rocs to be analyzed
unsigned int nOfFed = fedmax-fedmin+1;
unsigned int nOfChan[nOfFed];
unsigned int maxNOfChan = 0;
for (unsigned int pp=0; pp<nOfFed; ++pp) {
nOfChan[pp] = fedchanmax[pp]-fedchanmin[pp]+1;
if (maxNOfChan<fedchanmax[pp]-fedchanmin[pp]+1) maxNOfChan=fedchanmax[pp]-fedchanmin[pp]+1;
}
unsigned int nOfROCS = rocmax - rocmin +1;
//create the matrix with the scurves plots
pixelROCscurve roceff[nOfFed][maxNOfChan][nOfROCS];
//initialize expected fed links and all rocs
cout << "initialize expected fed links and all rocs...";
for(unsigned int fedid=0; fedid<nOfFed; fedid++) {
for(unsigned int linkid=0; linkid<nOfChan[fedid]; linkid++) {
for(unsigned int rocid=0; rocid<nOfROCS; rocid++) { //init all rocs
//cout << "init link="<<linkid+fedchanmin[fedid]<< " roc="<<rocid+1<<"...";
roceff[fedid][linkid][rocid].init(linkid+fedchanmin[fedid],rocid+rocmin,nvcal,vcalmin,vcalmax,ntrig);
}
}
}
cout << " success!" << endl;
std::vector<unsigned int> const *rows=0;
std::vector<unsigned int> const *cols=0;
int nEvent=0;
//set the maximum naumber of events to be processed
int maxevent=2000000;
//maxevent=15000;
unsigned int vcalvalue=0;
//event loop: read data
cout << "Starting event loop..." << endl;
while(pixeldata.load(in)&&nEvent<maxevent) {
//cout << "begin of event" << endl;
if (nEvent%10000==0) cout << "nEvent:"<<nEvent<<endl;
if (nEvent%(ntrig*nvcal*calib.getNumberOfFeds())==0) {
cout << "new pattern" <<endl;
//new pattern: get the rows and columns of this pattern
calib.getRowsAndCols(nEvent/(ntrig*calib.getNumberOfFeds()),rows,cols);
assert(rows!=0);
assert(cols!=0);
cout << "Event:"<<nEvent<<" Rows:";
for( unsigned int i=0; i<rows->size(); i++) {
cout << (*rows)[i]<<" ";
}
cout <<" Cols:";
for( unsigned int i=0; i<cols->size(); i++) {
cout << (*cols)[i]<<" ";
}
cout <<endl;
}
if(nEvent%(ntrig)==0) {
vcalvalue= calib.scanValue("Vcal",nEvent/(ntrig*calib.getNumberOfFeds()));
}
//get fedid and skip if not in [fedmin,fedmax]
int fed = pixeldata.getHeader().getSource_id();
if ( fed<((int)fedmin) || fed>((int)fedmax) ) {
nEvent++;
continue;
}
int fedn = fed-fedmin;
std::vector<pixel::SLinkHit> hits=pixeldata.getHits();
std::vector<pixel::SLinkHit>::iterator ihit=hits.begin();
//loop over the hits in the event
for (; ihit!=hits.end(); ++ihit) {
//cout << "begin of hits loop" << endl;
//get channel, roc, row, col
unsigned int linkid=ihit->get_link_id();
unsigned int rocid=ihit->get_roc_id();
unsigned int row=ihit->get_row();
unsigned int col=ihit->get_col();
/* cout << "fed=" << fed << " linkid=" << linkid */
/* << " rocid=" << rocid */
/* << " row=" << row */
/* << " col=" << col << endl; */
//continue if not in [fedchanmin,fedchanmax] and [rocmin,rocmax]
if (linkid<fedchanmin[fedn]||linkid>fedchanmax[fedn]) {
continue;
}
if (rocid<rocmin||rocid>rocmax) {
continue;
}
if (row>=80||col>=52) {
out << "Row or column outside limits (fed,link,roc,row,col):"<<
fed<<","<<linkid<<","<<rocid<<"," << row<<","<<col<<endl;
continue;
}
assert(linkid>0&&linkid<37);
assert(rocid<25);
assert(row<80);
assert(col<52);
bool valid_row=false;
bool valid_col=false;
for (unsigned int i=0; i<rows->size(); i++) {
if (row==(*rows)[i]) valid_row=true;
}
for (unsigned int i=0; i<cols->size(); i++) {
if (col==(*cols)[i]) valid_col=true;
}
//fill histograms
if (valid_row&&valid_col) {
assert(linkid>=1&&linkid<=36);
assert(rocid>=1&&rocid<=24);
//cout << "filling:" << fedn << " "<< linkid-fedchanmin[fedn] << " " << rocid <<" "<< row<<" " << col << endl;
roceff[fedn][linkid-fedchanmin[fedn]][rocid-rocmin].fill(row,col,vcalvalue);
}
else {
out << "Not valid row or column (fed,link,roc,row,col):"<<
fed<<","<<linkid<<","<<rocid<<"," << row<<","<<col<<endl;
}
//cout << "end of hits loop" << endl;
}
nEvent++;
//cout << "end of event" << endl;
}
cout << "...Processed:"<<nEvent<<" triggers"<<endl;
// fits
cout << "Fitting..." ;
for(unsigned int fedid=0; fedid<nOfFed; fedid++) {
for(unsigned int channel=0; channel<nOfChan[fedid]; channel++) {
for(unsigned int roc=0; roc<nOfROCS; roc++) {
for(int row = rowmin; row<=rowmax; row++) {
for(int col = colmin; col<=colmax; col++) {
//cout << "fit array pos=" << fedid << " " << channel << " " << roc << " " << row << " " << col << endl;
roceff[fedid][channel][roc].fit(row,col);
} //col
} //row
} //roc
} //chan
}
cout << "done!" << endl;
//save plots
cout << "Making FULL plots" << endl;
//create output file
char outFileName[20];
if (fedmin==fedmax) sprintf(outFileName,"FED%d_Ch%d-%d_SCurves.root",fedmin,fedchanmin[0],fedchanmax[0]) ;
else sprintf(outFileName,"FED%d-%d_PixSCurves.root",fedmin,fedmax);
TFile * f = new TFile(outFileName,"RECREATE") ;
TDirectory * dirSP = f->mkdir("SummaryPlots");
dirSP->cd();
TH1F * hMeanNoise = new TH1F("MeanNoise","MeanNoise",100,0,10);
TH1F * hMeanThreshold = new TH1F("MeanThreshold","MeanThreshold",100,0,200);
char title[20] ;
//these are the kind of plots we save
TString plotType[] = {"noise","threshold","prob","noiseMap","thresholdMap","probMap"};
int disk = 0;
int blade = 0;
int panel = 0;
unsigned int myfed = 0;
unsigned int mycha = 0;
TString panelType = "";
TString myPanelType = "";
//for every panel (=every channel) create a directory and fill it with canvases
//(one canvas per kind of plots per plaquette)
for (unsigned int it=0; it<panelTypes.size(); it++) {
disk = panelTypes[it].first[0];
blade = panelTypes[it].first[1];
panel = panelTypes[it].first[2];
myfed = panelTypes[it].first[3];
mycha = panelTypes[it].first[4];
myPanelType = panelTypes[it].second;
myfed+=32;
if (myfed<fedmin||myfed>fedmax) continue;
unsigned int fedid=myfed-fedmin;
if (mycha<fedchanmin[fedid]||mycha>fedchanmax[fedid]) continue;
unsigned int channelId=mycha-fedchanmin[fedid];
cout << "FED="<< fedmin+fedid <<" Channel " << channelId+fedchanmin[fedid]<<" panelType="<<myPanelType<<endl;
if(myPanelType=="4L") {
sprintf(title,"FED%d_Channel%d",fedmin+fedid,channelId+fedchanmin[fedid]) ;
TDirectory * dir = f->mkdir(title);
TDirectory * dirNC = dir->mkdir("NoisyCells");
TDirectory * dirEC = dir->mkdir("ErrorCells");
for (int kk=0; kk<6; ++kk) { //loop over the kind of plots, i.e. plotType[]
dir->cd() ;
panelType = "4L1x2";
TCanvas * c4L1x2 = new TCanvas(plotType[kk]+panelType, "4L - 1x2", 500,300) ;
c4L1x2->Divide(2,1) ;
c4L1x2->cd(1) ;
roceff[fedid][channelId][1].draw(kk);
c4L1x2->cd(2) ;
roceff[fedid][channelId][0].draw(kk);
c4L1x2->Write() ;
panelType = "4L2x3";
TCanvas * c4L2x3 = new TCanvas(plotType[kk]+panelType, "4L - 2x3", 750,600) ;
c4L2x3->Divide(3,2) ;
c4L2x3->cd(1) ;
roceff[fedid][channelId][7].draw(kk);
c4L2x3->cd(2) ;
roceff[fedid][channelId][6].draw(kk);
c4L2x3->cd(3) ;
roceff[fedid][channelId][5].draw(kk);
c4L2x3->cd(4) ;
roceff[fedid][channelId][2].draw(kk);
c4L2x3->cd(5) ;
roceff[fedid][channelId][3].draw(kk);
c4L2x3->cd(6) ;
roceff[fedid][channelId][4].draw(kk);
c4L2x3->Write() ;
panelType = "4L2x4";
TCanvas * c4L2x4 = new TCanvas(plotType[kk]+panelType, "4L - 2x4", 1000,600) ;
c4L2x4->Divide(4,2) ;
c4L2x4->cd(1) ;
roceff[fedid][channelId][15].draw(kk);
c4L2x4->cd(2) ;
roceff[fedid][channelId][14].draw(kk);
c4L2x4->cd(3) ;
roceff[fedid][channelId][13].draw(kk);
c4L2x4->cd(4) ;
roceff[fedid][channelId][12].draw(kk);
c4L2x4->cd(5) ;
roceff[fedid][channelId][8].draw(kk);
c4L2x4->cd(6) ;
roceff[fedid][channelId][9].draw(kk);
c4L2x4->cd(7) ;
roceff[fedid][channelId][10].draw(kk);
c4L2x4->cd(8) ;
roceff[fedid][channelId][11].draw(kk);
c4L2x4->Write() ;
panelType = "4L1x5";
TCanvas * c4L1x5 = new TCanvas(plotType[kk]+panelType, "4L - 1x5", 1250,300) ;
c4L1x5->Divide(5,1) ;
c4L1x5->cd(1) ;
roceff[fedid][channelId][20].draw(kk);
c4L1x5->cd(2) ;
roceff[fedid][channelId][19].draw(kk);
c4L1x5->cd(3) ;
roceff[fedid][channelId][18].draw(kk);
c4L1x5->cd(4) ;
roceff[fedid][channelId][17].draw(kk);
c4L1x5->cd(5) ;
roceff[fedid][channelId][16].draw(kk);
c4L1x5->Write() ;
}
dirNC->cd() ;
for(unsigned int roc=0; roc<nOfROCS; roc++) {
if (roc>20) break;
std::vector<pair<unsigned int, unsigned int> > noisyCells = roceff[fedid][channelId][roc].getNoisyCells();
for (unsigned int jj=0; jj<noisyCells.size(); ++jj) {
unsigned int row = noisyCells[jj].first;
unsigned int col = noisyCells[jj].second;
TString name = "ROC";
name+=(roc+rocmin);
name+="_ROW";
name+=(row);
name+="_COL";
name+=(col);
TCanvas * cc = new TCanvas(name,"noisyCell" , 250,300) ;
roceff[fedid][channelId][roc].draw(row,col);
cc->Write();
}
}
dirEC->cd() ;
for(unsigned int roc=0; roc<nOfROCS; roc++) {
if (roc>20) break;
std::vector<pair<unsigned int, unsigned int> > errorCells = roceff[fedid][channelId][roc].getErrorCells();
for (unsigned int jj=0; jj<errorCells.size(); ++jj) {
unsigned int row = errorCells[jj].first;
unsigned int col = errorCells[jj].second;
TString name = "ROC";
name+=(roc+rocmin);
name+="_ROW";
name+=(row);
name+="_COL";
name+=(col);
TCanvas * cc = new TCanvas(name,"errorCell" , 250,300) ;
roceff[fedid][channelId][roc].draw(row,col);
cc->Write();
}
}
}
else if(myPanelType=="3L") {
sprintf(title,"FED%d_Channel%d",fedmin+fedid,channelId+fedchanmin[fedid]) ;
TDirectory * dir = f->mkdir(title);
TDirectory * dirNC = dir->mkdir("NoisyCells");
TDirectory * dirEC = dir->mkdir("ErrorCells");
for (int kk=0; kk<6; ++kk) { //loop over the kind of plots, i.e. plotType[]
dir->cd() ;
panelType = "3L2x3";
TCanvas * c3L2x3 = new TCanvas(plotType[kk]+panelType, "3L - 2x3", 750,600) ;
c3L2x3->Divide(3,2) ;
c3L2x3->cd(1) ;
roceff[fedid][channelId][5].draw(kk);
c3L2x3->cd(2) ;
roceff[fedid][channelId][4].draw(kk);
c3L2x3->cd(3) ;
roceff[fedid][channelId][3].draw(kk);
c3L2x3->cd(4) ;
roceff[fedid][channelId][0].draw(kk);
c3L2x3->cd(5) ;
roceff[fedid][channelId][1].draw(kk);
c3L2x3->cd(6) ;
roceff[fedid][channelId][2].draw(kk);
c3L2x3->Write() ;
panelType = "3L2x4";
TCanvas * c3L2x4 = new TCanvas(plotType[kk]+panelType, "3L - 2x4", 1000,600) ;
c3L2x4->Divide(4,2) ;
c3L2x4->cd(1) ;
roceff[fedid][channelId][13].draw(kk);
c3L2x4->cd(2) ;
roceff[fedid][channelId][12].draw(kk);
c3L2x4->cd(3) ;
roceff[fedid][channelId][11].draw(kk);
c3L2x4->cd(4) ;
roceff[fedid][channelId][10].draw(kk);
c3L2x4->cd(5) ;
roceff[fedid][channelId][6].draw(kk);
c3L2x4->cd(6) ;
roceff[fedid][channelId][7].draw(kk);
c3L2x4->cd(7) ;
roceff[fedid][channelId][8].draw(kk);
c3L2x4->cd(8) ;
roceff[fedid][channelId][9].draw(kk);
c3L2x4->Write() ;
panelType = "3L2x5";
TCanvas * c3L2x5 = new TCanvas(plotType[kk]+panelType, "3L - 2x5", 1250,600) ;
c3L2x5->Divide(5,2) ;
c3L2x5->cd(1) ;
roceff[fedid][channelId][23].draw(kk);
c3L2x5->cd(2) ;
roceff[fedid][channelId][22].draw(kk);
c3L2x5->cd(3) ;
roceff[fedid][channelId][21].draw(kk);
c3L2x5->cd(4) ;
roceff[fedid][channelId][20].draw(kk);
c3L2x5->cd(5) ;
roceff[fedid][channelId][19].draw(kk);
c3L2x5->cd(6) ;
roceff[fedid][channelId][14].draw(kk);
c3L2x5->cd(7) ;
roceff[fedid][channelId][15].draw(kk);
c3L2x5->cd(8) ;
roceff[fedid][channelId][16].draw(kk);
c3L2x5->cd(9) ;
roceff[fedid][channelId][17].draw(kk);
c3L2x5->cd(10) ;
roceff[fedid][channelId][18].draw(kk);
c3L2x5->Write() ;
}
dirNC->cd() ;
for(unsigned int roc=0; roc<nOfROCS; roc++) {
std::vector<pair<unsigned int, unsigned int> > noisyCells = roceff[fedid][channelId][roc].getNoisyCells();
for (unsigned int jj=0; jj<noisyCells.size(); ++jj) {
unsigned int row = noisyCells[jj].first;
unsigned int col = noisyCells[jj].second;
TString name = "ROC";
name+=(roc+rocmin);
name+="_ROW";
name+=(row);
name+="_COL";
name+=(col);
TCanvas * cc = new TCanvas(name,"noisyCell" , 250,300) ;
roceff[fedid][channelId][roc].draw(row,col);
cc->Write();
}
}
dirEC->cd() ;
for(unsigned int roc=0; roc<nOfROCS; roc++) {
std::vector<pair<unsigned int, unsigned int> > errorCells = roceff[fedid][channelId][roc].getErrorCells();
for (unsigned int jj=0; jj<errorCells.size(); ++jj) {
unsigned int row = errorCells[jj].first;
unsigned int col = errorCells[jj].second;
TString name = "ROC";
name+=(roc+rocmin);
name+="_ROW";
name+=(row);
name+="_COL";
name+=(col);
TCanvas * cc = new TCanvas(name,"errorCell" , 250,300) ;
roceff[fedid][channelId][roc].draw(row,col);
cc->Write();
}
}
}
if(myPanelType=="4R") {
sprintf(title,"FED%d_Channel%d",fedmin+fedid,channelId+fedchanmin[fedid]) ;
TDirectory * dir = f->mkdir(title);
TDirectory * dirNC = dir->mkdir("NoisyCells");
TDirectory * dirEC = dir->mkdir("ErrorCells");
for (int kk=0; kk<6; ++kk) { //loop over the kind of plots, i.e. plotType[]
dir->cd() ;
panelType = "4R1x2";
TCanvas * c4R1x2 = new TCanvas(plotType[kk]+panelType, "4R - 1x2", 500,300) ;
c4R1x2->Divide(2,1) ;
c4R1x2->cd(1) ;
roceff[fedid][channelId][20].draw(kk);
c4R1x2->cd(2) ;
roceff[fedid][channelId][19].draw(kk);
c4R1x2->Write() ;
panelType = "4R2x3";
TCanvas * c4R2x3 = new TCanvas(plotType[kk]+panelType, "4R - 2x3", 750,600) ;
c4R2x3->Divide(3,2) ;
c4R2x3->cd(1) ;
roceff[fedid][channelId][15].draw(kk);
c4R2x3->cd(2) ;
roceff[fedid][channelId][14].draw(kk);
c4R2x3->cd(3) ;
roceff[fedid][channelId][13].draw(kk);
c4R2x3->cd(4) ;
roceff[fedid][channelId][16].draw(kk);
c4R2x3->cd(5) ;
roceff[fedid][channelId][17].draw(kk);
c4R2x3->cd(6) ;
roceff[fedid][channelId][18].draw(kk);
c4R2x3->Write() ;
panelType = "4R2x4";
TCanvas * c4R2x4 = new TCanvas(plotType[kk]+panelType, "4R - 2x4", 1000,600) ;
c4R2x4->Divide(4,2) ;
c4R2x4->cd(1) ;
roceff[fedid][channelId][8].draw(kk);
c4R2x4->cd(2) ;
roceff[fedid][channelId][7].draw(kk);
c4R2x4->cd(3) ;
roceff[fedid][channelId][6].draw(kk);
c4R2x4->cd(4) ;
roceff[fedid][channelId][5].draw(kk);
c4R2x4->cd(5) ;
roceff[fedid][channelId][9].draw(kk);
c4R2x4->cd(6) ;
roceff[fedid][channelId][10].draw(kk);
c4R2x4->cd(7) ;
roceff[fedid][channelId][11].draw(kk);
c4R2x4->cd(8) ;
roceff[fedid][channelId][12].draw(kk);
c4R2x4->Write() ;
panelType = "4R1x5";
TCanvas * c4R1x5 = new TCanvas(plotType[kk]+panelType, "4R - 1x5", 1250,300) ;
c4R1x5->Divide(5,1) ;
c4R1x5->cd(1) ;
roceff[fedid][channelId][4].draw(kk);
c4R1x5->cd(2) ;
roceff[fedid][channelId][3].draw(kk);
c4R1x5->cd(3) ;
roceff[fedid][channelId][2].draw(kk);
c4R1x5->cd(4) ;
roceff[fedid][channelId][1].draw(kk);
c4R1x5->cd(5) ;
roceff[fedid][channelId][0].draw(kk);
c4R1x5->Write() ;
}
dirNC->cd() ;
for(unsigned int roc=0; roc<nOfROCS; roc++) {
if (roc>20) break;
std::vector<pair<unsigned int, unsigned int> > noisyCells = roceff[fedid][channelId][roc].getNoisyCells();
for (unsigned int jj=0; jj<noisyCells.size(); ++jj) {
unsigned int row = noisyCells[jj].first;
unsigned int col = noisyCells[jj].second;
TString name = "ROC";
name+=(roc+rocmin);
name+="_ROW";
name+=(row);
name+="_COL";
name+=(col);
TCanvas * cc = new TCanvas(name,"noisyCell" , 250,300) ;
roceff[fedid][channelId][roc].draw(row,col);
cc->Write();
}
}
dirEC->cd() ;
for(unsigned int roc=0; roc<nOfROCS; roc++) {
if (roc>20) break;
std::vector<pair<unsigned int, unsigned int> > errorCells = roceff[fedid][channelId][roc].getErrorCells();
for (unsigned int jj=0; jj<errorCells.size(); ++jj) {
unsigned int row = errorCells[jj].first;
unsigned int col = errorCells[jj].second;
TString name = "ROC";
name+=(roc+rocmin);
name+="_ROW";
name+=(row);
name+="_COL";
name+=(col);
TCanvas * cc = new TCanvas(name,"errorCell" , 250,300) ;
roceff[fedid][channelId][roc].draw(row,col);
cc->Write();
}
}
}
else if(myPanelType=="3R") {
sprintf(title,"FED%d_Channel%d",fedmin+fedid,channelId+fedchanmin[fedid]) ;
TDirectory * dir = f->mkdir(title);
TDirectory * dirNC = dir->mkdir("NoisyCells");
TDirectory * dirEC = dir->mkdir("ErrorCells");
for (int kk=0; kk<6; ++kk) { //loop over the kind of plots, i.e. plotType[]
dir->cd() ;
panelType = "3R2x3";
TCanvas * c3R2x3 = new TCanvas(plotType[kk]+panelType, "3R - 2x3"+plotType[kk], 750,600) ;
c3R2x3->Divide(3,2) ;
c3R2x3->cd(1) ;
roceff[fedid][channelId][20].draw(kk);
c3R2x3->cd(2) ;
roceff[fedid][channelId][19].draw(kk);
c3R2x3->cd(3) ;
roceff[fedid][channelId][18].draw(kk);
c3R2x3->cd(4) ;
roceff[fedid][channelId][21].draw(kk);
c3R2x3->cd(5) ;
roceff[fedid][channelId][22].draw(kk);
c3R2x3->cd(6) ;
roceff[fedid][channelId][23].draw(kk);
c3R2x3->Write() ;
panelType = "3R2x4";
TCanvas * c3R2x4 = new TCanvas(plotType[kk]+panelType, "3R - 2x4"+plotType[kk], 1000,600) ;
c3R2x4->Divide(4,2) ;
c3R2x4->cd(1) ;
roceff[fedid][channelId][13].draw(kk);
c3R2x4->cd(2) ;
roceff[fedid][channelId][12].draw(kk);
c3R2x4->cd(3) ;
roceff[fedid][channelId][11].draw(kk);
c3R2x4->cd(4) ;
roceff[fedid][channelId][10].draw(kk);
c3R2x4->cd(5) ;
roceff[fedid][channelId][14].draw(kk);
c3R2x4->cd(6) ;
roceff[fedid][channelId][15].draw(kk);
c3R2x4->cd(7) ;
roceff[fedid][channelId][16].draw(kk);
c3R2x4->cd(8) ;
roceff[fedid][channelId][17].draw(kk);
c3R2x4->Write() ;
panelType = "3R2x5";
TCanvas * c3R2x5 = new TCanvas(plotType[kk]+panelType, "3R - 2x5"+plotType[kk], 1250,600) ;
c3R2x5->Divide(5,2) ;
c3R2x5->cd(1) ;
roceff[fedid][channelId][4].draw(kk);
c3R2x5->cd(2) ;
roceff[fedid][channelId][3].draw(kk);
c3R2x5->cd(3) ;
roceff[fedid][channelId][2].draw(kk);
c3R2x5->cd(4) ;
roceff[fedid][channelId][1].draw(kk);
c3R2x5->cd(5) ;
roceff[fedid][channelId][0].draw(kk);
c3R2x5->cd(6) ;
roceff[fedid][channelId][5].draw(kk);
c3R2x5->cd(7) ;
roceff[fedid][channelId][6].draw(kk);
c3R2x5->cd(8) ;
roceff[fedid][channelId][7].draw(kk);
c3R2x5->cd(9) ;
roceff[fedid][channelId][8].draw(kk);
c3R2x5->cd(10) ;
roceff[fedid][channelId][9].draw(kk);
c3R2x5->Write() ;
}
dirNC->cd() ;
for(unsigned int roc=0; roc<nOfROCS; roc++) {
std::vector<pair<unsigned int, unsigned int> > noisyCells = roceff[fedid][channelId][roc].getNoisyCells();
for (unsigned int jj=0; jj<noisyCells.size(); ++jj) {
unsigned int row = noisyCells[jj].first;
unsigned int col = noisyCells[jj].second;
TString name = "ROC";
name+=(roc+rocmin);
name+="_ROW";
name+=(row);
name+="_COL";
name+=(col);
TCanvas * cc = new TCanvas(name,"noisyCell" , 250,300) ;
roceff[fedid][channelId][roc].draw(row,col);
cc->Write();
}
}
dirEC->cd() ;
for(unsigned int roc=0; roc<nOfROCS; roc++) {
std::vector<pair<unsigned int, unsigned int> > errorCells = roceff[fedid][channelId][roc].getErrorCells();
for (unsigned int jj=0; jj<errorCells.size(); ++jj) {
unsigned int row = errorCells[jj].first;
unsigned int col = errorCells[jj].second;
TString name = "ROC";
name+=(roc+rocmin);
name+="_ROW";
name+=(row);
name+="_COL";
name+=(col);
TCanvas * cc = new TCanvas(name,"errorCell" , 250,300) ;
roceff[fedid][channelId][roc].draw(row,col);
cc->Write();
}
}
}
//summary plots
for (unsigned int roc=0; roc<nOfROCS; roc++) {
if ((myPanelType=="4R"||myPanelType=="4L")&&roc>20) break;
if (roceff[fedid][channelId][roc].isValid()) {
//cout << "filling summary plot: fedid=" << fedid << " channelId=" << channelId << " roc=" << roc << endl;
double meanSig = roceff[fedid][channelId][roc].getMeanNoise();
double meanThr = roceff[fedid][channelId][roc].getMeanThreshold();
hMeanNoise->Fill(meanSig);
hMeanThreshold->Fill(meanThr);
if (meanSig>3) out << "FED=" << fedid+fedmin << " channel=" << channelId+fedchanmin[fedid]
<< " ROC="<< roc+rocmin <<" Mean Noise=" << meanSig << endl;
if (meanThr>130) out << "FED=" << fedid+fedmin << " channel=" << channelId+fedchanmin[fedid]
<< " ROC="<< roc+rocmin <<" Mean Threshold=" << meanThr << endl;
}
}
}
dirSP->cd();
hMeanNoise->Write();
hMeanThreshold->Write();
f->Close() ;
/* TCanvas* c=0; */
/* if(false) {// summary plots */
/* cout << "Making plots" << endl; */
/* for(unsigned int channel=chanmin; channel<=chanmax; channel++) { */
/* for(unsigned int roc=rocmin; roc<=rocmax; roc++) { */
/* c= new TCanvas("ROC_Scurve_Results","ROC Scurve Results", 700, 800); */
/* c->Divide(2,3); */
/* c->cd(1); */
/* roceff[channel][roc].drawThresholds(); */
/* c->cd(2); */
/* roceff[channel][roc].drawThreshold(); */
/* c->cd(3); */
/* roceff[channel][roc].drawNoises(); */
/* c->cd(4); */
/* roceff[channel][roc].drawNoise(); */
/* c->cd(5); */
/* roceff[channel][roc].drawFitProbs(); */
/* c->cd(6); */
/* roceff[channel][roc].drawFitProb(); */
/* TString name="SCurveResults"; */
/* name=name+"_Channel"; */
/* name+=(channel+1); */
/* name+="_ROC"; */
/* name+=(roc+1); */
/* name+=".pdf"; */
/* c->Print(name); */
/* int plotnumber=0; */
/* bool plotted=false; */
/* for(int row = 35;row<45;row++){ */
/* for(int col = 21; col<31;col++) { */
/* if (plotnumber%12==0){ */
/* TString name="SCurve"; */
/* name=name+TString(plotnumber/12+1); */
/* c=new TCanvas(name,name, 700,800); */
/* c->Divide(3 ,4); */
/* } */
/* if (roceff[channel][roc].filled(row,col)){ */
/* c->cd(plotnumber%12+1); */
/* roceff[channel][roc].draw(row,col); */
/* plotted=true; */
/* plotnumber++; */
/* } */
/* if (plotted&&(plotnumber%12==0)){ */
/* TString name="SCurves"; */
/* name=name+"_Channel"; */
/* name+=(channel+1); */
/* name+="_ROC"; */
/* name+=(roc+1); */
/* name+=".ps"; */
/* if(plotnumber==12) name+="("; */
/* c->Print(name); */
/* plotted=false; */
/* } //new page */
/* } // loop col */
/* } // loop row */
/* if (plotted) { */
/* TString name="SCurves"; */
/* name=name+"_Channel"; */
/* name+=(channel+1); */
/* name+="_ROC"; */
/* name+=(roc+1); */
/* name+=".ps)"; */
/* c->Print(name); */
/* } */
/* } // roc */
/* } // channel */
/* } // make plots */
} // void pixel_scurve()
int ScanChain( TChain* chain, bool fast = true, int nEvents = -1, string skimFilePrefix = "test") {
// Benchmark
TBenchmark *bmark = new TBenchmark();
bmark->Start("benchmark");
// Example Histograms
TDirectory *rootdir = gDirectory->GetDirectory("Rint:");
// samplehisto->SetDirectory(rootdir);
TH1F *h_muonCount = new TH1F("h_muonCount", "Number of Muons in this event", 90, 0, 5);
// MuonTagAndProbe: define the trigger to check here
vector<string> triggerNames;
triggerNames.push_back("HLT_IsoMu24");
triggerNames.push_back("HLT_IsoTkMu24");
// triggerNames.push_back("HLT_IsoMu20");
// triggerNames.push_back("HLT_IsoTkMu20");
// triggerNames.push_back("HLT_Ele27_eta2p1_WPLoose_Gsf");
// triggerNames.push_back("HLT_Ele22_eta2p1_WPLoose_Gsf");
// Separate vector to store the pt cut to be used for eta and phi
vector<float> triggerPtCuts(triggerNames.size(), 50);
// triggerPtCuts[2] = 25;
// triggerPtCuts[3] = 25;
vector<map<histType,TH1F*>> muonHists = creatMuonHists(triggerNames);
vector<map<histType,TH1F*>> muonHists1 = creatMuonHists(triggerNames, "_1");
vector<map<histType,TH1F*>> muonHists2 = creatMuonHists(triggerNames, "_2");
vector<map<histType,TH1F*>> muonHists3 = creatMuonHists(triggerNames, "_3");
// Loop over events to Analyze
unsigned int nEventsTotal = 0;
unsigned int nEventsChain = chain->GetEntries();
if (nEvents >= 0) nEventsChain = nEvents;
TObjArray *listOfFiles = chain->GetListOfFiles();
TIter fileIter(listOfFiles);
TFile *currentFile = 0;
// File Loop
while ( (currentFile = (TFile*)fileIter.Next()) ) {
// Get File Content
TFile file( currentFile->GetTitle() );
TTree *tree = (TTree*)file.Get("t");
if (fast) TTreeCache::SetLearnEntries(10);
if (fast) tree->SetCacheSize(128*1024*1024);
t.Init(tree);
int evt_num = -1;
int nMuonCount = 0;
int isTriggerMuon = 0;
LorentzVector p4mu;
LorentzVector tag_p4mu;
vector<TBranch*> trigBranches = setupTriggerBranches(triggerNames, tree);
vector<TBranch*> tagTrigBranches = setupTagTriggerBranches(triggerNames, tree);
// Loop over Events in current file
if (nEventsTotal >= nEventsChain) continue;
unsigned int nEventsTree = tree->GetEntriesFast();
for (unsigned int event = 0; event < nEventsTree; ++event) {
// Get Event Content
if (nEventsTotal >= nEventsChain) continue;
if (fast) tree->LoadTree(event);
t.GetEntry(event);
++nEventsTotal;
// Progress
LepTree::progress(nEventsTotal, nEventsChain);
// Analysis Code
if (evt_isRealData() && evt_run() < 273423) continue; // Get runs after fixing the L1 interface problem
int nevt = evt_event();
if (nevt != evt_num) {
h_muonCount->Fill(nMuonCount);
nMuonCount = 0;
isTriggerMuon = 0;
}
// --- New Tag & Probe ---
if (abs(id()) != 13) continue;
if (p4().pt() < 10) continue;
if (fabs(p4().eta()) > 2.4 ) continue;
if (charge()*tag_charge() > 0) continue;
if (tag_p4().pt() < 25) continue;
if (tag_RelIso03EA() > 0.1) continue;
if (dilep_mass() < 81.2 || dilep_mass() > 101.2) continue;
if (!pid_PFMuon()) continue;
++nMuonCount;
// if (nMuonCount > 2) continue;
for (unsigned int i=0; i<triggerNames.size(); i++) {
if (getTriggerValue(tagTrigBranches[i], event) <= 0) continue;
fillTagMuonHists(muonHists[i], triggerPtCuts[i]);
if (passes_IsoCut() && passes_leptonID())
fillProbeMuonHists(muonHists[i], trigBranches[i], event, triggerPtCuts[i]);
fillTagMuonHists(muonHists1[i], triggerPtCuts[i]);
fillTagMuonHists(muonHists2[i], triggerPtCuts[i]);
fillTagMuonHists(muonHists3[i], triggerPtCuts[i]);
fillDenMuonHists(muonHists1[i], triggerPtCuts[i]);
if (passes_IsoCut() && passes_leptonID())
fillNumMuonHists(muonHists1[i], triggerPtCuts[i]);
if (passes_IsoCut()) {
fillDenMuonHists(muonHists2[i], triggerPtCuts[i]);
if (passes_leptonID())
fillNumMuonHists(muonHists2[i], triggerPtCuts[i]);
}
if (passes_leptonID()) {
fillDenMuonHists(muonHists3[i], triggerPtCuts[i]);
if (passes_IsoCut())
fillNumMuonHists(muonHists3[i], triggerPtCuts[i]);
}
}
// End of Analysis Code
}
// Clean Up
delete tree;
file.Close();
}
if ( nEventsChain != nEventsTotal ) {
cout << Form( "ERROR: number of events from files (%d) is not equal to total number of events (%d)", nEventsChain, nEventsTotal ) << endl;
}
// return
bmark->Stop("benchmark");
TFile* outfile = new TFile("hists.root", "RECREATE");
for (unsigned int i=0; i<triggerNames.size(); i++) {
TDirectory * dir = (TDirectory*) outfile->mkdir(triggerNames[i].c_str());
dir->cd();
TDirectory * dir2 = (TDirectory*) dir->mkdir("trigeff");
dir2->cd();
writeEfficiencyPlots(muonHists[i], triggerNames[i], outfile);
dir2 = (TDirectory*) dir->mkdir("ID+ISO");
dir2->cd();
writeEfficiencyPlots(muonHists1[i], triggerNames[i], outfile);
dir2 = (TDirectory*) dir->mkdir("ID");
dir2->cd();
writeEfficiencyPlots(muonHists2[i], triggerNames[i], outfile);
dir2 = (TDirectory*) dir->mkdir("ISO");
dir2->cd();
writeEfficiencyPlots(muonHists3[i], triggerNames[i], outfile);
}
h_muonCount->Write();
outfile->Close();
cout << endl;
cout << nEventsTotal << " Events Processed" << endl;
cout << "------------------------------" << endl;
cout << "CPU Time: " << Form( "%.01f", bmark->GetCpuTime("benchmark") ) << endl;
cout << "Real Time: " << Form( "%.01f", bmark->GetRealTime("benchmark") ) << endl;
cout << endl;
delete bmark;
return 0;
}
int main(int argc, char** argv)
{
TDRStyle();
gStyle->SetPadTopMargin(0.11);
gStyle->SetPadLeftMargin(0.07);
gStyle->SetPadRightMargin(0.23);
gStyle->cd();
std::cout << " " << std::endl;
std::cout << " " << std::endl;
std::cout << " ___| _) \\ | ___| / __ \\ \\ __ __| \\ " << std::endl;
std::cout << " | _ \\ __ `__ \\ __ \\ _` | __| | __| _ \\ __ \\ |\\/ | | / | | _ \\ | _ \\ " << std::endl;
std::cout << " | ( | | | | | | ( | | | \\__ \\ ( | | | | | | / | | ___ \\ | ___ \\ " << std::endl;
std::cout << " \\____| \\___/ _| _| _| .__/ \\__,_| _| _| ____/ \\___/ _| _| _| _| \\____| _/ ____/ _/ _\\ _| _/ _\\ " << std::endl;
std::cout << " _| " << std::endl;
std::cout << " " << std::endl;
std::cout << " " << std::endl;
std::cout << " ___ \\ __ \\ " << std::endl;
std::cout << " ) | | | " << std::endl;
std::cout << " __/ | | " << std::endl;
std::cout << " _____| ____/ " << std::endl;
std::cout << " " << std::endl;
std::cout << " " << std::endl;
char normal[] = { 0x1b, '[', '0', ';', '3', '9', 'm', 0 };
char black[] = { 0x1b, '[', '0', ';', '3', '0', 'm', 0 };
char red[] = { 0x1b, '[', '0', ';', '3', '1', 'm', 0 };
char green[] = { 0x1b, '[', '0', ';', '3', '2', 'm', 0 };
char yellow[] = { 0x1b, '[', '0', ';', '3', '3', 'm', 0 };
char blue[] = { 0x1b, '[', '0', ';', '3', '4', 'm', 0 };
char purple[] = { 0x1b, '[', '0', ';', '3', '5', 'm', 0 };
char cyan[] = { 0x1b, '[', '0', ';', '3', '6', 'm', 0 };
char Lgray[] = { 0x1b, '[', '0', ';', '3', '7', 'm', 0 };
char Dgray[] = { 0x1b, '[', '0', ';', '3', '8', 'm', 0 };
char Bred[] = { 0x1b, '[', '1', ';', '3', '1', 'm', 0 };
//for bold colors, just change the 0 after the [ to a 1
EColor vColor[1000] = {
(EColor) (kRed+1),
(EColor) (kRed+3),
(EColor) (kGray+1),
(EColor) (kAzure-2),
(EColor) (kAzure-9),
(EColor) (kYellow),
(EColor) (kGreen+2),
//
kGreen,
//kMagenta,(EColor) (kMagenta+1),(EColor) (kMagenta+2),
kTeal,//(EColor) (kTeal+1),
kRed,
kGray,
kOrange,(EColor) (kOrange+1),
kBlue,//(EColor)(kBlue+1),(EColor) (kBlue+2),
(EColor) (kPink+2),//(EColor) (kPink+1),(EColor) (kPink+2),
kViolet,
kYellow,
kGray,(EColor) (kGray+1),(EColor) (kViolet),(EColor) (kYellow),(EColor) (kGray)
};
//Check if all nedeed arguments to parse are there
if(argc != 2)
{
std::cerr << ">>>>> analysis.cpp::usage: " << argv[0] << " configFileName" << std::endl ;
return 1;
}
// Parse the config file
parseConfigFile (argv[1]) ;
std::string treeName = gConfigParser -> readStringOption("Input::treeName");
std::string treeNameSelections = gConfigParser -> readStringOption("Input::treeNameSelections");
std::string fileSamples = gConfigParser -> readStringOption("Input::fileSamples");
std::string inputDirectory = gConfigParser -> readStringOption("Input::inputDirectory");
std::string inputBeginningFile = "out_NtupleProducer_";
try {
inputBeginningFile = gConfigParser -> readStringOption("Input::inputBeginningFile");
}
catch (char const* exceptionString){
std::cerr << " exception = " << exceptionString << std::endl;
}
std::cout << ">>>>> Input::inputBeginningFile " << inputBeginningFile << std::endl;
double LUMI = gConfigParser -> readDoubleOption("Input::Lumi");
double LumiSyst = gConfigParser -> readDoubleOption("Input::LumiSyst");
double Discovery = gConfigParser -> readDoubleOption("Input::Discovery");
int Normalize = gConfigParser -> readIntOption("Input::Normalize");
std::vector<std::string> SignalName;
if (Discovery == 1) SignalName = gConfigParser -> readStringListOption("Input::SignalName");
///==== PU reweight (begin) ====
bool doWeightFromFile = false;
try {
doWeightFromFile = gConfigParser -> readStringOption("PU::doWeightFromFile");
}
catch (char const* exceptionString){
std::cerr << " exception = " << exceptionString << std::endl;
}
std::cout << ">>>>> PU::doWeightFromFile " << doWeightFromFile << std::endl;
std::vector<double> PUMC;
std::vector<double> PUDATA;
PUclass PU;
double sumPUMC = 0;
double sumPUDATA = 0;
TH1F* hPUMC;
TH1F* hPUDATA;
TH1F* hPUWeight;
std::string nameWeight = "weight";
if (doWeightFromFile) {
try {
nameWeight = gConfigParser -> readStringOption("PU::nameWeight");
}
catch (char const* exceptionString){
std::cerr << " exception = " << exceptionString << std::endl;
}
std::cout << ">>>>> PU::nameWeight " << nameWeight << std::endl;
}
if (!doWeightFromFile) {
PUMC = gConfigParser -> readDoubleListOption("PU::PUMC");
PUDATA = gConfigParser -> readDoubleListOption("PU::PUDATA");
std::cout << " PUMC.size() = " << PUMC.size() << std::endl;
std::cout << " PUDATA.size() = " << PUDATA.size() << std::endl;
if (PUMC.size() != PUDATA.size()) {
std::cerr << " ERROR " << std::endl;
return 1;
}
for (int itVPU = 0; itVPU < PUMC.size(); itVPU++ ){
sumPUMC += PUMC.at(itVPU);
}
for (int itVPU = 0; itVPU < PUDATA.size(); itVPU++ ){
sumPUDATA += PUDATA.at(itVPU);
}
for (int itVPU = 0; itVPU < PUMC.size(); itVPU++ ){
PU.PUWeight.push_back(PUDATA.at(itVPU) / PUMC.at(itVPU) * sumPUMC / sumPUDATA);
}
PU.Write("autoWeight.cxx");
gROOT->ProcessLine(".L autoWeight.cxx");
///==== save PU distribution in TH1F ====
hPUMC = new TH1F("hPUMC","hPUMC",PUMC.size(),0,PUMC.size());
hPUDATA = new TH1F("hPUDATA","hPUDATA",PUDATA.size(),0,PUDATA.size());
hPUWeight = new TH1F("hPUWeight","hPUWeight",PUDATA.size(),0,PUDATA.size());
for (int itVPU = 0; itVPU < PUMC.size(); itVPU++ ){
hPUMC -> SetBinContent(itVPU+1,PUMC.at(itVPU) / sumPUMC);
hPUDATA -> SetBinContent(itVPU+1,PUDATA.at(itVPU) / sumPUDATA);
hPUWeight -> SetBinContent(itVPU+1,PUDATA.at(itVPU) / PUMC.at(itVPU) * sumPUMC / sumPUDATA);
}
}
///==== PU reweight (end) ====
///==== pT Higgs reweight (begin) ====
std::string nameptHWeight;
try {
nameptHWeight = gConfigParser -> readStringOption("Input::nameptHWeight");
}
catch (char const* exceptionString){
std::cerr << " exception = " << exceptionString << std::endl;
}
std::cout << ">>>>> input::nameptHWeight " << nameptHWeight << std::endl;
if (nameptHWeight != ""){
TString toLoad;
// toLoad = Form("cp %s ./",nameptHWeight.c_str());
// gROOT->ProcessLine(toLoad.Data());
toLoad = Form(".L %s",nameptHWeight.c_str());
gROOT->ProcessLine(toLoad.Data());
}
std::string nameptHWeightSample;
try {
nameptHWeight = gConfigParser -> readStringOption("Input::nameptHWeightSample");
}
catch (char const* exceptionString){
std::cerr << " exception = " << exceptionString << std::endl;
}
std::cout << ">>>>> input::nameptHWeightSample " << nameptHWeightSample << std::endl;
///==== pT Higgs reweight (end) ====
TTree *treeEffVect[100];
TTree *treeJetLepVect[100];
// [iCut][iVar]
TString* infoString[20][30];
TLatex *infoLatex[20][30];
TCanvas* ccCanvas[20][30];
TCanvas* ccCanvasPull[20][30];
TCanvas* ccCanvasPullTrace[20][30];
TH2F* histoSumMC[20][30];
// [iName][iCut][iVar]
TH2F* histo[100][30][30];
TH2F* histo_temp[100][20][30];
// [iName][iCut]
double numEvents[100][30];
char *nameSample[1000];
char *nameHumanReadable[1000];
char* xsectionName[1000];
double Normalization[1000];
double xsection[1000];
char nameFileIn[1000];
sprintf(nameFileIn,"%s",fileSamples.c_str());
int numberOfSamples = ReadFile(nameFileIn, nameSample, nameHumanReadable, xsectionName);
///==== list of variables to plot ====
std::vector<std::pair<double, double> > vMin;
std::vector<std::pair<double, double> > vMax;
std::vector<std::pair<int, int> > vNBin;
std::vector<std::pair<std::string, std::string> > vVarName;
std::vector<std::pair<std::string, std::string> > vVarNameHR;
std::string VarFile = gConfigParser -> readStringOption("Plot::VarFile");
int numVar = ReadFileVar2D(VarFile,vMin,vMax,vNBin,vVarName,vVarNameHR);
// double XSection = gConfigParser -> readDoubleOption("Plot::XSection");
///==== list of selections to perform (NOT sequential additive selections) ====
std::string CutFile = gConfigParser -> readStringOption("Selections::CutFile");
std::string CutHRFile = "";
try {
CutHRFile = gConfigParser -> readStringOption("Selections::CutHRFile");
}
catch (char const* exceptionString){
std::cerr << " exception = " << exceptionString << std::endl;
}
std::vector<std::string> vCut;
std::vector<std::string> vCutHR;
std::cout << " nCuts = " << ReadFileCut(CutFile, vCut) << std::endl;
if (CutHRFile != "") {
std::cout << " nCutsHR = " << ReadFileCutHR(CutHRFile, vCutHR) << std::endl;
}
if (vCutHR.size() < vCut.size()) {
int size1 = vCut.size();
int size2 = vCutHR.size();
for (int i=0; i<(size1-size2+2); i++) {
vCutHR.push_back("test");
}
}
///==== output file ====
std::string OutFileName = gConfigParser -> readStringOption("Output::outFileName");
std::cout << ">>>>> Output::outFileName " << OutFileName << std::endl;
TFile outFile(OutFileName.c_str(),"RECREATE");
outFile.cd();
///==== Latinos flag ====
bool Latinos = false;
try {
Latinos = gConfigParser -> readBoolOption("Input::Latinos");
}
catch (char const* exceptionString){
std::cerr << " exception = " << exceptionString << std::endl;
}
std::cout << ">>>>> input::Latinos " << Latinos << std::endl;
///==== debug flag ====
bool debug = false;
try {
debug = gConfigParser -> readBoolOption("Input::debug");
}
catch (char const* exceptionString){
std::cerr << " exception = " << exceptionString << std::endl;
}
std::cout << ">>>>> input::debug " << debug << std::endl;
///==== program ====
double start, end;
start = clock();
for (int iSample=0; iSample<numberOfSamples; iSample++){
xsection[iSample] = atof(xsectionName[iSample]);
}
for (int iSample=0; iSample<numberOfSamples; iSample++){
char nameFile[20000];
sprintf(nameFile,"%s/%s%s.root",inputDirectory.c_str(),inputBeginningFile.c_str(),nameSample[iSample]);
TFile* f = new TFile(nameFile, "READ");
treeEffVect[iSample] = (TTree*) f->Get(treeNameSelections.c_str());
if (treeEffVect[iSample] != 0) {
char nameTreeEff[100];
sprintf(nameTreeEff,"treeEff_%d",iSample);
treeEffVect[iSample]->SetName(nameTreeEff);
}
treeJetLepVect[iSample] = (TTree*) f->Get(treeName.c_str());
char nameTreeJetLep[100];
sprintf(nameTreeJetLep,"treeJetLep_%d",iSample);
treeJetLepVect[iSample]->SetName(nameTreeJetLep);
}
///===== create map for joint sample ====
std::vector<int> join_samples;
std::vector<std::string> name_samples;
for (int iSample=0; iSample<numberOfSamples; iSample++){
name_samples.push_back(nameHumanReadable[iSample]);
join_samples.push_back(-1);
}
std::vector<std::string> reduced_name_samples;
std::vector<int> reduced_name_samples_flag;
for (int iSample = (numberOfSamples-1); iSample>= 0; iSample--){
bool flag_name = false;
for (unsigned int iName=0; iName<reduced_name_samples.size(); iName++){
if (reduced_name_samples.at(iName) == name_samples.at(iSample)) flag_name = true;
}
if (flag_name == false) {
reduced_name_samples.push_back(name_samples.at(iSample));
reduced_name_samples_flag.push_back(-1);
}
}
std::cout << " numberOfSamples = " << numberOfSamples << std::endl;
for (int iSample = (numberOfSamples-1); iSample>= 0; iSample--){
double XSection;
int numEntriesBefore;
double preselection_efficiency;
if (treeEffVect[iSample] != 0) {
treeEffVect[iSample]->SetBranchAddress("XSection",&XSection);
treeEffVect[iSample]->SetBranchAddress("numEntriesBefore",&numEntriesBefore);
treeEffVect[iSample]->SetBranchAddress("preselection_efficiency",&preselection_efficiency);
treeEffVect[iSample]->GetEntry(0);
}
std::cout << " Xsection = " << XSection << " ~~~> " << xsection[iSample] << std::endl;
XSection = xsection[iSample];
if (numEntriesBefore != 0) {
Normalization[iSample] = LUMI * XSection * preselection_efficiency / numEntriesBefore;
}
else {
Normalization[iSample] = 0;
}
if (Latinos) Normalization[iSample] = XSection * LUMI / 1000.;
}
TLegend* leg = new TLegend(0.8,0.25,0.98,0.78);
bool LegendBuilt = false;
TString lumiName = Form("#splitline{L = %.1f pb^{-1}}{#splitline{#sqrt{s} = 7}{CMS preliminary}}", LUMI);
// TString lumiName = Form("#sqrt{s}=7 TeV L=%.1f pb^{-1}", LUMI);
TLatex *latex = new TLatex(0.80, 0.90, lumiName);
latex->SetTextAlign(12);
latex->SetNDC();
latex->SetTextFont(42);
latex->SetTextSize(0.03);
///==== get number in sample list that correspond to DATA ====
int numDATA = -1;
for (unsigned int iName=0; iName<reduced_name_samples.size(); iName++){
if (reduced_name_samples.at(iName) == "DATA") {
numDATA = iName;
}
}
if (debug) std::cout << " Cut size = " << vCut.size() << " ~~ " << std::endl;
std::cout.precision (2) ;
///==== cicle on selections ====
for (unsigned int iCut = 0; iCut<vCut.size(); iCut++){
TString Cut = Form ("%s",vCut.at(iCut).c_str());
if (debug) std::cout << " Cut[" << iCut << ":" << vCut.size() << "] = " << Cut.Data() << " ~~ " << std::endl;
///==== cicle on variables to plot ====
for (unsigned int iVar = 0; iVar<vVarName.size(); iVar++){
if (debug) std::cout << " Var[" << iVar << ":" << vVarName.size() << "] = " << vVarName.at(iVar).first << " && " << vVarName.at(iVar).second << " ~~ " << std::endl;
///==== initialize ====
for (unsigned int iName=0; iName<reduced_name_samples.size(); iName++){
reduced_name_samples_flag.at(iName) = -1;
}
///==== cicle on samples ====
for (int iSample = (numberOfSamples-1); iSample>= 0; iSample--){
if (debug) std::cout << " Sample[" << iSample << ":" << numberOfSamples << "] = " << nameSample[iSample] << " ~~ " << std::endl;
TString name_histo_temp = Form("%s_%d_%d_temp",nameSample[iSample], iCut, iVar);
histo_temp[iSample][iCut][iVar] = new TH2F(name_histo_temp,name_histo_temp,vNBin.at(iVar).first,vMin.at(iVar).first, vMax.at(iVar).first,vNBin.at(iVar).second,vMin.at(iVar).second, vMax.at(iVar).second);
char toDraw[1000];
sprintf(toDraw,"%s:%s >> %s",vVarName.at(iVar).second.c_str(),vVarName.at(iVar).first.c_str(),name_histo_temp.Data());
histo_temp[iSample][iCut][iVar] -> Sumw2(); //---- così mette l'errore giusto!
TString CutExtended;
bool isData = false;
for (unsigned int iName=0; iName<reduced_name_samples.size(); iName++){
if (name_samples.at(iSample) == reduced_name_samples.at(iName)){
if (iName == numDATA) {
isData = true;
}
}
}
if (!isData) {
if (nameptHWeight != "" && name_samples.at(iSample) == nameptHWeightSample){
if (!doWeightFromFile) {
CutExtended = Form ("(%s) * autoWeight(numPUMC) * ptHWeight(ptH)",Cut.Data());
}
else {
CutExtended = Form ("(%s) * ptHWeight(ptH) * (%s)",Cut.Data(),nameWeight.c_str());
}
}
else {
if (!doWeightFromFile) {
CutExtended = Form ("(%s) * autoWeight(numPUMC)",Cut.Data());
}
else {
CutExtended = Form ("(%s) * (%s)",Cut.Data(),nameWeight.c_str());
}
}
// CutExtended = Form ("(%s) * autoWeight(numPUMC) * ptHWeight(ptH)",Cut.Data());
}
else {
CutExtended = Form ("(%s)",Cut.Data());
}
treeJetLepVect[iSample]->Draw(toDraw,CutExtended,"");
if (Normalization[iSample]>0) {
// histo_temp[iSample][iCut][iVar] -> Sumw2();
histo_temp[iSample][iCut][iVar] -> Scale(Normalization[iSample]);
}
// std::cout << "Processing: " << blue << (((double) numberOfSamples - iSample)/numberOfSamples) << "% \r" << normal << std::flush;
} ///==== end cicle on samples ====
// std::cout << "###";
std::cout << "Processing: " << blue << (((double) iCut)/vCut.size())*100. << "% " << normal << " -- " << blue << (((double) iVar)/vVarName.size())*100. << "% \r" << normal << std::flush;
} ///==== end cicle on variables to plot ====
// std::cout << "***";
} ///==== end cicle on selections ====
std::cout << std::endl;
///---- create "big" histos ----
for (unsigned int iCut = 0; iCut<vCut.size(); iCut++){
for (unsigned int iVar = 0; iVar<vVarName.size(); iVar++){
///---- initialize (begin) ----
for (unsigned int iName=0; iName<reduced_name_samples.size(); iName++){
reduced_name_samples_flag.at(iName) = -1;
}
///---- initialize (end) ----
for (int iSample = (numberOfSamples-1); iSample>= 0; iSample--){
for (unsigned int iName=0; iName<reduced_name_samples.size(); iName++){
if (name_samples.at(iSample) == reduced_name_samples.at(iName) && iName == numDATA){
if (reduced_name_samples_flag.at(iName) == -1){
TString name_histoTot_temp = Form("%s_%d_%d_Tot_temp",reduced_name_samples.at(iName).c_str(),iCut, iVar);
TString name_HR_histoTot_temp = Form("%s vs %s @ %s",vVarNameHR.at(iVar).second.c_str(),vVarNameHR.at(iVar).first.c_str(), vCutHR.at(iCut).c_str());
// TString name_HR_histoTot_temp = Form("%s %d %s",vVarNameHR.at(iVar).c_str(), iCut, reduced_name_samples.at(iName).c_str());
histo[iName][iCut][iVar] = new TH2F(name_histoTot_temp,name_HR_histoTot_temp,vNBin.at(iVar).first,vMin.at(iVar).first, vMax.at(iVar).first,vNBin.at(iVar).second,vMin.at(iVar).second, vMax.at(iVar).second);
histo[iName][iCut][iVar] -> Sumw2(); //---- così mette l'errore giusto!
reduced_name_samples_flag.at(iName) = 1;
}
histo[iName][iCut][iVar] -> Add(histo_temp[iSample][iCut][iVar]);
}
}
}
}
}
if (Normalize == 1) { //---- normalize to Data ----
for (unsigned int iCut = 0; iCut<vCut.size(); iCut++){
for (unsigned int iVar = 0; iVar<vVarName.size(); iVar++){
///---- initialize (begin) ----
for (unsigned int iName=0; iName<reduced_name_samples.size(); iName++){
reduced_name_samples_flag.at(iName) = -1;
}
///---- initialize (end) ----
double data_int = histo[numDATA][iCut][iVar] -> Integral();
double mc_int = 0;
for (int iSample = (numberOfSamples-1); iSample>= 0; iSample--){
for (unsigned int iName=0; iName<reduced_name_samples.size(); iName++){
if (name_samples.at(iSample) == reduced_name_samples.at(iName) && iName != numDATA){
mc_int += histo_temp[iSample][iCut][iVar] -> Integral();
}
}
}
std::cout << " data_int / mc_int = " << data_int / mc_int << std::endl;
for (int iSample = (numberOfSamples-1); iSample>= 0; iSample--){
histo_temp[iSample][iCut][iVar] -> Scale (data_int / mc_int);
for (unsigned int iName=0; iName<reduced_name_samples.size(); iName++){
if (name_samples.at(iSample) == reduced_name_samples.at(iName) && iName != numDATA){
if (reduced_name_samples_flag.at(iName) == -1){
TString name_histoTot_temp = Form("%s_%d_%d_Tot_temp",reduced_name_samples.at(iName).c_str(),iCut, iVar);
TString name_HR_histoTot_temp = Form("%s vs %s @ %s",vVarNameHR.at(iVar).second.c_str(),vVarNameHR.at(iVar).first.c_str(), vCutHR.at(iCut).c_str());
// TString name_HR_histoTot_temp = Form("%s %d %s",vVarNameHR.at(iVar).c_str(), iCut, reduced_name_samples.at(iName).c_str());
histo[iName][iCut][iVar] = new TH2F(name_histoTot_temp,name_HR_histoTot_temp,vNBin.at(iVar).first,vMin.at(iVar).first, vMax.at(iVar).first,vNBin.at(iVar).second,vMin.at(iVar).second, vMax.at(iVar).second);
histo[iName][iCut][iVar] -> Sumw2(); //---- così mette l'errore giusto!
reduced_name_samples_flag.at(iName) = 1;
}
histo[iName][iCut][iVar] -> Add(histo_temp[iSample][iCut][iVar]);
}
}
}
}
}
}
else { //---- normalize to Lumi
for (unsigned int iCut = 0; iCut<vCut.size(); iCut++){
for (unsigned int iVar = 0; iVar<vVarName.size(); iVar++){
///---- initialize (begin) ----
for (unsigned int iName=0; iName<reduced_name_samples.size(); iName++){
reduced_name_samples_flag.at(iName) = -1;
}
///---- initialize (end) ----
for (int iSample = (numberOfSamples-1); iSample>= 0; iSample--){
for (unsigned int iName=0; iName<reduced_name_samples.size(); iName++){
if (name_samples.at(iSample) == reduced_name_samples.at(iName) && iName != numDATA ){
if (reduced_name_samples_flag.at(iName) == -1){
TString name_histoTot_temp = Form("%s_%d_%d_Tot_temp",reduced_name_samples.at(iName).c_str(),iCut, iVar);
TString name_HR_histoTot_temp = Form("%s vs %s @ %s",vVarNameHR.at(iVar).second.c_str(),vVarNameHR.at(iVar).first.c_str(), vCutHR.at(iCut).c_str());
// TString name_HR_histoTot_temp = Form("%s %d %s",vVarNameHR.at(iVar).c_str(), iCut, reduced_name_samples.at(iName).c_str());
histo[iName][iCut][iVar] = new TH2F(name_histoTot_temp,name_HR_histoTot_temp,vNBin.at(iVar).first,vMin.at(iVar).first, vMax.at(iVar).first,vNBin.at(iVar).second,vMin.at(iVar).second, vMax.at(iVar).second);
histo[iName][iCut][iVar] -> Sumw2(); //---- così mette l'errore giusto!
reduced_name_samples_flag.at(iName) = 1;
}
histo[iName][iCut][iVar] -> Add(histo_temp[iSample][iCut][iVar]);
}
}
}
}
}
}
// [iCut][iVar]
THStack* hs[100][100];
std::cout << std::endl;
///==== cicle on selections ====
for (unsigned int iCut = 0; iCut<vCut.size(); iCut++){
///==== cicle on variables to plot ====
for (unsigned int iVar = 0; iVar<vVarName.size(); iVar++){
TString nameStack = Form("%d_%d_stack",iCut,iVar);
hs[iCut][iVar] = new THStack(nameStack,nameStack);
for (unsigned int iName=0; iName<reduced_name_samples.size(); iName++){
histo[iName][iCut][iVar]->GetXaxis()->SetTitle(vVarNameHR.at(iVar).first.c_str());
histo[iName][iCut][iVar]->GetYaxis()->SetTitle(vVarNameHR.at(iVar).second.c_str());
histo[iName][iCut][iVar]->SetMarkerColor(vColor[iName]);
histo[iName][iCut][iVar]->SetLineColor(vColor[iName]);
histo[iName][iCut][iVar]->SetFillColor(vColor[iName]);
histo[iName][iCut][iVar]->SetLineWidth(2);
histo[iName][iCut][iVar]->SetFillStyle(3001);
bool isSig = false;
for (std::vector<std::string>::const_iterator itSig = SignalName.begin(); itSig != SignalName.end(); itSig++){
if (reduced_name_samples.at(iName) == *itSig) isSig = true;
}
if (!isSig && reduced_name_samples.at(iName) != "DATA") {
hs[iCut][iVar]->Add(histo[iName][iCut][iVar]);
}
else {
if (!isSig) {
histo[iName][iCut][iVar]->SetMarkerStyle(20);
histo[iName][iCut][iVar]->SetMarkerSize(1);
histo[iName][iCut][iVar]->SetMarkerColor(kBlack);
histo[iName][iCut][iVar]->SetLineColor(kBlack);
histo[iName][iCut][iVar]->SetFillColor(kBlack);
histo[iName][iCut][iVar]->SetLineWidth(2);
histo[iName][iCut][iVar]->SetFillStyle(3001);
}
else {
histo[iName][iCut][iVar]->SetMarkerStyle(21);
histo[iName][iCut][iVar]->SetMarkerSize(1);
histo[iName][iCut][iVar]->SetLineWidth(2);
histo[iName][iCut][iVar]->SetFillStyle(3001);
}
}
}
///==== histo sum MC ====
///==== Add systrematic error ====
// AddError(hs[iCut][iVar],LumiSyst);
histoSumMC[iCut][iVar] = ((TH2F*)(hs[iCut][iVar]->GetStack()->Last()));
///==== legend ====
if (!LegendBuilt){
for (unsigned int iName=0; iName<reduced_name_samples.size(); iName++){
leg->AddEntry(histo[iName][iCut][iVar],reduced_name_samples.at(iName).c_str(),"pf");
LegendBuilt = true;
}
}
}
}
std::cout << std::endl << std::endl;
LumiSyst = 0; ///---- bug fix
// [iName][iCut][iVar]
TCanvas* cCanvasAll[100][30][30];
TCanvas* cCompareCut[100];
TCanvas* cCompareVar[100];
for (unsigned int iCut = 0; iCut<vCut.size(); iCut++){
TString nameCanvas = Form("%d_Cut_Canvas",iCut);
cCompareCut[iCut] = new TCanvas(nameCanvas,nameCanvas,400 * vVarName.size(),400);
cCompareCut[iCut] -> Divide (vVarName.size(),1);
}
for (unsigned int iVar = 0; iVar<vVarName.size(); iVar++){ ///==== cicle on variables to plot ====
TString nameCanvas = Form("%d_Var_Canvas",iVar);
cCompareVar[iVar] = new TCanvas(nameCanvas,nameCanvas,400,400 * vCut.size());
cCompareVar[iVar] -> Divide (1,vCut.size());
}
for (unsigned int iCut = 0; iCut<vCut.size(); iCut++){
for (unsigned int iVar = 0; iVar<vVarName.size(); iVar++){
TString nameCanvas = Form("%d_%d_Canvas",iCut,iVar);
ccCanvas[iCut][iVar] = new TCanvas(nameCanvas,nameCanvas,400,400);
for (unsigned int iName=0; iName<reduced_name_samples.size(); iName++){
TString nameCanvasName = Form("%d_%d_%d_Canvas",iCut,iVar,iName);
cCanvasAll[iName][iCut][iVar] = new TCanvas(nameCanvasName,nameCanvasName,400,400);
}
}
}
///==== cicle on selections ====
for (unsigned int iCut = 0; iCut<vCut.size(); iCut++){
///==== cicle on variables to plot ====
for (unsigned int iVar = 0; iVar<vVarName.size(); iVar++){
///==== draw in canvas ====
for (unsigned int iName=0; iName<reduced_name_samples.size(); iName++){
cCanvasAll[iName][iCut][iVar]->cd();
gPad->SetLeftMargin(0.14);
gPad->SetRightMargin(0.23);
histo[iName][iCut][iVar]->Draw();
histo[iName][iCut][iVar]->GetXaxis()->SetTitle(vVarNameHR.at(iVar).first.c_str());
histo[iName][iCut][iVar]->GetYaxis()->SetTitle(vVarNameHR.at(iVar).second.c_str());
gPad->SetLogz();
gPad->SetGrid();
leg->Draw();
latex->Draw();
}
cCompareCut[iCut] -> cd(iVar+1);
hs[iCut][iVar] ->Draw();
hs[iCut][iVar]->GetXaxis()->SetTitle(vVarNameHR.at(iVar).first.c_str());
hs[iCut][iVar]->GetYaxis()->SetTitle(vVarNameHR.at(iVar).second.c_str());
gPad->SetLogz();
gPad->SetGrid();
leg->Draw();
latex->Draw();
cCompareVar[iVar] -> cd(iCut+1);
hs[iCut][iVar] ->Draw("LEGO");
hs[iCut][iVar]->GetXaxis()->SetTitle(vVarNameHR.at(iVar).first.c_str());
hs[iCut][iVar]->GetYaxis()->SetTitle(vVarNameHR.at(iVar).second.c_str());
gPad->SetLogz();
gPad->SetGrid();
leg->Draw();
latex->Draw();
ccCanvas[iCut][iVar]-> cd();
hs[iCut][iVar]->Draw("LEGO");
hs[iCut][iVar]->GetXaxis()->SetTitle(vVarNameHR.at(iVar).first.c_str());
hs[iCut][iVar]->GetYaxis()->SetTitle(vVarNameHR.at(iVar).second.c_str());
gPad->SetLogz();
gPad->SetGrid();
leg->Draw();
latex->Draw();
for (unsigned int iName=0; iName<reduced_name_samples.size(); iName++){
bool isSig = false;
for (std::vector<std::string>::const_iterator itSig = SignalName.begin(); itSig != SignalName.end(); itSig++){
if (reduced_name_samples.at(iName) == *itSig) isSig = true;
}
if (isSig || reduced_name_samples.at(iName) == "DATA") {
cCompareCut[iCut] -> cd(iVar+1);
// histo[iName][iCut][iVar]->Draw("EsameB");
// histo[iName][iCut][iVar]->Draw("same");
cCompareVar[iVar] -> cd(iCut+1);
// histo[iName][iCut][iVar]->Draw("EsameB");
// histo[iName][iCut][iVar]->Draw("same");
ccCanvas[iCut][iVar]-> cd();
// histo[iName][iCut][iVar]->Draw("EsameB");
// histo[iName][iCut][iVar]->Draw("same");
}
}
cCompareCut[iCut] -> cd(iVar+1);
leg->Draw();
cCompareVar[iVar] -> cd(iCut+1);
leg->Draw();
ccCanvas[iCut][iVar]-> cd();
leg->Draw();
} ///==== end cicle on variables to plot ====
} ///==== end cicle on selections ====
std::cerr << " ******************************************* end *******************************************" << std::endl;
end = clock();
std::cout <<"Time = " << ((double) (end - start)) << " (a.u.)" << std::endl;
///==== save output ====
outFile.cd();
outFile.cd();
outFile.mkdir("PU");
outFile.cd("PU");
if (!doWeightFromFile) {
hPUMC -> Write();
hPUDATA -> Write();
hPUWeight -> Write();
}
outFile.cd();
outFile.mkdir("Cut");
outFile.cd("Cut");
for (unsigned int iCut = 0; iCut<vCut.size(); iCut++){
cCompareCut[iCut] -> Write();
TString nameCut = Form ("Cut_%d",iCut);
TString Cut = Form ("%s",vCut.at(iCut).c_str());
TNamed nameCutNamed (nameCut,Cut);
nameCutNamed.Write();
}
outFile.cd();
outFile.mkdir("Var");
outFile.cd("Var");
for (unsigned int iVar = 0; iVar<vVarName.size(); iVar++){
cCompareVar[iVar] -> Write();
}
outFile.cd();
TDirectory* cdAll = (TDirectory*) outFile.mkdir("All");
cdAll->mkdir("Var");
outFile.cd("All/Var");
for (unsigned int iCut = 0; iCut<vCut.size(); iCut++){
for (unsigned int iVar = 0; iVar<vVarName.size(); iVar++){
ccCanvas[iCut][iVar]-> Write();
}
}
outFile.cd();
outFile.mkdir("Data");
outFile.cd("Data");
for (unsigned int iCut = 0; iCut<vCut.size(); iCut++){
for (unsigned int iVar = 0; iVar<vVarName.size(); iVar++){
hs[iCut][iVar] -> Write() ;
for (unsigned int iName=0; iName<reduced_name_samples.size(); iName++){
histo[iName][iCut][iVar] -> Write();
// bool isSig = false;
// for (std::vector<std::string>::const_iterator itSig = SignalName.begin(); itSig != SignalName.end(); itSig++){
// if (reduced_name_samples.at(iName) == *itSig) isSig = true;
// }
// if (isSig || reduced_name_samples.at(iName) == "DATA") {
// histo[iName][iCut][iVar] -> Write();
// }
}
// ((TH1F*)(hs[iCut][iVar] ->GetStack()->Last()))->Write() ;
TH1F* tempH = ((TH1F*)(hs[iCut][iVar] ->GetStack()->Last())) ;
TString name = Form("All_%d_%d",iCut,iVar);
tempH -> SetName(name);
tempH -> Write();
}
}
outFile.cd();
cdAll->mkdir("CutVar");
outFile.cd("All/CutVar");
///==== cicle on selections ====
for (unsigned int iCut = 0; iCut<vCut.size(); iCut++){
///==== cicle on variables to plot ====
for (unsigned int iVar = 0; iVar<vVarName.size(); iVar++){
for (unsigned int iName=0; iName<reduced_name_samples.size(); iName++){
cCanvasAll[iName][iCut][iVar]->Write();
}
}
}
outFile.cd();
leg->Write();
}
int main( int argc, char * argv[] )
{
// Load libraries
gSystem->Load( "libFWCoreFWLite" );
AutoLibraryLoader::enable();
// Check configuration file
if ( argc < 2 ) {
std::cout << argv[ 0 ] << " --> Usage:" << std::endl
<< " " << argv[ 0 ] << " [CONFIG_FILE.py]" << std::endl;
return 0;
}
boost::shared_ptr< edm::ParameterSet > parameterSet_( edm::readPSetsFrom( argv[ 1 ] ) );
if ( ! parameterSet_->existsAs< edm::ParameterSet >( "process" ) ) {
std::cout << argv[ 0 ] << " --> ERROR:" << std::endl
<< " cms.PSet 'process' missing in " << argv[ 1 ] << std::endl;
return 1;
}
// Get the configurations
const edm::ParameterSet & process_( parameterSet_->getParameter< edm::ParameterSet >( "process" ) );
const unsigned verbosity_( process_.getParameter< unsigned >( "verbosity" ) );
const edm::ParameterSet & exist_( process_.getParameter< edm::ParameterSet >( "existing" ) );
const std::vector< double > objLimits_( exist_.getParameter< std::vector< double > >( "objectPtLimits" ) ); // object upper edge of p_t range to display
const std::vector< std::string > kinProps_( exist_.getParameter< std::vector< std::string > >( "kinematicProperties" ) ); // kinematic variables
const std::vector< edm::ParameterSet > resolutions_( process_.getParameter< std::vector< edm::ParameterSet > >( "resolutions" ) );
const std::string outFile_( exist_.getParameter< std::string >( "outputFile" ) );
// Constants
const std::string paramBin_( "bin" );
// Open output file
TFile * outFile( TFile::Open( outFile_.c_str(), "RECREATE" ) );
// Loop over resolutions
for ( unsigned iRes = 0; iRes < resolutions_.size(); ++iRes ) {
const edm::ParameterSet resolution( resolutions_.at( iRes ) );
const std::string label( resolution.getParameter< std::string >( "label" ) );
if ( verbosity_ > 0 ) std::cout << "Resolution set: " << label << std::endl;
TDirectory * dirRes( outFile->mkdir( label.c_str(), label.c_str() ) );
const std::vector< edm::ParameterSet > functions( resolution.getParameter< std::vector< edm::ParameterSet > >( "functions" ) );
for ( unsigned iBin = 0; iBin < functions.size(); ++iBin ) {
const edm::ParameterSet binFunctions( functions.at( iBin) );
const std::string binEta( "Eta" + boost::lexical_cast< std::string >( iBin ) );
std::string titleBin;
if ( binFunctions.exists( paramBin_ ) ) {
titleBin = binFunctions.getParameter< std::string >( paramBin_ );
if ( verbosity_ > 1 ) {
std::cout << " bin " << iBin << ": " << titleBin << std::endl;
}
}
else {
titleBin = "0" ;
if ( verbosity_ > 1 ) {
std::cout << " bin 0: no eta binning" << std::endl;
}
}
for ( unsigned iProp = 0; iProp < kinProps_.size(); ++iProp ) {
const std::string kinProp( kinProps_.at( iProp ) );
std::string kinParam( kinProp );
boost::to_lower( kinParam );
std::string formula( binFunctions.getParameter< std::string >( kinParam ) );
if ( verbosity_ > 2 ) {
std::cout << " " << kinParam << ": " << formula << std::endl;
}
boost::replace_all( formula, "et", "x" );
std::string name( "fitExist_" + kinProp + "_" + binEta );
TDirectory * dirProp;
dirRes->GetObject( kinProp.c_str(), dirProp );
if ( ! dirProp ) dirProp = dirRes->mkdir( kinProp.c_str(), kinProp.c_str() );
TDirectory * dirEta( dirProp->mkdir( binEta.c_str(), binEta.c_str() ) );
dirEta->cd();
TF1 * func( new TF1( name.c_str(), formula.c_str(), 0., objLimits_.at( iRes ) ) );
func->Write();
if ( kinProp == "Et" ) {
TF1 * funcRel( new TF1( std::string( name + "_Rel" ).c_str(), std::string( "(" + formula + ")/x" ).c_str(), 0., objLimits_.at( iRes ) ) );
funcRel->Write();
}
}
}
}
// Close output file
outFile->Write();
outFile->Close();
return 0;
}
int testFindObjectAny()
{
TDirectory* db = gROOT->mkdir("db","db");
TDirectory* a = db->mkdir("a","a");
TDirectory* aa = a->mkdir("aa","aa");
aa->cd();
TH1D* haa_new = new TH1D("haa","haa",10,0,1);
TH1D* haa_find = (TH1D*)db->FindObjectAny("haa");
#ifdef ClingWorkAroundMissingDynamicScope
TH1D* haa = haa_find;
#endif
if (!haa) {
cout << "haa missing\n";
} else if (haa_new != haa_find) {
cout << "haa not found correctly!\n";
}
TFile* base = new TFile("fdb.root","recreate");
#ifdef ClingReinstateRedeclarationAllowed
TDirectory* a = base->mkdir("a","First Level Dir");
#else
a = base->mkdir("a","First Level Dir");
#endif
a->cd();
TH1D* ha = new TH1D("ha","ha",10,0,1);
#ifdef ClingReinstateRedeclarationAllowed
TDirectory* aa = a->mkdir("aa","Second Level Dira");
#else
aa = a->mkdir("aa","Second Level Dira");
#endif
aa->cd();
#ifdef ClingWorkAroundMissingDynamicScope
haa = new TH1D("haa","haa",10,0,1);
#else
TH1D* haa = new TH1D("haa","haa",10,0,1);
#endif
testing( a, base->FindObjectAny("a"));
testing( ha, base->FindObjectAny("ha"));
testing( ha, a->FindObjectAny("ha"));
testing( aa, base->FindObjectAny("aa"));
testing( aa, a->FindObjectAny("aa"));
testing( haa, base->FindObjectAny("haa"));
testing( haa, a->FindObjectAny("haa"));
testing( haa, aa->FindObjectAny("haa"));
base->Write();
delete base;
base = TFile::Open("fdb.root","READ");
testing( 0, base->FindObjectAny("a"));
testing( 0, base->FindObjectAny("ha"));
a = (TDirectory*)base->FindObjectAny("a");
testing( 0, a->FindObjectAny("ha"));
testing( 0, base->FindObjectAny("aa"));
testing( 0, a->FindObjectAny("aa"));
testing( 0, base->FindObjectAny("haa"));
testing( 0, a->FindObjectAny("haa"));
aa = (TDirectory*)base->FindObjectAny("aa");
testing( 0, aa->FindObjectAny("haa"));
return 0;
}
int main ()
{
//open input file
//TFile *f=TFile::Open("input_rootfile/PhotonJet_G_PFlowAK5chs.root");
//TFile *f=TFile::Open("input_rootfile/PhotonJet_QCD_PFlowAK5chs.root");
TFile *f=TFile::Open("input_rootfile/PhotonJet_MC_TOT_PFlowAK5chs.root");
//*****************************************************************************************************
//
// histograms definition
//
//*****************************************************************************************************
QGSyst qgsyst;
//qgsyst.ReadDatabase("SystDatabase.txt");
qgsyst.ReadDatabaseDoubleMin("SystDatabase_doubleMin.txt");
qgsyst.SetTagger("QGLHisto");
ptBinning myPtBinning;
int isFor2DTagging = 1;
ptBinning my2DTaggingPtBinning(isFor2DTagging);
//usefull variables
Double_t xlow = getHistoXlow();
Double_t xup = getHistoXup();
//Double_t binrange = 0.1;
//Int_t nbinsx = (xup - xlow)/binrange;
Int_t nbinsx = getHistoNbinsx();
Double_t xlow2D = 0;
Double_t xup2D = 1;
Int_t nbinsx2D = 20;
Double_t ylow2D = 0;
Double_t yup2D = 1;
Int_t nbinsy2D = 20;
int nzones = getZoneNumber();
int nflavours = getFlavourNumber(); //uds, g, c, b, noMatched, all
int n2DTaggingPtBins = my2DTaggingPtBinning.getSize();
vector<TMatrixF> v4x4MatrixPt = buildSquareMatrixPtVector(my2DTaggingPtBinning);
vector<TMatrixF> v6x4MatrixPt = buildMatrixPtVector(my2DTaggingPtBinning);
//vectors for 2D tagging study
// gammapt per flavour per zone
std::vector<std::vector<TH1F*> > vGammaPt_ZoneFlavour = buildZoneFlavourVectorH1("Gammapt",30,0,800);
std::vector<std::vector<TH1F*> > vFirstJetPt_ZoneFlavour = buildZoneFlavourVectorH1("FirstJetPt",160,0,800);
//flavour fractions per pt
vector<TH1F*> vFractionHisto_Pt = buildPtVectorH1(my2DTaggingPtBinning,"FractionHisto",nflavours-1,0,nflavours-1) ;
//responses per zone per pt
vector<vector<TH1F*> > vRmpf_ZonePt = buildZonePtVectorH1(my2DTaggingPtBinning,"Rmpf",nbinsx,xlow,xup) ;
vector<vector<TH1F*> > vRtrue_ZonePt = buildZonePtVectorH1(my2DTaggingPtBinning,"Rtrue",nbinsx,xlow,xup) ;
//QG-likelihood per flavour per pt
vector<vector<TH1F*> > vQGL_FlavourPt = buildFlavourPtVectorH1(my2DTaggingPtBinning,"QGL",nbinsx2D,xlow2D,xup2D) ;
//Btag-CSV per flavour per pt
vector<vector<TH1F*> > vCSV_FlavourPt = buildFlavourPtVectorH1(my2DTaggingPtBinning,"CSV",nbinsx2D,xlow2D,xup2D) ;
//responses per flavour per pt
vector<vector<TH1F*> > vRmpf_FlavourPt = buildFlavourPtVectorH1(my2DTaggingPtBinning,"Rmpf",nbinsx,xlow,xup) ;
vector<vector<TH1F*> > vRtrue_FlavourPt = buildFlavourPtVectorH1(my2DTaggingPtBinning,"Rtrue",nbinsx,xlow,xup) ;
//responses per flavour per pt when we are in one of the 2D tagging zones
vector<vector<TH1F*> > vRmpf_in2DTaggingZone_FlavourPt = buildFlavourPtVectorH1(my2DTaggingPtBinning,"Rmpf_in2DTaggingZone",nbinsx,xlow,xup) ;
vector<vector<TH1F*> > vRtrue_in2DTaggingZone_FlavourPt = buildFlavourPtVectorH1(my2DTaggingPtBinning,"Rtrue_in2DTaggingZone",nbinsx,xlow,xup) ;
//Gammapt per flavour
vector<TH1F*> vGammapt_Flavour = buildFlavourVectorH1("Gammapt",30,0,800);
//responses per zone per flavour per pt
vector<vector<vector<TH1F*> > > vRmpf_ZoneFlavourPt = buildZoneFlavourPtVectorH1(my2DTaggingPtBinning,"Rmpf",nbinsx,xlow,xup) ;
vector<vector<vector<TH1F*> > > vRtrue_ZoneFlavourPt = buildZoneFlavourPtVectorH1(my2DTaggingPtBinning,"Rtrue",nbinsx,xlow,xup) ;
//2D tagging plans per flavour per pt
vector<vector<TH2F*> > v2DTaggingPlan_FlavourPt = buildFlavourPtVectorH2(my2DTaggingPtBinning,"2DTaggingPlan",nbinsx2D,xlow2D,xup2D,nbinsy2D,ylow2D,yup2D) ;
vector<vector<TH2F*> > v2DTaggingPlan_FlavourPt_divided = buildFlavourPtVectorH2(my2DTaggingPtBinning,"2DTaggingPlan_divided",nbinsx2D,xlow2D,xup2D,nbinsy2D,ylow2D,yup2D) ;
//flavour number per zone per flavour per pt
vector<vector<vector<float> > > vFlavourNumber = build_fraction_ZoneFlavourPtVector(my2DTaggingPtBinning) ;
//flavour number per zone per flavour per pt
vector<vector<vector<float> > > vFlavourFraction = build_fraction_ZoneFlavourPtVector(my2DTaggingPtBinning) ;
for(int j=0; j<n2DTaggingPtBins; j++) {
vFractionHisto_Pt[j]->Sumw2();
for(int i=0; i<nzones; i++) {
vRmpf_ZonePt[i][j]->Sumw2();
vRtrue_ZonePt[i][j]->Sumw2();
}
for(int k=0; k<nflavours; k++) {
vRmpf_FlavourPt[k][j]->Sumw2();
vRtrue_FlavourPt[k][j]->Sumw2();
vRmpf_in2DTaggingZone_FlavourPt[k][j]->Sumw2();
vRtrue_in2DTaggingZone_FlavourPt[k][j]->Sumw2();
v2DTaggingPlan_FlavourPt[k][j]->Sumw2();
vQGL_FlavourPt[k][j]->Sumw2();
vCSV_FlavourPt[k][j]->Sumw2();
for(int l=0; l<nzones; l++) {
vRmpf_ZoneFlavourPt[l][k][j]->Sumw2();
vRtrue_ZoneFlavourPt[l][k][j]->Sumw2();
}
}
}
for(int k=0; k<nflavours; k++) {
vGammapt_Flavour[k]->Sumw2();
for(int l=0; l<nzones; l++) {
vGammaPt_ZoneFlavour[l][k]->Sumw2();
vFirstJetPt_ZoneFlavour[l][k]->Sumw2();
}
}
TH1F* hGammaPt=new TH1F("hGammaPt","hGammaPt",40,40,800);
hGammaPt->SetXTitle("p_{T}^{#gamma} [GeV/c]");
hGammaPt->Sumw2();
TH1F* hFirstJetPt=new TH1F("hFirstJetPt","hFirstJetPt",50,0,1400);
hFirstJetPt->SetXTitle("1^{st} jet p_{T} [GeV/c]");
hFirstJetPt->Sumw2();
TH1F* hSecondJetPt=new TH1F("hSecondJetPt","hSecondJetPt",50,0,200);
hSecondJetPt->SetXTitle("2^{nd} jet p_{T} [GeV/c]");
hSecondJetPt->Sumw2();
TH1F* hMetPt=new TH1F("hMetPt","hMetPt",50,0,620);
hMetPt->SetXTitle("MET p_{T} [GeV/c]");
hMetPt->Sumw2();
TH1F* hParalleleMetPt=new TH1F("hParalleleMetPt","hParalleleMetPt",50,-200,200);
hParalleleMetPt->SetXTitle("parallele MET p_{T} [GeV/c]");
hParalleleMetPt->Sumw2();
TH1F* hPerpendicularMetPt=new TH1F("hPerpendicularMetPt","hPerpendicularMetPt",50,-140,140);
hPerpendicularMetPt->SetXTitle("perpendicular MET p_{T} [GeV/c]");
hPerpendicularMetPt->Sumw2();
TH1F* hAlpha=new TH1F("hAlpha","hAlpha",10,0.,1.);
hAlpha->SetXTitle("p_{T}^{2^{nd} jet}/p_{T}^{#gamma}");
hAlpha->Sumw2();
TH1F* hDeltaPhi_j1gamma=new TH1F("hDeltaPhi_j1gamma","hDeltaPhi_j1gamma",40,0,4);
hDeltaPhi_j1gamma->SetXTitle("|#Delta#phi (#gamma,1^{st}jet)|");
hDeltaPhi_j1gamma->Sumw2();
TH1F* hDeltaPhi_j2gamma=new TH1F("hDeltaPhi_j2gamma","hDeltaPhi_j2gamma",40,0,4);
hDeltaPhi_j2gamma->SetXTitle("|#Delta#phi (#gamma,2^{nd}jet)|");
hDeltaPhi_j2gamma->Sumw2();
TH1F* hDeltaPhi_j1j2=new TH1F("hDeltaPhi_j1j2","hDeltaPhi_j1j2",40,0,4);
hDeltaPhi_j1j2->SetXTitle("|#Delta#phi (1^{st} jet,2^{nd} jet)|");
hDeltaPhi_j1j2->Sumw2();
TH1F* hDeltaR_j1gamma=new TH1F("hDeltaR_j1gamma","hDeltaR_j1gamma",40,0,8);
hDeltaR_j1gamma->SetXTitle("|#DeltaR (#gamma,1^{st} jet)|");
hDeltaR_j1gamma->Sumw2();
TH1F* hDeltaR_j2gamma=new TH1F("hDeltaR_j2gamma","hDeltaR_j2gamma",40,0,8);
hDeltaR_j2gamma->SetXTitle("|#DeltaR (#gamma,2^{nd} jet)|");
hDeltaR_j2gamma->Sumw2();
TH1F* hDeltaR_j1j2=new TH1F("hDeltaR_j1j2","hDeltaR_j1j2",40,0,8);
hDeltaR_j1j2->SetXTitle("|#DeltaR (1^{st} jet,2^{nd} jet)|");
hDeltaR_j1j2->Sumw2();
//*****************************************************************************************************
//
// reading the root file
//
//*****************************************************************************************************
//retrieve the trees
TTree* t_firstjet=(TTree*)f->Get("first_jet");
TTree* t_firstjetraw=(TTree*)f->Get("first_jet_raw");
TTree* t_firstjetgen=(TTree*)f->Get("first_jet_gen");
TTree* t_secondjetgen=(TTree*)f->Get("second_jet_gen");
TTree* t_secondjet=(TTree*)f->Get("second_jet");
TTree* t_electron=(TTree*)f->Get("electrons");
TTree* t_muon=(TTree*)f->Get("muons");
TTree* t_met=(TTree*)f->Get("met");
TTree* t_gamma=(TTree*)f->Get("photon");
TTree* t_gammagen=(TTree*)f->Get("photon_gen");
TTree* t_misc=(TTree*)f->Get("misc");
TTree* t_rho=(TTree*)f->Get("rho");
//TTree* t_gen_particles=(TTree*)f->Get("gen_particles");
//retrieve the variables
//First jet
float firstjetpt;
t_firstjet->SetBranchAddress("pt",&firstjetpt);
float firstjetpx;
t_firstjet->SetBranchAddress("px",&firstjetpx);
float firstjetpy;
t_firstjet->SetBranchAddress("py",&firstjetpy);
float firstjetphi;
t_firstjet->SetBranchAddress("phi",&firstjetphi);
float firstjeteta;
t_firstjet->SetBranchAddress("eta",&firstjeteta);
float firstjetbtag_csv;
t_firstjet->SetBranchAddress("btag_csv",&firstjetbtag_csv);
float firstjetqg_tag_mlp;
t_firstjet->SetBranchAddress("qg_tag_mlp",&firstjetqg_tag_mlp);
float firstjetqg_tag_likelihood;
t_firstjet->SetBranchAddress("qg_tag_likelihood",&firstjetqg_tag_likelihood);
//First jet raw
float firstjetrawpt;
t_firstjetraw->SetBranchAddress("pt",&firstjetrawpt);
float firstjetrawphi;
t_firstjetraw->SetBranchAddress("phi",&firstjetrawphi);
float firstjetraweta;
t_firstjetraw->SetBranchAddress("eta",&firstjetraweta);
//First jet generated
gROOT->ProcessLine("#include <vector>");
float firstjetgenpt;
t_firstjetgen->SetBranchAddress("pt",&firstjetgenpt);
float firstjetgenpx;
t_firstjetgen->SetBranchAddress("px",&firstjetgenpx);
float firstjetgenpy;
t_firstjetgen->SetBranchAddress("py",&firstjetgenpy);
float firstjetgenphi;
t_firstjetgen->SetBranchAddress("phi",&firstjetgenphi);
float firstjetgeneta;
t_firstjetgen->SetBranchAddress("eta",&firstjetgeneta);
int firstjetgenpdgid;
t_firstjetgen->SetBranchAddress("parton_pdg_id",&firstjetgenpdgid); // physics definition
//t_firstjetgen->SetBranchAddress("parton_flavour",&firstjetgenpdgid); // algorithmic definition
// TClonesArray *aneutrino_4vect = 0;
// t_firstjetgen->SetBranchAddress("neutrinos",&aneutrino_4vect);
//Second jet generated
float secondjetgenpt;
t_secondjetgen->SetBranchAddress("pt",&secondjetgenpt);
float secondjetgenphi;
t_secondjetgen->SetBranchAddress("phi",&secondjetgenphi);
float secondjetgeneta;
t_secondjetgen->SetBranchAddress("eta",&secondjetgeneta);
//misc
float miscevent_weight;
t_misc->SetBranchAddress("event_weight",&miscevent_weight);
//Second jet
float secondjetpt;
t_secondjet->SetBranchAddress("pt",&secondjetpt);
float secondjetphi;
t_secondjet->SetBranchAddress("phi",&secondjetphi);
float secondjeteta;
t_secondjet->SetBranchAddress("eta",&secondjeteta);
//Gamma (reco)
float gammapt;
t_gamma->SetBranchAddress("pt",&gammapt);
float gammaphi;
t_gamma->SetBranchAddress("phi",&gammaphi);
float gammaeta;
t_gamma->SetBranchAddress("eta",&gammaeta);
float gammapx;
t_gamma->SetBranchAddress("px",&gammapx);
float gammapy;
t_gamma->SetBranchAddress("py",&gammapy);
float gammapz;
t_gamma->SetBranchAddress("pz",&gammapz);
bool gamma_has_pixel_seed;
t_gamma->SetBranchAddress("has_pixel_seed",&gamma_has_pixel_seed);
//Gamma gen
float gammagenpt;
t_gammagen->SetBranchAddress("pt",&gammagenpt);
float gammagenpx;
t_gammagen->SetBranchAddress("px",&gammagenpx);
float gammagenpy;
t_gammagen->SetBranchAddress("py",&gammagenpy);
//electron
float electronpt[100];
t_electron->SetBranchAddress("pt",&electronpt);
float electronphi[100];
t_electron->SetBranchAddress("phi",&electronphi);
float electroneta[100];
t_electron->SetBranchAddress("eta",&electroneta);
int electronn;
t_electron->SetBranchAddress("n",&electronn);
float electronisolation[100];
t_electron->SetBranchAddress("isolation",&electronisolation);
//muon
float muonpt[100];
t_muon->SetBranchAddress("pt",&muonpt);
float muonphi[100];
t_muon->SetBranchAddress("phi",&muonphi);
float muoneta[100];
t_muon->SetBranchAddress("eta",&muoneta);
int muonn;
t_muon->SetBranchAddress("n",&muonn);
float muonisolation[100];
t_muon->SetBranchAddress("relative_isolation",&muonisolation);
//met
float metpt;
t_met->SetBranchAddress("pt",&metpt);
float metpx;
t_met->SetBranchAddress("px",&metpx);
float metpy;
t_met->SetBranchAddress("py",&metpy);
float metpz;
t_met->SetBranchAddress("pz",&metpz);
float metphi;
t_met->SetBranchAddress("phi",&metphi);
//rho
double rho;
t_rho->SetBranchAddress("rho",&rho);
//Usefull variables
float Rmpf;
float Rtrue;
float alpha;
float metParal;
float metPerpend;
Double_t DeltaPhi_j1gamma;
Double_t DeltaPhi_j2gamma;
Double_t DeltaPhi_j1j2;
Double_t DeltaPhi_j1met;
Double_t DeltaR_j1gamma;
Double_t DeltaR_j2gamma;
Double_t DeltaR_j1j2;
Double_t DeltaEta_j1gamma;
Double_t DeltaEta_j2gamma;
Double_t DeltaEta_j1j2;
Double_t DeltaPhi_j1j2_gen;
Double_t DeltaEta_j1j2_gen;
Double_t DeltaR_j1j2_gen;
int binPt;//bin en pt
int bin2DTaggingPt;//gros bins en pt pour l etude 2D tagging
int binZone;// 2D tagging zone bin
int binFlavour;
bool dropEvent=false;
//count events in the tree
unsigned int nEvents = (int)t_firstjet->GetEntries();
string type;
//loop over them
for(unsigned int ievt=0; ievt<nEvents; ievt++) {
t_firstjet->GetEntry(ievt);
t_firstjetraw->GetEntry(ievt);
t_secondjet->GetEntry(ievt);
t_electron->GetEntry(ievt);
t_muon->GetEntry(ievt);
t_gamma->GetEntry(ievt);
t_gammagen->GetEntry(ievt);
t_met->GetEntry(ievt);
t_misc->GetEntry(ievt);
t_firstjetgen->GetEntry(ievt);
t_secondjetgen->GetEntry(ievt);
t_rho->GetEntry(ievt);
//t_gen_particles->GetEntry(ievt);
//*********************************************************************************************************
dropEvent=false;
if(gamma_has_pixel_seed == true) continue;
binPt = myPtBinning.getPtBin(gammapt);
if(binPt == -1) continue;
bin2DTaggingPt = my2DTaggingPtBinning.getPtBin(gammapt);
if(TMath::Abs(firstjetgenpdgid) == 21) {
type = "gluon";
}
else if(TMath::Abs(firstjetgenpdgid) == 4) {//c
type = "quark";
}
else if(TMath::Abs(firstjetgenpdgid) == 5) {//b
type = "quark";
}
else if(TMath::Abs(firstjetgenpdgid) == 1 || TMath::Abs(firstjetgenpdgid) == 2 || TMath::Abs(firstjetgenpdgid) == 3) {
type = "quark";
}
else {
type = "gluon";
}
firstjetqg_tag_likelihood = qgsyst.Smear(firstjetpt, firstjeteta, rho, firstjetqg_tag_likelihood, type);
binZone = getZoneBin(firstjetbtag_csv, firstjetqg_tag_likelihood);
//if(binZone == -1) continue;
binFlavour = getFlavourBin(firstjetgenpdgid);
//if(binFlavour == -1) continue;
Rmpf = 1 + (gammapx*metpx + gammapy*metpy)/(pow(gammapt,2));
alpha = (secondjetpt)/(gammapt);
Rtrue = (firstjetpt)/(firstjetgenpt);
//*****************************************************************************************************
//
// deltaPhi calculation
//
//*****************************************************************************************************
//DeltaPhi between the 1st jet and the gamma calculation
DeltaPhi_j1gamma = TMath::Abs((gammaphi) - (firstjetphi));
if(DeltaPhi_j1gamma>TMath::Pi()){
DeltaPhi_j1gamma = 2*TMath::Pi()-DeltaPhi_j1gamma;
}
//DeltaPhi between the 2nd jet and the gamma calculation
DeltaPhi_j2gamma = TMath::Abs((gammaphi) - (secondjetphi));
if(DeltaPhi_j2gamma>TMath::Pi()){
DeltaPhi_j2gamma = 2*TMath::Pi()-DeltaPhi_j2gamma;
}
//DeltaPhi between the first jet and the second jet calculation
DeltaPhi_j1j2 = TMath::Abs((secondjetphi) - (firstjetphi));
if(DeltaPhi_j1j2>TMath::Pi()){
DeltaPhi_j1j2 = 2*TMath::Pi()-DeltaPhi_j1j2;
}
//DeltaPhi between the first jetgen and the second jetgen calculation
DeltaPhi_j1j2_gen = TMath::Abs((secondjetgenphi) - (firstjetgenphi));
if(DeltaPhi_j1j2_gen>TMath::Pi()){
DeltaPhi_j1j2_gen = 2*TMath::Pi()-DeltaPhi_j1j2_gen;
}
//DeltaPhi between the first jet and the met
DeltaPhi_j1met = TMath::Abs((metphi) - (firstjetphi));
//*****************************************************************************************************
//
// deltaEta calculation
//
//*****************************************************************************************************
//DeltaEta between the first jet and the gamma calculation
DeltaEta_j1gamma = TMath::Abs((gammaeta) - (firstjeteta));
//DeltaEta between the second jet and the gamma calculation
DeltaEta_j2gamma = TMath::Abs((gammaeta) - (secondjeteta));
//DeltaEta between the first jet and the second jet calculation
DeltaEta_j1j2 = TMath::Abs((secondjeteta) - (firstjeteta));
//DeltaEta between the first jetgen and the second jetgen calculation
DeltaEta_j1j2_gen = TMath::Abs((secondjetgeneta) - (firstjetgeneta));
//*****************************************************************************************************
//
// deltaR calculation
//
//*****************************************************************************************************
//DeltaR between the first jet and the gamma calculation
DeltaR_j1gamma = sqrt ( pow(DeltaEta_j1gamma,2) + pow(DeltaPhi_j1gamma,2) );
//DeltaR between the second jet and the gamma calculation
DeltaR_j2gamma = sqrt ( pow(DeltaEta_j2gamma,2) + pow(DeltaPhi_j2gamma,2) );
//DeltaR between the first jet and the second jet calculation
DeltaR_j1j2 = sqrt ( pow(DeltaEta_j1j2,2) + pow(DeltaPhi_j1j2,2) );
//DeltaR between the first jetgen and the second jetgen calculation
DeltaR_j1j2_gen = sqrt ( pow(DeltaEta_j1j2_gen,2) + pow(DeltaPhi_j1j2_gen,2) );
//*****************************************************************************************************
//
// met parallele calculation
//
//*****************************************************************************************************
metParal = metpt * TMath::Cos(DeltaPhi_j1met);
//*****************************************************************************************************
//
// met perpendicular calculation
//
//*****************************************************************************************************
metPerpend = metpt * TMath::Sin(DeltaPhi_j1met);
//*****************************************************************************************************
//
// filling histogramms
//
//*****************************************************************************************************
//if(fabs(firstjetpt)>12. && DeltaPhi_j1gamma>2.8 && fabs(firstjeteta)<1.3 && (alpha<0.3 || secondjetpt<10)) {
if(fabs(firstjetpt)>12. && DeltaPhi_j1gamma>2.8 && fabs(firstjeteta)<1.3) {
if(muonn==0){
if(electronn==0) {
if(gammapt>200.) {
hAlpha->Fill(alpha,miscevent_weight);
}
if((alpha<0.3 || secondjetpt<10)) {
vGammapt_Flavour[binFlavour]->Fill(gammapt,miscevent_weight);
vGammapt_Flavour[nflavours-1]->Fill(gammapt,miscevent_weight);
hGammaPt->Fill(gammapt,miscevent_weight);
hFirstJetPt->Fill(firstjetpt,miscevent_weight);
hMetPt->Fill(metpt,miscevent_weight);
hParalleleMetPt->Fill(metParal,miscevent_weight);
hPerpendicularMetPt->Fill(metPerpend,miscevent_weight);
hSecondJetPt->Fill(secondjetpt,miscevent_weight);
hDeltaPhi_j1gamma->Fill(DeltaPhi_j1gamma,miscevent_weight);
hDeltaPhi_j2gamma->Fill(DeltaPhi_j2gamma,miscevent_weight);
hDeltaPhi_j1j2->Fill(DeltaPhi_j1j2,miscevent_weight);
hDeltaR_j1gamma->Fill(DeltaR_j1gamma,miscevent_weight);
hDeltaR_j2gamma->Fill(DeltaR_j2gamma,miscevent_weight);
hDeltaR_j1j2->Fill(DeltaR_j1j2,miscevent_weight);
if((firstjetbtag_csv>=0 && firstjetbtag_csv<=1) && (firstjetqg_tag_likelihood>=0 && firstjetqg_tag_likelihood<=1)) {
//protection contre les jets non matches
vQGL_FlavourPt[binFlavour][bin2DTaggingPt]->Fill(firstjetqg_tag_likelihood,miscevent_weight);
vCSV_FlavourPt[binFlavour][bin2DTaggingPt]->Fill(firstjetbtag_csv,miscevent_weight);
vQGL_FlavourPt[nflavours-1][bin2DTaggingPt]->Fill(firstjetqg_tag_likelihood,miscevent_weight);
vCSV_FlavourPt[nflavours-1][bin2DTaggingPt]->Fill(firstjetbtag_csv,miscevent_weight);
if(binZone!=-1) {
vGammaPt_ZoneFlavour[binZone][binFlavour]->Fill(gammapt,miscevent_weight);
vGammaPt_ZoneFlavour[binZone][nflavours-1]->Fill(gammapt,miscevent_weight);
if(gammapt>200.) {
vFirstJetPt_ZoneFlavour[binZone][binFlavour]->Fill(firstjetpt,miscevent_weight);
vFirstJetPt_ZoneFlavour[binZone][nflavours-1]->Fill(firstjetpt,miscevent_weight);
}
vRmpf_ZonePt[binZone][bin2DTaggingPt]->Fill(Rmpf,miscevent_weight);
vRtrue_ZonePt[binZone][bin2DTaggingPt]->Fill(Rtrue,miscevent_weight);
vRmpf_ZoneFlavourPt[binZone][binFlavour][bin2DTaggingPt]->Fill(Rmpf,miscevent_weight);
vRtrue_ZoneFlavourPt[binZone][binFlavour][bin2DTaggingPt]->Fill(Rtrue,miscevent_weight);
vRmpf_ZoneFlavourPt[binZone][nflavours-1][bin2DTaggingPt]->Fill(Rmpf,miscevent_weight);
vRtrue_ZoneFlavourPt[binZone][nflavours-1][bin2DTaggingPt]->Fill(Rtrue,miscevent_weight);
vRmpf_in2DTaggingZone_FlavourPt[binFlavour][bin2DTaggingPt]->Fill(Rmpf,miscevent_weight);
vRtrue_in2DTaggingZone_FlavourPt[binFlavour][bin2DTaggingPt]->Fill(Rtrue,miscevent_weight);
vRmpf_in2DTaggingZone_FlavourPt[nflavours-1][bin2DTaggingPt]->Fill(Rmpf,miscevent_weight);
vRtrue_in2DTaggingZone_FlavourPt[nflavours-1][bin2DTaggingPt]->Fill(Rtrue,miscevent_weight);
vFlavourNumber[binZone][binFlavour][bin2DTaggingPt] = vFlavourNumber[binZone][binFlavour][bin2DTaggingPt] + miscevent_weight;
vFlavourNumber[binZone][nflavours-1][bin2DTaggingPt] = vFlavourNumber[binZone][nflavours-1][bin2DTaggingPt] + miscevent_weight;
}
vRmpf_FlavourPt[binFlavour][bin2DTaggingPt]->Fill(Rmpf,miscevent_weight);
vRtrue_FlavourPt[binFlavour][bin2DTaggingPt]->Fill(Rtrue,miscevent_weight);
vRmpf_FlavourPt[nflavours-1][bin2DTaggingPt]->Fill(Rmpf,miscevent_weight);
vRtrue_FlavourPt[nflavours-1][bin2DTaggingPt]->Fill(Rtrue,miscevent_weight);
// vQGL_FlavourPt[binFlavour][bin2DTaggingPt]->Fill(firstjetqg_tag_likelihood,miscevent_weight);
// vCSV_FlavourPt[binFlavour][bin2DTaggingPt]->Fill(firstjetbtag_csv,miscevent_weight);
// vQGL_FlavourPt[nflavours-1][bin2DTaggingPt]->Fill(firstjetqg_tag_likelihood,miscevent_weight);
// vCSV_FlavourPt[nflavours-1][bin2DTaggingPt]->Fill(firstjetbtag_csv,miscevent_weight);
v2DTaggingPlan_FlavourPt[binFlavour][bin2DTaggingPt]->Fill(firstjetbtag_csv,firstjetqg_tag_likelihood,miscevent_weight);
v2DTaggingPlan_FlavourPt[nflavours-1][bin2DTaggingPt]->Fill(firstjetbtag_csv,firstjetqg_tag_likelihood,miscevent_weight);//nflavours-1 : corresponds to total
}
}
}
}
}
}
//*****************************************************************************************************
//
// 2D Tagging Plans
//
//*****************************************************************************************************
//v2DTaggingPlan_FlavourPt[binFlavour][bin2DTaggingPt]
std::string name2DTaggingPlan;
std::string name2DTaggingPlan_check;
std::string nameHisto;
std::string nameHisto_check;
TCanvas *cLikelihood_vs_csv = new TCanvas();
cLikelihood_vs_csv->cd();
string histoName;
for(int j=0; j<n2DTaggingPtBins; j++) {
for(int i=0; i<nflavours-1; i++) {//divide flavour distri by total distri
cLikelihood_vs_csv->Clear();
histoName = "images2DTagging/2DTaggingZones/beforeDividing/" + getFlavourBinName(i) + "_" + my2DTaggingPtBinning.getName(j) + ".pdf";
//name2DTaggingPlan_check = ("images2DTagging/2DTaggingZones/beforeDividing/");
v2DTaggingPlan_FlavourPt[i][j]->Draw("colz");
v2DTaggingPlan_FlavourPt[i][j]->SetStats(0);
v2DTaggingPlan_FlavourPt[i][j]->GetXaxis()->SetRangeUser(0.,1.);
v2DTaggingPlan_FlavourPt[i][j]->GetXaxis()->SetLabelOffset(0.005);
v2DTaggingPlan_FlavourPt[i][j]->GetXaxis()->SetLabelFont(42);
v2DTaggingPlan_FlavourPt[i][j]->GetXaxis()->SetLabelSize(0.045);
v2DTaggingPlan_FlavourPt[i][j]->GetXaxis()->SetTitleOffset(1.15);
v2DTaggingPlan_FlavourPt[i][j]->GetXaxis()->SetTitleSize(0.04);
v2DTaggingPlan_FlavourPt[i][j]->GetXaxis()->SetTitleFont(42);
v2DTaggingPlan_FlavourPt[i][j]->GetXaxis()->SetTitle("btag_csv");
v2DTaggingPlan_FlavourPt[i][j]->GetYaxis()->SetRangeUser(0.,1.);
v2DTaggingPlan_FlavourPt[i][j]->GetYaxis()->SetLabelOffset(0.005);
v2DTaggingPlan_FlavourPt[i][j]->GetYaxis()->SetLabelFont(42);
v2DTaggingPlan_FlavourPt[i][j]->GetYaxis()->SetLabelSize(0.045);
v2DTaggingPlan_FlavourPt[i][j]->GetYaxis()->SetTitleOffset(1.2);
v2DTaggingPlan_FlavourPt[i][j]->GetYaxis()->SetTitleFont(42);
v2DTaggingPlan_FlavourPt[i][j]->GetYaxis()->SetTitleSize(0.04);
v2DTaggingPlan_FlavourPt[i][j]->GetYaxis()->SetTitle("QG_likelihood");
v2DTaggingPlan_FlavourPt[i][j]->GetZaxis()->SetLabelSize(0.03);
//nameHisto_check = v2DTaggingPlan_FlavourPt[i][j]->GetTitle();
//name2DTaggingPlan_check += nameHisto;
//name2DTaggingPlan_check += ".pdf";
//cLikelihood_vs_csv->SaveAs(name2DTaggingPlan_check.c_str());
cLikelihood_vs_csv->SaveAs(histoName.c_str());
v2DTaggingPlan_FlavourPt_divided[i][j] = (TH2F*)v2DTaggingPlan_FlavourPt[i][j]->Clone(v2DTaggingPlan_FlavourPt[i][j]->GetTitle());
v2DTaggingPlan_FlavourPt_divided[i][j]->Divide(v2DTaggingPlan_FlavourPt[nflavours-1][j]);
name2DTaggingPlan = ("images2DTagging/2DTaggingZones/");
cLikelihood_vs_csv->Clear();
v2DTaggingPlan_FlavourPt_divided[i][j]->Draw("colz");
v2DTaggingPlan_FlavourPt_divided[i][j]->SetStats(0);
v2DTaggingPlan_FlavourPt_divided[i][j]->GetXaxis()->SetRangeUser(0.,1.);
v2DTaggingPlan_FlavourPt_divided[i][j]->GetXaxis()->SetLabelOffset(0.005);
v2DTaggingPlan_FlavourPt_divided[i][j]->GetXaxis()->SetLabelFont(42);
v2DTaggingPlan_FlavourPt_divided[i][j]->GetXaxis()->SetLabelSize(0.045);
v2DTaggingPlan_FlavourPt_divided[i][j]->GetXaxis()->SetTitleOffset(1.15);
v2DTaggingPlan_FlavourPt_divided[i][j]->GetXaxis()->SetTitleSize(0.04);
v2DTaggingPlan_FlavourPt_divided[i][j]->GetXaxis()->SetTitleFont(42);
v2DTaggingPlan_FlavourPt_divided[i][j]->GetXaxis()->SetTitle("btag_csv");
v2DTaggingPlan_FlavourPt_divided[i][j]->GetYaxis()->SetRangeUser(0.,1.);
v2DTaggingPlan_FlavourPt_divided[i][j]->GetYaxis()->SetLabelOffset(0.005);
v2DTaggingPlan_FlavourPt_divided[i][j]->GetYaxis()->SetLabelFont(42);
v2DTaggingPlan_FlavourPt_divided[i][j]->GetYaxis()->SetLabelSize(0.045);
v2DTaggingPlan_FlavourPt_divided[i][j]->GetYaxis()->SetTitleOffset(1.2);
v2DTaggingPlan_FlavourPt_divided[i][j]->GetYaxis()->SetTitleFont(42);
v2DTaggingPlan_FlavourPt_divided[i][j]->GetYaxis()->SetTitleSize(0.04);
v2DTaggingPlan_FlavourPt_divided[i][j]->GetYaxis()->SetTitle("QG_likelihood");
v2DTaggingPlan_FlavourPt_divided[i][j]->GetZaxis()->SetLabelSize(0.03);
nameHisto = v2DTaggingPlan_FlavourPt[i][j]->GetTitle();
name2DTaggingPlan += nameHisto;
name2DTaggingPlan += ".pdf";
cLikelihood_vs_csv->SaveAs(name2DTaggingPlan.c_str());
nameHisto = "";
name2DTaggingPlan = "";
name2DTaggingPlan = ("images2DTagging/2DTaggingZones/");
nameHisto = v2DTaggingPlan_FlavourPt[i][j]->GetTitle();
name2DTaggingPlan += nameHisto;
name2DTaggingPlan += ".C";
cLikelihood_vs_csv->SaveAs(name2DTaggingPlan.c_str());
nameHisto = "";
name2DTaggingPlan = "";
// nameHisto_check = "";
// name2DTaggingPlan_check = "";
histoName = "";
}
}
//*****************************************************************************************************
//
// Jet flavour fraction
//
//*****************************************************************************************************
float Nuds,Ng,Nc,Nb,NnoMatched,Ntot;
std::string nameFraction;
std::string nameHistoFraction;
for(int j=0;j<n2DTaggingPtBins; j++) {
for(int i=0; i<nzones; i++) {
nameFraction = ("images2DTagging/FlavourFractions/");
Nuds = vFlavourNumber[i][0][j];
Ng = vFlavourNumber[i][1][j];
Nc = vFlavourNumber[i][2][j];
Nb = vFlavourNumber[i][3][j];
NnoMatched = vFlavourNumber[i][4][j];
Ntot = vFlavourNumber[i][5][j];
//Ntot = vFlavourNumber[i][0][j]+vFlavourNumber[i][1][j]+vFlavourNumber[i][2][j]+vFlavourNumber[i][3][j];
nameHistoFraction = vFractionHisto_Pt[j]->GetName();
nameFraction += nameHistoFraction ;
nameFraction += ".pdf";
computeFlavourRatio(Nuds, Ng, Nc, Nb, NnoMatched, Ntot,vFractionHisto_Pt[j], nameFraction, my2DTaggingPtBinning, i, j);
nameFraction = "";
nameHistoFraction = "";
}
}
for(int j=0;j<n2DTaggingPtBins; j++) {
for(int i=0; i<nzones; i++) {
Nuds = vFlavourNumber[i][0][j];
Ng = vFlavourNumber[i][1][j];
Nc = vFlavourNumber[i][2][j];
Nb = vFlavourNumber[i][3][j];
NnoMatched = vFlavourNumber[i][4][j];
Ntot = vFlavourNumber[i][5][j];
printLatexTableFlavourRatio(Nuds, Ng, Nc, Nb, NnoMatched, Ntot,vFractionHisto_Pt[j], nameFraction, my2DTaggingPtBinning, i, j);
}
}
for(int k=0; k<n2DTaggingPtBins; k++) {
for(int j=0; j<nflavours ; j++) {
for(int i=0; i<nzones; i++) {
vFlavourFraction[i][j][k] = vFlavourNumber[i][j][k];
}
}
}
cout<<""<<endl<<endl;
for(int k=0; k<n2DTaggingPtBins; k++) {
for(int j=0; j<nflavours ; j++) {
for(int i=0; i<nzones; i++) {
//Ntot = vFlavourNumber[i][0][k]+vFlavourNumber[i][1][k]+vFlavourNumber[i][2][k]+vFlavourNumber[i][3][k];
//vFlavourFraction[i][j][k] = vFlavourFraction[i][j][k]/Ntot;
vFlavourFraction[i][j][k] = vFlavourFraction[i][j][k]/vFlavourFraction[i][nflavours-1][k];
cout<<"vFlavourFraction["<<i<<"]["<<j<<"]["<<k<<"] : "<<vFlavourFraction[i][j][k]*100.<<" %"<<endl;
}
}
}
//**********************************************************************************************************
//
// filling the matrix with the flavour fractions per zone
//
//**********************************************************************************************************
cout<<""<<endl<<endl;
//filling the matrices
for(int k=0; k<n2DTaggingPtBins; k++) {
for(int j=0; j<nflavours-2; j++) {
for(int i=0; i<nzones-2; i++) {
v4x4MatrixPt[k](i,j) = vFlavourFraction[i][j][k];
cout<<"v4x4MatrixPt["<<k<<"]("<<i<<","<<j<<") : "<<v4x4MatrixPt[k](i,j)*100.<<" %"<<endl;
}
}
}
cout<<""<<endl<<endl;
for(int k=0; k<n2DTaggingPtBins; k++) {
for(int j=0; j<nflavours-2; j++) {
for(int i=0; i<nzones; i++) {
v6x4MatrixPt[k](i,j) = vFlavourFraction[i][j][k];
cout<<"v6x4MatrixPt["<<k<<"]("<<i<<","<<j<<") : "<<v6x4MatrixPt[k](i,j)*100.<<" %"<<endl;
}
}
}
//write into the output matrix rootfile
TFile *out_matrix = new TFile("output_rootfile/outputMatrix2DTagging_MC_G.root", "recreate");
// TFile *out_matrix = new TFile("output_rootfile/outputMatrix2DTagging_MC_TOT.root", "recreate");
// TFile *out_matrix = new TFile("output_rootfile/outputMatrix2DTagging_MC_QCD.root", "recreate");
out_matrix->cd();
TDirectory *matrixDir = out_matrix->mkdir("matrix","matrix");
matrixDir->cd();
for(int k=0; k<n2DTaggingPtBins; k++) {
string matrix6x4Name;
string matrix4x4Name;
matrix6x4Name = "matrix6x4_" + my2DTaggingPtBinning.getName(k);
matrix4x4Name = "matrix4x4_" + my2DTaggingPtBinning.getName(k);
v6x4MatrixPt[k].Write(matrix6x4Name.c_str());
v4x4MatrixPt[k].Write(matrix4x4Name.c_str());
}
out_matrix->Close();
//*****************************************************************************************************
//
// Output file
//
//*****************************************************************************************************
//TFile *out_mikko = new TFile("output_rootfile/output2DTagging_MC_G_forMikko_L5Corr_physics.root", "recreate");
//TFile *out_mikko = new TFile("output_rootfile/output2DTagging_MC_QCD_forMikko_L5Corr_physics.root", "recreate");
TFile *out_mikko = new TFile("output_rootfile/output2DTagging_MC_TOT_forMikko_L5Corr_physics.root", "recreate");
out_mikko->cd();
TDirectory *firstJetPtPtDir = out_mikko->mkdir("firstJetPtPerZonePerFlavour","firstJetPtPerZonePerFlavour");
firstJetPtPtDir->cd();
for(int k=0; k<nflavours; k++) {
for(int l=0; l<nzones; l++) {
vFirstJetPt_ZoneFlavour[l][k]->Write();
}
}
/* TDirectory *response_Zone_FlavourDir = out_mikko->mkdir("response_perZone_perFlavour","response_perZone_perFlavour");*/
//TDirectory *Rmpf_Zone_FavourDir = response_Zone_FlavourDir->mkdir("Rmpf","Rmpf");
//Rmpf_Zone_FavourDir->cd();
//for(int k=0; k<nflavours; k++) {
//for(int l=0; l<nzones; l++) {
//vRmpf_ZoneFlavourPt[l][k][n2DTaggingPtBins-1]->Write();
//}
//}
//TDirectory *Rtrue_Zone_FavourDir = response_Zone_FlavourDir->mkdir("Rtrue","Rtrue");
//Rtrue_Zone_FavourDir->cd();
//for(int k=0; k<nflavours; k++) {
//for(int l=0; l<nzones; l++) {
//vRtrue_ZoneFlavourPt[l][k][n2DTaggingPtBins-1]->Write();
//}
//}
//TDirectory *response_Zone_PtDir_mikko = out_mikko->mkdir("response_perZone","response_perZone");
//TDirectory *Rmpf_Zone_PtDir_mikko = response_Zone_PtDir_mikko->mkdir("Rmpf","Rmpf");
//Rmpf_Zone_PtDir_mikko->cd();
//for(int i=0; i<nzones; i++) {
//vRmpf_ZonePt[i][n2DTaggingPtBins-1]->Write();
/*}*/
out_mikko->Close();
//write into the output file
//TFile *out = new TFile("output_rootfile/output2DTagging_MC_G_physics.root", "recreate");
TFile *out = new TFile("output_rootfile/output2DTagging_MC_TOT_physics.root", "recreate");
//TFile *out = new TFile("output_rootfile/output2DTagging_MC_QCD_physics.root", "recreate");
out->cd();
TDirectory *response_Zone_PtDir = out->mkdir("response_Zone_Pt","response_Zone_Pt");
TDirectory *Rmpf_Zone_PtDir = response_Zone_PtDir->mkdir("Rmpf","Rmpf");
Rmpf_Zone_PtDir->cd();
for(int j=0; j<n2DTaggingPtBins; j++) {
for(int i=0; i<nzones; i++) {
vRmpf_ZonePt[i][j]->Write();
}
}
TDirectory *Rtrue_Zone_PtDir = response_Zone_PtDir->mkdir("Rtrue","Rtrue");
Rtrue_Zone_PtDir->cd();
for(int j=0; j<n2DTaggingPtBins; j++) {
for(int i=0; i<nzones; i++) {
vRtrue_ZonePt[i][j]->Write();
}
}
TDirectory *response_Flavour_PtDir = out->mkdir("response_Flavour_Pt","response_Flavour_Pt");
TDirectory *Rmpf_Flavour_PtDir = response_Flavour_PtDir->mkdir("Rmpf","Rmpf");
Rmpf_Flavour_PtDir->cd();
for(int j=0; j<n2DTaggingPtBins; j++) {
for(int k=0; k<nflavours; k++) {
vRmpf_FlavourPt[k][j]->Write();
vRmpf_in2DTaggingZone_FlavourPt[k][j]->Write();
}
}
TDirectory *Rtrue_Flavour_PtDir = response_Flavour_PtDir->mkdir("Rtrue","Rtrue");
Rtrue_Flavour_PtDir->cd();
for(int j=0; j<n2DTaggingPtBins; j++) {
for(int k=0; k<nflavours; k++) {
vRtrue_FlavourPt[k][j]->Write();
vRtrue_in2DTaggingZone_FlavourPt[k][j]->Write();
}
}
TDirectory *response_Zone_Flavour_PtDir = out->mkdir("response_Zone_Flavour_Pt","response_Zone_Flavour_Pt");
TDirectory *Rmpf_Zone_Flavour_PtDir = response_Zone_Flavour_PtDir->mkdir("Rmpf","Rmpf");
Rmpf_Zone_Flavour_PtDir->cd();
for(int j=0; j<n2DTaggingPtBins; j++) {
for(int k=0; k<nflavours; k++) {
for(int l=0; l<nzones; l++) {
vRmpf_ZoneFlavourPt[l][k][j]->Write();
}
}
}
TDirectory *Rtrue_Zone_Flavour_PtDir = response_Zone_Flavour_PtDir->mkdir("Rtrue","Rtrue");
Rtrue_Zone_Flavour_PtDir->cd();
for(int j=0; j<n2DTaggingPtBins; j++) {
for(int k=0; k<nflavours; k++) {
for(int l=0; l<nzones; l++) {
vRtrue_ZoneFlavourPt[l][k][j]->Write();
}
}
}
TDirectory *tagger_Flavour_PtDir = out->mkdir("tagger_Flavour_Pt","tagger_Flavour_Pt");
TDirectory *CSV_Flavour_PtDir = tagger_Flavour_PtDir->mkdir("CSV","CSV");
CSV_Flavour_PtDir->cd();
for(int j=0; j<n2DTaggingPtBins; j++) {
for(int k=0; k<nflavours; k++) {
vCSV_FlavourPt[k][j]->Write();
}
}
TDirectory *QGL_Flavour_PtDir = tagger_Flavour_PtDir->mkdir("QGL","QGL");
QGL_Flavour_PtDir->cd();
for(int j=0; j<n2DTaggingPtBins; j++) {
for(int k=0; k<nflavours; k++) {
vQGL_FlavourPt[k][j]->Write();
}
}
TDirectory *gammapt_FlavourDir = out->mkdir("gammapt_Flavour","gammapt_Flavour");
gammapt_FlavourDir->cd();
for(int k=0; k<nflavours; k++) {
vGammapt_Flavour[k]->Write();
}
TDirectory *variablesDir = out->mkdir("variables","variables");
variablesDir->cd();
hGammaPt->Write();
hFirstJetPt->Write();
hSecondJetPt->Write();
hMetPt->Write();
hParalleleMetPt->Write();
hPerpendicularMetPt->Write();
hAlpha->Write();
hDeltaPhi_j1gamma->Write();
hDeltaPhi_j2gamma->Write();
hDeltaPhi_j1j2->Write();
hDeltaR_j1gamma->Write();
hDeltaR_j2gamma->Write();
hDeltaR_j1j2->Write();
TDirectory *gammaPtDir = variablesDir->mkdir("gammaPtPerZonePerFlavour","gammaPtPerZonePerFlavour");
gammaPtDir->cd();
for(int k=0; k<nflavours; k++) {
for(int l=0; l<nzones; l++) {
vGammaPt_ZoneFlavour[l][k]->Write();
}
}
TDirectory *plan2DTaggingDir = out->mkdir("plan2DTagging","plan2DTagging");
plan2DTaggingDir->cd();
for(int j=0; j<n2DTaggingPtBins; j++) {
for(int i=0; i<nflavours; i++) {//divide flavour distri by total distri
v2DTaggingPlan_FlavourPt[i][j]->Write();
v2DTaggingPlan_FlavourPt_divided[i][j]->Write();
}
}
out->Close();
return 0;
}
int InputForLimits(){
TH1::SetDefaultSumw2(true);
if(pcp)cout<<"going to set inputs"<<endl;
Int_t NBR = 3;
Float_t BR[] = { 1., 0.75, 0.5};
TFile* bkgFile = new TFile( "../../BkgPrediction/BkgPrediction.root", "READ");
TTree* bkgTree;
bkgFile->GetObject( "ElAndMu", bkgTree);
Float_t bkg = 0.;
Float_t bkgTotUnc = 0.;
Float_t obs = 0.;
bkgTree->SetBranchAddress( "srData", &obs);
bkgTree->SetBranchAddress( "srAllBkgCorr", &bkg);
bkgTree->SetBranchAddress( "TotUnc", &bkgTotUnc);
TFile* sigFile = new TFile( "../../SignalSystematics/SignalSys.root", "READ");
std::vector<std::vector<TString> > sysColl;
std::vector<TString> sys;
sys.push_back(TString("JES_Up"));
sys.push_back(TString("JES_Down"));
sysColl.push_back(sys);
sys.clear();
sys.push_back(TString("BTagReweight_UpBC"));
sys.push_back(TString("BTagReweight_DownBC"));
sysColl.push_back(sys);
sys.clear();
sys.push_back(TString("BTagReweight_UpLight"));
sys.push_back(TString("BTagReweight_DownLight"));
sysColl.push_back(sys);
std::vector<TString> decayMode;
decayMode.push_back(TString("tt"));
decayMode.push_back(TString("tb"));
decayMode.push_back(TString("bb"));
Systematics* systematics[3];
TString dirname;
TString histoname;
TDirectory* srDir;
TDirectory* histoDir;
TFile* outFile = new TFile( "InputForLimits.root", "RECREATE");
TDirectory* outBRDir;
TDirectory* outSRDir;
TH1F* datah = new TH1F( "data", "data", 1, 0., 1.);
TH1F* bkgh = new TH1F( "bkg", "bkg", 1, 0., 1.);
TH2F* sigh;
TH2F* sig_toth;
TH2F* effh;
TH2F* sigLh;
TH2F* effLh;
TH2F* sigRh;
TH2F* effRh;
TH2F* jesh;
TH2F* btagBCh;
TH2F* btagLighth;
TH2F* btagh;
TH2F* sysh;
TH2F* unch;
TH2F* jesPercenth;
TH2F* btagBCPercenth;
TH2F* btagLightPercenth;
TH2F* btagPercenth;
TH2F* sysPercenth;
TH2F* uncPercenth;
Float_t sig = 0.;
Float_t stat = 0.;
Float_t jes = 0.;
Float_t bc = 0.;
Float_t light = 0.;
Float_t unc = 0.;
int N = bkgTree->GetEntries();
for ( int ibr = 0; ibr < NBR; ibr++){
dirname = ""; dirname += BR[ibr];
outFile->mkdir(dirname);
outBRDir = outFile->GetDirectory(dirname);
for ( int iSR = 0; iSR < 9; iSR++){
bkgTree->GetEntry(iSR);
datah->SetBinContent( 1, obs);
bkgh->SetBinContent( 1, bkg);
bkgh->SetBinError( 1, bkgTotUnc);
dirname = ""; dirname += iSR;
outBRDir->mkdir(dirname);
outSRDir = outBRDir->GetDirectory(dirname);
dirname = ""; dirname += iSR; dirname += ".root";
srDir = sigFile->GetDirectory( dirname);
for ( int isys = 0; isys < (int) sysColl.size(); isys++){
systematics[isys] = new Systematics();
systematics[isys]->BR = BR[ibr];
histoDir = srDir->GetDirectory( "NoSystematic");
for ( int idecay = 0; idecay < (int) decayMode.size(); idecay++){
histoDir->GetObject( decayMode.at(idecay), systematics[isys]->h[idecay]);
histoDir->GetObject( decayMode.at(idecay) + "l", systematics[isys]->Lh);
histoDir->GetObject( decayMode.at(idecay) + "r", systematics[isys]->Rh);
}
histoDir->GetObject( decayMode.at(0) + "l", systematics[isys]->Lh);
histoDir->GetObject( decayMode.at(0) + "r", systematics[isys]->Rh);
histoDir->GetObject( "sig_tot", systematics[isys]->sig_toth);
for ( int ishift = 0; ishift < 2; ishift++){
histoDir = srDir->GetDirectory(sysColl.at(isys).at(ishift));
for ( int idecay = 0; idecay < (int) decayMode.size(); idecay++){
histoDir->GetObject( decayMode.at(idecay), systematics[isys]->shifth[ishift][idecay]);
}
}
systematics[isys]->Calc();
}
sig_toth = new TH2F( *systematics[0]->sig_toth);
sig_toth->SetName("sig_tot");
sig_toth->SetTitle("sig_tot");
sigh = new TH2F( *systematics[0]->sigh);
sigh->SetName("sig");
sigh->SetTitle("sig");
effh = new TH2F( *systematics[0]->effh);
effh->SetName("eff");
effh->SetTitle("eff");
sigLh = new TH2F( *systematics[0]->sigRh);
sigLh->SetName("sigL");
sigLh->SetTitle("sigL");
effLh = new TH2F( *systematics[0]->effLh);
effLh->SetName("effL");
effLh->SetTitle("effL");
sigRh = new TH2F( *systematics[0]->sigRh);
sigRh->SetName("sigR");
sigRh->SetTitle("sigR");
effRh = new TH2F( *systematics[0]->effRh);
effRh->SetName("effR");
effRh->SetTitle("effR");
jesh = new TH2F( *systematics[0]->sysh);
jesh->SetName("jes");
jesh->SetTitle("jes");
btagBCh = new TH2F( *systematics[1]->sysh);
btagBCh->SetName("btagBC");
btagBCh->SetTitle("btagBC");
btagLighth = new TH2F( *systematics[2]->sysh);
btagLighth->SetName("btagLight");
btagLighth->SetTitle("btagLight");
btagh = new TH2F( *btagBCh);
btagh->Reset();
btagh->SetName("btag");
btagh->SetTitle("btag");
sysh = new TH2F( *jesh);
sysh->Reset();
sysh->SetName("sys");
sysh->SetTitle("sys");
unch = new TH2F( *jesh);
unch->Reset();
unch->SetName("unc");
unch->SetTitle("unc");
jesPercenth = new TH2F( *systematics[0]->sysh);
jesPercenth->SetName("jesPercent");
jesPercenth->SetTitle("jesPercent");
jesPercenth->Divide( sigh);
jesPercenth->Scale( 100.);
btagBCPercenth = new TH2F( *systematics[1]->sysh);
btagBCPercenth->SetName("btagBCPercent");
btagBCPercenth->SetTitle("btagBCPercent");
btagBCPercenth->Divide( sigh);
btagBCPercenth->Scale( 100.);
btagLightPercenth = new TH2F( *systematics[2]->sysh);
btagLightPercenth->SetName("btagLightPercent");
btagLightPercenth->SetTitle("btagLightPercent");
btagLightPercenth->Divide( sigh);
btagLightPercenth->Scale( 100.);
btagPercenth = new TH2F( *btagBCh);
btagPercenth->Reset();
btagPercenth->SetName("btagPercent");
btagPercenth->SetTitle("btagPercent");
sysPercenth = new TH2F( *jesh);
sysPercenth->Reset();
sysPercenth->SetName("sysPercent");
sysPercenth->SetTitle("sysPercent");
uncPercenth = new TH2F( *jesh);
uncPercenth->Reset();
uncPercenth->SetName("uncPercent");
uncPercenth->SetTitle("uncPercent");
for (int ibin = 0; ibin < sigh->GetSize(); ibin++){
sig = sigh->GetBinContent( ibin);
stat = sigh->GetBinError( ibin);
jes = jesh->GetBinContent(ibin);
bc = btagBCh->GetBinContent(ibin);
light = btagLighth->GetBinContent(ibin);
unc = sqrt( bc * bc + light * light);
btagh->SetBinContent( ibin, unc);
btagPercenth->SetBinContent( ibin, unc / sig * 100.);
unc = sqrt( jes * jes + bc * bc + light * light +
sig * sig * (0.044 * 0.044 + // Lumi
0.03 * 0.03 + // Trigger
0.05 * 0.05 // Lep Id
)
);
sysh->SetBinContent( ibin, unc);
sysPercenth->SetBinContent( ibin, unc / sig * 100.);
unc = sqrt( jes * jes + bc * bc + light * light + stat * stat +
sig * sig * (0.044 * 0.044 + // Lumi
0.03 * 0.03 + // Trigger
0.05 * 0.05 // Lep Id
)
);
unch->SetBinContent( ibin, unc);
uncPercenth->SetBinContent( ibin, unc / sig * 100.);
}
outSRDir->cd();
datah->Write();
bkgh->Write();
sig_toth->Write();
sigh->Write();
effh->Write();
sigLh->Write();
effLh->Write();
sigRh->Write();
effRh->Write();
jesh->Write();
btagBCh->Write();
btagLighth->Write();
btagh->Write();
sysh->Write();
unch->Write();
jesPercenth->Write();
btagBCPercenth->Write();
btagLightPercenth->Write();
btagPercenth->Write();
sysPercenth->Write();
uncPercenth->Write();
}
}
delete systematics[0];
delete systematics[1];
delete systematics[2];
outFile->Close();
sigFile->Close();
bkgFile->Close();
return 0;
}
///
///________________________________________________________________________________
///
UEJetAreaHistograms::UEJetAreaHistograms( const char* fileName, string *triggerNames )
{
// cout << "UEJetAreaHistograms::UEJetAreaHistograms( const char* fileName, string *triggerNames )" << endl;
///
/// Constructor for histogram filler.
///
char buffer[200];
cout << "[UEJetAreaHistograms] Create file " << fileName << endl;
file = TFile::Open( fileName, "recreate" );
TDirectory* dir = file->mkdir( "UEJetArea" );
subdir = new TDirectory*[12];
///
/// Reserve space for histograms.
///
h_pTAllJets = new TH1D*[12]; // all jets
h_etaAllJets = new TH1D*[12];
h_areaAllJets = new TH1D*[12];
h_ptByAreaAllJets = new TH1D*[12];
h_nConstituentsAllJets = new TH1D*[12];
h2d_pTAllJets_vs_pTjet = new TH2D*[12];
h2d_areaAllJets_vs_pTjet = new TH2D*[12];
h2d_ptByAreaAllJets_vs_pTjet = new TH2D*[12];
h2d_nConstituentsAllJets_vs_pTjet = new TH2D*[12];
h_pTJet = new TH1D*[12]; // leading jet
h_etaJet = new TH1D*[12];
h_areaJet = new TH1D*[12];
h_ptByAreaJet = new TH1D*[12];
h_nConstituentsJet = new TH1D*[12];
h2d_areaJet_vs_pTjet = new TH2D*[12];
h2d_ptByAreaJet_vs_pTjet = new TH2D*[12];
h2d_nConstituentsJet_vs_pTjet = new TH2D*[12];
h_medianPt = new TH1D*[12]; // event-by-event medians
h_medianArea = new TH1D*[12];
h_medianPtByArea = new TH1D*[12];
h2d_medianPt_vs_pTjet = new TH2D*[12];
h2d_medianArea_vs_pTjet = new TH2D*[12];
h2d_medianPtByArea_vs_pTjet = new TH2D*[12];
///
/// 11 HLT bits :
/// 4 Min-Bias (Pixel, Hcal, Ecal, general), Zero-Bias, 6 Jet (30, 50, 80, 110, 180, 250)
///
unsigned int iHLTbit(0);
for ( ; iHLTbit<11; ++iHLTbit )
{
HLTBitNames[iHLTbit] = triggerNames[iHLTbit];
subdir[iHLTbit] = dir->mkdir( triggerNames[iHLTbit].c_str() );
sprintf ( buffer, "UEJetArea/%s", triggerNames[iHLTbit].c_str() );
file->cd( buffer );
///
/// Initialize histograms.
///
h_pTJet [iHLTbit] = new TH1D("h_pTJet" , "h_pTJet;p_{T}(leading jet) (GeV/c);", 300, 0., 600. );
h_pTAllJets[iHLTbit] = new TH1D("h_pTAllJets", "h_pTAllJets;p_{T}(jet) (GeV/c);" , 300, 0., 600. );
h_etaJet [iHLTbit] = new TH1D("h_etaJet" , "h_etaJet;#eta(leading jet);", 100, -2., 2. );
h_etaAllJets[iHLTbit] = new TH1D("h_etaAllJets", "h_etaAllJets;#eta(jet);" , 100, -2., 2. );
h_areaJet [iHLTbit] = new TH1D("h_areaJet" , "h_areaJet;Leading jet area A;", 100, 0., 2. );
h_areaAllJets[iHLTbit] = new TH1D("h_areaAllJets", "h_areaAllJets;Jet area A;" , 100, 0., 2. );
h_ptByAreaJet [iHLTbit] = new TH1D("h_ptByAreaJet" , "h_ptByAreaJet;Leading jet p_{T}/A;", 1000, 0., 200. );
h_ptByAreaAllJets[iHLTbit] = new TH1D("h_ptByAreaAllJets", "h_ptByAreaAllJets;Jet p_{T}/A;" , 1000, 0., 200. );
h_nConstituentsJet [iHLTbit] = new TH1D("h_nConstituentsJet" ,
"h_nConstituentsJet;N(leading jet constituents);", 50, 0.5, 50.5 );
h_nConstituentsAllJets[iHLTbit] = new TH1D("h_nConstituentsAllJets",
"h_nConstituentsAllJets;N(jet constituents);" , 50, 0.5, 50.5 );
h2d_pTAllJets_vs_pTjet[iHLTbit] = new TH2D( "h2d_pTAllJets_vs_pTjet",
"h2d_pTAllJets_vs_pTjet;p_{T}(leading jet) (GeV/c);p_{T}(jet) (GeV/c)",
300, 0., 600., 300, 0., 600. );
h2d_areaJet_vs_pTjet [iHLTbit]
= new TH2D("h2d_areaJet_vs_pTjet",
"h2d_areaJet_vs_pTjet;p_{T}(leading jet) (GeV/c);Leading Jet area A /rad", 300, 0., 600., 100, 0., 2. );
h2d_areaAllJets_vs_pTjet[iHLTbit]
= new TH2D("h2d_areaAllJets_vs_pTjet",
"h2d_areaAllJets_vs_pTjet;p_{T}(leading jet) (GeV/c);Jet area A /rad", 300, 0., 600., 100, 0., 2. );
h2d_ptByAreaJet_vs_pTjet [iHLTbit] =
new TH2D("h2d_ptByAreaJet_vs_pTjet",
"h2d_ptByAreaJet_vs_pTjet;p_{T}(leading jet) (GeV/c);Leading Jet p_{T}/A (GeV/c rad^{-1})", 300, 0., 600., 1000, 0., 200. );
h2d_ptByAreaAllJets_vs_pTjet[iHLTbit]
= new TH2D("h2d_ptByAreaAllJets_vs_pTjet",
"h2d_ptByAreaAllJets_vs_pTjet;p_{T}(leading jet) (GeV/c);Jet area p_{T}/A (GeV/c rad^{-1})", 300, 0., 600., 1000, 0., 200. );
h2d_nConstituentsJet_vs_pTjet[iHLTbit]
= new TH2D("h2d_nConstituentsJet_vs_pTjet",
"h2d_nConstituentsJet_vs_pTjet;p_{T}(leading jet) (GeV/c);N(leading jet constituents)",
300, 0., 600., 50, 0.5, 50.5 );
h2d_nConstituentsAllJets_vs_pTjet[iHLTbit]
= new TH2D("h2d_nConstituentsAllJets_vs_pTjet",
"h2d_nConstituentsAllJets_vs_pTjet;p_{T}(leading jet) (GeV/c);N(jet constituents)",
300, 0., 600., 50, 0.5, 50.5 );
h_medianPt [iHLTbit] = new TH1D("h_medianPt" , "h_medianPt;#mu_{1/2}({p_{Ti}}) (GeV/c);", 300, 0., 600. );
h_medianArea [iHLTbit] = new TH1D("h_medianArea", "h_medianArea;#mu_{1/2}({A_{Ti}}) (rad);", 100, 0., 2. );
h_medianPtByArea[iHLTbit] = new TH1D("h_medianPtByArea",
"h_medianPtByArea;#mu_{1/2}({p_{Ti}/A_{i}}) (GeV/c rad^{-1});",
1000, 0., 200. );
h2d_medianPt_vs_pTjet[iHLTbit] =
new TH2D("h2d_medianPt_vs_pTjet",
"h2d_medianPt_vs_pTjet;p_{T}(leading jet) (GeV/c);#mu_{1/2}({p_{Ti}}) (GeV/c)", 300, 0., 600., 300, 0., 600. );
h2d_medianArea_vs_pTjet[iHLTbit] =
new TH2D("h2d_medianArea_vs_pTjet",
"h2d_medianArea_vs_pTjet;p_{T}(leading jet) (GeV/c);#mu_{1/2}({A_{Ti}}) (rad)", 300, 0., 600., 100, 0., 2. );
h2d_medianPtByArea_vs_pTjet[iHLTbit]
= new TH2D("h2d_medianPtByArea_vs_pTjet",
"h2d_medianPtByArea_vs_pTjet;p_{T}(leading jet) (GeV/c);#mu_{1/2}({p_{Ti}/A_{i}}) (GeV/c rad^{-1})",
300, 0., 600., 100, 0., 20. );
}
///
/// Hadron level
///
iHLTbit = 11;
subdir[iHLTbit] = dir->mkdir( "Gen" );
file->cd( "UEJetArea/Gen" );
h_pTJet [iHLTbit] = new TH1D("h_pTJet" , "h_pTJet;p_{T}(leading jet) (GeV/c);", 300, 0., 600. );
h_pTAllJets[iHLTbit] = new TH1D("h_pTAllJets", "h_pTAllJets;p_{T}(jet) (GeV/c);" , 300, 0., 600. );
h_etaJet [iHLTbit] = new TH1D("h_etaJet" , "h_etaJet;#eta(leading jet);", 100, -2., 2. );
h_etaAllJets[iHLTbit] = new TH1D("h_etaAllJets", "h_etaAllJets;#eta(jet);" , 100, -2., 2. );
h_areaJet [iHLTbit] = new TH1D("h_areaJet" , "h_areaJet;Leading jet area A;", 100, 0., 2. );
h_areaAllJets[iHLTbit] = new TH1D("h_areaAllJets", "h_areaAllJets;Jet area A;" , 100, 0., 2. );
h_ptByAreaJet [iHLTbit] = new TH1D("h_ptByAreaJet" , "h_ptByAreaJet;Leading jet p_{T}/A;", 1000, 0., 200. );
h_ptByAreaAllJets[iHLTbit] = new TH1D("h_ptByAreaAllJets", "h_ptByAreaAllJets;Jet p_{T}/A;" , 1000, 0., 200. );
h_nConstituentsJet [iHLTbit] = new TH1D("h_nConstituentsJet" ,
"h_nConstituentsJet;N(leading jet constituents);", 50, 0.5, 50.5 );
h_nConstituentsAllJets[iHLTbit] = new TH1D("h_nConstituentsAllJets",
"h_nConstituentsAllJets;N(jet constituents);" , 50, 0.5, 50.5 );
h2d_pTAllJets_vs_pTjet[iHLTbit] = new TH2D( "h2d_pTAllJets_vs_pTjet",
"h2d_pTAllJets_vs_pTjet;p_{T}(leading jet) (GeV/c);p_{T}(jet) (GeV/c)",
300, 0., 600., 300, 0., 600. );
h2d_areaJet_vs_pTjet [iHLTbit]
= new TH2D("h2d_areaJet_vs_pTjet",
"h2d_areaJet_vs_pTjet;p_{T}(leading jet) (GeV/c);Leading Jet area A /rad", 300, 0., 600., 100, 0., 2. );
h2d_areaAllJets_vs_pTjet[iHLTbit]
= new TH2D("h2d_areaAllJets_vs_pTjet",
"h2d_areaAllJets_vs_pTjet;p_{T}(leading jet) (GeV/c);Jet area A /rad", 300, 0., 600., 100, 0., 2. );
h2d_ptByAreaJet_vs_pTjet [iHLTbit] =
new TH2D("h2d_ptByAreaJet_vs_pTjet",
"h2d_ptByAreaJet_vs_pTjet;p_{T}(leading jet) (GeV/c);Leading Jet p_{T}/A (GeV/c rad^{-1})", 300, 0., 600., 1000, 0., 200. );
h2d_ptByAreaAllJets_vs_pTjet[iHLTbit]
= new TH2D("h2d_ptByAreaAllJets_vs_pTjet",
"h2d_ptByAreaAllJets_vs_pTjet;p_{T}(leading jet) (GeV/c);Jet area p_{T}/A (GeV/c rad^{-1})", 300, 0., 600., 1000, 0., 200. );
h2d_nConstituentsJet_vs_pTjet[iHLTbit]
= new TH2D("h2d_nConstituentsJet_vs_pTjet",
"h2d_nConstituentsJet_vs_pTjet;p_{T}(leading jet) (GeV/c);N(leading jet constituents)",
300, 0., 600., 50, 0.5, 50.5 );
h2d_nConstituentsAllJets_vs_pTjet[iHLTbit]
= new TH2D("h2d_nConstituentsAllJets_vs_pTjet",
"h2d_nConstituentsAllJets_vs_pTjet;p_{T}(leading jet) (GeV/c);N(jet constituents)",
300, 0., 600., 50, 0.5, 50.5 );
h_medianPt [iHLTbit] = new TH1D("h_medianPt" , "h_medianPt;#mu_{1/2}({p_{Ti}}) (GeV/c);", 300, 0., 600. );
h_medianArea [iHLTbit] = new TH1D("h_medianArea", "h_medianArea;#mu_{1/2}({A_{Ti}}) (rad);", 100, 0., 2. );
h_medianPtByArea[iHLTbit] = new TH1D("h_medianPtByArea",
"h_medianPtByArea;#mu_{1/2}({p_{Ti}/A_{i}}) (GeV/c rad^{-1});",
1000, 0., 200. );
h2d_medianPt_vs_pTjet[iHLTbit] =
new TH2D("h2d_medianPt_vs_pTjet",
"h2d_medianPt_vs_pTjet;p_{T}(leading jet) (GeV/c);#mu_{1/2}({p_{Ti}}) (GeV/c)", 300, 0., 600., 300, 0., 600. );
h2d_medianArea_vs_pTjet[iHLTbit] =
new TH2D("h2d_medianArea_vs_pTjet",
"h2d_medianArea_vs_pTjet;p_{T}(leading jet) (GeV/c);#mu_{1/2}({A_{Ti}}) (rad)", 300, 0., 600., 100, 0., 2. );
h2d_medianPtByArea_vs_pTjet[iHLTbit]
= new TH2D("h2d_medianPtByArea_vs_pTjet",
"h2d_medianPtByArea_vs_pTjet;p_{T}(leading jet) (GeV/c);#mu_{1/2}({p_{Ti}/A_{i}}) (GeV/c rad^{-1})",
300, 0., 600., 100, 0., 20. );
}
mainClass(int luminosity){//constructor
//Importnat
//make sure this initialization of the
//maps is the same as that in main.cpp
cutname[0]="RA2nocut";
cutname[1]="RA2Asys";
cutname[2]="RA2Inc3Jetcut";
cutname[3]="RA2HT500cut";
cutname[4]="RA2MHT200cut";
cutname[5]="RA2delphicut";
cutname[6]="RA2noleptoncut";
cutname[7]="noPhotoncut";
cutname[8]="RA2Inc4Jetcut";
cutname[9]="RA2Inc5Jetcut";
cutname[10]="RA2Inc6Jetcut";
cutname[11]="RA2allbutHT2500cut";
cutname[12]="RA2allbutMHT1000cut";
cutname[13]="RA2allcut";
cutname[14]="RA2noleptoncutMHT1000";
cutname[15]="RA2noleptoncutBtag2";
cutname[16]="RA2noleptoncutBtag2MHT1000";
cutname[17]="RA2Inc4JetcutMHT1000";
cutname[18]="RA2Inc4JetcutBtag2";
cutname[19]="RA2Inc4JetcutBtag2MHT1000";
cutname[20]="RA2Inc5JetcutMHT1000";
cutname[21]="RA2Inc5JetcutBtag2";
cutname[22]="RA2Inc5JetcutBtag2MHT1000";
cutname[23]="RA2Inc6JetcutMHT1000";
cutname[24]="RA2Inc6JetcutBtag2";
cutname[25]="RA2Inc6JetcutBtag2MHT1000";
sigtype[0]="allEvents";
sigtype[1]="glgl";
BJtype[0]="allEvents";
BJtype[1]="W";
BJtype[2]="Wlv";
BJtype[3]="Wjj";
BJtype[4]="Z";
BJtype[5]="Zll";
BJtype[6]="Zvv";
BJtype[7]="Zjj";
BJtype[8]="photon";
BJtype[9]="H";
TTtype[0]="allEvents";
TTtype[1]="TTbar";
TTtype[2]="TTSingLep";
TTtype[3]="TTdiLep";
TTtype[4]="TThadronic";
//KH
histname[0]="weight";
histname[1]="HT";
histname[2]="MHT";
histname[3]="NJet";
histname[4]="NBtagLoose";
histname[5]="NBtagTight";
histname[6]="BtagLoose1Pt";
histname[7]="BtagLoose1Eta";
histname[8]="BtagLoose1Phi";
histname[9]="BtagLoose2Pt";
histname[10]="BtagLoose2Eta";
histname[11]="BtagLoose2Phi";
histname[12]="BtagTight1Pt";
histname[13]="BtagTight1Eta";
histname[14]="BtagTight1Phi";
histname[15]="BtagTight2Pt";
histname[16]="BtagTight2Eta";
histname[17]="BtagTight2Phi";
///end of initialization of the maps
yieldmap.clear();
//Signal Section//Signal Section//Signal Section//Signal Section//Signal Section//Signal Section//Signal Section//Signal Section
//build a vector of scale factors
//first load the cross sections into a vector
//Sig_xs_vec.push_back(0.757); /// v1
//Sig_xs_vec.push_back(1.12); // v2
//Sig_xs_vec.push_back(1.15); // v3
//Sig_xs_vec.push_back(1.14); // M(Stop,LSP)=(450,410) and also M(Stop,LSP)=(450,440)
//Sig_xs_vec.push_back(2.18); // M(Stop,LSP)=(400,390) and also M(Stop,LSP)=(400,360)
//Sig_xs_vec.push_back(4.41); // M(Stop,LSP)=(350,340) and also M(Stop,LSP)=(350,310)
//Sig_xs_vec.push_back(0.009635); //STOCv4
Sig_xs_vec.push_back(1.58); //StauC
double Sig_numberofevents =0;//this will use GetSumOfWeights()
const int Sig_nHT = 1; // Total number of HT bin samples
const int nHist = 18; // Number of histograms in each TDirectory
for(int i=1; i<=Sig_nHT ; i++){
//sprintf(tempname,"../Results/results_PhaseII4_Stop_CharmLSP_14TEV_140PileUp_00.root");
//sprintf(tempname,"../Results/results_PhaseII4_Stop_CharmLSPv2_14TEV_140PileUp_00.root");
//sprintf(tempname,"../Results/results_PhaseII4_Stop_CharmLSPv3_14TEV_140PileUp_00.root");
//sprintf(tempname,"../Results/results_PhaseII4_t2cc450410_14TEV_140PileUp_00.root");
//sprintf(tempname,"../Results/results_PhaseII4_t2cc450440_14TEV_140PileUp_00.root");
//sprintf(tempname,"../Results/results_PhaseII4_t2cc400390_14TEV_140PileUp_00.root");
//sprintf(tempname,"../Results/results_PhaseII4_t2cc400360_14TEV_140PileUp_00.root");
//sprintf(tempname,"../Results/results_PhaseII4_t2cc350340_14TEV_140PileUp_00.root");
//sprintf(tempname,"../Results/results_PhaseII4_t2cc350310_14TEV_140PileUp_00.root");
//sprintf(tempname,"../Results/results_PhaseII4_Stop_CharmLSPv4_14TEV_140PileUp_00.root");
sprintf(tempname,"../Results/results_PhaseII4_StauC_14TEV_140PileUp.root");
file = new TFile(tempname, "R");
sprintf(tempname,"allEvents/RA2nocut/MHT_RA2nocut_allEvents");
tempvalue = (luminosity*Sig_xs_vec[i-1])/((* (TH1D* ) file->Get(tempname)).GetEntries());
Sig_scalevec.push_back(tempvalue);
}//end of loop over HTbins
std::cout << "normalization scale factor determination done" << std::endl;
for(int i=1; i<=Sig_nHT; i++){
//sprintf(tempname,"../Results/results_PhaseII4_Stop_CharmLSP_14TEV_140PileUp_00.root");
//sprintf(tempname,"../Results/results_PhaseII4_Stop_CharmLSPv2_14TEV_140PileUp_00.root");
//sprintf(tempname,"../Results/results_PhaseII4_Stop_CharmLSPv3_14TEV_140PileUp_00.root");
//sprintf(tempname,"../Results/results_PhaseII4_t2cc450410_14TEV_140PileUp_00.root");
//sprintf(tempname,"../Results/results_PhaseII4_t2cc450440_14TEV_140PileUp_00.root");
//sprintf(tempname,"../Results/results_PhaseII4_t2cc400390_14TEV_140PileUp_00.root");
//sprintf(tempname,"../Results/results_PhaseII4_t2cc400360_14TEV_140PileUp_00.root");
//sprintf(tempname,"../Results/results_PhaseII4_t2cc350340_14TEV_140PileUp_00.root");
//sprintf(tempname,"../Results/results_PhaseII4_t2cc350310_14TEV_140PileUp_00.root");
//sprintf(tempname,"../Results/results_PhaseII4_Stop_CharmLSPv4_14TEV_140PileUp_00.root");
sprintf(tempname,"../Results/results_PhaseII4_StauC_14TEV_140PileUp.root");
Sig_inputfilevec.push_back(TFile::Open(tempname,"R"));
}
tempstack = new THStack("stack","Binned Sample Stack");
//sprintf(tempname,"PhaseII4_Stop_CharmLSP_14TEV_140PileUp_00.root");
//sprintf(tempname,"PhaseII4_Stop_CharmLSPv2_14TEV_140PileUp_00.root");
//sprintf(tempname,"PhaseII4_Stop_CharmLSPv3_14TEV_140PileUp_00.root");
//sprintf(tempname,"PhaseII4_t2cc450410_14TEV_140PileUp_00.root");
//sprintf(tempname,"PhaseII4_t2cc450440_14TEV_140PileUp_00.root");
//sprintf(tempname,"PhaseII4_t2cc400390_14TEV_140PileUp_00.root");
//sprintf(tempname,"PhaseII4_t2cc400360_14TEV_140PileUp_00.root");
//sprintf(tempname,"PhaseII4_t2cc350340_14TEV_140PileUp_00.root");
//sprintf(tempname,"PhaseII4_t2cc350310_14TEV_140PileUp_00.root");
//sprintf(tempname,"PhaseII4_Stop_CharmLSPv4_14TEV_140PileUp_00.root");
sprintf(tempname,"PhaseII4_StauC_14TEV_140PileUp.root");
file = new TFile(tempname,"RECREATE");
for(map<int , string >::iterator itt=sigtype.begin(); itt!=sigtype.end();itt++){ // loop over different event types
cdtoitt = file->mkdir((itt->second).c_str());
cdtoitt->cd();
int c=0;
for(map<int , string >::iterator it=cutname.begin(); it!=cutname.end();it++){ // loop over different cutnames
cdtoit = cdtoitt->mkdir((it->second).c_str());
cdtoit->cd();
for(int j=0; j<histname.size(); j++){ // loop over different histograms
for(int i=0; i<Sig_nHT ; i++){ // loop over different HT bins
sprintf(tempname,"%s/%s/%s_%s_%s",(itt->second).c_str(),(it->second).c_str(),(histname[j]).c_str(),(it->second).c_str(),(itt->second).c_str());
temphist = (TH1D *) Sig_inputfilevec.at(i)->Get(tempname)->Clone();
temphist->Scale(Sig_scalevec[i]);
if(histname[j]=="MHT"){
Sig_numberofevents+=(double)temphist->GetSumOfWeights();
}
temphist->SetFillColor(i+2);
tempstack->Add(temphist);
}//end of loop over HTbins 1..7
if(histname[j]=="MHT"){
if(itt->second=="allEvents"){
yieldmap[c].push_back(Sig_numberofevents);
}
}
Sig_numberofevents=0;
sprintf(tempname,"%s_%s_%s",histname[j].c_str(),(it->second).c_str(),(itt->second).c_str());
tempstack->Write(tempname);
delete tempstack;
tempstack = new THStack("stack","Binned Sample Stack");
}//end of loop over histograms
c+=1; }//end of loop over cutnames
}//end of loop over event types
file->Close();
//BJ Section//BJ Section//BJ Section//BJ Section//BJ Section//BJ Section//BJ Section//BJ Section//BJ Section//BJ Section//BJ Section
//build a vector of scale factors
//first load the cross sections into a vector
BJ_xs_vec.push_back(34409.92339);
BJ_xs_vec.push_back(2642.85309);
BJ_xs_vec.push_back(294.12311);
BJ_xs_vec.push_back(25.95000);
BJ_xs_vec.push_back(2.42111);
BJ_xs_vec.push_back(0.22690);
BJ_xs_vec.push_back(0.02767);
double BJ_numberofevents =0;
const int bjnHT = 7; // Total number of HT bin samples
for(int i=1; i<=bjnHT ; i++){
sprintf(tempname,"../Results/results_PhaseII4_BJ_14TEV_HT%d_140PileUp.root",i);
file = new TFile(tempname, "R");
sprintf(tempname,"allEvents/RA2nocut/MHT_RA2nocut_allEvents");
tempvalue = (luminosity*BJ_xs_vec[i-1])/((* (TH1D* ) file->Get(tempname)).GetEntries());
BJ_scalevec.push_back(tempvalue);
}//end of loop over HTbins
std::cout << "normalization scale factor determination done" << std::endl;
for(int i=1; i<=bjnHT; i++){
sprintf(tempname,"../Results/results_PhaseII4_BJ_14TEV_HT%d_140PileUp.root",i);
BJ_inputfilevec.push_back(TFile::Open(tempname,"R"));
}
//tempstack = new THStack("stack","Binned Sample Stack");
sprintf(tempname,"PhaseII4_BJ_14TEV_140PileUp.root");
//file = new TFile(tempname,"RECREATE");
for(map<int , string >::iterator itt=BJtype.begin(); itt!=BJtype.end();itt++){ // loop over different event types
// cdtoitt = file->mkdir((itt->second).c_str());
// cdtoitt->cd();
int c=0;
for(map<int , string >::iterator it=cutname.begin(); it!=cutname.end();it++){ // loop over different cutnames
// cdtoit = cdtoitt->mkdir((it->second).c_str());
// cdtoit->cd();
for(int j=0; j<histname.size(); j++){ // loop over different histograms
for(int i=0; i<bjnHT ; i++){ // loop over different HT bins
//cout << "================================" << endl;
//cout << "HT#: " <<i << ", BJtype: " << itt->second << ", cutname: " << it->second << ", hist#: " << j << endl;
sprintf(tempname,"%s/%s/%s_%s_%s",(itt->second).c_str(),(it->second).c_str(),(histname[j]).c_str(),(it->second).c_str(),(itt->second).c_str());
temphist = (TH1D *) BJ_inputfilevec.at(i)->Get(tempname)->Clone();
temphist->Scale(BJ_scalevec[i]);
if(histname[j]=="MHT"){
BJ_numberofevents+=(double)temphist->GetSumOfWeights();
}
temphist->SetFillColor(i+2);
//tempstack->Add(temphist);
}//end of loop over HTbins 1..7
if(histname[j]=="MHT"){
if(itt->second=="Wlv" || itt->second=="Zvv"){
yieldmap[c].push_back(BJ_numberofevents);
}
}
BJ_numberofevents=0;
sprintf(tempname,"%s_%s_%s",histname[j].c_str(),(it->second).c_str(),(itt->second).c_str());
// tempstack->Write(tempname);
// delete tempstack;
// tempstack = new THStack("stack","Binned Sample Stack");
}//end of loop over histograms
c+=1; }//end of loop over cutnames
}//end of loop over event types
//file->Close();
//TTbar Section//TTbar Section//TTbar Section//TTbar Section//TTbar Section//TTbar Section//TTbar Section//TTbar Section
//build a vector of scale factors
//first load the cross sections into a vector
TT_xs_vec.push_back(530.89358);
TT_xs_vec.push_back(42.55351);
TT_xs_vec.push_back(4.48209);
TT_xs_vec.push_back(0.52795);
TT_xs_vec.push_back(0.05449);
double TT_numberofevents =0;
const int ttnHT = 5; // Total number of HT bin samples
for(int i=1; i<=ttnHT ; i++){
sprintf(tempname,"../Results/results_PhaseII4_TT_14TEV_HT%d_140PileUp.root",i);
file = new TFile(tempname, "R");
sprintf(tempname,"allEvents/RA2nocut/MHT_RA2nocut_allEvents");
tempvalue = (luminosity*TT_xs_vec[i-1])/((* (TH1D* ) file->Get(tempname)).GetEntries());
TT_scalevec.push_back(tempvalue);
}//end of loop over HTbins
std::cout << "normalization scale factor determination done" << std::endl;
for(int i=1; i<=ttnHT; i++){
sprintf(tempname,"../Results/results_PhaseII4_TT_14TEV_HT%d_140PileUp.root",i);
TT_inputfilevec.push_back(TFile::Open(tempname,"R"));
}
//tempstack = new THStack("stack","Binned Sample Stack");
sprintf(tempname,"PhaseII4_TT_14TEV_140PileUp.root");
//file = new TFile(tempname,"RECREATE");
for(map<int , string >::iterator itt=TTtype.begin(); itt!=TTtype.end();itt++){ // loop over different event types
// cdtoitt = file->mkdir((itt->second).c_str());
// cdtoitt->cd();
int c=0;
for(map<int , string >::iterator it=cutname.begin(); it!=cutname.end();it++){ // loop over different cutnames
// cdtoit = cdtoitt->mkdir((it->second).c_str());
// cdtoit->cd();
for(int j=0; j<histname.size(); j++){ // loop over different histograms
for(int i=0; i<ttnHT ; i++){ // loop over different HT bins
sprintf(tempname,"%s/%s/%s_%s_%s",(itt->second).c_str(),(it->second).c_str(),(histname[j]).c_str(),(it->second).c_str(),(itt->second).c_str());
temphist = (TH1D *) TT_inputfilevec.at(i)->Get(tempname)->Clone();
temphist->Scale(TT_scalevec[i]);
if(histname[j]=="MHT"){
TT_numberofevents+=(double)temphist->GetSumOfWeights();
}
temphist->SetFillColor(i+2);
//tempstack->Add(temphist);
}//end of loop over HTbins 1..5
if(histname[j]=="MHT"){
if(itt->second=="allEvents"){
yieldmap[c].push_back(TT_numberofevents);
}
}
TT_numberofevents=0;
sprintf(tempname,"%s_%s_%s",histname[j].c_str(),(it->second).c_str(),(itt->second).c_str());
// tempstack->Write(tempname);
// delete tempstack;
// tempstack = new THStack("stack","Binned Sample Stack");
}//end of loop over histograms
c+=1; }//end of loop over cutnames
}//end of loop over event types
//file->Close();
///write the output in a file
fstream ff;
ff.open("CutFlow.txt", std::fstream::out);
ff << " Cut Name, " << " Signal, " << " Wlv, " << " Zvv, " << " TTbar, "<< " Total BG, " << " % Signal/Background, " << " Significance " << endl;
double totalBG=0, delWlv=0, delZvv=0, delTT=0, delB=0, delBsquare=0;
for(int i=0; i<yieldmap.size(); i++){
totalBG=(double) (yieldmap[i].at(1)+yieldmap[i].at(2)+yieldmap[i].at(3));
delWlv= 0.08*yieldmap[i].at(1);///uncrtainty for Wlv is 8%
delZvv= 0.05*yieldmap[i].at(2);
delTT= 0.5*yieldmap[i].at(3);///uncrtainty for TTbar is 50%
delBsquare=pow(delWlv,2)+pow(delZvv,2)+pow(delTT,2);///delta_background = sqrt(delWlv^2+delZvv^2+delTT^2)
ff << " " <<cutname[i]<<", " << yieldmap[i].at(0) << ", " << yieldmap[i].at(1) <<", " << yieldmap[i].at(2) <<", " <<yieldmap[i].at(3) << ", "<< totalBG << ", " << yieldmap[i].at(0)/totalBG*100 << ", " << yieldmap[i].at(0)/sqrt(delBsquare+totalBG+yieldmap[i].at(0)) <<endl;
}
ff.close();
/*
///write the output in a file
fstream ff;
ff.open("CutFlow.txt", std::fstream::out);
ff << " Cut Name, " << " Signal, " << endl;
for(int i=0; i<yieldmap.size(); i++){
ff << " " <<cutname[i]<<", " << yieldmap[i].at(0) << endl;
}
ff.close();
*/
}//end of the constructor