--- /dev/null
+// provided by Gamma Conversion Group, PWG4, Kathrin Koch, kkoch@physi.uni-heidelberg.de and Friederike Bock, fbock@physi.uni-heidelberg.de
+
+#include <Riostream.h>
+#include <fstream>
+#include "PlottingGammaHistos.h"
+using namespace std;
+
+extern TRandom *gRandom;
+extern TBenchmark *gBenchmark;
+extern TSystem *gSystem;
+
+void Plot_Mapping_Histos_Events(const char *input1 = "myOutput", const char *secondinput = "", const char *cutsel = "", const char *path = "", const char *output = "Mapping", const char *Plots = "kFALSE", const char *suffix = "gif"){
+
+ gROOT->Reset();
+ gROOT->SetStyle("Plain");
+ StyleSettings();
+
+ // Which file you want to analyse
+ Char_t filename_input1[200] = (Form("%s%s",path,input1));
+
+ Bool_t SinglePlots = kFALSE;
+ if(Plots == "kTRUE") SinglePlots = kTRUE;
+
+ // the outputfile
+ TPostScript *ps_mapping = 0x0;
+ if(!SinglePlots)ps_mapping = new TPostScript(Form("%s%s.ps",path,output),111);
+
+ //rebinning
+ const int rebin = 4;
+
+ //Which Minimum do you want to set for XY-2Dplot
+ Int_t minimumXY = 10;
+
+ //How big should the right margin in 2D plots be? Others are set by default setting.
+ Float_t RightMargin = 0.17;
+
+ //How many slices do you have?
+// const int NbinsPhi = 8;
+// const int NbinsR = 12;
+ const int NbinsZ = 6;
+ const int NbinsR = 13;
+ const int NbinsZ = 12;
+
+ // how many raws and colums you want to have in your output?
+ Int_t column = 2;
+ Int_t raw = 7;
+
+ //Array for ZinR-Ranges
+ Float_t *RangeZinR[NbinsR] = {30,30,40,50,60,70,80,100,120,140,160,180,240};
+ //Float_t *RangeZinR[NbinsR] = {30,40,50,60,70,80,100,120,140,160,180,240};
+
+ //Array of Rbins
+ Float_t ArrayRbins[12] = {3.5,5.75,9.5,13.,21.,27.5,35.,42.,55.,81.5,90,72.};
+ //Array of Zbins
+ Float_t ArrayZbins[11] = {0,15,30,50,100,200,-15,-30,-50,-100,-200};
+
+ //Array defintion for printing Logo in right upper corner
+ Float_t right_up[4]={0.7,0.63,0.15, 0.02};
+ Float_t right_down[4]={0.7,0.23,0.15, 0.02};
+ Float_t right_up2D[4]={0.68,0.775,0.11, 0.02};
+ //Array defintion for printing Logo in left upper corner
+ Float_t left_up[4]={0.17,0.73, 0.15, 0.02};
+ Float_t left_down[4] = {0.15,0.17, 0.15, 0.02};
+ //Array defintion for printing text in right upper corner
+ Float_t right_up_text[4]={0.6,0.8,0.15, 0.04};
+
+ // get the histos
+ TFile f1(filename_input1);
+
+
+ // choice of dateset
+ if(cutsel != ""){
+ char *GammaDirectory = Form("PWG4_GammaConversion_%s", cutsel);
+ cout << GammaDirectory << endl;
+ char *GammaList = Form("histogramsAliGammaConversion_%s", cutsel);
+ cout << GammaList << endl;
+ }else{
+ char *GammaDirectory = "PWG4_GammaConversion";
+ cout << GammaDirectory << endl;
+ char *GammaList = "histogramsAliGammaConversion";
+ cout << GammaList << endl;
+ }
+
+ // labeling
+ char *StandardYAxis = "#gamma/ event scaled by multiplicity";
+ char *Date = "3rd June 2010";
+ TLatex *EtaRange = new TLatex(0.15,0.845,"|#eta| < 0.9 "); // Bo: this was modified
+ EtaRange->SetNDC();
+ EtaRange->SetTextFont(62);
+ EtaRange->SetTextSize(0.04);
+ EtaRange->SetLineWidth(6);
+
+//------------------------------- Reading FILES ----------------------------------------------------------------------
+ TDirectory *fPWG4GammaConversion_input1 = new TDirectory(); // definition of first folder / list
+ TList *fHistosGammaConversion_input1 = new TList(); // definition of first folder / list
+ TList *fESDContainer_input1 = new TList(); // definition of following folder / list
+ TList *fMappingContainer_input1 = new TList();
+
+ fPWG4GammaConversion_input1 = (TDirectory*)f1.Get(GammaDirectory);
+ fHistosGammaConversion_input1 = (TList*)fPWG4GammaConversion_input1->Get(GammaList);
+ fMappingContainer_input1 = (TList*)fHistosGammaConversion_input1->FindObject("Mapping histograms");
+ fESDContainer_input1 = (TList*)fHistosGammaConversion_input1->FindObject("ESD histograms");
+
+ TH1F *ESD_Conversion_R_input1=fESDContainer_input1->FindObject("ESD_Conversion_R");
+ TH2F *ESD_Conversion_ZR_input1=fESDContainer_input1->FindObject("ESD_Conversion_ZR");
+ TH2F *ESD_Conversion_XY_input1=fESDContainer_input1->FindObject("ESD_Conversion_XY");
+ TH1F *ESD_Conversion_OpeningAngle_input1=fESDContainer_input1->FindObject("ESD_Conversion_OpeningAngle");
+ TH1D *ESD_Conversion_Z_input1=ESD_Conversion_ZR_input1->ProjectionX("ESD_Conversion_Z_input1");
+ TH1F *ESD_NumberOfContributorsVtx_input1=fESDContainer_input1->FindObject("ESD_NumberOfContributorsVtx");
+ TH1D *ESD_Conversion_Z_input1=ESD_Conversion_ZR_input1->ProjectionX("ESD_Cocdnversion_Z_input1");
+ TH1F *ScalingDiagramm_input1= fMappingContainer_input1->FindObject("ESD_Conversion_Mapping_Phi_in_R_11");
+ TH1F *ESD_NumberOfGoodESDTracks_input1=fESDContainer_input1->FindObject("ESD_NumberOfGoodESDTracksVtx");
+
+ ESD_NumberOfContributorsVtx_input1->SetAxisRange(1.,100.);
+// ESD_NumberOfGoodESDTracks_input1->SetAxisRange(1.,100.);
+
+ Float_t Scaling_input1 = ScalingDiagramm_input1->Integral();
+ Float_t nGoodEvents_input1 = ESD_NumberOfContributorsVtx_input1->Integral();
+ Float_t nGoodTrig_input1 = ESD_NumberOfContributorsVtx_input1->GetEntries();
+ Float_t nRecGamma_input1 = ESD_Conversion_R_input1->GetEntries();
+ cout<< input1 << " Number of events:: " << nGoodEvents_input1 << " Number of triggers:: " << nGoodTrig_input1 << " Number reconstructed gammas:: "<< nRecGamma_input1 <<endl;
+
+ Double_t mean_input1 = ESD_NumberOfGoodESDTracks_input1->GetMean();
+
+ Float_t normFacRec_input1=1./nGoodEvents_input1;
+// Float_t normFacRec_input1=1./Scaling_input1;
+ //Scaling reconstr.
+
+ GammaScalingHistogramm(ESD_Conversion_R_input1,normFacRec_input1);
+// GammaScalingHistogramm(ESD_Conversion_ZR_input1,normFacRec_input1);
+// GammaScalingHistogramm(ESD_Conversion_XY_input1,normFacRec_input1);
+ GammaScalingHistogramm(ESD_Conversion_OpeningAngle_input1,normFacRec_input1);
+ GammaScalingHistogramm(ESD_Conversion_Z_input1,normFacRec_input1);
+
+ TH1F *ESD_Conversion_R_summed_input1 = (TH1F*) ESD_Conversion_R_input1->Clone("ESD_Conversion_R_summed_input1");
+ ESD_Conversion_R_summed_input1->Reset();
+ Int_t ConvBinsR = ESD_Conversion_R_input1->GetNbinsX();
+ for(Int_t ConvR = 1; ConvR < ConvBinsR +1; ConvR++){
+ if (ConvR == 1){
+ ESD_Conversion_R_summed_input1->AddBinContent(ConvR, ESD_Conversion_R_input1-> GetBinContent(ConvR));
+ } else {
+ ESD_Conversion_R_summed_input1->AddBinContent(ConvR,(ESD_Conversion_R_summed_input1->GetBinContent(ConvR -1) + ESD_Conversion_R_input1->GetBinContent(ConvR)));
+ }
+ }
+
+ TH1F *ESD_Conversion_Mapping_Phi_in_R_input1[NbinsR];
+ Char_t histoname_Phi_in_R_input1[100];
+ for(Int_t iR = 0; iR < NbinsR; iR++){
+ sprintf(histoname_Phi_in_R_input1,"ESD_Conversion_Mapping_Phi_in_R_%02d",iR);
+ ESD_Conversion_Mapping_Phi_in_R_input1[iR] = dynamic_cast<TH1F*>(fMappingContainer_input1->FindObject(histoname_Phi_in_R_input1));
+ GammaScalingHistogramm(ESD_Conversion_Mapping_Phi_in_R_input1[iR],normFacRec_input1);
+ ESD_Conversion_Mapping_Phi_in_R_input1[iR]->Rebin(rebin);
+ }
+
+ TH1F *ESD_Conversion_Mapping_Z_in_R_input1[NbinsR];
+ Char_t histoname_Z_in_R_input1[100];
+ for(Int_t iR = 0; iR < NbinsR; iR++){
+ sprintf(histoname_Z_in_R_input1,"ESD_Conversion_Mapping_Z_in_R_%02d",iR);
+ ESD_Conversion_Mapping_Z_in_R_input1[iR] = dynamic_cast<TH1F*>(fMappingContainer_input1->FindObject(histoname_Z_in_R_input1));
+ GammaScalingHistogramm(ESD_Conversion_Mapping_Z_in_R_input1[iR],normFacRec_input1);
+ ESD_Conversion_Mapping_Z_in_R_input1[iR]->Rebin(rebin);
+ }
+
+ TH1F *ESD_Conversion_Mapping_Phi_in_Z_input1[NbinsZ];
+ Char_t histoname_Phi_in_Z_input1[100];
+ for(Int_t iZ = 0; iZ < NbinsZ; iZ++){
+ sprintf(histoname_Phi_in_Z_input1,"ESD_Conversion_Mapping_Phi_in_Z_%02d",iZ);
+ ESD_Conversion_Mapping_Phi_in_Z_input1[iZ] = dynamic_cast<TH1F*>(fMappingContainer_input1->FindObject(histoname_Phi_in_Z_input1));
+ GammaScalingHistogramm(ESD_Conversion_Mapping_Phi_in_Z_input1[iZ],normFacRec_input1);
+ ESD_Conversion_Mapping_Phi_in_Z_input1[iZ]->Rebin(rebin);
+ }
+
+ TH1F *ESD_Conversion_Mapping_R_in_Z_input1[NbinsZ];
+ Char_t histoname_R_in_Z_input1[100];
+ for(Int_t iZ = 0; iZ < NbinsZ; iZ++){
+ sprintf(histoname_R_in_Z_input1,"ESD_Conversion_Mapping_R_in_Z_%02d",iZ);
+ ESD_Conversion_Mapping_R_in_Z_input1[iZ] = dynamic_cast<TH1F*>(fMappingContainer_input1->FindObject(histoname_R_in_Z_input1));
+ GammaScalingHistogramm(ESD_Conversion_Mapping_R_in_Z_input1[iZ],normFacRec_input1);
+ ESD_Conversion_Mapping_R_in_Z_input1[iZ]->Rebin(rebin);
+ }
+
+ // Middle Pt
+ TH1F *ESD_Conversion_Mapping_MidPt_Phi_in_R_input1[NbinsR];
+ Char_t histoname_MidPt_Phi_in_R_input1[100];
+ for(Int_t iR = 0; iR < NbinsR; iR++){
+ sprintf(histoname_MidPt_Phi_in_R_input1,"ESD_Conversion_Mapping_MidPt_Phi_in_R_%02d",iR);
+ ESD_Conversion_Mapping_MidPt_Phi_in_R_input1[iR] = dynamic_cast<TH1F*>(fMappingContainer_input1->FindObject(histoname_MidPt_Phi_in_R_input1));
+ GammaScalingHistogramm(ESD_Conversion_Mapping_MidPt_Phi_in_R_input1[iR],normFacRec_input1);
+ ESD_Conversion_Mapping_MidPt_Phi_in_R_input1[iR] ->Rebin(rebin);
+ }
+
+ TH1F *ESD_Conversion_Mapping_MidPt_Z_in_R_input1[NbinsR];
+ Char_t histoname_MidPt_Z_in_R_input1[100];
+ for(Int_t iR = 0; iR < NbinsR; iR++){
+ sprintf(histoname_MidPt_Z_in_R_input1,"ESD_Conversion_Mapping_MidPt_Z_in_R_%02d",iR);
+ ESD_Conversion_Mapping_MidPt_Z_in_R_input1[iR] = dynamic_cast<TH1F*>(fMappingContainer_input1->FindObject(histoname_MidPt_Z_in_R_input1));
+ GammaScalingHistogramm(ESD_Conversion_Mapping_MidPt_Z_in_R_input1[iR],normFacRec_input1);
+ ESD_Conversion_Mapping_MidPt_Z_in_R_input1[iR] ->Rebin(rebin);
+ }
+
+ TH1F *ESD_Conversion_Mapping_MidPt_Phi_in_Z_input1[NbinsZ];
+ Char_t histoname_MidPt_Phi_in_Z_input1[100];
+ for(Int_t iZ = 0; iZ < NbinsZ; iZ++){
+ sprintf(histoname_MidPt_Phi_in_Z_input1,"ESD_Conversion_Mapping_MidPt_Phi_in_Z_%02d",iZ);
+ ESD_Conversion_Mapping_MidPt_Phi_in_Z_input1[iZ] = dynamic_cast<TH1F*>(fMappingContainer_input1->FindObject(histoname_MidPt_Phi_in_Z_input1));
+ GammaScalingHistogramm(ESD_Conversion_Mapping_MidPt_Phi_in_Z_input1[iZ],normFacRec_input1);
+ ESD_Conversion_Mapping_MidPt_Phi_in_Z_input1[iZ] ->Rebin(rebin);
+ }
+
+ TH1F *ESD_Conversion_Mapping_MidPt_R_in_Z_input1[NbinsZ];
+ Char_t histoname_MidPt_R_in_Z_input1[100];
+ for(Int_t iZ = 0; iZ < NbinsZ; iZ++){
+ sprintf(histoname_MidPt_R_in_Z_input1,"ESD_Conversion_Mapping_MidPt_R_in_Z_%02d",iZ);
+ ESD_Conversion_Mapping_MidPt_R_in_Z_input1[iZ] = dynamic_cast<TH1F*>(fMappingContainer_input1->FindObject(histoname_MidPt_R_in_Z_input1));
+ GammaScalingHistogramm(ESD_Conversion_Mapping_MidPt_R_in_Z_input1[iZ],normFacRec_input1);
+ ESD_Conversion_Mapping_MidPt_R_in_Z_input1[iZ] ->Rebin(rebin);
+ }
+
+ // ------------------------------------- second file-----------------------------------------------------------
+ TFile *input2 = 0x0 ;
+
+ TH1F *ESD_Conversion_Mapping_Phi_in_R_input2[NbinsR];
+ TH1F *ESD_Conversion_Mapping_Z_in_R_input2[NbinsR];
+ TH1F *ESD_Conversion_Mapping_Phi_in_Z_input2[NbinsZ];
+ TH1F *ESD_Conversion_Mapping_R_in_Z_input2[NbinsZ];
+ TH1F *ESD_Conversion_Mapping_MidPt_Phi_in_R_input2[NbinsR];
+ TH1F *ESD_Conversion_Mapping_MidPt_Z_in_R_input2[NbinsR];
+ TH1F *ESD_Conversion_Mapping_MidPt_Phi_in_Z_input2[NbinsZ];
+ TH1F *ESD_Conversion_Mapping_MidPt_R_in_Z_input2[NbinsZ];
+
+ if(secondinput != ""){
+
+ input2 = new TFile(Form("%s%s",path, secondinput));
+
+ TDirectory *fPWG4GammaConversion_input2 = new TDirectory(); // definition of first folder / list
+ TList *fHistosGammaConversion_input2 = new TList(); // definition of first folder / list
+ TList *fMappingContainer_input2 = new TList(); // definition of following folder / list
+ TList *fESDContainer_input2 = new TList(); // definition of following folder / list
+
+ fPWG4GammaConversion_input2 = (TDirectory*)input2->Get(GammaDirectory);
+ fHistosGammaConversion_input2 = (TList*)fPWG4GammaConversion_input2->Get(GammaList);
+ fMappingContainer_input2 = (TList*)fHistosGammaConversion_input2->FindObject("Mapping histograms");
+ fESDContainer_input2 = (TList*)fHistosGammaConversion_input2->FindObject("ESD histograms");
+
+ TH1F * ESD_NumberOfGoodESDTracks_input2=fESDContainer_input2->FindObject("ESD_NumberOfGoodESDTracksVtx");
+ TH1F *ESD_Conversion_R_input2=fESDContainer_input2->FindObject("ESD_Conversion_R");
+ TH2F *ESD_Conversion_ZR_input2=fESDContainer_input2->FindObject("ESD_Conversion_ZR");
+ TH2F *ESD_Conversion_XY_input2=fESDContainer_input2->FindObject("ESD_Conversion_XY");
+ TH1F *ESD_Conversion_OpeningAngle_input2=fESDContainer_input2->FindObject("ESD_Conversion_OpeningAngle");
+ TH1D *ESD_Conversion_Z_input2=ESD_Conversion_ZR_input2->ProjectionX("ESD_Conversion_Z_input2");
+ TH1F * ESD_NumberOfContributorsVtx_input2=fESDContainer_input2->FindObject("ESD_NumberOfContributorsVtx");
+ TH1F *ScalingDiagramm_input2= fMappingContainer_input2->FindObject("ESD_Conversion_Mapping_Phi_in_R_11");
+
+ ESD_NumberOfContributorsVtx_input2->SetAxisRange(1.,100.);
+ // ESD_NumberOfGoodESDTracks_input2->SetAxisRange(1.,100.);
+
+ Float_t Scaling_input2 = ScalingDiagramm_input2->Integral();
+ Float_t nGoodEvents_input2 = ESD_NumberOfContributorsVtx_input2->Integral();
+ Float_t nGoodTrig_input2 = ESD_NumberOfContributorsVtx_input2->GetEntries();
+ Float_t nRecGamma_input2 = ESD_Conversion_R_input2->GetEntries();
+ cout<< secondinput << " Number of events:: " << nGoodEvents_input2 << " Number of triggers:: " << nGoodTrig_input2 << " Number reconstructed gammas:: "<< nRecGamma_input2 <<endl;
+
+ Double_t mean_input2 = ESD_NumberOfGoodESDTracks_input2->GetMean();
+
+ // Float_t normFacRec_input2=1./nGoodEvents_input2;
+ Float_t normFacRec_input2=1./nGoodEvents_input2 * mean_input1/mean_input2;
+
+ //Scaling reconstr.
+ GammaScalingHistogramm(ESD_Conversion_R_input2,normFacRec_input2);
+// GammaScalingHistogramm(ESD_Conversion_ZR_input2,normFacRec_input2);
+// GammaScalingHistogramm(ESD_Conversion_XY_input2,normFacRec_input2);
+ GammaScalingHistogramm(ESD_Conversion_OpeningAngle_input2,normFacRec_input2);
+ GammaScalingHistogramm(ESD_Conversion_Z_input2,normFacRec_input2);
+
+ TH1F *ESD_Conversion_R_summed_input2 = (TH1F*) ESD_Conversion_R_input2->Clone("ESD_Conversion_R_summed_input2");
+ ESD_Conversion_R_summed_input2->Reset();
+ Int_t ConvBinsR = ESD_Conversion_R_input2->GetNbinsX();
+ for(Int_t ConvR = 1; ConvR < ConvBinsR +1; ConvR++){
+ if (ConvR == 1){
+ ESD_Conversion_R_summed_input2->AddBinContent(ConvR, ESD_Conversion_R_input2-> GetBinContent(ConvR));
+ } else {
+ ESD_Conversion_R_summed_input2->AddBinContent(ConvR,(ESD_Conversion_R_summed_input2->GetBinContent(ConvR -1) + ESD_Conversion_R_input2->GetBinContent(ConvR)));
+ }
+ }
+
+ Char_t histoname_Phi_in_R_input2[100];
+ Char_t histoname_Ratio_Phi_in_R_input2[100];
+ TH1F *Ratio_Mapping_Phi_in_R[NbinsR];
+ for(Int_t iR = 0; iR < NbinsR; iR++){
+ sprintf(histoname_Phi_in_R_input2,"ESD_Conversion_Mapping_Phi_in_R_%02d",iR);
+ ESD_Conversion_Mapping_Phi_in_R_input2[iR] = dynamic_cast<TH1F*>(fMappingContainer_input2->FindObject(histoname_Phi_in_R_input2));
+ GammaScalingHistogramm(ESD_Conversion_Mapping_Phi_in_R_input2[iR],normFacRec_input2);
+ ESD_Conversion_Mapping_Phi_in_R_input2[iR]->Rebin(rebin);
+
+ sprintf(histoname_Ratio_Phi_in_R_input2,"Ratio_Mapping_Phi_in_R_%02d",iR);
+ Ratio_Mapping_Phi_in_R[iR]= (TH1F*)ESD_Conversion_Mapping_Phi_in_R_input1[iR]->Clone();
+ Ratio_Mapping_Phi_in_R[iR]->SetName(histoname_Ratio_Phi_in_R_input2);
+ Ratio_Mapping_Phi_in_R[iR]->Divide(Ratio_Mapping_Phi_in_R[iR],ESD_Conversion_Mapping_Phi_in_R_input2[iR]);
+ }
+
+ Char_t histoname_Z_in_R_input2[100];
+ Char_t histoname_Ratio_Z_in_R_input2[100];
+ TH1F *Ratio_Mapping_Z_in_R[NbinsR];
+ for(Int_t iR = 0; iR < NbinsR; iR++){
+ sprintf(histoname_Z_in_R_input2,"ESD_Conversion_Mapping_Z_in_R_%02d",iR);
+ ESD_Conversion_Mapping_Z_in_R_input2[iR] = dynamic_cast<TH1F*>(fMappingContainer_input2->FindObject(histoname_Z_in_R_input2));
+ GammaScalingHistogramm(ESD_Conversion_Mapping_Z_in_R_input2[iR],normFacRec_input2);
+ ESD_Conversion_Mapping_Z_in_R_input2[iR]->Rebin(rebin);
+ sprintf(histoname_Ratio_Z_in_R_input2,"Ratio_Mapping_Z_in_R_%02d",iR);
+ Ratio_Mapping_Z_in_R[iR]= (TH1F*)ESD_Conversion_Mapping_Z_in_R_input1[iR]->Clone();
+ Ratio_Mapping_Z_in_R[iR]->SetName(histoname_Ratio_Z_in_R_input2);
+ Ratio_Mapping_Z_in_R[iR]->Divide(Ratio_Mapping_Z_in_R[iR],ESD_Conversion_Mapping_Z_in_R_input2[iR]);
+ }
+
+ Char_t histoname_Phi_in_Z_input2[100];
+ Char_t histoname_Ratio_Phi_in_Z_input2[100];
+ TH1F *Ratio_Mapping_Phi_in_Z[NbinsZ];
+ for(Int_t iZ = 0; iZ < NbinsZ; iZ++){
+ sprintf(histoname_Phi_in_Z_input2,"ESD_Conversion_Mapping_Phi_in_Z_%02d",iZ);
+ ESD_Conversion_Mapping_Phi_in_Z_input2[iZ] = dynamic_cast<TH1F*>(fMappingContainer_input2->FindObject(histoname_Phi_in_Z_input2));
+ GammaScalingHistogramm(ESD_Conversion_Mapping_Phi_in_Z_input2[iZ],normFacRec_input2);
+ ESD_Conversion_Mapping_Phi_in_Z_input2[iZ] ->Rebin(rebin);
+ sprintf(histoname_Ratio_Phi_in_Z_input2,"Ratio_Mapping_Phi_in_Z_%02d",iZ);
+ Ratio_Mapping_Phi_in_Z[iZ]= (TH1F*)ESD_Conversion_Mapping_Phi_in_Z_input1[iZ]->Clone();
+ Ratio_Mapping_Phi_in_Z[iZ]->SetName(histoname_Ratio_Phi_in_Z_input2);
+ Ratio_Mapping_Phi_in_Z[iZ]->Divide(Ratio_Mapping_Phi_in_Z[iZ],ESD_Conversion_Mapping_Phi_in_Z_input2[iZ]);
+ }
+
+ Char_t histoname_R_in_Z_input2[100];
+ Char_t histoname_Ratio_R_in_Z_input2[100];
+ TH1F *Ratio_Mapping_R_in_Z[NbinsZ];
+ for(Int_t iZ = 0; iZ < NbinsZ; iZ++){
+ sprintf(histoname_R_in_Z_input2,"ESD_Conversion_Mapping_R_in_Z_%02d",iZ);
+ ESD_Conversion_Mapping_R_in_Z_input2[iZ] = dynamic_cast<TH1F*>(fMappingContainer_input2->FindObject(histoname_R_in_Z_input2));
+ GammaScalingHistogramm(ESD_Conversion_Mapping_R_in_Z_input2[iZ],normFacRec_input2);
+ ESD_Conversion_Mapping_R_in_Z_input2[iZ] ->Rebin(rebin);
+ sprintf(histoname_Ratio_Phi_in_Z_input2,"Ratio_Mapping_R_in_Z_%02d",iZ);
+ Ratio_Mapping_R_in_Z[iZ]= (TH1F*)ESD_Conversion_Mapping_R_in_Z_input1[iZ]->Clone();
+ Ratio_Mapping_R_in_Z[iZ]->SetName(histoname_Ratio_R_in_Z_input2);
+ Ratio_Mapping_R_in_Z[iZ]->Divide(Ratio_Mapping_R_in_Z[iZ],ESD_Conversion_Mapping_R_in_Z_input2[iZ]);
+ }
+
+ // Middle Pt
+ Char_t histoname_MidPt_Phi_in_R_input2[100];
+ for(Int_t iR = 0; iR < NbinsR; iR++){
+ sprintf(histoname_MidPt_Phi_in_R_input2,"ESD_Conversion_Mapping_MidPt_Phi_in_R_%02d",iR);
+ ESD_Conversion_Mapping_MidPt_Phi_in_R_input2[iR] = dynamic_cast<TH1F*>(fMappingContainer_input2->FindObject(histoname_MidPt_Phi_in_R_input2));
+ GammaScalingHistogramm(ESD_Conversion_Mapping_MidPt_Phi_in_R_input2[iR],normFacRec_input2);
+ ESD_Conversion_Mapping_MidPt_Phi_in_R_input2[iR] ->Rebin(rebin);
+ }
+
+ Char_t histoname_MidPt_Z_in_R_input2[100];
+ for(Int_t iR = 0; iR < NbinsR; iR++){
+ sprintf(histoname_MidPt_Z_in_R_input2,"ESD_Conversion_Mapping_MidPt_Z_in_R_%02d",iR);
+ ESD_Conversion_Mapping_MidPt_Z_in_R_input2[iR] = dynamic_cast<TH1F*>(fMappingContainer_input2->FindObject(histoname_MidPt_Z_in_R_input2));
+ GammaScalingHistogramm(ESD_Conversion_Mapping_MidPt_Z_in_R_input2[iR],normFacRec_input2);
+ ESD_Conversion_Mapping_MidPt_Z_in_R_input2[iR] ->Rebin(rebin);
+ }
+
+ Char_t histoname_MidPt_Phi_in_Z_input2[100];
+ for(Int_t iZ = 0; iZ < NbinsZ; iZ++){
+ sprintf(histoname_MidPt_Phi_in_Z_input2,"ESD_Conversion_Mapping_MidPt_Phi_in_Z_%02d",iZ);
+ ESD_Conversion_Mapping_MidPt_Phi_in_Z_input2[iZ] = dynamic_cast<TH1F*>(fMappingContainer_input2->FindObject(histoname_MidPt_Phi_in_Z_input2));
+ GammaScalingHistogramm(ESD_Conversion_Mapping_MidPt_Phi_in_Z_input2[iZ],normFacRec_input2);
+ ESD_Conversion_Mapping_MidPt_Phi_in_Z_input2[iZ] ->Rebin(rebin);
+ }
+
+ Char_t histoname_MidPt_R_in_Z_input2[100];
+ for(Int_t iZ = 0; iZ < NbinsZ; iZ++){
+ sprintf(histoname_MidPt_R_in_Z_input2,"ESD_Conversion_Mapping_MidPt_R_in_Z_%02d",iZ);
+ ESD_Conversion_Mapping_MidPt_R_in_Z_input2[iZ] = dynamic_cast<TH1F*>(fMappingContainer_input2->FindObject(histoname_MidPt_R_in_Z_input2));
+ GammaScalingHistogramm(ESD_Conversion_Mapping_MidPt_R_in_Z_input2[iZ],normFacRec_input2);
+ ESD_Conversion_Mapping_MidPt_R_in_Z_input2[iZ] ->Rebin(rebin);
+ }
+ }
+ // end second file
+
+
+ // -----------------page 1---------------------------------------------------------------------------
+
+ // plot the ESD histos
+
+ TLine * linePhi = new TLine (-3.2,1,3.2,1);
+ TLine * lineZ = new TLine (-300,1,300,1);
+ TLine * lineR = new TLine (0,1,200,1);
+ linePhi->SetLineColor(2);
+ lineZ->SetLineColor(2);
+ lineR->SetLineColor(2);
+
+ leg1 = new TLegend(0.6,0.82,0.9,0.9);
+ leg1->AddEntry(ESD_Conversion_R_input1,("Data"),"l");
+ if(secondinput != ""){
+ leg1->AddEntry(ESD_Conversion_R_input2,("MC"),"l");}
+ leg1->SetFillColor(0);
+ leg1->SetTextSize(0.04);
+
+
+if (!SinglePlots) {
+ ps_mapping->NewPage();
+// c_0 = new TCanvas("c_0","",200,10,700,1000); // gives the page size
+
+ title0 = new TPaveLabel(0.05,0.92,0.95,0.96,(Form("Input1: %s",input1)));
+ title0->SetFillColor(16);
+ title0->SetTextSize(0.25);
+// title0->Draw();
+
+ if(secondinput != ""){
+ title1 = new TPaveLabel(0.05,0.87,0.95,0.91,(Form("Input2: %s",secondinput)));
+ title1->SetFillColor(16);
+ title1->SetTextSize(0.25);
+// title1->Draw();
+ }
+// c_0->Update();
+
+ // --------------------------------page 2 - R-distributions -----------------------------------
+
+ ps_mapping->NewPage();
+
+ c_R = new TCanvas("c_R","",200,10,700,1000); // gives the page size
+
+ pad_R = new TPad("pad_R","",0.05,0.05,0.95,0.85,0); // gives the size of the histo areas
+ pad_R->SetFillColor(0);
+ pad_R->GetFrame()->SetFillColor(0);
+ pad_R->SetBorderMode(0);
+ pad_R->Divide(2,2);
+ pad_R->Draw();
+
+ title0->Draw(); if(secondinput != ""){title1->Draw();}
+
+ pad_R->cd(1);
+ pad_R->cd(1)->SetLogy(1);
+ if(secondinput == ""){
+ DrawAutoGammaHisto( ESD_Conversion_R_input1,
+ "Conversions R distribution","R [cm]",StandardYAxis,
+ kTRUE, 1.5,0.00001,
+ kFALSE,0. ,0,
+ kTRUE, 0.,180.);
+ }else{
+ DrawAutoGammaHistos( ESD_Conversion_R_input1,
+ ESD_Conversion_R_input2,
+ "Conversions R distribution","R [cm]",StandardYAxis,
+ kTRUE, 1.5,0.00001,
+ kFALSE,0. ,0.,
+ kTRUE, 0.,180.);
+ }
+ for(Int_t i=0; i < 12 ; i++){
+ DrawGammaLines(ArrayRbins[i], ArrayRbins[i], 0.00001,ESD_Conversion_R_input1->GetMaximum());
+ }
+ DrawAliceLogo(right_up [0],right_up[1],right_up[2],right_up[3]);
+
+ pad_R->cd(2);
+ if(secondinput == ""){
+ DrawAutoGammaHisto( ESD_Conversion_R_input1,
+ "Conversions R distribution","R [cm]",StandardYAxis,
+ kFALSE, 1.5,0,
+ kFALSE,0. ,0.,
+ kTRUE, 0.,180.);
+ }else{
+ DrawAutoGammaHistos( ESD_Conversion_R_input1,
+ ESD_Conversion_R_input2,
+ "Conversions R distribution","R [cm] ",StandardYAxis,
+ kFALSE, 1.5,0,
+ kFALSE,0. ,0.,
+ kTRUE, 0.,180.);
+ }
+ for(Int_t i=0; i < 12 ; i++){
+ DrawGammaLines(ArrayRbins[i], ArrayRbins[i], 0.,ESD_Conversion_R_input1->GetMaximum());
+ }
+
+ DrawAliceLogo(right_up [0],right_up[1],right_up[2],right_up[3]);
+
+
+ //----------------------------- Integrated Radius -----------------------
+ pad_R->cd(3);
+ pad_R->cd(3)->SetLogy(1);
+ if(secondinput == ""){
+ DrawAutoGammaHisto( ESD_Conversion_R_summed_input1,
+ "Conversions R distribution","R [cm]","Integrated (0-to-R) #gamma candidates/event scaled by multiplicity",
+ kTRUE, 1.5,0.000001,
+ kFALSE,0. ,0.,
+ kTRUE, 0.,180.);
+ }else{
+ DrawAutoGammaHistos( ESD_Conversion_R_summed_input1,
+ ESD_Conversion_R_summed_input2,
+ "Integrated Radius of Conversion","R [cm] ","Integrated (0-to-R) #gamma candidates/event scaled by multiplicity",
+ kTRUE, 1.5,0.000001,
+ kFALSE,0. ,0.,
+ kTRUE, 0.,180.);
+ }
+ DrawAliceLogo(right_down [0],right_down[1],right_down[2],right_down[3]);
+
+ pad_R->cd(4);
+ pad_R->cd(4)->SetLogy(0);
+ if(secondinput == ""){
+ DrawAutoGammaHisto( ESD_Conversion_R_summed_input1,
+ "Conversions R distribution","R [cm]","Integrated (0-to-R) #gamma candidates/event scaled by multiplicity",
+ kTRUE, 1.5,0,
+ kFALSE,0. ,0.,
+ kTRUE, 0.,180.);
+ }else{
+ DrawAutoGammaHistos( ESD_Conversion_R_summed_input1,
+ ESD_Conversion_R_summed_input2,
+ "Integrated Radius of Conversion","R [cm] ","Integrated (0-to-R) #gamma candidates/event scaled by multiplicity",
+ kTRUE, 1.5,0,
+ kFALSE,0. ,0.,
+ kTRUE, 0.,180.);
+ }
+ DrawAliceLogo(left_up [0],left_up[1],left_up[2],left_up[3]);
+
+ pad_R->Update();
+
+ //--------------------------- Page 3 - Z-Distributions -----------------------------------------------
+ ps_mapping->NewPage();
+
+ c_Z = new TCanvas("c_Z","",200,10,700,1000); // gives the page size
+
+ pad_Z = new TPad("pad_Z","",0.05,0.05,0.95,0.85,0); // gives the size of the histo areas
+ pad_Z->SetFillColor(0);
+ pad_Z->GetFrame()->SetFillColor(0);
+ pad_Z->SetBorderMode(0);
+ pad_Z->Divide(2,2);
+ pad_Z->Draw();
+
+ title0->Draw(); if(secondinput != ""){title1->Draw();}
+
+ pad_Z->cd(1);
+ pad_Z->cd(1)->SetLogy(1);
+ if(secondinput == ""){
+ DrawAutoGammaHisto( ESD_Conversion_Z_input1
+ "Conversions Z distribution","Z [cm]",StandardYAxis,
+ kTRUE, 1.5,0.00001,
+ kFALSE,0. ,0,
+ kTRUE, -201.,201.);
+ }else{
+ DrawAutoGammaHistos( ESD_Conversion_Z_input1,
+ ESD_Conversion_Z_input2,
+ "Conversions Z distribution","Z [cm] ",StandardYAxis,
+ kTRUE, 1.5,0.00001,
+ kFALSE,0. ,0.,
+ kTRUE, -201.,201.);
+ }
+ for(Int_t i=0; i < 12 ; i++){
+ DrawGammaLines(ArrayZbins[i], ArrayZbins[i], 0.00001,ESD_Conversion_Z_input1->GetMaximum());
+ }
+ DrawAliceLogo(right_up [0],right_up[1],right_up[2],right_up[3]);
+ pad_Z->cd(2);
+ pad_Z->cd(2)->SetLogy(0);
+ if(secondinput == ""){
+ DrawAutoGammaHisto( ESD_Conversion_Z_input1
+ "Conversions Z distribution","Z [cm]",StandardYAxis,
+ kTRUE, 1.5,0.00001,
+ kFALSE,0. ,0,
+ kTRUE, -201.,201.);
+ }else{
+ DrawAutoGammaHistos( ESD_Conversion_Z_input1,
+ ESD_Conversion_Z_input2,
+ "Conversions Z distribution","Z [cm] ",StandardYAxis,
+ kTRUE, 1.5,0.00001,
+ kFALSE,0. ,0.,
+ kTRUE, -201.,201.);
+ }
+ for(Int_t i=0; i < 12 ; i++){
+ DrawGammaLines(ArrayZbins[i], ArrayZbins[i], 0.00001,ESD_Conversion_Z_input1->GetMaximum());
+ }
+ DrawAliceLogo(right_up [0],right_up[1],right_up[2],right_up[3]);
+
+ pad_Z->Update();
+
+
+ // --------------------------------page 4 - 2 Dimensional Plots-----------------------------------
+
+ //hier
+
+ ps_mapping->NewPage();
+
+ c_2dims = new TCanvas("c_2dims","",200,10,700,1000); // gives the page size
+
+ pad_2dims = new TPad("pad_2dims","",0.05,0.05,0.95,0.85,0); // gives the size of the histo areas
+ pad_2dims->SetFillColor(0);
+ pad_2dims->GetFrame()->SetFillColor(0);
+ pad_2dims->SetBorderMode(0);
+ pad_2dims->Divide(2,2);
+ pad_2dims->Draw();
+
+ title0->Draw(); if(secondinput != ""){title1->Draw();}
+
+ pad_2dims->cd(1)->SetRightMargin(RightMargin);
+ pad_2dims->cd(1);
+ pad_2dims->cd(1)->SetLogz(1);
+ DrawAutoGammaHisto2D( ESD_Conversion_ZR_input1,
+ "Conversion in ZR- input 1", "Z [cm]", "R [cm]", "Data",
+ kTRUE, 0., 200.,
+ kFALSE, 0., 20.);
+ DrawAliceLogo(right_up2D [0],right_up2D[1],right_up2D[2],right_up2D[3]);
+ pad_2dims->cd(2)->SetRightMargin(RightMargin);
+ pad_2dims->cd(2);
+ pad_2dims->cd(2)->SetLogz(1);
+ DrawAutoGammaHisto2D( ESD_Conversion_XY_input1,
+ "Conversion in XY- input 1", "X [cm]", "Y [cm]", "Data",
+ kTRUE, -180., 180.,
+ kTRUE, -180., 180.);
+ DrawAliceLogo(right_up2D [0],right_up2D[1],right_up2D[2],right_up2D[3]);
+
+ if(secondinput != ""){
+ pad_2dims->cd(3)->SetRightMargin(RightMargin);
+ pad_2dims->cd(3);
+ pad_2dims->cd(3)->SetLogz(1);
+ DrawAutoGammaHisto2D( ESD_Conversion_ZR_input2,
+ "Conversion in ZR- input 2", "Z [cm]", "R [cm]", "MC",
+ kTRUE, 0., 200.,
+ kFALSE, 0., 20.);
+ DrawAliceLogo(right_up2D [0],right_up2D[1],right_up2D[2],right_up2D[3]);
+ pad_2dims->cd(4)->SetRightMargin(RightMargin);
+ pad_2dims->cd(4);
+ pad_2dims->cd(4)->SetLogz(1);
+ DrawAutoGammaHisto2D( ESD_Conversion_XY_input2,
+ "Conversion in XY- input 2", "X [cm]", "Y [cm]", "MC",
+ kTRUE, -180., 180.,
+ kTRUE, -180., 180.);
+ DrawAliceLogo(right_up2D [0],right_up2D[1],right_up2D[2],right_up2D[3]);
+ }
+
+ pad_2dims->Update();
+
+
+ // ----------------------------------- Page 5 - Phi in R -------------------------------------
+ ps_mapping->NewPage();
+
+ c_Phi_in_R = new TCanvas("c_Phi_in_R","",200,10,700,1000); // gives the page size
+
+ pad_Phi_in_R = new TPad("pad_Phi_in_R","",0.05,0.05,0.95,0.85,0); // gives the size of the histo areas
+ pad_Phi_in_R->SetFillColor(0);
+ pad_Phi_in_R->GetFrame()->SetFillColor(0);
+ pad_Phi_in_R->SetBorderMode(0);
+ pad_Phi_in_R->Divide(column,raw);
+ pad_Phi_in_R->Draw();
+
+ title0->Draw();
+ if(secondinput != ""){
+ title1->Draw();
+ }
+
+ Double_t Integ_R_input1[NbinsR];
+ Double_t Integ_R_input2[NbinsR];
+
+ for(Int_t iR = 0; iR < NbinsR; iR++){
+ Int_t place = iR + 1;
+
+ pad_Phi_in_R->cd(place);
+ pad_Phi_in_R->cd(place)->SetLogy(1);
+ sprintf(histoname_Phi_in_R_input1,"ESD_Conversion_Mapping_Phi_in_R_iR%02d",iR);
+ if(secondinput == ""){
+ DrawAutoGammaHisto( ESD_Conversion_Mapping_Phi_in_R_input1[iR],
+ histoname_Phi_in_R_input1,"#Phi",StandardYAxis,
+ kTRUE,3 ,0.000001,
+ kFALSE,0. ,0.,
+ kFALSE, 0.,180.);
+ }else{
+ DrawAutoGammaHistos( ESD_Conversion_Mapping_Phi_in_R_input1[iR],
+ ESD_Conversion_Mapping_Phi_in_R_input2[iR],
+ histoname_Phi_in_R_input1,"#Phi",StandardYAxis,
+ kTRUE,3 ,0.000001,
+ kFALSE,0. ,0.,
+ kFALSE, 0.,180.);
+ Integ_R_input1[iR]=ESD_Conversion_Mapping_Phi_in_R_input1[iR]->Integral() ;
+ Integ_R_input2[iR]=ESD_Conversion_Mapping_Phi_in_R_input2[iR]->Integral() ;
+ }
+ }
+ pad_Phi_in_R->Update();
+
+ //------------------------------ Page 6 - Ratio Phi in R --------------------------------------
+ if(secondinput != ""){ ps_mapping->NewPage();
+
+ c_Ratio_Phi_in_R = new TCanvas("c_Ratio_Phi_in_R","",200,10,700,1000); // gives the page size
+
+ pad_Ratio_Phi_in_R = new TPad("pad_Ratio_Phi_in_R","",0.05,0.05,0.95,0.85,0); // gives the size of the histo areas
+ pad_Ratio_Phi_in_R->SetFillColor(0);
+ pad_Ratio_Phi_in_R->GetFrame()->SetFillColor(0);
+ pad_Ratio_Phi_in_R->SetBorderMode(0);
+ pad_Ratio_Phi_in_R->Divide(column,raw);
+ pad_Ratio_Phi_in_R->Draw();
+
+ title0->Draw();
+ if(secondinput != ""){
+ title1->Draw();
+ }
+
+ for(Int_t iR = 0; iR < NbinsR; iR++){
+ Int_t place = iR + 1;
+
+ pad_Ratio_Phi_in_R->cd(place);
+ pad_Ratio_Phi_in_R->cd(place)->SetLogy(1);
+ sprintf(histoname_Ratio_Phi_in_R_input2,"Ratio_Phi_in_R_iR%02d",iR);
+ if(secondinput != ""){
+ DrawRatioGammaHisto( Ratio_Mapping_Phi_in_R[iR],
+ histoname_Ratio_Phi_in_R_input2,"#Phi","norm Data/norm MC",
+ kFALSE,3 ,0.000001,
+ kTRUE,0.1 ,5.,
+ kFALSE, 0.,180.);
+ linePhi->Draw("same");
+ }
+ }
+ pad_Ratio_Phi_in_R->Update();
+}
+
+
+ //--------------- page 7 - Z in R ---------------------------------------------------
+
+ ps_mapping->NewPage();
+
+ c_Z_in_R = new TCanvas("c_Z_in_R","",200,10,700,1000); // gives the page size
+
+ pad_Z_in_R = new TPad("pad_Z_in_R","",0.05,0.05,0.95,0.85,0); // gives the size of the histo areas
+ pad_Z_in_R->SetFillColor(0);
+ pad_Z_in_R->GetFrame()->SetFillColor(0);
+ pad_Z_in_R->SetBorderMode(0);
+ pad_Z_in_R->Divide(column,raw);
+ pad_Z_in_R->Draw();
+
+ title0->Draw();
+ if(secondinput != ""){title1->Draw();}
+
+ Double_t Integ_ZinR_input1[NbinsR];
+ Double_t Integ_ZinR_input2[NbinsR];
+
+
+ for(Int_t iR = 0; iR < NbinsR; iR++){
+ Int_t place = iR + 1;
+ pad_Z_in_R->cd(place);
+ pad_Z_in_R->cd(place)->SetLogy(1);
+ sprintf(histoname_Z_in_R_input1,"ESD_Conversion_Mapping_Z_in_R_iR%02d",iR);
+ if(secondinput == ""){
+ DrawAutoGammaHisto( ESD_Conversion_Mapping_Z_in_R_input1[iR],
+ histoname_Z_in_R_input1,"Z [cm]",StandardYAxis,
+ kTRUE,3 ,0.00001,
+ kFALSE,0. ,0.,
+ kFALSE, 0.,180.);
+ }else{
+ DrawAutoGammaHistos( ESD_Conversion_Mapping_Z_in_R_input1[iR],
+ ESD_Conversion_Mapping_Z_in_R_input2[iR],
+ histoname_Z_in_R_input1,"Z [cm]",StandardYAxis,
+ kTRUE,3 ,0.00001,
+ kFALSE,0. ,0.,
+ kFALSE, 0.,180.);
+ Integ_ZinR_input1[iR]=ESD_Conversion_Mapping_Z_in_R_input1[iR]->Integral() ;
+ Integ_ZinR_input2[iR]=ESD_Conversion_Mapping_Z_in_R_input2[iR]->Integral() ;
+ }
+ }
+
+ pad_Z_in_R->Update();
+
+ //------------------------------ Page 8 - Ratio Z in R --------------------------------------
+ if(secondinput != ""){ ps_mapping->NewPage();
+
+ c_Ratio_Z_in_R = new TCanvas("c_Ratio_Z_in_R","",200,10,700,1000); // gives the page size
+
+ pad_Ratio_Z_in_R = new TPad("pad_Ratio_Z_in_R","",0.05,0.05,0.95,0.85,0); // gives the size of the histo areas
+ pad_Ratio_Z_in_R->SetFillColor(0);
+ pad_Ratio_Z_in_R->GetFrame()->SetFillColor(0);
+ pad_Ratio_Z_in_R->SetBorderMode(0);
+ pad_Ratio_Z_in_R->Divide(column,raw);
+ pad_Ratio_Z_in_R->Draw();
+
+ title0->Draw();
+ if(secondinput != ""){
+ title1->Draw();
+ }
+
+ for(Int_t iR = 0; iR < NbinsR; iR++){
+ Int_t place = iR + 1;
+
+ pad_Ratio_Z_in_R->cd(place);
+ pad_Ratio_Z_in_R->cd(place)->SetLogy(1);
+ sprintf(histoname_Ratio_Z_in_R_input2,"Ratio_Z_in_R_iR%02d",iR);
+ if(secondinput != ""){
+ Float_t ZRange = RangeZinR[iR];
+ DrawRatioGammaHisto( Ratio_Mapping_Z_in_R[iR],
+ histoname_Ratio_Z_in_R_input2,"Z","norm Data/norm MC",
+ kFALSE,3 ,0.000001,
+ kTRUE,0.1 ,5.,
+ kTRUE, -ZRange,ZRange);
+ DrawGammaLines(-ZRange,ZRange,1,1);
+ }
+ }
+
+ pad_Ratio_Z_in_R->Update();
+}
+
+
+
+ //---------page 9 - Phi in Z --------------------------------
+
+ ps_mapping->NewPage();
+
+
+ c_Phi_in_Z = new TCanvas("c_Phi_in_Z","",200,10,700,1000); // gives the page size
+
+ pad_Phi_in_Z = new TPad("pad_Phi_in_Z","",0.05,0.05,0.95,0.85,0); // gives the size of the histo areas
+ pad_Phi_in_Z->SetFillColor(0);
+ pad_Phi_in_Z->GetFrame()->SetFillColor(0);
+ pad_Phi_in_Z->SetBorderMode(0);
+ pad_Phi_in_Z->Divide(column,raw);
+ pad_Phi_in_Z->Draw();
+
+ title0->Draw(); if(secondinput != ""){title1->Draw();}
+
+ Double_t Integ_Z_input1[NbinsZ];
+ Double_t Integ_Z_input2[NbinsZ];
+
+ for(Int_t iZ = 0; iZ < NbinsZ; iZ++){
+ Int_t place = iZ + 1;
+ pad_Phi_in_Z->cd(place);
+ pad_Phi_in_Z->cd(place)->SetLogy(1);
+ sprintf(histoname_Phi_in_Z_input1,"ESD_Conversion_Mapping_Phi_in_Z_iZ%02d",iZ);
+ if(secondinput == ""){
+ DrawAutoGammaHisto( ESD_Conversion_Mapping_Phi_in_Z_input1[iZ],
+ histoname_Phi_in_Z_input1,"#Phi",StandardYAxis,
+ kTRUE,3 ,0.000001,
+ kFALSE,0. ,0.,
+ kFALSE, 0.,180.);
+ }else{
+ DrawAutoGammaHistos( ESD_Conversion_Mapping_Phi_in_Z_input1[iZ],
+ ESD_Conversion_Mapping_Phi_in_Z_input2[iZ],
+ histoname_Phi_in_Z_input1,"#Phi",StandardYAxis,
+ kTRUE,3 ,0.000001,
+ kFALSE,0. ,0.,
+ kFALSE, 0.,180.);
+ Integ_Z_input1[iZ]=ESD_Conversion_Mapping_Phi_in_Z_input1[iZ]->Integral() ;
+ Integ_Z_input2[iZ]=ESD_Conversion_Mapping_Phi_in_Z_input2[iZ]->Integral() ;
+ }
+ }
+
+ pad_Phi_in_Z->Update();
+
+ //------------------------------------- Page 10 - Ratio Phi in Z -----------------------------------
+
+ if(secondinput != ""){ ps_mapping->NewPage();
+
+ c_Ratio_Phi_in_Z = new TCanvas("c_Ratio_Phi_in_Z","",200,10,700,1000); // gives the page size
+
+ pad_Ratio_Phi_in_Z = new TPad("pad_Ratio_Phi_in_Z","",0.05,0.05,0.95,0.85,0); // gives the size of the histo areas
+ pad_Ratio_Phi_in_Z->SetFillColor(0);
+ pad_Ratio_Phi_in_Z->GetFrame()->SetFillColor(0);
+ pad_Ratio_Phi_in_Z->SetBorderMode(0);
+ pad_Ratio_Phi_in_Z->Divide(column,raw);
+ pad_Ratio_Phi_in_Z->Draw();
+
+ title0->Draw();
+ if(secondinput != ""){
+ title1->Draw();
+ }
+
+ for(Int_t iZ = 0; iZ < NbinsZ; iZ++){
+ Int_t place = iZ + 1;
+
+ pad_Ratio_Phi_in_Z->cd(place);
+ pad_Ratio_Phi_in_Z->cd(place)->SetLogy(1);
+ sprintf(histoname_Ratio_Phi_in_Z_input2,"Ratio_Phi_in_Z_iZ%02d",iZ);
+ if(secondinput != ""){
+ DrawRatioGammaHisto( Ratio_Mapping_Phi_in_Z[iZ],
+ histoname_Ratio_Phi_in_Z_input2,"#Phi","norm Data/norm MC",
+ kFALSE,3 ,0.000001,
+ kTRUE,0.1 ,5.,
+ kFALSE, 0,0);
+ linePhi->Draw("same");
+ }
+ }
+
+ pad_Ratio_Phi_in_Z->Update();
+}
+
+ //---------------page 11 - R in Z ---------------------------------------------------
+
+ ps_mapping->NewPage();
+
+ c_R_in_Z = new TCanvas("c_R_in_Z","",200,10,700,1000); // gives the page size
+
+ pad_R_in_Z = new TPad("pad_R_in_Z","",0.05,0.05,0.95,0.85,0); // gives the size of the histo areas
+ pad_R_in_Z->SetFillColor(0);
+ pad_R_in_Z->GetFrame()->SetFillColor(0);
+ pad_R_in_Z->SetBorderMode(0);
+ pad_R_in_Z->Divide(column,raw);
+ pad_R_in_Z->Draw();
+
+ title0->Draw(); if(secondinput != ""){title1->Draw();}
+
+ Double_t Integ_RinZ_input1[NbinsZ];
+ Double_t Integ_RinZ_input2[NbinsZ];
+
+ for(Int_t iZ = 0; iZ < NbinsZ; iZ++){
+ Int_t place = iZ + 1;
+ pad_R_in_Z->cd(place);
+ pad_R_in_Z->cd(place)->SetLogy(1);
+ sprintf(histoname_R_in_Z_input1,"ESD_Conversion_Mapping_R_in_Z_iZ%02d",iZ);
+ if(secondinput == ""){
+ DrawAutoGammaHisto( ESD_Conversion_Mapping_R_in_Z_input1[iZ],
+ histoname_R_in_Z_input1,"R [cm]",StandardYAxis,
+ kTRUE,3 ,0.000001,
+ kFALSE,0. ,0.,
+ kFALSE, 0.,180.);
+ }else{
+ DrawAutoGammaHistos( ESD_Conversion_Mapping_R_in_Z_input1[iZ],
+ ESD_Conversion_Mapping_R_in_Z_input2[iZ],
+ histoname_R_in_Z_input1,"R [cm]",StandardYAxis,
+ kTRUE,3 ,0.000001,
+ kFALSE,0. ,0.,
+ kFALSE, 0.,180.);
+ Integ_RinZ_input1[iZ]=ESD_Conversion_Mapping_R_in_Z_input1[iZ]->Integral() ;
+ Integ_RinZ_input2[iZ]=ESD_Conversion_Mapping_R_in_Z_input2[iZ]->Integral() ;
+ }
+ }
+ pad_R_in_Z->Update();
+
+ //------------------------------ Page 12 - Ratio R in Z --------------------------------------
+ if(secondinput != ""){ ps_mapping->NewPage();
+
+ c_Ratio_R_in_Z = new TCanvas("c_Ratio_R_in_Z","",200,10,700,1000); // gives the page size
+
+ pad_Ratio_R_in_Z = new TPad("pad_Ratio_R_in_Z","",0.05,0.05,0.95,0.85,0); // gives the size of the histo areas
+ pad_Ratio_R_in_Z->SetFillColor(0);
+ pad_Ratio_R_in_Z->GetFrame()->SetFillColor(0);
+ pad_Ratio_R_in_Z->SetBorderMode(0);
+ pad_Ratio_R_in_Z->Divide(column,raw);
+ pad_Ratio_R_in_Z->Draw();
+
+ title0->Draw();
+ if(secondinput != ""){
+ title1->Draw();
+ }
+
+ for(Int_t iZ = 0; iZ < NbinsZ; iZ++){
+ Int_t place = iZ + 1;
+
+ pad_Ratio_R_in_Z->cd(place);
+ pad_Ratio_R_in_Z->cd(place)->SetLogy(1);
+ sprintf(histoname_Ratio_R_in_Z_input2,"Ratio_R_in_Z_iZ%02d",iZ);
+ if(secondinput != ""){
+ DrawRatioGammaHisto( Ratio_Mapping_R_in_Z[iZ],
+ histoname_Ratio_R_in_Z_input2,"R [cm]","norm Data/norm MC",
+ kFALSE,3 ,0.000001,
+ kTRUE,0.1 ,5.,
+ kFALSE, 0,0);
+ lineR->Draw("same");
+ }
+ }
+
+ pad_Ratio_R_in_Z->Update();
+}
+
+ // --------------------page 13 - MidPt Phi in R-------------------------------------------------------------
+
+
+ ps_mapping->NewPage();
+
+
+ c_MidPt_Phi_in_R = new TCanvas("c_MidPt_Phi_in_R","",200,10,700,1000); // gives the page size
+
+ pad_MidPt_Phi_in_R = new TPad("pad_MidPt_Phi_in_R","",0.05,0.05,0.95,0.85,0); // gives the size of the histo areas
+ pad_MidPt_Phi_in_R->SetFillColor(0);
+ pad_MidPt_Phi_in_R->GetFrame()->SetFillColor(0);
+ pad_MidPt_Phi_in_R->SetBorderMode(0);
+ pad_MidPt_Phi_in_R->Divide(column,raw);
+ pad_MidPt_Phi_in_R->Draw();
+
+ title0->Draw(); if(secondinput != ""){title1->Draw();}
+
+ Double_t Integ_midpt_R_input1[NbinsR];
+ Double_t Integ_midpt_R_input2[NbinsR];
+
+ for(Int_t iR = 0; iR < NbinsR; iR++){
+ Int_t place = iR + 1;
+ pad_MidPt_Phi_in_R->cd(place);
+ pad_MidPt_Phi_in_R->cd(place)->SetLogy(1);
+ sprintf(histoname_MidPt_Phi_in_R_input1,"ESD_Conversion_Mapping_MidPt_Phi_in_R_iR%02d",iR);
+ if(secondinput == ""){
+ DrawAutoGammaHisto( ESD_Conversion_Mapping_MidPt_Phi_in_R_input1[iR],
+ histoname_MidPt_Phi_in_R_input1,"#Phi",StandardYAxis,
+ kTRUE,3 ,0.000001,
+ kFALSE,0. ,0.,
+ kFALSE, 0.,180.);
+ }else{
+ DrawAutoGammaHistos(ESD_Conversion_Mapping_MidPt_Phi_in_R_input1[iR],
+ ESD_Conversion_Mapping_MidPt_Phi_in_R_input2[iR],
+ histoname_MidPt_Phi_in_Z_input1,"#Phi",StandardYAxis,
+ kTRUE,3 ,0.000001,
+ kFALSE,0. ,0.,
+ kFALSE, 0.,180.);
+ Integ_midpt_R_input1[iR]=ESD_Conversion_Mapping_MidPt_Phi_in_R_input1[iR]->Integral() ;
+ Integ_midpt_R_input2[iR]=ESD_Conversion_Mapping_MidPt_Phi_in_R_input2[iR]->Integral() ;
+ }
+ }
+
+ pad_MidPt_Phi_in_R->Update();
+
+ //---------------------------page 14 - MidPt Z in R ---------------------------------------
+
+ ps_mapping->NewPage();
+
+ c_midpt_Z_in_R = new TCanvas("c_midpt_Z_in_R","",200,10,700,1000); // gives the page size
+
+ pad_midpt_Z_in_R = new TPad("pad_midpt_Z_in_R","",0.05,0.05,0.95,0.85,0); // gives the size of the histo areas
+ pad_midpt_Z_in_R->SetFillColor(0);
+ pad_midpt_Z_in_R->GetFrame()->SetFillColor(0);
+ pad_midpt_Z_in_R->SetBorderMode(0);
+ pad_midpt_Z_in_R->Divide(column,raw);
+ pad_midpt_Z_in_R->Draw();
+
+ title0->Draw(); if(secondinput != ""){title1->Draw();}
+
+ Double_t Integ_midpt_ZinR_input1[NbinsR];
+ Double_t Integ_midpt_ZinR_input2[NbinsR];
+
+
+
+ for(Int_t iR = 0; iR < NbinsR; iR++){
+ Int_t place = iR + 1;
+ pad_midpt_Z_in_R->cd(place);
+ pad_midpt_Z_in_R->cd(place)->SetLogy(1);
+ sprintf(histoname_MidPt_Z_in_R_input1,"ESD_Conversion_Mapping_MidPt_Z_in_R_iR%02d",iR);
+ if(secondinput == ""){
+ DrawAutoGammaHisto( ESD_Conversion_Mapping_MidPt_Z_in_R_input1[iR],
+ histoname_MidPt_Z_in_R_input1,"Z [cm]",StandardYAxis,
+ kTRUE,3 ,0.000001,
+ kFALSE,0. ,0.,
+ kFALSE, 0.,180.);
+ }else{
+ DrawAutoGammaHistos(ESD_Conversion_Mapping_MidPt_Z_in_R_input1[iR],
+ ESD_Conversion_Mapping_MidPt_Z_in_R_input2[iR],
+ histoname_MidPt_Z_in_R_input1,"Z [cm]",StandardYAxis,
+ kTRUE,3 ,0.000001,
+ kFALSE,0. ,0.,
+ kFALSE, 0.,180.);
+ Integ_midpt_ZinR_input1[iR]=ESD_Conversion_Mapping_MidPt_Z_in_R_input1[iR]->Integral() ;
+ Integ_midpt_ZinR_input2[iR]=ESD_Conversion_Mapping_MidPt_Z_in_R_input2[iR]->Integral() ;
+ }
+ }
+
+ pad_midpt_Z_in_R->Update();
+
+
+ //---------------------page 15 - MidPt Phi in Z--------------------
+
+ if(!SinglePlots)ps_mapping->NewPage();
+
+
+ c_MidPt_Phi_in_Z = new TCanvas("c_MidPt_Phi_in_Z","",200,10,700,1000); // gives the page size
+
+ pad_MidPt_Phi_in_Z = new TPad("pad_MidPt_Phi_in_Z","",0.05,0.05,0.95,0.85,0); // gives the size of the histo areas
+ pad_MidPt_Phi_in_Z->SetFillColor(0);
+ pad_MidPt_Phi_in_Z->GetFrame()->SetFillColor(0);
+ pad_MidPt_Phi_in_Z->SetBorderMode(0);
+ pad_MidPt_Phi_in_Z->Divide(column,raw);
+ pad_MidPt_Phi_in_Z->Draw();
+
+ title0->Draw(); if(secondinput != ""){title1->Draw();}
+
+ Double_t Integ_midpt_Z_input1[NbinsZ];
+ Double_t Integ_midpt_Z_input2[NbinsZ];
+
+ for(Int_t iZ = 0; iZ < NbinsZ; iZ++){
+ Int_t place = iZ + 1;
+ pad_MidPt_Phi_in_Z->cd(place);
+ pad_MidPt_Phi_in_Z->cd(place)->SetLogy(1);
+ sprintf(histoname_MidPt_Phi_in_Z_input1,"ESD_Conversion_Mapping_MidPt_Phi_in_Z_iR%02d",iR);
+ if(secondinput == ""){
+ DrawAutoGammaHisto( ESD_Conversion_Mapping_MidPt_Phi_in_Z_input1[iZ],
+ histoname_MidPt_Phi_in_Z_input1,"#Phi",StandardYAxis,
+ kTRUE,3 ,0.000001,
+ kFALSE,0. ,0.,
+ kFALSE, 0.,180.);
+ }else{
+ DrawAutoGammaHistos(ESD_Conversion_Mapping_MidPt_Phi_in_Z_input1[iZ],
+ ESD_Conversion_Mapping_MidPt_Phi_in_Z_input2[iZ],
+ histoname_MidPt_Phi_in_Z_input1,"#Phi",StandardYAxis,
+ kTRUE,3 ,0.000001,
+ kFALSE,0. ,0.,
+ kFALSE, 0.,180.);
+ Integ_midpt_Z_input1[iZ]=ESD_Conversion_Mapping_MidPt_Phi_in_Z_input1[iZ]->Integral() ;
+ Integ_midpt_Z_input2[iZ]=ESD_Conversion_Mapping_MidPt_Phi_in_Z_input2[iZ]->Integral() ;
+ }
+ }
+ pad_MidPt_Phi_in_Z->Update();
+
+ //---------------------------page 16 - MidPt R in Z ---------------------------------------
+
+ if(!SinglePlots)ps_mapping->NewPage();
+
+ c_MidPt_R_in_Z = new TCanvas("c_MidPt_R_in_Z","",200,10,700,1000); // gives the page size
+
+ pad_MidPt_R_in_Z = new TPad("pad_MidPt_R_in_Z","",0.05,0.05,0.95,0.85,0); // gives the size of the histo areas
+ pad_MidPt_R_in_Z->SetFillColor(0);
+ pad_MidPt_R_in_Z->GetFrame()->SetFillColor(0);
+ pad_MidPt_R_in_Z->SetBorderMode(0);
+ pad_MidPt_R_in_Z->Divide(column,raw);
+ pad_MidPt_R_in_Z->Draw();
+
+ title0->Draw(); if(secondinput != ""){title1->Draw();}
+
+ Double_t Integ_midpt_RinZ_input1[NbinsZ];
+ Double_t Integ_midpt_RinZ_input2[NbinsZ];
+
+ for(Int_t iZ = 0; iZ < NbinsZ; iZ++){
+ Int_t place = iZ + 1;
+ pad_MidPt_R_in_Z->cd(place);
+ pad_MidPt_R_in_Z->cd(place)->SetLogy(1);
+ sprintf(histoname_MidPt_R_in_Z_input1,"ESD_Conversion_Mapping_MidPt_R_in_Z_iR%02d",iR);
+ if(secondinput == ""){
+ DrawAutoGammaHisto( ESD_Conversion_Mapping_MidPt_R_in_Z_input1[iZ],
+ histoname_MidPt_R_in_Z_input1,"R [cm]",StandardYAxis,
+ kTRUE,3 ,0.000001,
+ kFALSE,0. ,0.,
+ kFALSE, 0.,180.);
+ }else{
+ DrawAutoGammaHistos(ESD_Conversion_Mapping_MidPt_R_in_Z_input1[iZ],
+ ESD_Conversion_Mapping_MidPt_R_in_Z_input2[iZ],
+ histoname_MidPt_R_in_Z_input1,"R [cm]",StandardYAxis,
+ kTRUE,3 ,0.000001,
+ kFALSE,0. ,0.,
+ kFALSE, 0.,180.);
+ Integ_midpt_RinZ_input1[iZ]=ESD_Conversion_Mapping_MidPt_R_in_Z_input1[iZ]->Integral() ;
+ Integ_midpt_RinZ_input2[iZ]=ESD_Conversion_Mapping_MidPt_R_in_Z_input2[iZ]->Integral() ;
+ }
+ }
+ pad_MidPt_R_in_Z->Update();
+
+ if(secondinput != ""){
+ Double_t Sum_phi_in_R_input1 = 0., Sum_phi_in_Z_input1 =0., Sum_midpt_phi_in_R_input1 = 0., Sum_midpt_phi_in_Z_input1= 0.;
+ Double_t Sum_phi_in_R_input2 = 0., Sum_phi_in_Z_input2 =0., Sum_midpt_phi_in_R_input2 = 0., Sum_midpt_phi_in_Z_input2= 0.;
+ Double_t Sum_Z_in_R_input1 = 0., Sum_R_in_Z_input1 =0., Sum_midpt_Z_in_R_input1 = 0., Sum_midpt_R_in_Z_input1= 0.;
+ Double_t Sum_Z_in_R_input2 = 0., Sum_R_in_Z_input2 =0., Sum_midpt_Z_in_R_input2 = 0., Sum_midpt_R_in_Z_input2= 0.;
+
+ for(Int_t iR = 0; iR < NbinsR; iR++){
+ Sum_phi_in_R_input1 = Sum_phi_in_R_input1 + Integ_R_input1[iR];
+ Sum_phi_in_R_input2 = Sum_phi_in_R_input2 + Integ_R_input2[iR];
+ Sum_midpt_phi_in_R_input1 = Sum_midpt_phi_in_R_input1 + Integ_midpt_R_input1[iR];
+ Sum_midpt_phi_in_R_input2 = Sum_midpt_phi_in_R_input2 + Integ_midpt_R_input2[iR];
+ Sum_Z_in_R_input1 = Sum_Z_in_R_input1 + Integ_ZinR_input1[iR];
+ Sum_Z_in_R_input2 = Sum_Z_in_R_input2 + Integ_ZinR_input2[iR];
+ Sum_midpt_Z_in_R_input1 = Sum_midpt_Z_in_R_input1 + Integ_midpt_ZinR_input1[iR];
+ Sum_midpt_Z_in_R_input2 = Sum_midpt_Z_in_R_input2 + Integ_midpt_ZinR_input2[iR];
+
+ }
+ for(Int_t iZ = 0; iZ < NbinsZ; iZ++){
+ Sum_phi_in_Z_input1 = Sum_phi_in_Z_input1 + Integ_Z_input1[iZ];
+ Sum_phi_in_Z_input2 = Sum_phi_in_Z_input2 + Integ_Z_input2[iZ];
+ Sum_midpt_phi_in_Z_input1 = Sum_midpt_phi_in_Z_input1 + Integ_midpt_Z_input1[iZ];
+ Sum_midpt_phi_in_Z_input2 = Sum_midpt_phi_in_Z_input2 + Integ_midpt_Z_input2[iZ];
+ Sum_R_in_Z_input1 = Sum_R_in_Z_input1 + Integ_RinZ_input1[iZ];
+ Sum_R_in_Z_input2 = Sum_R_in_Z_input2 + Integ_RinZ_input2[iZ];
+ Sum_midpt_R_in_Z_input1 = Sum_midpt_R_in_Z_input1 + Integ_midpt_RinZ_input1[iZ];
+ Sum_midpt_R_in_Z_input2 = Sum_midpt_R_in_Z_input2 + Integ_midpt_RinZ_input2[iZ];
+ }
+
+ const char *outlname = "Export_Mapping.dat";
+ fstream outl;
+ outl.open(outlname, ios::out);
+ outl << "#Calculating Integrals" << endl;
+ outl << "------------------------------------------------------------------------------------------" << endl;
+ outl << "# This file is created to display the Integrals of the different bins of the different diagrams. The forth column displays the Integral over the input1 in that bin divided by the sum over all bins of input1, the same does the sixth column for input2. The eigth column displays the difference of input1 - input2 divided by input2 of that bin. Therefore you should put the data in the first input and the Montecarlo in the second." << endl;
+ outl << "------------------------------------------------------------------------------------------" << endl;
+
+ outl << "input1 :\t" << input1 << endl;
+ outl << "input2 :\t" << secondinput << endl;
+ outl << "------------------------------------------------------------------------------------------" << endl;
+ outl << endl;
+ outl << "\t input1 \t input2 " << endl;
+ outl << "Number of events" << "\t" << nGoodEvents_input1 << "\t" << nGoodEvents_input2 << endl;
+ outl << "Number of triggers" << "\t" << nGoodTrig_input1 << "\t" << nGoodTrig_input2 << endl;
+ outl << "Number reconstructed gammas"<< "\t" << nRecGamma_input1 << "\t" << nRecGamma_input2 <<endl;
+ outl << "Mean Multiplicity" << "\t" << mean_input1 << "\t" << mean_input2 << endl;
+ outl << endl;
+ outl << endl;
+
+ outl << "------------------------------------------------------------------------------------------" << endl;
+ outl << "graph \t bin \t Input1 \t % \t Input2 \t % \t Input1-Input2 \t %" <<endl;
+
+
+ outl << "Phi in R" <<endl;
+ outl <<"\t0\t" << Integ_R_input1[0] << "\t" << Integ_R_input1[0]/Sum_phi_in_R_input1 * 100 <<"\t" << Integ_R_input2[0] << "\t" << Integ_R_input2[0]/Sum_phi_in_R_input2 * 100 << "\t" << Integ_R_input1[0]- Integ_R_input2[0] << "\t" << (Integ_R_input1[0]- Integ_R_input2[0])/Integ_R_input2[0] *100 << endl;
+ for(Int_t iR = 1; iR < NbinsR; iR++){
+ outl << "\t" << iR << "\t" << Integ_R_input1[iR] << "\t" << Integ_R_input1[iR]/Sum_phi_in_R_input1 * 100 <<"\t" << Integ_R_input2[iR] << "\t" << Integ_R_input2[iR]/Sum_phi_in_R_input2 * 100 << "\t" << Integ_R_input1[iR]- Integ_R_input2[iR] << "\t" << (Integ_R_input1[iR]- Integ_R_input2[iR])/Integ_R_input2[iR]* 100 << endl;
+ }
+ outl << "\t" << "sum" << "\t" << ESD_Conversion_R_input1->Integral() << "\t" << "100" << "\t" << ESD_Conversion_R_input2->Integral() << "\t" << "100" <<"\t" << ESD_Conversion_R_input1->Integral() - ESD_Conversion_R_input2->Integral() << "\t" << (ESD_Conversion_R_input1->Integral()-ESD_Conversion_R_input2->Integral())/ESD_Conversion_R_input2->Integral() *100 << endl;
+ outl << endl;
+
+ outl << "Phi in Z" <<endl;
+// outl <<"\t0\t" << Integ_Z_input1[0] << "\t"<< Integ_Z_input1[0]/Sum_phi_in_Z_input1 * 100 <<"\t" << Integ_Z_input2[0] << "\t" << Integ_Z_input2[0]/Sum_phi_in_Z_input2 * 100 << "\t" << Integ_Z_input1[0]- Integ_Z_input2[0] << "\t" << (Integ_Z_input1[0]- Integ_Z_input2[0])/Integ_Z_input2[0] * 100 << endl;
+ for(Int_t iZ = 1; iZ < NbinsZ; iZ++){
+ outl << "\t" << iZ<< "\t" << Integ_Z_input1[iZ] << "\t" << Integ_Z_input1[iZ]/Sum_phi_in_Z_input1 * 100 <<"\t" << Integ_Z_input2[iZ] << "\t" << Integ_Z_input2[iZ]/Sum_phi_in_Z_input2 * 100 << "\t" << Integ_Z_input1[iZ]- Integ_Z_input2[iZ] << "\t" << (Integ_Z_input1[iZ]- Integ_Z_input2[iZ])/Integ_Z_input2[iZ]*100 << endl;
+ }
+ outl << "\t" << "sum" << "\t" << ESD_Conversion_Z_input1->Integral() << "\t" << "100" << "\t" << ESD_Conversion_Z_input2->Integral() << "\t" << "100" <<"\t" << ESD_Conversion_Z_input1->Integral() - ESD_Conversion_Z_input2->Integral() << "\t" << (ESD_Conversion_Z_input1->Integral()-ESD_Conversion_Z_input2->Integral())/ESD_Conversion_Z_input2->Integral() *100 << endl;
+ outl << endl;
+
+ outl << "MidPt Phi in R" <<endl;
+ outl <<" \t0\t" << Integ_midpt_R_input1[0] << "\t" << Integ_midpt_R_input1[0]/Sum_midpt_phi_in_R_input1 * 100 <<"\t" << Integ_midpt_R_input2[0] << "\t" << Integ_midpt_R_input2[0]/Sum_midpt_phi_in_R_input2 * 100 << "\t" << Integ_midpt_R_input1[0]- Integ_midpt_R_input2[0] << "\t" << (Integ_midpt_R_input1[0]- Integ_midpt_R_input2[0])/Integ_midpt_R_input2[0]*100 << endl;
+ for(Int_t iR = 1; iR < NbinsR; iR++){
+ outl << "\t" << iR << "\t" << Integ_midpt_R_input1[iR] << "\t" << Integ_midpt_R_input1[iR]/Sum_midpt_phi_in_R_input1 * 100 <<"\t" << Integ_midpt_R_input2[iR] << "\t" << Integ_midpt_R_input2[iR]/Sum_midpt_phi_in_R_input2 * 100 << "\t" << Integ_midpt_R_input1[iR]- Integ_midpt_R_input2[iR] << "\t" << (Integ_midpt_R_input1[iR]- Integ_midpt_R_input2[iR])/Integ_midpt_R_input2[iR] *100 << endl;
+ }
+ outl << "\t" << "sum" << "\t" << Sum_midpt_phi_in_R_input1 << "\t" << "100" << "\t" << Sum_midpt_phi_in_R_input2 << "\t" << "100" <<"\t" << Sum_midpt_phi_in_R_input1 - Sum_midpt_phi_in_R_input2 << "\t" << (Sum_midpt_phi_in_R_input1-Sum_midpt_phi_in_R_input2)/Sum_midpt_phi_in_R_input2 *100 << endl;
+
+ outl << endl;
+
+ outl << "MidPt Phi in Z" <<endl;
+// outl <<" \t0\t" << Integ_midpt_Z_input1[0] << "\t"<< Integ_midpt_Z_input1[0]/Sum_midpt_phi_in_Z_input1 * 100 <<"\t" << Integ_midpt_Z_input2[0] << "\t" << Integ_midpt_Z_input2[0]/Sum_midpt_phi_in_Z_input2 * 100 << "\t" << Integ_midpt_Z_input1[0]- Integ_midpt_Z_input2[0] << "\t" << (Integ_midpt_Z_input1[0]- Integ_midpt_Z_input2[0])/Integ_midpt_Z_input2[0] *100<< endl;
+ for(Int_t iZ = 1; iZ < NbinsZ; iZ++){
+ outl << "\t" << iZ << "\t" << Integ_midpt_Z_input1[iZ] << "\t" << Integ_midpt_Z_input1[iZ]/Sum_midpt_phi_in_Z_input1 * 100 <<"\t" << Integ_midpt_Z_input2[iZ] << "\t" << Integ_midpt_Z_input2[iZ]/Sum_midpt_phi_in_Z_input2 * 100 << "\t" << Integ_midpt_Z_input1[iZ]- Integ_midpt_Z_input2[iZ] << "\t" << (Integ_midpt_Z_input1[iZ]- Integ_midpt_Z_input2[iZ])/Integ_midpt_Z_input2[iZ] *100 << endl;
+ }
+ outl << "\t" << "sum" << "\t" << Sum_midpt_phi_in_Z_input1 << "\t" << "100" << "\t" << Sum_midpt_phi_in_Z_input2 << "\t" << "100" <<"\t" << Sum_midpt_phi_in_Z_input1 - Sum_midpt_phi_in_Z_input2 << "\t" << (Sum_midpt_phi_in_Z_input1-Sum_midpt_phi_in_Z_input2)/Sum_midpt_phi_in_Z_input2 *100 << endl;
+ outl << endl;
+
+ outl << "Z in R" <<endl;
+ outl <<" \t0\t" << Integ_ZinR_input1[0] << "\t" << Integ_R_input1[0]/Sum_Z_in_R_input1 * 100 <<"\t" << Integ_ZinR_input2[0] << "\t" << Integ_ZinR_input2[0]/Sum_Z_in_R_input2 * 100 << "\t" << Integ_ZinR_input1[0]- Integ_ZinR_input2[0] << "\t" << (Integ_ZinR_input1[0]- Integ_ZinR_input2[0])/Integ_ZinR_input2[0] *100 << endl;
+ for(Int_t iR = 1; iR < NbinsR; iR++){
+ outl << "\t" << iR << "\t" << Integ_ZinR_input1[iR] << "\t" << Integ_ZinR_input1[iR]/Sum_Z_in_R_input1 * 100 <<"\t" << Integ_ZinR_input2[iR] << "\t" << Integ_ZinR_input2[iR]/Sum_Z_in_R_input2 * 100 << "\t" << Integ_ZinR_input1[iR]- Integ_ZinR_input2[iR] << "\t" << (Integ_ZinR_input1[iR]- Integ_ZinR_input2[iR])/Integ_ZinR_input2[iR]*100 << endl;
+ }
+ outl << "\t" << "sum" << "\t" << ESD_Conversion_R_input1->Integral() << "\t" << "100" << "\t" << ESD_Conversion_R_input2->Integral() << "\t" << "100" <<"\t" << ESD_Conversion_R_input1->Integral() - ESD_Conversion_R_input2->Integral() << "\t" << (ESD_Conversion_R_input1->Integral()-ESD_Conversion_R_input2->Integral())/ESD_Conversion_R_input2->Integral() *100 << endl;
+ outl << endl;
+
+ outl << "R in Z" <<endl;
+// outl <<" \t0\t" << Integ_RinZ_input1[0] << "\t"<< Integ_RinZ_input1[0]/Sum_R_in_Z_input1 * 100 <<"\t" << Integ_RinZ_input2[0] << "\t" << Integ_RinZ_input2[0]/Sum_R_in_Z_input2 * 100 << "\t" << Integ_RinZ_input1[0]- Integ_RinZ_input2[0] << "\t" << (Integ_RinZ_input1[0]- Integ_RinZ_input2[0])/Integ_RinZ_input2[0] * 100 << endl;
+ for(Int_t iZ = 1; iZ < NbinsZ; iZ++){
+ outl << "\t" << iZ<< "\t" << Integ_RinZ_input1[iZ] << "\t" << Integ_RinZ_input1[iZ]/Sum_R_in_Z_input1 * 100 <<"\t" << Integ_RinZ_input2[iZ] << "\t" << Integ_RinZ_input2[iZ]/Sum_R_in_Z_input2 * 100 << "\t" << Integ_RinZ_input1[iZ]- Integ_RinZ_input2[iZ] << "\t" << (Integ_RinZ_input1[iZ]- Integ_RinZ_input2[iZ])/Integ_RinZ_input2[iZ]*100 << endl;
+ }
+ outl << "\t" << "sum" << "\t" << ESD_Conversion_Z_input1->Integral() << "\t" << "100" << "\t" << ESD_Conversion_Z_input2->Integral() << "\t" << "100" <<"\t" << ESD_Conversion_Z_input1->Integral() - ESD_Conversion_Z_input2->Integral() << "\t" << (ESD_Conversion_Z_input1->Integral()-ESD_Conversion_Z_input2->Integral())/ESD_Conversion_Z_input2->Integral() *100 << endl;
+ outl << endl;
+
+ outl << "MidPt Z in R" <<endl;
+ outl <<" \t0\t" << Integ_midpt_ZinR_input1[0] << "\t" << Integ_midpt_ZinR_input1[0]/Sum_midpt_Z_in_R_input1 * 100 <<"\t" << Integ_midpt_ZinR_input2[0] << "\t" << Integ_midpt_ZinR_input2[0]/Sum_midpt_Z_in_R_input2 * 100 << "\t" << Integ_midpt_ZinR_input1[0]- Integ_midpt_ZinR_input2[0] << "\t" << (Integ_midpt_ZinR_input1[0]- Integ_midpt_ZinR_input2[0])/Integ_midpt_ZinR_input2[0]*100 << endl;
+ for(Int_t iR = 1; iR < NbinsR; iR++){
+ outl << "\t" << iR << "\t" << Integ_midpt_ZinR_input1[iR] << "\t" << Integ_midpt_ZinR_input1[iR]/Sum_midpt_Z_in_R_input1 * 100 <<"\t" << Integ_midpt_ZinR_input2[iR] << "\t" << Integ_midpt_ZinR_input2[iR]/Sum_midpt_Z_in_R_input2 * 100 << "\t" << Integ_midpt_ZinR_input1[iR]- Integ_midpt_ZinR_input2[iR] << "\t" << (Integ_midpt_ZinR_input1[iR]- Integ_midpt_ZinR_input2[iR])/Integ_midpt_ZinR_input2[iR] *100 << endl;
+ }
+ outl << "\t" << "sum" << "\t" << Sum_midpt_Z_in_R_input1 << "\t" << "100" << "\t" << Sum_midpt_Z_in_R_input2 << "\t" << "100" <<"\t" << Sum_midpt_Z_in_R_input1 - Sum_midpt_Z_in_R_input2 << "\t" << (Sum_midpt_Z_in_R_input1-Sum_midpt_Z_in_R_input2)/Sum_midpt_Z_in_R_input2 *100 << endl;
+ outl << endl;
+
+ outl << "MidPt R in Z" <<endl;
+// outl <<" \t0\t" << Integ_midpt_RinZ_input1[0] << "\t"<< Integ_midpt_RinZ_input1[0]/Sum_midpt_R_in_Z_input1 * 100 <<"\t" << Integ_midpt_RinZ_input2[0] << "\t" << Integ_midpt_RinZ_input2[0]/Sum_midpt_R_in_Z_input2 * 100 << "\t" << Integ_midpt_RinZ_input1[0]- Integ_midpt_RinZ_input2[0] << "\t" << (Integ_midpt_RinZ_input1[0]- Integ_midpt_RinZ_input2[0])/Integ_midpt_RinZ_input2[0] *100<< endl;
+ for(Int_t iZ = 1; iZ < NbinsZ; iZ++){
+ outl << "\t" << iZ << "\t" << Integ_midpt_RinZ_input1[iZ] << "\t" << Integ_midpt_RinZ_input1[iZ]/Sum_midpt_R_in_Z_input1 * 100 <<"\t" << Integ_midpt_RinZ_input2[iZ] << "\t" << Integ_midpt_RinZ_input2[iZ]/Sum_midpt_R_in_Z_input2 * 100 << "\t" << Integ_midpt_RinZ_input1[iZ]- Integ_midpt_RinZ_input2[iZ] << "\t" << (Integ_midpt_RinZ_input1[iZ]- Integ_midpt_RinZ_input2[iZ])/Integ_midpt_RinZ_input2[iZ] *100 << endl;
+ }
+ outl << "\t" << "sum" << "\t" << Sum_midpt_R_in_Z_input1 << "\t" << "100" << "\t" << Sum_midpt_R_in_Z_input2 << "\t" << "100" <<"\t" << Sum_midpt_R_in_Z_input1 - Sum_midpt_R_in_Z_input2 << "\t" << (Sum_midpt_R_in_Z_input1-Sum_midpt_R_in_Z_input2)/Sum_midpt_R_in_Z_input2 *100 << endl;
+
+ outl << "------------------------------------------------------------------------------------------" << endl;
+ }
+ ps_mapping->Close();
+ // hier ende
+ }
+
+ // --------------------------- single plots ----------------------------
+ if(SinglePlots){
+
+
+ // ---------------------------- R- Distribution -----------------------
+ TCanvas * c_SinglePlot_2 = new TCanvas("c_SinglePlot_2","",1000,1000); // gives the page size
+ c_SinglePlot_2->SetLogy(0);
+ c_SinglePlot_2->cd();
+
+ if(secondinput == ""){
+ DrawAutoGammaHisto( ESD_Conversion_R_input1,
+ "","R [cm]",StandardYAxis,
+ kTRUE, 1.1,0.00001,
+ kFALSE,0. ,0,
+ kTRUE, 0.,180.);
+ }else{
+ DrawAutoGammaHistos( ESD_Conversion_R_input1,
+ ESD_Conversion_R_input2,
+ "","R [cm]",StandardYAxis,
+ kTRUE, 1.1,0.00001,
+ kFALSE,0. ,0.,
+ kTRUE, 0.,180.);
+ }
+ for(Int_t i=0; i < 12 ; i++){
+ DrawGammaLines(ArrayRbins[i], ArrayRbins[i], 0.00001,ESD_Conversion_R_input1->GetMaximum());
+ }
+ DrawAliceLogoPerformance(right_up [0],right_up[1],right_up[2],right_up[3],0.03, Date);
+ c_SinglePlot_2->Update();
+ c_SinglePlot_2->SaveAs(Form("%sR_distribution_lin.%s",path,suffix));
+ delete c_SinglePlot_2;
+
+
+ TCanvas * c_SinglePlot_1 = new TCanvas("c_SinglePlot_1","",1000,1000); // gives the page size
+ c_SinglePlot_1->cd();
+ c_SinglePlot_1->SetLogy(1);
+
+ if(secondinput == ""){
+ DrawAutoGammaHisto( ESD_Conversion_R_input1,
+ "","R [cm]",StandardYAxis,
+ kTRUE, 1.5,0.00001,
+ kFALSE,0. ,0,
+ kTRUE, 0.,180.);
+ }else{
+ DrawAutoGammaHistos( ESD_Conversion_R_input1,
+ ESD_Conversion_R_input2,
+ "","R [cm]",StandardYAxis,
+ kTRUE, 1.5,0.00001,
+ kFALSE,0. ,0.,
+ kTRUE, 0.,180.);
+ }
+ for(Int_t i=0; i < 12 ; i++){
+ DrawGammaLines(ArrayRbins[i], ArrayRbins[i], 0.00001,ESD_Conversion_R_input1->GetMaximum());
+ }
+ DrawAliceLogoPerformance(right_up [0],right_up[1],right_up[2],right_up[3],0.03, Date);
+
+ c_SinglePlot_1->Update();
+ c_SinglePlot_1->SaveAs(Form("%sR_distribution_log.%s",path,suffix));
+ delete c_SinglePlot_1;
+
+
+ //----------------------------- Integrated Radius -----------------------
+ TCanvas * c_SinglePlot_18 = new TCanvas("c_SinglePlot_18","",1000,1000); // gives the page size
+ c_SinglePlot_18->SetLogy(0);
+ c_SinglePlot_18->cd();
+ if(secondinput == ""){
+ DrawAutoGammaHisto( ESD_Conversion_R_summed_input1,
+ "Conversions R distribution","R [cm]","Integrated (0-to-R) #gamma candidates/event scaled by multiplicity",
+ kTRUE, 1.2,0,
+ kTRUE,0. ,0.,
+ kTRUE, 0.,180.);
+ }else{
+ DrawAutoGammaHistos( ESD_Conversion_R_summed_input1,
+ ESD_Conversion_R_summed_input2,
+ "Integrated Radius of Conversion","R [cm] ","Integrated (0-to-R) #gamma candidates/event scaled by multiplicity",
+ kTRUE, 1.2,0,
+ kFALSE,0. ,0.,
+ kTRUE, 0.,180.);
+ }
+ DrawAliceLogo(left_up [0],left_up[1],left_up[2],left_up[3]);
+
+ c_SinglePlot_18->Update();
+ c_SinglePlot_18->SaveAs(Form("%sInteg_Radius.%s",path,suffix));
+ delete c_SinglePlot_18;
+
+
+ TCanvas * c_SinglePlot_17 = new TCanvas("c_SinglePlot_17","",1000,1000); // gives the page size
+ c_SinglePlot_17->SetLogy(1);
+ c_SinglePlot_17->cd();
+ if(secondinput == ""){
+ DrawAutoGammaHisto( ESD_Conversion_R_summed_input1,
+ "Conversions R distribution","R [cm]","Integrated (0-to-R) #gamma candidates/event scaled by multiplicity",
+ kTRUE,2.5,0,
+ kFALSE,0. ,0.,
+ kTRUE, 0.,180.);
+ }else{
+ DrawAutoGammaHistos( ESD_Conversion_R_summed_input1,
+ ESD_Conversion_R_summed_input2,
+ "Integrated Radius of Conversion","R [cm] ","Integrated (0-to-R) #gamma candidates/event scaled by multiplicity",
+ kTRUE, 2.5,0,
+ kFALSE,0. ,0.,
+ kTRUE, 0.,180.);
+ }
+ DrawAliceLogo(right_down [0],right_down[1],right_down[2],right_down[3]);
+
+
+ c_SinglePlot_17->Update();
+ c_SinglePlot_17->SaveAs(Form("%sInteg_Radius_log.%s",path,suffix));
+ delete c_SinglePlot_17;
+
+
+
+ // ----------------------- 2 dim Plots -----------------------------------
+ TCanvas * c_SinglePlot_3 = new TCanvas("c_SinglePlot_3","",1000,1000); // gives the page size
+ c_SinglePlot_3->SetLogz(1);
+ c_SinglePlot_3->SetRightMargin(RightMargin);
+ c_SinglePlot_3->cd();
+ DrawAutoGammaHisto2D( ESD_Conversion_ZR_input1,
+ "", "Z [cm]", "R [cm]", "",
+ kTRUE, 0., 200.,
+ kFALSE, 0., 20.);
+ DrawAliceLogoPerformance(right_up2D [0],right_up2D[1],right_up2D[2],right_up2D[3],0.03,Date);
+// DrawAliceText(left_down[0], left_down[1 ], left_down[3]);
+ EtaRange->Draw();
+ c_SinglePlot_3->Update();
+ c_SinglePlot_3->SaveAs(Form("%sZR_distribution.%s",path,suffix));
+ delete c_SinglePlot_3;
+
+ TCanvas * c_SinglePlot_4 = new TCanvas("c_SinglePlot_4","",1000,1000); // gives the page size
+ c_SinglePlot_4->SetLogz(1);
+ c_SinglePlot_4->SetRightMargin(RightMargin);
+ c_SinglePlot_4->cd();
+ DrawAutoGammaHisto2D( ESD_Conversion_XY_input1,
+ "", "X [cm]", "Y [cm]", "",
+ kTRUE, -180., 180.,
+ kTRUE, -180., 180.);
+ DrawStructure();
+ EtaRange->Draw();
+ DrawAliceLogoPerformance(right_up2D [0],right_up2D[1],right_up2D[2],right_up2D[3],0.03,Date);
+// DrawAliceText(left_down[0], left_down[1 ], left_down[3]);
+ c_SinglePlot_4->Update();
+ c_SinglePlot_4->SaveAs(Form("%sXY_distribution.%s",path,suffix));
+ delete c_SinglePlot_4;
+
+ TCanvas * c_SinglePlot_4 = new TCanvas("c_SinglePlot_4","",1000,1000); // gives the page size
+ c_SinglePlot_4->SetLogz(1);
+ c_SinglePlot_4->SetRightMargin(RightMargin);
+ c_SinglePlot_4->cd();
+ ESD_Conversion_XY_input1->SetMinimum(minimumXY);
+ DrawAutoGammaHisto2D( ESD_Conversion_XY_input1,
+ "", "X [cm]", "Y [cm]", "",
+ kTRUE, -180., 180.,
+ kTRUE, -180., 180.);
+ DrawStructure();
+ EtaRange->Draw();
+ DrawAliceLogoPerformance(right_up2D [0],right_up2D[1],right_up2D[2],right_up2D[3],0.03,Date);
+// DrawAliceText(left_down[0], left_down[1 ], left_down[3]);
+ c_SinglePlot_4->Update();
+ c_SinglePlot_4->SaveAs(Form("%sXY_distribution_minimum.%s",path,suffix));
+ delete c_SinglePlot_4;
+
+
+
+ if(secondinput != ""){
+ TCanvas * c_SinglePlot_5 = new TCanvas("c_SinglePlot_5","",1000,1000); // gives the page size
+ c_SinglePlot_5->SetLogz(1);
+ c_SinglePlot_5->SetRightMargin(RightMargin);
+ c_SinglePlot_5->cd();
+ Diff_XY_distribution = (TH1D*)ESD_Conversion_XY_input1->Clone();
+ Diff_XY_distribution->Divide(ESD_Conversion_XY_input1,ESD_Conversion_XY_input2,1.,1.,"B");
+ Diff_XY_distribution->Draw("col2");
+ DrawAliceLogo(right_up2D [0],right_up2D[1],right_up2D[2],right_up2D[3]);
+ c_SinglePlot_5->Update();
+ c_SinglePlot_5->SaveAs(Form("%sDiff_XY_distributions.%s",path,suffix));
+ delete c_SinglePlot_5;
+ }
+
+
+ //-------------------- Z - Distribution ------------------------------
+
+ TCanvas * c_SinglePlot_19 = new TCanvas("c_SinglePlot_19","",1000,1000); // gives the page size
+ c_SinglePlot_19->SetLogy(0);
+ c_SinglePlot_19->cd();
+ if(secondinput == ""){
+ DrawAutoGammaHisto( ESD_Conversion_Z_input1
+ "Conversions Z distribution","Z [cm]",StandardYAxis,
+ kTRUE, 1.1,0.00001,
+ kFALSE,0. ,0,
+ kTRUE, -201.,201.);
+ }else{
+ DrawAutoGammaHistos( ESD_Conversion_Z_input1,
+ ESD_Conversion_Z_input2,
+ "Conversions Z distribution","Z [cm] ",StandardYAxis,
+ kTRUE, 1.1,0.00001,
+ kFALSE,0. ,0.,
+ kFALSE, -201.,201.);
+ }
+ for(Int_t i=0; i < 12 ; i++){
+ DrawGammaLines(ArrayZbins[i], ArrayZbins[i], 0.00001,ESD_Conversion_Z_input1->GetMaximum());
+ }
+
+ leg1 = new TLegend( 0.6,0.82,0.9,0.9);
+ leg1->SetTextSize(0.04);
+ leg1->SetFillColor(0);
+ leg1->AddEntry(ESD_Conversion_Z_input1,("Data"));
+ if(secondinput != ""){leg1->AddEntry(ESD_Conversion_Z_input2,("MC"));}
+ leg1->Draw();
+
+ DrawAliceLogo(right_up [0],right_up[1],right_up[2],right_up[3]);
+
+ c_SinglePlot_19->Update();
+ c_SinglePlot_19->SaveAs(Form("%sZ_distribution_lin.%s",path,suffix));
+ delete c_SinglePlot_19;
+
+ TCanvas * c_SinglePlot_6 = new TCanvas("c_SinglePlot_6","",1000,1000); // gives the page size
+ c_SinglePlot_6->SetLogy(1);
+ c_SinglePlot_6->cd();
+ if(secondinput == ""){
+ DrawAutoGammaHisto( ESD_Conversion_Z_input1
+ "Conversions Z distribution","Z [cm]",StandardYAxis,
+ kTRUE, 1.5,0.00001,
+ kFALSE,0. ,0,
+ kTRUE, -250.,250.);
+ }else{
+ DrawAutoGammaHistos( ESD_Conversion_Z_input1,
+ ESD_Conversion_Z_input2,
+ "Conversions Z distribution","Z [cm] ",StandardYAxis,
+ kTRUE, 1.5,0.0000001,
+ kFALSE,0. ,0.,
+ kFALSE, -201.,201.);
+ }
+ for(Int_t i=0; i < 12 ; i++){
+ DrawGammaLines(ArrayZbins[i], ArrayZbins[i], 0.0000001,ESD_Conversion_Z_input1->GetMaximum());
+ }
+ leg1->Draw();
+ DrawAliceLogo(right_up [0],right_up[1],right_up[2],right_up[3]);
+
+ c_SinglePlot_6->Update();
+ c_SinglePlot_6->SaveAs(Form("%sZ_distribution_log.%s",path,suffix));
+ delete c_SinglePlot_6;
+
+
+ //------------------- Giving the Pad Phi in R in better resolution
+
+ c_Single_Phi_in_R = new TCanvas("c_Single_Phi_in_R","",400,20,1400,2000); // gives the page size
+ pad_Single_Phi_in_R = new TPad("pad_Single_Phi_in_R","",0.01,0.01,0.99,0.99,0); // gives the size of the histo areas
+ pad_Single_Phi_in_R->SetFillColor(0);
+ pad_Single_Phi_in_R->GetFrame()->SetFillColor(0);
+ pad_Single_Phi_in_R->SetBorderMode(0);
+ pad_Single_Phi_in_R->Divide(column,raw);
+ pad_Single_Phi_in_R->Draw();
+
+ for(Int_t iR = 0; iR < NbinsR; iR++){
+ Int_t place = iR + 1;
+
+ pad_Single_Phi_in_R->cd(place);
+ pad_Single_Phi_in_R->cd(place)->SetLogy(1);
+ sprintf(histoname_Phi_in_R_input1,"ESD_Conversion_Mapping_Phi_in_R_iR%02d",iR);
+ if(secondinput == ""){
+ DrawAutoGammaHisto( ESD_Conversion_Mapping_Phi_in_R_input1[iR],
+ histoname_Phi_in_R_input1,"#Phi",StandardYAxis,
+ kTRUE,2 ,0.0000002,
+ kFALSE,0. ,0.,
+ kFALSE, 0.,180.);
+ }else{
+ DrawAutoGammaHistos( ESD_Conversion_Mapping_Phi_in_R_input1[iR],
+ ESD_Conversion_Mapping_Phi_in_R_input2[iR],
+ histoname_Phi_in_R_input1,"#Phi",StandardYAxis,
+ kTRUE,2 ,0.0000002,
+ kFALSE,0. ,0.,
+ kFALSE, 0.,180.);
+ }
+ DrawAliceText(right_up_text[0],right_up_text[1], right_up_text[3]);
+ }
+ pad_Single_Phi_in_R->Update();
+ c_Single_Phi_in_R->Print(Form("%spad_Phi_in_R.%s",path,suffix));
+ delete pad_Single_Phi_in_R;
+ delete c_Single_Phi_in_R;
+
+
+ // --------------- Giving Phi in R for several bins -------------------------------------------------------------
+ TCanvas * c_SinglePlot_7 = new TCanvas("c_SinglePlot_7","",1000,700); // gives the page size
+ c_SinglePlot_7->SetLogy(1);
+ c_SinglePlot_7->cd();
+ if(secondinput == ""){
+ DrawAutoGammaHisto( ESD_Conversion_Mapping_Phi_in_R_input1[4],
+ "ESD_Conversion_Mapping_Phi_in_R_R04","#Phi",StandardYAxis,
+ kFALSE,3 ,0.000001,
+ kFALSE,0. ,0.,
+ kFALSE, 0.,180.);
+ }else{
+ DrawAutoGammaHistos( ESD_Conversion_Mapping_Phi_in_R_input1[4],
+ ESD_Conversion_Mapping_Phi_in_R_input2[4],
+ "ESD_Conversion_Mapping_Phi_in_R_R04","#Phi",StandardYAxis,
+ kFALSE,3 ,0.000001,
+ kFALSE,0. ,0.,
+ kFALSE, 0.,180.);
+ }
+ DrawAliceText(right_up_text[0],right_up_text[1], right_up_text[3]);
+
+ c_SinglePlot_7->Update();
+ c_SinglePlot_7->SaveAs(Form("%sPhi_in_R_04.%s",path,suffix));
+ delete c_SinglePlot_7;
+
+ TCanvas * c_SinglePlot_8 = new TCanvas("c_SinglePlot_8","",1000,700); // gives the page size
+ c_SinglePlot_8->SetLogy(1);
+ c_SinglePlot_8->cd();
+ if(secondinput == ""){
+ DrawAutoGammaHisto( ESD_Conversion_Mapping_Phi_in_R_input1[5],
+ "ESD_Conversion_Mapping_Phi_in_R_R05","#Phi",StandardYAxis,
+ kFALSE,3 ,0.000001,
+ kFALSE,0. ,0.,
+ kFALSE, 0.,180.);
+ }else{
+ DrawAutoGammaHistos( ESD_Conversion_Mapping_Phi_in_R_input1[5],
+ ESD_Conversion_Mapping_Phi_in_R_input2[5],
+ "ESD_Conversion_Mapping_Phi_in_R_R05","#Phi",StandardYAxis,
+ kFALSE,3 ,0.000001,
+ kFALSE,0. ,0.,
+ kFALSE, 0.,180.);
+ }
+ DrawAliceText(right_up_text[0],right_up_text[1], right_up_text[3]);
+ c_SinglePlot_8->Update();
+ c_SinglePlot_8->SaveAs(Form("%sPhi_in_R_05.%s",path,suffix));
+ delete c_SinglePlot_8;
+
+ TCanvas * c_SinglePlot_12 = new TCanvas("c_SinglePlot_12","",1000,700); // gives the page size
+ c_SinglePlot_12->SetLogy(1);
+ c_SinglePlot_12->cd();
+ if(secondinput == ""){
+ DrawAutoGammaHisto( ESD_Conversion_Mapping_Phi_in_R_input1[2],
+ "ESD_Conversion_Mapping_Phi_in_R_R02","#Phi",StandardYAxis,
+ kFALSE,3 ,0.000001,
+ kFALSE,0. ,0.,
+ kFALSE, 0.,180.);
+ }else{
+ DrawAutoGammaHistos( ESD_Conversion_Mapping_Phi_in_R_input1[2],
+ ESD_Conversion_Mapping_Phi_in_R_input2[2],
+ "ESD_Conversion_Mapping_Phi_in_R_R02","#Phi",StandardYAxis,
+ kFALSE,3 ,0.000001,
+ kFALSE,0. ,0.,
+ kFALSE, 0.,180.);
+ }
+ DrawAliceText(right_up_text[0],right_up_text[1], right_up_text[3]);
+
+ c_SinglePlot_12->Update();
+ c_SinglePlot_12->SaveAs(Form("%sPhi_in_R_02.%s",path,suffix));
+ delete c_SinglePlot_12;
+
+ TCanvas * c_SinglePlot_13 = new TCanvas("c_SinglePlot_13","",1000,700); // gives the page size
+ c_SinglePlot_13->SetLogy(1);
+ c_SinglePlot_13->cd();
+ if(secondinput == ""){
+ DrawAutoGammaHisto( ESD_Conversion_Mapping_Phi_in_R_input1[6],
+ "ESD_Conversion_Mapping_Phi_in_R_R06","#Phi",StandardYAxis,
+ kFALSE,3 ,0.000001,
+ kFALSE,0. ,0.,
+ kFALSE, 0.,180.);
+ }else{
+ DrawAutoGammaHistos( ESD_Conversion_Mapping_Phi_in_R_input1[6],
+ ESD_Conversion_Mapping_Phi_in_R_input2[6],
+ "ESD_Conversion_Mapping_Phi_in_R_R06","#Phi",StandardYAxis,
+ kFALSE,3 ,0.000001,
+ kFALSE,0. ,0.,
+ kFALSE, 0.,180.);
+ }
+ DrawAliceText(right_up_text[0],right_up_text[1], right_up_text[3]);
+ c_SinglePlot_13->Update();
+ c_SinglePlot_13->SaveAs(Form("%sPhi_in_R_06.%s",path,suffix));
+ delete c_SinglePlot_13;
+
+ TCanvas * c_SinglePlot_14 = new TCanvas("c_SinglePlot_14","",1000,700); // gives the page size
+ c_SinglePlot_14->SetLogy(1);
+ c_SinglePlot_14->cd();
+ if(secondinput == ""){
+ DrawAutoGammaHisto( ESD_Conversion_Mapping_Phi_in_R_input1[7],
+ "ESD_Conversion_Mapping_Phi_in_R_R07","#Phi",StandardYAxis,
+ kFALSE,3 ,0.000001,
+ kFALSE,0. ,0.,
+ kFALSE, 0.,180.);
+ }else{
+ DrawAutoGammaHistos( ESD_Conversion_Mapping_Phi_in_R_input1[7],
+ ESD_Conversion_Mapping_Phi_in_R_input2[7],
+ "ESD_Conversion_Mapping_Phi_in_R_R07","#Phi",StandardYAxis,
+ kFALSE,3 ,0.000001,
+ kFALSE,0. ,0.,
+ kFALSE, 0.,180.);
+ }
+ DrawAliceText(right_up_text[0],right_up_text[1], right_up_text[3]);
+
+ c_SinglePlot_14->Update();
+ c_SinglePlot_14->SaveAs(Form("%sPhi_in_R_07.%s",path,suffix));
+ delete c_SinglePlot_14;
+
+ TCanvas * c_SinglePlot_15 = new TCanvas("c_SinglePlot_15","",1000,700); // gives the page size
+ c_SinglePlot_15->SetLogy(1);
+ c_SinglePlot_15->cd();
+ if(secondinput == ""){
+ DrawAutoGammaHisto( ESD_Conversion_Mapping_Phi_in_R_input1[9 ],
+ "ESD_Conversion_Mapping_Phi_in_R_R09","#Phi",StandardYAxis,
+ kFALSE,3 ,0.000001,
+ kFALSE,0. ,0.,
+ kFALSE, 0.,180.);
+ }else{
+ DrawAutoGammaHistos( ESD_Conversion_Mapping_Phi_in_R_input1[9],
+ ESD_Conversion_Mapping_Phi_in_R_input2[9],
+ "ESD_Conversion_Mapping_Phi_in_R_R09","#Phi",StandardYAxis,
+ kFALSE,3 ,0.000001,
+ kFALSE,0. ,0.,
+ kFALSE, 0.,180.);
+ }
+ DrawAliceText(right_up_text[0],right_up_text[1], right_up_text[3]);
+ c_SinglePlot_15->Update();
+ c_SinglePlot_15->SaveAs(Form("%sPhi_in_R_09.%s",path,suffix));
+ delete c_SinglePlot_15;
+
+ TCanvas * c_SinglePlot_16 = new TCanvas("c_SinglePlot_16","",1000,700); // gives the page size
+ c_SinglePlot_16->SetLogy(1);
+ c_SinglePlot_16->cd();
+ if(secondinput == ""){
+ DrawAutoGammaHisto( ESD_Conversion_Mapping_Phi_in_R_input1[10],
+ "ESD_Conversion_Mapping_Phi_in_R_R10","#Phi",StandardYAxis,
+ kFALSE,3 ,0.000001,
+ kFALSE,0. ,0.,
+ kFALSE, 0.,180.);
+ }else{
+ DrawAutoGammaHistos( ESD_Conversion_Mapping_Phi_in_R_input1[10],
+ ESD_Conversion_Mapping_Phi_in_R_input2[10],
+ "ESD_Conversion_Mapping_Phi_in_R_R10","#Phi",StandardYAxis,
+ kFALSE,3 ,0.000001,
+ kFALSE,0. ,0.,
+ kFALSE, 0.,180.);
+ }
+ DrawAliceText(right_up_text[0],right_up_text[1], right_up_text[3]);
+ c_SinglePlot_16->Update();
+ c_SinglePlot_16->SaveAs(Form("%sPhi_in_R_10.%s",path,suffix));
+ delete c_SinglePlot_16;
+
+ //----------- Giving Z in R as single Pad ----------------
+ c_Single_Z_in_R = new TCanvas("c_Single_Z_in_R","",400,20,1400,2000); // gives the page size
+
+ pad_Single_Z_in_R = new TPad("pad_Single_Z_in_R","",0.01,0.01,0.99,0.99,0); // gives the size of the histo areas
+ pad_Single_Z_in_R->SetFillColor(0);
+ pad_Single_Z_in_R->GetFrame()->SetFillColor(0);
+ pad_Single_Z_in_R->SetBorderMode(0);
+ pad_Single_Z_in_R->Divide(column,raw);
+ pad_Single_Z_in_R->Draw();
+
+/* title0->Draw();
+ if(secondinput != ""){title1->Draw();}
+*/
+ for(Int_t iR = 0; iR < NbinsR; iR++){
+ Int_t place = iR + 1;
+ pad_Single_Z_in_R->cd(place);
+ pad_Single_Z_in_R->cd(place)->SetLogy(1);
+ sprintf(histoname_Z_in_R_input1,"ESD_Conversion_Mapping_Z_in_R_iR%02d",iR);
+ if(secondinput == ""){
+ DrawAutoGammaHisto( ESD_Conversion_Mapping_Z_in_R_input1[iR],
+ histoname_Z_in_R_input1,"Z [cm]",StandardYAxis,
+ kTRUE,2 ,0.00001,
+ kFALSE,0. ,0.,
+ kFALSE, 0.,180.);
+ }else{
+ DrawAutoGammaHistos( ESD_Conversion_Mapping_Z_in_R_input1[iR],
+ ESD_Conversion_Mapping_Z_in_R_input2[iR],
+ histoname_Z_in_R_input1,"Z [cm]",StandardYAxis,
+ kTRUE,2 ,0.00001,
+ kFALSE,0. ,0.,
+ kFALSE, 0.,180.);
+ }
+ DrawAliceText(right_up_text[0],right_up_text[1], right_up_text[3]);
+ }
+
+ pad_Single_Z_in_R->Update();
+ c_Single_Z_in_R->SaveAs(Form("%spad_Z_in_R.%s",path,suffix));
+ delete pad_Single_Z_in_R;
+ delete c_Single_Z_in_R;
+
+ // -------------- Giving Z in R for 4th and 5th bin
+ TCanvas * c_SinglePlot_9 = new TCanvas("c_SinglePlot_9","",1000,1000); // gives the page size
+ c_SinglePlot_9->SetLogy(1);
+ c_SinglePlot_9->cd();
+ if(secondinput == ""){
+ DrawAutoGammaHisto( ESD_Conversion_Mapping_Z_in_R_input1[9],
+ "ESD_Conversion_Mapping_Z_in_R_iR09","Z [cm]",StandardYAxis,
+ kFALSE,3 ,0.0001,
+ kFALSE,0. ,0.,
+ kFALSE, 0.,180.);
+ }else{
+ DrawAutoGammaHistos( ESD_Conversion_Mapping_Z_in_R_input1[9],
+ ESD_Conversion_Mapping_Z_in_R_input2[9],
+ "ESD_Conversion_Mapping_Z_in_R_iR09","Z [cm]",StandardYAxis,
+ kFALSE,3 ,0.0001,
+ kFALSE,0. ,0.,
+ kFALSE, 0.,180.);
+ }
+ DrawAliceText(right_up_text[0],right_up_text[1], right_up_text[3]);
+ c_SinglePlot_9->Update();
+ c_SinglePlot_9->SaveAs(Form("%sZ_in_R_09.%s",path,suffix));
+ delete c_SinglePlot_9;
+
+ TCanvas * c_SinglePlot_10 = new TCanvas("c_SinglePlot_10","",1000,1000); // gives the page size
+ c_SinglePlot_10->SetLogy(1);
+ c_SinglePlot_10->cd();
+ if(secondinput == ""){
+ DrawAutoGammaHisto( ESD_Conversion_Mapping_Z_in_R_input1[10],
+ "ESD_Conversion_Mapping_Z_in_R_iR10","Z [cm]",StandardYAxis,
+ kFALSE,3 ,0.0001,
+ kFALSE,0. ,0.,
+ kFALSE, 0.,180.);
+ }else{
+ DrawAutoGammaHistos( ESD_Conversion_Mapping_Z_in_R_input1[10],
+ ESD_Conversion_Mapping_Z_in_R_input2[10],
+ "ESD_Conversion_Mapping_Z_in_R_iR10","Z [cm]",StandardYAxis,
+ kFALSE,3 ,0.0001,
+ kFALSE,0. ,0.,
+ kFALSE, 0.,180.);
+ }
+ DrawAliceText(right_up_text[0],right_up_text[1], right_up_text[3]);
+ c_SinglePlot_10->Update();
+ c_SinglePlot_10->SaveAs(Form("%sZ_in_R_10.%s",path,suffix));
+ delete c_SinglePlot_10;
+
+ // ------------- Giving Z in phi in singleplot
+ c_Single_Phi_in_Z = new TCanvas("c_Single_Phi_in_Z","",200,10,1400,2000); // gives the page size
+
+ pad_Single_Phi_in_Z = new TPad("pad_Single_Phi_in_Z","",0.01,0.01,0.99,0.99,0); // gives the size of the histo areas
+ pad_Single_Phi_in_Z->SetFillColor(0);
+ pad_Single_Phi_in_Z->GetFrame()->SetFillColor(0);
+ pad_Single_Phi_in_Z->SetBorderMode(0);
+ pad_Single_Phi_in_Z->Divide(column,raw);
+ pad_Single_Phi_in_Z->Draw();
+
+
+ for(Int_t iZ = 0; iZ < NbinsZ; iZ++){
+ Int_t place = iZ + 1;
+ pad_Single_Phi_in_Z->cd(place);
+ pad_Single_Phi_in_Z->cd(place)->SetLogy(1);
+ sprintf(histoname_Phi_in_Z_input1,"ESD_Conversion_Mapping_Phi_in_Z_iZ%02d",iZ);
+ if(secondinput == ""){
+ DrawAutoGammaHisto( ESD_Conversion_Mapping_Phi_in_Z_input1[iZ],
+ histoname_Phi_in_Z_input1,"#Phi",StandardYAxis,
+ kTRUE,2 ,0.0000002,
+ kFALSE,0. ,0.,
+ kFALSE, 0.,180.);
+ }else{
+ DrawAutoGammaHistos( ESD_Conversion_Mapping_Phi_in_Z_input1[iZ],
+ ESD_Conversion_Mapping_Phi_in_Z_input2[iZ],
+ histoname_Phi_in_Z_input1,"#Phi",StandardYAxis,
+ kTRUE,2 ,0.0000002,
+ kFALSE,0. ,0.,
+ kFALSE, 0.,180.);
+ }
+ DrawAliceText(right_up_text[0],right_up_text[1], right_up_text[3]);
+ }
+
+ pad_Single_Phi_in_Z->Update();
+ c_Single_Phi_in_Z->SaveAs(Form("%spad_Phi_in_Z.%s",path,suffix));
+ delete pad_Single_Phi_in_Z ;
+ delete c_Single_Phi_in_Z;
+
+ // ----- Giving R in Z in SinglePlot
+ c_Single_R_in_Z = new TCanvas("c_Single_R_in_Z","",400,20,1400,2000); // gives the page size
+
+ pad_Single_R_in_Z = new TPad("pad_Single_R_in_Z","",0.01,0.01,0.99,0.99,0); // gives the size of the histo areas
+ pad_Single_R_in_Z->SetFillColor(0);
+ pad_Single_R_in_Z->GetFrame()->SetFillColor(0);
+ pad_Single_R_in_Z->SetBorderMode(0);
+ pad_Single_R_in_Z->Divide(column,raw);
+ pad_Single_R_in_Z->Draw();
+
+
+ for(Int_t iZ = 0; iZ < NbinsZ; iZ++){
+ Int_t place = iZ + 1;
+ pad_Single_R_in_Z->cd(place);
+ pad_Single_R_in_Z->cd(place)->SetLogy(1);
+ sprintf(histoname_R_in_Z_input1,"ESD_Conversion_Mapping_R_in_Z_iZ%02d",iZ);
+ if(secondinput == ""){
+ DrawAutoGammaHisto( ESD_Conversion_Mapping_R_in_Z_input1[iZ],
+ histoname_R_in_Z_input1,"R [cm]",StandardYAxis,
+ kTRUE,2 ,0.0000002,
+ kFALSE,0. ,0.,
+ kFALSE, 0.,180.);
+ }else{
+ DrawAutoGammaHistos( ESD_Conversion_Mapping_R_in_Z_input1[iZ],
+ ESD_Conversion_Mapping_R_in_Z_input2[iZ],
+ histoname_R_in_Z_input1,"R [cm]",StandardYAxis,
+ kTRUE,2 ,0.0000002,
+ kFALSE,0. ,0.,
+ kFALSE, 0.,180.);
+ }
+ DrawAliceText(right_up_text[0],right_up_text[1], right_up_text[3]);
+ }
+
+ pad_Single_R_in_Z->Update();
+ c_Single_R_in_Z->SaveAs(Form("%spad_R_in_Z.%s",path,suffix));
+ delete pad_Single_R_in_Z ;
+ delete c_Single_R_in_Z;
+ //---------------------------- Ratio Pads ----------------------------------
+
+if(secondinput != ""){
+
+ c_Ratio_Phi_in_R = new TCanvas("c_Ratio_Phi_in_R","",400,20,1400,2000); // gives the page size
+
+ pad_Ratio_Phi_in_R = new TPad("pad_Ratio_Phi_in_R","",0.01,0.01,0.99,0.99,0); // gives the size of the histo areas
+ pad_Ratio_Phi_in_R->SetFillColor(0);
+ pad_Ratio_Phi_in_R->GetFrame()->SetFillColor(0);
+ pad_Ratio_Phi_in_R->SetBorderMode(0);
+ pad_Ratio_Phi_in_R->Divide(column,raw);
+ pad_Ratio_Phi_in_R->Draw();
+
+ for(Int_t iR = 0; iR < NbinsR; iR++){
+ Int_t place = iR + 1;
+
+ pad_Ratio_Phi_in_R->cd(place);
+ pad_Ratio_Phi_in_R->cd(place)->SetLogy(1);
+ sprintf(histoname_Ratio_Phi_in_R_input2,"Ratio_Phi_in_R_iR%02d",iR);
+ DrawRatioGammaHisto( Ratio_Mapping_Phi_in_R[iR],
+ histoname_Ratio_Phi_in_R_input2,"#Phi","norm Data/norm MC",
+ kFALSE,3 ,0.000001,
+ kTRUE,0.1 ,5.,
+ kFALSE, 0.,180.);
+ linePhi->Draw("same");
+ DrawAliceText(right_up_text[0],right_up_text[1], right_up_text[3]);
+ }
+
+ pad_Ratio_Phi_in_R->Update();
+ c_Ratio_Phi_in_R->SaveAs(Form("%sRatio_Phi_in_R.%s",path,suffix));
+ delete pad_Ratio_Phi_in_R ;
+ delete c_Ratio_Phi_in_R;
+}
+
+if(secondinput != ""){
+
+ c_Ratio_Z_in_R = new TCanvas("c_Ratio_Z_in_R","",400,20,1400,2000); // gives the page size
+
+ pad_Ratio_Z_in_R = new TPad("pad_Ratio_Z_in_R","",0.01,0.01,0.99,0.99,0); // gives the size of the histo areas
+ pad_Ratio_Z_in_R->SetFillColor(0);
+ pad_Ratio_Z_in_R->GetFrame()->SetFillColor(0);
+ pad_Ratio_Z_in_R->SetBorderMode(0);
+ pad_Ratio_Z_in_R->Divide(column,raw);
+ pad_Ratio_Z_in_R->Draw();
+
+ for(Int_t iR = 0; iR < NbinsR; iR++){
+ Int_t place = iR + 1;
+
+ pad_Ratio_Z_in_R->cd(place);
+ pad_Ratio_Z_in_R->cd(place)->SetLogy(1);
+ sprintf(histoname_Ratio_Z_in_R_input2,"Ratio_Z_in_R_iR%02d",iR);
+ Float_t ZRange = RangeZinR[iR];
+ DrawRatioGammaHisto( Ratio_Mapping_Z_in_R[iR],
+ histoname_Ratio_Z_in_R_input2,"Z","norm Data/norm MC",
+ kFALSE,3 ,0.000001,
+ kTRUE,0.1 ,5.,
+ kTRUE, -ZRange,ZRange);
+ DrawGammaLines(-ZRange,ZRange,1,1);
+ DrawAliceText(right_up_text[0],right_up_text[1], right_up_text[3]);
+ }
+ pad_Ratio_Z_in_R->Update();
+ c_Ratio_Z_in_R->SaveAs(Form("%sRatio_Z_in_R.%s",path,suffix));
+ delete pad_Ratio_Z_in_R ;
+ delete c_Ratio_Z_in_R;
+}
+
+if(secondinput != ""){
+
+ c_Ratio_Phi_in_Z = new TCanvas("c_Ratio_Phi_in_Z","",400,20,1400,2000); // gives the page size
+
+ pad_Ratio_Phi_in_Z = new TPad("pad_Ratio_Phi_in_Z","",0.01,0.01,0.99,0.99,0); // gives the size of the histo areas
+ pad_Ratio_Phi_in_Z->SetFillColor(0);
+ pad_Ratio_Phi_in_Z->GetFrame()->SetFillColor(0);
+ pad_Ratio_Phi_in_Z->SetBorderMode(0);
+ pad_Ratio_Phi_in_Z->Divide(column,raw);
+ pad_Ratio_Phi_in_Z->Draw();
+
+ for(Int_t iZ = 0; iZ < NbinsZ; iZ++){
+ Int_t place = iZ + 1;
+
+ pad_Ratio_Phi_in_Z->cd(place);
+ pad_Ratio_Phi_in_Z->cd(place)->SetLogy(1);
+ sprintf(histoname_Ratio_Phi_in_Z_input2,"Ratio_Phi_in_Z_iZ%02d",iZ);
+ DrawRatioGammaHisto( Ratio_Mapping_Phi_in_Z[iZ],
+ histoname_Ratio_Phi_in_Z_input2,"#Phi","norm Data/norm MC",
+ kFALSE,3 ,0.000001,
+ kTRUE,0.1 ,5.,
+ kFALSE, 0,0);
+ linePhi->Draw("same");
+ DrawAliceText(right_up_text[0],right_up_text[1], right_up_text[3]);
+ }
+
+ pad_Ratio_Phi_in_Z->Update();
+ c_Ratio_Phi_in_Z->SaveAs(Form("%sRatio_Phi_in_Z.%s",path,suffix));
+ delete pad_Ratio_Phi_in_Z ;
+ delete c_Ratio_Phi_in_Z;
+}
+
+if(secondinput != ""){
+
+ c_Ratio_R_in_Z = new TCanvas("c_Ratio_R_in_Z","",400,20,1400,2000); // gives the page size
+
+ pad_Ratio_R_in_Z = new TPad("pad_Ratio_R_in_Z","",0.01,0.01,0.99,0.99,0); // gives the size of the histo areas
+ pad_Ratio_R_in_Z->SetFillColor(0);
+ pad_Ratio_R_in_Z->GetFrame()->SetFillColor(0);
+ pad_Ratio_R_in_Z->SetBorderMode(0);
+ pad_Ratio_R_in_Z->Divide(column,raw);
+ pad_Ratio_R_in_Z->Draw();
+
+ for(Int_t iZ = 0; iZ < NbinsZ; iZ++){
+ Int_t place = iZ + 1;
+
+ pad_Ratio_R_in_Z->cd(place);
+ pad_Ratio_R_in_Z->cd(place)->SetLogy(1);
+ sprintf(histoname_Ratio_R_in_Z_input2,"Ratio_R_in_Z_iZ%02d",iZ);
+ DrawRatioGammaHisto( Ratio_Mapping_R_in_Z[iZ],
+ histoname_Ratio_R_in_Z_input2,"R [cm]","norm Data/norm MC",
+ kFALSE,3 ,0.000001,
+ kTRUE,0.1 ,5.,
+ kFALSE, 0,0);
+ lineR->Draw("same");
+ DrawAliceText(right_up_text[0],right_up_text[1], right_up_text[3]);
+ }
+
+ pad_Ratio_R_in_Z->Update();
+ c_Ratio_R_in_Z->SaveAs(Form("%sRatio_R_in_Z.%s",path,suffix));
+ delete pad_Ratio_R_in_Z ;
+ delete c_Ratio_R_in_Z;
+}
+
+ }
+
+//Dealocating all reserved resources
+
+}
--- /dev/null
+#include <fstream>
+#include <Riostream.h>
+/*
+ *
+ *
+ *
+ */
+
+extern TRandom *gRandom;
+extern TBenchmark *gBenchmark;
+extern TSystem *gSystem;
+
+void Plot_Pi0_Characteristics(const char *inputRootFile = "Pi0Characteristics",const char *path = "./Output/"){
+
+ gROOT->Reset();
+ gROOT->SetStyle("Plain");
+ gStyle->SetOptFit(0);
+
+ TString filename = Form("%s%s.root",path,inputRootFile);
+ TFile f(filename.Data());
+
+ TList *histograms = f.GetListOfKeys(); // get the list of directories in the file
+
+ TString cutSelectionArray[15];
+ Int_t cutsAdded=0;
+ //Per pt bin histograms:
+ TH1F* YieldPerBin[32];
+ TH1F* StoBPerBin[32];
+ TH1F* SignificancePerBin[32];
+ TH1F* MassPerBin[32];
+ TH1F* FWHMPerBin[32];
+
+ Float_t lowBinLimits[32];
+ Float_t highBinLimits[32];
+
+ TH1F * Raw_Yield;
+ TH1F * StoB;
+ TH1F * Significance;
+ TH1F * Mass;
+ TH1F * FWHM;
+
+
+
+ Int_t colorCounterRawYield=1;
+ Int_t histogramCounterRawYield=2;
+ TCanvas *canvasRawYield = new TCanvas("canvasRawYield","",200,10,600,600);
+ canvasRawYield->SetFillColor(0);
+ canvasRawYield->SetLogy();
+ TLegend *legRawYield= new TLegend(0.7,0.7,1.,1.);
+ legRawYield->SetFillColor(0);
+
+ Int_t colorCounterStoB=1;
+ Int_t histogramCounterStoB=2;
+ TCanvas *canvasStoB = new TCanvas("canvasStoB","",200,10,600,600);
+ canvasStoB->SetFillColor(0);
+ canvasStoB->SetLogy();
+ TLegend *legStoB= new TLegend(0.7,0.7,1.,1.);
+ legStoB->SetFillColor(0);
+
+ Int_t colorCounterSignificance=1;
+ Int_t histogramCounterSignificance=2;
+ TCanvas *canvasSignificance = new TCanvas("canvasSignificance","",200,10,600,600);
+ canvasSignificance->SetFillColor(0);
+ canvasSignificance->SetLogy();
+ TLegend *legSignificance= new TLegend(0.7,0.7,1.,1.);
+ legSignificance->SetFillColor(0);
+
+ Int_t colorCounterMass=1;
+ Int_t histogramCounterMass=2;
+ TCanvas *canvasMass = new TCanvas("canvasMass","",200,10,600,600);
+ canvasMass->SetFillColor(0);
+ // canvasMass->SetLogy();
+ TLegend *legMass= new TLegend(0.7,0.7,1.,1.);
+ legMass->SetFillColor(0);
+
+ Int_t colorCounterFWHM=1;
+ Int_t histogramCounterFWHM=2;
+ TCanvas *canvasFWHM = new TCanvas("canvasFWHM","",200,10,600,600);
+ canvasFWHM->SetFillColor(0);
+ // canvasFWHM->SetLogy();
+ TLegend *legFWHM= new TLegend(0.7,0.7,1.,1.);
+ legFWHM->SetFillColor(0);
+
+
+ for(Int_t entFile=0;entFile<histograms->GetEntries();entFile++){
+
+ TString histoname = histograms->At(entFile)->GetName();
+ if(histoname.Contains("Raw_Yield")){
+ canvasRawYield->cd();
+ cout<<"Histogram contains Raw_Yield: "<<histoname.Data()<<endl;
+ if(Raw_Yield==NULL){
+ cout<<"Setting first histogram"<<endl;
+ Raw_Yield = (TH1F*)f.Get(histoname.Data());
+ cout<<"Histoname: "<<histoname.Data()<<endl;
+ TString cutValue= histoname(histoname.Index("Pi0_")+4,histoname.Length());
+ cutSelectionArray[cutsAdded]= cutValue;
+ cutsAdded++;
+ cout<<"Cut Value is: "<<cutValue.Data()<<endl;
+ for(Int_t bin=1;bin<Raw_Yield->GetNbinsX();bin++){
+ TString perBinHistoName = Form("Raw Yield %f <pt <%f",Raw_Yield->GetBinLowEdge(bin),Raw_Yield->GetBinLowEdge(bin)+Raw_Yield->GetBinWidth(bin));
+ lowBinLimits[bin]=Raw_Yield->GetBinLowEdge(bin);
+ highBinLimits[bin]=Raw_Yield->GetBinLowEdge(bin)+Raw_Yield->GetBinWidth(bin);
+ YieldPerBin[bin]= new TH1F(perBinHistoName.Data(),perBinHistoName.Data(),32,0,32);
+ YieldPerBin[bin]->SetBinContent(histogramCounterRawYield,Raw_Yield->GetBinContent(bin));
+ YieldPerBin[bin]->SetBinError(histogramCounterRawYield,Raw_Yield->GetBinError(bin));
+ YieldPerBin[bin]->GetXaxis()->SetBinLabel(histogramCounterRawYield,cutValue.Data());
+ }
+ cout<<"Raw_Yield: "<<Raw_Yield<<endl;
+ legRawYield->AddEntry(Raw_Yield,cutValue.Data(),"l");
+ // Raw_Yield->DrawCopy();
+ Raw_Yield->Draw();
+ canvasRawYield->Update();
+ }
+ else{
+ colorCounterRawYield++;
+ TH1F* histogram = (TH1F*)f.Get(histoname.Data());
+ cout<<"histogram number of bins: "<<histogram->GetNbinsX()<<endl;
+ TString cutValue= histoname(histoname.Index("Pi0_")+4,histoname.Length());
+ cutSelectionArray[cutsAdded]= cutValue;
+ cutsAdded++;
+ for(Int_t bin=1;bin<histogram->GetNbinsX();bin++){
+ // YieldPerBin[bin]= new TH1F(Form("yield bin %d",bin),Form("yield bin %d",bin),32,0,32);
+ YieldPerBin[bin]->SetBinContent(histogramCounterRawYield,histogram->GetBinContent(bin));
+ YieldPerBin[bin]->SetBinError(histogramCounterRawYield,histogram->GetBinError(bin));
+ YieldPerBin[bin]->GetXaxis()->SetBinLabel(histogramCounterRawYield,cutValue.Data());
+ }
+
+ histogram->SetLineColor(colorCounterRawYield);
+ legRawYield->AddEntry(histogram,cutValue.Data(),"l");
+ legRawYield->Draw();
+ // histogram->DrawCopy("same");
+ histogram->Draw("same");
+ canvasRawYield->Update();
+ }
+ histogramCounterRawYield+=2;
+
+ }
+
+ if(histoname.Contains("SB_Pi0")){
+ canvasStoB->cd();
+ cout<<"Histogram contains SB: "<<histoname.Data()<<endl;
+ if(StoB==NULL){
+ cout<<"Setting first histogram"<<endl;
+ StoB = (TH1F*)f.Get(histoname.Data());
+ cout<<"Histoname: "<<histoname.Data()<<endl;
+ TString cutValue= histoname(histoname.Index("Pi0_")+4,histoname.Length());
+ cout<<"Cut Value is: "<<cutValue.Data()<<endl;
+ for(Int_t bin=1;bin<Raw_Yield->GetNbinsX();bin++){
+ TString perBinHistoName = Form("S/B %f <pt <%f",StoB->GetBinLowEdge(bin),StoB->GetBinLowEdge(bin)+StoB->GetBinWidth(bin));
+ StoBPerBin[bin]= new TH1F(perBinHistoName.Data(),perBinHistoName.Data(),32,0,32);
+ StoBPerBin[bin]->SetBinContent(histogramCounterStoB,StoB->GetBinContent(bin));
+ StoBPerBin[bin]->SetBinError(histogramCounterStoB,StoB->GetBinError(bin));
+ StoBPerBin[bin]->GetXaxis()->SetBinLabel(histogramCounterStoB,cutValue.Data());
+ }
+ legStoB->AddEntry(StoB,cutValue.Data(),"l");
+ StoB->DrawCopy();
+ canvasStoB->Update();
+ }
+ else{
+ colorCounterStoB++;
+ TH1F* histogram = (TH1F*)f.Get(histoname.Data());
+ cout<<"histogram number of bins: "<<histogram->GetNbinsX()<<endl;
+ TString cutValue= histoname(histoname.Index("Pi0_")+4,histoname.Length());
+ for(Int_t bin=1;bin<histogram->GetNbinsX();bin++){
+ // YieldPerBin[bin]= new TH1F(Form("yield bin %d",bin),Form("yield bin %d",bin),32,0,32);
+ StoBPerBin[bin]->SetBinContent(histogramCounterStoB,histogram->GetBinContent(bin));
+ StoBPerBin[bin]->SetBinError(histogramCounterStoB,histogram->GetBinError(bin));
+ StoBPerBin[bin]->GetXaxis()->SetBinLabel(histogramCounterStoB,cutValue.Data());
+ }
+
+ histogram->SetLineColor(colorCounterStoB);
+ legStoB->AddEntry(histogram,cutValue.Data(),"l");
+ legStoB->Draw();
+ histogram->DrawCopy("same");
+ canvasStoB->Update();
+ }
+ histogramCounterStoB+=2;
+ }
+
+ if(histoname.Contains("Significance_Pi0")){
+ canvasSignificance->cd();
+ cout<<"Histogram contains Significance: "<<histoname.Data()<<endl;
+ if(Significance==NULL){
+ cout<<"Setting first histogram"<<endl;
+ Significance = (TH1F*)f.Get(histoname.Data());
+ cout<<"Histoname: "<<histoname.Data()<<endl;
+ TString cutValue= histoname(histoname.Index("Pi0_")+4,histoname.Length());
+ cout<<"Cut Value is: "<<cutValue.Data()<<endl;
+ for(Int_t bin=1;bin<Raw_Yield->GetNbinsX();bin++){
+ TString perBinHistoName = Form("Significance %f <pt <%f",Significance->GetBinLowEdge(bin),Significance->GetBinLowEdge(bin)+Significance->GetBinWidth(bin));
+ SignificancePerBin[bin]= new TH1F(perBinHistoName.Data(),perBinHistoName.Data(),32,0,32);
+ SignificancePerBin[bin]->SetBinContent(histogramCounterSignificance,Significance->GetBinContent(bin));
+ SignificancePerBin[bin]->SetBinError(histogramCounterSignificance,Significance->GetBinError(bin));
+ SignificancePerBin[bin]->GetXaxis()->SetBinLabel(histogramCounterSignificance,cutValue.Data());
+ }
+ legSignificance->AddEntry(Significance,cutValue.Data(),"l");
+ Significance->DrawCopy();
+ canvasSignificance->Update();
+ // Raw_Yield = new TH1F("Raw_Yield","Raw_Yield",histogram->GetN)
+ }
+ else{
+ colorCounterSignificance++;
+ TH1F* histogram = (TH1F*)f.Get(histoname.Data());
+ cout<<"histogram number of bins: "<<histogram->GetNbinsX()<<endl;
+ TString cutValue= histoname(histoname.Index("Pi0_")+4,histoname.Length());
+ for(Int_t bin=1;bin<histogram->GetNbinsX();bin++){
+ // YieldPerBin[bin]= new TH1F(Form("yield bin %d",bin),Form("yield bin %d",bin),32,0,32);
+ SignificancePerBin[bin]->SetBinContent(histogramCounterSignificance,histogram->GetBinContent(bin));
+ SignificancePerBin[bin]->SetBinError(histogramCounterSignificance,histogram->GetBinError(bin));
+ SignificancePerBin[bin]->GetXaxis()->SetBinLabel(histogramCounterSignificance,cutValue.Data());
+ }
+
+ histogram->SetLineColor(colorCounterSignificance);
+ legSignificance->AddEntry(histogram,cutValue.Data(),"l");
+ legSignificance->Draw();
+ histogram->DrawCopy("same");
+ canvasSignificance->Update();
+ }
+ histogramCounterSignificance+=2;
+ }
+
+ if(histoname.Contains("Mass_Pi0")){
+ canvasMass->cd();
+ cout<<"Histogram contains Mass: "<<histoname.Data()<<endl;
+ if(Mass==NULL){
+ cout<<"Setting first histogram"<<endl;
+ Mass = (TH1F*)f.Get(histoname.Data());
+ Mass->SetMinimum(0.1);
+ Mass->SetMaximum(.16);
+ cout<<"Histoname: "<<histoname.Data()<<endl;
+ TString cutValue= histoname(histoname.Index("Pi0_")+4,histoname.Length());
+ cout<<"Cut Value is: "<<cutValue.Data()<<endl;
+ for(Int_t bin=1;bin<Raw_Yield->GetNbinsX();bin++){
+ TString perBinHistoName = Form("Mass %f <pt <%f",Mass->GetBinLowEdge(bin),Mass->GetBinLowEdge(bin)+Mass->GetBinWidth(bin));
+ MassPerBin[bin]= new TH1F(perBinHistoName.Data(),perBinHistoName.Data(),32,0,32);
+ MassPerBin[bin]->SetBinContent(histogramCounterMass,Mass->GetBinContent(bin));
+ MassPerBin[bin]->SetBinError(histogramCounterMass,Mass->GetBinError(bin));
+ MassPerBin[bin]->GetXaxis()->SetBinLabel(histogramCounterMass,cutValue.Data());
+ }
+ legMass->AddEntry(Mass,cutValue.Data(),"l");
+ Mass->DrawCopy();
+ canvasMass->Update();
+ // Raw_Yield = new TH1F("Raw_Yield","Raw_Yield",histogram->GetN)
+ }
+ else{
+ colorCounterMass++;
+ TH1F* histogram = (TH1F*)f.Get(histoname.Data());
+ cout<<"histogram number of bins: "<<histogram->GetNbinsX()<<endl;
+ TString cutValue= histoname(histoname.Index("Pi0_")+4,histoname.Length());
+ for(Int_t bin=1;bin<histogram->GetNbinsX();bin++){
+ // YieldPerBin[bin]= new TH1F(Form("yield bin %d",bin),Form("yield bin %d",bin),32,0,32);
+ MassPerBin[bin]->SetBinContent(histogramCounterMass,histogram->GetBinContent(bin));
+ MassPerBin[bin]->SetBinError(histogramCounterMass,histogram->GetBinError(bin));
+ MassPerBin[bin]->GetXaxis()->SetBinLabel(histogramCounterMass,cutValue.Data());
+ }
+
+ histogram->SetLineColor(colorCounterMass);
+ legMass->AddEntry(histogram,cutValue.Data(),"l");
+ legMass->Draw();
+ histogram->DrawCopy("same");
+ canvasMass->Update();
+ }
+ histogramCounterMass+=2;
+ }
+
+ if(histoname.Contains("FWHM_Pi0")){
+ canvasFWHM->cd();
+ cout<<"Histogram contains FWHM: "<<histoname.Data()<<endl;
+ if(FWHM==NULL){
+ cout<<"Setting first histogram"<<endl;
+ FWHM = (TH1F*)f.Get(histoname.Data());
+ cout<<"Histoname: "<<histoname.Data()<<endl;
+ TString cutValue= histoname(histoname.Index("Pi0_")+4,histoname.Length());
+ cout<<"Cut Value is: "<<cutValue.Data()<<endl;
+ for(Int_t bin=1;bin<Raw_Yield->GetNbinsX();bin++){
+ TString perBinHistoName = Form("FWHM %f <pt <%f",FWHM->GetBinLowEdge(bin),FWHM->GetBinLowEdge(bin)+FWHM->GetBinWidth(bin));
+ FWHMPerBin[bin]= new TH1F(perBinHistoName.Data(),perBinHistoName.Data(),32,0,32);
+ FWHMPerBin[bin]->SetBinContent(histogramCounterFWHM,FWHM->GetBinContent(bin));
+ FWHMPerBin[bin]->SetBinError(histogramCounterFWHM,FWHM->GetBinError(bin));
+ FWHMPerBin[bin]->GetXaxis()->SetBinLabel(histogramCounterFWHM,cutValue.Data());
+ }
+ legFWHM->AddEntry(FWHM,cutValue.Data(),"l");
+ FWHM->DrawCopy();
+ canvasFWHM->Update();
+ // Raw_Yield = new TH1F("Raw_Yield","Raw_Yield",histogram->GetN)
+ }
+ else{
+ colorCounterFWHM++;
+ TH1F* histogram = (TH1F*)f.Get(histoname.Data());
+ cout<<"histogram number of bins: "<<histogram->GetNbinsX()<<endl;
+ TString cutValue= histoname(histoname.Index("Pi0_")+4,histoname.Length());
+ for(Int_t bin=1;bin<histogram->GetNbinsX();bin++){
+ // YieldPerBin[bin]= new TH1F(Form("yield bin %d",bin),Form("yield bin %d",bin),32,0,32);
+ FWHMPerBin[bin]->SetBinContent(histogramCounterFWHM,histogram->GetBinContent(bin));
+ FWHMPerBin[bin]->SetBinError(histogramCounterFWHM,histogram->GetBinError(bin));
+ FWHMPerBin[bin]->GetXaxis()->SetBinLabel(histogramCounterFWHM,cutValue.Data());
+ }
+
+ histogram->SetLineColor(colorCounterFWHM);
+ legFWHM->AddEntry(histogram,cutValue.Data(),"l");
+ legFWHM->Draw();
+ histogram->DrawCopy("same");
+ canvasFWHM->Update();
+ }
+ histogramCounterFWHM+=2;
+ }
+
+ }//end of for loop over histograms
+
+
+
+ TPostScript *ps_characteristics;
+ ps_characteristics = new TPostScript(Form("%sPi0Characteristics.ps",path),111);
+ ps_characteristics->NewPage();
+
+
+ canvasRawYield->Update();
+ canvasRawYield->Draw();
+ ps_characteristics->NewPage();
+ canvasSignificance->Update();
+ canvasSignificance->Draw();
+ ps_characteristics->NewPage();
+ canvasStoB->Update();
+ canvasStoB->Draw();
+ ps_characteristics->NewPage();
+ canvasMass->Update();
+ canvasMass->Draw();
+ ps_characteristics->NewPage();
+ canvasFWHM->Update();
+ canvasFWHM->Draw();
+ ps_characteristics->NewPage();
+
+
+
+
+ /*
+
+ TCanvas *canvas1 = new TCanvas("Integrated1","",10,10,700,1000);
+ TPad *pad1 = new TPad("pad1","",0.,0.,1.,1.,0);
+ pad1->SetFillColor(0);
+ pad1->GetFrame()->SetFillColor(0);
+ pad1->SetBorderMode(0);
+ pad1->Divide(1,2);
+ pad1->Draw();
+
+ pad1->cd(1);
+ Raw_Yield->Draw();
+
+ pad1->cd(2);
+ StoB->Draw();
+ ps_characteristics->NewPage();
+
+
+ TCanvas *canvas2 = new TCanvas("Integrated2","",10,10,700,1000);
+ TPad *pad2 = new TPad("pad2","",0.,0.,1.,1.,0);
+ pad2->SetFillColor(0);
+ pad2->GetFrame()->SetFillColor(0);
+ pad2->SetBorderMode(0);
+ pad2->Divide(1,2);
+ pad2->Draw();
+
+ pad2->cd(1);
+ Significance->Draw();
+
+ pad2->cd(2);
+ Mass->Draw();
+
+ ps_characteristics->NewPage();
+
+ TCanvas *canvas3 = new TCanvas("Integrated3","",10,10,700,1000);
+ TPad *pad3 = new TPad("pad3","",0.,0.,1.,1.,0);
+ pad3->SetFillColor(0);
+ pad3->GetFrame()->SetFillColor(0);
+ pad3->SetBorderMode(0);
+ pad3->Divide(1,2);
+ pad3->Draw();
+
+ pad3->cd(1);
+ FWHM->Draw();
+
+ pad3->cd(2);
+ // Mass->Draw();
+ */
+ ps_characteristics->NewPage();
+
+ for(Int_t bin=2;bin<Raw_Yield->GetNbinsX();bin++){
+ TString canvasname= Form("bin %d",bin);
+ TCanvas *binC = new TCanvas(canvasname.Data(),"",10,10,700,1000);
+ TString padname= Form("pad %d",bin);
+ // TPad *pad = new TPad(padname.Data(),"",0.05,0.05,0.95,0.95,0);
+ TPad *pad = new TPad(padname.Data(),"",0.,0.,1.,1.,0);
+ pad->SetFillColor(0);
+ pad->GetFrame()->SetFillColor(0);
+ pad->SetBorderMode(0);
+ pad->Divide(1,5);
+ pad->Draw();
+
+ pad->cd(1);
+ YieldPerBin[bin]->Draw();
+
+ pad->cd(2);
+ StoBPerBin[bin]->Draw();
+
+ pad->cd(3);
+ SignificancePerBin[bin]->Draw();
+
+ pad->cd(4);
+ MassPerBin[bin]->Draw();
+
+ pad->cd(5);
+ FWHMPerBin[bin]->Draw();
+
+ binC->Update();
+ binC->Close();
+
+ ps_characteristics->NewPage();
+ binC->Close();
+ }
+
+ Int_t rebinValue=4;
+
+ for(Int_t cuts=0;cuts<cutsAdded;cuts++){
+ cout<<"CUT: "<<cutSelectionArray[cuts].Data()<<endl;
+ for(Int_t bin=2;bin<32;bin++){
+ TCanvas *canvasTest = new TCanvas("canvastest","",200,10,600,600);
+ TPad *pad = new TPad(padname.Data(),"",0.,0.,1.,1.,0);
+ pad->SetFillColor(0);
+ pad->GetFrame()->SetFillColor(0);
+ pad->SetBorderMode(0);
+ pad->Divide(1,2);
+ pad->Draw();
+
+ pad->cd(1);
+ TString namet= Form("Mapping_Reco_InvMass_in_Pt_Bin%s%02d",cutSelectionArray[cuts].Data(),bin);
+ cout<<"Getting histogram: "<<namet.Data()<<endl;
+ TH1F * signalt = (TH1F*)f.Get(namet.Data());
+ signalt->Rebin(rebinValue);
+ TString titlet= Form("Inv_Mass_cut%s_pt[%f,%f]",cutSelectionArray[cuts].Data(),lowBinLimits[bin],highBinLimits[bin]);
+ signalt->SetTitle(titlet.Data());
+ signalt->Sumw2();
+ signalt->SetAxisRange(0.,0.4);
+ signalt->Draw();
+
+ TString nameb= Form("Mapping_Back_InvMass_in_Pt_Bin%s%02d",cutSelectionArray[cuts].Data(),bin);
+ cout<<"Getting histogram: "<<nameb.Data()<<endl;
+ TH1F * signalb = (TH1F*)f.Get(nameb.Data());
+ signalb->Rebin(rebinValue);
+ TString titleb= Form("Inv_Mass_cut%s_pt[%f,%f]",cutSelectionArray[cuts].Data(),lowBinLimits[bin],highBinLimits[bin]);
+ signalb->SetTitle(titleb.Data());
+ signalb->SetAxisRange(0.,0.4);
+ signalb->SetLineColor(4);
+ signalb->Draw("same");
+
+ pad->cd(2);
+ canvasTest->SetFillColor(0);
+ TString name= Form("Mapping_Signal_InvMass_in_Pt_Bin%s%02d",cutSelectionArray[cuts].Data(),bin);
+ cout<<"Getting histogram: "<<name.Data()<<endl;
+ TH1F * signal = (TH1F*)f.Get(name.Data());
+ signal->Rebin(rebinValue);
+ TString title= Form("Signal_Inv_Mass_cut%s_pt[%f,%f]",cutSelectionArray[cuts].Data(),lowBinLimits[bin],highBinLimits[bin]);
+ signal->SetTitle(title.Data());
+ signal->SetAxisRange(0.,0.4);
+ signal->Draw();
+ canvasTest->Update();
+
+ ps_characteristics->NewPage();
+ }
+
+ }
+ ps_characteristics->Close();
+}
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff