double r_sig(const char* f_inner, const char* f_outer)
{
TTree *TDiIn = new TTree();
TDiIn->ReadFile(f_inner, "di/D");
TH1D *h_din = new TH1D("h_din", "", 10000, 0, 100);
TDiIn->Draw("di>>h_din", "", "goff");
Double_t d_inner = h_din->GetMean(1);
Double_t sig_inner = h_din->GetMeanError(1);
// cout << "Mean Inner Diameter: " << d_inner << " +/- " << sig_inner << endl;
// cout<< "Reading Outer Diameters..." << f_outer <<endl;
TTree *TDiOut = new TTree();
TDiOut->ReadFile(f_outer, "do/D");
TH1D *h_dout = new TH1D("h_dout", "", 10000, 0, 100);
TDiOut->Draw("do>>h_dout", "", "goff");
Double_t d_outer = h_dout->GetMean(1);
Double_t sig_outer = h_dout->GetMeanError(1);
// cout << "Mean Outer Diameter: " << d_outer << " +/- " << sig_outer << endl;
double Ratio = d_inner/d_outer;
double Sigma = Ratio*sqrt( pow((sig_inner/d_inner),2) + pow((sig_outer/d_outer),2) );
// cout << Sigma << endl;
h_din->Delete();
h_dout->Delete();
return Sigma;
}
void treegraph(TString filename) {
gROOT->SetStyle("Plain");
gStyle->SetOptDate();
Double_t x, y;
Int_t nlines = 0;
TFile *f = new TFile("graph.root","RECREATE");
TCanvas *canvas_graph = new TCanvas("canvas_graph", "y vs x",467,89,400,700);
TTree t;
t.ReadFile(filename,"x:y");
t.Draw("x:y","","goff");
TGraph *g = new TGraph(t.GetSelectedRows(),t.GetV1(),t.GetV2());
g->SetTitle(filename+": Y vs X");
g->GetXaxis()->SetTitle("x[a.u.]");
g->GetYaxis()->SetTitle("y[a.u.]");
g->SetMarkerStyle(21);
g->Draw("AP");
f->Write();
}
void histogram() {
// Read data from ASCII file and create histogram/ntuple combo
ifstream in;
in.open("/users/ronnie/git/Journal-Analysis/data.txt");
Text_t month;
Float_t date, day, words;
TFile *file = new TFile("histogramTest.root", "CREATE");
TH1F *histo = new TH1F("histo", "writing distribution", 100, 0, 2);
TTree *Tree = new TTree("ntuple", "data from file");
Tree->ReadFile(Form("/users/ronnie/git/Journal-Analysis/Daily Journals/data.txt"), "month:date:day:words");
graph = new TGraph(200, &words, &day);
// Get the total number of words written and print out to CLI
Tree->Print();
Int_t numEntries = (Int_t)(Tree->GetEntries());
TBranch *wordsBranch = Tree->GetBranch("words");
for(Int_t i = 0; i < numEntries; i++) {
Tree->GetEntry(i, 0);
}
// Draw the Tree (words vs. day) on canvas
Tree->SetEstimate(Tree->GetEntries());
Tree->Draw("words:day");
// Have to loop back through drawn tree to get values and count number of words total
Float_t numWords = 0.0;
Double_t *array = Tree->GetV1();
for (Int_t i = 0; i < numEntries; i++) {
numWords += array[i];
}
cout << numWords << endl;
}
void analyseFitToystudiesB0(string filename, bool justTau = false)
{
fileprefix = "fitToyStudiesB0";
TTree *t = new TTree;
t->ReadFile(filename.c_str(),"tau:tau_err:mass_peak:mass_peak_err:m_sigma1:m_sigma1_err:m_sigma2:m_sigma2_err:frac_m_gauss:frac_m_gauss_err:core_frac:core_frac_err:tau_bk:tau_bk_err:n_nonprompt:n_nonprompt_err:n_prompt:n_prompt_err:n_signal:n_signal_err:prompt_p1:prompt_p1_err:prompt_sigma_core:prompt_sigma_core_err:prompt_sigma_tail:prompt_sigma_tail_err");
if (!justTau)
{
plotPulls(t, "tau_pulls", "#tau(B^{0})", "tau", 1.529, 100, 5.0);
plotPulls(t, "mass_pulls", "m(B^{0})", "mass_peak", 5.27950, 100, 5.0);
plotPulls(t, "tau_bk_pulls", "#tau_{bgr}(B^{0})", "tau_bk", 0.750, 100, 5.0);
plotPulls(t, "nsig_pulls", "n_{sig}", "n_signal", 6750, 100, 5.0);
plotPulls(t, "npr_pulls", "n_{prompt}", "n_prompt", 3375, 100, 10);
plotPulls(t, "nnpr_pulls", "n_{nonprompt}", "n_nonprompt", 1125, 100, 10);
}
plotHisto(t, "tau_histo", "#tau(B^{0})", "ps", "tau", 100, 1.30, 1.70);
if (!justTau)
{
plotHisto(t, "mass_histo", "m(B^{0})", "GeV", "mass_peak", 100, 5.2785, 5.281);
plotHisto(t, "tau_bk_histo", "#tau_{bgr}(B^{0})", "ps", "tau_bk", 100, 0.5, 0.9);
plotHisto(t, "nsig_histo", "n_{sig}", "", "n_signal", 100, 6500, 7000);
plotHisto(t, "npr_histo", "n_{prompt}", "", "n_prompt", 100, 2900, 3900);
plotHisto(t, "nnpr_histo", "n_{nonprompt}", "", "n_nonprompt", 100, 950, 1450);
}
}
TGraphErrors* plot_point(
const TString infile,
double R,
double R_sig
)
{
TTree *TData = new TTree();
TData->ReadFile(infile, "t/D:x:y:z:B1:B1Range:B2:B2Range:B3:B3Range:V:T1:T2:T3:T4:T5:T6:T7:T8");
TH1D *h = new TH1D("h", "", 10000, 0, 10000);
TH1D *h2 = new TH1D("h2", "", 10000, 0, 10000);
TData->Draw("TMath::Abs(B2)>>h", "", "goff");
TData->Draw("TMath::Abs(B3)>>h2", "", "goff");
vector<double> B_ext, B_in, Bratio, u, u_err, B_err;
B_in.push_back(h2->GetMean(1));
B_ext.push_back(h->GetMean(1));
Bratio.push_back(B_in[0] / B_ext[0]);
u.push_back( (Bratio[0]*(R**2) + Bratio[0] - 2 - 2*sqrt((Bratio[0]**2)*(R**2) - Bratio[0]*(R**2) - Bratio[0] + 1 ) ) / (Bratio[0]*(R**2) - Bratio[0]) );
B_err.push_back( 0.00 );
u_err.push_back( 0.00 );
TGraphErrors *g_uvB = new TGraphErrors(u.size(), &B_ext[0], &u[0], &B_err[0], &u_err[0]);
h->Delete();
h2->Delete();
return g_uvB;
}
/*
* The Ferromagnet_Scan function reads in
* a data file of magentic field scans
* from within the ferromagnet and returns
* a graph of the magnetic permeability
* of the ferromagnet vs the external field
* provided by the Helmholtz coil.
*/
TGraphErrors* plot_uvB(
const TString scan_file,
TF1* calib_fit,
double R,
double R_sig
)
{
/*Read in Data File to ROOT Tree*/
cout<< "processing file " << scan_file <<endl;
TTree *TData = new TTree();
TData->ReadFile(scan_file, "t/D:I:B");
/*Use TTree Draw command to write branches to usable arrays*/
int n = TData->Draw("I:TMath::Abs(B):0.0:0.005", "", "goff");
vector<double> B_ext, B_in, Bratio, u;
for(int i = 0; i < n; i++)
{
B_ext.push_back( calib_fit->Eval(TData->GetV1()[i]) );
B_in.push_back( TData->GetV2()[i] );
Bratio.push_back( B_in[i] / B_ext[i]);
u.push_back( (Bratio[i]*(R**2) + Bratio[i] - 2 - 2*sqrt((Bratio[i]**2)*(R**2) - Bratio[i]*(R**2) - Bratio[i] + 1 ) ) / (Bratio[i]*(R**2) - Bratio[i]) );
}
TGraphErrors *g_uvB = new TGraphErrors(n, &B_ext[0], &u[0], TData->GetV3(), TData->GetV4());
/*
g_uvB->Fit("pol1", "", "", 10, 60);
cout << "Permeability at 50: " << g_uvB->GetFunction("pol1")->Eval(50) << endl;
cout << "Permeability at 40: " << g_uvB->GetFunction("pol1")->Eval(40) << endl;
cout << "Permeability at 30: " << g_uvB->GetFunction("pol1")->Eval(30) << endl;
*/
return g_uvB;
}
void DrawConsistency()
{
TFile * cons_file = new TFile("cons_file.root","RECREATE");
TTree * tr = new TTree();
// cons is run number or fill number, depending on what study you're doing
tr->ReadFile("cons_study","cons/I:tbit/I:cbit/I:spinbit/I:p0/D:p0_err/D");
tr->Write("tr");
}
void rads2Hist(){
TFile * output_file = new TFile("RADS_Data.root", "RECREATE"); //Pointer to ROOT output file
TH1D * hist = new TH1D("hist", "Radiation Dosimetry with Altitude", 100, 0, 10000); //1D histogram of doubles
TTree * t = new TTree("t", "RADS_Data"); //Pointer to tree to store data
t->ReadFile("RADS_long.dat", "RAD_cpm/I"); // Add integer variable to tree called RAD_cpm
t->Write(); //Write tree to ROOT file
output_file->Close();
}
void basic2() {
TString dir = gROOT->GetTutorialsDir();
dir.Append("/tree/");
dir.ReplaceAll("/./","/");
TFile *f = new TFile("basic2.root","RECREATE");
TH1F *h1 = new TH1F("h1","x distribution",100,-4,4);
TTree *T = new TTree("ntuple","data from ascii file");
Long64_t nlines = T->ReadFile(Form("%sbasic.dat",dir.Data()),"x:y:z");
printf(" found %lld points\n",nlines);
T->Draw("x","z>2");
T->Write();
}
void treeFromAscii(const char* filen) {
// Read data from an ascii file and create a root file with a tree
std::string rFile( filen ) ;
rFile += ".root" ;
TFile *f = new TFile( rFile.c_str() ,"RECREATE");
TTree* ntuple = new TTree("ntuple","") ;
ntuple->ReadFile( filen ) ;
f->Write() ;
f->Close() ;
}
int RampCorrellation_single(std::string file_name, TGraphErrors &graph, TGraphErrors &graph2, vector<double> &vec_errors)
{
TTree *t = new TTree();
const std::string file_path = "/home/jlab/github/MagCloak_Analysis/calibration/data-calib/DATA_MegaVIEW/";
// std::string file_name = "DataFile_2016-12-08_06-59-11.csv";
std::string file = file_path+file_name;
t->ReadFile(file.c_str());
// t->Print();
TCanvas *c = new TCanvas();
t->Draw("TMath::Abs(B1/B2):time");
TGraph *gh = (TGraph*)c->GetListOfPrimitives()->FindObject("Graph");
double ratio_mean = gh->GetMean(2);
double ratio_std = gh->GetRMS(2);
t->Draw("Bnom:time");
TGraph *gh1 = (TGraph*)c->GetListOfPrimitives()->FindObject("Graph");
double nom_mean = gh1->GetMean(2);
double nom_std = 0;
// cout << "At " << nom_mean << " mT, B1/B2 is: " << ratio_mean << " +/- " << ratio_std << endl;
c->Close();
int n = graph.GetN();
graph.SetPoint(n,nom_mean,ratio_mean);
graph.SetPointError(n,nom_std,ratio_std);
//-------------------------------------------------------------------------------
TCanvas *c2 = new TCanvas();
t->Draw("B3:time");
TGraph *gh2 = (TGraph*)c2->GetListOfPrimitives()->FindObject("Graph");
double B3_mean = -1*(gh2->GetMean(2));
double B3_std = gh2->GetRMS(2);
int n2 = graph2.GetN();
graph2.SetPoint(n2, nom_mean, B3_mean);
graph2.SetPointError(n2, nom_std, B3_std);
c2->Close();
if(nom_mean < 500) vec_errors.push_back(B3_std);
return 0;
}
plot_cluster_vs_run()
{
TTree *tin = new TTree();
tin->ReadFile("summaries/allruns_Run13pp510MinBias_cluster.txt","run/I:cluster/F");
TCanvas *c1 = new TCanvas();
tin->Draw("cluster");
c1->Print("plots/cluster_per_event_hist.eps");
c1->Print("plots/cluster_per_event_hist.png");
TCanvas *c2 = new TCanvas();
tin->Draw("cluster:Entry$");
c2->Print("plots/cluster_per_event_graph.eps");
c2->Print("plots/cluster_per_event_graph.png");
}
/*
* The Calibration function reads in the
* calibration file and returns a graph
* that is used to find the relation
* between current and magentic field
* for the Helmholtz coil.
*/
TF1* Calibrate(
const char* f_calib
)
{
/*Read in Calibration File*/
cout<< "processing file " << f_calib <<endl;
TTree *TCalib = new TTree();
TCalib->ReadFile(f_calib, "t/D:I:B");
int n = TCalib->Draw("I:TMath::Abs(B)", "", "goff");
TGraph *g_calib = new TGraph(n, TCalib->GetV1(), TCalib->GetV2() );
g_calib->SetTitle("");
// g_calib->Draw("AP");
g_calib->Fit("pol1", "q");
TF1* calib_fit = g_calib->GetFunction("pol1");
return calib_fit;
}
TGraphErrors* getTheoXSec(TString file) {
TTree t;
t.ReadFile(file);
TGraphErrors *g = new TGraphErrors(t.GetEntries());
float m,x,e;
t.SetBranchAddress("mass",&m);
t.SetBranchAddress("xsec",&x);
t.SetBranchAddress("err",&e);
int iEntry=-1;
while(t.GetEntry(++iEntry)) {
g->SetPoint(iEntry,m,x);
g->SetPointError(iEntry,0,e);
}
return g;
}
void PlotFromMillepedeRes(TString strMillepedeRes, TString strOutdir, TString strVars, int plotType)
{
// strPar = "u", "v", "w", "alpha", "beta", "gamma", "def1", "def2", "def3"
TFile* f = new TFile(strOutdir+TString("fOut.root"),"recreate");
TTree* tr = new TTree("tr","tr");
tr->ReadFile(strMillepedeRes,strVars);
if (plotType==PARSwithERRvsLABEL)
PlotParValVsLabelWithErr(f, tr, strMillepedeRes, strOutdir);
if (plotType==NHITS)
PlotHistsNhitsPerModule(f, tr, strMillepedeRes, strOutdir);
if (plotType==PULLS)
PlotPullsDistr(f, tr, strMillepedeRes, strOutdir);
if (plotType==PARS)
PlotParsDistr(f, tr, strMillepedeRes, strOutdir);
}// end of PlotPars
TGraphErrors* plot_ramp(
const TString scan_file,
double R,
double R_sig
)
{
/*Read in Data File to ROOT Tree*/
cout<< "processing file " << scan_file <<endl;
TTree *TData = new TTree();
TData->ReadFile(scan_file, "t/D:x:y:z:B1:B1Range:B2:B2Range:B3:B3Range:V:T1:T2:T3:T4:T5:T6:T7:T8");
/*Use TTree Draw command to write branches to usable vector*/
int n = TData->Draw("TMath::Abs(B2):TMath::Abs(B3):0.0:0.005", "", "goff");
vector<double> B_ext, B_in, Bratio, u, u_err;
for(int i = 0; i < n; i++)
{
// if(i == 0)
// {
// B_ext.push_back(100.00);
// }
// else{
// B_ext.push_back( TData->GetV1()[i]);
// }
B_ext.push_back( TData->GetV1()[i] );
B_in.push_back( TData->GetV2()[i]);
// B_in.push_back( 90.53);
// if(TMath::Abs(B_in[i]) <= TMath::Abs(B_ext[i]))
// {
Bratio.push_back( B_in[i] / B_ext[i]);
u.push_back( (Bratio[i]*(R**2) + Bratio[i] - 2 - 2*sqrt((Bratio[i]**2)*(R**2) - Bratio[i]*(R**2) - Bratio[i] + 1 ) ) / (Bratio[i]*(R**2) - Bratio[i]) );
// u_err.push_back( u[i]*( 5.5*((0.005/Bratio[i])**2.) + 10*((R_sig/R)**2.) )**0.5 );
u_err.push_back( 0.01 );
// u_err.push_back( u[i]*( 5.5*((0.01/Bratio[i])**2.)) )**0.5 );
// }
}
TGraphErrors *g_uvB = new TGraphErrors(n, &B_ext[0], &u[0], TData->GetV3(), &u_err[0]);
return g_uvB;
}
// Read data from an ascii file and create a root file with an ntuple.
void makeTree(char* txtFile) {
char state[20];
char car_value[20];
float state_fips;
float car_value_num;
TFile *f = new TFile((TString(txtFile)+TString(".root")).Data(),"RECREATE");
TTree *tree = new TTree("ntuple","data from ascii file");
const char* branchDescriptor = "customer_ID/I:shopping_pt/F:record_type:day:time/C:state/C:location/F:group_size:homeowner:car_age:car_value/C:risk_factor/F:age_oldest:age_youngest:married_couple:C_previous:duration_previous:A:B:C:D:E:F:G:cost";
Long64_t nlines = tree->ReadFile((TString(txtFile)+TString(".csv")).Data(), branchDescriptor);
printf(" found %d points\n",nlines);
tree->SetBranchAddress("state", state);
tree->SetBranchAddress("car_value", car_value);
TBranch *fips_branch = tree->Branch("state_fips",
&state_fips,"state_fips/F");
TBranch *car_branch = tree->Branch("car_value_num",
&car_value_num,"car_value_num/F");
Long64_t nentries = tree->GetEntries();
for (Int_t i = 0; i < nentries; i++) {
tree->GetEntry(i);
state_fips = (float) GetStateFIPS(state);
fips_branch->Fill();
car_value_num = (float) GetCarValNum(car_value);
car_branch->Fill();
}
tree->Write();
f->Close();
}
void plot(){
//TH2F *hframe = new TH2F("hframe","Edep_tot vs. track length p=180MeV/C",50,0,50,100,178.0,179.0);
//TH2F *hframe = new TH2F("hframe","Edep_tot vs. track length p=120MeV/c",50,0,50,100,115.2,116.8);
// TH2F *hframe = new TH2F("hframe","Edep_tot vs. track length p=90MeV/c",500,0,50,100,79.5,83.0);
TH2F *hframe = new TH2F("hframe","Edep_tot vs. track length p=72MeV/c",500,0,50,100,45.5,56.1);
// TH2F *hframe = new TH2F("hframe","Edep_tot vs. track length p=65MeV/c",500,0,50,100,0.5,46.1);
TTree *MyTree = new TTree("MyTree", "MyTree");
MyTree->ReadFile("Rout_proton72mevOnSolenoid3LIV.txt","track:edep");
MyTree->SetMarkerStyle(kCircle);
MyTree->SetMarkerColorAlpha(kRed, 0.35);
hframe->Draw(); //you can set the axis att via hframe->GetXaxis()..
MyTree->Draw("edep:track","","same");
/*
TTree *MyTree1 = new TTree("MyTree1", "MyTree1");
MyTree1->ReadFile("Rout_proton120mevOnSolenoid3STD.txt","track1:edep1");
MyTree1->SetMarkerStyle(kOpenSquare);
MyTree1->SetMarkerColorAlpha(kBlue, 0.35);
MyTree1->Draw("edep1:track1","","same");
*/
}
void render(const char* infile=NULL, const char* title=NULL) {
gStyle->SetNumberContours(50);
TCanvas *cam;
if (!infile) {
printf("generating empty camera face and exiting\n");
cam = camFaceCanvas();
return;
}
char *graphTitle;
graphTitle = title?(char *)title:(char *)infile;
TTree *rays = new TTree();
char infile_format[64] = "cam/I:pmt:x/F:y";
rays->ReadFile(infile, infile_format);
TH2F *map = sqmmHeatMap();
map->SetTitle(Form("%s;-x (m);y (m)", graphTitle));
rays->Project("map", "y:-x");
// rays->Draw("y:-x", "", "same");
cam = camFaceCanvas(map, 0);
// map->Draw("colz");
cam->Print(Form("%s.pdf", infile));
}
void kf_plot(){
TH1F *hframe = new TH1F("hframe","momentum resolution",100,-10.,10.);
hframe->Draw(); //you can set the axis att via hframe->GetXaxis()..
gPad->SetLogx(0);
hframe->GetXaxis()->SetTitle(" #Delta p_T /p_T [%]");
hframe->GetYaxis()->SetTitle("Number of event");
TLatex Tl; Tl.SetTextFont(43); Tl.SetTextSize(20);
double pTresol,pXresol,pYresol;
int nline =0;
TTree *MyTree = new TTree("MyTree", "MyTree");
MyTree->ReadFile("helix_out.txt","pTresol:pXresol:pYresol");
MyTree->SetMarkerStyle(kCircle);
MyTree->SetMarkerColorAlpha(kRed, 0.3);
while(1){
hframe->Fill(pTresol);
nline++;
}
hframe->Draw("same");
Tl.DrawLatex(10, 142, "open: p_T resolution(helix)");
}
void analyseFitToystudiesLb(string filename, bool justTau = false)
{
fileprefix = "fitToyStudiesLb";
TTree *t = new TTree;
//t->ReadFile(filename.c_str(),"tau:tau_err:mass_peak:mass_peak_err:m_sigma1:m_sigma1_err:m_sigma2:m_sigma2_err:frac_m_gauss:frac_m_gauss_err:core_frac:core_frac_err:tau_bk:tau_bk_err:n_nonprompt:n_nonprompt_err:n_prompt:n_prompt_err:n_signal:n_signal_err:prompt_p1:prompt_p1_err:prompt_sigma_core:prompt_sigma_core_err:prompt_sigma_tail:prompt_sigma_tail_err"); // alter Fit
//t->ReadFile(filename.c_str(),"tau:tau_err:mass_peak:mass_peak_err:m_sigma1:m_sigma1_err:m_sigma2:m_sigma2_err:frac_m_gauss:frac_m_gauss_err:core_frac:core_frac_err:tau_bk:tau_bk_err:n_nonprompt:n_nonprompt_err:n_prompt:n_prompt_err:n_signal:n_signal_err:prompt_p1:prompt_p1_err:prompt_sigma_core:prompt_sigma_core_err:prompt_sigma_tail:prompt_sigma_tail_err:npr_reso_sigma:npr_reso_sigma_err:sig_reso_sigma:sig_reso_sigma_err"); // Fit ohne PEE
//t->ReadFile(filename.c_str(),"tau:tau_err:mass_peak:mass_peak_err:m_sigma1:m_sigma1_err:m_sigma2:m_sigma2_err:frac_m_gauss:frac_m_gauss_err:tau_bk:tau_bk_err:n_nonprompt:n_nonprompt_err:n_prompt:n_prompt_err:n_signal:n_signal_err:prompt_p1:prompt_p1_err:reso_bias:reso_bias_err:reso_sigma:reso_sigma_err"); // Fit mit PEE 1 Gauss
t->ReadFile(filename.c_str(),"tau:tau_err:mass_peak:mass_peak_err:m_sigma1:m_sigma1_err:m_sigma2:m_sigma2_err:frac_m_gauss:frac_m_gauss_err:tau_bk:tau_bk_err:n_nonprompt:n_nonprompt_err:n_prompt:n_prompt_err:n_signal:n_signal_err:prompt_p1:prompt_p1_err:reso_bias:reso_bias_err:reso_sigma:reso_sigma_err:npr_reso_bias:npr_reso_bias_err:npr_reso_sigma:npr_reso_sigma_err:sig_reso_bias:sig_reso_bias_err:sig_reso_sigma:sig_reso_sigma_err"); // Fit mit PEE 3 Gauss
//t.Draw("tau>>htau");
//t->Draw("(tau-1.507)/tau_err>>htau_pulls(100,-5,5)");
if (!justTau)
{
const int Nevents = 5000;
const double bgrfrac = 0.8;
const double nonprfrac = 0.25;
const int Nsig = Nevents * (1-bgrfrac);
const int Npr = Nevents * bgrfrac * ( 1-nonprfrac);
const int Nnpr = Nevents * bgrfrac * nonprfrac;
plotPulls(t, "tau_pulls", "#tau(#Lambda_{b})", "tau", 1.507, 100, 5.0);
plotPulls(t, "mass_pulls", "m(#Lambda_{b})", "mass_peak", 5.6202, 100, 5.0);
plotPulls(t, "tau_bk_pulls", "#tau_{bgr}(#Lambda_{b})", "tau_bk", 0.750, 100, 5.0);
plotPulls(t, "nsig_pulls", "n_{sig}", "n_signal", Nsig, 100, 5.0);
plotPulls(t, "npr_pulls", "n_{prompt}", "n_prompt", Npr, 100, 10.0);
plotPulls(t, "nnpr_pulls", "n_{nonprompt}", "n_nonprompt", Nnpr, 100, 10.0);
}
plotHisto(t, "tau_histo", "#tau(#Lambda_{b})", "ps", "tau", 100, 1.30, 1.70);
if (!justTau)
{
plotHisto(t, "mass_histo", "m(#Lambda_{b})", "GeV", "mass_peak", 100, 5.615, 5.625);
plotHisto(t, "tau_bk_histo", "#tau_{bgr}(#Lambda_{b})", "ps", "tau_bk", 100, 0.5, 0.9);
plotHisto(t, "nsig_histo", "n_{sig}", "", "n_signal", 100, .8*Nsig, 1.2*Nsig);
plotHisto(t, "npr_histo", "n_{prompt}", "", "n_prompt", 100, .8*Npr, 1.2*Npr);
plotHisto(t, "nnpr_histo", "n_{nonprompt}", "", "n_nonprompt", 100, 0.8*Nnpr, 1.2*Nnpr);
}
}
void Draw_yield_treeeff(char EBEE[20]="EB", int jetbin=0){
int ptbin_int=0;
float ptcut[30] = {22, 30, 36, 50, 75, 90, 105, 120, 135, 150, 165, 175, 185,
190, 200, 220, 250, 300, 350, 400, 500, 750, 1000, 1500, 2000, 3000, 10000}; //22 bins
// 13 14 15 16 17 18 19 20 21 22 23 24 25 26
int nbin=22;
TH1F *h_yield = new TH1F("h_yield","",nbin, ptcut);
TH1F *h_purity = new TH1F("h_purity","",nbin, ptcut);
TH1F *h_purity_tight = new TH1F("h_purity_tight","",nbin, ptcut);
TH1F *h_sig_yield = new TH1F("h_sig_yield","",nbin, ptcut);
TH1F *h_sig_yield_tight = new TH1F("h_sig_yield_tight","",nbin, ptcut);
TH1F *h_bkg_yield = new TH1F("h_bkg_yield","",nbin, ptcut);
TH1F *h_bkg_yield_tight = new TH1F("h_bkg_yield_tight","",nbin, ptcut);
TH1F *h_xs = new TH1F("h_xs","",nbin,ptcut);
double *fitted;
float lumi = 2568.83;
float lumi_err = lumi*0.046;
float deta = 1.4442*2.;
float template_sys = TMath::Sqrt(3.2*3.2+3.*3.)*0.01;
int ebeebin=0;
if(strcmp(EBEE,"EE")==0) {
deta = (2.5-1.566)*2.;
ebeebin=1;
}
TTree *tt = new TTree();
tt->ReadFile("eff.dat");
Int_t ptbin_;
Int_t ebee_;
Int_t jetbin_;
Float_t trigeff;
Float_t trigeff_err;
Float_t recoeff;
Float_t recoeff_err;
Float_t preseleff;
Float_t preseleff_err;
Float_t SF;
Float_t SF_err;
tt->SetBranchAddress("ptbin", &ptbin_);
tt->SetBranchAddress("EBEE", &ebee_);
tt->SetBranchAddress("jetbin", &jetbin_);
tt->SetBranchAddress("trigeff", &trigeff);
tt->SetBranchAddress("trigeff_err", &trigeff_err);
tt->SetBranchAddress("recoeff", &recoeff);
tt->SetBranchAddress("recoeff_err", &recoeff_err);
tt->SetBranchAddress("preseleff", &preseleff);
tt->SetBranchAddress("preseleff_err", &preseleff_err);
tt->SetBranchAddress("SF", &SF);
tt->SetBranchAddress("SF_err", &SF_err);
char txt[100];
for(int ii=13; ii<22; ii++){
//perform fit for yield
fitted=Ifit(ii, EBEE,1, jetbin);
if(fitted[0]>0.) {
h_yield->SetBinContent(ii+1, fitted[0]/h_yield->GetBinWidth(ii+1));
h_yield->SetBinError(ii+1, fitted[1]/h_yield->GetBinWidth(ii+1));
Long64_t jentry = ii-13 + 9*3*ebeebin + 9*jetbin;
tt->GetEntry(jentry);
printf("bin %d, %d, %d \n", ptbin_, ebee_, jetbin_);
float djet_eta=1.5*2.;
if(jetbin==1) djet_eta = 0.9*2.;
if(jetbin==2) djet_eta = 1;
printf("bin %d, ptcut %.1f, fit %.0f , bkg %.0f , eff %.2f, %2.f, binwidth %.1f, deta %.2f \n", ii, ptcut[ii], fitted[0], fitted[2], recoeff, preseleff, h_yield->GetBinWidth(ii+1), deta );
printf(" %f %f %f %f %f %f %f %f %f \n", fitted[0] , lumi , trigeff, recoeff , preseleff , h_yield->GetBinWidth(ii+1) ,SF ,deta , djet_eta);
float xs = fitted[0] / lumi / trigeff/ recoeff / preseleff / h_yield->GetBinWidth(ii+1) /SF /deta / djet_eta ; //xs per GeV
float xs_err = (fitted[1]/fitted[0])*(fitted[1]/fitted[0]) + (lumi_err/lumi)*(lumi_err/lumi) +
(preseleff_err/preseleff)*(preseleff_err/preseleff) +
(recoeff_err/recoeff)*(recoeff_err/recoeff) +
(trigeff_err/trigeff)*(trigeff_err/trigeff) +
(SF_err/SF)*(SF_err/SF) +
(template_sys*template_sys);
xs_err = TMath::Sqrt(xs_err)*xs;
printf("xs %f , xs_err %f \n", xs, xs_err);
h_xs->SetBinContent(ii+1, xs);
h_xs->SetBinError(ii+1, xs_err);
h_sig_yield->SetBinContent(ii+1, fitted[0]);
h_bkg_yield->SetBinContent(ii+1, fitted[2]);
h_sig_yield_tight->SetBinContent(ii+1, fitted[4]);
h_bkg_yield_tight->SetBinContent(ii+1, fitted[6]);
// //perform fit for purity in WP90 region
// h_purity_tight->SetBinContent(ii+1, fitted[4]/(fitted[4]+fitted[6]));
// float err = TMath::Sqrt(fitted[4]*fitted[6]/(fitted[4]+fitted[6])/(fitted[4]+fitted[6])/(fitted[4]+fitted[6]));
// h_purity_tight->SetBinError(ii+1, err);
// h_purity->SetBinContent(ii+1, fitted[0]/(fitted[0]+fitted[2]));
// err = TMath::Sqrt(fitted[0]*fitted[2]/(fitted[0]+fitted[2])/(fitted[0]+fitted[2])/(fitted[0]+fitted[2]));
// h_purity->SetBinError(ii+1, err);
}
}
for(int ii=13; ii<nbin; ii++){
// printf("ptbin %d, %.2f, xs %f , xs_err %f \n", ii, ptcut[ii], h_xs->GetBinContent(ii+1), h_xs->GetBinError(ii+1));
printf("ptbin %d, %.2f, yield, %.2f, %.2f \n", ii, ptcut[ii], h_sig_yield_tight->GetBinContent(ii+1), h_bkg_yield_tight->GetBinContent(ii+1));
}
TCanvas *c10 = new TCanvas("c10","",600,600);
c10->Draw();
gPad->SetLogy();
h_yield->SetNdivisions(505,"XY");
h_yield->SetXTitle("p_{T} (GeV)");
h_yield->SetYTitle("Entries / GeV");
h_yield->SetMarkerStyle(8);
h_yield->GetXaxis()->SetRangeUser(150.,1000.);
h_yield->Draw("pe");
char pho_text[100];
char jet_text[100];
if(ebeebin==0) sprintf(pho_text,"|#eta_{#gamma}|<1.4442");
else sprintf(pho_text,"1.566<|#eta_{#gamma}|<2.5");
if(jetbin==0) sprintf(jet_text,"|#eta_{jet}|<1.5");
else sprintf(jet_text,"1.5<|#eta_{jet}|<2.4");
TLegend *tleg = new TLegend(0.4, 0.65, 0.85, 0.85);
char text[50];
sprintf(text,"CMS 13TeV, %.0f pb^{-1}",lumi);
tleg->SetHeader(text);
tleg->SetFillColor(0);
tleg->SetShadowColor(0);
tleg->SetBorderSize(0);
sprintf(text,"%s, %s",pho_text, jet_text);
if(jetbin==2) sprintf(text,"%s",pho_text);
tleg->AddEntry(h_yield,text,"pl");
tleg->Draw();
TLatex *tlx = new TLatex();
tlx->SetTextSize(0.04);
tlx->DrawLatex(100, h_yield->GetMaximum()*1.3, "CMS Preliminary #sqrt{s} = 13TeV");
// //purity plot
// TCanvas *c11 = new TCanvas("c11","",600,600);
// h_purity->SetNdivisions(505,"XY");
// h_purity->SetXTitle("P_{T} (GeV)");
// h_purity->SetYTitle("Purity");
// h_purity->SetMarkerStyle(8);
// h_purity->GetXaxis()->SetRangeUser(150.,1000.);
// h_purity->GetYaxis()->SetRangeUser(0., 1.01);
// h_purity->Draw();
// // h_purity_tight->SetMarkerStyle(8);
// // h_purity_tight->SetMarkerColor(4);
// // h_purity_tight->SetLineColor(4);
// // h_purity_tight->Draw("pe same");
// TGraphAsymmErrors *tgrs = new TGraphAsymmErrors();
// h_bkg_yield->Add(h_sig_yield);
// tgrs->BayesDivide(h_sig_yield, h_bkg_yield);
// tgrs->SetMarkerStyle(8);
// tgrs->Draw("pe same");
// TGraphAsymmErrors *tgrs_tight = new TGraphAsymmErrors();
// h_bkg_yield_tight->Add(h_sig_yield_tight);
// for(int ii=13; ii<nbin; ii++){
// // printf("ptbin %d, %.2f, xs %f , xs_err %f \n", ii, ptcut[ii], h_xs->GetBinContent(ii+1), h_xs->GetBinError(ii+1));
// printf("ptbin %d, %.2f, yield, %.2f, %.2f \n", ii, ptcut[ii], h_sig_yield_tight->GetBinContent(ii+1), h_bkg_yield_tight->GetBinContent(ii+1));
// }
// tgrs_tight->BayesDivide(h_sig_yield_tight, h_bkg_yield_tight,"v");
// tgrs_tight->SetMarkerStyle(8);
// tgrs_tight->SetMarkerColor(4);
// tgrs_tight->SetLineColor(4);
// tgrs_tight->Draw("pe same");
// tleg = new TLegend(0.3, 0.15, 0.85, 0.35);
// char text[50];
// sprintf(text,"Single Photon PD %.0f pb^{-1}", lumi);
// tleg->SetHeader(text);
// tleg->SetFillColor(0);
// tleg->SetShadowColor(0);
// tleg->SetBorderSize(0);
// sprintf(text,"%s, %s",pho_text, jet_text);
// tleg->AddEntry(tgrs,text,"pl");
// sprintf(text,"%s, %s, BDT>0.37",pho_text, jet_text);
// tleg->AddEntry(tgrs_tight,text,"pl");
// tleg->Draw();
// tlx->SetTextSize(0.04);
// tlx->DrawLatex(200, 1.01, "CMS Preliminary #sqrt{s} = 13TeV");
//Draw XS plot
TCanvas *c12 = new TCanvas("c12","",600,700);
c12->Draw();
TPad* pad1 = new TPad("pad1","",0.02, 0.25, 0.99, 0.99);
TPad* pad2 = new TPad("pad1","",0.02, 0.02, 0.99, 0.25);
// pad1->SetLeftMargin(0.02);
pad1->SetRightMargin(0.035);
// pad1->SetTopMargin(0.02);
pad1->SetBottomMargin(0.0);
pad1->SetFrameBorderMode(0);
pad1->SetBorderMode(0);
pad1->SetBorderSize(0);
// pad2->SetLeftMargin(0.02);
pad2->SetRightMargin(0.035);
pad2->SetTopMargin(0.0);
pad2->SetBottomMargin(0.275);
pad2->SetFrameBorderMode(0);
pad2->SetBorderMode(0);
pad2->SetBorderSize(0);
pad1->Draw();
pad2->Draw();
pad1->cd();
gPad->SetLogy();
TH2F *hh2 = new TH2F("hh2","",100, 150, 1000, 100, 2e-7, 1.);
if(ebeebin==0) hh2 = new TH2F("hh2","",100, 150, 1000, 100, 2e-7, 1.);
hh2->SetNdivisions(505,"XY");
hh2->SetXTitle("P_{T} (GeV)");
hh2->SetYTitle("d^{3}#sigma / d^{#gamma}p_{T}d^{#gamma}#eta d^{jet}#eta [pb/GeV]");
if(jetbin==2) hh2->SetYTitle("d^{2}#sigma / d^{#gamma}p_{T}d^{#gamma}#eta [pb/GeV]");
hh2->GetXaxis()->SetLabelSize(0.035);
hh2->GetYaxis()->SetLabelSize(0.035);
hh2->GetYaxis()->SetTitleSize(0.04);
hh2->GetYaxis()->SetTitleOffset(1.1);
hh2->Draw();
h_xs->SetMarkerStyle(8);
h_xs->Draw("pel same");
//Draw JetPhox value
TTree *t_th = new TTree();
t_th->ReadFile("jetphox.dat");
t_th->Print();
Int_t ptbin_1;
Int_t ebee_1;
Int_t jetbin_1;
Double_t xs_th;
Double_t xs_th_err;
t_th->SetBranchAddress("ptbin", &ptbin_1);
t_th->SetBranchAddress("EBEE", &ebee_1);
t_th->SetBranchAddress("jetbin", &jetbin_1);
t_th->SetBranchAddress("xs", &xs_th);
t_th->SetBranchAddress("xs_err", &xs_th_err);
TH1F *h_th_xs = new TH1F("h_th_xs","",nbin, ptcut);
TH1F *h_th_xs_err = new TH1F("h_th_xs_err","",nbin, ptcut);
for(int ii=13; ii<22; ii++){
Long64_t jentry = ii-13 + 9*3*ebeebin + 9*jetbin;
t_th->GetEntry(jentry);
//printf("bin %d, %d, %d \n", ptbin_1, ebee_1, jetbin_1);
h_th_xs->SetBinContent(ii+1, xs_th);
h_th_xs->SetBinError(ii+1, xs_th_err);
h_th_xs_err->SetBinContent(ii+1, xs_th_err);
if(jetbin==2){
if(ebeebin==0){
h_th_xs->SetBinContent(ii+1, xs_th/deta);
h_th_xs->SetBinError(ii+1, xs_th_err/deta);
h_th_xs_err->SetBinContent(ii+1, xs_th_err/deta);
}else{
h_th_xs->SetBinContent(ii+1, xs_th/deta*2.);
h_th_xs->SetBinError(ii+1, xs_th_err/deta*2.);
h_th_xs_err->SetBinContent(ii+1, xs_th_err/deta*2.);
}
}
}
h_th_xs->SetMarkerStyle(25);
h_th_xs->SetMarkerColor(2);
h_th_xs->SetLineColor(2);
h_th_xs->Draw("same ple");
TLegend *tleg = new TLegend(0.4, 0.65, 0.85, 0.85);
char text[50];
sprintf(text,"CMS 13TeV, %.0f pb^{-1}",lumi);
tleg->SetHeader(text);
tleg->SetFillColor(0);
tleg->SetShadowColor(0);
tleg->SetBorderSize(0);
sprintf(text,"%s, %s",pho_text, jet_text);
if(jetbin==2) sprintf(text,"%s",pho_text);
tleg->AddEntry(h_xs,text,"pl");
tleg->AddEntry(h_th_xs,"JETPHOX","pl");
tleg->Draw();
tlx->DrawLatex(150, 1., "CMS Preliminary #sqrt{s} = 13TeV");
//Draw data/th XS ratio
// TCanvas *c15 = new TCanvas("c15","",600,600);
// c15->Draw();
pad2->cd();
gPad->SetGridy();
TH1F *h_xs_ratio = (TH1F*)h_xs->Clone();
h_xs_ratio->Draw();
h_xs_ratio->Divide(h_th_xs);
// TGraphAsymmErrors *tgrs = new TGraphAsymmErrors();
// tgrs->Divide(h_xs, h_th_xs);
// TH1F *h_xs_ratio = new TH1F("h_xs_ratio","",nbin,ptcut);
h_xs_ratio->SetMinimum(0.);
h_xs_ratio->SetMaximum(2.);
h_xs_ratio->SetNdivisions(505,"XY");
h_xs_ratio->SetXTitle("P_{T} (GeV)");
h_xs_ratio->SetYTitle("Data / MC");
h_xs_ratio->GetXaxis()->SetLabelSize(0.12);
h_xs_ratio->GetYaxis()->SetLabelSize(0.1);
h_xs_ratio->GetXaxis()->SetTitleSize(0.12);
h_xs_ratio->GetYaxis()->SetTitleSize(0.12);
h_xs_ratio->GetXaxis()->SetTitleOffset(1.);
h_xs_ratio->GetYaxis()->SetTitleOffset(0.4);
h_xs_ratio->GetXaxis()->SetRangeUser(150,1000);
h_xs_ratio->GetYaxis()->SetRangeUser(0.55, 1.45);
if(ebeebin==1) h_xs_ratio->GetYaxis()->SetRangeUser(0., 2.2);
if(jetbin==1) h_xs_ratio->GetYaxis()->SetRangeUser(0., 2.2);
//h_xs_ratio->GetYaxis()->SetNdivisions(102,"Y");
h_xs_ratio->Draw("pe");
// tgrs->SetMarkerStyle(8);
// tgrs->Draw("pe same");
}
void load_simresults(TString filenameinput, int inputtype=5, double enabledistsel = 0) {
Float_t SOURCE, L, B, TS, FLUX, FLUXERR, FLUXUL, R, EXP, SI, MINTS, FIXFLAG , CTS, CTSERR, CTSUL, TOTEXP, TOTNCOUNTS, FCN0, FCN1, EDM0, EDM1, ITER0, ITER1;
Float_t GAL, ISO;
double centerl = 79;
double centerb = 0;
L = B = TS = FLUX = FLUXERR = FLUXUL = R = EXP = SI = MINTS = FIXFLAG = CTS = CTSERR = CTSUL = TOTEXP = TOTNCOUNTS = FCN0 = FCN1 = EDM0 = EDM1 = ITER0 = ITER1 = 1;
GAL=ISO=-1;
Long64_t nlines;
TTree* T;
T = new TTree("DATA", "") ;
if(inputtype == 5) {
/*
After R:
double exposure = GetTotalExposure(i);
srcout << " " << exposure*m_sources[i].GetFlux();
srcout << " " << exposure*m_sources[i].GetFluxerr();
srcout << " " << exposure*m_sources[i].GetFluxul();
srcout << " " << exposure;
srcout << " " << m_fitInfo[i].counts;
srcout << " " << m_fitInfo[i].fcn0;
srcout << " " << m_fitInfo[i].fcn1;
srcout << " " << m_fitInfo[i].edm0;
srcout << " " << m_fitInfo[i].edm1;
srcout << " " << m_fitInfo[i].iter0;
srcout << " " << m_fitInfo[i].iter1 << endl;
*/
nlines = T->ReadFile(filenameinput, "SOURCE:L:B:TS:FLUX:INDEX:FIXFLAG:MINTS:GAL:ISO:R:CTS:CTSERR:CTSUL:TOTEXP:TOTNCOUNTS:FCN0:FCN1:EDM0:EDM1:ITER0:ITER1");
cout << "******************************************* " << endl;
cout << "SOURCE:L:B:TS:FLUX:INDEX:FIXFLAG:MINTS:GAL:ISO:R:CTS:CTSERR:CTSUL:TOTEXP:TOTNCOUNTS:FCN0:FCN1:EDM0:EDM1:ITER0:ITER1" << endl;
cout << "******************************************* " << endl;
}
cout << "N lines: " << nlines << endl;
if(inputtype == 5) {
T->SetBranchAddress("SOURCE", &SOURCE);
T->SetBranchAddress("L", &L);
T->SetBranchAddress("B", &B);
T->SetBranchAddress("TS", &TS);
T->SetBranchAddress("FLUX", &FLUX);
T->SetBranchAddress("R", &R);
T->SetBranchAddress("CTS", &CTS);
T->SetBranchAddress("TOTNCOUNTS", &TOTNCOUNTS);
T->SetBranchAddress("FCN0", &FCN0);
T->SetBranchAddress("FCN1", &FCN1);
T->SetBranchAddress("EDM0", &EDM0);
T->SetBranchAddress("EDM1", &EDM1);
T->SetBranchAddress("ITER0", &ITER0);
T->SetBranchAddress("ITER1", &ITER1);
//T->SetBranchAddress("GAL", &GAL);
//T->SetBranchAddress("ISO", &ISO);
}
TCanvas* c1 = new TCanvas;
c1->Divide(3,3);
//FCN1 = 2 ln L1
//FCN0 = 2 ln L0
//TS = TS = -2(ln L0 - ln L1) = 2 ln L1 - 2 ln L0 = FCN1 - FCN0
TH2D* h_tsdist = new TH2D("h_tsdist", "h_tsdist", 400, 0, 400, 100, 0, 10);
TH1D* h_fcn0 = new TH1D("h_fcn0", "h_fcn0", 40000, 0, 40000);
TH1D* h_fcn1 = new TH1D("h_fcn1", "h_fcn1", 40000, 0, 40000);
TH1D* h_fcndiff = new TH1D("h_fcndiff", "h_fcndiff", 400, 0, 400);
TH1D* h_ts = new TH1D("h_ts", "h_ts", 400, 0, 400);
TH1D* h_ts_thr = new TH1D("h_ts_thr", "h_ts_thr", 400, 0, 400);
TH1D* h_fcn0_thr = new TH1D("h_fcn0_thr", "h_fcn0_thr", 40000, 0, 40000);
TH1D* h_fcn0_thr = new TH1D("h_fcn1_thr", "h_fcn1_thr", 40000, 0, 40000);
TH1D* h_fcndiff_thr = new TH1D("h_fcndiff_thr", "h_fcndiff_thr", 400, 0, 400);
TH1D* h_ts_thr = new TH1D("h_ts_thr", "h_ts_thr", 400, 0, 400);
TH1D* h_edm0 = new TH1D("h_emd0", "h_edm0", 10000, 0, 100);
TH1D* h_edm0_thr = new TH1D("h_emd0_thr", "h_edm0_thr", 10000, 0, 100);
TH1D* h_edm1 = new TH1D("h_emd1", "h_edm1", 10000, 0, 0.02);
TH1D* h_edm1_thr = new TH1D("h_emd1_thr", "h_edm1_thr", 10000, 0, 0.02);
TH1D* h_iter0 = new TH1D("h_iter0", "h_iter0", 1000, 0, 1000);
TH1D* h_iter0_thr = new TH1D("h_iter0_thr", "h_iter0_thr", 1000, 0, 1000);
TH1D* h_iter1 = new TH1D("h_iter1", "h_iter1", 10000, 0, 10000);
TH1D* h_iter1_thr = new TH1D("h_iter1_thr", "h_iter1_thr", 10000, 0, 10000);
int discarded = 0;
for(Long64_t j = 0; j<nlines; j++) {
T->GetEntry(j);
if(EDM0 != 0.5) {
cout << "* " << SOURCE << " " << L << " " << B << " " << (FLUX) << " " << TS << " " << EDM0 << " " << EDM1 << endl;
discarded++;
continue;
}
double dist = distance(L, B, centerl, centerb);
h_tsdist->Fill(TS, dist);
h_fcn0->Fill(FCN0);
h_fcn1->Fill(FCN1);
h_fcndiff->Fill(2*(FCN0-FCN1));
h_ts->Fill(TS);
h_edm0->Fill(EDM0);
h_edm1->Fill(EDM1);
h_iter0->Fill(ITER0);
h_iter1->Fill(ITER1);
if(dist > 1) {
h_fcn0_thr->Fill(FCN0);
h_fcn1_thr->Fill(FCN1);
h_fcndiff_thr->Fill(2*(FCN0-FCN1));
h_ts_thr->Fill(TS);
h_edm0_thr->Fill(EDM0);
h_edm1_thr->Fill(EDM1);
h_iter0_thr->Fill(ITER0);
h_iter1_thr->Fill(ITER1);
h_ts->Fill(TS);
}
}
cout << "discarded: " << discarded << endl;
double scf = h_fcn0->Integral();
h_fcn0->Scale(1.0/scf);
h_fcn0_thr->Scale(1.0/scf);
scf = h_fcn1->Integral();
h_fcn1->Scale(1.0/scf);
h_fcn1_thr->Scale(1.0/scf);
scf = h_fcndiff->Integral();
h_fcndiff->Scale(1.0/scf);
h_fcndiff_thr->Scale(1.0/scf);
scf = h_ts->Integral();
h_ts->Scale(1.0/scf);
h_ts_thr->Scale(1.0/scf);
scf = h_edm0->Integral();
h_edm0->Scale(1.0/scf);
h_edm0_thr->Scale(1.0/scf);
scf = h_edm1->Integral();
h_edm1->Scale(1.0/scf);
h_edm1_thr->Scale(1.0/scf);
scf = h_iter0->Integral();
h_iter0->Scale(1.0/scf);
h_iter0_thr->Scale(1.0/scf);
scf = h_iter1->Integral();
h_iter1->Scale(1.0/scf);
h_iter1_thr->Scale(1.0/scf);
c1->cd(1);
gPad->SetLogy();
h_fcn0->Draw();
h_fcn0_thr->SetLineColor(kRed);
h_fcn0_thr->Draw("SAME");
c1->cd(2);
gPad->SetLogy();
h_fcn1->Draw();
h_fcn1_thr->SetLineColor(kRed);
h_fcn1_thr->Draw("SAME");
c1->cd(3);
gPad->SetLogy();
h_fcndiff->Draw();
h_ts->SetLineColor(kRed);
h_ts->Draw("SAME");
c1->cd(4);
gPad->SetLogy();
T->Draw("EDM0");
h_edm0->Draw();
h_edm0_thr->SetLineColor(kRed);
h_edm0_thr->Draw("SAME");
c1->cd(5);
gPad->SetLogy();
T->Draw("EDM1");
h_edm1->Draw();
h_edm1_thr->SetLineColor(kRed);
h_edm1_thr->Draw("SAME");
c1->cd(6);
gPad->SetLogy();
h_iter0->Draw();
h_iter0_thr->SetLineColor(kRed);
h_iter0_thr->Draw("SAME");
c1->cd(7);
gPad->SetLogy();
h_iter1->Draw();
h_iter1_thr->SetLineColor(kRed);
h_iter1_thr->Draw("SAME");
c1->cd(8);
gPad->SetLogy();
T->Draw("FCN1", "TS>9");
c1->cd(9);
gPad->SetLogy();
gPad->SetLogx();
h_tsdist->Draw("BOXCOL");
}
/*#include "TTree.h"
#include "TCanvas.h"
#include "TGraph.h"
#include "TMultiGraph.h"
#include "TRint.h"
#include <time.h>
#include <stdio.h>
const short MaxNN = 6;
*/
void make_scatterplot(TString data_file, TString plot_name, TString header)
{
//TApplication program = new TRInt();
//pull in data
TTree *t = new TTree();
t->ReadFile(data_file);
t->SetName("t");
//TString name = "run2.png";
TCanvas *BG = new TCanvas("c1", "Read Velocity on Local Disk for CMS3 Files", 1920, 1080);
BG->cd();
TPad *c = new TPad("MainPad", "My main pad", 0, 0, 1, 0.9);
c->Draw();
c->Divide(2,2);
//In first slot have Time vs. Buffer for 1 Concurrent Read
c->cd(1);
int n1 = t->Draw("VelocityMBps:BufferSize", "ConcurrentReads==1", "goff");
TGraph *ghist1 = new TGraph(n1, t->GetV2(), t->GetV1());
ghist1->SetName("ghist1");
ghist1->SetMarkerStyle(3);
ghist1->SetMarkerColor(1);
ghist1->SetTitle("Single File Read");
ghist1->GetXaxis()->SetTitle("Buffer Size (Bytes)");
ghist1->GetYaxis()->SetTitle("Read Velocity (MB/s)");
ghist1->Draw("ap");
//In second slot have Time vs. Buffer for 3 Concurrent Reads
c->cd(2);
int n2 = t->Draw("VelocityMBps:BufferSize", "ConcurrentReads==3", "goff");
TGraph *ghist2 = new TGraph(n2, t->GetV2(), t->GetV1());
Double_t DP2x[n2], DP2y[n2];
ghist2->SetName("ghist2");
ghist2->SetMarkerStyle(3);
ghist2->SetMarkerColor(1);
ghist2->SetTitle("3 Concurrent Reads");
ghist2->GetXaxis()->SetTitle("Buffer Size (Bytes)");
ghist2->GetYaxis()->SetTitle("Read Velocity (MB/s)");
ghist2->Draw("ap");
//In third slot have Time vs. Buffer for 3 Concurrent Reads
c->cd(3);
int n3 = t->Draw("VelocityMBps:BufferSize", "ConcurrentReads==6", "goff");
TGraph *ghist3 = new TGraph(n3, t->GetV2(), t->GetV1());
Double_t DP3x[n3], DP3y[n3];
ghist3->SetName("ghist3");
ghist3->SetMarkerStyle(3);
ghist3->SetMarkerColor(1);
ghist3->SetTitle("6 Concurrent Reads");
ghist3->GetXaxis()->SetTitle("Buffer Size (Bytes)");
ghist3->GetYaxis()->SetTitle("Read Velocity (MB/s)");
ghist3->Draw("ap");
//In fourth slot have Time vs. Buffer for 10 Concurrent Reads
c->cd(4);
int n4 = t->Draw("VelocityMBps:BufferSize", "ConcurrentReads==10", "goff");
TGraph *ghist4 = new TGraph(n4, t->GetV2(), t->GetV1());
ghist4->SetMarkerStyle(3);
ghist4->SetName("ghist4");
ghist4->SetMarkerColor(1);
ghist4->SetTitle("10 Concurrent Reads");
ghist4->GetXaxis()->SetTitle("Buffer Size (Bytes)");
ghist4->GetYaxis()->SetTitle("Read Velocity (MB/s)");
ghist4->Draw("ap");
//Draw to screen
//Initialize Canvas
c->cd(0);
c->Draw();
BG->cd();
TText *title = new TText(.5,.95, header);
title->SetTextAlign(22);
title->Draw();
gDirectory->Add(ghist1);
gDirectory->Add(ghist2);
gDirectory->Add(ghist3);
gDirectory->Add(ghist4);
gDirectory->Add(t);
gPad->SaveAs(plot_name);
}
void read_tpvar(const char* file, int YS,
const char* inputtable_pt, const char* outputtable_pt,
const char* inputtable_rap, const char* outputtable_rap,
const char* inputtable_cent="nocentrality", const char* outputtable_cent="nocentrality")
{
// YS decides on the binning.
// YS=1 -> fine binning
// YS=2 -> coarse binning
// YS=0 -> both
// YS=4 -> both, except centrality where only fine (for 1S in pbpb)
TFile *f = new TFile("tpvar.root","RECREATE");
TTree *tr = new TTree("tree","tree");
tr->ReadFile(file,"name/C:binlow/F:binhigh/F:eff/F:stat/F:syst/F");
unsigned int NPTNS = YS==1 ? NPT1S : NPT2S;
unsigned int NRAPNS = YS==1 ? NRAP1S : NRAP2S;
unsigned int NCENTNS = YS==1 ? NCENT1S : NCENT2S;
double *ptbins_NS = YS==1 ? ptbins_1S : ptbins_2S;
double *rapbins_NS = YS==1 ? rapbins_1S : rapbins_2S;
int *centbins_NS = YS==1 ? centbins_1S : centbins_2S;
bool docentrality=strcmp(inputtable_cent,"nocentrality");
ifstream intable_pt(inputtable_pt);
ifstream intable_rap(inputtable_rap);
ifstream intable_cent; if (docentrality) intable_cent.open(inputtable_cent);
ofstream outtable_pt(outputtable_pt);
ofstream outtable_rap(outputtable_rap);
ofstream outtable_cent; if (docentrality) outtable_cent.open(outputtable_cent);
double binmin, binmax, eff0, efferr, effmean;
TString var("pt_SF");
tr->Draw("eff:1>>htemp(1,0,2)",Form("name==\"%s\"&&abs(binlow-%f)<.1&&abs(binhigh-%f)<.1",var.Data(),ptbins_NS[0],ptbins_NS[NPTNS]),"PROFs");
// tr->Draw("eff:1>>htemp(1,0,2)",Form("name==\"%s\"&&abs(binlow-%f)<.1&&abs(binhigh-%f)<.1",var.Data(),ptbins_NS[0],40.),"PROFs"); // ugly fix
TProfile *htemp = (TProfile*) gDirectory->Get("htemp");
binmin=ptbins_NS[0];
binmax=ptbins_NS[NPTNS]; //40.;//(ugly fix)
eff0=firsteff(tr,var.Data(),binmin,binmax);
efferr=htemp->GetBinError(1);
effmean=htemp->GetBinContent(1);
cout << setprecision(3)<<fixed << var << " " << binmin << " " << binmax << " " << eff0 << " " << efferr << " " << effmean << endl;
if (dotables) print(intable_pt,outtable_pt,binmin,binmax,eff0,efferr);
delete htemp;
skip_lines(intable_pt,1);// \hline
if (YS==0||YS==4)
{
NPTNS=NPT2S; ptbins_NS=ptbins_2S;
}
for (unsigned int i=0; i<NPTNS; i++)
{
// cout << setprecision(3)<<fixed << Form("name==\"%s\"&&binlow==%f&&binhigh==%f",var.Data(),ptbins_1S[i],ptbins_1S[i+1]) << endl;
tr->Draw("eff:1>>htemp(1,0,2)",Form("name==\"%s\"&&abs(binlow-%f)<.1&&abs(binhigh-%f)<.1",var.Data(),ptbins_1S[i],ptbins_1S[i+1]),"PROFs");
htemp = (TProfile*) gDirectory->Get("htemp");
binmin=ptbins_NS[i];
binmax=ptbins_NS[i+1];
eff0=firsteff(tr,var.Data(),ptbins_NS[i],ptbins_NS[i+1]);
efferr=htemp->GetBinError(1);
effmean=htemp->GetBinContent(1);
cout << setprecision(3)<<fixed << var << " " << binmin << " " << binmax << " " << eff0 << " " << efferr << " " << effmean << endl;
if (dotables) print(intable_pt,outtable_pt,binmin,binmax,eff0,efferr);
delete htemp;
}
if (YS==0||YS==4)
{
NPTNS=NPT1S; ptbins_NS=ptbins_1S;
outtable_pt << "\\hline" << endl;
skip_lines(intable_pt,1);// \hline
for (unsigned int i=0; i<NPT1S; i++)
{
// cout << setprecision(3)<<fixed << Form("name==\"%s\"&&binlow==%f&&binhigh==%f",var.Data(),ptbins_1S[i],ptbins_1S[i+1]) << endl;
tr->Draw("eff:1>>htemp(1,0,2)",Form("name==\"%s\"&&abs(binlow-%f)<.1&&abs(binhigh-%f)<.1",var.Data(),ptbins_1S[i],ptbins_1S[i+1]),"PROFs");
htemp = (TProfile*) gDirectory->Get("htemp");
binmin=ptbins_NS[i];
binmax=ptbins_NS[i+1];
eff0=firsteff(tr,var.Data(),ptbins_NS[i],ptbins_NS[i+1]);
efferr=htemp->GetBinError(1);
effmean=htemp->GetBinContent(1);
cout << setprecision(3)<<fixed << var << " " << binmin << " " << binmax << " " << eff0 << " " << efferr << " " << effmean << endl;
if (dotables) print(intable_pt,outtable_pt,binmin,binmax,eff0,efferr);
delete htemp;
}
}
var = TString("rapidity_SF");
tr->Draw("eff:1>>htemp(1,0,2)",Form("name==\"%s\"&&abs(binlow-%f)<.1&&abs(binhigh-%f)<.1",var.Data(),rapbins_NS[0],rapbins_NS[NRAPNS]),"PROFs");
htemp = (TProfile*) gDirectory->Get("htemp");
binmin=rapbins_NS[0];
binmax=rapbins_NS[NRAPNS];
eff0=firsteff(tr,var.Data(),rapbins_NS[0],rapbins_NS[NRAPNS]);
efferr=htemp->GetBinError(1);
effmean=htemp->GetBinContent(1);
cout << setprecision(3)<<fixed << var << " " << binmin << " " << binmax << " " << eff0 << " " << efferr << " " << effmean << endl;
delete htemp;
if (YS==0||YS==4)
{
NRAPNS=NRAP2S; rapbins_NS=rapbins_2S;
}
for (unsigned int i=0; i<NRAPNS; i++)
{
// cout << setprecision(3)<<fixed << Form("name==\"%s\"&&binlow==%f&&binhigh==%f",var.Data(),rapbins_NS[i],rapbins_NS[i+1]) << endl;
tr->Draw("eff:1>>htemp(1,0,2)",Form("name==\"%s\"&&abs(binlow-%f)<.1&&abs(binhigh-%f)<.1",var.Data(),rapbins_NS[i],rapbins_NS[i+1]),"PROFs");
htemp = (TProfile*) gDirectory->Get("htemp");
binmin=rapbins_NS[i];
binmax=rapbins_NS[i+1];
eff0=firsteff(tr,var.Data(),rapbins_NS[i],rapbins_NS[i+1]);
efferr=htemp->GetBinError(1);
effmean=htemp->GetBinContent(1);
cout << setprecision(3)<<fixed << var << " " << binmin << " " << binmax << " " << eff0 << " " << efferr << " " << effmean << endl;
if (dotables) print(intable_rap,outtable_rap,binmin,binmax,eff0,efferr);
delete htemp;
}
if (YS==0||YS==4)
{
outtable_rap << "\\hline" << endl;
skip_lines(intable_rap,1);// \hline
NRAPNS=NRAP1S; rapbins_NS=rapbins_1S;
for (unsigned int i=0; i<NRAPNS; i++)
{
// cout << setprecision(3)<<fixed << Form("name==\"%s\"&&binlow==%f&&binhigh==%f",var.Data(),rapbins_NS[i],rapbins_NS[i+1]) << endl;
tr->Draw("eff:1>>htemp(1,0,2)",Form("name==\"%s\"&&abs(binlow-%f)<.1&&abs(binhigh-%f)<.1",var.Data(),rapbins_NS[i],rapbins_NS[i+1]),"PROFs");
htemp = (TProfile*) gDirectory->Get("htemp");
binmin=rapbins_NS[i];
binmax=rapbins_NS[i+1];
eff0=firsteff(tr,var.Data(),rapbins_NS[i],rapbins_NS[i+1]);
efferr=htemp->GetBinError(1);
effmean=htemp->GetBinContent(1);
cout << setprecision(3)<<fixed << var << " " << binmin << " " << binmax << " " << eff0 << " " << efferr << " " << effmean << endl;
if (dotables) print(intable_rap,outtable_rap,binmin,binmax,eff0,efferr);
delete htemp;
}
}
if (!docentrality) return;
var = TString("centrality_SF");
tr->Draw("eff:1>>htemp(1,0,2)",Form("name==\"%s\"&&abs(binlow-%f)<.1&&abs(binhigh-%f)<.1",var.Data(),centbins_NS[0]*2.5,centbins_NS[NCENTNS]*2.5),"PROFs");
htemp = (TProfile*) gDirectory->Get("htemp");
binmin=centbins_NS[0]*2.5;
binmax=centbins_NS[NCENTNS]*2.5;
eff0=firsteff(tr,var.Data(),centbins_NS[0]*2.5,centbins_NS[NCENTNS]*2.5);
efferr=htemp->GetBinError(1);
effmean=htemp->GetBinContent(1);
cout << setprecision(3)<<fixed << var << " " << binmin << " " << binmax << " " << eff0 << " " << efferr << " " << effmean << endl;
delete htemp;
if (YS==0)
{
NCENTNS=NCENT2S; centbins_NS=centbins_2S;
}
else if (YS==4)
{
NCENTNS=NCENT1S; centbins_NS=centbins_1S;
}
for (unsigned int i=0; i<NCENTNS; i++)
{
// cout << setprecision(3)<<fixed << Form("name==\"%s\"&&binlow==%f&&binhigh==%f",var.Data(),centbins_NS[i],centbins_NS[i+1]) << endl;
tr->Draw("eff:1>>htemp(1,0,2)",Form("name==\"%s\"&&abs(binlow-%f)<.1&&abs(binhigh-%f)<.1",var.Data(),centbins_NS[i]*2.5,centbins_NS[i+1]*2.5),"PROFs");
htemp = (TProfile*) gDirectory->Get("htemp");
binmin=centbins_NS[i]*2.5;
binmax=centbins_NS[i+1]*2.5;
eff0=firsteff(tr,var.Data(),centbins_NS[i]*2.5,centbins_NS[i+1]*2.5);
efferr=htemp->GetBinError(1);
effmean=htemp->GetBinContent(1);
cout << setprecision(3)<<fixed << var << " " << binmin << " " << binmax << " " << eff0 << " " << efferr << " " << effmean << endl;
if (dotables) print(intable_cent,outtable_cent,binmin,binmax,eff0,efferr);
delete htemp;
}
if (YS==0)
{
NCENTNS=NCENT1S; centbins_NS=centbins_1S;
outtable_cent << "\\hline" << endl;
skip_lines(intable_cent,1);// \hline
for (unsigned int i=0; i<NCENTNS; i++)
{
// cout << setprecision(3)<<fixed << Form("name==\"%s\"&&binlow==%f&&binhigh==%f",var.Data(),centbins_NS[i],centbins_NS[i+1]) << endl;
tr->Draw("eff:1>>htemp(1,0,2)",Form("name==\"%s\"&&abs(binlow-%f)<.1&&abs(binhigh-%f)<.1",var.Data(),centbins_NS[i]*2.5,centbins_NS[i+1]*2.5),"PROFs");
htemp = (TProfile*) gDirectory->Get("htemp");
binmin=centbins_NS[i]*2.5;
binmax=centbins_NS[i+1]*2.5;
eff0=firsteff(tr,var.Data(),centbins_NS[i]*2.5,centbins_NS[i+1]*2.5);
efferr=htemp->GetBinError(1);
effmean=htemp->GetBinContent(1);
cout << setprecision(3)<<fixed << var << " " << binmin << " " << binmax << " " << eff0 << " " << efferr << " " << effmean << endl;
if (dotables) print(intable_cent,outtable_cent,binmin,binmax,eff0,efferr);
delete htemp;
}
}
f->Write();
f->Close();
}
void mk_tree(const char * acc_file="datfiles/acc.dat")
{
// read acc file into tree
TTree * acc = new TTree("acc","counts tree from acc.dat");
char cols[2048];
char bbc_cols[256];
char zdc_cols[256];
char vpd_cols[256];
for(Int_t i=0; i<=7; i++)
{
if(i==0)
{
sprintf(bbc_cols,"bbc_%d/D",i);
sprintf(zdc_cols,"zdc_%d/D",i);
sprintf(vpd_cols,"vpd_%d/D",i);
}
else
{
sprintf(bbc_cols,"%s:bbc_%d/D",bbc_cols,i);
sprintf(zdc_cols,"%s:zdc_%d/D",zdc_cols,i);
sprintf(vpd_cols,"%s:vpd_%d/D",vpd_cols,i);
};
};
sprintf(cols,"i/I:runnum/I:fi/I:fill/I:t/D:bx/I:%s:%s:%s:tot_bx/D:blue/I:yell/I",bbc_cols,zdc_cols,vpd_cols);
printf("%s\n",cols);
acc->ReadFile(acc_file,cols);
acc->Print();
Int_t IMAX_tmp = acc->GetMaximum("i");
const Int_t IMAX = IMAX_tmp;
// set branch addresses to read through acc tree
Int_t index,runnum,fill_index,fill,bx;
Double_t bbc[8];
Double_t zdc[8];
Double_t vpd[8];
Double_t time;
Double_t tot_bx;
Int_t blue,yell;
acc->SetBranchAddress("i",&index);
acc->SetBranchAddress("runnum",&runnum);
acc->SetBranchAddress("fi",&fill_index);
acc->SetBranchAddress("fill",&fill);
acc->SetBranchAddress("t",&time);
acc->SetBranchAddress("bx",&bx);
char str[16];
for(Int_t i=0; i<8; i++) { sprintf(str,"bbc_%d",i); acc->SetBranchAddress(str,&bbc[i]); };
for(Int_t i=0; i<8; i++) { sprintf(str,"zdc_%d",i); acc->SetBranchAddress(str,&zdc[i]); };
for(Int_t i=0; i<8; i++) { sprintf(str,"vpd_%d",i); acc->SetBranchAddress(str,&vpd[i]); };
acc->SetBranchAddress("tot_bx",&tot_bx);
acc->SetBranchAddress("blue",&blue);
acc->SetBranchAddress("yell",&yell);
// build arrays for restructuring; arrays are needed so that
// we can implement bXing shift corrections
Double_t bbce_arr[IMAX][120];
Double_t bbcw_arr[IMAX][120];
Double_t bbcx_arr[IMAX][120];
Double_t zdce_arr[IMAX][120];
Double_t zdcw_arr[IMAX][120];
Double_t zdcx_arr[IMAX][120];
Double_t vpde_arr[IMAX][120];
Double_t vpdw_arr[IMAX][120];
Double_t vpdx_arr[IMAX][120];
Int_t runnum_arr[IMAX];
Int_t fi_arr[IMAX];
Int_t fill_arr[IMAX];
Double_t time_arr[IMAX];
Double_t tot_bx_arr[IMAX][120];
Int_t blue_arr[IMAX][120];
Int_t yell_arr[IMAX][120];
Bool_t kicked_arr[IMAX][120];
// restructure tree into one suitable for analysis
TTree * sca = new TTree("sca","restructured tree");
Double_t bbce,bbcw,bbcx; // e=east, w=west, x=coincidence
Double_t zdce,zdcw,zdcx;
Double_t vpde,vpdw,vpdx;
Bool_t okEntry,kicked;
sca->Branch("i",&index,"i/I");
sca->Branch("runnum",&runnum,"runnum/I");
sca->Branch("fi",&fill_index,"fi/I");
sca->Branch("fill",&fill,"fill/I");
sca->Branch("t",&time,"t/D");
sca->Branch("bx",&bx,"bx/I");
sca->Branch("bbce",&bbce,"bbce/D");
sca->Branch("bbcw",&bbcw,"bbcw/D");
sca->Branch("bbcx",&bbcx,"bbcx/D");
sca->Branch("zdce",&zdce,"zdce/D");
sca->Branch("zdcw",&zdcw,"zdcw/D");
sca->Branch("zdcx",&zdcx,"zdcx/D");
sca->Branch("vpde",&vpde,"vpde/D");
sca->Branch("vpdw",&vpdw,"vpdw/D");
sca->Branch("vpdx",&vpdx,"vpdx/D");
sca->Branch("tot_bx",&tot_bx,"tot_bx/D");
sca->Branch("blue",&blue,"blue/I");
sca->Branch("yell",&yell,"yell/I");
sca->Branch("kicked",&kicked,"kicked/O");
// read kicked bunches tree from "kicked" file
TTree * kicked_tr = new TTree();
kicked_tr->ReadFile("kicked","fill/I:bx/I:spinbit/I");
Int_t kicked_fill,kicked_bx,kicked_spinbit;
kicked_tr->SetBranchAddress("fill",&kicked_fill);
kicked_tr->SetBranchAddress("bx",&kicked_bx);
kicked_tr->SetBranchAddress("spinbit",&kicked_spinbit);
for(Int_t q=0; q<acc->GetEntries(); q++)
{
acc->GetEntry(q);
// -- see doc for bit details
// BBC, ZDC, VPD bits: [ x w e ]
bbce = bbc[1] + bbc[3] + bbc[5] + bbc[7]; // e + we + xe + xwe
bbcw = bbc[2] + bbc[3] + bbc[6] + bbc[7]; // w + we + xw + xwe
bbcx = bbc[3] + bbc[7]; // we + xwe
zdce = zdc[1] + zdc[3] + zdc[5] + zdc[7]; // e + we + xe + xwe
zdcw = zdc[2] + zdc[3] + zdc[6] + zdc[7]; // w + we + xw + xwe
zdcx = zdc[3] + zdc[7]; // we + xwe
vpde = vpd[1] + vpd[3] + vpd[5] + vpd[7]; // e + we + xe + xwe
vpdw = vpd[2] + vpd[3] + vpd[6] + vpd[7]; // w + we + xw + xwe
vpdx = vpd[3] + vpd[7]; // we + xwe
// KICKED BUNCHES
// manually omit empty bunches documented in pathologies.dat -- CLEAN UP PROCEDURE
// (see 09.01.14 log entry)
okEntry=true;
// kicked bunches (presumably empty)
/*
if(fill==17384 && (bx==29 || bx==30 || bx==117)) okEntry=false;
if(fill==17416 && bx==79) okEntry=false;
if(fill==17491 && bx==105) okEntry=false;
if(fill==17519 && (bx==94 || bx==109)) okEntry=false;
if(fill==17520 && bx==0) okEntry=false;
if(fill==17529 && bx==97) okEntry=false;
if(fill==17534 && bx==112) okEntry=false;
if(fill==17553 && bx==73) okEntry=false;
if(fill==17554 && (bx==7 || bx==14)) okEntry=false;
if(fill==17555 && bx==61) okEntry=false;
if(fill==17576 && bx==94) okEntry=false;
// afterpulse-like bunches -- remove 1st 2 bunches after abort gaps
//if(fill==17512 && (bx>=40 && bx<=59)) okEntry=false;
//if((fill>=17513 && fill<=17520) && ((bx>=0 && bx<=19) || (bx>=40 && bx<=59))) okEntry=false;
*/
for(Int_t kk=0; kk<kicked_tr->GetEntries(); kk++)
{
kicked_tr->GetEntry(kk);
if(fill==kicked_fill && bx==kicked_bx) okEntry=false;
};
kicked=!okEntry; // cleaned up analysis
//kicked=0; // take all bXings
// store data into arrays, implementing bXing shift corrections on scalers
if(fill==16570 ||
fill==16567)
{
bbce_arr[index-1][(bx+113)%120] = bbce; // shift down 7 bXings
bbcw_arr[index-1][(bx+113)%120] = bbcw;
bbcx_arr[index-1][(bx+113)%120] = bbcx;
zdce_arr[index-1][(bx+113)%120] = zdce; // shift down 7 bXings
zdcw_arr[index-1][(bx+113)%120] = zdcw;
zdcx_arr[index-1][(bx+113)%120] = zdcx;
vpde_arr[index-1][(bx+113)%120] = vpde; // shift down 7 bXings
vpdw_arr[index-1][(bx+113)%120] = vpdw;
vpdx_arr[index-1][(bx+113)%120] = vpdx;
}
else if(fill == 16582 ||
fill == 16586 ||
fill == 16587 ||
fill == 16592 ||
fill == 16593 ||
fill == 16594 ||
fill == 16597 ||
fill == 16602)
{
bbce_arr[index-1][bx] = bbce; // no shift
bbcw_arr[index-1][bx] = bbcw;
bbcx_arr[index-1][bx] = bbcx;
zdce_arr[index-1][bx] = zdce; // no shift
zdcw_arr[index-1][bx] = zdcw;
zdcx_arr[index-1][bx] = zdcx;
vpde_arr[index-1][(bx+1)%120] = vpde; // shift up 1 bXings
vpdw_arr[index-1][(bx+1)%120] = vpdw;
vpdx_arr[index-1][(bx+1)%120] = vpdx;
}
else
{
bbce_arr[index-1][bx] = bbce;
bbcw_arr[index-1][bx] = bbcw;
bbcx_arr[index-1][bx] = bbcx;
zdce_arr[index-1][bx] = zdce;
zdcw_arr[index-1][bx] = zdcw;
zdcx_arr[index-1][bx] = zdcx;
vpde_arr[index-1][bx] = vpde;
vpdw_arr[index-1][bx] = vpdw;
vpdx_arr[index-1][bx] = vpdx;
};
runnum_arr[index-1] = runnum;
fi_arr[index-1] = fill_index;
fill_arr[index-1] = fill;
time_arr[index-1] = time;
tot_bx_arr[index-1][bx] = tot_bx;
blue_arr[index-1][bx] = blue;
yell_arr[index-1][bx] = yell;
kicked_arr[index-1][bx] = kicked;
};
// fill restructured tree
for(Int_t i=0; i<IMAX; i++)
{
index = i+1;
runnum = runnum_arr[i];
fill_index = fi_arr[i];
fill = fill_arr[i];
time = time_arr[i];
for(Int_t b=0; b<120; b++)
{
bx = b;
bbce = bbce_arr[i][b];
bbcw = bbcw_arr[i][b];
bbcx = bbcx_arr[i][b];
zdce = zdce_arr[i][b];
zdcw = zdcw_arr[i][b];
zdcx = zdcx_arr[i][b];
vpde = vpde_arr[i][b];
vpdw = vpdw_arr[i][b];
vpdx = vpdx_arr[i][b];
tot_bx = tot_bx_arr[i][b];
blue = blue_arr[i][b];
yell = yell_arr[i][b];
kicked = kicked_arr[i][b];
sca->Fill();
};
};
TFile * outfile = new TFile("counts.root","RECREATE");
acc->Write("acc");
sca->Write("sca");
printf("counts.root written\n");
};
void
ModXSec(string inFile, string outFile, bool removeTaus=true, bool applyKFactors=true){
bool doTC = inFile.find("TC") != string::npos;
cout<<"doTC is "<<doTC<<endl;
TTree* tLimit = new TTree("tLimit", "Limits");
tLimit->ReadFile(inFile.c_str());
ofstream out(outFile.c_str());
if(doTC) out<<"Rho/F:";
else out<<"Mass/F:";
if(doTC){
out<<"Pi/F:";
out<<"SinX/F:";
}
out<<"Xsec/F:"
<<"percentError/F"
<<endl;
//kfactors
TGraph* gK = new TGraph(20);
gK->SetPoint( 0, 200,1.347);
gK->SetPoint( 1, 300,1.347);
gK->SetPoint( 2, 500,1.363);
gK->SetPoint( 3, 700,1.351);
gK->SetPoint( 4, 900,1.347);
gK->SetPoint( 5,1100,1.331);
gK->SetPoint( 6,1300,1.317);
gK->SetPoint( 7,1500,1.293);
gK->SetPoint( 8,1700,1.257);
gK->SetPoint( 9,1900,1.230);
gK->SetPoint( 10,2000,1.214);
//Signal pdf uncertainties
TGraph* gPerErr = new TGraph(20);
gPerErr->SetPoint( 0, 200,2.192);
gPerErr->SetPoint( 1, 300,2.192);
gPerErr->SetPoint( 2, 500,2.632);
gPerErr->SetPoint( 3, 700,3.070);
gPerErr->SetPoint( 4, 900,3.448);
gPerErr->SetPoint( 5,1100,3.771);
gPerErr->SetPoint( 6,1300,4.101);
gPerErr->SetPoint( 7,1500,4.339);
gPerErr->SetPoint( 8,1700,4.581);
gPerErr->SetPoint( 9,1900,4.846);
gPerErr->SetPoint( 10,2000,4.981);
if(doTC) tLimit->Draw("Rho:Xsec:Pi:SinX", "SinX > 0.32 && SinX<0.34", "para goff");
//if(doTC) tLimit->Draw("Rho:Xsec:Pi:SinX", "(280<=Rho && Rho<=300) && (150<=Pi && Pi<=160)", "para goff");
else tLimit->Draw("Mass:Xsec", "", "para goff");
float n = tLimit->GetSelectedRows();
for(int isample=0; isample<n; ++isample){
int idx=0;
Double_t mass = tLimit->GetVal(idx++)[isample];
Double_t xsec = tLimit->GetVal(idx++)[isample];
Double_t pi(-1), sinx(-1);
if(doTC){
pi = tLimit->GetVal(idx++)[isample];
sinx = tLimit->GetVal(idx++)[isample];
}
//cout<<"For rho: "<<rho<<" the kfactor is "<<gK->Eval(rho)<<endl;
//xsec *= 1e9; //convert from mb to pb
if(removeTaus) xsec *= 4./9.; //convert from emt to em
if(applyKFactors) xsec *= gK->Eval(mass);//apply k factor
Double_t perErr = gPerErr->Eval(mass);
out.precision(0) ;
out.setf ( ios::fixed, ios::floatfield);
out <<mass<<"\t";
if(doTC){
out.precision(0) ;
out.setf ( ios::fixed, ios::floatfield);
out <<pi<<"\t";
out.precision(4) ;
out.setf ( ios::fixed, ios::floatfield);
out <<sinx<<"\t";
}
out.precision(4) ;
out.setf ( ios::scientific, ios::floatfield);
out <<xsec<<"\t";
out.precision(3);
out.setf ( ios::fixed, ios::floatfield);
out<<perErr<<"\t";
out<<endl;
}
}
void csv(TString input="tmva.csvoutput.txt", TString par1="par2", TString par2="par3", TString par3="", TString value="eventEffScaled_5") {
std::cout << "Usage:" << std::endl
<< ".x scripts/csv.C with default arguments" << std::endl
<< ".x scripts/csv.C(filename, par1, par2, value)" << std::endl
<< std::endl
<< " Optional arguments:" << std::endl
<< " filename path to CSV file" << std::endl
<< " par1 name of X-parameter branch" << std::endl
<< " par2 name of Y-parameter branch (if empty, efficiency is drawn as a function of par1)" << std::endl
<< " value name of result (efficiency) branch" << std::endl
<< std::endl;
TTree *tree = new TTree("data", "data");
tree->ReadFile(input);
gStyle->SetPalette(1);
gStyle->SetPadRightMargin(0.14);
TCanvas *canvas = new TCanvas("csvoutput", "CSV Output", 1200, 900);
tree->SetMarkerStyle(kFullDotMedium);
tree->SetMarkerColor(kRed);
if(par2.Length() > 0) {
//tree->Draw(Form("%s:%s", par2.Data(), par1.Data()));
if(par3.Length() > 0)
tree->Draw(Form("%s:%s:%s:%s", par1.Data(), par2.Data(), par3.Data(), value.Data()), "", "COLZ"); //, "", "Z");
else
tree->Draw(Form("%s:%s:%s", par2.Data(), par1.Data(), value.Data()), "", "COLZ"); //, "", "Z");
TH1 *histo = tree->GetHistogram();
if(!histo)
return;
histo->SetTitle(Form("%s with different classifier parameters", value.Data()));
histo->GetXaxis()->SetTitle(Form("Classifier parameter %s", par1.Data()));
histo->GetYaxis()->SetTitle(Form("Classifier parameter %s", par2.Data()));
if(par3.Length() > 0)
histo->GetZaxis()->SetTitle(Form("Classifier parameter %s", par3.Data()));
else
histo->GetZaxis()->SetTitle("");
if(par3.Length() == 0) {
float x = 0;
float y = 0;
float val = 0;
double maxVal = tree->GetMaximum(value);
double minVal = tree->GetMinimum(value);
tree->SetBranchAddress(par1, &x);
tree->SetBranchAddress(par2, &y);
tree->SetBranchAddress(value, &val);
TLatex l;
l.SetTextSize(0.03);
Long64_t nentries = tree->GetEntries();
for(Long64_t entry=0; entry < nentries; ++entry) {
tree->GetEntry(entry);
l.SetTextColor(textColor(val, maxVal, minVal));
l.DrawLatex(x, y, Form("%.3f", val*100));
}
}
}
else {
tree->Draw(Form("%s:%s", value.Data(), par1.Data()));
TH1 *histo = tree->GetHistogram();
if(!histo)
return;
histo->SetTitle(Form("%s with different classifier parameters", value.Data()));
histo->GetXaxis()->SetTitle(Form("Classifier parameter %s", par1.Data()));
histo->GetYaxis()->SetTitle(value);
}
}
plot_stability_mean(){
gStyle->SetOptStat(0);
TTree *tfit = new TTree();
tfit->ReadFile("pi0peak_fit_Run13pp510ERT_reformat.txt","run_index/F:run_number:nevents:sector:mean:dmean:sigma:dsigma:chisquare");
TTree *tfit_raw = new TTree();
tfit_raw->ReadFile("pi0peak_fit_raw_Run13pp510ERT_reformat.txt","run_index/F:run_number:nevents:sector:mean:dmean:sigma:dsigma:chisquare");
TLine *lpi0 = new TLine( 0, 0.137, tfit->GetEntries("sector==0"), 0.137 );
lpi0->SetLineColor(kRed);
// frame
TH1F* hframe = new TH1F("hframe","",875,0,875);
hframe->GetYaxis()->SetRangeUser(0.12,0.16);
hframe->GetXaxis()->SetTitle("run");
hframe->GetYaxis()->SetTitle("mean [GeV]");
hframe->SetLineColor(kWhite);
// sectors PbSc-West
tfit->Draw("mean:run_index:dmean","sector==0");
TGraphErrors *g_mean_PbScW = new TGraphErrors( tfit->GetEntries("sector==0"), tfit->GetV2(), tfit->GetV1(), 0, tfit->GetV3());
tfit_raw->Draw("mean:run_index:dmean","sector==0");
TGraphErrors *g_mean_PbScW_raw = new TGraphErrors( tfit_raw->GetEntries("sector==0"), tfit_raw->GetV2(), tfit_raw->GetV1(), 0, tfit_raw->GetV3());
// sectors PbSc-East
tfit->Draw("mean:run_index:dmean","sector==1");
TGraphErrors *g_mean_PbScE = new TGraphErrors( tfit->GetEntries("sector==1"), tfit->GetV2(), tfit->GetV1(), 0, tfit->GetV3());
tfit_raw->Draw("mean:run_index:dmean","sector==1");
TGraphErrors *g_mean_PbScE_raw = new TGraphErrors( tfit_raw->GetEntries("sector==1"), tfit_raw->GetV2(), tfit_raw->GetV1(), 0, tfit_raw->GetV3());
// sectors PbGl-East
tfit->Draw("mean:run_index:dmean","sector==2");
TGraphErrors *g_mean_PbGlE = new TGraphErrors( tfit->GetEntries("sector==2"), tfit->GetV2(), tfit->GetV1(), 0, tfit->GetV3());
tfit_raw->Draw("mean:run_index:dmean","sector==2");
TGraphErrors *g_mean_PbGlE_raw = new TGraphErrors( tfit_raw->GetEntries("sector==2"), tfit_raw->GetV2(), tfit_raw->GetV1(), 0, tfit_raw->GetV3());
// Plotting
TCanvas *c_PbScW = new TCanvas();
hframe->Draw();
g_mean_PbScW->Draw("Psame");
lpi0->Draw("same");
c_PbScW->Print("plots-escale-check/mpi0_mean_PbScW.png");
TCanvas *c_PbScW_raw = new TCanvas();
hframe->Draw();
g_mean_PbScW_raw->Draw("Psame");
lpi0->Draw("same");
c_PbScW_raw->Print("plots-escale-check/mpi0_mean_PbScW_raw.png");
TCanvas *c_PbScE = new TCanvas();
hframe->Draw();
g_mean_PbScE->Draw("Psame");
lpi0->Draw("same");
c_PbScE->Print("plots-escale-check/mpi0_mean_PbScE.png");
TCanvas *c_PbScE_raw = new TCanvas();
hframe->Draw();
g_mean_PbScE_raw->Draw("Psame");
lpi0->Draw("same");
c_PbScE_raw->Print("plots-escale-check/mpi0_mean_PbScE_raw.png");
TCanvas *c_PbGlE = new TCanvas();
hframe->Draw();
g_mean_PbGlE->Draw("Psame");
lpi0->Draw("same");
c_PbGlE->Print("plots-escale-check/mpi0_mean_PbGlE.png");
TCanvas *c_PbGlE_raw = new TCanvas();
hframe->Draw();
g_mean_PbGlE_raw->Draw("Psame");
lpi0->Draw("same");
c_PbGlE_raw->Print("plots-escale-check/mpi0_mean_PbGlE_raw.png");
}
void
CalcLimit(bool useCLs=true, string inName="nEvents.txt", string outName="nLimit.txt"){
gErrorIgnoreLevel = kWarning;
gSystem->SetIncludePath( "-I$ROOFITSYS/include" );
gSystem->Load("libRooFit");
// gSystem->SetIncludePath( "-I/afs/hep.wisc.edu/cern/.root/root_v5.30.00.Linux-slc5_amd64-gcc4.3/include/RooStats" );
gROOT->ProcessLine(".L ../../../StatisticalTools/RooStatsRoutines/root/roostats_cl95.C+");
string outfile(outName.c_str());
ofstream out(outfile.c_str());
if(!out) {
cout << "Cannot open file " << outfile << endl;
abort();
}
out << setiosflags(ios::fixed) << setprecision(4) << setiosflags(ios::left);
out<<"SignalCode/F:"
<<"Mass/F:"
<<"Lumi/F:"
<<"sLumi/F:"
<<"Eff/F:"
<<"sEff/F:"
<<"DataEvts/F:"
<<"BkgEvts/F:"
<<"sBkgEvts/F:"
<<"ObsLimit/F:"
<<"ExpLimit/F:"
<<"ExpLimitP1/F:"
<<"ExpLimitM1/F:"
<<"ExpLimitP2/F:"
<<"ExpLimitM2/F"
<<endl;
TTree* tree = new TTree("tree", "Number of Events");
tree->ReadFile(inName.c_str());
tree->Draw("SignalCode:Mass:Lumi:DataEvts:BkgEvts:sBkgEvts:Eff:sEff",
"", "para goff");
float n = tree->GetSelectedRows();
for(int isample=0; isample<n; ++isample){
const Double_t SignalCode = tree->GetVal(0)[isample];
const Double_t mass = tree->GetVal(1)[isample];
const Double_t lumi = tree->GetVal(2)[isample];
const Double_t DataEvts = tree->GetVal(3)[isample];
const Double_t BkgEvts = tree->GetVal(4)[isample];
const Double_t sBkgEvts = tree->GetVal(5)[isample];
const Double_t Eff = tree->GetVal(6)[isample];
const Double_t sEff = tree->GetVal(7)[isample];
cout<<"Calculating limit for mass: "<<mass<<" and lumi: "<<lumi<<endl;
float sLumi = sLumiFrac*lumi;
Double_t obs_limit, exp_limit;
Double_t exp_up, exp_down, exp_2up, exp_2down;
if(useCLs){////CLs Limits
//Does not work for bayesian, only works with cls
LimitResult limit = roostats_limit(lumi, sLumi, Eff, sEff, BkgEvts, sBkgEvts, DataEvts, false, 0, "cls", "", 12345);
cout<<"\nCompleted Limit Calc\n";
obs_limit = limit.GetObservedLimit();
exp_limit = limit.GetExpectedLimit();
exp_up = limit.GetOneSigmaHighRange();
exp_down = limit.GetOneSigmaLowRange();
exp_2up = limit.GetTwoSigmaHighRange();
exp_2down = limit.GetTwoSigmaLowRange();
}else{
////Bayesian Limits
LimitResult limit = roostats_clm (lumi, sLumi, Eff, sEff, BkgEvts, sBkgEvts);
//obs_limit = limit.GetObservedLimit();
obs_limit = roostats_cl95(lumi, sLumi, Eff, sEff, BkgEvts, sBkgEvts, DataEvts, false, 0, "bayesian", "");
exp_limit = limit.GetExpectedLimit();
exp_up = limit.GetOneSigmaHighRange();
exp_down = limit.GetOneSigmaLowRange();
exp_2up = limit.GetTwoSigmaHighRange();
exp_2down = limit.GetTwoSigmaLowRange();
}
out<<setprecision(1)
<<SignalCode<<"\t"
<<setprecision(0)
<<mass<<"\t"
<<lumi<<"\t"
<<sLumi<<"\t"
<<setprecision(4)
<<Eff<<"\t"
<<sEff<<"\t"
<<setprecision(0)
<<DataEvts<<"\t"
<<setprecision(4)
<<BkgEvts<<"\t"
<<sBkgEvts<<"\t";
// out<<Value(obs_limit,-4)<<"\t"
// <<Value(exp_limit,-4)<<"\t"
// <<Value(exp_up,-4)<<"\t"
// <<Value(exp_down,-4)<<"\t"
// <<Value(exp_2up,-4)<<"\t"
// <<Value(exp_2down,-4)
// <<endl;
out<<setprecision(8)
<<obs_limit<<"\t"
<<exp_limit<<"\t"
<<exp_up<<"\t"
<<exp_down<<"\t"
<<exp_2up<<"\t"
<<exp_2down
<<endl;
}
out.close();
cout<<"Done\n";
return;
}
