void covertQuan(){
TFile *fin = TFile::Open("pPb.root");
// TFile *fout = new TFile("pPb_xq.root","Recreate");
int mult[4] = {120,150,185,220};
int n[4] = {2,4,6,8};
for(int i=0;i<4;i++){
for(int j=0;j<4;j++){
TGraphErrors *g = (TGraphErrors*)fin->Get(Form("v2Pt_%d_%d",n[j],mult[i]));
if(n[j]==4){
cout<<mult[i]<<endl;
for(int ibin=0;ibin<g->GetN();ibin++){
cout<<g->GetX()[ibin]<<",";
}
cout<<endl;
for(int ibin=0;ibin<g->GetN();ibin++){
cout<<g->GetY()[ibin]<<",";
}
cout<<endl;
for(int ibin=0;ibin<g->GetN();ibin++){
cout<<g->GetEY()[ibin]<<",";
}
cout<<endl;
}
// fout->cd();
// g->Write("AP");
// g1->Write();
}
}
}
void add_point( double coefover, double sigma, double dsigma ){//============================================================
TGraphErrors *fisig;
if ( gROOT->GetListOfSpecials()->FindObject("fisig")!=NULL ){
fisig=(TGraphErrors*) gROOT->GetListOfSpecials()->FindObject("fisig");
printf("fisig exists\n%s","");
}else{
printf("\n\n NO fisig exists NONONO \n\n\n%s","");
fisig=new TGraphErrors();
fisig->SetTitle("fisig");
fisig->SetName("fisig");
gROOT->GetListOfSpecials()->Add( fisig );// TRICK TO KEEP IT
gDirectory->Add( fisig );
fisig->SetMarkerStyle(7);
}
int n=fisig->GetN();
fisig->SetPoint(n,coefover,sigma);
fisig->SetPointError(n,0.0,dsigma);
// fisig->Print(); // too many data
char text[100];
sprintf(text,"%.3f ... %d",coefover, fisig->GetN() );
// TText *t=new TText(from,0,text );
// t->SetTextSize(0.08);t->Draw();
}//============================================================
void JEC_fit_Uncertainty(int N)
{
TF1 *func[1000];
TFile *inf = new TFile("L3Graphs_test_Icone5.root");
TGraphErrors *g = (TGraphErrors*)inf->Get("Correction_vs_CaloPt");
TGraphErrors *vg[1000];
int i,k;
double x[20],y[20],ex[20],ey[20];
double vx[20],vy[20],vex[20],vey[20];
for(i=0;i<g->GetN();i++)
{
g->GetPoint(i,x[i],y[i]);
ex[i]=g->GetErrorX(i);
ey[i]=g->GetErrorY(i);
}
TRandom *rnd = new TRandom();
rnd->SetSeed(0);
for(k=0;k<N;k++)
{
for(i=0;i<g->GetN();i++)
{
vx[i] = rnd->Gaus(x[i],ex[i]);
//vx[i] = x[i];
vy[i] = rnd->Gaus(y[i],ey[i]);
vex[i] = ex[i];
vey[i] = ey[i];
}
vg[k] = new TGraphErrors(g->GetN(),vx,vy,vex,vey);
func[k] = new TF1("func","[0]+[1]/(pow(log10(x),[2])+[3])",1,2000);
func[k]->SetParameters(1,3,6,5);
vg[k]->Fit(func[k],"RQ");
}
TCanvas *c = new TCanvas("c","c");
gPad->SetLogx();
g->SetMarkerStyle(20);
g->SetMaximum(3.5);
g->Draw("AP");
for(k=0;k<N;k++)
{
func[k]->SetLineColor(5);
func[k]->SetLineWidth(1);
cout<<func[k]->GetChisquare()<<endl;
vg[k]->SetMarkerColor(2);
vg[k]->SetLineColor(2);
vg[k]->SetMarkerStyle(21);
//if (func[k]->GetChisquare()<0.1)
//vg[k]->Draw("sameP");
func[k]->Draw("same");
}
}
int RampCorrellation_single(std::string file_name, TGraphErrors &graph, TGraphErrors &graph2, vector<double> &vec_errors)
{
TTree *t = new TTree();
const std::string file_path = "/home/jlab/github/MagCloak_Analysis/calibration/data-calib/DATA_MegaVIEW/";
// std::string file_name = "DataFile_2016-12-08_06-59-11.csv";
std::string file = file_path+file_name;
t->ReadFile(file.c_str());
// t->Print();
TCanvas *c = new TCanvas();
t->Draw("TMath::Abs(B1/B2):time");
TGraph *gh = (TGraph*)c->GetListOfPrimitives()->FindObject("Graph");
double ratio_mean = gh->GetMean(2);
double ratio_std = gh->GetRMS(2);
t->Draw("Bnom:time");
TGraph *gh1 = (TGraph*)c->GetListOfPrimitives()->FindObject("Graph");
double nom_mean = gh1->GetMean(2);
double nom_std = 0;
// cout << "At " << nom_mean << " mT, B1/B2 is: " << ratio_mean << " +/- " << ratio_std << endl;
c->Close();
int n = graph.GetN();
graph.SetPoint(n,nom_mean,ratio_mean);
graph.SetPointError(n,nom_std,ratio_std);
//-------------------------------------------------------------------------------
TCanvas *c2 = new TCanvas();
t->Draw("B3:time");
TGraph *gh2 = (TGraph*)c2->GetListOfPrimitives()->FindObject("Graph");
double B3_mean = -1*(gh2->GetMean(2));
double B3_std = gh2->GetRMS(2);
int n2 = graph2.GetN();
graph2.SetPoint(n2, nom_mean, B3_mean);
graph2.SetPointError(n2, nom_std, B3_std);
c2->Close();
if(nom_mean < 500) vec_errors.push_back(B3_std);
return 0;
}
void draw() {
gStyle->SetOptStat(0000);
TGraphErrors* gr = new TGraphErrors("papel_um.txt", "%lg %lg %lg %lg");
gr->Draw("A");
gr->GetXaxis()->SetTitle("Diametro (mm)");
gr->GetYaxis()->SetTitle("Massa (u.m.)");
gr->SetTitle("Dimensao Fractal - Papel");
gr->SetMarkerStyle(20);
gr->SetMarkerSize(gr->GetMarkerSize()/2.);
TCanvas* c1 = new TCanvas();
gr->Draw("AP");
c1->Print("gr1.png");
TGraphErrors* grlog = new TGraphErrors();
for (int i=0; i<gr->GetN(); i++) {
grlog->SetPoint(i, TMath::Log(gr->GetX()[i]), TMath::Log(gr->GetY()[i]));
grlog->SetPointError(i, gr->GetEX()[i]/gr->GetX()[i], 0.0);
}
grlog->Draw("A");
grlog->GetXaxis()->SetTitle("Logaritmo do diametro (diametro em mm)");
grlog->GetYaxis()->SetTitle("Logaritmo da massa (massa em unidade arbitraria)");
grlog->SetTitle("Dimensao Fractal - Papel");
grlog->SetMarkerStyle(20);
// grlog->SetMarkerSize(gr->GetMarkerSize()/2.);
grlog->Fit("pol1");
TCanvas* c2 = new TCanvas();
grlog->Draw("AP");
c2->Print("gr2.png");
}
void InitSummaryTrending(TTree * tree){
//
// Init drawing for the <detector> QA
// Detector specific qaConfig() has to be called before invoking this function
// 0.) Make descriptor
// 1.) Make default canvas - addopt canvas width to the number of entries to draw
// 3.) compute detector status graphs
//
// 0.) Make descriptor
//
TLatex *latex= new TLatex;
latex->SetX(0.11);
latex->SetY(0.8);
latex->SetTextSize(0.03);
descriptionQA = GetTexDescription(latex);
//
// 1.) Make default canvas - addopt canvas width to the number of entries to draw
//
TGraphErrors *gr = (TGraphErrors*) TStatToolkit::MakeGraphSparse(tree,"resolution:tagID","");
Int_t numberOfTags = gr->GetN();
cout<<"number of graph entries: "<<numberOfTags<<endl;
double SpaceForLegend = 0.;
Int_t canvas_width = SpaceForLegend + (numberOfTags+5)*30;
Int_t canvas_height = 600;
if ( canvas_width>kMaxCanvasWidth) canvas_width=kMaxCanvasWidth;
canvasQA = new TCanvas("canvasQA","canvasQA",canvas_width,canvas_height);
canvasQA->SetGrid(3);
canvasQA->cd();
gPad->SetTicks(1,2);
// canvasQA->SetRightMargin(SpaceForLegend/canvas_width);
double leftlegend = 1 - 180./canvasQA->GetWw();
double rightlegend = 1 - 10./canvasQA->GetWw();
//
// 2.) process config file qaConfig.C to initialize status aliases (outliers etc.), status bar criteria, status lines, ...
//
TString sStatusbarVars = statusDescription[0];
TString sStatusbarNames = statusDescription[1];
TString sCriteria = statusDescription[2];
cout << "sStatusbarVars = " << sStatusbarVars.Data() << endl;
cout << "sCriteria = " << sCriteria.Data() << endl;
//
// 3.) compute detector status graphs
//
TObjArray* oaStatusbarVars = sStatusbarVars.Tokenize(";");
TObjArray* oaStatusbarNames = sStatusbarNames.Tokenize(";");
oaMultGr = new TObjArray();
int igr=0;
for (Int_t vari=oaStatusbarVars->GetEntriesFast()-1; vari>=0; vari--){ // invert the order of the status graphs
TString sVar = Form("%s:tagID", oaStatusbarVars->At(vari)->GetName()); //e.g. -> dcar:run
oaMultGr->Add( TStatToolkit::MakeStatusMultGr(tree, sVar.Data(), "", sCriteria.Data(), igr) );
TString sYtitle = oaStatusbarNames->At(vari)->GetName(); // set better name for y axis of statuspad
((TMultiGraph*) oaMultGr->At(igr))->SetTitle(sYtitle.Data());
igr++;
}
}
void points(TString filename) {
TString cmssw;
// 167
cmssw = "$1.6.7$";
TFile *f = TFile::Open(filename);
std::vector< TString > taggers;
taggers.push_back( "gTC2_udsg" );
taggers.push_back( "gTC3_udsg" );
taggers.push_back( "gTP_udsg" );
taggers.push_back( "gJBP_udsg" );
taggers.push_back( "gSSV_udsg" );
taggers.push_back( "gCSV_udsg" );
std::vector< TString > discriminators;
discriminators.push_back( "discTC2_udsg" );
discriminators.push_back( "discTC3_udsg" );
discriminators.push_back( "discTP_udsg" );
discriminators.push_back( "discJBP_udsg" );
discriminators.push_back( "discSSV_udsg" );
discriminators.push_back( "discCSV_udsg" );
//TCanvas *cv_TC = new TCanvas("cv_TC","cv_TC",700,700);
//TCanvas *cv_TP = new TCanvas("cv_TP","cv_TP",700,700);
std::cout << "Tagger & Point & Discriminator & light mistag & b-efficiency \\\\ \\hline" << std::endl;
for ( size_t itagger = 0; itagger < taggers.size(); ++itagger ) {
TString tag = taggers[itagger];
TGraphErrors *agraph = (TGraphErrors*) gDirectory->Get("Histograms/MCtruth/"+tag);
//if (taggers == "gTC2_udsg" || taggers =
TGraph *dgraph = (TGraph*) gDirectory->Get("Histograms/MCtruth/"+discriminators[itagger]);
dgraph->Sort();
TGraphErrors *g = new TGraphErrors(agraph->GetN(),agraph->GetY(),agraph->GetX(),agraph->GetEY(),agraph->GetEX());
g->Sort();
//cv[itagger] = new TCanvas("cv","cv",600,600);
//g->Draw("ACP");
TString se = " & ";
std::cout << tag << se << "Loose" << se << std::setprecision(3) << dgraph->Eval(0.1) << se << "0.1" << se << std::setprecision(2) << g->Eval(0.1) << "\\\\" << std::endl;
std::cout << tag << se << "Medium" << se << std::setprecision(3) << dgraph->Eval(0.01) << se << "0.01" << se << std::setprecision(2) << g->Eval(0.01) << "\\\\" << std::endl;
std::cout << tag << se << "Tight" << se << std::setprecision(3) << dgraph->Eval(0.001) << se << "0.001" << se << std::setprecision(2) << g->Eval(0.001) << "\\\\ \\hline" << std::endl;
}
}
TGraphErrors *tools::makeGraph(TH1 *hx, TH1 *hy, double scale ) {
assert(hx->GetNbinsX()==hy->GetNbinsX());
TGraphErrors *g = new TGraphErrors(0);
for (int i = 1; i != hx->GetNbinsX()+1; ++i) {
assert(hx->GetBinLowEdge(i)==hy->GetBinLowEdge(i));
int n = g->GetN();
SetPoint(g, n, hx->GetBinContent(i), scale*hy->GetBinContent(i),
hx->GetBinError(i), scale*hy->GetBinError(i));
}
return g;
}
double ll_matrix::matrix_calibration::get_min_mass( TGraphErrors & graph )
{
double m_min_x = graph.GetX()[0] , m_min_y = graph.GetY()[0];
for( int i = 0 ; i < graph.GetN() ; i++ )
{
if( graph.GetY()[i] < m_min_y )
{
if( graph.GetX()[i] < LOWEST_MASS || graph.GetX()[i] > HIGHEST_MASS )
continue;
m_min_x = graph.GetX()[i];
m_min_y = graph.GetY()[i];
}
}
return m_min_x;
}
printgraph(const char* file, const char* graphname, const char* graphname_syst, bool reverseta=false, double scale=1./34.62)
{
TFile * f = new TFile(file);
TGraphErrors *gr = (TGraphErrors*) f->Get(graphname);
TGraphErrors *grsyst = (TGraphErrors*) f->Get(graphname_syst);
int nbins = gr->GetN();
double *x = new double[nbins];
if (reverseta)
for (int i=0; i<nbins; i++)
x[i] = gr->GetX()[nbins-i-1];
else
x = gr->GetX();
double *y = gr->GetY();
double *ey = gr->GetEY();
double *ey_syst = grsyst->GetEY();
for (int i=0; i<nbins; i++)
cout << x[i] << ": " << y[i]*scale << "+-" << ey[i]*scale << "(stat.) +-" << ey_syst[i]*scale << "(syst.)" << endl;
}
TGraphErrors *tools::ratioGraphs(TGraphErrors *g1, TGraphErrors *g2,
double erry) {
assert(g1); assert(g2);
TGraphErrors *g = new TGraphErrors(0);
g->SetName(Form("ratio_%s_%s",g1->GetName(),g2->GetName()));
g->SetMarkerStyle(g1->GetMarkerStyle());
g->SetMarkerColor(g1->GetMarkerColor());
g->SetLineColor(g1->GetLineColor());
// take ratio only of points that are closer to each other than any others
for (int i = 0, j = 0; (i != g1->GetN() && j != g2->GetN());) {
double x1m, x1p, x2m, x2p, y, ex, ey;
GetPoint(g1, max(i-1,0), x1m, y, ex, ey);
GetPoint(g1, min(i+1,g1->GetN()-1), x1p, y, ex, ey);
GetPoint(g2, max(j-1,0), x2m, y, ex, ey);
GetPoint(g2, min(j+1,g2->GetN()-1), x2p, y, ex, ey);
double x1, y1, ex1, ey1;
GetPoint(g1, i, x1, y1, ex1, ey1);
double x2, y2, ex2, ey2;
GetPoint(g2, j, x2, y2, ex2, ey2);
if (fabs(x1-x2)<=fabs(x1-x2m) && fabs(x1-x2)<=fabs(x1-x2p) &&
fabs(x1-x2)<=fabs(x2-x1m) && fabs(x1-x2)<=fabs(x2-x1p)) {
int n = g->GetN();
SetPoint(g, n, 0.5*(x1+x2), (y2 ? y1/y2 : 0.), 0.5*fabs(x1-x2),
oplus(ey1/y1, ey2/y2) * fabs(y2 ? y1/y2 : 0.) * erry);
++i, ++j;
}
else
(x1<x2 ? ++i : ++j);
} // for i, j
return g;
} // ratioGraphs
Int_t VisualizeSurface()
{
std::string gfname;
std::cout << "\nFor the graph ";
ListAllFilesInDirOfType (".",".root");
std::cout << "\nEnter filename : ";
std::getline(std::cin, gfname);
TGraphErrors* mygr = GetGraph(gfname);
mygr->SetMarkerColor(kRed);
mygr->SetLineColor(kRed);
mygr->SetMarkerStyle(20);
std::string parfname = GetParamFile();
std::ifstream pfile(parfname.data());
Parameters params(pfile);
if (! params.KeysAreSensible()) return -1;
AngDistC W(params, 1, ELECTRIC);
std::cout << params << std::endl;
TGraph* gr = new TGraph(mygr->GetN());
gr->SetMarkerColor(kBlue);
gr->SetLineColor(kBlue);
gr->SetMarkerStyle(20);
Double_t num, denom;
Double_t ratio;
Double_t x[2];
for (UInt_t i=0; i<mygr->GetN(); i++)
{
x[0] = mygr->GetX()[i];
x[1] = 0;
num = W(x);
x[1] = TMath::Pi()/2.;
denom = W(x);
ratio = num/denom;
gr->SetPoint(i, mygr->GetX()[i], TMath::Abs(ratio));
}
std::cout << "\n Phase2ChiSqC setup completed " << std::endl;
TPaveText* pt = new TPaveText(0.5, 0.75, 0.8, 0.95);
std::ostringstream os("", std::ios::out|std::ios::app);
os << "a = " << params[0]->GetValue();
pt->AddText(os.str().data());
os.str("b = ");
os << params[1]->GetValue();
pt->AddText(os.str().data());
os.str("c = ");
os << params[2]->GetValue();
pt->AddText(os.str().data());
os.str("d = ");
os << params[3]->GetValue();
pt->AddText(os.str().data());
TH1* h = new TH2D("Ratio Comparison", "", 10, -1,1, 500, 0,100);
h->SetStats(0);
TCanvas* c = new TCanvas("c");
h->Draw();
gr->Draw("LP");
mygr->Draw("LP");
gPad->Modified();
c->Update();
TLegend *leg = new TLegend(0.5, 0.75, 0.8, 0.95);
leg->AddEntry(gr, "Fit", "PL");
leg->AddEntry(mygr, "Data", "PL");
leg->Draw();
return 0;
}
void AnalyzeClipping(TString inputWaveName = "sum trigger input ch5 960mV",
TString outputWaveName = "sum trigger output ch5 - 2V clip - 960mV input",
Double_t inputDelay = 1.1E-8, Double_t lowerCut = 16E-9, Double_t upperCut = 23E-9,
const char *inFile = "Data.root",const char *WaveformsFile = "Waveforms.root") {
//try to access data file and in case of failure return
if(gSystem->AccessPathName(inFile,kFileExists)) {
cout << "Error: file " << inFile << " does not exsist. Run .x DataParse.C to create it" << endl;
return;
}
TFile *f = TFile::Open(inFile);
TFolder *dataSet;
TString dataFolderS = "SumTriggerBoardData";
dataFolderS.Append(";1");
dataSet = (TFolder*)f->Get(dataFolderS);
cout << dataSet << endl;
cout << dataSet->GetName() << endl;
Int_t nScope = 150; // number of measurements done by the scope evey time
//try to access waveforms file and in case of failure return
if(gSystem->AccessPathName(WaveformsFile,kFileExists)) {
cout << "Error: file " << WaveformsFile << " does not exsist. Run .x WaveformsFileMaker.C to create it" << endl;
return;
}
TFile *f = TFile::Open(WaveformsFile);
TList *listOfKeys = f->GetListOfKeys();
Int_t numberOfKeys = listOfKeys->GetEntries();
TList *listOfGraphs = new TList();
// if the waveform file name begins with the string "comparator" it goes in this list
TList *listOfCompWaves = new TList();
// if the waveform file name begins with the string "sum output" it goes in this list
TList *listOfAdderWaves = new TList();
for(Int_t i = 0; i < numberOfKeys; i++) {
TString *keyName = new TString(listOfKeys->At(i)->GetName());
TTree *tree = (TTree*)f->Get(keyName->Data());
Float_t x = 0;
Float_t y = 0;
tree->SetBranchAddress("x",&x);
tree->SetBranchAddress("y",&y);
Int_t nentries = tree->GetEntries();
TString *gName = new TString(keyName->Data());
gName->Append(" graph");
TGraphErrors *gWave = new TGraphErrors(nentries);
gWave->SetName(gName->Data());
gWave->SetTitle(gName->Data());
gWave->GetXaxis()->SetTitle("Time");
gWave->GetYaxis()->SetTitle("Voltage");
for (Int_t j = 0; j < nentries; j++) {
tree->GetEntry(j);
gWave->SetPoint(j,x,y);
}
listOfGraphs->Add(gWave);
}
// Global variables
Double_t *xInput, *xOutput, *yInput, *yOutput;
// V input 960 mV
TString path = "Clipping/Output width analysis/Channel 5/V input 960mV/";
TGraphErrors *gClip960mV = TBGraphErrors(dataSet,path,"V clip","Output FWHM",1,nScope);
gClip960mV->SetMarkerStyle(20);
gClip960mV->SetMarkerSize(0.8);
gClip960mV->GetXaxis()->SetTitle("V clipping (mV)");
gClip960mV->GetYaxis()->SetTitle("Output FWHM (ns)");
TCanvas *cClip960mV = new TCanvas("cClip960mV","Output FWHM in function of V clipping",800,600);
gClip960mV->Draw("APEL");
// Expected output FWHM
TGraphErrors *gInput960mV = listOfGraphs->FindObject("sum trigger input ch5 960mV graph");
Double_t *xClip = gClip960mV->GetX();
Int_t nClip = gClip960mV->GetN();
cout << "nClip = " << nClip << endl;
Long64_t graphPoints = gInput960mV->GetN();
yInput = gInput960mV->GetY();
xInput = gInput960mV->GetX();
vector<double> xFirst(nClip);
vector<double> xLast(nClip);
Double_t half;
Int_t flag = 0;
vector<double> yConv(graphPoints);
for(Int_t i = 0; i < graphPoints; i++) {
yConv[i] = -(yInput[i]);
yConv[i] *= 1000;
if(xInput[i] + inputDelay < lowerCut || xInput[i] + inputDelay > upperCut)
yConv[i] = 0;
}
Double_t yInput960mVMax = TMath::MaxElement(graphPoints,&yConv[0]);
for(Int_t i = 0; i < nClip; i++) {
if(xClip[i] > yInput960mVMax) half = yInput960mVMax;
else half = xClip[i];
half /=2;
cout << half << endl;
flag = 0;
for(Int_t j = 0; j < graphPoints - 3; j++) {
if((yConv[j + 1] - half)*(yConv[j] - half) < 0 && flag == 0) {
xFirst[i] = xInput[j];
flag = 1;
cout << "found first point! " << xFirst[i] << endl;
continue;
}
if((yConv[j + 1] - half)*(yConv[j] - half) < 0 && flag == 1) {
xLast[i] = xInput[j];
cout << "found last point! " << xLast[i] << endl;
break;
}
}
}
vector<double> expectedFWHM960mV(nClip);
for(Int_t i = 0; i < expectedFWHM960mV.size(); i++) {
expectedFWHM960mV[i] = xLast[i] - xFirst[i];
// convert from seconds to nanoseconds
expectedFWHM960mV[i] *= 10E8;
cout << "expectedFWHM960mV[" << i << "] = " << expectedFWHM960mV[i] << endl;
}
// expected FWHM 960 mV graph
TGraphErrors *gExpClip960mV = new TGraphErrors(nClip,xClip,&expectedFWHM960mV[0],0,0);
gExpClip960mV->SetLineStyle(7);
gExpClip960mV->SetMarkerStyle(20);
gExpClip960mV->SetMarkerSize(0.8);
// V input 1.9 V
path = "Clipping/Output width analysis/Channel 5/V input 1.9V/";
TGraphErrors *gClip1Point9V = TBGraphErrors(dataSet,path,"V clip","Output FWHM",1,nScope);
gClip1Point9V->SetMarkerStyle(20);
gClip1Point9V->SetMarkerSize(0.8);
gClip1Point9V->SetLineColor(kRed);
gClip1Point9V->GetXaxis()->SetTitle("V clipping (mV)");
gClip1Point9V->GetYaxis()->SetTitle("Output FWHM (ns)");
TCanvas *cClip1Point9V = new TCanvas("cClip1Point9V","Output FWHM in function of V clipping",800,600);
gClip1Point9V->Draw("APEL");
// Expected output FWHM
TGraphErrors *gInput1Point9V = listOfGraphs->FindObject("sum trigger input ch5 1900mV graph");
xClip = gClip1Point9V->GetX();
nClip = gClip1Point9V->GetN();
cout << "nClip = " << nClip << endl;
graphPoints = gInput1Point9V->GetN();
yInput = gInput1Point9V->GetY();
xInput = gInput1Point9V->GetX();
vector<double> xFirst(nClip);
vector<double> xLast(nClip);
flag = 0;
vector<double> yConv(graphPoints);
for(Int_t i = 0; i < graphPoints; i++) {
yConv[i] = -(yInput[i]);
yConv[i] *= 1000;
if(xInput[i] + inputDelay < lowerCut || xInput[i] + inputDelay > upperCut) yConv[i] = 0;
}
Double_t yInput1Point9VMax = TMath::MaxElement(graphPoints,&yConv[0]);
for(Int_t i = 0; i < nClip; i++) {
if(xClip[i] > yInput1Point9VMax) half = yInput1Point9VMax;
else half = xClip[i];
half /= 2;
cout << half << endl;
flag = 0;
for(Int_t j = 0; j < graphPoints - 3; j++) {
if((yConv[j + 1] - half)*(yConv[j] - half) < 0 && flag == 0) {
xFirst[i] = xInput[j];
flag = 1;
cout << "found first point! " << xFirst[i] << endl;
continue;
}
if((yConv[j + 1] - half)*(yConv[j] - half) < 0 && flag == 1) {
xLast[i] = xInput[j];
cout << "found last point! " << xLast[i] << endl;
break;
}
}
}
vector<double> expectedFWHM1Point9V(nClip);
for(Int_t i = 0; i < expectedFWHM1Point9V.size(); i++) {
expectedFWHM1Point9V[i] = xLast[i] - xFirst[i];
// convert from seconds to nanoseconds
expectedFWHM1Point9V[i] *= 10E8;
cout << "expectedFWHM1Point9V[" << i << "] = " << expectedFWHM1Point9V[i] << endl;
}
// expected FWHM 960 mV graph
TGraphErrors *gExpClip1Point9V = new TGraphErrors(nClip,xClip,&expectedFWHM1Point9V[0],0,0);
gExpClip1Point9V->SetLineStyle(7);
gExpClip1Point9V->SetLineColor(kRed);
gExpClip1Point9V->SetMarkerStyle(20);
gExpClip1Point9V->SetMarkerSize(0.8);
// Collection of Output FWHM graphs, 2 amplitudes, serveral V clipping
TMultiGraph *mgClipOutputFWHM = new TMultiGraph();
mgClipOutputFWHM->SetTitle("Collection of Output FWHM graphs, 2 amplitudes, serveral V clipping");
mgClipOutputFWHM->Add(gClip1Point9V);
mgClipOutputFWHM->Add(gClip960mV);
mgClipOutputFWHM->Add(gExpClip960mV);
mgClipOutputFWHM->Add(gExpClip1Point9V);
TCanvas *cmgClipOutputFWHM = new TCanvas("cmgClipOutputFWHM","Collection of Output FWHM graphs, 2 amplitudes, serveral V clipping");
mgClipOutputFWHM->Draw("APEL");
cmgClipOutputFWHM->Modified();
mgClipOutputFWHM->GetXaxis()->SetTitle("V clipping (mV)");
mgClipOutputFWHM->GetYaxis()->SetTitle("Output FWHM (ns)");
cmgClipOutputFWHM->Update();
legend = new TLegend(0.6,0.67,0.89,0.86,"V input");
legend->AddEntry(gClip1Point9V, "1.9 V", "lp");
legend->AddEntry(gClip960mV, "960 mV", "lp");
legend->AddEntry(gExpClip960mV, "Exp 960 mV", "lp");
legend->AddEntry(gExpClip1Point9V, "Exp 1.9 V", "lp");
legend->SetTextSize(0.04);
legend->SetMargin(0.5);
legend->Draw();
// Hysteresis plot: V output (t) in function of V input (t) for several clipping values
// variables used in the analysis
Long64_t iInputMax, iOutputMax;
Float_t xInputMax, xOutputMax, xInputHalf, xOutputHalf;
Double_t InputMax, OutputMax, InputHalf, OutputHalf;
Long64_t firstIndex = 0;
Long64_t lastIndex = 0;
Long64_t inputGraphPoints = 0;
Long64_t outputGraphPoints = 0;
// hard coded values to cut the x axis of both waves
// Input wave
inputWaveName += " graph";
TGraphErrors *gInput = listOfGraphs->FindObject(inputWaveName);
gInput->SetLineColor(kRed);
gInput->SetLineWidth(2);
xInput = gInput->GetX();
yInput = gInput->GetY();
inputGraphPoints = gInput->GetN();
cout << inputGraphPoints << endl;
// Invert the input wave
for(Int_t i = 0; i < inputGraphPoints; i++) {
yInput[i] = -(yInput[i]);
}
// find the x at which the graph reaches the max value
iInputMax = TMath::LocMax(inputGraphPoints, yInput);
xInputMax = xInput[iInputMax];
cout << "iInputMax = " << iInputMax << endl;
cout << "xInputMax = " << xInputMax << endl;
InputMax = gInput->Eval(xInput[iInputMax]);
cout << "InputMax = " << InputMax << endl;
// Output wave
outputWaveName += " graph";
TGraphErrors *gOutput = listOfGraphs->FindObject(outputWaveName);
gOutput->SetLineWidth(2);
xOutput = gOutput->GetX();
yOutput = gOutput->GetY();
outputGraphPoints = gOutput->GetN();
// find the x at which the graph reaches the max value
iOutputMax = TMath::LocMax(outputGraphPoints, yOutput);
xOutputMax = xOutput[iOutputMax];
cout << "iOutputMax = " << iOutputMax << endl;
cout << "xOutputMax = " << xOutputMax << endl;
OutputMax = gOutput->Eval(xOutput[iOutputMax]);
cout << "OutputMax = " << OutputMax << endl;
// compute x delay between max points
Double_t delay = xOutputMax - xInputMax;
cout << "delay = " << delay << endl;
// Shift the x axis of the input graph and create a new graph with only a portion of the first graph
for(Int_t i = 0; i < inputGraphPoints; i++) {
xInput[i] += inputDelay;
if(xInput[i] >= lowerCut) {
if(firstIndex == 0) firstIndex = i;
}
if(xInput[i] <= upperCut)
lastIndex = i;
}
cout << "firstIndex = " << firstIndex << endl;
cout << "lastIndex = " << lastIndex << endl;
cout << "xInput[firstIndex] = " << xInput[firstIndex] << endl;
cout << lastIndex - firstIndex << endl;
Long64_t input2GraphPoints = lastIndex - firstIndex;
TGraphErrors *gInput2 = new TGraphErrors(input2GraphPoints);
gInput2->SetTitle(inputWaveName);
for(Int_t i = firstIndex; i <= lastIndex; i++) {
gInput2->SetPoint(i - firstIndex,xInput[i],yInput[i]);
}
TCanvas *cgInput2 = new TCanvas("cgInput2", "cgInput2", 1200,800);
gInput2->Draw("AL");
// create a new graph with only a portion of the first graph
firstIndex = 0;
lastIndex = 0;
for(Int_t i = 0; i < outputGraphPoints; i++) {
if(xOutput[i] >= lowerCut) {
if(firstIndex == 0) firstIndex = i;
}
if(xOutput[i] <= upperCut)
lastIndex = i;
}
cout << "firstIndex = " << firstIndex << endl;
cout << "lastIndex = " << lastIndex << endl;
cout << "xOutput[firstIndex] = " << xOutput[firstIndex] << endl;
cout << lastIndex - firstIndex << endl;
Long64_t output2GraphPoints = lastIndex - firstIndex;
TGraphErrors *gOutput2 = new TGraphErrors(output2GraphPoints);
gOutput2->SetTitle(outputWaveName);
for(Int_t i = firstIndex; i <= lastIndex; i++) {
gOutput2->SetPoint(i - firstIndex,xOutput[i],yOutput[i]);
}
TCanvas *cgOutput2 = new TCanvas("cgOutput2", "cgOutput2", 1200,800);
gOutput2->Draw("AL");
// first hysteresis plot
Double_t step;
Double_t *xInput2;
xInput2 = gInput2->GetX();
cout << "xInput2[input2GraphPoints - 1] = " << xInput2[input2GraphPoints - 1] << endl;
cout << "xInput2[0] = " << xInput2[0] << endl;
step = (xInput2[input2GraphPoints - 1] - xInput2[0])/output2GraphPoints;
cout << "step = " << step << endl;
// in case gInput2 and gOutput2 contain a different number of points create the hysteresis plot with gOutput2 points
// and modify the yInput2 to match the number of points of yOutput2
vector<double> yInput2;
for(Int_t i = 0; i < output2GraphPoints; i++) {
yInput2.push_back(gInput2->Eval(xInput2[0] + i*step));
}
Double_t *yOutput2;
yOutput2 = gOutput2->GetY();
TGraphErrors *gHyst = new TGraphErrors(output2GraphPoints, &yInput2.at(0),yOutput2);
gHyst->SetTitle("Hysteresis plot");
gHyst->GetXaxis()->SetTitle("Vin(t) [mV]");
gHyst->GetYaxis()->SetTitle("Vout(t) [mV]");
gHyst->GetYaxis()->SetTitleOffset(1.4);
TCanvas *cgHyst = new TCanvas("cgHyst", "cgHyst", 1200,800);
cgHyst->SetLeftMargin(0.12);
gHyst->Draw("AL");
// collection of graphs
TMultiGraph *mgInputOutput = new TMultiGraph();
mgInputOutput->Add(gInput);
mgInputOutput->Add(gOutput);
mgInputOutput->SetTitle("Input and output");
TCanvas *cmgInputOutput = new TCanvas("cmgInputOutput", "Input and output", 1200,800);
mgInputOutput->Draw("AL");
cmgInputOutput->Update();
legend = new TLegend(0.65,0.68,0.86,0.86);
legend->AddEntry(gInput, "Input", "lp");
legend->AddEntry(gOutput, "Output", "lp");
legend->SetMargin(0.4);
legend->SetTextSize(0.04);
legend->Draw();
cmgInputOutput->Modified();
}
// Soft radiation corrections for L3Res
void softrad(double etamin=0.0, double etamax=1.3, bool dodijet=false) {
setTDRStyle();
writeExtraText = false; // for JEC paper CWR
TDirectory *curdir = gDirectory;
// Open jecdata.root produced by reprocess.C
TFile *fin = new TFile("rootfiles/jecdata.root","UPDATE");
assert(fin && !fin->IsZombie());
const int ntypes = 3;
const char* types[ntypes] = {"data", "mc", "ratio"};
const int nmethods = 2;
const char* methods[nmethods] = {"mpfchs1", "ptchs"};
const int nsamples = (dodijet ? 4 : 3);
const char* samples[4] = {"gamjet", "zeejet", "zmmjet", "dijet"};
string sbin = Form("eta%02.0f-%02.0f",10*etamin,10*etamax);
const char* bin = sbin.c_str();
const int nalphas = 4;
const int alphas[nalphas] = {30, 20, 15, 10};
// Z+jet bins
const double ptbins1[] = {30, 40, 50, 60, 75, 95, 125, 180, 300, 1000};
const int npt1 = sizeof(ptbins1)/sizeof(ptbins1[0])-1;
TH1D *hpt1 = new TH1D("hpt1","",npt1,&ptbins1[0]);
TProfile *ppt1 = new TProfile("ppt1","",npt1,&ptbins1[0]);
// gamma+jet bins
const double ptbins2[] = {30, 40, 50, 60, 75, 100, 125, 155, 180,
210, 250, 300, 350, 400, 500, 600, 800};
const int npt2 = sizeof(ptbins2)/sizeof(ptbins2[0])-1;
TH1D *hpt2 = new TH1D("hpt2","",npt2,&ptbins2[0]);
TProfile *ppt2 = new TProfile("ppt2","",npt2,&ptbins2[0]);
// dijet bins
const double ptbins4[] = {20, 62, 107, 175, 242, 310, 379, 467,
628, 839, 1121, 1497, 2000};
const int npt4 = sizeof(ptbins4)/sizeof(ptbins4[0])-1;
TH1D *hpt4 = new TH1D("hpt4","",npt4,&ptbins4[0]);
TProfile *ppt4 = new TProfile("ppt4","",npt4,&ptbins4[0]);
TLatex *tex = new TLatex();
tex->SetNDC();
tex->SetTextSize(0.045);
map<string,const char*> texlabel;
texlabel["gamjet"] = "#gamma+jet";
texlabel["zeejet"] = "Z#rightarrowee+jet";
texlabel["zmmjet"] = "Z#rightarrow#mu#mu+jet";
texlabel["dijet"] = "Dijet";
texlabel["ptchs"] = "p_{T} balance (CHS)";
texlabel["mpfchs"] = "MPF raw (CHS)";
texlabel["mpfchs1"] = "MPF type-I (CHS)";
// overlay of various alpha values
TCanvas *c1 = new TCanvas("c1","c1",ntypes*400,nmethods*400);
c1->Divide(ntypes,nmethods);
TH1D *h1 = new TH1D("h1",";p_{T} (GeV);Response",1270,30,1300);
// extrapolation vs alpha for each pT bin
vector<TCanvas*> c2s(ntypes*nmethods);
for (unsigned int icanvas = 0; icanvas != c2s.size(); ++icanvas) {
TCanvas *c2 = new TCanvas(Form("c2_%d",icanvas),Form("c2_%d",icanvas),
1200,1200);
c2->Divide(3,3);
c2s[icanvas] = c2;
}
TH1D *h2 = new TH1D("h2",";#alpha;Response",10,0.,0.4);
h2->SetMaximum(1.08);
h2->SetMinimum(0.88);
// krad corrections
TCanvas *c3 = new TCanvas("c3","c3",ntypes*400,nmethods*400);
c3->Divide(ntypes,nmethods);
TH1D *h3 = new TH1D("h3",";p_{T,ref} (GeV);FSR sensitivity: -dR/d#alpha [%]",
1270,30,1300);
cout << "Reading in data" << endl << flush;
// Read in plots vs pT (and alpha)
map<string, map<string, map<string, map<int, TGraphErrors*> > > > gemap;
map<string, map<string, map<string, map<int, TGraphErrors*> > > > gamap;
for (int itype = 0; itype != ntypes; ++itype) {
for (int imethod = 0; imethod != nmethods; ++imethod) {
for (int isample = 0; isample != nsamples; ++isample) {
for (int ialpha = 0; ialpha != nalphas; ++ialpha) {
fin->cd();
assert(gDirectory->cd(types[itype]));
assert(gDirectory->cd(bin));
TDirectory *d = gDirectory;
const char *ct = types[itype];
const char *cm = methods[imethod];
const char *cs = samples[isample];
const int a = alphas[ialpha];
// Get graph made vs pT
string s = Form("%s/%s/%s_%s_a%d",types[itype],bin,cm,cs,a);
TGraphErrors *g = (TGraphErrors*)fin->Get(s.c_str());
if (!g) cout << "Missing " << s << endl << flush;
assert(g);
// Clean out empty points
// as well as trigger-biased ones for dijets
// as well as weird gamma+jet high pT point
for (int i = g->GetN()-1; i != -1; --i) {
if (g->GetY()[i]==0 || g->GetEY()[i]==0 ||
(string(cs)=="dijet" && g->GetX()[i]<70.) ||
(string(cs)=="gamjet" && g->GetX()[i]>600. && etamin!=0))
g->RemovePoint(i);
}
gemap[ct][cm][cs][a] = g;
// Sort points into new graphs vs alpha
TH1D *hpt = (isample==0 ? hpt2 : hpt1);
TProfile *ppt = (isample==0 ? ppt2 : ppt1);
if (isample==3) { hpt = hpt4; ppt = ppt4; } // pas-v6
for (int i = 0; i != g->GetN(); ++i) {
double pt = g->GetX()[i];
ppt->Fill(pt, pt);
int ipt = int(hpt->GetBinLowEdge(hpt->FindBin(pt))+0.5);
//int ipt = int(pt+0.5);
TGraphErrors *ga = gamap[ct][cm][cs][ipt];
if (!ga) {
ga = new TGraphErrors(0);
ga->SetMarkerStyle(g->GetMarkerStyle());
ga->SetMarkerColor(g->GetMarkerColor());
ga->SetLineColor(g->GetLineColor());
gamap[ct][cm][cs][ipt] = ga;
}
int n = ga->GetN();
ga->SetPoint(n, 0.01*a, g->GetY()[i]);
ga->SetPointError(n, 0, g->GetEY()[i]);
} // for i
} // for ialpha
} // for isample
} // for imethod
} // for itype
cout << "Drawing plots vs pT for each alpha" << endl << flush;
// 2x6 plots
for (int itype = 0; itype != ntypes; ++itype) {
for (int imethod = 0; imethod != nmethods; ++imethod) {
const char *ct = types[itype];
const char *cm = methods[imethod];
int ipad = ntypes*imethod + itype + 1; assert(ipad<=6);
c1->cd(ipad);
gPad->SetLogx();
h1->SetMaximum(itype<2 ? 1.15 : 1.08);
h1->SetMinimum(itype<2 ? 0.85 : 0.93);
h1->SetYTitle(Form("Response (%s)",ct));
h1->DrawClone("AXIS");
tex->DrawLatex(0.20,0.85,texlabel[cm]);
tex->DrawLatex(0.20,0.80,"|#eta| < 1.3, #alpha=0.1--0.3");
TLegend *leg = tdrLeg(0.60,0.75,0.90,0.90);
for (int isample = 0; isample != nsamples; ++isample) {
for (int ialpha = 0; ialpha != nalphas; ++ialpha) {
const char *cs = samples[isample];
const int a = alphas[ialpha];
TGraphErrors *g = gemap[ct][cm][cs][a]; assert(g);
// Clean out points with very large uncertainty for plot readability
for (int i = g->GetN()-1; i != -1; --i) {
if (g->GetEY()[i]>0.02) g->RemovePoint(i);
}
g->Draw("SAME Pz");
if (ialpha==0) leg->AddEntry(g,texlabel[cs],"P");
}
} // for isample
// Individual plots for JEC paper
if ( true ) { // paper
TH1D *h = new TH1D(Form("h_5%s_%s",ct,cm),
Form(";p_{T} (GeV);Response (%s)",ct),
1270,30,1300);
h->GetXaxis()->SetMoreLogLabels();
h->GetXaxis()->SetNoExponent();
h->SetMinimum(0.88);
h->SetMaximum(1.13);
writeExtraText = true;
extraText = (string(ct)=="mc" ? "Simulation" : "");
lumi_8TeV = (string(ct)=="mc" ? "" : "19.7 fb^{-1}");
TCanvas *c0 = tdrCanvas(Form("c0_%s_%s",cm,ct), h, 2, 11, true);
c0->SetLogx();
TLegend *leg = tdrLeg(0.55,0.68,0.85,0.83);
tex->DrawLatex(0.55,0.85,texlabel[cm]);
tex->DrawLatex(0.55,0.18,"|#eta| < 1.3, #alpha=0.3");
//tex->DrawLatex(0.55,0.18,"Anti-k_{T} R=0.5");
// Loop over Z+jet and gamma+jet (only, no dijet/multijet)
for (int isample = 0; isample != min(3,nsamples); ++isample) {
const char *cs = samples[isample];
TGraphErrors *g = gemap[ct][cm][cs][30]; assert(g);
g->Draw("SAME Pz");
leg->AddEntry(g,texlabel[cs],"P");
} // for isample
if (etamin==0) {
c0->SaveAs(Form("pdf/paper_softrad_%s_%s_vspt.pdf",ct,cm));
c0->SaveAs(Form("pdfC/paper_softrad_%s_%s_vspt.C",ct,cm));
}
else {
c0->SaveAs(Form("pdf/an_softrad_%s_%s_eta%1.0f-%1.0f_vspt.pdf",
ct,cm,10*etamin,10*etamax));
}
} // paper
} // for imethod
} // for itype
c1->cd(0);
//cmsPrel(_lumi, true);
CMS_lumi(c1, 2, 33);
c1->SaveAs("pdf/softrad_2x6_vspt.pdf");
cout << "Drawing plots vs alpha for each pT" << endl << flush;
cout << "...and fitting slope vs alpha" << endl << flush;
map<string, map<string, map<string, TGraphErrors* > > > gkmap;
// 2x6 plots
for (int itype = 0; itype != ntypes; ++itype) {
for (int imethod = 0; imethod != nmethods; ++imethod) {
int icanvas = nmethods*imethod + itype; assert(icanvas<=6);
TCanvas *c2 = c2s[icanvas]; assert(c2);
const char *ct = types[itype];
const char *cm = methods[imethod];
const int npads = 9;
for (int ipad = 0; ipad != npads; ++ipad) {
c2->cd(ipad+1);
h2->SetYTitle(Form("Response (%s)",ct));
h2->DrawClone("AXIS");
tex->DrawLatex(0.20,0.85,texlabel[cm]);
tex->DrawLatex(0.20,0.80,"|#eta| < 1.3");
tex->DrawLatex(0.20,0.75,Form("%1.0f < p_{T} < %1.0f GeV",
hpt1->GetBinLowEdge(ipad+1),
hpt1->GetBinLowEdge(ipad+2)));
TLegend *leg = tdrLeg(0.65,0.75,0.90,0.90);
leg->AddEntry(gemap[ct][cm]["gamjet"][30], texlabel["gamjet"], "P");
leg->AddEntry(gemap[ct][cm]["zeejet"][30], texlabel["zeejet"], "P");
leg->AddEntry(gemap[ct][cm]["zmmjet"][30], texlabel["zmmjet"], "P");
leg->AddEntry(gemap[ct][cm]["dijet"][30], texlabel["dijet"], "P");
}
for (int isample = 0; isample != nsamples; ++isample) {
const char *cs = samples[isample];
map<int, TGraphErrors*> &gam = gamap[ct][cm][cs];
map<int, TGraphErrors*>::iterator itpt;
for (itpt = gam.begin(); itpt != gam.end(); ++itpt) {
int ipt = itpt->first;
int jpt = hpt1->FindBin(ipt);
if (jpt>npads) continue;
assert(jpt<=npads);
c2->cd(jpt);
TGraphErrors *ga = itpt->second; assert(ga);
ga->Draw("SAME Pz");
// Fit slope
TF1 *f1 = new TF1(Form("f1_%s_%s_%s_%d",ct,cm,cs,ipt),
"(x<1)*([0]+[1]*x) + (x>1 && x<2)*[0] +"
"(x>2)*[1]",-1,1);
f1->SetLineColor(ga->GetLineColor());
f1->SetParameters(1,0);
const double minalpha = (isample==0 ? 10./ipt : 5./ipt);
// Constrain slope to within reasonable values
// in the absence of sufficient data using priors
if (true) { // use priors
int n = ga->GetN();
// For response, limit to 1+/-0.02 (we've corrected for L3Res
ga->SetPoint(n, 1.5, 1);
ga->SetPointError(n, 0, 0.02);
n = ga->GetN();
if (imethod==1) { // pT balance
// For pT balance, estimate slope of <vecpT2>/alpha from data
// => 7.5%/0.30 = 25%
// Approximate uncertainty on this to be
// 0.5%/0.30 ~ 1.5% for data, 0.5%/0.30 ~ 1.5% for Z+jet MC, and
// 2%/0.30 ~ 6% for gamma+jet MC (same as slope)
if (itype==0) ga->SetPoint(n, 2.5, -0.250); // DT
if (itype==1 && isample!=0) ga->SetPoint(n, 2.5, -0.250); // MC
if (itype==1 && isample==0) ga->SetPoint(n, 2.5, -0.190);
if (itype==2 && isample!=0) ga->SetPoint(n, 2.5, -0.000); // rt
if (itype==2 && isample==0) ga->SetPoint(n, 2.5, -0.060);
//
// BUG: found 2015-01-08 (no effect on ratio)
//if (itype==1) ga->SetPointError(n, 0, -0.015);
if (itype==0) ga->SetPointError(n, 0, -0.015); // DT
if (itype==1 && isample!=0) ga->SetPointError(n, 0, -0.015); // MC
if (itype==1 && isample==0) ga->SetPointError(n, 0, -0.060);
if (itype==2 && isample!=0) ga->SetPointError(n, 0, -0.015); // rt
if (itype==2 && isample==0) ga->SetPointError(n, 0, -0.060);
}
if (imethod==0) { // MPF
// For MPF, expectation is no slope
// Maximal slope would be approximately
// (<vecpT2>/alpha ~ 25% from pT balance) times
// (response difference between pT1 and vecpT2~10%)
// => 0.25*0.10 = 2.5%
// For data/MC, estimate uncertainty as half of this
// => 1.25%
ga->SetPoint(n, 2.5, 0.);
if (itype!=2) ga->SetPointError(n, 0, 0.025);
if (itype==2) ga->SetPointError(n, 0, 0.0125);
} // MPF
} // use priors
if (ga->GetN()>2) {
f1->SetRange(minalpha, 3.);
ga->Fit(f1,"QRN");
if (f1->GetNDF()>=0) {
f1->DrawClone("SAME");
f1->SetRange(0,0.4);
f1->SetLineStyle(kDashed);
f1->DrawClone("SAME");
// Store results
TGraphErrors *gk = gkmap[ct][cm][cs];
if (!gk) {
gk = new TGraphErrors(0);
gk->SetMarkerStyle(ga->GetMarkerStyle());
gk->SetMarkerColor(ga->GetMarkerColor());
gk->SetLineColor(ga->GetLineColor());
gkmap[ct][cm][cs] = gk;
}
int n = gk->GetN();
TProfile *ppt = (isample==0 ? ppt2 : ppt1);
if (isample==3) { ppt = ppt4; } // pas-v6
double pt = ppt->GetBinContent(ppt->FindBin(ipt));
gk->SetPoint(n, pt, f1->GetParameter(1));
gk->SetPointError(n, 0, f1->GetParError(1));
} // f1->GetNDF()>=0
} // ga->GetN()>2
} // for itpt
} // for isample
c2->SaveAs(Form("pdf/softrad_3x3_%s_%s_vsalpha.pdf",ct,cm));
}
}
cout << "Drawing plots of kFSR vs pT" << endl;
// 2x6 plots
for (int itype = 0; itype != ntypes; ++itype) {
for (int imethod = 0; imethod != nmethods; ++imethod) {
const char *ct = types[itype];
const char *cm = methods[imethod];
TMultiGraph *mgk = new TMultiGraph();
int ipad = ntypes*imethod + itype + 1; assert(ipad<=6);
c3->cd(ipad);
gPad->SetLogx();
h3->SetMaximum(imethod==0 ? 0.05 : (itype!=2 ? 0.1 : 0.25));
h3->SetMinimum(imethod==0 ? -0.05 : (itype!=2 ? -0.4 : -0.25));
h3->SetYTitle(Form("k_{FSR} = dR/d#alpha (%s)",ct));
h3->DrawClone("AXIS");
tex->DrawLatex(0.20,0.85,texlabel[cm]);
tex->DrawLatex(0.20,0.80,"|#eta| < 1.3");
TLegend *leg = tdrLeg(0.60,0.75,0.90,0.90);
for (int isample = 0; isample != nsamples; ++isample) {
const char *cs = samples[isample];
TGraphErrors *gk = gkmap[ct][cm][cs]; assert(gk);
leg->AddEntry(gk,texlabel[cs],"P");
// Fit each sample separately for pT balance
if (true) {
TF1 *fk = new TF1(Form("fk_%s_%s_%s",ct,cm,cs),
"[0]+[1]*log(0.01*x)+[2]*pow(log(0.01*x),2)",
30,1300);
fk->SetParameters(-0.25,-0.5);
fk->SetLineColor(gk->GetLineColor());
gk->Fit(fk, "QRN");
tex->SetTextColor(fk->GetLineColor());
tex->DrawLatex(0.55,0.27-0.045*isample,
Form("#chi^{2}/NDF = %1.1f / %d",
fk->GetChisquare(), fk->GetNDF()));
tex->SetTextColor(kBlack);
// Error band
const int n = fk->GetNpar();
TMatrixD emat(n,n);
gMinuit->mnemat(emat.GetMatrixArray(), n);
TF1 *fke = new TF1(Form("fk_%s_%s_%s",ct,cm,cs),
sr_fitError, 30, 1300, 1);
_sr_fitError_func = fk;
_sr_fitError_emat = &emat;
fke->SetLineStyle(kSolid);
fke->SetLineColor(fk->GetLineColor()-10);
fke->SetParameter(0,-1);
fke->DrawClone("SAME");
fke->SetParameter(0,+1);
fke->DrawClone("SAME");
fk->DrawClone("SAME");
gk->DrawClone("SAME Pz");
// Store soft radiation corrections in fsr subdirectory
assert(fin->cd(ct));
assert(gDirectory->cd(bin));
if (!gDirectory->FindObject("fsr")) gDirectory->mkdir("fsr");
assert(gDirectory->cd("fsr"));
TH1D *hk = (TH1D*)(isample==0 ? hpt2->Clone() : hpt1->Clone());
hk->SetName(Form("hkfsr_%s_%s",cm,cs));
TProfile *ppt = (isample==0 ? ppt2 : ppt1);
if (isample==3) { ppt = ppt4; } // pas-v6
for (int i = 1; i != hk->GetNbinsX()+1; ++i) {
double pt = ppt->GetBinContent(i);
if (pt>30 && pt<1300) {
hk->SetBinContent(i, fk->Eval(pt));
hk->SetBinError(i, fabs(fke->Eval(pt)-fk->Eval(pt)));
}
else {
hk->SetBinContent(i, 0);
hk->SetBinError(i, 0);
}
}
hk->Write(hk->GetName(), TObject::kOverwrite);
// Factorize error matrix into eigenvectors
// Remember: A = Q*Lambda*Q^-1, where
// A is emat, Q is eigmat, and Lambda is a diagonal matrix with
// eigenvalues from eigvec on the diagonal. For eigenmatrix
// Q^-1 = Q^T, i.e. inverse matrix is the original transposed
TVectorD eigvec(n);
TMatrixD eigmat = emat.EigenVectors(eigvec);
// Eigenvectors are the columns and sum of eigenvectors squared
// equals original uncertainty. Calculate histograms from the
// eigenvectors and store them
TF1 *fkeig = (TF1*)fk->Clone(Form("%s_eig",fk->GetName()));
fkeig->SetLineStyle(kDotted);
for (int ieig = 0; ieig != n; ++ieig) {
// Eigenvector functions
for (int i = 0; i != n; ++i) {
fkeig->SetParameter(i, fk->GetParameter(i)
+ eigmat[i][ieig] * sqrt(eigvec[ieig]));
}
fkeig->DrawClone("SAMEL");
// Eigenvector histograms evaluated at bin mean pT
TH1D *hke = (TH1D*)hk->Clone(Form("%s_eig%d",hk->GetName(),ieig));
hke->Reset();
for (int i = 0; i != gk->GetN(); ++i) {
double pt = gk->GetX()[i];
int ipt = hke->FindBin(pt);
// Need to store central value as well, because
// uncertainty sources are signed
hke->SetBinContent(ipt, fkeig->Eval(pt)-fk->Eval(pt));
hke->SetBinError(ipt, fabs(fkeig->Eval(pt)-fk->Eval(pt)));
}
hke->Write(hke->GetName(), TObject::kOverwrite);
}
cout << "." << flush;
} // if tree
} // for isample
} // for imethod
} // for itype
c3->cd(0);
//cmsPrel(_lumi, true);
CMS_lumi(c3, 2, 33);
c3->SaveAs("pdf/softrad_2x6_kfsr.pdf");
fin->Close();
curdir->cd();
} // softrad
void DrawKinvarPlot(TString filename="kinvarset/FMSOR_Pt_vs_run.root",
TString classname="pi0") {
TFile * infile = new TFile(filename.Data(),"READ");
char trig[32];
char typ[32];
char tmp[128];
TString tmpstr = filename;
tmpstr.ReplaceAll("_"," ");
TRegexp re("^.*\/");
tmpstr(re) = "";
cout << tmpstr << endl;
sscanf(tmpstr.Data(),"%s %s",trig,typ);
printf("%s %s\n",trig,typ);
TString hname = "h2_"+classname;
TH2D * h = (TH2D*)infile->Get(hname.Data());
TString gname = "g_"+classname;
TGraphErrors * g = (TGraphErrors*)infile->Get(gname.Data());
TString gtname = "gt_"+classname;
TGraphErrors * gt;
if(!strcmp(typ,"Pt")) gt = (TGraphErrors*)infile->Get(gtname.Data());
char htitle[256];
char hnewtitle[512];
strcpy(htitle,h->GetTitle());
sprintf(hnewtitle,"%s -- %s triggers",htitle,trig);
h->SetTitle(hnewtitle);
h->SetMinimum(0.001);
if(!strcmp(typ,"Pt")) {
gt->SetLineWidth(2);
gt->SetLineColor(kBlack);
};
// temporary hack to cut out fluctuations of pt_thresh vs. run to 0
Double_t xx,yy;
Int_t gtn = gt->GetN();
for(int ii=0; ii<gtn; ii++) {
gt->GetPoint(ii,xx,yy);
printf("xx=%f yy=%f\n",xx,yy);
if(yy<0.001) gt->RemovePoint(ii);
};
// drawing range
Float_t xmin = h->GetXaxis()->GetXmin();
Float_t xmax = h->GetXaxis()->GetXmax();
xmax = 515;
if(xmax<gtn) {
fprintf(stderr,"\nWARNING: xmax < gt->GetN(); graphs will be cut off!\n\n");
};
TCanvas * c = new TCanvas("c","c",1500,700);
c->Divide(1,2);
gStyle->SetOptStat(0);
for(int x=1; x<=2; x++) c->GetPad(x)->SetGrid(1,1);
c->cd(1);
c->GetPad(1)->SetLogz();
h->GetXaxis()->SetRangeUser(xmin,xmax);
h->Draw("colz");
if(!strcmp(typ,"Pt")) gt->Draw("LX");
c->cd(2);
g->SetFillColor(kGray);
printf("%f %f\n",xmin,xmax);
g->GetXaxis()->SetLimits(xmin,xmax);
g->GetXaxis()->SetRangeUser(xmin,xmax);
/*
g->Draw("A3");
g->Draw("PLX");
*/
g->Draw("APLX");
TString outname = filename.ReplaceAll(".root"," "+classname);
outname = outname+".png";
c->Print(outname.Data(),"png");
};
void AnalyzeWaveforms(char *WaveformsFile = "Waveforms.root", const int nAddedChannels = 5) {
//try to access waveforms file and in case of failure return
if(gSystem->AccessPathName(WaveformsFile,kFileExists)) {
cout << "Error: file " << WaveformsFile << " does not exsist. Run .x WaveformsFileMaker.C to create it" << endl;
return;
}
// gStyle->SetOptFit(111);
// gStyle->SetStatFormat("1.3E");
// gStyle->SetFitFormat("1.3E");
// fetch the list of trees contained in the waveforms file
// for every tree generate a waveform graph
TFile *f = TFile::Open(WaveformsFile);
TList *listOfKeys = f->GetListOfKeys();
Int_t numberOfKeys = listOfKeys->GetEntries();
TList *listOfGraphs = new TList();
// if the waveform file name begins with the string "comparator" it goes in this list
TList *listOfCompWaves = new TList();
// if the waveform file name begins with the string "sum output" it goes in this list
TList *listOfAdderWaves = new TList();
for(Int_t i = 0; i < numberOfKeys; i++) {
TString *keyName = new TString(listOfKeys->At(i)->GetName());
TTree *tree = (TTree*)f->Get(keyName->Data());
Float_t x = 0;
Float_t y = 0;
tree->SetBranchAddress("x",&x);
tree->SetBranchAddress("y",&y);
Int_t nentries = tree->GetEntries();
TString *gName = new TString(keyName->Data());
gName->Append(" graph");
TGraphErrors *gWave = new TGraphErrors(nentries);
gWave->SetName(gName->Data());
gWave->SetTitle(gName->Data());
gWave->GetXaxis()->SetTitle("Time");
gWave->GetYaxis()->SetTitle("Voltage");
// gWave->SetBit(TH1::kCanRebin);
for (Int_t j = 0; j < nentries; j++) {
tree->GetEntry(j);
gWave->SetPoint(j,x,y);
}
listOfGraphs->Add(gWave);
if(keyName->BeginsWith("comparator"))
listOfCompWaves->Add(gWave);
if(keyName->BeginsWith("sum output"))
listOfAdderWaves->Add(gWave);
/* TString *cName = new TString(keyName->Data());
cName->Append(" canvas");
TCanvas *cy = new TCanvas(cName->Data(),cName->Data(),800,600);
gWave->Draw("AL"); */
}
cout << listOfAdderWaves->GetEntries() << endl;
// analysis for waves with no delay
// global variables
Double_t xMin,xMax,yStart,yEnd;
Int_t graphPoints;
Double_t step;
// comparator outputs waves sum
TGraphErrors *gFirstCompWave = (TGraphErrors *)listOfCompWaves->First();
graphPoints = gFirstCompWave->GetN();
gFirstCompWave->GetPoint(0,xMin,yStart);
gFirstCompWave->GetPoint(graphPoints - 1,xMax,yEnd);
step = (xMax - xMin)/graphPoints;
cout << gFirstCompWave->GetName() << endl;
cout << "xMin = " << xMin << " xMax = " << xMax << " graphPoints = " << graphPoints << endl;
TGraphErrors *gCompSum = new TGraphErrors(graphPoints);
gCompSum->SetLineColor(kBlue);
gCompSum->SetLineWidth(2);
gCompSum->SetName("Comparator Outputs Sum");
gCompSum->SetTitle("Comparator Outputs Sum");
Int_t nCompWaves = listOfCompWaves->GetEntries();
Float_t gx,gy = 0;
// Alpha coefficiens are now written "hard coded" here
Float_t alphaArray[3] = {0.199,0.201,0.197};
// Deleays coming from the multiplexer are written "hard coded" here
Float_t muxDelayArray[3] = {0,77.14E-12,192.01E-12};
for(Int_t i = 0; i < graphPoints; i++) {
for(Int_t j = 0; j < nCompWaves; j++) {
TGraphErrors *gCompWave = (TGraphErrors *)listOfCompWaves->At(j);
gy += (gCompWave->Eval(xMin + i*step + muxDelayArray[j]))*alphaArray[j];
}
gCompSum->SetPoint(i,xMin + i*step,gy);
gy = 0;
}
// note that there is a manual correction on the x axis for the comparator waves sum to compare them better in the multigraph
Double_t *xArray = gCompSum->GetX();
for(Int_t i = 0; i < graphPoints; i++) {
xArray[i] += 5.6E-9;
}
// TCanvas *cCompSum = new TCanvas("cCompSum","Comparator Outputs Sum",800,600);
// gCompSum->Draw("AL");
// adder outputs waves sum
// THE ANALYSIS FOR THE ADDER OUTPUT WITH NOT DELAY AND 3 CHANNELS ADDED IS DEPRECATED.
// THERE WAS A MISTAKE IN THE DATA TAKING
// I'LL KEEP THE CODE HERE FOR FURTHER REFERENCE
/*
TGraphErrors *gFirstAdderWave = (TGraphErrors *)listOfAdderWaves->First();
graphPoints = gFirstAdderWave->GetN();
gFirstAdderWave->GetPoint(0,xMin,yStart);
gFirstAdderWave->GetPoint(graphPoints - 1,xMax,yEnd);
step = (xMax - xMin)/graphPoints;
cout << gFirstAdderWave->GetName() << endl;
cout << "xMin : " << xMin << " xMax : " << xMax << endl;
TGraphErrors *gAdderSum = new TGraphErrors(graphPoints);
gAdderSum->SetLineWidth(2);
// gAdderSum->SetLineColor(kGreen);
gAdderSum->SetLineStyle(9);
gAdderSum->SetName("Sum of the adder outputs with no delay");
gAdderSum->SetTitle("Sum of the adder outputs with no delay");
Int_t nAdderWaves = listOfAdderWaves->GetEntries();
gy = 0;
for(Int_t i = 0; i < graphPoints; i++) {
for(Int_t j = 0; j < nAdderWaves; j++) {
TGraphErrors *gAdderWave = (TGraphErrors *)listOfAdderWaves->At(j);
gy += gAdderWave->Eval(xMin + i*step);
}
gAdderSum->SetPoint(i,xMin + i*step,gy);
gy = 0;
}
// TCanvas *cAdderSum = new TCanvas("cAdderSum","Sum of the adder outputs",800,600);
// gAdderSum->Draw("AL");
TGraphErrors *g3ChannelsSumNoDelay = listOfGraphs->FindObject("sum_output_3_channels_(3) graph");
g3ChannelsSumNoDelay->SetLineColor(kRed);
g3ChannelsSumNoDelay->SetLineWidth(2);
// note that there is a manual correction on the x axis for the adder output to compare it better in the multigraph
Double_t *xArray = g3ChannelsSumNoDelay->GetX();
graphPoints = g3ChannelsSumNoDelay->GetN();
for(Int_t i = 0; i < graphPoints; i++) {
xArray[i] -= 600E-12;
}
// comparison among the computed adder output ,the real one and the sum of the comparator outputs with alpha coefficients correction
TMultiGraph *mgSumNoDelay = new TMultiGraph();
mgSumNoDelay->Add(g3ChannelsSumNoDelay);
mgSumNoDelay->Add(gAdderSum);
mgSumNoDelay->Add(gCompSum);
mgSumNoDelay->SetTitle("Collection of graphs for 3 channels sum with no delay");
TCanvas *cmgSumNoDelay = new TCanvas("cmgSumNoDelay", "Collection of graphs for 3 channels sum with no delay", 1200,800);
cmgSumNoDelay->Update();
mgSumNoDelay->Draw("AL");
legend = new TLegend(0.6,0.78,0.99,0.99);
legend->AddEntry(g3ChannelsSumNoDelay, "Actual sum done by the adder", "lp");
legend->AddEntry(gAdderSum, "Sum of the adder outputs", "lp");
legend->AddEntry(gCompSum, "Sum of the comparator outputs","lp");
legend->Draw();
mgSumNoDelay->GetXaxis()->SetTitle("Seconds");
mgSumNoDelay->GetYaxis()->SetTitle("Volts");
TPaveText *title = (TPaveText*)cmgSumNoDelay->GetPrimitive("title");
title->SetX1NDC(0.009);
title->SetY1NDC(0.94);
title->SetX2NDC(0.56);
title->SetY2NDC(0.99);
cmgSumNoDelay->Modified();
*/
// analysis for delayed adder outputs
Int_t nAdderWaves = listOfAdderWaves->GetEntries();
TGraphErrors *g3ChannelsSumDelay = listOfGraphs->FindObject("sum_output_3_channels_(1-1-1) graph");
g3ChannelsSumDelay->SetLineColor(kRed);
g3ChannelsSumDelay->SetLineWidth(2);
// Delay coming from cables are written "hard coded" here
Float_t cablesDelayArray[3] = {0,1.45E-9,3.21E-9};
graphPoints = g3ChannelsSumDelay->GetN();
//g3ChannelsSumDelay->GetPoint(0,xMin,yStart);
//g3ChannelsSumDelay->GetPoint(graphPoints - 1,xMax,yEnd);
xMin = 6E-9;
xMax = 16E-9;
step = (xMax - xMin)/graphPoints;
cout << "Sum of the adder outputs with delay" << endl;
cout << "xMin : " << xMin << " xMax : " << xMax << endl;
TGraphErrors *gAdderSumDelay = new TGraphErrors(graphPoints);
gAdderSumDelay->SetLineColor(kBlue);
gAdderSumDelay->SetLineWidth(2);
gAdderSumDelay->SetName("Sum of the adder outputs with delay");
gAdderSumDelay->SetTitle("Sum of the adder outputs with delay");
gy = 0;
// note that there is a manual correction on the delay of 500E-12 to compare the adder output better in the multigraph
for(Int_t i = 0; i < graphPoints; i++) {
for(Int_t j = 0; j < nAdderWaves; j++) {
TGraphErrors *gAdderWave = (TGraphErrors *)listOfAdderWaves->At(j);
gy += gAdderWave->Eval(xMin + i*step + cablesDelayArray[j] - 500E-12);
}
gAdderSumDelay->SetPoint(i,xMin + i*step,gy);
gy = 0;
}
// TCanvas *cSumSumDelay = new TCanvas("cSumSumDelay","Sum of the sum outputs with delay",800,600);
// gAdderSumDelay->Draw("APEL");
TMultiGraph *mg3ChannelsSumDelay = new TMultiGraph();
mg3ChannelsSumDelay->Add(gAdderSumDelay);
mg3ChannelsSumDelay->Add(g3ChannelsSumDelay);
mg3ChannelsSumDelay->SetTitle("Collection of graphs for 3 channels sum with delay");
TCanvas *cmg3ChannelsSumDelay = new TCanvas("cmg3ChannelsSumDelay", "Collection of graphs for 3 channels sum with delay", 1200, 800);
cmg3ChannelsSumDelay->Update();
legend = new TLegend(0.6,0.78,0.99,0.99);
legend->AddEntry(g3ChannelsSumDelay, "Actual sum done by the adder", "lp");
legend->AddEntry(gAdderSumDelay, "Sum of the delayed adder outputs", "lp");
mg3ChannelsSumDelay->Draw("AL");
legend->Draw();
mg3ChannelsSumDelay->GetXaxis()->SetTitle("Seconds");
mg3ChannelsSumDelay->GetYaxis()->SetTitle("Volts");
TPaveText *title = (TPaveText*)cmg3ChannelsSumDelay->GetPrimitive("title");
title->SetX1NDC(0.009);
title->SetY1NDC(0.94);
title->SetX2NDC(0.56);
title->SetY2NDC(0.99);
cmg3ChannelsSumDelay->Modified();
/*
// delay test just to try a different method
TMultiGraph *mgDelayTest = new TMultiGraph();
Double_t gxTest,gyTest;
TGraphErrors *gDelayTest0 = new TGraphErrors(((TGraphErrors *)listOfAdderWaves->At(0))->GetN());
for(Int_t j = 0; j < gDelayTest0->GetN(); j++) {
((TGraphErrors *)listOfAdderWaves->At(0))->GetPoint(j,gxTest,gyTest);
gDelayTest0->SetPoint(j,gxTest - cablesDelayArray[0],gyTest);
}
mgDelayTest->Add(gDelayTest0);
TGraphErrors *gDelayTest1 = new TGraphErrors(((TGraphErrors *)listOfAdderWaves->At(1))->GetN());
for(Int_t j = 0; j < gDelayTest1->GetN(); j++) {
((TGraphErrors *)listOfAdderWaves->At(1))->GetPoint(j,gxTest,gyTest);
gDelayTest1->SetPoint(j,gxTest - cablesDelayArray[1],gyTest);
}
mgDelayTest->Add(gDelayTest1);
TGraphErrors *gDelayTest2 = new TGraphErrors(((TGraphErrors *)listOfAdderWaves->At(2))->GetN());
for(Int_t j = 0; j < gDelayTest2->GetN(); j++) {
((TGraphErrors *)listOfAdderWaves->At(2))->GetPoint(j,gxTest,gyTest);
gDelayTest2->SetPoint(j,gxTest - cablesDelayArray[2],gyTest);
}
mgDelayTest->Add(gDelayTest2);
// TCanvas *cmgDelayTest = new TCanvas("cmgDelayTest", "cmgDelayTest", 800,600);
// mgDelayTest->Draw("APEL");
graphPoints = 12000;
xMin = 2E-9;
xMax = 22E-9;
step = (xMax - xMin)/graphPoints;
cout << "xMin : " << xMin << " xMax : " << xMax << endl;
Double_t delayTest0xMin,delayTest0xMax,delayTest1xMin,delayTest1xMax,delayTest2xMin,delayTest2xMax;
gDelayTest0->GetPoint(0,delayTest0xMin,gyTest);
gDelayTest0->GetPoint(gDelayTest0->GetN() - 1,delayTest0xMax,gyTest);
gDelayTest1->GetPoint(0,delayTest1xMin,gyTest);
gDelayTest1->GetPoint(gDelayTest1->GetN() - 1,delayTest1xMax,gyTest);
gDelayTest2->GetPoint(0,delayTest2xMin,gyTest);
gDelayTest2->GetPoint(gDelayTest2->GetN() - 1,delayTest2xMax,gyTest);
cout << delayTest0xMin << endl;
TGraphErrors *gAdderSumDelayV2 = new TGraphErrors(graphPoints);
for(Int_t i = 0; i < graphPoints; i++) {
gyTest = gDelayTest0->Eval(xMin + i*step);
gyTest += gDelayTest1->Eval(xMin + i*step);
gyTest += gDelayTest2->Eval(xMin + i*step);
gAdderSumDelayV2->SetPoint(i,xMin + i*step+ 500E-12,gyTest);
}
gAdderSumDelayV2->SetLineColor(kGreen);
gAdderSumDelayV2->SetLineWidth(2);
mg3ChannelsSumDelay->Add(gAdderSumDelayV2);
c3ChannelsSumDelay->Modified();
TCanvas *cAdderSumDelayV2 = new TCanvas("cAdderSumDelayV2","cAdderSumDelayV2",800,600);
gAdderSumDelayV2->Draw("APL");
*/
// List of waves representing the adder output with 5,4,3,2,1 channels in input
TGraphErrors *gAdder5Channels = listOfGraphs->FindObject("adder output 5 channels v2 graph");
TGraphErrors *gAdder4Channels = listOfGraphs->FindObject("adder output 4 channels v2 graph");
TGraphErrors *gAdder3Channels = listOfGraphs->FindObject("adder output 3 channels v2 graph");
TGraphErrors *gAdder2Channels = listOfGraphs->FindObject("adder output 2 channels v2 graph");
TGraphErrors *gAdder1Channel = listOfGraphs->FindObject("adder output 1 channel v2 graph");
TGraphErrors *gAdderSingleCh0 = listOfGraphs->FindObject("single sum output ch 0 input 500 mV DT 100 mV graph");
TGraphErrors *gAdderSingleCh1 = listOfGraphs->FindObject("single sum output ch 1 input 500 mV DT 100 mV graph");
TGraphErrors *gAdderSingleCh4 = listOfGraphs->FindObject("single sum output ch 4 input 500 mV DT 100 mV graph");
TGraphErrors *gAdderSingleCh5 = listOfGraphs->FindObject("single sum output ch 5 input 500 mV DT 100 mV graph");
TGraphErrors *gAdderSingleCh7 = listOfGraphs->FindObject("single sum output ch 7 input 500 mV DT 100 mV graph");
TMultiGraph *mgAdder54321Channels = new TMultiGraph();
mgAdder54321Channels->SetTitle("Collection of graphs for different numbers of added channels");
mgAdder54321Channels->Add(gAdder5Channels);
mgAdder54321Channels->Add(gAdder4Channels);
mgAdder54321Channels->Add(gAdder3Channels);
mgAdder54321Channels->Add(gAdder2Channels);
mgAdder54321Channels->Add(gAdder1Channel);
TCanvas *cmgAdder54321Channels = new TCanvas("cmgAdder54321Channels", "Collection of graphs for different numbers of added channels",1200,800);
mgAdder54321Channels->Draw("AL");
cmgAdder54321Channels->Update();
mgAdder54321Channels->GetXaxis()->SetTitle("seconds");
mgAdder54321Channels->GetYaxis()->SetTitle("Volts");
cmgAdder54321Channels->Modified();
// analysis of the linearity of the adder
Double_t addedVMax[nAddedChannels];
addedVMax[0] = TMath::MaxElement(gAdder1Channel->GetN(), gAdder1Channel->GetY());
addedVMax[1] = TMath::MaxElement(gAdder2Channels->GetN(), gAdder2Channels->GetY());
addedVMax[2] = TMath::MaxElement(gAdder3Channels->GetN(), gAdder3Channels->GetY());
addedVMax[3] = TMath::MaxElement(gAdder4Channels->GetN(), gAdder4Channels->GetY());
addedVMax[4] = TMath::MaxElement(gAdder5Channels->GetN(), gAdder5Channels->GetY());
Double_t singleVMax[nAddedChannels];
singleVMax[0] = TMath::MaxElement(gAdderSingleCh0->GetN(), gAdderSingleCh0->GetY());
singleVMax[1] = TMath::MaxElement(gAdderSingleCh1->GetN(), gAdderSingleCh1->GetY());
singleVMax[2] = TMath::MaxElement(gAdderSingleCh4->GetN(), gAdderSingleCh4->GetY());
singleVMax[3] = TMath::MaxElement(gAdderSingleCh5->GetN(), gAdderSingleCh5->GetY());
singleVMax[4] = TMath::MaxElement(gAdderSingleCh7->GetN(), gAdderSingleCh7->GetY());
vector<double> expectedVMax(nAddedChannels);
Double_t previousVmax = 0;
for(Int_t i = 0; i < expectedVMax.size(); i++) {
expectedVMax[i] = singleVMax[i] + previousVmax;
previousVmax = expectedVMax[i];
cout << "singleVMax[" <<i <<"] = " << singleVMax[i] << endl;
cout << "addedVMax[" <<i <<"] = " << addedVMax[i] << endl;
cout << "expectedVMax[" <<i <<"] = " << expectedVMax[i] << endl;
}
TGraph *gAdderLinearity = new TGraph(expectedVMax.size(),&expectedVMax[0],addedVMax);
gAdderLinearity->SetTitle("Linearity of the adder");
gAdderLinearity->GetXaxis()->SetTitle("Expected amplitude value (V)");
gAdderLinearity->GetYaxis()->SetTitle("Actual amplitude value (V)");
gAdderLinearity->GetYaxis()->SetTitleOffset(1.3);
TCanvas *cgAdderLinearity = new TCanvas("cgAdderLinearity","Linearity of the adder",800,600);
cgAdderLinearity->SetGrid();
cgAdderLinearity->Update();
gAdderLinearity->SetMarkerStyle(20);
gAdderLinearity->SetMarkerSize(0.8);
//gAdderLinearity->Fit("pol1","Q+","",expectedVMax[0],expectedVMax[2]);
TF1 *line = new TF1("line","x",expectedVMax.back(),expectedVMax.front());
gAdderLinearity->Draw("APEL");
line->Draw("SAME");
//gAdderLinearity->GetFunction("pol1")->SetRange(expectedVMax.back(),expectedVMax.front());;
cgAdderLinearity->SetLeftMargin(0.13);
cgAdderLinearity->Modified();
f->Close();
}
int evaluate( std::string filelist, std::string outfile )
{
gStyle->SetOptStat(0);
TCanvas *ctemp = new TCanvas();
TCanvas *cres = new TCanvas("TimeDependence");
TH1F* hres = new TH1F("hres","",100,0,650);
hres->GetYaxis()->SetRangeUser(0,50);
hres->SetTitle("");
hres->GetXaxis()->SetTitle("time (s)");
hres->GetYaxis()->SetTitle("B_{int} (mT)");
hres->Draw();
leg = new TLegend(0.2,0.6,0.9,0.9);
// leg->SetHeader("The Legend Title"); // option "C" allows to center the header
leg->SetNColumns(5);
vector< double > v_Bint;
vector< double > v_BintErr;
vector< double > v_Bext;
vector< double > v_BextErr;
/* Loop over all lines in input file */
std::ifstream infilelist(filelist);
std::string line;
unsigned colorcounter=38;
while (std::getline(infilelist, line))
{
// skip lines with '#' and empty lines
if ( line.find("#") != string::npos )
{
cout << "Skip line " << line << endl;
continue;
}
if ( line == "" )
continue;
//cout << "Processing file " << line << endl;
TString infilename("data_calib/");
infilename.Append(line);
TFile *fin = new TFile( infilename );
TTree *tin = (TTree*)fin->Get("t");
ctemp->cd();
tin->Draw("Bi:time");
TGraph *gtime = new TGraph(tin->GetEntries(), &(tin->GetV2()[0]), &(tin->GetV1()[0]));
gtime->SetLineColor(colorcounter);
colorcounter++;
TH1F* hBext = new TH1F("hBext","",100,0,1000);
tin->Draw("Bo >> hBext");
cres->cd();
gtime->Draw("lsame");
double Bext_i = hBext->GetMean();
double BextErr_i = hBext->GetRMS();
double Bint_i = gtime->Eval(590);
double BintErr_i = 0;
/* add legend entry */
TString legname("B_ext ~ ");
legname += (int)Bext_i;
leg->AddEntry(gtime,legname,"l");
cout << "B_ext: " << Bext_i << " \t B_int: " << Bint_i << endl;
v_Bint.push_back(Bint_i);
v_BintErr.push_back(BintErr_i);
v_Bext.push_back(Bext_i);
v_BextErr.push_back(BextErr_i);
}
cres->cd();
leg->Draw();
TGraphErrors *gfinal = new TGraphErrors(v_Bext.size(), &(v_Bext[0]), &(v_Bint[0]), &(v_BextErr[0]), &(v_BintErr[0]));
gfinal->Sort();
gfinal->SetName("Bint_Vs_Bext");
gfinal->SetTitle("");
gfinal->GetXaxis()->SetTitle("B_{ext} (mT)");
gfinal->GetYaxis()->SetTitle("B_{int} (mT)");
TCanvas *cfinal = new TCanvas();
gfinal->Draw("APL");
/* Save output graph */
TString outfilename("output/");
outfilename.Append(outfile);
TFile *fout = new TFile(outfilename,"RECREATE");
cres->Write();
gfinal->Write();
fout->Close();
/* Write result to txt output file */
TString outfilenametxt = outfilename;
outfilenametxt.ReplaceAll(".root",".txt");
ofstream foutxt;
foutxt.open( outfilenametxt );
foutxt << "# Bo sig_Bo Bi sig_Bi shield sig_shield sf sig_sf time_dependent" << endl;
for ( int i = 0; i < gfinal->GetN(); i++ )
{
double Bo = gfinal->GetX()[i];
double sig_Bo = gfinal->GetEX()[i];
double Bi = gfinal->GetY()[i];
double sig_Bi = gfinal->GetEY()[i];
double shield = 0;
double sig_shield = 0;
double sf = 0;
double sig_sf = 0;
double time_dependent = 0;
foutxt << Bo << " " << sig_Bo << " " << Bi << " " << sig_Bi << " "
<< shield << " " << sig_shield << " " << sf << " " << sig_sf
<< " " << time_dependent << endl;
}
return 0;
}
void pointsed(TString filename = "btagpatanalyzerpy.root", TString check="") {
TString cmssw;
// 167
cmssw = "$3.1.0_pre9$";
TFile *f = TFile::Open(filename);
/////////////////////////////////////////////////////////////////////////////////////////
std::vector< TString > checks;
checks.push_back("");
checks.push_back("Corr30_");
checks.push_back("Corr30t0_");
checks.push_back("Corr30t1_");
checks.push_back("Corr30t2_");
checks.push_back("Corr30t0_nConstituent_");
checks.push_back("Corr30t1_nConstituent_");
checks.push_back("Corr30t2_nConstituent_");
checks.push_back("Uncor10_");
checks.push_back("Uncor10t0_");
checks.push_back("Uncor10t1_");
checks.push_back("Uncor10t2_");
checks.push_back("Uncor10t0_nConstituent_");
checks.push_back("Uncor10t1_nConstituent_");
checks.push_back("Uncor10t2_nConstituent_");
/////////////////////////////////////////////////////////////////////////////////////////
std::vector< TString > taggers;
std::vector< TString > labeltag;
std::vector< int> colorlines;
taggers.push_back( "TC2" );colorlines.push_back( 1 );labeltag.push_back( "TCHE");
taggers.push_back( "TC3" );colorlines.push_back( 2 );labeltag.push_back( "TCHP");
taggers.push_back( "TP" );colorlines.push_back( 3 );labeltag.push_back( "JP");
taggers.push_back( "SSV" );colorlines.push_back( 4 );labeltag.push_back( "SSV");
taggers.push_back( "CSV" );colorlines.push_back( 5 );labeltag.push_back( "CSV");
taggers.push_back( "MSV" );colorlines.push_back( 6 );labeltag.push_back( "CSVMVAB");
taggers.push_back( "SMT" );colorlines.push_back( 8 );labeltag.push_back( "SMT");
taggers.push_back( "BTP" );colorlines.push_back( 9 );labeltag.push_back( "JBP");
taggers.push_back( "SMTbyIP3d" );colorlines.push_back( 11 );labeltag.push_back( "SMTByIP3d");
taggers.push_back( "SMTbyPt" );colorlines.push_back( 12 );labeltag.push_back( "SMTByPt");
taggers.push_back( "SETbyIP3d" );colorlines.push_back( 13 );labeltag.push_back( "SETByIP3d");
taggers.push_back( "SETbyPt" );colorlines.push_back( 14 );labeltag.push_back( "SETByPt");
// taggers.push_back( "IPM" );colorlines.push_back( 11 );labeltag.push_back( "IPMVAB");
// taggers.push_back( "SMNIPT" );colorlines.push_back( 12 );labeltag.push_back( "SMTNoIP");
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//ed for ( size_t ichks = 0; ichks < checks.size(); ++ichks ) {
//ed TString check = checks[ichks];
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
TString PerfTitle= check;
if (check == "") PerfTitle="uncorr pt>30";
if (check == "Corr30_") PerfTitle="pt>30";
if (check == "Corr30t0_") PerfTitle="pt>30, #tracks > 0";
if (check == "Corr30t1_") PerfTitle="pt>30, #tracks > 1";
if (check == "Corr30t2_") PerfTitle="pt>30, #tracks > 2";
if (check == "Corr30t0_nConstituent_") PerfTitle="pt>30, #tracks > 0 & nConstituents >1";
if (check == "Corr30t1_nConstituent_") PerfTitle="pt>30, #tracks > 1 & nConstituents >1";
if (check == "Corr30t2_nConstituent_") PerfTitle="pt>30, #tracks > 2 & nConstituents >1";
if (check == "Uncor10_") PerfTitle="uncorr pt>10";
if (check == "Uncor10t0_") PerfTitle="uncorr pt>10 #tracks > 0";
if (check == "Uncor10t1_") PerfTitle="uncorr pt>10 #tracks > 1";
if (check == "Uncor10t2_") PerfTitle="uncorr pt>10 #tracks > 2";
if (check == "Uncor10t0_nConstituent_") PerfTitle="uncorr pt>10 #tracks > 0 & nConstituents >1";
if (check == "Uncor10t1_nConstituent_") PerfTitle="uncorr pt>10 #tracks > 1 & nConstituents >1";
if (check == "Uncor10t2_nConstituent_") PerfTitle="uncorr pt>10 #tracks > 2 & nConstituents >1";
std::vector< TString > discriminators;
for ( size_t itagger = 0; itagger < taggers.size(); ++itagger ) {
discriminators.push_back( check+"disc"+taggers[itagger]+"_udsg" );
}
// discriminators.push_back( "discTC3_udsg" );
// discriminators.push_back( "discTP_udsg" );
TCanvas *cv = new TCanvas("cv","cv",900,900);
TMultiGraph *mg =new TMultiGraph();
TLegend *legend0 = new TLegend(0.68,0.12,0.88,0.32);
// inverted axis
TMultiGraph *mginv =new TMultiGraph();
TLegend *legend1 = new TLegend(0.65,0.18,0.85,0.48);
std::ofstream salida("BTagPATop3"+check+".txt");
for ( size_t itagger = 0; itagger < taggers.size(); ++itagger ) {
TString tag = check+"g"+taggers[itagger]+"_udsg";
TGraphErrors *agraph = (TGraphErrors*) gDirectory->Get("BTagPATAnalyzer"+taggers[itagger]+"/"+taggers[itagger]+"/"+tag);
TGraph *dgraph = (TGraph*) gDirectory->Get("BTagPATAnalyzer"+taggers[itagger]+"/"+taggers[itagger]+"/"+discriminators[itagger]);
// TGraph *udsgvsdgraph = new TGraph(dgraph->GetN(),dgraph->GetY(),dgraph->GetX());
dgraph->Sort();
// udsgvsdgraph->Sort();
TGraphErrors *g = new TGraphErrors(agraph->GetN(),agraph->GetY(),agraph->GetX(),agraph->GetEY(),agraph->GetEX());
g->Sort();
g->SetLineColor(itagger+1);
legend0 -> AddEntry(g,taggers[itagger],"l");
mg->Add(g);
//inverted axis
TGraphErrors *ginv = new TGraphErrors(agraph->GetN(),agraph->GetX(),agraph->GetY(),agraph->GetEX(),agraph->GetEY());
ginv->Sort();
ginv->SetLineColor(colorlines[itagger]);
ginv->SetMarkerStyle(8);
ginv->SetMarkerColor(colorlines[itagger]);
legend1 -> AddEntry(ginv,labeltag[itagger],"l");
mginv->Add(ginv);
std::cout << " Tagger: " << tag << std::endl;
std::cout << " Loose(10%): " << " cut > " << std::setprecision(4) << dgraph->Eval(0.1) << " b-eff = " << g->Eval(0.1) << std::endl;
std::cout << " Medium(1%): " << " cut > " << std::setprecision(4) << dgraph->Eval(0.01) << " b-eff = " << g->Eval(0.01) << std::endl;
std::cout << " Tight(0.1%) = " << " cut > " << std::setprecision(4) << dgraph->Eval(0.001) << " b-eff = " << g->Eval(0.001) << std::endl;
salida << " " << taggers[itagger] << endl;
salida << " #bin \t b-eff \t err-beff \t non-beff \t err-non-b"<< endl;
for ( size_t i=0;i< agraph->GetN();i++){
salida << " " << (i+1) << " \t "
<< agraph->GetX()[i] <<" \t "
<< agraph->GetEX()[i]<<" \t "
<< agraph->GetY()[i] <<" \t "
<< agraph->GetEY()[i]
<< " "<< endl;
}
}
// cv->SetLogx();
mg->Draw("ALP");
mg->GetYaxis()->SetTitle("b-eff");
mg->GetXaxis()->SetTitle("udsg-mistagging");
legend0 -> Draw();
cv-> SetGrid();
cv-> Print ("BTagPATop"+check+".eps");
cv-> Print ("BTagPATop"+check+".png");
cv->cd(0);
cv->SetLogx();
mg->Draw("ALP");
legend0 -> Draw();
cv-> Print ("BTagPATop1"+check+".eps");
cv-> Print ("BTagPATop1"+check+".png");
//inverted axis
TCanvas *cvinv = new TCanvas("cvinv","cvinv",700,700);
cvinv->SetLogy(0);
mginv->Draw("ALP");
mginv->GetXaxis()->SetTitle("b-eff");
mginv->GetYaxis()->SetTitle("udsg-mistagging");
legend1 -> Draw();
cvinv->SetGrid();
cvinv-> Print ("BTagPATop2"+check+".eps");
cvinv-> Print ("BTagPATop2"+check+".png");
cvinv->cd(0);
// cvinv->Update();
// cvinv->SetLogx();
// mginv->SetXmin(10^-4);
// axis range using a histogram helper
TH2D*hpx = new TH2D("hpx",PerfTitle,200,0.0,1.005,200,0.00002,1.05);
hpx->SetStats(kFALSE);
hpx->Draw();
hpx->GetXaxis()->SetTitle("b-eff");
hpx->GetYaxis()->SetTitle("udsg-mistagging");
cvinv->SetLogy(1);
mginv->Draw("AP");
legend1 -> Draw();
cvinv-> Print ("BTagPATop3"+check+".eps");
cvinv-> Print ("BTagPATop3"+check+".png");
//ed}
}
void theoryBin(TDirectory *din, TDirectory *dth, TDirectory *dout) {
float etamin, etamax;
assert(sscanf(din->GetName(),"Eta_%f-%f",&etamin,&etamax)==2);
sscanf(din->GetName(),"Eta_%f-%f",&etamin,&etamax);
int ieta = int((0.5*(etamin+etamax))/0.5);
int jeta = (_jp_algo=="AK7" ? min(4,ieta) : ieta);
// inclusive jets
TH1D *hpt = (TH1D*)din->Get("hpt"); assert(hpt);
// theory curves
// http://www-ekp.physik.uni-karlsruhe.de/~rabbertz/fastNLO_LHC/InclusiveJets/
// -> fnl2342_cteq66_aspdf_full.root
// Numbering scheme explained in
// https://twiki.cern.ch/twiki/bin/view/CMS/CMSfastNLO
// 2-point to 6-point theory uncertainty:
// h200X00->h300X09, h400X00->h300X08
TH1D *hnlo(0);//, *hpdfup(0), *hpdfdw(0), *hscup(0), *hscdw(0);//, *herr(0);
cout << din->GetName() << " ieta="<<ieta<< " jeta="<<jeta << endl;
TH1D *hmc = (TH1D*)dth->Get("hpt_g0tw");
assert(hmc);
/*
int S = (_jp_algo=="AK7" ? 1 : 3);
TH1D *hnlo_cteq = (TH1D*)dnlo0->Get(Form("h%d00%d00",S,jeta+1));
assert(hnlo_cteq);
hnlo_cteq->Scale(1000.);
// CTEQ10
TH1D *hnlo_ct10 = (TH1D*)dnlo1->Get(Form("h300%d00",jeta+1));
TH1D *hpdfup_ct10 = (TH1D*)dnlo1->Get(Form("h300%d02",jeta+1));
TH1D *hpdfdw_ct10 = (TH1D*)dnlo1->Get(Form("h300%d01",jeta+1));
TH1D *hscup_ct10 = (TH1D*)dnlo1->Get(Form("h300%d09",jeta+1));
TH1D *hscdw_ct10 = (TH1D*)dnlo1->Get(Form("h300%d08",jeta+1));
assert(hnlo_ct10); assert(hpdfup_ct10); assert(hpdfdw_ct10);
assert(hscup_ct10); assert(hscdw_ct10);
hnlo_ct10->Scale(1000.);
hpdfup_ct10->Scale(1./1.65);
hpdfdw_ct10->Scale(1./1.65);
// MSTW2008
TH1D *hnlo_mstw = (TH1D*)dnlo2->Get(Form("h%d00%d00",S,jeta+1));
assert(hnlo_mstw);
hnlo_mstw->Scale(1000.);
// NNPDF2010
TH1D *hnlo_nnpdf = (TH1D*)dnlo3->Get(Form("h%d00%d00",S,jeta+1));
assert(hnlo_nnpdf);
hnlo_nnpdf->Scale(1000.);
// HERA10
TH1D *hnlo_hera = (TH1D*)dnlo4->Get(Form("h%d00%d00",S,jeta+1));
TH1D *hpdfup_hera = (TH1D*)dnlo4->Get(Form("h%d00%d02",S,jeta+1));
TH1D *hpdfdw_hera = (TH1D*)dnlo4->Get(Form("h%d00%d01",S,jeta+1));
assert(hnlo_hera); assert(hpdfup_hera); assert(hpdfdw_hera);
hnlo_hera->Scale(1000.);
// alpha-S
TH1D *hasup = (TH1D*)das->Get(Form("h300%d02",ieta+1));
TH1D *hasdw = (TH1D*)das->Get(Form("h300%d01",ieta+1));
assert(hasup); assert(hasdw);
TH1D *hnp = (TH1D*)dnp->Get(Form("corr%d",min(int(etamin/0.5+0.5),5)));
if (!hnp) cout << "eta: " << etamin << " " << etamax << endl;
assert(hnp);
*/
// make sure new histograms get created in the output file
dout->cd();
/*
TH1D *hnpup(0), *hnpdw(0), *hsysup(0), *hsysdw(0);
{
// Move CTEQ6.6
hnlo_cteq = (TH1D*)hnlo_cteq->Clone("hnlo0_ct10k");
hnlo_ct10 = (TH1D*)hnlo_ct10->Clone("hnlo0_ct10");
hnlo_mstw = (TH1D*)hnlo_mstw->Clone("hnlo0_mstw");
hnlo_nnpdf = (TH1D*)hnlo_nnpdf->Clone("hnlo0_nnpdf");
hnlo_hera = (TH1D*)hnlo_hera->Clone("hnlo0_hera");
// Determine PDF4LHC from CT10, MSTW08, NNPDF10
hnlo = (TH1D*)hnlo_ct10->Clone("hnlo0"); // central PDF again later
hpdfup = (TH1D*)hpdfup_ct10->Clone("hpdfup"); // central PDF
hpdfdw = (TH1D*)hpdfdw_ct10->Clone("hpdfdw"); // central PDF
for (int i = 1; i != hnlo->GetNbinsX()+1; ++i) {
// Sanity checks
assert(hpdfup_ct10->GetBinContent(i)>=0);
assert(hpdfdw_ct10->GetBinContent(i)<=0);
}
hscup = (TH1D*)hscup_ct10->Clone("hscup"); // central PDF
hscdw = (TH1D*)hscdw_ct10->Clone("hscdw"); // central PDF
hasup = (TH1D*)hasup->Clone("hasup");
hasdw = (TH1D*)hasdw->Clone("hasdw");
hnp = (TH1D*)hnp->Clone("hnpcorr");
hnpup = (TH1D*)hnlo->Clone("hnpup");
hnpdw = (TH1D*)hnlo->Clone("hnpdw");
hsysup = (TH1D*)hnlo->Clone("hsysup");
hsysdw = (TH1D*)hnlo->Clone("hsysdw");
}
*/
/*
// Patch up the hnp to adapt the wrong binning at low pT
if (true) { // patch hnp
TH1D *hnp_tmp = (TH1D*)hnlo->Clone("hnp_tmp");
for (int i = 1; i != hnlo->GetNbinsX()+1; ++i) {
double x = hnlo->GetBinCenter(i);
int j1 = hnp->FindBin(x);
double x1 = hnp->GetBinCenter(j1);
double y1 = hnp->GetBinContent(j1);
double ey1 = hnp->GetBinError(j1);
int j2 = (x>x1? j1+1 : j1-1);
double x2 = hnp->GetBinCenter(j2);
double y2 = hnp->GetBinContent(j2);
double ey2 = hnp->GetBinError(j2);
double y = y1 + (y2-y1) / (x2-x1) * (x-x1);
double ey = ey1 + (ey2-ey1) / (x2-x1) * (x-x1);
hnp_tmp->SetBinContent(i, y);
hnp_tmp->SetBinError(i, ey);
} // for i
delete hnp;
hnp = hnp_tmp;
hnp->SetName("hnpcorr");
} // patch hnp
*/
/*
// Turn NP uncertainty into uncertainty histogram
for (int i = 1; i != hnlo->GetNbinsX()+1; ++i) {
int j = hnp->FindBin(hnlo->GetBinCenter(i));
hnpup->SetBinContent(i, +hnp->GetBinError(j)/hnp->GetBinContent(j));
hnpup->SetBinError(i, 0.);
hnpdw->SetBinContent(i, -hnp->GetBinError(j)/hnp->GetBinContent(j));
hnpdw->SetBinError(i, 0.);
if (!(hnp->GetBinLowEdge(j)>=hnlo->GetBinLowEdge(i)) ||
!(hnp->GetBinLowEdge(j+1)<=hnlo->GetBinLowEdge(i+1))) {
cout << Form("hnlo = [%1.0f,%1.0f]; hnp = [%1.0f,%1.0f]",
hnlo->GetBinLowEdge(i), hnlo->GetBinLowEdge(i+1),
hnp->GetBinLowEdge(j), hnp->GetBinLowEdge(j+1)) << endl;
if (hnlo->GetBinLowEdge(i)>100 && hnlo->GetBinLowEdge(i)<2500.) {
assert(hnp->GetBinLowEdge(j)>=hnlo->GetBinLowEdge(i));
assert(hnp->GetBinLowEdge(j+1)<=hnlo->GetBinLowEdge(i+1));
}
}
} // for i
*/
/*
for (int i = 1; i != hnlo->GetNbinsX()+1; ++i) {
double x = hnlo->GetBinCenter(i);
int i1 = hnpup->FindBin(x);
double y1a = hnpup->GetBinContent(i1);
double y1b = hnpdw->GetBinContent(i1);
int i2 = hscup->FindBin(x);
double y2a = hscup->GetBinContent(i2);
double y2b = hscdw->GetBinContent(i2);
int i3 = hpdfup->FindBin(x);
double y3a = hpdfup->GetBinContent(i3);
double y3b = hpdfdw->GetBinContent(i3);
int i4 = hasup->FindBin(x);
double y4a = hasup->GetBinContent(i4);
double y4b = hasdw->GetBinContent(i4);
double errup = sqrt(pow(max3(y1a,y1b,0),2) + pow(max3(y2a,y2b,0),2)
+ pow(max3(y3a,y3b,0),2) + pow(max3(y4a,y4b,0),2));
double errdw = sqrt(pow(min3(y1a,y1b,0),2) + pow(min3(y2a,y2b,0),2)
+ pow(min3(y3a,y3b,0),2) + pow(min3(y4a,y4b,0),2));
hsysup->SetBinContent(i, errup);
hsysup->SetBinError(i, 0.);
hpdfup->SetBinError(i, 0.);
hscup->SetBinError(i, 0.);
hasup->SetBinError(i, 0);
hsysdw->SetBinContent(i, -errdw);
hsysdw->SetBinError(i, 0.);
hpdfdw->SetBinError(i, 0.);
hscdw->SetBinError(i, 0.);
hasdw->SetBinError(i, 0);
} // for i
*/
/*
for (int i = 1; i != hnlo_ct10->GetNbinsX()+1; ++i) {
double x = hnlo_ct10->GetBinCenter(i);
int jnp = hnp->FindBin(x);
double np = hnp->GetBinContent(jnp);
int j = hnlo_ct10->FindBin(x);
hnlo->SetBinContent(j, 1e-3*hnlo->GetBinContent(j)*np);
int jc = hnlo_ct10->FindBin(x);
hnlo_ct10->SetBinContent(jc, 1e-3*hnlo_ct10->GetBinContent(jc)*np);
int jk = hnlo_cteq->FindBin(x);
hnlo_cteq->SetBinContent(jk, 1e-3*hnlo_cteq->GetBinContent(jk)*np);
int jm = hnlo_mstw->FindBin(x);
hnlo_mstw->SetBinContent(jm, 1e-3*hnlo_mstw->GetBinContent(jm)*np);
int jn = hnlo_nnpdf->FindBin(x);
hnlo_nnpdf->SetBinContent(jn, 1e-3*hnlo_nnpdf->GetBinContent(jn)*np);
int jh = hnlo_hera->FindBin(x);
hnlo_hera->SetBinContent(jh, 1e-3*hnlo_hera->GetBinContent(jh)*np);
//
hnlo->SetBinError(j, 0.);
hnlo_ct10->SetBinError(jc, 0.);
hnlo_cteq->SetBinError(jk, 0.);
hnlo_mstw->SetBinError(jm, 0.);
hnlo_nnpdf->SetBinError(jn, 0.);
hnlo_hera->SetBinError(jh, 0.);
}
*/
// initial fit of the NLO curve
TF1 *fnlo = new TF1("fnlo",
"[0]*exp([1]/x)*pow(x,[2])"
"*pow(1-x*cosh([4])/3500.,[3])", 10., 1000.);
fnlo->SetParameters(2e14,-18,-5.2,8.9,0.5*ieta);
fnlo->FixParameter(4,0.5*ieta);
hnlo = hmc;
hnlo->Fit(fnlo,"QRN");
// Graph of theory points with centered bins
const double minerr = 0.02;
TGraphErrors *gnlo = new TGraphErrors(0);
TGraphErrors *gnlo2 = new TGraphErrors(0); // above + minerr
TGraphErrors *gnlocut = new TGraphErrors(0); // only up to expected pT
gnlo->SetName("gnlo");
gnlo2->SetName("gnlo2");
gnlocut->SetName("gnlocut");
for (int i = 1; i != hnlo->GetNbinsX()+1; ++i) {
double y = hnlo->GetBinContent(i);
double dy = hnlo->GetBinError(i);
double ptmin = hnlo->GetBinLowEdge(i);
double ptmax = hnlo->GetBinLowEdge(i+1);
double y0 = fnlo->Integral(ptmin, ptmax) / (ptmax - ptmin);
double x = fnlo->GetX(y0, ptmin, ptmax);
int n = gnlo->GetN();
tools::SetPoint(gnlo, n, x, y, 0, dy);
tools::SetPoint(gnlo2, n, x, y, 0, tools::oplus(dy, minerr*y));
if (y*(ptmax-ptmin) > 0.0001) { // for 10/fb
int m = gnlocut->GetN();
tools::SetPoint(gnlocut, m, x, y, 0, 0);
}
}
gnlo2->Fit(fnlo,"QRN");
// Divide graph with fit to check stability
TGraphErrors *gnlofit = new TGraphErrors(0);
gnlofit->SetName("gnlofit");
for (int i = 0; i != gnlo->GetN(); ++i) {
double x, y, ex, ey;
tools::GetPoint(gnlo, i, x, y, ex, ey);
double f = fnlo->Eval(x);
tools::SetPoint(gnlofit, i, x, y/f, ex, ey/f);
}
// Rebin theory to match data bins
TH1D *hnlo0 = hnlo;
hnlo0->SetName("hnlo0");
hnlo = tools::Rebin(hnlo0, hpt);
hnlo->SetName("hnlo");
// Same for earlier 2010 and 2011 studies to get a matching theory set
// (moved from PDF4LHC to CT10 since 2010)
if (false) {
// Match this to drawSummary.C inputs
TDirectory *curdir = gDirectory;
TFile *fin2010 = new TFile("../pfjet/output-DATA-4c.root","READ");
assert(fin2010 && !fin2010->IsZombie());
assert(fin2010->cd("Standard"));
fin2010->cd("Standard");
assert(gDirectory->cd(din->GetName()));
gDirectory->cd(din->GetName());
TDirectory *din2010 = gDirectory;
TH1D *hpt2010 = (TH1D*)din2010->Get("hpt");
curdir->cd();
TH1D *hnlo2010 = tools::Rebin(hnlo0, hpt2010);
hnlo2010->SetName("hnlo2010");
hnlo2010->Write();
}
if (false) {
// Match this to drawSummary.C inputs
TDirectory *curdir = gDirectory;
TFile *fin2011 = new TFile("backup/oct26/output-DATA-4c.root","READ");
assert(fin2011 && !fin2011->IsZombie());
assert(fin2011->cd("Standard"));
fin2011->cd("Standard");
assert(gDirectory->cd(din->GetName()));
gDirectory->cd(din->GetName());
TDirectory *din2011 = gDirectory;
TH1D *hpt2011 = (TH1D*)din2011->Get("hpt");
curdir->cd();
TH1D *hnlo2011 = tools::Rebin(hnlo0, hpt2011);
hnlo2011->SetName("hnlo2011");
hnlo2011->Write();
}
/*
{
TH1D *hnlo0_cteq = hnlo_cteq;
hnlo0_cteq->SetName("hnlo0_ct10k");
hnlo_cteq = tools::Rebin(hnlo0_cteq, hpt);
hnlo_cteq->SetName("hnlo_ct10k");
//
TH1D *hnlo0_ct10 = hnlo_ct10;
hnlo0_ct10->SetName("hnlo0_ct10");
hnlo_ct10 = tools::Rebin(hnlo0_ct10, hpt);
hnlo_ct10->SetName("hnlo_ct10");
//
TH1D *hnlo0_mstw = hnlo_mstw;
hnlo0_mstw->SetName("hnlo0_mstw");
hnlo_mstw = tools::Rebin(hnlo0_mstw, hpt);
hnlo_mstw->SetName("hnlo_mstw");
//
TH1D *hnlo0_nnpdf = hnlo_nnpdf;
hnlo0_nnpdf->SetName("hnlo0_nnpdf");
hnlo_nnpdf = tools::Rebin(hnlo0_nnpdf, hpt);
hnlo_nnpdf->SetName("hnlo_nnpdf");
//
TH1D *hnlo0_hera = hnlo_hera;
hnlo0_hera->SetName("hnlo0_hera");
hnlo_hera = tools::Rebin(hnlo0_hera, hpt);
hnlo_hera->SetName("hnlo_hera");
}
*/
dout->cd();
gnlo->Write();
gnlocut->Write();
gnlofit->Write();
fnlo->Write();
din->cd();
} // theoryBin
double FitCurve(TGraphErrors* g, int debug=0)
{
double vdep=0;
if(!g) return vdep;
TF1* f3 = new TF1("fp1", "pol1", 20, 360);
f3->SetLineColor(4);
double y;
double xlow=350;
double ymax=0;
double vdep1=0;
// prendre le point le plus haut est robuste et marche bien pour les hauts vdep
TGraphErrors *gsmooth = MedianFilter(g);
gsmooth = MedianFilter(gsmooth);
for(int ipt=0; ipt<gsmooth->GetN(); ipt++)
{
gsmooth->GetPoint(ipt, xlow, y);
if(y>ymax) {ymax=y; vdep1=xlow;}
}
//g=gsmooth;
int npt = g->GetN()-5;
xlow=350;
double chi2=0;
int status = 0;
while(chi2<5. && xlow>100 && npt>=0)
{
g->GetPoint(npt, xlow, y);
f3->SetRange(xlow, 350);
status = g->Fit("fp1", "rqn");
chi2 = f3->GetChisquare()/f3->GetNDF();
if(debug>=1) cout<<"xlow "<<xlow<<" chi2 "<<chi2<<endl;
npt--;
}
g->GetPoint(npt+2, xlow, y);
f3->SetRange(xlow, 350);
g->Fit("fp1", "rqn");
vdep = xlow;
//if(vdep>230) vdep = vdep1;
//else if(fabs(vdep-vdep1)>40) vdep = vdep1;
//vdep=vdep1;
cout<<" Vdepl = "<<vdep<<endl;
TF1* f1 = new TF1("fitsigmo", fitsigmo, 50, 350, 5);
f1->SetParameter(0, 3.);
f1->SetParameter(1, 0.02);
f1->SetParameter(2, vdep);
f1->SetParameter(3, -10.);
f1->SetParameter(4, -0.00001);
f1->SetParLimits(2, 100., 300.);
f1->SetParLimits(4, -0.1, 0);
TF1* f2 = new TF1("fitpol", fitpol, 20, 360, 6);
f2->SetParLimits(4, 100., 300.);
f2->SetParLimits(5, -0.1, 0);
/* xlow = 30;
chi2 = 100;
double xmin = xlow;
double chi2min = chi2;
string opt="rq";
if(debug>=2) opt="r";
while(chi2>0.1 && xlow<vdep-80)
{
f2->SetParameter(0, 1.);
f2->SetParameter(1, 0.005);
f2->SetParameter(2, 0.0001);
f2->SetParameter(3, 0.);
f2->SetParameter(4, vdep);
f2->SetParameter(5, -0.00001);
f2->SetRange(xlow, 350);
status = g->Fit("fitpol", opt.c_str());
if(status!=0) status = g->Fit("fitpol", opt.c_str());
chi2 = f2->GetChisquare()/f2->GetNDF();
if(debug>=1) cout<<"xlow "<<xlow<<" chi2 "<<chi2<<endl;
if(debug>=2) cout<<" chi2 "<<f2->GetChisquare()<<" ndf "<<f2->GetNDF()<<endl;
if(chi2<chi2min) {chi2min=chi2; xmin=xlow;}
xlow+=10;
}
f2->SetParameter(0, 1.);
f2->SetParameter(1, 0.005);
f2->SetParameter(2, 0.0001);
f2->SetParameter(3, 0.);
f2->SetParameter(4, vdep);
f2->SetParameter(5, -0.00001);
f2->SetRange(xmin, 350);
status = g->Fit("fitpol", opt.c_str());
if(status!=0) status = g->Fit("fitpol", opt.c_str());
vdep = f2->GetParameter(4);
cout<<" Vdepl2 = "<<vdep<<" xmin "<<xmin<<endl;
if(fabs(vdep-vdep1)>30) vdep = vdep1;
*/
TGraphErrors* gmedian;
gmedian = MedianFilter( g );
int nfilt=1;
/*while (!IsMonoton(gmedian) && nfilt<4) {
gmedian = MedianFilter( gmedian );
nfilt++;
}*/
gmedian = HanningFilter(gsmooth);
cout<<nfilt<<" median filter applied"<<endl;
TGraphErrors* gscurv = GetCurvatureGraph( gmedian );
gscurv->SetMarkerStyle(20);
TGraph* g3pts = new TGraph();
float xopt = GetOptimalMinNPts(gscurv, g3pts);
vdep = xopt;
cout<<" Kink = "<<xopt<<endl;
TCanvas *c1;
TCanvas *c2;
if(debug>=1)
{
c1 = new TCanvas();
g->Draw("AP");
f2->Draw("same");
f3->Draw("same");
//gsmooth->SetMarkerColor(17);
//gsmooth->Draw("P");
//gmedian->SetMarkerColor(4);
//gmedian->Draw("P");
TLine *l = new TLine(vdep,2, vdep, ymax+0.1);
l->SetLineStyle(3);
l->Draw();
c1->Modified();
c1->Update();
string detid = g->GetTitle();
detid.erase(0,6);
//c1->Print(Form("ClusterWidthVsVbias_detid_%s_run203832.eps", detid.c_str()));
c2 = new TCanvas;
gscurv->Draw("AP");
g3pts->Draw("P");
g3pts->Fit("pol2", "q");
c2->Modified();
c2->Update();
//c2->Print(Form("ClusterWidthVsVbias_detid_%s_curv_run203832.eps", detid.c_str()));
getchar();
c1->Close();
c2->Close();
}
return vdep;
}
void DrawCosmicResult(){
TFile* tf = new TFile("Cosmic3Out.root");
TTree* trin = (TTree*)tf->Get("trOut");
const int nCSI = 2716;
Int_t RunNumber;
Int_t EventNumber;
Double_t ScintiSignal = 0;
Double_t ScintiHHTime = -500.;
Double_t ScintiTime =-500.;
Int_t nCSIDigi = 0;
Double_t CSIDigiE[nCSI];//nCSIDigi
Double_t CSIDigiTime[nCSI];//nCSIDigi
Double_t CSIDigiHHTime[nCSI];//nCSIDigi
Int_t CSIDigiID[nCSI];//nCSIDigi
Double_t CSIDigiSignal[nCSI];//nCSIDigi
Double_t FitP0[2];
Double_t FitP1[2];
Double_t FitChisq[2];
Double_t CSIDigiDeltaT0[nCSI];//nCSIDigi
Double_t CSIDigiDeltaT1[nCSI];//nCSIDigi
Int_t CosmicTrigUp;
Int_t CosmicTrigDn;
Double_t Roh;
Double_t Theta;
trin->SetBranchAddress( "RunNumber" , &RunNumber );
trin->SetBranchAddress( "EventNumber" , &EventNumber );
trin->SetBranchAddress( "ScintiSignal" , &ScintiSignal );
trin->SetBranchAddress( "ScintiHHTimne" , &ScintiHHTime );
trin->SetBranchAddress( "ScintiTime" , &ScintiTime );
trin->SetBranchAddress( "nCSIDigi" , &nCSIDigi );
trin->SetBranchAddress( "CSIDigiE" , CSIDigiE );
trin->SetBranchAddress( "CSIDigiTime" , CSIDigiTime );
trin->SetBranchAddress( "CSIDigiHHTime" , CSIDigiHHTime );
trin->SetBranchAddress( "CSIDigiID" , CSIDigiID );
trin->SetBranchAddress( "CSIDigiSignal" , CSIDigiSignal );
trin->SetBranchAddress( "CSIDigiDeltaT0" , CSIDigiDeltaT0 );
trin->SetBranchAddress( "CSIDigiDeltaT1" , CSIDigiDeltaT1 );
trin->SetBranchAddress( "FitP0" , FitP0 );
trin->SetBranchAddress( "FitP1" , FitP1 );
trin->SetBranchAddress( "FitChisq" , FitChisq );
trin->SetBranchAddress( "CosmicTrigUp" , &CosmicTrigUp );
trin->SetBranchAddress( "CosmicTrigDn" , &CosmicTrigDn );
trin->SetBranchAddress( "Roh" , &Roh );
trin->SetBranchAddress( "Theta" , &Theta );
TFile* tfout = new TFile("CosmicOut_hist3.root", "recreate");
TH2D* hisDeltaChannel = new TH2D("hisDeltaChannel","hisDeltaChannel",2716,0,2716,100,-10,10);
TH1D* hisDelta[2716];
TGraphErrors* grDelta = new TGraphErrors();
TGraphErrors* grRES = new TGraphErrors();
TCanvas *can = new TCanvas("can","",800,800);
for( int i = 0; i< 2716; i++){
hisDelta[i] = new TH1D(Form("hisDelta%d",i ),Form("hisDelta%d",i),100,-10,10);
}
for( int ievent = 0; ievent < trin->GetEntries(); ievent++){
trin->GetEntry(ievent);
for( int idigi = 0; idigi < nCSIDigi ; idigi++){
hisDelta[ CSIDigiID[ idigi ] ]->Fill( CSIDigiDeltaT1[ idigi ] );
hisDeltaChannel->Fill( CSIDigiID[ idigi ] , CSIDigiDeltaT1[ idigi ] );
//std::cout << CSIDigiID[ idigi ] << std::endl;
}
}
for( int i = 0; i< 2716; i++){
//std::cout << hisDelta[i]->GetEntries() << std::endl;
if( hisDelta[i]->GetEntries() > 10){
int rst = hisDelta[i]->Fit("gaus","Q","",hisDelta[i]->GetBinCenter( hisDelta[i]->GetMaximumBin() ) - 3, hisDelta[i]->GetBinCenter( hisDelta[i]->GetMaximumBin() )+3);
TF1* func = NULL;
func = hisDelta[i]->GetFunction("gaus");
if( func != NULL ){
grDelta->SetPoint( grDelta->GetN(), i, func->GetParameter(1));
grDelta->SetPointError( grDelta->GetN()-1, 0, func->GetParError(2));
grRES->SetPoint( grRES->GetN() , i , func->GetParameter(2));
}
}
/*
hisDelta[i]->Draw();
can->Modified();
can->Update();
getchar();
*/
hisDelta[ i ] ->Write();
}
std::ofstream ofs("TimeResolutionCosmic3.dat");
int ID[2716];
double Delta[2716];
double Resolution[2716];
for( int i = 0; i< 2716; i++){
Resolution[i] = 0xFFFF;
Delta[i] = 0xFFFF;
}
for( int i = 0; i< grRES->GetN(); i++){
Delta[(int)(grDelta->GetX()[i])] = grDelta->GetY()[i];
Resolution[(int)(grRES->GetX()[i])] = grRES->GetY()[i] ;
}
for( int i = 0; i< 2716; i++){
ofs << i << "\t"
<< Delta[i] << "\t"
<< Resolution[i] << "\n";
}
grDelta->SetNameTitle("grDelta","grDelta");
grRES->SetNameTitle("grRES","grRES");
grDelta->Write();
grRES->Write();
hisDeltaChannel->Write();
tfout->Close();
ofs.close();
}
TGraphErrors *ReadMWGraph(const char *name, Int_t flag)
{
Double_t xreject = 0.49;
TGraphErrors *g = new TGraphErrors(name);
if (g->IsZombie()) return 0;
while (g->GetX()[0] < xreject)
g->RemovePoint(0);
TGraphErrors *g2 = new TGraphErrors(name);
if (g2->IsZombie()) return 0;
while (g2->GetX()[0] < xreject)
g2->RemovePoint(0);
g2->SetMarkerStyle(4);
g2->SetMarkerSize(1.00);
g2->SetMarkerColor(kBlack);
g2->SetLineColor(kBlack);
TGraphErrors *gsys = new TGraphErrors(name, "%lg %lg %lg %*lg %lg");
if (gsys->IsZombie()) return 0;
while (gsys->GetX()[0] < xreject)
gsys->RemovePoint(0);
for (Int_t i = 0; i < gsys->GetN(); i++)
gsys->SetPointError(i, gsys->GetErrorX(i)*0.75, gsys->GetErrorY(i));
gsys->SetFillColor(kGray+2);
gsys->SetLineColor(kGray+2);
gsys->SetFillStyle(3000);
if (flag == 1 || flag == 3) {
TGraphErrors *gt = new TGraphErrors(Form("%s_%s", name, "trues"));
if (gt->IsZombie()) return 0;
while (gt->GetX()[0] < xreject)
gt->RemovePoint(0);
gt->SetMarkerStyle(20);
gt->SetMarkerSize(0.75);
gt->SetMarkerColor(kGreen+1);
gt->SetLineColor(kGreen+1);
TGraphErrors *gbw = new TGraphErrors(Form("%s_%s", name, "gen"));
if (gbw->IsZombie()) return 0;
while (gbw->GetX()[0] < xreject)
gbw->RemovePoint(0);
gbw->SetMarkerStyle(20);
gbw->SetMarkerSize(0.75);
gbw->SetMarkerColor(kBlue+1);
gbw->SetLineColor(kBlue+1);
for (Int_t i = 0; i < g->GetN(); i++) {
g->SetPointError(i, g->GetEX()[i], 0.);
gt->SetPointError(i, gt->GetEX()[i], 0.);
gbw->SetPointError(i, gbw->GetEX()[i], 0.);
}
for (Int_t i = 0; i < g2->GetN(); i++) {
g2->SetPoint(i, g2->GetX()[i], g2->GetY()[i] - gt->GetY()[i] + gbw->GetY()[i]);
g2->SetPointError(i, g2->GetEX()[i], TMath::Sqrt(g2->GetEY()[i]*g2->GetEY()[i] + gt->GetEY()[i]*gt->GetEY()[i] +
gbw->GetEY()[i]*gbw->GetEY()[i]));
// g2->SetPoint(i, g2->GetX()[i], g2->GetY()[i] - gt->GetY()[i] + 1.01947);
// g2->SetPointError(i, g2->GetEX()[i], TMath::Sqrt(g2->GetEY()[i]*g2->GetEY()[i] + gt->GetEY()[i]*gt->GetEY()[i] +
// 7.78680e-06*7.78680e-06));
gsys->SetPoint(i, gsys->GetX()[i], g2->GetY()[i]);
}
}
g->SetTitle();
g->SetName(name);
g->GetXaxis()->SetTitle("p_{T}, GeV/c");
g->SetMarkerStyle(20);
g->SetMarkerSize(0.95);
g->SetMarkerColor(kRed+1);
g->SetLineColor(kRed+1);
const Double_t mass = 1.019455;
const Double_t mass_delta = 0.000020;
const Double_t width = 0.00426;
const Double_t width_delta = 0.00004;
if (flag == 1) { // mass
g->GetYaxis()->SetTitleOffset(1.50);
g->GetYaxis()->SetTitle("mass, GeV/c^{2}");
g->SetMaximum(mass+0.0015);
g->SetMinimum(mass-0.0015);
TBox *box = new TBox(g->GetXaxis()->GetXmin(), mass - mass_delta, g->GetXaxis()->GetXmax(), mass + mass_delta);
box->SetFillColor(kGray+1);
box->SetFillStyle(3001);
g->GetListOfFunctions()->Add(box);
g->GetListOfFunctions()->Add(g2, "CP");
g->GetListOfFunctions()->Add(gt, "CP");
g->GetListOfFunctions()->Add(gbw, "CP");
}
else if (flag == 3) { // mass simple
g2->SetTitle();
g2->SetName(Form("%s_only", name));
g2->GetXaxis()->SetTitle("p_{T}, GeV/c");
g2->SetMarkerStyle(20);
g2->SetMarkerSize(0.75);
g2->SetMarkerColor(kBlack);
g2->SetLineColor(kBlack);
g2->GetYaxis()->SetTitleOffset(1.50);
g2->GetYaxis()->SetTitle("mass, GeV/c^{2}");
g2->SetMaximum(mass+0.0015);
g2->SetMinimum(mass-0.0015);
TBox *box = new TBox(g->GetXaxis()->GetXmin(), mass - mass_delta, g2->GetXaxis()->GetXmax(), mass + mass_delta);
box->SetFillColor(kGray+1);
box->SetFillStyle(3001);
g2->GetListOfFunctions()->Add(box);
g2->GetListOfFunctions()->Add(gsys, "E5");
return g2;
}
else if (flag == 2) { // width
g->SetTitle();
g->SetName(name);
g->GetXaxis()->SetTitle("p_{T}, GeV/c");
g->SetMarkerStyle(20);
g->SetMarkerSize(0.75);
g->SetMarkerColor(kBlack);
g->SetLineColor(kBlack);
g->GetYaxis()->SetTitleOffset(1.50);
g->GetYaxis()->SetTitle("width, GeV/c^{2}");
g->SetMaximum(0.01);
g->SetMinimum(0.0);
TBox *box = new TBox(g->GetXaxis()->GetXmin(), width - width_delta, g->GetXaxis()->GetXmax(), width + width_delta);
box->SetFillColor(kGray+1);
box->SetFillStyle(3001);
g->GetListOfFunctions()->Add(box);
g->GetListOfFunctions()->Add(gsys, "E5");
}
return g;
}
// /r06/lc/sg568/HCAL_Optimisation_Studies/EnergyResolutionResults/Detector_Model_103/Reco_Stage_38/Photon
// EnergyResolution_PandoraSettingsDefault_DetectorModel_103_ReconstructionVariant_38_Photon.root
void DrawNumLayers()
{
const int recoVar(71);
const int energy(100);
std::vector<int> detectorModels;
detectorModels.push_back(96);
detectorModels.push_back(97);
detectorModels.push_back(98);
detectorModels.push_back(99);
std::map<int, int> detModelToLayerNumber;
detModelToLayerNumber[96] = 30;
detModelToLayerNumber[97] = 26;
detModelToLayerNumber[98] = 20;
detModelToLayerNumber[99] = 16;
TCanvas *pTCanvas = new TCanvas();
TGraphErrors *pTGraphErrors = new TGraphErrors("EResVsLayer","EResVsLayer");
for (std::vector<int>::iterator it = detectorModels.begin(); it != detectorModels.end(); it++)
{
const int detModel(*it);
const int layerNumber(detModelToLayerNumber.find(detModel)->second);
std::string rootFile("/r06/lc/sg568/HCAL_Optimisation_Studies/EnergyResolutionResults/Detector_Model_" + NumberToString(detModel) + "/Reco_Stage_" + NumberToString(recoVar) + "/Photon/EnergyResolution_PandoraSettingsDefault_DetectorModel_" + NumberToString(detModel) + "_ReconstructionVariant_" + NumberToString(recoVar) + "_Photon.root");
std::cout << rootFile << std::endl;
TFile *pTFile = new TFile(rootFile.c_str());
std::string histogramName("Resolution_DetectorModel_" + NumberToString(detModel) + "_ReconstructionVariant_" + NumberToString(recoVar) + "/PFOEnergyHistogram_DetectorModel_" + NumberToString(detModel) + "_ReconstructionVariant_" + NumberToString(recoVar) + ";4");
std::cout << histogramName << std::endl;
TH1F *pTH1F = (TH1F*)pTFile->Get(histogramName.c_str());
std::string fitTitle = "PFOEnergyHistogramGaussianFit_DetectorModel_" + NumberToString(detModel) + "_ReconstructionVariant_" + NumberToString(recoVar) + "_Energy" + NumberToString(energy) + "GeV";
TF1 *pGaussianFit = new TF1(fitTitle.c_str(),"gaus",0,1000);
pTH1F->Fit(fitTitle.c_str());
const float fitAmplitude(pGaussianFit->GetParameter(0));
const float fitMean(pGaussianFit->GetParameter(1));
const float fitStdDev(pGaussianFit->GetParameter(2));
const float energyResolution(fitStdDev/fitMean);
const float meanError(pGaussianFit->GetParError(1));
const float meanFracError(meanError / fitMean);
const float stdDevError(pGaussianFit->GetParError(2));
const float stdDevFracError(stdDevError / fitStdDev);
const float energyResolutionError = energyResolution * std::pow( (meanFracError*meanFracError) + (stdDevFracError*stdDevFracError) ,0.5);
pTGraphErrors->SetPoint(pTGraphErrors->GetN(),layerNumber,energyResolution*100.f);
pTGraphErrors->SetPointError(pTGraphErrors->GetN()-1,0,energyResolutionError*100.f);
std::cout << "For energy : " << energy << std::endl;
std::cout << "Amplitude : " << fitAmplitude << std::endl;
std::cout << "Mean : " << fitMean << std::endl;
std::cout << "Standard Deviation : " << fitStdDev << std::endl;
std::cout << "Det model " << detModel << std::endl;
std::cout << "Energy Resolution : " << energyResolution*100 << std::endl;
}
TH2F *pAxes = new TH2F("axesEj","",100,14,32,1000,2.5,3.5);
pAxes->SetTitle("100 GeV Photon Energy Resolution vs Number of Layers in ECal (Si)");
pAxes->GetYaxis()->SetTitle("#sigma_{Reco} / E_{Reco}");
pAxes->GetXaxis()->SetTitle("Number of ECal Layers");
pAxes->Draw();
pTGraphErrors->Draw("same PL");
}
void disceff(TString filename) {
gROOT->SetStyle("Plain");
TString cmssw;
// 167
cmssw = "$3.1.0_pre9$";
TFile *f = TFile::Open(filename);
std::vector< TString > taggers;
taggers.push_back( "TC2" );
taggers.push_back( "TC3" );
taggers.push_back( "TP" );
taggers.push_back( "BTP" );
taggers.push_back( "SSV" );
taggers.push_back( "CSV" );
taggers.push_back( "MSV" );
taggers.push_back( "SMT" );
taggers.push_back( "SETbyIP3d" );
taggers.push_back( "SETbyPt" );
taggers.push_back( "SMTbyIP3d" );
taggers.push_back( "SMTbyPt" );
std::vector< TString > discriminators;
for ( size_t itagger = 0; itagger < taggers.size(); ++itagger ) {
discriminators.push_back( "disc"+taggers[itagger]+"_udsg" );
}
// discriminators.push_back( "discTC3_udsg" );
// discriminators.push_back( "discTP_udsg" );
const int dim=taggers.size();
TCanvas *cv[dim];
TMultiGraph* mg[dim];
for ( size_t itagger = 0; itagger < taggers.size(); ++itagger ) {
TString tag = "g"+taggers[itagger]+"_udsg";
TString tagb = "g"+taggers[itagger]+"_b";
TString tagc = "g"+taggers[itagger]+"_c";
cv[itagger] = new TCanvas("cv_"+taggers[itagger],"cv_"+taggers[itagger],700,700);
TLegend *legend0 = new TLegend(0.68,0.70,0.88,0.90);
TGraphErrors *agraph = (TGraphErrors*) gDirectory->Get("BTagPATAnalyzer"+taggers[itagger]+"/"+taggers[itagger]+"/"+tag);
TGraphErrors *bgraph = (TGraphErrors*) gDirectory->Get("BTagPATAnalyzer"+taggers[itagger]+"/"+taggers[itagger]+"/"+tagb);
TGraphErrors *cgraph = (TGraphErrors*) gDirectory->Get("BTagPATAnalyzer"+taggers[itagger]+"/"+taggers[itagger]+"/"+tagc);
TGraph *dgraph = (TGraph*) gDirectory->Get("BTagPATAnalyzer"+taggers[itagger]+"/"+taggers[itagger]+"/"+discriminators[itagger]);
TGraph *bvsdgraph = new TGraph(dgraph->GetN(),dgraph->GetY(),bgraph->GetY());
TGraph *cvsdgraph = new TGraph(dgraph->GetN(),dgraph->GetY(),cgraph->GetY());
TGraph *lvsdgraph = new TGraph(dgraph->GetN(),dgraph->GetY(),agraph->GetY());
TGraph *udsgvsdgraph = new TGraph(dgraph->GetN(),dgraph->GetY(),dgraph->GetX());
dgraph->Sort();
// udsgvsdgraph->Sort();
// udsgvsdgraph->SetLineColor(1);
// legend0 -> AddEntry(udsgvsdgraph,"control","l");
lvsdgraph->Sort();
lvsdgraph->SetLineColor(2);
legend0 -> AddEntry(lvsdgraph,tag,"l");
cvsdgraph->Sort();
cvsdgraph->SetLineColor(3);
legend0 -> AddEntry(cvsdgraph,tagc,"l");
bvsdgraph->Sort();
bvsdgraph->SetLineColor(4);
legend0 -> AddEntry(bvsdgraph,tagb,"l");
mg[itagger]= new TMultiGraph();
// mg[itagger]->Add(udsgvsdgraph);
mg[itagger]->Add(lvsdgraph);
mg[itagger]->Add(cvsdgraph);
mg[itagger]->Add(bvsdgraph);
// mg[itagger]->Add(dgraph);
cv[itagger]->cd(1);
mg[itagger]->Draw("ALP");
mg[itagger]->GetYaxis()->SetTitle("eff");
mg[itagger]->GetXaxis()->SetTitle("discriminant");
legend0 -> Draw();
cv[itagger]->Update();
cv[itagger]->cd(0);
cv[itagger]-> Print ("BTagPATeff_vs_disc"+taggers[itagger]+".eps");
cv[itagger]-> Print ("BTagPATeff_vs_disc"+taggers[itagger]+".ps");
TGraphErrors *g = new TGraphErrors(agraph->GetN(),agraph->GetY(),agraph->GetX(),agraph->GetEY(),agraph->GetEX());
g->Sort();
g->SetLineColor(itagger+1);
std::cout << " Tagger: " << tag << std::endl;
std::cout << " Loose(10%): " << " cut > " << std::setprecision(4) << dgraph->Eval(0.1) << " b-eff = " << g->Eval(0.1) << std::endl;
std::cout << " Medium(1%): " << " cut > " << std::setprecision(4) << dgraph->Eval(0.01) << " b-eff = " << g->Eval(0.01) << std::endl;
std::cout << " Tight(0.1%) = " << " cut > " << std::setprecision(4) << dgraph->Eval(0.001) << " b-eff = " << g->Eval(0.001) << std::endl;
}//end for
}
void getCalibrationResults(TString url="TopMassCalibration.root",int nCategs=4)
{
TString mpts[]={"161.5","163.5","166.5","169.5","172.5","175.5","178.5","181.5","184.5"};
const size_t nmpts=sizeof(mpts)/sizeof(TString);
std::vector<TString> labels;
if(nCategs==2)
{
labels.push_back("1 b-tags");
labels.push_back("#geq 2 b-tags");
}
else if(nCategs==4)
{
labels.push_back("1 b-tags (ee+#mu#mu)");
labels.push_back("#geq 2 b-tags (ee+#mu#mu)");
labels.push_back("1 b-tags (e#mu)");
labels.push_back("#geq 2 b-tags (e#mu)");
}
else
{
labels.push_back("1 b-tags (ee)");
labels.push_back("#geq 2 b-tags (ee)");
labels.push_back("1 b-tags (#mu#mu)");
labels.push_back("#geq 2 b-tags (#mu#mu)");
labels.push_back("1 b-tags (e#mu)");
labels.push_back("#geq 2 b-tags (e#mu)");
}
TString outDir=gSystem->DirName(url);
report << "Plots will be stored at @ " << outDir << endl;
TGraphErrors *lingr = new TGraphErrors;
lingr->SetMarkerStyle(20);
TGraphErrors *biasgr = new TGraphErrors;
biasgr->SetMarkerStyle(20);
std::vector<TGraphErrors *> categbiasgr;
for(int icat=0; icat<nCategs; icat++) categbiasgr.push_back( new TGraphErrors );
TObjArray statUncResults;
TObjArray pullResults;
//get results from file
TFile *fin=TFile::Open(url);
for(size_t i=0; i<nmpts; i++)
{
Float_t trueMass=mpts[i].Atof();
TH1D *massFitH=(TH1D *)fin->Get(mpts[i]+"/massfit");
if(massFitH==0) continue;
TF1 *ffunc=massFitH->GetFunction("gaus");
float avgMass=ffunc->GetParameter(1);
float avgMassErr=ffunc->GetParError(1);
int ipt=lingr->GetN();
lingr->SetPoint(ipt,trueMass,avgMass);
lingr->SetPointError(ipt,0,avgMassErr);
for(int icat=0; icat<=nCategs;icat++)
{
TString postfix("");
TGraphErrors *gr=biasgr;
if(icat<nCategs){ postfix ="_"; postfix +=( icat+1); gr=categbiasgr[icat]; }
TH1D *biasH=(TH1D *)fin->Get(mpts[i]+"/bias"+postfix);
ffunc=biasH->GetFunction("gaus");
float avgBias=ffunc->GetParameter(1);
float avgBiasErr=ffunc->GetParError(1);
ipt=gr->GetN();
gr->SetPoint(ipt,trueMass,avgBias);
gr->SetPointError(ipt,0,avgBiasErr);
if(trueMass==172.5)
{
TH1D *h=(TH1D *)fin->Get(mpts[i]+"/statunc"+postfix);
h->SetDirectory(0);
h->SetLineColor(icat==nCategs? 1 : icat+2);
h->SetMarkerColor(icat==nCategs? 1 : icat+2);
h->SetMarkerStyle(1);
h->SetLineWidth(2);
statUncResults.Add(h);
}
}
TH1D *pullH=(TH1D *)fin->Get(mpts[i]+"/pull");
pullH->SetDirectory(0);
pullResults.Add(pullH);
}
fin->Close();
//plot results
setStyle();
gStyle->SetOptFit(0);
TCanvas *c=new TCanvas("linc","linc",600,600);
c->SetWindowSize(600,600);
c->Divide(1,2);
TPad *p=(TPad *)c->cd(1);
p->SetPad(0,0.3,1.0,1.0);
lingr->Draw("ap");
lingr->GetXaxis()->SetTitle("Generated m_{top} [GeV/c^{2}]");
lingr->GetXaxis()->SetTitle("Fitted m_{top} [GeV/c^{2}]");
TLine *l=new TLine(lingr->GetXaxis()->GetXmin(),lingr->GetYaxis()->GetXmin(),
lingr->GetXaxis()->GetXmax(),lingr->GetYaxis()->GetXmax());
l->SetLineColor(kGray);
l->SetLineStyle(6);
l->Draw("same");
TLegend *leg = p->BuildLegend();
formatForCmsPublic(p,leg,"CMS simulation",3);
leg->Delete();
p=(TPad *)c->cd(2);
p->SetPad(0,0.0,1.0,0.28);
p->SetTopMargin(0);
p->SetBottomMargin(0.5);
float yscale = (1.0-0.3)/(0.28-0);
biasgr->Draw("ap");
biasgr->GetXaxis()->SetTitle("Generated m_{top} [GeV/c^{2}]");
biasgr->GetYaxis()->SetTitle("Bias");
biasgr->GetYaxis()->SetRangeUser(-5.2,5.2);
biasgr->GetXaxis()->SetTitleOffset(0.85);
biasgr->GetXaxis()->SetLabelSize(0.04 * yscale);
biasgr->GetXaxis()->SetTitleSize(0.05 * yscale);
biasgr->GetXaxis()->SetTickLength( 0.03 * yscale );
biasgr->GetYaxis()->SetTitleOffset(0.5);
biasgr->GetYaxis()->SetLabelSize(0.04 * yscale);
biasgr->GetYaxis()->SetTitleSize(0.04 * yscale);
biasgr->Fit("pol1");
float a=biasgr->GetFunction("pol1")->GetParameter(1);
float b=biasgr->GetFunction("pol1")->GetParameter(0);
report << "[Inclusive bias correction] resslope:" << (a+1.) << " resbias:" << b << endl;
c->Modified();
c->Update();
c->SaveAs(outDir+"/TopMassCalibrationResults.C");
c->SaveAs(outDir+"/TopMassCalibrationResults.png");
c->SaveAs(outDir+"/TopMassCalibrationResults.pdf");
// delete c;
//biases per category
c=new TCanvas("biasc","biasc",600,600);
c->SetWindowSize(600,600);
c->Divide(1,nCategs+1);
c->cd(nCategs+1)->Delete();
float ystep=(1.0)/(nCategs+1);
for(int icat=nCategs-1; icat>=0; --icat)
{
TGraphErrors *gr=categbiasgr[icat];
gr->SetMarkerStyle(20);
TPad *p=(TPad *)c->cd(icat+1);
p->SetFillStyle(1001);
p->SetFillColor(0);
float ymin=(icat+1)*ystep-0.05;
float ymax=(icat+2)*ystep-0.05;
if(icat==0)
{
ymin=icat*ystep;
}
p->SetPad(0,ymin,1.0,ymax);
p->SetTopMargin(0.0);
p->SetBottomMargin(icat==0?0.4:0.0);
gr->Draw("ap");
float yscale = (0.95-ystep)/(ystep-0.0);
if(icat==0) yscale=(0.95-2*ystep)/(1.2*ystep-0);
if(icat==0) gr->GetXaxis()->SetTitle("Generated m_{top} [GeV/c^{2}]");
else gr->GetXaxis()->SetNdivisions(0);
gr->GetYaxis()->SetTitle("Bias");
gr->GetYaxis()->SetRangeUser(-5.2,5.2);
gr->GetXaxis()->SetTitleOffset(0.85);
gr->GetXaxis()->SetLabelSize(0.04 * yscale);
gr->GetXaxis()->SetTitleSize(0.05 * yscale);
gr->GetXaxis()->SetTickLength( 0.03 * yscale );
gr->GetYaxis()->SetTitleOffset(icat==0?0.5:0.3);
gr->GetYaxis()->SetLabelSize(0.04 * yscale);
gr->GetYaxis()->SetTitleSize(0.04 * yscale);
gr->Fit("pol1");
float a=gr->GetFunction("pol1")->GetParameter(1);
float b=gr->GetFunction("pol1")->GetParameter(0);
report << "[Bias correction #" << icat+1 << "] resslope:" << (a+1.) << " resbias:" << b << endl;
//prepare label
TPaveText *pave = new TPaveText(0.70,0.65,0.8,0.92,"NDC");
pave->SetTextFont(42);
pave->SetFillStyle(0);
pave->SetBorderSize(0);
pave->AddText( labels[icat] )->SetTextAlign(11);
pave->Draw();
if(icat==nCategs-1)
{
pave = new TPaveText(0.2,0.75,0.45,0.92,"NDC");
pave->SetTextFont(42);
pave->SetFillStyle(0);
pave->SetBorderSize(0);
pave->AddText( "CMS simulation" )->SetTextAlign(11);
pave->Draw();
}
}
c->Modified();
c->Update();
c->SaveAs(outDir+"/TopMassCalibrationBiases.C");
c->SaveAs(outDir+"/TopMassCalibrationBiases.png");
c->SaveAs(outDir+"/TopMassCalibrationBiases.pdf");
//delete c;
//stat uncertainty
c=new TCanvas("statc","statc",600,600);
c->SetWindowSize(600,600);
for(int i=0; i<statUncResults.GetEntriesFast(); i++)
{
int idx=statUncResults.GetEntriesFast()-1-i;
statUncResults.At(idx)->Draw(i==0?"hist":"histsame");
((TH1*)statUncResults.At(idx))->SetTitle( i==0 ? "combined" :labels[idx] );
}
leg = c->BuildLegend();
formatForCmsPublic(c,leg,"CMS simulation",3); c->Modified();
c->Update();
c->SaveAs(outDir+"/TopMassCalibrationStat.C");
c->SaveAs(outDir+"/TopMassCalibrationStat.png");
c->SaveAs(outDir+"/TopMassCalibrationStat.pdf");
//delete c;
//pulls
TGraphErrors *avgPull = new TGraphErrors; avgPull->SetMarkerStyle(20);
TGraphErrors *sigmaPull = new TGraphErrors; sigmaPull->SetMarkerStyle(20);
c=new TCanvas("pullsc","pullsc",1600,(pullResults.GetEntriesFast()/4+1)*400);
c->SetWindowSize(1600,(pullResults.GetEntriesFast()/4+1)*400);
c->Divide(4,pullResults.GetEntriesFast()/4+1);
for(int i=0; i<pullResults.GetEntriesFast(); i++)
{
TPad *p=(TPad *)c->cd(i+1);
TH1 *pullH=(TH1 *)pullResults.At(i);
pullH->Draw("e1");
Float_t trueMass=mpts[i].Atof();
TF1 *gaus=pullH->GetFunction("gaus");
avgPull->SetPoint(i,trueMass,gaus->GetParameter(1));
avgPull->SetPointError(i,0,gaus->GetParError(1));
sigmaPull->SetPoint(i,trueMass,gaus->GetParameter(2));
sigmaPull->SetPointError(i,0,gaus->GetParError(2));
if(i==0)
{
leg = p->BuildLegend();
formatForCmsPublic(p,leg,"CMS simulation",3);
leg->Delete();
}
TPaveText *pave = new TPaveText(0.2,0.8,0.35,0.88,"NDC");
pave->SetTextFont(42);
pave->SetFillStyle(0);
pave->SetBorderSize(0);
pave->AddText( mpts[i] )->SetTextAlign(11);
pave->Draw();
}
c->Modified();
c->Update();
c->SaveAs(outDir+"/TopMassCalibrationPulls.C");
c->SaveAs(outDir+"/TopMassCalibrationPulls.png");
c->SaveAs(outDir+"/TopMassCalibrationPulls.pdf");
//delete c;
//pull momenta
c=new TCanvas("pullsmomc","pullsmomc",600,600);
c->SetWindowSize(600,600);
c->Divide(1,2);
p=(TPad *)c->cd(1);
avgPull->Draw("ap");
avgPull->GetYaxis()->SetRangeUser(-3,3);
avgPull->GetXaxis()->SetTitle("Generated m_{top} [GeV/c^{2}]");
avgPull->GetYaxis()->SetTitle("Average pull");
leg = p->BuildLegend();
formatForCmsPublic(p,leg,"CMS simulation",3);
leg->Delete();
c->cd(2);
sigmaPull->GetYaxis()->SetRangeUser(0.9,1.2);
sigmaPull->Draw("ap");
sigmaPull->GetXaxis()->SetTitle("Generated m_{top} [GeV/c^{2}]");
sigmaPull->GetYaxis()->SetTitle("Pull width");
c->Modified();
c->Update();
c->SaveAs(outDir+"/TopMassCalibrationPullsMomenta.C");
c->SaveAs(outDir+"/TopMassCalibrationPullsMomenta.png");
c->SaveAs(outDir+"/TopMassCalibrationPullsMomenta.pdf");
//delete c;
cout << report.str() << endl;
}
void get_nn_ptpt_FROM_FB_TREE() // TString inputFileName = "MergedOutput.root")
{
// TFile *myFile = new TFile( "/Users/macbook/alice/aliceAnalysis/results/task_2016_02_09_PbPb_Data_AOD_3etaWins_phi1_pt02_20_FB_TREE_blocks123/block1/AnalysisResults.139465.root" );
TFile *myFile = new TFile( "/Users/macbook/alice/aliceAnalysis/results/task_2016_02_21_PbPb_Data_AOD_3etaWins_phi1_pt02_20_FB_TREE_TEST_NEW_DATA_5_02TeV_tryAOD2/MergedOutput.root" );
if (!myFile)
{
cout << "No input file!" << endl;
return;
}
myFile->ls();
TList *listKeys = myFile->GetListOfKeys();
cout << "going into list: " << listKeys->At(1)->GetName() << endl;
//return;
myFile->cd( listKeys->At(1)->GetName() );
TList *listKeys2 = gDirectory->GetListOfKeys();
TList *myTask = (TList*) gDirectory->Get( listKeys2->At(0)->GetName() );
TTree *t1 = (TTree*) myTask->FindObject( "treeFB" );
// cout << t1->GetEntries() << endl;
//t1->Print();
//return;
// TFile *f = new TFile( "file_event_tree_merged_impPar_2files.root" );
// TTree *t1 = (TTree*) f->Get( "t1" );
// TFile *f = new TFile( "output_1_list.grid.root" );
// TList *list = (TList*) f->Get( "coutput_V0_mult_0.000000_100000.000000" );
// TTree *t1 = (TTree*) list->FindObject( "t1" );
//other vars:
// const int nVars = 3;
// TString strVarName[] = {
// "centr_V0M" ,
// "centr_CL1" ,
// "centr_ZEMvsZDC" ,
// };
// Float_t varBranch[nVars];
// for(Int_t var = 0; var < nVars; var++)
// t1->SetBranchAddress(strVarName[var],&varBranch[var]);
Float_t brV0M;
// t1->SetBranchAddress( "centr_V0M", &brV0M );
t1->SetBranchAddress( "centrV0M_NEW_MULT_SEL", &brV0M );
Float_t brZEMvsZDC;
t1->SetBranchAddress( "centr_ZEMvsZDC", &brZEMvsZDC );
// const int nCW = 1; //nCentrWidths
// const double cWidths[nCW] = { 10 }; //width of the centrality bins
// const double cStep[nCW] = { 5 }; //centrality bins step
// const int nCentrBins[nCW] = { 17 }; //n centrality bins
// const int nCW = 2; //nCentrWidths
// const double cWidths[nCW] = { 10, 5.001 }; //width of the centrality bins
// const double cStep[nCW] = { 5, 2.5 }; //centrality bins step
// const int nCentrBins[nCW] = { 17, 35 }; //n centrality bins
const int nCW = 2; //nCentrWidths
const double cWidths[nCW] = { 10, 5 }; //width of the centrality bins
const double cStep[nCW] = { 10, 5 }; //centrality bins step
const int nCentrBins[nCW] = { 9, 18 }; //n centrality bins
// const int nCW = 5; //nCentrWidths
// const double cWidths[nCW] = { 10, 5, 2.5, 1.0, 0.5 }; //width of the centrality bins
// const double cStep[nCW] = { 5, 2.5, 2.5, 1.0, 1.0 }; //centrality bins step
// const int nCentrBins[nCW] = { 17, 35, 36, 90, 90 }; //n centrality bins
const int nEtaWins = 3;
const int nPhiWins = 1;
const int maxNCentrBins = 100; //TMath::MaxElement(nCW, &nCentrBins);
WinPair wins[nCW][maxNCentrBins][nEtaWins][nPhiWins];
CentralityOccupancy cOccupancy[nCW][maxNCentrBins];
for ( int cW = 0; cW < nCW; cW++ )
for ( int cBin = 0; cBin < nCentrBins[cW]; cBin++ )
{
float cBinMin = cStep[cW] * cBin;
float cBinMax = cWidths[cW] + cStep[cW] * cBin;
cOccupancy[cW][cBin].cBinMin = cBinMin;
cOccupancy[cW][cBin].cBinMax = cBinMax;
for ( int etaW = 0; etaW < nEtaWins; etaW++ )
for ( int phiW = 0; phiW < nPhiWins; phiW++ )
wins[cW][cBin][etaW][phiW].init(cBinMin, cBinMax, etaW, phiW);
}
BranchFB br[nEtaWins][nPhiWins];
for ( int etaW = 0; etaW < nEtaWins; etaW++ )
for ( int phiW = 0; phiW < nPhiWins; phiW++ )
{
int ptW = 0;
TString brNamePostfix = Form("eta_%d_phi%d_pt_%d"
, etaW, phiW, ptW );
t1->SetBranchAddress( Form("nF_%s", brNamePostfix.Data() ), &br[etaW][phiW].nF );
t1->SetBranchAddress( Form("nB_%s", brNamePostfix.Data() ), &br[etaW][phiW].nB );
t1->SetBranchAddress( Form("PtF_%s", brNamePostfix.Data() ), &br[etaW][phiW].PtF );
t1->SetBranchAddress( Form("PtB_%s", brNamePostfix.Data() ), &br[etaW][phiW].PtB );
}
TH1D *hist1D_QA_percentilesEstimator = new TH1D( "hist1D_QA_percentilesEstimator", "hist1D_QA_percentilesEstimator;percentile;entries", 3001, -0.5, 300.5);
TH1D *hist1D_QA_multALL = new TH1D( "hist1D_QA_multALL", "hist1D_QA_multALL;mult;entries", 3001, -0.5, 3000.5);
// ##### prepare for tree loop
int nEvents = t1->GetEntries();
cout <<"nEvents = " << nEvents << endl;
// float **BS_Nf = new float*[nPhiWins];
// float **BS_Nb = new float*[nPhiWins];
// for ( int w = 0; w < nPhiWins; w++ )
// {
// BS_Nf[w] = new float[nEvents];
// BS_Nb[w] = new float[nEvents];
// }
// ##### main loop over events
int flag_V0M_ZDC = 0;//1;
int nAccepted = 0;
for (Long64_t i=0; i < nEvents; i++)
{
if ( i % 100000 == 0 )
cout << "getting " << (int)i << endl;
// cout <<"getting " << (int)i << "\r"; cout.flush();
t1->GetEntry( i );
// t1->GetEntry( TMath::Nint( gRandom->Uniform(-0.5,nEvents-0.5) ) );
float cEstimator = -1;
if ( flag_V0M_ZDC==0 )
{
if ( brV0M > 90 ) //V0M cut
continue;
cEstimator = brV0M;
}
else
{
if ( brZEMvsZDC > 50 ) //ZDCvsZEM cut
continue;
cEstimator = brZEMvsZDC;
}
hist1D_QA_percentilesEstimator->Fill(cEstimator);
//calc mult in whole TPC using wins:
int multTPC = 0;
for ( int phiW = 0; phiW < nPhiWins; phiW++ )
multTPC += (br[0][phiW].nF + br[2][phiW].nF) + (br[0][phiW].nB + br[2][phiW].nB);
hist1D_QA_multALL->Fill(multTPC);
// for ( int w = 0; w < nPhiWins; w++ )
// {
// BS_Nf[w][nAccepted] = Nf[w];
// BS_Nb[w][nAccepted] = Nb[w];
// }
for ( int cW = 0; cW < nCW; cW++ )
for ( int cBin = 0; cBin < nCentrBins[cW]; cBin++ )
{
cOccupancy[cW][cBin].fill(brV0M, brZEMvsZDC);
for ( int etaW = 0; etaW < nEtaWins; etaW++ )
for ( int phiW = 0; phiW < nPhiWins; phiW++ )
wins[cW][cBin][etaW][phiW].fill( cEstimator, br[etaW][phiW].nF, br[etaW][phiW].nB, br[etaW][phiW].PtF, br[etaW][phiW].PtB );
}
nAccepted++;
} // end of events
cout << "nAccepted = " << nAccepted << endl;
cout << "nAccepted/nAll = " << (float)nAccepted/nEvents << endl;
// ########## QA PLOTTING:
TCanvas *canv_estimatorPercentiles_QA_all = new TCanvas("canv_estimatorPercentiles_QA_all","canv_estimatorPercentiles_QA_all",0,0,700,600 );
hist1D_QA_percentilesEstimator->DrawCopy();
TCanvas *canv_hist1D_QA_multALL = new TCanvas("canv_hist1D_QA_multALL","canv_hist1D_QA_multALL",50,50,700,600 );
hist1D_QA_multALL->DrawCopy();
// MULT BINNING:
int nCentrBinsMult = 10;
cout << "nCentrBins=" << nCentrBinsMult << endl;
double *estBounds = new double[nCentrBinsMult]; // array to contain the quantiles
getQuantiles(hist1D_QA_multALL, nCentrBinsMult, estBounds);
drawCanvasWithClasses( hist1D_QA_multALL, "byMultTPC", nCentrBinsMult, estBounds );
// ##########MAIN PLOTTING FOR CORRS:
TGraphErrors *grNN [nCW][nEtaWins];
TGraphErrors *grPtPt[nCW][nEtaWins];
TGraphErrors *grPtN[nCW][nEtaWins];
TGraphErrors *grFractEstByV0M[nCW];
TGraphErrors *grFractEstByZDC[nCW];
for ( int cW = 0; cW < nCW; cW++ )
{
grFractEstByV0M[cW] = new TGraphErrors;
grFractEstByZDC[cW] = new TGraphErrors;
for ( int etaW = 0; etaW < nEtaWins; etaW++ )
{
grNN[cW][etaW] = new TGraphErrors;
grPtPt[cW][etaW] = new TGraphErrors;
grPtN[cW][etaW] = new TGraphErrors;
}
}
//calc (1) - occupancies in centr bins, (2) - corr coeffs
for ( int cW = 0; cW < nCW; cW++ )
for ( int cBin = 0; cBin < nCentrBins[cW]; cBin++ )
{
if ( cOccupancy[cW][cBin].nEventsV0M > 0 )
{
CentralityOccupancy *c = &cOccupancy[cW][cBin];
float centr = c->cBinMin + (c->cBinMax - c->cBinMin)/2;
float cRatio = 0;
if (c->nEventsV0M>0)
cRatio = (float)c->nEventsV0M_and_ZDCZEM / c->nEventsV0M;
grFractEstByV0M[cW]->SetPoint(grFractEstByV0M[cW]->GetN(), centr, cRatio);
if (c->nEventsZDCZEM>0)
cRatio = (float)c->nEventsV0M_and_ZDCZEM / c->nEventsZDCZEM;
grFractEstByZDC[cW]->SetPoint(grFractEstByZDC[cW]->GetN(), centr, cRatio);
}
for ( int etaW = 0; etaW < nEtaWins; etaW++ )
for ( int phiW = 0; phiW < nPhiWins; phiW++ )
{
WinPair *w = &wins[cW][cBin][etaW][phiW];
float centr = w->cBinMin + (w->cBinMax - w->cBinMin)/2;
w->calcCorrCoeffs();
if(0)cout << "cMin=" << w->cBinMin << ", cMax=" << w->cBinMax << ", etaW=" << etaW
<< ", NN_bCorr= " << w->NN_bCorr
<< ", PtPt_bCorr= " << w->PtPt_bCorr
<< endl;
//fill graphs
TGraphErrors *gr;
//gr NN
gr = grNN[cW][etaW];
if ( fabs(w->NN_bCorr) < 10 )
gr->SetPoint(gr->GetN(), centr, w->NN_bCorr);
//gr PtPt
gr = grPtPt[cW][etaW];
if ( fabs(w->PtPt_bCorr) < 10 )
gr->SetPoint(gr->GetN(), centr, w->PtPt_bCorr);
//gr PtN
gr = grPtN[cW][etaW];
if ( fabs(w->PtN_bCorr) < 10 )
gr->SetPoint(gr->GetN(), centr, w->PtN_bCorr);
}
}
int colors[] = { kBlack, kBlack, kBlue, kRed, kMagenta };
int markers[] = { 20, 24, 5, 2, 21 };
// NN
TCanvas *canv_grNN = new TCanvas("canv_grNN","canv_grNN",20,50,700,600 );
tuneCanvas(canv_grNN);
grNN[0][0]->SetTitle( ";centrality percentile;b_{corr}" ); //C_{2}
tuneGraphAxisLabels(grNN[0][0]);
//centr 10
drawGraph(grNN[0][0], 20, kBlack, "AP");
// drawGraph(grNN[0][1], 21, kBlack, "P");
// drawGraph(grNN[0][2], 22, kBlack, "P");
for ( int cW = 1; cW < nCW; cW++ )
drawGraph(grNN[cW][0], markers[cW], colors[cW], "P");
grNN[0][0]->SetMinimum( 0 );
TLegend *leg = new TLegend(0.65,0.65,0.999,0.95);
leg->SetFillColor(kWhite);
leg->SetFillStyle(0);
leg->SetBorderSize(0);
for ( int cW = 0; cW < nCW; cW++ )
leg->AddEntry(grNN[cW][0], Form("class width %.1f", cWidths[cW]), "p");
leg->Draw();
TLatex *tex = new TLatex(0.7,0.4, "#eta_{gap}=0.8, #delta#eta=0.4");
drawTex(tex, 0.045);
tex = new TLatex(0.4,0.89, "NN");
drawTex(tex, 0.045);
TString strPostfix;
if (flag_V0M_ZDC==0)
strPostfix = Form("V0M.eps");
else
strPostfix = Form("ZDCZEM.eps");
canv_grNN->SaveAs( Form("NN_%s", strPostfix.Data() ) );
// PtPt
TCanvas *canv_grPtPt = new TCanvas("canv_grPtPt","canv_grPtPt",250,50,700,600 );
tuneCanvas(canv_grPtPt);
grPtPt[0][0]->SetTitle( ";centrality percentile;b_{corr}" ); //C_{2}
tuneGraphAxisLabels(grPtPt[0][0]);
//centr 10
drawGraph(grPtPt[0][0], 20, kBlack, "AP");
// drawGraph(grPtPt[0][1], 21, kBlack, "P");
// drawGraph(grPtPt[0][2], 22, kBlack, "P");
for ( int cW = 1; cW < nCW; cW++ )
drawGraph(grPtPt[cW][0], markers[cW], colors[cW], "P");
grPtPt[0][0]->SetMinimum( 0 );
leg = new TLegend(0.65,0.65,0.999,0.95);
leg->SetFillColor(kWhite);
leg->SetFillStyle(0);
leg->SetBorderSize(0);
for ( int cW = 0; cW < nCW; cW++ )
leg->AddEntry(grPtPt[cW][0], Form("class width %.1f", cWidths[cW]), "p");
leg->Draw();
tex = new TLatex(0.7,0.4, "#eta_{gap}=0.8, #delta#eta=0.4");
drawTex(tex, 0.045);
tex = new TLatex(0.4,0.89, "PtPt");
drawTex(tex, 0.045);
canv_grNN->SaveAs( Form("PtPt_%s", strPostfix.Data() ) );
// PtN
TCanvas *canv_grPtN = new TCanvas("canv_grPtN","canv_grPtN",450,50,700,600 );
tuneCanvas(canv_grPtN);
grPtN[0][0]->SetTitle( ";centrality percentile;b_{corr}" ); //C_{2}
tuneGraphAxisLabels(grPtN[0][0]);
//centr 10
drawGraph(grPtN[0][0], 20, kBlack, "AP");
// drawGraph(grPtN[0][1], 21, kBlack, "P");
// drawGraph(grPtN[0][2], 22, kBlack, "P");
for ( int cW = 1; cW < nCW; cW++ )
drawGraph(grPtN[cW][0], markers[cW], colors[cW], "P");
grPtN[0][0]->SetMinimum( 0 );
leg = new TLegend(0.65,0.65,0.999,0.95);
leg->SetFillColor(kWhite);
leg->SetFillStyle(0);
leg->SetBorderSize(0);
for ( int cW = 0; cW < nCW; cW++ )
leg->AddEntry(grPtN[cW][0], Form("class width %.1f", cWidths[cW]), "p");
leg->Draw();
tex = new TLatex(0.7,0.4, "#eta_{gap}=0.8, #delta#eta=0.4");
drawTex(tex, 0.045);
tex = new TLatex(0.4,0.89, "PtN");
drawTex(tex, 0.045);
canv_grNN->SaveAs( Form("PtN_%s", strPostfix.Data() ) );
TCanvas *canv_grPtN_2D = new TCanvas("canv_grPtN_2D","canv_grPtN_2D",450,50,700,600 );
tuneCanvas(canv_grPtN_2D);
// wins[0][0][0][0].hist2D_PtN->DrawCopy();
wins[0][0][0][0].hist2D_PtN->ProfileX()->DrawCopy();
// CENTR ESTIMATOR EVENT RATIO:
TCanvas *canv_grCentrRatio = new TCanvas("canv_grCentrRatio","canv_grCentrRatio",450,250,700,600 );
tuneCanvas(canv_grCentrRatio);
grFractEstByV0M[0]->SetTitle(";centrality percentile;ratio");
tuneGraphAxisLabels(grFractEstByV0M[0]);
//centr 10
drawGraph(grFractEstByV0M[0], 20, kBlack, "AP");
// drawGraph(grFractEstByZDC[0], 20, kBlack, "L");
for ( int cW = 1; cW < nCW; cW++ )
drawGraph(grFractEstByV0M[cW], markers[cW], colors[cW], "P");
leg = new TLegend(0.65,0.65,0.999,0.95,"ratio #frac{V0M-and-ZEMZDC}{V0M}");
leg->SetFillColor(kWhite);
leg->SetFillStyle(0);
leg->SetBorderSize(0);
for ( int cW = 0; cW < nCW; cW++ )
leg->AddEntry(grFractEstByV0M[cW], Form("class width %.1f", cWidths[cW]), "p");
leg->Draw();
// leg->SetHeader("ratio #frac{V0M-and-ZEMZDC}/{V0M}");
canv_grCentrRatio->SaveAs("ratio_V0M-and-ZEMZDC_by_V0M.eps");
// CENTR ESTIMATOR PERCENTILES QA:
TCanvas *canv_estimatorPercentiles_QA = new TCanvas("canv_estimatorPercentiles_QA","canv_estimatorPercentiles_QA",50,350,700,600 );
for ( int cBin = 0; cBin < nCentrBins[0]; cBin++ )
{
TH1D *h = wins[0][cBin][0][0].hist1D_EstimatorEntries;
h->SetLineColor(kOrange-9+cBin);
if ( cBin == 0 )
h->DrawCopy();
else
h->DrawCopy("same");
}
// MULT F IN CENTR CLASSES QA:
TCanvas *canv_mult_F_in_centr_QA = new TCanvas("canv_mult_F_in_centr_QA","canv_mult_F_in_centr_QA",50,400,700,600 );
gPad->SetLogy();
for ( int cBin = 0; cBin < nCentrBins[0]; cBin++ )
{
TH1D *h = wins[0][cBin][0][0].hist1D_multDistrF;
h->SetLineColor(kOrange-9+cBin);
if ( cBin == 0 )
{
h->SetLineColor(kRed);
h->GetYaxis()->SetRangeUser(1,100000);
}
if ( cBin == 0 )
h->DrawCopy();
else
h->DrawCopy("same");
}
// Check entries in centrality bins:
for ( int cW = 0; cW < nCW; cW++ )
{
cout << " ###### cW = " << cW << endl;
for ( int cBin = 0; cBin < nCentrBins[cW]; cBin++ )
{
TH1D *h = wins[cW][cBin][0][0].hist1D_multDistrF;
cout << "cBin = " << h->GetEntries() << endl;
// h->SetLineColor(kOrange-9+cBin);
// if ( cBin == 0 )
// h->DrawCopy();
// else
// h->DrawCopy("same");
}
}
return;
}
void DrawVelocity() {
gStyle->SetOptFit(11111111);
TFile* tfCosmic = new TFile("CosmicOut_V4.root");
TTree* trCosmic = (TTree*)tfCosmic->Get("trOut");
Double_t FitP1[2];
Double_t FitP0[2];
Double_t FitChisq[2];
Int_t CosmicTrigUp;
Int_t CosmicTrigDn;
Double_t Theta;
Double_t Roh;
trCosmic->SetBranchAddress("FitP1" ,FitP1 );
trCosmic->SetBranchAddress("FitP0" ,FitP0 );
trCosmic->SetBranchAddress("FitChisq" ,FitChisq);
trCosmic->SetBranchAddress("CosmicTrigUp",&CosmicTrigUp);
trCosmic->SetBranchAddress("CosmicTrigDn",&CosmicTrigDn);
trCosmic->SetBranchAddress("Theta" ,&Theta);
trCosmic->SetBranchAddress("Roh" ,&Roh);
std::cout<< "Output" << std::endl;
//TFile* tfHist = new TFile("CosmicOut_V4_TrigHist.root","recreate");
TH1D* CosmicP1UpTrig[5];
TH1D* CosmicP1Trig[5][5];
TH1D* CosmicP1TrigLarge[5][5];
for( int i = 0; i< 5; i++){
CosmicP1UpTrig[i] = new TH1D( Form("CosmicP1UpTrig%d",i),
Form("CosmicP1UpTrig%d",i),
100,-0.01,0.01);
for( int j = 0; j< 5; j++){
CosmicP1Trig[i][j] = new TH1D( Form("CosmicP1_%d_%d",i,j),
Form("CosmicP1_%d_%d",i,j),
100,-0.01,0.01);
CosmicP1TrigLarge[i][j] = new TH1D( Form("CosmicP1Large_%d_%d",i,j),
Form("CosmicP1Large_%d_%d",i,j),
100,-0.01,0.01);
}
}
std::cout<< "LOOP" << std::endl;
for( int ievent = 0; ievent < trCosmic->GetEntries(); ievent++){
trCosmic->GetEntry(ievent);
if( TMath::Abs(Theta) < 5 ){ continue; }
if( FitChisq[1] > 10 ){ continue; }
CosmicP1UpTrig[ CosmicTrigUp ]->Fill( FitP1[1]*TMath::Cos(Theta*TMath::Pi()/180.));
CosmicP1Trig[CosmicTrigUp][CosmicTrigDn]->Fill( FitP1[1]*TMath::Cos(Theta*TMath::Pi()/180.) );
if( Roh > 600){
CosmicP1TrigLarge[CosmicTrigUp][CosmicTrigDn]->Fill( FitP1[1]*TMath::Cos(Theta*TMath::Pi()/180.) );
}
}
std::cout << "Draw" << std::endl;
TGraphErrors* grSlope = new TGraphErrors();
TGraphErrors* grDelta = new TGraphErrors();
TGraphErrors* grSlopeLarge = new TGraphErrors();
grSlope->SetMarkerStyle( 7 );
grDelta->SetMarkerStyle( 7 );
grSlopeLarge->SetMarkerStyle( 7 );
TCanvas* can = new TCanvas("can","",1200,800);
can->Divide(3,2);
for( int i = 0; i< 5; i++){
for( int j = 0; j< 5; j++){
CosmicP1Trig[i][j]->Fit("gaus","Q","",
CosmicP1Trig[i][j]->GetMean()-CosmicP1Trig[i][j]->GetRMS(),
CosmicP1Trig[i][j]->GetMean()+CosmicP1Trig[i][j]->GetRMS());
TF1* func = CosmicP1Trig[i][j]->GetFunction("gaus");
grSlope->SetPoint( grSlope->GetN(),i*5+j+1, func->GetParameter(1));
grSlope->SetPointError( grSlope->GetN()-1, 0, func->GetParameter(2));
CosmicP1TrigLarge[i][j]->Fit("gaus","Q","",
CosmicP1Trig[i][j]->GetMean()-1.5*CosmicP1Trig[i][j]->GetRMS(),
CosmicP1Trig[i][j]->GetMean()+1.5*CosmicP1Trig[i][j]->GetRMS());
func = CosmicP1TrigLarge[i][j]->GetFunction("gaus");
grSlopeLarge->SetPoint( grSlopeLarge->GetN(), i*5+j+1, func->GetParameter(1));
grSlopeLarge->SetPointError( grSlopeLarge->GetN()-1,0,func->GetParameter(2));
}
}
for( int i = 0; i< 5; i++){
can->cd( i +1 );
CosmicP1UpTrig[i]->Draw();
for( int j = 0; j < 5; j++){
CosmicP1Trig[i][j]->SetLineColor(j+1);
CosmicP1Trig[i][j]->Draw("same");
CosmicP1TrigLarge[i][j]->Draw("same");
}
}
double sol = 299.97;//[mm/ns]
TLine* solLine = new TLine( -1, -1./sol, 25, -1./sol);
//can->cd( 6 );
TCanvas* can1 = new TCanvas("can1","",800,400);
can1->Divide( 2,1);
can1->cd(1);
grSlope->GetXaxis()->SetRangeUser( -1, 25);
grSlope->Draw("AP");
solLine->SetLineStyle(2);
solLine->Draw("same");
TCanvas* can2 = new TCanvas("can2","",1200,800);
can2->Divide(3,2);
for( int i = 0; i< 5; i++){
can2->cd( i+1 );
CosmicP1TrigLarge[i][0]->Draw();
for( int j = 0; j< 5; j++){
CosmicP1TrigLarge[i][j]->Draw("same");
}
}
can2->cd(6);
grSlopeLarge->Draw("AP");
Double_t H_trig = 2800;
Double_t R = 1200;
TGraph* grDelta1 = new TGraph();
TGraph* grDelta2 = new TGraph();
TGraphErrors * grVCluster = new TGraphErrors();
for( int i = 0; i< 5; i++){
for( int j =0; j< 5; j++){
Double_t iv_0 = TMath::Abs(grSlope->GetY()[ i*5 +j ]);
Double_t ive_0 = grSlope->GetEY()[ i*5 + j];
Double_t deltaZ = (i-j)*100*R/H_trig;//mm
Double_t EdeltaZ = TMath::Sqrt(2)*50*R/H_trig;
Double_t l = TMath::Sqrt( R*R + deltaZ*deltaZ);
Double_t El = deltaZ*EdeltaZ/TMath::Sqrt( R*R + deltaZ*deltaZ);
Double_t delta_t0 = l/sol;
Double_t delta_t1 = iv_0*R - delta_t0;
Double_t Edelta_t1 = QuadSum(ive_0*R, El/sol);
Double_t V_CsI = deltaZ / delta_t1;
Double_t EV_CsI = QuadSum( EdeltaZ / delta_t1, Edelta_t1/delta_t1);
Double_t delta_t1_adj = deltaZ/70.;
Double_t delta_t1_adj1 = deltaZ/80.;
Double_t delta_t1_adj2 = deltaZ/90.;
grDelta->SetPoint(grDelta->GetN(), (delta_t0+delta_t1_adj)/R , iv_0);
grDelta1->SetPoint(grDelta1->GetN(), (delta_t0+delta_t1_adj1)/R , iv_0);
grDelta2->SetPoint(grDelta2->GetN(), (delta_t0+delta_t1_adj2)/R , iv_0);
if( TMath::Abs(deltaZ) <= 2*EdeltaZ ){ continue; }
grVCluster->SetPoint( grVCluster->GetN(), i*5+j+1 , V_CsI);
grVCluster->SetPointError( grVCluster->GetN()-1 , 0, EV_CsI);
}
}
can1->cd(2);
grVCluster->SetMarkerStyle( 6);
grVCluster->Draw("AP");
grVCluster->Fit("pol0","","",0,26);
/*
grDelta1->SetMarkerColor(2);
grDelta2->SetMarkerColor(3);
grDelta1->SetMarkerStyle(6);
grDelta2->SetMarkerStyle(6);
can1->cd(2);
grDelta->Draw("AP");
grDelta1->Draw("P");
grDelta2->Draw("P");
TF1* func = new TF1("func","x",0,0.1);
func->Draw("same");
*/
/*
for( int i = 0; i< 5; i++){
CosmicP1UpTrig[i]->Write();
for( int j =0 ;j < 5; j++){
CosmicP1Trig[i][j]->Write();
}
}
tfHist->Close();
*/
}
int postprocessingSysError(){
cout<<endl<<endl<<endl<<"%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% Postproccess all systematic uncertainties! %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%"<<endl<<endl;
gErrorIgnoreLevel = 1001;
const TString method = "RMS99";
const TString type = "PFCHS";
const int nEta =4;
double eta_bins[5] = {0., 0.5, 1.1, 1.7, 2.3};
// For looking at different systematic uncertainties independently
const bool QCD = true;
const bool JEC = true;
const bool flavor = true;
const bool PU = true;
const bool MC = true;
TString etaString, filename;
TString rootFiles, AuxString;
TString JetType = "PFCHS";
TString Method = "RMS99";
double *ratioEtaBinnedX = new double[nEta];
double *ratioEtaBinnedY = new double[nEta];
double *ratioEtaBinnedEX = new double[nEta];
double *ratioEtaBinnedEY = new double[nEta];
double *ratioEtaBinnedQCDUpY = new double[nEta];
double *ratioEtaBinnedQCDDownY = new double[nEta];
TF1 *QCDuncertainty;
if(QCD){
rootFiles = (TString) "scripts/plotsQCD/FinalErrorsQCD_" + type + (TString) "_" + method + (TString) ".root";
TFile *_file = TFile::Open(rootFiles);
_file->GetObject("function",QCDuncertainty);
}
for(int eta = 0; eta < nEta; eta++){
//cout<< endl<<endl<<endl<<eta+1<<". eta Bin!!"<<endl;
// Read the MC and data results
rootFiles = (TString) "root_files_FINAL_data/Resolution_for_" + (long) (eta+1) + (TString) "_eta_bin_" + JetType + (TString) "_data_" + Method + (TString) ".root";
TGraphErrors* JERData = readTGraphErrors(rootFiles,"Graph;1","Graph");
rootFiles = (TString) "root_files_FINAL_mc/Resolution_for_" + (long) (eta+1) + (TString) "_eta_bin_" + JetType + (TString) "_mc_" + Method + (TString) ".root";
TGraphErrors* JERMC = readTGraphErrors(rootFiles,"Graph","Graph");
if(eta+1 == 1) etaString = Form("JER for |#eta| < %4.1f",etaBins[eta+1]);
else etaString = Form("JER for %4.1f <|#eta|< %4.1f",etaBins[eta+1],etaBins[eta+2]);
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// 1.) Calculate the ratio w/o systematic Uncertainties
int nData = JERData->GetN();
double *dataX = JERData->GetX();
double *dataY = JERData->GetY();
double *dataEX = JERData->GetEX();
double *dataEY = JERData->GetEY();
double *mcX = new double[nData];
double *mcY = new double[nData];
double *mcEX = new double[nData];
double *mcEY = new double[nData];
double *ratioX = new double[nData];
double *ratioY = new double[nData];
double *ratioEX = new double[nData];
double *ratioEY = new double[nData];
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// Initialize some stuff for QCD uncertainty
double *ratioQCDUpY = new double[nData];
double *ratioQCDDownY = new double[nData];
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
int idx = 0;
for(int i=0; i<nData; i++){
JERMC -> GetPoint(idx,mcX[i],mcY[i]);
mcEX[i] = JERMC -> GetErrorX(idx);
mcEY[i] = JERMC -> GetErrorY(idx);
idx += 1;
if(TMath::Abs(dataX[i]/mcX[i] - 1.) > 0.1){
i -= 1;
continue;
}
ratioX[i] = 1./2.*(dataX[i] + mcX[i]);
ratioY[i] = dataY[i]/mcY[i];
ratioEX[i] = 1./2.*TMath::Sqrt(TMath::Power(dataEX[i],2)+TMath::Power(mcEX[i],2));
ratioEY[i] = TMath::Sqrt(TMath::Power((1./mcY[i]),2)*TMath::Power(dataEY[i],2)+TMath::Power((dataY[i]/(TMath::Power(mcY[i],2))),2)*TMath::Power(mcEY[i],2));
if(QCD){
// For QCD
ratioQCDUpY[i] = ratioY[i]*(1. + QCDuncertainty->Eval(ratioX[i]));
ratioQCDDownY[i] = ratioY[i]*(1. - QCDuncertainty->Eval(ratioX[i]));
//cout<<"QCDuncertainty->Eval(ratioX[i]) = "<<QCDuncertainty->Eval(ratioX[i])<<endl;
}
}
TGraphErrors *Ratio = new TGraphErrors(nData,ratioX,ratioY,ratioEX,ratioEY);
// For QCD
TGraphErrors *QCDUp = new TGraphErrors(nData,ratioX,ratioQCDUpY,ratioEX,ratioEY);
TGraphErrors *QCDDown = new TGraphErrors(nData,ratioX,ratioQCDDownY,ratioEX,ratioEY);
if(eta+1 == 1 ) AuxString = Form("Ratio between Data and MC for |#eta| < %4.1f",etaBins[eta+1]);
else AuxString = Form("Ratio between Data and MC for %4.1f <|#eta|<%4.1f",etaBins[eta+1],etaBins[eta+2]);
Ratio -> SetTitle(AuxString);
Ratio -> GetXaxis() -> SetTitle("Photon pT");
Ratio -> GetXaxis() -> SetTitleOffset(1.1);
Ratio -> GetYaxis() -> SetTitle("Ratio of JER (DATA/MC)");
Ratio -> GetYaxis() -> SetTitleOffset(1.2);
Ratio -> GetXaxis() -> SetLimits(0,600);
TF1* f1 = new TF1("name","pol0",0,600);
Ratio -> Fit("name","QR");
TF1* fitQCDUp = new TF1("fitQCDUp","pol0",0,600);
TF1* fitQCDDown = new TF1("fitQCDDown","pol0",0,600);
if(QCD){
// For QCD
QCDUp -> Fit("fitQCDUp","QR");
QCDDown -> Fit("fitQCDDown","QR");
}
TLegend *legend = 0;
legend = new TLegend(0.55,0.8,0.9,0.9);
legend -> SetFillColor(0);
legend -> SetHeader(Form(" %4.3f #pm %4.3f", f1 -> GetParameter(0), f1->GetParError(0)));
TCanvas *c11 = new TCanvas("c11",AuxString,200,10,500,500);
c11 -> cd();
Ratio -> SetMinimum(0.5);
Ratio -> SetMaximum(2.0);
Ratio -> Draw("AP");
legend -> Draw("same");
TLatex* info = new TLatex();
info-> SetNDC();
info->SetTextSize(0.045);
info->DrawLatex(0.22,0.84,Form("#splitline{#chi^{2} = %4.2f}{dof = %i}",f1 -> GetChisquare(),f1 -> GetNDF()));
filename = (TString) "plots/Ratio_Resolution_for_" + (long) (eta+1) + (TString) "_eta_bin_" + type + (TString) "_data_comparison_" + method + (TString) ".pdf";
c11 -> SaveAs(filename);
delete c11;
ratioEtaBinnedX[eta] = (eta_bins[eta+1] + eta_bins[eta])/2.;
ratioEtaBinnedY[eta] = f1 -> GetParameter(0);
ratioEtaBinnedEX[0]=0.25;
ratioEtaBinnedEX[1]=0.3;
ratioEtaBinnedEX[2]=0.3;
ratioEtaBinnedEX[3]=0.3;
ratioEtaBinnedEY[eta] = f1->GetParError(0);
if(QCD){
ratioEtaBinnedQCDUpY[eta] = fitQCDUp -> GetParameter(0);
ratioEtaBinnedQCDDownY[eta]= fitQCDDown -> GetParameter(0);
// Some additional stuff for QCD uncertainty
TCanvas *plotsQCD = new TCanvas("plotsQCD","plotsQCD",200,10,500,500);
plotsQCD -> cd();
Ratio -> SetMarkerColor(1);
Ratio -> SetLineColor(1);
Ratio -> SetMarkerStyle(20);
Ratio -> GetFunction("name")->SetLineColor(1);
QCDUp -> SetMarkerColor(3);
QCDDown -> SetMarkerColor(3);
QCDUp -> SetLineColor(3);
QCDDown -> SetLineColor(3);
QCDUp -> SetMarkerStyle(20);
QCDDown -> SetMarkerStyle(20);
QCDUp -> SetMarkerSize(0.8);
QCDDown -> SetMarkerSize(0.8);
QCDUp -> GetFunction("fitQCDUp")->SetLineColor(3);
QCDDown -> GetFunction("fitQCDDown")->SetLineColor(3);
Ratio -> Draw("AP");
QCDUp -> Draw("sameP");
QCDDown -> Draw("sameP");
delete legend;
legend = new TLegend(0.4,0.8,0.9,0.9);
legend -> SetFillColor(0);
legend -> SetTextSize(0.045);
legend -> AddEntry(Ratio,"Central Value","l");
legend -> AddEntry(QCDUp,Form("Upward variation: + %4.3f",abs(ratioEtaBinnedQCDUpY[eta]/ratioEtaBinnedY[eta]-1.)),"l");
legend -> AddEntry(QCDDown,Form("Downward variation: - %4.3f",abs(ratioEtaBinnedQCDDownY[eta]/ratioEtaBinnedY[eta]-1.)),"l");
legend -> Draw("same");
filename = (TString) "plots/plotsQCD_for_" + (long) (eta+1) + (TString) "_bin_" + type + (TString) "_" + method + (TString) ".pdf";
plotsQCD -> SaveAs(filename);
delete plotsQCD;
}
}
TGraphErrors* ratioEtaBinned = new TGraphErrors(nEta,ratioEtaBinnedX,ratioEtaBinnedY,ratioEtaBinnedEX,ratioEtaBinnedEY);
filename = (TString) "plots/RatioEtaBinned_" + type + (TString) "_" + method + (TString) ".root";
TFile *f = new TFile(filename,"RECREATE");
f -> WriteTObject(ratioEtaBinned,"Graph");
f->Close();
delete f;
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// 1.) Calculate sys Error from QCD contamination
//cout<<endl;
double deltaRatioUpQCD[nEta] = {0.};
double deltaRatioDownQCD[nEta] = {0.};
if(QCD){
for(int eta = 0; eta<nEta; eta++){
deltaRatioUpQCD[eta] = abs(ratioEtaBinnedQCDUpY[eta]/ratioEtaBinnedY[eta]-1.);
deltaRatioDownQCD[eta] = abs(ratioEtaBinnedQCDDownY[eta]/ratioEtaBinnedY[eta]-1.);
//cout<<"ratioEtaBinnedQCDDownY[eta]"<<ratioEtaBinnedQCDDownY[eta]<<endl;
//cout<<"ratioEtaBinnedY[eta]"<<ratioEtaBinnedY[eta]<<endl;
//cout<<"deltaRatioUpQCD["<<eta<<"] = "<<deltaRatioUpQCD[eta]<<endl;
//cout<<"deltaRatioDownQCD["<<eta<<"] = "<<deltaRatioDownQCD[eta]<<endl;
}
}
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// 2.) Calculate sys Error from JEC uncertainty (percentage change of MC result)
//cout<<endl;
double deltaRatioUpJEC[nEta] = {0.};
double deltaRatioDownJEC[nEta] = {0.};
if(JEC){
rootFiles = (TString) "scripts/plotsJEC/FinalEtaBinnedErrorsJECUp_" + type + (TString) "_" + method + (TString) ".root";
TGraphErrors *JECuncertaintyUp = readTGraphErrors(rootFiles,"graph","Graph");
double *sysRelJECUp = JECuncertaintyUp -> GetY();
rootFiles = (TString) "scripts/plotsJEC/FinalEtaBinnedErrorsJECLow_" + type + (TString) "_" + method + (TString) ".root";
TGraphErrors *JECuncertaintyLow = readTGraphErrors(rootFiles,"graph","Graph");
double *sysRelJECLow = JECuncertaintyLow -> GetY();
for(int eta = 0; eta<nEta; eta++){
deltaRatioUpJEC[eta] = sysRelJECUp[eta];
deltaRatioDownJEC[eta] = sysRelJECLow[eta];
//cout<<"deltaRatioUpJEC["<<eta<<"] = "<<deltaRatioUpJEC[eta]<<endl;
//cout<<"deltaRatioDownJEC["<<eta<<"] = "<<deltaRatioDownJEC[eta]<<endl;
}
}
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// 3.) Calculate sys Error from Flavor uncertainty (percentage change of MC result)
//cout<<endl;
// Multiply on mc (as symmetric Error)
// ratioUp = 1/(1 - delta) * ratio
// ratioLow = 1/(1 + delta) * ratio
double deltaRatioUpFlavor[nEta] = {0.};
double deltaRatioDownFlavor[nEta] = {0.};
if(flavor){
rootFiles = (TString) "scripts/plotsFlavor/FinalEtaBinnedErrorsFlavorUp_" + type + (TString) "_" + method + (TString) ".root";
TGraphErrors *FlavoruncertaintyUp = readTGraphErrors(rootFiles,"graph","Graph");
double *sysRelFlavorUp = FlavoruncertaintyUp -> GetY();
rootFiles = (TString) "scripts/plotsFlavor/FinalEtaBinnedErrorsFlavorLow_" + type + (TString) "_" + method + (TString) ".root";
TGraphErrors *FlavoruncertaintyLow = readTGraphErrors(rootFiles,"graph","Graph");
double *sysRelFlavorLow = FlavoruncertaintyLow -> GetY();
for(int eta = 0; eta<nEta; eta++){
deltaRatioUpFlavor[eta] = sysRelFlavorUp[eta];
deltaRatioDownFlavor[eta] = sysRelFlavorLow[eta];
//cout<<"deltaRatioUpFlavor["<<eta<<"] = "<<deltaRatioUpFlavor[eta]<<endl;
//cout<<"deltaRatioDownFlavor["<<eta<<"] = "<<deltaRatioDownFlavor[eta]<<endl;
}
}
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// 4.) Calculate sys Error from PU uncertainty (percentage change of MC result)
//cout<<endl;
double deltaRatioUpPU[nEta] = {0.};
double deltaRatioDownPU[nEta] = {0.};
if(PU){
rootFiles = (TString) "scripts/plotsPU/FinalEtaBinnedErrorsPUUp_" + type + (TString) "_" + method + (TString) ".root";
TGraphErrors *PUuncertaintyUp = readTGraphErrors(rootFiles,"graph","Graph");
double *sysRelPUUp = PUuncertaintyUp -> GetY();
rootFiles = (TString) "scripts/plotsPU/FinalEtaBinnedErrorsPULow_" + type + (TString) "_" + method + (TString) ".root";
TGraphErrors *PUuncertaintyLow = readTGraphErrors(rootFiles,"graph","Graph");
double *sysRelPULow = PUuncertaintyLow -> GetY();
// Multiply on mc (as symmetric Error)
// ratioUp = 1/(1 - delta) * ratio
// ratioUp = 1/(1 + delta) * ratio
for(int eta = 0; eta<nEta; eta++){
deltaRatioUpPU[eta] = sysRelPUUp[eta];
deltaRatioDownPU[eta] = sysRelPULow[eta];
//cout<<"deltaRatioUpPU["<<eta<<"] = "<<deltaRatioUpPU[eta]<<endl;
//cout<<"deltaRatioDownPU["<<eta<<"] = "<<deltaRatioDownPU[eta]<<endl;
}
}
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// 5.) Calculate sys Error from Out-of Cone showering simulation (percentage change of full ratio result)
//cout<<endl;
double deltaRatioUpMC[nEta] = {0.};
double deltaRatioDownMC[nEta] = {0.};
if(MC){
rootFiles = (TString) "scripts/plotsMC/FinalErrorsMC_" + type + (TString) "_" + method + (TString) ".root";
TGraphErrors *MCuncertainty = readTGraphErrors(rootFiles,"graph","Graph");
double *sysRelMC = MCuncertainty -> GetY();
// Percentage change is only in one direction, to take this into account keep deltaRatioDownMC = 0
for(int eta = 0; eta<nEta; eta++){
deltaRatioUpMC[eta] = sysRelMC[eta];
deltaRatioDownMC[eta] = sysRelMC[eta];
//cout<<"deltaRatioUpMC["<<eta<<"] = "<<deltaRatioUpMC[eta]<<endl;
//cout<<"deltaRatioDownMC["<<eta<<"] = "<<deltaRatioDownMC[eta]<<endl;
}
}
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// Take all systematic Uncertainties together and plot
//cout<<endl;
double *deltaTotalSysUp = new double[nEta];
double *deltaTotalSysDown = new double[nEta];
double *DeltaTotalSysUp = new double[nEta];
double *DeltaTotalSysDown = new double[nEta];
double *DeltaTotalDown = new double[nEta];
double *DeltaTotalUp = new double[nEta];
for(int eta = 0; eta<nEta; eta++){
// Add all systematic Uncertainties in quadrature (delta is relative Uncertainty)
deltaTotalSysUp[eta] = sqrt(TMath::Power(deltaRatioUpJEC[eta],2) + TMath::Power(deltaRatioUpFlavor[eta],2) + TMath::Power(deltaRatioUpPU[eta],2) + TMath::Power(deltaRatioUpMC[eta],2) + TMath::Power(deltaRatioUpQCD[eta],2));
deltaTotalSysDown[eta] = sqrt(TMath::Power(deltaRatioDownJEC[eta],2) + TMath::Power(deltaRatioDownFlavor[eta],2) + TMath::Power(deltaRatioDownPU[eta],2) + TMath::Power(deltaRatioDownMC[eta],2) + TMath::Power(deltaRatioDownQCD[eta],2));
// Calculation of the absolute Uncertainty with Delta = ratio * delta
DeltaTotalSysUp[eta] = deltaTotalSysUp[eta] * ratioEtaBinnedY[eta];
DeltaTotalSysDown[eta] = deltaTotalSysDown[eta] * ratioEtaBinnedY[eta];
// Calculate Systematic plus staistical Uncertainty
DeltaTotalUp[eta] = sqrt(pow(DeltaTotalSysUp[eta],2) + pow(ratioEtaBinnedEY[eta],2));
DeltaTotalDown[eta] = sqrt(pow(DeltaTotalSysDown[eta],2) + pow(ratioEtaBinnedEY[eta],2));
cout<<endl<<"relative: deltaTotalSysUp["<<eta<<"] = "<<fixed<<setprecision(3)<<deltaTotalSysUp[eta]<<endl;
cout<<"relative: deltaTotalSysDown["<<eta<<"] = "<<deltaTotalSysDown[eta]<<endl;
cout<<endl<<"absolute: DeltaTotalSysUp["<<eta<<"] = "<<DeltaTotalSysUp[eta]<<endl;
cout<<"absolute: DeltaTotalSysDown["<<eta<<"] = "<<DeltaTotalSysDown[eta]<<endl;
}
double ex[nEta] ={0.25,0.3,0.3,0.3};
TGraphAsymmErrors* ratioEtaBinnedSys = new TGraphAsymmErrors(nEta,ratioEtaBinnedX,ratioEtaBinnedY,ex,ex,DeltaTotalSysDown,DeltaTotalSysUp);
double *TotalSysUp = new double[nEta];
double *TotalSysDown = new double[nEta];
for(int i=0; i<nEta; i++){
TotalSysUp[i] = ratioEtaBinnedY[i]+DeltaTotalSysUp[i];
TotalSysDown[i] = ratioEtaBinnedY[i]-DeltaTotalSysDown[i];
}
TGraph* ratioSysBorderUp = new TGraph(nEta, ratioEtaBinnedX, TotalSysUp);
TGraph* ratioSysBorderDown = new TGraph(nEta, ratioEtaBinnedX, TotalSysDown);
TGraph* ratioRelativeErrorsUp = new TGraph(nEta,ratioEtaBinnedX,deltaTotalSysUp);
TGraph* ratioRelativeErrorsDown = new TGraph(nEta,ratioEtaBinnedX,deltaTotalSysDown);
TGraphErrors* ratioEtaBinnedStat = new TGraphErrors(nEta,ratioEtaBinnedX,ratioEtaBinnedY,ratioEtaBinnedEX,ratioEtaBinnedEY);
TGraphAsymmErrors* ratioEtaBinnedStatPlusSys = new TGraphAsymmErrors(nEta,ratioEtaBinnedX,ratioEtaBinnedY,ex,ex,DeltaTotalDown,DeltaTotalUp);
TCanvas *cFinal = new TCanvas("cFinal","cFinal",200,10,500,500);
cFinal -> cd();
ratioEtaBinnedSys -> GetYaxis() -> SetTitle("Data/MC ratio for JER");
ratioEtaBinnedSys -> GetXaxis() -> SetTitle("|#eta|");
if(PU && flavor && JEC && MC && QCD) etaString = "All sys. Uncertainties";
else if(PU && !flavor && !JEC && !MC && !QCD) etaString = "Only PU uncert.";
else if(!PU && flavor && !JEC && !MC && !QCD) etaString = "Only flavor uncert.";
else if(!PU && !flavor && JEC && !MC && !QCD) etaString = "Only JEC uncert.";
else if(!PU && !flavor && !JEC && MC && !QCD) etaString = "Only Out-of-Cone sim. uncert.";
else if(!PU && !flavor && !JEC && MC && !QCD) etaString = "Only Out-of-Cone sim. uncert.";
else if(!PU && !flavor && !JEC && !MC && QCD) etaString = "Only QCD uncert.";
else if(PU && flavor && JEC && !MC && QCD) etaString = "All besides MC uncertainty.";
else etaString = "Strange set of systematic uncertainties.";
cout<<endl<<etaString<<endl<<endl;
ratioEtaBinnedSys -> SetMarkerStyle(20);
ratioEtaBinnedSys -> SetMarkerSize(1.4);
ratioEtaBinnedSys -> SetFillColor(kGray);
ratioEtaBinnedSys -> SetFillStyle(3001);
ratioEtaBinnedSys -> SetLineColor(kGray);
ratioEtaBinnedSys -> SetMinimum(0.8);
ratioEtaBinnedSys -> SetMaximum(1.5);
ratioEtaBinnedSys -> GetXaxis() -> SetLimits(0., 2.3);
ratioEtaBinnedSys -> GetXaxis() -> SetNdivisions(6,6,0, "X");
ratioEtaBinnedSys -> DrawClone("Ae3p");
//ratioEtaBinnedSys -> SetPointError(0, 0., 0., 0., 0.);
//ratioEtaBinnedSys -> SetPointError(1, 0., 0., 0., 0.);
//ratioEtaBinnedSys -> SetPointError(2, 0., 0., 0., 0.);
//ratioEtaBinnedSys -> SetPointError(3, 0., 0., 0., 0.);
//ratioEtaBinnedSys -> SetPointError(4, 0., 0., 0., 0.);
ratioEtaBinnedStat -> SetMarkerStyle(20);
ratioEtaBinnedStat -> SetMarkerSize(1.4);
ratioEtaBinnedStat -> SetFillColor(kGray);
ratioEtaBinnedStat -> SetFillStyle(3001);
ratioEtaBinnedStat -> SetLineColor(1);
ratioEtaBinnedStat -> Draw("psame");
TLatex *infoFinal = new TLatex();
infoFinal -> SetTextFont(132);
infoFinal -> SetNDC();
infoFinal -> SetTextSize(0.045);
infoFinal -> DrawLatex(0.2,0.8,etaString);
filename = (TString) "plots/FinalErrorPlot_" + type + (TString) "_" + method + (TString) ".pdf";
cFinal -> Print(filename,"pdf");
filename = (TString) "plots/FinalErrorPlot_" + type + (TString) "_" + method + (TString) ".pdf";
cFinal -> SaveAs(filename,"pdf");
delete cFinal;
filename = (TString) "plots/FinalRelativeErrorsUp_" + type + (TString) "_" + method + (TString) ".root";
f = new TFile(filename,"RECREATE");
f -> WriteTObject(ratioRelativeErrorsUp,"graph");
f->Close();
delete f;
filename = (TString) "plots/FinalRelativeErrorsLow_" + type + (TString) "_" + method + (TString) ".root";
f = new TFile(filename,"RECREATE");
f -> WriteTObject(ratioRelativeErrorsDown,"graph");
f->Close();
delete f;
ofstream RelativeErrors;
RelativeErrors.open("plots/Errors.txt");
RelativeErrors<<"Relative Errors: "<<endl;
for(int i=0; i<nEta; i++){
RelativeErrors<<i+1<<". Eta bin: "<<"-"<<fixed<<setprecision(3)<<(deltaTotalSysDown[i]*100)<<"% / +"<<(deltaTotalSysUp[i]*100)<<"%"<<endl;
}
RelativeErrors<<endl<<"Absolute Errors: "<<endl;
for(int i=0; i<nEta; i++){
RelativeErrors<<i+1<<". Eta bin: "<<"-"<<(DeltaTotalSysDown[i])<<" / +"<<(DeltaTotalSysUp[i])<<endl;
}
RelativeErrors<<endl<<endl<<"Relative Errors JEC: "<<endl;
for(int i=0; i<nEta; i++){
RelativeErrors<<i+1<<". Eta bin: "<<"-"<<(deltaRatioDownJEC[i]*100)<<"% / +"<<(deltaRatioUpJEC[i]*100)<<"%"<<endl;
}
RelativeErrors<<endl<<endl<<"Relative Errors Flavor: "<<endl;
for(int i=0; i<nEta; i++){
RelativeErrors<<i+1<<". Eta bin: "<<"-"<<(deltaRatioDownFlavor[i]*100)<<"% / +"<<(deltaRatioUpFlavor[i]*100)<<"%"<<endl;
}
RelativeErrors<<endl<<endl<<"Relative Errors Out-of-Cone showering simulation: "<<endl;
for(int i=0; i<nEta; i++){
RelativeErrors<<i+1<<". Eta bin: "<<"-"<<(deltaRatioDownMC[i]*100)<<"% / +"<<(deltaRatioUpMC[i]*100)<<"%"<<endl;
}
RelativeErrors<<endl<<endl<<"Relative Errors QCD: "<<endl;
for(int i=0; i<nEta; i++){
RelativeErrors<<i+1<<". Eta bin: "<<"-"<<(deltaRatioDownQCD[i]*100)<<"% / +"<<(deltaRatioUpQCD[i]*100)<<"%"<<endl;
}
RelativeErrors<<endl<<endl<<"Relative Errors PU reweighing: "<<endl;
for(int i=0; i<nEta; i++){
RelativeErrors<<i+1<<". Eta bin: "<<"-"<<(deltaRatioDownPU[i]*100)<<"% / +"<<(deltaRatioUpPU[i]*100)<<"%"<<endl;
}
RelativeErrors<<endl<<endl<<"Central values and statistical Uncertainty: "<<endl;
for(int i=0; i<nEta; i++){
RelativeErrors<<i+1<<". Eta bin: "<<"-"<<(ratioEtaBinnedY[i])<<" +/- "<<ratioEtaBinnedEY[i]<<endl;
}
RelativeErrors.close();
// Write directly full latex table with systematic and statistical unceratinty
ofstream latexTable;
latexTable.open("plots/latexTable.txt");
latexTable<<"\\renewcommand{\\arraystretch}{2.0}"<<endl;
latexTable<<"\\begin{center}"<<endl;
latexTable<<"\\begin{tabular}{ | c | c c c| }"<<endl;
latexTable<<"$|\\eta^{\\text{Jet}}|$ & Ratio & stat. & sys. \\\\\\hline"<<endl;
for(int z=0;z<nEta;z++){
latexTable<<"$"<<fixed<<setprecision(1)<<etaBins[z]<<" - "<<etaBins[z+1]<<"$ &"<<fixed<<setprecision(3)<<ratioEtaBinnedY[z]<<" & $\\pm "<<ratioEtaBinnedEY[z]<<"$ & $^{+"<<DeltaTotalSysUp[z]<<"}_{-"<<DeltaTotalSysDown[z]<<"}$ \\\\"<<endl;
}
latexTable<<"\\hline"<<endl;
latexTable<<"\\end{tabular}"<<endl;
latexTable<<"\\end{center}"<<endl<<endl<<endl<<endl<<endl;
latexTable<<"\\begin{center}"<<endl;
latexTable<<"\\begin{tabular}{ l| c | c | c | c |}"<<endl;
latexTable<<"\\multicolumn{1}{c}{} & \\multicolumn{4}{c}{$|\\eta^{\\text{Jet}}|$}\\\\\\hline"<<endl<<fixed<<setprecision(1);
for(int z=0;z<nEta;z++) latexTable<<"& \\textbf{"<<etaBins[z]<<" - "<<etaBins[z+1]<<"}";
latexTable<<"\\\\\\hline"<<endl;
latexTable<<"\\multirow{2}{*}{\\textbf{Multijet contamination}}";
for(int z=0;z<nEta;z++) latexTable<<"& $+"<<deltaRatioUpQCD[z]*100<<" \\% $ ";
latexTable<<"\\\\"<<endl;
for(int z=0;z<nEta;z++) latexTable<<"& $-"<<deltaRatioDownQCD[z]*100<<" \\% $ ";
latexTable<<"\\\\\\hline"<<endl;
latexTable<<"\\multirow{2}{*}{\\textbf{Flavor uncertainty}}";
for(int z=0;z<nEta;z++) latexTable<<"& $+"<<deltaRatioUpFlavor[z]*100<<" \\% $ ";
latexTable<<"\\\\"<<endl;
for(int z=0;z<nEta;z++) latexTable<<"& $"<<deltaRatioDownFlavor[z]*100<<" \\% $ ";
latexTable<<"\\\\\\hline"<<endl;
latexTable<<"\\multirow{2}{*}{\\textbf{JEC uncertainty}}";
for(int z=0;z<nEta;z++) latexTable<<"& $+"<<deltaRatioUpJEC[z]*100<<" \\% $ ";
latexTable<<"\\\\"<<endl;
for(int z=0;z<nEta;z++) latexTable<<"& $"<<deltaRatioDownJEC[z]*100<<" \\% $ ";
latexTable<<"\\\\\\hline"<<endl;
latexTable<<"\\multirow{2}{*}{\\textbf{Out-of-Cone showering simulation}}";
for(int z=0;z<nEta;z++) latexTable<<"& $+"<<deltaRatioUpMC[z]*100<<" \\% $ ";
latexTable<<"\\\\"<<endl;
for(int z=0;z<nEta;z++) latexTable<<"& $-"<<deltaRatioDownMC[z]*100<<" \\% $ ";
latexTable<<"\\\\\\hline"<<endl;
latexTable<<"\\multirow{2}{*}{\\textbf{PU uncertainty}}";
for(int z=0;z<nEta;z++) latexTable<<"& $+"<<deltaRatioUpPU[z]*100<<" \\% $ ";
latexTable<<"\\\\"<<endl;
for(int z=0;z<nEta;z++) latexTable<<"& $"<<deltaRatioDownPU[z]*100<<" \\% $ ";
latexTable<<"\\\\\\hline\\hline"<<endl;
latexTable<<"\\multirow{2}{*}{\\textbf{Total}}";
for(int z=0;z<nEta;z++) latexTable<<"& $+"<<deltaTotalSysUp[z]*100<<" \\% $ ";
latexTable<<"\\\\"<<endl;
for(int z=0;z<nEta;z++) latexTable<<"& $-"<<deltaTotalSysDown[z]*100<<" \\% $ ";
latexTable<<"\\\\\\hline"<<endl;
latexTable<<"\\end{tabular}"<<endl;
latexTable<<"\\end{center}"<<endl;
latexTable.close();
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// Comparison to 2011 Data
cout<<endl;
gROOT->LoadMacro("tdrstyle_mod14.C");
setTDRStyle();
gROOT->LoadMacro("CMS_lumi.C");
writeExtraText = true; // if extra text
extraText = "Preliminary"; // default extra text is "Preliminary"
lumi_8TeV = "19.7 fb^{-1}"; // default is "19.7 fb^{-1}"
lumi_7TeV = "4.9 fb^{-1}"; // default is "5.1 fb^{-1}"
int iPeriod = 2; // 1=7TeV, 2=8TeV, 3=7+8TeV, 7=7+8+13TeV
gStyle->SetHatchesLineWidth(1);
gStyle->SetHatchesSpacing(2.2);
//-----------------------------------------------------
TCanvas *cFinal2 = new TCanvas("cFinal2","cFinal2",200,10,1000,1000);
cFinal2 -> cd();
double x_2011[4];
x_2011[0]=0.25;
x_2011[1]=0.80;
x_2011[2]=1.40;
x_2011[3]=2.00;
double y_2011[4];
y_2011[0]=1.052;
y_2011[1]=1.057;
y_2011[2]=1.096;
y_2011[3]=1.134;
double yErrStat_2011[4];
yErrStat_2011[0]=0.012;
yErrStat_2011[1]=0.012;
yErrStat_2011[2]=0.017;
yErrStat_2011[3]=0.035;
double yErrSysHigh_2011[4];
yErrSysHigh_2011[0]=0.062;
yErrSysHigh_2011[1]=0.056;
yErrSysHigh_2011[2]=0.063;
yErrSysHigh_2011[3]=0.087;
double yErrSysLow_2011[4];
yErrSysLow_2011[0]=0.061;
yErrSysLow_2011[1]=0.055;
yErrSysLow_2011[2]=0.062;
yErrSysLow_2011[3]=0.085;
double xErrLow_2011[4];
xErrLow_2011[0]=0.25;
xErrLow_2011[1]=0.3;
xErrLow_2011[2]=0.3;
xErrLow_2011[3]=0.3;
double xErrHigh_2011[4];
xErrHigh_2011[0]=0.25;
xErrHigh_2011[1]=0.3;
xErrHigh_2011[2]=0.3;
xErrHigh_2011[3]=0.3;
double yErrTotalHigh_2011[4];
double yErrTotalLow_2011[4];
for(int i=0; i<4; i++){
yErrTotalHigh_2011[i]=sqrt(pow(yErrStat_2011[i],2) + pow(yErrSysHigh_2011[i],2));
yErrTotalLow_2011[i]=sqrt(pow(yErrStat_2011[i],2) + pow(yErrSysLow_2011[i],2));
}
TGraphAsymmErrors *Res_2011_stat = new TGraphAsymmErrors(4,x_2011,y_2011,xErrLow_2011,xErrHigh_2011,yErrStat_2011,yErrStat_2011);
Res_2011_stat->SetName("Res_2011_stat");
TGraphAsymmErrors *Res_2011_sys = new TGraphAsymmErrors(4,x_2011,y_2011,xErrLow_2011,xErrHigh_2011,yErrSysLow_2011,yErrSysHigh_2011);
Res_2011_sys->SetName("Res_2011_sys");
TGraphAsymmErrors *Res_2011_total = new TGraphAsymmErrors(4,x_2011,y_2011,xErrLow_2011,xErrHigh_2011,yErrTotalLow_2011,yErrTotalHigh_2011);
Res_2011_sys->SetName("Res_2011_total");
//-----------------------------------------------------
ratioEtaBinnedStatPlusSys -> GetXaxis() -> SetTitle("|#eta|");
ratioEtaBinnedStatPlusSys -> GetXaxis() -> SetRangeUser(0., 2.3);
ratioEtaBinnedStatPlusSys -> GetYaxis() -> SetTitle("Data/MC ratio for JER");
ratioEtaBinnedSys -> GetXaxis() -> SetTitle("|#eta|");
ratioEtaBinnedSys -> GetXaxis() -> SetRangeUser(0., 2.3);
ratioEtaBinnedSys -> GetYaxis() -> SetTitle("Data/MC ratio for JER");
ratioEtaBinnedStat -> GetXaxis() -> SetTitle("|#eta|");
ratioEtaBinnedStat -> GetXaxis() -> SetRangeUser(0., 2.3);
ratioEtaBinnedStat -> GetYaxis() -> SetTitle("Data/MC ratio for JER");
ratioEtaBinnedStat -> GetYaxis() -> SetRangeUser(0.8, 1.6);
Res_2011_stat -> GetXaxis() -> SetTitle("|#eta|");
Res_2011_stat -> GetXaxis() -> SetLimits(0., 2.3);
Res_2011_stat -> GetXaxis() -> SetNdivisions(505, "X");
Res_2011_stat -> GetYaxis() -> SetTitle("Data/MC ratio for JER");
Res_2011_sys -> GetXaxis() -> SetTitle("|#eta|");
Res_2011_sys -> GetXaxis() -> SetLimits(0., 2.3);
Res_2011_sys -> GetXaxis() -> SetNdivisions(505, "X");
Res_2011_sys -> GetYaxis() -> SetTitle("Data/MC ratio for JER");
Res_2011_total -> GetXaxis() -> SetTitle("|#eta|");
Res_2011_total -> GetXaxis() -> SetLimits(0., 2.3);
Res_2011_total -> GetXaxis() -> SetNdivisions(505, "X");
Res_2011_total -> GetYaxis() -> SetTitle("Data/MC ratio for JER");
Res_2011_total -> GetYaxis() -> SetRangeUser(0.8, 1.5);
ratioEtaBinnedStatPlusSys -> SetMarkerStyle(20);
ratioEtaBinnedStatPlusSys -> SetMarkerSize(2.0);
ratioEtaBinnedStatPlusSys -> SetLineColor(kPink-8);
ratioEtaBinnedStatPlusSys -> SetLineWidth(2);
ratioEtaBinnedStatPlusSys -> SetMarkerColor(kPink-8);
ratioEtaBinnedStatPlusSys -> SetFillColor(kPink-8);
ratioEtaBinnedStatPlusSys -> SetName("statPlusSys_2012");
ratioEtaBinnedStat -> SetMarkerStyle(20);
ratioEtaBinnedStat -> SetMarkerSize(2.0);
ratioEtaBinnedStat -> SetLineColor(kPink-8);
ratioEtaBinnedStat -> SetLineWidth(2);
ratioEtaBinnedStat -> SetMarkerColor(kPink-8);
ratioEtaBinnedStat -> SetFillColor(kPink-8);
ratioEtaBinnedStat -> SetName("Stat_2012");
ratioEtaBinnedStatPlusSys -> SetFillStyle(3244);
ratioEtaBinnedStat -> SetFillStyle(3144);
Res_2011_stat->SetMarkerStyle(24);
Res_2011_stat->SetMarkerSize(2.0);
Res_2011_stat->SetLineColor(kGray+2);
Res_2011_stat->SetLineWidth(2);
Res_2011_stat->SetLineWidth(2);
Res_2011_stat->SetFillStyle(1001);
Res_2011_total->SetMarkerStyle(24);
Res_2011_total->SetMarkerSize(2.0);
Res_2011_total->SetLineColor(1);
Res_2011_total->SetLineWidth(2);
Res_2011_total->SetFillColor(kGray);
Res_2011_total->SetFillStyle(1001);
Res_2011_total->SetLineColor(kGray+2);
Res_2011_total->Draw("a2");
Res_2011_stat->Draw("esame");
ratioEtaBinnedStatPlusSys -> Draw("2same");
Res_2011_stat->Draw("pXsame");
Res_2011_stat->SetMarkerSize(1.9);
Res_2011_stat->Draw("pXsame");
Res_2011_stat->SetMarkerSize(1.7);
Res_2011_stat->Draw("pXsame");
ratioEtaBinnedStatPlusSys -> Draw("pXsame");
ratioEtaBinnedStat -> Draw("esame");
TLegend *leg = new TLegend(0.18, 0.60, 0.55, 0.75);
leg->SetBorderSize(0);
leg->SetFillColor(0);
leg->SetFillStyle(0);
leg->SetTextFont(42);
leg->SetTextSize(0.045);
leg->AddEntry(Res_2011_total,"5/fb (7 TeV)", "pfl");
leg->AddEntry(ratioEtaBinnedStatPlusSys,"20/fb (8 TeV)", "pfl");
leg->Draw("same");
TLatex *info = new TLatex();
info->SetNDC();
info->DrawLatex(0.67,0.83,"Anti-k_{T} R=0.5");
info->DrawLatex(0.67,0.77,"PF+CHS");
CMS_lumi( cFinal2, iPeriod, 11 );
cFinal2->Print("plots/resultsComparisonFINAL.pdf","pdf");
cFinal2->SaveAs("plots/resultsComparisonFINAL.C");
return 0;
}
void profileDistributions(TString dist)
{
gStyle->SetOptStat(0);
gStyle->SetOptTitle(0);
gStyle->SetPalette(1);
TFile *inF=TFile::Open("~/work/top_539/plotter.root");
TFile *inSystF=TFile::Open("~/work/top_539/plotter_syst.root");
bool isPhi(dist.Contains("phi"));
TString profs[]={dist,
dist+"toward",
dist+"transverse",
dist+"away"};
const size_t nprofs= isPhi ? 1 : sizeof(profs)/sizeof(TString);
Int_t colors[]={1,kBlue,kRed,kGreen-3};
TString cats[]={"inclusive","away","transverse","toward"};
/*
TFile *inNomF=inF;
TString nomTTbar="t#bar{t}";
TString nomTTbarTitle="MG+PY";
//TString systList[]={"t#bar{t}systmcatnlo"};
//TString systLabels[]={"MC@NLO+HW"};
//TString systList[]={"t#bar{t}systq2down","t#bar{t}systq2up"};
//TString systLabels[]={"-Q^{2}","+Q^{2}"};
//TString systList[]={"t#bar{t}systmepsdown","t#bar{t}systmepsup"};
// TString systLabels[]={"-ME-PS","+ME-PS"};
*/
TFile *inNomF=inSystF;
TString nomTTbar="t#bar{t}systtunep11";
TString nomTTbarTitle="P11";
TString systList[]={"t#bar{t}systtunep11nocr","t#bar{t}systtunep11tev"};
TString systLabels[]={"P11-noCR","P11TeV"};
Int_t systColors[]={1,kAzure,kRed-6,kGreen+3};
const size_t nSysts=sizeof(systList)/sizeof(TString);
TString ch[]={"emu"};
const size_t nch=sizeof(ch)/sizeof(TString);
for(size_t ich=0; ich<nch; ich++)
{
TCanvas *c=new TCanvas("c"+ch[ich]+dist,"c"+ch[ich]+dist,800,800); c->SetTopMargin(0); c->SetBottomMargin(0);
c->Divide(1,nprofs);
TCanvas *cratios=new TCanvas("cratios"+ch[ich]+dist,"cratios"+ch[ich]+dist,800,800); cratios->SetTopMargin(0); cratios->SetBottomMargin(0);
cratios->Divide(1,nprofs);
TCanvas *cproj=new TCanvas("cproj"+ch[ich]+dist,"cproj"+ch[ich]+dist,600,600);
TLegend *dataprojLeg=new TLegend(0.5,0.9,0.6,0.7,"Data","brNDC");
TLegend *mcprojLeg=new TLegend(0.7,0.9,0.92,0.7,"MC","brNDC");
for(size_t i=0; i<nprofs; i++)
{
TH2 *bckgMC = (TH2 *) inF->Get("Z#rightarrow ll/"+ch[ich]+"_"+profs[i]);
bckgMC->Add( (TH2 *) inF->Get("VV/"+ch[ich]+"_"+profs[i]) );
bckgMC->Add( (TH2 *) inF->Get("Single top/"+ch[ich]+"_"+profs[i]) );
bckgMC->Add( (TH2 *) inF->Get("W+jets-multijets/"+ch[ich]+"_"+profs[i]) );
//build the total MC with signal alternatives
TH2 *MC = (TH2 *) inNomF->Get(nomTTbar+"/"+ch[ich]+"_"+profs[i]) ;
Double_t totalTTbar(MC->Integral());
MC->Add(bckgMC);
MC->SetDirectory(0);
MC->Sumw2();
std::vector<TH2 *> systMC;
for(size_t isyst=0; isyst<nSysts; isyst++)
{
TH2F *h=(TH2F *)inSystF->Get(systList[isyst]+"/"+ch[ich]+"_"+profs[i]) ;
h->Scale(totalTTbar/h->Integral());
h->Add(bckgMC);
h->Sumw2();
h->SetDirectory(0);
systMC.push_back(h);
}
//get the data
TH2 *Data = (TH2 *) inF->Get("data/"+ch[ich]+"_"+profs[i]);
Data->SetDirectory(0);
Data->Sumw2();
TGraphErrors *MCProf = new TGraphErrors(MC->ProfileX()); MCProf->SetMarkerStyle(24); MCProf->SetFillStyle(0); MCProf->SetName(ch[ich]+profs[i]+"mc");
TGraphErrors *DataProf = new TGraphErrors(Data->ProfileX()); DataProf->SetMarkerStyle(20); DataProf->SetFillStyle(0); DataProf->SetName(ch[ich]+profs[i]+"data");
//build data/MC scale factors
std::vector<TGraphErrors *> data2mcProfs;
for(size_t isyst=0; isyst<=systMC.size(); isyst++)
{
TGraphErrors *prof= (isyst==0 ? MCProf : new TGraphErrors(systMC[isyst-1]->ProfileX()));
TString baseName(ch[ich]+profs[i]);
if(isyst) baseName += systList[isyst];
prof = (TGraphErrors *) prof->Clone(baseName+"data2mc");
for(int ip=0; ip<DataProf->GetN(); ip++)
{
Double_t x,y,ydata,y_err,ydata_err;
prof->GetPoint(ip,x,y); y_err=prof->GetErrorY(ip);
DataProf->GetPoint(ip,x,ydata); ydata_err=DataProf->GetErrorY(ip);
if(y<=0) continue;
prof->SetPoint(ip,x,ydata/y);
prof->SetPointError(ip,0,sqrt(pow(ydata*y_err,2)+pow(ydata_err*y,2))/pow(y,2));
}
prof->SetFillColor(systColors[isyst]);
prof->SetFillStyle(3001+isyst%2);
prof->SetTitle( isyst==0 ? nomTTbarTitle : systLabels[isyst-1] );
//prof->SetMarkerStyle(24); prof->SetFillStyle(3001); prof->SetMarkerColor(1+isyst); prof->SetMarkerColor(1+isyst); prof->SetLineColor(1+isyst);
data2mcProfs.push_back(prof);
}
TH1D *MCProjY=MC->ProjectionY();
MCProjY->Scale(1./MCProjY->Integral());
TGraphErrors *MCProj = new TGraphErrors(MCProjY); MCProj->SetMarkerStyle(24); MCProj->SetFillStyle(0); MCProj->SetName(ch[ich]+profs[i]+"projmc");
TH1D *DataProjY=Data->ProjectionY();
DataProjY->Scale(1./DataProjY->Integral());
TGraphErrors *DataProj = new TGraphErrors(DataProjY); DataProj->SetMarkerStyle(20); DataProj->SetFillStyle(0); DataProj->SetName(ch[ich]+profs[i]+"projdata");
MCProj->SetLineColor(colors[i]); MCProj->SetMarkerColor(colors[i]); MCProj->SetFillColor(colors[i]); MCProj->SetFillStyle(1001);
DataProj->SetLineColor(colors[i]); DataProj->SetMarkerColor(colors[i]); DataProj->SetFillColor(colors[i]);
TPad *p=(TPad *)cproj->cd();
p->SetLeftMargin(0.15);
p->SetRightMargin(0.02);
p->SetTopMargin(0.05);
p->SetLogy();
MCProj->SetFillStyle(0);
MCProj->Draw(i==0 ? "al3" : "l3");
MCProj->GetYaxis()->SetRangeUser(1e-5,1.0);
MCProj->GetXaxis()->SetTitle( MC->GetYaxis()->GetTitle() );
MCProj->GetYaxis()->SetTitle( "1/N dN/dx" );
MCProj->GetYaxis()->SetTitleOffset(1.8);
DataProj->Draw("p");
std::pair<float,int> chi2=computeChiSquareFor(DataProj,MCProj);
char buf[200];
sprintf(buf,"#scale[0.7]{#chi^{2}/ndof=%3.1f}", chi2.first/chi2.second );
dataprojLeg->AddEntry(DataProj,buf,"p");
mcprojLeg->AddEntry(MCProj,cats[i],"l");
if(i==0) drawCMSHeader(ch[ich]);
p=(TPad *)c->cd(i+1);
if(i<nprofs-1) p->SetBottomMargin(0.01);
if(i>0) p->SetTopMargin(0);
if(i==0)p->SetTopMargin(0.1);
if(i==nprofs-1) p->SetBottomMargin(0.15);
TGraphErrors *frame=DataProf;
frame->Draw("ap");
//frame->GetYaxis()->SetRangeUser(0.54,1.46);
frame->GetXaxis()->SetTitle(MC->GetXaxis()->GetTitle());
//frame->GetXaxis()->SetRangeUser(0,4.75);
TString yTit("<"); yTit+=MC->GetYaxis()->GetTitle(); yTit +=">";
frame->GetYaxis()->SetTitle(yTit);
frame->GetYaxis()->SetLabelSize(0.07);
frame->GetYaxis()->SetTitleSize(0.09);
frame->GetYaxis()->SetTitleOffset(0.5);
frame->GetXaxis()->SetLabelSize(0.07);
frame->GetXaxis()->SetTitleSize(0.09);
frame->GetXaxis()->SetTitleOffset(0.7);
//p->SetGridy();
//DataProf->Draw("p");
MCProf->Draw("p");
if(i==0)
{
drawCMSHeader(ch[ich],0.08);
TLegend *leg=new TLegend(0.6,0.95,1.0,0.99);
leg->SetBorderSize(0);
leg->SetFillStyle(0);
leg->SetTextFont(42);
leg->SetTextSize(0.09);
leg->AddEntry(DataProf,"data","p");
leg->AddEntry(MCProf,"simulation","p");
leg->SetNColumns(2);
leg->Draw();
}
TPaveText *pt=new TPaveText(0.15,0.5,0.8,0.85,"brNDC");
pt->SetBorderSize(0);
pt->SetFillStyle(0);
pt->SetTextAlign(13);
pt->SetTextFont(42);
pt->SetTextColor(kBlue);
pt->SetTextSize(0.08);
pt->AddText("[ "+cats[i]+" ]");
if(i==0)
{
pt->AddText("p_{T}>0.5 GeV");
pt->AddText("|#eta|<2.1");
}
pt->Draw();
p=(TPad *) cratios->cd(i+1);
if(i<nprofs-1) p->SetBottomMargin(0.01);
if(i>0) p->SetTopMargin(0);
if(i==0)p->SetTopMargin(0.1);
if(i==nprofs-1) p->SetBottomMargin(0.15);
frame=data2mcProfs[0];
frame->Draw("a3");
TLine *l=new TLine(frame->GetXaxis()->GetXmin(),1,frame->GetXaxis()->GetXmax(),1);
l->Draw();
frame->GetYaxis()->SetRangeUser(0.54,1.46);
frame->GetXaxis()->SetTitle(MC->GetXaxis()->GetTitle());
frame->GetYaxis()->SetTitle("Data/Simulation");
frame->GetYaxis()->SetLabelSize(0.07);
frame->GetYaxis()->SetTitleSize(0.09);
frame->GetYaxis()->SetTitleOffset(0.5);
frame->GetXaxis()->SetLabelSize(0.07);
frame->GetXaxis()->SetTitleSize(0.09);
frame->GetXaxis()->SetTitleOffset(0.7);
//p->SetGridy();
for(size_t ip=1; ip<data2mcProfs.size(); ip++) data2mcProfs[ip]->Draw("3");
if(i==0)
{
drawCMSHeader(ch[ich],0.08);
TLegend *leg=new TLegend(0.6,0.94,1.0,0.98);
leg->SetBorderSize(0);
leg->SetFillStyle(0);
leg->SetTextFont(42);
leg->SetTextSize(0.09);
leg->SetNColumns(data2mcProfs.size());
for(size_t ip=0; ip<data2mcProfs.size(); ip++)
leg->AddEntry(data2mcProfs[ip],data2mcProfs[ip]->GetTitle(),"f");
leg->Draw();
}
pt=new TPaveText(0.12,0.65,0.8,0.9,"brNDC");
pt->SetBorderSize(0);
pt->SetFillStyle(0);
pt->SetTextAlign(13);
pt->SetTextFont(42);
pt->SetTextColor(kBlue);
pt->SetTextSize(0.08);
pt->AddText("[ "+cats[i]+" ]");
if(i==0)
{
pt->AddText("p_{T}>0.5 GeV");
pt->AddText("|#eta|<2.1");
}
pt->Draw();
}
cproj->cd();
dataprojLeg->SetFillStyle(0);
dataprojLeg->SetBorderSize(0);
dataprojLeg->SetTextFont(42);
dataprojLeg->SetTextSize(0.03);
dataprojLeg->Draw();
mcprojLeg->SetFillStyle(0);
mcprojLeg->SetBorderSize(0);
mcprojLeg->SetTextFont(42);
mcprojLeg->SetTextSize(0.03);
mcprojLeg->Draw();
TString pf(".png");
c->SaveAs(outDir+c->GetName()+pf);
cproj->SaveAs(outDir+cproj->GetName()+pf);
cratios->SaveAs(outDir+cratios->GetName()+pf);
}
inF->Close();
inSystF->Close();
}
int main (int argc, char **argv) {
/// Input File MCTruth IC Map , RECO IC map, MC IC set after calibration (Usually set with miscalibration 5%)
/// and StatPrecision IC coefficient obtained from DrawCalibrationPlotsEE.C
if(argc != 2){
std::cerr << ">>>>> analysis.cpp::usage: " << argv[0] << " configFileName" << std::endl ;
return 1;
}
parseConfigFile (argv[1]) ;
std::string inputFile = gConfigParser -> readStringOption("Input::inputFile");
std::string inputMomentumScale = gConfigParser -> readStringOption("Input::inputMomentumScale");
std::string fileMCTruth = gConfigParser -> readStringOption("Input::fileMCTruth");
std::string fileMCRecoIC = gConfigParser -> readStringOption("Input::fileMCRecoIC");
std::string fileStatPrecision = gConfigParser -> readStringOption("Input::fileStatPrecision");
std::string outputFile = gConfigParser -> readStringOption("Output::outputFile");
TApplication* theApp = new TApplication("Application",&argc, argv);
TFile *f1 = TFile::Open(fileMCTruth.c_str());
TFile *f2 = TFile::Open(fileMCRecoIC.c_str());
/// L3 result MC endcap
TFile *f3 = TFile::Open(inputFile.c_str());
/// File form momentum scale correction
TFile* input = new TFile(inputMomentumScale.c_str());
/// Statistical Precision map
TFile *f4 = TFile::Open(fileStatPrecision.c_str());
if(f1==0 || f2==0 || f3==0 || f4==0) return -1;
// Set style options
gROOT->Reset();
gROOT->SetStyle("Plain");
gStyle->SetPadTickX(1);
gStyle->SetPadTickY(1);
gStyle->SetOptTitle(0);
gStyle->SetOptStat(1110);
gStyle->SetOptFit(0);
gStyle->SetFitFormat("6.3g");
gStyle->SetPalette(1);
gStyle->SetTextFont(42);
gStyle->SetTextSize(0.05);
gStyle->SetTitleFont(42,"xyz");
gStyle->SetTitleSize(0.05);
gStyle->SetLabelFont(42,"xyz");
gStyle->SetLabelSize(0.05);
gROOT->ForceStyle();
/// input coeff map for EEP and EEM
TH2F *hcmapMcT_EEP = (TH2F*)f1->Get("h_scale_EEP");
TH2F *hcmapMcT_EEM = (TH2F*)f1->Get("h_scale_EEM");
TH2F *hcmapMcR_EEP = (TH2F*)f2->Get("h_scale_EEP");
TH2F *hcmapMcR_EEM = (TH2F*)f2->Get("h_scale_EEM");
TH2F * hcmap_EEP = (TH2F*)hcmapMcT_EEP->Clone("hcmap_EEP");
TH2F * hcmap_EEM = (TH2F*)hcmapMcT_EEM->Clone("hcmap_EEM");
hcmap_EEP->Reset();
hcmap_EEM->Reset();
for (int jbin = 1; jbin < hcmap_EEP-> GetNbinsY(); jbin++){
for (int ibin = 1; ibin < hcmap_EEM-> GetNbinsX()+1; ibin++){
if(hcmapMcT_EEP->GetBinContent(ibin,jbin)!=0 && hcmapMcR_EEP->GetBinContent(ibin,jbin)!=0)
hcmap_EEP->SetBinContent(ibin,jbin,hcmapMcT_EEP->GetBinContent(ibin,jbin)/hcmapMcR_EEP->GetBinContent(ibin,jbin));
if(hcmapMcT_EEM->GetBinContent(ibin,jbin)!=0 && hcmapMcR_EEM->GetBinContent(ibin,jbin)!=0)
hcmap_EEM->SetBinContent(ibin,jbin,hcmapMcT_EEM->GetBinContent(ibin,jbin)/hcmapMcR_EEM->GetBinContent(ibin,jbin));
}
}
/// Scalib and L3 map Normalized for EE+ and EE-
TH2F * miscalib_map_EEP = (TH2F*) f3 -> Get("h_scalib_EEP");
TH2F * miscalib_map_EEM = (TH2F*) f3 -> Get("h_scalib_EEM");
TH2F *hcL3_EEP = (TH2F*)f3->Get("h_scale_map_EEP");
TH2F *hcL3_EEM = (TH2F*)f3->Get("h_scale_map_EEM");
TH2F *hcmap2_EEP = (TH2F*)hcL3_EEP ->Clone("hcmap2_EEP");
TH2F *hcmap2_EEM = (TH2F*)hcL3_EEM ->Clone("hcmap2_EEM");
hcmap2_EEP->Reset();
hcmap2_EEM->Reset();
/// Momentum scale correction
TGraphErrors* g_EoP_EE = (TGraphErrors*) input->Get("g_EoP_EE_0");
TGraphErrors* PhiProjectionEEp = new TGraphErrors();
TGraphErrors* PhiProjectionEEm = new TGraphErrors();
PhiProjectionEEp->SetMarkerStyle(20);
PhiProjectionEEp->SetMarkerSize(1);
PhiProjectionEEp->SetMarkerColor(kRed);
PhiProjectionEEm->SetMarkerStyle(20);
PhiProjectionEEm->SetMarkerSize(1);
PhiProjectionEEm->SetMarkerColor(kBlue);
TEndcapRings *eRings = new TEndcapRings();
std::vector<double> vectSum;
std::vector<double> vectCounter;
vectCounter.assign(g_EoP_EE->GetN(),0.);
vectSum.assign(g_EoP_EE->GetN(),0.);
/// EE+ and EE- projection
for(int ix=1; ix<hcL3_EEM->GetNbinsX()+1;ix++){
for(int iy=1; iy<hcL3_EEM->GetNbinsY()+1;iy++){
if(hcL3_EEM->GetBinContent(ix,iy)==0) continue;
int iPhi = int(eRings->GetEndcapIphi(ix,iy,-1)/(360./g_EoP_EE->GetN()));
vectSum.at(iPhi)=vectSum.at(iPhi)+hcL3_EEM->GetBinContent(ix,iy);
vectCounter.at(iPhi)=vectCounter.at(iPhi)+1;
}
}
for(unsigned int i=0; i<vectCounter.size();i++)
PhiProjectionEEm->SetPoint(i,int(i*(360./g_EoP_EE->GetN())),vectSum.at(i)/vectCounter.at(i));
for(unsigned int i=0; i<vectSum.size(); i++){
vectSum.at(i)=0; vectCounter.at(i)=0;
}
for(int ix=1; ix<hcL3_EEP->GetNbinsX()+1;ix++){
for(int iy=1; iy<hcL3_EEP->GetNbinsY()+1;iy++){
if(hcL3_EEP->GetBinContent(ix,iy)==0) continue;
int iPhi = int(eRings->GetEndcapIphi(ix,iy,1)/(360./g_EoP_EE->GetN()));
vectSum.at(iPhi)=vectSum.at(iPhi)+hcL3_EEP->GetBinContent(ix,iy);
vectCounter.at(iPhi)=vectCounter.at(iPhi)+1;
}
}
for(unsigned int i=0; i<vectCounter.size();i++)
PhiProjectionEEp->SetPoint(i,int(i*(360./g_EoP_EE->GetN())),vectSum.at(i)/vectCounter.at(i));
for(unsigned int i=0; i<vectSum.size(); i++){
vectSum.at(i)=0; vectCounter.at(i)=0;
}
/// Correction EE+ and EE-
TH2F* mapMomentumCorrected[2];
mapMomentumCorrected[0] = (TH2F*) hcL3_EEM->Clone("mapMomentumCorrected_EEM");
mapMomentumCorrected[1] = (TH2F*) hcL3_EEP->Clone("mapMomentumCorrected_EEP");
mapMomentumCorrected[0]->Reset();
mapMomentumCorrected[1]->Reset();
for(int ix=1; ix<hcL3_EEM->GetNbinsX()+1;ix++){
for(int iy=1; iy<hcL3_EEM->GetNbinsY()+1;iy++){
if(hcL3_EEM->GetBinContent(ix,iy)==0) continue;
int iPhi = int(eRings->GetEndcapIphi(ix,iy,-1));
double xphi,yphi;
g_EoP_EE->GetPoint(int(iPhi/(360./PhiProjectionEEm->GetN())),xphi,yphi);
mapMomentumCorrected[0]->SetBinContent(ix,iy,hcL3_EEM->GetBinContent(ix,iy)*yphi);
}
}
for(int ix=1; ix<hcL3_EEP->GetNbinsX()+1;ix++){
for(int iy=1; iy<hcL3_EEP->GetNbinsY()+1;iy++){
if(hcL3_EEP->GetBinContent(ix,iy)==0) continue;
int iPhi = int(eRings->GetEndcapIphi(ix,iy,1));
double xphi,yphi;
g_EoP_EE->GetPoint(int(iPhi/(360./PhiProjectionEEp->GetN())),xphi,yphi);
mapMomentumCorrected[1]->SetBinContent(ix,iy,hcL3_EEP->GetBinContent(ix,iy)*yphi);
}
}
/// Use momentum map corrected
for (int jbin = 1; jbin < mapMomentumCorrected[1]-> GetNbinsY()+1; jbin++){
for (int ibin = 1; ibin < mapMomentumCorrected[1]-> GetNbinsX()+1; ibin++){
if(miscalib_map_EEP->GetBinContent(ibin,jbin)!=0 && mapMomentumCorrected[1]->GetBinContent(ibin,jbin)!=0)
hcmap2_EEP->SetBinContent(ibin,jbin,miscalib_map_EEP->GetBinContent(ibin,jbin)*mapMomentumCorrected[1]->GetBinContent(ibin,jbin));
if(miscalib_map_EEM->GetBinContent(ibin,jbin)!=0 && mapMomentumCorrected[0]->GetBinContent(ibin,jbin)!=0)
hcmap2_EEM->SetBinContent(ibin,jbin,miscalib_map_EEM->GetBinContent(ibin,jbin)*mapMomentumCorrected[0]->GetBinContent(ibin,jbin));
}
}
/// output histos
TH2F * h2_EEP = new TH2F("h2_EEP","h2_EEP",400,0.5,1.5,400,0.5,1.5);
TH2F * h2_EEM = new TH2F("h2_EEM","h2_EEM",400,0.5,1.5,400,0.5,1.5);
TH2F * h2diff_EEP = (TH2F*)hcmap_EEP->Clone("h2diff_EEP");
TH2F * h2diff_EEM = (TH2F*)hcmap_EEM->Clone("h2diff_EEM");
h2diff_EEP->Reset();
h2diff_EEM->Reset();
char hname[100];
TH1F *hspread_EEP[40];
TH1F *hspread_EEM[40];
TH1F *hspread_All[40];
/// ring geometry for the endcap
TH2F *hrings_EEP;
TH2F *hrings_EEM;
hrings_EEP = (TH2F*)hcmap2_EEP->Clone("hringsEEP");
hrings_EEM = (TH2F*)hcmap2_EEM->Clone("hringsEEM");
hrings_EEP ->Reset();
hrings_EEM ->Reset();
FILE *fRing;
fRing = fopen("macros/eerings.dat","r");
int x,y,z,ir;
while(fscanf(fRing,"(%d,%d,%d) %d \n",&x,&y,&z,&ir) !=EOF ) {
if(z>0) hrings_EEP->Fill(x,y,ir);
if(z<0) hrings_EEM->Fill(x,y,ir);
}
/// spread IC histos
for (int jbin = 0; jbin < 40; jbin++){
sprintf(hname,"hspread_ring_EEP_%02d",jbin);
hspread_EEP[jbin]= new TH1F(hname, hname, 75,0.5,1.5);
sprintf(hname,"hspread_ring_EEM_%02d",jbin);
hspread_EEM[jbin]= new TH1F(hname, hname, 75,0.5,1.5);
sprintf(hname,"hspread_ring_All_%02d",jbin);
hspread_All[jbin]= new TH1F(hname, hname, 75,0.5,1.5);
}
for (int jbin = 1; jbin < hcmap_EEP-> GetNbinsY()+1; jbin++){
for (int ibin = 1; ibin < hcmap_EEP-> GetNbinsX()+1; ibin++){
int mybin_EEP = hcmap_EEP -> FindBin(ibin,jbin);
int ring_EEP = int(hrings_EEP-> GetBinContent(mybin_EEP));
float c1_EEP = hcmap_EEP->GetBinContent(mybin_EEP);
float c2_EEP = hcmap2_EEP->GetBinContent(mybin_EEP);
int mybin_EEM = hcmap_EEM -> FindBin(ibin,jbin);
int ring_EEM = int(hrings_EEM-> GetBinContent(mybin_EEM));
float c1_EEM = hcmap_EEM->GetBinContent(mybin_EEM);
float c2_EEM = hcmap2_EEM->GetBinContent(mybin_EEM);
if (c1_EEP!=0 && c2_EEP!=0 ){
///Ratio betweem IC and not the difference
hspread_EEP[ring_EEP]->Fill(c1_EEP/c2_EEP);
hspread_All[ring_EEP]->Fill(c1_EEP/c2_EEP);
h2_EEP->Fill(c1_EEP,c2_EEP);
h2diff_EEP->SetBinContent(ibin,jbin,c1_EEP/c2_EEP);
}
else h2diff_EEP->SetBinContent(ibin,jbin,0);
if (c1_EEM!=0 && c2_EEM!=0 ){
hspread_EEM[ring_EEM]->Fill(c1_EEM/c2_EEM);
hspread_All[ring_EEM]->Fill(c1_EEM/c2_EEM);
h2_EEM->Fill(c1_EEM,c2_EEM);
h2diff_EEM->SetBinContent(ibin,jbin,c1_EEM/c2_EEM);
}
else h2diff_EEM->SetBinContent(ibin,jbin,0);
}
}
/// TGraphErrors for final plot
TGraphErrors *sigma_vs_iring_EEP = new TGraphErrors();
sigma_vs_iring_EEP->SetMarkerStyle(20);
sigma_vs_iring_EEP->SetMarkerSize(1);
sigma_vs_iring_EEP->SetMarkerColor(kBlue+2);
TGraphErrors *sigma_vs_iring_EEM = new TGraphErrors();
sigma_vs_iring_EEM->SetMarkerStyle(20);
sigma_vs_iring_EEM->SetMarkerSize(1);
sigma_vs_iring_EEM->SetMarkerColor(kBlue+2);
TGraphErrors *sigma_vs_iring_All = new TGraphErrors();
sigma_vs_iring_All->SetMarkerStyle(20);
sigma_vs_iring_All->SetMarkerSize(1);
sigma_vs_iring_All->SetMarkerColor(kBlue+2);
TGraphErrors *scale_vs_iring_EEP = new TGraphErrors();
scale_vs_iring_EEP->SetMarkerStyle(20);
scale_vs_iring_EEP->SetMarkerSize(1);
scale_vs_iring_EEP->SetMarkerColor(kBlue+2);
TGraphErrors *scale_vs_iring_EEM = new TGraphErrors();
scale_vs_iring_EEM->SetMarkerStyle(20);
scale_vs_iring_EEM->SetMarkerSize(1);
scale_vs_iring_EEM->SetMarkerColor(kBlue+2);
TGraphErrors *scale_vs_iring_All = new TGraphErrors();
scale_vs_iring_All->SetMarkerStyle(20);
scale_vs_iring_All->SetMarkerSize(1);
scale_vs_iring_All->SetMarkerColor(kBlue+2);
/// Gauss function for fit
TF1 *fgaus_EEP = new TF1("fgaus_EEP","gaus",0.,2.);
TF1 *fgaus_EEM = new TF1("fgaus_EEM","gaus",0.,2.);
TF1 *fgaus_All = new TF1("fgaus_All","gaus",0.,2.);
int np_EEP = 0;
int np_EEM = 0;
int np_All = 0;
for (int i = 0; i < 40; i++){
if ( hspread_EEP[i]->GetEntries() == 0) {sigma_vs_iring_EEP-> SetPoint(np_EEP,i,-100);np_EEP++;continue;}
if ( hspread_EEM[i]->GetEntries() == 0) {sigma_vs_iring_EEM-> SetPoint(np_EEM,i,-100);np_EEM++;continue;}
if ( hspread_All[i]->GetEntries() == 0) {sigma_vs_iring_All-> SetPoint(np_All,i,-100);np_All++;continue;}
hspread_EEP[i]->Fit("fgaus_EEP","QRME");
hspread_EEM[i]->Fit("fgaus_EEM","QRME");
hspread_All[i]->Fit("fgaus_All","QRME");
TString Name = Form("c_%d",i);
sigma_vs_iring_EEP-> SetPoint(np_EEP,i,fgaus_EEP->GetParameter(2));
sigma_vs_iring_EEP-> SetPointError(np_EEP,0,fgaus_EEP->GetParError(2));
scale_vs_iring_EEP-> SetPoint(np_EEP,i,fgaus_EEP->GetParameter(1));
scale_vs_iring_EEP-> SetPointError(np_EEP,0,fgaus_EEP->GetParError(1));
np_EEP++;
sigma_vs_iring_EEM-> SetPoint(np_EEM,i,fgaus_EEM->GetParameter(2));
sigma_vs_iring_EEM-> SetPointError(np_EEM,0,fgaus_EEM->GetParError(2));
scale_vs_iring_EEM-> SetPoint(np_EEM,i,fgaus_EEM->GetParameter(1));
scale_vs_iring_EEM-> SetPointError(np_EEM,0,fgaus_EEM->GetParError(1));
np_EEM++;
sigma_vs_iring_All-> SetPoint(np_All,i,fgaus_All->GetParameter(2));
sigma_vs_iring_All-> SetPointError(np_All,0,fgaus_All->GetParError(2));
scale_vs_iring_All-> SetPoint(np_All,i,fgaus_All->GetParameter(1));
scale_vs_iring_All-> SetPointError(np_All,0,fgaus_All->GetParError(1));
np_All++;
}
/// For from statistical precision analysis
TGraphErrors* gr_stat_prec_EEP = (TGraphErrors*) f4->Get("gr_stat_prec_EEP");
TGraphErrors* gr_stat_prec_EEM = (TGraphErrors*) f4->Get("gr_stat_prec_EEM");
TGraphErrors* gr_stat_prec_All = (TGraphErrors*) f4->Get("gr_stat_prec");
/// Residual Plot
TGraphErrors* residual_EEP = new TGraphErrors();
TGraphErrors* residual_EEM = new TGraphErrors();
TGraphErrors* residual_All = new TGraphErrors();
for(int pp=0; pp< gr_stat_prec_EEP->GetN(); pp++){
double ring1, ring2,tot, stat, espread, estat,ex,res,eres;
sigma_vs_iring_EEP->GetPoint(pp, ring2, tot);
espread = sigma_vs_iring_EEP-> GetErrorY(pp);
gr_stat_prec_EEP->GetPoint(pp,ring1, stat);
estat = gr_stat_prec_EEP-> GetErrorY(pp);
ex = gr_stat_prec_EEP-> GetErrorX(pp);
if (tot > stat ){res = sqrt( tot*tot - stat*stat );
eres = sqrt( pow(tot*espread,2) + pow(stat*estat,2))/res;
}
else {res = -sqrt( fabs(tot*tot - stat*stat) );
eres = sqrt( pow(tot*espread,2) + pow(stat*estat,2))/fabs(res);
}
residual_EEP->SetPoint(pp,ring1,res);
if(eres<0.01) residual_EEP->SetPointError(pp,ex,eres);
else residual_EEP->SetPointError(pp,ex,0.01);
}
for(int pp=0; pp< gr_stat_prec_EEM->GetN(); pp++){
double ring1, ring2,tot, stat, espread, estat,ex,res,eres;
sigma_vs_iring_EEM->GetPoint(pp, ring2, tot);
espread = sigma_vs_iring_EEM-> GetErrorY(pp);
gr_stat_prec_EEM->GetPoint(pp,ring1, stat);
estat = gr_stat_prec_EEM-> GetErrorY(pp);
ex = gr_stat_prec_EEM-> GetErrorX(pp);
if (tot > stat ){res = sqrt( tot*tot - stat*stat );
eres = sqrt( pow(tot*espread,2) + pow(stat*estat,2))/res;
}
else {res = -sqrt( fabs(tot*tot - stat*stat) );
eres = sqrt( pow(tot*espread,2) + pow(stat*estat,2))/fabs(res);
}
residual_EEM->SetPoint(pp,ring1,res);
if(eres<0.01) residual_EEM->SetPointError(pp,ex,eres);
else residual_EEM->SetPointError(pp,ex,0.01);
}
for(int pp=0; pp< gr_stat_prec_All->GetN(); pp++){
double ring1, ring2,tot, stat, espread, estat,ex,res,eres;
sigma_vs_iring_All->GetPoint(pp, ring2, tot);
espread = sigma_vs_iring_All-> GetErrorY(pp);
gr_stat_prec_All->GetPoint(pp,ring1, stat);
estat = gr_stat_prec_All-> GetErrorY(pp);
ex = gr_stat_prec_All-> GetErrorX(pp);
if (tot > stat ){ res = sqrt( tot*tot - stat*stat );
eres = sqrt( pow(tot*espread,2) + pow(stat*estat,2))/res;
}
else {res = -sqrt( fabs(tot*tot - stat*stat) );
eres = sqrt( pow(tot*espread,2) + pow(stat*estat,2))/fabs(res);
}
residual_All->SetPoint(pp,ring1,res);
if(eres<0.01) residual_All->SetPointError(pp,ex,eres);
else residual_All->SetPointError(pp,ex,0.01);
}
/// Final Plot
TCanvas *cscale_EEP = new TCanvas("cscale_EEP","cscale_EEP");
cscale_EEP->SetGridx();
cscale_EEP->SetGridy();
scale_vs_iring_EEP->GetHistogram()->GetYaxis()-> SetRangeUser(0.9,1.1);
scale_vs_iring_EEP->GetHistogram()->GetXaxis()-> SetRangeUser(0,40);
scale_vs_iring_EEP->GetHistogram()->GetYaxis()-> SetTitle("c_{1}-c_{2}");
scale_vs_iring_EEP->GetHistogram()->GetXaxis()-> SetTitle("iring");
scale_vs_iring_EEP->Draw("ap");
TCanvas *cscale_EEM = new TCanvas("cscale_EEM","cscale_EEM");
cscale_EEM->SetGridx();
cscale_EEM->SetGridy();
scale_vs_iring_EEM->GetHistogram()->GetYaxis()-> SetRangeUser(0.9,1.1);
scale_vs_iring_EEM->GetHistogram()->GetXaxis()-> SetRangeUser(0,40);
scale_vs_iring_EEM->GetHistogram()->GetYaxis()-> SetTitle("c_{1}-c_{2}");
scale_vs_iring_EEM->GetHistogram()->GetXaxis()-> SetTitle("iring");
scale_vs_iring_EEM->Draw("ap");
TCanvas *cmap2_EEP = new TCanvas("cmap2_EEP","cmap2_EEP",500,500);
cmap2_EEP->SetGridx();
cmap2_EEP->SetGridy();
cmap2_EEP -> cd();
cmap2_EEP->SetLeftMargin(0.1);
cmap2_EEP->SetRightMargin(0.15);
h2_EEP->GetXaxis()->SetRangeUser(0.85,1.15);
h2_EEP->GetYaxis()->SetRangeUser(0.85,1.15);
h2_EEP->GetXaxis()->SetTitle("C_{1}");
h2_EEP->GetYaxis()->SetTitle("C_{2}");
h2_EEP->Draw("colz");
TCanvas *cmap2_EEM = new TCanvas("cmap2_EEM","cmap2_EEM",500,500);
cmap2_EEM->SetGridx();
cmap2_EEM->SetGridy();
cmap2_EEM -> cd();
cmap2_EEM->SetLeftMargin(0.1);
cmap2_EEM->SetRightMargin(0.15);
h2_EEM->GetXaxis()->SetRangeUser(0.85,1.15);
h2_EEM->GetYaxis()->SetRangeUser(0.85,1.15);
h2_EEM->GetXaxis()->SetTitle("C_{1}");
h2_EEM->GetYaxis()->SetTitle("C_{2}");
h2_EEM->Draw("colz");
TCanvas *cdiff_EEP = new TCanvas("cdiff_EEP","cdiff_EEP",700,500);
cdiff_EEP->SetGridx();
cdiff_EEP->SetGridy();
cdiff_EEP -> cd();
cdiff_EEP->SetLeftMargin(0.1);
cdiff_EEP->SetRightMargin(0.15);
h2diff_EEP->GetZaxis()->SetRangeUser(0.5,1.6);
h2diff_EEP->GetXaxis()->SetTitle("ix");
h2diff_EEP->GetYaxis()->SetTitle("iy");
h2diff_EEP->Draw("colz");
TCanvas *cdiff_EEM = new TCanvas("cdiff_EEM","cdiff_EEM",700,500);
cdiff_EEM->SetGridx();
cdiff_EEM->SetGridy();
cdiff_EEM -> cd();
cdiff_EEM->SetLeftMargin(0.1);
cdiff_EEM->SetRightMargin(0.15);
h2diff_EEM->GetZaxis()->SetRangeUser(0.5,1.6);
h2diff_EEM->GetXaxis()->SetTitle("ix");
h2diff_EEM->GetYaxis()->SetTitle("iy");
h2diff_EEM->Draw("colz");
TCanvas *csigma_EEP = new TCanvas("csigma_EEP","csigma_EEP");
csigma_EEP->SetGridx();
csigma_EEP->SetGridy();
sigma_vs_iring_EEP->GetHistogram()->GetYaxis()-> SetRangeUser(0.00,0.2);
sigma_vs_iring_EEP->GetHistogram()->GetXaxis()-> SetRangeUser(0,40);
sigma_vs_iring_EEP->GetHistogram()->GetYaxis()-> SetTitle("#sigma");
sigma_vs_iring_EEP->GetHistogram()->GetXaxis()-> SetTitle("iring");
sigma_vs_iring_EEP->Draw("ap");
gr_stat_prec_EEP->Draw("psame");
TCanvas *csigma_EEM = new TCanvas("csigma_EEM","csigma_EEM");
csigma_EEM->SetGridx();
csigma_EEM->SetGridy();
sigma_vs_iring_EEM->GetHistogram()->GetYaxis()-> SetRangeUser(0.00,0.2);
sigma_vs_iring_EEM->GetHistogram()->GetXaxis()-> SetRangeUser(0,40);
sigma_vs_iring_EEM->GetHistogram()->GetYaxis()-> SetTitle("#sigma");
sigma_vs_iring_EEM->GetHistogram()->GetXaxis()-> SetTitle("iring");
sigma_vs_iring_EEM->Draw("ap");
gr_stat_prec_EEM->Draw("psame");
TCanvas *csigma_All= new TCanvas("csigma_All","csigma_Folded");
csigma_All->SetGridx();
csigma_All->SetGridy();
sigma_vs_iring_All->GetHistogram()->GetYaxis()-> SetRangeUser(0.00,0.2);
sigma_vs_iring_All->GetHistogram()->GetXaxis()-> SetRangeUser(0,40);
sigma_vs_iring_All->GetHistogram()->GetYaxis()-> SetTitle("#sigma");
sigma_vs_iring_All->GetHistogram()->GetXaxis()-> SetTitle("iring");
sigma_vs_iring_All->Draw("ap");
gr_stat_prec_All->Draw("psame");
TCanvas *cres_EEP = new TCanvas("cres_EEP","cresidual_EEP");
cres_EEP->SetGridx();
cres_EEP->SetGridy();
residual_EEP->GetHistogram()->GetYaxis()-> SetRangeUser(-0.1,0.1);
residual_EEP->GetHistogram()->GetXaxis()-> SetRangeUser(0,40);
residual_EEP-> SetTitle("residual EE+");
residual_EEP-> SetTitle("iring");
residual_EEP->SetMarkerStyle(20);
residual_EEP->SetMarkerSize(1);
residual_EEP->SetMarkerColor(kGreen+2);
residual_EEP->Draw("ap");
TCanvas *cres_EEM = new TCanvas("cres_EEM","cresidual_EEM");
cres_EEM->SetGridx();
cres_EEM->SetGridy();
residual_EEM->GetHistogram()->GetYaxis()-> SetRangeUser(-0.1,0.1);
residual_EEM->GetHistogram()->GetXaxis()-> SetRangeUser(0,40);
residual_EEM->GetHistogram()->GetYaxis()-> SetTitle("residual EE-");
residual_EEM->GetHistogram()->GetXaxis()-> SetTitle("iring");
residual_EEM ->SetMarkerStyle(20);
residual_EEM->SetMarkerSize(1);
residual_EEM->SetMarkerColor(kGreen+2);
residual_EEM->Draw("ap");
TCanvas *cres_All = new TCanvas("cres_All","cresidual_Folded");
cres_All->SetGridx();
cres_All->SetGridy();
residual_All->GetHistogram()->GetYaxis()-> SetRangeUser(-0.1,0.1);
residual_All->GetHistogram()->GetXaxis()-> SetRangeUser(0,40);
residual_All->GetYaxis()->SetTitle("residual EE Folded");
residual_All->GetXaxis()->SetTitle("iring");
residual_All->SetMarkerStyle(20);
residual_All->SetMarkerSize(1);
residual_All->SetMarkerColor(kGreen+2);
residual_All->Draw("ap");
/// save output result:
TFile* output = new TFile(outputFile.c_str(),"RECREATE");
output->cd();
residual_EEM->Write("residual_EEM");
residual_EEP->Write("residual_EEP");
residual_All->Write("residual_All");
output->Close();
theApp->Run();
return 0;
}
