Macros for IZV RAS figures added.

macros/izvRAN/figIZVBestFits.cxx

+//Figure 5 IZV RAS
+
+#if !defined(__CLING__)
+
+#include "TFile.h"
+#include "TCanvas.h"
+#include "TH1F.h"
+#include "TText.h"
+#include <iostream>
+
+#endif
+
+using std::cout;
+using std::endl;
+
+void figIZVBestFits(Bool_t saveFigs = 0)
+{
+
+//	const Int_t canMap[6] = {1,4,3,6,2,5};
+
+
+	TH1F *hCurr = 0;
+	TString hName;
+
+	TFile *fr2 = new TFile("figures/PRCthetaA.root");
+
+	TH1F *hAlphaExp7590[6];
+	TH1F *hAlphaSim7590[6];
+
+	for (Int_t i = 0; i < 6; i++) {
+		hName.Form("hethetaAT3_%d_7590", i);
+		hCurr = (TH1F*)fr2->Get(hName.Data());
+		hAlphaExp7590[i] = new TH1F(*hCurr);
+
+		hName.Form("hsthetaAT3_%d_7590", i);
+		hCurr = (TH1F*)fr2->Get(hName.Data());
+		hAlphaSim7590[i] = new TH1F(*hCurr);
+	}
+
+	TH1F *hAlphaExp90120[6];
+	TH1F *hAlphaSim90120[6];
+
+	for (Int_t i = 0; i < 6; i++) {
+		hName.Form("hethetaAT3_%d_90120", i);
+		hCurr = (TH1F*)fr2->Get(hName.Data());
+		hAlphaExp90120[i] = new TH1F(*hCurr);
+
+		hName.Form("hsthetaAT3_%d_90120", i);
+		hCurr = (TH1F*)fr2->Get(hName.Data());
+		hAlphaSim90120[i] = new TH1F(*hCurr);
+	}
+
+	TFile *fr4560 = new TFile("figures/BestFit4560.root");
+
+	TH1F *hAlphaExp4560[6];
+	TH1F *hAlphaSim4560[6];
+	TH1F *hAlphaExp4560low[6];
+	TH1F *hAlphaSim4560low[6];
+	TH1F *hAlphaExp4560lowest[6];
+	TH1F *hAlphaSim4560lowest[6];
+
+	for (Int_t i = 0; i < 6; i++) {
+		hName.Form("hethetaAT3_%d_4560", i);
+		hCurr = (TH1F*)fr4560->Get(hName.Data());
+		hAlphaExp4560[i] = new TH1F(*hCurr);
+
+		hName.Form("hsthetaAT3_%d_4560", i);
+		hCurr = (TH1F*)fr4560->Get(hName.Data());
+		hAlphaSim4560[i] = new TH1F(*hCurr);
+
+		hName.Form("hethetaAT2_%d_4560", i);
+		hCurr = (TH1F*)fr4560->Get(hName.Data());
+		hAlphaExp4560low[i] = new TH1F(*hCurr);
+
+		hName.Form("hsthetaAT2_%d_4560", i);
+		hCurr = (TH1F*)fr4560->Get(hName.Data());
+		hAlphaSim4560low[i] = new TH1F(*hCurr);
+
+		hName.Form("hethetaAT1_%d_4560", i);
+		hCurr = (TH1F*)fr4560->Get(hName.Data());
+		hAlphaExp4560lowest[i] = new TH1F(*hCurr);
+
+		hName.Form("hsthetaAT1_%d_4560", i);
+		hCurr = (TH1F*)fr4560->Get(hName.Data());
+		hAlphaSim4560lowest[i] = new TH1F(*hCurr);
+	}
+
+	TFile *fr90120 = new TFile("figures/BestFit90120.root");
+
+	TH1F *hAlphaExp90120low[6];
+	TH1F *hAlphaSim90120low[6];
+	TH1F *hAlphaExp90120lowest[6];
+	TH1F *hAlphaSim90120lowest[6];
+
+	for (Int_t i = 0; i < 6; i++) {
+		hName.Form("hethetaAT2_%d_90120", i);
+		hCurr = (TH1F*)fr90120->Get(hName.Data());
+		hAlphaExp90120low[i] = new TH1F(*hCurr);
+
+		hName.Form("hsthetaAT2_%d_90120", i);
+		hCurr = (TH1F*)fr90120->Get(hName.Data());
+		hAlphaSim90120low[i] = new TH1F(*hCurr);
+
+		hName.Form("hethetaAT1_%d_90120", i);
+		hCurr = (TH1F*)fr90120->Get(hName.Data());
+		hAlphaExp90120lowest[i] = new TH1F(*hCurr);
+
+		hName.Form("hsthetaAT1_%d_90120", i);
+		hCurr = (TH1F*)fr90120->Get(hName.Data());
+		hAlphaSim90120lowest[i] = new TH1F(*hCurr);
+	}
+
+	TFile *fr7590 = new TFile("figures/BestFit7590.root");
+
+	TH1F *hAlphaExp7590low[6];
+	TH1F *hAlphaSim7590low[6];
+	TH1F *hAlphaExp7590lowest[6];
+	TH1F *hAlphaSim7590lowest[6];
+
+	for (Int_t i = 0; i < 6; i++) {
+		hName.Form("hethetaAT2_%d_7590", i);
+		hCurr = (TH1F*)fr7590->Get(hName.Data());
+		hAlphaExp7590low[i] = new TH1F(*hCurr);
+
+		hName.Form("hsthetaAT2_%d_7590", i);
+		hCurr = (TH1F*)fr7590->Get(hName.Data());
+		hAlphaSim7590low[i] = new TH1F(*hCurr);
+
+		hName.Form("hethetaAT1_%d_7590", i);
+		hCurr = (TH1F*)fr7590->Get(hName.Data());
+		hAlphaExp7590lowest[i] = new TH1F(*hCurr);
+
+		hName.Form("hsthetaAT1_%d_7590", i);
+		hCurr = (TH1F*)fr7590->Get(hName.Data());
+		hAlphaSim7590lowest[i] = new TH1F(*hCurr);
+	}
+
+
+	TFile *fr6075 = new TFile("figures/BestFit6075.root");
+
+	TH1F *hAlphaExp6075[6];
+	TH1F *hAlphaSim6075[6];
+	TH1F *hAlphaExp6075low[6];
+	TH1F *hAlphaSim6075low[6];
+	TH1F *hAlphaExp6075lowest[6];
+	TH1F *hAlphaSim6075lowest[6];
+
+	for (Int_t i = 0; i < 6; i++) {
+		hName.Form("hethetaAT3_%d_6075", i);
+		hCurr = (TH1F*)fr6075->Get(hName.Data());
+		hAlphaExp6075[i] = new TH1F(*hCurr);
+
+		hName.Form("hsthetaAT3_%d_6075", i);
+		hCurr = (TH1F*)fr6075->Get(hName.Data());
+		hAlphaSim6075[i] = new TH1F(*hCurr);
+
+		hName.Form("hethetaAT2_%d_6075", i);
+		hCurr = (TH1F*)fr6075->Get(hName.Data());
+		hAlphaExp6075low[i] = new TH1F(*hCurr);
+
+		hName.Form("hsthetaAT2_%d_6075", i);
+		hCurr = (TH1F*)fr6075->Get(hName.Data());
+		hAlphaSim6075low[i] = new TH1F(*hCurr);
+
+		hName.Form("hethetaAT1_%d_6075", i);
+		hCurr = (TH1F*)fr6075->Get(hName.Data());
+		hAlphaExp6075lowest[i] = new TH1F(*hCurr);
+
+		hName.Form("hsthetaAT1_%d_6075", i);
+		hCurr = (TH1F*)fr6075->Get(hName.Data());
+		hAlphaSim6075lowest[i] = new TH1F(*hCurr);
+	}
+
+
+
+	TCanvas *c1 = new TCanvas("c1", "Fig. 5, IZV RAS", 1200, 900);
+	c1->ToggleEditor();
+	c1->Divide(4, 3, .001, .001);
+
+	cout << "new Figure" << endl;
+
+////////////////////////
+//	2.5 - 3.1 MeV
+////////////////////////
+
+
+	c1->cd(9);
+	TH1F *hAlphaComb4560 = new TH1F(*hAlphaSim4560[3]);
+	//	hAlphaComb7590->Add(hAlphaSim[5], 1);
+	hAlphaComb4560->Add(hAlphaSim4560[2], 0.1);
+	hAlphaComb4560->Scale(0.9);
+//	for (Int_t nBin; nBin <= hAlphaComb4560->GetNbinsX(); nBin++) {
+//		hAlphaComb4560->SetBinError(nBin, 0);
+//	}
+
+	hAlphaComb4560->SetTitle("");
+	hAlphaComb4560->GetYaxis()->SetRangeUser(0., 480.);
+	hAlphaComb4560->GetYaxis()->SetTitle("");
+	hAlphaComb4560->GetYaxis()->SetNdivisions(30505);
+	hAlphaComb4560->GetXaxis()->SetNdivisions(506);
+	hAlphaComb4560->GetXaxis()->SetLabelSize(0.07);
+	hAlphaComb4560->GetXaxis()->SetLabelOffset(0.002);
+	hAlphaComb4560->GetXaxis()->SetTitleSize(0.07);
+	hAlphaComb4560->GetXaxis()->SetTitleOffset(0.74);
+	hAlphaComb4560->GetXaxis()->SetTitle("#it{#theta}_{#alpha}, rad");
+
+//	hAlphaComb4560->SetFillColor(kGray+1);
+	hAlphaComb4560->SetLineColor(kGray+1);
+
+	hAlphaComb4560->GetXaxis()->CenterTitle(0);
+
+	hAlphaComb4560->Draw("hist");
+	hAlphaExp4560[4]->Draw("E same");
+
+//	hAlphaExp4560[4]->Chi2Test(hAlphaComb4560, "P");
+
+	c1->cd(10);
+	TH1F *hAlphaComb6075 = new TH1F(*hAlphaSim6075[3]);
+//	hAlphaComb7590->Add(hAlphaSim[5], 1);
+	hAlphaComb6075->Add(hAlphaSim6075[2], 0.3);
+	hAlphaComb6075->Scale(0.8);
+//	for (Int_t nBin; nBin <= hAlphaComb6075->GetNbinsX(); nBin++) {
+//		hAlphaComb6075->SetBinError(nBin, 0);
+//	}
+
+	hAlphaComb6075->SetTitle("");
+	hAlphaComb6075->GetYaxis()->SetRangeUser(0., 650.);
+	hAlphaComb6075->GetYaxis()->SetTitle("");
+	hAlphaComb6075->GetYaxis()->SetNdivisions(30505);
+	hAlphaComb6075->GetXaxis()->SetNdivisions(506);
+	hAlphaComb6075->GetXaxis()->SetLabelSize(0.07);
+	hAlphaComb6075->GetXaxis()->SetLabelOffset(0.002);
+	hAlphaComb6075->GetXaxis()->SetTitleSize(0.07);
+	hAlphaComb6075->GetXaxis()->SetTitleOffset(0.74);
+	hAlphaComb6075->GetXaxis()->SetTitle("#it{#theta}_{#alpha}, rad");
+
+//	hAlphaComb6075->SetFillColor(kGray+1);
+	hAlphaComb6075->SetLineColor(kGray+1);
+
+	hAlphaComb6075->GetXaxis()->CenterTitle(0);
+
+	hAlphaComb6075->Draw("hist");
+	hAlphaExp6075[4]->Draw("E same");
+
+//	hAlphaExp6075[4]->Chi2Test(hAlphaComb6075, "P");
+	c1->Update();
+
+	c1->cd(11);
+
+	TH1F *hAlphaComb7590 = new TH1F(*hAlphaSim7590[3]);
+//	hAlphaComb7590->Add(hAlphaSim[5], 1);
+	hAlphaComb7590->Add(hAlphaSim7590[2], 0.2);
+	hAlphaComb7590->Scale(0.9);
+//	for (Int_t nBin; nBin <= hAlphaComb7590->GetNbinsX(); nBin++) {
+//		hAlphaComb7590->SetBinError(nBin, 0);
+//	}
+
+	hAlphaComb7590->SetTitle("");
+	hAlphaComb7590->GetYaxis()->SetRangeUser(0., 499.);
+	hAlphaComb7590->GetYaxis()->SetTitle("");
+	hAlphaComb7590->GetYaxis()->SetNdivisions(30505);
+	hAlphaComb7590->GetXaxis()->SetNdivisions(506);
+	hAlphaComb7590->GetXaxis()->SetLabelSize(0.07);
+	hAlphaComb7590->GetXaxis()->SetLabelOffset(0.002);
+	hAlphaComb7590->GetXaxis()->SetTitleSize(0.07);
+	hAlphaComb7590->GetXaxis()->SetTitleOffset(0.74);
+	hAlphaComb7590->GetXaxis()->SetTitle("#it{#theta}_{#alpha}, rad");
+
+//	hAlphaComb7590->SetFillColor(kGray+1);
+	hAlphaComb7590->SetLineColor(kGray+1);
+
+	hAlphaComb7590->GetXaxis()->CenterTitle(0);
+
+	hAlphaComb7590->Draw("hist");
+	hAlphaExp7590[4]->Draw("E same");
+
+	hAlphaExp7590[4]->Chi2Test(hAlphaComb7590, "P");
+
+	c1->cd(12);
+
+	TH1F *hAlphaComb90120 = new TH1F(*hAlphaSim90120[5]);
+//	hAlphaComb7590->Add(hAlphaSim[5], 1);
+	hAlphaComb90120->Add(hAlphaSim90120[3], 1);
+	hAlphaComb90120->Scale(0.5);
+//	for (Int_t nBin; nBin <= hAlphaComb90120->GetNbinsX(); nBin++) {
+//		hAlphaComb90120->SetBinError(nBin, 0);
+//	}
+
+	hAlphaComb90120->SetTitle("");
+	hAlphaComb90120->GetYaxis()->SetRangeUser(0., 399.);
+	hAlphaComb90120->GetYaxis()->SetTitle("");
+	hAlphaComb90120->GetYaxis()->SetNdivisions(30505);
+	hAlphaComb90120->GetXaxis()->SetNdivisions(506);
+	hAlphaComb90120->GetXaxis()->SetLabelSize(0.07);
+	hAlphaComb90120->GetXaxis()->SetLabelOffset(0.002);
+	hAlphaComb90120->GetXaxis()->SetTitleSize(0.07);
+	hAlphaComb90120->GetXaxis()->SetTitleOffset(0.74);
+	hAlphaComb90120->GetXaxis()->SetTitle("#it{#theta}_{#alpha}, rad");
+
+//	hAlphaComb90120->SetFillColor(kGray+1);
+	hAlphaComb90120->SetLineColor(kGray+1);
+
+	hAlphaComb90120->GetXaxis()->CenterTitle(0);
+
+	hAlphaComb90120->Draw("hist");
+	hAlphaExp90120[4]->Draw("E same");
+
+	hAlphaExp90120[4]->Chi2Test(hAlphaComb90120, "P");
+
+//	return;
+
+////////////////////////
+//	1.9 - 2.5 MeV
+////////////////////////
+
+//	TCanvas *c2 = new TCanvas("c2", "Combined fits 1.9 - 2.5 MeV", 1000, 1000);
+//	c2->ToggleEditor();
+//	c2->Divide(2, 2, .001, .001);
+
+	cout << endl << endl << endl << "new Figure for lower energy interval" << endl;
+
+	c1->cd(5);
+	TH1F *hAlphaComb4560low = new TH1F(*hAlphaSim4560low[5]);
+	//	hAlphaComb7590->Add(hAlphaSim[5], 1);
+	hAlphaComb4560low->Add(hAlphaSim4560low[4], 0.1);
+	hAlphaComb4560low->Add(hAlphaSim4560low[2], 0.1);
+	hAlphaComb4560low->Add(hAlphaSim4560low[3], 1);
+	hAlphaComb4560low->Scale(0.5);
+
+	hAlphaComb4560low->SetTitle("");
+	hAlphaComb4560low->GetYaxis()->SetRangeUser(0., 300.);
+	hAlphaComb4560low->GetYaxis()->SetTitle("");
+	hAlphaComb4560low->GetYaxis()->SetNdivisions(30505);
+	hAlphaComb4560low->GetXaxis()->SetNdivisions(506);
+	hAlphaComb4560low->GetXaxis()->SetLabelSize(0.07);
+	hAlphaComb4560low->GetXaxis()->SetLabelOffset(0.002);
+	hAlphaComb4560low->GetXaxis()->SetTitleSize(0.07);
+	hAlphaComb4560low->GetXaxis()->SetTitleOffset(0.74);
+	hAlphaComb4560low->GetXaxis()->SetTitle("#it{#theta}_{#alpha}, rad");
+
+	hAlphaComb4560low->SetLineColor(kGray+1);
+//	hAlphaComb4560low->SetLineColor(kRed+1);
+//	hAlphaComb4560low->SetFillColor(kGray+1);
+	hAlphaComb4560low->GetXaxis()->CenterTitle(0);
+
+	hAlphaComb4560low->Draw("hist");
+	hAlphaExp4560low[4]->Draw("E same");
+
+	hAlphaExp4560low[4]->Chi2Test(hAlphaComb4560low, "P");
+
+
+	c1->cd(6);
+	TH1F *hAlphaComb6075low = new TH1F(*hAlphaSim6075low[3]);
+	//	hAlphaComb7590->Add(hAlphaSim[5], 1);
+	hAlphaComb6075low->Add(hAlphaSim6075low[2], 0.1);
+	hAlphaComb6075low->Scale(0.9);
+
+	hAlphaComb6075low->SetTitle("");
+	hAlphaComb6075low->GetYaxis()->SetRangeUser(0., 400.);
+	hAlphaComb6075low->GetYaxis()->SetTitle("");
+	hAlphaComb6075low->GetYaxis()->SetNdivisions(30505);
+	hAlphaComb6075low->GetXaxis()->SetNdivisions(506);
+	hAlphaComb6075low->GetXaxis()->SetLabelSize(0.07);
+	hAlphaComb6075low->GetXaxis()->SetLabelOffset(0.002);
+	hAlphaComb6075low->GetXaxis()->SetTitleSize(0.07);
+	hAlphaComb6075low->GetXaxis()->SetTitleOffset(0.74);
+	hAlphaComb6075low->GetXaxis()->SetTitle("#it{#theta}_{#alpha}, rad");
+
+	hAlphaComb6075low->SetLineColor(kGray+1);
+//	hAlphaComb6075low->SetFillColor(kGray+1);
+	hAlphaComb6075low->GetXaxis()->CenterTitle(0);
+
+	hAlphaComb6075low->Draw("hist");
+	hAlphaExp6075low[4]->Draw("E same");
+
+	hAlphaExp6075low[4]->Chi2Test(hAlphaComb6075low, "P");
+
+	c1->cd(7);
+	TH1F *hAlphaComb7590low = new TH1F(*hAlphaSim7590low[3]);
+//	hAlphaComb7590low->Add(hAlphaSim7590low[2], 0.2);
+//	hAlphaComb7590low->Scale(0.8);
+//	for (Int_t nBin; nBin <= hAlphaComb4560->GetNbinsX(); nBin++) {
+//		hAlphaComb4560->SetBinError(nBin, 0);
+//	}
+
+	hAlphaComb7590low->SetTitle("");
+	hAlphaComb7590low->GetYaxis()->SetRangeUser(0., 300.);
+	hAlphaComb7590low->GetYaxis()->SetTitle("");
+	hAlphaComb7590low->GetYaxis()->SetNdivisions(30505);
+	hAlphaComb7590low->GetXaxis()->SetNdivisions(506);
+	hAlphaComb7590low->GetXaxis()->SetLabelSize(0.07);
+	hAlphaComb7590low->GetXaxis()->SetLabelOffset(0.002);
+	hAlphaComb7590low->GetXaxis()->SetTitleSize(0.07);
+	hAlphaComb7590low->GetXaxis()->SetTitleOffset(0.74);
+	hAlphaComb7590low->GetXaxis()->SetTitle("#it{#theta}_{#alpha}, rad");
+
+	hAlphaComb7590low->SetLineColor(kGray+1);
+//	hAlphaComb7590low->SetFillColor(kGray+1);
+	hAlphaComb7590low->GetXaxis()->CenterTitle(0);
+
+	hAlphaComb7590low->Draw("hist");
+	hAlphaExp7590low[4]->Draw("E same");
+
+	hAlphaExp7590low[4]->Chi2Test(hAlphaComb7590low, "P");
+
+	c1->cd(8);
+	TH1F *hAlphaComb90120low = new TH1F(*hAlphaSim90120low[5]);
+	hAlphaComb90120low->Add(hAlphaSim90120low[4], 0.1);
+	hAlphaComb90120low->Scale(0.8);
+	for (Int_t nBin; nBin <= hAlphaComb90120low->GetNbinsX(); nBin++) {
+		hAlphaComb90120low->SetBinError(nBin, 0);
+	}
+
+	hAlphaComb90120low->SetTitle("");
+	hAlphaComb90120low->GetYaxis()->SetRangeUser(0., 300.);
+	hAlphaComb90120low->GetYaxis()->SetTitle("");
+	hAlphaComb90120low->GetYaxis()->SetNdivisions(30505);
+	hAlphaComb90120low->GetXaxis()->SetNdivisions(506);
+	hAlphaComb90120low->GetXaxis()->SetLabelSize(0.07);
+	hAlphaComb90120low->GetXaxis()->SetLabelOffset(0.002);
+	hAlphaComb90120low->GetXaxis()->SetTitleSize(0.07);
+	hAlphaComb90120low->GetXaxis()->SetTitleOffset(0.74);
+	hAlphaComb90120low->GetXaxis()->SetTitle("#it{#theta}_{#alpha}, rad");
+
+	hAlphaComb90120low->GetXaxis()->CenterTitle(0);
+
+	hAlphaComb90120low->SetLineColor(kGray+1);
+//	hAlphaComb90120low->SetFillColor(kGray+1);
+
+	hAlphaComb90120low->Draw("hist");
+	hAlphaExp90120low[4]->Draw("E same");
+
+	hAlphaExp90120low[4]->Chi2Test(hAlphaComb90120low, "P");
+
+	c1->Update();
+
+////////////////////////
+//	1.4 - 1.9 MeV
+////////////////////////
+
+	c1->cd(1);
+	TH1F *hAlphaComb4560lowest = new TH1F(*hAlphaSim4560lowest[2]);
+	//	hAlphaComb7590->Add(hAlphaSim[5], 1);
+	hAlphaComb4560lowest->Add(hAlphaSim4560lowest[4], 1.);
+	//	hAlphaComb4560lowest->Add(hAlphaSim4560low[2], 0.1);
+	//	hAlphaComb4560lowest->Add(hAlphaSim4560low[3], 1);
+	hAlphaComb4560lowest->Scale(0.5);
+
+	hAlphaComb4560lowest->SetTitle("");
+	hAlphaComb4560lowest->GetYaxis()->SetRangeUser(0., 300.);
+	hAlphaComb4560lowest->GetYaxis()->SetTitle("");
+	hAlphaComb4560lowest->GetYaxis()->SetNdivisions(30505);
+	hAlphaComb4560lowest->GetXaxis()->SetNdivisions(506);
+	hAlphaComb4560lowest->GetXaxis()->SetLabelSize(0.07);
+	hAlphaComb4560lowest->GetXaxis()->SetLabelOffset(0.002);
+	hAlphaComb4560lowest->GetXaxis()->SetTitleSize(0.07);
+	hAlphaComb4560lowest->GetXaxis()->SetTitleOffset(0.74);
+	hAlphaComb4560lowest->GetXaxis()->SetTitle("#it{#theta}_{#alpha}, rad");
+
+	//	hAlphaComb4560low->GetYaxis()->SetRangeUser(0., 650.);
+	//	hAlphaComb4560low->GetYaxis()->SetTitle("");
+
+	hAlphaComb4560lowest->SetLineColor(kGray+1);
+
+	hAlphaComb4560lowest->GetXaxis()->CenterTitle(0);
+
+	hAlphaComb4560lowest->Draw("hist");
+
+	//	hAlphaComb4560lowest->Draw("same");
+	hAlphaExp4560lowest[4]->Draw("E same");
+
+	hAlphaExp4560lowest[4]->Chi2Test(hAlphaComb4560lowest, "P");
+
+
+	c1->cd(2);
+	TH1F *hAlphaComb6075lowest = new TH1F(*hAlphaSim6075lowest[2]);
+	//	hAlphaComb7590->Add(hAlphaSim[5], 1);
+	hAlphaComb6075lowest->Add(hAlphaSim6075lowest[3], 0.5);
+	hAlphaComb6075lowest->Scale(0.7);
+
+	hAlphaComb6075lowest->SetTitle("");
+	hAlphaComb6075lowest->GetYaxis()->SetRangeUser(0., 500.);
+	hAlphaComb6075lowest->GetYaxis()->SetTitle("");
+	hAlphaComb6075lowest->GetYaxis()->SetNdivisions(30505);
+	hAlphaComb6075lowest->GetXaxis()->SetNdivisions(506);
+	hAlphaComb6075lowest->GetXaxis()->SetLabelSize(0.07);
+	hAlphaComb6075lowest->GetXaxis()->SetLabelOffset(0.002);
+	hAlphaComb6075lowest->GetXaxis()->SetTitleSize(0.07);
+	hAlphaComb6075lowest->GetXaxis()->SetTitleOffset(0.74);
+	hAlphaComb6075lowest->GetXaxis()->SetTitle("#it{#theta}_{#alpha}, rad");
+
+	hAlphaComb6075lowest->SetLineColor(kGray+1);
+
+	hAlphaComb6075lowest->GetXaxis()->CenterTitle(0);
+
+	hAlphaComb6075lowest->Draw("hist");
+	hAlphaExp6075lowest[4]->Draw("E same");
+
+	hAlphaExp6075lowest[4]->Chi2Test(hAlphaComb6075lowest, "P");
+
+	c1->cd(3);
+	TH1F *hAlphaComb7590lowest = new TH1F(*hAlphaSim7590lowest[2]);
+	//	hAlphaComb7590lowest->Add(hAlphaSim7590low[2], 0.2);
+	//	hAlphaComb7590lowest->Scale(0.8);
+
+	hAlphaComb7590lowest->SetTitle("");
+	hAlphaComb7590lowest->GetYaxis()->SetRangeUser(0., 300.);
+	hAlphaComb7590lowest->GetYaxis()->SetTitle("");
+	hAlphaComb7590lowest->GetYaxis()->SetNdivisions(30505);
+	hAlphaComb7590lowest->GetXaxis()->SetNdivisions(506);
+	hAlphaComb7590lowest->GetXaxis()->SetLabelSize(0.07);
+	hAlphaComb7590lowest->GetXaxis()->SetLabelOffset(0.002);
+	hAlphaComb7590lowest->GetXaxis()->SetTitleSize(0.07);
+	hAlphaComb7590lowest->GetXaxis()->SetTitleOffset(0.74);
+	hAlphaComb7590lowest->GetXaxis()->SetTitle("#it{#theta}_{#alpha}, rad");
+
+	hAlphaComb7590lowest->SetLineColor(kGray+1);
+
+	hAlphaComb7590lowest->GetXaxis()->CenterTitle(0);
+
+	hAlphaComb7590lowest->Draw("same");
+	hAlphaExp7590lowest[4]->Draw("E same");
+
+	hAlphaExp7590lowest[4]->Chi2Test(hAlphaComb7590lowest, "P");
+
+	c1->cd(4);
+	TH1F *hAlphaComb90120lowest = new TH1F(*hAlphaSim90120lowest[2]);
+	hAlphaComb90120lowest->Add(hAlphaSim90120lowest[3], 0.2);
+	hAlphaComb90120lowest->Scale(0.8);
+
+	hAlphaComb90120lowest->SetTitle("");
+	hAlphaComb90120lowest->GetYaxis()->SetRangeUser(0., 300.);
+	hAlphaComb90120lowest->GetYaxis()->SetTitle("");
+	hAlphaComb90120lowest->GetYaxis()->SetNdivisions(30505);
+	hAlphaComb90120lowest->GetXaxis()->SetNdivisions(506);
+	hAlphaComb90120lowest->GetXaxis()->SetLabelSize(0.07);
+	hAlphaComb90120lowest->GetXaxis()->SetLabelOffset(0.002);
+	hAlphaComb90120lowest->GetXaxis()->SetTitleSize(0.07);
+	hAlphaComb90120lowest->GetXaxis()->SetTitleOffset(0.74);
+	hAlphaComb90120lowest->GetXaxis()->SetTitle("#it{#theta}_{#alpha}, rad");
+
+	hAlphaComb90120lowest->SetLineColor(kGray+1);
+
+	hAlphaComb90120lowest->GetXaxis()->CenterTitle(0);
+
+	hAlphaComb90120lowest->Draw("hist");
+	hAlphaExp90120lowest[4]->Draw("E same");
+
+	hAlphaExp90120lowest[4]->Chi2Test(hAlphaComb90120lowest, "P");
+
+	c1->Update();
+
+	TText *t1[12];
+	TString panel[12] = {"a)", "b)", "c)", "d)",
+						"e)", "f)", "g)", "h)",
+						"i)", "j)", "k)", "l)"};
+
+	for (Int_t i = 0; i < 12; i++) {
+		c1->cd(i+1);
+		t1[i] = new TText(0.18,0.87,panel[i].Data());
+//		t1[i] = new TText(0.5,0.95,panel[i].Data());
+		t1[i]->SetNDC();
+		t1[i]->SetTextFont(132);
+		t1[i]->SetTextSize(0.07);
+		t1[i]->Draw();
+	}
+
+
+	if (saveFigs) {
+		c1->SaveAs("figures/Fig5izvBestFits.png");
+		c1->SaveAs("figures/Fig5izvBestFits.eps");
+	}
+
+}

