//Return a graph of the llscan
TGraph * LLscanResult::GetGraph()
{
double* pvs = new double[parameterValues.size()] ;
double* llvs = new double[parameterValues.size()] ;
double llmax = 0 ;
for(unsigned int i=0; i< parameterValues.size() ; ++i ){
pvs[i] = parameterValues[i] ;
llvs[i] = llvalues_offset[i] ;
if( llvs[i] > llmax ) llmax = llvs[i] ;
}
TGraph* gr = new TGraph( Int_t(parameterValues.size()), pvs, llvs ) ;
//gr->SetTitle("LL Scan for Parameter xxx");
gr->SetMarkerStyle(1);
gr->SetLineWidth(2);
gr->SetMarkerColor(4);
gr->SetLineColor(4);
gr->GetYaxis()->SetRangeUser( 0., llmax*1.2 );
gr->GetYaxis()->SetLimits( 0., llmax*1.2 );
gr->SetMinimum( 0.0 );
gr->SetMaximum( llmax*1.2 );
gr->Draw("ALP");
string title("LL Scan for Parameter ") ;
title+=parameterName.c_str();
gr->SetTitle(title.c_str());
gr->GetXaxis()->SetTitle(parameterName.c_str());
return gr ;
}
void histos_pde_two(){
std::string material[3] = {"lxe","lxe_tpb","lyso"};
std::string interaction[3] = {"","_noCher","_noScint"};
double sigmas[3][3][20]; // [mat][inter][pde]
double pdeValues[20];
char pde[5];
TCanvas *c1 = new TCanvas("c1","multipads",900,700);
for(int mat=0; mat<3;mat++){
for(int inter=0; inter<2;inter++){
for(int i=5;i<=100;i+=5){
pdeValues[i/5-1] = i;
//There is an error with lsyo noScint pde 0.05
if((mat==2 && inter==2) && i==5)){
continue;
}
sprintf(pde, "%.2lf", i/100.0);
if(i==100){
sprintf(pde, "0%.2lf", i/100.0);
}
std::string path = "/home/jmbenlloch/next/petalo/work/histo/pde/";
std::string fileName = path + material[mat] + interaction[inter] + std::string("_PHYS_QE_") + std::string(pde) + std::string("_SPTR_0_ASIC_0_DT300_histos.root"); std::string(Form("%d", 1));
std::cout << fileName << std::endl;
TFile *fIn = new TFile(fileName.c_str(), "read");
TH1F *h1 = (TH1F*) fIn->Get("DTOF.DTOF3");
TF1* gauF1 = new TF1("gauF1","gaus",-20,20);
TF1* gauF2 = new TF1("gauF2","gaus",-60,60);
TF1 *total = new TF1("total","gaus(0)+gaus(3)",-50,50);
h1->Scale(1/h1->Integral(), "width");
Double_t par[6];
h1->Fit(gauF1,"R");
h1->Fit(gauF2,"R+");
//Do not plot
h1->GetFunction("gauF1")->SetBit(TF1::kNotDraw);
h1->GetFunction("gauF2")->SetBit(TF1::kNotDraw);
gauF1->GetParameters(&par[0]);
gauF2->GetParameters(&par[3]);
total->SetParameters(par);
h1->Fit(total,"R+");
h1->Draw();
std::string histo = path + material[mat] + interaction[inter] + std::string("_pde_") + pde + std::string(".png");
std::cout << histo << std::endl;
c1->Print(histo.c_str());
std::cout << "PDE: " << pde << "sigma: " << h1->GetFunction("gauF1")->GetParameter(2) << std::endl;
sigmas[mat][inter][i/5-1] = h1->GetFunction("gauF1")->GetParameter(2);
fIn->Close();
}
}
}
c1->Close();
TCanvas *c2 = new TCanvas("c2","multipads",900,700);
TGraph *gLxe = new TGraph(20, pdeValues, sigmas[0][0]);
gLxe->SetLineColor(kRed);
gLxe->SetLineWidth(2);
TGraph *gTpb = new TGraph(20, pdeValues, sigmas[1][0]);
gTpb->SetLineColor(kBlue);
gTpb->SetLineWidth(2);
TGraph *gLyso = new TGraph(20, pdeValues, sigmas[2][0]);
gLyso->SetLineColor(kGreen);
gLyso->SetLineWidth(2);
gLyso->Draw();
gLyso->SetTitle("");
gLyso->GetXaxis().SetTitle("PDE (%)");
gLyso->GetXaxis()->SetLimits(0.,100.);
gLyso->GetYaxis().SetTitle("CRT (ps)");
gLyso->SetMinimum(0.);
gLyso->SetMaximum(50.);
gTpb->Draw("same");
gLxe->Draw("same");
TLegend *leg = new TLegend(0.7, 0.7, 0.9, 0.9);
leg->SetFillColor(0);
leg->AddEntry(gLxe, "LXe", "lp");
leg->AddEntry(gTpb, "LXe-TPB", "lp");
leg->AddEntry(gLyso, "LYSO", "lp");
leg->Draw("same");
c2->Print("/home/jmbenlloch/next/petalo/work/histo/pde/pde.png");
TCanvas *c3 = new TCanvas("c3","multipads",900,700);
TGraph *gLxe_noCher = new TGraph(20, pdeValues, sigmas[0][1]);
gLxe_noCher->SetLineColor(kRed);
gLxe_noCher->SetLineWidth(2);
TGraph *gTpb_noCher = new TGraph(20, pdeValues, sigmas[1][1]);
gTpb_noCher->SetLineColor(kBlue);
gTpb_noCher->SetLineWidth(2);
TGraph *gLyso_noCher = new TGraph(20, pdeValues, sigmas[2][1]);
gLyso_noCher->SetLineColor(kGreen);
gLyso_noCher->SetLineWidth(2);
gLyso_noCher->Draw();
gLyso_noCher->SetTitle("noCher");
gLyso_noCher->GetXaxis().SetTitle("PDE (%)");
gLyso_noCher->GetXaxis()->SetLimits(0.,100.);
gLyso_noCher->GetYaxis().SetTitle("CRT (ps)");
gLyso_noCher->SetMinimum(0.);
gLyso_noCher->SetMaximum(50.);
gTpb_noCher->Draw("same");
gLxe_noCher->Draw("same");
TLegend *leg_noCher = new TLegend(0.7, 0.7, 0.9, 0.9);
leg_noCher->SetFillColor(0);
leg_noCher->AddEntry(gLxe, "LXe", "lp");
leg_noCher->AddEntry(gTpb, "LXe-TPB", "lp");
leg_noCher->AddEntry(gLyso, "LYSO", "lp");
leg_noCher->Draw("same");
c3->Print("/home/jmbenlloch/next/petalo/work/histo/pde/pde_noCher.png");
}
void plotFittedValueHPOL(){
AnitaGeomTool *myGeomTool = AnitaGeomTool::Instance();
double x[MAX_ANTENNAS] = {0.};
double y[MAX_ANTENNAS] = {0.};
double z[MAX_ANTENNAS] = {0.};
double r[MAX_ANTENNAS] = {0.};
double phi[MAX_ANTENNAS] = {0.};
double zFit[MAX_ANTENNAS] = {0.};
double rFit[MAX_ANTENNAS] = {0.};
double phiFit[MAX_ANTENNAS] = {0.};
double zFit2[MAX_ANTENNAS] = {0.};
double rFit2[MAX_ANTENNAS] = {0.};
double phiFit2[MAX_ANTENNAS] = {0.};
Double_t deltaR[MAX_ANTENNAS]={0};
Double_t deltaZ[MAX_ANTENNAS]={0};
Double_t deltaPhi[MAX_ANTENNAS]={0};
Double_t deltaCableDelays[MAX_ANTENNAS]={0};
Double_t antArray[MAX_ANTENNAS] = {0.};
Double_t cableDelays[MAX_ANTENNAS]={0};
AnitaPol::AnitaPol_t pol = AnitaPol::kHorizontal;
for (unsigned int ant=0; ant<MAX_ANTENNAS; ++ant){
antArray[ant] = (ant+1)*1.;
// myGeomTool->getAntXYZ(ant, x[ant], y[ant], z[ant], pol);
// r[ant] = myGeomTool->getAntR(ant, pol);
// phi[ant] = myGeomTool->getAntPhiPosition(ant, pol);
}
TLegend *leg = new TLegend(0.6, 0.75, 0.89, 0.89);
leg->SetFillColor(kWhite);
TGraph *gphotoR = new TGraph(48, antArray, r);
gphotoR->SetMarkerStyle(22);
TGraph *gphotoZ = new TGraph(48, antArray, z);
gphotoZ->SetMarkerStyle(22);
TGraph *gphotoPHI = new TGraph(48, antArray, phi);
gphotoPHI->SetMarkerStyle(22);
TGraph *gphotoCableDelay = new TGraph(48, antArray, cableDelays);
gphotoCableDelay->SetMarkerStyle(22);
const int numfile = 2;
// string filename[numfile]={"newLindaNumbers_4steps_zDisplaced_VPOL_10kVSeavey_2015_11_05_time_19_47_53.txt", "newLindaNumbers_4steps_zDisplaced_VPOL_10kVSeavey_2015_11_06_time_10_42_48.txt", "newLindaNumbers_4steps_zDisplaced_VPOL_10kVSeavey_2015_11_11_time_15_38_30.txt", "newLindaNumbers_4steps_2015_10_13_time_14_30_54.txt"};
string filename[numfile]={"final/newLindaNumbers_4steps_HPOL_2015_11_13_time_17_19_58.txt", "newLindaNumbers_4steps_LDBHPOL_10kVSeavey_2015_11_19_time_10_16_23.txt"};
string which[numfile] = {"FIT WAIS H-POL", "FIT LDB H-POL"};
TCanvas *c1 = new TCanvas("c1", "", 1200, 750);
gphotoR->SetTitle(";Antenna;#Delta r [m]");
gphotoR->Draw("Ap");
gphotoR->SetMinimum(-0.2);
gphotoR->SetMaximum(+0.2);
gphotoR->Draw("Ap");
TCanvas *c2 = new TCanvas("c2", "", 1200, 750);
gphotoZ->SetTitle(";Antenna;#Delta z [m]");
gphotoZ->Draw("Ap");
gphotoZ->SetMinimum(-0.2);
gphotoZ->SetMaximum(+0.2);
gphotoZ->Draw("Ap");
TCanvas *c3 = new TCanvas("c3", "", 1200, 750);
gphotoPHI->SetTitle(";Antenna;#Delta phi [rad]");
gphotoPHI->Draw("Ap");
gphotoPHI->SetMinimum(-0.2);
gphotoPHI->SetMaximum(+0.2);
gphotoPHI->Draw("Ap");
TCanvas *c4 = new TCanvas("c4", "", 1200, 750);
gphotoCableDelay->SetTitle(";Antenna;Time offset [ns]");
gphotoCableDelay->Draw("Ap");
gphotoCableDelay->SetMinimum(-0.5);
gphotoCableDelay->SetMaximum(+0.5);
gphotoCableDelay->Draw("Ap");
leg->AddEntry(gphotoR, "Photogrammetry", "p");
Color_t colors[5]={kRed, kOrange, kGreen, kBlue, kCyan};
for (int i=0;i<numfile;i++){
ifstream myInput(Form("/home/lindac/ANITA/Software/EventCorrelator/macros/lindaMacros/%s", filename[i].c_str()));
if (myInput.is_open()){
for (int i=0;i<48;i++){
myInput >> antArray[i] >> deltaR[i] >> deltaZ[i] >> deltaPhi[i] >> deltaCableDelays[i];
cout << antArray[i] << " " << deltaR[i] << endl;
}
}
for (unsigned int ant=0; ant<MAX_ANTENNAS; ++ant){
rFit[ant] = r[ant] + deltaR[ant];
zFit[ant] = z[ant] + deltaZ[ant];
phiFit[ant] = phi[ant] + deltaPhi[ant];
antArray[ant] = (ant+1)*1.;
}
TGraph *gfitR = new TGraph(48, antArray, rFit);
gfitR->SetMarkerStyle(22);
gfitR->SetMarkerColor(colors[i]);
TGraph *gfitZ = new TGraph(48, antArray, zFit);
gfitZ->SetMarkerStyle(22);
gfitZ->SetMarkerColor(colors[i]);
TGraph *gfitPHI = new TGraph(48, antArray, phiFit);
gfitPHI->SetMarkerStyle(22);
gfitPHI->SetMarkerColor(colors[i]);
TGraph *gfitT = new TGraph(48, antArray, deltaCableDelays);
gfitT->SetMarkerStyle(22);
gfitT->SetMarkerColor(colors[i]);
leg->AddEntry(gfitR, Form("Fitted w/ %s", which[i].c_str()), "p");
c1->cd();
gfitR->Draw("p same");
c2->cd();
gfitZ->Draw("p same");
c3->cd();
gfitPHI->Draw("p same");
c4->cd();
gfitT->Draw("p same");
}
c1->cd();
leg->Draw();
c1->Print("FittedValues_HPOL_R_4steps_compare.png");
c1->Print("FittedValues_HPOL_R_4steps_compare.pdf");
c2->cd();
leg->Draw();
c2->Print("FittedValues_HPOL_Z_4steps_compare.png");
c2->Print("FittedValues_HPOL_Z_4steps_compare.pdf");
c3->cd();
leg->Draw();
c3->Print("FittedValues_HPOL_PHI_4steps_compare.png");
c3->Print("FittedValues_HPOL_PHI_4steps_compare.pdf");
c4->cd();
leg->Draw();
c4->Print("FittedValues_HPOL_CableDelay_4steps_compare.png");
c4->Print("FittedValues_HPOL_CableDelay_4steps_compare.pdf");
}
void ExtractSignalYield(string ModelName, string decayMode, float natural_width, bool dependsOnKtilde=0)
{
string dir = "/usr/users/dschaefer/root/results/";
string outputfile = ModelName+"_"+decayMode+"_signalYield.root";
//float natural_width =0.05;
std::stringstream s;
if(int(natural_width*100+0.5) == 10 or int(100*natural_width+0.5)==20 or int(natural_width*100+0.5)==30)
{
s << std::fixed << std::setprecision(1) << natural_width;
}
else
{
s << std::fixed << std::setprecision(2) << natural_width;
}
string swidth = s.str();
float ktilde;
string sktilde;
if(dependsOnKtilde)
{
ktilde = natural_width;
sktilde = swidth;
}
TGraph* limit = getObservedLimit(ModelName,decayMode,natural_width,dependsOnKtilde);
TGraph* limitUP = getLimitUp(ModelName,decayMode,natural_width,1,dependsOnKtilde);
TGraph* limitDOWN = getLimitDown(ModelName,decayMode,natural_width,1,dependsOnKtilde);
TGraph* limitUP2 = getLimitUp(ModelName,decayMode,natural_width,2,dependsOnKtilde);
TGraph* limitDOWN2 = getLimitDown(ModelName,decayMode,natural_width,2,dependsOnKtilde);
int number;
float* masses;
if(decayMode.find("lvjj")!=string::npos)
{
masses = new float[38];
number =38;
float array[38] = {800,900,1000,1100,1200,1300,1400,1500,1600,1700,1800,1900,2000,2100,2200,2300,2400,2500,2600,2700,2800,2900,3000,3100,3200,3300,3400,3500,3600,3700,3800,3900,4000,4100,4200,4300,4400,4500};
masses = array;
}
else
{
number = 29;
masses = new float[29];
float array[29] = {1200,1300,1400,1500,1600,1700,1800,1900,2000,2100,2200,2300,2400,2500,2600,2700,2800,2900,3000,3100,3200,3300,3400,3500,3600,3700,3800,3900,4000};
masses = array;
}
TGraph* gryellow = new TGraph(2*number);
TGraph* grgreen = new TGraph(2*number);
for(int m=0;m<number;m++)
{
gryellow->SetPoint(m,masses[m],limitUP->Eval(masses[m]));
gryellow->SetPoint(number+m,masses[number-m-1],limitDOWN->Eval(masses[number-m-1]));
grgreen->SetPoint(m,masses[m],limitUP2->Eval(masses[m]));
grgreen->SetPoint(number+m,masses[number-m-1],limitDOWN2->Eval(masses[number-m-1]));
}
gryellow->SetFillColor(kYellow);
grgreen->SetFillColor(kGreen);
TCanvas* test = new TCanvas("test","test",400,400);
test->SetLogy();
limitUP->SetFillColor(kGreen+2);
limitUP->SetLineColor(kGreen+2);
limitUP->SetLineWidth(-1504);
//limitUP->Draw("ACP");
limitDOWN->SetFillColor(kBlue);
limitDOWN->SetLineColor(kGreen+2);
limitDOWN->SetLineWidth(-1504);
//limitDOWN->Draw("CPsame");
gryellow->Draw("AFsame");
grgreen->Draw("Fsame");
limit->SetLineColor(kBlue);
limit->SetLineWidth(3);
limit->Draw("Lsame");
test->Update();
float lumi = 2.10*1000; //pb^-1
if(decayMode.find("jjjj")!=string::npos){lumi = 2.6*1000;}//pb^-1
//float *xs = getTheoryCrossSection(ModelName,0.1);
//x values for which a theory prediction for production cross section exists
float m_xs[10] = {800,900,1000,1500,1800,2000,2500,3000,3500,4500};
float BR_G_to_WW[10];
float BR_G_to_ZZ[10];
float *acceptance;
float *N_expected;
//float xs = 0.01;
float *xs = new float[10];
if(dependsOnKtilde)
{
xs = getTheoryCrossSection(ModelName,ktilde);
}
else
{
for(int i=0;i<10;i++)
{
if(natural_width!=0)
{
ktilde = getKtilde(ModelName,m_xs[i],natural_width);
//std::cout << m_xs[i] << " k = " << ktilde <<std::endl;
xs[i] = getTheoryCrossSection(ModelName,m_xs[i],ktilde);
}
else
{
ktilde = getKtilde(ModelName,m_xs[i],0.02);
//std::cout << m_xs[i] << " k = " << ktilde <<std::endl;
xs[i] = getTheoryCrossSection(ModelName,m_xs[i],ktilde);
}
}
}
TGraph* production_xs = new TGraph(10,m_xs,xs);
// TCanvas* c_xs = new TCanvas("c_xs","c_xs",400,400);
// c_xs->SetLogy();
// production_xs->SetMarkerColor(1);
// production_xs->GetXaxis()->SetTitle("m_G [GeV]");
// production_xs->GetYaxis()->SetTitle("theory production cross section");
// production_xs->Draw("AL");
if(!dependsOnKtilde)
{
acceptance = getAcceptance(ModelName,decayMode,m_xs,10);
}
else
{
acceptance = getAcceptance(decayMode,ktilde);
}
N_expected = getNumberOfExpectedEvents(xs,m_xs,acceptance,ModelName,decayMode);
std::cout << "production cross section : "<< std::endl;
for(int i=0;i<10;i++)
{
std::cout << m_xs[i] << " " << xs[i]<< std::endl;
}
std::cout << " acceptance : "<<std::endl;
for(int i=0;i<10;i++)
{
std::cout << m_xs[i] << " "<<acceptance[i]<<std::endl;
}
float br[10];
std::cout << "Branching Ratios : "<<std::endl;
for(int i=0;i<10;i++)
{
float BR_W_to_lv = 0.327;
float BR_W_to_jj = 0.674;
float BR_Z_to_jj = 0.6991;
br[i] = getBranchingRatioToWW(ModelName,m_xs[i])*std::pow(BR_W_to_jj,2)*2 + getBranchingRatioToZZ(ModelName,m_xs[i])*std::pow(BR_Z_to_jj,2)*2;
if(decayMode.find("lvjj")!=std::string::npos)
{
br[i] = getBranchingRatioToWW(ModelName,m_xs[i])*2*BR_W_to_lv*BR_W_to_jj;
}
std::cout << m_xs[i] << " "<< br[i] << std::endl;
}
std::cout << lumi <<std::endl;
std::cout << " N expected : "<<std::endl;
for(int i=0;i<10;i++)
{
std::cout << m_xs[i] << " "<<N_expected[i] << " " <<xs[i]*lumi*br[i]*acceptance[i] << std::endl;
}
TGraph* N = new TGraph(10,m_xs,N_expected);
//N->SetName("expected signal yield");
grgreen->GetXaxis()->SetTitle("m_{VV} [GeV]");
grgreen->GetYaxis()->SetTitle("number signal events");
grgreen->GetYaxis()->SetTitleOffset(1.3);
grgreen->SetTitle("");
TCanvas* c_N = new TCanvas("c_N","c_N",600,400);
gPad->SetRightMargin(0.1);
gPad->SetLeftMargin(0.1);
limit->SetLineColor(kBlue);
limit->SetLineWidth(3);
c_N->SetLogy();
N->SetLineColor(kRed);
N->SetLineWidth(2);
//N->Draw("A");
grgreen->SetMaximum(1000);
grgreen->Draw("AF");
gryellow->Draw("Fsame");
limit->Draw("Csame");
N->Draw("Lsame");
TLegend* leg = new TLegend(0.59,0.65,0.95,0.89);
leg->SetFillColor(kWhite);
leg->SetFillStyle(0);
leg->SetTextSize(0.04);
leg->SetBorderSize(0);
string title = "Preliminary";
string cms = "#font[62]{CMS} #font[52]{"+string(title)+"} ";
string lumitext = "2.6 fb^{-1}, #sqrt{s} = 13 TeV";
string cmstext = "CMS ,2.6 fb^{-1}, #sqrt{s} = 13 TeV";
if(decayMode.find("had")==string::npos){lumitext = "2.1 fb^{-1}, #sqrt{s} = 13 TeV";}
string theory = "G #rightarrow WW, #Gamma = "+swidth;
if(dependsOnKtilde)
{
theory = "G #rightarrow WW, #tilde{k} = "+sktilde;
}
if(ModelName.find("RSGrav")!=string::npos)
{
theory = "RS #rightarrow WW, #Gamma = "+swidth;
if(dependsOnKtilde)
{
theory = "RS #rightarrow WW, #tilde{k} = "+sktilde;
}
}
leg->AddEntry(grgreen,"Expected (95%)","f");
leg->AddEntry(gryellow,"Expected (68%)","f");
leg->AddEntry(limit,"observed","L");
leg->AddEntry(N,theory.c_str(),"L");
leg->Draw("same");
TLatex CMS;
int y = 1050;
int x = 500;
int x2 = 3400;
if(decayMode.find("jjjj")!= string::npos){y=1050;x=1000;x2=3000;}
CMS.SetTextFont(43);
CMS.SetTextSize(18);
CMS.DrawLatex(x,y,cms.c_str());
CMS.DrawLatex(x2,y,lumitext.c_str());
c_N->Update();
if(dependsOnKtilde)
{
c_N->SaveAs(("/usr/users/dschaefer/root/results/misc/"+ModelName+"_limit_"+decayMode+"_ktilde"+swidth+".pdf").c_str());
}
else
{
c_N->SaveAs(("/usr/users/dschaefer/root/results/misc/"+ModelName+"_limit_"+decayMode+"_"+swidth+".pdf").c_str());
}
//===========================================================================================
//======== my own produced samples with ktilde = 0.095 ======================================
//===========================================================================================
float* acc2 = getAcceptance(decayMode,0.095);
float* xs_new = getTheoryCrossSection(ModelName,0.095);
for(int i=0;i<10;i++)
{
std::cout << " acceptance int : " << acceptance[i] <<std::endl;
std::cout << " acceptance 2 : " << acc2[i] << std::endl;
}
// TGraph* testa
// TCanvas* test2 = new TCanvas("test2","test2",400,400);
// obsl->Draw("AL");
// Neve->Draw("LSAME");
float* N_expected2 = getNumberOfExpectedEvents(xs_new,m_xs,acc2,ModelName,decayMode);
TGraph* obsl = getObservedLimit(ModelName,decayMode,0.095,1);
TGraph* Neve = new TGraph(10,m_xs,N_expected2);
TGraph* pl = getExcludedPoints(ModelName,decayMode,obsl,Neve,0.095);
pl->SetLineWidth(3);
pl->SetLineColor(kWhite);
//pl->SetFillStyle(3013);
//pl->SetFillColor(kWhite);
string channel = "had";
if(decayMode.find("lvjj")!=std::string::npos)
{
channel = "em";
}
TFile* file = new TFile(("/home/dschaefer/CMSSW_7_1_5/src/HiggsAnalysis/CombinedLimit/graphs_"+channel+".root").c_str(),"READ");
string histoname = "ExclusionLimitOnEventNumber_BulkG_WW_em_HP";
if(channel.find("had")!=std::string::npos)
{
histoname = "ExclusionLimitOnEventNumber_BulkWW_had_HP";
}
TH2F* obsLim = dynamic_cast<TH2F*>(file->Get(histoname.c_str()));
TCanvas* MyC = new TCanvas("MyC","MyC",800,600);
MyC->SetRightMargin(0.19);
// MyC->SetLeftMargin(0.12);
// MyC->SetTopMargin(0.08);
// MyC->SetBottomMargin(0.15);
MyC->SetLogz();
obsLim->Draw("COLZ");
//pl->Draw("f");
pl->Draw("Same");
std::map<float,float> mass_acc;
for(int i=0;i<10;i++)
{
mass_acc.insert(std::pair<float, float>(m_xs[i],acc2[i]));
}
TGraph* allpoints = findAllExcludedPoints(ModelName,decayMode, mass_acc,0.095);
MyC->cd();
allpoints->Draw("Psame");
float massmax = 4500;
float massmin = 800;
int n = (massmax-massmin)/100;
float* k = new float[n*2];
int t=0;
for(int i=0;i<=n;i++)
{
k[i] = getKtilde("RSGrav",massmin+i*100,0.3);
std::cout << "mass max: "<< massmin+i*100 << " ktilde " << k[i]<<std::endl;
}
for(int i=n;i<2*n;i++)
{
k[i] = getKtilde("RSGrav",massmin+(i-n)*100,0.02);
std::cout << " mass min : "<< massmin+(i-n)*100 << " ktilde " << k[i] << std::endl;
}
printWidthForKtilde("RSGrav",0.12,3600,800);
printWidthForKtilde("RSGrav",0.2 ,2400,800);
printWidthForKtilde("RSGrav",0.3 ,1800,800);
printWidthForKtilde("RSGrav",0.4 ,1500,800);
printWidthForKtilde("RSGrav",0.5 ,1100 ,800);
printWidthForKtilde("RSGrav",0.05,4500,2000);
printWidthForKtilde("RSGrav",0.03,4600,3200);
}
void makePlots( const char * model,
const char * target,
const char * src,
const char * config,
const char * infile)
{
double MAXY = 2.4;
double x_Q13_SetI = sin(8.8*TMath::Pi()/180.0)*sin(8.8*TMath::Pi()/180.0);
double x_Q13_SetII = sin(12.0*TMath::Pi()/180.0)*sin(12.0*TMath::Pi()/180.0);
//Input path
TString inpath("./root_files/RvsQ13/");
TString inputfile = inpath + TString(infile);
//Output path
TString path("./paper02-plots/ratio/");
TList * v_Variations = new TList();
TObjString *var;
var = new TObjString("Sin2Q13-1.8-dCP0");
v_Variations->Add( var );
var = new TObjString("Sin2Q13-1.8-dCP180");
v_Variations->Add( var );
if ( TString(model) != TString("StdPicture") ) {
var = new TObjString("Sin2Q13-2.0-dCP0");
v_Variations->Add( var );
var = new TObjString("Sin2Q13-2.0-dCP180");
v_Variations->Add( var );
} else {
var = new TObjString("Sin2Q13-2-dCP0");
v_Variations->Add( var );
var = new TObjString("Sin2Q13-2-dCP180");
v_Variations->Add( var );
}
var = new TObjString("Sin2Q13-2.2-dCP0");
v_Variations->Add( var );
var = new TObjString("Sin2Q13-2.2-dCP180");
v_Variations->Add( var );
int * linewidth = new int[6];
int * linestyle = new int[6];
int * linecolor = new int[6];
linewidth[0] = 2;
linewidth[1] = 3;
linewidth[2] = 2;
linewidth[3] = 3;
linewidth[4] = 2;
linewidth[5] = 3;
linecolor[0] = 1;
linecolor[1] = 2;
linecolor[2] = 1;
linecolor[3] = 2;
linecolor[4] = 1;
linecolor[5] = 2;
linestyle[0] = 1;
linestyle[1] = 1;
linestyle[2] = 2;
linestyle[3] = 2;
linestyle[4] = 3;
linestyle[5] = 3;
TList * v_Labels = new TList();
TObjString *label;
label = new TObjString( "#alpha = 1.8" );
v_Labels->Add( label );
label = new TObjString( "#alpha = 2.0" );
v_Labels->Add( label );
label = new TObjString( "#alpha = 2.2" );
v_Labels->Add( label );
TFile * f1 = new TFile( inputfile.Data() );
f1->cd();
TList * v_Graphs = new TList();
int max = v_Variations->GetEntries();
for( int k = 0; k < max; ++k )
{
TString current = ((TObjString*)v_Variations->At(k))->GetString();
TString dataPxx = TString( "Ratio_" )
+ TString( model ) + TString("_")
+ TString( target ) + TString("_")
+ TString( src ) + TString("_")
+ TString( current.Data() )
+ TString("/data");
std::cout << dataPxx << std::endl;
TTree * PxxTreeNu = (TTree*)gDirectory->Get( dataPxx.Data() );
//Branches
double xx = 0.0;
double yy = 0.0;
PxxTreeNu->SetBranchAddress("Xx",&xx);
PxxTreeNu->SetBranchAddress("Ratio",&yy);
Long64_t nentries = PxxTreeNu->GetEntries();
TGraph * g1 = new TGraph();
for (Long64_t i=0;i<nentries;i++) {
PxxTreeNu->GetEntry(i);
g1->SetPoint( i, xx, yy);
}
v_Graphs->Add( g1 );
}
TString cname = TString("Ratio") + TString("_") + TString(model) + TString("_") + TString(config);
TCanvas * c1 = new TCanvas( cname.Data(), "track/shower ratio", 206,141,722,575);
c1->SetBorderSize(2);
TLegend * leg = new TLegend(0.18,0.64,0.44,0.87);
leg->SetBorderSize(0);
leg->SetTextFont(22);
leg->SetTextSize(0.062);
leg->SetLineColor(1);
leg->SetLineStyle(1);
leg->SetLineWidth(1);
leg->SetFillColor(0);
leg->SetFillStyle(0);
int labelpos = 0;
for( int k = 0; k < max; ++k )
{
TGraph * gg = (TGraph*)v_Graphs->At(k);
gg->SetMarkerStyle(25);
gg->SetFillColor(10);
gg->SetLineColor(linecolor[k]);
gg->SetLineWidth(linewidth[k]);
gg->SetLineStyle(linestyle[k]);
gg->SetMaximum(MAXY);
gg->SetMinimum(1.6);
gg->GetXaxis()->SetLimits( 0.0, 0.055 );
gg->GetXaxis()->SetTitle("sin^{2}#theta_{13}");
gg->GetXaxis()->CenterTitle(true);
gg->GetXaxis()->SetLabelFont(42);
gg->GetXaxis()->SetLabelOffset(0.006);
gg->GetXaxis()->SetLabelSize(0.06);
gg->GetXaxis()->SetTitleSize(0.06);
gg->GetXaxis()->SetTickLength(0.05);
gg->GetXaxis()->SetTitleOffset(1.07);
gg->GetXaxis()->SetTitleFont(42);
gg->GetXaxis()->SetNdivisions(509);
gg->GetYaxis()->SetTitle("R");
gg->GetYaxis()->CenterTitle(true);
gg->GetYaxis()->SetNdivisions(509);
gg->GetYaxis()->SetLabelFont(42);
gg->GetYaxis()->SetLabelOffset(0.007);
gg->GetYaxis()->SetLabelSize(0.06);
gg->GetYaxis()->SetTitleSize(0.06);
gg->GetYaxis()->SetTitleOffset(0.93);
gg->GetYaxis()->SetTitleFont(42);
if ( ((k+1) % 2) == 0 )
{
TString alpha = ((TObjString*)v_Labels->At(labelpos))->GetString();
leg->AddEntry( gg, alpha.Data(),"l");
labelpos+=1;
}
c1->cd();
if( k == 0 )
gg->Draw("AC");
else
gg->Draw("C");
TString ThisModel;
TString ThisConfig;
if( TString(model) == TString("StdPicture") )
ThisModel = TString("No matter effect");
else
{
ThisModel = TString(model);
ThisModel.Insert(5," ");
}
ThisConfig = TString(config);
ThisConfig.Insert(3," ");
TLatex * tex = new TLatex(0.033, (MAXY-(MAXY*0.035)), ThisModel.Data() );
tex->SetLineWidth(2);
tex->Draw();
if ( TString(model) != TString("StdPicture") ) {
tex = new TLatex(0.033, (MAXY-(MAXY*0.055)), ThisConfig.Data() );
tex->SetLineWidth(2);
tex->Draw();
}
}
leg->Draw();
double y_min = 1.60;
double y_max = MAXY;
TLine *line = new TLine(x_Q13_SetI, y_min,x_Q13_SetI, y_max);
//line->Draw();
line = new TLine(x_Q13_SetII, y_min,x_Q13_SetII, y_max);
//line->Draw();
c1->cd();
std::stringstream saveAs;
saveAs.str("");
saveAs << path << model << "/pdf/" << "RvsSin2Q13_" << model << "_" << target << "_" << config << ".pdf";
c1->SaveAs( saveAs.str().c_str() );
saveAs.str("");
saveAs << path << model << "/png/" << "RvsSin2Q13_" << model << "_" << target << "_" << config << ".png";
c1->SaveAs( saveAs.str().c_str() );
saveAs.str("");
saveAs << path << model << "/eps/" << "RvsSin2Q13_" << model<< "_" << target << "_" << config << ".eps";
c1->SaveAs( saveAs.str().c_str() );
}
// -------------------------
// -- Functions --
// -------------------------
void makeDeadEcalEff() {
gStyle->SetOptStat(0);
TCanvas *c1 = new TCanvas("c1","A Simple Graph with error bars",200,10,700,500);
const Int_t nbins = 6;
TString lifetime = "0.5";
// TString lifetime = "1";
// TString lifetime = "5";
Float_t masses [nbins] = {103, 164, 246, 328, 408, 488};
Float_t effOld0p5ns [nbins] = {0.884, 0.958, 0.889, 0.895, 0.897, 0.909};
Float_t effDPG0p5ns [nbins] = {0.877, 0.958, 0.894, 0.884, 0.901, 0.888}; // Federico's DPG map
Float_t effOld1ns [nbins] = {0.896, 0.93, 0.912, 0.944, 0.918, 0.914};
Float_t effDPG1ns [nbins] = {0.899, 0.92, 0.912, 0.926, 0.90, 0.901}; // Federico's DPG map
Float_t effOld5ns [nbins] = {0.921, 0.938, 0.942, 0.92, 0.936, 0.942};
Float_t effDPG5ns [nbins] = {0.909, 0.913, 0.934, 0.911, 0.93, 0.936}; // Federico's DPG map
Float_t* effOld;
Float_t* effDPG;
if (lifetime=="0p5") {
effOld = effOld0p5ns;
effDPG = effDPG0p5ns;
}
if (lifetime=="1") {
effOld = effOld1ns;
effDPG = effDPG1ns;
}
if (lifetime=="5") {
effOld = effOld5ns;
effDPG = effDPG5ns;
}
for (int i=0; i<nbins; i++) {
effOld[i] = 1.0 - effOld[i];
effDPG[i] = 1.0 - effDPG[i];
}
TGraph *grEffOld = new TGraph(nbins, masses, effOld);
TGraph *grEffDPG = new TGraph(nbins, masses, effDPG);
grEffOld->SetMarkerStyle(21); // 21: square
grEffOld->SetMarkerSize(0.8);
grEffOld->SetMarkerColor(kBlue);
grEffOld->SetLineWidth(2);
grEffOld->SetMinimum(0);
grEffOld->SetMaximum(0.25);
// grEffOld->SetTitle(";chargino mass;efficiency of dead ECAL veto");
grEffOld->SetTitle(";chargino mass;1 - #epsilon");
grEffOld->Draw("AP");
// grEffOld->Draw("P");
grEffDPG->SetMarkerStyle(26); // 26: hollow triangle
grEffDPG->SetMarkerSize(0.8);
grEffDPG->SetMarkerColor(kRed);
grEffDPG->SetLineWidth(2);
grEffDPG->Draw("P, same");
TLine l;
l.SetLineColor(kRed);
l.DrawLine(2.5,1.0,6.5,1.0);
TLegend leg2(0.50,0.6,0.85,0.8);
leg2.AddEntry(grEffOld, "old map (" + lifetime + " ns)", "pl");
leg2.AddEntry(grEffDPG, "ECAL DPG map (" + lifetime + " ns)", "pl");
leg2.SetBorderSize(0);
leg2.SetFillStyle(1001);
leg2.SetFillColor(kWhite);
leg2.SetBorderSize(0);
leg2.SetTextFont(gStyle->GetTitleFont());
leg2.Draw();
TPaveText* pt = new TPaveText(0.50, 0.82, 0.90, 0.88, "NDC");
pt->SetFillStyle(0);
pt->SetBorderSize(0);
pt->SetTextFont(gStyle->GetTitleFont());
pt->AddText("CMS Preliminary, #sqrt{s} = 8 TeV");
// pt->Draw();
c1->SetLogy(0);
c1->Print("deadEcalEff" + lifetime + "ns.pdf");
c1->Clear();
return;
}
void makePlots( const char * model, const char * src, const char * infile , const char * option )
{
//Output path
TString path("./paper01-plots/probs/");
TString dataPee = TString( model ) + TString("_") + TString( src ) + TString("_Pee/data");
TString dataPem = TString( model ) + TString("_") + TString( src ) + TString("_Pem/data");
TString dataPet = TString( model ) + TString("_") + TString( src ) + TString("_Pet/data");
TString dataAPee = TString( model ) + TString("_") + TString( src ) + TString("_aPee/data");
TString dataAPem = TString( model ) + TString("_") + TString( src ) + TString("_aPem/data");
TString dataAPet = TString( model ) + TString("_") + TString( src ) + TString("_aPet/data");
TList * v_Labels = new TList();
TObjString *label;
label = new TObjString( "Pee" );
v_Labels->Add( label );
label = new TObjString( "Pe#mu" );
v_Labels->Add( label );
label = new TObjString( "Pe#tau" );
v_Labels->Add( label );
TFile * f1 = new TFile(infile);
f1->cd();
TTree * PeeTreeNu = (TTree*)gDirectory->Get( dataPee.Data() );
TTree * PemTreeNu = (TTree*)gDirectory->Get( dataPem.Data() );
TTree * PetTreeNu = (TTree*)gDirectory->Get( dataPet.Data() );
TTree * PeeTreeANu = (TTree*)gDirectory->Get( dataAPee.Data() );
TTree * PemTreeANu = (TTree*)gDirectory->Get( dataAPem.Data() );
TTree * PetTreeANu = (TTree*)gDirectory->Get( dataAPet.Data() );
//Branches
double xx = 0.0;
double yy = 0.0;
TCanvas * c1 = new TCanvas(model, "Oscillation probabilities", 184, 60, 861, 670);
c1->Divide(1,3);
TGraph * ProbNu[3];
ProbNu[0] = new TGraph();
ProbNu[1] = new TGraph();
ProbNu[2] = new TGraph();
TGraph * ProbANu[3];
ProbANu[0] = new TGraph();
ProbANu[1] = new TGraph();
ProbANu[2] = new TGraph();
TGraph * Psum = new TGraph();
TGraph * aPsum = new TGraph();
TLegend * leg = new TLegend(0.14,0.69,0.24,0.85);
PeeTreeNu->SetBranchAddress("Ex",&xx);
PeeTreeNu->SetBranchAddress("Pb",&yy);
Long64_t nentries = PeeTreeNu->GetEntries();
for (Long64_t i=0;i<nentries;i++) {
PeeTreeNu->GetEntry(i);
ProbNu[0]->SetPoint( i, xx, yy);
}
PeeTreeANu->SetBranchAddress("Ex",&xx);
PeeTreeANu->SetBranchAddress("Pb",&yy);
nentries = PeeTreeANu->GetEntries();
for (Long64_t i=0;i<nentries;i++) {
PeeTreeANu->GetEntry(i);
ProbANu[0]->SetPoint( i, xx, yy);
}
///Pem
PemTreeNu->SetBranchAddress("Ex",&xx);
PemTreeNu->SetBranchAddress("Pb",&yy);
nentries = PemTreeNu->GetEntries();
for (Long64_t i=0;i<nentries;i++) {
PemTreeNu->GetEntry(i);
ProbNu[1]->SetPoint( i, xx, yy);
}
PemTreeANu->SetBranchAddress("Ex",&xx);
PemTreeANu->SetBranchAddress("Pb",&yy);
nentries = PemTreeANu->GetEntries();
for (Long64_t i=0;i<nentries;i++) {
PemTreeANu->GetEntry(i);
ProbANu[1]->SetPoint( i, xx, yy);
}
///Pet
PetTreeNu->SetBranchAddress("Ex",&xx);
PetTreeNu->SetBranchAddress("Pb",&yy);
nentries = PetTreeNu->GetEntries();
for (Long64_t i=0;i<nentries;i++) {
PetTreeNu->GetEntry(i);
ProbNu[2]->SetPoint( i, xx, yy);
}
PetTreeANu->SetBranchAddress("Ex",&xx);
PetTreeANu->SetBranchAddress("Pb",&yy);
nentries = PetTreeANu->GetEntries();
for (Long64_t i=0;i<nentries;i++) {
PetTreeANu->GetEntry(i);
ProbANu[2]->SetPoint( i, xx, yy);
}
for( int k=0; k < 3; ++k)
{
ProbNu[k]->SetLineColor(4);
ProbNu[k]->SetMarkerColor(4);
ProbNu[k]->SetMarkerStyle(7);
ProbNu[k]->SetFillColor(10);
ProbNu[k]->SetMaximum(1.0);
ProbNu[k]->SetMinimum(0.0);
TString yaxis = ((TObjString*)v_Labels->At(k))->GetString();
ProbNu[k]->GetYaxis()->SetTitle( yaxis.Data() );
ProbNu[k]->GetXaxis()->SetTitle("E [eV]");
ProbNu[k]->GetYaxis()->CenterTitle(true);
ProbNu[k]->GetXaxis()->CenterTitle(true);
ProbNu[k]->GetXaxis()->SetLabelOffset(0.007);
ProbNu[k]->GetXaxis()->SetLabelSize(0.08);
ProbNu[k]->GetXaxis()->SetTitleSize(0.07);
ProbNu[k]->GetXaxis()->SetTitleOffset(0.9);
ProbNu[k]->GetXaxis()->SetLabelFont(42);
ProbNu[k]->GetYaxis()->SetLabelOffset(0.007);
ProbNu[k]->GetYaxis()->SetLabelSize(0.08);
ProbNu[k]->GetYaxis()->SetLabelFont(42);
ProbNu[k]->GetYaxis()->SetTitleSize(0.09);
ProbNu[k]->GetYaxis()->SetTitleOffset(0.45);
ProbNu[k]->GetYaxis()->SetTitleFont(42);
ProbANu[k]->SetMarkerColor(42);
ProbANu[k]->SetMarkerStyle(23);
ProbANu[k]->SetMarkerSize(0.3);
ProbANu[k]->SetFillColor(10);
ProbANu[k]->SetMaximum(1.0);
ProbANu[k]->SetMinimum(0.0);
}
leg->AddEntry( ProbNu[0], "#nu");
leg->AddEntry( ProbANu[0], "#bar{#nu}");
leg->SetBorderSize(0);
leg->SetTextSize(0.1);
leg->SetLineColor(1);
leg->SetLineStyle(1);
leg->SetLineWidth(1);
leg->SetFillColor(0);
leg->SetFillStyle(1001);
c1->cd(1);
gPad->SetGridx();
gPad->SetGridy();
gPad->SetLogx();
if ( std::string(model).compare("EarthB") == 0 )
ProbNu[0]->GetXaxis()->SetLimits(0.98e9, 1.0e10);
ProbNu[0]->Draw("APL");
ProbANu[0]->Draw("PL");
topTitle(model);
leg->DrawClone();
c1->cd(2);
gPad->SetGridx();
gPad->SetGridy();
gPad->SetLogx();
if ( std::string(model).compare("EarthB") == 0 )
ProbNu[1]->GetXaxis()->SetLimits(0.98e9, 1.0e10);
ProbNu[1]->Draw("APL");
ProbANu[1]->Draw("PL");
leg->DrawClone();
c1->cd(3);
gPad->SetGridx();
gPad->SetGridy();
gPad->SetLogx();
if ( std::string(model).compare("EarthB") == 0 )
ProbNu[2]->GetXaxis()->SetLimits(0.98e9, 1.0e10);
ProbNu[2]->Draw("APL");
ProbANu[2]->Draw("PL");
leg->DrawClone();
c1->cd();
std::stringstream saveAs;
saveAs.str("");
saveAs << path << model << "/pdf/" << "nueosc_probs_" << model << "_" << option << ".pdf";
c1->SaveAs( saveAs.str().c_str() );
saveAs.str("");
saveAs << path << model << "/png/" << "nueosc_probs_" << model << "_" << option << ".png";
c1->SaveAs( saveAs.str().c_str() );
saveAs.str("");
saveAs << path << model << "/eps/" << "nueosc_probs_" << model << "_" << option << ".eps";
c1->SaveAs( saveAs.str().c_str() );
TH1D * h_Psum = new TH1D("Psum.Histo","",100, 0.99999, 1.0001);
TH1D * h_aPsum = h_Psum->Clone("aPsum.Histo");
for (Long64_t i=0;i<nentries;i++) {
double xx = 0.0;
double yy = 0.0;
double p1 = 0.0;
double p2 = 0.0;
double p3 = 0.0;
ProbNu[0]->GetPoint(i, xx, p1);
ProbNu[1]->GetPoint(i, xx, p2);
ProbNu[2]->GetPoint(i, xx, p3);
yy = p1 + p2 + p3;
if ( xx < 1.0e14 )
{
Psum->SetPoint( i, xx, yy);
h_Psum->Fill( yy );
}
else
break;
}
for (Long64_t i=0;i<nentries;i++) {
double xx = 0.0;
double yy = 0.0;
double p1 = 0.0;
double p2 = 0.0;
double p3 = 0.0;
ProbANu[0]->GetPoint(i, xx, p1);
ProbANu[1]->GetPoint(i, xx, p2);
ProbANu[2]->GetPoint(i, xx, p3);
yy = p1 + p2 + p3;
if ( xx < 1.0e14 )
{
aPsum->SetPoint( i, xx, yy);
h_aPsum->Fill( yy );
}
else
break;
}
TCanvas * c2 = new TCanvas("Sums", "Oscillation probabilities - SUMS", 184,112,394,472);
c2->Divide(2,2);
c2->cd(1);
gPad->SetLogx();
Psum->SetMaximum(1.1);
Psum->SetMinimum(0.0);
Psum->SetMarkerStyle(21);
Psum->SetMarkerSize(0.2);
if ( std::string(model).compare("EarthB") == 0 )
Psum->GetXaxis()->SetLimits(0.98e9, 1.0e10);
Psum->Draw("APL");
TLatex * tex = new TLatex(1.823945e+11,0.8753448,"Nu");
tex->SetLineWidth(2);
tex->Draw();
c2->Modified();
c2->cd();
//Now the histogram
c2->cd(2);
// h_Psum->GetXaxis()->SetRange(6,14);
h_Psum->GetXaxis()->SetNdivisions(501);
h_Psum->GetXaxis()->SetLabelFont(42);
h_Psum->GetXaxis()->SetLabelOffset(0.007);
h_Psum->GetXaxis()->SetLabelSize(0.05);
h_Psum->GetXaxis()->SetTitleSize(0.06);
h_Psum->GetXaxis()->SetTitleOffset(0.9);
h_Psum->GetXaxis()->SetTitleFont(42);
h_Psum->Draw("");
h_Psum->Draw();
/////
c2->cd(3);
gPad->SetLogx();
aPsum->SetMaximum(1.1);
aPsum->SetMinimum(0.0);
aPsum->SetMarkerStyle(21);
aPsum->SetMarkerSize(0.2);
aPsum->SetMarkerColor(2);
aPsum->GetXaxis()->SetTitle("E [eV]");
aPsum->GetXaxis()->CenterTitle(true);
aPsum->GetXaxis()->SetLabelFont(42);
aPsum->GetXaxis()->SetLabelOffset(0.007);
aPsum->GetXaxis()->SetLabelSize(0.05);
aPsum->GetXaxis()->SetTitleSize(0.06);
aPsum->GetXaxis()->SetTitleOffset(1.06);
if ( std::string(model).compare("EarthB") == 0 )
aPsum->GetXaxis()->SetLimits(0.98e9, 1.0e10);
aPsum->Draw("APL");
tex = new TLatex(1.56236e+11,0.8214771,"anti-Nu");
tex->SetLineWidth(2);
tex->Draw();
//Now the histogram
c2->cd(4);
h_aPsum->Draw();
/////
c2->Modified();
c2->cd();
saveAs.str("");
saveAs << path << model << "/png/" << "nueosc_sum_of_probs_" << model << "_" << option << ".png";
c2->SaveAs( saveAs.str().c_str() );
}
TGraph* newShiftChi2Graph(const T* const dat1,
const Int_t nd1,
const U* const dat2,
const Int_t nd2,
const Int_t minbin=-1, // -1 => 0
const Int_t maxbin=-1, // -1 => nd1-1
const Bool_t useSqrtErrs=kFALSE) {
const Int_t minb = (minbin<0) ? 0 : minbin;
const Int_t maxb = (maxbin<0) ? nd1-1 : maxbin;
if ( (maxb<=minb) || (maxb>=nd1) || (maxb>=nd2) ) {
Fatal("newShiftChi2Graph",
"Invalid maxb=%d. (minb=%d, nd1=%d, nd2=%d)",
maxb, minb, nd1, nd2);
}
const T* c1 = dat1;
const U* c2 = dat2;
Int_t pos, j(0);
const Int_t ndh = (maxb-minb+1)/2;
TGraphErrors* gc = new TGraphErrors;
for (Int_t sh=1-ndh; sh<ndh; ++sh) {
Double_t x=0, t=0, cmp=0;
c1 = dat1+minb;
c2 = dat2+minb-sh;
for (Int_t i=minb; i<=maxb; ++i, ++c1, ++c2) {
pos = c2 - dat2;
#ifdef SHIFT_INTO_WINDOW
if (pos<nd2) {
if (pos>=0) {
#else
if (pos<=maxb) {
if (pos>=minb) {
#endif
t = (*c1) - (*c2);
t *= t;
if (useSqrtErrs) {
t /= TMath::Abs(static_cast<Double_t>(*c2));
}
x += t;
cmp += 1.0;
}
} else {
break;
}
}
if (cmp>1.0) {
x /= cmp-1.0;
gc->SetPoint(j, static_cast<Double_t>(sh), x);
++j;
}
}
return gc;
}
void noAveBounceStdy(const Char_t* rtfn,
const Char_t* wvfn,
const Char_t* FPNfn,
const Char_t* outfn,
const Int_t fitType=0,
const Int_t fitOpt=0,
const Char_t* minner="Minuit2",
const Char_t* algo="Migrad",
const Int_t shiftminb=-1,
const Int_t shiftmaxb=-1,
const Bool_t applyFilter=kTRUE) {
// fitType:
// 0 = fit theta phi with getShiftLL
// 5 = fit theta phi with getShiftChi2
// 20 = fit 3 deltaT's; use contraints for other 3
//
// fitOpt:
// 0 = fit (filtered) waveforms
// 10 = fit envelope of (filtered) waveforms
//
// minner algo
// Minuit /Minuit2 Migrad,Simplex,Combined,Scan (default is Migrad)
// Minuit2 Fumili2
// Fumili
// GSLMultiMin ConjugateFR, ConjugatePR, BFGS,
// BFGS2, SteepestDescent
// GSLMultiFit
// GSLSimAn
// Genetic
if (mini==0) {
mini = ROOT::Math::Factory::CreateMinimizer(minner, algo);
mini->SetMaxFunctionCalls(1000000);
mini->SetMaxIterations(10000);
mini->SetTolerance(0.001);
mini->SetPrintLevel(0);
}
nt = new TChain("runtree");
nt->Add(rtfn);
const Long64_t nents = nt->GetEntries();
if (nents==0) {
Error("noAveBunceStdy","No events in tree from [%s].",rtfn);
return;
}
ns = new TChain("nShifts");
ns->Add(wvfn);
if (nents>ns->GetEntries()) {
Error("bounceStudy","%lld entries in runtree but "
"%lld entries in shift tree",nents,ns->GetEntries());
return;
}
fpnf = TFile::Open(FPNfn);
if ( (fpnf==0) || (fpnf->IsZombie()) ) {
Error("bounceStudy","Could not open FPN file [%s]",FPNfn);
return;
}
for (Int_t ch=0; ch<NSnConstants::kNchans; ++ch) {
gPed[ch] = dynamic_cast<TGraphErrors*>(
fpnf->Get(Form("gExlPed_ch%d",ch)));
gNoise[ch] = dynamic_cast<TGraphErrors*>(
fpnf->Get(Form("gExlRms_ch%d",ch)));
if ( (gPed[ch]==0) || (gNoise[ch]==0) ) {
Error("bounceStudy",
"Couldn't get FPN/noise graphs from [%s]",FPNfn);
return;
}
}
// read from tree into...
Float_t pedsubs[NSnConstants::kNchans][NSnConstants::kNsamps];
Float_t psshift[NSnConstants::kNchans][NSnConstants::kNsamps];
Float_t filtered[NSnConstants::kNchans][NSnConstants::kNsamps];
Float_t envelope[NSnConstants::kNchans][NSnConstants::kNsamps];
UShort_t samples[NSnConstants::kNchans][NSnConstants::kNsamps];
UInt_t evnum, utime, utimeus, mbchksum;
nt->SetBranchAddress("mbChecksum",&mbchksum);
nt->SetBranchAddress("EvtNum",&evnum);
nt->SetBranchAddress("unixTime",&utime);
nt->SetBranchAddress("unixTimeUS",&utimeus);
for (Int_t ch=0; ch<NSnConstants::kNchans; ++ch) {
nt->SetBranchAddress(Form("data%02d",ch), &(samples[ch][0]));
}
// shift for stop tree
Int_t nsent;
UInt_t nsevn;
Int_t aveShift(0), aveLen(0);
Int_t shift[NSnConstants::kNchans];
Int_t len[NSnConstants::kNchans];
ns->SetBranchAddress("Ent",&nsent);
ns->SetBranchAddress("EvtNum",&nsevn);
for (Int_t ch=0; ch<NSnConstants::kNchans; ++ch) {
ns->SetBranchAddress(Form("shift%02d",ch),&(shift[ch]));
ns->SetBranchAddress(Form("len%02d",ch),&(len[ch]));
}
ns->BuildIndex("EvtNum");
// output
TString hn;
outf = TFile::Open(outfn,"recreate");
if (fitType==20) {
hn = "EvtNum:";
for (Int_t i=1; i<NSnConstants::kNchans; ++i) {
hn += Form("dt%d%d:",i,i-1);
}
hn += "chi2";
tChanDTsFit = new TNtuple("tChanDTsFit",
"fit of channel dts",
hn.Data());
} else {
tThetaPhiFit = new TNtuple("tThetaPhiFit","theta phi fit tree",
"EvtNum:theta:phi:chi2");
}
for (Int_t ch=0; ch<NSnConstants::kNchans; ++ch) {
for (Int_t xc=0; xc<ch; ++xc) {
hn = Form("hFiltCorrCoefShiftVsEvt_ch%02d_ch%02d",ch,xc);
hFiltCorrCoefShiftVsEvt[ch][xc] = new TH2F(hn.Data(),
Form("corr coef for offset between ch%d and ch%d of filtered "
"wvfms vs event;event;offset (ch%d-ch%d);correlation coef",
ch,xc,ch,xc),
nents, -0.5, nents-0.5,
NSnConstants::kNsamps,
1-(NSnConstants::kNsamps/2)-0.5,
(NSnConstants::kNsamps/2)+0.5);
hFiltCorrCoefShiftVsEvt[ch][xc]->SetDirectory(outf);
hn = Form("hFiltShiftChi2VsEvt_ch%02d_ch%02d",ch,xc);
hFiltShiftChi2VsEvt[ch][xc] = new TH2F(hn.Data(),
Form("#chi^{2} of offset between ch%d and ch%d of filtered "
"wvfms vs event;event;offset (ch%d-ch%d);#chi^{2}",
ch,xc,ch,xc),
nents, -0.5, nents-0.5,
NSnConstants::kNsamps,
1-(NSnConstants::kNsamps/2)-0.5,
(NSnConstants::kNsamps/2)+0.5);
hFiltShiftChi2VsEvt[ch][xc]->SetDirectory(outf);
}
}
Long64_t ne(0);
for (Long64_t ev=0; ev<nents; ++ev) {
//for (Long64_t ev=0; ev<250; ++ev) {
if ( (ev%500)==0 ) {
fprintf(stderr,"Processing %lld / %lld (%02.2f%%) \r",
ev, nents,
100.*static_cast<Float_t>(ev)/static_cast<Float_t>(nents));
}
nt->GetEntry(ev);
ne = ns->GetEntryNumberWithIndex(evnum);
if (ne>-1) {
ns->GetEntry(ne);
// find the stop shift
aveShift = aveLen = 0;
for (Int_t ch=0; ch<NSnConstants::kNchans; ++ch) {
aveShift += shift[ch];
aveLen += len[ch];
}
aveShift = TMath::Nint( static_cast<Float_t>(aveShift)/
static_cast<Float_t>(NSnConstants::kNchans) );
aveLen = TMath::Nint( static_cast<Float_t>(aveLen)/
static_cast<Float_t>(NSnConstants::kNchans) );
const Int_t shiftStart = NSnConstants::kNsamps-1 - aveShift - aveLen;
for (Int_t ch=0; ch<NSnConstants::kNchans; ++ch) {
// subtract FPN
const Double_t* pd = gPed[ch]->GetY();
const UShort_t* sp = &(samples[ch][0]);
Float_t* ps = &(pedsubs[ch][0]);
Float_t* ph = &(psshift[ch][ shiftStart ]);
for (Int_t sm=0; sm<NSnConstants::kNsamps;
++sm, ++pd, ++sp, ++ps, ++ph) {
*ps = *sp - *pd;
while ( (ph-&(psshift[ch][0])) >= NSnConstants::kNsamps) {
ph -= NSnConstants::kNsamps;
}
*ph = *ps;
}
// apply filter
memcpy(&(filtered[ch][0]), &(psshift[ch][0]),
NSnConstants::kNsamps*sizeof(Float_t));
if (applyFilter) {
filterWaveform(&(filtered[ch][0]), NSnConstants::kNsamps);
}
// find envelope
memcpy(&(envelope[ch][0]), &(filtered[ch][0]),
NSnConstants::kNsamps*sizeof(Float_t));
TSnSpectral::EnvelopeReal(&(envelope[ch][0]), NSnConstants::kNsamps);
#ifdef DEBUG_SHIFTS
TCanvas* cdbgsh = new TCanvas;
cdbgsh->cd();
Float_t xsm[NSnConstants::kNsamps], rsmp[NSnConstants::kNsamps];
for (Int_t i=0; i<NSnConstants::kNsamps; ++i) {
xsm[i] = i;
rsmp[i] = samples[ch][i];
}
TGraph* gsmp = new TGraph(NSnConstants::kNsamps, xsm, rsmp);
TGraph* gps = new TGraph(NSnConstants::kNsamps, xsm,
&(pedsubs[ch][0]));
TGraph* gph = new TGraph(NSnConstants::kNsamps, xsm,
&(psshift[ch][0]));
TGraph* gfl = new TGraph(NSnConstants::kNsamps, xsm,
&(filtered[ch][0]));
TGraph* gen = new TGraph(NSnConstants::kNsamps, xsm,
&(envelope[ch][0]));
gsmp->SetMarkerStyle(7);
gsmp->SetMarkerColor(kBlack);
gsmp->SetLineColor(kBlack);
gps->SetMarkerStyle(7);
gps->SetMarkerColor(kRed);
gps->SetLineColor(kRed);
gph->SetMarkerStyle(7);
gph->SetMarkerColor(kAzure-7);
gph->SetLineColor(kAzure-7);
gfl->SetMarkerStyle(7);
gfl->SetMarkerColor(kGreen+2);
gfl->SetLineColor(kGreen+2);
gen->SetMarkerStyle(7);
gen->SetMarkerColor(kViolet-1);
gen->SetLineColor(kViolet-1);
gsmp->SetMinimum(-1500);
gsmp->SetMaximum(2500);
Printf("ch%d: shift=%d, len=%d",
ch, shift[ch], len[ch]);
gsmp->Draw("apc");
gps->Draw("pc");
gph->Draw("pc");
gfl->Draw("pc");
gen->Draw("pc");
cdbgsh->WaitPrimitive();
delete gsmp; delete gps; delete gph; delete gfl; delete gen;
delete cdbgsh;
#endif
}
if (shiftmaxb!=shiftminb) {
maxdt = (shiftmaxb - shiftminb) / (2.0*kSmpRate);
} else {
maxdt = NSnConstants::kNsamps / (2.0*kSmpRate);
}
const Float_t* chdat(0), * xcdat(0);
for (Int_t ch=0; ch<NSnConstants::kNchans; ++ch) {
if (fitOpt==0) {
chdat = &(filtered[ch][0]);
} else if (fitOpt==10) {
chdat = &(envelope[ch][0]);
} else {
Fatal("noAveBounceStdy","Unknown fitOpt [%d]",fitOpt);
}
for (Int_t xc=0; xc<ch; ++xc) {
if (fitOpt==0) {
xcdat = &(filtered[xc][0]);
} else if (fitOpt==10) {
xcdat = &(envelope[xc][0]);
} else {
Fatal("noAveBounceStdy","Unknown fitOpt [%d]",fitOpt);
}
gcor[ch][xc] = newCorrCoefGraph(chdat,
xcdat,
NSnConstants::kNsamps,
shiftminb,
shiftmaxb);
gspl[ch][xc] = new TSpline3(Form("spl_%d_%d",ch,xc),
gcor[ch][xc]);
gchi[ch][xc] = newShiftChi2Graph(chdat,
NSnConstants::kNsamps,
xcdat,
NSnConstants::kNsamps,
shiftminb,
shiftmaxb);
gspc[ch][xc] = new TSpline3(Form("spc_%d_%d",ch,xc),
gchi[ch][xc]);
#ifdef DEBUG_CORRELS
TCanvas* cdbgcl = new TCanvas("cdbgcl","cdbgcl",800,1000);
cdbgcl->Divide(1,3);
cdbgcl->cd(1);
Float_t xxsm[NSnConstants::kNsamps];
for (Int_t i=0; i<NSnConstants::kNsamps; ++i) {
xxsm[i] = i;
}
TGraph* gcfl = new TGraph(NSnConstants::kNsamps, xxsm,
&(filtered[ch][0]));
TGraph* gxfl = new TGraph(NSnConstants::kNsamps, xxsm,
&(filtered[xc][0]));
TGraph* gcen = new TGraph(NSnConstants::kNsamps, xxsm,
&(envelope[ch][0]));
TGraph* gxen = new TGraph(NSnConstants::kNsamps, xxsm,
&(envelope[xc][0]));
gcfl->SetMarkerStyle(7);
gcfl->SetMarkerColor(kBlack);
gcfl->SetLineColor(kBlack);
gxfl->SetMarkerStyle(7);
gxfl->SetMarkerColor(kRed);
gxfl->SetLineColor(kRed);
gcen->SetMarkerStyle(7);
gcen->SetMarkerColor(kGray);
gcen->SetLineColor(kGray);
gxen->SetMarkerStyle(7);
gxen->SetMarkerColor(kViolet-1);
gxen->SetLineColor(kViolet-1);
gcfl->Draw("apc");
gxfl->Draw("pc");
gcen->Draw("pc");
gxen->Draw("pc");
cdbgcl->cd(2);
gspl[ch][xc]->SetMarkerStyle(7);
gspl[ch][xc]->SetMarkerColor(kAzure-7);
gspl[ch][xc]->SetLineColor(kAzure-7);
gspl[ch][xc]->Draw("pc");
cdbgcl->cd(3);
gspc[ch][xc]->SetMarkerStyle(7);
gspc[ch][xc]->SetMarkerColor(kViolet-6);
gspc[ch][xc]->SetLineColor(kViolet-6);
gspc[ch][xc]->Draw("pc");
cdbgcl->cd();
cdbgcl->Update();
cdbgcl->WaitPrimitive();
delete gcfl; delete gxfl; delete cdbgcl;
delete gcen; delete gxen;
#endif
const Int_t gn = gcor[ch][xc]->GetN();
const Double_t* gx = gcor[ch][xc]->GetX(),
* gy = gcor[ch][xc]->GetY(),
* cx = gchi[ch][xc]->GetX(),
* cy = gchi[ch][xc]->GetY();
for (Int_t k=0; k<gn; ++k, ++gx, ++gy, ++cx, ++cy) {
hFiltCorrCoefShiftVsEvt[ch][xc]->Fill(ev, *gx, *gy);
hFiltShiftChi2VsEvt[ch][xc]->Fill(ev, *cx, *cy);
}
}
}
if (fitType==20) {
// fit for the best, consistent time offsets
mini->Clear();
ROOT::Math::Functor f(&getDeltaTsLL, NSnConstants::kNchans-1);
mini->SetFunction(f);
for (Int_t ch=1; ch<NSnConstants::kNchans; ++ch) {
if (strcmp(minner,"Genetic")==0) {
mini->SetLimitedVariable(ch-1,
Form("dt%d%d",ch,ch-1), 0, 0.01,
-maxdt, maxdt);
} else {
mini->SetVariable(ch-1, Form("dt%d%d",ch,ch-1), 0, 0.01);
}
}
mini->Minimize();
const Double_t* result = mini->X();
const Double_t* rs = result;
Float_t* tofil = new Float_t[NSnConstants::kNchans+2];
Float_t* tf = tofil;
*tf++ = ev;
for (Int_t ch=1; ch<NSnConstants::kNchans; ++ch, ++tf, ++rs) {
*tf = *rs;
}
*tf = mini->MinValue();
tChanDTsFit->Fill(tofil);
delete[] tofil;
#ifdef DEBUG_DTS
for (Int_t ch=1; ch<NSnConstants::kNchans; ++ch) {
Printf("result[%d]=%g",ch-1,result[ch-1]);
}
TCanvas* cdbgdt = new TCanvas("cdbgdt","cdbgdt",1000,1000);
cdbgdt->Divide(2,3);
Float_t xxsm[NSnConstants::kNsamps];
for (Int_t i=0; i<NSnConstants::kNsamps; ++i) {
xxsm[i] = i;
}
TGraph* gorg[NSnConstants::kNchans];
TGraph* gocp[NSnConstants::kNchans];
TGraph* goen[NSnConstants::kNchans];
TGraph* gshf[NSnConstants::kNchans][NSnConstants::kNchans];
TGraph* gshe[NSnConstants::kNchans][NSnConstants::kNchans];
for (Int_t ch=0; ch<NSnConstants::kNchans; ++ch) {
gorg[ch] = new TGraph(NSnConstants::kNsamps, xxsm,
&(filtered[ch][0]));
gocp[ch] = new TGraph(NSnConstants::kNsamps, xxsm,
&(filtered[ch][0]));
goen[ch] = new TGraph(NSnConstants::kNsamps, xxsm,
&(envelope[ch][0]));
for (Int_t xc=0; xc<ch; ++xc) {
Double_t dt=0;
for (Int_t i=(ch-xc); i>0; --i) {
dt += result[ch-i];
}
dt *= kSmpRate; // convert to samples
Printf("dt[%d][%d]=%g",ch,xc,dt);
gshf[ch][xc] = new TGraph(NSnConstants::kNsamps);
gshe[ch][xc] = new TGraph(NSnConstants::kNsamps);
for (Int_t i=0; i<NSnConstants::kNsamps; ++i) {
gshf[ch][xc]->SetPoint(i, xxsm[i]+dt, filtered[xc][i]);
gshe[ch][xc]->SetPoint(i, xxsm[i]+dt, envelope[xc][i]);
}
gshf[ch][xc]->SetMarkerStyle(7);
gshf[ch][xc]->SetLineColor(kRed);
gshf[ch][xc]->SetMarkerColor(kRed);
gshe[ch][xc]->SetMarkerStyle(7);
gshe[ch][xc]->SetLineColor(kViolet-1);
gshe[ch][xc]->SetMarkerColor(kViolet-1);
}
gorg[ch]->SetMarkerStyle(7);
gorg[ch]->SetLineColor(kBlack);
gorg[ch]->SetMarkerColor(kBlack);
goen[ch]->SetMarkerStyle(7);
goen[ch]->SetLineColor(kGray);
goen[ch]->SetMarkerColor(kGray);
gocp[ch]->SetMarkerStyle(7);
gocp[ch]->SetLineStyle(7);
gocp[ch]->SetLineColor(kGreen+2);
gocp[ch]->SetMarkerColor(kGreen+2);
}
gStyle->SetOptStat(0);
Int_t pp=0;
for (Int_t ch=0; ch<NSnConstants::kNchans; ++ch) {
for (Int_t xc=0; xc<ch; ++xc) {
cdbgdt->cd(++pp);
hn = Form("hd_%d_%d",ch,xc);
TH2F* hd = new TH2F(hn.Data(),
Form("black=ch%d, red/green=ch%d;"
"sample;ADC",ch,xc),
NSnConstants::kNsamps, -0.5,
NSnConstants::kNsamps-0.5,
200, -900, 900);
hd->SetBit(TH1::kCanDelete);
hd->Draw();
gorg[ch]->Draw("pc");
goen[ch]->Draw("pc");
gocp[xc]->Draw("pc");
gshf[ch][xc]->Draw("pc");
gshe[ch][xc]->Draw("pc");
}
}
cdbgdt->cd();
cdbgdt->Update();
cdbgdt->WaitPrimitive();
for (Int_t ch=0; ch<NSnConstants::kNchans; ++ch) {
delete gorg[ch]; delete gocp[ch]; delete goen[ch];
for (Int_t xc=0; xc<ch; ++xc) {
delete gshf[ch][xc];
delete gshe[ch][xc];
}
}
delete cdbgdt;
#endif
} else {
Int_t npars(2);
Double_t (*fitFunction)(const Double_t*) = 0;
if (fitType==0) {
fitFunction = &getShiftLL;
} else if (fitType==5) {
fitFunction = &getShiftChi2;
} else {
Fatal("bounceStudy","Unknown fit type %d",fitType);
}
mini->Clear();
ROOT::Math::Functor f(fitFunction, npars);
mini->SetFunction(f);
if (strcmp(minner,"Genetic")==0) {
mini->SetLimitedVariable(0, "theta", 3, 0.01,
0, TMath::Pi());
mini->SetLimitedVariable(1, "phi" , 5.5, 0.01,
0, TMath::TwoPi());
} else {
//mini->SetVariable(0, "theta", TMath::Pi(), 0.01);
//mini->SetVariable(1, "phi" , (gRandom->Rndm()-0.5), 0.01);
mini->SetVariable(0, "theta", 3, 0.01);
mini->SetVariable(1, "phi" , 5.5, 0.01);
//mini->SetVariable(0, "theta", 3, 0.05);
//mini->SetVariable(1, "phi" , 5.5, 0.05);
}
mini->Minimize();
const Double_t* result = mini->X();
tThetaPhiFit->Fill(ev, result[0], result[1], mini->MinValue());
#ifdef DEBUG_THETAPHI
// regularize the angles
Double_t theta = TVector2::Phi_mpi_pi(result[0]);
Double_t phi = result[1];
if (theta<0) {
theta *= -1.0;
phi += TMath::Pi();
}
phi = TVector2::Phi_0_2pi(phi);
Printf("theta=%g, phi=%g (%g, %g)",
theta*TMath::RadToDeg(),
phi*TMath::RadToDeg(),
result[0], result[1]);
TCanvas* cdbgtp = new TCanvas("cdbgtp","cdbgtp",1000,1000);
cdbgtp->Divide(2,3);
Float_t xxsm[NSnConstants::kNsamps];
for (Int_t i=0; i<NSnConstants::kNsamps; ++i) {
xxsm[i] = i;
}
TGraph* gorg[NSnConstants::kNchans];
TGraph* gocp[NSnConstants::kNchans];
TGraph* gshf[NSnConstants::kNchans][NSnConstants::kNchans];
for (Int_t ch=0; ch<NSnConstants::kNchans; ++ch) {
gorg[ch] = new TGraph(NSnConstants::kNsamps, xxsm,
&(filtered[ch][0]));
gocp[ch] = new TGraph(NSnConstants::kNsamps, xxsm,
&(filtered[ch][0]));
for (Int_t xc=0; xc<ch; ++xc) {
Double_t dtcor=0;
for (Int_t i=(ch-xc); i>0; --i) {
dtcor += dtCorrs[ch-i];
}
const TVector3& posCh = getStnPos(ch);
const TVector3& posXc = getStnPos(xc);
TVector3 norm;
norm.SetMagThetaPhi(1.0, result[0], result[1]);
//norm.SetMagThetaPhi(1.0, 2.95833, 5.497787);
const Double_t disCh = -(posCh.Dot(norm));
const Double_t disXc = -(posXc.Dot(norm));
// !!! check sign of delta(distance) and dtcor!
const Double_t dt = kSmpRate * (
( (disCh-disXc) * kNgTopFern / kC_m_ns ) // from m to ns
+ dtcor );
Printf("dt[%d,%d]=%g (dis[%d]=%g, dis[%d]=%g)",
ch,xc,dt, ch,disCh,xc,disXc);
gshf[ch][xc] = new TGraph(NSnConstants::kNsamps);
for (Int_t i=0; i<NSnConstants::kNsamps; ++i) {
gshf[ch][xc]->SetPoint(i, xxsm[i]+dt, filtered[xc][i]);
}
gshf[ch][xc]->SetMarkerStyle(7);
gshf[ch][xc]->SetLineColor(kRed);
gshf[ch][xc]->SetMarkerColor(kRed);
}
gorg[ch]->SetMarkerStyle(7);
gorg[ch]->SetLineColor(kBlack);
gorg[ch]->SetMarkerColor(kBlack);
gocp[ch]->SetMarkerStyle(7);
gocp[ch]->SetLineStyle(7);
gocp[ch]->SetLineColor(kGreen+2);
gocp[ch]->SetMarkerColor(kGreen+2);
}
gStyle->SetOptStat(0);
Int_t pp=0;
for (Int_t ch=0; ch<NSnConstants::kNchans; ++ch) {
for (Int_t xc=0; xc<ch; ++xc) {
cdbgtp->cd(++pp);
hn = Form("hd_%d_%d",ch,xc);
TH2F* hd = new TH2F(hn.Data(),
Form("black=ch%d, red/green=ch%d;"
"sample;ADC",ch,xc),
NSnConstants::kNsamps, -0.5,
NSnConstants::kNsamps-0.5,
200, -900, 900);
hd->SetBit(TH1::kCanDelete);
hd->Draw();
gorg[ch]->Draw("pc");
gocp[xc]->Draw("pc");
gshf[ch][xc]->Draw("pc");
}
}
cdbgtp->cd();
cdbgtp->Update();
cdbgtp->WaitPrimitive();
for (Int_t ch=0; ch<NSnConstants::kNchans; ++ch) {
delete gorg[ch]; delete gocp[ch];
for (Int_t xc=0; xc<ch; ++xc) {
delete gshf[ch][xc];
}
}
delete cdbgtp;
#endif
}
for (Int_t ch=0; ch<NSnConstants::kNchans; ++ch) {
for (Int_t xc=0; xc<ch; ++xc) {
delete gspl[ch][xc];
delete gcor[ch][xc];
delete gchi[ch][xc];
delete gspc[ch][xc];
}
}
}
} // event loop
outf->Write();
}
TCanvas* plotLinearityMAT_ERUpgrade(double eta, double etmin /* GeV */, double etmax /* GeV */, int ptype,
string year, string esmodel,
bool debug=false, bool logx=false, bool subtractAverage=false,
TGraph* overlay=0 ) {
double GeV = 1000;
gROOT->ProcessLine(".L EnergyRescalerUpgrade.cxx");
egRescaler::EnergyRescalerUpgrade ers;
ers.Init("../share/EnergyRescalerData.root",year,esmodel);
ers.SetDebugFlag( debug );
ers.includePresamplerContribution( false );
ers.includeLeakageContribution( false );
double eMin = etmin * cosh(eta) * GeV;
double eMax = etmax * cosh(eta) * GeV;
int nStep = 100;
double eStep;
if( logx )
eStep = (log(eMax)-log(eMin))/(double)nStep;
else
eStep = (eMax-eMin)/(double)nStep;
double e = eMin;
TGraphErrors* gZee = new TGraphErrors(); // Z scale
TGraph* gNom = new TGraph(); // nominal scale correction
TGraph* gZeeAllUp = new TGraph(); // Zee scale uncertainty, Up
TGraph* gZeeAllDown = new TGraph(); // , Down
TGraph* gZeeUp = new TGraph(); // Zee scale uncertainty, Up
TGraph* gZeeDown = new TGraph(); // , Down
TGraph* gZeeGenUp = new TGraph(); // Zee scale uncertainty, Up
TGraph* gZeeGenDown = new TGraph(); // , Down
TGraph* gMATUp = new TGraph(); // MAT uncertainty, Up
TGraph* gMATDown = new TGraph(); // , Down
TGraph* gPSUp = new TGraph(); // ps uncertainty, Up
TGraph* gPSDown = new TGraph(); // , Down
TGraph* gLowUp = new TGraph(); // low-pt uncertainty, Up
TGraph* gLowDown = new TGraph(); // , Down
int i=0;
while( e<=eMax ) {
double alpha = ers.getAlphaZee(eta, egRescaler::EnergyRescalerUpgrade::Nominal);
double alphaUp = ers.getAlphaZee(eta, egRescaler::EnergyRescalerUpgrade::ZeeStatUp);
double eNominal = ers.applyEnergyCorrection(eta, e, ptype, egRescaler::EnergyRescalerUpgrade::Nominal);
double eVarZeeAllUp = ers.applyEnergyCorrection(eta, e, ptype, egRescaler::EnergyRescalerUpgrade::ZeeAllUp);
double eVarZeeAllDown = ers.applyEnergyCorrection(eta, e, ptype, egRescaler::EnergyRescalerUpgrade::ZeeAllDown);
double eVarZeeUp = ers.applyEnergyCorrection(eta, e, ptype, egRescaler::EnergyRescalerUpgrade::ZeeMethodUp);
double eVarZeeDown = ers.applyEnergyCorrection(eta, e, ptype, egRescaler::EnergyRescalerUpgrade::ZeeMethodDown);
double eVarGenUp = ers.applyEnergyCorrection(eta, e, ptype, egRescaler::EnergyRescalerUpgrade::ZeeGenUp);
double eVarGenDown = ers.applyEnergyCorrection(eta, e, ptype, egRescaler::EnergyRescalerUpgrade::ZeeGenDown);
double eVarMATUp = ers.applyEnergyCorrection(eta, e, ptype, egRescaler::EnergyRescalerUpgrade::R12StatUp);
double eVarMATDown = ers.applyEnergyCorrection(eta, e, ptype, egRescaler::EnergyRescalerUpgrade::R12StatDown);
double eVarPSUp = ers.applyEnergyCorrection(eta, e, ptype, egRescaler::EnergyRescalerUpgrade::PSStatUp);
double eVarPSDown = ers.applyEnergyCorrection(eta, e, ptype, egRescaler::EnergyRescalerUpgrade::PSStatDown);
double eVarLowUp = ers.applyEnergyCorrection(eta, e, ptype, egRescaler::EnergyRescalerUpgrade::LowPtUp);
double eVarLowDown = ers.applyEnergyCorrection(eta, e, ptype, egRescaler::EnergyRescalerUpgrade::LowPtDown);
if(i==0) {
gZee->SetPointError(i,0,alphaUp-alpha);
if( !subtractAverage )
gZee->SetPoint(i,40.*cosh(eta),alpha);
else
gZee->SetPoint(i,40.*cosh(eta),0);
}
if( !subtractAverage ) {
gNom->SetPoint(i, e/GeV, (e-eNominal)/eNominal);
gZeeAllUp->SetPoint(i, e/GeV, (e-eVarZeeAllUp)/eVarZeeAllUp);
gZeeAllDown->SetPoint(i, e/GeV, (e-eVarZeeAllDown)/eVarZeeAllDown);
gZeeUp->SetPoint(i, e/GeV, (e-eVarZeeUp)/eVarZeeUp);
gZeeDown->SetPoint(i, e/GeV, (e-eVarZeeDown)/eVarZeeDown);
gZeeGenUp->SetPoint(i, e/GeV, (e-eVarGenUp)/eVarGenUp);
gZeeGenDown->SetPoint(i, e/GeV, (e-eVarGenDown)/eVarGenDown);
gMATUp->SetPoint(i, e/GeV, (e-eVarMATUp)/eVarMATUp);
gMATDown->SetPoint(i, e/GeV, (e-eVarMATDown)/eVarMATDown);
gPSUp->SetPoint(i, e/GeV, (e-eVarPSUp)/eVarPSUp);
gPSDown->SetPoint(i, e/GeV, (e-eVarPSDown)/eVarPSDown);
gLowUp->SetPoint(i, e/GeV, (e-eVarLowUp)/eVarLowUp);
gLowDown->SetPoint(i, e/GeV, (e-eVarLowDown)/eVarLowDown);
} else {
gNom->SetPoint(i, e/GeV, (e-eNominal)/eNominal - alpha);
gZeeAllUp->SetPoint(i, e/GeV, (e-eVarZeeAllUp)/eVarZeeAllUp - alpha);
gZeeAllDown->SetPoint(i, e/GeV, (e-eVarZeeAllDown)/eVarZeeAllDown - alpha);
gZeeUp->SetPoint(i, e/GeV, (e-eVarZeeUp)/eVarZeeUp - alpha);
gZeeDown->SetPoint(i, e/GeV, (e-eVarZeeDown)/eVarZeeDown - alpha);
gZeeGenUp->SetPoint(i, e/GeV, (e-eVarGenUp)/eVarGenUp - alpha);
gZeeGenDown->SetPoint(i, e/GeV, (e-eVarGenDown)/eVarGenDown - alpha);
gMATUp->SetPoint(i, e/GeV, (e-eVarMATUp)/eVarMATUp - alpha);
gMATDown->SetPoint(i, e/GeV, (e-eVarMATDown)/eVarMATDown - alpha);
gPSUp->SetPoint(i, e/GeV, (e-eVarPSUp)/eVarPSUp - alpha);
gPSDown->SetPoint(i, e/GeV, (e-eVarPSDown)/eVarPSDown - alpha);
gLowUp->SetPoint(i, e/GeV, (e-eVarLowUp)/eVarLowUp - alpha);
gLowDown->SetPoint(i, e/GeV, (e-eVarLowDown)/eVarLowDown - alpha);
}
i++;
if( logx )
e *= exp(eStep);
else
e += eStep;
}
TCanvas* canvas = new TCanvas();
if( logx )
canvas->SetLogx();
if( !subtractAverage ) {
gMATUp->SetMaximum(alpha+.005);
gMATUp->SetMinimum(alpha+-.007);
} else {
gMATUp->SetMaximum(.005);
gMATUp->SetMinimum(-.007);
}
char grafname[99];
if( ptype==0 )
sprintf(grafname,"ES Linearity (%s), #eta = %4.2f, Electrons", year.c_str(), eta);
else if( ptype==1 )
sprintf(grafname,"ES Linearity (%s), #eta = %4.2f, Unconverted photons", year.c_str(), eta);
else if( ptype==2 )
sprintf(grafname,"ES Linearity (%s), #eta = %4.2f, Converted photons", year.c_str(), eta);
gMATUp->SetTitle(grafname);
gMATUp->GetXaxis()->SetTitleOffset(1.2*gNom->GetXaxis()->GetTitleOffset());
gMATUp->GetYaxis()->SetTitleOffset(1.2*gNom->GetYaxis()->GetTitleOffset());
gMATUp->GetXaxis()->SetTitle("E [GeV]");
gMATUp->GetYaxis()->SetTitle("#alpha(E)");
gMATUp->SetLineWidth(2);
gMATUp->SetLineStyle(2);
gMATUp->SetLineColor(4);
gMATUp->Draw("AL");
gMATDown->SetLineWidth(2);
gMATDown->SetLineStyle(3);
gMATDown->SetLineColor(4);
gMATDown->Draw("L");
gNom->SetLineWidth(2);
gNom->SetLineColor(4);
gNom->Draw("L");
gZee->SetMarkerStyle(20);
gZee->Draw("P");
TLegend* leg1 = new TLegend(.7,.15,.89,.3);
leg1->SetBorderSize(0);
leg1->SetFillColor(0);
leg1->AddEntry(gZee,"#alpha, Z peak", "p");
leg1->AddEntry(gNom,"PS, central", "l");
leg1->AddEntry(gMATUp,"PS, up", "l");
leg1->AddEntry(gMATDown,"PS, down", "l");
leg1->Draw("same");
// char plotname[99];
// sprintf(plotname,"linearity_%d_%2.1f.png",ptype,eta);
// canvas->Print("overlay.ps");
return canvas;
}
//------------------------------------------------------------------------
void DrawWalk()
{
Int_t npeaks = 20;
Int_t sigma=3.;
Bool_t down = false;
Int_t index[20];
Char_t buf1[10], buf2[10];
TCanvas *c1 = new TCanvas("c1", "c1",0,48,1280,951);
gStyle->SetOptStat(0);
c1->Divide(4,3);
for (Int_t i=0; i<12; i++)
{
c1->cd(i+1);
sprintf(buf1,"T0_C_%i_CFD",i+1);
sprintf(buf2,"CFDvsQTC%i",i+1);
cout<<buf1<<" "<<buf2<<endl;
TH2F *qtc_cfd = (TH2F*) gFile->Get(buf2);
TH1F *cfd = (TH1F*) gFile->Get(buf1);
// cfd->Draw();
TSpectrum *s = new TSpectrum(2*npeaks,1);
Int_t nfound = s->Search(cfd,sigma," ",0.05);
cout<<"Found "<<nfound<<" peaks sigma "<<sigma<<endl;;
if(nfound!=0){
Float_t *xpeak = s->GetPositionX();
TMath::Sort(nfound, xpeak, index,down);
Float_t xp = xpeak[index[0]];
Int_t xbin = cfd->GetXaxis()->FindBin(xp);
Float_t yp = cfd->GetBinContent(xbin);
cout<<"xbin = "<<xbin<<"\txpeak = "<<xpeak[1]<<"\typeak = "<<yp<<endl;
Float_t hmax = xp+10*sigma;
Float_t hmin = xp-10*sigma;
cout<<hmin<< " "<<hmax<<endl;
// cfd->GetXaxis()->SetRange(hmin,hmax);
// TF1 *g1 = new TF1("g1", "gaus", hmin, hmax);
// cfd->Fit("g1","R");
Int_t hminbin= qtc_cfd->GetXaxis()->GetFirst();
Int_t hmaxbin= qtc_cfd->GetXaxis()->GetLast();
Int_t nbins= qtc_cfd->GetXaxis()->GetNbins();
cout<<" qtc_cfd "<<hminbin<<" "<<hmaxbin<<" "<<nbins<<endl;
// qtc_cfd->Draw();
TProfile *pr_y = qtc_cfd->ProfileX();
Float_t maxHr=pr_y->GetBinCenter(hmaxbin);
pr_y->SetMaximum(hmax);
pr_y->SetMinimum(hmin);
Int_t np=nbins/20;
Double_t *xx = new Double_t[np];
Double_t *yy = new Double_t[np];
Int_t ng=0;
Double_t yg=0;
for (Int_t ip=1; ip<nbins; ip++)
{
if(ip%20 != 0 ) {
if (pr_y->GetBinContent(ip) !=0)
yg +=pr_y->GetBinContent(ip);
// cout<<ng<<" "<<pr_y->GetBinContent(ip)<<" "<<yg<<endl;
ng++;}
else {
xx[ip/20] = Float_t (pr_y->GetBinCenter(ip));
yy[ip/20] = yg/ng;
yg=0;
ng=0;
cout<<ip<<" "<<ip/20<<" "<< xx[ip/20]<<" "<< yy[ip/20]<<endl;
}
}
TH2F *hr = new TH2F("hr"," ",np,0,maxHr, np, hmin, hmax);
hr->Draw();
TGraph *gr = new TGraph(np,xx,yy);
gr->SetMinimum(hmin);
gr->SetMaximum(hmax);
gr->SetMarkerStyle(20);
gr->Draw("P");
// delete [] xx;
// delete [] yy;
// pr_y->Rebin(10);
// pr_y->Draw();
}
}
}
void EnergyDependentCorrections() {
gStyle->SetOptStat(0);
gStyle->SetTitleSize(0.08,"t");
gStyle->SetPadLeftMargin(0.15);
//gStyle->SetPadRightMargin(0.15);
gStyle->SetPadBottomMargin(0.15);
gStyle->SetTitleYSize(0.05);
gStyle->SetTitleYOffset(1.4);
gStyle->SetTitleXSize(0.05);
gStyle->SetTitleXOffset(1.2);
gStyle->SetTitleSize(0.04,"Z");
gStyle->SetTitleOffset(1.6,"Z");
gStyle->SetLabelSize(0.04,"xyz");
gStyle->SetLegendBorderSize(0);
gStyle->SetFillStyle(0);
// read in the corrections and plot their deltaA/A for each bin
// This can be done for both theory and MC
//Int_t octmin = year==2011?0:60;
//Int_t octmax = year==2011?59:121;
std::vector <Double_t> energy;
std::vector <Double_t> UnCorr2011;
std::vector <Double_t> TheoryCorr2011;
std::vector <Double_t> AllCorr2011;
std::vector <Double_t> UnCorr2012;
std::vector <Double_t> TheoryCorr2012;
std::vector <Double_t> AllCorr2012;
Double_t en, val, err;
std::ifstream infile(TString::Format("%s/Asymmetries/UnCorr_OctetAsymmetries_AnaChC_Octets_%i-%i_BinByBin.txt",getenv("ANALYSIS_RESULTS"),0,59));
while (infile >> en >> val >> err ) {
energy.push_back(en);
UnCorr2011.push_back(val);
}
infile.close();
infile.open(TString::Format("%s/Asymmetries/DeltaTheoryOnly_OctetAsymmetries_AnaChC_Octets_%i-%i_BinByBin.txt",getenv("ANALYSIS_RESULTS"),0,59));
while (infile >> en >> val >> err) {
TheoryCorr2011.push_back(val);
}
infile.close();
infile.open(TString::Format("%s/Asymmetries/AllCorr_OctetAsymmetries_AnaChC_Octets_%i-%i_BinByBin.txt",getenv("ANALYSIS_RESULTS"),0,59));
while (infile >> en >> val >> err) {
AllCorr2011.push_back(val);
}
infile.close();
infile.open(TString::Format("%s/Asymmetries/UnCorr_OctetAsymmetries_AnaChC_Octets_%i-%i_BinByBin.txt",getenv("ANALYSIS_RESULTS"),60,121));
while (infile >> en >> val >> err ) {
energy.push_back(en);
UnCorr2012.push_back(val);
}
infile.close();
infile.open(TString::Format("%s/Asymmetries/DeltaTheoryOnly_OctetAsymmetries_AnaChC_Octets_%i-%i_BinByBin.txt",getenv("ANALYSIS_RESULTS"),60,121));
while (infile >> en >> val >> err) {
TheoryCorr2012.push_back(val);
}
infile.close();
infile.open(TString::Format("%s/Asymmetries/AllCorr_OctetAsymmetries_AnaChC_Octets_%i-%i_BinByBin.txt",getenv("ANALYSIS_RESULTS"),60,121));
while (infile >> en >> val >> err) {
AllCorr2012.push_back(val);
}
infile.close();
std::vector <Double_t> en_Th;
std::vector <Double_t> corr_Th;
std::vector <Double_t> en_MC2011;
std::vector <Double_t> corr_MC2011;
std::vector <Double_t> en_MC2012;
std::vector <Double_t> corr_MC2012;
for (int i=2;i<80;++i) {
if (UnCorr2011[i]!=0.) en_Th.push_back(energy[i]), corr_Th.push_back(100.*(TheoryCorr2011[i]/UnCorr2011[i]-1.));
if (TheoryCorr2011[i]!=0.) en_MC2011.push_back(energy[i]), corr_MC2011.push_back(100.*(AllCorr2011[i]/TheoryCorr2011[i]-1.));
if (TheoryCorr2012[i]!=0.) en_MC2012.push_back(energy[i]), corr_MC2012.push_back(100.*(AllCorr2012[i]/TheoryCorr2012[i]-1.));
}
TCanvas *c2 = new TCanvas("c2","c2",1200,800);
c2->Divide(2,1);
c2->cd(1);
TGraph *gTheory = new TGraph(en_Th.size(),&en_Th[0],&corr_Th[0]);
gTheory->SetTitle("Theory Corrections vs. Energy");
gTheory->SetMarkerStyle(kFullCircle);
gTheory->SetMinimum(-5.);
gTheory->SetMaximum(0.);
gTheory->SetLineWidth(3);
gTheory->SetLineColor(kBlack);
gTheory->GetYaxis()->SetTitle("#DeltaA/A (%)");
gTheory->GetYaxis()->CenterTitle();
gTheory->GetXaxis()->SetTitle("Energy (keV)");
gTheory->GetXaxis()->CenterTitle();
gTheory->Draw("AL");
c2->cd(2);
TMultiGraph *mg = new TMultiGraph();
mg->SetTitle("MC Corrections vs. Energy");
TGraph *gMC2011 = new TGraph(en_MC2011.size(),&en_MC2011[0],&corr_MC2011[0]);
gMC2011->SetMarkerStyle(kFullCircle);
//gMC2011->SetMinimum(-10.);
//gMC2011->SetMaximum(6.);
gMC2011->SetLineWidth(3);
gMC2011->SetLineColor(kBlue);
gMC2011->GetYaxis()->SetTitle("#DeltaA/A (%)");
gMC2011->GetYaxis()->CenterTitle();
gMC2011->GetXaxis()->SetTitle("Energy (keV)");
gMC2011->GetXaxis()->CenterTitle();
//gMC2011->Draw("AC");
TGraph *gMC2012 = new TGraph(en_MC2012.size(),&en_MC2012[0],&corr_MC2012[0]);
gMC2012->SetMarkerStyle(kFullCircle);
//gMC2012->SetMinimum(-10.);
//gMC2012->SetMaximum(6.);
gMC2012->SetLineWidth(3);
gMC2012->SetLineColor(kGreen);
//gMC2012->GetYaxis()->SetTitle("#DeltaA/A (%)");
//gMC2012->GetYaxis()->CenterTitle();
//gMC2012->GetXaxis()->SetTitle("Energy (keV)");
//gMC2012->GetXaxis()->CenterTitle();
//gMC2012->Draw("AC");
mg->Add(gMC2011);
mg->Add(gMC2012);
mg->SetMinimum(-8.);
mg->SetMaximum(6.);
mg->Draw("AC");
mg->GetYaxis()->SetTitle("#DeltaA/A (%)");
mg->GetYaxis()->CenterTitle();
mg->GetXaxis()->SetTitle("Energy (keV)");
mg->GetXaxis()->CenterTitle();
gPad->Modified();
TLegend *leg = new TLegend(0.55,0.75,0.85,0.85);
leg->AddEntry(gMC2011,"2011-2012","l");
leg->AddEntry(gMC2012,"2012-2013","l");
leg->SetTextSize(0.05);
leg->Draw("SAME");
}
TCanvas* plotLinearityPS_AllTypes_ERUpgrade(double eta, double etmin /* GeV */, double etmax /* GeV */,
string year, string esmodel,
bool debug=false, bool logx=false, bool subtractAverage=false,
TGraph* overlay=0 ) {
double GeV = 1000;
gROOT->ProcessLine(".L EnergyRescalerUpgrade.cxx");
egRescaler::EnergyRescalerUpgrade ers;
ers.Init("../share/EnergyRescalerData.root",year,esmodel);
ers.SetDebugFlag( debug );
ers.includeMaterialContribution( false );
ers.includeLeakageContribution( false );
double eMin = etmin * cosh(eta) * GeV;
double eMax = etmax * cosh(eta) * GeV;
int nStep = 100;
double eStep;
if( logx )
eStep = (log(eMax)-log(eMin))/(double)nStep;
else
eStep = (eMax-eMin)/(double)nStep;
double e = eMin;
TGraphErrors* gZee = new TGraphErrors(); // Z scale
TGraph* gNom = new TGraph(); // nominal scale correction
TGraph* gPSUp = new TGraph(); // ps uncertainty, Up
TGraph* gPSDown = new TGraph(); // , Down
TGraph* gNom_UC = new TGraph();
TGraph* gPSUp_UC = new TGraph();
TGraph* gPSDown_UC = new TGraph();
TGraph* gNom_CV = new TGraph();
TGraph* gPSUp_CV = new TGraph();
TGraph* gPSDown_CV = new TGraph();
int i=0;
while( e<=eMax ) {
double eT = e/cosh(eta);
double alpha = ers.getAlphaZee(eta, egRescaler::EnergyRescalerUpgrade::Nominal);
double alphaUp = ers.getAlphaZee(eta, egRescaler::EnergyRescalerUpgrade::ZeeStatUp);
double eNominal = ers.applyEnergyCorrection(eta, e, 0, egRescaler::EnergyRescalerUpgrade::Nominal);
double eVarPSUp = ers.applyEnergyCorrection(eta, e, 0, egRescaler::EnergyRescalerUpgrade::B12Up);
double eVarPSDown = ers.applyEnergyCorrection(eta, e, 0, egRescaler::EnergyRescalerUpgrade::B12Down);
double eNominal_UC = ers.applyEnergyCorrection(eta, e, 1, egRescaler::EnergyRescalerUpgrade::Nominal);
double eVarPSUp_UC = ers.applyEnergyCorrection(eta, e, 1, egRescaler::EnergyRescalerUpgrade::B12Up);
double eVarPSDown_UC = ers.applyEnergyCorrection(eta, e, 1, egRescaler::EnergyRescalerUpgrade::B12Down);
double eNominal_CV = ers.applyEnergyCorrection(eta, e, 2, egRescaler::EnergyRescalerUpgrade::Nominal);
double eVarPSUp_CV = ers.applyEnergyCorrection(eta, e, 2, egRescaler::EnergyRescalerUpgrade::B12Up);
double eVarPSDown_CV = ers.applyEnergyCorrection(eta, e, 2, egRescaler::EnergyRescalerUpgrade::B12Down);
if(i==0) {
gZee->SetPointError(i,0,alphaUp-alpha);
if( !subtractAverage )
gZee->SetPoint(i,40.,alpha);
else
gZee->SetPoint(i,40.,0);
}
if( !subtractAverage ) {
gNom->SetPoint(i, eT/GeV, (e-eNominal)/eNominal);
gPSUp->SetPoint(i, eT/GeV, (e-eVarPSUp)/eVarPSUp);
gPSDown->SetPoint(i, eT/GeV, (e-eVarPSDown)/eVarPSDown);
gNom_UC->SetPoint(i, eT/GeV, (e-eNominal_UC)/eNominal_UC);
gPSUp_UC->SetPoint(i, eT/GeV, (e-eVarPSUp_UC)/eVarPSUp_UC);
gPSDown_UC->SetPoint(i, eT/GeV, (e-eVarPSDown_UC)/eVarPSDown_UC);
gNom_CV->SetPoint(i, eT/GeV, (e-eNominal_CV)/eNominal_CV);
gPSUp_CV->SetPoint(i, eT/GeV, (e-eVarPSUp_CV)/eVarPSUp_CV);
gPSDown_CV->SetPoint(i, eT/GeV, (e-eVarPSDown_CV)/eVarPSDown_CV);
} else {
gNom->SetPoint(i, eT/GeV, (e-eNominal)/eNominal - alpha);
gPSUp->SetPoint(i, eT/GeV, (e-eVarPSUp)/eVarPSUp - alpha);
gPSDown->SetPoint(i, eT/GeV, (e-eVarPSDown)/eVarPSDown - alpha);
gNom_UC->SetPoint(i, eT/GeV, (e-eNominal_UC)/eNominal_UC - alpha);
gPSUp_UC->SetPoint(i, eT/GeV, (e-eVarPSUp_UC)/eVarPSUp_UC - alpha);
gPSDown_UC->SetPoint(i, eT/GeV, (e-eVarPSDown_UC)/eVarPSDown_UC - alpha);
gNom_CV->SetPoint(i, eT/GeV, (e-eNominal_CV)/eNominal_CV - alpha);
gPSUp_CV->SetPoint(i, eT/GeV, (e-eVarPSUp_CV)/eVarPSUp_CV - alpha);
gPSDown_CV->SetPoint(i, eT/GeV, (e-eVarPSDown_CV)/eVarPSDown_CV - alpha);
}
i++;
if( logx )
e *= exp(eStep);
else
e += eStep;
}
TCanvas* canvas = new TCanvas();
if( logx )
canvas->SetLogx();
if( !subtractAverage ) {
gPSUp->SetMaximum(alpha+.005);
gPSUp->SetMinimum(alpha+-.007);
} else {
gPSUp->SetMaximum(.005);
gPSUp->SetMinimum(-.007);
}
char grafname[99];
sprintf(grafname,"Linearity (%s), PS contribution, #eta = %4.2f", year.c_str(), eta);
gPSUp->SetTitle(grafname);
// Electrons
gPSUp->GetXaxis()->SetTitleOffset(1.2*gNom->GetXaxis()->GetTitleOffset());
gPSUp->GetYaxis()->SetTitleOffset(1.2*gNom->GetYaxis()->GetTitleOffset());
gPSUp->GetXaxis()->SetTitle("E_{T} [GeV]");
gPSUp->GetYaxis()->SetTitle("#alpha(E_{T})");
gPSUp->SetLineWidth(2);
gPSUp->SetLineStyle(2);
gPSUp->SetLineColor(4);
gPSUp->Draw("AL");
gPSDown->SetLineWidth(2);
gPSDown->SetLineStyle(3);
gPSDown->SetLineColor(4);
gPSDown->Draw("L");
gNom->SetLineWidth(2);
gNom->SetLineColor(4);
gNom->Draw("L");
// Unconverted
gPSUp_UC->SetLineWidth(2);
gPSUp_UC->SetLineStyle(2);
gPSUp_UC->SetLineColor(2);
gPSUp_UC->Draw("L");
gPSDown_UC->SetLineWidth(2);
gPSDown_UC->SetLineStyle(3);
gPSDown_UC->SetLineColor(2);
gPSDown_UC->Draw("L");
gNom_UC->SetLineWidth(2);
gNom_UC->SetLineColor(2);
gNom_UC->Draw("L");
// Converted
gPSUp_CV->SetLineWidth(2);
gPSUp_CV->SetLineStyle(2);
gPSUp_CV->SetLineColor(8);
gPSUp_CV->Draw("L");
gPSDown_CV->SetLineWidth(2);
gPSDown_CV->SetLineStyle(3);
gPSDown_CV->SetLineColor(8);
gPSDown_CV->Draw("L");
gNom_CV->SetLineWidth(2);
gNom_CV->SetLineColor(8);
gNom_CV->Draw("L");
gZee->SetMarkerStyle(20);
gZee->Draw("P");
TLegend* leg1 = new TLegend(.65,.15,.9,.3);
leg1->SetBorderSize(0);
leg1->SetFillColor(0);
leg1->AddEntry(gZee,"#alpha, Z peak", "p");
leg1->AddEntry(gNom,"PS, e, nom.", "l");
leg1->AddEntry(gPSUp,"PS, e, up", "l");
leg1->AddEntry(gPSDown,"PS, e, down", "l");
leg1->Draw("same");
TLegend* leg2 = new TLegend(.4,.15,.65,.3);
leg2->SetBorderSize(0);
leg2->SetFillColor(0);
leg2->AddEntry(gZee," ", "");
leg2->AddEntry(gNom_UC,"PS, #gamma (unc.), nom.", "l");
leg2->AddEntry(gPSUp_UC,"PS, #gamma (unc.), up", "l");
leg2->AddEntry(gPSDown_UC,"PS, #gamma (unc.), down", "l");
leg2->Draw("same");
TLegend* leg3 = new TLegend(.15,.15,.4,.3);
leg3->SetBorderSize(0);
leg3->SetFillColor(0);
leg3->AddEntry(gZee," ", "");
leg3->AddEntry(gNom_CV,"PS, #gamma (cnv.), nom.", "l");
leg3->AddEntry(gPSUp_CV,"PS, #gamma (cnv.), up", "l");
leg3->AddEntry(gPSDown_CV,"PS, #gamma (cnv.), down", "l");
leg3->Draw("same");
// char plotname[99];
// sprintf(plotname,"linearity_%d_%2.1f.png",ptype,eta);
// canvas->Print("overlay.ps");
return canvas;
}
void SinglePionEfficiencyNewVSpT::Loop()
{
// In a ROOT session, you can do:
// Root > .L SinglePionEfficiencyNewVSpT.C
// Root > SinglePionEfficiencyNewVSpT t
// Root > t.GetEntry(12); // Fill t data members with entry number 12
// Root > t.Show(); // Show values of entry 12
// Root > t.Show(16); // Read and show values of entry 16
// Root > t.Loop(); // Loop on all entries
//
// This is the loop skeleton where:
// jentry is the global entry number in the chain
// ientry is the entry number in the current Tree
// Note that the argument to GetEntry must be:
// jentry for TChain::GetEntry
// ientry for TTree::GetEntry and TBranch::GetEntry
//
// To read only selected branches, Insert statements like:
// METHOD1:
// fChain->SetBranchStatus("*",0); // disable all branches
// fChain->SetBranchStatus("branchname",1); // activate branchname
// METHOD2: replace line
// fChain->GetEntry(jentry); //read all branches
//by b_branchname->GetEntry(ientry); //read only this branch
if (fChain == 0) return;
Long64_t nentries = fChain->GetEntriesFast();
Long64_t nbytes = 0, nb = 0;
// number of pt bins and intervals
const Int_t nptbins = 17;
const Int_t nptcuts = nptbins+1;
// const Double_t pt[nptcuts]={0.0, 1.0, 1.2, 1.4, 1.6, 1.8, 2.0, 2.5, 3.0, 4.0, 5.0, 10.0, 15.0, 20.0, 25.0, 30.0, 40., 50.0};
const Double_t pt[nptcuts]= {1.0, 1.2, 1.4, 1.6, 1.8, 2.0, 2.5, 3.0, 4.0, 5.0, 10.0, 15.0, 20.0, 25.0, 30.0, 40., 50.0, 60.0};
// 0 1 2 3 4 5 6 7 8 9
// energy ecal+hcal in different matrices
TProfile* hprEH11x5 = new TProfile("hprEH11x5","prEH11x5",nptbins, pt, -10., 10.);
TProfile* hprEH11x3 = new TProfile("hprEH11x3","prEH11x3",nptbins, pt, -10., 10.);
TProfile* hprEH7x5 = new TProfile("hprEH7x5","prEH7x5",nptbins, pt, -10., 10.);
TProfile* hprEH7x3 = new TProfile("hprEH7x3","prEH7x3",nptbins, pt, -10., 10.);
// energy in hcal matrix
TProfile* hprH5 = new TProfile("hprH5","prH5",nptbins, pt, -10., 10.);
TProfile* hprH3 = new TProfile("hprH3","prH3",nptbins, pt, -10., 10.);
//
TH1F * hH5_1_2GeV = new TH1F( "hH5_1_2GeV", "H5_1_2GeV", 40, -2., 2.);
TH1F * hH3_1_2GeV = new TH1F( "hH3_1_2GeV", "H3_1_2GeV", 40, -2., 2.);
TH1F * hH5_3_4GeV = new TH1F( "hH5_3_4GeV", "H5_3_4GeV", 40, -2., 2.);
TH1F * hH3_3_4GeV = new TH1F( "hH3_3_4GeV", "H3_3_4GeV", 40, -2., 2.);
TH1F * hH5_5_10GeV = new TH1F( "hH5_5_10GeV", "H5_5_10GeV", 40, -2., 2.);
TH1F * hH3_5_10GeV = new TH1F( "hH3_5_10GeV", "H3_5_10GeV", 40, -2., 2.);
//
TH1F * hE11_1_2GeV = new TH1F( "hE11_1_2GeV", "E11_1_2GeV", 100, -2., 2.);
TH1F * hE11_3_4GeV = new TH1F( "hE11_3_4GeV", "E11_3_4GeV", 100, -2., 2.);
TH1F * hE11_5_10GeV = new TH1F( "hE11_5_10GeV", "E11_5_10GeV", 100, -2., 2.);
//
TH1F * hE11H5_1_2GeV = new TH1F( "hE11H5_1_2GeV", "E11H5_1_2GeV", 40, -2., 2.);
TH1F * hE11H5_3_4GeV = new TH1F( "hE11H5_3_4GeV", "E11H5_3_4GeV", 40, -2., 2.);
TH1F * hE11H5_5_10GeV = new TH1F( "hE11H5_5_10GeV", "E11H5_5_10GeV", 40, -2., 2.);
// TH1F * hEH11x5 = new TH1F( "hEH11x5", "EH11x5", 200, -2., 2.);
// TH2F * hresp2 = new TH2F( "hresp2", "resp2", 200, -2., 2.,200, -2., 2.);
// prepare for graph
Float_t ptgr[nptbins], eptgr[nptbins];
for(Int_t i = 0; i < nptbins; i++) {
ptgr[i] = 0.5*(pt[i]+pt[i+1]);
eptgr[i] = 0.5*(pt[i+1]-pt[i]);
cout <<" i = " << i <<" pT = " << ptgr[i] <<" err pT = " << eptgr[i] << endl;
}
// number of eta bins and intervals
const Int_t netabins = 12;
const Int_t netacuts = netabins+1;
Float_t eta[netacuts]= {0.01, 0.2, 0.4, 0.6, 0.8, 1.0, 1.2, 1.4, 1.6, 1.8, 2.0, 2.2, 2.4};
cout <<" Eta bins " << endl;
// prepare eta points for graph
Float_t etagr[netabins], eetagr[netabins];
for(Int_t i = 0; i < netabins; i++) {
etagr[i] = 0.5*(eta[i]+eta[i+1]);
eetagr[i] = 0.5*(eta[i+1]-eta[i]);
cout <<" i = " << i <<" Eta = " << etagr[i] <<" err Eta = " << eetagr[i] << endl;
}
// ===> for pi- and pi+
// N total and N reco tracks
// efficiency and error as a function of pT
Int_t ntrk[nptbins] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
Int_t ntrkreco[nptbins] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
Int_t ntrkrecor[nptbins] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
Float_t trkeff[nptbins], etrkeff[nptbins];
Double_t responceVSpt[nptbins] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
Double_t responceVSptF[nptbins];
Double_t eresponceVSpt[nptbins] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
// N total and N reco tracks
// efficiency and error as a function of eta
Int_t ntrketa[netabins] = {0,0,0,0,0,0,0,0,0,0,0,0};
Int_t ntrketareco[netabins] = {0,0,0,0,0,0,0,0,0,0,0,0};
Int_t ntrketarecor[netabins] = {0,0,0,0,0,0,0,0,0,0,0,0};
Float_t trketaeff[netabins], etrketaeff[netabins];
Double_t responceVSeta[nptbins] = {0,0,0,0,0,0,0,0,0,0,0,0};
Double_t responceVSetaF[nptbins];
Double_t eresponceVSeta[nptbins] = {0,0,0,0,0,0,0,0,0,0,0,0};
//
Int_t Ntot = 0;
for (Long64_t jentry=0; jentry<nentries; jentry++) {
Long64_t ientry = LoadTree(jentry);
if (ientry < 0) break;
nb = fChain->GetEntry(jentry);
nbytes += nb;
Ntot = Ntot + 1;
// if (Cut(ientry) < 0) continue;
// evaluate as a function of pT
for(Int_t i = 0; i < nptbins; i++) {
// ==> pi+
if(ptSim1 >= pt[i] && ptSim1 < pt[i+1]) {
ntrk[i] = ntrk[i]+1;
// number of reco tracks
if(drTrk1 < 0.01 && purityTrk1 == 1) {
ntrkreco[i] = ntrkreco[i]+1;
Double_t theta = 2.*atan(exp(-etaSim1));
Double_t eSim1 = ptSim1/sin(theta);
if(e1ECAL11x11 > -1000. && e1HCAL5x5 > -1000. && fabs(etaSim1) < 1.0) {
// if(e1ECAL11x11 > -1000. && e1HCAL5x5 > -1000. && fabs(etaSim1) < 1000) {
ntrkrecor[i] = ntrkrecor[i]+1;
Double_t e_ecal11 = e1ECAL11x11/eSim1;
Double_t e_ecal7 = e1ECAL7x7/eSim1;
Double_t e_hcal5 = e1HCAL5x5/eSim1;
Double_t e_hcal3 = e1HCAL3x3/eSim1;
Double_t e_ecalhcal11x5 = e_ecal11 + e_hcal5;
Double_t e_ecalhcal11x3 = e_ecal11 + e_hcal3;
Double_t e_ecalhcal7x5 = e_ecal7 + e_hcal5;
Double_t e_ecalhcal7x3 = e_ecal7 + e_hcal3;
responceVSpt[i] = responceVSpt[i] + e_ecalhcal11x5;
hprEH11x5->Fill(ptSim1,e_ecalhcal11x5,1.);
hprEH11x3->Fill(ptSim1,e_ecalhcal11x3,1.);
hprEH7x5->Fill(ptSim1,e_ecalhcal7x5,1.);
hprEH7x3->Fill(ptSim1,e_ecalhcal7x3,1.);
hprH5->Fill(ptSim1,e_hcal5,1.);
hprH3->Fill(ptSim1,e_hcal3,1.);
// if(i == nptbins-1) {
if(i < 5) {
hH5_1_2GeV->Fill(e_hcal5,1.);
hH3_1_2GeV->Fill(e_hcal3,1.);
hE11_1_2GeV->Fill(e_ecal11,1.);
hE11H5_1_2GeV->Fill(e_ecalhcal11x5,1.);
}
if(i == 7) {
hH5_3_4GeV->Fill(e_hcal5,1.);
hH3_3_4GeV->Fill(e_hcal3,1.);
hE11_3_4GeV->Fill(e_ecal11,1.);
hE11H5_3_4GeV->Fill(e_ecalhcal11x5,1.);
}
if(i == 9) {
hH5_5_10GeV->Fill(e_hcal5,1.);
hH3_5_10GeV->Fill(e_hcal3,1.);
hE11_5_10GeV->Fill(e_ecal11,1.);
hE11H5_5_10GeV->Fill(e_ecalhcal11x5,1.);
}
}
}
}
// ==> pi-
if(ptSim2 >= pt[i] && ptSim2 < pt[i+1]) {
ntrk[i] = ntrk[i]+1;
// number of reco tracks
if(drTrk2 < 0.01 && purityTrk2 == 1) {
ntrkreco[i] = ntrkreco[i]+1;
Double_t theta = 2.*atan(exp(-etaSim2));
Double_t eSim2 = ptSim2/sin(theta);
if(e2ECAL11x11 > -1000. && e2HCAL5x5 > -1000. && fabs(etaSim2) < 1.0) {
// if(e2ECAL11x11 > -1000. && e2HCAL5x5 > -1000. && fabs(etaSim2) < 1000.) {
ntrkrecor[i] = ntrkrecor[i]+1;
Double_t e_ecal11 = e2ECAL11x11/eSim2;
Double_t e_ecal7 = e2ECAL7x7/eSim2;
Double_t e_hcal5 = e2HCAL5x5/eSim2;
Double_t e_hcal3 = e2HCAL3x3/eSim2;
Double_t e_ecalhcal11x5 = e_ecal11 + e_hcal5;
Double_t e_ecalhcal11x3 = e_ecal11 + e_hcal3;
Double_t e_ecalhcal7x5 = e_ecal7 + e_hcal5;
Double_t e_ecalhcal7x3 = e_ecal7 + e_hcal3;
responceVSpt[i] = responceVSpt[i] + e_ecalhcal11x5;
hprEH11x5->Fill(ptSim2,e_ecalhcal11x5,1.);
hprEH11x3->Fill(ptSim2,e_ecalhcal11x3,1.);
hprEH7x5->Fill(ptSim2,e_ecalhcal7x5,1.);
hprEH7x3->Fill(ptSim2,e_ecalhcal7x3,1.);
hprH5->Fill(ptSim2,e_hcal5,1.);
hprH3->Fill(ptSim2,e_hcal3,1.);
// if(i == nptbins-1) {
if(i < 5) {
hH5_1_2GeV->Fill(e_hcal5,1.);
hH3_1_2GeV->Fill(e_hcal3,1.);
hE11_1_2GeV->Fill(e_ecal11,1.);
hE11H5_1_2GeV->Fill(e_ecalhcal11x5,1.);
}
if(i == 7) {
hH5_3_4GeV->Fill(e_hcal5,1.);
hH3_3_4GeV->Fill(e_hcal3,1.);
hE11_3_4GeV->Fill(e_ecal11,1.);
hE11H5_3_4GeV->Fill(e_ecalhcal11x5,1.);
}
if(i == 9) {
hH5_5_10GeV->Fill(e_hcal5,1.);
hH3_5_10GeV->Fill(e_hcal3,1.);
hE11_5_10GeV->Fill(e_ecal11,1.);
hE11H5_5_10GeV->Fill(e_ecalhcal11x5,1.);
}
}
}
}
}
// Nick
// evaluate efficiency as a function on eta
for(Int_t i = 0; i < netabins; i++) {
// ==> pi+
if(fabs(etaSim1) >= eta[i] && fabs(etaSim1) < eta[i+1]) {
// number of sim tracks in pt interval
ntrketa[i] = ntrketa[i]+1;
// number of reco tracks
if(drTrk1 < 0.04 && purityTrk1 >= 0.7) {
Double_t theta = 2.*atan(exp(-etaSim1));
Double_t eSim1 = ptSim1/sin(theta);
ntrketareco[i] = ntrketareco[i]+1;
if(e1ECAL11x11 > -1000. && e1HCAL5x5 > -1000.) {
ntrketarecor[i] = ntrketarecor[i]+1;
responceVSeta[i] = responceVSeta[i] + (e1ECAL7x7 + e1HCAL3x3)/eSim1;
}
}
}
// ==> pi-
if(fabs(etaSim2) >= eta[i] && fabs(etaSim2) < eta[i+1]) {
// number of sim tracks in pt interval
ntrketa[i] = ntrketa[i]+1;
// number of reco tracks
if(drTrk2 < 0.04 && purityTrk2 >= 0.7) {
ntrketareco[i] = ntrketareco[i]+1;
Double_t theta = 2.*atan(exp(-etaSim2));
Double_t eSim2 = ptSim2/sin(theta);
if(e2ECAL11x11 > -1000. && e2HCAL5x5 > -1000.) {
ntrketarecor[i] = ntrketarecor[i]+1;
responceVSeta[i] = responceVSeta[i] + (e2ECAL7x7 + e2HCAL3x3)/eSim2;
}
}
}
}
}
// calculate efficiency and full graph
for(Int_t i = 0; i < nptbins; i++) {
if(ntrk[i] > 0) {
trkeff[i] = 1.*ntrkreco[i]/ntrk[i];
etrkeff[i] = sqrt( trkeff[i]*(1.-trkeff[i])/ntrk[i] );
// responceVSptF[i] = responceVSpt[i]/ntrkrecor[i];
cout <<" i = " << i
<<" pt interval = " << pt[i] <<" - " << pt[i+1]
<<" ntrkreco[i] = " << ntrkreco[i]
<<" ntrkrecor[i] = " << ntrkrecor[i]
<<" ntrk[i] = " << ntrk[i]
<<" eff = " << trkeff[i] << endl;
// <<" responce = " << responceVSptF[i] << endl;
}
}
// calculate efficiency vs Eta and full graph
cout <<" Efficiency vs Eta " << endl;
for(Int_t i = 0; i < netabins; i++) {
if(ntrketa[i] > 0) {
trketaeff[i] = 1.*ntrketareco[i]/ntrketa[i];
etrketaeff[i] = sqrt( trketaeff[i]*(1.-trketaeff[i])/ntrketa[i] );
responceVSetaF[i] = responceVSeta[i]/ntrketarecor[i];
cout <<" i = " << i
<<" eta interval = " << eta[i] <<" - " << eta[i+1]
<<" ntrketareco[i] = " << ntrketareco[i]
<<" ntrketa[i] = " << ntrketa[i]
<<" eff = " << trketaeff[i]
<<" responce = " << responceVSetaF[i] << endl;
}
}
// create graph
// vs pT
setTDRStyle(1,0);
TCanvas* c1 = new TCanvas("X","Y",1);
TGraph *grpt = new TGraphErrors(nptbins,ptgr,trkeff,eptgr,etrkeff);
TAxis* xaxis = grpt->GetXaxis();
grpt->GetXaxis()->SetTitle("p_{T}, GeV");
grpt->GetYaxis()->SetTitle("track finding efficiency");
xaxis->SetLimits(0.8,50.);
grpt->SetMarkerStyle(21);
grpt->SetMaximum(0.9);
grpt->SetMinimum(0.6);
grpt->Draw("AP");
TLatex *t = new TLatex();
t->SetTextSize(0.042);
// TLegend *leg = new TLegend(0.5,0.2,0.7,0.35,NULL,"brNDC");
// leg->SetFillColor(10);
// leg->AddEntry(grpt,"#pi ^{+} and #pi ^{-}","P");
// leg->Draw();
t->DrawLatex(1.,0.85,"CMSSW169, single #pi ^{+} and #pi ^{-}. |#eta ^{#pi}|< 2.5");
c1->SaveAs("trkeff_vs_pt.gif");
c1->SaveAs("trkeff_vs_pt.eps");
setTDRStyle(0,0);
// vs Eta
TCanvas* c2 = new TCanvas("X","Y",1);
TGraph *greta = new TGraphErrors(netabins,etagr,trketaeff,eetagr,etrketaeff);
TAxis* xaxis = greta->GetXaxis();
greta->GetXaxis()->SetTitle("#eta");
greta->GetYaxis()->SetTitle("track finding efficiency");
xaxis->SetLimits(0.0,2.4);
greta->SetMarkerStyle(21);
greta->SetMaximum(1.0);
greta->SetMinimum(0.50);
greta->Draw("AP");
TLatex *t = new TLatex();
t->SetTextSize(0.042);
// TLegend *leg = new TLegend(0.5,0.2,0.7,0.35,NULL,"brNDC");
// leg->SetFillColor(10);
// leg->AddEntry(greta,"#pi ^{+} and #pi ^{-}","P");
// leg->Draw();
t->DrawLatex(0.3,0.87,"CMSSW217, single #pi ^{+} and #pi ^{-}");
t->DrawLatex(0.8,0.85,"1 < p^{#pi^{#pm}} < 50 GeV");
c2->SaveAs("trkeff_vs_eta.gif");
c2->SaveAs("trkeff_vs_eta.eps");
cout <<" Ntot = " << Ntot << endl;
/*
setTDRStyle(1,0);
//
TCanvas* c3 = new TCanvas("X","Y",1);
TAxis* xaxis = hEH->GetXaxis();
hEH->GetXaxis()->SetTitle("p_{T} of #pi ^{+} and #pi ^{-}, GeV");
hEH->GetYaxis()->SetTitle("(ECAL11x11+HCAL5x5)/E^{true}");
// xaxis->SetLimits(1.2,50.);
hEH->SetMarkerStyle(21);
hEH->SetMaximum(0.9);
hEH->SetMinimum(0.2);
hEH->Draw();
c3->SaveAs("EmatrixtWithZSP11x11.5x5.gif");
setTDRStyle(1,0);
//
TCanvas* c4 = new TCanvas("X","Y",1);
TAxis* xaxis = hEmatrix->GetXaxis();
hHmatrix->GetXaxis()->SetTitle("p_{T} of #pi ^{+} and #pi ^{-}, GeV");
hHmatrix->GetYaxis()->SetTitle("HCAL3x3/E^{true}");
// xaxis->SetLimits(1.2,50.);
hHmatrix->SetMarkerStyle(21);
hHmatrix->SetMaximum(0.9);
hHmatrix->SetMinimum(-0.2);
hHmatrix->Draw();
c4->SaveAs("HmatrixWithNoZSP3x3.gif");
setTDRStyle(0,0);
TCanvas* c5 = new TCanvas("X","Y",1);
hresp2->Draw("hist");
setTDRStyle(0,0);
TCanvas* c6 = new TCanvas("X","Y",1);
hhcal->Draw("hist");
*/
TFile efile("sr_barrel.root","recreate");
hprEH11x5->Write();
hprEH11x3->Write();
hprEH7x5->Write();
hprEH7x3->Write();
hprH5->Write();
hprH3->Write();
hH5_1_2GeV->Write();
hH3_1_2GeV->Write();
hH5_3_4GeV->Write();
hH3_3_4GeV->Write();
hH5_5_10GeV->Write();
hH3_5_10GeV->Write();
hE11_1_2GeV->Write();
hE11_3_4GeV->Write();
hE11_5_10GeV->Write();
hE11H5_1_2GeV->Write();
hE11H5_3_4GeV->Write();
hE11H5_5_10GeV->Write();
efile.Close();
}
void SinglePionEfficiency::Loop()
{
// In a ROOT session, you can do:
// Root > .L SinglePionEfficiency.C
// Root > SinglePionEfficiency t
// Root > t.GetEntry(12); // Fill t data members with entry number 12
// Root > t.Show(); // Show values of entry 12
// Root > t.Show(16); // Read and show values of entry 16
// Root > t.Loop(); // Loop on all entries
//
// This is the loop skeleton where:
// jentry is the global entry number in the chain
// ientry is the entry number in the current Tree
// Note that the argument to GetEntry must be:
// jentry for TChain::GetEntry
// ientry for TTree::GetEntry and TBranch::GetEntry
//
// To read only selected branches, Insert statements like:
// METHOD1:
// fChain->SetBranchStatus("*",0); // disable all branches
// fChain->SetBranchStatus("branchname",1); // activate branchname
// METHOD2: replace line
// fChain->GetEntry(jentry); //read all branches
//by b_branchname->GetEntry(ientry); //read only this branch
if (fChain == 0) return;
Long64_t nentries = fChain->GetEntriesFast();
Long64_t nbytes = 0, nb = 0;
// number of pt bins and intervals
const Int_t nptbins = 12;
const Int_t nptcuts = nptbins+1;
// 0 1 2 3 4 5 6 7 8 9 10 11
Double_t pt[nptcuts]={0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 10.0, 15.0, 20.0, 25.0, 30.0, 40., 50.0};
// number of eta bins and intervals
const Int_t netabins = 12;
const Int_t netacuts = netabins+1;
// 0 1 2 3 4 5 6 7 8 9 10 11
Double_t eta[netacuts]={0.0, 0.2, 0.4, 0.6, 0.8, 1.0, 1.2, 1.4, 1.6, 1.8, 2.0, 2.2, 2.4};
cout <<" Eta bins " << endl;
// prepare eta points for graph
Float_t etagr[netabins], eetagr[netabins];
for(Int_t i = 0; i < netabins; i++) {
etagr[i] = 0.5*(eta[i]+eta[i+1]);
eetagr[i] = 0.5*(eta[i+1]-eta[i]);
cout <<" i = " << i <<" Eta = " << etagr[i] <<" err Eta = " << eetagr[i] << endl;
}
// prepare for graph
Float_t ptgr[nptbins], eptgr[nptbins];
for(Int_t i = 0; i < nptbins; i++) {
ptgr[i] = 0.5*(pt[i]+pt[i+1]);
eptgr[i] = 0.5*(pt[i+1]-pt[i]);
cout <<" i = " << i <<" pT = " << ptgr[i] <<" err pT = " << eptgr[i] << endl;
}
TH2D* hResp = new TH2D("hResp","Resp",nptbins, pt, netabins, eta);
// histos for energy losses
TH1F* hEnTrkNotInter[netabins];
const char* namesEnTrkNotInter[netabins] = {"hEnTrkNotInter1",
"hEnTrkNotInter2",
"hEnTrkNotInter3",
"hEnTrkNotInter4",
"hEnTrkNotInter5",
"hEnTrkNotInter6",
"hEnTrkNotInter7",
"hEnTrkNotInter8",
"hEnTrkNotInter9",
"hEnTrkNotInter10",
"hEnTrkNotInter11",
"hEnTrkNotInter12"};
const char* titleEnTrkNotInter[netabins] = {"EnTrkNotInter1",
"EnTrkNotInter2",
"EnTrkNotInter3",
"EnTrkNotInter4",
"EnTrkNotInter5",
"EnTrkNotInter6",
"EnTrkNotInter7",
"EnTrkNotInter8",
"EnTrkNotInter9",
"EnTrkNotInter10",
"EnTrkNotInter11",
"EnTrkNotInter12"};
TH1F* hEnTrkInter[netabins];
const char* namesEnTrkInter[netabins] = {"hEnTrkInter1",
"hEnTrkInter2",
"hEnTrkInter3",
"hEnTrkInter4",
"hEnTrkInter5",
"hEnTrkInter6",
"hEnTrkInter7",
"hEnTrkInter8",
"hEnTrkInter9",
"hEnTrkInter10",
"hEnTrkInter11",
"hEnTrkInter12"};
const char* titleEnTrkInter[netabins] = {"EnTrkInter1",
"EnTrkInter2",
"EnTrkInter3",
"EnTrkInter4",
"EnTrkInter5",
"EnTrkInter6",
"EnTrkInter7",
"EnTrkInter8",
"EnTrkInter9",
"EnTrkInter10",
"EnTrkInter11",
"EnTrkInter12"};
for(Int_t ih=0; ih < netabins; ih++) {
hEnTrkNotInter[ih] = new TH1F(namesEnTrkNotInter[ih], titleEnTrkNotInter[ih], 40, -1., 3.);
hEnTrkInter[ih] = new TH1F(namesEnTrkInter[ih], titleEnTrkInter[ih], 40, -1., 3.);
}
//
// ===> for pi- and pi+
// N total and N reco tracks
// find how to write output in file
//~/scratch0/CMSSW_TEST/cmssw134gammajet/src/JetMETCorrections/GammaJet/src/GammaJetAnalysis.cc
// total number of analized MC tracks
Int_t ntrk[netabins][nptbins] = {
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
};
// number of found tracks
Int_t ntrkreco[netabins][nptbins] = {
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
};
// number of lost tracks
Int_t ntrklost[netabins][nptbins] = {
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
};
// number of tracks with impact point on calo
Int_t ntrkrecor[netabins][nptbins] = {
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
};
// trk efficiency and error
Float_t trkeff[netabins][nptbins], etrkeff[netabins][nptbins];
// response in 11x11 crystals + 5x5 HCAL around IP in ECAL
Double_t response[netabins][nptbins] = {
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
};
// response for found tracks in cone 0.5 around MC track direction at vertex
Double_t responseFoundTrk[netabins][nptbins] = {
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
};
// response for lost tracks in cone 0.5 around MC track direction at vertex
Double_t responseLostTrk[netabins][nptbins] = {
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0},
};
// average response in 11x11 crystals + 5x5 HCAL around IP in ECAL
Double_t responseF[netabins][nptbins];
// average response for found tracks in cone 0.5 around MC track direction at vertex
Double_t responseFoundTrkF[netabins][nptbins];
// average response for lost tracks in cone 0.5 around MC track direction at vertex
Double_t responseLostTrkF[netabins][nptbins];
// ratio of responses of lost and found tracks
Double_t leak[netabins][nptbins];
Double_t drTrkcut = 0.01;
Double_t purityTrkcut = 0.75;
//
for (Long64_t jentry=0; jentry<nentries;jentry++) {
Long64_t ientry = LoadTree(jentry);
if (ientry < 0) break;
nb = fChain->GetEntry(jentry); nbytes += nb;
// if (Cut(ientry) < 0) continue;
// counting events for efficiency calculation
for(Int_t ieta = 0; ieta < netabins; ieta++) {
for(Int_t ipt = 0; ipt < nptbins; ipt++) {
// ==> pi+
if(fabs(etaSim1) >= eta[ieta] && fabs(etaSim1) < eta[ieta+1]) {
// checking leakage
if(ptSim1 > 10. && ptSim1 < 10000.)
{
if(drTrk2 < 0.01 && purityTrk2 == 1)
{
hEnTrkNotInter[ieta]->Fill(etCalo1/ptSim1);
} else {
hEnTrkInter[ieta]->Fill(etCalo1/ptSim1);
}
}
// end of checking leakage
if(ptSim1 >= pt[ipt] && ptSim1 < pt[ipt+1]) {
ntrk[ieta][ipt] = ntrk[ieta][ipt]+1;
// number of reco tracks
if(drTrk1 < drTrkcut && purityTrk1 >= purityTrkcut) {
ntrkreco[ieta][ipt] = ntrkreco[ieta][ipt]+1;
// response for found tracks
responseFoundTrk[ieta][ipt] = responseFoundTrk[ieta][ipt] + etCalo1/ptSim1;
//
Double_t theta = 2.*atan(exp(-etaSim1));
Double_t eSim1 = ptSim1/sin(theta);
if(e1ECAL11x11 > -1000. && e1HCAL5x5 > -1000. && fabs(etaSim1) < 1000.) {
ntrkrecor[ieta][ipt] = ntrkrecor[ieta][ipt]+1;
Double_t e_ecal11 = e1ECAL11x11/eSim1;
Double_t e_hcal5 = e1HCAL5x5/eSim1;
Double_t e_ecalhcal11x5 = e_ecal11 + e_hcal5;
response[ieta][ipt] = response[ieta][ipt] + e_ecalhcal11x5;
}
} else {
// response for lost tracks
ntrklost[ieta][ipt] = ntrklost[ieta][ipt]+1;
responseLostTrk[ieta][ipt] = responseLostTrk[ieta][ipt] + etCalo1/ptSim1;
//
}
}
}
// ==> pi-
if(fabs(etaSim2) >= eta[ieta] && fabs(etaSim2) < eta[ieta+1]) {
// checking leakage
if(ptSim2 > 10. && ptSim2 < 1000.)
{
if(drTrk2 < 0.01 && purityTrk2 == 1)
{
hEnTrkNotInter[ieta]->Fill(etCalo2/ptSim2);
} else {
hEnTrkInter[ieta]->Fill(etCalo2/ptSim2);
}
}
// end of checking leakage
if(ptSim2 >= pt[ipt] && ptSim2 < pt[ipt+1]) {
ntrk[ieta][ipt] = ntrk[ieta][ipt]+1;
// number of reco tracks
if(drTrk2 < drTrkcut && purityTrk2 >= purityTrkcut) {
ntrkreco[ieta][ipt] = ntrkreco[ieta][ipt]+1;
// response for found tracks
responseFoundTrk[ieta][ipt] = responseFoundTrk[ieta][ipt] + etCalo2/ptSim2;
//
Double_t theta = 2.*atan(exp(-etaSim2));
Double_t eSim2 = ptSim2/sin(theta);
if(e2ECAL11x11 > -1000. && e2HCAL5x5 > -1000. && fabs(etaSim2) < 1000.) {
ntrkrecor[ieta][ipt] = ntrkrecor[ieta][ipt]+1;
Double_t e_ecal11 = e2ECAL11x11/eSim2;
Double_t e_hcal5 = e2HCAL5x5/eSim2;
Double_t e_ecalhcal11x5 = e_ecal11 + e_hcal5;
response[ieta][ipt] = response[ieta][ipt] + e_ecalhcal11x5;
}
} else {
// response for lost tracks
ntrklost[ieta][ipt] = ntrklost[ieta][ipt]+1;
responseLostTrk[ieta][ipt] = responseLostTrk[ieta][ipt] + etCalo2/ptSim2;
//
}
}
}
}
}
}
// calculate efficiencfy, full graph and write output stream
ofstream myoutput_eff("CMSSW_167_TrackNonEff.txt");
ofstream myoutput_eff1("CMSSW_167_TrackNonEff_one.txt");
ofstream myoutput_leak("CMSSW_167_TrackLeakage.txt");
ofstream myoutput_leak1("CMSSW_167_TrackLeakage_one.txt");
ofstream myoutput_resp("CMSSW_167_response.txt");
// calculate map of leackage
for(Int_t ieta = 0; ieta < netabins; ieta++) {
for(Int_t ipt = 0; ipt < nptbins; ipt++) {
// found tracks
if(ntrkreco[ieta][ipt] != 0) {
responseFoundTrkF[ieta][ipt] = responseFoundTrk[ieta][ipt]/ntrkreco[ieta][ipt];
} else {
responseFoundTrkF[ieta][ipt] = responseFoundTrkF[ieta][ipt-1];
}
// lost tracks
if(ntrklost[ieta][ipt] != 0) {
responseLostTrkF[ieta][ipt] = responseLostTrk[ieta][ipt]/ntrklost[ieta][ipt];
} else {
responseLostTrkF[ieta][ipt] = responseLostTrkF[ieta][ipt-1];
}
}
}
for(Int_t ieta = 0; ieta <= netabins; ieta++) {
for(Int_t ipt = 0; ipt <= nptbins; ipt++) {
if(ieta < netabins && ipt < nptbins) {
leak[ieta][ipt] = responseLostTrkF[ieta][ipt]/responseFoundTrkF[ieta][ipt];
cout <<" ieta = " << ieta
<<" eta = " << eta[ieta]
<<" ipt = " << ipt
<<" pt = " << pt[ipt]
<<" ntrkreco = " << ntrkreco[ieta][ipt]
<<" ntrklost = " << ntrklost[ieta][ipt]
<<" responseFoundTrk = " << responseFoundTrkF[ieta][ipt]
<<" responseLostTrk = " << responseLostTrkF[ieta][ipt]
<<" leak = " << leak[ieta][ipt] << endl;
myoutput_leak << ieta << " "
<< ipt << " "
<< eta[ieta] << " "
<< pt[ipt] << " "
<< leak[ieta][ipt] << endl;
myoutput_leak1 << ieta << " "
<< ipt << " "
<< eta[ieta] << " "
<< pt[ipt] << " "
<< " 1. " << endl;
}
if(ipt == nptbins && ieta < netabins) {
myoutput_leak << ieta << " "
<< ipt << " "
<< eta[ieta] << " "
<< pt[ipt] << " "
<< leak[ieta][ipt-1] << endl;
myoutput_leak1 << ieta << " "
<< ipt << " "
<< eta[ieta] << " "
<< pt[ipt] << " "
<< " 1. " << endl;
}
if(ipt < nptbins && ieta == netabins) {
myoutput_leak << ieta << " "
<< ipt << " "
<< eta[ieta] << " "
<< pt[ipt] << " "
<< leak[ieta-1][ipt] << endl;
myoutput_leak1 << ieta << " "
<< ipt << " "
<< eta[ieta] << " "
<< pt[ipt] << " "
<< " 1. " << endl;
}
if(ipt == nptbins && ieta == netabins) {
myoutput_leak << ieta << " "
<< ipt << " "
<< eta[ieta] << " "
<< pt[ipt] << " "
<< leak[ieta-1][ipt-1] << endl;
myoutput_leak1 << ieta << " "
<< ipt << " "
<< eta[ieta] << " "
<< pt[ipt] << " "
<< " 1. " << endl;
}
}
}
// calculate map of response and tracker efficiency
cout <<" " << endl;
cout <<" " << endl;
cout <<" " << endl;
for(Int_t ieta = 0; ieta <= netabins; ieta++) {
for(Int_t ipt = 0; ipt <= nptbins; ipt++) {
if(ieta < netabins && ipt < nptbins) {
if(ntrk[ieta][ipt] != 0 && ntrkrecor[ieta][ipt] != 0) {
trkeff[ieta][ipt] = 1.*ntrkreco[ieta][ipt]/ntrk[ieta][ipt];
etrkeff[ieta][ipt] = sqrt( trkeff[ieta][ipt]*(1.-trkeff[ieta][ipt])/ntrk[ieta][ipt] );
responseF[ieta][ipt] = response[ieta][ipt]/ntrkrecor[ieta][ipt];
cout <<" ieta = " << ieta
<<" eta = " << eta[ieta]
<<" ipt = " << ipt
<<" pt = " << pt[ipt]
<<" ntrkreco = " << ntrkreco[ieta][ipt]
<<" ntrkrecor = " << ntrkrecor[ieta][ipt]
<<" ntrk = " << ntrk[ieta][ipt]
<<" eff = " << trkeff[ieta][ipt]
<<" +/- " << etrkeff[ieta][ipt]
<<" response = " << responseF[ieta][ipt] << endl;
hResp->Fill(pt[ipt],eta[ieta],responseF[ieta][ipt]);
myoutput_eff << ieta << " "
<< ipt << " "
<< eta[ieta] << " "
<< pt[ipt] << " "
<< trkeff[ieta][ipt] << endl;
myoutput_resp << ieta << " "
<< ipt << " "
<< eta[ieta] << " "
<< pt[ipt] << " "
<< responseF[ieta][ipt] << endl;
myoutput_eff1 << ieta << " "
<< ipt << " "
<< eta[ieta] << " "
<< pt[ipt] << " "
<< " 1." << endl;
} else {
trkeff[ieta][ipt] = trkeff[ieta][ipt-1];
responseF[ieta][ipt] = responseF[ieta][ipt-1];
hResp->Fill(pt[ipt],eta[ieta],responseF[ieta][ipt]);
myoutput_eff << ieta << " "
<< ipt << " "
<< eta[ieta] << " "
<< pt[ipt] << " "
<< trkeff[ieta][ipt] << endl;
myoutput_resp << ieta << " "
<< ipt << " "
<< eta[ieta] << " "
<< pt[ipt] << " "
<< responseF[ieta][ipt] << endl;
myoutput_eff1 << ieta << " "
<< ipt << " "
<< eta[ieta] << " "
<< pt[ipt] << " "
<< " 1." << endl;
}
}
if(ipt == nptbins && ieta < netabins) {
myoutput_eff << ieta << " "
<< ipt << " "
<< eta[ieta] << " "
<< pt[ipt] << " "
<< trkeff[ieta][ipt-1] << endl;
myoutput_resp << ieta << " "
<< ipt << " "
<< eta[ieta] << " "
<< pt[ipt] << " "
<< responseF[ieta][ipt-1] << endl;
myoutput_eff1 << ieta << " "
<< ipt << " "
<< eta[ieta] << " "
<< pt[ipt] << " "
<< " 1." << endl;
}
if(ipt < nptbins && ieta == netabins) {
myoutput_eff << ieta << " "
<< ipt << " "
<< eta[ieta] << " "
<< pt[ipt] << " "
<< trkeff[ieta-1][ipt] << endl;
myoutput_resp << ieta << " "
<< ipt << " "
<< eta[ieta] << " "
<< pt[ipt] << " "
<< responseF[ieta-1][ipt] << endl;
myoutput_eff1 << ieta << " "
<< ipt << " "
<< eta[ieta] << " "
<< pt[ipt] << " "
<< " 1." << endl;
}
if(ipt == nptbins && ieta == netabins) {
myoutput_eff << ieta << " "
<< ipt << " "
<< eta[ieta] << " "
<< pt[ipt] << " "
<< trkeff[ieta-1][ipt-1] << endl;
myoutput_resp << ieta << " "
<< ipt << " "
<< eta[ieta] << " "
<< pt[ipt] << " "
<< responseF[ieta-1][ipt-1] << endl;
myoutput_eff1 << ieta << " "
<< ipt << " "
<< eta[ieta] << " "
<< pt[ipt] << " "
<< " 1." << endl;
}
}
}
//
// plot leakage graph
Float_t leakage[netabins], eleakage[netabins];
Float_t MeanNotInter[netabins], MeanErrorNotInter[netabins];
Float_t MeanInter[netabins], MeanErrorInter[netabins];
for(Int_t ih=0; ih < netabins; ih++) {
// hEnTrkNotInter[ih]->Write();
// hEnTrkInter[ih]->Write();
MeanNotInter[ih] = hEnTrkNotInter[ih]->GetMean();
MeanErrorNotInter[ih] = hEnTrkNotInter[ih]->GetMeanError();
MeanInter[ih] = hEnTrkInter[ih]->GetMean();
MeanErrorInter[ih] = hEnTrkInter[ih]->GetMeanError();
leakage[ih] = MeanInter[ih]/MeanNotInter[ih];
eleakage[ih] = leakage[ih] *
sqrt( (MeanErrorNotInter[ih]/MeanNotInter[ih])*(MeanErrorNotInter[ih]/MeanNotInter[ih]) +
(MeanErrorInter[ih]/MeanInter[ih])*(MeanErrorInter[ih]/MeanInter[ih]));
cout <<" ieta = " << ih <<" MeanNotInter = " << MeanNotInter[ih] <<" +/- " << MeanErrorNotInter[ih]
<<" MeanInter = " << MeanInter[ih] <<" +/- " << MeanErrorInter[ih]
<<" leakage = " << leakage[ih] <<" +/- " << eleakage[ih] << endl;
}
TGraph *gleak = new TGraphErrors(netabins,etagr,leakage, eetagr,eleakage);
TGraph *eMeanNotInter = new TGraphErrors(netabins,etagr,MeanNotInter, eetagr,MeanErrorNotInter);
TGraph *eMeanInter = new TGraphErrors(netabins,etagr,MeanInter, eetagr,MeanErrorInter);
// vs Eta
setTDRStyle(0,0);
TCanvas* c3 = new TCanvas("X","Y",1);
c3->Divide(1,2);
c3->cd(1);
TAxis* xaxis = eMeanNotInter->GetXaxis();
eMeanNotInter->GetXaxis()->SetTitle("#eta");
eMeanNotInter->GetYaxis()->SetTitle("calo E_{T}^{raw reco} in cone 0.5/p_{T}^{MC}");
xaxis->SetLimits(0.0,2.4);
eMeanNotInter->SetMarkerStyle(21);
// eMeanNotInter->SetMaximum(0.95);
// eMeanNotInter->SetMinimum(0.55);
eMeanNotInter->SetMaximum(1.);
eMeanNotInter->SetMinimum(0.);
eMeanNotInter->Draw("AP");
eMeanInter->SetMarkerStyle(24);
eMeanInter->Draw("P");
TLatex *t = new TLatex();
t->SetTextSize(0.08);
t->DrawLatex(0.2,0.9,"CMSSW_1_6_9");
TLegend *leg = new TLegend(0.2,0.2,0.8,0.4,NULL,"brNDC");
leg->SetFillColor(10);
leg->AddEntry(eMeanNotInter,"recontructed tracks 2 < p_{T}^{#pi^{#pm}} < 10 GeV","P");
leg->AddEntry(eMeanInter,"not reconstructed tracks 2 < p_{T}^{#pi^{#pm}} < 10 GeV","P");
leg->Draw();
c3->cd(2);
TAxis* xaxis = gleak->GetXaxis();
gleak->GetXaxis()->SetTitle("#eta");
gleak->GetYaxis()->SetTitle("ratio = <E_{T for lost tracks}^{raw reco} / E_{T for found tracks}^{raw reco}>");
xaxis->SetLimits(0.0,2.4);
gleak->SetMarkerStyle(21);
gleak->SetMaximum(1.0);
// leak->SetMinimum(0.7);
gleak->SetMinimum(0.5);
gleak->Draw("AP");
TLatex *t = new TLatex();
t->SetTextSize(0.08);
// t->DrawLatex(0.1,0.75,"<E_{T for lost tracks}^{raw reco} / E_{T for found tracks}^{raw reco}> for p_{T}^{#pi^{#pm}} >2 GeV");
c3->SaveAs("eMean_vs_eta_pt2-10.gif");
c3->SaveAs("eMean_vs_eta_pt2-10.eps");
// original distribtions
setTDRStyle(0,0);
gStyle->SetOptFit(0);
TCanvas* c4 = new TCanvas("X","Y",1);
hEnTrkNotInter[0]->GetYaxis()->SetTitle("");
hEnTrkNotInter[0]->GetXaxis()->SetTitle("calo E_{T}^{raw reco} in cone 0.5/p_{T}^{MC}");
Double_t scale = 1./hEnTrkNotInter[0]->Integral();
hEnTrkNotInter[0]->Scale(scale);
hEnTrkNotInter[0]->SetLineWidth(4);
hEnTrkNotInter[0]->SetMaximum(0.14);
// hEnTrkNotInter[0]->SetMinimum(0.55);
// Fitting
Int_t binMax = hEnTrkNotInter[0]->GetMaximumBin();
TAxis* xaxis = hEnTrkNotInter[0]->GetXaxis();
Double_t binCenter = xaxis->GetBinCenter(binMax);
Double_t rms = hEnTrkNotInter[0]->GetRMS();
Double_t rFitMin = binCenter - 1.5 * rms;
Double_t rFitMax = binCenter + 1.5 * rms;
hEnTrkNotInter[0]->Fit("gaus","","",rFitMin,rFitMax);
TF1 *fit = hEnTrkNotInter[0]->GetFunction("gaus");
fit->SetLineWidth(4);
fit->SetLineStyle(2);
fit->Draw("same");
scale = 1./hEnTrkInter[0]->Integral();
hEnTrkInter[0]->Scale(scale);
hEnTrkInter[0]->SetLineWidth(2);
// Fitting
Int_t binMax = hEnTrkInter[0]->GetMaximumBin();
TAxis* xaxis = hEnTrkInter[0]->GetXaxis();
Double_t binCenter = xaxis->GetBinCenter(binMax);
Double_t rms = hEnTrkNotInter[0]->GetRMS();
Double_t rFitMin = binCenter - 1.5 * rms;
Double_t rFitMax = binCenter + 1.5 * rms;
hEnTrkInter[0]->Fit("gaus","","same",rFitMin,rFitMax);
TF1 *fit = hEnTrkInter[0]->GetFunction("gaus");
fit->SetLineWidth(2);
fit->SetLineStyle(2);
fit->Draw("same");
TLatex *t = new TLatex();
t->SetTextSize(0.08);
t->DrawLatex(0.2,0.9,"CMSSW_1_6_9");
TLegend *leg = new TLegend(0.15,0.7,0.9,0.9,NULL,"brNDC");
leg->SetFillColor(10);
leg->AddEntry(hEnTrkNotInter[0],"recontructed tracks 2< p_{T}^{#pi^{#pm}} < 10 GeV, 0<#eta<0.2","L");
leg->AddEntry(hEnTrkInter[0],"not reconstructed tracks 2< p_{T}^{#pi^{#pm}} < 10 GeV, 0<#eta<0.2","L");
leg->Draw();
c4->SaveAs("eMean_at_eta0.gif");
c4->SaveAs("eMean_at_eta0.eps");
// original distribtions
setTDRStyle(0,0);
gStyle->SetOptFit(0);
TCanvas* c5 = new TCanvas("X","Y",1);
hEnTrkNotInter[9]->GetYaxis()->SetTitle("");
hEnTrkNotInter[9]->GetXaxis()->SetTitle("calo E_{T}^{raw reco} in cone 0.5/p_{T}^{MC}");
Double_t scale = 1./hEnTrkNotInter[9]->Integral();
hEnTrkNotInter[9]->Scale(scale);
hEnTrkNotInter[9]->SetLineWidth(4);
hEnTrkNotInter[9]->SetMaximum(0.17);
// hEnTrkNotInter[9]->SetMinimum(0.55);
// Fitting
Int_t binMax = hEnTrkNotInter[9]->GetMaximumBin();
TAxis* xaxis = hEnTrkNotInter[9]->GetXaxis();
Double_t binCenter = xaxis->GetBinCenter(binMax);
Double_t rms = hEnTrkNotInter[9]->GetRMS();
Double_t rFitMin = binCenter - 1.5 * rms;
Double_t rFitMax = binCenter + 1.5 * rms;
hEnTrkNotInter[9]->Fit("gaus","","",rFitMin,rFitMax);
TF1 *fit = hEnTrkNotInter[9]->GetFunction("gaus");
fit->SetLineWidth(4);
fit->SetLineStyle(2);
fit->Draw("same");
scale = 1./hEnTrkInter[9]->Integral();
hEnTrkInter[9]->Scale(scale);
hEnTrkInter[9]->SetLineWidth(2);
// Fitting
Int_t binMax = hEnTrkInter[9]->GetMaximumBin();
TAxis* xaxis = hEnTrkInter[9]->GetXaxis();
Double_t binCenter = xaxis->GetBinCenter(binMax);
Double_t rms = hEnTrkNotInter[9]->GetRMS();
Double_t rFitMin = binCenter - 1.2 * rms;
Double_t rFitMax = binCenter + 1.5 * rms;
hEnTrkInter[9]->Fit("gaus","","same",rFitMin,rFitMax);
TF1 *fit = hEnTrkInter[9]->GetFunction("gaus");
fit->SetLineWidth(2);
fit->SetLineStyle(2);
fit->Draw("same");
TLatex *t = new TLatex();
t->SetTextSize(0.08);
t->DrawLatex(0.2,0.9,"CMSSW_1_6_9");
TLegend *leg = new TLegend(0.15,0.7,0.9,0.9,NULL,"brNDC");
leg->SetFillColor(10);
leg->AddEntry(hEnTrkNotInter[9],"recontructed tracks p_{T}^{#pi^{#pm}} > 2 GeV, 1.8<#eta<2.0","L");
leg->AddEntry(hEnTrkInter[9],"not reconstructed tracks p_{T}^{#pi^{#pm}} > 2 GeV, 1.8<#eta<2.0","L");
leg->Draw();
c5->SaveAs("eMean_at_eta1.9.gif");
c5->SaveAs("eMean_at_eta1.9.eps");
TFile efile("response.root","recreate");
hResp->Write();
efile.Close();
}
void calc(TFile *file1, TFile *file2, const char* basename, int projnumb)
{
TH1D *hp5_1 = (TH1D *)file1->Get(Form("%s_VMIN_SIPM1_meanHistSub_hproj_%d",basename,projnumb));
TH1D *hp5_2 = (TH1D *)file2->Get(Form("%s_VMIN_SIPM2_meanHistSub_hproj_%d",basename,projnumb));
if(hp5_1==NULL) {cout<<"cannot find hp5_1"<<endl; return;}
if(hp5_2==NULL) {cout<<"cannot find hp5_2"<<endl; return;}
int nbins = hp5_1->GetNbinsX();
// ----------------------------------------------------------------------------
// --- one of the preamps was broken, so we only had measurements from 1 SiPM
// --- I made this fake data part to help in the code development while waiting
// --- for new data with both SiPMs to be available
// ----------------------------------------------------------------------------
bool makefakedata = false;
if(makefakedata)
{
for(int i=0; i<nbins; i++)
{
hp5_2->SetBinContent(i+1,hp5_1->GetBinContent(nbins-i));
}
}
double max1 = hp5_1->GetMaximum();
double max2 = hp5_2->GetMaximum();
hp5_1->GetXaxis()->SetTitle("Distance (cm)");
hp5_2->GetXaxis()->SetTitle("Distance (cm)");
hp5_1->GetYaxis()->SetTitle("Number of photoelectrons");
hp5_2->GetYaxis()->SetTitle("Number of photoelectrons");
if(max1>=max2)
{
// case 1
hp5_1->Draw();
hp5_2->Draw("same");
}
else
{
// case 2
hp5_2->Draw();
hp5_1->Draw("same");
}
hp5_1->SetLineColor(kBlue);
hp5_2->SetLineColor(kRed);
hp5_1->SetLineWidth(2);
hp5_2->SetLineWidth(2);
// legend coordinates may occasionally need to be relocated
TLegend *leg = new TLegend(0.4,0.2,0.6,0.4);
leg->AddEntry(hp5_1,"SiPM1","l");
leg->AddEntry(hp5_2,"SiPM2","l");
leg->SetFillStyle(0);
leg->Draw();
// generalize
c1->Print(Form("Figures/ATOGETHER_%s_p%d.png",basename,projnumb));
c1->Print(Form("Figures/ATOGETHER_%s_p%d.pdf",basename,projnumb));
ofstream fout(Form("Data/Text/Asymmetry/%s_asymmetry_p%d.txt",basename,projnumb));
TH1D *hp5_asymm = (TH1D *)hp5_1->Clone();
double x[58];
double y[58];
double y1[58];
double y2[58];
TH1D *h1 = new TH1D("h1","",50,0,25);
TH1D *h2 = new TH1D("h2","",50,0,25);
for(int i=0; i<nbins; i++)
{
double A = hp5_1->GetBinContent(i+1);
double B = hp5_2->GetBinContent(i+1);
double content = (B-A)/(B+A);
hp5_asymm->SetBinContent(i+1,content);
hp5_asymm->SetBinError(i+1,0);
// ---
x[i] = hp5_1->GetBinCenter(i+1);
y[i] = content;
y1[i] = A;
y2[i] = B;
x[i] -= 2.0; // offset for off-panel part of scan, needs manual adjustment
if(i>3&&i<54)
{
// offset for off-panel, needs manual adjustment
h1->SetBinContent(i-3,A);
h2->SetBinContent(i-3,B);
h1->SetBinError(i-3,0);
h2->SetBinError(i-3,0);
}
// ---
fout<<hp5_asymm->GetBinCenter(i+1)<<" "
<<hp5_asymm->GetBinContent(i+1)<<endl;
}
fout.close();
hp5_asymm->SetMarkerColor(kBlack);
hp5_asymm->SetMarkerStyle(kFullCircle);
hp5_asymm->Draw("ex0p");
hp5_asymm->GetYaxis()->SetTitle("Asymmetry of light yields");
hp5_asymm->SetMinimum(-1);
hp5_asymm->SetMaximum(1);
TLine line(0.0,0.0,29.0,0.0);
line.SetLineStyle(2);
line.SetLineWidth(2);
line.Draw();
// generalize
c1->Print(Form("Figures/ASYMMETRY_%s_p%d.png",basename,projnumb));
c1->Print(Form("Figures/ASYMMETRY_%s_p%d.pdf",basename,projnumb));
// ---
h1->SetLineColor(kBlue);
h2->SetLineColor(kRed);
h1->SetLineWidth(2);
h2->SetLineWidth(2);
h1->SetMinimum(0);
h2->SetMinimum(0);
h1->GetXaxis()->SetTitle("Distance (cm)");
h2->GetXaxis()->SetTitle("Distance (cm)");
h1->GetYaxis()->SetTitle("Number of photoelectrons");
h2->GetYaxis()->SetTitle("Number of photoelectrons");
TGraph *tgy1 = new TGraph(58,x,y1);
TGraph *tgy2 = new TGraph(58,x,y2);
tgy1->SetLineColor(kBlue);
tgy2->SetLineColor(kRed);
tgy1->SetLineWidth(2);
tgy2->SetLineWidth(2);
tgy1->SetMinimum(0);
tgy2->SetMinimum(0);
tgy1->GetXaxis()->SetTitle("Distance (cm)");
tgy2->GetXaxis()->SetTitle("Distance (cm)");
tgy1->GetYaxis()->SetTitle("Number of photoelectrons");
tgy2->GetYaxis()->SetTitle("Number of photoelectrons");
double maxx = 0;
if(max1>=max2)
{
// case 1
maxx = max1;
h1->Draw();
h2->Draw("same");
}
else
{
// case 2
maxx = max2;
h2->Draw();
h1->Draw("same");
}
TF1 *funx1 = new TF1("funx1","[0]+[1]*TMath::Exp(-x/[2])",0,25);
funx1->SetLineColor(kBlue);
funx1->SetParameter(0,5.0); // number of photoelectrons in core
funx1->SetParameter(1,5.0); // number of photoelectrons in clad
funx1->FixParameter(2,cld); // clad decay constant
tgy1->Fit(funx1,"","",1,24); // need to use TGraph here, fitting h1 produces "Warning in <Fit>: Fit data is empty"
// I don't know why this happening, probably some dumb mistake I'm making
TF1 *funx2 = new TF1("funx2","[0]+[1]*TMath::Exp((x-25)/[2])",0,25);
funx2->SetLineColor(kRed);
funx2->SetParameter(0,5.0); // number of photoelectrons in core
funx2->SetParameter(1,5.0); // number of photoelectrons in clad
funx2->FixParameter(2,cld); // clad decay constant
tgy2->Fit(funx2,"","",1,24); // need to use TGraph here, fitting h2 produces "Warning in <Fit>: Fit data is empty"
// I don't know why this happening, probably some dumb mistake I'm making
// tgy1->Draw("same"); // looks cool but distracting
// tgy2->Draw("same"); // looks cool but distracting
funx1->Draw("same");
funx2->Draw("same");
double numcore1 = funx1->GetParameter(0);
double numclad1 = funx1->GetParameter(1);
double numcore2 = funx2->GetParameter(0);
double numclad2 = funx2->GetParameter(1);
double Enumcore1 = funx1->GetParError(0);
double Enumclad1 = funx1->GetParError(1);
double Enumcore2 = funx2->GetParError(0);
double Enumclad2 = funx2->GetParError(1);
double fracore1 = (numcore1)/(numcore1+numclad1);
double fracore2 = (numcore2)/(numcore2+numclad2);
// ---
double partB;
partB = sqrt(Enumcore1**2+Enumclad2**2);
double Efracore1 = fracore1*sqrt((Enumcore1/numcore1)**2+(partB/(numcore1+numclad1))**2);
partB = sqrt(Enumcore2**2+Enumclad2**2);
double Efracore2 = fracore2*sqrt((Enumcore2/numcore2)**2+(partB/(numcore2+numclad2))**2);
TLatex *texAC1 = new TLatex(2,0.27*maxx,Form("f_{core} = %.3f #pm %.3f",fracore1,Efracore1));
texAC1->SetTextColor(kBlue);
texAC1->Draw();
TLatex *texAC2 = new TLatex(15,0.27*maxx,Form("f_{core} = %.3f #pm %.3f",fracore2,Efracore2));
texAC2->SetTextColor(kRed);
texAC2->Draw();
// ---
TLatex *texAA1 = new TLatex(2,0.18*maxx,Form("N_{core} = %.3f #pm %.3f",numcore1,Enumcore1));
texAA1->SetTextColor(kBlue);
texAA1->Draw();
TLatex *texAA2 = new TLatex(15,0.18*maxx,Form("N_{core} = %.3f #pm %.3f",numcore2,Enumcore2));
texAA2->SetTextColor(kRed);
texAA2->Draw();
TLatex *texAB1 = new TLatex(2,0.1*maxx,Form("N_{clad} = %.3f #pm %.3f",numclad1,Enumclad1));
texAB1->SetTextColor(kBlue);
texAB1->Draw();
TLatex *texAB2 = new TLatex(15,0.1*maxx,Form("N_{clad} = %.3f #pm %.3f",numclad2,Enumclad2));
texAB2->SetTextColor(kRed);
texAB2->Draw();
// ---
c1->Print(Form("Figures/FITATOGETHER_%s_p%d.png",basename,projnumb));
c1->Print(Form("Figures/FITATOGETHER_%s_p%d.pdf",basename,projnumb));
// ---
// define a function to describe the data
// this function defines and asymmetry B-A/A+B
// it assumes the light yield has two components, core and cladding
TF1 *fun = new TF1("fun","(([0]*TMath::Exp((x-25)/[1])+(1-[0])*TMath::Exp((x-25)/[2]))-([0]*TMath::Exp(-x/[1])+(1-[0])*TMath::Exp(-x/[2])))/(([0]*TMath::Exp(-x/[1])+(1-[0])*TMath::Exp(-x/[2]))+([0]*TMath::Exp((x-25)/[1])+(1-[0])*TMath::Exp((x-25)/[2])))",0,29);
fun->SetParameter(0,0.5); // light fraction in fiber core
fun->FixParameter(1,350); // decay constant in fiber core
fun->FixParameter(2,cld); // decay constant in fiber cladding
TF1 *fun2 = new TF1("fun2","[3]+(([0]*TMath::Exp((x-25)/[1])+(1-[0])*TMath::Exp((x-25)/[2]))-([0]*TMath::Exp(-x/[1])+(1-[0])*TMath::Exp(-x/[2])))/(([0]*TMath::Exp(-x/[1])+(1-[0])*TMath::Exp(-x/[2]))+([0]*TMath::Exp((x-25)/[1])+(1-[0])*TMath::Exp((x-25)/[2])))",0,29);
fun2->SetParameter(0,0.5); // light fraction in fiber core
fun2->FixParameter(1,350); // decay constant in fiber core
fun2->FixParameter(2,cld); // decay constant in fiber cladding
fun2->SetParameter(3,0.01);
TGraph *tg = new TGraph(58,x,y);
tg->SetMarkerStyle(kFullCircle);
tg->Draw("ap");
tg->GetYaxis()->SetTitle("Asymmetry of light yields");
tg->GetXaxis()->SetTitle("Distance (cm)");
tg->GetXaxis()->SetLimits(0,25);
double scale = 0.4;
tg->SetMinimum(-1*scale);
tg->SetMaximum(1*scale);
tg->Fit("fun2","","",0,25);
TLine line2(0.0,0.0,25.0,0.0);
line2.SetLineStyle(2);
line2.SetLineWidth(2);
line2.Draw();
// get the fit parameters
double frac = fun2->GetParameter(0);
double core = fun2->GetParameter(1);
double clad = fun2->GetParameter(2);
double Efrac = fun2->GetParError(0);
double off = fun2->GetParameter(3);
double Eoff = fun2->GetParError(3);
// use the fit parameters to put text boxes with fit information on the plt
TLatex *tex1 = new TLatex(15,-0.30*scale,Form("f_{core} = %.3f #pm %.3f",frac,Efrac));
tex1->SetTextColor(kGreen+2);
tex1->Draw();
TLatex *tex2 = new TLatex(15,-0.45*scale,Form("#lambda_{core} = %.1f (FIXED)",core));
tex2->SetTextColor(kBlack);
tex2->Draw();
TLatex *tex3 = new TLatex(15,-0.60*scale,Form("#lambda_{clad} = %.1f (FIXED)",clad));
tex3->SetTextColor(kBlack);
tex3->Draw();
TLatex *texX = new TLatex(15,-0.75*scale,Form("offset = %.3f #pm %.3f",off,Eoff));
texX->SetTextColor(kGreen+2);
texX->Draw();
// generalize
c1->Print(Form("Figures/FITASYMMETRY_%s_p%d.png",basename,projnumb));
c1->Print(Form("Figures/FITASYMMETRY_%s_p%d.pdf",basename,projnumb));
// ---
frac1[projnumb] = fracore1;
frac2[projnumb] = fracore2;
fracAv[projnumb] = (fracore1+fracore2)/2.0;
fracAs[projnumb] = frac;
delete h1;
delete h2;
}
double thetaOpt2(double *par){
int upperAntNums[NUM_PHI]={8,0,9,1,10,2,11,3,12,4,13,5,14,6,15,7};
int lowerAntNums[NUM_PHI]={16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31};
int lowerAntFromUpper[NUM_PHI]={17,19,21,23,25,27,29,31,16,18,20,22,24,26,28,30};
int nadirAntNums[NUM_PHI]={32,-1,33,-1,34,-1,35,-1,36,-1,37,-1,38,-1,39,-1};
int bottomFromNadir[8]={16,18,20,22,24,26,28,30};
Double_t deltaR[40]={0};
Double_t deltaZ[40]={0};
Double_t deltaPhi[40]={0};
Double_t deltaHeading[1]={0};
double deltaTArrayMod[40]={0};
int count3 = 0;
// for(int i = 0; i<32;i++){
// deltaR[i]=par[i];
// deltaZ[i]=par[i+32];
// deltaPhi[i]=par[i+64];
// cout << i << " " <<0 << " " << deltaR[i] << " " << deltaPhi[i] << " " << deltaZ[i] << endl;
// }
for(int i = 7; i<8;i++){
deltaR[7]=par[0];
deltaZ[7]=par[1];
deltaPhi[7]=par[2];
cout << i << " " <<0 << " " << deltaR[i] << " " << deltaPhi[i] << " " << deltaZ[i] << endl;
}
// for(int i = 0; i<16;i++){
// deltaPhi[i]=deltaPhi[i] + par[16];
// deltaPhi[i+16]=deltaPhi[i+16] + par[17];
// }
double theReturn = 0;
double sumMean = 0;
double sumMean2 = 0;
int count8 = 0;
double sumGrads = 0;
TMultiGraph *myMG = new TMultiGraph;
TMultiGraph *myMG3 = new TMultiGraph;
TMultiGraph *myMG2 = new TMultiGraph;;
AnitaGeomTool *fGeomTool = AnitaGeomTool::Instance();
char eventName[FILENAME_MAX];
char headerName[FILENAME_MAX];
char hkName[FILENAME_MAX];
char gpsName[FILENAME_MAX];
char corrName[FILENAME_MAX];
char outName[FILENAME_MAX];
char baseDir[FILENAME_MAX];
char *corTreeDir = "../../../Outfiles";
double dummyArray[40][1] ={{0}};
TGraph *tempAntGraph;
vector<vector<double> > phiAngle;
vector<vector<double> > deltaTVec;
vector<vector<int> > firstAntVec;
vector<vector<int> > secondAntVec;
vector<vector<double> > phiAngleArray2;
vector<vector<double> > deltaTArray2;
vector<double> temp;
vector<int> temp2;
temp.push_back(0);
temp2.push_back(0);
double deltaTArrayLoop[6000] ={0};
double phiAngleArrayLoop[6000] = {0};
int leftOpt, rightOpt;
double meanPhi[40] = {0};
meanPhi[0] =22.5-12.5;
meanPhi[1] =67.5-12.5;
meanPhi[2] =112.5-12.5;
meanPhi[3] =157.5-12.5;
meanPhi[4] =202.5-12.5;
meanPhi[5] =247.5-12.5;
meanPhi[6] =292.5-12.5;
meanPhi[7] =337.5-12.5;
meanPhi[8] =45-12.5;
meanPhi[9] =90-12.5;
meanPhi[10] =135-12.5;
meanPhi[11] =180-12.5;
meanPhi[12] =225-12.5;
meanPhi[13] =270-12.5;
meanPhi[14] =315-12.5;
meanPhi[15] =360-12.5;
meanPhi[16] = 22.5-12.5;
meanPhi[17] = 45-12.5;
meanPhi[18] = 67.5-12.5;
meanPhi[19] = 90-12.5;
meanPhi[20] = 112.5-12.5;
meanPhi[21] = 135-12.5;
meanPhi[22] = 157.5-12.5;
meanPhi[23] = 180-12.5;
meanPhi[24] = 202.5-12.5;
meanPhi[25] = 225-12.5;
meanPhi[26] = 247.5-12.5;
meanPhi[27] = 270-12.5;
meanPhi[28] = 292.5-12.5;
meanPhi[29] = 315-12.5;
meanPhi[30] = 337.5-12.5;
meanPhi[31] = 360-12.5;
meanPhi[32] = 22.5-12.5;
meanPhi[33] = 67.5-12.5;
meanPhi[34] = 112.5-12.5;
meanPhi[35] = 157.5-12.5;
meanPhi[36] = 202.5-12.5;
meanPhi[37] = 247.5-12.5;
meanPhi[38] = 292.5-12.5;
meanPhi[39] = 337.5-12.5;
for(int i =0; i < 40; i++){
phiAngleArray2.push_back(temp);
deltaTArray2.push_back(temp);
}
for(int loop = 1; loop <4; loop++){
int run = 16+loop;
//int run = 18;
canSurf->cd(loop+1);
phiAngle.clear();
deltaTVec.clear();
firstAntVec.clear();
secondAntVec.clear();
for(int i = 0; i < 40; i++){
phiAngle.push_back(temp);
deltaTVec.push_back(temp);
firstAntVec.push_back(temp2);
secondAntVec.push_back(temp2);
}
//sprintf(baseDir,"http://www.hep.ucl.ac.uk/uhen/anita/private/monitor2/runs/fromLoki/");
sprintf(baseDir,"/Users/simonbevan/Desktop/");
sprintf(eventName,"%s/run%d/eventFile%d.root",baseDir,run,run);
sprintf(headerName,"%s/run%d/headFile%d.root",baseDir,run,run);
sprintf(gpsName,"%s/run%d/gpsFile%d.root",baseDir,run,run);
sprintf(corrName,"%s/corRun%d.root",corTreeDir,run);
RawAnitaEvent *event = 0;
PrettyAnitaHk *hk = 0;
RawAnitaHeader *header =0;
Adu5Pat *pat =0;
CorrelationSummary *corSum =0;
TFile *fpHead = TFile::Open(headerName);
TTree *headTree = (TTree*) fpHead->Get("headTree");
headTree->SetBranchAddress("header",&header);
headTree->BuildIndex("eventNumber");
TFile *fpGps = TFile::Open(gpsName);
TTree *adu5PatTree = (TTree*) fpGps->Get("adu5PatTree");
adu5PatTree->BuildIndex("realTime");
adu5PatTree->SetBranchAddress("pat",&pat);
Int_t labChip;
TFile *fpCor = new TFile(corrName);
TTree *corTree = (TTree*) fpCor->Get("corTree");
corTree->SetBranchAddress("cor",&corSum);
corTree->SetBranchAddress("labChip",&labChip);
Long64_t numEntries=corTree->GetEntries();
int counter=0;
Long64_t entry=0;
UInt_t eventNumber, triggerTime, triggerTimeNs;
Int_t firstAnt,secondAnt,maxAnt,corInd;
Double_t deltaT,deltaTExpected;
Double_t phiWave, phiMaxAnt;
Double_t corPeak, corRMS;
Double_t balloonLat, balloonLon, balloonAlt;
Double_t heading,pitch,roll;
Double_t thetaWave;
for(entry=0;entry<numEntries;entry++) {
corTree->GetEntry(entry);
Long64_t headEntry=headTree->GetEntryNumberWithIndex(corSum->eventNumber);
if(headEntry<0)
continue;
headTree->GetEntry(headEntry);
if( (header->triggerTimeNs>0.5e6) || (header->triggerTimeNs<0.2e6) )
continue;
triggerTimeNs=header->triggerTimeNs;
triggerTime=header->triggerTime;
eventNumber=header->eventNumber;
Long64_t bestEntry = adu5PatTree->GetEntryNumberWithBestIndex(header->triggerTime);
if(bestEntry>-1)
adu5PatTree->GetEntry(bestEntry);
else
continue;
balloonLat=pat->latitude;
balloonLon=pat->longitude;
balloonAlt=pat->altitude;
heading=pat->heading;
pat->pitch=0.64;
pat->roll=0.14;
pitch=pat->pitch;
roll=pat->roll;
UsefulAdu5Pat usefulPat(pat);
for(corInd=0;corInd<19;corInd++) {
firstAnt=corSum->firstAnt[corInd];
secondAnt=corSum->secondAnt[corInd];
//replace taylor dome
usefulPat.fSourceLongitude=0;
// deltaTExpected=usefulPat.getDeltaTTaylor(corSum->firstAnt[corInd],corSum->secondAnt[corInd]);
deltaTExpected=usefulPat.getDeltaTTaylorOpt(corSum->firstAnt[corInd],corSum->secondAnt[corInd],deltaR,deltaZ,deltaPhi);
deltaT=corSum->maxCorTimes[corInd];
maxAnt=corSum->centreAntenna;
phiWave=usefulPat.getPhiWave()*TMath::RadToDeg();
phiMaxAnt=fGeomTool->getAntPhiPositionRelToAftFore(corSum->centreAntenna)*TMath::RadToDeg();
corPeak=corSum->maxCorVals[corInd];
corRMS=corSum->rmsCorVals[corInd];
if((deltaT - deltaTExpected)*(deltaT - deltaTExpected) < 1 && (corPeak/corRMS)>8 ){
phiAngle[0].push_back(phiWave);
deltaTVec[0].push_back(deltaT - deltaTExpected + deltaTArrayMod[firstAnt] - deltaTArrayMod[secondAnt]);
firstAntVec[0].push_back(firstAnt);
secondAntVec[0].push_back(secondAnt);
}
}
counter++;
}
double deltaTArray[40][3000] = {{0}};
double phiAngleArray[40][3000]= {{0}};
double deltaTArrayCut[40][3000]= {{0}};
double phiAngleArrayCut[40][3000]= {{0}};
int whichCut[40][3000] = {{0}};
int middleAnt;
int leftAnt,rightAnt;
int countArray[40] = {0};
//fill arrays
//for(int ants = par[0]; ants < par[0]+1; ants++){
for(int ants = 0; ants < 32; ants++){
double lower = meanPhi[ants] - 20;
double upper = meanPhi[ants] + 10;
// double lower = 0;
// double upper = 360;
if(ants<8){
lower = lower;
upper=upper;
if(lower < 0){
lower = 0;
upper = 20;
}
if(upper > 360){
lower = 330;
upper = 360;
}
}else if(ants<16){
lower = lower;
upper= upper;
if(lower < 0){
lower = 330;
upper = 355;
}
if(upper > 360){
lower = 330;
upper = 360;
}
}
int count = 0;
int count2 = 0;
count3 = 0;
double sumPhi = 0;
bool true1 = false;
bool true2 = false;
if(ants <32){
fGeomTool->getThetaPartners(ants,leftAnt,rightAnt);
}else{
leftAnt = ants;
rightAnt = ants +1;
if(ants == 39){
leftAnt = ants;
rightAnt = 32;
}
}
for(int events = 1; events < phiAngle[0].size(); events++){
int firstAntTemp = (int)firstAntVec[0][events];
int secondAntTemp = (int)secondAntVec[0][events];
int rightTemp = int(rightAnt);
int aboveTemp = 0;
if(ants <16){
aboveTemp = lowerAntFromUpper[ants];
}else{
aboveTemp = upperAntNums[ants-16];
}
if(firstAntTemp < 32){
if( ((firstAntTemp == ants) && (secondAntTemp == rightTemp))){
//if((firstAntTemp == ants) && (secondAntTemp == rightTemp)){
if((phiAngle[0][events] > lower ) && (phiAngle[0][events]< upper)){
deltaTArray[ants][count] = deltaTVec[0][events];
phiAngleArray[ants][count] = phiAngle[0][events];
whichCut[ants][count] = 1;
count++;
}
} else if(((firstAntTemp == ants) && (secondAntTemp == aboveTemp))){
// //if((firstAntTemp == ants) && (secondAntTemp == rightTemp)){
double lower = meanPhi[ants] - 20;
double upper = meanPhi[ants] + 10;
// double lower = 0;
// double upper = 360;
if(ants<8){
lower = lower;
upper=upper;
if(lower < 0){
lower = 0;
upper = 20;
}
if(upper > 360){
lower = 330;
upper = 360;
}
}else if(ants<16){
lower = lower - 45;
upper= upper - 45;
if(lower < 0){
lower = 330;
upper = 355;
}
if(upper > 360){
lower = 330;
upper = 360;
}
}
// if((phiAngleArray[ants][events] > lower ) && (phiAngleArray[ants][events]< upper)){
if((phiAngle[0][events] > lower ) && (phiAngle[0][events]< upper)){
deltaTArray[ants][count] = deltaTVec[0][events];
phiAngleArray[ants][count] = phiAngle[0][events];
whichCut[ants][count] = 0;
count++;
}
}
}else{
rightTemp = firstAntTemp+1;
if(rightTemp>39){
rightTemp = 32;
}
if(firstAntTemp == ants){
}
if((firstAntTemp == ants) && (secondAntTemp == rightTemp)){
deltaTArray[ants][count] = deltaTVec[0][events];
phiAngleArray[ants][count] = phiAngle[0][events];
whichCut[ants][count] = 3;
count++;
}
}
}
countArray[ants] = count;
}
//make cuts
for(int ants = 0; ants < 32; ants++){
count3 = 0;
if(ants <32){
fGeomTool->getThetaPartners(ants,leftAnt,rightAnt);
}else{
leftAnt = ants -1;
rightAnt = ants +1;
if(ants == 39){
leftAnt = ants - 1;
rightAnt = 32;
}
}
double sumPhi = 0;
double lower = meanPhi[ants] - 20;
double upper = meanPhi[ants] + 10;
// double lower = 0;
// double upper = 360;
if(ants<8){
lower = lower;
upper=upper;
if(lower < 0){
lower = 0;
upper = 20;
}
if(upper > 360){
lower = 330;
upper = 360;
}
}else if(ants<16){
lower = lower;
upper= upper;
if(lower < 0){
lower = 330;
upper = 355;
}
if(upper > 360){
lower = 330;
upper = 360;
}
}
for(int events = 0; events < countArray[ants]; events++){
// if(whichCut[ants][events]==1){
// lower = meanPhi[ants] - 20;
// upper = meanPhi[ants] + 20;
// if(lower < 0){
// lower = 0;
// upper = 20;
// }
// if(upper > 360){
// lower = 330;
// upper = 360;
// }
// }
// if((phiAngleArray[ants][events] > lower ) && (phiAngleArray[ants][events]< upper)){
phiAngleArrayCut[ants][count3] = phiAngleArray[ants][events];
deltaTArrayCut[ants][count3] = deltaTArray[ants][events];
count3++;
// }
}
for(int events = 0; events < count3-1; events++){
phiAngleArray2[ants].push_back(phiAngleArrayCut[ants][events]);
deltaTArray2[ants].push_back(deltaTArrayCut[ants][events]);
}
}
delete event;
delete hk;
delete header;
delete pat;
delete corSum;
delete fpHead;
delete fpGps ;
delete fpCor;
}
sumMean = 0;
sumMean2 = 0;
sumGrads = 0;
for(int ants = 0; ants < 32; ants++){
count8 = 0;
for(int events = 1; events < phiAngleArray2[ants].size(); events++){
if( deltaTArrayLoop[count8]<1){
deltaTArrayLoop[count8] = deltaTArray2[ants][events];
phiAngleArrayLoop[count8] = phiAngleArray2[ants][events];
count8++;
}
}
if(count8==0){
tempAntGraph = new TGraph(1, dummyArray[ants], dummyArray[ants]);
}else{
tempAntGraph = new TGraph(count8-1, phiAngleArrayLoop, deltaTArrayLoop);
if(ants == 7){
canSurf->cd(1);
tempAntGraph->SetMinimum(-0.5);
tempAntGraph->SetMaximum(0.5);
tempAntGraph->Draw("ap");
tempAntGraph->SetMarkerStyle(1);
tempAntGraph->GetXaxis()->SetLimits(0,360);
sumMean = sumMean + tempAntGraph->GetMean(2)*tempAntGraph->GetMean(2);
if(ants == 8 || ants == 16 || ants == 12 || ants == 24){
tempAntGraph->SetMarkerColor(8);
}
if(ants == 3 || ants == 7 || ants == 23 || ants == 31){
tempAntGraph->SetMarkerColor(1);
}
if(ants == 9 || ants == 13 || ants == 18 || ants == 26){
tempAntGraph->SetMarkerColor(2);
}
if(ants == 10 || ants == 14 || ants == 20 || ants == 28){
tempAntGraph->SetMarkerColor(3);
}
if(ants == 11 || ants == 15 || ants == 22 || ants == 30){
tempAntGraph->SetMarkerColor(4);
}
if(ants == 0 || ants == 4 || ants == 17 || ants == 25){
tempAntGraph->SetMarkerColor(5);
}
if(ants == 2 || ants == 6 || ants == 21 || ants == 29){
tempAntGraph->SetMarkerColor(6);
}
if(ants == 1 || ants == 5 || ants == 19 || ants == 27){
tempAntGraph->SetMarkerColor(7);
}
tempAntGraph->GetXaxis()->SetTitle("phi (degrees)");
tempAntGraph->GetYaxis()->SetTitle("actual - expected time");
myMG2->Add(tempAntGraph);
myMG2->Draw("p");
vector<double> myFit = leastSquares(phiAngleArrayLoop, deltaTArrayLoop, count8-1);
double slope = myFit[0];
double intercept = myFit[1];
double tempX[2] = {slope*(meanPhi[ants]-20)+intercept,slope*(meanPhi[ants]+20)+intercept};
double tempY[2] = {(meanPhi[ants]-20),(meanPhi[ants]+20)};
sumGrads = sumGrads + myFit[0]*myFit[0]*10000;
}
}
}
cout << " " << endl;
cout << sumMean << " " << sumGrads <<endl;
canSurf->Update();
cout << " " << endl;
theReturn = sumMean+sumGrads;
return theReturn;
}
void L1PrescalesSimulator::run(int nevs) {
cout << "Start..." << endl;
lumiSectTimeNs_ = 23.31;
l_ = new TLegend(0.6, 0.7, 0.85, 0.9);
Hbits_ = new TH1D("Hbits","",192,0.,192.);
Hbits2_ = new TH1D("Hbits2","",192,0.,192.);
gStyle->SetOptTitle(kFALSE);
Hbits_->SetTitle("");
Hbits_->GetXaxis()->SetTitle("Bit");
Hbits2_->SetTitle("");
Hbits2_->GetXaxis()->SetTitle("Bit");
// clear buffers
lumiSec2Lumi_.clear();
lumiSec2rate_.clear();
lumiSec2ratePrescaled_.clear();
rateVecs_.clear();
bit2prescale_.clear();
bxMultiplicatorVec_.clear();
lumiVec_.ResizeTo(0);
bitMaskVec_.clear();
cout << "Open config file: " << tb_.getMacroDir()
<< "conf/PrescalesSimulator.conf" << endl;
tb_.readConfigFile(tb_.getMacroDir() + "conf/PrescalesSimulator.conf",
parameterMap_);
// fill parameters
numberOfBunches_ = toolbox::convertFromString<int>(parameterMap_["nOfBunches"]);
commonPrescale_ = toolbox::convertFromString<int>(parameterMap_["commonPrescale"]);
xMin_ = toolbox::convertFromString<float>(parameterMap_["xMin"]);
xMax_ = toolbox::convertFromString<float>(parameterMap_["xMax"]);
xFitMin_ = toolbox::convertFromString<float>(parameterMap_["xFitMin"]);
xFitMax_ = toolbox::convertFromString<float>(parameterMap_["xFitMax"]);
yMax_ = toolbox::convertFromString<int>(parameterMap_["yMax"]);
int tmp = 1;
std::map<string, string>::iterator itr;
do {
ostringstream oss;
oss << tmp;
itr = parameterMap_.find(oss.str());
if (itr != parameterMap_.end())
bxMultiplicatorVec_.push_back(toolbox::convertFromString<float>(itr->second));
tmp++;
} while (itr != parameterMap_.end());
tmp = 1;
tb_.readConfigFile(tb_.getMacroDir() + "conf/bitmasks.dat", parameterMap_);
cout << "Bit masks: " << endl;
do {
ostringstream oss;
oss << "m" << tmp;
itr = parameterMap_.find(oss.str());
if (itr != parameterMap_.end()) {
cout << (itr->second) << endl;
bitMaskVec_.push_back(toolbox::convertFromString<ULong64_t>(itr->second, 16));
}
tmp++;
} while (itr != parameterMap_.end());
// original luminosity and prescaled luminosity + bx multiplicator
nOfPlots_ = 2 + bxMultiplicatorVec_.size();
if (nevs) {
hreset();
getPrescales();
getLuminosities();
loop(bit2prescale_);
}
TCanvas* c2 = new TCanvas("c2", "", 900, 700);
c2->GetEvent();
Hbits_->Draw();
Hbits2_->SetLineColor(2);
Hbits2_->Draw("same");
// draw the graphs
TCanvas* c1 = new TCanvas("c1", "", 900, 700);
c1->SetGrid(1, 1);
TGraph* g = new TGraph(lumiVec_, rateVecs_[0]);
g->GetXaxis()->SetLimits(xMin_, xMax_);
g->GetXaxis()->SetTitle("Luminosity per bunch [10^{30} Hz/cm^{2}]");
g->GetYaxis()->SetTitle("Rate [Hz]");
g->Fit("pol2", "", "", xFitMin_, xFitMax_);
g->SetMaximum(yMax_);
g->Draw("A*");
gStyle->SetOptTitle(kFALSE);
g->SetTitle();
ostringstream buf, buf2;
buf << numberOfBunches_ << " (original rate)";
buf2 << numberOfBunches_ << "b";
l_->AddEntry(g, tb_.toCStr(buf), "l");
TGraph* g2 = new TGraph(lumiVec_, rateVecs_[1]);
g2->SetMarkerStyle(21);
g2->SetLineColor(2);
g2->Fit("pol2", "", "", xFitMin_, xFitMax_);
TF1* fitFkt = g2->GetFunction("pol2");
fitFkt->SetLineColor(2);
l_->AddEntry(g2, tb_.toCStr(buf2), "l");
g2->Draw("*");
addGraphsForSimulatedNOfBx();
l_->Draw();
}
int main(int argc, char *argv[])
{
FILE *fp;
RawDataPacket r;
//char *filename;
unsigned char buf[1024*1024];
int n;
//if (argc != 2) {
// usage();
// exit(1);
//}
//filename = argv[1];
//fp = fopen(filename, "r");
//if (fp == NULL) {
//err(1, "fopen for %s", filename);
//}
fp = stdin;
TApplication theApp("name", &argc, argv);
TCanvas *c1 = new TCanvas("c1", "C1", 800, 600);
int n_points = 1024;
int x[n_points];
int y[n_points];
//TGraph *graph = new TGraph(n_points);
TGraph *graph = new TGraph();
TText *text = new TText();
text->SetTextSize(0.05);
text->SetTextColor(kBlack);
text->SetNDC(1);
for ( ; ; ) {
n = fread(buf, 1, RawDataPacket::HEADER_SIZE, fp);
if (n == 0) {
if (feof(fp)) {
break;;
}
else if (ferror(fp)) {
exit(0);
}
}
else if (n != RawDataPacket::HEADER_SIZE) {
errx(1, "partial read %d bytes. Should be %d bytes", n, RawDataPacket::HEADER_SIZE);
}
r.set_buf(buf, n);
if (! r.is_raw_data_packet()) {
cout << "Not a RawDataPacket" << endl;
exit(1);
}
int data_length = r.get_data_length();
cout << "data_length: " << data_length << endl;
n = fread(&buf[RawDataPacket::HEADER_SIZE], 1, data_length, fp);
if (n == 0) {
if (feof(fp)) {
break;;
}
else if (ferror(fp)) {
exit(0);
}
}
else if (n != data_length) {
errx(1, "partial read %d bytes. Should be %d bytes", n, data_length);
}
int window_size = r.get_window_size();
int trigger_count = r.get_trigger_count();
//int n_ch = r.get_num_of_ch();
//cout << "window_size: " << window_size << endl;
//cout << "trigger_count: " << trigger_count << endl;
//for (int ch = 0; ch < n_ch; ch ++) {
// for (int w = 0; w < window_size; w++) {
// unsigned short data = r.get_data_at(ch, w);
// cout << "trg: " << trigger_count;
// cout << " ch: " << ch;
// cout << " window: " << w;
// cout << " data: " << data;
// cout << endl;
// }
//}
int ch = 0;
for (int w = 0; w < window_size; w++) {
x[w] = w;
y[w] = r.get_data_at(ch, w);
graph->SetPoint(w, x[w], y[w]);
}
graph->SetTitle(Form("Channel: %d", ch));
graph->SetMinimum(0.0);
graph->SetMaximum(4096.0);
graph->Draw("al*");
text -> DrawText(0.7, 0.92, Form("Trigger: %d", trigger_count));
c1->Update();
r.reset_buf();
usleep(500000);
}
return 0;
}