//------------------------------------------------------------------------------
std::pair<double,double> fitskwlin( char* hs, double xl=-0.1, double xr=0.1 ) {
TH1 *h = (TH1*)gDirectory->Get(hs);
if( h == NULL ) {
cout << hs << " does not exist\n";
return std::make_pair(0.,0.);
}
int nb = h->GetNbinsX();
double x1 = h->GetBinCenter(1); // first
double x9 = h->GetBinCenter(nb); // last
if( xl > x1 && xl < x9 ) x1 = xl; // left
if( xr > x1 && xr < x9 ) x9 = xr; // right
// create a TF1 with the range from x1 to x9 and 3 parameters
TF1 *tanhFcn = new TF1( "tanhFcn", fitSkw, x1, x9, 2 );
tanhFcn->SetParName( 0, "dyoff" );
tanhFcn->SetParName( 1, "dyslp" );
// set start values:
tanhFcn->SetParameter( 0, 0 ); // dy off [um]
tanhFcn->SetParameter( 1, 99 ); // dy slope [um/skw]
h->Fit( "tanhFcn", "R Q", "p" );// R = range from tanhFcn
return std::make_pair(tanhFcn->GetParameter(0),tanhFcn->GetParameter(1));
}
Double_t fitgp0( char* hs ) {
TH1 *h = (TH1*)gDirectory->Get(hs);
if( h == NULL ){
cout << hs << " does not exist\n";
return 0;
}
h->SetMarkerStyle(21);
h->SetMarkerSize(0.8);
h->SetStats(1);
gStyle->SetOptFit(101);
gROOT->ForceStyle();
double dx = h->GetBinWidth(1);
double nmax = h->GetBinContent(h->GetMaximumBin());
double xmax = h->GetBinCenter(h->GetMaximumBin());
double nn = 7*nmax;
int nb = h->GetNbinsX();
double n1 = h->GetBinContent(1);
double n9 = h->GetBinContent(nb);
double bg = 0.5*(n1+n9);
double x1 = h->GetBinCenter(1);
double x9 = h->GetBinCenter(nb);
// create a TF1 with the range from x1 to x9 and 4 parameters
TF1 *gp0Fcn = new TF1( "gp0Fcn", gp0Fit, x1, x9, 4 );
gp0Fcn->SetParName( 0, "mean" );
gp0Fcn->SetParName( 1, "sigma" );
gp0Fcn->SetParName( 2, "area" );
gp0Fcn->SetParName( 3, "BG" );
gp0Fcn->SetNpx(500);
gp0Fcn->SetLineWidth(4);
gp0Fcn->SetLineColor(kMagenta);
gp0Fcn->SetLineColor(kGreen);
// set start values for some parameters:
gp0Fcn->SetParameter( 0, xmax ); // peak position
gp0Fcn->SetParameter( 1, 4*dx ); // width
gp0Fcn->SetParameter( 2, nn ); // N
gp0Fcn->SetParameter( 3, bg );
// N: not drawing
// Q: quiet
// R: use specified range
h->Fit( "gp0Fcn", "NQR", "ep" );
return gp0Fcn->GetParameter(1);
}
void KVCanvas::ProjectionX(TH2* hh)
{
TString pname = Form("%s_px", hh->GetName());
Int_t ip = 1;
while (gROOT->FindObject(pname.Data())) {
pname = Form("%s_px%d", hh->GetName(), ip);
ip++;
}
TH1* px = hh->ProjectionX(pname.Data());
if (!px) return;
Double_t minY = (hh->GetYaxis()->GetXmin());
Double_t maxY = (hh->GetYaxis()->GetXmax());
Double_t dY = (maxY - minY) * 0.8;
Double_t maxH = px->GetBinContent(px->GetMaximumBin());
TGraph* gg = 0;
if ((gg = (TGraph*)gROOT->FindObject(Form("%s_gjx", hh->GetName())))) gg->Delete();
gg = new TGraph;
for (int i = 0; i < px->GetNbinsX(); i++) {
gg->SetPoint(i, px->GetBinCenter(i), minY + px->GetBinContent(i)*dY / maxH);
}
gg->SetName(Form("%s_gjx", hh->GetName()));
gg->SetTitle(Form("%s_gjx", hh->GetName()));
gg->SetLineColor(kBlack);
gg->SetMarkerColor(kBlack);
gg->SetMarkerStyle(8);
gg->Draw("PL");
Modified();
Update();
}
Double_t fitep0sigma( char* hs, int binlow=-999, int binhigh=999) {
TH1 *h = (TH1*)gDirectory->Get(hs);
if( h == NULL ){ cout << hs << " does not exist\n"; return 0; }
double dx = h->GetBinWidth(1);
double nmax = h->GetBinContent(h->GetMaximumBin());
double xmax = h->GetBinCenter(h->GetMaximumBin());
double nn = 7*nmax;
int nb = h->GetNbinsX();
double n1 = h->GetBinContent(1);
double n9 = h->GetBinContent(nb);
double bg = 0.5*(n1+n9);
double x1, x9;
if(binlow < -900 && binhigh > 900) {
x1 = h->GetBinCenter(1);
x9 = h->GetBinCenter(nb);
}
else {
x1 = binlow;
x9 = binhigh;
}
// create a TF1 with the range from x1 to x9 and 5 parameters
TF1 *ep0Fcn = new TF1( "ep0Fcn", ep0Fit, x1, x9, 5 );
ep0Fcn->SetParName( 0, "mean" );
ep0Fcn->SetParName( 1, "sigma" );
ep0Fcn->SetParName( 2, "pow" );
ep0Fcn->SetParName( 3, "area" );
ep0Fcn->SetParName( 4, "BG" );
// Start values for some parameters:
ep0Fcn->SetParameter( 0, xmax ); // peak position
ep0Fcn->SetParameter( 1, 4*dx ); // width
ep0Fcn->SetParameter( 2, 3.3 ); // pow
ep0Fcn->SetParameter( 3, nn ); // N
ep0Fcn->SetParameter( 4, bg );
h->Fit("ep0Fcn", "Q R", "ep" );
TF1 *fit = h->GetFunction("ep0Fcn");
return fit->GetParameter(1);
}
RooHistN::RooHistN(const TH1 &data1, const TH1 &data2, Double_t nominalBinWidth, Double_t nSigma, Double_t xErrorFrac) :
TGraphAsymmErrors(), _nominalBinWidth(nominalBinWidth), _nSigma(nSigma), _rawEntries(-1)
{
// Create a histogram from the asymmetry between the specified TH1 objects
// which may have fixed or variable bin widths, but which must both have
// the same binning. The asymmetry is calculated as (1-2)/(1+2). Error bars are
// calculated using Binomial statistics. Prints a warning and rounds
// any bins with non-integer contents. Use the optional parameter to
// specify the confidence level in units of sigma to use for
// calculating error bars. The nominal bin width specifies the
// default used by addAsymmetryBin(), and is used to set the relative
// normalization of bins with different widths. If not set, the
// nominal bin width is calculated as range/nbins.
initialize();
// copy the first input histogram's name and title
SetName(data1.GetName());
SetTitle(data1.GetTitle());
// calculate our nominal bin width if necessary
if(_nominalBinWidth == 0) {
const TAxis *axis= ((TH1&)data1).GetXaxis();
if(axis->GetNbins() > 0) _nominalBinWidth= (axis->GetXmax() - axis->GetXmin())/axis->GetNbins();
}
setYAxisLabel(Form("Asymmetry (%s - %s)/(%s + %s)",
data1.GetName(),data2.GetName(),data1.GetName(),data2.GetName()));
// initialize our contents from the input histogram contents
Int_t nbin= data1.GetNbinsX();
if(data2.GetNbinsX() != nbin) {
coutE(InputArguments) << "RooHistN::RooHistN: histograms have different number of bins" << endl;
return;
}
for(Int_t bin= 1; bin <= nbin; bin++) {
Axis_t x= data1.GetBinCenter(bin);
if(fabs(data2.GetBinCenter(bin)-x)>1e-10) {
coutW(InputArguments) << "RooHistN::RooHistN: histograms have different centers for bin " << bin << endl;
}
Stat_t y1= data1.GetBinContent(bin);
Stat_t y2= data2.GetBinContent(bin);
addAsymmetryBin(x,roundBin(y1),roundBin(y2),data1.GetBinWidth(bin),xErrorFrac);
}
// we do not have a meaningful number of entries
_entries= -1;
}
/**
* Create ratios to other data
*
* @param ib Bin number
* @param res Result
* @param alice ALICE result if any
* @param cms CMS result if any
* @param all Stack to add ratio to
*/
void Ratio2Stack(Int_t ib, TH1* res, TGraph* alice, TGraph* cms, THStack* all)
{
if (!all || !res || !(alice || cms)) return;
Int_t off = 5*ib;
TGraph* gs[] = { (alice ? alice : cms), (alice ? cms : 0), 0 };
TGraph** pg = gs;
while (*pg) {
TGraph* g = *pg;
const char* n = (g == alice ? "ALICE" : "CMS");
TH1* r = static_cast<TH1*>(res->Clone(Form("ratio%s", n)));
TString tit(r->GetTitle());
tit.ReplaceAll("Corrected", Form("Ratio to %s", n));
r->SetTitle(tit);
r->SetMarkerColor(g->GetMarkerColor());
r->SetLineColor(g->GetLineColor());
TObject* tst = r->FindObject("legend");
if (tst) r->GetListOfFunctions()->Remove(tst);
for (Int_t i = 1; i <= r->GetNbinsX(); i++) {
Double_t c = r->GetBinContent(i);
Double_t e = r->GetBinError(i);
Double_t o = g->Eval(r->GetBinCenter(i));
if (o < 1e-12) {
r->SetBinContent(i, 0);
r->SetBinError(i, 0);
continue;
}
r->SetBinContent(i, (c - o) / o + off);
r->SetBinError(i, e / o);
}
all->Add(r);
pg++;
}
TLegend* leg = StackLegend(all);
if (!leg) return;
TString txt = res->GetTitle();
txt.ReplaceAll("Corrected P(#it{N}_{ch}) in ", "");
if (ib == 0) txt.Append(" "); // (#times1)");
// else if (ib == 1) txt.Append(" (#times10)");
else txt.Append(Form(" (+%d)", off));
TObject* dummy = 0;
TLegendEntry* e = leg->AddEntry(dummy, txt, "p");
e->SetMarkerStyle(res->GetMarkerStyle());
e->SetMarkerSize(res->GetMarkerSize());
e->SetMarkerColor(kBlack);
e->SetFillColor(0);
e->SetFillStyle(0);
e->SetLineColor(kBlack);
}
double fittp0sigma( char* hs ) {
TH1 *h = (TH1*)gDirectory->Get(hs);
if( h == NULL ){ cout << hs << " does not exist\n"; return 0; }
double dx = h->GetBinWidth(1);
double nmax = h->GetBinContent(h->GetMaximumBin());
double xmax = h->GetBinCenter(h->GetMaximumBin());
double nn = 7*nmax;
int nb = h->GetNbinsX();
double n1 = h->GetBinContent(1);
double n9 = h->GetBinContent(nb);
double bg = 0.5*(n1+n9);
double x1 = h->GetBinCenter(1);
double x9 = h->GetBinCenter(nb);
// create a TF1 with the range from x1 to x9 and 5 parameters
TF1 *tp0Fcn = new TF1( "tp0Fcn", tp0Fit, x1, x9, 5 );
tp0Fcn->SetParName( 0, "mean" );
tp0Fcn->SetParName( 1, "sigma" );
tp0Fcn->SetParName( 2, "nu" );
tp0Fcn->SetParName( 3, "area" );
tp0Fcn->SetParName( 4, "BG" );
// set start values for some parameters:
tp0Fcn->SetParameter( 0, xmax ); // peak position
tp0Fcn->SetParameter( 1, 4*dx ); // width
tp0Fcn->SetParameter( 2, 2.2 ); // nu
tp0Fcn->SetParameter( 3, nn ); // N
tp0Fcn->SetParameter( 4, bg );
h->Fit( "tp0Fcn", "Q R", "ep" );
// h->Fit("tp0Fcn","V+","ep");
TF1 *fit = h->GetFunction("tp0Fcn");
return fit->GetParameter(1);
}
std::vector<double> fitskwpol( char* hs, double xl=-0.1, double xr=0.1) {
TH1 *h = (TH1*)gDirectory->Get(hs);
if( h == NULL ) {
cout << hs << " does not exist\n";
return std::vector<double>();
}
int nb = h->GetNbinsX();
double x1 = h->GetBinCenter(1); // first
double x9 = h->GetBinCenter(nb); // last
if( xl > x1 && xl < x9 ) x1 = xl; // left
if( xr > x1 && xr < x9 ) x9 = xr; // right
// create a TF1 with the range from x1 to x9 and 3 parameters
TF1 *tanhFcn = new TF1( "tanhFcn", fitSkwPol, x1, x9, 4 );
tanhFcn->SetParName( 0, "dyoff" );
tanhFcn->SetParName( 1, "dyslp" );
tanhFcn->SetParName( 2, "dypar" );
tanhFcn->SetParName( 3, "dyhyp" );
// set start values:
tanhFcn->SetParameter( 0, 0 ); // dy off [um]
tanhFcn->SetParameter( 1, 99 ); // dy slope [um/skw]
tanhFcn->SetParameter( 2, 0 ); // dy parabola
tanhFcn->SetParameter( 3, 0 ); // dy hyperbola
h->Fit( "tanhFcn", "R Q", "p" );// R = range from tanhFcn
std::vector<double> result;
for(size_t i = 0; i < 4; i++) {
result.push_back(tanhFcn->GetParameter(i));
}
return result;
}
Double_t fitfulllang( char* hs ) {
TH1 *h = (TH1*)gDirectory->Get(hs);
if( h == NULL ){
cout << hs << " does not exist\n";
return 0;
}
double aa = h->GetEntries();//normalization
// find peak:
int ipk = h->GetMaximumBin();
double xpk = h->GetBinCenter(ipk);
double sm = xpk / 9; // sigma
double ns = sm; // noise
// fit range:
int ib0 = ipk/2;
int ib9 = h->GetNbinsX() - 1;
double x0 = h->GetBinLowEdge(ib0);
double x9 = h->GetBinLowEdge(ib9) + h->GetBinWidth(ib9);
// create a TF1 with the range from x0 to x9 and 4 parameters
TF1 *fitFcn = new TF1( "fitFcn", fitLandauGauss, x0, x9, 4 );
fitFcn->SetParName( 0, "peak" );
fitFcn->SetParName( 1, "sigma" );
fitFcn->SetParName( 2, "area" );
fitFcn->SetParName( 3, "smear" );
fitFcn->SetNpx(500);
fitFcn->SetLineWidth(4);
fitFcn->SetLineColor(kMagenta);
// set start values:
fitFcn->SetParameter( 0, xpk ); // peak position, defined above
fitFcn->SetParameter( 1, sm ); // width
fitFcn->SetParameter( 2, aa ); // area
fitFcn->SetParameter( 3, ns ); // noise
h->Fit("fitFcn", "NQR", "ep" );// R = range from fitFcn
return fitFcn->GetParameter(0);
}
//======================================================================
// takes the ID of a graph to fill into a pre-booked histo
//
void fill1DHistoFromGraph(std::string& gid,
wTH1 *&wth1)
{
map<string, wGraph_t *>::const_iterator it=glmap_id2graph.find(gid);
if (it==glmap_id2graph.end()) {
cerr<<"Couldn't find graph with id "<<gid<<", define first"<<endl;
exit(-1);
}
if (gl_verbose)
cout << "Loading histo from graph " << gid << endl;
TH1 *h = wth1->histo();
for (int ibin=1; ibin <= h->GetNbinsX(); ibin++)
h->SetBinContent(ibin,it->second->gr->Eval(h->GetBinCenter(ibin)));
} // fill1DHistoFromGraph
RooHistN::RooHistN(const TH1 &data, Double_t nominalBinWidth, Double_t nSigma, RooAbsData::ErrorType etype, Double_t xErrorFrac) :
TGraphAsymmErrors(), _nominalBinWidth(nominalBinWidth), _nSigma(nSigma), _rawEntries(-1)
{
// Create a histogram from the contents of the specified TH1 object
// which may have fixed or variable bin widths. Error bars are
// calculated using Poisson statistics. Prints a warning and rounds
// any bins with non-integer contents. Use the optional parameter to
// specify the confidence level in units of sigma to use for
// calculating error bars. The nominal bin width specifies the
// default used by addBin(), and is used to set the relative
// normalization of bins with different widths. If not set, the
// nominal bin width is calculated as range/nbins.
initialize();
// copy the input histogram's name and title
SetName(data.GetName());
SetTitle(data.GetTitle());
// calculate our nominal bin width if necessary
if(_nominalBinWidth == 0) {
const TAxis *axis= ((TH1&)data).GetXaxis();
if(axis->GetNbins() > 0) _nominalBinWidth= (axis->GetXmax() - axis->GetXmin())/axis->GetNbins();
}
// TH1::GetYaxis() is not const (why!?)
setYAxisLabel(const_cast<TH1&>(data).GetYaxis()->GetTitle());
// initialize our contents from the input histogram's contents
Int_t nbin= data.GetNbinsX();
for(Int_t bin= 1; bin <= nbin; bin++) {
Axis_t x= data.GetBinCenter(bin);
Stat_t y= data.GetBinContent(bin);
Stat_t dy = data.GetBinError(bin) ;
if (etype==RooAbsData::Poisson) {
addBin(x,roundBin(y),data.GetBinWidth(bin),xErrorFrac);
} else {
addBinWithError(x,y,dy,dy,data.GetBinWidth(bin),xErrorFrac);
}
}
// add over/underflow bins to our event count
_entries+= data.GetBinContent(0) + data.GetBinContent(nbin+1);
}
void HistToText () {
TFile *f = new TFile("/music/bpt1/bpt/bdn/shane/137i/rootfiles/137i07.root", "READ");
// TFile *f = new TFile("/music/bpt1/bpt/bdn/shane/135sb/rootfiles/135sb08.root", "READ");
// TFile *f = new TFile("/music/bpt1/bpt/bdn/shane/136sb/rootfiles/136sb01.root", "READ");
// TFile *f = new TFile("/music/bpt1/bpt/bdn/shane/140i/rootfiles/140i0.root", "READ");
TH1 *h = (TH1*)f->Get("h_En");
Int_t nBins = h->GetXaxis()->GetNbins();
cout << nBins << endl;
ofstream outfile;
outfile.open("HistToTextOutput.txt", std::ofstream::out);
Double_t x, y;
for (Int_t i = 0; i<=nBins; i++) {
x = h->GetBinCenter(i);
y = h->GetBinContent(i);
outfile << x << "," << y << endl;
}
outfile.close();
}
void dataCutM(int cent0=20, int cent1=25, int from=0, int to=34){
char name[200];
int bad, centrality;
float trk_Q [RDET][NHAR];
float trk_Psi [RDET][NHAR];
float cal_Q [CDET][NHAR];
float cal_Psi [CDET][NHAR];
TChain* tree = new TChain("tree");
char dfilelist[100];
sprintf(dfilelist,"outlist.txt");
ifstream lis(dfilelist);
int cnt=0;
int dnt=0;
while(!lis.eof())
{
string filename;
lis >> filename;
if(cnt>=from&&cnt<to)
{
cout << filename << endl;
if(!filename.empty()) tree->Add(filename.c_str());
dnt++;
}
cnt++;
}
tree->SetBranchAddress("bad", &bad);
tree->SetBranchAddress("centrality", ¢rality);
tree->SetBranchAddress("trk_Q", trk_Q );
tree->SetBranchAddress("trk_Psi", trk_Psi );
tree->SetBranchAddress("cal_Q", cal_Q );
tree->SetBranchAddress("cal_Psi", cal_Psi );
float Trk_Q [RDET][NHAR];
float Trk_Psi[RDET][NHAR];
float Cal_Q [CDET][NHAR];
float Cal_Psi[CDET][NHAR];
Init(cent0, cent1);
cout<<"Run Centrality "<<cent0<<" "<<cent1<<endl;
int nevents = tree->GetEntries();
cout<<"nevents "<<nevents<<endl;
// for(int iev=0; iev<2000000; iev++){
float maxqcut[CDET][NHAR] = {{0}};
for(int ihar=0; ihar<NHAR; ihar++){ for(int idet=0; idet<CDET; idet++){ maxqcut[idet][ihar] = 0; }}
for(int iev=0; iev<nevents; iev++){
tree->GetEntry(iev);
if(iev%1000000==0) cout<<iev<<endl;
if(centrality>=cent1 || centrality<cent0) continue;
hcent->Fill(centrality);
for(int idet = 0; idet<RDET; idet++){
for(int ihar=0; ihar<NHAR; ihar++){
Trk_Q[idet][ihar] = trk_Q[idet][ihar];
Trk_Psi[idet][ihar] = trk_Psi[idet][ihar];
}
}
for(int idet = 0; idet<CDET; idet++){
for(int ihar=0; ihar<NHAR; ihar++){
Cal_Q[idet][ihar] = cal_Q[idet][ihar];
Cal_Psi[idet][ihar] = cal_Psi[idet][ihar];
}
}
double dQ[] = {0,0,0,0,0,0,0};
double dPsi[] = {0,0,0,0,0,0,0};
for(int ih=0; ih<NHAR;ih++){
dQ[ih] = Cal_Q[0][ih] - Cal_Q[1][ih];
dPsi[ih] = (Cal_Psi[0][ih] - Cal_Psi[1][ih]);
dPsi[ih] = atan2(sin(dPsi[ih]), cos(dPsi[ih]));
}
for(int ihar=0; ihar<NHAR; ihar++){
for(int idet=0; idet<CDET; idet++){
if(Cal_Q[idet][ihar] >maxqcut[idet][ihar]) maxqcut[idet][ihar] = Cal_Q[idet][ihar];
hqFcal[idet][ihar] ->Fill(Cal_Q[idet][ihar]);
}
hQPsi[NA-1][ihar] ->Fill(dPsi[ihar],dQ[ihar]);
}
}//end of events
TH1* htmp;
float steps[] = {0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.01};
float qcut[CDET][NHAR][NQ];
for(int idet=0; idet<CDET; idet++){
for(int ihar=0; ihar<NHAR; ihar++){
sprintf(name,"scale_%d_%d", idet, ihar);
htmp = (TH1*)hqFcal[idet][ihar] ->Clone(name);
htmp-> Scale(1.0/htmp->GetEntries());
htmp-> SetTitle(name);
double sum = 0;
int cnt = 0;
for(int ib=1; ib<=htmp->GetNbinsX(); ib++){
sum+= htmp->GetBinContent(ib);
if(sum>steps[cnt]) { qcut[idet][ihar][cnt] = htmp->GetBinCenter(ib); cnt++;}
}
qcut[idet][ihar][9] = maxqcut[idet][ihar] + 0.00001;
cout<<idet<<" "<<ihar<<" "<<cnt<<" "<<sum<<endl;
}
}
ofstream tout;
sprintf(name,"cutInfo1_%d_%d.txt", cent0, cent1);
tout.open(name);
tout<<"cent "<<cent0<<"--"<<cent1<<endl;
for(int idet=0; idet<CDET; idet++){
tout<<"IDET = "<<idet<<endl;
for(int ihar=0; ihar<NHAR; ihar++){
for(int iq=0; iq<NQ; iq++){
if(iq==0) tout<<"{"<<qcut[idet][ihar][iq]<<", ";
else if(iq<9) tout<<qcut[idet][ihar][iq]<<", ";
else if(iq ==9) tout<<qcut[idet][ihar][iq]<<"}, "<<endl;
}
}
}
tout.close();
fileout->Write();
fileout->Close();
}
void CreatePictureBooks(const char* data_dir, int first_run, const int n_runs) {
gROOT->Reset();
gROOT->SetStyle("Plain");
gStyle->SetCanvasBorderMode(0); // turn off canvas borders
// Create the canvases
TCanvas* trend_canvas = new TCanvas("trend_canvas", "trend_canvas");
TFile* files[n_runs];
TCanvas* individual_canvases[n_runs];
// Names for opening, closing and saving to PDFs
std::stringstream individual_basepdfname[n_runs];
std::string individual_openpdfname[n_runs];
std::string individual_closepdfname[n_runs];
for (int iRun = 0; iRun < n_runs; ++iRun) {
int run_number = first_run + iRun;
// Open up the file for this run
std::stringstream filename;
filename << data_dir << "/hist/hist0" << run_number << ".root";
files[iRun] = new TFile(filename.str().c_str(), "READ");
// Create an individual canvas for this run
std::stringstream canvasname;
canvasname << "individual_canvas_run0" << run_number;
individual_canvases[iRun] = new TCanvas(canvasname.str().c_str(),canvasname.str().c_str());
// Open a PDF for each run
individual_basepdfname[iRun].str("");
individual_basepdfname[iRun] << "DQ_LowLevel_RunPlots_Run0" << run_number << ".pdf";
individual_openpdfname[iRun] = individual_basepdfname[iRun].str() + "[";
individual_closepdfname[iRun] = individual_basepdfname[iRun].str() + "]";
individual_canvases[iRun]->Print(individual_openpdfname[iRun].c_str());
}
// Get the names of all the histograms
std::vector<std::string> histogram_names;
TIter nextFileKey(files[0]->GetListOfKeys()); // get the list of keys for the top level in the first file (all files should be the same)
TKey *fileKey;
while (fileKey = (TKey*)nextFileKey()) {
// Get the directory for low-level data quality plots first
if (strcmp(fileKey->ReadObj()->ClassName(), "TDirectoryFile") == 0) {
// Check that the directory has the correct name
if (strcmp(fileKey->ReadObj()->GetName(), "DataQuality_LowLevel") == 0) {
TDirectoryFile* dir = (TDirectoryFile*) fileKey->ReadObj();
TIter nextDirKey(dir->GetListOfKeys()); // get the list of keys in the directory (all histograms should be in this folder)
TKey *dirKey;
while (dirKey = (TKey*)nextDirKey()) {
// Get the names of all the histograms and count them up
if (strcmp(dirKey->ReadObj()->ClassName(), "TH1F") == 0 ||
strcmp(dirKey->ReadObj()->ClassName(), "TH2F") == 0) {
histogram_names.push_back(dirKey->ReadObj()->GetName());
} // end if (class is TH1F)
} // end while loop (through keys in the directory)
} // end if (directory is DataQuality_LowLevel)
} // end if (class is TDirectoryFile)
} // end while loop (through keys in file)
// Reorder the histogram names so that channels from the same board are next to each other (might make it easier to print 4 plots on the same page)
std::vector<std::string> ordered_histogram_names = OrderHistogramNames(histogram_names);
std::stringstream trend_basepdfname;
trend_basepdfname << "DQ_LowLevel_TrendPlots_Runs0" << first_run << "-" << first_run + n_runs << ".pdf";
std::string trend_openpdfname = trend_basepdfname.str() + "[";
std::string trend_closepdfname = trend_basepdfname.str() + "]";
trend_canvas->Print(trend_openpdfname.c_str());
// Now we have the histogram names, so loop though them
for (int iHist = 0; iHist < ordered_histogram_names.size(); ++iHist) {
std::string histname = ordered_histogram_names.at(iHist);
std::string fullhistname = "DataQuality_LowLevel/" + histname;
// Check to see if we actually want this plot
if ( !WantPlot(histname)) {
continue;
}
// Create the trend plot
std::string trendplotname = histname + "_TrendPlot";
std::string trendplottitle = "Trend plot of " + histname;
// Get some useful information from the histogram in the first run file (for the y-axis range of the trend plot)
TH1F* hist = (TH1F*) files[0]->Get(fullhistname.c_str());
TH2F* trend_plot = new TH2F(trendplotname.c_str(), trendplottitle.c_str(), n_runs, first_run, first_run+n_runs, hist->GetNbinsX(), hist->GetXaxis()->GetXmin(), hist->GetXaxis()->GetXmax());
trend_plot->GetYaxis()->SetTitle(hist->GetXaxis()->GetTitle());
trend_plot->GetYaxis()->SetLabelSize(0.03);
trend_plot->GetXaxis()->SetTitle("Run Number");
trend_plot->GetXaxis()->SetLabelSize(0.03);
trend_plot->GetZaxis()->SetTitle(hist->GetYaxis()->GetTitle());
trend_plot->GetZaxis()->SetLabelSize(0.03);
trend_plot->GetZaxis()->SetTitleOffset(0.85);
trend_plot->GetZaxis()->SetTitleSize(0.03);
trend_plot->SetStats(false);
// Set the fraction trend plots to have a maximum of 1 so that red = bad
if (histname.find("Fraction") != std::string::npos) {
trend_plot->GetZaxis()->SetRangeUser(0,1);
}
// Copy the axis labels so that they show the detector and channel names
else if (histname.find("hDQ_IslandRate") != std::string::npos) {
for (int jBin = 1; jBin < hist->GetNbinsX(); ++jBin) {
trend_plot->GetYaxis()->SetBinLabel(jBin, hist->GetXaxis()->GetBinLabel(jBin));
}
trend_plot->GetYaxis()->SetTitle(false);
trend_plot->GetYaxis()->SetLabelSize(0.02);
trend_plot->GetZaxis()->SetLabelSize(0.02);
}
// Check to see if we want this histogram as an individual or a trend plot
bool want_trend_plot = WantAsTrendPlot(histname);
// Loop through the runs
for (int iRun = 0; iRun < n_runs; ++iRun) {
// Make sure this file exists (there may be some missing in our golden run ranges)
if (files[iRun]->IsZombie())
continue;
// Get the histogram
TH1* hist = (TH1*) files[iRun]->Get(fullhistname.c_str());
if (want_trend_plot == false) {
// Print the histogram out directly to the individual picture book
individual_canvases[iRun]->cd();
ZoomIndividualPlot(hist);
hist->Draw("COLZ");
individual_canvases[iRun]->SetLogz(WantLogZ(histname)); // change to a log-z scale if we want to
individual_canvases[iRun]->Update();
individual_canvases[iRun]->Print(individual_basepdfname[iRun].str().c_str());
}
else {
// Fill this histogram into the trend plot
for (int iBin = 1; iBin <= hist->GetNbinsX(); ++iBin) {
trend_plot->Fill(first_run + iRun, hist->GetBinCenter(iBin), hist->GetBinContent(iBin)); // (x = run #, y = time stamp, z = N_TPI)
} // end for loop (filling trend plot)
} // end if (trend plot)
} // end for loop (through runs)
// Now export the trend plot to PDF (if applicable)
if (want_trend_plot) {
trend_canvas->cd();
ZoomTrendPlot(trend_plot);
trend_plot->Draw("COLZ");
trend_canvas->Print(trend_basepdfname.str().c_str());
}
}
// Now go through and clean up
for (int iRun = 0; iRun < n_runs; ++iRun) {
individual_canvases[iRun]->Print(individual_closepdfname[iRun].c_str());
}
trend_canvas->Print(trend_closepdfname.c_str());
}
void printCalibStat(Int_t run, const char * fname, TTreeSRedirector * pcstream){
//
// Dump the statistical information about all histograms in the calibration files
// into the statistical tree, print on the screen (log files) as well
//
//
// 1. Default dump for all histograms
// Information to dump:
// stat =Entries, Mean, MeanError, RMS, MaxBin
// Branch naming convention:
// <detName>_<hisName><statName>
//
// 2. Detector statistical information - to be implemented by expert
// - First version implemented by MI
//
//
TFile *fin = TFile::Open(fname);
if (!fin) return;
const Double_t kMaxHis=10000;
TList * keyList = fin->GetListOfKeys();
Int_t nkeys=keyList->GetEntries();
Double_t *hisEntries = new Double_t[kMaxHis];
Double_t *hisMean = new Double_t[kMaxHis];
Double_t *hisMeanError = new Double_t[kMaxHis];
Double_t *hisRMS = new Double_t[kMaxHis];
Double_t *hisMaxBin = new Double_t[kMaxHis];
Int_t counter=0;
if (pcstream) (*pcstream)<<"calibStatAll"<<"run="<<run;
for (Int_t ikey=0; ikey<nkeys; ikey++){
TObject * object = fin->Get(keyList->At(ikey)->GetName());
if (!object) continue;
if (object->InheritsFrom("TCollection")==0) continue;
TSeqCollection *collection = (TSeqCollection*)object;
Int_t nentries= collection->GetEntries();
for (Int_t ihis=0; ihis<nentries; ihis++){
TObject * ohis = collection->At(ihis);
if (!ohis) continue;
if (ohis->InheritsFrom("TH1")==0) continue;
TH1* phis = (TH1*)ohis;
hisEntries[counter]=phis->GetEntries();
Int_t idim=1;
if (ohis->InheritsFrom("TH2")) idim=2;
if (ohis->InheritsFrom("TH3")) idim=3;
hisMean[counter]=phis->GetMean(idim);
hisMeanError[counter]=phis->GetMeanError(idim);
hisRMS[counter]=phis->GetRMS(idim);
hisMaxBin[counter]=phis->GetBinCenter(phis->GetMaximumBin());
if (pcstream) (*pcstream)<<"calibStatAll"<<
Form("%s_%sEntries=",keyList->At(ikey)->GetName(), phis->GetName())<<hisEntries[counter]<<
Form("%s_%sMean=",keyList->At(ikey)->GetName(), phis->GetName())<<hisMean[counter]<<
Form("%s_%sMeanError=",keyList->At(ikey)->GetName(), phis->GetName())<<hisMeanError[counter]<<
Form("%s_%sRMS=",keyList->At(ikey)->GetName(), phis->GetName())<<hisRMS[counter]<<
Form("%s_%sMaxBin=",keyList->At(ikey)->GetName(), phis->GetName())<<hisMaxBin[counter];
//printf("Histo:\t%s_%s\t%f\t%d\n",keyList->At(ikey)->GetName(), phis->GetName(), hisEntries[counter],idim);
counter++;
}
delete object;
}
//
// Expert dump example (MI first iteration):
//
// 0.) TOF dump
//
Int_t tofEvents=0;
Int_t tofTracks=0;
TList * TOFCalib = (TList*)fin->Get("TOFHistos");
if (TOFCalib) {
TH1 *histoEvents = (TH1*)TOFCalib->FindObject("hHistoVertexTimestamp");
TH1 *histoTracks = (TH1*)TOFCalib->FindObject("hHistoDeltatTimestamp");
if (histoEvents && histoTracks){
tofEvents = TMath::Nint(histoEvents->GetEntries());
tofTracks = TMath::Nint(histoTracks->GetEntries());
}
delete TOFCalib;
}
printf("Monalisa TOFevents\t%d\n",tofEvents);
if (pcstream) (*pcstream)<<"calibStatAll"<<"TOFevents="<<tofEvents;
printf("Monalisa TOFtracks\t%d\n",tofTracks);
if (pcstream) (*pcstream)<<"calibStatAll"<<"TOFtracks="<<tofTracks;
//
// 1.) TPC dump - usefull events/tracks for the calibration
//
Int_t tpcEvents=0;
Int_t tpcTracks=0;
TObject* obj = dynamic_cast<TObject*>(fin->Get("TPCCalib"));
TObjArray* array = dynamic_cast<TObjArray*>(obj);
TDirectory* dir = dynamic_cast<TDirectory*>(obj);
AliTPCcalibTime * calibTime = NULL;
if (dir) {
calibTime = dynamic_cast<AliTPCcalibTime*>(dir->Get("calibTime"));
}
else if (array){
calibTime = (AliTPCcalibTime *)array->FindObject("calibTime");
}
if (calibTime) {
tpcEvents = TMath::Nint(calibTime->GetTPCVertexHisto(0)->GetEntries());
tpcTracks = TMath::Nint(calibTime->GetResHistoTPCITS(0)->GetEntries());
}
printf("Monalisa TPCevents\t%d\n",tpcEvents);
if (pcstream) (*pcstream)<<"calibStatAll"<<"TPCevents="<<tpcEvents;
printf("Monalisa TPCtracks\t%d\n",tpcTracks);
if (pcstream) (*pcstream)<<"calibStatAll"<<"TPCtracks="<<tpcTracks;
//
// 2. TRD dump
//
Int_t trdEvents=0;
Int_t trdTracks=0;
TList * TRDCalib = (TList*)fin->Get("TRDCalib");
if (TRDCalib) {
TH1 *histoEvents = (TH1*)TRDCalib->FindObject("NEventsInput_AliTRDCalibTask");
TH1 *histoTracks = (TH1*)TRDCalib->FindObject("AbsoluteGain_AliTRDCalibTask");
if (histoEvents && histoTracks){
trdEvents= TMath::Nint(histoEvents->GetEntries());
trdTracks= TMath::Nint(histoTracks->GetEntries());
}
delete TRDCalib;
}
printf("Monalisa TRDevents\t%d\n",trdEvents);
if (pcstream) (*pcstream)<<"calibStatAll"<<"TRDevents="<<trdEvents;
printf("Monalisa TRDtracks\t%d\n",trdTracks);
if (pcstream) (*pcstream)<<"calibStatAll"<<"TRDtracks="<<trdTracks;
//
// 3. T0 dump
//
Int_t T0Events=0;
TList * T0Calib = (TList*)fin->Get("T0Calib");
if (T0Calib) {
TH1 *histoEvents = (TH1*) T0Calib->FindObject("fTzeroORAplusORC");
if (histoEvents){
T0Events= TMath::Nint(histoEvents->GetEntries());
}
delete T0Calib;
}
printf("Monalisa T0events\t%d\n",T0Events);
if (pcstream) (*pcstream)<<"calibStatAll"<<"T0events="<<T0Events;
//
// 4. Mean vertex - dump
// Not present in CPass1
/*
Int_t meanVertexEvents=0;
TList * meanVertexCalib = (TList*)fin->Get("MeanVertex");
if (meanVertexCalib) {
TH1 *histoEvents = (TH1*) meanVertexCalib->FindObject("hTRKVertexX");
if (histoEvents){
meanVertexEvents = TMath::Nint(histoEvents->GetEntries());
}
delete meanVertexCalib;
}
printf("Monalisa MeanVertexevents\t%d\n",meanVertexEvents);
if (pcstream) (*pcstream)<<"calibStatAll"<<"MeanVertexevents="<<meanVertexEvents;
*/
//
// 5. SDD dump
//
Int_t sddEvents=0;
Int_t sddTracks=0;
TList * SDDCalib = (TList*)fin->Get("clistSDDCalib");
if (SDDCalib) {
TH1 *histoEvents = (TH1*) SDDCalib->FindObject("hNEvents");
if (histoEvents ){
sddEvents = TMath::Nint(histoEvents->GetBinContent(4));
sddTracks = TMath::Nint(histoEvents->GetBinContent(5));
}
delete SDDCalib;
}
printf("Monalisa SDDevents\t%d\n",sddEvents);
if (pcstream) (*pcstream)<<"calibStatAll"<<"SDDevents="<<sddEvents;
printf("Monalisa SDDtracks\t%d\n",sddTracks);
if (pcstream) (*pcstream)<<"calibStatAll"<<"SDDtracks="<<sddTracks;
//
// 6. AD dump
//
Int_t adEvents=0;
TDirectory *adDir = (TDirectory*)fin->Get("ADCalib");
if (adDir) {
TList *adList = (TList*) adDir->Get("ADCalibListHist");
if (adList) {
TH2* adHistInt0 = (TH2*) adList->FindObject("hCh00_bc10_int0");
if (adHistInt0)
adEvents += TMath::Nint(adHistInt0->GetEntries());
TH2* adHistInt1 = (TH2*) adList->FindObject("hCh00_bc10_int1");
if (adHistInt1)
adEvents += TMath::Nint(adHistInt1->GetEntries());
delete adList;
}
}
printf("Monalisa ADevents\t%d\n",adEvents);
if (pcstream) (*pcstream)<<"calibStatAll"<<"ADevents="<<adEvents;
//
if (pcstream) (*pcstream)<<"calibStatAll"<<"\n";
delete fin;
}
TH1* GetCentK(TDirectory* top, Double_t c1, Double_t c2, Int_t s,
TLegend* l)
{
TString dname; dname.Form("cent%06.2f_%06.2f", c1, c2);
dname.ReplaceAll(".", "d");
TDirectory* d = top->GetDirectory(dname);
if (!d) {
Warning("GetCetnK", "Directory %s not found in %s",
dname.Data(), top->GetName());
return;
}
TDirectory* det = d->GetDirectory("details");
if (!det) {
Warning("GetCetnK", "Directory details not found in %s",
d->GetName());
d->ls();
return;
}
TObject* o = det->Get("scalar");
if (!o) {
Warning("GetCetnK", "Object scalar not found in %s",
det->GetName());
return;
}
if (!o->IsA()->InheritsFrom(TH1::Class())) {
Warning("GetCetnK", "Object %s is not a TH1, but a %s",
o->GetName(), o->ClassName());
return;
}
TH1* h = static_cast<TH1*>(o->Clone());
Color_t col = cc[(s-1)%10];
h->SetLineColor(col);
h->SetMarkerColor(col);
h->SetFillColor(col);
h->SetFillStyle(1001);
// h->SetTitle(Form("%5.2f-%5.2f%% #times %d", c1, c2, s));
h->SetTitle(Form("%2.0f-%2.0f%% + %d", c1, c2, s-1));
TF1* f = new TF1("", "[0]",-2.2,2.2);
f->SetParameter(0,s-1);
f->SetLineColor(col);
f->SetLineStyle(7);
f->SetLineWidth(1);
// h->Scale(s);
h->Add(f);
h->GetListOfFunctions()->Add(f);
f->SetParameter(0,s);
for (Int_t i = 1; i <= h->GetNbinsX(); i++) {
if (TMath::Abs(h->GetBinCenter(i)) > 2) {
h->SetBinContent(i,0);
h->SetBinError(i,0);
}
}
TLegendEntry* e = l->AddEntry(h, h->GetTitle(), "f");
e->SetFillColor(col);
e->SetFillStyle(1001);
e->SetLineColor(col);
return h;
}
double leptonic_fitter_algebraic::likeliest_scale( const TH1& ITF )
{
Int_t ibin = ITF.GetMaximumBin();
return ITF.GetBinCenter( ibin );
}
//
//----------------------------------------------------------------------
//
int fittp0( char* hs ) {
TH1 *h = (TH1*)gDirectory->Get(hs);
if( h == NULL ){
cout << hs << " does not exist\n";
}
else{
h->SetMarkerStyle(21);
h->SetMarkerSize(0.8);
h->SetStats(1);
gStyle->SetOptFit(101);
gROOT->ForceStyle();
double dx = h->GetBinWidth(1);
double nmax = h->GetBinContent(h->GetMaximumBin());
double xmax = h->GetBinCenter(h->GetMaximumBin());
double nn = 7*nmax;
int nb = h->GetNbinsX();
double n1 = h->GetBinContent(1);
double n9 = h->GetBinContent(nb);
double bg = 0.5*(n1+n9);
double x1 = h->GetBinCenter(1);
double x9 = h->GetBinCenter(nb);
cout << hs << ": " << x1 << " - " << x9 << endl;
// create a TF1 with the range from x1 to x9 and 5 parameters
TF1 *tp0Fcn = new TF1( "tp0Fcn", tp0Fit, x1, x9, 5 );
tp0Fcn->SetParName( 0, "mean" );
tp0Fcn->SetParName( 1, "sigma" );
tp0Fcn->SetParName( 2, "nu" );
tp0Fcn->SetParName( 3, "area" );
tp0Fcn->SetParName( 4, "BG" );
tp0Fcn->SetNpx(500);
tp0Fcn->SetLineWidth(4);
tp0Fcn->SetLineColor(kMagenta);
tp0Fcn->SetLineColor(kGreen);
// set start values for some parameters:
cout << hs << " " << dx << ", " << nn << ", " << xmax << endl;
tp0Fcn->SetParameter( 0, xmax ); // peak position
tp0Fcn->SetParameter( 1, 4*dx ); // width
tp0Fcn->SetParameter( 2, 2.2 ); // nu
tp0Fcn->SetParameter( 3, nn ); // N
tp0Fcn->SetParameter( 4, bg );
h->Fit( "tp0Fcn", "R", "ep" );
// h->Fit("tp0Fcn","V+","ep");
h->Draw("histepsame"); // data again on top
}
}
void glauberCut(int from=0, int to=100){
char name[200];
TChain* t = new TChain("t");
char dfilelist[100];
sprintf(dfilelist,"filelist.txt");
ifstream lis(dfilelist);
int cnt=0;
int dnt=0;
while(!lis.eof())
{
string filename;
lis >> filename;
if(cnt>=from&&cnt<to)
{
cout << filename << endl;
if(!filename.empty()) t->Add(filename.c_str());
dnt++;
}
cnt++;
}
double b;
int ncoll;
int npart,npartproj,nparttarg;
int nHitBbc_n, nHitBbc_s, BBCTrig;
int Centbin;
double qBBC_n, qBBC_s, pTrigBBC;
double vertex, ecc_std,ecc_rp, ecc_part,ecc_partr,r_ollitra,r_geo,r_arith,r_ollitrar,r_geor,r_arithr,e4;
double e_gl[ETOT],ang_gl[ETOT];
double re_gl[ETOT],rang_gl[ETOT];
double pe_gl[ETOT],pang_gl[ETOT];
double pre_gl[ETOT],prang_gl[ETOT];
t->SetBranchAddress("b", &b );
t->SetBranchAddress("Centbin", &Centbin);
t->SetBranchAddress("ncoll", &ncoll);
t->SetBranchAddress("npart", &npart);
t->SetBranchAddress("npartproj", &npartproj);
t->SetBranchAddress("nparttarg", &nparttarg);
/* t->SetBranchAddress("ecc_std", &ecc_std );
t->SetBranchAddress("ecc_rp", &ecc_rp );
t->SetBranchAddress("ecc_part", &ecc_part );
t->SetBranchAddress("e_gl", e_gl ); //r2
t->SetBranchAddress("ang_gl", ang_gl );
t->SetBranchAddress("pe_gl", pe_gl ); //no only Conside Npart
t->SetBranchAddress("pang_gl", pang_gl);
*/
// t->SetBranchAddress("re_gl", re_gl ); //r3,2,3,4,5,6
// t->SetBranchAddress("rang_gl", rang_gl);
t->SetBranchAddress("pre_gl", pre_gl);
// t->SetBranchAddress("prang_gl", prang_gl);
//t->SetBranchAddress("nux", &nux);
//t->SetBranchAddress("nuy", &nuy);
//t->SetBranchAddress("st_part", &st_part);
int nevents = t->GetEntries();
cout<<"will run "<<nevents/1000000<<"M events"<<endl;
TH1D* hecc [NCENT][NHAR];
TH1D* hcent[NCENT];
for(int icent=0; icent<NCENT; icent++){
sprintf(name,"hcent_%.2d", icent);
hcent[icent] = new TH1D(name, name ,NCENT, 0-0.5, NCENT-0.5);
}
for(int icent=0; icent<NCENT; icent++){
for(int ihar=0; ihar<NHAR; ihar++){
sprintf(name, "hecc_ic%.2d_ih%d", icent, ihar);
hecc[icent][ihar] = new TH1D(name, name, 100000, 0, 1);
}
}
for(int iev=0; iev<nevents; iev++){
t->GetEntry(iev);
if(iev%1000000==0) cout<<iev<<endl;
if(Centbin!=0) continue;
hcent[Centbin] ->Fill(Centbin);
for(int ihar=0; ihar<NHAR; ihar++){
hecc[Centbin][ihar] ->Fill(pre_gl[ihar]);
}
} //end of events
float steps[NSTEP] = {0};
float Ecut[NCENT][NHAR][NSTEP];
for(int is=0; is<NSTEP-1; is++){
steps[is] = (is+1)*1.0/NSTEP;
}
steps[NSTEP-1] = 1.01;
for(int icent=0; icent<NCENT; icent++){
for(int ihar=0; ihar<NHAR; ihar++){
TH1* htmp;
sprintf(name,"scale_%d_%d", icent, ihar);
htmp = (TH1*)hecc[icent][ihar] ->Clone(name);
htmp-> Scale(1.0/htmp->GetEntries());
double sum = 0;
int cnt = 0;
for(int ib=1; ib<=htmp->GetNbinsX(); ib++){
sum+= htmp->GetBinContent(ib);
if(sum>steps[cnt]) { Ecut[icent][ihar][cnt] = htmp->GetBinCenter(ib); cnt++;}
}
Ecut[icent][ihar][NSTEP-1] = 1.01;
cout<<icent<<" "<<ihar<<" "<<cnt<<" "<<sum<<endl;
}
}
ofstream tout;
sprintf(name,"ECut_cent0.txt");
tout.open(name);
for(int cent=0; cent<NCENT; cent++){
tout<<"centb "<<cent<<endl;
for(int ihar=0; ihar<NHAR; ihar++){
for(int iq=0; iq<NSTEP; iq++){
if(iq==0) tout<<"{"<<Ecut[cent][ihar][iq]<<", ";
else if(iq<NSTEP-1) tout<<Ecut[cent][ihar][iq]<<", ";
else if(iq ==NSTEP-1) tout<<Ecut[cent][ihar][iq]<<"}, "<<endl;
}
}
}
tout.close();
TFile* fout = new TFile("glauber_cut_cent0.root","recreate");
for(int icent=0; icent<NCENT; icent++){
for(int ihar=0; ihar<NHAR; ihar++){
hecc[icent][ihar] ->Write();
}
}
for(int icent=0; icent<NCENT; icent++){
hcent[icent] ->Write();
}
fout->Close();
}
void plot(int mass) {
double myQCDRelUncert = 0.038;
double myEWKRelUncert = 0.131;
double myFakesRelUncert = 0.238;
double delta = 1.4;
double br = 0.05;
bool debug = false;
bool log = false;
double ymin = 0.001;
double ymax = 48;
static bool bMessage = false;
if (!bMessage) {
cout << "Values used as relative uncertainty (please check):" << endl;
cout << " QCD: " << myQCDRelUncert << endl;
cout << " EWK genuine tau: " << myEWKRelUncert << endl;
cout << " EWK fake tau: " << myFakesRelUncert << endl << endl;
bMessage = true;
}
cout << "Processing mass point: " << mass << " GeV/c2" << endl;
gStyle->SetOptFit(1);
gStyle->SetOptStat(0);
gStyle->SetOptTitle(0);
gStyle->SetTitleFont(43, "xyz");
gStyle->SetTitleSize(33, "xyz");
gStyle->SetLabelFont(43, "xyz");
gStyle->SetLabelSize(27, "xyz");
//std::string infile = "EPS_data_nodeltaphi/hplus_100.root";
//std::string infile = "EPS_data_deltaphi160/hplus_100.root";
std::stringstream s;
s << "lands_histograms_hplushadronic_m" << mass << ".root";
std::string infile = s.str();
// Canvas
TCanvas *myCanvas = new TCanvas("myCanvas", "",0,0,600,600);
myCanvas->SetHighLightColor(2);
myCanvas->Range(0,0,1,1);
myCanvas->SetFillColor(0);
myCanvas->SetBorderMode(0);
myCanvas->SetBorderSize(2);
if (log)
myCanvas->SetLogy();
myCanvas->SetTickx(1);
myCanvas->SetTicky(1);
myCanvas->SetLeftMargin(0.16);
myCanvas->SetRightMargin(0.05);
myCanvas->SetTopMargin(0.05);
myCanvas->SetBottomMargin(0.08);
myCanvas->SetFrameFillStyle(0);
myCanvas->SetFrameBorderMode(0);
myCanvas->SetFrameFillStyle(0);
myCanvas->SetFrameBorderMode(0);
myCanvas->cd();
Int_t ci;
TFile* f = TFile::Open(infile.c_str());
s.str("");
s << "HW" << mass << "_1";
TH1* hw = (TH1*)f->Get(s.str().c_str());
s.str("");
s << "HH" << mass << "_1";
TH1* hh = (TH1*)f->Get(s.str().c_str());
TH1* data = (TH1*)f->Get("data_obs");
data->SetLineWidth(2);
data->SetMarkerStyle(20);
data->SetMarkerSize(1.2);
TH1* ewktau = (TH1*)f->Get("EWK_Tau");
ci = TColor::GetColor("#993399");
ewktau->SetFillColor(ci);
ewktau->SetLineWidth(0);
TH1* ewkDY = (TH1*)f->Get("EWK_DYx");
TH1* ewkVV = (TH1*)f->Get("EWK_VVx");
ewktau->Add(ewkDY);
ewktau->Add(ewkVV);
//TH1* qcd = (TH1*)f->Get("QCDInv");
TH1* qcd = (TH1*)f->Get("QCD");
ci = TColor::GetColor("#ffcc33");
qcd->SetFillColor(ci);
qcd->SetLineWidth(0);
TH1* fakett = (TH1*)f->Get("fake_tt");
ci = TColor::GetColor("#669900");
fakett->SetFillColor(ci);
fakett->SetLineWidth(0);
TH1* fakeW = (TH1*)f->Get("fake_W");
ci = TColor::GetColor("#cc3300");
fakeW->SetFillColor(ci);
fakeW->SetLineWidth(0);
TH1* faket = (TH1*)f->Get("fake_t");
TH1F *hFrame = new TH1F("hFrame","",20,0,400);
hFrame->SetMinimum(ymin);
if (log)
hFrame->SetMaximum(ymax*1.5);
else
hFrame->SetMaximum(ymax);
hFrame->SetDirectory(0);
hFrame->SetStats(0);
hFrame->SetLineStyle(0);
hFrame->SetMarkerStyle(20);
hFrame->SetXTitle("Transverse mass (#tau jet, E_{T}^{miss}), (GeV/c^{2})");
if (paperStatus)
hFrame->SetXTitle("Transverse mass (#tau_{h}, E_{T}^{miss}), (GeV/c^{2})");
hFrame->SetYTitle("Events / 20 GeV/c^{2}");
hFrame->GetXaxis()->SetTitleSize(0);
hFrame->GetXaxis()->SetLabelSize(0);
hFrame->GetYaxis()->SetTitleFont(43);
hFrame->GetYaxis()->SetTitleSize(27);
hFrame->GetYaxis()->SetTitleOffset(1.3);
// signal
hh->Scale(br*br);
hw->Scale(2*br*(1.0-br));
TH1* signal = (TH1*)hh->Clone();
signal->Add(hw);
ci = TColor::GetColor("#ff3399");
signal->SetLineColor(ci);
signal->SetLineStyle(2);
signal->SetLineWidth(2);
// Fakes
TH1* fakes = (TH1*)(fakett->Clone());
fakes->Add(fakeW);
fakes->Add(faket);
// stacked backgrounds
THStack *exp = new THStack();
exp->SetName("exp");
exp->SetTitle("exp");
exp->Add(fakes);
exp->Add(ewktau);
exp->Add(qcd);
exp->Add(signal);
TH1* hExpBkg = (TH1*)fakes->Clone();
hExpBkg->Add(ewktau);
hExpBkg->Add(qcd);
// uncertainty
TH1* uncert = (TH1*)fakeW->Clone();
uncert->Add(fakett);
uncert->Add(ewktau);
uncert->Add(qcd);
uncert->SetFillColor(1);
uncert->SetFillStyle(3344);
uncert->SetLineColor(0);
uncert->SetLineStyle(0);
uncert->SetLineWidth(0);
TH1* hExpBkgTotalUncert = (TH1*)uncert->Clone();
hExpBkgTotalUncert->SetFillStyle(3354);
TH1* hAgreement = (TH1*)data->Clone();
hAgreement->Divide(hExpBkg);
TGraphErrors* hAgreementRelUncert = new TGraphErrors(hAgreement->GetNbinsX());
hAgreementRelUncert->SetLineWidth(2);
hAgreementRelUncert->SetLineColor(kBlack);
for (int i = 1; i <= hFrame->GetNbinsX(); ++i) {
double myQCDTotalUncert = TMath::Power(qcd->GetBinError(i), 2)
+ TMath::Power(qcd->GetBinContent(i)*myQCDRelUncert, 2);
double myEWKTotalUncert = TMath::Power(ewktau->GetBinError(i), 2)
+ TMath::Power(ewktau->GetBinContent(i)*myEWKRelUncert, 2);
double myFakesTotalUncert = TMath::Power(fakes->GetBinError(i), 2)
+ TMath::Power(fakes->GetBinContent(i)*myFakesRelUncert, 2);
hExpBkgTotalUncert->SetBinError(i, TMath::Sqrt(myQCDTotalUncert + myEWKTotalUncert + myFakesTotalUncert));
if (hExpBkg->GetBinContent(i) > 0) {
hAgreementRelUncert->SetPoint(i-1, hExpBkg->GetBinCenter(i), data->GetBinContent(i) / hExpBkg->GetBinContent(i));
double myUncertData = 0;
if (data->GetBinContent(i) > 0)
myUncertData = TMath::Power(data->GetBinError(i) / data->GetBinContent(i), 2);
double myUncertBkg = (myQCDTotalUncert + myEWKTotalUncert + myFakesTotalUncert) / TMath::Power(hExpBkg->GetBinContent(i), 2);
hAgreementRelUncert->SetPointError(i-1, 0, data->GetBinContent(i) / hExpBkg->GetBinContent(i) * TMath::Sqrt(myUncertData + myUncertBkg));
} else {
hAgreementRelUncert->SetPoint(i-1, hExpBkg->GetBinCenter(i), 0);
hAgreementRelUncert->SetPointError(i-1, 0, 0);
}
if (debug) {
cout << "Point: " << hAgreementRelUncert->GetX()[i-1]-10 << "-" << hAgreementRelUncert->GetX()[i-1]+10
<< " GeV/c2, agreement: " << hAgreementRelUncert->GetY()[i-1] << ", uncert: " << hAgreement->GetBinError(i) << ", " << hAgreementRelUncert->GetErrorY(i-1) << endl;
cout << " bkg. stat. uncert. " << hExpBkg->GetBinError(i) << " (i.e. " << hExpBkg->GetBinError(i) / hExpBkg->GetBinContent(i) * 100.0 << " %)"
<< ", stat+syst uncert. " << TMath::Sqrt(myQCDTotalUncert + myEWKTotalUncert + myFakesTotalUncert)
<< " (i.e. " << TMath::Sqrt(myQCDTotalUncert + myEWKTotalUncert + myFakesTotalUncert) / hExpBkg->GetBinContent(i) * 100.0 << " %)" << endl;
}
}
// Agreement pad
TPad* pad = new TPad("ratiopad","ratiopad",0.,0.,1.,.3);
pad->Draw();
pad->cd();
pad->Range(0,0,1,1);
pad->SetFillColor(0);
pad->SetFillStyle(4000);
pad->SetBorderMode(0);
pad->SetBorderSize(2);
pad->SetTickx(1);
pad->SetTicky(1);
pad->SetLeftMargin(0.16);
pad->SetRightMargin(0.05);
pad->SetTopMargin(0);
pad->SetBottomMargin(0.34);
pad->SetFrameFillStyle(0);
pad->SetFrameBorderMode(0);
// Plot here ratio
if (1.0-delta > 0)
hAgreement->SetMinimum(1.0-delta);
else
hAgreement->SetMinimum(0.);
hAgreement->SetMaximum(1.0+delta);
hAgreement->GetXaxis()->SetLabelOffset(0.007);
hAgreement->GetXaxis()->SetLabelFont(43);
hAgreement->GetXaxis()->SetLabelSize(27);
hAgreement->GetYaxis()->SetLabelFont(43);
hAgreement->GetYaxis()->SetLabelSize(27);
hAgreement->GetYaxis()->SetLabelOffset(0.007);
hAgreement->GetYaxis()->SetNdivisions(505);
hAgreement->GetXaxis()->SetTitleFont(43);
hAgreement->GetYaxis()->SetTitleFont(43);
hAgreement->GetXaxis()->SetTitleSize(33);
hAgreement->GetYaxis()->SetTitleSize(33);
hAgreement->SetTitleSize(27, "xyz");
hAgreement->GetXaxis()->SetTitleOffset(3.2);
hAgreement->GetYaxis()->SetTitleOffset(1.3);
hAgreement->SetXTitle(hFrame->GetXaxis()->GetTitle());
hAgreement->SetYTitle("Data/#Sigmabkg");
hAgreement->Draw("e2");
// Plot line at zero
TH1* hAgreementLine = dynamic_cast<TH1*>(hAgreement->Clone());
for (int i = 1; i <= hAgreementLine->GetNbinsX(); ++i) {
hAgreementLine->SetBinContent(i,1.0);
hAgreementLine->SetBinError(i,0.0);
}
hAgreementLine->SetLineColor(kRed);
hAgreementLine->SetLineWidth(2);
hAgreementLine->SetLineStyle(3);
hAgreementLine->Draw("hist same");
hAgreement->Draw("same");
hAgreementRelUncert->Draw("[]");
pad->RedrawAxis();
myCanvas->cd();
TPad* plotpad = new TPad("plotpad", "plotpad",0,0.3,1.,1.);
plotpad->Draw();
plotpad->cd();
plotpad->Range(0,0,1,1);
plotpad->SetFillColor(0);
plotpad->SetFillStyle(4000);
plotpad->SetBorderMode(0);
plotpad->SetBorderSize(2);
//if (logy)
// plotpad->SetLogy();
plotpad->SetTickx(1);
plotpad->SetTicky(1);
plotpad->SetLeftMargin(0.16);
plotpad->SetRightMargin(0.05);
plotpad->SetTopMargin(0.065);
plotpad->SetBottomMargin(0.0);
plotpad->SetFrameFillStyle(0);
plotpad->SetFrameBorderMode(0);
hFrame->GetXaxis()->SetTitleSize(0);
hFrame->GetXaxis()->SetLabelSize(0);
hFrame->GetYaxis()->SetTitleFont(43);
hFrame->GetYaxis()->SetTitleSize(33);
hFrame->GetYaxis()->SetTitleOffset(1.3);
// Draw objects
hFrame->Draw();
exp->Draw("hist same");
uncert->Draw("E2 same");
hExpBkgTotalUncert->Draw("E2 same");
// Data
data->Draw("same");
//signal->Draw("same");
TLegend *leg = new TLegend(0.53,0.6,0.87,0.91,NULL,"brNDC");
leg->SetBorderSize(0);
leg->SetTextFont(63);
leg->SetTextSize(18);
leg->SetLineColor(1);
leg->SetLineStyle(1);
leg->SetLineWidth(1);
leg->SetFillColor(kWhite);
//leg->SetFillStyle(4000); // enabling this will cause the plot to be erased from the pad
TLegendEntry* entry = leg->AddEntry(data, "Data", "P");
s.str("");
s << "with H^{#pm}#rightarrow#tau^{#pm}#nu";
entry = leg->AddEntry(signal, s.str().c_str(), "L");
entry = leg->AddEntry(qcd, "QCD (meas.)", "F");
entry = leg->AddEntry(ewktau, "EWK genuine #tau (meas.)", "F");
entry = leg->AddEntry(fakes, "EWK fake #tau (MC)", "F");
entry = leg->AddEntry(uncert, "stat. uncert.", "F");
entry = leg->AddEntry(hExpBkgTotalUncert, "stat. #oplus syst. uncert.", "F");
leg->Draw();
string myTitle = "CMS Preliminary";
if (paperStatus)
myTitle = "CMS";
TLatex *tex = new TLatex(0.62,0.945,myTitle.c_str());
tex->SetNDC();
tex->SetTextFont(43);
tex->SetTextSize(27);
tex->SetLineWidth(2);
tex->Draw();
tex = new TLatex(0.2,0.945,"#sqrt{s} = 7 TeV");
tex->SetNDC();
tex->SetTextFont(43);
tex->SetTextSize(27);
tex->SetLineWidth(2);
tex->Draw();
tex = new TLatex(0.43,0.945,"2.2 fb^{-1}");
tex->SetNDC();
tex->SetTextFont(43);
tex->SetTextSize(27);
tex->SetLineWidth(2);
tex->Draw();
s.str("");
s << "m_{H^{#pm}} = " << mass << " GeV/c^{2}";
tex = new TLatex(0.28,0.865,s.str().c_str());
tex->SetNDC();
tex->SetTextFont(63);
tex->SetTextSize(20);
tex->SetLineWidth(2);
tex->Draw();
s.str("");
s << "BR(t#rightarrowbH^{#pm})=" << setprecision(2) << br;
tex = new TLatex(0.28,0.805,s.str().c_str());
tex->SetNDC();
tex->SetTextFont(63);
tex->SetTextSize(20);
tex->SetLineWidth(2);
tex->Draw();
plotpad->RedrawAxis();
plotpad->Modified();
s.str("");
s << "mT_datadriven_m" << mass << ".png";
myCanvas->Print(s.str().c_str());
s.str("");
s << "mT_datadriven_m" << mass << ".C";
myCanvas->Print(s.str().c_str());
s.str("");
s << "mT_datadriven_m" << mass << ".eps";
myCanvas->Print(s.str().c_str());
}