macros/izvRAN/figIZVCorrGS.cxx

+//Figure 2 IZV RAS
+
+#if !defined(__CLING__)
+
+#include "TFile.h"
+#include "TCanvas.h"
+#include "TH1F.h"
+#include "TText.h"
+
+#endif
+
+void figIZVCorrGS(const Bool_t saveFigs = 0)
+{
+
+	TFile *fr1 = new TFile("figures/PRCepsilonT.root", "READ");
+//	TFile *fr2 = new TFile("figures/PRCepsilonT.root", "READ");
+
+	TH1F *hExp[4];
+	TH1F *hSim[4];
+	TH1F *hInput[4];
+
+	TH1F *hCurr = 0;
+
+	hCurr = (TH1F*)fr1->Get("heeT0_0_4560");
+	hExp[0] = new TH1F(*hCurr);
+	hCurr = (TH1F*)fr1->Get("heeT0_5_6075");
+	hExp[1] = new TH1F(*hCurr);
+	hCurr = (TH1F*)fr1->Get("heeT0_5_7590");
+	hExp[2] = new TH1F(*hCurr);
+	hCurr = (TH1F*)fr1->Get("heeT0_0_90120");
+	hExp[3] = new TH1F(*hCurr);
+
+	hCurr = (TH1F*)fr1->Get("hseT0_0_4560");
+	hSim[0] = new TH1F(*hCurr);
+	hCurr = (TH1F*)fr1->Get("hseT0_5_6075");
+	hSim[1] = new TH1F(*hCurr);
+	hCurr = (TH1F*)fr1->Get("hseT0_5_7590");
+	hSim[2] = new TH1F(*hCurr);
+	hCurr = (TH1F*)fr1->Get("hseT0_0_90120");
+	hSim[3] = new TH1F(*hCurr);
+
+	hCurr = (TH1F*)fr1->Get("hieT0_0_4560");
+	hInput[0] = new TH1F(*hCurr);
+	hCurr = (TH1F*)fr1->Get("hieT0_5_6075");
+	hInput[1] = new TH1F(*hCurr);
+	hCurr = (TH1F*)fr1->Get("hieT0_5_7590");
+	hInput[2] = new TH1F(*hCurr);
+	hCurr = (TH1F*)fr1->Get("hieT0_0_90120");
+	hInput[3] = new TH1F(*hCurr);
+
+
+
+	TCanvas *c1 = new TCanvas("c1", "Fig. 2, IZV RAS");
+	c1->ToggleEditor();
+//	c1->SetWindowSize(800, 1200);
+	c1->SetWindowSize(1800, 450);
+	c1->Divide(4, 1, .001, .001);
+
+	TText *t1[4];
+	TString panel[4] = {"a)", "b)", "c)", "d)"};
+
+	for (Int_t i = 0; i < 4; i++) {
+		c1->cd(i+1);
+
+//		cout << i << endl;
+
+		hSim[i]->SetTitle("");
+		hSim[i]->SetLineColor(kGray);
+//		hSim[i]->SetFillColor(kGray+1);
+		hSim[i]->GetXaxis()->SetNdivisions(405);
+		hSim[i]->GetYaxis()->SetTitle("");
+		if (i == 0 || i == 1) {
+			hSim[i]->GetYaxis()->SetNdivisions(1005);
+		}
+//		hInput[i]->SetLineWidth(2);
+		hInput[i]->SetLineColor(kBlack);
+		hInput[i]->SetLineStyle(2);
+
+//		hSim[i]->Smooth();
+
+		hSim[i]->GetXaxis()->CenterTitle(0);
+
+		hSim[i]->Draw("");
+		hExp[i]->Draw("E same");
+		hInput[i]->Draw("same");
+		hInput[i]->Smooth();
+
+		hExp[i]->Chi2Test(hSim[i], "P");
+
+		t1[i] = new TText(0.18,0.87,panel[i].Data());
+		t1[i]->SetNDC();
+		t1[i]->SetTextFont(132);
+		t1[i]->SetTextSize(0.07);
+		t1[i]->Draw();
+	}
+	c1->Update();
+
+
+	if (saveFigs) {
+//		c2->SaveAs("figures/PresGSepsilonTright7590.png");
+
+		c1->SaveAs("figures/Fig2izvIntCorrsEvolution.png");
+		c1->SaveAs("figures/Fig2izvIntCorrsEvolution.eps");
+	}
+
+	return;
+
+}

