//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 auto_lednic_input_new()
{
gROOT->SetStyle("Plain");
Double_t ZR_min = 0.5;
Double_t ZR_max = 3.0;
const Int_t n = 100;
// lednic_input default values (ZT = 0.01, V = 0.001)
Double_t ZT_min = 0.001;
Double_t ZT_max = 2.0;
Double_t V_min = 0.0001;
Double_t V_max = 0.3;
Double_t x[n], y_min[n], y_max[n], step = (ZR_max - ZR_min)/n;
for (Int_t i = 0; i < n; i++) {
x[i] = ZR_min + i*step;
y_min[i] = CalcLednicR(x[i], ZT_min, V_min);
y_max[i] = CalcLednicR(x[i], ZT_max, V_max);
}
TGraph *g_min = new TGraph(n, x, y_min);
TGraph *g_max = new TGraph(n, x, y_max);
TGraph *gg = new TGraph(2*n);
for (Int_t i = 0; i < n; i++) {
gg->SetPoint(i, x[i], y_max[i]);
gg->SetPoint(n+i, x[n-i-1], y_min[n-i-1]);
}
gg->SetTitle(";r_{0} [fm];R (k = 0.02 GeV/c)");
gg->GetYaxis()->CenterTitle(); gg->SetMinimum(0); gg->SetFillStyle(3003);
gg->Draw("AF");
g_min->Draw("C");
g_max->SetLineStyle(2);
g_max->Draw("C");
TLegend *leg = new TLegend(0.50, 0.70, 0.85, 0.85);
leg->AddEntry(g_min, Form("t_{0} = %.3f fm, v = %.4fc", ZT_min, V_min), "L");
leg->AddEntry(g_max, Form("t_{0} = %.3f fm, v = %.4fc", ZT_max, V_max), "L");
leg->SetFillColor(0);
leg->Draw();
gPad->Print("pp_correl_r0.pdf");
}
void DrawResponsePlot( Float_t genMean[], Float_t genSigma[],
Float_t recoMean[], Float_t recoSigma[]) {
gROOT->ProcessLine(".L mystyle.C");
setTDRStyle();
tdrStyle->SetErrorX(0.5);
tdrStyle->SetPadLeftMargin(0.2);
tdrStyle->SetPadRightMargin(0.10);
tdrStyle->SetLegendBorderSize(0);
tdrStyle->SetTitleYOffset(1.3);
// plot full spectrum
TGraphErrors *ptbalanceGen = new TGraphErrors(nZPtBins, pt, genMean,
errpt, genSigma);
TGraphErrors *ptbalanceReco = new TGraphErrors(nZPtBins, pt, recoMean,
errpt, recoSigma);
// plot Zmumu values
Float_t ptmm[9] = { 40.0, 60.0, 100.0, 140.0, 200.0, 250.0,
330.0, 400.0, 520.0 };
Float_t balancemm[9] = { 0.496, 0.568, 0.66, 0.71, 0.75, 0.765,
0.775, 0.79, 0.81 };
TGraph *ptbalancemm = new TGraph( 9, ptmm, balancemm);
ptbalanceGen->GetXaxis()->SetTitle("p_{T}^{Z} (GeV/c)");
ptbalanceGen->GetYaxis()->SetTitle("p_{T}^{jet} / p_{T}^{Z}");
ptbalanceGen->SetMarkerStyle(22);
ptbalanceGen->SetMarkerSize(1.2);
ptbalanceGen->SetTitle("");
ptbalanceGen->SetMinimum(0.3);
ptbalanceReco->SetMarkerColor(2);
ptbalanceReco->SetLineColor(2);
ptbalanceReco->SetMarkerStyle(22);
ptbalanceReco->SetMarkerSize(1.2);
ptbalanceReco->SetMinimum(0.3);
ptbalancemm->SetMarkerStyle(24);
ptbalancemm->SetMarkerSize(1.2);
ptbalancemm->SetMinimum(0.3);
ptbalancemm->SetMarkerColor(4);
ptbalancemm->SetLineColor(4);
TCanvas c1("c1","",500,500);
ptbalanceGen->Draw("APL");
ptbalanceReco->Draw("PL");
ptbalancemm->Draw("PL");
leg_hist = new TLegend(0.6,0.7,0.89,0.89);
leg_hist->AddEntry( ptbalanceGen, "Generator level", "l");
leg_hist->AddEntry( ptbalanceReco,"Calorimeter level","l");
leg_hist->AddEntry( ptbalancemm,"Z#rightarrow#mu#mu","l");
leg_hist->SetFillColor(0);
leg_hist->Draw();
c1.SaveAs("PtBalanceVsPt.eps");
c1.SaveAs("PtBalanceVsPt.gif");
c1.SaveAs("PtBalanceVsPt.root");
c1.Close();
delete leg_hist;
delete ptbalanceGen;
delete ptbalanceReco;
delete ptbalancemm;
}
// -------------------------
// -- 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();
}
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 MUONStatusMapEvolution(const char* runlist, const char* outfile)
{
// Compute the number of bad pads (because of bad ped, bad hv, bad lv,
// or missing in configuration)
//
// output a root file with the different graphs.
//
// output can be then plotted using the DrawEvolution function
//
// Note that the output of different runlists can then be merged simply using
// the hadd program, and so then the DrawEvolution can be used over
// a huge period, e.g. a full year, while this method is better restricted
// to a period or even less (depending on your success of accessing the OCDB)
//
std::vector<int> runs;
ReadIntegers(runlist,runs);
if ( runs.empty() )
{
cout << "No runs to process..." << endl;
return;
}
int year(2016);
if ( runs[0] <= 139699 ) year=2010;
if ( runs[0] <= 176000 ) year=2011;
if ( runs[0] <= 195344 ) year = 2012;
if ( runs[0] <= 198000 ) year = 2013;
if ( runs[0] <= 246994 ) year = 2015;
TString defaultOCDB;
defaultOCDB.Form("local:///cvmfs/alice-ocdb.cern.ch/calibration/data/%d/OCDB",year);
// defaultOCDB.Form("alien://folder=/alice/data/%d/OCDB?cacheFold=/local/cdb",year);
AliCDBManager::Instance()->SetDefaultStorage(defaultOCDB.Data());
AliCDBManager::Instance()->SetRun(0);
TList glist;
glist.SetOwner(kTRUE);
TGraph* gnbad = new TGraph(runs.size());
gnbad->SetName("nbad");
glist.Add(gnbad);
TGraph* gnbadped = new TGraph(runs.size());
gnbadped->SetName("nbadped");
glist.Add(gnbadped);
TGraph* gnbadocc = new TGraph(runs.size());
gnbadocc->SetName("nbadocc");
glist.Add(gnbadocc);
TGraph* gnbadhv = new TGraph(runs.size());
gnbadhv->SetName("nbadhv");
glist.Add(gnbadhv);
TGraph* gnmissing = new TGraph(runs.size());
gnmissing->SetName("nmissing");
glist.Add(gnmissing);
TGraph* gnreco = new TGraph(runs.size());
gnreco->SetName("nreco");
glist.Add(gnreco);
TGraph* gnbadlv = new TGraph(runs.size());
gnbadlv->SetName("nbadlv");
glist.Add(gnbadlv);
for ( std::vector<int>::size_type i = 0; i < runs.size(); ++i )
{
Int_t runNumber = runs[i];
Int_t nbadped;
Int_t nbadhv;
Int_t nbadlv;
Int_t nbadocc;
Int_t nmissing;
Int_t nreco;
Int_t nbad = GetBadChannels(runNumber,nbadped,nbadhv,nbadlv,nbadocc,nmissing,nreco);
gnbad->SetPoint(i,runNumber,nbad);
gnbadped->SetPoint(i,runNumber,nbadped);
gnbadhv->SetPoint(i,runNumber,nbadhv);
gnbadlv->SetPoint(i,runNumber,nbadlv);
gnbadocc->SetPoint(i,runNumber,nbadocc);
gnmissing->SetPoint(i,runNumber,nmissing);
gnreco->SetPoint(i,runNumber,nreco);
}
TIter next(&glist);
TGraph* g;
Int_t index(0);
TFile f(outfile,"recreate");
Int_t color[] = { 1 , 2 , 3 , 4, 6, 8, 7 };
Int_t marker[] = { 28 , 24 , 23 , 26, 30, 5, 32 };
while ( ( g = static_cast<TGraph*>(next() ) ) )
{
g->GetXaxis()->SetNdivisions(505);
g->GetXaxis()->SetNoExponent();
g->SetMinimum(0);
g->GetYaxis()->SetNoExponent();
g->SetLineColor(color[index]);
g->SetMarkerStyle(marker[index]);
g->SetMarkerColor(color[index]);
g->SetMarkerSize(1.0);
++index;
g->Write();
}
f.Close();
}
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 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");
}
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 AnalysisSparse(Bool_t save_output = kFALSE)
{
gStyle->SetGridColor(kGray);
// TString tmpstr(fname);
// if (tmpstr.Contains("data")) {
// Printf("!!! Real Data !!!");
// mc = kFALSE;
// }
TString gtitle = Form("Monte Carlo, %s", graph_name.Data());
grapht = graph_name.Data();
Double_t grx[999], gry[999], gry2[999], gry3[999], gry4[999],
gry_eff[999], gry_fix[999], grxE[999];
Double_t gry22[999], gry22E[999], grx22E[999];
Double_t gry_true[999], gry_true_eff[999], gry_true_effE[999];
TH1::AddDirectory(kFALSE);
TFile::SetCacheFileDir(gSystem->HomeDirectory());
TFile *f = TFile::Open(fname.Data(), "CACHEREAD");
if (!f) return;
TList *l; f->GetObject(lname.Data(), l);
if (!l) return;
Int_t bf[999], bl[999];
Int_t nn = FindExactRange(((THnSparse *)(l->FindObject(s1name.Data())))->
Projection(1), del_step, bf, bl);
// Int_t nn = FindRange5(bf, bl);
Bool_t binhaluska = kFALSE;
if (binAnders) {
nn = 8;
bf[0] = 6;bf[1] = 9;bf[2] = 11;bf[3] = 16;bf[4] = 21;bf[5] = 26;
bl[0] = 8;bl[1] = 10;bl[2] = 15;bl[3] = 20;bl[4] = 25;bl[5] = 30;
bf[6] = 31;bf[7] = 41;
bl[6] = 40;bl[7] = 50;
}
Printf("number of intervals = %d =>", nn);
Int_t count = 0;
Double_t ptmean = 0, value = 0;
Int_t fitStatus = -1;
gStyle->SetOptStat(0);
TCanvas *c = new TCanvas("c", "Signal & Background");
c->Divide(5, 5); c->Modified(); c->Draw();
TCanvas *c2 = (TCanvas *)c->DrawClone("c2");
c2->SetTitle("Phi mesons (raw)"); c2->Modified(); c2->Draw();
TCanvas *c3, *c4;
if (mc) {
c3 = (TCanvas *)c->DrawClone("c3");
c3->SetTitle("Phi mesons (gen)"); c3->Modified(); c3->Draw();
c4 = (TCanvas *)c->DrawClone("c4");
c4->SetTitle("Phi mesons (true)"); c4->Modified(); c4->Draw();
}
for (Int_t i = 0; i < nn; i++) {
c->cd(count + 1)->SetGrid();
h1 = (TH1D *)PullHisto(l, s1name.Data(), bf[i], bl[i], ptmean);
h1->SetLineColor(kRed);
h1->GetXaxis()->SetTitle("inv. mass, GeV/c^2");
h1->Draw("hist");
h3_p = (TH1D *)PullHisto(l, s3name_p.Data(), bf[i], bl[i], ptmean);
h3_m = (TH1D *)PullHisto(l, s3name_m.Data(), bf[i], bl[i], ptmean);
// !!!!!!!!!!!!!!!!!!!!!!!!
if (count==0) h3_p = h1;
// !!!!!!!!!!!!!!!!!!!!!!!!
else {
h3_p->Add(h3_m);
// h3_p->Add((TH1D *)PullHisto(l, smix.Data(), bf[i], bl[i], ptmean));
// h3_p->Add((TH1D *)PullHisto(l, smixpp.Data(), bf[i], bl[i], ptmean));
// h3_p->Add((TH1D *)PullHisto(l, smixmm.Data(), bf[i], bl[i], ptmean));
Norm(h1, h3_p, norm[0], norm[1]);
}
h3_p->SetLineColor(kBlue);
h3_p->Draw("hist, same");
if (mc) {
c3->cd(count + 1)->SetGrid();
Printf("%s", s1namegen.Data());
hg = (TH1D *)PullHisto(l, s1namegen.Data(), bf[i], bl[i], ptmean);
hg->SetLineColor(kMagenta);
hg->GetXaxis()->SetTitle("inv. mass, GeV/c^2");
hg->Draw("hist");
c4->cd(count + 1)->SetGrid();
ht = (TH1D *)PullHisto(l, s1nametrue.Data(), bf[i], bl[i], ptmean);
ht->SetLineColor(kMagenta-5);
ht->GetXaxis()->SetTitle("inv. mass, GeV/c^2");
ht->Draw("hist");
}
c2->cd(count + 1)->SetGrid();
TH1 *hh = (TH1 *)h1->Clone("hh");
hh->SetLineColor(kRed+1);
hh->Add(h3_p, -1);
/// !!!!!!!!!!!!!!!!!!!!!!
////////// if ((ilist == 3) && (count < 2)) hh->Reset();
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!
hh->Draw("hist");
// !!!!!!!!!!!!!!!!!!
ff->SetParameters(0.1, 1.02, 0.004, -25000., 0., 0., 0.);
ff->SetLineColor(hh->GetLineColor());
ff->SetLineWidth(1);
// ff->SetLineStyle(kDashed);
// where fit
Double_t fmin = 1.02-2*0.004;
Double_t fmax = 1.02+2*0.004;
// Double_t fmin = 0.995;
// Double_t fmax = 1.185;
// !!!!!!!!!!!!!!!!!!
Bool_t hisfun = kFALSE; // kFALSE = integral from function
Double_t hisfun_k = 1.0/hh->GetBinWidth(10);
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
if (binhaluska)
if (i > 9) hisfun_k = 0.5/hh->GetBinWidth(10);
Printf("======= %f", hisfun_k);
// !!!!!!!!!!!!!!!!!!
// wehere integral (his or fun)
Double_t fmini = 1.02-2*0.004;
Double_t fmaxi = 1.02+2*0.004;
hh->Fit(ff, "Q", "", fmin, fmax);
hh->Fit(ff, "Q", "", fmin, fmax);
fitStatus = hh->Fit(ff, "Q", "", fmin, fmax);
TF1 *pp3 = new TF1("pp3", "[0]+x*[1]+x*x*[2]+x*x*x*[3]", fmin, fmax);
pp3->SetParameters(ff->GetParameter(3), ff->GetParameter(4),
ff->GetParameter(5), ff->GetParameter(6));
pp3->SetLineWidth(1);
pp3->SetLineColor(h3_p->GetLineColor());
pp3->Draw("same");
// ff->SetRange(fmin, fmax);
// ff->DrawCopy("same");
value = hh->Integral(hh->FindBin(fmini), hh->FindBin(fmaxi));
if (!hisfun) value = ff->Integral(fmini, fmaxi)*hisfun_k -
pp3->Integral(fmini, fmaxi)*hisfun_k;
if (value < 0) value = 0;
if ((fitStatus != 0) || (ff->GetParameter(2) > 0.1)) {
printf(" SKIP Data");
value = 0;
}
grx[count] = ptmean;
if (binhaluska) {
if (count < 10) grxE[count] = 0.25; // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
else grxE[count] = 0.50; // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
}
else
// grxE[count] = (1.30-1.10)/2.0; // !!!!!!!!!!!!!!!!!!!!!!!!!!
grxE[count] = 0.05;
gry[count] = value;
Double_t tmp1 = h1->Integral(h1->FindBin(fmini), h1->FindBin(fmaxi));
Double_t tmp2 = h3_p->Integral(h3_p->FindBin(fmini), h3_p->FindBin(fmaxi));
Double_t tmp_sg = tmp1 - tmp2;
Double_t tmp_bg = tmp2;
// if ((tmp_sg <= -tmp_bg) || (tmp_bg < 33.0)) {
// gry3[count] = 0.0;
// gry4[count] = 0.0;
// }
// else {
gry3[count] = tmp_sg/tmp_bg;
gry4[count] = tmp_sg/TMath::Sqrt(tmp_sg + tmp_bg);
// }
// Printf("%4.2f, %10f, %10f, %10f", ptmean, tmp1, tmp2, gry3[count]);
if (mc) {
c3->cd(count + 1);
// !!!!!!!!!!!!!!!!
ff->SetParameters(1, 1.02, 0.004, 0., 0., 0., 0.);
hg->Fit(ff, "Q", "", fmin, fmax);
hg->Fit(ff, "Q", "", fmin, fmax);
fitStatus = hg->Fit(ff, "Q", "", fmin, fmax);
/* TF1 *pp3 = new TF1("pp3", "[0]+x*[1]+x*x*[2]+x*x*x*[3]", fmin, fmax);
pp3->SetParameters(ff->GetParameter(3), ff->GetParameter(4),
ff->GetParameter(5), ff->GetParameter(6));
pp3->SetLineWidth(1);
pp3->SetLineColor(h3_p->GetLineColor());
pp3->Draw("same");
*/
value = hg->Integral(hg->FindBin(fmini), hg->FindBin(fmaxi));
if (!hisfun) value = ff->Integral(fmini, fmaxi)*hisfun_k;
//!!!!!!!!!!!!!!!!!!!pp3->Integral(fmini, fmaxi)*hisfun_k;
if (value <= 0) value = -1;
if ((fitStatus != 0) || (ff->GetParameter(2) > 0.1)) {
printf(" SKIP MC");
value = -1;
}
gry2[count] = value;
Double_t superfactor = CalculateFactor(l, 0.1);
if (useCF) {
gry22E[i] = TMath::Sqrt(gry2[i])*superfactor;
// gry22E[i] = 0.0001;
gry22[i] = gry2[i]*superfactor;
grx22E[i] = 0.05;
}
gry_eff[count] = gry[count]/gry2[count];
c4->cd(count + 1);
// !!!!!!!!!!!!!!!!
ff->SetParameters(1, 1.02, 0.004, 0., 0., 0., 0.);
ht->Fit(ff, "Q", "", fmin, fmax);
ht->Fit(ff, "Q", "", fmin, fmax);
fitStatus = ht->Fit(ff, "Q", "", fmin, fmax);
/* TF1 *pp3 = new TF1("pp3", "[0]+x*[1]+x*x*[2]+x*x*x*[3]", fmin, fmax);
pp3->SetParameters(ff->GetParameter(3), ff->GetParameter(4),
ff->GetParameter(5), ff->GetParameter(6));
pp3->SetLineWidth(1);
pp3->SetLineColor(h3_p->GetLineColor());
pp3->Draw("same");
*/
value = ht->Integral(ht->FindBin(fmini), ht->FindBin(fmaxi));
if (!hisfun) value = ff->Integral(fmini, fmaxi)*hisfun_k;
//!!!!!!!!!!!!!!!!!!!pp3->Integral(fmini, fmaxi)*hisfun_k;
if (value <= 0) value = -1;
if ((fitStatus != 0) || (ff->GetParameter(2) > 0.1)) {
printf(" SKIP true");
value = -1;
}
gry_true[count] = value;
gry_true_eff[count] = gry_true[count]/gry2[count];
// Propagation of uncertainty (A/B)
Double_t AAA = gry_true[count];
Double_t AAAE = TMath::Sqrt(AAA);
Double_t BBB = gry2[count];
Double_t BBBE = TMath::Sqrt(BBB);
Double_t EEE = TMath::Sqrt((AAAE/AAA)*(AAAE/AAA)+(BBBE/BBB)*(BBBE/BBB));
EEE = EEE*gry_true_eff[count];
gry_true_effE[count] = EEE;
}
Printf("=> %6.4f", ptmean);
count++;
}
new TCanvas();
TGraph *gr = new TGraph(count, grx, gry);
gr->SetMarkerStyle(8);
gr->SetMarkerColor(hh->GetLineColor());
gr->GetXaxis()->SetTitle("p_{t}, GeV/c");
gr->SetTitle(Form("raw phi, %s", gtitle.Data()));
gr->Draw("AP");
cc3 = new TCanvas();
TGraph *gr3 = new TGraph(count, grx, gry3);
gr3->SetMarkerStyle(22);
gr3->SetMarkerColor(kBlue+1);
gr3->GetXaxis()->SetTitle("p_{t}, GeV/c");
gr3->SetTitle(Form("SIG / BKG, %s", gtitle.Data()));
gr3->SetMinimum(0);
gr3->Draw("AP");
cc4 = new TCanvas();
TGraph *gr4 = new TGraph(count, grx, gry4);
gr4->SetMarkerStyle(23);
gr4->SetMarkerColor(kBlue-1);
gr4->GetXaxis()->SetTitle("p_{t}, GeV/c");
gr4->SetTitle(Form("Significance, %s", gtitle.Data()));
gr4->SetMinimum(0);
gr4->Draw("AP");
ccc = new TCanvas("ccc","ccc",0,0,900,300);
ccc->Divide(2, 1, 0.001, 0.001);
ccc->cd(1); gr3->Draw("AP");
ccc->cd(2); gr4->Draw("AP");
TString blabla = "mc";
if (!mc) blabla = "data";
// gr3->SaveAs(Form("SB_%s_%s.C", blabla.Data(), grapht.Data()));
// gr4->SaveAs(Form("Sig_%s_%s.C", blabla.Data(), grapht.Data()));
// ccc->SaveAs(Form("%s_%s_2.eps", blabla.Data(), grapht.Data()));
// c->SaveAs(Form("%s_%s_0.eps", blabla.Data(), grapht.Data()));
// c2->SaveAs(Form("%s_%s_1.eps", blabla.Data(), grapht.Data()));
// cc3->SaveAs(Form("%s_%s_2.eps", blabla.Data(), grapht.Data()));
// gr3->SaveAs(Form("sig_bck_%s_%s.C", blabla.Data(), grapht.Data()));
if (mc) {
new TCanvas();
TGraph *gr2 = new TGraph(count, grx, gry2);
gr2->SetMarkerStyle(8);
gr2->SetMarkerColor(hg->GetLineColor());
gr2->GetXaxis()->SetTitle("p_{t}, GeV/c");
gr2->SetTitle(Form("gen phi, %s", gtitle.Data()));
gr2->Draw("AP");
new TCanvas();
TGraphErrors *gr22 = new TGraphErrors(count, grx, gry22, grx22E, gry22E);
gr22->SetMarkerStyle(8);
gr22->SetMarkerColor(kCyan);
gr22->GetXaxis()->SetTitle("p_{t}, GeV/c");
gr22->SetTitle(Form("gen phi, %s", gtitle.Data()));
gr22->Draw("AP");
c = new TCanvas();
c->SetGrid();
TGraph *gr_e = new TGraph(count, grx, gry_eff);
gr_e->SetMarkerStyle(22);
gr_e->SetMarkerColor(kBlack);
gr_e->GetXaxis()->SetTitle("p_{t}, GeV/c");
gr_e->SetTitle(Form("efficiency (raw), %s", grapht.Data()));
gr_e->Draw("AP");
Printf("Save as '\033[1meffi_raw_%s\033[0m' file", grapht.Data());
for (Int_t i = 0; i < gr_e->GetN(); i++)
Printf("%f %f", gr_e->GetX()[i], gr_e->GetY()[i]);
cvb = new TCanvas();
cvb->cd();
TGraph *gr_true = new TGraph(count, grx, gry_true);
gr_true->SetMarkerStyle(8);
gr_true->SetMarkerColor(ht->GetLineColor());
gr_true->GetXaxis()->SetTitle("p_{t}, GeV/c");
gr_true->SetTitle(Form("true phi, %s", gtitle.Data()));
gr_true->Draw("AP");
c = new TCanvas();
c->cd();
c->SetGrid();
TGraphErrors *gr_true_eff = new TGraphErrors(count, grx, gry_true_eff,
grxE, gry_true_effE);
gr_true_eff->SetMarkerStyle(20);
// gr_true_eff->SetMarkerSize(0.75);
gr_true_eff->SetMarkerColor(kBlack);
gr_true_eff->GetXaxis()->SetTitle("p_{t}, GeV/c");
gr_true_eff->SetTitle(Form("efficiency (true), %s", grapht.Data()));
gr_true_eff->Draw("AEP");
m_gr->Add(gr_true_eff);
Printf("Save as '\033[1meffi_true_%s\033[0m' file", grapht.Data());
TString tout;
Double_t oux, ouy, ouxe, ouye;
for (Int_t i = 0; i < gr_true_eff->GetN(); i++) {
oux = gr_true_eff->GetX()[i];
ouy = gr_true_eff->GetY()[i];
ouy = MinusCheck(ouy);
ouxe = gr_true_eff->GetErrorX(i);
ouye = gr_true_eff->GetErrorY(i);
ouye = NanCheck(ouye);
Printf("%f %f %f %f", gr_true_eff->GetX()[i], gr_true_eff->GetY()[i],
gr_true_eff->GetErrorX(i), gr_true_eff->GetErrorY(i));
if (!save_output) continue;
gSystem->mkdir(dir_prefix.Data());
tout = Form("%f %f %f %f", oux, ouy, ouxe, ouye);
if (i == 0)
tout = Form("Printf(\"%s\"); > %s/effi_%s", tout.Data(),
dir_prefix.Data(), grapht.Data());
else
tout = Form("Printf(\"%s\"); >> %s/effi_%s", tout.Data(),
dir_prefix.Data(), grapht.Data());
// Printf(":::::: %s", tout.Data());
gROOT->ProcessLine(tout.Data());
}
// ------------------
c = new TCanvas("cfinal", "mc_effi", 1200, 450);
c->Divide(2, 1, 0.001, 0.001); c->Modified(); c->Draw();
c->cd(1);
gr_true->SetMinimum(0);
gr_true->SetTitle(Form("phi (true & raw), %s", gtitle.Data()));
gr_true->SetMarkerColor(kGreen+1);
gr_true->Draw("AP");
gr->SetMarkerColor(kRed+1);
gr->Draw("P");
c->cd(2)->SetGrid();
gr_true_eff->SetMinimum(0);
gr_true_eff->SetTitle(Form("efficiency, %s", grapht.Data()));
gr_true_eff->SetMarkerColor(kGreen+1);
gr_true_eff->Draw("AP");
gr_e->SetMarkerColor(kRed+1);
gr_e->Draw("P");
// c->SaveAs(Form("%s_%s.eps", blabla.Data(), grapht.Data()));
return;
}
// TGraph *geff = new TGraph(Form("effi_raw_%s", grapht.Data()));
// TGraph *geff = new TGraph(Form("effi_true_%s", grapht.Data()));
// TGraph *geff = new TGraph("effi_true_Phi2010_qualityonly");
TGraph *geff = new TGraph("effi_true_PhiNsigma_qualityonly");
if (geff->IsZombie()) return;
geff->SetMarkerStyle(22);
geff->SetMarkerColor(kBlack);
geff->GetXaxis()->SetTitle("p_{t}, GeV/c");
geff->SetTitle(Form("efficiency, %s", grapht.Data()));
c = new TCanvas();
c->SetGrid();
geff->Draw("AP");
Double_t tpcsigma = 9999.9;
if (ilist == 1) tpcsigma = 1.0;
if (ilist == 2) tpcsigma = 1.5;
if (ilist == 3) tpcsigma = 2.0;
if (ilist == 4) tpcsigma = 2.5;
if (ilist == 5) tpcsigma = 3.0;
Double_t sss = TMath::Erf(tpcsigma/TMath::Sqrt(2.0));
if (noSigma) sss = 1.0;
Printf("sigma = %10f", sss);
// for (Int_t i = 0; i < count; i++)
// geff->GetY()[i] = (sss*sss)/(geff->GetY()[i]);
// geff->SetMaximum(1.0);
// geff->Draw("AP");
for (Int_t i = 0; i < count; i++) {
Double_t deno = geff->Eval(grx[i])*sss*sss;
if (deno < 0.00001) deno = 1;
gry_fix[i] = gry[i]/deno;
}
new TCanvas;
TGraph *gr_fix = new TGraph(count, grx, gry_fix);
gr_fix->SetMarkerStyle(21);
gr_fix->SetMarkerColor(hh->GetLineColor());
gr_fix->GetXaxis()->SetTitle("p_{t}, GeV/c");
gr_fix->SetTitle(Form("corrected phi * #sigma^{2}, %s", gtitle.Data()));
if (noSigma)
gr_fix->SetTitle(Form("corrected phi (no #sigma), %s", gtitle.Data()));
gr_fix->Draw("AP");
//---------------------
c = new TCanvas("cfinald", "data_correct", 1200, 450);
c->Divide(2, 1, 0.001, 0.001); c->Modified(); c->Draw();
c->cd(1);
gr->SetMinimum(0);
gr->SetMarkerColor(kBlack);
gr->Draw("AP");
c->cd(2);
gr_fix->SetMinimum(0);
gr_fix->SetMarkerColor(kGreen+3);
gr_fix->Draw("AP");
TString bla9 = Form("qualityonly_PID2_%s", grapht.Data());
if (noSigma) bla9 = Form("%s_noSig.C", bla9.Data());
else bla9 = Form("%s.C", bla9.Data());
// gr_fix->SaveAs(bla9.Data());
// TPad *cp = new TPad("cpf", "", 0.45,0.45,0.99,0.92);
TPad *cp = new TPad("cpf", "", 0.60,0.55,0.99,0.93);
cp->SetLogy(); cp->Draw(); cp->cd();
TGraph *cloneg = ((TGraph *)gr_fix->Clone());
cloneg->SetTitle(); cloneg->SetMarkerSize(0.8);
cloneg->Draw("AP");
// c->SaveAs(Form("%s_%s.eps", blabla.Data(), grapht.Data()));
f->Close();
}
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() );
}
//------------------------------------------------------------------------
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 plot_ZJetBalance(int JetAlgo) {
Float_t pt[NGenPtBins];
TString ptBin[NGenPtBins];
for(int i=0; i<NGenPtBins; i++) {
pt[i] = 0.5*( GenPt[i] + GenPt[i+1] );
ptBin[i] = Form("%d_%d", (int) GenPt[i], (int) GenPt[i+1] );
}
Float_t errpt[NGenPtBins];
Float_t genMean[NGenPtBins];
Float_t genSigma[NGenPtBins];
Float_t recoMean[NGenPtBins];
Float_t recoSigma[NGenPtBins];
TString algoSt;
if(JetAlgo==0) algoSt = "_ic5";
if(JetAlgo==1) algoSt = "_ic7";
if(JetAlgo==2) algoSt = "_mp5";
if(JetAlgo==3) algoSt = "_mp7";
if(JetAlgo==4) algoSt = "_kt6";
TString textFilename = "ZjetPtBalance" + algoSt + TString(".txt");
TString JetResponseFilename
= "Histograms_ZjetResponse" + algoSt + TString(".root");
FILE *file = fopen(textFilename,"w+");
fprintf( file ,"%s %s %s %s %s \n", "pT bin",
"genMean", "genSigma", "recoMean", "recoSigma");
TH1F* responseHistGen;
TH1F* responseHistReco;
TH1F* genJetpt;
TH1F* caloJetpt;
TH1F* Zpt;
if(storeResponsHistogramsInRootFile == true) {
TFile respHistFile(JetResponseFilename,"RECREATE");
}
for(int i=0; i<NGenPtBins; i++) {
responseHistGen = new TH1F("responseHistGen_"+ptBin[i],"", 40, 0.0, 2.0);
responseHistGen->Sumw2();
TAxis* responseHistGenx = responseHistGen->GetXaxis();
TAxis* responseHistGeny = responseHistGen->GetYaxis();
responseHistGenx->SetTitle("p_{T,Jet} / p_{T,Z} ");
responseHistGeny->SetTitle("Events / 0.05 ");
responseHistGeny->SetTitleOffset(1.2);
responseHistReco = new TH1F("responseHistReco_"+ptBin[i],"", 40, 0.0, 2.0);
responseHistReco->Sumw2();
responseHistReco->SetLineColor(2);
responseHistReco->SetMarkerColor(2);
genJetpt = new TH1F("genJetpt_"+ptBin[i],"", NGenPtBins-1, GenPt);
genJetpt->Sumw2();
caloJetpt = new TH1F("caloJetpt_"+ptBin[i],"", NGenPtBins-1, GenPt);
caloJetpt->Sumw2();
recoZpt = new TH1F("recoZpt_"+ptBin[i],"", NGenPtBins-1, GenPt);
recoZpt->Sumw2();
errpt[i] = 0.0;
genMean[i] = 0.0;
genSigma[i] = 0.0;
recoMean[i] = 0.0;
recoSigma[i] = 0.0;
plot_ZJetBalance( JetAlgo, i, *responseHistGen, *responseHistReco,
*genJetpt, *caloJetpt, *recoZpt);
genMean[i] = (Float_t) responseHistGen->GetMean(1);
genSigma[i] = (Float_t) responseHistGen->GetMean(11);
recoMean[i] = (Float_t) responseHistReco->GetMean(1);
recoSigma[i] = (Float_t) responseHistReco->GetMean(11);
if(storeResponseInTextFile == true) {
fprintf( file ,"%5.1f %5.4f %5.4f %5.4f %5.4f \n", pt[i],
genMean[i], genSigma[i], recoMean[i], recoSigma[i] );
}
if(storeResponsHistogramsInRootFile == true) {
respHistFile.cd();
responseHistGen->Write();
responseHistReco->Write();
genJetpt->Write();
caloJetpt->Write();
recoZpt->Write();
}
delete responseHistGen;
delete responseHistReco;
delete genJetpt;
delete caloJetpt;
delete recoZpt;
}
fclose(file);
respHistFile.Close();
if(makeplot_Response == true) {
// plot full spectrum
TGraphErrors *ptbalanceGen = new TGraphErrors(NGenPtBins, pt, genMean,
errpt, genSigma);
TGraphErrors *ptbalanceReco = new TGraphErrors(NGenPtBins, pt, recoMean,
errpt, recoSigma);
// plot Zmumu values
Float_t ptmm[9] = { 40.0, 60.0, 100.0, 140.0, 200.0, 250.0,
330.0, 400.0, 520.0 };
Float_t balancemm[9] = { 0.496, 0.568, 0.66, 0.71, 0.75, 0.765,
0.775, 0.79, 0.81 };
TGraph *ptbalancemm = new TGraph( 9, ptmm, balancemm);
ptbalanceGen->GetXaxis()->SetTitle("p_{T}^{Z} [GeV/c] ");
ptbalanceGen->GetYaxis()->SetTitle("p_{T}^{Jet} / p_{T}^{Z} ");
ptbalanceGen->SetMarkerStyle(22);
ptbalanceGen->SetMarkerSize(1.2);
ptbalanceGen->SetTitle("");
ptbalanceGen->SetMinimum(0.2);
ptbalanceReco->SetMarkerColor(2);
ptbalanceReco->SetLineColor(2);
ptbalanceReco->SetMarkerStyle(22);
ptbalanceReco->SetMarkerSize(1.2);
ptbalanceReco->SetMinimum(0.2);
ptbalancemm->SetMarkerStyle(24);
ptbalancemm->SetMarkerSize(1.2);
ptbalancemm->SetMinimum(0.2);
ptbalancemm->SetMarkerColor(4);
ptbalancemm->SetLineColor(4);
TCanvas c1("c1","",800,600);
c1.SetGrid();
ptbalanceGen->Draw("APL");
ptbalanceReco->Draw("PL");
ptbalancemm->Draw("PL");
leg_hist = new TLegend(0.6,0.35,0.85,0.55);
leg_hist->AddEntry( ptbalanceGen, "Generator level", "l");
leg_hist->AddEntry( ptbalanceReco,"Calorimeter level","l");
leg_hist->AddEntry( ptbalancemm,"Z#rightarrow#mu#mu","l");
leg_hist->SetFillColor(0);
leg_hist->Draw();
c1.SaveAs("PtBalanceVsPt.eps");
c1.SaveAs("PtBalanceVsPt.gif");
c1.SaveAs("PtBalanceVsPt.root");
c1.Close();
delete leg_hist;
delete ptbalanceGen;
delete ptbalanceReco;
delete ptbalancemm;
}
}
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 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");
}
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 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;
}
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;
}