/*************************************************************************************
* getKS: Searches through the histograms in the plotter output, adds the MC together
* for each field, and compares the MC with the Data histogram using a KS test
* input: the main() arguments array
* output: writes to stdout the (human-readable) KS statistics of pairs of histograms
*
* Structure-wise: this is fine, can be implemented into class easily.
***********************************/
void getKS(const char* argv[]) {
//open the input TFile
TFile *f = new TFile(argv[2]);
f->cd();
//get the filesystem information from the file
TList *alokDirs = (TList*) f->GetListOfKeys();
//loop through the directories in the input file
for(int idir=0; alokDirs->At(idir-1) != alokDirs->Last(); idir++) {
TDirectory *cDir = (TDirectory*) f->Get(alokDirs->At(idir)->GetName());
TList *alokHistos = (TList*) cDir->GetListOfKeys();
// create the MC histogram and start collecting relevant MC histograms
// from the current directory
TList *aloh = new TList;
// loop through keys (histograms) in current directory
for(int ihisto=0; alokHistos->At(ihisto) != alokHistos->Last(); ihisto++) {
if(TString(alokHistos->At(ihisto)->GetName()).Contains("MC8TeV")) {
TH1F *cHisto = (TH1F*) cDir->Get(alokHistos->At(ihisto)->GetName());
aloh->Add(cHisto);
}
}
//merge the data histograms into one histogram
TH1F *MCHisto = (TH1F*) (aloh->Last())->Clone(TString(cDir->GetName()) + TString("MCHisto"));
aloh->RemoveLast();
MCHisto->Merge(aloh);
cout<<"-------------------- "<<cDir->GetName()<<" -----------------------"<<endl;
//now create the data histogram and run the KS test
TH1F *DataHisto = (TH1F*) cDir->Get(alokHistos->Last()->GetName());
cout<<" ---> KS Test: "<<cDir->GetName()<<" has probability "<<MCHisto->KolmogorovTest(DataHisto, "D")<<"\n"<<endl;
}
}
double Chi2F(const double *xx ){
const Double_t scale = xx[0];
fileInMC->cd();
TTree* MyTreeMC = (TTree*) fileInMC->Get(treeNameMC.c_str());
outFile->cd();
TString nameDATA = Form("hDATA_%d_%d_%.5f",Data_or_MC,nIter,ScaleTrue);
TH1F* hDATA = (TH1F*) outFile->Get(nameDATA);
TString NameMC = Form("hMC_Chi2_%.5f",scale);
//std::cerr << " NameMC = " << NameMC.Data() << " => " << scale << std::endl;
TH1F* hMC;
if (!gROOT->FindObject(NameMC.Data())){
hMC = new TH1F(NameMC,NameMC,numBINS,minBINS,maxBINS);
hMC->Reset();
// std::cerr << " AdditionalCut.Data() = " << AdditionalCut.Data() << std::endl;
MyTreeMC->SetEntryList(0);
MyTreeMC->Draw(">> myListMCTot",(AdditionalCut + Form(" && (ET * (1+(%f)))>%f",scale,minET)).Data(),"entrylist");
TEntryList *mylistMCTot = (TEntryList*)gDirectory->Get("myListMCTot");
MyTreeMC->SetEntryList(mylistMCTot);
TString DrawMC = Form("(%s * (1+(%f)))>>%s",variableName.c_str(),scale,NameMC.Data());
// std::cerr << " DrawMC = " << DrawMC.Data() << std::endl;
MyTreeMC->Draw(DrawMC);
// MyTreeMC->Draw(DrawMC,(AdditionalCut+Form("&& (ET * (1+(%f)))>%f",scale,minET)).Data());
hMC->Sumw2();
hMC->Scale(hDATA->GetEffectiveEntries()/hMC->GetEffectiveEntries());
outFile->cd();
hMC->Write();
}
else {
// std::cerr << " KM old " << NameMC.Data() << std::endl;
hMC = (TH1F*) outFile->Get(NameMC.Data());
}
outFile->cd();
// hDATA.Write();
// hMC.Write();
double result = hMC->KolmogorovTest(hDATA,"M");
// double result = - hMC->KolmogorovTest(hDATA,"X");
// double result = hMC->Chi2Test(&hDATA,"CHI2/NDF");
//=========> E' QUESTO! ==> double result = hMC->Chi2Test(hDATA,"CHI2");
//double result = - hMC.Chi2Test(&hDATA,""); ///==== http://root.cern.ch/root/html/TH1.html#TH1:Chi2Test
return result;
}
void plottingmacro_IVF()
{
double fa = 0.46502;
double fb = 0.53498;
bool debug_ = true;
// std::string path("Nov10thFall11Plots/");
// std::string path("Nov10Fall1160MTopSlimPlots/");
std::string path("Nov10Fall1160MTopIVFPlots_b/");
if(debug_)
std::cout << "Init the style form setTDRStyle" << std::endl;
setTDRStyle();
gStyle->SetErrorX(0.5);
gROOT->ForceStyle();
initOptions();
if(debug_)
std::cout << "Init the sample" << std::endl;
// std::vector<Sample> s = Nov10thDiJetPtUpdatedSlimHistos();
//std::vector<Sample> s = Nov10Fall1160MTopSlimHistos();
std::vector<Sample> s = Nov10Fall1160MTopIVFHistos();
Sample data(1,"fake data","S1.root",0,true,1000);
if(debug_)
std::cout << "Init the data sample" << std::endl;
for(size_t i=0;i< s.size();i++) if(s[i].data) {data=s[i];break;}
if(debug_)
std::cout << "Ls data sample" << std::endl;
data.file()->ls();
if(debug_)
std::cout << "Init the mc sample" << std::endl;
for(size_t i=0;i< s.size();i++) s[i].dump(1,fa,fb);
std::vector<std::string> names;
if(debug_)
std::cout << "Get List of Keys" << std::endl;
TList * subs = data.file()->GetListOfKeys();
for(size_t i=0;i< subs->GetSize();i++)
{
TString nn = subs->At(i)->GetName();
if( nn.Contains(TRegexp("Count*")) )
continue;
if(debug_)
std::cout << "Get List of Keys in subdirs" << std::endl;
TList * objs = ((TDirectoryFile *)data.file()->Get(subs->At(i)->GetName()))->GetListOfKeys();
for(size_t j=0;j< objs->GetSize();j++)
{
if(debug_)
std::cout << "Name = " << subs->At(i)->GetName()+std::string("/") + objs->At(j)->GetName() << std::endl;
names.push_back(subs->At(i)->GetName()+std::string("/") + objs->At(j)->GetName());
// std::cout << subs->At(i)->GetName() << "/" << objs->At(j)->GetName() << std::endl;
//TODO: select plots via regexp
}
}
if(debug_)
std::cout << "Starting plotting" << std::endl;
std::string process;
for(size_t i = 0 ; i < names.size() ; i++)
{
std::map<std::string,TH1F *> grouped;
TString n=names[i];
// if(!n.Contains(TRegexp("VlightRegionHZee/HiggsPtVlightRegionHZee"))) continue;
// if(!n.Contains(TRegexp("VlightRegionHZee/ZPtVlightRegionHZee"))) continue;
// if(!n.Contains(TRegexp("VlightRegionHZee"))) continue;
// if(!n.Contains(TRegexp("ZSVRegionZmmSV"))) continue;
// if(!n.Contains(TRegexp("ZSVRegionZeeSV"))) continue;
// if(!n.Contains(TRegexp("ZSVRegionZcombSV"))) continue;
// if(!n.Contains(TRegexp("ZSVPureRegionZcombSV"))) continue;
// if(!n.Contains(TRegexp("ZSVTTbarPureRegionZcombSV"))) continue;
if(!n.Contains(TRegexp("TTbarRegionZeeSVJets"))) continue;
if(n.Contains(TRegexp("RegionHZcomb")))
process = "Z(l^{+}l^{-})H(b#bar{b})";
if(n.Contains(TRegexp("RegionHZmm")))
process = "Z(#mu^{+}#mu^{-})H(b#bar{b})";
if(n.Contains(TRegexp("RegionHZee")))
process = "Z(e^{+}e^{-})H(b#bar{b})";
if(debug_)
std::cout << "Creating the Canvas" << std::endl;
TCanvas *c = new TCanvas();
c->SetLogy(false);
c->SetTitle(names[i].c_str());
if(debug_)
std::cout << "Creating histograms" << std::endl;
TH1F *hd = ((TH1F*)data.file()->Get(names[i].c_str()));
hd->Sumw2();
Options o=options[names[i]];
// hd->Rebin(o.rebin);
hd->SetMarkerStyle(20);
hd->GetXaxis()->SetLabelOffset(99);
hd->SetYTitle(o.yaxis.c_str());
double nbin = hd->GetNbinsX();
double min_bin = hd->GetXaxis()->GetXmin();
double max_bin = hd->GetXaxis()->GetXmax();
TH1F *hmc = new TH1F("hmc","hmc", nbin, min_bin, max_bin);
hmc->SetFillColor(kWhite);
hmc->Sumw2();
// hmc->Rebin(o.rebin);
if(debug_)
std::cout << "Creating the THStack and Legend" << std::endl;
THStack * sta = new THStack("sta",hd->GetTitle());
TLegend * l = new TLegend(o.legendx1,o.legendy1,o.legendx2,o.legendy2); //0.7,0.1,0.9,0.6);
l->SetFillColor(kWhite);
l->SetBorderSize(0);
l->SetTextFont(62);
l->SetTextSize(0.03);
if(debug_)
std::cout << "Adding data to the legend" << std::endl;
l->AddEntry(hd, "Data","P");
if(debug_)
std::cout << "Adding MC to the THStack" << std::endl;
//with the proper trigger eff
// double SF[] = {1.01,1.03,1.00};
// double SF[] = {1.03,1.054,1.032};
double SF[] = {1.0,1.0,1.0};
if(debug_){
for(int i = 0; i< 3; ++i)
std::cout << "SF [" << i << "] = " << SF[i] << std::endl;
}
double mcIntegral=0;
for(size_t j=0;j< s.size() ;j++)
{
if(!s[j].data)
{
if(debug_)
std::cout << "Creating TH1F from file " << s[j].name << std::endl;
TH1F * h = ((TH1F*)s[j].file()->Get(names[i].c_str()));
h->Sumw2();
if(debug_){
std::cout << "TH1F created from file " << s[j].name << std::endl;
std::cout << "Scaling : " << s[j].scale(data.lumi(),fa,fb) << std::endl;
std::cout << "Scaling with SF : " << s[j].scale(data.lumi(),fa,fb,SF) << std::endl;
std::cout << "Histo integral before scaling = " << h->Integral() << std::endl;
}
h->Scale(s[j].scale(data.lumi(),fa,fb,SF));
if(debug_){
std::cout << "Histo integral after scaling = " << h->Integral() << std::endl;
std::cout << "Managing style... " << std::endl;
}
h->SetLineWidth(1.);
h->SetFillColor(s[j].color);
h->SetLineColor(s[j].color);
// h->Rebin(options[names[i]].rebin);
if(debug_)
std::cout << "Cloning and update legend " << std::endl;
if(grouped.find(s[j].name) == grouped.end()){
l->AddEntry(h,s[j].name.c_str(),"F");
}
std::cout << "Sample : " << s[j].name << " - Integral for plot " << names[i] << " = " << h->Integral(-10000,10000) << std::endl;
mcIntegral += h->Integral();
sta->Add(h);
hmc->Add(h);
//TO FIX grouped map
// sovrascrive histo con lo stesso nome tipo VV o ST etc...
grouped[s[j].name]=(TH1F *)h->Clone(("_"+names[i]).c_str());
}
}
if(debug_){
std::cout << "Data total = " << hd->Integral() << std::endl;
std::cout << "MC = " << mcIntegral << std::endl;
std::cout << "Data/MC = " << hd->Integral()/mcIntegral << std::endl;
}
TPad * TopPad = new TPad("TopPad","Top Pad",0.,0.3,1.,1. ) ;
TPad * BtmPad = new TPad("BtmPad","Bottom Pad",0.,0.,1.,0.313 ) ;
TopPad->SetBottomMargin(0.02);
BtmPad->SetTopMargin(0.0);
BtmPad->SetFillStyle(4000);
TopPad->SetFillStyle(4000);
BtmPad->SetFillColor(0);
BtmPad->SetBottomMargin(0.35);
TopPad->Draw() ;
BtmPad->Draw() ;
std::cout << "hd maximum = " << hd->GetMaximum() << " sta maximum = " << sta->GetMaximum() << std::endl;
double maxY;
if(hd->GetMaximum() > sta->GetMaximum()) maxY = (hd->GetMaximum())*1.5;
else maxY = (sta->GetMaximum())*1.5;
TopPad->cd();
hd->Draw("E1X0");
sta->Draw("sameHIST");
hmc->Draw("sameE2");
hmc->SetFillColor(2);
hmc->SetMarkerSize(0);
hmc->SetFillStyle(3013);
hd->Draw("E1X0same");
l->Draw("same");
std::cout << "Set Maximum to = " << maxY << std::endl;
hd->GetYaxis()->SetRangeUser(0.,maxY);
hd->GetXaxis()->SetRangeUser(options[names[i]].min,options[names[i]].max);
BtmPad->cd();
std::cout << "Division" << std::endl;
TH1D * divisionErrorBand = (TH1D*)(hmc)->Clone("divisionErrorBand");
divisionErrorBand->Sumw2();
divisionErrorBand->Divide(hmc);
divisionErrorBand->Draw("E2");
divisionErrorBand->SetMaximum(2.49);
divisionErrorBand->SetMinimum(0);
divisionErrorBand->SetMarkerStyle(20);
divisionErrorBand->SetMarkerSize(0.55);
divisionErrorBand->GetXaxis()->SetTitleOffset(1.12);
divisionErrorBand->GetXaxis()->SetLabelSize(0.12);
divisionErrorBand->GetXaxis()->SetTitleSize(0.5);
divisionErrorBand->GetYaxis()->SetTitle("Data/MC");
divisionErrorBand->GetYaxis()->SetLabelSize(0.12);
divisionErrorBand->GetYaxis()->SetTitleSize(0.12);
divisionErrorBand->GetYaxis()->SetTitleOffset(0.40);
divisionErrorBand->GetYaxis()->SetNdivisions(505);
//divisionErrorBand->UseCurrentStyle();
divisionErrorBand->SetFillColor(2);
divisionErrorBand->SetFillStyle(3001);
divisionErrorBand->SetMarkerSize(0.);
TH1D * division = (TH1D*)(hd)->Clone("division");
division->Sumw2();
division->Divide(hmc);
// division->SetMaximum(2.5);
// division->SetMinimum(0);
// division->SetMarkerStyle(20);
// division->SetMarkerSize(0.55);
// division->GetXaxis()->SetLabelSize(0.12);
// division->GetXaxis()->SetTitleSize(0.14);
// division->GetYaxis()->SetLabelSize(0.10);
// division->GetYaxis()->SetTitleSize(0.10);
// division->GetYaxis()->SetTitle("Data/MC");
Double_t min = division->GetXaxis()->GetXmin();
Double_t max = division->GetXaxis()->GetXmax();
division->Draw("E1X0same");
TLine *line = new TLine(min, 1.0, max, 1.0);
line->SetLineColor(kRed);
line->Draw("same");
TLegend * leg3 =new TLegend(0.50,0.86,0.69,0.96);
leg3->AddEntry(divisionErrorBand,"MC uncert. (stat.)","f");
leg3->SetFillColor(0);
leg3->SetLineColor(0);
leg3->SetShadowColor(0);
leg3->SetTextFont(62);
leg3->SetTextSize(0.06);
leg3->Draw();
TPaveText *pave = new TPaveText(0.15,0.85,0.32,0.96,"brNDC");
pave->SetTextAlign(12);
pave->SetLineColor(0);
pave->SetFillColor(0);
pave->SetShadowColor(0);
//TText *text = pave->AddText(Form("#chi_{#nu}^{2} = %.3f, K_{s} = %.3f",histDt->Chi2Test(histCopyMC5,"UWCHI2/NDF"),histDt->KolmogorovTest(histCopyMC5))); // stat + sys
TText *text = pave->AddText(Form("#chi_{#nu}^{2} = %.3f, K_{s} = %.3f",hd->Chi2Test(hmc,"UWCHI2/NDF"),hd->KolmogorovTest(hmc))); // stat only
text->SetTextFont(62);
text->SetTextSize(0.08);
pave->Draw();
TopPad->cd();
TLatex latex;
latex.SetNDC();
latex.SetTextAlign(12);
latex.SetTextSize(0.052);
latex.DrawLatex(0.17,0.89,"CMS Preliminary");
latex.SetTextSize(0.04);
latex.DrawLatex(0.17,0.84,"#sqrt{s} = 7 TeV, L = 4.7 fb^{-1}");
// latex.DrawLatex(0.17,0.79,"Z(e^{+}e^{-})H(b#bar{b})");
latex.DrawLatex(0.17,0.79,process.c_str());
c->Update();
std::string cName= hd->GetName();
cName += "_bare.pdf";
cName = path+cName;
c->Print(cName.c_str(),"pdf");
// std::cout << names[i] << " d: " << hd->Integral() << " ";
// THStack * sta2 = new THStack("sta2",hd->GetTitle());
// float tot=0;
// float toterr2=0;
// if(debug_)
// std::cout << "Putting the iterator in the for loop" << std::endl;
// for(std::map<std::string,TH1F *>::reverse_iterator it=grouped.rbegin(); it!=grouped.rend();++it)
// {
// if(debug_)
// std::cout << "Using the iterator" << std::endl;
// std::cout << (*it).first << " " << (*it).second->Integral() << " | " << std::endl ;
// if((*it).second->GetEntries() > 0) {
// float er=1.*sqrt((*it).second->GetEntries())/(*it).second->GetEntries()*(*it).second->Integral();
// toterr2+=er*er;
// }
// tot+=(*it).second->Integral();
// sta2->Add(it->second);
// }
// std::cout << " Tot: " << tot << "+-" << sqrt(toterr2) << " SF: " << hd->Integral()/tot << std::endl;
// TCanvas *c2 = new TCanvas();
// c2->SetTitle(names[i].c_str());
// std::cout << "hd maximum = " << hd->GetMaximum() << " sta2 maximum = " << sta2->GetMaximum() << std::endl;
// if(hd->GetMaximum() > sta2->GetMaximum()) maxY = hd->GetBinContent(hd->GetMaximumBin()) * 1.5;
// else maxY = ( sta2->GetMaximum())*1.5;
// // hd->Draw("E1");
// sta2->Draw("PADSHIST");
// // hd->Draw("E1same");
// // l->Draw("same");
// std::cout << "Set Maximum to = " << maxY << std::endl;
// hd->GetYaxis()->SetRangeUser(0.,maxY);
// hd->GetXaxis()->SetRangeUser(options[names[i]].min,options[names[i]].max);
// c2->Update();
// std::string c2Name = hd->GetName();
// c2Name = path+c2Name;
// c2Name += "_norm.pdf";
// c2->Print(c2Name.c_str(),"pdf");
}
}
// Simple example of reading a generated Root file
void verification_HitsChargeTime(char *filename=NULL, char *filename2, bool verbose=false)
{
// Clear global scope
//gROOT->Reset();
gStyle->SetOptStat(0);
gStyle->SetCanvasColor(0);
gStyle->SetTitleColor(1);
gStyle->SetStatColor(0);
gStyle->SetFrameFillColor(0);
gStyle->SetPadColor(0);
gStyle->SetPadTickX(1);
gStyle->SetPadTickY(1);
gStyle->SetTitleSize(0.04);
gStyle->SetCanvasBorderMode(0);
gStyle->SetFrameBorderMode(0);
gStyle->SetFrameLineWidth(2);
gStyle->SetPadBorderMode(0);
gStyle->SetPalette(1);
gStyle->SetTitleAlign(23);
gStyle->SetTitleX(.5);
gStyle->SetTitleY(0.99);
gStyle->SetTitleBorderSize(0);
gStyle->SetTitleFillColor(0);
gStyle->SetHatchesLineWidth(2);
gStyle->SetLineWidth(1.5);
gStyle->SetTitleFontSize(0.07);
gStyle->SetLabelSize(0.05,"X");
gStyle->SetLabelSize(0.05,"Y");
gStyle->SetTitleSize(0.04,"X");
gStyle->SetTitleSize(0.04,"Y");
gStyle->SetTitleBorderSize(0);
gStyle->SetCanvasBorderMode(0);
// Load the library with class dictionary info
// (create with "gmake shared")
char* wcsimdirenv;
wcsimdirenv = getenv ("WCSIMDIR");
if(wcsimdirenv != NULL){
gSystem->Load("${WCSIMDIR}/libWCSimRoot.so");
}else{
gSystem->Load("../libWCSimRoot.so");
}
TFile *f;
// Open the file
if (filename==NULL){
f = new TFile("wcsimtest.root","read");
filename = "wcsimtest.root";
}else{
f = new TFile(filename,"read");
}
if (!f->IsOpen()){
cout << "Error, could not open input file: " << filename << endl;
return -1;
}
TFile *f2;
// Open the file
if (filename2==NULL){
f2 = new TFile("../../WCSim_clean/verification-test-scripts/wcsimtest.root","read");
filename2 = "../../WCSim_clean/verification-test-scripts/wcsimtest.root";
}else{
f2 = new TFile(filename2,"read");
}
if (!f2->IsOpen()){
cout << "Error, could not open input file: " << filename2 << endl;
return -1;
}
TTree *wcsimT = f->Get("wcsimT");
int nevent = wcsimT->GetEntries();
WCSimRootEvent *wcsimrootsuperevent = new WCSimRootEvent();
wcsimT->SetBranchAddress("wcsimrootevent",&wcsimrootsuperevent);
// Force deletion to prevent memory leak when issuing multiple
// calls to GetEvent()
wcsimT->GetBranch("wcsimrootevent")->SetAutoDelete(kTRUE);
wcsimT->GetEvent(0);
// In the default vis.mac, only one event is run. I suspect you could loop over more events, if they existed.
WCSimRootTrigger *wcsimrootevent = wcsimrootsuperevent->GetTrigger(0);
cout << "Stats for the first event in your version of WCSim using " << filename << endl;
cout << "Number of tube hits " << wcsimrootevent->GetNumTubesHit() << endl;
cout << "Number of digitized tube hits " << wcsimrootevent->GetNumDigiTubesHit() << endl;
cout << "Number of photoelectron hit times " << wcsimrootevent->GetCherenkovHitTimes()->GetEntries() << endl;
//Save these to compare with the clean version of the code.
int num_tubes = wcsimrootevent->GetNumTubesHit();
int num_digi_tubes = wcsimrootevent->GetNumDigiTubesHit();
int hit_times = wcsimrootevent->GetCherenkovHitTimes()->GetEntries();
// Create a WCSimRootEvent to put stuff from the tree in
WCSimRootEvent* wcsimrootsuperevent = new WCSimRootEvent();
// Set the branch address for reading from the tree
TBranch *branch = wcsimT->GetBranch("wcsimrootevent");
branch->SetAddress(&wcsimrootsuperevent);
// Force deletion to prevent memory leak
wcsimT->GetBranch("wcsimrootevent")->SetAutoDelete(kTRUE);
// start with the main "subevent", as it contains most of the info
// and always exists.
WCSimRootTrigger* wcsimrootevent;
TH1F *h1 = new TH1F("PMT Hits", "# Digitized Hits", 500, 0, 3000);
TH1F *time = new TH1F("Average time", "Average time", 600, 900, 2000);
TH1F *pe = new TH1F("Q/# Digitzed PMT", "Average Charge", 200, 0, 5);
// Now loop over events
for (int ev=0; ev<nevent; ev++)
{
// Read the event from the tree into the WCSimRootEvent instance
wcsimT->GetEntry(ev);
wcsimrootevent = wcsimrootsuperevent->GetTrigger(0);
if(verbose){
printf("********************************************************");
printf("Evt, date %d %d\n", wcsimrootevent->GetHeader()->GetEvtNum(),
wcsimrootevent->GetHeader()->GetDate());
printf("Mode %d\n", wcsimrootevent->GetMode());
printf("Number of subevents %d\n",
wcsimrootsuperevent->GetNumberOfSubEvents());
printf("Vtxvol %d\n", wcsimrootevent->GetVtxvol());
printf("Vtx %f %f %f\n", wcsimrootevent->GetVtx(0),
wcsimrootevent->GetVtx(1),wcsimrootevent->GetVtx(2));
}
for (int index = 0 ; index < wcsimrootsuperevent->GetNumberOfEvents(); index++)
{
int ncherenkovdigihits = wcsimrootevent->GetNcherenkovdigihits();
h1->Fill(ncherenkovdigihits);
float totalq = 0.;
float totalt = 0.;
// Loop through elements in the TClonesArray of WCSimRootCherenkovHits
for (int i=0; i< ncherenkovdigihits; i++)
{
TObject *Digi = (wcsimrootevent->GetCherenkovDigiHits())->At(i);
WCSimRootCherenkovDigiHit *wcsimrootcherenkovdigihit =
dynamic_cast<WCSimRootCherenkovDigiHit*>(Digi);
int tubeNumber = (wcsimrootcherenkovdigihit->GetT(),wcsimrootcherenkovdigihit->GetTubeId());
float q = wcsimrootcherenkovdigihit->GetQ();
float t = wcsimrootcherenkovdigihit->GetT();
totalq+=q;
totalt+=t;
}
float av_time = totalt/ncherenkovdigihits;
float av_q = totalq/ncherenkovdigihits;
}
pe->Fill(av_q);
time->Fill(av_time);
// reinitialize super event between loops.
wcsimrootsuperevent->ReInitialize();
}// End of loop over events
TTree *wcsimT2 = f2->Get("wcsimT");
int nevent2 = wcsimT2->GetEntries();
WCSimRootEvent *wcsimrootsuperevent = new WCSimRootEvent();
wcsimT2->SetBranchAddress("wcsimrootevent",&wcsimrootsuperevent);
// Force deletion to prevent memory leak when issuing multiple
// calls to GetEvent()
wcsimT2->GetBranch("wcsimrootevent")->SetAutoDelete(kTRUE);
wcsimT2->GetEvent(0);
// In the default vis.mac, only one event is run. I suspect you could loop over more events, if they existed.
WCSimRootTrigger *wcsimrootevent = wcsimrootsuperevent->GetTrigger(0);
cout << "***********************************************************" << endl;
cout << "Stats for the first event of WCSim version on GitHub using "<< filename2 << endl;
cout << "Number of tube hits " << wcsimrootevent->GetNumTubesHit() << endl;
cout << "Number of digitized tube hits " << wcsimrootevent->GetNumDigiTubesHit() << endl;
cout << "Number of photoelectron hit times " << wcsimrootevent->GetCherenkovHitTimes()->GetEntries() << endl;
cout << "***********************************************************" << endl;
if (abs(num_tubes- wcsimrootevent->GetNumTubesHit())>1.0e-6){cout << "FIRST EVENT TEST FAILED: Number of hit tubes do not match" << endl;}
else {cout << "FIRST EVENT TEST PASSED: Number of hit tubes matches" << endl;}
if (abs(num_digi_tubes-wcsimrootevent->GetNumDigiTubesHit())>1.0e-6){cout << "FIRST EVENT TEST FAILED: Number of digitized tubes do not match" << endl; }
else {cout << "FIRST EVENT TEST PASSED: Number of digitized tubes matches" << endl; }
if (abs(hit_times-(wcsimrootevent->GetCherenkovHitTimes()->GetEntries()))> 1.0e-6){cout << "FIRST EVENT TEST FAILED: Number of hit times do not match" << endl;}
else {cout << "FIRST EVENT TEST PASSED: Number of hit times matches" << endl;}
// Create a WCSimRootEvent to put stuff from the tree in
WCSimRootEvent* wcsimrootsuperevent = new WCSimRootEvent();
// Set the branch address for reading from the tree
TBranch *branch = wcsimT2->GetBranch("wcsimrootevent");
branch->SetAddress(&wcsimrootsuperevent);
// Force deletion to prevent memory leak
wcsimT2->GetBranch("wcsimrootevent")->SetAutoDelete(kTRUE);
// start with the main "subevent", as it contains most of the info
// and always exists.
WCSimRootTrigger* wcsimrootevent;
TH1F *h2 = new TH1F("PMT Hits 2", "Digitized Hits", 500, 0, 3000);
TH1F *time2 = new TH1F("Average time 2", "Average time", 600, 900, 2000);
TH1F *pe2 = new TH1F("Q/# Digitzed PMT 2", "Q/# Digitzed PMT", 200, 0, 5);
// Now loop over events
for (int ev=0; ev<nevent; ev++)
{
// Read the event from the tree into the WCSimRootEvent instance
wcsimT2->GetEntry(ev);
wcsimrootevent = wcsimrootsuperevent->GetTrigger(0);
if(verbose){
printf("********************************************************");
printf("Evt, date %d %d\n", wcsimrootevent->GetHeader()->GetEvtNum(),
wcsimrootevent->GetHeader()->GetDate());
printf("Mode %d\n", wcsimrootevent->GetMode());
printf("Number of subevents %d\n",
wcsimrootsuperevent->GetNumberOfSubEvents());
printf("Vtxvol %d\n", wcsimrootevent->GetVtxvol());
printf("Vtx %f %f %f\n", wcsimrootevent->GetVtx(0),
wcsimrootevent->GetVtx(1),wcsimrootevent->GetVtx(2));
}
for (int index = 0 ; index < wcsimrootsuperevent->GetNumberOfEvents(); index++)
{
int ncherenkovdigihits = wcsimrootevent->GetNcherenkovdigihits();
h2->Fill(ncherenkovdigihits);
float totalq = 0.;
float totalt = 0.;
// Loop through elements in the TClonesArray of WCSimRootCherenkovHits
for (int i=0; i< ncherenkovdigihits; i++)
{
TObject *Digi = (wcsimrootevent->GetCherenkovDigiHits())->At(i);
WCSimRootCherenkovDigiHit *wcsimrootcherenkovdigihit =
dynamic_cast<WCSimRootCherenkovDigiHit*>(Digi);
int tubeNumber = (wcsimrootcherenkovdigihit->GetT(),wcsimrootcherenkovdigihit->GetTubeId());
float q = wcsimrootcherenkovdigihit->GetQ();
float t = wcsimrootcherenkovdigihit->GetT();
totalq+=q;
totalt+=t;
}
float av_time = totalt/ncherenkovdigihits;
float av_q = totalq/ncherenkovdigihits;
}
pe2->Fill(av_q);
time2->Fill(av_time);
// reinitialize super event between loops.
wcsimrootsuperevent->ReInitialize();
}// End of loop over events
Double_t ks_hits = h1->KolmogorovTest(h2);
Double_t ks_charge = pe->KolmogorovTest(pe2);
Double_t ks_time = time->KolmogorovTest(time2);
cout << "***********************************************************" << endl;
cout << "ks test for # of digitized hits: " << ks_hits << endl;
cout << "ks test for average charge: " << ks_charge << endl;
cout << "ks test for average time: " << ks_time << endl;
// TCanvas c1("c1");
float win_scale = 0.75;
int n_wide(2);
int n_high(2);
TCanvas* c1 = new TCanvas("c1", "Test Plots", 500*n_wide*win_scale, 500*n_high*win_scale);
c1->Draw();
c1->Divide(2,2);
c1->cd(1);
h2->SetLineColor(kRed);
h1->Draw();
c1->cd(1); h2->Draw("SAME");
TLegend *leg = new TLegend(0.2,0.7,0.55,0.85, "");
leg->SetFillColor(0);
leg->SetBorderSize(0);
leg->AddEntry(h1,filename, "l");
leg->AddEntry(h2,filename2, "l");
leg->Draw();
c1->cd(2);
pe->GetXaxis()->SetTitle("Total Charge / # digitized hits");
pe->Draw();
pe2->SetLineColor(kRed);
c1->cd(2); pe2->Draw("SAME");
c1->cd(3);
time->GetXaxis()->SetTitle("Total Time / # digitized hits (ns)");
time->Draw();
time2->SetLineColor(kRed);
c1->cd(3); time2->Draw("SAME");
}
int main(int argc, char *argv[]) {
// make sure command line arguments were supplied
if (argc != 6) { cerr << "Usage: " << argv[0] << " [reference.root] [new-comparison.root] [root dir] [new-release] [old-release] \n"; return 1; }
// create the comparison class
PlotCompareUtility *pc = new PlotCompareUtility(argv[1],argv[2],argv[3],"METTask_");
HistoData *hd;
if (pc->GetStatus() != 0) { cout << "Final Result: no_data" << endl; return 0; }
// add histogram information
//Type = 0 (Do not rebin or zoom) , 1 (Rebin and Zoom, x-axis > 0 ) , 2 (Rebin and Zoom)
hd = pc->AddHistoData("MET"); hd->SetType(1);
hd = pc->AddHistoData("METPhi"); hd->SetType(2);
hd = pc->AddHistoData("METSig"); hd->SetType(1);
hd = pc->AddHistoData("MEx"); hd->SetType(2);
hd = pc->AddHistoData("MEy"); hd->SetType(2);
hd = pc->AddHistoData("SumET"); hd->SetType(2);
if (pc->GetStatus() != 0) { cerr << "error encountered, exiting.\n"; return pc->GetStatus(); }
int num_histos = pc->GetNumHistos();
bool combinedFailed = false;
float threshold = KS_TEST ? pc->GetKSThreshold() : pc->GetChi2Threshold();
// get the reference and comparison histograms
int Nevents_ref = ((TH1F *)pc->GetRefHisto("Nevents"))->GetEntries();
int Nevents_new = ((TH1F *)pc->GetNewHisto("Nevents"))->GetEntries();
int Nevents = -1;
if (Nevents_ref>Nevents_new) Nevents = Nevents_ref;
else Nevents = Nevents_new;
// create summary histograms
TH1F h1dResults_passed("h1dResults_passed","",num_histos, 1, num_histos + 1);
TH1F h1dResults_failed("h1dResults_failed","",num_histos, 1, num_histos + 1);
// loop over the supplied list of histograms for comparison
for (int index = 0; index < pc->GetNumHistos(); index++) {
int number = index + 1;
hd = pc->GetHistoData(number);
//int type = hd->GetType();
//types[index] = type;
string name = hd->GetName();
//string value = hd->GetValueX();
cout << name << endl;
// get the reference and comparison histograms
TH1F *href = (TH1F *)pc->GetRefHisto(name);
TH1F *hnew = (TH1F *)pc->GetNewHisto(name);
// ignore if histogram is empty
if (hnew->GetEntries() <= 1 || href->GetEntries() <= 1) {
cerr << name << " error: no entries"; combinedFailed = true; continue;
}
// calculate and set range and number of bins
double h1RMS = hnew->GetRMS();
double h2RMS = href->GetRMS();
double RMS = TMath::Max(h1RMS, h2RMS);
double h1Mean = hnew->GetMean();
double h2Mean = href->GetMean();
double Mean = 0.5 * (h1Mean + h2Mean);
double Nbins = href->GetNbinsX();
double min = href->GetXaxis()->GetXmin();
double max = href->GetXaxis()->GetXmax();
double dX = max - min;
double dNdX = 1;
double NewMin = min;
double NewMax = max;
int rebinning = Nbins;
if (RMS>0 && hd->GetType() )
{
dNdX = 100. / ( 10 * RMS);
NewMin = Mean - 10 * RMS;
NewMax = Mean + 10 * RMS;
}
if ((dX * dNdX)>0 && hd->GetType() )
rebinning = (int)(double(Nbins) / (dX * dNdX));
if ( rebinning > 1 && hd->GetType() )
{
href->Rebin(rebinning);
hnew->Rebin(rebinning);
}
if ( hd->GetType() == 1 )
{
href->GetXaxis()->SetRangeUser(0.0, NewMax);
hnew->GetXaxis()->SetRangeUser(0.0, NewMax);
}
else if ( hd->GetType() == 2 )
{
href->GetXaxis()->SetRangeUser(NewMin, NewMax);
hnew->GetXaxis()->SetRangeUser(NewMin, NewMax);
}
// perform statistical tests
double ks_score = hnew->KolmogorovTest(href,"D");
double chi2_score = hnew->Chi2Test(href, "p");
//double result = KS_TEST ? ks_score : chi2_score;
double result = (ks_score>chi2_score) ? ks_score : chi2_score;
href->SetNormFactor(Nevents_new);
hnew->SetNormFactor(Nevents_new);
//hnew->SetNormFactor(1);
// ensure that the peaks of both histograms will be shown by making a dummy histogram
float Nentries_ref = href->GetEntries();
float Nentries_new = hnew->GetEntries();
float XaxisMin_ref = 0, XaxisMax_ref = 0, YaxisMin_ref = 0, YaxisMax_ref = 0;
float XaxisMin_new = 0, XaxisMax_new = 0, YaxisMin_new = 0, YaxisMax_new = 0;
if (Nentries_ref>0) YaxisMax_ref = (href->GetMaximum()+TMath::Sqrt(href->GetMaximum()))*(Nentries_new/Nentries_ref);
if (Nentries_new>0) YaxisMax_new = (hnew->GetMaximum()+TMath::Sqrt(hnew->GetMaximum()));
XaxisMin_ref = href->GetXaxis()->GetXmin()>NewMin ? href->GetXaxis()->GetXmin() : NewMin;
XaxisMax_ref = href->GetXaxis()->GetXmax()<=NewMax ? href->GetXaxis()->GetXmax() : NewMax;
YaxisMax_ref = (YaxisMax_ref>=YaxisMax_new) ? YaxisMax_ref : YaxisMax_new;
if (TMath::Abs(XaxisMin_ref - XaxisMax_ref)<1E-6)
{
XaxisMin_ref = 0;
XaxisMax_ref = 1;
}
TH1F *hdumb = new TH1F("hdumb","", rebinning, XaxisMin_ref, XaxisMax_ref);
hdumb->SetMinimum(1E-1); //--For Rick
hdumb->SetMaximum(1.05*YaxisMax_ref);
// if (href->GetMaximum() < hnew->GetMaximum())
// href->SetAxisRange(0, 1.1 * hnew->GetMaximum(), "Y");
// set drawing options on the reference histogram
href->SetStats(0);
href->SetLineWidth(2);
href->SetLineColor(14);
href->SetMarkerColor(14);
href->SetFillColor(17);
//href->SetFillStyle(3004);
href->GetXaxis()->SetTitle(name.c_str());
href->GetYaxis()->SetTitle("Entries");
href->GetYaxis()->SetTitleOffset(1.5);
// set drawing options on the new histogram
hnew->SetStats(0);
hnew->SetLineWidth(2);
hnew->SetFillStyle(3001);
// set drawing options on the dummy histogram
hdumb->SetStats(0);
hdumb->GetXaxis()->SetTitle(name.c_str());
hdumb->GetXaxis()->SetLabelSize(0.5 * hdumb->GetXaxis()->GetTitleSize());
hdumb->GetYaxis()->SetTitle("Entries");
hdumb->GetYaxis()->SetTitleOffset(1.5);
hdumb->GetYaxis()->SetLabelSize(0.5 * hdumb->GetXaxis()->GetTitleSize());
stringstream ss_title;
ss_title.precision(5);
if (ks_score>chi2_score)
ss_title << "KS Score = " << ks_score;
else
ss_title << "Chi^2 Score = " << chi2_score;
TText canvas_title(0.1,0.97,ss_title.str().c_str());
// determine if test is a "pass" or a "fail"
if (result <= threshold) {
canvas_title.SetTextColor(kRed);
// make this histogram red to denote failure
hnew->SetFillColor(kRed);
hnew->SetLineColor(206);
hnew->SetMarkerColor(206);
// mark the entire sample as being 'not-compatible'
combinedFailed = true;
// set the summary bin to failed (only need to set titles for passed h1dResults)
h1dResults_passed.GetXaxis()->SetBinLabel(number, name.c_str());
h1dResults_failed.SetBinContent(number, result);
} else {
canvas_title.SetTextColor(kGreen);
// make this histogram green to denote passing score
hnew->SetFillColor(kGreen);
hnew->SetLineColor(103);
hnew->SetMarkerColor(103);
// set the summary bin to passed
h1dResults_passed.GetXaxis()->SetBinLabel(number, name.c_str());
h1dResults_passed.SetBinContent(number, result);
}
// setup canvas for displaying the compared histograms
TCanvas histo_c("histo_c","histo_c",785,800);
histo_c.Draw();
TPad histo_p("histo_p","histo_p",0,0,1,0.99);
histo_p.Draw();
histo_c.cd();
canvas_title.SetTextSize(0.025);
canvas_title.Draw();
histo_p.cd();
histo_p.SetLogy(1); //--This is just for Dr. Rick
hdumb->Draw();
href->Draw("SAME");
hnew->Draw("SAME");
hnew->Draw("E1SAME");
stringstream legend_new;
stringstream legend_ref;
legend_new << argv[4] << ": " << Nentries_new << " entries, " << Nevents_new << " events";
legend_ref << argv[5] << ": " << Nentries_ref << " entries, " << Nevents_ref << " events";
TLegend l1(0.15,0.001,0.33, 0.06);
l1.SetTextSize(0.02);
l1.AddEntry(hnew, legend_new.str().c_str(),"lF");
l1.AddEntry(href, legend_ref.str().c_str(),"lF");
l1.SetFillColor(kNone);
l1.Draw("SAME");
// print the result to gif
string histo_name = name + ".gif";
histo_c.Print(histo_name.c_str(),"gif");
cout << "Result of comparison for " << name << ": ks score = " << ks_score << " : chi2 score = " << chi2_score << endl << endl;
}
// create summary canvas
int summary_height = int(780 * float(num_histos) / 11); // 780;
TCanvas main_c("main_c","main_c",799,summary_height);
main_c.Draw();
TPad main_p("main_p","main_p",0.01,0.01,0.99,0.94);
main_p.SetLeftMargin(0.30);
main_p.SetBottomMargin(0.15);
main_p.SetLogx(1);
main_p.SetGrid();
main_p.SetFrameFillColor(10);
main_p.Draw();
main_c.cd();
TText summary_title(.01, .95, "");
summary_title.Draw("SAME");
main_p.cd();
// setup the passing test bars
h1dResults_passed.SetStats(0);
h1dResults_passed.GetXaxis()->SetLabelSize(0.06);
h1dResults_passed.GetYaxis()->SetLabelSize(0.04);
h1dResults_passed.GetYaxis()->SetTitle("Compatibility");
h1dResults_passed.SetBarWidth(0.7);
h1dResults_passed.SetBarOffset(0.1);
h1dResults_passed.SetFillColor(kGreen);
h1dResults_passed.SetLineColor(1);
h1dResults_passed.GetYaxis()->SetRangeUser(1E-7,2);
h1dResults_passed.Draw("hbar0");
// setup the failing test bars
h1dResults_failed.SetStats(0);
h1dResults_failed.GetXaxis()->SetLabelSize(0.06);
h1dResults_failed.GetYaxis()->SetLabelSize(0.04);
h1dResults_failed.GetYaxis()->SetTitle("Compatibility");
h1dResults_failed.SetBarWidth(0.7);
h1dResults_failed.SetBarOffset(0.1);
h1dResults_failed.SetFillColor(kRed);
h1dResults_failed.SetLineColor(1);
h1dResults_failed.GetYaxis()->SetRangeUser(1E-7,2);
h1dResults_failed.Draw("hbar0SAME");
// draw the pass/fail threshold line
TLine l(threshold, 1, threshold, num_histos+1);
l.SetLineColor(kRed);
l.SetLineWidth(2);
l.SetLineStyle(2);
l.Draw("SAME");
// print the results
main_c.Update();
main_c.Print("AllResults-1dHistoCheck.gif","gif");
if (combinedFailed) cout << "Final Result: fail" << endl;
else cout << "Final Result: pass" << endl;
//delete pc;
return 0;
}
void compareCorrRCSpike(){
char tmp[1000];
setTDRStyle();
// settings for purity TGraphAsymmetryErrors
Double_t fBinsPtMidPoint[nPtBin]={0};
Double_t fBinsPtError[nPtBin]={0};
for(int ipt=0; ipt < nPtBin; ipt++)
{
fBinsPtMidPoint[ipt] = 0.5*(fBinsPt[ipt+1]+fBinsPt[ipt]);
fBinsPtError[ipt] = 0.5*(fBinsPt[ipt+1]-fBinsPt[ipt]);
}
TH1F* hTemplate_S[nEtaBin][nPtBin];
TH1F* hdata_S[nEtaBin][nPtBin];
std::string dataFile = "SBDataTemplate_131511_139239.root";
std::string templateFile = "spike_131511_139239.root";
TFile* inf_data = new TFile(dataFile.data());
TFile* inf_template = new TFile(templateFile.data());
char* dec[2] = {"EB","EE"};
for(int ieta=0; ieta<1; ieta++){
for(int ipt=0; ipt < nPtBin; ipt++){
// getting histograms from data root file
sprintf(tmp,"h_%s_comb3Iso_sig_pt%d",dec[ieta],(int)fBinsPt[ipt]);
cout << "looking for histogram " << tmp << " in file " <<
inf_data->GetName() << endl;
hdata_S[ieta][ipt] = (TH1F*)inf_data->FindObjectAny(tmp);
hdata_S[ieta][ipt]->SetName(Form("hdata_S_%d_%d",ieta,ipt));
hdata_S[ieta][ipt]->Rebin(REBINNINGS);
// getting histogram for template root file
sprintf(tmp,"h_EB_comb3Iso_EGdata_SIG");
cout << "looking for histogram " << tmp << " in file " <<
inf_template->GetName() << endl;
hTemplate_S[ieta][ipt] = (TH1F*)inf_template->FindObjectAny(tmp);
hTemplate_S[ieta][ipt]->SetName(Form("hTemplate_S_%d_%d",ieta,ipt));
hTemplate_S[ieta][ipt]->Rebin(REBINNINGS);
}
}
TH1F* hfit_sig;
TH1F* hfit_spike;
TH1F* hsig = new TH1F("hsig","",120,-1,11);
hsig->SetXTitle("Iso (GeV)");
hsig->SetYTitle("A.U.");
hsig->GetYaxis()->SetDecimals();
hsig->SetYTitle("Iso (GeV)");
hsig->SetLineColor(2);
TH1F* hspike = new TH1F("hspike","",120,-1,11);
hspike->SetLineColor(4);
TCanvas* c1 = new TCanvas("c1","",500,500);
for(int ieta=0; ieta< 1; ieta++){
for(int ipt=0; ipt < nPtBin; ipt++){
hsig->Reset();
hspike->Reset();
// first obtain fit for the random cone corrected values
hfit_sig = (TH1F*)hdata_S[ieta][ipt]->Clone();
hfit_sig -> SetName("hfit_sig");
hfit_sig -> Rebin(4);
double sigPar[20] = {hfit_sig->GetMaximum(), 1., 0.5, 0.3,
1.,-.3,-1., 0.01, 0.5, 0.01, 1., 1.};
TF1 *fsig = new TF1("fsig", exp_conv, -1., 11., 12);
fsig->SetParameters(sigPar);
fsig->SetNpx(2500);
fsig->SetLineColor(2);
hfit_sig->Fit(fsig,"","",-1,5.0);
c1->Print(Form("hfit_sig_pt%d.gif",(int)fBinsPt[ipt]));
fsig->SetParameter(0,2);
fsig->SetParameter(1,fsig->GetParameter(1)*8.39614e-01/6.83080e-01);//correction from RC
fsig->SetParameter(2,4.83182e-01);
fsig->SetParameter(3,fsig->GetParameter(3)*2.33769e-01/2.26323e-01);
cout << "fsig Integral = " << fsig->Integral(-1,11) << endl;
for(int i=0;i<4;i++)
cout << "fsig par " << i << "= " << fsig->GetParameter(i) << endl;
// second obtain fit for the spikes
hfit_spike = (TH1F*)hTemplate_S[ieta][ipt]->Clone();
hfit_spike -> SetName("hfit_spike");
hfit_spike -> Rebin(4);
TF1 *fspike = new TF1("fspike", exp_conv, -1., 11., 12);
fspike->SetParameters(sigPar);
fspike->SetParameter(0,hfit_spike->GetMaximum());
fspike->SetLineColor(4);
fspike->SetNpx(2500);
hfit_spike->Fit(fspike,"","",-1,5.0);
c1->Print(Form("hfit_spike_pt%d.gif",(int)fBinsPt[ipt]));
fspike->SetParameter(0,2.0);
cout << "fspike Integral = " << fspike->Integral(-1,11) << endl;
float scale = (float)fsig->Integral(-1,11)/(float)fspike->Integral(-1,11);
fspike->SetParameter(0,2.0*scale);
cout << "now fspike Integral = " << fspike->Integral(-1,11) << endl;
for(int i=0;i<4;i++)
cout << "fspike par " << i << "= " << fspike->GetParameter(i) << endl;
hsig->FillRandom("fsig",10000);
hspike->FillRandom("fspike",10000);
cout << "KS test for sideband data and sideband MC = " <<
hsig->KolmogorovTest(hspike,"X") << endl;
cout << "KS test 2 for sideband data and sideband MC = " <<
hsig->KolmogorovTest(hspike) << endl;
hsig->Reset();
hsig->SetMaximum(1.2);
hsig->Draw();
// hspike->Draw("same");
fsig->Draw("same");
fspike->Draw("same");
TLegend* leg = new TLegend(0.35,0.70,0.55,0.85);
leg->SetHeader(Form("p_{T}[%d,%d]",(int)fBinsPt[ipt],(int)fBinsPt[ipt+1]));
leg->SetFillColor(0);
leg->SetFillStyle(0);
leg->SetTextSize(0.04);
leg->SetBorderSize(0);
leg->AddEntry(fsig,"Random-cone-corrected MC","f");
leg->AddEntry(fspike,"Spike","f");
leg->Draw("same");
c1->Print(Form("CorrRCSpike_pt%d.eps",(int)fBinsPt[ipt]));
c1->Print(Form("CorrRCSpike_pt%d.gif",(int)fBinsPt[ipt]));
c1->Print(Form("CorrRCSpike_pt%d.C",(int)fBinsPt[ipt]));
}
}
}
int main(int argc, char** argv)
{
//Check if all nedeed arguments to parse are there
if(argc != 2)
{
std::cerr << ">>>>> VertexStudiesAnalysis::usage: " << argv[0] << " configFileName" << std::endl ;
return 1;
}
// Parse the config file
parseConfigFile (argv[1]) ;
std::string inputFileList = gConfigParser -> readStringOption("Input::inputFileList");
std::string treeName = gConfigParser -> readStringOption("Input::treeName");
std::string outputRootFilePath = gConfigParser -> readStringOption("Output::outputRootFilePath");
std::string outputRootFileName = gConfigParser -> readStringOption("Output::outputRootFileName");
std::string tmvaMethod = gConfigParser -> readStringOption("Input::tmvaMethod");
std::string tmvaWeights = gConfigParser -> readStringOption("Input::tmvaWeights");
int entryMIN = gConfigParser -> readIntOption("Options::entryMIN");
int entryMAX = gConfigParser -> readIntOption("Options::entryMAX");
int isZee = gConfigParser -> readIntOption("Options::isZee");
int isZmumu = gConfigParser -> readIntOption("Options::isZmumu");
int isHiggs = gConfigParser -> readIntOption("Options::isHiggs");
int isData = gConfigParser -> readIntOption("Options::isData");
double trackThr = gConfigParser -> readDoubleOption("Options::trackThr");
int useWeights = gConfigParser -> readIntOption("Options::useWeights");
int poissonWeights = gConfigParser -> readIntOption("Options::poissonWeights");
int nAvePU = gConfigParser -> readIntOption("Options::nAvePU");
std::string puweightsFileName = gConfigParser -> readStringOption("Options::puweightsFileName");
int useJSON = gConfigParser -> readIntOption("Options::useJSON");
std::string jsonFileName = gConfigParser -> readStringOption("Options::jsonFileName");
//******* Get run/LS map from JSON file *******
std::map<int, std::vector<std::pair<int, int> > > jsonMap;
if ( isData && useJSON ) {
std::cout << ">>> Getting GOOD run/LS from JSON file" << std::endl;
jsonMap = readJSONFile(jsonFileName);
std::cout << std::endl;
std::cout << std::endl;
}
//****** Get weights for MC ******
float nmax;
float w[50];
TRandom *gRandom = new TRandom();
if (useWeights){
TFile weightsFile(puweightsFileName.c_str(),"READ");
TH1F* hweights;
if ( poissonWeights ){
std::cout << "N ave PU for Poisson PU reweighting : " << nAvePU << std::endl;
char hname[100];
sprintf(hname,"hwpoisson_%d",nAvePU);
hweights = (TH1F*)weightsFile.Get(hname);
}
else {
hweights = (TH1F*)weightsFile.Get("hweights");
}
nmax = hweights ->GetMaximum();
std::cout << " Max weight " << nmax << std::endl;
for (int ibin = 1; ibin < hweights->GetNbinsX()+1; ibin++){
w[ibin-1] = hweights->GetBinContent(ibin); // bin 1 --> nvtx = 0
}
weightsFile.Close();
}
//****** open TH1 with tracks pt for kolmogorov test
TH1F *hTrackPt;
TFile ptFile("hTracksPt_PU25_upTo10GeV.root","READ");
hTrackPt = (TH1F*)ptFile.Get("hTracksPt")->Clone("hTrackPt");
hTrackPt->SetDirectory(0);
ptFile.Close();
std::cout << hTrackPt->GetEntries() << std::endl;
TH1F *htemp = (TH1F*)hTrackPt->Clone("htemp");
htemp->Reset();
//****** Parameters for vertex finding algo ******
VertexAlgoParameters vtxAlgoParams_;
vtxAlgoParams_.rescaleTkPtByError = false;
vtxAlgoParams_.trackCountThr = 1.;
vtxAlgoParams_.highPurityOnly = false;
vtxAlgoParams_.maxD0Signif = 9999999.;
vtxAlgoParams_.maxDzSignif = 9999999.;
vtxAlgoParams_.removeTracksInCone = 1;
vtxAlgoParams_.coneSize = 0.05;
//--- sumpt2 ordering
vector<string> ranksumpt2_;
ranksumpt2_.push_back("logsumpt2");
//--- ranking product variables
vector<string> rankVariables_;
// variables order matters to resolve ties
rankVariables_.push_back("ptbal"), rankVariables_.push_back("ptasym"),rankVariables_.push_back("logsumpt2");
//--- book TMVA
int isSig, evtNumber, nVertices;
float diphopt;
float logsumpt2;
float ptbal, ptasym, ptmax, ptmax3, sumpt, nchthr, nch, sumtwd;
float dk;
TMVA::Reader *tmvaReader_ = new TMVA::Reader( "!Color:!Silent" );
tmvaReader_->AddVariable( "logsumpt2",&logsumpt2 );
tmvaReader_->AddVariable( "ptbal" , &ptbal);
tmvaReader_->AddVariable( "ptasym", &ptasym );
tmvaReader_->AddVariable( "nch",&nch );
tmvaReader_->AddVariable( "nchthr",&nchthr );
tmvaReader_->AddVariable( "ptmax" ,&ptmax );
tmvaReader_->AddVariable( "ptmax3",&ptmax3 );
tmvaReader_->AddVariable( "sumtwd",&sumtwd );
tmvaReader_->AddVariable( "dk",&dk );
tmvaReader_->BookMVA( tmvaMethod.c_str(), tmvaWeights.c_str() );
//****** BOOK OUTPUT HISTOGRAMS ******
TH1F PtAll("PtAll","Pt of boson all",80,0,400);
TH1F PtGood("PtGood","Pt of boson good",80,0,400);
TH1F PtGood_BDT("PtGood_BDT","Pt of boson good (BDT)",80,0,400);
TH1F PtGood_RANK("PtGood_RANK","Pt of boson good (RANKING)",80,0,400);
TH1F PtAll_EBEB("PtAll_EBEB","Pt of boson all",80,0,400);
TH1F PtGood_EBEB("PtGood_EBEB","Pt of boson good",80,0,400);
TH1F PtGood_BDT_EBEB("PtGood_BDT_EBEB","Pt of boson good (BDT)",80,0,400);
TH1F PtGood_RANK_EBEB("PtGood_RANK_EBEB","Pt of boson good (RANKING)",80,0,400);
TH1F PtAll_EBEE("PtAll_EBEE","Pt of boson all",80,0,400);
TH1F PtGood_EBEE("PtGood_EBEE","Pt of boson good",80,0,400);
TH1F PtGood_BDT_EBEE("PtGood_BDT_EBEE","Pt of boson good (BDT)",80,0,400);
TH1F PtGood_RANK_EBEE("PtGood_RANK_EBEE","Pt of boson good (RANKING)",80,0,400);
TH1F PtAll_EEEE("PtAll_EEEE","Pt of boson all",80,0,400);
TH1F PtGood_EEEE("PtGood_EEEE","Pt of boson good",80,0,400);
TH1F PtGood_BDT_EEEE("PtGood_BDT_EEEE","Pt of boson good (BDT)",80,0,400);
TH1F PtGood_RANK_EEEE("PtGood_RANK_EEEE","Pt of boson good (RANKING)",80,0,400);
TH1F EtaAll("EtaAll","Eta of max SC",50,-5,5);
TH1F EtaGood("EtaGood","Eta of max SC good",50,-5,5);
TH1F EtaGood_BDT("EtaGood_BDT","Eta of max SC good (BDT)",50,-5,5);
TH1F EtaGood_RANK("EtaGood_RANK","Eta of max SC good (RANKING)",50,-5,5);
TH1F NvtAll("NvtAll","number of PV all",50,0,50);
TH1F NvtGood("NvtGood","number of PV good",50,0,50);
TH1F NvtGood_BDT("NvtGood_BDT","number of PV good (BDT)",50,0,50);
TH1F NvtGood_RANK("NvtGood_RANK","number of PV good (RANKING)",50,0,50);
TH1F NpuAll("NpuAll","number of PV all",50,0,50);
TH1F NpuGood("NpuGood","number of PV good",50,0,50);
TH1F NpuGood_BDT("NpuGood_BDT","number of PV good (BDT)",50,0,50);
TH1F NpuGood_RANK("NpuGood_RANK","number of PV good (RANKING)",50,0,50);
TH1F PtGood_matchedClosest("PtGood_matchedClosest","Pt of boson good",80,0,400);
TH1F PtGood_BDT_matchedClosest("PtGood_BDT_matchedClosest","Pt of boson good (BDT)",80,0,400);
TH1F PtGood_RANK_matchedClosest("PtGood_RANK_matchedClosest","Pt of boson good (RANKING)",80,0,400);
TH1F EtaGood_matchedClosest("EtaGood_matchedClosest","Eta of max SC good",50,-5,5);
TH1F EtaGood_BDT_matchedClosest("EtaGood_BDT_matchedClosest","Eta of max SC good (BDT)",50,-5,5);
TH1F EtaGood_RANK_matchedClosest("EtaGood_RANK_matchedClosest","Eta of max SC good (RANKING)",50,-5,5);
TH1F NvtGood_matchedClosest("NvtGood_matchedClosest","number of PV good",50,0,50);
TH1F NvtGood_BDT_matchedClosest("NvtGood_BDT_matchedClosest","number of PV good (BDT)",50,0,50);
TH1F NvtGood_RANK_matchedClosest("NvtGood_RANK_matchedClosest","number of PV good (RANKING)",50,0,50);
TH1F NpuGood_matchedClosest("NpuGood_matchedClosest","number of PV good",50,0,50);
TH1F NpuGood_BDT_matchedClosest("NpuGood_BDT_matchedClosest","number of PV good (BDT)",50,0,50);
TH1F NpuGood_RANK_matchedClosest("NpuGood_RANK_matchedClosest","number of PV good (RANKING)",50,0,50);
TH2F hdist("hdist"," hdist",80,0,200,400,-10,10);
TH2F hdiff_dZ_muons("hdiff_dZ_muons","hdiff_dZ_muons",80,0,200,400,-10,10);
TH2F hdiff_dZ_electrons("hdiff_dZ_electrons","hdiff_dZ_electrons",80,0,200,400,-10,10);
TH1F BDToutput("BDToutput","BDT output",500,-1,1);
TH1F BDToutput_sig("BDToutput_sig","BDT output - signal vertices",500,-1,1);
TH1F BDToutput_bkg("BDToutput_bkg","BDT output - background",500,-1,1);
TH1F pt2h("pt2h","pt2 H",500,0,500);
TH1F pt2bkg("pt2bkg","pt2 bkg",500,0,500);
TH2F * hAcceptedLumis = new TH2F("hAcceptedLumis","hAcceptedLumis",20000, 160000, 180000, 10000, 0, 10000);
float ww = 1;
float r9cut = 0.93;
//****** LOAD TREE ******
TChain* chain = new TChain(treeName.c_str());
FillChain(*chain, inputFileList.c_str());
treeReader reader((TTree*)(chain));
std::cout<<"found "<< reader.GetEntries() <<" entries"<<std::endl;
//****** Start loop over entries ******
int runId, lumiId;
for (int u = 0; u < reader.GetEntries(); u++ )
{
if(u == entryMAX) break;
if(u < entryMIN) continue;
if(u%10000 == 0) std::cout<<"reading event "<< u <<std::endl;
reader.GetEntry(u);
//*** filter bad runs/lumis
runId = reader.GetInt("runId")->at(0);
lumiId = reader.GetInt("lumiId")->at(0);
bool skipEvent = false;
if( isData && useJSON ){
if(AcceptEventByRunAndLumiSection(runId,lumiId,jsonMap) == false)
skipEvent = true;
}
if( skipEvent == true ) continue;
hAcceptedLumis -> Fill(runId, lumiId);
//*** pu weights
std::vector<float>*PU_z ;
std::vector<int>* mc_PUit_NumInteractions;
int npu ;
if ( !isData ){
mc_PUit_NumInteractions = reader.GetInt("mc_PUit_NumInteractions");
npu = mc_PUit_NumInteractions->at(0);
//--- use weights
if (useWeights){
float myrnd = gRandom->Uniform(0,nmax);
if (myrnd > w[npu]) continue;
}
}
//*** setup common branches ***
std::vector<int>* PV_nTracks;
std::vector<float>* PV_z;
std::vector<float>* PV_d0;
std::vector<ROOT::Math::XYZVector>* PVtracks;
std::vector<int>* PVtracks_PVindex;
std::vector<int>* tracks_PVindex;
std::vector<float>* tracks_dz ; //?
std::vector<float>* tracks_dz_PV ; //?
std::vector<float>* tracks_dxy_PV ; //?
std::vector<ROOT::Math::XYZTVector>* sc; // supercluster
int accept = 0;
int indpho1 = -100;
int indpho2 = -100;
ROOT::Math::XYZTVector sum2pho;
float etaMaxSC ;
float TrueVertex_Z;
//*** selections for Hgg ***
if (isHiggs){
std::vector<ROOT::Math::XYZVector>* mc_H_vertex = reader.Get3V("mc_H_vertex");
std::vector<ROOT::Math::XYZTVector>* mcV1 = reader.Get4V("mcV1");
std::vector<ROOT::Math::XYZTVector>* mcV2 = reader.Get4V("mcV2");
std::vector<ROOT::Math::XYZTVector>* photons = reader.Get4V("photons");
std::vector<float>* photons_r9 = reader.GetFloat("photons_r9");
if (mc_H_vertex->size() != 1) continue;
PV_nTracks = reader.GetInt("PV_nTracks");
PV_z = reader.GetFloat("PV_z");
PV_d0 = reader.GetFloat("PV_d0");
PVtracks = reader.Get3V("PVtracks");
PVtracks_PVindex = reader.GetInt("PVtracks_PVindex");
tracks_PVindex = reader.GetInt("tracks_PVindex");
tracks_dxy_PV = reader.GetFloat("tracks_dxy_PV");
tracks_dz_PV = reader.GetFloat("tracks_dz_PV");
tracks_dz = reader.GetFloat("tracks_dz");
sc = reader.Get4V("photons_SC");
hggSelection(mcV1, mcV2, photons, sc, photons_r9, accept, indpho1, indpho2);
if (!accept) continue;
if ( photons_r9->at(indpho1) < r9cut ) continue;
if ( photons_r9->at(indpho2) < r9cut ) continue;
etaMaxSC = sc->at(indpho1).eta();
sum2pho = photons->at(indpho1)+ photons->at(indpho2);
TrueVertex_Z = mc_H_vertex->at(0).Z();
}// end Hgg selection
//*** selections for Zee ***
if (isZee){
std::vector<ROOT::Math::XYZTVector>* electrons = reader.Get4V("electrons");
// std::vector<float>* eleid = reader.GetFloat("simpleEleId95cIso");
// no eleID95 available for data 2011 --> compute it by hand
std::vector<float>* eleid = new std::vector<float>;
eleid->clear();
if ( electrons->size() < 2) continue;
for (unsigned int iele = 0; iele < electrons->size(); iele++){
float pt = electrons->at(iele).pt();
float tkIso = reader.GetFloat("electrons_tkIsoR03")->at(iele);
float emIso = reader.GetFloat("electrons_emIsoR03")->at(iele);
float hadIso = reader.GetFloat("electrons_hadIsoR03_depth1")->at(iele) + reader.GetFloat("electrons_hadIsoR03_depth2")->at(iele);
float combIso = tkIso + emIso + hadIso;
int isEB = reader.GetInt("electrons_isEB")->at(iele);
float sigmaIetaIeta = reader.GetFloat("electrons_sigmaIetaIeta")->at(iele);
float DetaIn = reader.GetFloat("electrons_deltaEtaIn")->at(iele);
float DphiIn = reader.GetFloat("electrons_deltaPhiIn")->at(iele);
float HOverE = reader.GetFloat("electrons_hOverE")->at(iele);
int mishits = reader.GetInt("electrons_mishits")->at(iele);
float id = eleId95 ( pt, tkIso, emIso, hadIso, combIso, isEB, sigmaIetaIeta, DetaIn, DphiIn, HOverE, mishits);
id *= 7.; // to emulate simpleEleId95cIso
eleid->push_back( id );
}
std::vector<float>* electrons_dz_PV_noEle = reader.GetFloat("electrons_dz_PV_noEle");
PV_nTracks = reader.GetInt("PV_noEle_nTracks");
PV_z = reader.GetFloat("PV_noEle_z");
PV_d0 = reader.GetFloat("PV_noEle_d0");
PVtracks = reader.Get3V("PVEleLessTracks");
PVtracks_PVindex = reader.GetInt("PVEleLessTracks_PVindex");
tracks_PVindex = reader.GetInt("tracks_PVindex");
tracks_dxy_PV = reader.GetFloat("tracks_dxy_PV");
tracks_dz_PV = reader.GetFloat("tracks_dz_PV");
tracks_dz = reader.GetFloat("tracks_dz");
//sc = reader.Get4V("electrons_SC");
sc = reader.Get4V("electrons");
zeeSelection(electrons, eleid, accept, indpho1, indpho2);
if (!accept) continue;
etaMaxSC = sc->at(indpho1).eta();
sum2pho = electrons->at(indpho1)+ electrons->at(indpho2);
TrueVertex_Z = PV_z->at(0) + (electrons_dz_PV_noEle->at(indpho1) + electrons_dz_PV_noEle->at(indpho2))/2.;
hdiff_dZ_electrons.Fill( sum2pho.pt(), electrons_dz_PV_noEle->at(indpho1) - electrons_dz_PV_noEle->at(indpho2) );
}
//*** selections for Zmumu
if ( isZmumu ){
std::vector<ROOT::Math::XYZTVector>* muons = reader.Get4V("muons");
std::vector<int>* muons_global = reader.GetInt("muons_global");
std::vector<int>* muons_tracker = reader.GetInt("muons_tracker");
std::vector<float>* muons_tkIsoR03 = reader.GetFloat("muons_tkIsoR03");
std::vector<float>* muons_normalizedChi2 = reader.GetFloat("muons_normalizedChi2");
std::vector<int>* muons_numberOfValidMuonHits = reader.GetInt("muons_numberOfValidMuonHits");
std::vector<int>* muons_numberOfValidPixelHits = reader.GetInt("muons_numberOfValidPixelHits");
std::vector<float>* muons_dxy_PV = reader.GetFloat("muons_dxy_PV");
std::vector<float>* muons_dz_PV = reader.GetFloat("muons_dz_PV");
std::vector<float>* muons_dz_PV_noMuon = reader.GetFloat("muons_dz_PV_noMuon");
PV_nTracks = reader.GetInt("PV_noMuon_nTracks");
PV_z = reader.GetFloat("PV_noMuon_z");
PV_d0 = reader.GetFloat("PV_noMuon_d0");
PVtracks = reader.Get3V("PVMuonLessTracks");
PVtracks_PVindex = reader.GetInt("PVMuonLessTracks_PVindex");
tracks_PVindex = reader.GetInt("tracks_PVindex");
tracks_dxy_PV = reader.GetFloat("tracks_dxy_PV");
tracks_dz_PV = reader.GetFloat("tracks_dz_PV");
tracks_dz = reader.GetFloat("tracks_dz");
sc = reader.Get4V("muons"); // use muon info for SC
zmumuSelection(muons,muons_global,muons_tracker, muons_tkIsoR03,
muons_normalizedChi2 ,
muons_numberOfValidMuonHits,
muons_numberOfValidPixelHits,
muons_dxy_PV,
muons_dz_PV,
accept, indpho1, indpho2);
if (!accept) continue;
etaMaxSC = muons->at(indpho1).eta();
sum2pho = muons->at(indpho1)+ muons->at(indpho2);
TrueVertex_Z = PV_z->at(0) + (muons_dz_PV_noMuon->at(indpho1) + muons_dz_PV_noMuon->at(indpho2))/2.;
hdiff_dZ_muons.Fill( sum2pho.pt(), muons_dz_PV_noMuon->at(indpho1) - muons_dz_PV_noMuon->at(indpho2) );
if ( fabs(muons_dz_PV_noMuon->at(indpho1) - muons_dz_PV_noMuon->at(indpho2))> 0.5) continue;
}//Zmumu end
// branches buffers
int nvtx_;
float vtxx_[1000], vtxy_[1000], vtxz_[1000];
int ntracks_;
float tkpx_[1000], tkpy_[1000], tkpz_[1000], tkPtErr_[1000], tkWeight_[1000],
tkd0_[1000], tkd0Err_[1000], tkdz_[1000], tkdzErr_[1000];
int tkVtxId_[1000];
bool tkIsHighPurity_[1000];
float phocalox_[100], phocaloy_[100], phocaloz_[100], phoen_[100];
// set variables
// vertices
nvtx_ = (int) PV_z->size();
for ( int iv = 0; iv < nvtx_; iv++){
vtxx_[iv] = 0;
vtxy_[iv] = 0;
vtxz_[iv] = PV_z->at(iv) ;
}
// tracks
ntracks_ = PVtracks->size();
for (int itrk = 0; itrk <ntracks_; itrk++ ){
tkpx_[itrk] = PVtracks->at(itrk).X();
tkpy_[itrk] = PVtracks->at(itrk).Y();
tkpz_[itrk] = PVtracks->at(itrk).Z();
tkPtErr_[itrk] = 0;
tkVtxId_[itrk] = PVtracks_PVindex->at(itrk);
tkWeight_[itrk]= 1.;
tkd0_[itrk] = 0;
tkd0Err_[itrk] = 0;
tkdz_[itrk] = 0;
tkdzErr_[itrk] = 0;
tkIsHighPurity_[itrk]= 1.;
}
// photons
for (int ipho = 0 ; ipho < sc->size(); ipho++){
float px = sc->at(ipho).X();
float py = sc->at(ipho).Y();
float pz = sc->at(ipho).Z();
float pt = sqrt ( px*px+py*py );
float theta = 2*atan(exp(-sc->at(ipho).eta()) );
float tantheta = tan(theta);
if ( fabs(sc->at(ipho).eta()) < etaEB ) {
phocalox_[ipho] = R_ECAL*px/pt;
phocaloy_[ipho] = R_ECAL*py/pt;
phocaloz_[ipho] = R_ECAL/tantheta;
}
if ( fabs(sc->at(ipho).eta()) > etaEE ) {
float r_endcap = fabs(Z_ENDCAP * tantheta);
phocalox_[ipho] = r_endcap * px/pt;
phocaloy_[ipho] = r_endcap * py/pt;
if (pz > 0) phocaloz_[ipho] = Z_ENDCAP;
else phocaloz_[ipho] = -Z_ENDCAP;
}
phoen_[ipho] = sc->at(ipho).E();
}
float eta1 = sc->at(indpho1).eta();
float eta2 = sc->at(indpho2).eta();
if ( (fabs(eta1) > etaEB && fabs(eta1) < etaEE) || fabs(eta1) > 2.5) continue;
if ( (fabs(eta2) > etaEB && fabs(eta2) < etaEE) || fabs(eta2) > 2.5) continue;
//*** set vertex info
TupleVertexInfo vinfo( nvtx_, vtxx_ , vtxy_, vtxz_, ntracks_, tkpx_, tkpy_, tkpz_, tkPtErr_, tkVtxId_, tkWeight_, tkd0_, tkd0Err_,tkdz_, tkdzErr_ , tkIsHighPurity_);
//*** set photon info
PhotonInfo pho1(indpho1, TVector3(phocalox_[indpho1],phocaloy_[indpho1],phocaloz_[indpho1]),phoen_[indpho1]);
PhotonInfo pho2(indpho2, TVector3(phocalox_[indpho2],phocaloy_[indpho2],phocaloz_[indpho2]),phoen_[indpho2]);
//*** vertex analyzer
HggVertexAnalyzer vAna(vtxAlgoParams_,nvtx_);
vAna.analyze(vinfo,pho1,pho2);
// if Zmumu : setNconv to zero
if (isZmumu) vAna.setNConv(0);
//*** preselect vertices
std::vector<int> presel;
for(int i=0; i<nvtx_; i++) {
presel.push_back(i);
}
vAna.preselection(presel);
//*** Look if the H vertex matches one of the PV vertices
float dmin = 10000;
int iClosest = -1;
for ( int uu = 0; uu < nvtx_; uu++){
float distt = fabs( PV_z->at(uu) - TrueVertex_Z );
if ( distt < dmin) { dmin = distt; iClosest = uu; }
}
//*** NOW FILL HISTOGRAMS
PtAll.Fill( sum2pho.pt(),ww );
if (fabs(eta1) < etaEB && fabs(eta2) < etaEB) PtAll_EBEB.Fill( sum2pho.pt(),ww );
if (fabs(eta1) > etaEE && fabs(eta2) > etaEE) PtAll_EEEE.Fill( sum2pho.pt(),ww );
if ( (fabs(eta1) < etaEB && fabs(eta2) > etaEE) || (fabs(eta2) < etaEB && fabs(eta1) > etaEE)) PtAll_EBEE.Fill( sum2pho.pt(),ww );
EtaAll.Fill( etaMaxSC ,ww);
NvtAll.Fill( nvtx_,ww );
if (!isData) NpuAll.Fill(npu,ww);
//*** SUMPT2 CRITERION
vector<int> ranksumpt2 = vAna.rankprod(ranksumpt2_);
//-- matching 1cm
if ( fabs( TrueVertex_Z - PV_z->at(ranksumpt2[0]) ) < 1.) {
PtGood.Fill( sum2pho.pt(),ww );
EtaGood.Fill( etaMaxSC ,ww);
NvtGood.Fill( nvtx_ ,ww);
if (!isData) NpuGood.Fill(npu,ww);
}
//-- matching closest vtx
if ( iClosest == ranksumpt2[0]){
PtGood_matchedClosest.Fill( sum2pho.pt(),ww );
EtaGood_matchedClosest.Fill( etaMaxSC ,ww);
NvtGood_matchedClosest.Fill( nvtx_ ,ww);
if (!isData) NpuGood_matchedClosest.Fill(npu,ww);
}
//*** RANKING PRODUCT
vector<int> rankprod = vAna.rankprod(rankVariables_);
//-- matching 1cm
if ( fabs( TrueVertex_Z - PV_z->at(rankprod[0]) ) < 1.) {
PtGood_RANK.Fill( sum2pho.pt(),ww );
EtaGood_RANK.Fill( etaMaxSC ,ww);
NvtGood_RANK.Fill( nvtx_,ww );
if (!isData) NpuGood_RANK.Fill(npu,ww);
}
//-- matching closest vtx
if ( iClosest == rankprod[0]){
PtGood_RANK_matchedClosest.Fill( sum2pho.pt(),ww );
EtaGood_RANK_matchedClosest.Fill( etaMaxSC ,ww);
NvtGood_RANK_matchedClosest.Fill( nvtx_,ww );
if (!isData) NpuGood_RANK_matchedClosest.Fill(npu,ww);
}
//*** BDT
int TMVAind = -1;
float TMVAmax = -1000.;
for ( int uu = 0; uu < nvtx_; uu++){
diphopt = vAna.diphopt(uu);
logsumpt2 = vAna.logsumpt2(uu);
nch = vAna.nch(uu);
nchthr = vAna.nchthr(uu);
ptbal = vAna.ptbal(uu);
ptasym = vAna.ptasym(uu);
ptmax = vAna.ptmax(uu);
ptmax3 = vAna.ptmax3(uu);
sumtwd = vAna.sumtwd(uu);
htemp->Reset();
for (unsigned int kk = 0; kk < PVtracks->size(); ++kk){
if (PVtracks_PVindex->at(kk) == uu){
float tkpt = sqrt(PVtracks->at(kk).perp2()) ;
htemp ->Fill( (tkpt < 10. ? tkpt : 10.) );
}
}
if ( htemp->GetEntries()!=0 )
dk = htemp->KolmogorovTest(hTrackPt);
//--- Evaluate TMVA
Double_t mva = tmvaReader_->EvaluateMVA( "BDTG" );
BDToutput.Fill( mva );
if ( fabs( TrueVertex_Z - PV_z->at(uu) ) < 1.)
BDToutput_sig.Fill( mva );
else
BDToutput_bkg.Fill( mva );
// take the highest score
if ( mva > TMVAmax) {
TMVAmax = mva;
TMVAind = uu;
}
} // end loop over vertices
//-- matching 1cm
if ( fabs( TrueVertex_Z - PV_z->at(TMVAind) ) < 1.) {
PtGood_BDT.Fill( sum2pho.pt(),ww );
EtaGood_BDT.Fill( etaMaxSC ,ww);
NvtGood_BDT.Fill( nvtx_ ,ww);
if (!isData) NpuGood_BDT.Fill(npu,ww);
}
//-- matching closest vtx
if ( iClosest == TMVAind){
PtGood_BDT_matchedClosest.Fill( sum2pho.pt(),ww );
EtaGood_BDT_matchedClosest.Fill( etaMaxSC ,ww);
NvtGood_BDT_matchedClosest.Fill( nvtx_,ww );
if (!isData) NpuGood_BDT_matchedClosest.Fill(npu,ww);
}
}// end loop over entries
std::cout << "END LOOP OVER ENTRIES" << std::endl;
std::cout << "Saving histos on file ..." << std::endl;
TFile ff( (outputRootFilePath+outputRootFileName).c_str(),"recreate");
hAcceptedLumis -> Write();
PtAll.Write();
PtGood.Write();
PtGood_BDT.Write();
PtGood_RANK.Write();
EtaAll.Write();
EtaGood.Write();
EtaGood_BDT.Write();
EtaGood_RANK.Write();
NvtAll.Write();
NvtGood.Write();
NvtGood_BDT.Write();
NvtGood_RANK.Write();
NpuAll.Write();
NpuGood.Write();
NpuGood_BDT.Write();
NpuGood_RANK.Write();
PtGood_matchedClosest.Write();
PtGood_BDT_matchedClosest.Write();
PtGood_RANK_matchedClosest.Write();
EtaGood_matchedClosest.Write();
EtaGood_BDT_matchedClosest.Write();
EtaGood_RANK_matchedClosest.Write();
NvtGood_matchedClosest.Write();
NvtGood_BDT_matchedClosest.Write();
NvtGood_RANK_matchedClosest.Write();
NpuGood_matchedClosest.Write();
NpuGood_BDT_matchedClosest.Write();
NpuGood_RANK_matchedClosest.Write();
hdist.Write();
hdiff_dZ_muons.Write();
hdiff_dZ_electrons.Write();
BDToutput.Write();
BDToutput_sig.Write();
BDToutput_bkg.Write();
ff.Close();
std::cout << "BYE BYE !!!! " << std::endl;
return 0;
}
void fullPedestalAnalysis(string inputDIR, string outputDIR, string inputCablingMap, string outputFileName){
gROOT->ProcessLine("gErrorIgnoreLevel = 1");
// open the file and prepare the cluster tree, adding the other trees as frined --> memory consuming
std::cout<<"##################################"<<std::endl;
std::cout<<"###### fullPedestalAnalysis ######"<<std::endl;
std::cout<<"##################################"<<std::endl;
clock_t tStart = clock();
// prepare style and load macros
setTDRStyle();
gROOT->SetBatch(kTRUE);
system(("mkdir -p "+outputDIR).c_str());
ifstream file;
std::cout<<"### Make input file list"<<std::endl;
system(("find "+inputDIR+" -name \"*.root\" > file.temp").c_str());
std::ifstream infile;
string line;
vector<string> fileList;
infile.open("file.temp",ifstream::in);
if(infile.is_open()){
while(!infile.eof()){
getline(infile,line);
if(line != "" and TString(line).Contains(".root") and line !="\n"){
fileList.push_back(line);
}
}
}
system("rm file.temp");
std::sort(fileList.begin(),fileList.end());
TFile* cablingFile = TFile::Open(inputCablingMap.c_str(),"READ");
cablingFile->cd();
TTree* readoutMap = (TTree*) cablingFile->FindObjectAny("readoutMap");
TTreeReader reader(readoutMap);
TTreeReaderValue<uint32_t> detid (reader,"detid");
TTreeReaderValue<uint16_t> fecCrate (reader,"fecCrate");
TTreeReaderValue<uint16_t> fecSlot (reader,"fecSlot");
TTreeReaderValue<uint16_t> fecRing (reader,"fecRing");
TTreeReaderValue<uint16_t> ccuAdd (reader,"ccuAdd");
TTreeReaderValue<uint16_t> ccuChan (reader,"ccuChan");
TTreeReaderValue<uint16_t> lldChannel (reader,"lldChannel");
TTreeReaderValue<uint16_t> fedId (reader,"fedId");
TTreeReaderValue<uint16_t> fedCh (reader,"fedCh");
// output tree
TFile* ouputTreeFile = new TFile((outputDIR+"/"+outputFileName).c_str(),"RECREATE");
ouputTreeFile->cd();
ouputTreeFile->SetCompressionLevel(0);
TTree* outputTree = new TTree("pedestalFullNoise","pedestalFullNoise");
// branches
uint32_t detid_,fedKey_;
uint16_t fecCrate_,fecSlot_, fecRing_, ccuAdd_, ccuChan_, lldChannel_, fedId_, fedCh_, apvId_, stripId_;
float noiseMean_,noiseRMS_, noiseSkewness_, noiseKurtosis_;
float fitChi2_, fitChi2Probab_, fitStatus_;
float fitGausMean_, fitGausSigma_, fitGausNormalization_;
float fitGausMeanError_, fitGausSigmaError_, fitGausNormalizationError_;
float noiseIntegral3Sigma_, noiseIntegral3SigmaFromFit_;
float noiseIntegral4Sigma_, noiseIntegral4SigmaFromFit_;
float noiseIntegral5Sigma_, noiseIntegral5SigmaFromFit_;
float kSValue_, kSProbab_, jBValue_, jBProbab_, aDValue_, aDProbab_;
vector<float> noiseDistribution_, noiseDistributionError_;
float xMin_, xMax_, nBin_ ;
outputTree->Branch("detid",&detid_,"detid/i");
outputTree->Branch("fedKey",&fedKey_,"fedKey/i");
outputTree->Branch("fecCrate",&fecCrate_,"fecCrate/s");
outputTree->Branch("fecSlot",&fecSlot_,"fecSlot/s");
outputTree->Branch("fecRing",&fecRing_,"fecRing/s");
outputTree->Branch("ccuAdd",&ccuAdd_,"ccuAdd/s");
outputTree->Branch("ccuChan",&ccuChan_,"ccuChan/s");
outputTree->Branch("lldChannel",&lldChannel_,"lldChannel/s");
outputTree->Branch("fedId",&fedId_,"fedId/s");
outputTree->Branch("fedCh",&fedCh_,"fedCh/s");
outputTree->Branch("apvId",&apvId_,"apvId/s");
outputTree->Branch("stripId",&stripId_,"stripId/s");
outputTree->Branch("noiseMean",&noiseMean_,"noiseMean/F");
outputTree->Branch("noiseRMS",&noiseRMS_,"noiseRMS/F");
outputTree->Branch("noiseSkewness",&noiseSkewness_,"noiseSkewness/F");
outputTree->Branch("noiseKurtosis",&noiseKurtosis_,"noiseKurtosis/F");
outputTree->Branch("fitGausNormalization",&fitGausNormalization_,"fitGausNormalization/F");
outputTree->Branch("fitGausMean",&fitGausMean_,"fitGausMean/F");
outputTree->Branch("fitGausSigma",&fitGausSigma_,"fitGausSigma/F");
outputTree->Branch("fitGausNormalizationError",&fitGausNormalizationError_,"fitGausNormalizationError/F");
outputTree->Branch("fitGausMeanError",&fitGausMeanError_,"fitGausMeanError/F");
outputTree->Branch("fitGausSigmaError",&fitGausSigmaError_,"fitGausSigmaError/F");
outputTree->Branch("fitChi2",&fitChi2_,"fitChi2/F");
outputTree->Branch("fitChi2Probab",&fitChi2Probab_,"fitChi2Probab/F");
outputTree->Branch("fitStatus",&fitStatus_,"fitStatus_F");
outputTree->Branch("noiseIntegral3Sigma",&noiseIntegral3Sigma_,"noiseIntegral3Sigma/F");
outputTree->Branch("noiseIntegral3SigmaFromFit",&noiseIntegral3SigmaFromFit_,"noiseIntegral3SigmaFromFit/F");
outputTree->Branch("noiseIntegral4Sigma",&noiseIntegral4Sigma_,"noiseIntegral4Sigma/F");
outputTree->Branch("noiseIntegral4SigmaFromFit",&noiseIntegral4SigmaFromFit_,"noiseIntegral4SigmaFromFit/F");
outputTree->Branch("noiseIntegral5Sigma",&noiseIntegral4Sigma_,"noiseIntegral5Sigma/F");
outputTree->Branch("noiseIntegral5SigmaFromFit",&noiseIntegral4SigmaFromFit_,"noiseIntegral5SigmaFromFit/F");
outputTree->Branch("kSValue",&kSValue_,"kSValue/F");
outputTree->Branch("jBValue",&jBValue_,"jBValue/F");
outputTree->Branch("aDValue",&aDValue_,"aDValue/F");
outputTree->Branch("kSProbab",&kSProbab_,"kSProbab/F");
outputTree->Branch("jBProbab",&jBProbab_,"jBProbab/F");
outputTree->Branch("aDProbab",&aDProbab_,"aDProbab/F");
outputTree->Branch("xMin",&xMin_,"xMin/F");
outputTree->Branch("xMax",&xMax_,"xMax/F");
outputTree->Branch("nBin",&nBin_,"nBin/F");
bool histoBranches = false;
// Loop on the file list to extract each histogram 2D DQM histo with full noise distribution
TH1F* histoNoiseStrip = NULL;
TF1* fitFunc = NULL;
TH1F* randomHisto = NULL;
TFitResultPtr result;
for(auto file : fileList){
cout<<"input file: "<<file<<endl;
TFile* inputFile = TFile::Open(file.c_str(),"READ");
inputFile->cd();
// take into account that the DQM file structure for strips is always the same --> use cabling map to browse the histograms
reader.SetEntry(0);
TH2* histoNoise = NULL;
long int iChannel = 0;
int noFitResult = 0;
while(reader.Next()){
cout.flush();
if(iChannel %10 == 0) cout<<"\r"<<"iChannel "<<100*double(iChannel)/(readoutMap->GetEntries()/reductionFactor)<<" % ";
if(iChannel > double(readoutMap->GetEntries())/reductionFactor) break;
iChannel++;
TString objName;
uint32_t fedKey = SiStripFedKey(*fedId,SiStripFedKey::feUnit(*fedCh),SiStripFedKey::feChan(*fedCh)).key();
std::stringstream stream;
stream << std::hex << fedKey;
string fedKeyStr = stream.str();
if(fedKeyStr.size() == 4)
objName = Form("DQMData/SiStrip/ControlView/FecCrate%d/FecSlot%d/FecRing%d/CcuAddr%d/CcuChan%d/ExpertHisto_PedsFullNoise_FedKey0x0000%s_LldChannel%d_Noise2D",*fecCrate,*fecSlot,*fecRing,*ccuAdd,*ccuChan,fedKeyStr.c_str(),*lldChannel);
else if(fedKeyStr.size() == 5)
objName = Form("DQMData/SiStrip/ControlView/FecCrate%d/FecSlot%d/FecRing%d/CcuAddr%d/CcuChan%d/ExpertHisto_PedsFullNoise_FedKey0x000%s_LldChannel%d_Noise2D",*fecCrate,*fecSlot,*fecRing,*ccuAdd,*ccuChan,fedKeyStr.c_str(),*lldChannel);
else
cerr<<"hex number to short "<<fedKeyStr<<" --> please check "<<endl;
inputFile->GetObject(objName.Data(),histoNoise);
// extract single strip noise histogram --> loop on the y-axis
uint16_t apvID = 0;
uint16_t stripID = 0;
if(histoNoiseStrip == 0 or histoNoiseStrip == NULL){
histoNoiseStrip = new TH1F ("histoNoiseStrip","",histoNoise->GetNbinsX(),histoNoise->GetXaxis()->GetXmin(),histoNoise->GetXaxis()->GetXmax());
histoNoiseStrip->Sumw2();
}
for(int iBinY = 0; iBinY < histoNoise->GetNbinsY(); iBinY++){
histoNoiseStrip->Reset();
histoNoiseStrip->SetDirectory(0);
// two multiplexed APV per line
if(iBinY < histoNoise->GetNbinsY()/2) apvID = 1;
else apvID = 2;
// strip id
stripID++;
if(stripID > 128) stripID = 1;
// loop on x-axis bin
for(int iBinX = 0; iBinX < histoNoise->GetNbinsX(); iBinX++){
histoNoiseStrip->SetBinContent(iBinX+1,histoNoise->GetBinContent(iBinX+1,iBinY+1));
histoNoiseStrip->SetBinError(iBinX+1,histoNoise->GetBinError(iBinX+1,iBinY+1));
}
// to initialize branches
detid_ = 0; fedKey_ = 0; fecCrate_ = 0; fecSlot_ = 0; fecRing_ = 0; ccuAdd_ = 0; ccuChan_ = 0; lldChannel_ = 0; fedId_ = 0; fedCh_ = 0; apvId_ = 0; stripId_ = 0;
noiseMean_ = 0.; noiseRMS_ = 0.; noiseSkewness_ = 0.; noiseKurtosis_ = 0.;
fitGausMean_ = 0.; fitGausSigma_ = 0.;fitGausNormalization_ = 0.;
fitGausMeanError_ = 0.; fitGausSigmaError_ = 0.;fitGausNormalizationError_ = 0.;
fitChi2_ = 0.; fitChi2Probab_ = 0.; fitStatus_ = -1.;
noiseIntegral3Sigma_ = 0.; noiseIntegral3SigmaFromFit_ = 0.;
noiseIntegral4Sigma_ = 0.; noiseIntegral4SigmaFromFit_ = 0.;
noiseIntegral5Sigma_ = 0.; noiseIntegral5SigmaFromFit_ = 0.;
kSProbab_ = 0.; jBProbab_ = 0.;
kSValue_ = 0.; jBValue_ = 0.;
aDValue_= 0.; aDProbab_ = 0.;
nBin_ = 0.; xMin_ = 0.; xMax_ = 0.;
// basic info
detid_ = *detid;
fedKey_ = fedKey;
fecCrate_ = *fecCrate;
fecSlot_ = *fecSlot;
fecRing_ = *fecRing;
ccuAdd_ = *ccuAdd;
ccuChan_ = *ccuChan;
lldChannel_ = *lldChannel;
fedId_ = *fedId;
fedCh_ = *fedCh;
apvId_ = apvID;
stripId_ = stripID;
// basic info of nioise distribution
noiseMean_ = histoNoiseStrip->GetMean();
noiseRMS_ = histoNoiseStrip->GetRMS();
noiseSkewness_ = histoNoiseStrip->GetSkewness();
noiseKurtosis_ = histoNoiseStrip->GetKurtosis();
float integral = histoNoiseStrip->Integral();
noiseIntegral3Sigma_ = (histoNoiseStrip->Integral(histoNoiseStrip->FindBin(noiseMean_+noiseRMS_*3),histoNoiseStrip->GetNbinsX()+1) + histoNoiseStrip->Integral(0,histoNoiseStrip->FindBin(noiseMean_-noiseRMS_*3)))/integral;
noiseIntegral4Sigma_ = (histoNoiseStrip->Integral(histoNoiseStrip->FindBin(noiseMean_+noiseRMS_*4),histoNoiseStrip->GetNbinsX()+1) + histoNoiseStrip->Integral(0,histoNoiseStrip->FindBin(noiseMean_-noiseRMS_*4)))/integral;
noiseIntegral5Sigma_ = (histoNoiseStrip->Integral(histoNoiseStrip->FindBin(noiseMean_+noiseRMS_*5),histoNoiseStrip->GetNbinsX()+1) + histoNoiseStrip->Integral(0,histoNoiseStrip->FindBin(noiseMean_-noiseRMS_*5)))/integral;
// make a gaussian fit
if(fitFunc == NULL or fitFunc == 0){
fitFunc = new TF1 ("fitFunc","gaus(0)",histoNoise->GetXaxis()->GetXmin(),histoNoise->GetXaxis()->GetXmax());
}
fitFunc->SetRange(histoNoise->GetXaxis()->GetXmin(),histoNoise->GetXaxis()->GetXmax());
fitFunc->SetParameters(histoNoiseStrip->Integral(),noiseMean_,noiseRMS_);
result = histoNoiseStrip->Fit(fitFunc,"QSR");
if(result.Get()){
fitStatus_ = result->Status();
fitGausNormalization_ = fitFunc->GetParameter(0);
fitGausMean_ = fitFunc->GetParameter(1);
fitGausSigma_ = fitFunc->GetParameter(2);
fitGausNormalizationError_ = fitFunc->GetParError(0);
fitGausMeanError_ = fitFunc->GetParError(1);
fitGausSigmaError_ = fitFunc->GetParError(2);
fitChi2_ = result->Chi2();
fitChi2Probab_ = result->Prob();
noiseIntegral3SigmaFromFit_ = (histoNoiseStrip->Integral(histoNoiseStrip->FindBin(noiseMean_+fitGausSigma_*3),histoNoiseStrip->GetNbinsX()+1) + histoNoiseStrip->Integral(0,histoNoiseStrip->FindBin(noiseMean_-fitGausSigma_*3)))/histoNoiseStrip->Integral();
noiseIntegral4SigmaFromFit_ = (histoNoiseStrip->Integral(histoNoiseStrip->FindBin(noiseMean_+fitGausSigma_*4),histoNoiseStrip->GetNbinsX()+1) + histoNoiseStrip->Integral(0,histoNoiseStrip->FindBin(noiseMean_-fitGausSigma_*4)))/histoNoiseStrip->Integral();
noiseIntegral5SigmaFromFit_ = (histoNoiseStrip->Integral(histoNoiseStrip->FindBin(noiseMean_+fitGausSigma_*5),histoNoiseStrip->GetNbinsX()+1) + histoNoiseStrip->Integral(0,histoNoiseStrip->FindBin(noiseMean_-fitGausSigma_*5)))/histoNoiseStrip->Integral();
jBValue_ = (histoNoiseStrip->Integral()/6)*(noiseSkewness_*noiseSkewness_+(noiseKurtosis_*noiseKurtosis_)/4);
jBProbab_ = ROOT::Math::chisquared_cdf_c(jBValue_,2);
if(randomHisto == 0 or randomHisto == NULL)
randomHisto = (TH1F*) histoNoiseStrip->Clone("randomHisto");
randomHisto->Reset();
randomHisto->SetDirectory(0);
if(integral != 0){
if(generateRandomDistribution){
randomHisto->FillRandom("fitFunc",histoNoiseStrip->Integral());
kSValue_ = histoNoiseStrip->KolmogorovTest(randomHisto,"MN");
kSProbab_ = histoNoiseStrip->KolmogorovTest(randomHisto,"N");
aDValue_ = histoNoiseStrip->AndersonDarlingTest(randomHisto,"T");
aDProbab_ = histoNoiseStrip->AndersonDarlingTest(randomHisto);
}
else{
randomHisto->Add(fitFunc);
kSValue_ = histoNoiseStrip->KolmogorovTest(randomHisto,"MN");
kSProbab_ = histoNoiseStrip->KolmogorovTest(randomHisto,"N");
// AD test
ROOT::Fit::BinData data1;
ROOT::Fit::BinData data2;
ROOT::Fit::FillData(data1,histoNoiseStrip,0);
data2.Initialize(randomHisto->GetNbinsX()+1,1);
for(int ibin = 0; ibin < randomHisto->GetNbinsX(); ibin++){
if(histoNoiseStrip->GetBinContent(ibin+1) != 0 or randomHisto->GetBinContent(ibin+1) >= 1)
data2.Add(randomHisto->GetBinCenter(ibin+1),randomHisto->GetBinContent(ibin+1),randomHisto->GetBinError(ibin+1));
}
double probab;
double value;
ROOT::Math::GoFTest::AndersonDarling2SamplesTest(data1,data2,probab,value);
aDValue_ = value;
aDProbab_ = probab;
}
}
}
else
noFitResult++;
if(not histoBranches){
noiseDistribution_.clear();
noiseDistributionError_.clear();
outputTree->Branch("noiseDistribution","vector<float>",&noiseDistribution_);
outputTree->Branch("noiseDistributionError","vector<float>",&noiseDistributionError_);
histoBranches = true;
}
// set histogram
noiseDistribution_.clear();
noiseDistributionError_.clear();
for(int iBin = 0; iBin < histoNoiseStrip->GetNbinsX(); iBin++){
noiseDistribution_.push_back(histoNoiseStrip->GetBinContent(iBin+1));
noiseDistributionError_.push_back(histoNoiseStrip->GetBinError(iBin+1));
}
nBin_ = histoNoiseStrip->GetNbinsX();
xMin_ = histoNoise->GetXaxis()->GetBinLowEdge(1);
xMax_ = histoNoise->GetXaxis()->GetBinLowEdge(histoNoise->GetNbinsX()+1);
// fill all branches for each strip
ouputTreeFile->cd();
outputTree->Fill();
}
}
inputFile->Close();
std::cout<<std::endl;
cout<<"No fit results found for "<<100*double(noFitResult)/iChannel<<endl;
}
outputTree->BuildIndex("detid");
outputTree->Write(outputTree->GetName(),TObject::kOverwrite);
ouputTreeFile->Close();
cablingFile->Close();
/* Do your stuff here */
cout<<"Time taken: "<<(double)(clock() - tStart)/CLOCKS_PER_SEC<<endl;
}
