//________________________________________________________
TVirtualPad* GFHistManager::GetPad(Int_t layer, Int_t histNum)
{
// pointer to pad where hists from layer/histNum are painted in
// callable after draw!
Int_t totHistsYet = 0;
Int_t numHists = 0;
TCanvas *can = NULL;
for (Int_t numCan = 0; ; ++numCan) {
can = this->GetCanvas(layer, numCan);
if (!can) break;
numHists = TMath::Max(1, this->NumberOfSubPadsOf(can));
totHistsYet += numHists;
if (totHistsYet > histNum) {
totHistsYet -= numHists;
break;
}
}
TVirtualPad *result = NULL;
if (can) {
TVirtualPad *oldPad = gPad;
if (numHists <= 1) can->cd(0); // one hist per canvas: no pads!
else can->cd(histNum - totHistsYet + 1);
result = gPad;
oldPad->cd();
}
return result;
}
//_______________________________________________________________________________________
void MakeFourView(TVirtualPad *pad=0)
{
// Creates 4 pads view of the pad (or qPad)
// ------------------------------
// | | |
// | | |
// | | |
// | Front | Top |
// | view | view |
// | | |
// | | |
// | | |
// ---------------+-------------
// | | |
// | | |
// | | |
// | Side | Spacial |
// | view | view |
// | | |
// | | |
// | | |
// ------------------------------
// begin_html <P ALIGN=CENTER> <IMG SRC="gif/FourStarView.gif" ></P> end_html
//
TVirtualPad *thisPad = pad;
if (!thisPad) thisPad = qPad();
TView *view = 0;
TList *thisPrimitives = 0;
if (thisPad && (thisPrimitives = thisPad->GetListOfPrimitives()) && (view = thisPad->GetView()) )
{
Double_t min[3],max[3];
view->GetRange(min,max);
Int_t system = view->GetSystem();
TCanvas *c = new TCanvas(" 4 views", thisPad->GetTitle(),600,600);
c->Divide(2,2);
TIter *next= new TIter(thisPrimitives);
for (int i =1; i <= 4; i++) {
c->cd(i);
TList *newPrimitives = qPad()->GetListOfPrimitives();
TObject *obj = 0;
while (obj = next->Next()) newPrimitives->Add(obj);
TView *newView = new TView(system);
newView->SetRange(min,max);
next->Reset();
}
delete next;
// set separate view;
// Fron view
Int_t j = 1;
c->cd(j++); FrontView();
c->cd(j++); TopView();
c->cd(j++); SideView();
c->cd(j++); RotateView(-30.0,60.0,0);
c->Modified();
c->Update();
}
}
//_______________________________________________________________________________________
static void SetBackround(Color_t color, TVirtualPad *pad=0)
{
TVirtualPad *thisPad = pad;
if (!thisPad) thisPad = qPad();
if (thisPad) {
thisPad->SetFillColor(color);
thisPad->Modified();
thisPad->Update();
}
}
void DynamicExec()
{
// Example of function called when a mouse event occurs in a pad.
// When moving the mouse in the canvas, a second canvas shows the
// projection along X of the bin corresponding to the Y position
// of the mouse. The resulting histogram is fitted with a gaussian.
// A "dynamic" line shows the current bin position in Y.
// This more elaborated example can be used as a starting point
// to develop more powerful interactive applications exploiting CINT
// as a development engine.
//
// Author: Rene Brun
TObject *select = gPad->GetSelected();
if(!select) return;
if (!select->InheritsFrom("TH2")) {gPad->SetUniqueID(0); return;}
TH2 *h = (TH2*)select;
gPad->GetCanvas()->FeedbackMode(kTRUE);
//erase old position and draw a line at current position
int pyold = gPad->GetUniqueID();
int px = gPad->GetEventX();
int py = gPad->GetEventY();
float uxmin = gPad->GetUxmin();
float uxmax = gPad->GetUxmax();
int pxmin = gPad->XtoAbsPixel(uxmin);
int pxmax = gPad->XtoAbsPixel(uxmax);
if(pyold) gVirtualX->DrawLine(pxmin,pyold,pxmax,pyold);
gVirtualX->DrawLine(pxmin,py,pxmax,py);
gPad->SetUniqueID(py);
Float_t upy = gPad->AbsPixeltoY(py);
Float_t y = gPad->PadtoY(upy);
//create or set the new canvas c2
TVirtualPad *padsav = gPad;
TCanvas *c2 = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("c2");
if(c2) delete c2->GetPrimitive("Projection");
else c2 = new TCanvas("c2","Projection Canvas",710,10,700,500);
c2->SetGrid();
c2->cd();
//draw slice corresponding to mouse position
Int_t biny = h->GetYaxis()->FindBin(y);
TH1D *hp = h->ProjectionX("",biny,biny);
hp->SetFillColor(38);
char title[80];
sprintf(title,"Projection of biny=%d",biny);
hp->SetName("Projection");
hp->SetTitle(title);
hp->Fit("gaus","ql");
hp->GetFunction("gaus")->SetLineColor(kRed);
hp->GetFunction("gaus")->SetLineWidth(6);
c2->Update();
padsav->cd();
}
TCanvas* pHitSpecPos( )
{
TCanvas* c = new TCanvas("cHitSpecPos","cHitSpecPos",1000,1100);
c->Divide(2,2);
TVirtualPad* p; TH2D *h;
TText t; t.SetTextColor(4);
p =c->cd(1); p->SetLogy(); p->SetGrid(1,0);
h = (TH2D*)gROOT->FindObject("hHitSpec_PtVsPhi_BarMinus");
h->GetYaxis()->SetRange(4,33);
h->DrawCopy("box");
t.DrawTextNDC(0.17,0.15, "BARREL MU MINUS");
p =c->cd(2); p->SetLogy(); p->SetGrid(1,0);
h = (TH2D*)gROOT->FindObject("hHitSpec_PtVsPhi_BarPlus");
h->GetYaxis()->SetRange(4,32);
h->DrawCopy("box");
t.DrawTextNDC(0.17,0.15, "BARREL MU PLUS");
p =c->cd(3); p->SetLogy(); p->SetGrid(1,0);
h = (TH2D*)gROOT->FindObject("hHitSpec_PtVsPhi_EndMinus");
h->GetYaxis()->SetRange(4,32);
h->DrawCopy("box");
t.DrawTextNDC(0.17,0.15, "ENDCAP MU MINUS");
p =c->cd(4); p->SetLogy(); p->SetGrid(1,0);
h = (TH2D*)gROOT->FindObject("hHitSpec_PtVsPhi_EndPlus");
h->GetYaxis()->SetRange(4,32);
h->DrawCopy("box");
t.DrawTextNDC(0.17,0.15, "ENDCAP MU PLUS");
return c;
}
void makeimage(const char *MacroName, const char *ImageName, const char *OutDir, bool cp)
{
gROOT->ProcessLine(Form(".x %s",MacroName));
if (cp) gSystem->Exec(TString::Format("cp %s %s/macros", MacroName, OutDir));
TIter iCanvas(gROOT->GetListOfCanvases());
TVirtualPad* pad = 0;
while ((pad = (TVirtualPad*) iCanvas())) {
pad->SaveAs(TString::Format("%s/html/%s",OutDir,ImageName));
}
}
void plotTrk() {
gStyle->SetOptStat(0);
gStyle->SetOptTitle(1);
char c[50];
c1->Clear();
c1->Divide(2,3);
for(int hid=0; hid<6; hid++){
TVirtualPad* pad = c1->cd(hid+1);
pad->SetLogy(lTrkHist[hid]);
double xmin, xmax, ymin=0.0, ymax=0.0;
if(lTrkHist[hid]==1) ymin=0.1;
for(int quad=0; quad<kFgtNumQuads; quad++){
sprintf(c,"Quad%1s-%s",cquad[quad],cTrkHist[hid]);
//printf("Getting %s\n",c);
TH1F *h = histTrk[quad][hid] = (TH1F*)file->Get(c);
xmin=h->GetXaxis()->GetXmin();
xmax=h->GetXaxis()->GetXmax();
double m=h->GetMaximum();
if(ymax<m) ymax=m;
//printf("quad=%d max=%6.1f ymax=%6.1f xmin=%6.1f xmax=%6.1f\n",quad,m,ymax,xmin,xmax);
}
ymax*=1.2; if(lTrkHist[hid]==1){ymax*=20.0;}
sprintf(c,"%s",cTrkHist[hid]);
TH2F *frame = new TH2F(c,c,1,xmin,xmax,1,ymin,ymax); frame->SetStats(0); frame->Draw();
for(int quad=0; quad<kFgtNumQuads; quad++){
TH1F *h=histTrk[quad][hid];
h->SetLineColor(colorQuad[quad]); h->SetLineWidth(3);
if(hid<5){
h->Draw("SAME");
float mean=h->GetMean();
if(hid==1 || hid==4) {sprintf(c,"%s mean=%6.4f",cquad[quad],mean);}
else {sprintf(c,"%s mean=%6.2f",cquad[quad],mean);}
}else{
h->SetMarkerColor(colorQuad[quad]); h->SetMarkerStyle(20); h->SetMarkerSize(1);
h->Draw("SAME PL");
sprintf(c,"Quad%s",cquad[quad]);
}
TText *t1;
float x1= 0.2, x2= 0.55;
float y1=0.8 - 0.07*quad;
float y2=0.8 - 0.07*(quad-2);
if(quad<2) { t1 = new TText(x1,y1,c); }
else { t1 = new TText(x2,y2,c); }
t1->SetNDC();
t1->SetTextSize(0.06);
t1->SetTextColor(colorQuad[quad]);
t1->Draw();
}
}
c1->Update();
save("trk");
}
//#endif
void DrawInPad(TVirtualPad* p,
Int_t sub,
TH1* h,
Bool_t logy=false)
{
TVirtualPad* pp = p->cd(sub);
pp->SetRightMargin(0.02);
if (logy) pp->SetLogy();
TH1* copy = h->DrawCopy("hist");
copy->GetXaxis()->SetLabelSize(0.13);
copy->GetYaxis()->SetLabelSize(0.08);
copy->SetDirectory(0);
}
void splithist(double ratio=0.2){
TVirtualPad* pmain = TVirtualPad::Pad();
double h = 1. - pmain->GetTopMargin() - pmain->GetBottomMargin();
double xlow = 0.; //gStyle->GetPadLeftMargin();
double xhigh = 1.; // - gStyle->GetPadRightMargin();
double ytop = 1.; //- gStyle->GetPadTopMargin();
double ybot = 0.; //gStyle->GetPadBottomMargin();
double ymid = pmain->GetBottomMargin() + ratio * h; //ybot + ratio * (ytop-ybot);
double yp1bot = ymid;
double yp2top = ymid;
TPad* p1 = new TPad(TString(pmain->GetName()) + "_1", pmain->GetTitle(),
xlow, yp1bot, xhigh, ytop);
p1->SetNumber(1);
TPad* p2 = new TPad(TString(pmain->GetName()) + "_2", pmain->GetTitle(),
xlow, ybot, xhigh, yp2top);
p2->SetNumber(2);
p1->SetFillStyle(4000);
p2->SetFillStyle(4000);
double p1h = ytop - yp1bot;
double p2h = yp2top - ybot;
/*
p1->SetTopMargin(pmain->GetTopMargin()/p1h);
p1->SetBottomMargin((ymid-yp1bot)/p1h);
p1->SetLeftMargin(pmain->GetLeftMargin());
p1->SetRightMargin(pmain->GetRightMargin());
p2->SetTopMargin((ymid-yp2top)/p2h);
p2->SetBottomMargin(pmain->GetBottomMargin()/p2h);
p2->SetLeftMargin(pmain->GetLeftMargin());
p2->SetRightMargin(pmain->GetRightMargin());
*/
p1->SetTopMargin(0.11);
p1->SetBottomMargin(0.);
p1->SetRightMargin(0.02);
p2->SetTopMargin(0.);
p2->SetBottomMargin(0.3);
p2->SetRightMargin(0.02);
p2->Draw();
p1->Draw();
pmain->Modified();
p1->cd();
}
//_______________________________________________________________________________________
static void Inscrease3DScale()
{
TVirtualPad *thisPad = qPad();
if (thisPad) {
TView *view = thisPad->GetView();
if (!view) return;
Double_t min[3],max[3];
view->GetRange(min,max);
int i;
for (i=0;i<3; i++) {max[i] *= 0.8; min[i]=max[i]*0.1;}
view->SetRange(min,max);
thisPad->Modified();
thisPad->Update();
}
}
//_______________________________________________________________________________________
static void Centered3DImages()
{
// This macro prints out the sizes of the sekected 3d pad
TVirtualPad *thisPad = qPad();
if (thisPad) {
TView *view = thisPad->GetView();
if (!view) return;
Double_t min[3],max[3];
view->GetRange(min,max);
int i;
for (i=0;i<3; i++) min[i]=-max[i];
view->SetRange(min,max);
thisPad->Modified();
thisPad->Update();
}
}
void exec2()
{
if (!gPad) {
Error("exec2", "gPad is null, you are not supposed to run this macro");
return;
}
TObject *select = gPad->GetSelected();
if(!select) return;
if (!select->InheritsFrom(TH2::Class())) {gPad->SetUniqueID(0); return;}
gPad->GetCanvas()->FeedbackMode(kTRUE);
//erase old position and draw a line at current position
int pyold = gPad->GetUniqueID();
int px = gPad->GetEventX();
int py = gPad->GetEventY();
float uxmin = gPad->GetUxmin();
float uxmax = gPad->GetUxmax();
int pxmin = gPad->XtoAbsPixel(uxmin);
int pxmax = gPad->XtoAbsPixel(uxmax);
if(pyold) gVirtualX->DrawLine(pxmin,pyold,pxmax,pyold);
gVirtualX->DrawLine(pxmin,py,pxmax,py);
gPad->SetUniqueID(py);
Float_t upy = gPad->AbsPixeltoY(py);
Float_t y = gPad->PadtoY(upy);
//create or set the new canvas c2
TVirtualPad *padsav = gPad;
TCanvas *c2 = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("c2");
if(c2) delete c2->GetPrimitive("Projection");
else c2 = new TCanvas("c2");
c2->cd();
//draw slice corresponding to mouse position
TH2 *h = (TH2*)select;
Int_t biny = h->GetYaxis()->FindBin(y);
TH1D *hp = h->ProjectionX("",biny,biny);
char title[80];
sprintf(title,"Projection of biny=%d",biny);
hp->SetName("Projection");
hp->SetTitle(title);
hp->Fit("gaus","ql");
c2->Update();
padsav->cd();
}
//______________________________________________________________________________
void HighlightFragment()
{
// TODO templates: what and how highlighing
if (!gPad || !gr) return;
// not correct
TVirtualPad *ph = (TVirtualPad *)gPad->FindObject("ph");
if (!ph) {
ph = new TPad("ph", "ph", 0.0, 0.2, 1.0, 1.0);
ph->SetFillColor(kBlue-10);
ph->Draw();
}
Int_t ih = gr->GetHighlightPoint();
if (ih == -1) return;
TRsnFragment *frag = group->FragmentAt(ih);
if (!frag) return;
TVirtualPad *save = gPad;
ph->cd();
TObject *element = frag->FindElement(tagname);
if (!element) ph->Clear();
else element->Draw();
save->cd();
}
void QtPrintDialog(TVirtualPad *pad = 0) {
TVirtualPad *pd = pad;
if (!pd) pd = TPad::Pad(); // ->GetCanvas();
if (pd) {
QPrinter p;
// Open the Qt "Setup Printer" dialog to configure the "QPrinter p" object
QPrintDialog printDialog(&p);
if (printDialog.exec() == QDialog::Accepted) {
Int_t id = pd->GetPixmapID();
QPixmap *pix = (QPixmap *)(TGQt::iwid(id));
QPainter pnt(&p);
pnt.drawPixmap(0,0,*pix);
}
} else {
printf(" No TCanvas has been selected yet! \n");
}
}
//_______________________________________________________________________________________
static void AdjustScales()
{
TVirtualPad *thisPad = qPad();
if (thisPad) {
TView *view = thisPad->GetView();
if (!view) return;
Double_t min[3],max[3];
view->GetRange(min,max);
int i;
Double_t maxSide = 0;
// Find the largest side
for (i=0;i<3; i++) maxSide = TMath::Max(maxSide,max[i]-min[i]);
//Adjust scales:
for (i=0;i<3; i++) max[i] += maxSide - (max[i]-min[i]);
view->SetRange(min,max);
thisPad->Modified();
thisPad->Update();
}
}
//_______________________________________________________________________________________
static void AddGrid()
{
TVirtualPad *thisPad = qPad();
if (thisPad) {
TView *view = thisPad->GetView();
if (!view) return;
Double_t min[3],max[3];
view->GetRange(min,max);
TList *list = thisPad->GetListOfPrimitives();
TString histName = thisPad->GetName();
TH2F *m_DummyHist = 0;
const Char_t *dummyName = "Axis3D";
histName += dummyName;
m_DummyHist = list->FindObject(histName.Data());
if (!m_DummyHist) {
m_DummyHist = new TH2F(histName.Data(),"",1,min[0],max[0],1,min[1],max[1]);
m_DummyHist->SetDirectory(0);
m_DummyHist->Draw("surf,same");
}
m_DummyHist->GetXaxis()->SetLimits(min[0],max[0]);
m_DummyHist->GetYaxis()->SetLimits(min[1],max[1]);
m_DummyHist->GetZaxis()->SetLimits(min[2],max[2]);
thisPad->Modified();
thisPad->Update();
}
}
void fixsplithist(TH1* htop, TH1* hbot){
TVirtualPad* pmain = TVirtualPad::Pad()->GetCanvas();
if(!pmain) return;
TVirtualPad* p1 = pmain->cd(1);
TVirtualPad* p2 = pmain->cd(2);
if(!p1 || !p2) return;
double scale = p1->GetHNDC() / p2->GetHNDC();
double s = htop->GetYaxis()->GetLabelSize() * scale;
double ss = htop->GetYaxis()->GetLabelSize();
hbot->GetYaxis()->SetLabelSize(s);
htop->GetYaxis()->SetLabelSize(ss);
s = htop->GetYaxis()->GetTitleSize() * scale;
hbot->GetYaxis()->SetTitleSize(s);
hbot->GetYaxis()->SetTitleOffset(0.5);
htop->GetYaxis()->SetTitleOffset(0.5);
s = htop->GetYaxis()->GetLabelOffset() * scale;
s = htop->GetXaxis()->GetLabelSize() * scale;
hbot->GetXaxis()->SetLabelSize(s);
htop->GetXaxis()->SetLabelSize(0.);
s = htop->GetXaxis()->GetTitleSize() * scale;
hbot->GetXaxis()->SetTitleSize(s);
s = htop->GetXaxis()->GetLabelOffset() * scale;
hbot->GetXaxis()->SetLabelOffset(s);
hbot->GetYaxis()->SetNdivisions(5);
}
void makeimage(const char *MacroName, const char *ImageName, const char *OutDir, bool cp, bool py)
{
if (!py) gROOT->ProcessLine(Form(".x %s",MacroName));
else gROOT->ProcessLine(Form("TPython::ExecScript(\"%s\");",MacroName));
if (cp) {
TString MN = MacroName;
Int_t i = MN.Index("(");
Int_t l = MN.Length();
if (i>0) MN.Remove(i, l);
gSystem->Exec(TString::Format("cp %s %s/macros", MN.Data(), OutDir));
}
TIter iCanvas(gROOT->GetListOfCanvases());
TVirtualPad* pad = 0;
int ImageNum = 0;
while ((pad = (TVirtualPad*) iCanvas())) {
ImageNum++;
pad->SaveAs(TString::Format("%s/html/pict%d_%s",OutDir,ImageNum,ImageName));
}
FILE *f = fopen("NumberOfImages.dat", "w");
fprintf(f,"%d\n",ImageNum);
fclose(f);
}
/* *********** multi-pad canvases ******************** */
void setLogy(TCanvas *c, bool on = true) {
c->Modified();
c->Update();
//gSystem->ProcessEvents();
TObject *obj;
TIter next(c->GetListOfPrimitives());
while ((obj = next())) {
if (obj->InheritsFrom(TVirtualPad::Class())) {
TVirtualPad *pad = (TVirtualPad*)obj;
pad->Modified();
pad->Update();
pad->SetLogy(on);
pad->Modified();
pad->Update();
}
}
}
//_______________________________________________________________________________________
static void RotateView(Float_t phi, Float_t theta, TVirtualPad *pad=0)
{
TVirtualPad *thisPad = pad;
if (!thisPad) thisPad = qPad();
if (thisPad) {
TView *view = thisPad->GetView();
if (view) {
Int_t iret;
Float_t p = phi;
Float_t t = theta;
view->SetView(p, t, 0, iret);
thisPad->SetPhi(-90-p);
thisPad->SetTheta(90-t);
thisPad->Modified();
thisPad->Update();
}
}
}
//_______________________________________________________________________________________
static void SetBackroundStyle(TVirtualPad *pad=0)
{
TVirtualPad *thisPad = pad;
if (!thisPad) thisPad = qPad();
if (thisPad) thisPad->SetFillAttributes();
}
void draw_R2m(void)
{
const double er[9] = {0, 0, 0, 0, 0, 0, 0, 0, 0};
double ccnt[9];
double eccnt[9];
double dcnt[9];
TGraphErrors *gr;
TGraphErrors *grd;
TH1D *hst;
TH1D *hstd;
double effUp, effDown, C, shift, size;
double eeffUp, eeffDown, eC, eshift, esize;
double fmin, fedm, errdef;
int npari, nparx;
int i, irc;
char str[1024];
TF1 *fR2;
TVirtualPad *pd;
gStyle->SetOptStat(0);
gStyle->SetOptFit(0);
MyMinuit = new TMinuit(5);
MyMinuit->SetFCN(chi2fun);
MyMinuit->DefineParameter(0, "Const", 1000, 10, 0, 1E10);
MyMinuit->DefineParameter(1, "EffUp", 1, 0.1, 0.5, 1.5);
MyMinuit->DefineParameter(2, "EffDown", 1, 0.1, 0.5, 1.5);
MyMinuit->DefineParameter(3, "Shift", 0, 0.1, -10, 10);
MyMinuit->DefineParameter(4, "Size", 3, 1, 0, 10);
MyMinuit->FixParameter(3);
MyMinuit->FixParameter(4);
MyMinuit->Migrad();
MyMinuit->GetParameter(0, C, eC);
MyMinuit->GetParameter(1, effUp, eeffUp);
MyMinuit->GetParameter(2, effDown, eeffDown);
MyMinuit->GetParameter(3, shift, eshift);
MyMinuit->GetParameter(4, size, esize);
MyMinuit->mnstat(fmin, fedm, errdef, npari, nparx, irc);
// Renorm top and bottom sections to the middle
for (i=0; i<3; i++) {
ccnt[i] = DataArray.cnt[i] / effUp;
ccnt[i+3] = DataArray.cnt[i+3];
ccnt[i+6] = DataArray.cnt[i+6] / effDown;
eccnt[i] = DataArray.ecnt[i] / effUp;
eccnt[i+3] = DataArray.ecnt[i+3];
eccnt[i+6] = DataArray.ecnt[i+6] / effDown;
}
// for (i=0; i<9; i++) printf("L = %8.3f CNT = %6.1f +- %4.1f\n", r[i], cnt[i], ecnt[i]);
gr = new TGraphErrors(9, DataArray.r, ccnt, er, eccnt);
gr->SetLineColor(kBlue);
gr->SetLineWidth(4);
gr->SetMarkerStyle(20);
gr->SetMarkerColor(kBlue);
gr->SetMarkerSize(2);
fR2 = new TF1("fR2", "[0] / ((x - [1]) * (x - [1]) - [2] * [2] / 4.0)", 1, 100);
fR2->SetParameter(0, C);
fR2->SetParameter(1, shift);
fR2->SetParameter(2, size);
fR2->SetLineColor(kRed);
fR2->SetLineWidth(3);
hst = new TH1D("H", ";Distance to reactor core center, m;Events per day", 35, 10, 13.5);
hst->SetMinimum(DataArray.cnt[4] * 0.5);
hst->SetMaximum(DataArray.cnt[4] * 1.5);
hst->GetXaxis()->SetLabelSize(0.06);
hst->GetYaxis()->SetLabelSize(0.06);
hst->GetXaxis()->SetTitleSize(0.06);
hst->GetYaxis()->SetTitleSize(0.06);
hst->GetYaxis()->SetTitleOffset(1.25);
hstd = new TH1D("H", ";Distance to reactor core center, m;Events per day", 35, 10, 13.5);
hstd->SetMinimum(-40);
hstd->SetMaximum(40);
hstd->GetXaxis()->SetLabelSize(0.06);
hstd->GetYaxis()->SetLabelSize(0.06);
hstd->GetXaxis()->SetTitleSize(0.06);
hstd->GetYaxis()->SetTitleSize(0.06);
hstd->GetYaxis()->SetTitleOffset(1.25);
TCanvas *cv = new TCanvas("CV", "R2", 800, 1200);
cv->Divide(1, 2);
// Do common fit and draw
pd = cv->cd(1);
pd->SetLeftMargin(0.15);
pd->SetBottomMargin(0.15);
pd->SetTopMargin(0.03);
hst->Draw();
gr->Draw("p");
fR2->Draw("same");
TLatex txt;
txt.SetTextSize(0.07);
sprintf(str, "#chi^{2}/n.d.f. = %6.2f/5", fmin);
txt.DrawLatex(11.3, DataArray.cnt[4] * 1.3, str);
// Draw difference
for (i=0; i<9; i++) dcnt[i] = ccnt[i] - fR2->Eval(DataArray.r[i]);
grd = new TGraphErrors(9, DataArray.r, dcnt, er, eccnt);
grd->SetLineColor(kBlue);
grd->SetLineWidth(4);
grd->SetMarkerStyle(20);
grd->SetMarkerColor(kBlue);
grd->SetMarkerSize(2);
pd = cv->cd(2);
pd->SetLeftMargin(0.15);
pd->SetBottomMargin(0.15);
pd->SetTopMargin(0.03);
hstd->Draw();
grd->Draw("p");
}
void
TestSPD(const TString& which, Double_t nVar=2)
{
TFile* file = TFile::Open("forward.root", "READ");
if (!file) return;
Bool_t spd = which.EqualTo("spd", TString::kIgnoreCase);
TList* l = 0;
if (spd) l = static_cast<TList*>(file->Get("CentralSums"));
else l = static_cast<TList*>(file->Get("ForwardSums"));
if (!l) {
Warning("", "%sSums not found", spd ? "Central" : "Forward");
return;
}
TList* ei = static_cast<TList*>(l->FindObject("fmdEventInspector"));
if (!l) {
Warning("", "fmdEventInspector not found");
return;
}
TObject* run = ei->FindObject("runNo");
if (!run)
Warning("", "No run number found");
ULong_t runNo = run ? run->GetUniqueID() : 0;
TH2* h = 0;
if (spd) h = static_cast<TH2*>(l->FindObject("nClusterVsnTracklet"));
else {
TList* den = static_cast<TList*>(l->FindObject("fmdDensityCalculator"));
if (!den) {
Error("", "fmdDensityCalculator not found");
return;
}
TList* rng = static_cast<TList*>(den->FindObject(which));
if (!rng) {
Error("", "%s not found", which.Data());
return;
}
h = static_cast<TH2*>(rng->FindObject("elossVsPoisson"));
}
if (!h) {
Warning("", "%s not found", spd ? nClusterVsnTracklet : "elossVsPoisson");
return;
}
gStyle->SetOptFit(1111);
gStyle->SetOptStat(0);
TCanvas* c = new TCanvas("c", Form("Run %u", runNo));
c->Divide(2,2);
TVirtualPad* p = c->cd(1);
if (spd) {
p->SetLogx();
p->SetLogy();
}
p->SetLogz();
h->Draw("colz");
TObjArray* fits = new TObjArray;
h->FitSlicesY(0, 1, -1, 0, "QN", fits);
TF1* mean = new TF1("mean", "pol1");
TF1* var = new TF1("var", "pol1");
// mean->FixParameter(0, 0);
// var->FixParameter(0, 0);
for (Int_t i = 0; i < 3; i++) {
p = c->cd(2+i);
if (spd) {
p->SetLogx();
p->SetLogy();
}
TH1* hh = static_cast<TH1*>(fits->At(i));
hh->Draw();
if (i == 0) continue;
hh->Fit((i == 1? mean : var), "+Q");
}
TGraphErrors* g1 = new TGraphErrors(h->GetNbinsX());
g1->SetFillColor(kBlue-10);
g1->SetFillStyle(3001);
g1->SetLineStyle(1);
TGraph* u1 = new TGraph(h->GetNbinsX());
TGraph* l1 = new TGraph(h->GetNbinsX());
u1->SetLineColor(kBlue+1);
l1->SetLineColor(kBlue+1);
u1->SetName("u1");
l1->SetName("l1");
TGraphErrors* g2 = new TGraphErrors(h->GetNbinsX());
g2->SetFillColor(kRed-10);
g2->SetFillStyle(3001);
g2->SetLineStyle(2);
TGraph* u2 = new TGraph(h->GetNbinsX());
TGraph* l2 = new TGraph(h->GetNbinsX());
u2->SetLineColor(kRed+1);
l2->SetLineColor(kRed+1);
u2->SetName("u2");
l2->SetName("l2");
for (Int_t i = 1; i <= h->GetNbinsX(); i++) {
Double_t x = hh->GetXaxis()->GetBinCenter(i);
Double_t y = mean->Eval(x);
Double_t e = var->Eval(y);
Double_t e1 = nVar * e;
if (spd) e1 *= TMath::Log10(e);
// Printf("%10e -> %10e +/- %10e", x, y, ee);
g1->SetPoint(i-1, x, y);
g1->SetPointError(i-1, 0, e1);
u1->SetPoint(i-1, x, y+e1);
l1->SetPoint(i-1, x, y-e1);
// Printf("%3d: %f -> %f +/- %f", i, x, y, ee);
Double_t e2 = nVar*0.05*x;
g2->SetPoint(i-1, x, x);
g2->SetPointError(i-1, 0, e2);
u2->SetPoint(i-1, x, x+e2);
l2->SetPoint(i-1, x, x-e2);
}
p = c->cd(1);
c->Clear();
c->cd();
c->SetLogz();
h->Draw("colz");
g1->Draw("3 same");
u1->Draw("l same");
l1->Draw("l same");
g2->Draw("3 same");
u2->Draw("l same");
l2->Draw("l same");
Double_t ly = 0.9;
Double_t dy = 0.06;
TLatex* ltx = new TLatex(0.15, ly, Form("#LTy#GT = %f + %f x",
mean->GetParameter(0),
mean->GetParameter(1)));
ltx->SetNDC();
ltx->SetTextSize(dy);
ltx->SetTextAlign(13);
ltx->Draw();
ly -= dy + 0.01;
ltx->DrawLatex(0.15, ly, Form("#sigma_{y} = %f + %f x",
var->GetParameter(0),
var->GetParameter(1)));
ly -= dy + 0.01;
ltx->DrawLatex(0.15, ly, Form("#delta = %f #sigma %s",
nVar, (spd ? "log_{10}(#sigma" : "")));
}
void danss_calc_ratio(void)
{
#ifdef STRONG_CUTS
const char fname[] = "danss_report_strong.root";
const char pname[] = "danss_ratio_strong.pdf";
#else
const char fname[] = "danss_report.root";
const char pname[] = "danss_ratio.pdf";
#endif
const struct {
char name[32];
int first;
int last;
} positions[] = {
{ "down_21.04.16", 2307, 2361}, // [0] - 0-
{ "up_22.04.16", 2366, 2387}, // [1] - 0+
{ "down_23.04.16", 2399, 2445}, // [2] - 0-
{ "mid_24.04.16", 2449, 2512},
{ "up_25.04.16", 2514, 2562}, // [4] - 1+
{ "down_26.04.16", 2564, 2609}, // [5] - 1-
{ "mid_27.04.16", 2620, 2685},
{ "up_28.04.16", 2687, 2730}, // [7] - 2+
{ "down_29.04.16", 2733, 2788}, // [8] - 2-
{ "mid_30.04.16", 2791, 2832},
{ "stuck_01.05.16", 2836, 3399},
{ "stuck_10.05.16", 3400, 3788},
{ "up_03.06.16", 4261, 4400}, // [12] - 3+
{ "down_06.06.16", 4403, 4439}, // [13] - 3-
{ "up_08.06.16", 4508, 4601}, // [14] - 3+
{ "raised_30.09.16", 5540, 5807},
{ "raised_04.10.16", 5808, 5903}, // veto corners on
{ "mid_05.10.16", 5907, 5995}, // [17]
{ "up_10.10.16", 6007, 6130}, // [18] - 5+
// { "mid_12.10.16", 6136, 6275},
// { "down_14.10.16", 6278, 6467},
// { "up_17.10.16", 6469, 6570},
// { "mid_21.10.16", 6573, 6582},
// { "down_21.10.16", 6587, 6745},
// { "up_24.10.16", 6757, 6815},
// { "mid_27.10.16", 6842, 6923},
// { "down_28.10.16", 6926, 7095},
{ "up_31.10.16", 7106, 7364}, // [19] - 5+
{ "mid_11.11.16", 7387, 7406}, // [20]
{ "down_11.11.16", 7418, 7458}, // [21] - 5-
{ "up_14.11.16", 7478, 7579}, // [22] - 6+
// { "mid_16.11.16", 7581, 7717},
{ "down_18.11.16", 7727, 7913}, // [23] - 6-
{ "up_21.11.16", 7922, 8042}, // [24] - 7+
{ "mid_23.11.16", 8048, 8179}, // [25]
{ "down_25.11.16", 8185, 8353}, // [26] - 7-
{ "up_28.11.16", 8357, 8430}, // [27] - 8+
{ "mid_01.12.16", 8470, 8571}, // [28]
{ "down_02.12.16", 8574, 8738}, // [29] - 8-
{ "up_05.12.16", 8741, 8869}, // [30] - 8+
{ "mid_07.12.16", 8873, 9009}, // [31]
{ "up_12.12.16", 9012, 9112}, // [32] - 9+
{ "mid_14.12.16", 9116, 9245}, // [33]
{ "down_16.12.16", 9253, 9470}, // [34] - 9-
// { "up_19.12.16", 9475, 9600},
// { "mid_21.12.16", 9603, 9712},
// { "down_23.12.16", 9715, 9869},
// { "up_26.12.16", 9871, 10019}
// { "mid_28.12.16", 10021, 10171},
// { "down_30.12.16", 10175, 10307},
// { "down_02.01.17", 10308, 10356},
// { "down_03.01.17", 10357, 10424},
{ "up_04.01.17", 10433, 10832}, // [35] - 10+
{ "mid_11.01.17", 10834, 10973}, // [36]
{ "down_13.01.17", 10979, 11147}, // [37] - 10-
{ "up_16.01.17", 11150, 11267}, // [38] - 11+
{ "mid_18.01.17", 11271, 11401}, // [39]
{ "down_20.01.17", 11404, 11563}, // [40] - 11-
{ "up_23.01.17", 11570, 11619} // [41] - 11+
};
int i, j;
int N;
TCanvas *cv;
TFile *f;
TH1 *h[sizeof(positions) / sizeof(positions[0])];
TH1 *hSum[12];
TH1 *hRatio[7];
TH1 *hTmp[3];
char str[1024];
TLatex *txt;
double val, err;
TVirtualPad *pd;
const char periods[3][30] = {"April-June", "October-November", "December-January"};
gStyle->SetOptStat(0);
gStyle->SetOptFit(1);
N = sizeof(positions) / sizeof(positions[0]);
cv = new TCanvas("CV", "Results", 2400, 1200);
f = new TFile(fname, "UPDATE");
if (!f->IsOpen()) return;
sprintf(str, "%s[", pname);
cv->Print(str);
txt = new TLatex();
for (i=0; i<N; i++) {
sprintf(str, "%s_hRes", positions[i].name);
h[i] = (TH1 *) f->Get(str);
if (!h[i]) {
printf("%s not found in %s\n", positions[i].name, fname);
return;
}
h[i]->SetBit(TH1::kIsAverage);
}
hSum[0] = (TH1 *) h[0]->Clone("hUp");
hSum[1] = (TH1 *) h[0]->Clone("hDown");
hSum[2] = (TH1 *) h[0]->Clone("hMid");
hSum[3] = (TH1 *) h[0]->Clone("hSum");
hSum[4] = (TH1 *) h[0]->Clone("hSum_first");
hSum[5] = (TH1 *) h[0]->Clone("hSum_last");
hSum[6] = (TH1 *) h[0]->Clone("hUpAprilJune");
hSum[7] = (TH1 *) h[0]->Clone("hDownAprilJune");
hSum[8] = (TH1 *) h[0]->Clone("hUpOctoberNovember");
hSum[9] = (TH1 *) h[0]->Clone("hDownOctoberNovember");
hSum[10] = (TH1 *) h[0]->Clone("hUpDecemberJanuary");
hSum[11] = (TH1 *) h[0]->Clone("hDownDecemberJanuary");
hRatio[0] = (TH1 *) h[0]->Clone("hRatio");
hRatio[1] = (TH1 *) h[0]->Clone("hMix");
hRatio[2] = (TH1 *) h[0]->Clone("hRatio2");
hRatio[3] = (TH1 *) h[0]->Clone("hRatioMidUp");
hRatio[4] = (TH1 *) h[0]->Clone("hRatioAprilJune");
hRatio[5] = (TH1 *) h[0]->Clone("hRatioOctoberNovember");
hRatio[6] = (TH1 *) h[0]->Clone("hRatioDecemberJanuary");
hTmp[0] = (TH1 *) h[0]->Clone("hTmpUp");
hTmp[1] = (TH1 *) h[0]->Clone("hTmpDown");
hTmp[2] = (TH1 *) h[0]->Clone("hTmpRatio");
for (i=0; i<12; i++) hSum[i]->Reset();
for (i=0; i<12; i++) hSum[i]->SetLineWidth(2);
for (i=0; i<N; i++) {
switch (positions[i].name[0]) {
case 'u' : j = 0; break;
case 'd' : j = 1; break;
case 'm' : j = 2; break;
default : j = -1; break;
}
if (j >= 0) hSum[j]->Add(h[i]);
hSum[(i < N/2) ? 4 : 5]->Add(h[i]);
hSum[3]->Add(h[i]);
}
// for (i=0; i<3; i++) hSum[3]->Add(hSum[i]);
hRatio[0]->Divide(hSum[1], hSum[0]);
hRatio[1]->Divide(hSum[5], hSum[4]);
hRatio[3]->Divide(hSum[2], hSum[0]);
// Ratio from short ratios
hRatio[2]->Reset();
hRatio[2]->SetBit(TH1::kIsAverage);
// 0+2 / 1
hTmp[0]->Add(h[0], h[2]);
hTmp[2]->Divide(hTmp[0], h[1]);
hRatio[2]->Add(hTmp[2]);
// 5 / 4
hTmp[2]->Divide(h[5], h[4]);
hRatio[2]->Add(hTmp[2]);
// 8 / 7
hTmp[2]->Divide(h[8], h[7]);
hRatio[2]->Add(hTmp[2]);
// 13 / 12 + 14
hTmp[0]->Add(h[12], h[14]);
hTmp[2]->Divide(h[13], hTmp[0]);
hRatio[2]->Add(hTmp[2]);
// 21 / 18+19
hTmp[0]->Add(h[18], h[19]);
hTmp[2]->Divide(h[21], hTmp[0]);
hRatio[2]->Add(hTmp[2]);
// 23 / 22
hTmp[2]->Divide(h[23], h[22]);
hRatio[2]->Add(hTmp[2]);
// 26 / 24
hTmp[2]->Divide(h[26], h[24]);
hRatio[2]->Add(hTmp[2]);
// 29 / 27 + 30
hTmp[0]->Add(h[27], h[30]);
hTmp[2]->Divide(h[29], hTmp[0]);
hRatio[2]->Add(hTmp[2]);
// 34 / 32
hTmp[2]->Divide(h[34], h[32]);
hRatio[2]->Add(hTmp[2]);
// 37 / 35
hTmp[2]->Divide(h[37], h[35]);
hRatio[2]->Add(hTmp[2]);
// 40 / 38 + 41
hTmp[0]->Add(h[38], h[41]);
hTmp[2]->Divide(h[40], hTmp[0]);
hRatio[2]->Add(hTmp[2]);
// AprilJune (0 + 2 + 5 + 8 + 13) / (1 + 4 + 7 + 12 + 14)
hSum[6]->Add(h[1]);
hSum[6]->Add(h[4]);
hSum[6]->Add(h[7]);
hSum[6]->Add(h[12]);
hSum[6]->Add(h[14]);
hSum[7]->Add(h[0]);
hSum[7]->Add(h[2]);
hSum[7]->Add(h[5]);
hSum[7]->Add(h[8]);
hSum[7]->Add(h[13]);
hRatio[4]->Divide(hSum[7], hSum[6]);
// OctoberNovember (21 + 23 + 26 + 29) / (18 + 19 + 22 + 24 + 27 + 30)
hSum[8]->Add(h[18]);
hSum[8]->Add(h[19]);
hSum[8]->Add(h[22]);
hSum[8]->Add(h[24]);
hSum[8]->Add(h[27]);
hSum[8]->Add(h[30]);
hSum[9]->Add(h[21]);
hSum[9]->Add(h[23]);
hSum[9]->Add(h[26]);
hSum[9]->Add(h[29]);
hRatio[5]->Divide(hSum[9], hSum[8]);
// DecemberJanuary (34 + 37 + 40) / (32 + 35 + 38 + 41)
hSum[10]->Add(h[32]);
hSum[10]->Add(h[35]);
hSum[10]->Add(h[38]);
hSum[10]->Add(h[41]);
hSum[11]->Add(h[34]);
hSum[11]->Add(h[37]);
hSum[11]->Add(h[40]);
hRatio[6]->Divide(hSum[11], hSum[10]);
cv->Divide(2, 1);
pd = cv->cd(1);
pd->Divide(1, 2);
pd->cd(1);
hSum[0]->SetTitle("Up - Middle - Down;MeV;mHz");
hSum[0]->SetLineColor(kRed);
hSum[2]->SetLineColor(kGreen);
hSum[1]->SetLineColor(kBlue);
for (i=0; i<4; i++) hSum[i]->SetLineWidth(2);
hSum[0]->Draw();
hSum[2]->Draw("same");
hSum[1]->Draw("same");
val = hSum[0]->IntegralAndError(1, 35, err);
sprintf(str, "Up = %5.2f+-%4.2f", val, err);
txt->SetTextColor(kRed);
txt->DrawTextNDC(0.4, 0.85, str);
val = hSum[2]->IntegralAndError(1, 35, err);
sprintf(str, "Mid = %5.2f+-%4.2f", val, err);
txt->SetTextColor(kGreen);
txt->DrawTextNDC(0.4, 0.8, str);
val = hSum[1]->IntegralAndError(1, 35, err);
sprintf(str, "Down = %5.2f+-%4.2f", val, err);
txt->SetTextColor(kBlue);
txt->DrawTextNDC(0.4, 0.75, str);
pd->cd(2);
hSum[3]->SetTitle("Average of all positions;MeV;mHz");
hSum[3]->SetLineColor(kBlack);
hSum[3]->Draw();
val = hSum[3]->IntegralAndError(1, 35, err);
sprintf(str, "Avr = %5.2f+-%4.2f", val, err);
txt->SetTextColor(kBlack);
txt->DrawTextNDC(0.4, 0.8, str);
pd = cv->cd(2);
pd->Divide(1, 4);
pd->cd(1);
hRatio[0]->SetTitle("Down/Up all by all;MeV;");
hRatio[0]->SetLineColor(kBlack);
hRatio[0]->SetLineWidth(2);
hRatio[0]->SetMinimum(0.5);
hRatio[0]->SetMaximum(1.0);
hRatio[0]->Fit("pol0", "", "", 1, 7);
pd->cd(2);
hRatio[2]->SetTitle("Down/Up pair by pair;MeV;");
hRatio[2]->SetLineColor(kBlack);
hRatio[2]->SetLineWidth(2);
hRatio[2]->SetMinimum(0.5);
hRatio[2]->SetMaximum(1.0);
hRatio[2]->Fit("pol0", "", "", 1, 7);
pd->cd(3);
hRatio[3]->SetTitle("Mid/Up all by all;MeV;");
hRatio[3]->SetLineColor(kBlack);
hRatio[3]->SetLineWidth(2);
hRatio[3]->SetMinimum(0.65);
hRatio[3]->SetMaximum(1.15);
hRatio[3]->Fit("pol0", "", "", 1, 7);
pd->cd(4);
hRatio[1]->SetTitle("First half/Last half;MeV;");
hRatio[1]->SetLineColor(kBlack);
hRatio[1]->SetLineWidth(2);
hRatio[1]->SetMinimum(0.75);
hRatio[1]->SetMaximum(1.25);
hRatio[1]->Fit("pol0", "", "", 1, 7);
cv->Update();
cv->Print(pname);
cv->Clear();
cv->Divide(2, 2);
for (i=0; i<3; i++) {
cv->cd(i+1);
sprintf(str, "Down/Up all by all for %s;MeV;", periods[i]);
hRatio[4+i]->SetTitle(str);
hRatio[4+i]->SetLineColor(kBlack);
hRatio[4+i]->SetLineWidth(2);
hRatio[4+i]->SetMinimum(0.5);
hRatio[4+i]->SetMaximum(1.0);
hRatio[4+i]->Fit("pol0", "", "", 1, 7);
}
cv->Update();
cv->Print(pname);
sprintf(str, "%s]", pname);
cv->Print(str);
for (i=0; i<12; i++) hSum[i]->Write();
for (i=0; i<7; i++) hRatio[i]->Write();
f->Close();
delete cv;
}
void ExtractOutputHistos(Bool_t onlyPrims=0,Bool_t onlyPion=0,Int_t plotFlag=0) {
// gROOT->SetStyle("Plain");
gStyle->SetPalette(1);
const Int_t nbins=20;
Double_t ptmin=0.06;//04;
Double_t ptmax=2.0;//GeV
Double_t logxmin = TMath::Log10(ptmin);
Double_t logxmax = TMath::Log10(ptmax);
Double_t binwidth = (logxmax-logxmin)/(nbins+1);
enum {nb=nbins+1};
Double_t xbins[nb];
xbins[0] = ptmin;
for (Int_t i=1;i<=nbins;i++) {
xbins[i] = ptmin + TMath::Power(10,logxmin+(i)*binwidth);
// cout<<xbins[i]<<endl;
}
// TH1F *h = new TH1F("h","hist with log x axis",nbins,xbins);
TH1F *hMultCount = new TH1F("mult","averaged multiplicity (charg. prim)",80,-4.,4.);
hMultCount->GetXaxis()->SetTitle("eta");
hMultCount->GetYaxis()->SetTitle("N/d#eta");
TH1F *hAllMC = new TH1F("allMC","All Tracks MC primaries",nbins,xbins);
TH1F *hAllFound = new TH1F("allFound","All Tracks found",nbins,xbins);
TH1F *hImperfect = new TH1F("imperfect","Imperfect tracks",nbins,xbins);
TH1F *hPerfect = new TH1F("perfect","Perfect tracks",nbins,xbins);
TH1F *hEff = new TH1F("efficiency","Efficiency (Perfect tracks in \"ALL MC\")",nbins,xbins);
TH1F *hFake = new TH1F("fake","Fake tracks (Inperfect tracks in \"ALL MC\")",nbins,xbins);
TH1F *hPurity = new TH1F("purity","Purity (Perfect tracks in \"All Found\")",nbins,xbins);
TH1F *hAnna = new TH1F("annaEff","AnnalisaEff ",nbins,xbins);
TH1F *hNoMCTrack = new TH1F("noMCtrack","noMCtrack ",nbins,xbins);
TH1F *hEta = new TH1F("","",50,-2,2);
// TH1F *hEtaMC = new TH1F("","",50,-2,2);
TH2D *h2Ddca = new TH2D("dca2D","DCAvsPt2D",nbins,xbins,50,-0.05,0.05);
TH2D *h2Dpt = new TH2D("dPt2D","dPtdvsPt2D",nbins,xbins,50,-25,25);
// open run loader and load gAlice, kinematics and header
AliRunLoader* runLoader = AliRunLoader::Open("galice.root");
if (!runLoader) {
Error("Check kine", "getting run loader from file %s failed",
"galice.root");
return;
}
runLoader->LoadgAlice();
gAlice = runLoader->GetAliRun();
if (!gAlice) {
Error("Check kine", "no galice object found");
return;
}
runLoader->LoadHeader();
runLoader->LoadKinematics();
TFile* esdFile = TFile::Open("AliESDs.root");
if (!esdFile || !esdFile->IsOpen()) {
Error("CheckESD", "opening ESD file %s failed", "AliESDs.root");
return;
}
AliESDEvent *esd = new AliESDEvent();
TTree* tree = (TTree*) esdFile->Get("esdTree");
if (!tree) {
Error("CheckESD", "no ESD tree found");
return;
}
esd->ReadFromTree(tree);
Int_t nTrackTotalMC = 0;
Int_t nTrackFound = 0;
Int_t nTrackImperfect = 0;
Int_t nTrackPerfect = 0;
Int_t nNoMCTrack = 0;
for(Int_t iEv =0; iEv<tree->GetEntries(); iEv++){
tree->GetEvent(iEv);
runLoader->GetEvent(iEv);
printf("+++ event %i (of %lld) +++++++++++++++++++++++ # ESDtracks: %d \n",iEv,tree->GetEntries()-1,esd->GetNumberOfTracks());
Int_t nESDtracks = esd->GetNumberOfTracks();
for (Int_t iTrack = 0; iTrack < nESDtracks; iTrack++) {
AliESDtrack* track = esd->GetTrack(iTrack);
if (!(iTrack%1000)) printf("event %i: ESD track count %d (of %d)\n",iEv,iTrack,nESDtracks);
Int_t label = track->GetLabel();
Int_t idx[12];
// Int_t ncl = track->GetITSclusters(idx);
if(label<0) {
// cout<< " ESD track label " << label;
// cout<<" ---> imperfect track (label "<<label<<"<0) !! -> track Pt: "<< track->Pt() << endl;
}
AliStack* stack = runLoader->Stack();
// nTrackTotalMC += stack->GetNprimary();
TParticle* particle = stack->Particle(TMath::Abs(label));
Double_t pt = track->Pt();
if(particle) {
if (TMath::Abs(particle->Eta())>etaCut) continue;
Double_t ptMC = particle->Pt();
// Efficiencies
if (onlyPion && TMath::Abs(particle->GetPdgCode())!=211) continue;
if ( (!onlyPrims) || stack->IsPhysicalPrimary(TMath::Abs(label))) {
// cout<<" # clusters "<<ncl<<endl;
nTrackFound++;
hAllFound->Fill(ptMC);
hEta->Fill(track->Eta());
if (label<0) {
nTrackImperfect++;
hImperfect->Fill(ptMC);
} else {
nTrackPerfect++;
hPerfect->Fill(ptMC);
}
}
// following only for "true tracks, pions
if(particle->Pt() < 0.001)continue;
if (TMath::Abs(particle->GetPdgCode())!=211) continue;
if (label>0) {
// Impact parameters for Pions only
Double_t dca = track->GetD(0,0,0.5);
h2Ddca->Fill(ptMC,dca);
// Pt resolution for Pions only
Double_t dPt = (pt-ptMC)/ptMC*100;
h2Dpt->Fill(ptMC,dPt);
}
} else {
nNoMCTrackFound++;
hNoMCTrack->Fill(pt);
cout<<" according MC particle not found"<<endl;
}
} //entries track esd
}//entries tree
runLoader->UnloadHeader();
runLoader->UnloadKinematics();
delete runLoader;
// Count trackable MC tracks
CountTrackableMCs(hAllMC, onlyPrims, onlyPion);
// Count trackable MC tracks
CountPrimaries(hMultCount);
// Get Errors right
hMultCount->Sumw2();
hAllMC->Sumw2();
hAllFound->Sumw2();
hPerfect->Sumw2();
hImperfect->Sumw2();
h2Dpt->Sumw2();
h2Ddca->Sumw2();
// -- Global efficienies
nTrackTotalMC = hAllMC->GetEntries();
Double_t eff = ((Double_t)nTrackPerfect)/nTrackTotalMC;
printf("-> Total number of events: %lld -> MCtracks %d -> nPerfect %d -> Eff: %3.2lf \n",
tree->GetEntries(),nTrackTotalMC,nTrackPerfect,eff);
Double_t purity = ((Double_t)nTrackPerfect)/nTrackFound;
printf("-> Total number of events: %lld -> FoundTracks %d -> nPerfect %d -> Purity: %3.2lf \n",
tree->GetEntries(),nTrackFound,nTrackPerfect,purity);
// Efficiencies - and normalize to 100%
TF1 f1("f1","100+x*0",0.,1.e3);
hPurity->Divide(hPerfect,hAllFound,1,1,"b");
hPurity->Multiply(&f1);
hPurity->SetMarkerColor(kGreen);
hPurity->SetMarkerStyle(21);
hPurity->GetXaxis()->SetTitle("transverse momentum p_{t} (GeV)");
hPurity->SetStats(0);
hPurity->GetYaxis()->SetRangeUser(0,100);
hPurity->SetTitle("Efficiency & Purity");
hEff->Divide(hPerfect,hAllMC,1,1,"b");
hEff->Multiply(&f1);
hEff->GetXaxis()->SetTitle("transverse momentum p_{t} (GeV)");
hEff->SetMarkerColor(kBlue);
hEff->SetMarkerStyle(21);
hEff->SetStats(0);
hFake->Divide(hImperfect,hAllMC,1,1,"b");
hFake->Multiply(&f1);
hFake->GetXaxis()->SetTitle("transverse momentum p_{t} (GeV)");
hFake->SetMarkerColor(kRed);
hFake->SetMarkerStyle(21);
hFake->SetStats(0);
hAnna->Divide(hAllFound,hAllMC,1,1,"b");
hAnna->Multiply(&f1);
hAnna->GetXaxis()->SetTitle("transverse momentum p_{t} (GeV)");
hAnna->SetMarkerColor(kBlack);
hAnna->SetMarkerStyle(21);
hAnna->SetStats(0);
TCanvas *c1 = new TCanvas("c1","NoMCTrackFound");//,200,10,900,900);
TVirtualPad *pad = c1->cd();
pad->SetGridx(); pad->SetGridy();
hNoMCTrack->Draw();
TCanvas *c2 = new TCanvas("c2","Eff&Purity");//,200,10,900,900);
TVirtualPad *pad = c2->cd();
pad->SetGridx(); pad->SetGridy();
// pad->SetLogx();
hPurity->Draw("E");
hEff->Draw("Same E");
hFake->Draw("Same E");
hAnna->Draw("Same E");
TLegend *leg = new TLegend(0.1,0.8,0.6,0.9);leg->SetFillColor(0);
leg->AddEntry(hPurity,"Purity (\"Perfect tracks\" within \"Found Tracks\")","PE");
leg->AddEntry(hEff,"Efficiency (\"Perfect tracks\" within \"MC findable Tracks\")","PE");
leg->AddEntry(hFake,"Fake (\"Inperfect tracks\" within \"MC findable Tracks\")","PE");
leg->AddEntry(hAnna,"AnnaLisa - Efficiency (\"Found tracks\" within \"MC findable Tracks\")","PE");
leg->Draw();
if (plotFlag==1){
hAllMC->GetXaxis()->SetTitle("transverse momentum p_{t} (GeV)");
hAllMC->Draw(); // MC pt distribution
hAllFound->SetLineColor(2);
hAllFound->Draw("same"); // MC pt distribution
}
/*
.L ~/ITSupgrade/BuildDetector/DetectorK.cxx+
// All NEW
DetectorK its("ALICE","ITS");
its.MakeAliceAllNew(0);
its.SetMaxRadiusOfSlowDetectors(0.01);
its.SolveViaBilloir(0);
TGraph *c = its.GetGraphRecoEfficiency(0,3,2);
c->Draw("C");
// Current
DetectorK its("ALICE","ITS");
its.MakeAliceCurrent(0,0);
its.SetMaxRadiusOfSlowDetectors(0.01);
its.SolveViaBilloir(0);
TGraph *c = its.GetGraphRecoEfficiency(0,4,2);
c->Draw("C");
*/
TCanvas *c3 = new TCanvas("c3","impact");//,200,10,900,900);
c3->Divide(2,1); c3->cd(1);
// Impact parameter
// Impact parameter resolution ---------------
h2Ddca->Draw("colz");
h2Ddca->FitSlicesY() ;
TH2D *dcaM = (TH2D*)gDirectory->Get("dca2D_1"); dcaM->Draw("same");
TH2D *dcaRMS = (TH2D*)gDirectory->Get("dca2D_2"); //dcaRMS->Draw();
TGraphErrors *d0 = new TGraphErrors();
for (Int_t ibin =1; ibin<=dcaRMS->GetXaxis()->GetNbins(); ibin++) {
d0->SetPoint( ibin-1,dcaRMS->GetBinCenter(ibin),dcaRMS->GetBinContent(ibin)*1e4); // microns
d0->SetPointError(ibin-1,0,dcaRMS->GetBinError(ibin)*1e4); // microns
}
d0->SetMarkerStyle(21);
d0->SetMaximum(200); d0->SetMinimum(0);
d0->GetXaxis()->SetTitle("transverse momentum p_{t} (GeV)");
d0->GetYaxis()->SetTitle("R-#phi Pointing Resolution (#mum)");
d0->SetName("dca"); d0->SetTitle("DCAvsPt");
c3->cd(1); h2Ddca->Draw("surf2");
c3->cd(2); d0->Draw("APE");
// PT RESOLUTION ------------
TCanvas *c4 = new TCanvas("c4","pt resolution");//,200,10,900,900);
c4->Divide(2,1); c4->cd(1);
// Impact parameter
h2Dpt->Draw("colz");
h2Dpt->FitSlicesY() ;
TH2D *dPtM = (TH2D*)gDirectory->Get("dPt2D_1"); dPtM->Draw("same");
TH2D *dPtRMS = (TH2D*)gDirectory->Get("dPt2D_2"); // dPtRMS->Draw("");
TGraphErrors *gPt = new TGraphErrors();
for (Int_t ibin =1; ibin<=dPtRMS->GetXaxis()->GetNbins(); ibin++) {
gPt->SetPoint( ibin-1,dPtRMS->GetBinCenter(ibin),dPtRMS->GetBinContent(ibin));
gPt->SetPointError(ibin-1,0,dPtRMS->GetBinError(ibin));
}
gPt->SetMarkerStyle(21);
gPt->SetMaximum(20); gPt->SetMinimum(0);
gPt->GetXaxis()->SetTitle("transverse momentum p_{t} (GeV)");
gPt->GetYaxis()->SetTitle("relative momentum resolution (%)");
gPt->SetName("dPt"); gPt->SetTitle("DPTvsPt");
c4->cd(1); h2Dpt->Draw("surf2");
c4->cd(2); gPt->Draw("APE");
// EXPORT --------
TFile f("histos.root","RECREATE");
hMultCount->Write();
hAllMC->Write();
hAllFound->Write();
hImperfect->Write();
hPerfect->Write();
hNoMCTrack->Write();
hPurity->Write();
hEff->Write();
hFake->Write();
hAnna->Write();
h2Ddca->Write();
d0->Write();
h2Dpt->Write();
gPt->Write();
f.Close();
return;
}
void makePlot(const std::string& inputFilePath, const std::string& canvasName, const std::string& sample, int massPoint, const std::string& channel, double k,
const std::string& inputFileName, const std::string& outputFilePath, const std::string& outputFileName)
{
std::string inputFileName_full = Form("%s%s", inputFilePath.data(), inputFileName.data());
TFile* inputFile = new TFile(inputFileName_full.data());
if ( !inputFile ) {
std::cerr << "Failed to open input file = " << inputFileName_full << " !!" << std::endl;
assert(0);
}
inputFile->ls();
TCanvas* canvas = dynamic_cast<TCanvas*>(inputFile->Get(canvasName.data()));
if ( !canvas ) {
std::cerr << "Failed to load canvas = " << canvasName << " !!" << std::endl;
assert(0);
}
int idxPad = -1;
if ( massPoint == 90 ) idxPad = 1;
if ( massPoint == 125 ) idxPad = 2;
if ( massPoint == 200 ) idxPad = 3;
if ( massPoint == 300 ) idxPad = 4;
if ( massPoint == 500 ) idxPad = 5;
if ( massPoint == 800 ) idxPad = 6;
if ( !(idxPad >= 1 && idxPad <= 6) ) {
std::cerr << "Invalid sample = " << sample << " !!" << std::endl;
assert(0);
}
TVirtualPad* pad = canvas->GetPad(idxPad);
std::cout << "pad = " << pad << ": ClassName = " << pad->ClassName() << std::endl;
TCanvas* canvas_new = new TCanvas("canvas_new", "canvas_new", 900, 800);
canvas_new->SetFillColor(10);
canvas_new->SetBorderSize(2);
canvas_new->SetTopMargin(0.065);
canvas_new->SetLeftMargin(0.17);
canvas_new->SetBottomMargin(0.165);
canvas_new->SetRightMargin(0.015);
canvas_new->SetLogx(true);
canvas_new->SetLogy(true);
canvas_new->Draw();
canvas_new->cd();
//TList* pad_primitives = canvas->GetListOfPrimitives();
TList* pad_primitives = pad->GetListOfPrimitives();
TH1* histogramCA = 0;
TH1* histogramSVfit = 0;
TH1* histogramSVfitMEMkEq0 = 0;
TH1* histogramSVfitMEMkNeq0 = 0;
TIter pad_nextObj(pad_primitives);
while ( TObject* obj = pad_nextObj() ) {
std::string objName = "";
if ( dynamic_cast<TNamed*>(obj) ) objName = (dynamic_cast<TNamed*>(obj))->GetName();
std::cout << "obj = " << obj << ": name = " << objName << ", type = " << obj->ClassName() << std::endl;
TH1* tmpHistogram = dynamic_cast<TH1*>(obj);
if ( tmpHistogram ) {
std::cout << "tmpHistogram:"
<< " fillColor = " << tmpHistogram->GetFillColor() << ", fillStyle = " << tmpHistogram->GetFillStyle() << ","
<< " lineColor = " << tmpHistogram->GetLineColor() << ", lineStyle = " << tmpHistogram->GetLineStyle() << ", lineWidth = " << tmpHistogram->GetLineWidth() << ","
<< " markerColor = " << tmpHistogram->GetMarkerColor() << ", markerStyle = " << tmpHistogram->GetMarkerStyle() << ", markerSize = " << tmpHistogram->GetMarkerSize() << ","
<< " integral = " << tmpHistogram->Integral() << std::endl;
std::cout << "(mean = " << tmpHistogram->GetMean() << ", rms = " << tmpHistogram->GetRMS() << ": rms/mean = " << (tmpHistogram->GetRMS()/tmpHistogram->GetMean()) << ")" << std::endl;
if ( tmpHistogram->GetLineColor() == 416 ) histogramCA = tmpHistogram;
if ( tmpHistogram->GetLineColor() == 600 ) histogramSVfit = tmpHistogram;
if ( tmpHistogram->GetLineColor() == 616 ) histogramSVfitMEMkEq0 = tmpHistogram;
if ( tmpHistogram->GetLineColor() == 632 ) histogramSVfitMEMkNeq0 = tmpHistogram;
}
}
if ( !(histogramCA && histogramSVfit && histogramSVfitMEMkEq0 && histogramSVfitMEMkNeq0) ) {
std::cerr << "Failed to load histograms !!" << std::endl;
assert(0);
}
//gStyle->SetLineStyleString(2,"40 10 10 10 10 10 10 10");
//gStyle->SetLineStyleString(3,"25 15");
//gStyle->SetLineStyleString(4,"60 25");
//int colors[4] = { kBlack, kGreen - 6, kBlue - 7, kMagenta - 7 };
int colors[4] = { 28, kGreen - 6, kBlue - 7, kBlack };
//int lineStyles[4] = { 2, 3, 4, 1 };
int lineStyles[4] = { 7, 1, 1, 1 };
//int lineWidths[4] = { 3, 3, 4, 3 };
int lineWidths[4] = { 3, 3, 1, 1 };
int markerStyles[4] = { 20, 25, 21, 24 };
int markerSizes[4] = { 2, 2, 2, 2 };
histogramCA->SetFillColor(0);
histogramCA->SetFillStyle(0);
histogramCA->SetLineColor(colors[0]);
histogramCA->SetLineStyle(lineStyles[0]);
histogramCA->SetLineWidth(lineWidths[0]);
histogramCA->SetMarkerColor(colors[0]);
histogramCA->SetMarkerStyle(markerStyles[0]);
histogramCA->SetMarkerSize(markerSizes[0]);
histogramSVfit->SetFillColor(0);
histogramSVfit->SetFillStyle(0);
histogramSVfit->SetLineColor(colors[1]);
histogramSVfit->SetLineStyle(lineStyles[1]);
histogramSVfit->SetLineWidth(lineWidths[1]);
histogramSVfit->SetMarkerColor(colors[1]);
histogramSVfit->SetMarkerStyle(markerStyles[1]);
histogramSVfit->SetMarkerSize(markerSizes[1]);
histogramSVfitMEMkEq0->SetFillColor(0);
histogramSVfitMEMkEq0->SetFillStyle(0);
histogramSVfitMEMkEq0->SetLineColor(colors[2]);
histogramSVfitMEMkEq0->SetLineStyle(lineStyles[2]);
histogramSVfitMEMkEq0->SetLineWidth(lineWidths[2]);
histogramSVfitMEMkEq0->SetMarkerColor(colors[2]);
histogramSVfitMEMkEq0->SetMarkerStyle(markerStyles[2]);
histogramSVfitMEMkEq0->SetMarkerSize(markerSizes[2]);
// CV: fix pathological bins at high mass for which dN/dm increases
int numBins = histogramSVfitMEMkEq0->GetNbinsX();
for ( int idxBin = 1; idxBin <= numBins; ++idxBin ) {
double binCenter = histogramSVfitMEMkEq0->GetBinCenter(idxBin);
if ( (channel == "#tau_{h}#tau_{h}" && massPoint == 500 && binCenter > 1500.) ||
(channel == "#tau_{h}#tau_{h}" && massPoint == 800 && binCenter > 2000.) ||
(channel == "#mu#tau_{h}" && massPoint == 500 && binCenter > 1500.) ||
(channel == "#mu#tau_{h}" && massPoint == 800 && binCenter > 2500.) ) {
histogramSVfitMEMkEq0->SetBinContent(idxBin, 0.);
}
}
histogramSVfitMEMkNeq0->SetFillColor(0);
histogramSVfitMEMkNeq0->SetFillStyle(0);
histogramSVfitMEMkNeq0->SetLineColor(colors[3]);
histogramSVfitMEMkNeq0->SetLineStyle(lineStyles[3]);
histogramSVfitMEMkNeq0->SetLineWidth(lineWidths[3]);
histogramSVfitMEMkNeq0->SetMarkerColor(colors[3]);
histogramSVfitMEMkNeq0->SetMarkerStyle(markerStyles[3]);
histogramSVfitMEMkNeq0->SetMarkerSize(markerSizes[3]);
TAxis* xAxis = histogramCA->GetXaxis();
xAxis->SetTitle("m_{#tau#tau} [GeV]");
xAxis->SetTitleOffset(1.15);
xAxis->SetTitleSize(0.070);
xAxis->SetTitleFont(42);
xAxis->SetLabelOffset(0.010);
xAxis->SetLabelSize(0.055);
xAxis->SetLabelFont(42);
xAxis->SetTickLength(0.040);
xAxis->SetNdivisions(510);
//double xMin = 20.;
//double xMax = xAxis->GetXmax();
//xAxis->SetRangeUser(xMin, xMax);
TAxis* yAxis = histogramCA->GetYaxis();
yAxis->SetTitle("dN/dm_{#tau#tau} [1/GeV]");
yAxis->SetTitleOffset(1.20);
yAxis->SetTitleSize(0.070);
yAxis->SetTitleFont(42);
yAxis->SetLabelOffset(0.010);
yAxis->SetLabelSize(0.055);
yAxis->SetLabelFont(42);
yAxis->SetTickLength(0.040);
yAxis->SetNdivisions(505);
double massPoint_double = 0.;
if ( massPoint == 90 ) massPoint_double = 91.2;
else massPoint_double = massPoint;
double dLog = (TMath::Log(5.*massPoint_double) - TMath::Log(50.))/25.; // xMin = 50, xMax = 5*massPoint, numBins = 25
double binWidth = TMath::Exp(TMath::Log(massPoint_double) + 0.5*dLog) - TMath::Exp(TMath::Log(massPoint_double) - 0.5*dLog);
double sf_binWidth = 1./binWidth;
std::cout << "massPoint = " << massPoint << ": sf_binWidth = " << sf_binWidth << std::endl;
histogramCA->SetTitle("");
histogramCA->SetStats(false);
histogramCA->SetMaximum(sf_binWidth*0.79);
histogramCA->SetMinimum(sf_binWidth*1.1e-4);
histogramCA->Draw("hist");
histogramSVfit->Draw("histsame");
//histogramSVfitMEMkEq0->Draw("histsame");
histogramSVfitMEMkEq0->Draw("epsame");
//histogramSVfitMEMkNeq0->Draw("histsame");
histogramSVfitMEMkNeq0->Draw("epsame");
histogramCA->Draw("axissame");
//TPaveText* label_sample = new TPaveText(0.21, 0.86, 0.46, 0.94, "NDC");
TPaveText* label_sample = new TPaveText(0.1700, 0.9475, 0.4600, 1.0375, "NDC");
label_sample->SetFillStyle(0);
label_sample->SetBorderSize(0);
label_sample->AddText(sample.data());
label_sample->SetTextFont(42);
label_sample->SetTextSize(0.055);
label_sample->SetTextColor(1);
label_sample->SetTextAlign(13);
label_sample->Draw();
//TLegend* legend_new = new TLegend(0.225, 0.52, 0.41, 0.82, NULL, "brNDC");
TLegend* legend_new = new TLegend(0.30, 0.30, 0.80, 0.80, NULL, "brNDC");
legend_new->SetFillColor(10);
legend_new->SetFillStyle(0);
legend_new->SetBorderSize(0);
legend_new->SetTextFont(42);
legend_new->SetTextSize(0.055);
legend_new->SetTextColor(1);
legend_new->SetMargin(0.20);
legend_new->AddEntry(histogramCA, "CA", "l");
legend_new->AddEntry(histogramSVfit, "SVfit", "l");
//legend_new->AddEntry(histogramSVfitMEMkEq0, "SVfitMEM (k=0)", "l");
legend_new->AddEntry(histogramSVfitMEMkEq0, "SVfitMEM (k=0)", "p");
//legend_new->AddEntry(histogramSVfitMEMkNeq0, Form("SVfitMEM(k=%1.0f)", k), "l");
legend_new->AddEntry(histogramSVfitMEMkNeq0, Form("SVfitMEM (k=%1.0f)", k), "p");
//legend_new->Draw();
double label_channel_y0;
if ( channel == "e#mu" ) label_channel_y0 = 0.9275;
else if ( channel == "#mu#tau_{h}" ) label_channel_y0 = 0.9400;
else if ( channel == "#tau_{h}#tau_{h}" ) label_channel_y0 = 0.9350;
else {
std::cerr << "Invalid channel = " << channel << " !!" << std::endl;
assert(0);
}
TPaveText* label_channel = new TPaveText(0.895, label_channel_y0, 0.975, label_channel_y0 + 0.055, "NDC");
label_channel->SetFillStyle(0);
label_channel->SetBorderSize(0);
label_channel->AddText(channel.data());
label_channel->SetTextFont(62);
label_channel->SetTextSize(0.055);
label_channel->SetTextColor(1);
label_channel->SetTextAlign(31);
label_channel->Draw();
canvas_new->Update();
std::string outputFileName_full = Form("%s%s", outputFilePath.data(), outputFileName.data());
size_t idx = outputFileName_full.find_last_of('.');
std::string outputFileName_plot = std::string(outputFileName_full, 0, idx);
canvas_new->Print(std::string(outputFileName_plot).append(".pdf").data());
canvas_new->Print(std::string(outputFileName_plot).append(".root").data());
std::string channel_string;
if ( channel == "e#mu" ) channel_string = "emu";
else if ( channel == "#mu#tau_{h}" ) channel_string = "muhad";
else if ( channel == "#tau_{h}#tau_{h}" ) channel_string = "hadhad";
else {
std::cerr << "Invalid channel = " << channel << " !!" << std::endl;
assert(0);
}
std::string outputFileName_legend = Form("makeSVfitMEM_PerformancePlots_legend_%s.pdf", channel_string.data());
makePlot_legend(legend_new, outputFilePath, outputFileName_legend);
delete label_sample;
delete legend_new;
delete label_channel;
delete canvas_new;
delete inputFile;
}
/**
*
*
* @param o
* @param useWeights
* @param correct
*
* @ingroup pwglf_forward_scripts_tests
*/
void
TestPoisson(Double_t o=.3, bool useWeights=false, bool correct=true)
{
const char* load = "$ALICE_PHYSICS/PWGLF/FORWARD/analysis2/scripts/LoadLibs.C";
if (!gROOT->GetClass("AliAODForwardMult")) {
gROOT->Macro(load);
gROOT->GetInterpreter()->UnloadFile(gSystem->ExpandPathName(load));
}
// --- Parameters of this script -----------------------------------
Int_t nBin = 5; // Our detector matrix size
Int_t nMax = TMath::Max(Int_t(nBin * nBin * o + .5)+nBin/2,nBin);
Int_t nEv = 10000; // Number of events
Double_t mp = o; // The 'hit' probability
TH2D* base = new TH2D("base", "Basic histogram",
nBin,-.5, nBin-.5, nBin, -.5, nBin-.5);
base->SetXTitle("#eta");
base->SetYTitle("#varphi");
base->SetDirectory(0);
base->SetOption("colz");
Int_t tN1=nMax; Double_t tMin1; Double_t tMax1;
Int_t tN2=nMax*10; Double_t tMin2; Double_t tMax2=nMax;
MakeIntegerAxis(tN1, tMin1, tMax1);
MakeIntegerAxis(tN2, tMin2, tMax2);
TH2D* corr = new TH2D("comp", "Comparison",
tN1, tMin1, tMax1, tN2, tMin2, tMax2);
corr->SetXTitle("Input");
corr->SetYTitle("Poisson");
corr->SetDirectory(0);
corr->SetOption("colz");
corr->SetStats(0);
TLine* lcorr = new TLine(0, 0, tMax2, tMax2);
Int_t mm = TMath::Max(Int_t(nBin * o + .5),nBin/2);
tN2=mm*10; tMax2 = mm;
MakeIntegerAxis(tN2, tMin2, tMax2);
Info("", "Making mean w/nbins=%d,range=[%f,%f]", tN2, tMin2, tMax2);
TH2D* mean = new TH2D("mean", "Mean comparison",
tN2, tMin2, tMax2, tN2, tMin2, tMax2);
mean->SetXTitle("Input");
mean->SetYTitle("Poisson");
mean->SetDirectory(0);
mean->SetOption("colz");
mean->SetStats(0);
TLine* lmean = new TLine(tMin2, tMin2, tMax2, tMax2);
TH1D* dist = new TH1D("dist", "Distribution of hits", tN1, tMin1, tMax1);
dist->SetXTitle("s");
dist->SetYTitle("P(s)");
dist->SetFillColor(kRed+1);
dist->SetFillStyle(3001);
dist->SetDirectory(0);
TH1D* diff = new TH1D("diff", "P-T", 100, -25, 25);
diff->SetXTitle("Difference");
diff->SetFillColor(kRed+1);
diff->SetFillStyle(3001);
diff->SetYTitle("Prob");
AliPoissonCalculator* c = new AliPoissonCalculator("ignored");
c->Init(nBin ,nBin);
for (Int_t i = 0; i < nEv; i++) {
c->Reset(base);
base->Reset();
for (Int_t iEta = 0; iEta < nBin; iEta++) {
for (Int_t iPhi = 0; iPhi < nBin; iPhi++) {
// Throw a die
Int_t m = gRandom->Poisson(mp);
dist->Fill(m);
// Fill into our base histogram
base->Fill(iEta, iPhi, m);
// Fill into poisson calculator
c->Fill(iEta, iPhi, m > 0, (useWeights ? m : 1));
}
}
// Calculate the result
TH2D* res = c->Result(correct);
// Now loop and compare
Double_t mBase = 0;
Double_t mPois = 0;
for (Int_t iEta = 0; iEta < nBin; iEta++) {
for (Int_t iPhi = 0; iPhi < nBin; iPhi++) {
Double_t p = res->GetBinContent(iEta, iPhi);
Double_t t = base->GetBinContent(iEta, iPhi);
mBase += t;
mPois += p;
corr->Fill(t, p);
diff->Fill(p-t);
}
}
Int_t nn = nBin * nBin;
mean->Fill(mBase / nn, mPois / nn);
}
TCanvas* cc = new TCanvas("c", "c", 900, 900);
cc->SetFillColor(0);
cc->SetFillStyle(0);
cc->SetBorderMode(0);
cc->SetRightMargin(0.02);
cc->SetTopMargin(0.02);
cc->Divide(2,2);
TVirtualPad* pp = cc->cd(1);
pp->SetFillColor(0);
pp->SetFillStyle(0);
pp->SetBorderMode(0);
pp->SetRightMargin(0.15);
pp->SetTopMargin(0.02);
pp->SetLogz();
pp->SetGridx();
pp->SetGridy();
corr->Draw();
lcorr->Draw();
pp = cc->cd(2);
pp->SetFillColor(0);
pp->SetFillStyle(0);
pp->SetBorderMode(0);
pp->SetRightMargin(0.02);
pp->SetTopMargin(0.02);
#if 0
c->GetMean()->Draw();
#elif 1
pp->SetLogy();
diff->Draw();
#elif 1
c->GetOccupancy()->Draw();
#else
pp->SetLogy();
dist->SetStats(0);
dist->Scale(1. / dist->Integral());
dist->Draw();
TH1D* m1 = c->GetMean();
m1->Scale(1. / m1->Integral());
m1->Draw("same");
Double_t eI;
Double_t ii = 100 * dist->Integral(2, 0);
TLatex* ll = new TLatex(.97, .85,
Form("Input #bar{m}: %5.3f", mp));
ll->SetNDC();
ll->SetTextFont(132);
ll->SetTextAlign(31);
ll->Draw();
ll->DrawLatex(.97, .75, Form("Result #bar{m}: %5.3f", dist->GetMean()));
ll->DrawLatex(.97, .65, Form("Occupancy: #int_{1}^{#infty}P(s)ds = %6.2f%%",
ii));
#endif
pp = cc->cd(3);
pp->SetFillColor(0);
pp->SetFillStyle(0);
pp->SetBorderMode(0);
pp->SetRightMargin(0.15);
pp->SetTopMargin(0.02);
pp->SetGridx();
pp->SetGridy();
c->GetCorrection()->Draw();
pp = cc->cd(4);
pp->SetFillColor(0);
pp->SetFillStyle(0);
pp->SetBorderMode(0);
pp->SetRightMargin(0.15);
pp->SetTopMargin(0.02);
pp->SetLogz();
pp->SetGridx();
pp->SetGridy();
mean->Draw();
lmean->Draw();
cc->cd();
}
void makeqaplot(int run=0, int plt=0, int save=0){
runnum=run;
yearday=run/1000;
if(save==0) {png=0; pdf=0;}
if(save==1) {png=1; pdf=0;}
if(save==2) {png=0; pdf=1;}
if(save==3) {png=1; pdf=1;}
c1 = new TCanvas("c1","QA",50,50,800,800);
gStyle->SetLabelSize(0.04,"xy");
//colortable();
gStyle->SetPalette(1);
gStyle->SetStatW(0.4);
char fname[50];
if(run==0) {sprintf(fname,"fgtQA.root");}
else {sprintf(fname,"%d/fgtQA_%d.root",yearday,run);}
cout << "Opening "<<fname<<endl;
file=new TFile(fname,"");
char c[50];
if(plt==0 || plt==1) {
gStyle->SetOptStat(111110);
c1->Divide(1,3);
for(int i=0; i<3; i++){
TVirtualPad* pad = c1->cd(i+1);
int log=0;
if(i>0) {log=1;}
pad->SetLogy(log);
hist0[i]=(TH1F*) file->Get(cHist[i]);
hist0[i]->SetFillColor(kBlue);
hist0[i]->Draw();
if(i==2){
float ntot = float(hist0[i]->GetEntries());
if(ntot>0.0){
int nbin = hist0[i]->GetNbinsX();
float nofgt = hist0[i]->Integral(1,1);
int bin = hist0[i]->FindBin(float(kFgtNumElecIds));
float nonzs = hist0[i]->Integral(bin-1,nbin+1);
float zs = hist0[i]->Integral(2,bin-2);
hist0[i]->GetXaxis()->SetRange(2, bin-2);
float mean = hist0[i]->GetMean() / float(kFgtNumElecIds);
char c[100];
sprintf(c,"Total %d",ntot); TText *t1 = new TText(0.3,0.8,c); t1->SetNDC(); t1->SetTextSize(0.06); t1->Draw();
sprintf(c,"NoFGT %d (%5.2f)",nofgt,nofgt/ntot); TText *t2 = new TText(0.3,0.7,c); t2->SetNDC(); t2->SetTextSize(0.06); t2->Draw();
sprintf(c,"NoneZS %d (%5.2f)",nonzs,nonzs/ntot); TText *t3 = new TText(0.3,0.6,c); t3->SetNDC(); t3->SetTextSize(0.06); t3->Draw();
sprintf(c,"ZS %d (%5.2f)",zs,zs/ntot); TText *t4 = new TText(0.3,0.5,c); t4->SetNDC(); t4->SetTextSize(0.06); t4->Draw();
sprintf(c,"Mean ZS data size/fullsize= %5.3f",mean); TText *t5 = new TText(0.3,0.4,c); t5->SetNDC(); t5->SetTextSize(0.06); t5->Draw();
if(mean>0.08) { t5->SetTextColor(2); }
else { t5->SetTextColor(4); }
}
}
}
c1->Update();
save("plot");
}
if(plt==0 || plt==2) {
c1->Clear();
gStyle->SetOptStat(0);
gStyle->SetOptTitle(0);
c1->Divide(1,3);
for(int i=3; i<6; i++){ hist0[i]=(TH1F*) file->Get(cHist[i]); }
int nevt=hist0[5]->GetEntries();
printf("Nevent=%d\n",nevt);
TVirtualPad* pad;
pad=c1->cd(1); pad->SetLogy(); pad->SetTopMargin(0.01); pad->SetRightMargin(0.01);
hist0[3]->GetXaxis()->SetLabelSize(0.07); hist0[3]->GetYaxis()->SetLabelSize(0.07);
hist0[3]->SetFillColor(kRed); hist0[3]->Scale(1/float(nevt)); hist0[3]->Draw();
TText *tx= new TText(0.87,0.0,"EleID"); tx->SetNDC(); tx->SetTextSize(0.1); tx->Draw();
TText *t3= new TText(0.05,0.1,"F3=frac in 3sig/2tb"); t3->SetNDC(); t3->SetTextSize(0.08); t3->SetTextAngle(90); t3->Draw();
pad=c1->cd(2); pad->SetLogy(); pad->SetTopMargin(0.01); pad->SetRightMargin(0.01);
hist0[4]->GetXaxis()->SetLabelSize(0.07); hist0[4]->GetYaxis()->SetLabelSize(0.07);
hist0[4]->SetFillColor(kBlue); hist0[4]->Scale(1/float(nevt)); hist0[4]->Draw();
tx->Draw();
TText *t4= new TText(0.05,0.1,"F10=frac in 10sig & >500"); t4->SetNDC(); t4->SetTextSize(0.08); t4->SetTextAngle(90); t4->Draw();
float min=-4;
int max=hist0[3]->GetNbinsX();
printf("Max=%d\n",max);
TH1F *h1 = new TH1F("ZSdataFrac","ZSdataFrac",50,min,0);
TH1F *h2 = new TH1F("10SigmaFrac","10SigmaFrac",50,min,0);
float f1[kFgtNumElecIds],f2[kFgtNumElecIds];
for(int i=0; i<max; i++){
f1[i] = log10(hist0[3]->GetBinContent(i+1)); if(f1[i]<min) {f1[i]=min;} h1->Fill(f1[i]);
f2[i] = log10(hist0[4]->GetBinContent(i+1)); if(f2[i]<min) {f2[i]=min;} h2->Fill(f2[i]);
}
pad = c1->cd(3); pad->Divide(2,1);
TVirtualPad *pad2;
pad2 = pad->cd(1);
pad2->SetLogy(); pad2->SetTopMargin(0.01); pad2->SetRightMargin(0.01);
h1->GetXaxis()->SetLabelSize(0.1); h1->GetYaxis()->SetLabelSize(0.1);
h2->GetXaxis()->SetLabelSize(0.1); h2->GetYaxis()->SetLabelSize(0.1);
h1->SetLineColor(kRed); h2->SetLineColor(kBlue);
if(h1->GetMaximum()>h2->GetMaximum()){
h1->Draw(); h2->Draw("SAME");
}else{
h2->Draw(); h1->Draw("SAME");
}
TText *t5= new TText(0.2,0.88,"Log(F3)"); t5->SetNDC(); t5->SetTextSize(0.1); t5->SetTextColor(2); t5->Draw();
TText *t6= new TText(0.6,0.88,"Log(F10)"); t6->SetNDC(); t6->SetTextSize(0.1); t6->SetTextColor(4); t6->Draw();
//read ped file
int eid, t;
float ped[kFgtNumElecIds],rms[kFgtNumElecIds],p,r;
int status[kFgtNumElecIds]; memset(status,0,sizeof(status));
cout<<"Reading Ped File "<<endl;
std::ifstream in("ped.txt");
if (!in.is_open()) {
cout << "Can't find file!\n";
exit(0);
}
while (!in.eof()){
in >> eid >> t >> p >> r;
ped[eid]=p;
rms[eid]=r;
}
in.close();
TH1F * hr1= new TH1F("RMS","RMS",60,0,120);
TH1F * hr2= new TH1F("RMS2","RMS2",60,0,120);
TH1F * hr3= new TH1F("RMS3","RMS3",60,0,120);
TH1F * hr4= new TH1F("RMS4","RMS4",60,0,120);
TH1F * hr5= new TH1F("RMS5","RMS5",60,0,120);
float f1l=-3.5, f1h=-0.5;
float f2l=-3.5, f2h=-1.2;
for(int i=0; i<kFgtNumElecIds; i++){
if(f1[i]<f1l) status[i]+=1;
if(f1[i]>f1h) status[i]+=2;
if(f1[i]<f2l) status[i]+=4;
if(f1[i]>f2h) status[i]+=8;
hr1->Fill(rms[i]);
if(f1[i]<f1l) {hr2->Fill(rms[i]);}
if(f1[i]<f1l || f1[i]>f1h) {hr3->Fill(rms[i]);}
if(f1[i]<f1l || f1[i]>f1h || f2[i]<f2l) {hr4->Fill(rms[i]);}
if(f1[i]<f1l || f1[i]>f1h || f2[i]<f2l || f2[i]>f2h) {hr5->Fill(rms[i]);}
}
char filename[150];
if(nevt>=1000){
sprintf(filename,"%d/status/status.%d.txt",yearday,run);
}else{
sprintf(filename,"%d/status/status.%d.lowstat.txt",yearday,run);
}
FILE* pfile=fopen(filename,"w");
if(!pfile){
printf("Couldn't open file %s\n",filename);
}else{
printf("Writing %s\n",filename);
for(int i=0; i<kFgtNumElecIds; i++){
fprintf(pfile,"%d 0x%d\n",i,status[i]);
}
fclose(pfile);
}
pad2 = pad->cd(2);
pad2->SetLogy(0); pad2->SetTopMargin(0.01); pad2->SetRightMargin(0.01);
hr1->GetXaxis()->SetLabelSize(0.1); hr1->GetYaxis()->SetLabelSize(0.05);
hr1->SetFillColor(3); hr1->Draw();
hr5->SetFillColor(9); hr5->Draw("same");
hr4->SetFillColor(4); hr4->Draw("same");
hr3->SetFillColor(6); hr3->Draw("same");
hr2->SetFillColor(2); hr2->Draw("same");
char cc1[100]; sprintf(cc1,"Log(F3)<%4.1f",f1l);
char cc2[100]; sprintf(cc2,"Log(F3)>%4.1f",f1h);
char cc3[100]; sprintf(cc3,"Log(F10)<%4.1f",f2l);
char cc4[100]; sprintf(cc4,"Log(F10)>%4.1f",f2h);
TText *t7 = new TText(0.6,0.88,cc1); t7->SetNDC(); t7->SetTextSize(0.07); t7->SetTextColor(2); t7->Draw();
TText *t8 = new TText(0.6,0.78,cc2); t8->SetNDC(); t8->SetTextSize(0.07); t8->SetTextColor(6); t8->Draw();
TText *t9 = new TText(0.6,0.68,cc3); t9->SetNDC(); t9->SetTextSize(0.07); t9->SetTextColor(4); t9->Draw();
TText *t10= new TText(0.6,0.58,cc4); t10->SetNDC(); t10->SetTextSize(0.07); t10->SetTextColor(9); t10->Draw();
TText *t11= new TText(0.6,0.48,"OK"); t11->SetNDC(); t11->SetTextSize(0.07); t11->SetTextColor(3); t11->Draw();
TText *t12= new TText(0.8,0.15,"PedRMS"); t12->SetNDC(); t12->SetTextSize(0.07); t12->Draw();
c1->Update();
save("frac");
}
/**
* Draw final plot for QM2011
*
* @param max
*
* @ingroup pwglf_forward_scripts
*/
void
dndeta_final(Double_t max=6)
{
gStyle->SetOptTitle(0);
gStyle->SetOptFit(0);
gStyle->SetTitleFont(132, "xyz");
gStyle->SetTitleSize(0.1, "xyz");
gStyle->SetTitleOffset(0.4, "y");
gStyle->SetTitleOffset(0.8, "x");
gStyle->SetLabelFont(132, "xyz");
gStyle->SetLabelSize(0.08, "xyz");
gStyle->SetNdivisions(212, "x");
gStyle->SetNdivisions(208, "y");
gStyle->SetTextFont(132);
gStyle->SetPadColor(0);
gStyle->SetPadBorderMode(0);
// gStyle->SetFillColor(0);
// gStyle->SetFillStyle(0);
TCanvas* c = new TCanvas("c", "c", 900, 900);
c->SetFillColor(0);
c->SetFillStyle(0);
c->SetBorderSize(0);
c->SetBorderMode(0);
c->SetRightMargin(0.02);
c->SetTopMargin(0.02);
c->SetBottomMargin(0.15);
c->Divide(1,3,0,0);
// --- INEL --------------------------------------------------------
TVirtualPad* p = c->cd(1);
p->SetGridx();
p->SetRightMargin(.01);
THStack* inel = new THStack("inel", "INEL");
TLatex* inelT = new TLatex(1-p->GetRightMargin()-.01,
1-p->GetTopMargin()-.01,
"INEL");
inelT->SetNDC();
inelT->SetTextAlign(33);
inelT->SetTextSize(0.12);
TLegend* inelL = new TLegend(.3, .02, .8, .4);
inelL->SetBorderSize(0);
inelL->SetNColumns(2);
inelL->SetFillColor(0);
inelL->SetFillStyle(0);
TLegendEntry* e = inelL->AddEntry("d1", "Forward", "lp");
e->SetMarkerColor(kRed+2);
e->SetMarkerStyle(29);
e = inelL->AddEntry("d2", "Central", "lp");
e->SetMarkerColor(kMagenta+2);
e->SetMarkerStyle(29);
e = inelL->AddEntry("d3", "Data", "lp");
e->SetMarkerStyle(29);
e = inelL->AddEntry("d4", "Mirrored data", "lp");
e->SetMarkerStyle(30);
e = inelL->AddEntry("d5", "Systematic error", "f");
e->SetFillColor(kGray);
e->SetLineColor(kGray);
e->SetLineWidth(0);
e->SetFillStyle(3001);
gROOT->LoadMacro("export_pp_0900GeV_INEL_m10p10cm_000100000ev.C");
export_pp_0900GeV_INEL_m10p10cm_000100000ev(inel, inelL, 20);
export_pp_0900GeV_INEL_m10p10cm_000100000ev(inel, inelL, 21);
export_pp_0900GeV_INEL_m10p10cm_000100000ev(inel, inelL, 22);
inel->Draw("nostack e1");
inel->GetHistogram()->SetYTitle("#frac{1}{N}#frac{dN_{ch}}{d#eta}");
inel->GetHistogram()->SetXTitle("#eta");
inel->GetHistogram()->GetYaxis()->SetDecimals();
inelL->Draw();
inelT->Draw();
// --- INEL>0 ------------------------------------------------------
p = c->cd(2);
p->SetGridx();
p->SetRightMargin(.01);
THStack* inelgt0 = new THStack("inelgt0", "INEL>0");
TLatex* inelgt0T = new TLatex(1-p->GetRightMargin()-.01,
1-p->GetTopMargin()-.01,
"INEL>0");
inelgt0T->SetNDC();
inelgt0T->SetTextAlign(33);
inelgt0T->SetTextSize(0.12);
gROOT->LoadMacro("export_pp_0900GeV_INEL_m10p10cm_000100000ev.C");
export_pp_0900GeV_INEL_m10p10cm_000100000ev(inelgt0, 0, 20);
export_pp_0900GeV_INEL_m10p10cm_000100000ev(inelgt0, 0, 21);
export_pp_0900GeV_INEL_m10p10cm_000100000ev(inelgt0, 0, 22);
inelgt0->Draw("nostack e1");
inelgt0->GetHistogram()->SetXTitle("#eta");
inelgt0->GetHistogram()->GetYaxis()->SetDecimals();
inelgt0T->Draw();
// --- NSD ---------------------------------------------------------
p = c->cd(3);
p->SetGridx();
p->SetRightMargin(.01);
THStack* nsd = new THStack("nsd", "NSD");
TLatex* nsdT = new TLatex(1-p->GetRightMargin()-.01,
1-p->GetTopMargin()-.01,
"NSD");
nsdT->SetNDC();
nsdT->SetTextAlign(33);
nsdT->SetTextSize(0.12);
gROOT->LoadMacro("export_pp_0900GeV_NSD_m10p10cm_000100000ev.C");
export_pp_0900GeV_NSD_m10p10cm_000100000ev(nsd, 0, 20);
export_pp_0900GeV_NSD_m10p10cm_000100000ev(nsd, 0, 21);
export_pp_0900GeV_NSD_m10p10cm_000100000ev(nsd, 0, 22);
nsd->Draw("nostack e1");
nsd->GetHistogram()->SetXTitle("#eta");
nsd->GetHistogram()->GetYaxis()->SetDecimals();
nsdT->Draw();
c->cd();
c->SaveAs("dndeta_final.png");
}
void KVSpIdGUI::SpiderIdentification()
{
if ((!fHisto) || (!fGrid)) return;
TVirtualPad* pad = fGrid->GetPad();
fGrid->UnDraw();
fZp = fZpEntry->GetIntNumber();
if (!fUserParameter) fSpFactor = GetFactor();
else fSpFactor = fSpiderFactorEntry->GetNumber();
fAnglesUp = fAngleUpEntry->GetIntNumber();
fAnglesDown = fAngleDownEntry->GetIntNumber();
fAlpha = fApertureUpEntry->GetNumber();
fPiedType = fPiedChoice->GetSelected();
fMatrixType = fTypeChoice->GetSelected();
Int_t type = fMatrixType;
TH2* tmpHisto = fHisto;
TList* tmpCut = 0;
if (fUseCut) {
tmpHisto = (TH2*)fHisto->Clone(Form("%s_cut", fHisto->GetName()));
tmpHisto->Reset();
for (int i = 1; i <= fHisto->GetNbinsX(); i++) {
for (int j = 1; j <= fHisto->GetNbinsY(); j++) {
Stat_t ww = fHisto->GetBinContent(i, j);
Axis_t x0 = fHisto->GetXaxis()->GetBinCenter(i);
Axis_t y0 = fHisto->GetYaxis()->GetBinCenter(j);
if (fGrid->IsIdentifiable(x0, y0)) tmpHisto->Fill(x0, y0, ww);
}
}
tmpCut = (TList*)fGrid->GetCuts()->Clone("tmpCuts");
}
fGrid->Clear();
if (fScaledHisto) delete fScaledHisto;
KVHistoManipulator hm;
TF1 RtLt("RtLt", Form("x*%lf", fSfx), 0, tmpHisto->GetXaxis()->GetXmax());
TF1 RtLty("RtLty", Form("x*%lf", fSfy), 0, tmpHisto->GetXaxis()->GetXmax());
fScaledHisto = (TH2F*)hm.ScaleHisto(tmpHisto, &RtLt, &RtLty);
if (fIdentificator) delete fIdentificator;
fIdentificator = new KVSpiderIdentificator(fScaledHisto, fXm * fSfx, fYm * fSfy);
switch (fPiedType) {
case kUser:
fIdentificator->SetX0(fPdx * fSfx);
fIdentificator->SetY0(fPdy * fSfy);
break;
case kAuto:
break;
case kNone:
fIdentificator->SetX0(0.);
fIdentificator->SetY0(0.);
}
fIdentificator->SetParameters(fSpFactor);
fIdentificator->SetNangles(fAnglesUp, fAnglesDown);
fIdentificator->SetAlpha(fAlpha);
fProgressBar->SetRange(0, fAnglesUp + fAnglesDown + 1);
fProgressBar->Reset();
fIdentificator->Connect("Increment(Float_t)", "TGHProgressBar", fProgressBar, "SetPosition(Float_t)");
fTestButton->SetEnabled(kFALSE);
fCloseButton->SetEnabled(kFALSE);
fIdentificator->ProcessIdentification();
fTestButton->SetEnabled(kTRUE);
fCloseButton->SetEnabled(kTRUE);
fIdentificator->Disconnect("Increment(Float_t)", fProgressBar, "SetPosition(Float_t)");
fProgressBar->Reset();
if (fDebug) fIdentificator->Draw(fOption.Data());
TList* ll = (TList*)fIdentificator->GetListOfLines();
KVIDZALine* TheLine = 0;
int zmax = 0;
KVSpiderLine* spline = 0;
TIter next_line(ll);
while ((spline = (KVSpiderLine*)next_line())) {
if ((spline->GetN() > 10)) { //&&(spline->GetX(0)<=fIdentificator->GetX0()+200.))
TF1* ff1 = 0;
if (type == kSiCsI) ff1 = spline->GetFunction(fPdx * fSfx, TMath::Max(fScaledHisto->GetXaxis()->GetXmax() * 0.9, spline->GetX(spline->GetN() - 1)));
else if (type == kSiSi) ff1 = spline->GetFunction(fPdx * fSfx, TMath::Min(fScaledHisto->GetXaxis()->GetXmax() * 0.9, spline->GetX(spline->GetN() - 1) * 1.5));
else if (type == kChIoSi) ff1 = spline->GetFunction(fPdx * fSfx, TMath::Min(fScaledHisto->GetXaxis()->GetXmax() * 0.9, spline->GetX(spline->GetN() - 1) * 1.5));
else ff1 = spline->GetFunction();
if ((type == kSiCsI) && (ff1->GetParameter(1) >= 3000. || (ff1->GetParameter(2) <= 0.35) || (ff1->GetParameter(2) >= 1.))) {
Info("SpiderIdentification", "Z = %d has been rejected (fit parameters)", spline->GetZ());
continue;
}
TheLine = (KVIDZALine*)((KVIDZAGrid*)fGrid)->NewLine("ID");
TheLine->SetZ(spline->GetZ());
double min, max;
ff1->GetRange(min, max);
double step = TMath::Min((max - min) * 0.05, 20.); //20.;
double stepmax = (max - min) * 0.2; //800.;
double x = 0.;
for (x = min + 1; x < max + step; x += step) {
if (step <= stepmax) step *= 1.3;
if (ff1->Eval(x) < 4000) TheLine->SetPoint(TheLine->GetN(), x, ff1->Eval(x));
}
if (max > x) TheLine->SetPoint(TheLine->GetN(), max, ff1->Eval(max));
fGrid->Add("ID", TheLine);
if (spline->GetZ() >= zmax) zmax = spline->GetZ();
} else {
Info("SpiderIdentification", "Z = %d has been rejected (too few points)", spline->GetZ());
}
}
TF1 fx("fx12", Form("x/%lf", fSfx), 0., fScaledHisto->GetNbinsX() * 1.);
TF1 fy("fy12", Form("x/%lf", fSfy), 0., fScaledHisto->GetNbinsY() * 1.);
fGrid->Scale(&fx, &fy);
if (fUseCut) delete tmpHisto;
if (tmpCut) fGrid->GetCuts()->AddAll(tmpCut);
pad->cd();
fGrid->Draw();
pad->Modified();
pad->Update();
DoClose();
}