macros/izvRAN/figIZVCorrLeftES.cxx

+//Figure 4 IZV RAS
+
+#if !defined(__CLING__)
+
+#include "TFile.h"
+#include "TCanvas.h"
+#include "TH1F.h"
+#include "TText.h"
+#include <iostream>
+
+#endif
+
+using std::cout;
+using std::endl;
+
+void figIZVCorrLeftES(const Bool_t saveFigs = 0)
+{
+
+//	gStyle->SetLabelFont();
+
+	TFile *fr = new TFile("figures/PRCepsilonT.root", "READ");
+
+	const Int_t canMap[6] = {1,4,3,6,2,5};
+
+	TH1F *hCurr = 0;
+
+	TString hName;
+
+	TFile *fr2 = new TFile("figures/PRCthetaA.root");
+
+	TCanvas *c4 = new TCanvas("c4", "Fig. 4, IZV RAS");
+	c4->ToggleEditor();
+//	c4->SetWindowSize(800, 1227);
+//	c4->Divide(2, 3, .001, .001);
+	c4->SetWindowSize(1500, 1000);
+	c4->Divide(3, 2, .001, .001);
+
+//	TFile *fr2 = new TFile("figures/PRCthetaA.root");
+
+	TH1F *hAlphaExp90120[6];
+	TH1F *hAlphaSim90120[6];
+	TH1F *hAlphaInput90120[6];
+	TH1F *hAlphaInput90120Corr[6];
+
+
+	cout << "Fig. 4" << endl;
+
+	TText *t1[6];
+	TString panel[6] = {"a)", "b)", "c)", "d)", "e)", "f)"};
+
+	for (Int_t i = 0; i < 6; i++) {
+		c4->cd(canMap[i]);
+
+		hName.Form("hethetaAT3_%d_90120", i);
+		hCurr = (TH1F*)fr2->Get(hName.Data());
+		hAlphaExp90120[i] = new TH1F(*hCurr);
+
+		hName.Form("hsthetaAT3_%d_90120", i);
+		hCurr = (TH1F*)fr2->Get(hName.Data());
+		hAlphaSim90120[i] = new TH1F(*hCurr);
+
+		hName.Form("hithetaAT3_%d_90120", i);
+		hCurr = (TH1F*)fr2->Get(hName.Data());
+		hAlphaInput90120[i] = new TH1F(*hCurr);
+
+		hAlphaInput90120Corr[i] = new TH1F(*hAlphaInput90120[i]);
+		Double_t binContent = 0;
+		for (Int_t binN = 1; binN <= 15; binN++) {
+//			binContent = hAlphaInput90120Corr[i]->GetBinContent(binN);
+			binContent = hAlphaInput90120[i]->GetBinContent(binN);
+			hAlphaInput90120Corr[i]->SetBinContent(binN, binContent + hAlphaInput90120Corr[i]->GetBinContent(31-binN));
+			hAlphaInput90120Corr[i]->SetBinContent(31-binN, hAlphaInput90120Corr[i]->GetBinContent(binN));
+//			hAlphaInput90120Corr[i]->SetBinError(binN, 0.);
+//			hAlphaInput90120Corr[i]->SetBinError(31-binN, 0.);
+		}
+
+		hAlphaInput90120[i]->SetLineWidth(2);
+		hAlphaSim90120[i]->SetTitle("");
+		hAlphaSim90120[i]->GetXaxis()->SetNdivisions(506);
+		hAlphaSim90120[i]->GetXaxis()->SetLabelSize(0.07);
+		hAlphaSim90120[i]->GetXaxis()->SetLabelOffset(0.002);
+		hAlphaSim90120[i]->GetXaxis()->SetTitleSize(0.08);
+		hAlphaSim90120[i]->GetXaxis()->SetTitleOffset(0.74);
+
+		hAlphaSim90120[i]->GetYaxis()->SetRangeUser(0., 650.);
+		hAlphaSim90120[i]->GetYaxis()->SetTitle("");
+
+		hAlphaSim90120[i]->SetLineColor(kGray+1);
+//		hAlphaSim90120[i]->SetFillColor(kGray+1);
+
+		hAlphaSim90120[i]->GetXaxis()->CenterTitle(0);
+
+		hAlphaSim90120[i]->Draw("hist");
+		hAlphaSim90120[i]->GetXaxis()->SetTitle("#it{#theta}_{#alpha}, rad");
+//		hAlphaInput90120Corr[i]->Draw("same");
+		hAlphaExp90120[i]->Draw("E same");
+//		hAlphaInput90120[i]->Draw("same");
+		hAlphaInput90120Corr[i]->SetLineColor(kBlack);
+		hAlphaInput90120Corr[i]->SetLineStyle(2);
+		hAlphaInput90120Corr[i]->Scale(0.5);
+		hAlphaInput90120Corr[i]->Smooth();
+		hAlphaInput90120Corr[i]->Draw("hist same");
+//		hAlphaInput90120[i]->Draw("same");
+//		hAlphaInput90120Corr[i]->
+
+		hAlphaExp90120[i]->Chi2Test(hAlphaSim90120[i], "P");
+
+		t1[i] = new TText(0.18,0.87,panel[i].Data());
+		//		t1[i] = new TText(0.5,0.95,panel[i].Data());
+		t1[i]->SetNDC();
+		t1[i]->SetTextFont(132);
+		t1[i]->SetTextSize(0.07);
+		t1[i]->Draw();
+
+	}
+	c4->Update();
+
+
+	if (saveFigs) {
+		c4->SaveAs("figures/Fig4izvExtCorrs.png");
+		c4->SaveAs("figures/Fig4izvExtCorrs.eps");
+	}
+
+}

