#include "TGraph.h" #include "TGraphErrors.h" #include "TString.h" #include "TMultiGraph.h" #include "TLegend.h" #include "TCanvas.h" #include "TLatex.h" #include "TAxis.h" #include "TROOT.h" #include "TFile.h" #include #include #include #include struct FitResults { unsigned int run; unsigned int data; unsigned int lowtrunc; unsigned int hightrunc; double meanel; double meanelerr; double sigmael; double sigmaelerr; double meanpi; double meanpierr; double sigmapi; double sigmapierr; double separation1; double separation1err; double separation2; double separation2err; }; std::string inttostring(Int_t input) { std::string s; std::stringstream out; out << input; s = out.str(); return s; } //temporary solution: a map - better with root trees std::map fitresultsmap; void LoadData(TString datafile, unsigned int datasetnumber, unsigned int setlowtrunc, unsigned int sethightrunc){ ifstream instr; instr.open(datafile.Data()); if (instr.is_open()) std::cout<<"opened file: "<>run>>data>>lowtrunc>>hightrunc>>meanel>>meanelerr>>sigmael>>sigmaelerr>>meanpi>>meanpierr>>sigmapi>>sigmapierr>>separation1>>separation1err>>separation2>>separation2err; if(instr.eof()) break; cout << "reading data: " << run <<" "<< data << " "<< lowtrunc <<" "<< hightrunc<ProcessLine(".x ~/rootlogon_Bernhard.C"); gROOT->SetStyle("col"); gROOT->ForceStyle(); } LoadData("/nfs/hicran/project/panda/SIM/pgadow/fopiROOT_trunk/macro/ALICE/plots/dEdx/FITDATA.dat", datasetnumber, trunclow, trunchigh); TString dirname = "/nfs/mds/data/tpc/alice/ps_test_beam/dEdx/fitresults/"; TString filename = "dEdxFitResults"; filename+= "_"+inttostring(datasetnumber)+"_"+inttostring(trunclow)+"_"+inttostring(trunchigh); TString savefilename = dirname + filename + ".root"; TFile *savefile = new TFile(savefilename.Data(),"RECREATE"); savefile->cd(); //################################################################################################################################################ //1 GeV - Beam ################################################################################################################################### //################################################################################################################################################ //################################################################################################################################################ //Standard Gain: Mean ############################################################################################################################ //################################################################################################################################################ TCanvas *cstdmean = new TCanvas("cstdmean","dEdx standard gain mean",1000,700); cstdmean->SetFillColor(00); cstdmean->SetGrid(); cstdmean->cd(); TMultiGraph *mgstdmean = new TMultiGraph(); const int nstdmean = 5; double gainstdmean[nstdmean] = {69., 70., 71., 72., 73.}; double meanel[nstdmean]; double meanpi[nstdmean]; double dmeanel[nstdmean]; double dmeanpi[nstdmean]; meanel[0] = (fitresultsmap[681]).meanel; meanel[1] = (fitresultsmap[682]).meanel; meanel[2] = (fitresultsmap[683]).meanel; meanel[3] = (fitresultsmap[684]).meanel; meanel[4] = (fitresultsmap[685]).meanel; dmeanel[0] = (fitresultsmap[681]).meanelerr; dmeanel[1] = (fitresultsmap[682]).meanelerr; dmeanel[2] = (fitresultsmap[683]).meanelerr; dmeanel[3] = (fitresultsmap[684]).meanelerr; dmeanel[4] = (fitresultsmap[685]).meanelerr; meanpi[0] = (fitresultsmap[681]).meanpi; meanpi[1] = (fitresultsmap[682]).meanpi; meanpi[2] = (fitresultsmap[683]).meanpi; meanpi[3] = (fitresultsmap[684]).meanpi; meanpi[4] = (fitresultsmap[685]).meanpi; dmeanpi[0] = (fitresultsmap[681]).meanpierr; dmeanpi[1] = (fitresultsmap[682]).meanpierr; dmeanpi[2] = (fitresultsmap[683]).meanpierr; dmeanpi[3] = (fitresultsmap[684]).meanpierr; dmeanpi[4] = (fitresultsmap[685]).meanpierr; TGraphErrors* grmeanel = new TGraphErrors(nstdmean,gainstdmean,meanel,0,dmeanel); grmeanel->SetLineColor(1); grmeanel->SetLineWidth(1); grmeanel->SetMarkerColor(1); grmeanel->SetMarkerStyle(20); grmeanel->SetTitle("electrons"); mgstdmean->Add(grmeanel); TGraphErrors* grmeanpi = new TGraphErrors(nstdmean,gainstdmean,meanpi,0,dmeanpi); grmeanpi->SetLineColor(15); grmeanpi->SetLineWidth(1); grmeanpi->SetMarkerColor(15); grmeanpi->SetMarkerStyle(20); grmeanpi->SetTitle("pions"); mgstdmean->Add(grmeanpi); mgstdmean->Draw("ap"); mgstdmean->GetXaxis()->SetTitle("HV scaling factor (%)"); mgstdmean->GetYaxis()->SetTitle(""); mgstdmean->GetXaxis()->SetLimits(66,76); mgstdmean->GetYaxis()->SetRangeUser(0.001,400); TLegend *legstdmean=new TLegend(0.2,0.78,0.5,.9); legstdmean->SetBorderSize(1); legstdmean->SetFillColor(10); legstdmean->AddEntry(grmeanel,"electrons","p"); legstdmean->AddEntry(grmeanpi,"pions","p"); legstdmean->Draw("same"); cstdmean->Update(); cstdmean->Modified(); cstdmean->Write(); cstdmean->SaveAs(dirname+filename+"StdMean.pdf"); //################################################################################################################################################ //Standard Gain: Sigma ########################################################################################################################### //################################################################################################################################################ TCanvas *cstdsigma = new TCanvas("cstdsigma","dEdx standard gain sigma",1000,700); cstdsigma->SetFillColor(00); cstdsigma->SetGrid(); cstdsigma->cd(); TMultiGraph *mgstdsigma = new TMultiGraph(); const int nstdsigma = 5; double gainstdsigma[nstdsigma] = {69., 70., 71., 72., 73.}; double sigmael[nstdsigma]; double sigmapi[nstdsigma]; double dsigmael[nstdsigma]; double dsigmapi[nstdsigma]; sigmael[0] = (fitresultsmap[681]).sigmael*100; sigmael[1] = (fitresultsmap[682]).sigmael*100; sigmael[2] = (fitresultsmap[683]).sigmael*100; sigmael[3] = (fitresultsmap[684]).sigmael*100; sigmael[4] = (fitresultsmap[685]).sigmael*100; sigmapi[0] = (fitresultsmap[681]).sigmapi*100; sigmapi[1] = (fitresultsmap[682]).sigmapi*100; sigmapi[2] = (fitresultsmap[683]).sigmapi*100; sigmapi[3] = (fitresultsmap[684]).sigmapi*100; sigmapi[4] = (fitresultsmap[685]).sigmapi*100; dsigmael[0] = (fitresultsmap[681]).sigmaelerr*100; dsigmael[1] = (fitresultsmap[682]).sigmaelerr*100; dsigmael[2] = (fitresultsmap[683]).sigmaelerr*100; dsigmael[3] = (fitresultsmap[684]).sigmaelerr*100; dsigmael[4] = (fitresultsmap[685]).sigmaelerr*100; dsigmapi[0] = (fitresultsmap[681]).sigmapierr*100; dsigmapi[1] = (fitresultsmap[682]).sigmapierr*100; dsigmapi[2] = (fitresultsmap[683]).sigmapierr*100; dsigmapi[3] = (fitresultsmap[684]).sigmapierr*100; dsigmapi[4] = (fitresultsmap[685]).sigmapierr*100; TGraphErrors* grsigmael = new TGraphErrors(nstdsigma,gainstdsigma,sigmael,0,dsigmael); grsigmael->SetLineColor(1); grsigmael->SetLineWidth(1); grsigmael->SetMarkerColor(1); grsigmael->SetMarkerStyle(20); grsigmael->SetTitle("electrons"); mgstdsigma->Add(grsigmael); TGraphErrors* grsigmapi = new TGraphErrors(nstdsigma,gainstdsigma,sigmapi,0,dsigmapi); grsigmapi->SetLineColor(15); grsigmapi->SetLineWidth(1); grsigmapi->SetMarkerColor(15); grsigmapi->SetMarkerStyle(20); grsigmapi->SetTitle("pions"); mgstdsigma->Add(grsigmapi); mgstdsigma->Draw("ap"); mgstdsigma->GetXaxis()->SetTitle("HV scaling factor (%)"); mgstdsigma->GetYaxis()->SetTitle("#sigma(dE/dx)/ (%)"); mgstdsigma->GetXaxis()->SetLimits(66,76); mgstdsigma->GetYaxis()->SetRangeUser(7,15); TLegend *legstdsigma=new TLegend(0.2,0.78,0.5,.9); legstdsigma->SetBorderSize(1); legstdsigma->SetFillColor(10); legstdsigma->AddEntry(grmeanel,"electrons","p"); legstdsigma->AddEntry(grmeanpi,"pions","p"); legstdsigma->Draw("same"); cstdsigma->Update(); cstdsigma->Modified(); cstdsigma->Write(); cstdsigma->SaveAs(dirname+filename+"StdSigma.pdf"); //################################################################################################################################################ //IBF Gain Electrons: Mean ####################################################################################################################### //################################################################################################################################################ TCanvas *cibfelemean = new TCanvas("cibfelemean","dEdx IBF gain electron mean",1000,700); cibfelemean->SetFillColor(00); cibfelemean->SetGrid(); cibfelemean->cd(); TMultiGraph *mgibfelemean = new TMultiGraph(); const int nibfelemean = 4; double gainibfelemean[nibfelemean] = {100., 103.,105.,107.}; double tf200ibfelemean[nibfelemean]; double tf400ibfelemean[nibfelemean]; double tf600ibfelemean[nibfelemean]; double tf800ibfelemean[nibfelemean]; double dtf200ibfelemean[nibfelemean]; double dtf400ibfelemean[nibfelemean]; double dtf600ibfelemean[nibfelemean]; double dtf800ibfelemean[nibfelemean]; tf200ibfelemean[0] = (fitresultsmap[686]).meanel; tf200ibfelemean[1] = (fitresultsmap[691]).meanel; tf200ibfelemean[2] = (fitresultsmap[698]).meanel; tf200ibfelemean[3] = (fitresultsmap[703]).meanel; tf400ibfelemean[0] = (fitresultsmap[687]).meanel; tf400ibfelemean[1] = (fitresultsmap[692]).meanel; tf400ibfelemean[2] = (fitresultsmap[699]).meanel; tf400ibfelemean[3] = (fitresultsmap[704]).meanel; tf600ibfelemean[0] = (fitresultsmap[688]).meanel; tf600ibfelemean[1] = (fitresultsmap[693]).meanel; tf600ibfelemean[2] = (fitresultsmap[700]).meanel; tf600ibfelemean[3] = (fitresultsmap[709]).meanel; tf800ibfelemean[0] = (fitresultsmap[690]).meanel; tf800ibfelemean[1] = (fitresultsmap[694]).meanel; tf800ibfelemean[2] = (fitresultsmap[702]).meanel; tf800ibfelemean[3] = 0; dtf200ibfelemean[0] = (fitresultsmap[686]).meanelerr; dtf200ibfelemean[1] = (fitresultsmap[691]).meanelerr; dtf200ibfelemean[2] = (fitresultsmap[698]).meanelerr; dtf200ibfelemean[3] = (fitresultsmap[703]).meanelerr; dtf400ibfelemean[0] = (fitresultsmap[687]).meanelerr; dtf400ibfelemean[1] = (fitresultsmap[692]).meanelerr; dtf400ibfelemean[2] = (fitresultsmap[699]).meanelerr; dtf400ibfelemean[3] = (fitresultsmap[704]).meanelerr; dtf600ibfelemean[0] = (fitresultsmap[688]).meanelerr; dtf600ibfelemean[1] = (fitresultsmap[693]).meanelerr; dtf600ibfelemean[2] = (fitresultsmap[700]).meanelerr; dtf600ibfelemean[3] = (fitresultsmap[709]).meanelerr; dtf800ibfelemean[0] = (fitresultsmap[690]).meanelerr; dtf800ibfelemean[1] = (fitresultsmap[694]).meanelerr; dtf800ibfelemean[2] = (fitresultsmap[702]).meanelerr; dtf800ibfelemean[3] = 0; double gainibfelemeanstd[nstdmean] = {100.,101.449,102.899,104.348,105.797}; double meanelibf[nstdmean]; double dmeanelibf[nstdmean]; meanelibf[0] = (fitresultsmap[681]).meanel; meanelibf[1] = (fitresultsmap[682]).meanel; meanelibf[2] = (fitresultsmap[683]).meanel; meanelibf[3] = (fitresultsmap[684]).meanel; meanelibf[4] = (fitresultsmap[685]).meanel; dmeanelibf[0] = (fitresultsmap[681]).meanelerr; dmeanelibf[1] = (fitresultsmap[682]).meanelerr; dmeanelibf[2] = (fitresultsmap[683]).meanelerr; dmeanelibf[3] = (fitresultsmap[684]).meanelerr; dmeanelibf[4] = (fitresultsmap[685]).meanelerr; TGraphErrors* grtf200ibfelemean = new TGraphErrors(nibfelemean,gainibfelemean,tf200ibfelemean,0,dtf200ibfelemean); grtf200ibfelemean->SetLineColor(1); grtf200ibfelemean->SetLineWidth(1); grtf200ibfelemean->SetMarkerColor(1); grtf200ibfelemean->SetMarkerStyle(20); grtf200ibfelemean->SetTitle("TF 200"); mgibfelemean->Add(grtf200ibfelemean); TGraphErrors* grtf400ibfelemean = new TGraphErrors(nibfelemean,gainibfelemean,tf400ibfelemean,0,dtf400ibfelemean); grtf400ibfelemean->SetLineColor(4); grtf400ibfelemean->SetLineWidth(1); grtf400ibfelemean->SetMarkerColor(4); grtf400ibfelemean->SetMarkerStyle(20); grtf400ibfelemean->SetTitle("TF 400"); mgibfelemean->Add(grtf400ibfelemean); TGraphErrors* grtf600ibfelemean = new TGraphErrors(nibfelemean,gainibfelemean,tf600ibfelemean,0,dtf600ibfelemean); grtf600ibfelemean->SetLineColor(kOrange); grtf600ibfelemean->SetLineWidth(1); grtf600ibfelemean->SetMarkerColor(kOrange); grtf600ibfelemean->SetMarkerStyle(20); grtf600ibfelemean->SetTitle("TF 600"); mgibfelemean->Add(grtf600ibfelemean); TGraphErrors* grtf800ibfelemean = new TGraphErrors(nibfelemean,gainibfelemean,tf800ibfelemean,0,dtf800ibfelemean); grtf800ibfelemean->SetLineColor(2); grtf800ibfelemean->SetLineWidth(1); grtf800ibfelemean->SetMarkerColor(2); grtf800ibfelemean->SetMarkerStyle(20); grtf800ibfelemean->SetTitle("TF 800"); mgibfelemean->Add(grtf800ibfelemean); TGraphErrors* grstdibfelemean = new TGraphErrors(nstdmean,gainibfelemeanstd,meanelibf,0,dmeanelibf); grstdibfelemean->SetLineColor(15); grstdibfelemean->SetLineWidth(1); grstdibfelemean->SetMarkerColor(15); grstdibfelemean->SetMarkerStyle(20); grstdibfelemean->SetTitle("Standard"); mgibfelemean->Add(grstdibfelemean); mgibfelemean->Draw("ap"); mgibfelemean->GetXaxis()->SetTitle("HV scaling factor (%)"); mgibfelemean->GetYaxis()->SetTitle(" electrons"); mgibfelemean->GetXaxis()->SetLimits(98,109); mgibfelemean->GetYaxis()->SetRangeUser(0.001,500); TLegend *legibfelemean=new TLegend(0.2,0.65,0.5,.9); legibfelemean->SetBorderSize(1); legibfelemean->SetFillColor(10); legibfelemean->AddEntry(grtf200ibfelemean,"TF 200","p"); legibfelemean->AddEntry(grtf400ibfelemean,"TF 400","p"); legibfelemean->AddEntry(grtf600ibfelemean,"TF 600","p"); legibfelemean->AddEntry(grtf800ibfelemean,"TF 800","p"); legibfelemean->AddEntry(grstdibfelemean,"Std. #upoint 100/69","p"); legibfelemean->Draw("same"); cibfelemean->Update(); cibfelemean->Modified(); cibfelemean->Write(); cibfelemean->SaveAs(dirname+filename+"IbfElMean.pdf"); //################################################################################################################################################ //IBF Gain Pions: Mean ########################################################################################################################### //################################################################################################################################################ TCanvas *cibfpimean = new TCanvas("cibfpimean","dEdx IBF gain pion mean",1000,700); cibfpimean->SetFillColor(00); cibfpimean->SetGrid(); cibfpimean->cd(); TMultiGraph *mgibfpimean = new TMultiGraph(); const int nibfpimean = 4; double gainibfpimean[nibfpimean] = {100., 103.,105.,107.}; double tf200ibfpimean[nibfpimean]; double tf400ibfpimean[nibfpimean]; double tf600ibfpimean[nibfpimean]; double tf800ibfpimean[nibfpimean]; double dtf200ibfpimean[nibfpimean]; double dtf400ibfpimean[nibfpimean]; double dtf600ibfpimean[nibfpimean]; double dtf800ibfpimean[nibfpimean]; tf200ibfpimean[0] = (fitresultsmap[686]).meanpi; tf200ibfpimean[1] = (fitresultsmap[691]).meanpi; tf200ibfpimean[2] = (fitresultsmap[698]).meanpi; tf200ibfpimean[3] = (fitresultsmap[703]).meanpi; tf400ibfpimean[0] = (fitresultsmap[687]).meanpi; tf400ibfpimean[1] = (fitresultsmap[692]).meanpi; tf400ibfpimean[2] = (fitresultsmap[699]).meanpi; tf400ibfpimean[3] = (fitresultsmap[704]).meanpi; tf600ibfpimean[0] = (fitresultsmap[688]).meanpi; tf600ibfpimean[1] = (fitresultsmap[693]).meanpi; tf600ibfpimean[2] = (fitresultsmap[700]).meanpi; tf600ibfpimean[3] = (fitresultsmap[709]).meanpi; tf800ibfpimean[0] = (fitresultsmap[690]).meanpi; tf800ibfpimean[1] = (fitresultsmap[694]).meanpi; tf800ibfpimean[2] = (fitresultsmap[702]).meanpi; tf800ibfpimean[3] = 0; dtf200ibfpimean[0] = (fitresultsmap[686]).meanpierr; dtf200ibfpimean[1] = (fitresultsmap[691]).meanpierr; dtf200ibfpimean[2] = (fitresultsmap[698]).meanpierr; dtf200ibfpimean[3] = (fitresultsmap[703]).meanpierr; dtf400ibfpimean[0] = (fitresultsmap[687]).meanpierr; dtf400ibfpimean[1] = (fitresultsmap[692]).meanpierr; dtf400ibfpimean[2] = (fitresultsmap[699]).meanpierr; dtf400ibfpimean[3] = (fitresultsmap[704]).meanpierr; dtf600ibfpimean[0] = (fitresultsmap[688]).meanpierr; dtf600ibfpimean[1] = (fitresultsmap[693]).meanpierr; dtf600ibfpimean[2] = (fitresultsmap[700]).meanpierr; dtf600ibfpimean[3] = (fitresultsmap[709]).meanpierr; dtf800ibfpimean[0] = (fitresultsmap[690]).meanpierr; dtf800ibfpimean[1] = (fitresultsmap[694]).meanpierr; dtf800ibfpimean[2] = (fitresultsmap[702]).meanpierr; dtf800ibfpimean[3] = 0; double gainibfpimeanstd[nstdmean] = {100.,101.449,102.899,104.348,105.797}; double meanpiibfstd[nstdmean]; double dmeanpiibfstd[nstdmean]; meanpiibfstd[0] = (fitresultsmap[681]).meanpi; meanpiibfstd[1] = (fitresultsmap[682]).meanpi; meanpiibfstd[2] = (fitresultsmap[683]).meanpi; meanpiibfstd[3] = (fitresultsmap[684]).meanpi; meanpiibfstd[4] = (fitresultsmap[685]).meanpi; dmeanpiibfstd[0] = (fitresultsmap[681]).meanpierr; dmeanpiibfstd[1] = (fitresultsmap[682]).meanpierr; dmeanpiibfstd[2] = (fitresultsmap[683]).meanpierr; dmeanpiibfstd[3] = (fitresultsmap[684]).meanpierr; dmeanpiibfstd[4] = (fitresultsmap[685]).meanpierr; TGraphErrors* grtf200ibfpimean = new TGraphErrors(nibfpimean,gainibfpimean,tf200ibfpimean,0,dtf200ibfpimean); grtf200ibfpimean->SetLineColor(1); grtf200ibfpimean->SetLineWidth(1); grtf200ibfpimean->SetMarkerColor(1); grtf200ibfpimean->SetMarkerStyle(20); grtf200ibfpimean->SetTitle("TF 200"); mgibfpimean->Add(grtf200ibfpimean); TGraphErrors* grtf400ibfpimean = new TGraphErrors(nibfpimean,gainibfpimean,tf400ibfpimean,0,dtf400ibfpimean); grtf400ibfpimean->SetLineColor(4); grtf400ibfpimean->SetLineWidth(1); grtf400ibfpimean->SetMarkerColor(4); grtf400ibfpimean->SetMarkerStyle(20); grtf400ibfpimean->SetTitle("TF 400"); mgibfpimean->Add(grtf400ibfpimean); TGraphErrors* grtf600ibfpimean = new TGraphErrors(nibfpimean,gainibfpimean,tf600ibfpimean,0,dtf600ibfpimean); grtf600ibfpimean->SetLineColor(kOrange); grtf600ibfpimean->SetLineWidth(1); grtf600ibfpimean->SetMarkerColor(kOrange); grtf600ibfpimean->SetMarkerStyle(20); grtf600ibfpimean->SetTitle("TF 600"); mgibfpimean->Add(grtf600ibfpimean); TGraphErrors* grtf800ibfpimean = new TGraphErrors(nibfpimean,gainibfpimean,tf800ibfpimean,0,dtf800ibfpimean); grtf800ibfpimean->SetLineColor(2); grtf800ibfpimean->SetLineWidth(1); grtf800ibfpimean->SetMarkerColor(2); grtf800ibfpimean->SetMarkerStyle(20); grtf800ibfpimean->SetTitle("TF 800"); mgibfpimean->Add(grtf800ibfpimean); TGraphErrors* grstdibfpimean = new TGraphErrors(nstdmean,gainibfpimeanstd,meanpiibfstd,0,dmeanpiibfstd); grstdibfpimean->SetLineColor(15); grstdibfpimean->SetLineWidth(1); grstdibfpimean->SetMarkerColor(15); grstdibfpimean->SetMarkerStyle(20); grstdibfpimean->SetTitle("Standard"); mgibfpimean->Add(grstdibfpimean); mgibfpimean->Draw("ap"); mgibfpimean->GetXaxis()->SetTitle("HV scaling factor (%)"); mgibfpimean->GetYaxis()->SetTitle(" pions"); mgibfpimean->GetXaxis()->SetLimits(98,109); mgibfpimean->GetYaxis()->SetRangeUser(0.001,400); TLegend *legibfpimean=new TLegend(0.2,0.65,0.5,.9); legibfpimean->SetBorderSize(1); legibfpimean->SetFillColor(10); legibfpimean->AddEntry(grtf200ibfpimean,"TF 200","p"); legibfpimean->AddEntry(grtf400ibfpimean,"TF 400","p"); legibfpimean->AddEntry(grtf600ibfpimean,"TF 600","p"); legibfpimean->AddEntry(grtf800ibfpimean,"TF 800","p"); legibfpimean->AddEntry(grstdibfpimean,"Std. #upoint 100/69","p"); legibfpimean->Draw("same"); cibfpimean->Update(); cibfpimean->Modified(); cibfpimean->Write(); cibfpimean->SaveAs(dirname+filename+"IbfPiMean.pdf"); //################################################################################################################################################ //IBF Gain Electrons: Sigma ###################################################################################################################### //################################################################################################################################################ TCanvas *cibfelesigma = new TCanvas("cibfelesigma","dEdx IBF gain electron sigma",1000,700); cibfelesigma->SetFillColor(00); cibfelesigma->SetGrid(); cibfelesigma->cd(); TMultiGraph *mgibfelesigma = new TMultiGraph(); const int nibfelesigma = 4; double gainibfelesigma[nibfelesigma] = {100., 103.,105.,107.}; double tf200ibfelesigma[nibfelesigma]; double tf400ibfelesigma[nibfelesigma]; double tf600ibfelesigma[nibfelesigma]; double tf800ibfelesigma[nibfelesigma]; double dtf200ibfelesigma[nibfelesigma]; double dtf400ibfelesigma[nibfelesigma]; double dtf600ibfelesigma[nibfelesigma]; double dtf800ibfelesigma[nibfelesigma]; tf200ibfelesigma[0] = (fitresultsmap[686]).sigmael*100; tf200ibfelesigma[1] = (fitresultsmap[691]).sigmael*100; tf200ibfelesigma[2] = (fitresultsmap[698]).sigmael*100; tf200ibfelesigma[3] = (fitresultsmap[703]).sigmael*100; tf400ibfelesigma[0] = (fitresultsmap[687]).sigmael*100; tf400ibfelesigma[1] = (fitresultsmap[692]).sigmael*100; tf400ibfelesigma[2] = (fitresultsmap[699]).sigmael*100; tf400ibfelesigma[3] = (fitresultsmap[704]).sigmael*100; tf600ibfelesigma[0] = (fitresultsmap[688]).sigmael*100; tf600ibfelesigma[1] = (fitresultsmap[693]).sigmael*100; tf600ibfelesigma[2] = (fitresultsmap[700]).sigmael*100; tf600ibfelesigma[3] = (fitresultsmap[709]).sigmael*100; tf800ibfelesigma[0] = (fitresultsmap[690]).sigmael*100; tf800ibfelesigma[1] = (fitresultsmap[694]).sigmael*100; tf800ibfelesigma[2] = (fitresultsmap[702]).sigmael*100; tf800ibfelesigma[3] = 0; dtf200ibfelesigma[0] = (fitresultsmap[686]).sigmaelerr*100; dtf200ibfelesigma[1] = (fitresultsmap[691]).sigmaelerr*100; dtf200ibfelesigma[2] = (fitresultsmap[698]).sigmaelerr*100; dtf200ibfelesigma[3] = (fitresultsmap[703]).sigmaelerr*100; dtf400ibfelesigma[0] = (fitresultsmap[687]).sigmaelerr*100; dtf400ibfelesigma[1] = (fitresultsmap[692]).sigmaelerr*100; dtf400ibfelesigma[2] = (fitresultsmap[699]).sigmaelerr*100; dtf400ibfelesigma[3] = (fitresultsmap[704]).sigmaelerr*100; dtf600ibfelesigma[0] = (fitresultsmap[688]).sigmaelerr*100; dtf600ibfelesigma[1] = (fitresultsmap[693]).sigmaelerr*100; dtf600ibfelesigma[2] = (fitresultsmap[700]).sigmaelerr*100; dtf600ibfelesigma[3] = (fitresultsmap[709]).sigmaelerr*100; dtf800ibfelesigma[0] = (fitresultsmap[690]).sigmaelerr*100; dtf800ibfelesigma[1] = (fitresultsmap[694]).sigmaelerr*100; dtf800ibfelesigma[2] = (fitresultsmap[702]).sigmaelerr*100; dtf800ibfelesigma[3] = 0; double gainibfelesigmastd[nstdsigma] = {100.,101.449,102.899,104.348,105.797}; double sigmaelibfstd[nstdsigma]; double dsigmaelibfstd[nstdsigma]; sigmaelibfstd[0] = (fitresultsmap[681]).sigmael*100; sigmaelibfstd[1] = (fitresultsmap[682]).sigmael*100; sigmaelibfstd[2] = (fitresultsmap[683]).sigmael*100; sigmaelibfstd[3] = (fitresultsmap[684]).sigmael*100; sigmaelibfstd[4] = (fitresultsmap[685]).sigmael*100; dsigmaelibfstd[0] = (fitresultsmap[681]).sigmaelerr*100; dsigmaelibfstd[1] = (fitresultsmap[682]).sigmaelerr*100; dsigmaelibfstd[2] = (fitresultsmap[683]).sigmaelerr*100; dsigmaelibfstd[3] = (fitresultsmap[684]).sigmaelerr*100; dsigmaelibfstd[4] = (fitresultsmap[685]).sigmaelerr*100; TGraphErrors* grtf200ibfelesigma = new TGraphErrors(nibfelesigma,gainibfelesigma,tf200ibfelesigma,0,dtf200ibfelesigma); grtf200ibfelesigma->SetLineColor(1); grtf200ibfelesigma->SetLineWidth(1); grtf200ibfelesigma->SetMarkerColor(1); grtf200ibfelesigma->SetMarkerStyle(20); grtf200ibfelesigma->SetTitle("TF 200"); mgibfelesigma->Add(grtf200ibfelesigma); TGraphErrors* grtf400ibfelesigma = new TGraphErrors(nibfelesigma,gainibfelesigma,tf400ibfelesigma,0,dtf400ibfelesigma); grtf400ibfelesigma->SetLineColor(4); grtf400ibfelesigma->SetLineWidth(1); grtf400ibfelesigma->SetMarkerColor(4); grtf400ibfelesigma->SetMarkerStyle(20); grtf400ibfelesigma->SetTitle("TF 400"); mgibfelesigma->Add(grtf400ibfelesigma); TGraphErrors* grtf600ibfelesigma = new TGraphErrors(nibfelesigma,gainibfelesigma,tf600ibfelesigma,0,dtf600ibfelesigma); grtf600ibfelesigma->SetLineColor(kOrange); grtf600ibfelesigma->SetLineWidth(1); grtf600ibfelesigma->SetMarkerColor(kOrange); grtf600ibfelesigma->SetMarkerStyle(20); grtf600ibfelesigma->SetTitle("TF 600"); mgibfelesigma->Add(grtf600ibfelesigma); TGraphErrors* grtf800ibfelesigma = new TGraphErrors(nibfelesigma,gainibfelesigma,tf800ibfelesigma,0,dtf800ibfelesigma); grtf800ibfelesigma->SetLineColor(2); grtf800ibfelesigma->SetLineWidth(1); grtf800ibfelesigma->SetMarkerColor(2); grtf800ibfelesigma->SetMarkerStyle(20); grtf800ibfelesigma->SetTitle("TF 800"); mgibfelesigma->Add(grtf800ibfelesigma); TGraphErrors* grstdibfelesigma = new TGraphErrors(nstdsigma,gainibfelesigmastd,sigmaelibfstd,0,dsigmaelibfstd); grstdibfelesigma->SetLineColor(15); grstdibfelesigma->SetLineWidth(1); grstdibfelesigma->SetMarkerColor(15); grstdibfelesigma->SetMarkerStyle(20); grstdibfelesigma->SetTitle("Standard"); mgibfelesigma->Add(grstdibfelesigma); mgibfelesigma->Draw("ap"); mgibfelesigma->GetXaxis()->SetTitle("HV scaling factor (%)"); mgibfelesigma->GetYaxis()->SetTitle("#sigma(dE/dx)/ (%) electrons"); mgibfelesigma->GetXaxis()->SetLimits(98,109); mgibfelesigma->GetYaxis()->SetRangeUser(8,14); TLegend *legibfelesigma=new TLegend( 0.6,0.65,0.9,.9); legibfelesigma->SetBorderSize(1); legibfelesigma->SetFillColor(10); legibfelesigma->AddEntry(grtf200ibfelesigma,"TF 200","p"); legibfelesigma->AddEntry(grtf400ibfelesigma,"TF 400","p"); legibfelesigma->AddEntry(grtf600ibfelesigma,"TF 600","p"); legibfelesigma->AddEntry(grtf800ibfelesigma,"TF 800","p"); legibfelesigma->AddEntry(grstdibfelesigma,"Std. #upoint 100/69","p"); legibfelesigma->Draw("same"); cibfelesigma->Update(); cibfelesigma->Modified(); cibfelesigma->Write(); cibfelesigma->SaveAs(dirname+filename+"IbfElSigma.pdf"); //################################################################################################################################################ //IBF Gain Pions: Sigma ########################################################################################################################## //################################################################################################################################################ TCanvas *cibfpisigma = new TCanvas("cibfpisigma","dEdx IBF gain pion sigma",1000,700); cibfpisigma->SetFillColor(00); cibfpisigma->SetGrid(); cibfpisigma->cd(); TMultiGraph *mgibfpisigma = new TMultiGraph(); const int nibfpisigma = 4; double gainibfpisigma[nibfpisigma] = {100., 103.,105.,107.}; double tf200ibfpisigma[nibfpisigma]; double tf400ibfpisigma[nibfpisigma]; double tf600ibfpisigma[nibfpisigma]; double tf800ibfpisigma[nibfpisigma]; double dtf200ibfpisigma[nibfpisigma]; double dtf400ibfpisigma[nibfpisigma]; double dtf600ibfpisigma[nibfpisigma]; double dtf800ibfpisigma[nibfpisigma]; tf200ibfpisigma[0] = (fitresultsmap[686]).sigmapi*100; tf200ibfpisigma[1] = (fitresultsmap[691]).sigmapi*100; tf200ibfpisigma[2] = (fitresultsmap[698]).sigmapi*100; tf200ibfpisigma[3] = (fitresultsmap[703]).sigmapi*100; tf400ibfpisigma[0] = (fitresultsmap[687]).sigmapi*100; tf400ibfpisigma[1] = (fitresultsmap[692]).sigmapi*100; tf400ibfpisigma[2] = (fitresultsmap[699]).sigmapi*100; tf400ibfpisigma[3] = (fitresultsmap[704]).sigmapi*100; tf600ibfpisigma[0] = (fitresultsmap[688]).sigmapi*100; tf600ibfpisigma[1] = (fitresultsmap[693]).sigmapi*100; tf600ibfpisigma[2] = (fitresultsmap[700]).sigmapi*100; tf600ibfpisigma[3] = (fitresultsmap[709]).sigmapi*100; tf800ibfpisigma[0] = (fitresultsmap[690]).sigmapi*100; tf800ibfpisigma[1] = (fitresultsmap[694]).sigmapi*100; tf800ibfpisigma[2] = (fitresultsmap[702]).sigmapi*100; tf800ibfpisigma[3] = 0; dtf200ibfpisigma[0] = (fitresultsmap[686]).sigmapierr*100; dtf200ibfpisigma[1] = (fitresultsmap[691]).sigmapierr*100; dtf200ibfpisigma[2] = (fitresultsmap[698]).sigmapierr*100; dtf200ibfpisigma[3] = (fitresultsmap[703]).sigmapierr*100; dtf400ibfpisigma[0] = (fitresultsmap[687]).sigmapierr*100; dtf400ibfpisigma[1] = (fitresultsmap[692]).sigmapierr*100; dtf400ibfpisigma[2] = (fitresultsmap[699]).sigmapierr*100; dtf400ibfpisigma[3] = (fitresultsmap[704]).sigmapierr*100; dtf600ibfpisigma[0] = (fitresultsmap[688]).sigmapierr*100; dtf600ibfpisigma[1] = (fitresultsmap[693]).sigmapierr*100; dtf600ibfpisigma[2] = (fitresultsmap[700]).sigmapierr*100; dtf600ibfpisigma[3] = (fitresultsmap[709]).sigmapierr*100; dtf800ibfpisigma[0] = (fitresultsmap[690]).sigmapierr*100; dtf800ibfpisigma[1] = (fitresultsmap[694]).sigmapierr*100; dtf800ibfpisigma[2] = (fitresultsmap[702]).sigmapierr*100; dtf800ibfpisigma[3] = 0; double gainibfpisigmastd[nstdsigma] = {100.,101.449,102.899,104.348,105.797}; double sigmapiibfstd[nstdsigma]; double dsigmapiibfstd[nstdsigma]; sigmapiibfstd[0] = (fitresultsmap[681]).sigmapi*100; sigmapiibfstd[1] = (fitresultsmap[682]).sigmapi*100; sigmapiibfstd[2] = (fitresultsmap[683]).sigmapi*100; sigmapiibfstd[3] = (fitresultsmap[684]).sigmapi*100; sigmapiibfstd[4] = (fitresultsmap[685]).sigmapi*100; dsigmapiibfstd[0] = (fitresultsmap[681]).sigmapierr*100; dsigmapiibfstd[1] = (fitresultsmap[682]).sigmapierr*100; dsigmapiibfstd[2] = (fitresultsmap[683]).sigmapierr*100; dsigmapiibfstd[3] = (fitresultsmap[684]).sigmapierr*100; dsigmapiibfstd[4] = (fitresultsmap[685]).sigmapierr*100; TGraphErrors* grtf200ibfpisigma = new TGraphErrors(nibfpisigma,gainibfpisigma,tf200ibfpisigma,0,dtf200ibfpisigma); grtf200ibfpisigma->SetLineColor(1); grtf200ibfpisigma->SetLineWidth(1); grtf200ibfpisigma->SetMarkerColor(1); grtf200ibfpisigma->SetMarkerStyle(20); grtf200ibfpisigma->SetTitle("TF 200"); mgibfpisigma->Add(grtf200ibfpisigma); TGraphErrors* grtf400ibfpisigma = new TGraphErrors(nibfpisigma,gainibfpisigma,tf400ibfpisigma,0,dtf400ibfpisigma); grtf400ibfpisigma->SetLineColor(4); grtf400ibfpisigma->SetLineWidth(1); grtf400ibfpisigma->SetMarkerColor(4); grtf400ibfpisigma->SetMarkerStyle(20); grtf400ibfpisigma->SetTitle("TF 400"); mgibfpisigma->Add(grtf400ibfpisigma); TGraphErrors* grtf600ibfpisigma = new TGraphErrors(nibfpisigma,gainibfpisigma,tf600ibfpisigma,0,dtf600ibfpisigma); grtf600ibfpisigma->SetLineColor(kOrange); grtf600ibfpisigma->SetLineWidth(1); grtf600ibfpisigma->SetMarkerColor(kOrange); grtf600ibfpisigma->SetMarkerStyle(20); grtf600ibfpisigma->SetTitle("TF 600"); mgibfpisigma->Add(grtf600ibfpisigma); TGraphErrors* grtf800ibfpisigma = new TGraphErrors(nibfpisigma,gainibfpisigma,tf800ibfpisigma,0,dtf800ibfpisigma); grtf800ibfpisigma->SetLineColor(2); grtf800ibfpisigma->SetLineWidth(1); grtf800ibfpisigma->SetMarkerColor(2); grtf800ibfpisigma->SetMarkerStyle(20); grtf800ibfpisigma->SetTitle("TF 800"); mgibfpisigma->Add(grtf800ibfpisigma); TGraphErrors* grstdibfpisigma = new TGraphErrors(nstdsigma,gainibfpisigmastd,sigmapiibfstd,0,dsigmapiibfstd); grstdibfpisigma->SetLineColor(15); grstdibfpisigma->SetLineWidth(1); grstdibfpisigma->SetMarkerColor(15); grstdibfpisigma->SetMarkerStyle(20); grstdibfpisigma->SetTitle("Standard"); mgibfpisigma->Add(grstdibfpisigma); mgibfpisigma->Draw("ap"); mgibfpisigma->GetXaxis()->SetTitle("HV scaling factor (%)"); mgibfpisigma->GetYaxis()->SetTitle("#sigma(dE/dx)/ (%) pions"); mgibfpisigma->GetXaxis()->SetLimits(98,109); mgibfpisigma->GetYaxis()->SetRangeUser(8,14); TLegend *legibfpisigma=new TLegend(0.2,0.17,0.5,.42); legibfpisigma->SetBorderSize(1); legibfpisigma->SetFillColor(10); legibfpisigma->AddEntry(grtf200ibfpisigma,"TF 200","p"); legibfpisigma->AddEntry(grtf400ibfpisigma,"TF 400","p"); legibfpisigma->AddEntry(grtf600ibfpisigma,"TF 600","p"); legibfpisigma->AddEntry(grtf800ibfpisigma,"TF 800","p"); legibfpisigma->AddEntry(grstdibfpisigma,"Std. #upoint 100/69","p"); legibfpisigma->Draw("same"); cibfpisigma->Update(); cibfpisigma->Modified(); cibfpisigma->Write(); cibfpisigma->SaveAs(dirname+filename+"IbfPiSigma.pdf"); //################################################################################################################################################ //IBF Gain: Separation Power ##################################################################################################################### //################################################################################################################################################ TCanvas *cibfsep = new TCanvas("cibfsep","dEdx IBF Separation Power",1000,700); cibfsep->SetFillColor(00); cibfsep->SetGrid(); cibfsep->cd(); TMultiGraph *mgibfsep = new TMultiGraph(); const int nibfsep = 4; double gainibfsep[nibfsep] = {100., 103.,105.,107.}; double tf200ibfsep[nibfsep]; double tf400ibfsep[nibfsep]; double tf600ibfsep[nibfsep]; double tf800ibfsep[nibfsep]; double dtf200ibfsep[nibfsep]; double dtf400ibfsep[nibfsep]; double dtf600ibfsep[nibfsep]; double dtf800ibfsep[nibfsep]; tf200ibfsep[0] = (fitresultsmap[686]).separation2; tf200ibfsep[1] = (fitresultsmap[691]).separation2; tf200ibfsep[2] = (fitresultsmap[698]).separation2; tf200ibfsep[3] = (fitresultsmap[703]).separation2; tf400ibfsep[0] = (fitresultsmap[687]).separation2; tf400ibfsep[1] = (fitresultsmap[692]).separation2; tf400ibfsep[2] = (fitresultsmap[699]).separation2; tf400ibfsep[3] = (fitresultsmap[704]).separation2; tf600ibfsep[0] = (fitresultsmap[688]).separation2; tf600ibfsep[1] = (fitresultsmap[693]).separation2; tf600ibfsep[2] = (fitresultsmap[700]).separation2; tf600ibfsep[3] = (fitresultsmap[709]).separation2; tf800ibfsep[0] = (fitresultsmap[690]).separation2; tf800ibfsep[1] = (fitresultsmap[694]).separation2; tf800ibfsep[2] = (fitresultsmap[702]).separation2; tf800ibfsep[3] = 0; dtf200ibfsep[0] = (fitresultsmap[686]).separation2err; dtf200ibfsep[1] = (fitresultsmap[691]).separation2err; dtf200ibfsep[2] = (fitresultsmap[698]).separation2err; dtf200ibfsep[3] = (fitresultsmap[703]).separation2err; dtf400ibfsep[0] = (fitresultsmap[687]).separation2err; dtf400ibfsep[1] = (fitresultsmap[692]).separation2err; dtf400ibfsep[2] = (fitresultsmap[699]).separation2err; dtf400ibfsep[3] = (fitresultsmap[704]).separation2err; dtf600ibfsep[0] = (fitresultsmap[688]).separation2err; dtf600ibfsep[1] = (fitresultsmap[693]).separation2err; dtf600ibfsep[2] = (fitresultsmap[700]).separation2err; dtf600ibfsep[3] = (fitresultsmap[709]).separation2err; dtf800ibfsep[0] = (fitresultsmap[690]).separation2err; dtf800ibfsep[1] = (fitresultsmap[694]).separation2err; dtf800ibfsep[2] = (fitresultsmap[702]).separation2err; dtf800ibfsep[3] = 0; const int nstdsep = 5; double gainstdsep[nstdsep] = {100.,101.449,102.899,104.348,105.797}; double stdsep[nstdsep]; double dstdsep[nstdsep]; stdsep[0] = (fitresultsmap[681]).separation2; stdsep[1] = (fitresultsmap[682]).separation2; stdsep[2] = (fitresultsmap[683]).separation2; stdsep[3] = (fitresultsmap[684]).separation2; stdsep[4] = (fitresultsmap[685]).separation2; dstdsep[0] = (fitresultsmap[681]).separation2err; dstdsep[1] = (fitresultsmap[682]).separation2err; dstdsep[2] = (fitresultsmap[683]).separation2err; dstdsep[3] = (fitresultsmap[684]).separation2err; dstdsep[4] = (fitresultsmap[685]).separation2err; TGraphErrors* grstdsep = new TGraphErrors(nibfsep,gainstdsep,stdsep,0,dstdsep); grstdsep->SetLineColor(15); grstdsep->SetLineWidth(1); grstdsep->SetMarkerColor(15); grstdsep->SetMarkerStyle(20); grstdsep->SetTitle("Standard"); mgibfsep->Add(grstdsep); TGraphErrors* grtf200ibfsep = new TGraphErrors(nibfsep,gainibfsep,tf200ibfsep,0,dtf200ibfsep); grtf200ibfsep->SetLineColor(1); grtf200ibfsep->SetLineWidth(1); grtf200ibfsep->SetMarkerColor(1); grtf200ibfsep->SetMarkerStyle(20); grtf200ibfsep->SetTitle("TF 200"); mgibfsep->Add(grtf200ibfsep); TGraphErrors* grtf400ibfsep = new TGraphErrors(nibfsep,gainibfsep,tf400ibfsep,0,dtf400ibfsep); grtf400ibfsep->SetLineColor(4); grtf400ibfsep->SetLineWidth(1); grtf400ibfsep->SetMarkerColor(4); grtf400ibfsep->SetMarkerStyle(20); grtf400ibfsep->SetTitle("TF 400"); mgibfsep->Add(grtf400ibfsep); TGraphErrors* grtf600ibfsep = new TGraphErrors(nibfsep,gainibfsep,tf600ibfsep,0,dtf600ibfsep); grtf600ibfsep->SetLineColor(kOrange); grtf600ibfsep->SetLineWidth(1); grtf600ibfsep->SetMarkerColor(kOrange); grtf600ibfsep->SetMarkerStyle(20); grtf600ibfsep->SetTitle("TF 600"); mgibfsep->Add(grtf600ibfsep); TGraphErrors* grtf800ibfsep = new TGraphErrors(nibfsep,gainibfsep,tf800ibfsep,0,dtf800ibfsep); grtf800ibfsep->SetLineColor(2); grtf800ibfsep->SetLineWidth(1); grtf800ibfsep->SetMarkerColor(2); grtf800ibfsep->SetMarkerStyle(20); grtf800ibfsep->SetTitle("TF 800"); mgibfsep->Add(grtf800ibfsep); mgibfsep->Draw("ap"); mgibfsep->GetXaxis()->SetTitle("HV scaling factor (%)"); mgibfsep->GetYaxis()->SetTitle("separation power (#sigma)"); mgibfsep->GetXaxis()->SetLimits(98,109); mgibfsep->GetYaxis()->SetRangeUser(0.001,10); TLegend *legibfsep=new TLegend(0.2,0.65,0.5,.9); legibfsep->SetBorderSize(1); legibfsep->SetFillColor(10); legibfsep->AddEntry(grtf200ibfpisigma,"TF 200","p"); legibfsep->AddEntry(grtf400ibfpisigma,"TF 400","p"); legibfsep->AddEntry(grtf600ibfpisigma,"TF 600","p"); legibfsep->AddEntry(grtf800ibfpisigma,"TF 800","p"); legibfsep->AddEntry(grstdsep,"Std. #upoint 100/69","p"); legibfsep->Draw("same"); cibfsep->Update(); cibfsep->Modified(); cibfsep->Write(); cibfsep->SaveAs(dirname+filename+"IbfSeparationPower.pdf"); //################################################################################################################################################ //1 GeV + Beam ################################################################################################################################### //################################################################################################################################################ //851 856 858, 859, 860,861, 682 //################################################################################################################################################ //Standard Gain: Mean ############################################################################################################################ //################################################################################################################################################ TCanvas *cstdmean1p = new TCanvas("cstdmean1p","dEdx standard gain mean",1000,700); cstdmean1p->SetFillColor(00); cstdmean1p->SetGrid(); cstdmean1p->cd(); TMultiGraph *mgstdmean1p = new TMultiGraph(); const int nstdmean1p = 5; double gainstdmean1p[nstdmean1p] = {69., 70., 71., 72., 73.}; double meanel1p[nstdmean1p]; double meanpi1p[nstdmean1p]; double dmeanel1p[nstdmean1p]; double dmeanpi1p[nstdmean1p]; meanel1p[0] = (fitresultsmap[858]).meanel; meanel1p[1] = (fitresultsmap[859]).meanel; meanel1p[2] = (fitresultsmap[860]).meanel; meanel1p[3] = (fitresultsmap[861]).meanel; meanel1p[4] = (fitresultsmap[862]).meanel; dmeanel1p[0] = (fitresultsmap[858]).meanelerr; dmeanel1p[1] = (fitresultsmap[859]).meanelerr; dmeanel1p[2] = (fitresultsmap[860]).meanelerr; dmeanel1p[3] = (fitresultsmap[861]).meanelerr; dmeanel1p[4] = (fitresultsmap[862]).meanelerr; meanpi1p[0] = (fitresultsmap[858]).meanpi; meanpi1p[1] = (fitresultsmap[859]).meanpi; meanpi1p[2] = (fitresultsmap[860]).meanpi; meanpi1p[3] = (fitresultsmap[861]).meanpi; meanpi1p[4] = (fitresultsmap[862]).meanpi; dmeanpi1p[0] = (fitresultsmap[858]).meanpierr; dmeanpi1p[1] = (fitresultsmap[859]).meanpierr; dmeanpi1p[2] = (fitresultsmap[860]).meanpierr; dmeanpi1p[3] = (fitresultsmap[861]).meanpierr; dmeanpi1p[4] = (fitresultsmap[862]).meanpierr; TGraphErrors* grmeanel1p = new TGraphErrors(nstdmean1p,gainstdmean1p,meanel1p,0,dmeanel1p); grmeanel1p->SetLineColor(1); grmeanel1p->SetLineWidth(1); grmeanel1p->SetMarkerColor(1); grmeanel1p->SetMarkerStyle(20); grmeanel1p->SetTitle("electrons"); mgstdmean1p->Add(grmeanel1p); TGraphErrors* grmeanpi1p = new TGraphErrors(nstdmean1p,gainstdmean1p,meanpi1p,0,dmeanpi1p); grmeanpi1p->SetLineColor(15); grmeanpi1p->SetLineWidth(1); grmeanpi1p->SetMarkerColor(15); grmeanpi1p->SetMarkerStyle(20); grmeanpi1p->SetTitle("pions"); mgstdmean1p->Add(grmeanpi1p); mgstdmean1p->Draw("ap"); mgstdmean1p->GetXaxis()->SetTitle("HV scaling factor (%)"); mgstdmean1p->GetYaxis()->SetTitle(""); mgstdmean1p->GetXaxis()->SetLimits(66,76); mgstdmean1p->GetYaxis()->SetRangeUser(0.001,400); TLegend *legstdmean1p=new TLegend(0.2,0.78,0.5,.9); legstdmean1p->SetBorderSize(1); legstdmean1p->SetFillColor(10); legstdmean1p->AddEntry(grmeanel1p,"electrons","p"); legstdmean1p->AddEntry(grmeanpi1p,"pions","p"); legstdmean1p->Draw("same"); cstdmean1p->Update(); cstdmean1p->Modified(); cstdmean1p->Write(); cstdmean1p->SaveAs(dirname+filename+"StdMean1p.pdf"); //################################################################################################################################################ //Standard Gain: Sigma ########################################################################################################################### //################################################################################################################################################ TCanvas *cstdsigma1p = new TCanvas("cstdsigma1p","dEdx standard gain sigma",1000,700); cstdsigma1p->SetFillColor(00); cstdsigma1p->SetGrid(); cstdsigma1p->cd(); TMultiGraph *mgstdsigma1p = new TMultiGraph(); const int nstdsigma1p = 5; double gainstdsigma1p[nstdsigma1p] = {69., 70., 71., 72., 73.}; double sigmael1p[nstdsigma1p]; double sigmapi1p[nstdsigma1p]; double dsigmael1p[nstdsigma1p]; double dsigmapi1p[nstdsigma1p]; sigmael1p[0] = (fitresultsmap[858]).sigmael*100; sigmael1p[1] = (fitresultsmap[859]).sigmael*100; sigmael1p[2] = (fitresultsmap[860]).sigmael*100; sigmael1p[3] = (fitresultsmap[861]).sigmael*100; sigmael1p[4] = (fitresultsmap[862]).sigmael*100; sigmapi1p[0] = (fitresultsmap[858]).sigmapi*100; sigmapi1p[1] = (fitresultsmap[859]).sigmapi*100; sigmapi1p[2] = (fitresultsmap[860]).sigmapi*100; sigmapi1p[3] = (fitresultsmap[861]).sigmael*100; sigmapi1p[4] = (fitresultsmap[862]).sigmapi*100; dsigmael1p[0] = (fitresultsmap[858]).sigmaelerr*100; dsigmael1p[1] = (fitresultsmap[859]).sigmaelerr*100; dsigmael1p[2] = (fitresultsmap[860]).sigmaelerr*100; dsigmael1p[3] = (fitresultsmap[861]).sigmaelerr*100; dsigmael1p[4] = (fitresultsmap[862]).sigmaelerr*100; dsigmapi1p[0] = (fitresultsmap[858]).sigmapierr*100; dsigmapi1p[1] = (fitresultsmap[859]).sigmapierr*100; dsigmapi1p[2] = (fitresultsmap[860]).sigmapierr*100; dsigmapi1p[3] = (fitresultsmap[861]).sigmapierr*100; dsigmapi1p[4] = (fitresultsmap[862]).sigmapierr*100; TGraphErrors* grsigmael1p = new TGraphErrors(nstdsigma1p,gainstdsigma1p,sigmael1p,0,dsigmael1p); grsigmael1p->SetLineColor(1); grsigmael1p->SetLineWidth(1); grsigmael1p->SetMarkerColor(1); grsigmael1p->SetMarkerStyle(20); grsigmael1p->SetTitle("electrons"); mgstdsigma1p->Add(grsigmael1p); TGraphErrors* grsigmapi1p = new TGraphErrors(nstdsigma1p,gainstdsigma1p,sigmapi1p,0,dsigmapi1p); grsigmapi1p->SetLineColor(15); grsigmapi1p->SetLineWidth(1); grsigmapi1p->SetMarkerColor(15); grsigmapi1p->SetMarkerStyle(20); grsigmapi1p->SetTitle("pions"); mgstdsigma1p->Add(grsigmapi1p); mgstdsigma1p->Draw("ap"); mgstdsigma1p->GetXaxis()->SetTitle("HV scaling factor (%)"); mgstdsigma1p->GetYaxis()->SetTitle("#sigma(dE/dx)/ (%)"); mgstdsigma1p->GetXaxis()->SetLimits(66,76); mgstdsigma1p->GetYaxis()->SetRangeUser(7,15); TLegend *legstdsigma1p=new TLegend(0.2,0.78,0.5,.9); legstdsigma1p->SetBorderSize(1); legstdsigma1p->SetFillColor(10); legstdsigma1p->AddEntry(grmeanel1p,"electrons","p"); legstdsigma1p->AddEntry(grmeanpi1p,"pions","p"); legstdsigma1p->Draw("same"); cstdsigma1p->Update(); cstdsigma1p->Modified(); cstdsigma1p->Write(); cstdsigma1p->SaveAs(dirname+filename+"StdSigma1p.pdf"); //################################################################################################################################################ //2 GeV - Beam ################################################################################################################################### //################################################################################################################################################ // 768, 769, 770, 771, 773, 713,714,715,716,717,718,719,723,726,731,733,735,736, //################################################################################################################################################ //Standard Gain: Mean ############################################################################################################################ //################################################################################################################################################ TCanvas *cstdmean2n = new TCanvas("cstdmean2n","dEdx standard gain mean",1000,700); cstdmean2n->SetFillColor(00); cstdmean2n->SetGrid(); cstdmean2n->cd(); TMultiGraph *mgstdmean2n = new TMultiGraph(); const int nstdmean2n = 5; double gainstdmean2n[nstdmean2n] = {69., 70., 71., 72., 73.}; double meanel2n[nstdmean2n]; double meanpi2n[nstdmean2n]; double dmeanel2n[nstdmean2n]; double dmeanpi2n[nstdmean2n]; meanel2n[0] = (fitresultsmap[768]).meanel; meanel2n[1] = (fitresultsmap[769]).meanel; meanel2n[2] = (fitresultsmap[770]).meanel; meanel2n[3] = (fitresultsmap[771]).meanel; meanel2n[4] = (fitresultsmap[773]).meanel; dmeanel2n[0] = (fitresultsmap[768]).meanelerr; dmeanel2n[1] = (fitresultsmap[769]).meanelerr; dmeanel2n[2] = (fitresultsmap[770]).meanelerr; dmeanel2n[3] = (fitresultsmap[771]).meanelerr; dmeanel2n[4] = (fitresultsmap[773]).meanelerr; meanpi2n[0] = (fitresultsmap[768]).meanpi; meanpi2n[1] = (fitresultsmap[769]).meanpi; meanpi2n[2] = (fitresultsmap[770]).meanpi; meanpi2n[3] = (fitresultsmap[771]).meanpi; meanpi2n[4] = (fitresultsmap[773]).meanpi; dmeanpi2n[0] = (fitresultsmap[768]).meanpierr; dmeanpi2n[1] = (fitresultsmap[769]).meanpierr; dmeanpi2n[2] = (fitresultsmap[770]).meanpierr; dmeanpi2n[3] = (fitresultsmap[771]).meanpierr; dmeanpi2n[4] = (fitresultsmap[773]).meanpierr; TGraphErrors* grmeanel2n = new TGraphErrors(nstdmean2n,gainstdmean2n,meanel2n,0,dmeanel2n); grmeanel2n->SetLineColor(1); grmeanel2n->SetLineWidth(1); grmeanel2n->SetMarkerColor(1); grmeanel2n->SetMarkerStyle(20); grmeanel2n->SetTitle("electrons"); mgstdmean2n->Add(grmeanel2n); TGraphErrors* grmeanpi2n = new TGraphErrors(nstdmean2n,gainstdmean2n,meanpi2n,0,dmeanpi2n); grmeanpi2n->SetLineColor(15); grmeanpi2n->SetLineWidth(1); grmeanpi2n->SetMarkerColor(15); grmeanpi2n->SetMarkerStyle(20); grmeanpi2n->SetTitle("pions"); mgstdmean2n->Add(grmeanpi2n); mgstdmean2n->Draw("ap"); mgstdmean2n->GetXaxis()->SetTitle("HV scaling factor (%)"); mgstdmean2n->GetYaxis()->SetTitle(""); mgstdmean2n->GetXaxis()->SetLimits(66,76); mgstdmean2n->GetYaxis()->SetRangeUser(0.001,400); TLegend *legstdmean2n=new TLegend(0.2,0.78,0.5,.9); legstdmean2n->SetBorderSize(1); legstdmean2n->SetFillColor(10); legstdmean2n->AddEntry(grmeanel2n,"electrons","p"); legstdmean2n->AddEntry(grmeanpi2n,"pions","p"); legstdmean2n->Draw("same"); cstdmean2n->Update(); cstdmean2n->Modified(); cstdmean2n->Write(); cstdmean2n->SaveAs(dirname+filename+"StdMean2n.pdf"); //################################################################################################################################################ //Standard Gain: Sigma ########################################################################################################################### //################################################################################################################################################ TCanvas *cstdsigma2n = new TCanvas("cstdsigma2n","dEdx standard gain sigma",1000,700); cstdsigma2n->SetFillColor(00); cstdsigma2n->SetGrid(); cstdsigma2n->cd(); TMultiGraph *mgstdsigma2n = new TMultiGraph(); const int nstdsigma2n = 5; double gainstdsigma2n[nstdsigma2n] = {69., 70., 71., 72., 73.}; double sigmael2n[nstdsigma2n]; double sigmapi2n[nstdsigma2n]; double dsigmael2n[nstdsigma2n]; double dsigmapi2n[nstdsigma2n]; sigmael2n[0] = (fitresultsmap[768]).sigmael*100; sigmael2n[1] = (fitresultsmap[769]).sigmael*100; sigmael2n[2] = (fitresultsmap[770]).sigmael*100; sigmael2n[3] = (fitresultsmap[771]).sigmael*100; sigmael2n[4] = (fitresultsmap[773]).sigmael*100; sigmapi2n[0] = (fitresultsmap[768]).sigmapi*100; sigmapi2n[1] = (fitresultsmap[769]).sigmapi*100; sigmapi2n[2] = (fitresultsmap[770]).sigmapi*100; sigmapi2n[3] = (fitresultsmap[771]).sigmapi*100; sigmapi2n[4] = (fitresultsmap[773]).sigmapi*100; dsigmael2n[0] = (fitresultsmap[768]).sigmaelerr*100; dsigmael2n[1] = (fitresultsmap[769]).sigmaelerr*100; dsigmael2n[2] = (fitresultsmap[770]).sigmaelerr*100; dsigmael2n[3] = (fitresultsmap[771]).sigmaelerr*100; dsigmael2n[4] = (fitresultsmap[773]).sigmaelerr*100; dsigmapi2n[0] = (fitresultsmap[768]).sigmapierr*100; dsigmapi2n[1] = (fitresultsmap[769]).sigmapierr*100; dsigmapi2n[2] = (fitresultsmap[770]).sigmapierr*100; dsigmapi2n[3] = (fitresultsmap[771]).sigmapierr*100; dsigmapi2n[4] = (fitresultsmap[773]).sigmapierr*100; TGraphErrors* grsigmael2n = new TGraphErrors(nstdsigma2n,gainstdsigma2n,sigmael2n,0,dsigmael2n); grsigmael2n->SetLineColor(1); grsigmael2n->SetLineWidth(1); grsigmael2n->SetMarkerColor(1); grsigmael2n->SetMarkerStyle(20); grsigmael2n->SetTitle("electrons"); mgstdsigma2n->Add(grsigmael2n); TGraphErrors* grsigmapi2n = new TGraphErrors(nstdsigma2n,gainstdsigma2n,sigmapi2n,0,dsigmapi2n); grsigmapi2n->SetLineColor(15); grsigmapi2n->SetLineWidth(1); grsigmapi2n->SetMarkerColor(15); grsigmapi2n->SetMarkerStyle(20); grsigmapi2n->SetTitle("pions"); mgstdsigma2n->Add(grsigmapi2n); mgstdsigma2n->Draw("ap"); mgstdsigma2n->GetXaxis()->SetTitle("HV scaling factor (%)"); mgstdsigma2n->GetYaxis()->SetTitle("#sigma(dE/dx)/ (%)"); mgstdsigma2n->GetXaxis()->SetLimits(66,76); mgstdsigma2n->GetYaxis()->SetRangeUser(7,15); TLegend *legstdsigma2n=new TLegend(0.2,0.78,0.5,.9); legstdsigma2n->SetBorderSize(1); legstdsigma2n->SetFillColor(10); legstdsigma2n->AddEntry(grmeanel2n,"electrons","p"); legstdsigma2n->AddEntry(grmeanpi2n,"pions","p"); legstdsigma2n->Draw("same"); cstdsigma2n->Update(); cstdsigma2n->Modified(); cstdsigma2n->Write(); cstdsigma2n->SaveAs(dirname+filename+"StdSigma2n.pdf"); //################################################################################################################################################ //IBF Gain Electrons: Mean ####################################################################################################################### //################################################################################################################################################ TCanvas *cibfelemean2n = new TCanvas("cibfelemean2n","dEdx IBF gain electron mean",1000,700); cibfelemean2n->SetFillColor(00); cibfelemean2n->SetGrid(); cibfelemean2n->cd(); TMultiGraph *mgibfelemean2n = new TMultiGraph(); const int nibfelemean2n = 4; double gainibfelemean2n[nibfelemean2n] = {100., 103.,105.,107.}; double tf200ibfelemean2n[nibfelemean2n]; double tf400ibfelemean2n[nibfelemean2n]; double tf600ibfelemean2n[nibfelemean2n]; double tf800ibfelemean2n[nibfelemean2n]; double dtf200ibfelemean2n[nibfelemean2n]; double dtf400ibfelemean2n[nibfelemean2n]; double dtf600ibfelemean2n[nibfelemean2n]; double dtf800ibfelemean2n[nibfelemean2n]; tf200ibfelemean2n[0] = (fitresultsmap[713]).meanel; tf200ibfelemean2n[1] = (fitresultsmap[717]).meanel; tf200ibfelemean2n[2] = (fitresultsmap[726]).meanel; tf200ibfelemean2n[3] = (fitresultsmap[736]).meanel; tf400ibfelemean2n[0] = (fitresultsmap[714]).meanel; tf400ibfelemean2n[1] = (fitresultsmap[718]).meanel; tf400ibfelemean2n[2] = (fitresultsmap[731]).meanel; tf400ibfelemean2n[3] = 0; tf600ibfelemean2n[0] = (fitresultsmap[715]).meanel; tf600ibfelemean2n[1] = (fitresultsmap[719]).meanel; tf600ibfelemean2n[2] = (fitresultsmap[733]).meanel; tf600ibfelemean2n[3] = 0; tf800ibfelemean2n[0] = (fitresultsmap[716]).meanel; tf800ibfelemean2n[1] = (fitresultsmap[723]).meanel; tf800ibfelemean2n[2] = (fitresultsmap[735]).meanel; tf800ibfelemean2n[3] = 0; dtf200ibfelemean2n[0] = (fitresultsmap[713]).meanelerr; dtf200ibfelemean2n[1] = (fitresultsmap[717]).meanelerr; dtf200ibfelemean2n[2] = (fitresultsmap[726]).meanelerr; dtf200ibfelemean2n[3] = (fitresultsmap[736]).meanelerr; dtf400ibfelemean2n[0] = (fitresultsmap[714]).meanelerr; dtf400ibfelemean2n[1] = (fitresultsmap[718]).meanelerr; dtf400ibfelemean2n[2] = (fitresultsmap[731]).meanelerr; dtf400ibfelemean2n[3] = 0; dtf600ibfelemean2n[0] = (fitresultsmap[715]).meanelerr; dtf600ibfelemean2n[1] = (fitresultsmap[719]).meanelerr; dtf600ibfelemean2n[2] = (fitresultsmap[733]).meanelerr; dtf600ibfelemean2n[3] = 0; dtf800ibfelemean2n[0] = (fitresultsmap[716]).meanelerr; dtf800ibfelemean2n[1] = (fitresultsmap[723]).meanelerr; dtf800ibfelemean2n[2] = (fitresultsmap[735]).meanelerr; dtf800ibfelemean2n[3] = 0; double gainibfelemeanstd2n[nstdmean2n] = {100.,101.449,102.899,104.348,105.797}; double meanelibf2n[nstdmean2n]; double dmeanelibf2n[nstdmean2n]; meanelibf2n[0] = (fitresultsmap[768]).meanel; meanelibf2n[1] = (fitresultsmap[769]).meanel; meanelibf2n[2] = (fitresultsmap[770]).meanel; meanelibf2n[3] = (fitresultsmap[771]).meanel; meanelibf2n[4] = (fitresultsmap[773]).meanel; dmeanelibf2n[0] = (fitresultsmap[768]).meanelerr; dmeanelibf2n[1] = (fitresultsmap[769]).meanelerr; dmeanelibf2n[2] = (fitresultsmap[770]).meanelerr; dmeanelibf2n[3] = (fitresultsmap[771]).meanelerr; dmeanelibf2n[4] = (fitresultsmap[773]).meanelerr; TGraphErrors* grtf200ibfelemean2n = new TGraphErrors(nibfelemean2n,gainibfelemean2n,tf200ibfelemean2n,0,dtf200ibfelemean2n); grtf200ibfelemean2n->SetLineColor(1); grtf200ibfelemean2n->SetLineWidth(1); grtf200ibfelemean2n->SetMarkerColor(1); grtf200ibfelemean2n->SetMarkerStyle(20); grtf200ibfelemean2n->SetTitle("TF 200"); mgibfelemean2n->Add(grtf200ibfelemean2n); TGraphErrors* grtf400ibfelemean2n = new TGraphErrors(nibfelemean2n,gainibfelemean2n,tf400ibfelemean2n,0,dtf400ibfelemean2n); grtf400ibfelemean2n->SetLineColor(4); grtf400ibfelemean2n->SetLineWidth(1); grtf400ibfelemean2n->SetMarkerColor(4); grtf400ibfelemean2n->SetMarkerStyle(20); grtf400ibfelemean2n->SetTitle("TF 400"); mgibfelemean2n->Add(grtf400ibfelemean2n); TGraph* grtf600ibfelemean2n = new TGraphErrors(nibfelemean2n,gainibfelemean2n,tf600ibfelemean2n,0,dtf600ibfelemean2n); grtf600ibfelemean2n->SetLineColor(kOrange); grtf600ibfelemean2n->SetLineWidth(1); grtf600ibfelemean2n->SetMarkerColor(kOrange); grtf600ibfelemean2n->SetMarkerStyle(20); grtf600ibfelemean2n->SetTitle("TF 600"); mgibfelemean2n->Add(grtf600ibfelemean2n); TGraph* grtf800ibfelemean2n = new TGraphErrors(nibfelemean2n,gainibfelemean2n,tf800ibfelemean2n,0,dtf800ibfelemean2n); grtf800ibfelemean2n->SetLineColor(2); grtf800ibfelemean2n->SetLineWidth(1); grtf800ibfelemean2n->SetMarkerColor(2); grtf800ibfelemean2n->SetMarkerStyle(20); grtf800ibfelemean2n->SetTitle("TF 800"); mgibfelemean2n->Add(grtf800ibfelemean2n); TGraphErrors* grstdibfelemean2n = new TGraphErrors(nstdmean2n,gainibfelemeanstd2n,meanelibf2n,0,dmeanelibf2n); grstdibfelemean2n->SetLineColor(15); grstdibfelemean2n->SetLineWidth(1); grstdibfelemean2n->SetMarkerColor(15); grstdibfelemean2n->SetMarkerStyle(20); grstdibfelemean2n->SetTitle("Standard"); mgibfelemean2n->Add(grstdibfelemean2n); mgibfelemean2n->Draw("ap"); mgibfelemean2n->GetXaxis()->SetTitle("HV scaling factor (%)"); mgibfelemean2n->GetYaxis()->SetTitle(" electrons"); mgibfelemean2n->GetXaxis()->SetLimits(98,109); mgibfelemean2n->GetYaxis()->SetRangeUser(0.001,500); TLegend *legibfelemean2n=new TLegend(0.2,0.65,0.5,.9); legibfelemean2n->SetBorderSize(1); legibfelemean2n->SetFillColor(10); legibfelemean2n->AddEntry(grtf200ibfelemean2n,"TF 200","p"); legibfelemean2n->AddEntry(grtf400ibfelemean2n,"TF 400","p"); legibfelemean2n->AddEntry(grtf600ibfelemean2n,"TF 600","p"); legibfelemean2n->AddEntry(grtf800ibfelemean2n,"TF 800","p"); legibfelemean2n->AddEntry(grstdibfelemean2n,"Std. #upoint 100/69","p"); legibfelemean2n->Draw("same"); cibfelemean2n->Update(); cibfelemean2n->Modified(); cibfelemean2n->Write(); cibfelemean2n->SaveAs(dirname+filename+"IbfElMean2n.pdf"); //################################################################################################################################################ //IBF Gain Pions: Mean ########################################################################################################################### //################################################################################################################################################ TCanvas *cibfpimean2n = new TCanvas("cibfpimean2n","dEdx IBF gain pion mean",1000,700); cibfpimean2n->SetFillColor(00); cibfpimean2n->SetGrid(); cibfpimean2n->cd(); TMultiGraph *mgibfpimean2n = new TMultiGraph(); const int nibfpimean2n = 4; double gainibfpimean2n[nibfpimean2n] = {100., 103.,105.,107.}; double tf200ibfpimean2n[nibfpimean2n]; double tf400ibfpimean2n[nibfpimean2n]; double tf600ibfpimean2n[nibfpimean2n]; double tf800ibfpimean2n[nibfpimean2n]; double dtf200ibfpimean2n[nibfpimean2n]; double dtf400ibfpimean2n[nibfpimean2n]; double dtf600ibfpimean2n[nibfpimean2n]; double dtf800ibfpimean2n[nibfpimean2n]; tf200ibfpimean2n[0] = (fitresultsmap[713]).meanpi; tf200ibfpimean2n[1] = (fitresultsmap[717]).meanpi; tf200ibfpimean2n[2] = (fitresultsmap[726]).meanpi; tf200ibfpimean2n[3] = (fitresultsmap[736]).meanpi; tf400ibfpimean2n[0] = (fitresultsmap[714]).meanpi; tf400ibfpimean2n[1] = (fitresultsmap[718]).meanpi; tf400ibfpimean2n[2] = (fitresultsmap[731]).meanpi; tf400ibfpimean2n[3] = 0; tf600ibfpimean2n[0] = (fitresultsmap[715]).meanpi; tf600ibfpimean2n[1] = (fitresultsmap[719]).meanpi; tf600ibfpimean2n[2] = (fitresultsmap[733]).meanpi; tf600ibfpimean2n[3] = 0; tf800ibfpimean2n[0] = (fitresultsmap[716]).meanpi; tf800ibfpimean2n[1] = (fitresultsmap[723]).meanpi; tf800ibfpimean2n[2] = (fitresultsmap[735]).meanpi; tf800ibfpimean2n[3] = 0; dtf200ibfpimean2n[0] = (fitresultsmap[713]).meanpierr; dtf200ibfpimean2n[1] = (fitresultsmap[717]).meanpierr; dtf200ibfpimean2n[2] = (fitresultsmap[726]).meanpierr; dtf200ibfpimean2n[3] = (fitresultsmap[736]).meanpierr; dtf400ibfpimean2n[0] = (fitresultsmap[714]).meanpierr; dtf400ibfpimean2n[1] = (fitresultsmap[718]).meanpierr; dtf400ibfpimean2n[2] = (fitresultsmap[731]).meanpierr; dtf400ibfpimean2n[3] = 0; dtf600ibfpimean2n[0] = (fitresultsmap[715]).meanpierr; dtf600ibfpimean2n[1] = (fitresultsmap[719]).meanpierr; dtf600ibfpimean2n[2] = (fitresultsmap[733]).meanpierr; dtf600ibfpimean2n[3] = 0; dtf800ibfpimean2n[0] = (fitresultsmap[716]).meanpierr; dtf800ibfpimean2n[1] = (fitresultsmap[723]).meanpierr; dtf800ibfpimean2n[2] = (fitresultsmap[735]).meanpierr; dtf800ibfpimean2n[3] = 0; double gainibfpimeanstd2n[nstdmean2n] = {100.,101.449,102.899,104.348,105.797}; double meanpiibfstd2n[nstdmean2n]; double dmeanpiibfstd2n[nstdmean2n]; meanpiibfstd2n[0] = (fitresultsmap[768]).meanpi; meanpiibfstd2n[1] = (fitresultsmap[769]).meanpi; meanpiibfstd2n[2] = (fitresultsmap[770]).meanpi; meanpiibfstd2n[3] = (fitresultsmap[771]).meanpi; meanpiibfstd2n[4] = (fitresultsmap[773]).meanpi; dmeanpiibfstd2n[0] = (fitresultsmap[768]).meanpierr; dmeanpiibfstd2n[1] = (fitresultsmap[769]).meanpierr; dmeanpiibfstd2n[2] = (fitresultsmap[770]).meanpierr; dmeanpiibfstd2n[3] = (fitresultsmap[771]).meanpierr; dmeanpiibfstd2n[4] = (fitresultsmap[773]).meanpierr; TGraphErrors* grtf200ibfpimean2n = new TGraphErrors(nibfpimean2n,gainibfpimean2n,tf200ibfpimean2n,0,dtf200ibfpimean2n); grtf200ibfpimean2n->SetLineColor(1); grtf200ibfpimean2n->SetLineWidth(1); grtf200ibfpimean2n->SetMarkerColor(1); grtf200ibfpimean2n->SetMarkerStyle(20); grtf200ibfpimean2n->SetTitle("TF 200"); mgibfpimean2n->Add(grtf200ibfpimean2n); TGraphErrors* grtf400ibfpimean2n = new TGraphErrors(nibfpimean2n,gainibfpimean2n,tf400ibfpimean2n,0,dtf400ibfpimean2n); grtf400ibfpimean2n->SetLineColor(4); grtf400ibfpimean2n->SetLineWidth(1); grtf400ibfpimean2n->SetMarkerColor(4); grtf400ibfpimean2n->SetMarkerStyle(20); grtf400ibfpimean2n->SetTitle("TF 400"); mgibfpimean2n->Add(grtf400ibfpimean2n); TGraphErrors* grtf600ibfpimean2n = new TGraphErrors(nibfpimean2n,gainibfpimean2n,tf600ibfpimean2n,0,dtf600ibfpimean2n); grtf600ibfpimean2n->SetLineColor(kOrange); grtf600ibfpimean2n->SetLineWidth(1); grtf600ibfpimean2n->SetMarkerColor(kOrange); grtf600ibfpimean2n->SetMarkerStyle(20); grtf600ibfpimean2n->SetTitle("TF 600"); mgibfpimean2n->Add(grtf600ibfpimean2n); TGraphErrors* grtf800ibfpimean2n = new TGraphErrors(nibfpimean2n,gainibfpimean2n,tf800ibfpimean2n,0,dtf800ibfpimean2n); grtf800ibfpimean2n->SetLineColor(2); grtf800ibfpimean2n->SetLineWidth(1); grtf800ibfpimean2n->SetMarkerColor(2); grtf800ibfpimean2n->SetMarkerStyle(20); grtf800ibfpimean2n->SetTitle("TF 800"); mgibfpimean2n->Add(grtf800ibfpimean2n); TGraphErrors* grstdibfpimean2n = new TGraphErrors(nstdmean2n,gainibfpimeanstd2n,meanpiibfstd2n,0,dmeanpiibfstd2n); grstdibfpimean2n->SetLineColor(15); grstdibfpimean2n->SetLineWidth(1); grstdibfpimean2n->SetMarkerColor(15); grstdibfpimean2n->SetMarkerStyle(20); grstdibfpimean2n->SetTitle("Standard"); mgibfpimean2n->Add(grstdibfpimean2n); mgibfpimean2n->Draw("ap"); mgibfpimean2n->GetXaxis()->SetTitle("HV scaling factor (%)"); mgibfpimean2n->GetYaxis()->SetTitle(" pions"); mgibfpimean2n->GetXaxis()->SetLimits(98,109); mgibfpimean2n->GetYaxis()->SetRangeUser(0.001,400); TLegend *legibfpimean2n=new TLegend(0.2,0.65,0.5,.9); legibfpimean2n->SetBorderSize(1); legibfpimean2n->SetFillColor(10); legibfpimean2n->AddEntry(grtf200ibfpimean2n,"TF 200","p"); legibfpimean2n->AddEntry(grtf400ibfpimean2n,"TF 400","p"); legibfpimean2n->AddEntry(grtf600ibfpimean2n,"TF 600","p"); legibfpimean2n->AddEntry(grtf800ibfpimean2n,"TF 800","p"); legibfpimean2n->AddEntry(grstdibfpimean2n,"Std. #upoint 100/69","p"); legibfpimean2n->Draw("same"); cibfpimean2n->Update(); cibfpimean2n->Modified(); cibfpimean2n->Write(); cibfpimean2n->SaveAs(dirname+filename+"IbfPiMean2n.pdf"); //################################################################################################################################################ //IBF Gain Electrons: Sigma ###################################################################################################################### //################################################################################################################################################ TCanvas *cibfelesigma2n = new TCanvas("cibfelesigma2n","dEdx IBF gain electron sigma",1000,700); cibfelesigma2n->SetFillColor(00); cibfelesigma2n->SetGrid(); cibfelesigma2n->cd(); TMultiGraph *mgibfelesigma2n = new TMultiGraph(); const int nibfelesigma2n = 4; double gainibfelesigma2n[nibfelesigma2n] = {100., 103.,105.,107.}; double tf200ibfelesigma2n[nibfelesigma2n]; double tf400ibfelesigma2n[nibfelesigma2n]; double tf600ibfelesigma2n[nibfelesigma2n]; double tf800ibfelesigma2n[nibfelesigma2n]; double dtf200ibfelesigma2n[nibfelesigma2n]; double dtf400ibfelesigma2n[nibfelesigma2n]; double dtf600ibfelesigma2n[nibfelesigma2n]; double dtf800ibfelesigma2n[nibfelesigma2n]; tf200ibfelesigma2n[0] = (fitresultsmap[713]).sigmael*100; tf200ibfelesigma2n[1] = (fitresultsmap[717]).sigmael*100; tf200ibfelesigma2n[2] = (fitresultsmap[726]).sigmael*100; tf200ibfelesigma2n[3] = (fitresultsmap[736]).sigmael*100; tf400ibfelesigma2n[0] = (fitresultsmap[714]).sigmael*100; tf400ibfelesigma2n[1] = (fitresultsmap[718]).sigmael*100; tf400ibfelesigma2n[2] = (fitresultsmap[731]).sigmael*100; tf400ibfelesigma2n[3] = 0; tf600ibfelesigma2n[0] = (fitresultsmap[715]).sigmael*100; tf600ibfelesigma2n[1] = (fitresultsmap[719]).sigmael*100; tf600ibfelesigma2n[2] = (fitresultsmap[733]).sigmael*100; tf600ibfelesigma2n[3] = 0; tf800ibfelesigma2n[0] = (fitresultsmap[716]).sigmael*100; tf800ibfelesigma2n[1] = (fitresultsmap[723]).sigmael*100; tf800ibfelesigma2n[2] = (fitresultsmap[735]).sigmael*100; tf800ibfelesigma2n[3] = 0; dtf200ibfelesigma2n[0] = (fitresultsmap[713]).sigmaelerr*100; dtf200ibfelesigma2n[1] = (fitresultsmap[717]).sigmaelerr*100; dtf200ibfelesigma2n[2] = (fitresultsmap[726]).sigmaelerr*100; dtf200ibfelesigma2n[3] = (fitresultsmap[736]).sigmaelerr*100; dtf400ibfelesigma2n[0] = (fitresultsmap[714]).sigmaelerr*100; dtf400ibfelesigma2n[1] = (fitresultsmap[718]).sigmaelerr*100; dtf400ibfelesigma2n[2] = (fitresultsmap[731]).sigmaelerr*100; dtf400ibfelesigma2n[3] = 0; dtf600ibfelesigma2n[0] = (fitresultsmap[715]).sigmaelerr*100; dtf600ibfelesigma2n[1] = (fitresultsmap[719]).sigmaelerr*100; dtf600ibfelesigma2n[2] = (fitresultsmap[733]).sigmaelerr*100; dtf600ibfelesigma2n[3] = 0; dtf800ibfelesigma2n[0] = (fitresultsmap[716]).sigmaelerr*100; dtf800ibfelesigma2n[1] = (fitresultsmap[723]).sigmaelerr*100; dtf800ibfelesigma2n[2] = (fitresultsmap[735]).sigmaelerr*100; dtf800ibfelesigma2n[3] = 0; double gainibfelesigmastd2n[nstdsigma2n] = {100.,101.449,102.899,104.348,105.797}; double sigmaelibfstd2n[nstdsigma2n]; double dsigmaelibfstd2n[nstdsigma2n]; sigmaelibfstd2n[0] = (fitresultsmap[768]).sigmael*100; sigmaelibfstd2n[1] = (fitresultsmap[769]).sigmael*100; sigmaelibfstd2n[2] = (fitresultsmap[770]).sigmael*100; sigmaelibfstd2n[3] = (fitresultsmap[771]).sigmael*100; sigmaelibfstd2n[4] = (fitresultsmap[773]).sigmael*100; dsigmaelibfstd2n[0] = (fitresultsmap[768]).sigmaelerr*100; dsigmaelibfstd2n[1] = (fitresultsmap[769]).sigmaelerr*100; dsigmaelibfstd2n[2] = (fitresultsmap[770]).sigmaelerr*100; dsigmaelibfstd2n[3] = (fitresultsmap[771]).sigmaelerr*100; dsigmaelibfstd2n[4] = (fitresultsmap[773]).sigmaelerr*100; TGraphErrors* grtf200ibfelesigma2n = new TGraphErrors(nibfelesigma2n,gainibfelesigma2n,tf200ibfelesigma2n,0,dtf200ibfelesigma2n); grtf200ibfelesigma2n->SetLineColor(1); grtf200ibfelesigma2n->SetLineWidth(1); grtf200ibfelesigma2n->SetMarkerColor(1); grtf200ibfelesigma2n->SetMarkerStyle(20); grtf200ibfelesigma2n->SetTitle("TF 200"); mgibfelesigma2n->Add(grtf200ibfelesigma2n); TGraphErrors* grtf400ibfelesigma2n = new TGraphErrors(nibfelesigma2n,gainibfelesigma2n,tf400ibfelesigma2n,0,dtf400ibfelesigma2n); grtf400ibfelesigma2n->SetLineColor(4); grtf400ibfelesigma2n->SetLineWidth(1); grtf400ibfelesigma2n->SetMarkerColor(4); grtf400ibfelesigma2n->SetMarkerStyle(20); grtf400ibfelesigma2n->SetTitle("TF 400"); mgibfelesigma2n->Add(grtf400ibfelesigma2n); TGraphErrors* grtf600ibfelesigma2n = new TGraphErrors(nibfelesigma2n,gainibfelesigma2n,tf600ibfelesigma2n,0,dtf600ibfelesigma2n); grtf600ibfelesigma2n->SetLineColor(kOrange); grtf600ibfelesigma2n->SetLineWidth(1); grtf600ibfelesigma2n->SetMarkerColor(kOrange); grtf600ibfelesigma2n->SetMarkerStyle(20); grtf600ibfelesigma2n->SetTitle("TF 600"); mgibfelesigma2n->Add(grtf600ibfelesigma2n); TGraphErrors* grtf800ibfelesigma2n = new TGraphErrors(nibfelesigma2n,gainibfelesigma2n,tf800ibfelesigma2n,0,dtf800ibfelesigma2n); grtf800ibfelesigma2n->SetLineColor(2); grtf800ibfelesigma2n->SetLineWidth(1); grtf800ibfelesigma2n->SetMarkerColor(2); grtf800ibfelesigma2n->SetMarkerStyle(20); grtf800ibfelesigma2n->SetTitle("TF 800"); mgibfelesigma2n->Add(grtf800ibfelesigma2n); TGraphErrors* grstdibfelesigma2n = new TGraphErrors(nstdsigma2n,gainibfelesigmastd2n,sigmaelibfstd2n,0,dsigmaelibfstd2n); grstdibfelesigma2n->SetLineColor(15); grstdibfelesigma2n->SetLineWidth(1); grstdibfelesigma2n->SetMarkerColor(15); grstdibfelesigma2n->SetMarkerStyle(20); grstdibfelesigma2n->SetTitle("Standard"); mgibfelesigma2n->Add(grstdibfelesigma2n); mgibfelesigma2n->Draw("ap"); mgibfelesigma2n->GetXaxis()->SetTitle("HV scaling factor (%)"); mgibfelesigma2n->GetYaxis()->SetTitle("#sigma(dE/dx)/ (%) electrons"); mgibfelesigma2n->GetXaxis()->SetLimits(98,109); mgibfelesigma2n->GetYaxis()->SetRangeUser(8,14); TLegend *legibfelesigma2n=new TLegend( 0.6,0.65,0.9,.9); legibfelesigma2n->SetBorderSize(1); legibfelesigma2n->SetFillColor(10); legibfelesigma2n->AddEntry(grtf200ibfelesigma2n,"TF 200","p"); legibfelesigma2n->AddEntry(grtf400ibfelesigma2n,"TF 400","p"); legibfelesigma2n->AddEntry(grtf600ibfelesigma2n,"TF 600","p"); legibfelesigma2n->AddEntry(grtf800ibfelesigma2n,"TF 800","p"); legibfelesigma2n->AddEntry(grstdibfelesigma2n,"Std. #upoint 100/69","p"); legibfelesigma2n->Draw("same"); cibfelesigma2n->Update(); cibfelesigma2n->Modified(); cibfelesigma2n->Write(); cibfelesigma2n->SaveAs(dirname+filename+"IbfElSigma2n.pdf"); //################################################################################################################################################ //IBF Gain Pions: Sigma ########################################################################################################################## //################################################################################################################################################ TCanvas *cibfpisigma2n = new TCanvas("cibfpisigma2n","dEdx IBF gain pion sigma",1000,700); cibfpisigma2n->SetFillColor(00); cibfpisigma2n->SetGrid(); cibfpisigma2n->cd(); TMultiGraph *mgibfpisigma2n = new TMultiGraph(); const int nibfpisigma2n = 4; double gainibfpisigma2n[nibfpisigma2n] = {100., 103.,105.,107.}; double tf200ibfpisigma2n[nibfpisigma2n]; double tf400ibfpisigma2n[nibfpisigma2n]; double tf600ibfpisigma2n[nibfpisigma2n]; double tf800ibfpisigma2n[nibfpisigma2n]; double dtf200ibfpisigma2n[nibfpisigma2n]; double dtf400ibfpisigma2n[nibfpisigma2n]; double dtf600ibfpisigma2n[nibfpisigma2n]; double dtf800ibfpisigma2n[nibfpisigma2n]; tf200ibfpisigma2n[0] = (fitresultsmap[713]).sigmapi*100; tf200ibfpisigma2n[1] = (fitresultsmap[717]).sigmapi*100; tf200ibfpisigma2n[2] = (fitresultsmap[726]).sigmapi*100; tf200ibfpisigma2n[3] = (fitresultsmap[736]).sigmapi*100; tf400ibfpisigma2n[0] = (fitresultsmap[714]).sigmapi*100; tf400ibfpisigma2n[1] = (fitresultsmap[718]).sigmapi*100; tf400ibfpisigma2n[2] = (fitresultsmap[731]).sigmapi*100; tf400ibfpisigma2n[3] = 0; tf600ibfpisigma2n[0] = (fitresultsmap[715]).sigmapi*100; tf600ibfpisigma2n[1] = (fitresultsmap[719]).sigmapi*100; tf600ibfpisigma2n[2] = (fitresultsmap[733]).sigmapi*100; tf600ibfpisigma2n[3] = 0; tf800ibfpisigma2n[0] = (fitresultsmap[716]).sigmapi*100; tf800ibfpisigma2n[1] = (fitresultsmap[723]).sigmapi*100; tf800ibfpisigma2n[2] = (fitresultsmap[735]).sigmapi*100; tf800ibfpisigma2n[3] = 0; dtf200ibfpisigma2n[0] = (fitresultsmap[713]).sigmapierr*100; dtf200ibfpisigma2n[1] = (fitresultsmap[717]).sigmapierr*100; dtf200ibfpisigma2n[2] = (fitresultsmap[726]).sigmapierr*100; dtf200ibfpisigma2n[3] = (fitresultsmap[736]).sigmapierr*100; dtf400ibfpisigma2n[0] = (fitresultsmap[714]).sigmapierr*100; dtf400ibfpisigma2n[1] = (fitresultsmap[718]).sigmapierr*100; dtf400ibfpisigma2n[2] = (fitresultsmap[731]).sigmapierr*100; dtf400ibfpisigma2n[3] = 0; dtf600ibfpisigma2n[0] = (fitresultsmap[715]).sigmapierr*100; dtf600ibfpisigma2n[1] = (fitresultsmap[719]).sigmapierr*100; dtf600ibfpisigma2n[2] = (fitresultsmap[733]).sigmapierr*100; dtf600ibfpisigma2n[3] = 0; dtf800ibfpisigma2n[0] = (fitresultsmap[716]).sigmapierr*100; dtf800ibfpisigma2n[1] = (fitresultsmap[723]).sigmapierr*100; dtf800ibfpisigma2n[2] = (fitresultsmap[735]).sigmapierr*100; dtf800ibfpisigma2n[3] = 0; double gainibfpisigmastd2n[nstdsigma] = {100.,101.449,102.899,104.348,105.797}; double sigmapiibfstd2n[nstdsigma]; double dsigmapiibfstd2n[nstdsigma]; sigmapiibfstd2n[0] = (fitresultsmap[768]).sigmapi*100; sigmapiibfstd2n[1] = (fitresultsmap[769]).sigmapi*100; sigmapiibfstd2n[2] = (fitresultsmap[770]).sigmapi*100; sigmapiibfstd2n[3] = (fitresultsmap[771]).sigmapi*100; sigmapiibfstd2n[4] = (fitresultsmap[773]).sigmapi*100; dsigmapiibfstd2n[0] = (fitresultsmap[768]).sigmapierr*100; dsigmapiibfstd2n[1] = (fitresultsmap[769]).sigmapierr*100; dsigmapiibfstd2n[2] = (fitresultsmap[770]).sigmapierr*100; dsigmapiibfstd2n[3] = (fitresultsmap[771]).sigmapierr*100; dsigmapiibfstd2n[4] = (fitresultsmap[773]).sigmapierr*100; TGraphErrors* grtf200ibfpisigma2n = new TGraphErrors(nibfpisigma2n,gainibfpisigma2n,tf200ibfpisigma2n,0,dtf200ibfpisigma2n); grtf200ibfpisigma2n->SetLineColor(1); grtf200ibfpisigma2n->SetLineWidth(1); grtf200ibfpisigma2n->SetMarkerColor(1); grtf200ibfpisigma2n->SetMarkerStyle(20); grtf200ibfpisigma2n->SetTitle("TF 200"); mgibfpisigma2n->Add(grtf200ibfpisigma2n); TGraphErrors* grtf400ibfpisigma2n = new TGraphErrors(nibfpisigma2n,gainibfpisigma2n,tf400ibfpisigma2n,0,dtf400ibfpisigma2n); grtf400ibfpisigma2n->SetLineColor(4); grtf400ibfpisigma2n->SetLineWidth(1); grtf400ibfpisigma2n->SetMarkerColor(4); grtf400ibfpisigma2n->SetMarkerStyle(20); grtf400ibfpisigma2n->SetTitle("TF 400"); mgibfpisigma2n->Add(grtf400ibfpisigma2n); TGraphErrors* grtf600ibfpisigma2n = new TGraphErrors(nibfpisigma2n,gainibfpisigma2n,tf600ibfpisigma2n,0,dtf600ibfpisigma2n); grtf600ibfpisigma2n->SetLineColor(kOrange); grtf600ibfpisigma2n->SetLineWidth(1); grtf600ibfpisigma2n->SetMarkerColor(kOrange); grtf600ibfpisigma2n->SetMarkerStyle(20); grtf600ibfpisigma2n->SetTitle("TF 600"); mgibfpisigma2n->Add(grtf600ibfpisigma2n); TGraphErrors* grtf800ibfpisigma2n = new TGraphErrors(nibfpisigma2n,gainibfpisigma2n,tf800ibfpisigma2n,0,dtf800ibfpisigma2n); grtf800ibfpisigma2n->SetLineColor(2); grtf800ibfpisigma2n->SetLineWidth(1); grtf800ibfpisigma2n->SetMarkerColor(2); grtf800ibfpisigma2n->SetMarkerStyle(20); grtf800ibfpisigma2n->SetTitle("TF 800"); mgibfpisigma2n->Add(grtf800ibfpisigma2n); TGraphErrors* grstdibfpisigma2n = new TGraphErrors(nstdsigma,gainibfpisigmastd2n,sigmapiibfstd2n,0,dsigmapiibfstd2n); grstdibfpisigma2n->SetLineColor(15); grstdibfpisigma2n->SetLineWidth(1); grstdibfpisigma2n->SetMarkerColor(15); grstdibfpisigma2n->SetMarkerStyle(20); grstdibfpisigma2n->SetTitle("Standard"); mgibfpisigma2n->Add(grstdibfpisigma2n); mgibfpisigma2n->Draw("ap"); mgibfpisigma2n->GetXaxis()->SetTitle("HV scaling factor (%)"); mgibfpisigma2n->GetYaxis()->SetTitle("#sigma(dE/dx)/ (%) pions"); mgibfpisigma2n->GetXaxis()->SetLimits(98,109); mgibfpisigma2n->GetYaxis()->SetRangeUser(8,14); TLegend *legibfpisigma2n=new TLegend(0.2,0.17,0.5,.42); legibfpisigma2n->SetBorderSize(1); legibfpisigma2n->SetFillColor(10); legibfpisigma2n->AddEntry(grtf200ibfpisigma2n,"TF 200","p"); legibfpisigma2n->AddEntry(grtf400ibfpisigma2n,"TF 400","p"); legibfpisigma2n->AddEntry(grtf600ibfpisigma2n,"TF 600","p"); legibfpisigma2n->AddEntry(grtf800ibfpisigma2n,"TF 800","p"); legibfpisigma2n->AddEntry(grstdibfpisigma2n,"Std. #upoint 100/69","p"); legibfpisigma2n->Draw("same"); cibfpisigma2n->Update(); cibfpisigma2n->Modified(); cibfpisigma2n->Write(); cibfpisigma2n->SaveAs(dirname+filename+"IbfPiSigma2n.pdf"); //################################################################################################################################################ //IBF Gain: Separation Power ##################################################################################################################### //################################################################################################################################################ TCanvas *cibfsep2n = new TCanvas("cibfsep2n","dEdx IBF Separation Power",1000,700); cibfsep2n->SetFillColor(00); cibfsep2n->SetGrid(); cibfsep2n->cd(); TMultiGraph *mgibfsep2n = new TMultiGraph(); const int nibfsep2n = 4; double gainibfsep2n[nibfsep2n] = {100., 103.,105.,107.}; double tf200ibfsep2n[nibfsep2n]; double tf400ibfsep2n[nibfsep2n]; double tf600ibfsep2n[nibfsep2n]; double tf800ibfsep2n[nibfsep2n]; double dtf200ibfsep2n[nibfsep2n]; double dtf400ibfsep2n[nibfsep2n]; double dtf600ibfsep2n[nibfsep2n]; double dtf800ibfsep2n[nibfsep2n]; tf200ibfsep2n[0] = (fitresultsmap[713]).separation2; tf200ibfsep2n[1] = (fitresultsmap[717]).separation2; tf200ibfsep2n[2] = (fitresultsmap[726]).separation2; tf200ibfsep2n[3] = (fitresultsmap[736]).separation2; tf400ibfsep2n[0] = (fitresultsmap[714]).separation2; tf400ibfsep2n[1] = (fitresultsmap[718]).separation2; tf400ibfsep2n[2] = (fitresultsmap[731]).separation2; tf400ibfsep2n[3] = 0; tf600ibfsep2n[0] = (fitresultsmap[715]).separation2; tf600ibfsep2n[1] = (fitresultsmap[719]).separation2; tf600ibfsep2n[2] = (fitresultsmap[733]).separation2; tf600ibfsep2n[3] = 0; tf800ibfsep2n[0] = (fitresultsmap[716]).separation2; tf800ibfsep2n[1] = (fitresultsmap[723]).separation2; tf800ibfsep2n[2] = (fitresultsmap[735]).separation2; tf800ibfsep2n[3] = 0; dtf200ibfsep2n[0] = (fitresultsmap[713]).separation2err; dtf200ibfsep2n[1] = (fitresultsmap[717]).separation2err; dtf200ibfsep2n[2] = (fitresultsmap[726]).separation2err; dtf200ibfsep2n[3] = (fitresultsmap[736]).separation2err; dtf400ibfsep2n[0] = (fitresultsmap[714]).separation2err; dtf400ibfsep2n[1] = (fitresultsmap[718]).separation2err; dtf400ibfsep2n[2] = (fitresultsmap[731]).separation2err; dtf400ibfsep2n[3] = 0; dtf600ibfsep2n[0] = (fitresultsmap[715]).separation2err; dtf600ibfsep2n[1] = (fitresultsmap[719]).separation2err; dtf600ibfsep2n[2] = (fitresultsmap[733]).separation2err; dtf600ibfsep2n[3] = 0; dtf800ibfsep2n[0] = (fitresultsmap[716]).separation2err; dtf800ibfsep2n[1] = (fitresultsmap[723]).separation2err; dtf800ibfsep2n[2] = (fitresultsmap[735]).separation2err; dtf800ibfsep2n[3] = 0; const int nstdsep2n = 5; double gainstdsep2n[nstdsep2n] = {100.,101.449,102.899,104.348,105.797}; double stdsep2n[nstdsep2n]; double dstdsep2n[nstdsep2n]; stdsep2n[0] = (fitresultsmap[768]).separation2; stdsep2n[1] = (fitresultsmap[769]).separation2; stdsep2n[2] = (fitresultsmap[770]).separation2; stdsep2n[3] = (fitresultsmap[771]).separation2; stdsep2n[4] = (fitresultsmap[773]).separation2; dstdsep2n[0] = (fitresultsmap[768]).separation2err; dstdsep2n[1] = (fitresultsmap[769]).separation2err; dstdsep2n[2] = (fitresultsmap[770]).separation2err; dstdsep2n[3] = (fitresultsmap[771]).separation2err; dstdsep2n[4] = (fitresultsmap[773]).separation2err; TGraphErrors* grstdsep2n = new TGraphErrors(nibfsep2n,gainstdsep2n,stdsep2n,0,dstdsep2n); grstdsep2n->SetLineColor(15); grstdsep2n->SetLineWidth(1); grstdsep2n->SetMarkerColor(15); grstdsep2n->SetMarkerStyle(20); grstdsep2n->SetTitle("Standard"); mgibfsep2n->Add(grstdsep2n); TGraphErrors* grtf200ibfsep2n = new TGraphErrors(nibfsep2n,gainibfsep2n,tf200ibfsep2n,0,dtf200ibfsep2n); grtf200ibfsep2n->SetLineColor(1); grtf200ibfsep2n->SetLineWidth(1); grtf200ibfsep2n->SetMarkerColor(1); grtf200ibfsep2n->SetMarkerStyle(20); grtf200ibfsep2n->SetTitle("TF 200"); mgibfsep2n->Add(grtf200ibfsep2n); TGraphErrors* grtf400ibfsep2n = new TGraphErrors(nibfsep2n,gainibfsep2n,tf400ibfsep2n,0,dtf400ibfsep2n); grtf400ibfsep2n->SetLineColor(4); grtf400ibfsep2n->SetLineWidth(1); grtf400ibfsep2n->SetMarkerColor(4); grtf400ibfsep2n->SetMarkerStyle(20); grtf400ibfsep2n->SetTitle("TF 400"); mgibfsep2n->Add(grtf400ibfsep2n); TGraphErrors* grtf600ibfsep2n = new TGraphErrors(nibfsep2n,gainibfsep2n,tf600ibfsep2n,0,dtf600ibfsep2n); grtf600ibfsep2n->SetLineColor(kOrange); grtf600ibfsep2n->SetLineWidth(1); grtf600ibfsep2n->SetMarkerColor(kOrange); grtf600ibfsep2n->SetMarkerStyle(20); grtf600ibfsep2n->SetTitle("TF 600"); mgibfsep2n->Add(grtf600ibfsep2n); TGraphErrors* grtf800ibfsep2n = new TGraphErrors(nibfsep2n,gainibfsep2n,tf800ibfsep2n,0,dtf800ibfsep2n); grtf800ibfsep2n->SetLineColor(2); grtf800ibfsep2n->SetLineWidth(1); grtf800ibfsep2n->SetMarkerColor(2); grtf800ibfsep2n->SetMarkerStyle(20); grtf800ibfsep2n->SetTitle("TF 800"); mgibfsep2n->Add(grtf800ibfsep2n); mgibfsep2n->Draw("ap"); mgibfsep2n->GetXaxis()->SetTitle("HV scaling factor (%)"); mgibfsep2n->GetYaxis()->SetTitle("separation power (#sigma)"); mgibfsep2n->GetXaxis()->SetLimits(98,109); mgibfsep2n->GetYaxis()->SetRangeUser(0.001,10); TLegend *legibfsep2n=new TLegend(0.2,0.65,0.5,.9); legibfsep2n->SetBorderSize(1); legibfsep2n->SetFillColor(10); legibfsep2n->AddEntry(grtf200ibfsep2n,"TF 200","p"); legibfsep2n->AddEntry(grtf400ibfsep2n,"TF 400","p"); legibfsep2n->AddEntry(grtf600ibfsep2n,"TF 600","p"); legibfsep2n->AddEntry(grtf800ibfsep2n,"TF 800","p"); legibfsep2n->AddEntry(grstdsep2n,"Standard #upoint 100/69","p"); legibfsep2n->Draw("same"); cibfsep2n->Update(); cibfsep2n->Modified(); cibfsep2n->Write(); cibfsep2n->SaveAs(dirname+filename+"IbfSeparationPower2n.pdf"); //################################################################################################################################################ //3 GeV - Beam ################################################################################################################################### //################################################################################################################################################ // 795, 816, 817, 818,829,830,831,832,834,838,841,842 //################################################################################################################################################ //Standard Gain: Mean ############################################################################################################################ //################################################################################################################################################ TCanvas *cstdmean3n = new TCanvas("cstdmean3n","dEdx standard gain mean",1000,700); cstdmean3n->SetFillColor(00); cstdmean3n->SetGrid(); cstdmean3n->cd(); TMultiGraph *mgstdmean3n = new TMultiGraph(); const int nstdmean3n = 5; double gainstdmean3n[nstdmean3n] = {69., 70., 71., 72., 73.}; double meanel3n[nstdmean3n]; double meanpi3n[nstdmean3n]; double dmeanel3n[nstdmean3n]; double dmeanpi3n[nstdmean3n]; meanel3n[0] = (fitresultsmap[795]).meanel; meanel3n[1] = (fitresultsmap[816]).meanel; meanel3n[2] = (fitresultsmap[817]).meanel; meanel3n[3] = 0; meanel3n[4] = 0; dmeanel3n[0] = (fitresultsmap[795]).meanelerr; dmeanel3n[1] = (fitresultsmap[816]).meanelerr; dmeanel3n[2] = (fitresultsmap[817]).meanelerr; dmeanel3n[3] = 0; dmeanel3n[4] = 0; meanpi3n[0] = (fitresultsmap[795]).meanpi; meanpi3n[1] = (fitresultsmap[816]).meanpi; meanpi3n[2] = (fitresultsmap[817]).meanpi; meanpi3n[3] = 0; meanpi3n[4] = 0; dmeanpi3n[0] = (fitresultsmap[795]).meanpierr; dmeanpi3n[1] = (fitresultsmap[816]).meanpierr; dmeanpi3n[2] = (fitresultsmap[817]).meanpierr; dmeanpi3n[3] = 0; dmeanpi3n[4] = 0; TGraphErrors* grmeanel3n = new TGraphErrors(nstdmean3n,gainstdmean3n,meanel3n,0,dmeanel3n); grmeanel3n->SetLineColor(1); grmeanel3n->SetLineWidth(1); grmeanel3n->SetMarkerColor(1); grmeanel3n->SetMarkerStyle(20); grmeanel3n->SetTitle("electrons"); mgstdmean3n->Add(grmeanel3n); TGraphErrors* grmeanpi3n = new TGraphErrors(nstdmean3n,gainstdmean3n,meanpi3n,0,dmeanpi3n); grmeanpi3n->SetLineColor(15); grmeanpi3n->SetLineWidth(1); grmeanpi3n->SetMarkerColor(15); grmeanpi3n->SetMarkerStyle(20); grmeanpi3n->SetTitle("pions"); mgstdmean3n->Add(grmeanpi3n); mgstdmean3n->Draw("ap"); mgstdmean3n->GetXaxis()->SetTitle("HV scaling factor (%)"); mgstdmean3n->GetYaxis()->SetTitle(""); mgstdmean3n->GetXaxis()->SetLimits(66,76); mgstdmean3n->GetYaxis()->SetRangeUser(0.001,400); TLegend *legstdmean3n=new TLegend(0.2,0.78,0.5,.9); legstdmean3n->SetBorderSize(1); legstdmean3n->SetFillColor(10); legstdmean3n->AddEntry(grmeanel3n,"electrons","p"); legstdmean3n->AddEntry(grmeanpi3n,"pions","p"); legstdmean3n->Draw("same"); cstdmean3n->Update(); cstdmean3n->Modified(); cstdmean3n->Write(); cstdmean3n->SaveAs(dirname+filename+"StdMean3n.pdf"); //################################################################################################################################################ //Standard Gain: Sigma ########################################################################################################################### //################################################################################################################################################ TCanvas *cstdsigma3n = new TCanvas("cstdsigma3n","dEdx standard gain sigma",1000,700); cstdsigma3n->SetFillColor(00); cstdsigma3n->SetGrid(); cstdsigma3n->cd(); TMultiGraph *mgstdsigma3n = new TMultiGraph(); const int nstdsigma3n = 5; double gainstdsigma3n[nstdsigma3n] = {69., 70., 71., 72., 73.}; double sigmael3n[nstdsigma3n]; double sigmapi3n[nstdsigma3n]; double dsigmael3n[nstdsigma3n]; double dsigmapi3n[nstdsigma3n]; sigmael3n[0] = (fitresultsmap[795]).sigmael*100; sigmael3n[1] = (fitresultsmap[816]).sigmael*100; sigmael3n[2] = (fitresultsmap[817]).sigmael*100; sigmael3n[3] = 0; sigmael3n[4] = 0; sigmapi3n[0] = (fitresultsmap[795]).sigmapi*100; sigmapi3n[1] = (fitresultsmap[816]).sigmapi*100; sigmapi3n[2] = (fitresultsmap[817]).sigmapi*100; sigmapi3n[3] = 0; sigmapi3n[4] = 0; dsigmael3n[0] = (fitresultsmap[795]).sigmaelerr*100; dsigmael3n[1] = (fitresultsmap[816]).sigmaelerr*100; dsigmael3n[2] = (fitresultsmap[817]).sigmaelerr*100; dsigmael3n[3] = 0; dsigmael3n[4] = 0; dsigmapi3n[0] = (fitresultsmap[795]).sigmapierr*100; dsigmapi3n[1] = (fitresultsmap[816]).sigmapierr*100; dsigmapi3n[2] = (fitresultsmap[817]).sigmapierr*100; dsigmapi3n[3] = 0; dsigmapi3n[4] = 0; TGraphErrors* grsigmael3n = new TGraphErrors(nstdsigma3n,gainstdsigma3n,sigmael3n,0,dsigmael3n); grsigmael3n->SetLineColor(1); grsigmael3n->SetLineWidth(1); grsigmael3n->SetMarkerColor(1); grsigmael3n->SetMarkerStyle(20); grsigmael3n->SetTitle("electrons"); mgstdsigma3n->Add(grsigmael3n); TGraphErrors* grsigmapi3n = new TGraphErrors(nstdsigma3n,gainstdsigma3n,sigmapi3n,0,dsigmapi3n); grsigmapi3n->SetLineColor(15); grsigmapi3n->SetLineWidth(1); grsigmapi3n->SetMarkerColor(15); grsigmapi3n->SetMarkerStyle(20); grsigmapi3n->SetTitle("pions"); mgstdsigma3n->Add(grsigmapi3n); mgstdsigma3n->Draw("ap"); mgstdsigma3n->GetXaxis()->SetTitle("HV scaling factor (%)"); mgstdsigma3n->GetYaxis()->SetTitle("#sigma(dE/dx)/ (%)"); mgstdsigma3n->GetXaxis()->SetLimits(66,76); mgstdsigma3n->GetYaxis()->SetRangeUser(7,15); TLegend *legstdsigma3n=new TLegend(0.2,0.78,0.5,.9); legstdsigma3n->SetBorderSize(1); legstdsigma3n->SetFillColor(10); legstdsigma3n->AddEntry(grmeanel3n,"electrons","p"); legstdsigma3n->AddEntry(grmeanpi3n,"pions","p"); legstdsigma3n->Draw("same"); cstdsigma3n->Update(); cstdsigma3n->Modified(); cstdsigma3n->Write(); cstdsigma3n->SaveAs(dirname+filename+"StdSigma3n.pdf"); //################################################################################################################################################ //IBF Gain Electrons: Mean ####################################################################################################################### //################################################################################################################################################ TCanvas *cibfelemean3n = new TCanvas("cibfelemean3n","dEdx IBF gain electron mean",1000,700); cibfelemean3n->SetFillColor(00); cibfelemean3n->SetGrid(); cibfelemean3n->cd(); TMultiGraph *mgibfelemean3n = new TMultiGraph(); const int nibfelemean3n = 4; double gainibfelemean3n[nibfelemean3n] = {100., 103.,105.,107.}; double tf200ibfelemean3n[nibfelemean3n]; double tf400ibfelemean3n[nibfelemean3n]; double tf600ibfelemean3n[nibfelemean3n]; double tf800ibfelemean3n[nibfelemean3n]; double dtf200ibfelemean3n[nibfelemean3n]; double dtf400ibfelemean3n[nibfelemean3n]; double dtf600ibfelemean3n[nibfelemean3n]; double dtf800ibfelemean3n[nibfelemean3n]; tf200ibfelemean3n[0] = 0; tf200ibfelemean3n[1] = (fitresultsmap[830]).meanel; tf200ibfelemean3n[2] = (fitresultsmap[832]).meanel; tf200ibfelemean3n[3] = (fitresultsmap[834]).meanel; tf400ibfelemean3n[0] = (fitresultsmap[818]).meanel; tf400ibfelemean3n[1] = (fitresultsmap[831]).meanel; tf400ibfelemean3n[2] = (fitresultsmap[838]).meanel; tf400ibfelemean3n[3] = 0; tf600ibfelemean3n[0] = (fitresultsmap[829]).meanel; tf600ibfelemean3n[1] = (fitresultsmap[841]).meanel; tf600ibfelemean3n[2] = 0; tf600ibfelemean3n[3] = 0; tf800ibfelemean3n[0] = (fitresultsmap[842]).meanel; tf800ibfelemean3n[1] = 0; tf800ibfelemean3n[2] = 0; tf800ibfelemean3n[3] = 0; dtf200ibfelemean3n[0] = 0; dtf200ibfelemean3n[1] = (fitresultsmap[830]).meanelerr; dtf200ibfelemean3n[2] = (fitresultsmap[832]).meanelerr; dtf200ibfelemean3n[3] = (fitresultsmap[834]).meanelerr; dtf400ibfelemean3n[0] = (fitresultsmap[818]).meanelerr; dtf400ibfelemean3n[1] = (fitresultsmap[831]).meanelerr; dtf400ibfelemean3n[2] = (fitresultsmap[838]).meanelerr; dtf400ibfelemean3n[3] = 0; dtf600ibfelemean3n[0] = (fitresultsmap[829]).meanelerr; dtf600ibfelemean3n[1] = (fitresultsmap[841]).meanelerr; dtf600ibfelemean3n[2] = 0; dtf600ibfelemean3n[3] = 0; dtf800ibfelemean3n[0] = (fitresultsmap[842]).meanelerr; dtf800ibfelemean3n[1] = 0; dtf800ibfelemean3n[2] = 0; dtf800ibfelemean3n[3] = 0; double gainibfelemeanstd3n[nstdmean3n] = {100.,101.449,102.899,104.348,105.797}; double meanelibf3n[nstdmean3n]; double dmeanelibf3n[nstdmean3n]; meanelibf3n[0] = (fitresultsmap[795]).meanel; meanelibf3n[1] = (fitresultsmap[816]).meanel; meanelibf3n[2] = (fitresultsmap[817]).meanel; meanelibf3n[3] = 0; meanelibf3n[4] = 0; dmeanelibf3n[0] = (fitresultsmap[795]).meanelerr; dmeanelibf3n[1] = (fitresultsmap[816]).meanelerr; dmeanelibf3n[2] = (fitresultsmap[817]).meanelerr; dmeanelibf3n[3] = 0; dmeanelibf3n[4] = 0; TGraphErrors* grtf200ibfelemean3n = new TGraphErrors(nibfelemean3n,gainibfelemean3n,tf200ibfelemean3n,0,dtf200ibfelemean3n); grtf200ibfelemean3n->SetLineColor(1); grtf200ibfelemean3n->SetLineWidth(1); grtf200ibfelemean3n->SetMarkerColor(1); grtf200ibfelemean3n->SetMarkerStyle(20); grtf200ibfelemean3n->SetTitle("TF 200"); mgibfelemean3n->Add(grtf200ibfelemean3n); TGraphErrors* grtf400ibfelemean3n = new TGraphErrors(nibfelemean3n,gainibfelemean3n,tf400ibfelemean3n,0,dtf400ibfelemean3n); grtf400ibfelemean3n->SetLineColor(4); grtf400ibfelemean3n->SetLineWidth(1); grtf400ibfelemean3n->SetMarkerColor(4); grtf400ibfelemean3n->SetMarkerStyle(20); grtf400ibfelemean3n->SetTitle("TF 400"); mgibfelemean3n->Add(grtf400ibfelemean3n); TGraph* grtf600ibfelemean3n = new TGraphErrors(nibfelemean3n,gainibfelemean3n,tf600ibfelemean3n,0,dtf600ibfelemean3n); grtf600ibfelemean3n->SetLineColor(kOrange); grtf600ibfelemean3n->SetLineWidth(1); grtf600ibfelemean3n->SetMarkerColor(kOrange); grtf600ibfelemean3n->SetMarkerStyle(20); grtf600ibfelemean3n->SetTitle("TF 600"); mgibfelemean3n->Add(grtf600ibfelemean3n); TGraph* grtf800ibfelemean3n = new TGraphErrors(nibfelemean3n,gainibfelemean3n,tf800ibfelemean3n,0,dtf800ibfelemean3n); grtf800ibfelemean3n->SetLineColor(2); grtf800ibfelemean3n->SetLineWidth(1); grtf800ibfelemean3n->SetMarkerColor(2); grtf800ibfelemean3n->SetMarkerStyle(20); grtf800ibfelemean3n->SetTitle("TF 800"); mgibfelemean3n->Add(grtf800ibfelemean3n); TGraphErrors* grstdibfelemean3n = new TGraphErrors(nstdmean3n,gainibfelemeanstd3n,meanelibf3n,0,dmeanelibf3n); grstdibfelemean3n->SetLineColor(15); grstdibfelemean3n->SetLineWidth(1); grstdibfelemean3n->SetMarkerColor(15); grstdibfelemean3n->SetMarkerStyle(20); grstdibfelemean3n->SetTitle("Standard"); mgibfelemean3n->Add(grstdibfelemean3n); mgibfelemean3n->Draw("ap"); mgibfelemean3n->GetXaxis()->SetTitle("HV scaling factor (%)"); mgibfelemean3n->GetYaxis()->SetTitle(" electrons"); mgibfelemean3n->GetXaxis()->SetLimits(98,109); mgibfelemean3n->GetYaxis()->SetRangeUser(0.001,500); TLegend *legibfelemean3n=new TLegend(0.2,0.65,0.5,.9); legibfelemean3n->SetBorderSize(1); legibfelemean3n->SetFillColor(10); legibfelemean3n->AddEntry(grtf200ibfelemean3n,"TF 200","p"); legibfelemean3n->AddEntry(grtf400ibfelemean3n,"TF 400","p"); legibfelemean3n->AddEntry(grtf600ibfelemean3n,"TF 600","p"); legibfelemean3n->AddEntry(grtf800ibfelemean3n,"TF 800","p"); legibfelemean3n->AddEntry(grstdibfelemean3n,"Std. #upoint 100/69","p"); legibfelemean3n->Draw("same"); cibfelemean3n->Update(); cibfelemean3n->Modified(); cibfelemean3n->Write(); cibfelemean3n->SaveAs(dirname+filename+"IbfElMean3n.pdf"); //################################################################################################################################################ //IBF Gain Pions: Mean ########################################################################################################################### //################################################################################################################################################ TCanvas *cibfpimean3n = new TCanvas("cibfpimean3n","dEdx IBF gain pion mean",1000,700); cibfpimean3n->SetFillColor(00); cibfpimean3n->SetGrid(); cibfpimean3n->cd(); TMultiGraph *mgibfpimean3n = new TMultiGraph(); const int nibfpimean3n = 4; double gainibfpimean3n[nibfpimean3n] = {100., 103.,105.,107.}; double tf200ibfpimean3n[nibfpimean3n]; double tf400ibfpimean3n[nibfpimean3n]; double tf600ibfpimean3n[nibfpimean3n]; double tf800ibfpimean3n[nibfpimean3n]; double dtf200ibfpimean3n[nibfpimean3n]; double dtf400ibfpimean3n[nibfpimean3n]; double dtf600ibfpimean3n[nibfpimean3n]; double dtf800ibfpimean3n[nibfpimean3n]; tf200ibfpimean3n[0] = 0; tf200ibfpimean3n[1] = (fitresultsmap[830]).meanpi; tf200ibfpimean3n[2] = (fitresultsmap[832]).meanpi; tf200ibfpimean3n[3] = (fitresultsmap[834]).meanpi; tf400ibfpimean3n[0] = (fitresultsmap[818]).meanpi; tf400ibfpimean3n[1] = (fitresultsmap[831]).meanpi; tf400ibfpimean3n[2] = (fitresultsmap[838]).meanpi; tf400ibfpimean3n[3] = 0; tf600ibfpimean3n[0] = (fitresultsmap[829]).meanpi; tf600ibfpimean3n[1] = (fitresultsmap[841]).meanpi; tf600ibfpimean3n[2] = 0; tf600ibfpimean3n[3] = 0; tf800ibfpimean3n[0] = (fitresultsmap[842]).meanpi; tf800ibfpimean3n[1] = 0; tf800ibfpimean3n[2] = 0; tf800ibfpimean3n[3] = 0; dtf200ibfpimean3n[0] = 0; dtf200ibfpimean3n[1] = (fitresultsmap[830]).meanpierr; dtf200ibfpimean3n[2] = (fitresultsmap[832]).meanpierr; dtf200ibfpimean3n[3] = (fitresultsmap[834]).meanpierr; dtf400ibfpimean3n[0] = (fitresultsmap[818]).meanpierr; dtf400ibfpimean3n[1] = (fitresultsmap[831]).meanpierr; dtf400ibfpimean3n[2] = (fitresultsmap[838]).meanpierr; dtf400ibfpimean3n[3] = 0; dtf600ibfpimean3n[0] = (fitresultsmap[829]).meanpierr; dtf600ibfpimean3n[1] = (fitresultsmap[841]).meanpierr; dtf600ibfpimean3n[2] = 0; dtf600ibfpimean3n[3] = 0; dtf800ibfpimean3n[0] = (fitresultsmap[842]).meanpierr; dtf800ibfpimean3n[1] = 0; dtf800ibfpimean3n[2] = 0; dtf800ibfpimean3n[3] = 0; double gainibfpimeanstd3n[nstdmean3n] = {100.,101.449,102.899,104.348,105.797}; double meanpiibfstd3n[nstdmean3n]; double dmeanpiibfstd3n[nstdmean3n]; meanpiibfstd3n[0] = (fitresultsmap[795]).meanpi; meanpiibfstd3n[1] = (fitresultsmap[816]).meanpi; meanpiibfstd3n[2] = (fitresultsmap[817]).meanpi; meanpiibfstd3n[3] = 0; meanpiibfstd3n[4] = 0; dmeanpiibfstd3n[0] = (fitresultsmap[795]).meanpierr; dmeanpiibfstd3n[1] = (fitresultsmap[816]).meanpierr; dmeanpiibfstd3n[2] = (fitresultsmap[817]).meanpierr; dmeanpiibfstd3n[3] = 0; dmeanpiibfstd3n[4] = 0; TGraphErrors* grtf200ibfpimean3n = new TGraphErrors(nibfpimean3n,gainibfpimean3n,tf200ibfpimean3n,0,dtf200ibfpimean3n); grtf200ibfpimean3n->SetLineColor(1); grtf200ibfpimean3n->SetLineWidth(1); grtf200ibfpimean3n->SetMarkerColor(1); grtf200ibfpimean3n->SetMarkerStyle(20); grtf200ibfpimean3n->SetTitle("TF 200"); mgibfpimean3n->Add(grtf200ibfpimean3n); TGraphErrors* grtf400ibfpimean3n = new TGraphErrors(nibfpimean3n,gainibfpimean3n,tf400ibfpimean3n,0,dtf400ibfpimean3n); grtf400ibfpimean3n->SetLineColor(4); grtf400ibfpimean3n->SetLineWidth(1); grtf400ibfpimean3n->SetMarkerColor(4); grtf400ibfpimean3n->SetMarkerStyle(20); grtf400ibfpimean3n->SetTitle("TF 400"); mgibfpimean3n->Add(grtf400ibfpimean3n); TGraphErrors* grtf600ibfpimean3n = new TGraphErrors(nibfpimean3n,gainibfpimean3n,tf600ibfpimean3n,0,dtf600ibfpimean3n); grtf600ibfpimean3n->SetLineColor(kOrange); grtf600ibfpimean3n->SetLineWidth(1); grtf600ibfpimean3n->SetMarkerColor(kOrange); grtf600ibfpimean3n->SetMarkerStyle(20); grtf600ibfpimean3n->SetTitle("TF 600"); mgibfpimean3n->Add(grtf600ibfpimean3n); TGraphErrors* grtf800ibfpimean3n = new TGraphErrors(nibfpimean3n,gainibfpimean3n,tf800ibfpimean3n,0,dtf800ibfpimean3n); grtf800ibfpimean3n->SetLineColor(2); grtf800ibfpimean3n->SetLineWidth(1); grtf800ibfpimean3n->SetMarkerColor(2); grtf800ibfpimean3n->SetMarkerStyle(20); grtf800ibfpimean3n->SetTitle("TF 800"); mgibfpimean3n->Add(grtf800ibfpimean3n); TGraphErrors* grstdibfpimean3n = new TGraphErrors(nstdmean3n,gainibfpimeanstd3n,meanpiibfstd3n,0,dmeanpiibfstd3n); grstdibfpimean3n->SetLineColor(15); grstdibfpimean3n->SetLineWidth(1); grstdibfpimean3n->SetMarkerColor(15); grstdibfpimean3n->SetMarkerStyle(20); grstdibfpimean3n->SetTitle("Standard"); mgibfpimean3n->Add(grstdibfpimean3n); mgibfpimean3n->Draw("ap"); mgibfpimean3n->GetXaxis()->SetTitle("HV scaling factor (%)"); mgibfpimean3n->GetYaxis()->SetTitle(" pions"); mgibfpimean3n->GetXaxis()->SetLimits(98,109); mgibfpimean3n->GetYaxis()->SetRangeUser(0.001,400); TLegend *legibfpimean3n=new TLegend(0.2,0.65,0.5,.9); legibfpimean3n->SetBorderSize(1); legibfpimean3n->SetFillColor(10); legibfpimean3n->AddEntry(grtf200ibfpimean3n,"TF 200","p"); legibfpimean3n->AddEntry(grtf400ibfpimean3n,"TF 400","p"); legibfpimean3n->AddEntry(grtf600ibfpimean3n,"TF 600","p"); legibfpimean3n->AddEntry(grtf800ibfpimean3n,"TF 800","p"); legibfpimean3n->AddEntry(grstdibfpimean3n,"Std. #upoint 100/69","p"); legibfpimean3n->Draw("same"); cibfpimean3n->Update(); cibfpimean3n->Modified(); cibfpimean3n->Write(); cibfpimean3n->SaveAs(dirname+filename+"IbfPiMean3n.pdf"); //################################################################################################################################################ //IBF Gain Electrons: Sigma ###################################################################################################################### //################################################################################################################################################ TCanvas *cibfelesigma3n = new TCanvas("cibfelesigma3n","dEdx IBF gain electron sigma",1000,700); cibfelesigma3n->SetFillColor(00); cibfelesigma3n->SetGrid(); cibfelesigma3n->cd(); TMultiGraph *mgibfelesigma3n = new TMultiGraph(); const int nibfelesigma3n = 4; double gainibfelesigma3n[nibfelesigma3n] = {100., 103.,105.,107.}; double tf200ibfelesigma3n[nibfelesigma3n]; double tf400ibfelesigma3n[nibfelesigma3n]; double tf600ibfelesigma3n[nibfelesigma3n]; double tf800ibfelesigma3n[nibfelesigma3n]; double dtf200ibfelesigma3n[nibfelesigma3n]; double dtf400ibfelesigma3n[nibfelesigma3n]; double dtf600ibfelesigma3n[nibfelesigma3n]; double dtf800ibfelesigma3n[nibfelesigma3n]; tf200ibfelesigma3n[0] = 0; ; tf200ibfelesigma3n[1] = (fitresultsmap[830]).sigmael*100; tf200ibfelesigma3n[2] = (fitresultsmap[832]).sigmael*100; tf200ibfelesigma3n[3] = (fitresultsmap[834]).sigmael*100; tf400ibfelesigma3n[0] = (fitresultsmap[818]).sigmael*100; tf400ibfelesigma3n[1] = (fitresultsmap[831]).sigmael*100; tf400ibfelesigma3n[2] = (fitresultsmap[838]).sigmael*100; tf400ibfelesigma3n[3] = 0; tf600ibfelesigma3n[0] = (fitresultsmap[829]).sigmael*100; tf600ibfelesigma3n[1] = (fitresultsmap[841]).sigmael*100; tf600ibfelesigma3n[2] = 0; tf600ibfelesigma3n[3] = 0; tf800ibfelesigma3n[0] = (fitresultsmap[842]).sigmael*100; tf800ibfelesigma3n[1] = 0; tf800ibfelesigma3n[2] = 0; tf800ibfelesigma3n[3] = 0; dtf200ibfelesigma3n[0] = 0; dtf200ibfelesigma3n[1] = (fitresultsmap[830]).sigmaelerr*100; dtf200ibfelesigma3n[2] = (fitresultsmap[832]).sigmaelerr*100; dtf200ibfelesigma3n[3] = (fitresultsmap[834]).sigmaelerr*100; dtf400ibfelesigma3n[0] = (fitresultsmap[818]).sigmaelerr*100; dtf400ibfelesigma3n[1] = (fitresultsmap[831]).sigmaelerr*100; dtf400ibfelesigma3n[2] = (fitresultsmap[838]).sigmaelerr*100; dtf400ibfelesigma3n[3] = 0; dtf600ibfelesigma3n[0] = (fitresultsmap[829]).sigmaelerr*100; dtf600ibfelesigma3n[1] = (fitresultsmap[841]).sigmaelerr*100; dtf600ibfelesigma3n[2] = 0; dtf600ibfelesigma3n[3] = 0; dtf800ibfelesigma3n[0] = (fitresultsmap[842]).sigmaelerr*100; dtf800ibfelesigma3n[1] = 0; dtf800ibfelesigma3n[2] = 0; dtf800ibfelesigma3n[3] = 0; double gainibfelesigmastd3n[nstdsigma3n] = {100.,101.449,102.899,104.348,105.797}; double sigmaelibfstd3n[nstdsigma3n]; double dsigmaelibfstd3n[nstdsigma3n]; sigmaelibfstd3n[0] = (fitresultsmap[795]).sigmael*100; sigmaelibfstd3n[1] = (fitresultsmap[816]).sigmael*100; sigmaelibfstd3n[2] = (fitresultsmap[817]).sigmael*100; sigmaelibfstd3n[3] = 0; sigmaelibfstd3n[4] = 0; dsigmaelibfstd3n[0] = (fitresultsmap[795]).sigmaelerr*100; dsigmaelibfstd3n[1] = (fitresultsmap[816]).sigmaelerr*100; dsigmaelibfstd3n[2] = (fitresultsmap[817]).sigmaelerr*100; dsigmaelibfstd3n[3] = 0; dsigmaelibfstd3n[4] = 0; TGraphErrors* grtf200ibfelesigma3n = new TGraphErrors(nibfelesigma3n,gainibfelesigma3n,tf200ibfelesigma3n,0,dtf200ibfelesigma3n); grtf200ibfelesigma3n->SetLineColor(1); grtf200ibfelesigma3n->SetLineWidth(1); grtf200ibfelesigma3n->SetMarkerColor(1); grtf200ibfelesigma3n->SetMarkerStyle(20); grtf200ibfelesigma3n->SetTitle("TF 200"); mgibfelesigma3n->Add(grtf200ibfelesigma3n); TGraphErrors* grtf400ibfelesigma3n = new TGraphErrors(nibfelesigma3n,gainibfelesigma3n,tf400ibfelesigma3n,0,dtf400ibfelesigma3n); grtf400ibfelesigma3n->SetLineColor(4); grtf400ibfelesigma3n->SetLineWidth(1); grtf400ibfelesigma3n->SetMarkerColor(4); grtf400ibfelesigma3n->SetMarkerStyle(20); grtf400ibfelesigma3n->SetTitle("TF 400"); mgibfelesigma3n->Add(grtf400ibfelesigma3n); TGraphErrors* grtf600ibfelesigma3n = new TGraphErrors(nibfelesigma3n,gainibfelesigma3n,tf600ibfelesigma3n,0,dtf600ibfelesigma3n); grtf600ibfelesigma3n->SetLineColor(kOrange); grtf600ibfelesigma3n->SetLineWidth(1); grtf600ibfelesigma3n->SetMarkerColor(kOrange); grtf600ibfelesigma3n->SetMarkerStyle(20); grtf600ibfelesigma3n->SetTitle("TF 600"); mgibfelesigma3n->Add(grtf600ibfelesigma3n); TGraphErrors* grtf800ibfelesigma3n = new TGraphErrors(nibfelesigma3n,gainibfelesigma3n,tf800ibfelesigma3n,0,dtf800ibfelesigma3n); grtf800ibfelesigma3n->SetLineColor(2); grtf800ibfelesigma3n->SetLineWidth(1); grtf800ibfelesigma3n->SetMarkerColor(2); grtf800ibfelesigma3n->SetMarkerStyle(20); grtf800ibfelesigma3n->SetTitle("TF 800"); mgibfelesigma3n->Add(grtf800ibfelesigma3n); TGraphErrors* grstdibfelesigma3n = new TGraphErrors(nstdsigma3n,gainibfelesigmastd3n,sigmaelibfstd3n,0,dsigmaelibfstd3n); grstdibfelesigma3n->SetLineColor(15); grstdibfelesigma3n->SetLineWidth(1); grstdibfelesigma3n->SetMarkerColor(15); grstdibfelesigma3n->SetMarkerStyle(20); grstdibfelesigma3n->SetTitle("Standard"); mgibfelesigma3n->Add(grstdibfelesigma3n); mgibfelesigma3n->Draw("ap"); mgibfelesigma3n->GetXaxis()->SetTitle("HV scaling factor (%)"); mgibfelesigma3n->GetYaxis()->SetTitle("#sigma(dE/dx)/ (%) electrons"); mgibfelesigma3n->GetXaxis()->SetLimits(98,109); mgibfelesigma3n->GetYaxis()->SetRangeUser(8,14); TLegend *legibfelesigma3n=new TLegend( 0.6,0.65,0.9,.9); legibfelesigma3n->SetBorderSize(1); legibfelesigma3n->SetFillColor(10); legibfelesigma3n->AddEntry(grtf200ibfelesigma3n,"TF 200","p"); legibfelesigma3n->AddEntry(grtf400ibfelesigma3n,"TF 400","p"); legibfelesigma3n->AddEntry(grtf600ibfelesigma3n,"TF 600","p"); legibfelesigma3n->AddEntry(grtf800ibfelesigma3n,"TF 800","p"); legibfelesigma3n->AddEntry(grstdibfelesigma3n,"Std. #upoint 100/69","p"); legibfelesigma3n->Draw("same"); cibfelesigma3n->Update(); cibfelesigma3n->Modified(); cibfelesigma3n->Write(); cibfelesigma3n->SaveAs(dirname+filename+"IbfElSigma3n.pdf"); //################################################################################################################################################ //IBF Gain Pions: Sigma ########################################################################################################################## //################################################################################################################################################ TCanvas *cibfpisigma3n = new TCanvas("cibfpisigma3n","dEdx IBF gain pion sigma",1000,700); cibfpisigma3n->SetFillColor(00); cibfpisigma3n->SetGrid(); cibfpisigma3n->cd(); TMultiGraph *mgibfpisigma3n = new TMultiGraph(); const int nibfpisigma3n = 4; double gainibfpisigma3n[nibfpisigma3n] = {100., 103.,105.,107.}; double tf200ibfpisigma3n[nibfpisigma3n]; double tf400ibfpisigma3n[nibfpisigma3n]; double tf600ibfpisigma3n[nibfpisigma3n]; double tf800ibfpisigma3n[nibfpisigma3n]; double dtf200ibfpisigma3n[nibfpisigma3n]; double dtf400ibfpisigma3n[nibfpisigma3n]; double dtf600ibfpisigma3n[nibfpisigma3n]; double dtf800ibfpisigma3n[nibfpisigma3n]; tf200ibfpisigma3n[0] = 0; tf200ibfpisigma3n[1] = (fitresultsmap[830]).sigmapi*100; tf200ibfpisigma3n[2] = (fitresultsmap[832]).sigmapi*100; tf200ibfpisigma3n[3] = (fitresultsmap[834]).sigmapi*100; tf400ibfpisigma3n[0] = (fitresultsmap[818]).sigmapi*100; tf400ibfpisigma3n[1] = (fitresultsmap[831]).sigmapi*100; tf400ibfpisigma3n[2] = (fitresultsmap[838]).sigmapi*100; tf400ibfpisigma3n[3] = 0; tf600ibfpisigma3n[0] = (fitresultsmap[829]).sigmapi*100; tf600ibfpisigma3n[1] = (fitresultsmap[841]).sigmapi*100; tf600ibfpisigma3n[2] = 0; tf600ibfpisigma3n[3] = 0; tf800ibfpisigma3n[0] = (fitresultsmap[842]).sigmapi*100; tf800ibfpisigma3n[1] = 0; tf800ibfpisigma3n[2] = 0; tf800ibfpisigma3n[3] = 0; dtf200ibfpisigma3n[0] = 0; dtf200ibfpisigma3n[1] = (fitresultsmap[830]).sigmapierr*100; dtf200ibfpisigma3n[2] = (fitresultsmap[832]).sigmapierr*100; dtf200ibfpisigma3n[3] = (fitresultsmap[834]).sigmapierr*100; dtf400ibfpisigma3n[0] = (fitresultsmap[818]).sigmapierr*100; dtf400ibfpisigma3n[1] = (fitresultsmap[831]).sigmapierr*100; dtf400ibfpisigma3n[2] = (fitresultsmap[838]).sigmapierr*100; dtf400ibfpisigma3n[3] = 0; dtf600ibfpisigma3n[0] = (fitresultsmap[829]).sigmapierr*100; dtf600ibfpisigma3n[1] = (fitresultsmap[841]).sigmapierr*100; dtf600ibfpisigma3n[2] = 0; dtf600ibfpisigma3n[3] = 0; dtf800ibfpisigma3n[0] = (fitresultsmap[842]).sigmapierr*100; dtf800ibfpisigma3n[1] = 0; dtf800ibfpisigma3n[2] = 0; dtf800ibfpisigma3n[3] = 0; double gainibfpisigmastd3n[nstdsigma] = {100.,101.449,102.899,104.348,105.797}; double sigmapiibfstd3n[nstdsigma]; double dsigmapiibfstd3n[nstdsigma]; sigmapiibfstd3n[0] = (fitresultsmap[795]).sigmapi*100; sigmapiibfstd3n[1] = (fitresultsmap[816]).sigmapi*100; sigmapiibfstd3n[2] = (fitresultsmap[817]).sigmapi*100; sigmapiibfstd3n[3] = 0; sigmapiibfstd3n[4] = 0; dsigmapiibfstd3n[0] = (fitresultsmap[795]).sigmapierr*100; dsigmapiibfstd3n[1] = (fitresultsmap[816]).sigmapierr*100; dsigmapiibfstd3n[2] = (fitresultsmap[817]).sigmapierr*100; dsigmapiibfstd3n[3] = 0; dsigmapiibfstd3n[4] = 0; TGraphErrors* grtf200ibfpisigma3n = new TGraphErrors(nibfpisigma3n,gainibfpisigma3n,tf200ibfpisigma3n,0,dtf200ibfpisigma3n); grtf200ibfpisigma3n->SetLineColor(1); grtf200ibfpisigma3n->SetLineWidth(1); grtf200ibfpisigma3n->SetMarkerColor(1); grtf200ibfpisigma3n->SetMarkerStyle(20); grtf200ibfpisigma3n->SetTitle("TF 200"); mgibfpisigma3n->Add(grtf200ibfpisigma3n); TGraphErrors* grtf400ibfpisigma3n = new TGraphErrors(nibfpisigma3n,gainibfpisigma3n,tf400ibfpisigma3n,0,dtf400ibfpisigma3n); grtf400ibfpisigma3n->SetLineColor(4); grtf400ibfpisigma3n->SetLineWidth(1); grtf400ibfpisigma3n->SetMarkerColor(4); grtf400ibfpisigma3n->SetMarkerStyle(20); grtf400ibfpisigma3n->SetTitle("TF 400"); mgibfpisigma3n->Add(grtf400ibfpisigma3n); TGraphErrors* grtf600ibfpisigma3n = new TGraphErrors(nibfpisigma3n,gainibfpisigma3n,tf600ibfpisigma3n,0,dtf600ibfpisigma3n); grtf600ibfpisigma3n->SetLineColor(kOrange); grtf600ibfpisigma3n->SetLineWidth(1); grtf600ibfpisigma3n->SetMarkerColor(kOrange); grtf600ibfpisigma3n->SetMarkerStyle(20); grtf600ibfpisigma3n->SetTitle("TF 600"); mgibfpisigma3n->Add(grtf600ibfpisigma3n); TGraphErrors* grtf800ibfpisigma3n = new TGraphErrors(nibfpisigma3n,gainibfpisigma3n,tf800ibfpisigma3n,0,dtf800ibfpisigma3n); grtf800ibfpisigma3n->SetLineColor(2); grtf800ibfpisigma3n->SetLineWidth(1); grtf800ibfpisigma3n->SetMarkerColor(2); grtf800ibfpisigma3n->SetMarkerStyle(20); grtf800ibfpisigma3n->SetTitle("TF 800"); mgibfpisigma3n->Add(grtf800ibfpisigma3n); TGraphErrors* grstdibfpisigma3n = new TGraphErrors(nstdsigma,gainibfpisigmastd3n,sigmapiibfstd3n,0,dsigmapiibfstd3n); grstdibfpisigma3n->SetLineColor(15); grstdibfpisigma3n->SetLineWidth(1); grstdibfpisigma3n->SetMarkerColor(15); grstdibfpisigma3n->SetMarkerStyle(20); grstdibfpisigma3n->SetTitle("Standard"); mgibfpisigma3n->Add(grstdibfpisigma3n); mgibfpisigma3n->Draw("ap"); mgibfpisigma3n->GetXaxis()->SetTitle("HV scaling factor (%)"); mgibfpisigma3n->GetYaxis()->SetTitle("#sigma(dE/dx)/ (%) pions"); mgibfpisigma3n->GetXaxis()->SetLimits(98,109); mgibfpisigma3n->GetYaxis()->SetRangeUser(8,14); TLegend *legibfpisigma3n=new TLegend(0.2,0.17,0.5,.42); legibfpisigma3n->SetBorderSize(1); legibfpisigma3n->SetFillColor(10); legibfpisigma3n->AddEntry(grtf200ibfpisigma3n,"TF 200","p"); legibfpisigma3n->AddEntry(grtf400ibfpisigma3n,"TF 400","p"); legibfpisigma3n->AddEntry(grtf600ibfpisigma3n,"TF 600","p"); legibfpisigma3n->AddEntry(grtf800ibfpisigma3n,"TF 800","p"); legibfpisigma3n->AddEntry(grstdibfpisigma3n,"Std. #upoint 100/69","p"); legibfpisigma3n->Draw("same"); cibfpisigma3n->Update(); cibfpisigma3n->Modified(); cibfpisigma3n->Write(); cibfpisigma3n->SaveAs(dirname+filename+"IbfPiSigma3n.pdf"); //################################################################################################################################################ //IBF Gain: Separation Power ##################################################################################################################### //################################################################################################################################################ TCanvas *cibfsep3n = new TCanvas("cibfsep3n","dEdx IBF Separation Power",1000,700); cibfsep3n->SetFillColor(00); cibfsep3n->SetGrid(); cibfsep3n->cd(); TMultiGraph *mgibfsep3n = new TMultiGraph(); const int nibfsep3n = 4; double gainibfsep3n[nibfsep3n] = {100., 103.,105.,107.}; double tf200ibfsep3n[nibfsep3n]; double tf400ibfsep3n[nibfsep3n]; double tf600ibfsep3n[nibfsep3n]; double tf800ibfsep3n[nibfsep3n]; double dtf200ibfsep3n[nibfsep3n]; double dtf400ibfsep3n[nibfsep3n]; double dtf600ibfsep3n[nibfsep3n]; double dtf800ibfsep3n[nibfsep3n]; tf200ibfsep3n[0] = 0; tf200ibfsep3n[1] = (fitresultsmap[830]).separation2; tf200ibfsep3n[2] = (fitresultsmap[832]).separation2; tf200ibfsep3n[3] = (fitresultsmap[834]).separation2; tf400ibfsep3n[0] = (fitresultsmap[818]).separation2; tf400ibfsep3n[1] = (fitresultsmap[831]).separation2; tf400ibfsep3n[2] = (fitresultsmap[838]).separation2; tf400ibfsep3n[3] = 0; tf600ibfsep3n[0] = (fitresultsmap[829]).separation2; tf600ibfsep3n[1] = (fitresultsmap[841]).separation2; tf600ibfsep3n[2] = 0; tf600ibfsep3n[3] = 0; tf800ibfsep3n[0] = (fitresultsmap[842]).separation2; tf800ibfsep3n[1] = 0; tf800ibfsep3n[2] = 0; tf800ibfsep3n[3] = 0; dtf200ibfsep3n[0] = 0; dtf200ibfsep3n[1] = (fitresultsmap[830]).separation2err; dtf200ibfsep3n[2] = (fitresultsmap[832]).separation2err; dtf200ibfsep3n[3] = (fitresultsmap[834]).separation2err; dtf400ibfsep3n[0] = (fitresultsmap[818]).separation2err; dtf400ibfsep3n[1] = (fitresultsmap[831]).separation2err; dtf400ibfsep3n[2] = (fitresultsmap[838]).separation2err; dtf400ibfsep3n[3] = 0; dtf600ibfsep3n[0] = (fitresultsmap[829]).separation2err; dtf600ibfsep3n[1] = (fitresultsmap[841]).separation2err; dtf600ibfsep3n[2] = 0; dtf600ibfsep3n[3] = 0; dtf800ibfsep3n[0] = (fitresultsmap[842]).separation2err; dtf800ibfsep3n[1] = 0; dtf800ibfsep3n[2] = 0; dtf800ibfsep3n[3] = 0; const int nstdsep3n = 5; double gainstdsep3n[nstdsep3n] = {100.,101.449,102.899,104.348,105.797}; double stdsep3n[nstdsep3n]; double dstdsep3n[nstdsep3n]; stdsep3n[0] = (fitresultsmap[795]).separation2; stdsep3n[1] = (fitresultsmap[816]).separation2; stdsep3n[2] = (fitresultsmap[817]).separation2; stdsep3n[3] = 0; stdsep3n[4] = 0; dstdsep3n[0] = (fitresultsmap[795]).separation2err; dstdsep3n[1] = (fitresultsmap[816]).separation2err; dstdsep3n[2] = (fitresultsmap[817]).separation2err; dstdsep3n[3] = 0; dstdsep3n[4] = 0; TGraphErrors* grstdsep3n = new TGraphErrors(nibfsep3n,gainstdsep3n,stdsep3n,0,dstdsep3n); grstdsep3n->SetLineColor(15); grstdsep3n->SetLineWidth(1); grstdsep3n->SetMarkerColor(15); grstdsep3n->SetMarkerStyle(20); grstdsep3n->SetTitle("Standard"); mgibfsep3n->Add(grstdsep3n); TGraphErrors* grtf200ibfsep3n = new TGraphErrors(nibfsep3n,gainibfsep3n,tf200ibfsep3n,0,dtf200ibfsep3n); grtf200ibfsep3n->SetLineColor(1); grtf200ibfsep3n->SetLineWidth(1); grtf200ibfsep3n->SetMarkerColor(1); grtf200ibfsep3n->SetMarkerStyle(20); grtf200ibfsep3n->SetTitle("TF 200"); mgibfsep3n->Add(grtf200ibfsep3n); TGraphErrors* grtf400ibfsep3n = new TGraphErrors(nibfsep3n,gainibfsep3n,tf400ibfsep3n,0,dtf400ibfsep3n); grtf400ibfsep3n->SetLineColor(4); grtf400ibfsep3n->SetLineWidth(1); grtf400ibfsep3n->SetMarkerColor(4); grtf400ibfsep3n->SetMarkerStyle(20); grtf400ibfsep3n->SetTitle("TF 400"); mgibfsep3n->Add(grtf400ibfsep3n); TGraphErrors* grtf600ibfsep3n = new TGraphErrors(nibfsep3n,gainibfsep3n,tf600ibfsep3n,0,dtf600ibfsep3n); grtf600ibfsep3n->SetLineColor(kOrange); grtf600ibfsep3n->SetLineWidth(1); grtf600ibfsep3n->SetMarkerColor(kOrange); grtf600ibfsep3n->SetMarkerStyle(20); grtf600ibfsep3n->SetTitle("TF 600"); mgibfsep3n->Add(grtf600ibfsep3n); TGraphErrors* grtf800ibfsep3n = new TGraphErrors(nibfsep3n,gainibfsep3n,tf800ibfsep3n,0,dtf800ibfsep3n); grtf800ibfsep3n->SetLineColor(2); grtf800ibfsep3n->SetLineWidth(1); grtf800ibfsep3n->SetMarkerColor(2); grtf800ibfsep3n->SetMarkerStyle(20); grtf800ibfsep3n->SetTitle("TF 800"); mgibfsep3n->Add(grtf800ibfsep3n); mgibfsep3n->Draw("ap"); mgibfsep3n->GetXaxis()->SetTitle("HV scaling factor (%)"); mgibfsep3n->GetYaxis()->SetTitle("separation power (#sigma)"); mgibfsep3n->GetXaxis()->SetLimits(98,109); mgibfsep3n->GetYaxis()->SetRangeUser(0.001,10); TLegend *legibfsep3n=new TLegend(0.2,0.65,0.5,.9); legibfsep3n->SetBorderSize(1); legibfsep3n->SetFillColor(10); legibfsep3n->AddEntry(grtf200ibfsep3n,"TF 200","p"); legibfsep3n->AddEntry(grtf400ibfsep3n,"TF 400","p"); legibfsep3n->AddEntry(grtf600ibfsep3n,"TF 600","p"); legibfsep3n->AddEntry(grtf800ibfsep3n,"TF 800","p"); legibfsep3n->AddEntry(grstdsep3n,"Standard #upoint 100/69","p"); legibfsep3n->Draw("same"); cibfsep3n->Update(); cibfsep3n->Modified(); cibfsep3n->Write(); cibfsep3n->SaveAs(dirname+filename+"IbfSeparationPower3n.pdf"); //################################################################################################################################################ //6 GeV + Beam ################################################################################################################################### //################################################################################################################################################ // 867,868,869,871,872 818,829,830,831,832,834,838,841,842 //################################################################################################################################################ //Standard Gain: Mean ############################################################################################################################ //################################################################################################################################################ TCanvas *cstdmean6p = new TCanvas("cstdmean6p","dEdx standard gain mean",1000,700); cstdmean6p->SetFillColor(00); cstdmean6p->SetGrid(); cstdmean6p->cd(); TMultiGraph *mgstdmean6p = new TMultiGraph(); const int nstdmean6p = 5; double gainstdmean6p[nstdmean6p] = {69., 70., 71., 72., 73.}; double meanel6p[nstdmean6p]; double meanpi6p[nstdmean6p]; double dmeanel6p[nstdmean6p]; double dmeanpi6p[nstdmean6p]; meanel6p[0] = (fitresultsmap[867]).meanel; meanel6p[1] = (fitresultsmap[868]).meanel; meanel6p[2] = (fitresultsmap[869]).meanel; meanel6p[3] = (fitresultsmap[871]).meanel; meanel6p[4] = (fitresultsmap[872]).meanel; dmeanel6p[0] = (fitresultsmap[867]).meanelerr; dmeanel6p[1] = (fitresultsmap[868]).meanelerr; dmeanel6p[2] = (fitresultsmap[869]).meanelerr; dmeanel6p[3] = (fitresultsmap[871]).meanelerr; dmeanel6p[4] = (fitresultsmap[872]).meanelerr; meanpi6p[0] = (fitresultsmap[867]).meanpi; meanpi6p[1] = (fitresultsmap[868]).meanpi; meanpi6p[2] = (fitresultsmap[869]).meanpi; meanpi6p[3] = (fitresultsmap[871]).meanpi; meanpi6p[4] = (fitresultsmap[872]).meanpi; dmeanpi6p[0] = (fitresultsmap[867]).meanpierr; dmeanpi6p[1] = (fitresultsmap[868]).meanpierr; dmeanpi6p[2] = (fitresultsmap[869]).meanpierr; dmeanpi6p[3] = (fitresultsmap[871]).meanpierr; dmeanpi6p[4] = (fitresultsmap[872]).meanpierr; TGraphErrors* grmeanel6p = new TGraphErrors(nstdmean6p,gainstdmean6p,meanel6p,0,dmeanel6p); grmeanel6p->SetLineColor(1); grmeanel6p->SetLineWidth(1); grmeanel6p->SetMarkerColor(1); grmeanel6p->SetMarkerStyle(20); grmeanel6p->SetTitle("electrons"); mgstdmean6p->Add(grmeanel6p); TGraphErrors* grmeanpi6p = new TGraphErrors(nstdmean6p,gainstdmean6p,meanpi6p,0,dmeanpi6p); grmeanpi6p->SetLineColor(15); grmeanpi6p->SetLineWidth(1); grmeanpi6p->SetMarkerColor(15); grmeanpi6p->SetMarkerStyle(20); grmeanpi6p->SetTitle("pions"); mgstdmean6p->Add(grmeanpi6p); mgstdmean6p->Draw("ap"); mgstdmean6p->GetXaxis()->SetTitle("HV scaling factor (%)"); mgstdmean6p->GetYaxis()->SetTitle(""); mgstdmean6p->GetXaxis()->SetLimits(66,76); mgstdmean6p->GetYaxis()->SetRangeUser(0.001,400); TLegend *legstdmean6p=new TLegend(0.2,0.78,0.5,.9); legstdmean6p->SetBorderSize(1); legstdmean6p->SetFillColor(10); legstdmean6p->AddEntry(grmeanel6p,"electrons","p"); legstdmean6p->AddEntry(grmeanpi6p,"pions","p"); legstdmean6p->Draw("same"); cstdmean6p->Update(); cstdmean6p->Modified(); cstdmean6p->Write(); cstdmean6p->SaveAs(dirname+filename+"StdMean6p.pdf"); //################################################################################################################################################ //Standard Gain: Sigma ########################################################################################################################### //################################################################################################################################################ TCanvas *cstdsigma6p = new TCanvas("cstdsigma6p","dEdx standard gain sigma",1000,700); cstdsigma6p->SetFillColor(00); cstdsigma6p->SetGrid(); cstdsigma6p->cd(); TMultiGraph *mgstdsigma6p = new TMultiGraph(); const int nstdsigma6p = 5; double gainstdsigma6p[nstdsigma6p] = {69., 70., 71., 72., 73.}; double sigmael6p[nstdsigma6p]; double sigmapi6p[nstdsigma6p]; double dsigmael6p[nstdsigma6p]; double dsigmapi6p[nstdsigma6p]; sigmael6p[0] = (fitresultsmap[867]).sigmael*100; sigmael6p[1] = (fitresultsmap[868]).sigmael*100; sigmael6p[2] = (fitresultsmap[869]).sigmael*100; sigmael6p[3] = (fitresultsmap[871]).sigmael*100; sigmael6p[4] = (fitresultsmap[872]).sigmael*100; sigmapi6p[0] = (fitresultsmap[867]).sigmapi*100; sigmapi6p[1] = (fitresultsmap[868]).sigmapi*100; sigmapi6p[2] = (fitresultsmap[869]).sigmapi*100; sigmapi6p[3] = (fitresultsmap[871]).sigmapi*100; sigmapi6p[4] = (fitresultsmap[872]).sigmapi*100; dsigmael6p[0] = (fitresultsmap[867]).sigmaelerr*100; dsigmael6p[1] = (fitresultsmap[868]).sigmaelerr*100; dsigmael6p[2] = (fitresultsmap[869]).sigmaelerr*100; dsigmael6p[3] = (fitresultsmap[871]).sigmaelerr*100; dsigmael6p[4] = (fitresultsmap[872]).sigmaelerr*100; dsigmapi6p[0] = (fitresultsmap[867]).sigmapierr*100; dsigmapi6p[1] = (fitresultsmap[868]).sigmapierr*100; dsigmapi6p[2] = (fitresultsmap[869]).sigmapierr*100; dsigmapi6p[3] = (fitresultsmap[872]).sigmapierr*100; dsigmapi6p[4] = (fitresultsmap[872]).sigmapierr*100; TGraphErrors* grsigmael6p = new TGraphErrors(nstdsigma6p,gainstdsigma6p,sigmael6p,0,dsigmael6p); grsigmael6p->SetLineColor(1); grsigmael6p->SetLineWidth(1); grsigmael6p->SetMarkerColor(1); grsigmael6p->SetMarkerStyle(20); grsigmael6p->SetTitle("electrons"); mgstdsigma6p->Add(grsigmael6p); TGraphErrors* grsigmapi6p = new TGraphErrors(nstdsigma6p,gainstdsigma6p,sigmapi6p,0,dsigmapi6p); grsigmapi6p->SetLineColor(15); grsigmapi6p->SetLineWidth(1); grsigmapi6p->SetMarkerColor(15); grsigmapi6p->SetMarkerStyle(20); grsigmapi6p->SetTitle("pions"); mgstdsigma6p->Add(grsigmapi6p); mgstdsigma6p->Draw("ap"); mgstdsigma6p->GetXaxis()->SetTitle("HV scaling factor (%)"); mgstdsigma6p->GetYaxis()->SetTitle("#sigma(dE/dx)/ (%)"); mgstdsigma6p->GetXaxis()->SetLimits(66,76); mgstdsigma6p->GetYaxis()->SetRangeUser(7,15); TLegend *legstdsigma6p=new TLegend(0.2,0.78,0.5,.9); legstdsigma6p->SetBorderSize(1); legstdsigma6p->SetFillColor(10); legstdsigma6p->AddEntry(grmeanel6p,"electrons","p"); legstdsigma6p->AddEntry(grmeanpi6p,"pions","p"); legstdsigma6p->Draw("same"); cstdsigma6p->Update(); cstdsigma6p->Modified(); cstdsigma6p->Write(); cstdsigma6p->SaveAs(dirname+filename+"StdSigma6p.pdf"); //################################################################################################################################################ //IBF Gain Electrons: Mean ####################################################################################################################### //################################################################################################################################################ TCanvas *cibfelemean6p = new TCanvas("cibfelemean6p","dEdx IBF gain electron mean",1000,700); cibfelemean6p->SetFillColor(00); cibfelemean6p->SetGrid(); cibfelemean6p->cd(); TMultiGraph *mgibfelemean6p = new TMultiGraph(); const int nibfelemean6p = 4; double gainibfelemean6p[nibfelemean6p] = {100., 103.,105.,107.}; double tf200ibfelemean6p[nibfelemean6p]; double tf400ibfelemean6p[nibfelemean6p]; double tf600ibfelemean6p[nibfelemean6p]; double tf800ibfelemean6p[nibfelemean6p]; double dtf200ibfelemean6p[nibfelemean6p]; double dtf400ibfelemean6p[nibfelemean6p]; double dtf600ibfelemean6p[nibfelemean6p]; double dtf800ibfelemean6p[nibfelemean6p]; tf200ibfelemean6p[0] = 0; tf200ibfelemean6p[1] = (fitresultsmap[876]).meanel; tf200ibfelemean6p[2] = (fitresultsmap[879]).meanel; tf200ibfelemean6p[3] = (fitresultsmap[881]).meanel; tf400ibfelemean6p[0] = (fitresultsmap[873]).meanel; tf400ibfelemean6p[1] = (fitresultsmap[882]).meanel; tf400ibfelemean6p[2] = (fitresultsmap[883]).meanel; tf400ibfelemean6p[3] = 0; tf600ibfelemean6p[0] = (fitresultsmap[884]).meanel; tf600ibfelemean6p[1] = (fitresultsmap[886]).meanel; tf600ibfelemean6p[2] = 0; tf600ibfelemean6p[3] = 0; tf800ibfelemean6p[0] = (fitresultsmap[887]).meanel; tf800ibfelemean6p[1] = 0; tf800ibfelemean6p[2] = 0; tf800ibfelemean6p[3] = 0; dtf200ibfelemean6p[0] = 0; dtf200ibfelemean6p[1] = (fitresultsmap[876]).meanelerr; dtf200ibfelemean6p[2] = (fitresultsmap[879]).meanelerr; dtf200ibfelemean6p[3] = (fitresultsmap[881]).meanelerr; dtf400ibfelemean6p[0] = (fitresultsmap[873]).meanelerr; dtf400ibfelemean6p[1] = (fitresultsmap[882]).meanelerr; dtf400ibfelemean6p[2] = (fitresultsmap[883]).meanelerr; dtf400ibfelemean6p[3] = 0; dtf600ibfelemean6p[0] = (fitresultsmap[884]).meanelerr; dtf600ibfelemean6p[1] = (fitresultsmap[886]).meanelerr; dtf600ibfelemean6p[2] = 0; dtf600ibfelemean6p[3] = 0; dtf800ibfelemean6p[0] = (fitresultsmap[887]).meanelerr; dtf800ibfelemean6p[1] = 0; dtf800ibfelemean6p[2] = 0; dtf800ibfelemean6p[3] = 0; double gainibfelemeanstd6p[nstdmean6p] = {100.,101.449,102.899,104.348,105.797}; double meanelibf6p[nstdmean6p]; double dmeanelibf6p[nstdmean6p]; meanelibf6p[0] = (fitresultsmap[867]).meanel; meanelibf6p[1] = (fitresultsmap[868]).meanel; meanelibf6p[2] = (fitresultsmap[869]).meanel; meanelibf6p[3] = (fitresultsmap[871]).meanel; meanelibf6p[4] = (fitresultsmap[872]).meanel; dmeanelibf6p[0] = (fitresultsmap[867]).meanelerr; dmeanelibf6p[1] = (fitresultsmap[868]).meanelerr; dmeanelibf6p[2] = (fitresultsmap[869]).meanelerr; dmeanelibf6p[3] = (fitresultsmap[871]).meanelerr; dmeanelibf6p[4] = (fitresultsmap[872]).meanelerr; TGraphErrors* grtf200ibfelemean6p = new TGraphErrors(nibfelemean6p,gainibfelemean6p,tf200ibfelemean6p,0,dtf200ibfelemean6p); grtf200ibfelemean6p->SetLineColor(1); grtf200ibfelemean6p->SetLineWidth(1); grtf200ibfelemean6p->SetMarkerColor(1); grtf200ibfelemean6p->SetMarkerStyle(20); grtf200ibfelemean6p->SetTitle("TF 200"); mgibfelemean6p->Add(grtf200ibfelemean6p); TGraphErrors* grtf400ibfelemean6p = new TGraphErrors(nibfelemean6p,gainibfelemean6p,tf400ibfelemean6p,0,dtf400ibfelemean6p); grtf400ibfelemean6p->SetLineColor(4); grtf400ibfelemean6p->SetLineWidth(1); grtf400ibfelemean6p->SetMarkerColor(4); grtf400ibfelemean6p->SetMarkerStyle(20); grtf400ibfelemean6p->SetTitle("TF 400"); mgibfelemean6p->Add(grtf400ibfelemean6p); TGraph* grtf600ibfelemean6p = new TGraphErrors(nibfelemean6p,gainibfelemean6p,tf600ibfelemean6p,0,dtf600ibfelemean6p); grtf600ibfelemean6p->SetLineColor(kOrange); grtf600ibfelemean6p->SetLineWidth(1); grtf600ibfelemean6p->SetMarkerColor(kOrange); grtf600ibfelemean6p->SetMarkerStyle(20); grtf600ibfelemean6p->SetTitle("TF 600"); mgibfelemean6p->Add(grtf600ibfelemean6p); TGraph* grtf800ibfelemean6p = new TGraphErrors(nibfelemean6p,gainibfelemean6p,tf800ibfelemean6p,0,dtf800ibfelemean6p); grtf800ibfelemean6p->SetLineColor(2); grtf800ibfelemean6p->SetLineWidth(1); grtf800ibfelemean6p->SetMarkerColor(2); grtf800ibfelemean6p->SetMarkerStyle(20); grtf800ibfelemean6p->SetTitle("TF 800"); mgibfelemean6p->Add(grtf800ibfelemean6p); TGraphErrors* grstdibfelemean6p = new TGraphErrors(nstdmean6p,gainibfelemeanstd6p,meanelibf6p,0,dmeanelibf6p); grstdibfelemean6p->SetLineColor(15); grstdibfelemean6p->SetLineWidth(1); grstdibfelemean6p->SetMarkerColor(15); grstdibfelemean6p->SetMarkerStyle(20); grstdibfelemean6p->SetTitle("Standard"); mgibfelemean6p->Add(grstdibfelemean6p); mgibfelemean6p->Draw("ap"); mgibfelemean6p->GetXaxis()->SetTitle("HV scaling factor (%)"); mgibfelemean6p->GetYaxis()->SetTitle(" electrons"); mgibfelemean6p->GetXaxis()->SetLimits(98,109); mgibfelemean6p->GetYaxis()->SetRangeUser(0.001,500); TLegend *legibfelemean6p=new TLegend(0.2,0.65,0.5,.9); legibfelemean6p->SetBorderSize(1); legibfelemean6p->SetFillColor(10); legibfelemean6p->AddEntry(grtf200ibfelemean6p,"TF 200","p"); legibfelemean6p->AddEntry(grtf400ibfelemean6p,"TF 400","p"); legibfelemean6p->AddEntry(grtf600ibfelemean6p,"TF 600","p"); legibfelemean6p->AddEntry(grtf800ibfelemean6p,"TF 800","p"); legibfelemean6p->AddEntry(grstdibfelemean6p,"Std. #upoint 100/69","p"); legibfelemean6p->Draw("same"); cibfelemean6p->Update(); cibfelemean6p->Modified(); cibfelemean6p->Write(); cibfelemean6p->SaveAs(dirname+filename+"IbfElMean6p.pdf"); //################################################################################################################################################ //IBF Gain Pions: Mean ########################################################################################################################### //################################################################################################################################################ TCanvas *cibfpimean6p = new TCanvas("cibfpimean6p","dEdx IBF gain pion mean",1000,700); cibfpimean6p->SetFillColor(00); cibfpimean6p->SetGrid(); cibfpimean6p->cd(); TMultiGraph *mgibfpimean6p = new TMultiGraph(); const int nibfpimean6p = 4; double gainibfpimean6p[nibfpimean6p] = {100., 103.,105.,107.}; double tf200ibfpimean6p[nibfpimean6p]; double tf400ibfpimean6p[nibfpimean6p]; double tf600ibfpimean6p[nibfpimean6p]; double tf800ibfpimean6p[nibfpimean6p]; double dtf200ibfpimean6p[nibfpimean6p]; double dtf400ibfpimean6p[nibfpimean6p]; double dtf600ibfpimean6p[nibfpimean6p]; double dtf800ibfpimean6p[nibfpimean6p]; tf200ibfpimean6p[0] = 0; tf200ibfpimean6p[1] = (fitresultsmap[876]).meanpi; tf200ibfpimean6p[2] = (fitresultsmap[879]).meanpi; tf200ibfpimean6p[3] = (fitresultsmap[881]).meanpi; tf400ibfpimean6p[0] = (fitresultsmap[873]).meanpi; tf400ibfpimean6p[1] = (fitresultsmap[882]).meanpi; tf400ibfpimean6p[2] = (fitresultsmap[883]).meanpi; tf400ibfpimean6p[3] = 0; tf600ibfpimean6p[0] = (fitresultsmap[884]).meanpi; tf600ibfpimean6p[1] = (fitresultsmap[886]).meanpi; tf600ibfpimean6p[2] = 0; tf600ibfpimean6p[3] = 0; tf800ibfpimean6p[0] = (fitresultsmap[887]).meanpi; tf800ibfpimean6p[1] = 0; tf800ibfpimean6p[2] = 0; tf800ibfpimean6p[3] = 0; dtf200ibfpimean6p[0] = 0; dtf200ibfpimean6p[1] = (fitresultsmap[876]).meanpierr; dtf200ibfpimean6p[2] = (fitresultsmap[879]).meanpierr; dtf200ibfpimean6p[3] = (fitresultsmap[881]).meanpierr; dtf400ibfpimean6p[0] = (fitresultsmap[873]).meanpierr; dtf400ibfpimean6p[1] = (fitresultsmap[882]).meanpierr; dtf400ibfpimean6p[2] = (fitresultsmap[883]).meanpierr; dtf400ibfpimean6p[3] = 0; dtf600ibfpimean6p[0] = (fitresultsmap[884]).meanpierr; dtf600ibfpimean6p[1] = (fitresultsmap[886]).meanpierr; dtf600ibfpimean6p[2] = 0; dtf600ibfpimean6p[3] = 0; dtf800ibfpimean6p[0] = (fitresultsmap[887]).meanpierr; dtf800ibfpimean6p[1] = 0; dtf800ibfpimean6p[2] = 0; dtf800ibfpimean6p[3] = 0; double gainibfpimeanstd6p[nstdmean6p] = {100.,101.449,102.899,104.348,105.797}; double meanpiibfstd6p[nstdmean6p]; double dmeanpiibfstd6p[nstdmean6p]; meanpiibfstd6p[0] = (fitresultsmap[867]).meanpi; meanpiibfstd6p[1] = (fitresultsmap[868]).meanpi; meanpiibfstd6p[2] = (fitresultsmap[869]).meanpi; meanpiibfstd6p[3] = (fitresultsmap[871]).meanpi; meanpiibfstd6p[4] = (fitresultsmap[872]).meanpi; dmeanpiibfstd6p[0] = (fitresultsmap[867]).meanpierr; dmeanpiibfstd6p[1] = (fitresultsmap[868]).meanpierr; dmeanpiibfstd6p[2] = (fitresultsmap[869]).meanpierr; dmeanpiibfstd6p[3] = (fitresultsmap[871]).meanpierr; dmeanpiibfstd6p[4] = (fitresultsmap[872]).meanpierr; TGraphErrors* grtf200ibfpimean6p = new TGraphErrors(nibfpimean6p,gainibfpimean6p,tf200ibfpimean6p,0,dtf200ibfpimean6p); grtf200ibfpimean6p->SetLineColor(1); grtf200ibfpimean6p->SetLineWidth(1); grtf200ibfpimean6p->SetMarkerColor(1); grtf200ibfpimean6p->SetMarkerStyle(20); grtf200ibfpimean6p->SetTitle("TF 200"); mgibfpimean6p->Add(grtf200ibfpimean6p); TGraphErrors* grtf400ibfpimean6p = new TGraphErrors(nibfpimean6p,gainibfpimean6p,tf400ibfpimean6p,0,dtf400ibfpimean6p); grtf400ibfpimean6p->SetLineColor(4); grtf400ibfpimean6p->SetLineWidth(1); grtf400ibfpimean6p->SetMarkerColor(4); grtf400ibfpimean6p->SetMarkerStyle(20); grtf400ibfpimean6p->SetTitle("TF 400"); mgibfpimean6p->Add(grtf400ibfpimean6p); TGraphErrors* grtf600ibfpimean6p = new TGraphErrors(nibfpimean6p,gainibfpimean6p,tf600ibfpimean6p,0,dtf600ibfpimean6p); grtf600ibfpimean6p->SetLineColor(kOrange); grtf600ibfpimean6p->SetLineWidth(1); grtf600ibfpimean6p->SetMarkerColor(kOrange); grtf600ibfpimean6p->SetMarkerStyle(20); grtf600ibfpimean6p->SetTitle("TF 600"); mgibfpimean6p->Add(grtf600ibfpimean6p); TGraphErrors* grtf800ibfpimean6p = new TGraphErrors(nibfpimean6p,gainibfpimean6p,tf800ibfpimean6p,0,dtf800ibfpimean6p); grtf800ibfpimean6p->SetLineColor(2); grtf800ibfpimean6p->SetLineWidth(1); grtf800ibfpimean6p->SetMarkerColor(2); grtf800ibfpimean6p->SetMarkerStyle(20); grtf800ibfpimean6p->SetTitle("TF 800"); mgibfpimean6p->Add(grtf800ibfpimean6p); TGraphErrors* grstdibfpimean6p = new TGraphErrors(nstdmean6p,gainibfpimeanstd6p,meanpiibfstd6p,0,dmeanpiibfstd6p); grstdibfpimean6p->SetLineColor(15); grstdibfpimean6p->SetLineWidth(1); grstdibfpimean6p->SetMarkerColor(15); grstdibfpimean6p->SetMarkerStyle(20); grstdibfpimean6p->SetTitle("Standard"); mgibfpimean6p->Add(grstdibfpimean6p); mgibfpimean6p->Draw("ap"); mgibfpimean6p->GetXaxis()->SetTitle("HV scaling factor (%)"); mgibfpimean6p->GetYaxis()->SetTitle(" pions"); mgibfpimean6p->GetXaxis()->SetLimits(98,109); mgibfpimean6p->GetYaxis()->SetRangeUser(0.001,400); TLegend *legibfpimean6p=new TLegend(0.2,0.65,0.5,.9); legibfpimean6p->SetBorderSize(1); legibfpimean6p->SetFillColor(10); legibfpimean6p->AddEntry(grtf200ibfpimean6p,"TF 200","p"); legibfpimean6p->AddEntry(grtf400ibfpimean6p,"TF 400","p"); legibfpimean6p->AddEntry(grtf600ibfpimean6p,"TF 600","p"); legibfpimean6p->AddEntry(grtf800ibfpimean6p,"TF 800","p"); legibfpimean6p->AddEntry(grstdibfpimean6p,"Std. #upoint 100/69","p"); legibfpimean6p->Draw("same"); cibfpimean6p->Update(); cibfpimean6p->Modified(); cibfpimean6p->Write(); cibfpimean6p->SaveAs(dirname+filename+"IbfPiMean6p.pdf"); //################################################################################################################################################ //IBF Gain Electrons: Sigma ###################################################################################################################### //################################################################################################################################################ TCanvas *cibfelesigma6p = new TCanvas("cibfelesigma6p","dEdx IBF gain electron sigma",1000,700); cibfelesigma6p->SetFillColor(00); cibfelesigma6p->SetGrid(); cibfelesigma6p->cd(); TMultiGraph *mgibfelesigma6p = new TMultiGraph(); const int nibfelesigma6p = 4; double gainibfelesigma6p[nibfelesigma6p] = {100., 103.,105.,107.}; double tf200ibfelesigma6p[nibfelesigma6p]; double tf400ibfelesigma6p[nibfelesigma6p]; double tf600ibfelesigma6p[nibfelesigma6p]; double tf800ibfelesigma6p[nibfelesigma6p]; double dtf200ibfelesigma6p[nibfelesigma6p]; double dtf400ibfelesigma6p[nibfelesigma6p]; double dtf600ibfelesigma6p[nibfelesigma6p]; double dtf800ibfelesigma6p[nibfelesigma6p]; tf200ibfelesigma6p[0] = 0; ; tf200ibfelesigma6p[1] = (fitresultsmap[876]).sigmael*100; tf200ibfelesigma6p[2] = (fitresultsmap[879]).sigmael*100; tf200ibfelesigma6p[3] = (fitresultsmap[881]).sigmael*100; tf400ibfelesigma6p[0] = (fitresultsmap[873]).sigmael*100; tf400ibfelesigma6p[1] = (fitresultsmap[882]).sigmael*100; tf400ibfelesigma6p[2] = (fitresultsmap[883]).sigmael*100; tf400ibfelesigma6p[3] = 0; tf600ibfelesigma6p[0] = (fitresultsmap[884]).sigmael*100; tf600ibfelesigma6p[1] = (fitresultsmap[886]).sigmael*100; tf600ibfelesigma6p[2] = 0; tf600ibfelesigma6p[3] = 0; tf800ibfelesigma6p[0] = (fitresultsmap[887]).sigmael*100; tf800ibfelesigma6p[1] = 0; tf800ibfelesigma6p[2] = 0; tf800ibfelesigma6p[3] = 0; dtf200ibfelesigma6p[0] = 0; dtf200ibfelesigma6p[1] = (fitresultsmap[876]).sigmaelerr*100; dtf200ibfelesigma6p[2] = (fitresultsmap[879]).sigmaelerr*100; dtf200ibfelesigma6p[3] = (fitresultsmap[881]).sigmaelerr*100; dtf400ibfelesigma6p[0] = (fitresultsmap[873]).sigmaelerr*100; dtf400ibfelesigma6p[1] = (fitresultsmap[882]).sigmaelerr*100; dtf400ibfelesigma6p[2] = (fitresultsmap[883]).sigmaelerr*100; dtf400ibfelesigma6p[3] = 0; dtf600ibfelesigma6p[0] = (fitresultsmap[884]).sigmaelerr*100; dtf600ibfelesigma6p[1] = (fitresultsmap[886]).sigmaelerr*100; dtf600ibfelesigma6p[2] = 0; dtf600ibfelesigma6p[3] = 0; dtf800ibfelesigma6p[0] = (fitresultsmap[887]).sigmaelerr*100; dtf800ibfelesigma6p[1] = 0; dtf800ibfelesigma6p[2] = 0; dtf800ibfelesigma6p[3] = 0; double gainibfelesigmastd6p[nstdsigma6p] = {100.,101.449,102.899,104.348,105.797}; double sigmaelibfstd6p[nstdsigma6p]; double dsigmaelibfstd6p[nstdsigma6p]; sigmaelibfstd6p[0] = (fitresultsmap[867]).sigmael*100; sigmaelibfstd6p[1] = (fitresultsmap[868]).sigmael*100; sigmaelibfstd6p[2] = (fitresultsmap[869]).sigmael*100; sigmaelibfstd6p[3] = (fitresultsmap[871]).sigmael*100; sigmaelibfstd6p[4] = (fitresultsmap[872]).sigmael*100; dsigmaelibfstd6p[0] = (fitresultsmap[867]).sigmaelerr*100; dsigmaelibfstd6p[1] = (fitresultsmap[868]).sigmaelerr*100; dsigmaelibfstd6p[2] = (fitresultsmap[869]).sigmaelerr*100; dsigmaelibfstd6p[3] = (fitresultsmap[871]).sigmaelerr*100; dsigmaelibfstd6p[4] = (fitresultsmap[872]).sigmaelerr*100; TGraphErrors* grtf200ibfelesigma6p = new TGraphErrors(nibfelesigma6p,gainibfelesigma6p,tf200ibfelesigma6p,0,dtf200ibfelesigma6p); grtf200ibfelesigma6p->SetLineColor(1); grtf200ibfelesigma6p->SetLineWidth(1); grtf200ibfelesigma6p->SetMarkerColor(1); grtf200ibfelesigma6p->SetMarkerStyle(20); grtf200ibfelesigma6p->SetTitle("TF 200"); mgibfelesigma6p->Add(grtf200ibfelesigma6p); TGraphErrors* grtf400ibfelesigma6p = new TGraphErrors(nibfelesigma6p,gainibfelesigma6p,tf400ibfelesigma6p,0,dtf400ibfelesigma6p); grtf400ibfelesigma6p->SetLineColor(4); grtf400ibfelesigma6p->SetLineWidth(1); grtf400ibfelesigma6p->SetMarkerColor(4); grtf400ibfelesigma6p->SetMarkerStyle(20); grtf400ibfelesigma6p->SetTitle("TF 400"); mgibfelesigma6p->Add(grtf400ibfelesigma6p); TGraphErrors* grtf600ibfelesigma6p = new TGraphErrors(nibfelesigma6p,gainibfelesigma6p,tf600ibfelesigma6p,0,dtf600ibfelesigma6p); grtf600ibfelesigma6p->SetLineColor(kOrange); grtf600ibfelesigma6p->SetLineWidth(1); grtf600ibfelesigma6p->SetMarkerColor(kOrange); grtf600ibfelesigma6p->SetMarkerStyle(20); grtf600ibfelesigma6p->SetTitle("TF 600"); mgibfelesigma6p->Add(grtf600ibfelesigma6p); TGraphErrors* grtf800ibfelesigma6p = new TGraphErrors(nibfelesigma6p,gainibfelesigma6p,tf800ibfelesigma6p,0,dtf800ibfelesigma6p); grtf800ibfelesigma6p->SetLineColor(2); grtf800ibfelesigma6p->SetLineWidth(1); grtf800ibfelesigma6p->SetMarkerColor(2); grtf800ibfelesigma6p->SetMarkerStyle(20); grtf800ibfelesigma6p->SetTitle("TF 800"); mgibfelesigma6p->Add(grtf800ibfelesigma6p); TGraphErrors* grstdibfelesigma6p = new TGraphErrors(nstdsigma6p,gainibfelesigmastd6p,sigmaelibfstd6p,0,dsigmaelibfstd6p); grstdibfelesigma6p->SetLineColor(15); grstdibfelesigma6p->SetLineWidth(1); grstdibfelesigma6p->SetMarkerColor(15); grstdibfelesigma6p->SetMarkerStyle(20); grstdibfelesigma6p->SetTitle("Standard"); mgibfelesigma6p->Add(grstdibfelesigma6p); mgibfelesigma6p->Draw("ap"); mgibfelesigma6p->GetXaxis()->SetTitle("HV scaling factor (%)"); mgibfelesigma6p->GetYaxis()->SetTitle("#sigma(dE/dx)/ (%) electrons"); mgibfelesigma6p->GetXaxis()->SetLimits(98,109); mgibfelesigma6p->GetYaxis()->SetRangeUser(8,14); TLegend *legibfelesigma6p=new TLegend( 0.6,0.65,0.9,.9); legibfelesigma6p->SetBorderSize(1); legibfelesigma6p->SetFillColor(10); legibfelesigma6p->AddEntry(grtf200ibfelesigma6p,"TF 200","p"); legibfelesigma6p->AddEntry(grtf400ibfelesigma6p,"TF 400","p"); legibfelesigma6p->AddEntry(grtf600ibfelesigma6p,"TF 600","p"); legibfelesigma6p->AddEntry(grtf800ibfelesigma6p,"TF 800","p"); legibfelesigma6p->AddEntry(grstdibfelesigma6p,"Std. #upoint 100/69","p"); legibfelesigma6p->Draw("same"); cibfelesigma6p->Update(); cibfelesigma6p->Modified(); cibfelesigma6p->Write(); cibfelesigma6p->SaveAs(dirname+filename+"IbfElSigma6p.pdf"); //################################################################################################################################################ //IBF Gain Pions: Sigma ########################################################################################################################## //################################################################################################################################################ TCanvas *cibfpisigma6p = new TCanvas("cibfpisigma6p","dEdx IBF gain pion sigma",1000,700); cibfpisigma6p->SetFillColor(00); cibfpisigma6p->SetGrid(); cibfpisigma6p->cd(); TMultiGraph *mgibfpisigma6p = new TMultiGraph(); const int nibfpisigma6p = 4; double gainibfpisigma6p[nibfpisigma6p] = {100., 103.,105.,107.}; double tf200ibfpisigma6p[nibfpisigma6p]; double tf400ibfpisigma6p[nibfpisigma6p]; double tf600ibfpisigma6p[nibfpisigma6p]; double tf800ibfpisigma6p[nibfpisigma6p]; double dtf200ibfpisigma6p[nibfpisigma6p]; double dtf400ibfpisigma6p[nibfpisigma6p]; double dtf600ibfpisigma6p[nibfpisigma6p]; double dtf800ibfpisigma6p[nibfpisigma6p]; tf200ibfpisigma6p[0] = 0; tf200ibfpisigma6p[1] = (fitresultsmap[876]).sigmapi*100; tf200ibfpisigma6p[2] = (fitresultsmap[879]).sigmapi*100; tf200ibfpisigma6p[3] = (fitresultsmap[881]).sigmapi*100; tf400ibfpisigma6p[0] = (fitresultsmap[873]).sigmapi*100; tf400ibfpisigma6p[1] = (fitresultsmap[882]).sigmapi*100; tf400ibfpisigma6p[2] = (fitresultsmap[883]).sigmapi*100; tf400ibfpisigma6p[3] = 0; tf600ibfpisigma6p[0] = (fitresultsmap[884]).sigmapi*100; tf600ibfpisigma6p[1] = (fitresultsmap[886]).sigmapi*100; tf600ibfpisigma6p[2] = 0; tf600ibfpisigma6p[3] = 0; tf800ibfpisigma6p[0] = (fitresultsmap[887]).sigmapi*100; tf800ibfpisigma6p[1] = 0; tf800ibfpisigma6p[2] = 0; tf800ibfpisigma6p[3] = 0; dtf200ibfpisigma6p[0] = 0; dtf200ibfpisigma6p[1] = (fitresultsmap[876]).sigmapierr*100; dtf200ibfpisigma6p[2] = (fitresultsmap[879]).sigmapierr*100; dtf200ibfpisigma6p[3] = (fitresultsmap[881]).sigmapierr*100; dtf400ibfpisigma6p[0] = (fitresultsmap[873]).sigmapierr*100; dtf400ibfpisigma6p[1] = (fitresultsmap[882]).sigmapierr*100; dtf400ibfpisigma6p[2] = (fitresultsmap[883]).sigmapierr*100; dtf400ibfpisigma6p[3] = 0; dtf600ibfpisigma6p[0] = (fitresultsmap[884]).sigmapierr*100; dtf600ibfpisigma6p[1] = (fitresultsmap[886]).sigmapierr*100; dtf600ibfpisigma6p[2] = 0; dtf600ibfpisigma6p[3] = 0; dtf800ibfpisigma6p[0] = (fitresultsmap[887]).sigmapierr*100; dtf800ibfpisigma6p[1] = 0; dtf800ibfpisigma6p[2] = 0; dtf800ibfpisigma6p[3] = 0; double gainibfpisigmastd6p[nstdsigma] = {100.,101.449,102.899,104.348,105.797}; double sigmapiibfstd6p[nstdsigma]; double dsigmapiibfstd6p[nstdsigma]; sigmapiibfstd6p[0] = (fitresultsmap[867]).sigmapi*100; sigmapiibfstd6p[1] = (fitresultsmap[868]).sigmapi*100; sigmapiibfstd6p[2] = (fitresultsmap[869]).sigmapi*100; sigmapiibfstd6p[3] = (fitresultsmap[871]).sigmapi*100; sigmapiibfstd6p[4] = (fitresultsmap[872]).sigmapi*100; dsigmapiibfstd6p[0] = (fitresultsmap[867]).sigmapierr*100; dsigmapiibfstd6p[1] = (fitresultsmap[868]).sigmapierr*100; dsigmapiibfstd6p[2] = (fitresultsmap[869]).sigmapierr*100; dsigmapiibfstd6p[3] = (fitresultsmap[871]).sigmapierr*100; dsigmapiibfstd6p[4] = (fitresultsmap[872]).sigmapierr*100; TGraphErrors* grtf200ibfpisigma6p = new TGraphErrors(nibfpisigma6p,gainibfpisigma6p,tf200ibfpisigma6p,0,dtf200ibfpisigma6p); grtf200ibfpisigma6p->SetLineColor(1); grtf200ibfpisigma6p->SetLineWidth(1); grtf200ibfpisigma6p->SetMarkerColor(1); grtf200ibfpisigma6p->SetMarkerStyle(20); grtf200ibfpisigma6p->SetTitle("TF 200"); mgibfpisigma6p->Add(grtf200ibfpisigma6p); TGraphErrors* grtf400ibfpisigma6p = new TGraphErrors(nibfpisigma6p,gainibfpisigma6p,tf400ibfpisigma6p,0,dtf400ibfpisigma6p); grtf400ibfpisigma6p->SetLineColor(4); grtf400ibfpisigma6p->SetLineWidth(1); grtf400ibfpisigma6p->SetMarkerColor(4); grtf400ibfpisigma6p->SetMarkerStyle(20); grtf400ibfpisigma6p->SetTitle("TF 400"); mgibfpisigma6p->Add(grtf400ibfpisigma6p); TGraphErrors* grtf600ibfpisigma6p = new TGraphErrors(nibfpisigma6p,gainibfpisigma6p,tf600ibfpisigma6p,0,dtf600ibfpisigma6p); grtf600ibfpisigma6p->SetLineColor(kOrange); grtf600ibfpisigma6p->SetLineWidth(1); grtf600ibfpisigma6p->SetMarkerColor(kOrange); grtf600ibfpisigma6p->SetMarkerStyle(20); grtf600ibfpisigma6p->SetTitle("TF 600"); mgibfpisigma6p->Add(grtf600ibfpisigma6p); TGraphErrors* grtf800ibfpisigma6p = new TGraphErrors(nibfpisigma6p,gainibfpisigma6p,tf800ibfpisigma6p,0,dtf800ibfpisigma6p); grtf800ibfpisigma6p->SetLineColor(2); grtf800ibfpisigma6p->SetLineWidth(1); grtf800ibfpisigma6p->SetMarkerColor(2); grtf800ibfpisigma6p->SetMarkerStyle(20); grtf800ibfpisigma6p->SetTitle("TF 800"); mgibfpisigma6p->Add(grtf800ibfpisigma6p); TGraphErrors* grstdibfpisigma6p = new TGraphErrors(nstdsigma,gainibfpisigmastd6p,sigmapiibfstd6p,0,dsigmapiibfstd6p); grstdibfpisigma6p->SetLineColor(15); grstdibfpisigma6p->SetLineWidth(1); grstdibfpisigma6p->SetMarkerColor(15); grstdibfpisigma6p->SetMarkerStyle(20); grstdibfpisigma6p->SetTitle("Standard"); mgibfpisigma6p->Add(grstdibfpisigma6p); mgibfpisigma6p->Draw("ap"); mgibfpisigma6p->GetXaxis()->SetTitle("HV scaling factor (%)"); mgibfpisigma6p->GetYaxis()->SetTitle("#sigma(dE/dx)/ (%) pions"); mgibfpisigma6p->GetXaxis()->SetLimits(98,109); mgibfpisigma6p->GetYaxis()->SetRangeUser(9,15); TLegend *legibfpisigma6p=new TLegend(0.2,0.17,0.5,.42); legibfpisigma6p->SetBorderSize(1); legibfpisigma6p->SetFillColor(10); legibfpisigma6p->AddEntry(grtf200ibfpisigma6p,"TF 200","p"); legibfpisigma6p->AddEntry(grtf400ibfpisigma6p,"TF 400","p"); legibfpisigma6p->AddEntry(grtf600ibfpisigma6p,"TF 600","p"); legibfpisigma6p->AddEntry(grtf800ibfpisigma6p,"TF 800","p"); legibfpisigma6p->AddEntry(grstdibfpisigma6p,"Std. #upoint 100/69","p"); legibfpisigma6p->Draw("same"); cibfpisigma6p->Update(); cibfpisigma6p->Modified(); cibfpisigma6p->Write(); cibfpisigma6p->SaveAs(dirname+filename+"IbfPiSigma6p.pdf"); //################################################################################################################################################ //IBF Gain: Separation Power ##################################################################################################################### //################################################################################################################################################ TCanvas *cibfsep6p = new TCanvas("cibfsep6p","dEdx IBF Separation Power",1000,700); cibfsep6p->SetFillColor(00); cibfsep6p->SetGrid(); cibfsep6p->cd(); TMultiGraph *mgibfsep6p = new TMultiGraph(); const int nibfsep6p = 4; double gainibfsep6p[nibfsep6p] = {100., 103.,105.,107.}; double tf200ibfsep6p[nibfsep6p]; double tf400ibfsep6p[nibfsep6p]; double tf600ibfsep6p[nibfsep6p]; double tf800ibfsep6p[nibfsep6p]; double dtf200ibfsep6p[nibfsep6p]; double dtf400ibfsep6p[nibfsep6p]; double dtf600ibfsep6p[nibfsep6p]; double dtf800ibfsep6p[nibfsep6p]; tf200ibfsep6p[0] = 0; tf200ibfsep6p[1] = (fitresultsmap[876]).separation2; tf200ibfsep6p[2] = (fitresultsmap[879]).separation2; tf200ibfsep6p[3] = (fitresultsmap[881]).separation2; tf400ibfsep6p[0] = (fitresultsmap[873]).separation2; tf400ibfsep6p[1] = (fitresultsmap[882]).separation2; tf400ibfsep6p[2] = (fitresultsmap[883]).separation2; tf400ibfsep6p[3] = 0; tf600ibfsep6p[0] = (fitresultsmap[884]).separation2; tf600ibfsep6p[1] = (fitresultsmap[886]).separation2; tf600ibfsep6p[2] = 0; tf600ibfsep6p[3] = 0; tf800ibfsep6p[0] = (fitresultsmap[887]).separation2; tf800ibfsep6p[1] = 0; tf800ibfsep6p[2] = 0; tf800ibfsep6p[3] = 0; dtf200ibfsep6p[0] = 0; dtf200ibfsep6p[1] = (fitresultsmap[876]).separation2err; dtf200ibfsep6p[2] = (fitresultsmap[879]).separation2err; dtf200ibfsep6p[3] = (fitresultsmap[881]).separation2err; dtf400ibfsep6p[0] = (fitresultsmap[873]).separation2err; dtf400ibfsep6p[1] = (fitresultsmap[882]).separation2err; dtf400ibfsep6p[2] = (fitresultsmap[883]).separation2err; dtf400ibfsep6p[3] = 0; dtf600ibfsep6p[0] = (fitresultsmap[884]).separation2err; dtf600ibfsep6p[1] = (fitresultsmap[886]).separation2err; dtf600ibfsep6p[2] = 0; dtf600ibfsep6p[3] = 0; dtf800ibfsep6p[0] = (fitresultsmap[887]).separation2err; dtf800ibfsep6p[1] = 0; dtf800ibfsep6p[2] = 0; dtf800ibfsep6p[3] = 0; const int nstdsep6p = 5; double gainstdsep6p[nstdsep6p] = {100.,101.449,102.899,104.348,105.797}; double stdsep6p[nstdsep6p]; double dstdsep6p[nstdsep6p]; stdsep6p[0] = (fitresultsmap[867]).separation2; stdsep6p[1] = (fitresultsmap[868]).separation2; stdsep6p[2] = (fitresultsmap[869]).separation2; stdsep6p[3] = (fitresultsmap[871]).separation2; stdsep6p[4] = (fitresultsmap[872]).separation2; dstdsep6p[0] = (fitresultsmap[867]).separation2err; dstdsep6p[1] = (fitresultsmap[868]).separation2err; dstdsep6p[2] = (fitresultsmap[869]).separation2err; dstdsep6p[3] = (fitresultsmap[871]).separation2err; dstdsep6p[4] = (fitresultsmap[872]).separation2err; TGraphErrors* grstdsep6p = new TGraphErrors(nibfsep6p,gainstdsep6p,stdsep6p,0,dstdsep6p); grstdsep6p->SetLineColor(15); grstdsep6p->SetLineWidth(1); grstdsep6p->SetMarkerColor(15); grstdsep6p->SetMarkerStyle(20); grstdsep6p->SetTitle("Standard"); mgibfsep6p->Add(grstdsep6p); TGraphErrors* grtf200ibfsep6p = new TGraphErrors(nibfsep6p,gainibfsep6p,tf200ibfsep6p,0,dtf200ibfsep6p); grtf200ibfsep6p->SetLineColor(1); grtf200ibfsep6p->SetLineWidth(1); grtf200ibfsep6p->SetMarkerColor(1); grtf200ibfsep6p->SetMarkerStyle(20); grtf200ibfsep6p->SetTitle("TF 200"); mgibfsep6p->Add(grtf200ibfsep6p); TGraphErrors* grtf400ibfsep6p = new TGraphErrors(nibfsep6p,gainibfsep6p,tf400ibfsep6p,0,dtf400ibfsep6p); grtf400ibfsep6p->SetLineColor(4); grtf400ibfsep6p->SetLineWidth(1); grtf400ibfsep6p->SetMarkerColor(4); grtf400ibfsep6p->SetMarkerStyle(20); grtf400ibfsep6p->SetTitle("TF 400"); mgibfsep6p->Add(grtf400ibfsep6p); TGraphErrors* grtf600ibfsep6p = new TGraphErrors(nibfsep6p,gainibfsep6p,tf600ibfsep6p,0,dtf600ibfsep6p); grtf600ibfsep6p->SetLineColor(kOrange); grtf600ibfsep6p->SetLineWidth(1); grtf600ibfsep6p->SetMarkerColor(kOrange); grtf600ibfsep6p->SetMarkerStyle(20); grtf600ibfsep6p->SetTitle("TF 600"); mgibfsep6p->Add(grtf600ibfsep6p); TGraphErrors* grtf800ibfsep6p = new TGraphErrors(nibfsep6p,gainibfsep6p,tf800ibfsep6p,0,dtf800ibfsep6p); grtf800ibfsep6p->SetLineColor(2); grtf800ibfsep6p->SetLineWidth(1); grtf800ibfsep6p->SetMarkerColor(2); grtf800ibfsep6p->SetMarkerStyle(20); grtf800ibfsep6p->SetTitle("TF 800"); mgibfsep6p->Add(grtf800ibfsep6p); mgibfsep6p->Draw("ap"); mgibfsep6p->GetXaxis()->SetTitle("HV scaling factor (%)"); mgibfsep6p->GetYaxis()->SetTitle("separation power (#sigma)"); mgibfsep6p->GetXaxis()->SetLimits(98,109); mgibfsep6p->GetYaxis()->SetRangeUser(0.001,10); TLegend *legibfsep6p=new TLegend(0.2,0.65,0.5,.9); legibfsep6p->SetBorderSize(1); legibfsep6p->SetFillColor(10); legibfsep6p->AddEntry(grtf200ibfpisigma6p,"TF 200","p"); legibfsep6p->AddEntry(grtf400ibfpisigma6p,"TF 400","p"); legibfsep6p->AddEntry(grtf600ibfpisigma6p,"TF 600","p"); legibfsep6p->AddEntry(grtf800ibfpisigma6p,"TF 800","p"); legibfsep6p->AddEntry(grstdsep6p,"Std. #upoint 100/69","p"); legibfsep6p->Draw("same"); cibfsep6p->Update(); cibfsep6p->Modified(); cibfsep6p->Write(); cibfsep6p->SaveAs(dirname+filename+"IbfSeparationPower6p.pdf"); //----------------------------------------------------------------------------------- savefile->Close(); }