macros/izvRAN/figIZVCorrRightGS.cxx

+//Figure 3 IZV RAS
+
+#if !defined(__CLING__)
+
+#include "TFile.h"
+#include "TCanvas.h"
+#include "TH1F.h"
+#include "TText.h"
+#include <iostream>
+
+#endif
+
+using std::cout;
+using std::endl;
+
+void figIZVCorrRightGS(const Bool_t saveFigs = 0)
+{
+
+	const Int_t canMap[6] = {1,4,3,6,2,5};
+
+	TFile *fr1 = new TFile("figures/PRCepsilonT.root", "READ");
+//	TFile *fr2 = new TFile("figures/PRCepsilonT.root", "READ");
+
+	TH1F *hExp[4];
+	TH1F *hSim[4];
+	TH1F *hInput[4];
+
+	TH1F *hCurr = 0;
+
+	hCurr = (TH1F*)fr1->Get("heeT1_2_4560");
+	hExp[0] = new TH1F(*hCurr);
+	hCurr = (TH1F*)fr1->Get("heeT1_2_6075");
+	hExp[1] = new TH1F(*hCurr);
+	hCurr = (TH1F*)fr1->Get("heeT1_2_7590");
+	hExp[2] = new TH1F(*hCurr);
+	hCurr = (TH1F*)fr1->Get("heeT1_2_90120");
+	hExp[3] = new TH1F(*hCurr);
+
+	hCurr = (TH1F*)fr1->Get("hseT1_2_4560");
+	hSim[0] = new TH1F(*hCurr);
+	hCurr = (TH1F*)fr1->Get("hseT1_2_6075");
+	hSim[1] = new TH1F(*hCurr);
+	hCurr = (TH1F*)fr1->Get("hseT1_2_7590");
+	hSim[2] = new TH1F(*hCurr);
+	hCurr = (TH1F*)fr1->Get("hseT1_2_90120");
+	hSim[3] = new TH1F(*hCurr);
+
+	hCurr = (TH1F*)fr1->Get("hieT1_2_4560");
+	hInput[0] = new TH1F(*hCurr);
+	hCurr = (TH1F*)fr1->Get("hieT1_2_6075");
+	hInput[1] = new TH1F(*hCurr);
+	hCurr = (TH1F*)fr1->Get("hieT1_2_7590");
+	hInput[2] = new TH1F(*hCurr);
+	hCurr = (TH1F*)fr1->Get("hieT1_2_90120");
+	hInput[3] = new TH1F(*hCurr);
+
+	TCanvas *c2 = new TCanvas("c2", "Fig. 3, IZV RAS");
+	c2->ToggleEditor();
+	c2->SetWindowSize(1500, 1000);
+	c2->Divide(3, 2, .001, .001);
+
+	TH1F *hCorrExp[6];
+	TH1F *hCorrSim[6];
+	TH1F *hCorrInput[6];
+
+	TString hName;
+
+	cout << "Fig. 3" << endl;
+
+	TText *t1[6];
+	TString panel[6] = {"a)", "b)", "c)", "d)", "e)", "f)"};
+
+	for (Int_t i = 0; i < 6; i++) {
+		c2->cd(canMap[i]);
+
+		hName.Form("heeT1_%d_7590", i);
+		hCurr = (TH1F*)fr1->Get(hName.Data());
+		hCorrExp[i] = new TH1F(*hCurr);
+
+		hName.Form("hseT1_%d_7590", i);
+		hCurr = (TH1F*)fr1->Get(hName.Data());
+		hCorrSim[i] = new TH1F(*hCurr);
+
+		hName.Form("hieT1_%d_7590", i);
+		hCurr = (TH1F*)fr1->Get(hName.Data());
+		hCorrInput[i] = new TH1F(*hCurr);
+
+		hCorrInput[i]->SetLineColor(kBlack);
+		hCorrInput[i]->SetLineStyle(2);
+		hCorrInput[i]->Smooth();
+
+		hCorrSim[i]->SetTitle("");
+		hCorrSim[i]->GetXaxis()->SetNdivisions(505);
+
+		hCorrSim[i]->GetYaxis()->SetRangeUser(0., 850.);
+		hCorrSim[i]->GetYaxis()->SetNdivisions(505);
+		hCorrSim[i]->GetYaxis()->SetTitle("");
+
+		hCorrSim[i]->SetLineColor(kGray+1);
+//		hCorrSim[i]->SetFillColor(kGray+1);
+
+		hCorrSim[i]->GetXaxis()->CenterTitle(0);
+
+		hCorrSim[i]->Draw("hist");
+		hCorrExp[i]->Draw("E same");
+		hCorrInput[i]->Draw("hist same");
+
+		hCorrExp[i]->Chi2Test(hCorrSim[i], "P");
+
+		t1[i] = new TText(0.18,0.87,panel[i].Data());
+//		t1[i] = new TText(0.5,0.95,panel[i].Data());
+		t1[i]->SetNDC();
+		t1[i]->SetTextFont(132);
+		t1[i]->SetTextSize(0.07);
+		t1[i]->Draw();
+	}
+	c2->Update();
+
+	if (saveFigs) {
+//		c2->SaveAs("figures/PresGSepsilonTright7590.png");
+
+		c2->SaveAs("figures/Fig3izvIntCorrs.png");
+		c2->SaveAs("figures/Fig3izvIntCorrs.eps");
+	}
+}

macros/izvRAN/figSpectraIZV.cxx

+//Figure 1 IZV RAS
+
 #if !defined(__CLING__)
 
 #include "TFile.h"
@@ -7,7 +9,7 @@
 
 #endif
 
-void figSpectraIZV()
+void figSpectraIZV(const Bool_t saveFigs = 0)
 {
 
 //	TFile *fr = new TFile("figures/spectra.root", "READ");
@@ -45,7 +47,7 @@ void figSpectraIZV()
 
 
 
-	TCanvas *c1 = new TCanvas();
+	TCanvas *c1 = new TCanvas("c1", "Fig. 1, IZV RAS");
 	c1->ToggleEditor();
 //	c1->SetWindowSize(800, 1200);
 //	c1->SetWindowSize(800, 800);
@@ -74,21 +76,19 @@ void figSpectraIZV()
 
 		if (i==0) hSim[i]->GetYaxis()->SetRangeUser(0,13000);
 
-//		t1[i] = new TText(0.61,10829.39,"d)");
 		t1[i] = new TText(0.18,0.87,panel[i].Data());
 		t1[i]->SetNDC();
 		t1[i]->SetTextFont(132);
 		t1[i]->SetTextSize(0.07);
 		t1[i]->Draw();
-//		t1[i]->DrawTextNDC(.5, .5, "ajdas");
 	}
 
-//	TText *t1 = new TText(0.61,10829.39,"d)");
-////	   t1->SetTextColor(kRed);
-//	t1->SetTextFont(132);
-//	t1->SetTextSize(0.07);
-//	t1->Draw();
+	if (saveFigs) {
+//		c2->SaveAs("figures/PresGSepsilonTright7590.png");
 
-//	c1->SaveAs("figures/spectra.eps");
+		c1->SaveAs("figures/Fig1izvSpectra.png");
+		c1->SaveAs("figures/Fig1izvSpectra.eps");
+	}
 
+	return;
 }