void ratioPlots( TCanvas* c1, TH1* h_r, TH1* h_i, string xTitle, string yTitle, string savePath, double fitMin=-100000, double fitMax=100000, bool doubleColFit=0 ){ double xMaximum = h_r->GetXaxis()->GetBinUpEdge(h_r->GetXaxis()->GetLast()); double xMinimum = h_r->GetXaxis()->GetBinLowEdge(h_r->GetXaxis()->GetFirst()); double yMaximum; double yMinimum; h_i->Sumw2(); h_r->Sumw2(); TLine* line1 = new TLine(xMinimum,1,xMaximum,1); line1->SetLineColor(1); line1->SetLineWidth(2); line1->SetLineStyle(7); TF1* fpol1 = new TF1("fpol1", "pol1", fitMin, fitMax); fpol1->SetLineColor(2); fpol1->SetLineWidth(3); fpol1->SetLineStyle(7); TH1* hRatio = (TH1*)h_r->Clone("clone_record"); hRatio->Divide(h_i); yMaximum = hRatio->GetMaximum(); yMinimum = hRatio->GetMinimum(0); hRatio->GetYaxis()->SetRangeUser(yMinimum/2.5,yMaximum+yMaximum/5); hRatio->SetXTitle(xTitle.c_str()); hRatio->SetYTitle(yTitle.c_str()); hRatio->SetLineColor(9); hRatio->SetLineWidth(2); hRatio->SetMarkerStyle(8); hRatio->Draw("e"); hRatio->Fit("fpol1", "L"); line1->Draw("SAME"); if(doubleColFit){ double p0=fpol1->GetParameter(0); double p1=fpol1->GetParameter(1); double endPoint=double(fitMax*p1)+p0; double p1new=(endPoint-1)/(fitMax-fitMin); char fun[100], text[100]; sprintf(fun,"x*(%f)+1",p1new); sprintf(text,"Tangent: %f",p1new); TF1* fnew = new TF1("fnew", fun, fitMin, fitMax); fnew->SetLineColor(2); fnew->SetLineWidth(3); fnew->Draw("SAME"); TText* Title = new TText( fitMax/12, yMinimum, text); Title->SetTextColor(2); Title->SetTextSize(0.035); Title->Draw("SAME"); } c1->SaveAs(savePath.c_str()); c1->cd(); }
/*============================================================================*/ void gaus1peakfit(Char_t *s, Float_t x1, Float_t x2, Float_t x3, Float_t x4) { Double_t par[5],epar[5],x[4],y[4]; TH1 *hist; hist = (TH1 *) gROOT->FindObject(s); setcanvas(1); TCanvas *c1=(TCanvas*) gROOT->FindObject("c1"); if(c1==NULL)setcanvas(1); c1->Clear(); hist->SetAxisRange(x1-30,x4+30); hist->Draw(); //--**-- Linear background estimation --**--// x[0] = x1; x[1] = x2; x[2] = x3; x[3] = x4; Int_t bin1 = hist->FindBin(x1); y[0] = hist->GetBinContent(bin1); Int_t bin2 = hist->FindBin(x2); y[1] = hist->GetBinContent(bin2); Int_t bin3 = hist->FindBin(x3); y[2] = hist->GetBinContent(bin3); Int_t bin4 = hist->FindBin(x4); y[3] = hist->GetBinContent(bin4); TGraph *g = new TGraph(4,x,y); TF1 *fpol1 = new TF1("POL1","pol1",x1,x4); g->Fit(fpol1,"RQN"); par[3]=fpol1->GetParameter(0); par[4]=fpol1->GetParameter(1); //--**-- Gaussian Peak estimation without background --**--// TF1 *fgaus = new TF1("GAUS","gaus",x2,x3); hist->Fit(fgaus,"RQN"); fgaus->GetParameters(&par[0]); //--**-- Final Peak Fit with Background --**--// TF1 *func = new TF1("FGAUS","gaus(0)+pol1(3)",x1,x4); func->SetParameters(par); hist->Fit(func,"R+QN"); func->GetParameters(par); epar[0]=func->GetParError(0); epar[1]=func->GetParError(1); epar[2]=func->GetParError(2); Double_t fwhm = par[2]*TMath::Sqrt(8*TMath::Log(2)); Double_t efwhm = epar[2]*TMath::Sqrt(8*TMath::Log(2)); Double_t N0 = par[0]*(TMath::Sqrt(TMath::TwoPi())*par[2]); Double_t r0 = epar[0]/par[0]; Double_t r2 = epar[2]/par[2]; Double_t eN0= N0*TMath::Sqrt(r0*r0+r2*r2); printf("Peak = %f +- %f; FFHM = %f +- %f; Area = %f +- %f\n", par[1],epar[1],fwhm,efwhm,N0,eN0); //printf("%11.4f %11.4f %11.0f %11.0f\n", // par[1],epar[1],N0,eN0); func->SetLineWidth(0.5); func->SetLineStyle(1); func->SetLineColor(4); func->SetFillColor(4); func->Draw("same"); }
//------------------------------------------------------------------------------ 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)); }
void fadc_fit_heights(std::string fadc_id,std::string hist_type) { /*****************************************************************/ // Prepare the canvas gStyle->SetOptFit(1111); TCanvas *AlCapCanvas = (TCanvas *) gROOT->GetListOfCanvases()->At(0); AlCapCanvas->Clear(); AlCapCanvas->Divide(4,2); // gROOT->ProcessLine(".L common/get_histogram.C"); // get_histogram() is called here /*****************************************************************/ const int n_channels = 8; std::string bank_names[n_channels] = {"Na", "Nb", "Nc", "Nd", "Ne", "Nf", "Ng", "Nh"}; std::string name; double mean = 0; double rms = 0; for (int iChn = 0; iChn < n_channels; iChn++) { name=bank_names[iChn]+fadc_id; TH1* hist = get_histogram(name, hist_type); mean = hist->GetMean(); rms = hist->GetRMS(); AlCapCanvas->cd(iChn+1); if (hist->Integral()!=0) { TF1* gaus = new TF1("gaus","gaus",mean-rms,mean+rms); hist->Fit("gaus","Q"); hist->GetXaxis()->SetRange(mean-2*rms,mean+2*rms); hist->Draw(); } } }
// show the histogram in first slot, try a Gaussian fit with given parameters void PRadHistCanvas::UpdateHist(int index, TObject *tob, int range_min, int range_max) { --index; if(index < 0 || index >= canvases.size()) return; canvases[index]->cd(); canvases[index]->SetGrid(); gPad->SetLogy(); TH1 *hist = (TH1*)tob; hist->GetXaxis()->SetRangeUser(hist->FindFirstBinAbove(0,1) - 10, hist->FindLastBinAbove(0,1) + 10); hist->GetXaxis()->SetLabelSize(HIST_LABEL_SIZE); hist->GetYaxis()->SetLabelSize(HIST_LABEL_SIZE); // try to fit gaussian in certain range if(range_max > range_min && hist->Integral(range_min, range_max + 1) > 0) { TF1 *fit = new TF1("", "gaus", range_min, range_max); fit->SetLineColor(kRed); fit->SetLineWidth(2); hist->Fit(fit,"qlR"); } hist->SetFillColor(fillColors[index]); hist->Draw(); canvases[index]->Refresh(); }
TCanvas* DrawNP(int np, TObjArray* harr, TCanvas* cnv) { if (!harr) harr = &histoArr; if (!cnv) cnv = new TCanvas(Form("cnv%d",np),Form("cnv%d",np),900,700); cnv->Clear(); cnv->Divide(2,1); cnv->cd(1); // TH1* dxodd = (TH1*)harr->At(np*10+kDTXodd); TH1* dxevn = (TH1*)harr->At(np*10+kDTXeven); TH1* dxoddS =(TH1*)harr->At(np*10+kDTXoddSPL); TH1* dxevnS =(TH1*)harr->At(np*10+kDTXevenSPL); double max = TMath::Max(dxodd->GetMaximum(),dxevn->GetMaximum()); dxodd->SetMaximum(1.1*max); dxodd->GetXaxis()->SetTitle("#DeltaX, #mum"); dxodd->SetTitle(Form("#DeltaX for clSize=%d",np)); dxodd->Fit("gaus","",""); dxevn->Fit("gaus","","sames"); // dxoddS->Draw("sames"); dxevnS->Draw("sames"); // gPad->Modified(); gPad->Update(); SetStPadPos(dxodd,0.75,0.97,0.8,1., -1,dxodd->GetLineColor()); SetStPadPos(dxevn,0.75,0.97,0.6,0.8, -1,dxevn->GetLineColor()); SetStPadPos(dxoddS,0.75,0.97,0.4,0.6, -1,dxoddS->GetLineColor()); SetStPadPos(dxevnS,0.75,0.97,0.2,0.4, -1,dxevnS->GetLineColor()); // cnv->cd(2); TH1* dz = (TH1*)harr->At(np*10+kDTZ); dz->SetTitle(Form("#DeltaZ for clSize=%d",np)); dz->GetXaxis()->SetTitle("#DeltaZ, #mum"); dz->Fit("gaus"); TH1* dzS = (TH1*)harr->At(np*10+kDTZSPL); dz->Draw("sames"); gPad->Modified(); gPad->Update(); SetStPadPos(dz,0.75,0.97,0.8,1., -1, dz->GetLineColor()); SetStPadPos(dzS,0.75,0.97,0.5,0.7, -1, dzS->GetLineColor()); gPad->Modified(); gPad->Update(); // cnv->cd(); return cnv; }
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); }
double Fit511Photopeak(TH1* h, double* error=0) { TSpectrum spec(1); spec.Search(h); h->GetXaxis()->SetTitle("Energy [photoelectrons]"); h->Draw("e"); TH1* bg = spec.Background(h); TH1* sig = (TH1*)(h->Clone()); sig->SetLineColor(kGreen); sig->Add(bg,-1); sig->Draw("same e"); sig->Fit("gaus","m","same e"); TF1* gaus = sig->GetFunction("gaus"); if(gaus) gaus->SetLineColor(kGreen); bg->SetLineColor(kRed); bg->Draw("same e"); TLine* line = new TLine(gaus->GetParameter(1),0, gaus->GetParameter(1),h->GetMaximum()); line->SetLineColor(kBlue); line->SetLineWidth(2); line->Draw(); double yield = spec.GetPositionX()[0]/epeak; double err = 0; cout<<"Results from TSpectrum: \n\t" <<"Peak = "<<spec.GetPositionX()[0]<<" p.e.; Light Yield = " <<yield<<" p.e./keV"<<endl; if(gaus){ yield = gaus->GetParameter(1)/epeak; err = gaus->GetParError(1)/epeak; cout<<"Results from BG Subtracted Gaus Fit: \n\t" <<"Peak = "<<gaus->GetParameter(1)<<" p.e.; Light Yield = " <<yield<<" +/- "<<err<<" p.e./keV"<<endl; err = max(err, TMath::Abs(yield-spec.GetPositionX()[0]/epeak)); } TLegend* leg = new TLegend(.6,.6,.9,.9); leg->AddEntry(h,"Raw Spectrum","lpe"); leg->AddEntry(bg,"Background","lpe"); leg->AddEntry(sig,"Signal","lpe"); char title[20]; sprintf(title,"Yield = %.2f pe/keV",yield); leg->AddEntry(line, title ,"l"); leg->Draw(); if(error) *error = err; return yield; }
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); }
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); }
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); }
void fitmmp(TH1 *hmmp, bool verbose = false) { TString options; if (verbose) options = ""; else options = "Q"; TF1 *fbg = f_pol4("fbg",0.4,2,true); hmmp->Fit(fbg,options.Data(),"",0.42,2); //printf("%s\n",gMinuit->fCstatu.Data()); if (true) { //gMinuit->fCstatu.Contains("CONVER")) { TF1 *fbg2 = f_pol4("fbg",0.4,2,false); fbg2->SetParameters(fbg->GetParameters()); //fbg2->Draw("same"); fbg2->SetParameter(5,0); fbg2->SetParameter(6,0); TH1 *htmp = (TH1*)hmmp->Clone("hmmp_bgsub"); htmp->Add(fbg2,-1); //htmp->Draw(); TF1 *fgaus = new TF1("fgaus","gaus",0.4,2); htmp->Fit(fgaus,options.Data(),"",0.74,0.85); TF1 *f = f_pol4gaus("f",0.4,2,fbg2,fgaus); f->SetNpx(500); hmmp->Fit(f,options.Data(),"",0.42,2); fgaus->SetRange(0.4,2); for (int i = 0; i < 3; i++) fgaus->SetParameter(i,f->GetParameter(i+5)); for (int i = 0; i < 5; i++) fbg2->SetParameter(i,f->GetParameter(i)); fbg2->SetLineStyle(2); fbg2->SetLineColor(kRed+1); fgaus->SetLineStyle(2); fgaus->SetLineColor(kGreen+1); hmmp->GetListOfFunctions()->Add(fbg2->Clone()); hmmp->GetListOfFunctions()->Add(fgaus->Clone()); delete fbg2; delete htmp; delete fgaus; delete f; } else hmmp->GetListOfFunctions()->Delete(); delete fbg; }
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; }
void fitmmp(TH1 *hmmp, float step_x0 = 2, float step_x1 = 2.1, float wval = 0, bool verbose = false) { float fnrangemax = 1.1; float mmplow = 0.4; //float bgp2 = 2.1e8; float gsig = -0.0065+0.013*wval; float pol2cutoff = 4; //wval under which to use pol2 float fitcutoff = 1.1; TString options; if (verbose) options = ""; else options = "Q"; TF1 *fbg = f_pol4("fbg",0.4,fnrangemax,true); fbg->FixParameter(7,step_x0); fbg->FixParameter(8,step_x1); if (wval<pol2cutoff) { fitcutoff = 1.1; fbg->FixParameter(3,0); fbg->FixParameter(4,0); } else fitcutoff = 2; hmmp->Fit(fbg,options.Data(),"",mmplow,fitcutoff); if (true) { //gMinuit->fCstatu.Contains("CONVER")) { TF1 *fbg2 = f_pol4("fbg",0.4,fnrangemax,false); fbg2->SetParameters(fbg->GetParameters()); fbg2->FixParameter(7,step_x0); fbg2->FixParameter(8,step_x1); if (wval<pol2cutoff) { fbg2->FixParameter(3,0); fbg2->FixParameter(4,0); } fbg2->SetParameter(5,0); fbg2->SetParameter(6,0); TH1 *htmp = (TH1*)hmmp->Clone("hmmp_bgsub"); htmp->Add(fbg2,-1); TF1 *fgaus = new TF1("fgaus","gaus",0.4,fnrangemax); fgaus->FixParameter(2,gsig); fgaus->FixParameter(1,0.783); float gmax = 0.85; if (gmax > step_x0) gmax = step_x0; htmp->Fit(fgaus,options.Data(),"",0.74,gmax); TF1 *f = f_pol4gaus("f",0.4,fnrangemax,fbg2,fgaus); f->FixParameter(8,step_x0); f->FixParameter(9,step_x1); if (wval<pol2cutoff) { f->FixParameter(3,0); f->FixParameter(4,0); } f->SetNpx(500); f->FixParameter(6,0.783); f->FixParameter(7,gsig); hmmp->Fit(f,options.Data(),"",mmplow,fitcutoff); //f->FixParameter(2,0.9*f->GetParameter(2)); //hmmp->Fit(f,options.Data(),"",mmplow,fitcutoff); fgaus->SetRange(0.4,fnrangemax); for (int i = 0; i < 3; i++) fgaus->SetParameter(i,f->GetParameter(i+5)); for (int i = 0; i < 5; i++) fbg2->SetParameter(i,f->GetParameter(i)); fbg2->SetLineStyle(2); fbg2->SetLineColor(kRed+1); fgaus->SetLineStyle(2); fgaus->SetLineColor(kGreen+1); hmmp->GetListOfFunctions()->Add(fbg2->Clone()); hmmp->GetListOfFunctions()->Add(fgaus->Clone()); float ymax = 1.1*hmmp->GetMaximum(); hmmp->GetYaxis()->SetRangeUser(0,ymax); TLine *l1 = new TLine(step_x0,0,step_x0,ymax); TLine *l2 = new TLine(step_x1,0,step_x1,ymax); l1->SetLineColor(kBlue+1); l2->SetLineColor(kBlue+1); hmmp->GetListOfFunctions()->Add(l1); hmmp->GetListOfFunctions()->Add(l2); delete fbg2; delete htmp; delete fgaus; delete f; } else hmmp->GetListOfFunctions()->Delete(); delete fbg; }
TH1D * GetTOFRatio(TFile *file, Int_t num, Int_t den, Int_t cent, Bool_t cutSpectrum = kTRUE) { /* pt limits for combined spectra */ Double_t ptMin_[9] = { 0.5, 0.5, 0.5, 0.45, 0.45, 0.45, 0.5, 0.5, 0.5 }; Double_t ptMax_[9] = { 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 4.5, 4.5, 4.5 }; Double_t ptMin = TMath::Max(ptMin_[num], ptMin_[den]); Double_t ptMax = TMath::Min(ptMax_[num], ptMax_[den]); TH1D *hin = (TH1D *)file->Get(Form("hRatio_cent%d_%s_%s", cent, ratioName[num], ratioName[den])); if (!hin) return NULL; #if 0 /* get matching systematics */ TFile *fsys = TFile::Open(Form("MATCHSYS_TOF_%s.root", TOFChargeName[charge])); TH1 *hsys = fsys->Get(Form("hErr%sMatch", ITSsaPartName[part])); TF1 *ffsys = new TF1("fsys", "[0] + [1] * x + [2] * TMath::Exp(-[3] * x)"); ffsys->SetParameter(0, 0.02); ffsys->FixParameter(1, 0.); ffsys->SetParameter(2, 0.5); ffsys->SetParameter(3, 10.); hsys->Fit(ffsys, "W"); ffsys->ReleaseParameter(1); hsys->Fit(ffsys, "W"); hsys->Fit(ffsys, "W"); hsys->Fit(ffsys, "W"); hsys->Draw(); #endif TH1D *h = new TH1D(Form("hTOF_cent%d_%s_%s", cent, ratioName[num], ratioName[den]), "TOF", NptBins, ptBin); Double_t pt, width, value, error, sys; Int_t bin; for (Int_t ipt = 0; ipt < NptBins; ipt++) { /* get input bin */ pt = h->GetBinCenter(ipt + 1); width = h->GetBinWidth(ipt + 1); bin = hin->FindBin(pt); /* sanity check */ if (TMath::Abs(hin->GetBinCenter(bin) - pt) > 0.001 || TMath::Abs(hin->GetBinWidth(bin) - width) > 0.001) continue; /* check pt limits */ if (cutSpectrum && (pt < ptMin || pt > ptMax)) continue; /* copy bin */ value = hin->GetBinContent(bin); error = hin->GetBinError(bin); /*** TEMP ADD SYS ***/ // sys = ffsys->Eval(pt) * value; // error = TMath::Sqrt(error * error + sys * sys); // h->SetBinContent(ipt + 1, value); // h->SetBinError(ipt + 1, error); h->SetBinContent(ipt + 1, value); h->SetBinError(ipt + 1, error); } h->SetTitle("TOF"); h->SetLineWidth(1); h->SetLineColor(1); h->SetMarkerStyle(23); h->SetMarkerColor(4); h->SetFillStyle(0); h->SetFillColor(0); return h; }
void EMCDistribution_PeakSample_Fast(bool full_gain = false) { const TString gain = "RAW"; TString hname = "EMCDistribution_" + gain + TString(full_gain ? "_FullGain" : "") + cuts; TH2 *h2 = NULL; { if (full_gain) { h2 = new TH2F(hname, Form(";Calibrated Tower Energy Sum (ADC);Count / bin"), 100, .05 * 100, 25 * 100, 64, -.5, 63.5); QAHistManagerDef::useLogBins(h2->GetXaxis()); } else { h2 = new TH2F(hname, Form(";Calibrated Tower Energy Sum (ADC);Count / bin"), 260, -.2 * 100, 5 * 100, 64, -.5, 63.5); } T->Draw( "TOWER_" + gain + "_CEMC[].get_bineta() + 8* TOWER_" + gain + "_CEMC[].get_binphi():(TOWER_RAW_CEMC[].signal_samples[10] - TOWER_RAW_CEMC[].signal_samples[0])*(-1)>>" + hname, "", "goff"); } TText *t; TCanvas *c1 = new TCanvas( "EMCDistribution_PeakSample_Fast_" + TString(full_gain ? "_FullGain" : "") + cuts, "EMCDistribution_PeakSample_Fast_" + TString(full_gain ? "_FullGain" : "") + cuts, 1800, 950); c1->Divide(8, 8, 0., 0.01); int idx = 1; TPad *p; for (int iphi = 8 - 1; iphi >= 0; iphi--) { for (int ieta = 0; ieta < 8; ieta++) { p = (TPad *) c1->cd(idx++); c1->Update(); p->SetLogy(); if (full_gain) { p->SetLogx(); } p->SetGridx(0); p->SetGridy(0); TString hname = Form("hEnergy_ieta%d_iphi%d", ieta, iphi) + TString(full_gain ? "_FullGain" : ""); TH1 *h = h2->ProjectionX(hname, ieta + 8 * iphi + 1, ieta + 8 * iphi + 1); // axis bin number is encoded as ieta+8*iphi+1 h->SetLineWidth(0); h->SetLineColor(kBlue + 3); h->SetFillColor(kBlue + 3); h->GetXaxis()->SetTitleSize(.09); h->GetXaxis()->SetLabelSize(.08); h->GetYaxis()->SetLabelSize(.08); h->Draw(); if (full_gain) h->Fit("x*gaus", "M"); else h->Fit("landau", "M"); double peak = -1; TF1 *fit = ((TF1 *) (h->GetListOfFunctions()->At(0))); if (fit) { fit->SetLineColor(kRed); peak = fit->GetParameter(1); } cout << Form("Finished <Col%d Row%d> = %.1f", ieta, iphi, peak) << endl; TText *t = new TText(.9, .9, Form("<Col%d Row%d> = %.1f", ieta, iphi, peak)); t->SetTextAlign(33); t->SetTextSize(.15); t->SetNDC(); t->Draw(); } } SaveCanvas(c1, TString(_file0->GetName()) + TString("_DrawPrototype3EMCalTower_") + TString(c1->GetName()), false); }
void EMCDistribution_SUM_RawADC(TString sTOWER = "Energy_Sum_col1_row2_5x5", TString CherenkovSignal = "C2_Inner") { TH1 *EnergySum_LG_full = new TH1F("EnergySum_LG_full", ";Tower Energy Sum (ADC);Count / bin", 260, -100, 2500); TH1 *EnergySum_LG = new TH1F("EnergySum_LG", ";Tower Energy Sum (ADC);Count / bin", 260, -100, 2500); // TH1 * EnergySum_HG = new TH1F("EnergySum_HG", // ";Low range Tower Energy Sum (ADC);Count / bin", 50, 0, 500); TH1 *C2_Inner_full = new TH1F("C2_Inner_full", CherenkovSignal + ";Cherenkov Signal (ADC);Count / bin", 1000, 0, 2000); TH1 *C2_Inner = new TH1F("C2_Inner", CherenkovSignal + ";Cherenkov Inner Signal (ADC);Count / bin", 1000, 0, 2000); EnergySum_LG_full->SetLineColor(kBlue + 3); EnergySum_LG_full->SetLineWidth(2); EnergySum_LG->SetLineColor(kGreen + 3); EnergySum_LG->SetLineWidth(3); EnergySum_LG->SetMarkerColor(kGreen + 3); C2_Inner_full->SetLineColor(kBlue + 3); C2_Inner_full->SetLineWidth(2); C2_Inner->SetLineColor(kGreen + 3); C2_Inner->SetLineWidth(3); C2_Inner->SetMarkerColor(kGreen + 3); TCut c2 = CherenkovSignal + ">240"; T->Draw(sTOWER + ">>EnergySum_LG_full", "", "goff"); T->Draw(sTOWER + ">>EnergySum_LG", c2, "goff"); T->Draw(CherenkovSignal + ">>C2_Inner_full", "", "goff"); T->Draw(CherenkovSignal + ">>C2_Inner", c2, "goff"); TText *t; TCanvas *c1 = new TCanvas( "EMCDistribution_SUM_RawADC_" + sTOWER + "_" + CherenkovSignal + cuts, "EMCDistribution_SUM_RawADC_" + sTOWER + "_" + CherenkovSignal + cuts, 1800, 600); c1->Divide(3, 1); int idx = 1; TPad *p; p = (TPad *) c1->cd(idx++); c1->Update(); p->SetLogy(); p->SetGridx(0); p->SetGridy(0); C2_Inner_full->DrawClone(); C2_Inner->DrawClone("same"); p = (TPad *) c1->cd(idx++); c1->Update(); p->SetLogy(); p->SetGridx(0); p->SetGridy(0); TH1 *h = (TH1 *) EnergySum_LG_full->DrawClone(); // h->GetXaxis()->SetRangeUser(0, h->GetMean() + 5 * h->GetRMS()); (TH1 *) EnergySum_LG->DrawClone("same"); p = (TPad *) c1->cd(idx++); c1->Update(); // p->SetLogy(); p->SetGridx(0); p->SetGridy(0); TH1 *h_full = (TH1 *) EnergySum_LG_full->DrawClone(); TH1 *h = (TH1 *) EnergySum_LG->DrawClone("same"); TF1 *fgaus_g = new TF1("fgaus_LG_g", "gaus", h->GetMean() - 1 * h->GetRMS(), h->GetMean() + 4 * h->GetRMS()); fgaus_g->SetParameters(1, h->GetMean() - 2 * h->GetRMS(), h->GetMean() + 2 * h->GetRMS()); h->Fit(fgaus_g, "MR0N"); TF1 *fgaus = new TF1("fgaus_LG", "gaus", fgaus_g->GetParameter(1) - 1 * fgaus_g->GetParameter(2), fgaus_g->GetParameter(1) + 4 * fgaus_g->GetParameter(2)); fgaus->SetParameters(fgaus_g->GetParameter(0), fgaus_g->GetParameter(1), fgaus_g->GetParameter(2)); h->Fit(fgaus, "MR"); h->Sumw2(); h_full->Sumw2(); h_full->GetXaxis()->SetRangeUser(h->GetMean() - 4 * h->GetRMS(), h->GetMean() + 4 * h->GetRMS()); h->SetLineWidth(2); h->SetMarkerStyle(kFullCircle); h_full->SetTitle( Form("#DeltaE/<E> = %.1f%%", 100 * fgaus->GetParameter(2) / fgaus->GetParameter(1))); // p = (TPad *) c1->cd(idx++); // c1->Update(); // p->SetLogy(); // p->SetGridx(0); // p->SetGridy(0); // // TH1 * h = (TH1 *) EnergySum_LG->DrawClone(); // h->GetXaxis()->SetRangeUser(0,500); // h->SetLineWidth(2); // h->SetLineColor(kBlue + 3); //// h->Sumw2(); // h->GetXaxis()->SetRangeUser(0, h->GetMean() + 5 * h->GetRMS()); // // p = (TPad *) c1->cd(idx++); // c1->Update(); //// p->SetLogy(); // p->SetGridx(0); // p->SetGridy(0); // // TH1 * h = (TH1 *) EnergySum_LG->DrawClone(); // h->GetXaxis()->SetRangeUser(0,500); // // TF1 * fgaus = new TF1("fgaus_HG", "gaus", 0, 100); // fgaus->SetParameters(1, h->GetMean() - 2 * h->GetRMS(), // h->GetMean() + 2 * h->GetRMS()); // h->Fit(fgaus, "M"); // // h->Sumw2(); // h->GetXaxis()->SetRangeUser(h->GetMean() - 4 * h->GetRMS(), // h->GetMean() + 4 * h->GetRMS()); // // h->SetLineWidth(2); // h->SetMarkerStyle(kFullCircle); // // h->SetTitle( // Form("#DeltaE/<E> = %.1f%%", // 100 * fgaus->GetParameter(2) / fgaus->GetParameter(1))); SaveCanvas(c1, TString(_file0->GetName()) + TString("_DrawPrototype3EMCalTower_") + TString(c1->GetName()), false); }
TObjArray* ProcessSummary(TObjArray* arrs, int icl, const char* pref) { // Process TObjArray (e.g. for set of pt bins) of TObjArray of KMCTrackSummary objects: // pick the KMCTrackSummary for "summary class" icl (definition of acceptable track) and create // graphs vs bin. // These graphs are returned in new TObjArray // TString prefs = pref; if (!gs) gs = new TF1("gs","gaus",-1,1); // int nb = arrs->GetEntriesFast(); TObjArray* sums = (TObjArray*) arrs->At(0); int nclass = sums->GetEntriesFast(); if (icl>=nclass) {printf("summary set has %d classes only, %d requested\n",nclass,icl);return 0;} // KMCTrackSummary* sm = (KMCTrackSummary*)sums->At(icl); // TH1* h; // h = sm->GetHMCSigDCARPhi(); // MC resolution in transverse DCA TGraphErrors * grSigD = 0; if (h) { grSigD = new TGraphErrors(nb); grSigD->SetName(Form("%s%s",prefs.Data(),h->GetName())); grSigD->SetTitle(Form("%s%s",prefs.Data(),h->GetTitle())); } // TGraphErrors * grSigZ = 0; h = sm->GetHMCSigDCAZ(); // MC resolution in Z DCA if (h) { grSigZ = new TGraphErrors(nb); grSigZ->SetName(Form("%s%s",prefs.Data(),h->GetName())); grSigZ->SetTitle(Form("%s%s",prefs.Data(),h->GetTitle())); } // TGraphErrors * grSigAD = 0; // anaitical estimate for resolution in transverse DCA { grSigAD = new TGraphErrors(nb); grSigAD->SetName(Form("%s%s",prefs.Data(),"sigmaDan")); grSigAD->SetTitle(Form("%s%s",prefs.Data(),"#sigmaD an")); } // TGraphErrors * grSigAZ = 0; // anaitical estimate for resolution in Z DCA { grSigAZ = new TGraphErrors(nb); grSigAZ->SetName(Form("%s%s",prefs.Data(),"sigmaZan")); grSigAZ->SetTitle(Form("%s%s",prefs.Data(),"#sigmaZ an")); } // // TGraphErrors * grSigPt = 0; // MC res. in pt { grSigPt = new TGraphErrors(nb); grSigPt->SetName(Form("%s%s",prefs.Data(),"sigmaPt")); grSigPt->SetTitle(Form("%s%s",prefs.Data(),"#sigmaPt")); } // TGraphErrors * grSigAPt = 0; // analitycal res. in pt { grSigAPt = new TGraphErrors(nb); grSigAPt->SetName(Form("%s%s",prefs.Data(),"sigmaPtan")); grSigAPt->SetTitle(Form("%s%s",prefs.Data(),"#sigmaPt an")); } // TGraphErrors * grEff = 0; // MC efficiency { grEff = new TGraphErrors(nb); grEff->SetName(Form("%s_rate",prefs.Data())); grEff->SetTitle(Form("%s Rate",prefs.Data())); } // TGraphErrors * grUpd = 0; // number of Kalman track updates { grUpd = new TGraphErrors(nb); grUpd->SetName(Form("%s_updCalls",prefs.Data())); grUpd->SetTitle(Form("%s Updates",prefs.Data())); } // for (int ib=0;ib<nb;ib++) { sums = (TObjArray*) arrs->At(ib); sm = (KMCTrackSummary*)sums->At(icl); KMCProbe& prbRef = sm->GetRefProbe(); KMCProbe& prbAn = sm->GetAnProbe(); double pt = prbRef.Pt(); // if (grSigAD) { grSigAD->SetPoint(ib, pt,prbAn.GetSigmaY2()>0 ? TMath::Sqrt(prbAn.GetSigmaY2()) : 0.); } // if (grSigAZ) { grSigAZ->SetPoint(ib, pt,prbAn.GetSigmaZ2()>0 ? TMath::Sqrt(prbAn.GetSigmaZ2()) : 0.); } // if (grSigAPt) { double pts = TMath::Sqrt(prbAn.GetSigma1Pt2()); grSigAPt->SetPoint(ib, pt,pts>0 ? pts*pt : 0.); } // if (grSigPt) { h = sm->GetHMCSigPt(); h->Fit(gs,"0q"); grSigPt->SetPoint(ib, pt, gs->GetParameter(2)); grSigPt->SetPointError(ib, 0, gs->GetParError(2)); } // if (grSigD) { h = sm->GetHMCSigDCARPhi(); h->Fit(gs,"0q"); grSigD->SetPoint(ib, pt,gs->GetParameter(2)); grSigD->SetPointError(ib, 0,gs->GetParError(2)); } // if (grSigZ) { h = sm->GetHMCSigDCAZ(); h->Fit(gs,"0q"); grSigZ->SetPoint(ib, pt,gs->GetParameter(2)); grSigZ->SetPointError(ib, 0,gs->GetParError(2)); } // if (grEff) { grEff->SetPoint(ib, pt,sm->GetEff()); grEff->SetPointError(ib, 0,sm->GetEffErr()); } // if (grUpd) { grUpd->SetPoint(ib, pt,sm->GetUpdCalls()); grUpd->SetPointError(ib, 0, 0); } } // TObjArray* dest = new TObjArray(); dest->AddAtAndExpand(grSigAD,kSigAD); dest->AddAtAndExpand(grSigAZ,kSigAZ); dest->AddAtAndExpand(grSigAPt,kSigAPt); dest->AddAtAndExpand(grSigD,kSigD); dest->AddAtAndExpand(grSigZ,kSigZ); dest->AddAtAndExpand(grSigPt,kSigPt); dest->AddAtAndExpand(grEff,kEff); dest->AddAtAndExpand(grUpd,kUpd); // if (!prefs.IsNull()) dest->SetName(pref); return dest; }
void CalibrateData(Int_t nevt,Int_t startEv = 1, char *PedFile = "drs4_20100311_t_ped.root") { // create progress bar TGHProgressBar *gProgress = ProgressBar("Calibrazione dati"); // Redefine DOMINO Depth in ADC counts const Float_t DominoDepthADC = pow(2, DOMINO_DEPTH); // create list of histograms for pedestals TList *grPedList = new TList(); TGraphErrors *grPed; // create list of histograms for channels TList *hCellCalibList = new TList(); TH1F *hCellCalib; TList *grCellCalibList = new TList(); TGraphErrors *grCellCalib; int mV[NCALIBFILES] = {-500,-400,-300,-200,-100,0,100,200,300,400,500}; /*for (int iFile = 0; iFile < NCALIBFILES; iFile++) { mV[iFile] = mVStart; mVStart += mVStep; }*/ char *calibrationFile; char *calibrationFileArray[NCALIBFILES]; calibrationFileArray[0] = "drs4_1000ev_dcm500mv.dat"; calibrationFileArray[1] = "drs4_1000ev_dcm400mv.dat"; calibrationFileArray[2] = "drs4_1000ev_dcm300mv.dat"; calibrationFileArray[3] = "drs4_1000ev_dcm200mv.dat"; calibrationFileArray[4] = "drs4_1000ev_dcm100mv.dat"; calibrationFileArray[5] = "drs4_1000ev_dc1mv.dat"; calibrationFileArray[6] = "drs4_1000ev_dc100mv.dat"; calibrationFileArray[7] = "drs4_1000ev_dc200mv.dat"; calibrationFileArray[8] = "drs4_1000ev_dc300mv.dat"; calibrationFileArray[9] = "drs4_1000ev_dc400mv.dat"; calibrationFileArray[10] = "drs4_1000ev_dc500mv.dat"; for (int iFile = 0; iFile < NCALIBFILES; iFile++) { for (int ch = 0; ch < DOMINO_NCELL; ch++) { // TString title = "Calibration signal file:"; title += iFile; title += " ch:"; title += ch; hCellCalib = new TH1F(title,title, DominoDepthADC, -DominoDepthADC, DominoDepthADC); hCellCalibList->Add(hCellCalib); } } for (int ch = 0; ch < DOMINO_NCELL; ch++) { grCellCalib = new TGraphErrors(NCALIBFILES); grCellCalibList->Add(grCellCalib); } // calculate or read pedestals from file grPedList = OpenPedestals(PedFile); grPedData = (TGraphErrors *) grPedList->At(anaChannel); grPedTrig = (TGraphErrors *) grPedList->At(trigChannel); // create gauss function TF1 *fgauss = new TF1("fgauss", "TMath::Gaus(x,[0],[1],0)", -DOMINO_NCELL, DOMINO_NCELL); fgauss->SetParameter(0,0.); fgauss->SetParameter(1,1.); fgauss->SetParLimits(0, 0., DominoDepthADC); fgauss->SetParLimits(1, 0.1, 20.); TCanvas *ctest = new TCanvas("ChannelTest", "ChannelTest", 800, 600); ctest->Divide(3, 4); gProgress->Reset(); gProgress->SetMax(nevt*NCALIBFILES); gSystem->ProcessEvents(); for (int iFile = 0; iFile < NCALIBFILES; iFile++) { // open file calibrationFile = calibrationFileArray[iFile]; FILE *fdata = OpenDataFile(calibrationFile); struct channel_struct *p; struct channel_struct *dep; Double_t refval=0, reftmp = 0; Double_t PedVal, itmp; // Count number of events in data file int nevtDataMax = 0; while (!feof(fdata)) { fread((void *) &event_data, 1, sizeof(event_data), fdata); nevtDataMax++; } printf("nevtDataMax: %d\n", nevtDataMax); if (nevt > (nevtDataMax - startEv) || nevt == 0) nevt = nevtDataMax - startEv; cout << endl << "==>> Processing " << nevt << " events from file " << calibrationFile << endl; rewind(fdata); for (int j = 0; j < 1; j++) { fread((void *) &event_data, 1, sizeof(event_data), fdata); p = (struct channel_struct *) &event_data.ch[0]; // read bunch of data p += anaChannel; for (ch = 0; ch < DOMINO_NCELL; ch++) { grPedData->GetPoint(ch, itmp, PedVal); reftmp = TMath::Abs((Double_t)(p->data[ch])-PedVal); if (reftmp > 0.8* refval) refval = 0.2*reftmp+0.8*refval; // cout << ch << " " <<p->data[ch] << " " <<reftmp << " " << refval <<endl ; } } cout << "refval="<< refval<<endl; rewind(fdata); Int_t ievt = 1; // go to first event (startEv) while (ievt < startEv) { fread((void *) &event_data, 1, sizeof(event_data), fdata); if (feof(fdata)) break; ievt++; } ievt = 1; Int_t iTrig = 0; Int_t flagEnd = 0; Double_t chtmp, chtrig; Double_t ratio; Double_t mean, rms; // loop on events while (ievt <= nevt && !flagEnd) { fread((void *) &event_data, 1, sizeof(event_data), fdata); if (feof(fdata)) flagEnd = 1; p = (struct channel_struct *) &event_data.ch[0]; // read bunch of data dep = (struct channel_struct *) &event_data.ch[1]; // read bunch of data //now anaChannel analysis p += anaChannel; // read data, subtract pedestals values and fill hCellCalibList. for (int ch = 0; ch < DOMINO_NCELL; ch++) { // Read pedestal value for this cell grPedData->GetPoint(ch, itmp, PedVal); chtmp = (Double_t)(p->data[ch]); // data value chtmp = chtmp - PedVal; //if (TMath::Abs(chtmp) > 0.9 * refval) ((TH1 *) hCellCalibList->At(iFile*DOMINO_NCELL+ch))->Fill(chtmp); //cout << ch << " " << iFile << " " << chtmp << endl; } gProgress->Increment(1); gSystem->DispatchOneEvent(kTRUE); ievt++; // next event } TH1 *hCellTmp; for(ch = 0; ch < DOMINO_NCELL;ch++) { hCellTmp = ((TH1 *) hCellCalibList->At(iFile*DOMINO_NCELL+ch)); //hCellTmp->Fit("gaus", "Q"); //mean = (hCellTmp->GetFunction("gaus"))->GetParameter(1); //rms = (hCellTmp->GetFunction("gaus"))->GetParameter(2); mean = hCellTmp->GetMean(); rms = hCellTmp->GetRMS(); ((TGraphErrors *) (grCellCalibList->At(ch)))->SetPoint(iFile, (Double_t) mV[iFile], mean); ((TGraphErrors *) (grCellCalibList->At(ch)))->SetPointError(iFile, 0., rms); } ctest->cd(iFile + 1); hCellTmp = ((TH1 *) hCellCalibList->At(567 + iFile*DOMINO_NCELL)); hCellTmp->Fit("gaus","Q"); hCellTmp->DrawCopy(); } TString OutFile = "CalibrationDataNew"; OutFile += nevt; OutFile += "events.root"; TFile *f = new TFile(OutFile, "RECREATE"); for (int ch = 0; ch < DOMINO_NCELL; ch++) { TString key = "CalibDataCell"; key += ch; ((TGraphErrors*) grCellCalibList->At(ch))->Write(key); } f->Close(); hCellCalibList->Delete(); ((TGMainFrame *) gProgress->GetParent())->CloseWindow(); fclose(fdata); }
void AnalysisSparse(Bool_t save_output = kFALSE) { gStyle->SetGridColor(kGray); // TString tmpstr(fname); // if (tmpstr.Contains("data")) { // Printf("!!! Real Data !!!"); // mc = kFALSE; // } TString gtitle = Form("Monte Carlo, %s", graph_name.Data()); grapht = graph_name.Data(); Double_t grx[999], gry[999], gry2[999], gry3[999], gry4[999], gry_eff[999], gry_fix[999], grxE[999]; Double_t gry22[999], gry22E[999], grx22E[999]; Double_t gry_true[999], gry_true_eff[999], gry_true_effE[999]; TH1::AddDirectory(kFALSE); TFile::SetCacheFileDir(gSystem->HomeDirectory()); TFile *f = TFile::Open(fname.Data(), "CACHEREAD"); if (!f) return; TList *l; f->GetObject(lname.Data(), l); if (!l) return; Int_t bf[999], bl[999]; Int_t nn = FindExactRange(((THnSparse *)(l->FindObject(s1name.Data())))-> Projection(1), del_step, bf, bl); // Int_t nn = FindRange5(bf, bl); Bool_t binhaluska = kFALSE; if (binAnders) { nn = 8; bf[0] = 6;bf[1] = 9;bf[2] = 11;bf[3] = 16;bf[4] = 21;bf[5] = 26; bl[0] = 8;bl[1] = 10;bl[2] = 15;bl[3] = 20;bl[4] = 25;bl[5] = 30; bf[6] = 31;bf[7] = 41; bl[6] = 40;bl[7] = 50; } Printf("number of intervals = %d =>", nn); Int_t count = 0; Double_t ptmean = 0, value = 0; Int_t fitStatus = -1; gStyle->SetOptStat(0); TCanvas *c = new TCanvas("c", "Signal & Background"); c->Divide(5, 5); c->Modified(); c->Draw(); TCanvas *c2 = (TCanvas *)c->DrawClone("c2"); c2->SetTitle("Phi mesons (raw)"); c2->Modified(); c2->Draw(); TCanvas *c3, *c4; if (mc) { c3 = (TCanvas *)c->DrawClone("c3"); c3->SetTitle("Phi mesons (gen)"); c3->Modified(); c3->Draw(); c4 = (TCanvas *)c->DrawClone("c4"); c4->SetTitle("Phi mesons (true)"); c4->Modified(); c4->Draw(); } for (Int_t i = 0; i < nn; i++) { c->cd(count + 1)->SetGrid(); h1 = (TH1D *)PullHisto(l, s1name.Data(), bf[i], bl[i], ptmean); h1->SetLineColor(kRed); h1->GetXaxis()->SetTitle("inv. mass, GeV/c^2"); h1->Draw("hist"); h3_p = (TH1D *)PullHisto(l, s3name_p.Data(), bf[i], bl[i], ptmean); h3_m = (TH1D *)PullHisto(l, s3name_m.Data(), bf[i], bl[i], ptmean); // !!!!!!!!!!!!!!!!!!!!!!!! if (count==0) h3_p = h1; // !!!!!!!!!!!!!!!!!!!!!!!! else { h3_p->Add(h3_m); // h3_p->Add((TH1D *)PullHisto(l, smix.Data(), bf[i], bl[i], ptmean)); // h3_p->Add((TH1D *)PullHisto(l, smixpp.Data(), bf[i], bl[i], ptmean)); // h3_p->Add((TH1D *)PullHisto(l, smixmm.Data(), bf[i], bl[i], ptmean)); Norm(h1, h3_p, norm[0], norm[1]); } h3_p->SetLineColor(kBlue); h3_p->Draw("hist, same"); if (mc) { c3->cd(count + 1)->SetGrid(); Printf("%s", s1namegen.Data()); hg = (TH1D *)PullHisto(l, s1namegen.Data(), bf[i], bl[i], ptmean); hg->SetLineColor(kMagenta); hg->GetXaxis()->SetTitle("inv. mass, GeV/c^2"); hg->Draw("hist"); c4->cd(count + 1)->SetGrid(); ht = (TH1D *)PullHisto(l, s1nametrue.Data(), bf[i], bl[i], ptmean); ht->SetLineColor(kMagenta-5); ht->GetXaxis()->SetTitle("inv. mass, GeV/c^2"); ht->Draw("hist"); } c2->cd(count + 1)->SetGrid(); TH1 *hh = (TH1 *)h1->Clone("hh"); hh->SetLineColor(kRed+1); hh->Add(h3_p, -1); /// !!!!!!!!!!!!!!!!!!!!!! ////////// if ((ilist == 3) && (count < 2)) hh->Reset(); // !!!!!!!!!!!!!!!!!!!!!!!!!!!!! hh->Draw("hist"); // !!!!!!!!!!!!!!!!!! ff->SetParameters(0.1, 1.02, 0.004, -25000., 0., 0., 0.); ff->SetLineColor(hh->GetLineColor()); ff->SetLineWidth(1); // ff->SetLineStyle(kDashed); // where fit Double_t fmin = 1.02-2*0.004; Double_t fmax = 1.02+2*0.004; // Double_t fmin = 0.995; // Double_t fmax = 1.185; // !!!!!!!!!!!!!!!!!! Bool_t hisfun = kFALSE; // kFALSE = integral from function Double_t hisfun_k = 1.0/hh->GetBinWidth(10); // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! if (binhaluska) if (i > 9) hisfun_k = 0.5/hh->GetBinWidth(10); Printf("======= %f", hisfun_k); // !!!!!!!!!!!!!!!!!! // wehere integral (his or fun) Double_t fmini = 1.02-2*0.004; Double_t fmaxi = 1.02+2*0.004; hh->Fit(ff, "Q", "", fmin, fmax); hh->Fit(ff, "Q", "", fmin, fmax); fitStatus = hh->Fit(ff, "Q", "", fmin, fmax); TF1 *pp3 = new TF1("pp3", "[0]+x*[1]+x*x*[2]+x*x*x*[3]", fmin, fmax); pp3->SetParameters(ff->GetParameter(3), ff->GetParameter(4), ff->GetParameter(5), ff->GetParameter(6)); pp3->SetLineWidth(1); pp3->SetLineColor(h3_p->GetLineColor()); pp3->Draw("same"); // ff->SetRange(fmin, fmax); // ff->DrawCopy("same"); value = hh->Integral(hh->FindBin(fmini), hh->FindBin(fmaxi)); if (!hisfun) value = ff->Integral(fmini, fmaxi)*hisfun_k - pp3->Integral(fmini, fmaxi)*hisfun_k; if (value < 0) value = 0; if ((fitStatus != 0) || (ff->GetParameter(2) > 0.1)) { printf(" SKIP Data"); value = 0; } grx[count] = ptmean; if (binhaluska) { if (count < 10) grxE[count] = 0.25; // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! else grxE[count] = 0.50; // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! } else // grxE[count] = (1.30-1.10)/2.0; // !!!!!!!!!!!!!!!!!!!!!!!!!! grxE[count] = 0.05; gry[count] = value; Double_t tmp1 = h1->Integral(h1->FindBin(fmini), h1->FindBin(fmaxi)); Double_t tmp2 = h3_p->Integral(h3_p->FindBin(fmini), h3_p->FindBin(fmaxi)); Double_t tmp_sg = tmp1 - tmp2; Double_t tmp_bg = tmp2; // if ((tmp_sg <= -tmp_bg) || (tmp_bg < 33.0)) { // gry3[count] = 0.0; // gry4[count] = 0.0; // } // else { gry3[count] = tmp_sg/tmp_bg; gry4[count] = tmp_sg/TMath::Sqrt(tmp_sg + tmp_bg); // } // Printf("%4.2f, %10f, %10f, %10f", ptmean, tmp1, tmp2, gry3[count]); if (mc) { c3->cd(count + 1); // !!!!!!!!!!!!!!!! ff->SetParameters(1, 1.02, 0.004, 0., 0., 0., 0.); hg->Fit(ff, "Q", "", fmin, fmax); hg->Fit(ff, "Q", "", fmin, fmax); fitStatus = hg->Fit(ff, "Q", "", fmin, fmax); /* TF1 *pp3 = new TF1("pp3", "[0]+x*[1]+x*x*[2]+x*x*x*[3]", fmin, fmax); pp3->SetParameters(ff->GetParameter(3), ff->GetParameter(4), ff->GetParameter(5), ff->GetParameter(6)); pp3->SetLineWidth(1); pp3->SetLineColor(h3_p->GetLineColor()); pp3->Draw("same"); */ value = hg->Integral(hg->FindBin(fmini), hg->FindBin(fmaxi)); if (!hisfun) value = ff->Integral(fmini, fmaxi)*hisfun_k; //!!!!!!!!!!!!!!!!!!!pp3->Integral(fmini, fmaxi)*hisfun_k; if (value <= 0) value = -1; if ((fitStatus != 0) || (ff->GetParameter(2) > 0.1)) { printf(" SKIP MC"); value = -1; } gry2[count] = value; Double_t superfactor = CalculateFactor(l, 0.1); if (useCF) { gry22E[i] = TMath::Sqrt(gry2[i])*superfactor; // gry22E[i] = 0.0001; gry22[i] = gry2[i]*superfactor; grx22E[i] = 0.05; } gry_eff[count] = gry[count]/gry2[count]; c4->cd(count + 1); // !!!!!!!!!!!!!!!! ff->SetParameters(1, 1.02, 0.004, 0., 0., 0., 0.); ht->Fit(ff, "Q", "", fmin, fmax); ht->Fit(ff, "Q", "", fmin, fmax); fitStatus = ht->Fit(ff, "Q", "", fmin, fmax); /* TF1 *pp3 = new TF1("pp3", "[0]+x*[1]+x*x*[2]+x*x*x*[3]", fmin, fmax); pp3->SetParameters(ff->GetParameter(3), ff->GetParameter(4), ff->GetParameter(5), ff->GetParameter(6)); pp3->SetLineWidth(1); pp3->SetLineColor(h3_p->GetLineColor()); pp3->Draw("same"); */ value = ht->Integral(ht->FindBin(fmini), ht->FindBin(fmaxi)); if (!hisfun) value = ff->Integral(fmini, fmaxi)*hisfun_k; //!!!!!!!!!!!!!!!!!!!pp3->Integral(fmini, fmaxi)*hisfun_k; if (value <= 0) value = -1; if ((fitStatus != 0) || (ff->GetParameter(2) > 0.1)) { printf(" SKIP true"); value = -1; } gry_true[count] = value; gry_true_eff[count] = gry_true[count]/gry2[count]; // Propagation of uncertainty (A/B) Double_t AAA = gry_true[count]; Double_t AAAE = TMath::Sqrt(AAA); Double_t BBB = gry2[count]; Double_t BBBE = TMath::Sqrt(BBB); Double_t EEE = TMath::Sqrt((AAAE/AAA)*(AAAE/AAA)+(BBBE/BBB)*(BBBE/BBB)); EEE = EEE*gry_true_eff[count]; gry_true_effE[count] = EEE; } Printf("=> %6.4f", ptmean); count++; } new TCanvas(); TGraph *gr = new TGraph(count, grx, gry); gr->SetMarkerStyle(8); gr->SetMarkerColor(hh->GetLineColor()); gr->GetXaxis()->SetTitle("p_{t}, GeV/c"); gr->SetTitle(Form("raw phi, %s", gtitle.Data())); gr->Draw("AP"); cc3 = new TCanvas(); TGraph *gr3 = new TGraph(count, grx, gry3); gr3->SetMarkerStyle(22); gr3->SetMarkerColor(kBlue+1); gr3->GetXaxis()->SetTitle("p_{t}, GeV/c"); gr3->SetTitle(Form("SIG / BKG, %s", gtitle.Data())); gr3->SetMinimum(0); gr3->Draw("AP"); cc4 = new TCanvas(); TGraph *gr4 = new TGraph(count, grx, gry4); gr4->SetMarkerStyle(23); gr4->SetMarkerColor(kBlue-1); gr4->GetXaxis()->SetTitle("p_{t}, GeV/c"); gr4->SetTitle(Form("Significance, %s", gtitle.Data())); gr4->SetMinimum(0); gr4->Draw("AP"); ccc = new TCanvas("ccc","ccc",0,0,900,300); ccc->Divide(2, 1, 0.001, 0.001); ccc->cd(1); gr3->Draw("AP"); ccc->cd(2); gr4->Draw("AP"); TString blabla = "mc"; if (!mc) blabla = "data"; // gr3->SaveAs(Form("SB_%s_%s.C", blabla.Data(), grapht.Data())); // gr4->SaveAs(Form("Sig_%s_%s.C", blabla.Data(), grapht.Data())); // ccc->SaveAs(Form("%s_%s_2.eps", blabla.Data(), grapht.Data())); // c->SaveAs(Form("%s_%s_0.eps", blabla.Data(), grapht.Data())); // c2->SaveAs(Form("%s_%s_1.eps", blabla.Data(), grapht.Data())); // cc3->SaveAs(Form("%s_%s_2.eps", blabla.Data(), grapht.Data())); // gr3->SaveAs(Form("sig_bck_%s_%s.C", blabla.Data(), grapht.Data())); if (mc) { new TCanvas(); TGraph *gr2 = new TGraph(count, grx, gry2); gr2->SetMarkerStyle(8); gr2->SetMarkerColor(hg->GetLineColor()); gr2->GetXaxis()->SetTitle("p_{t}, GeV/c"); gr2->SetTitle(Form("gen phi, %s", gtitle.Data())); gr2->Draw("AP"); new TCanvas(); TGraphErrors *gr22 = new TGraphErrors(count, grx, gry22, grx22E, gry22E); gr22->SetMarkerStyle(8); gr22->SetMarkerColor(kCyan); gr22->GetXaxis()->SetTitle("p_{t}, GeV/c"); gr22->SetTitle(Form("gen phi, %s", gtitle.Data())); gr22->Draw("AP"); c = new TCanvas(); c->SetGrid(); TGraph *gr_e = new TGraph(count, grx, gry_eff); gr_e->SetMarkerStyle(22); gr_e->SetMarkerColor(kBlack); gr_e->GetXaxis()->SetTitle("p_{t}, GeV/c"); gr_e->SetTitle(Form("efficiency (raw), %s", grapht.Data())); gr_e->Draw("AP"); Printf("Save as '\033[1meffi_raw_%s\033[0m' file", grapht.Data()); for (Int_t i = 0; i < gr_e->GetN(); i++) Printf("%f %f", gr_e->GetX()[i], gr_e->GetY()[i]); cvb = new TCanvas(); cvb->cd(); TGraph *gr_true = new TGraph(count, grx, gry_true); gr_true->SetMarkerStyle(8); gr_true->SetMarkerColor(ht->GetLineColor()); gr_true->GetXaxis()->SetTitle("p_{t}, GeV/c"); gr_true->SetTitle(Form("true phi, %s", gtitle.Data())); gr_true->Draw("AP"); c = new TCanvas(); c->cd(); c->SetGrid(); TGraphErrors *gr_true_eff = new TGraphErrors(count, grx, gry_true_eff, grxE, gry_true_effE); gr_true_eff->SetMarkerStyle(20); // gr_true_eff->SetMarkerSize(0.75); gr_true_eff->SetMarkerColor(kBlack); gr_true_eff->GetXaxis()->SetTitle("p_{t}, GeV/c"); gr_true_eff->SetTitle(Form("efficiency (true), %s", grapht.Data())); gr_true_eff->Draw("AEP"); m_gr->Add(gr_true_eff); Printf("Save as '\033[1meffi_true_%s\033[0m' file", grapht.Data()); TString tout; Double_t oux, ouy, ouxe, ouye; for (Int_t i = 0; i < gr_true_eff->GetN(); i++) { oux = gr_true_eff->GetX()[i]; ouy = gr_true_eff->GetY()[i]; ouy = MinusCheck(ouy); ouxe = gr_true_eff->GetErrorX(i); ouye = gr_true_eff->GetErrorY(i); ouye = NanCheck(ouye); Printf("%f %f %f %f", gr_true_eff->GetX()[i], gr_true_eff->GetY()[i], gr_true_eff->GetErrorX(i), gr_true_eff->GetErrorY(i)); if (!save_output) continue; gSystem->mkdir(dir_prefix.Data()); tout = Form("%f %f %f %f", oux, ouy, ouxe, ouye); if (i == 0) tout = Form("Printf(\"%s\"); > %s/effi_%s", tout.Data(), dir_prefix.Data(), grapht.Data()); else tout = Form("Printf(\"%s\"); >> %s/effi_%s", tout.Data(), dir_prefix.Data(), grapht.Data()); // Printf(":::::: %s", tout.Data()); gROOT->ProcessLine(tout.Data()); } // ------------------ c = new TCanvas("cfinal", "mc_effi", 1200, 450); c->Divide(2, 1, 0.001, 0.001); c->Modified(); c->Draw(); c->cd(1); gr_true->SetMinimum(0); gr_true->SetTitle(Form("phi (true & raw), %s", gtitle.Data())); gr_true->SetMarkerColor(kGreen+1); gr_true->Draw("AP"); gr->SetMarkerColor(kRed+1); gr->Draw("P"); c->cd(2)->SetGrid(); gr_true_eff->SetMinimum(0); gr_true_eff->SetTitle(Form("efficiency, %s", grapht.Data())); gr_true_eff->SetMarkerColor(kGreen+1); gr_true_eff->Draw("AP"); gr_e->SetMarkerColor(kRed+1); gr_e->Draw("P"); // c->SaveAs(Form("%s_%s.eps", blabla.Data(), grapht.Data())); return; } // TGraph *geff = new TGraph(Form("effi_raw_%s", grapht.Data())); // TGraph *geff = new TGraph(Form("effi_true_%s", grapht.Data())); // TGraph *geff = new TGraph("effi_true_Phi2010_qualityonly"); TGraph *geff = new TGraph("effi_true_PhiNsigma_qualityonly"); if (geff->IsZombie()) return; geff->SetMarkerStyle(22); geff->SetMarkerColor(kBlack); geff->GetXaxis()->SetTitle("p_{t}, GeV/c"); geff->SetTitle(Form("efficiency, %s", grapht.Data())); c = new TCanvas(); c->SetGrid(); geff->Draw("AP"); Double_t tpcsigma = 9999.9; if (ilist == 1) tpcsigma = 1.0; if (ilist == 2) tpcsigma = 1.5; if (ilist == 3) tpcsigma = 2.0; if (ilist == 4) tpcsigma = 2.5; if (ilist == 5) tpcsigma = 3.0; Double_t sss = TMath::Erf(tpcsigma/TMath::Sqrt(2.0)); if (noSigma) sss = 1.0; Printf("sigma = %10f", sss); // for (Int_t i = 0; i < count; i++) // geff->GetY()[i] = (sss*sss)/(geff->GetY()[i]); // geff->SetMaximum(1.0); // geff->Draw("AP"); for (Int_t i = 0; i < count; i++) { Double_t deno = geff->Eval(grx[i])*sss*sss; if (deno < 0.00001) deno = 1; gry_fix[i] = gry[i]/deno; } new TCanvas; TGraph *gr_fix = new TGraph(count, grx, gry_fix); gr_fix->SetMarkerStyle(21); gr_fix->SetMarkerColor(hh->GetLineColor()); gr_fix->GetXaxis()->SetTitle("p_{t}, GeV/c"); gr_fix->SetTitle(Form("corrected phi * #sigma^{2}, %s", gtitle.Data())); if (noSigma) gr_fix->SetTitle(Form("corrected phi (no #sigma), %s", gtitle.Data())); gr_fix->Draw("AP"); //--------------------- c = new TCanvas("cfinald", "data_correct", 1200, 450); c->Divide(2, 1, 0.001, 0.001); c->Modified(); c->Draw(); c->cd(1); gr->SetMinimum(0); gr->SetMarkerColor(kBlack); gr->Draw("AP"); c->cd(2); gr_fix->SetMinimum(0); gr_fix->SetMarkerColor(kGreen+3); gr_fix->Draw("AP"); TString bla9 = Form("qualityonly_PID2_%s", grapht.Data()); if (noSigma) bla9 = Form("%s_noSig.C", bla9.Data()); else bla9 = Form("%s.C", bla9.Data()); // gr_fix->SaveAs(bla9.Data()); // TPad *cp = new TPad("cpf", "", 0.45,0.45,0.99,0.92); TPad *cp = new TPad("cpf", "", 0.60,0.55,0.99,0.93); cp->SetLogy(); cp->Draw(); cp->cd(); TGraph *cloneg = ((TGraph *)gr_fix->Clone()); cloneg->SetTitle(); cloneg->SetMarkerSize(0.8); cloneg->Draw("AP"); // c->SaveAs(Form("%s_%s.eps", blabla.Data(), grapht.Data())); f->Close(); }
void FitOmegaPeak(const bool fixOmegaMass=false, const double r_min=650.0, const double r_max=900.0) { const char* hist_name = "ggg_IM"; const int npx = 500; const double omega_mass = 782.0; const double expected_width = 15.0; TH1* h = NULL; gDirectory->GetObject(hist_name, h); if(!h) { cerr << "Can't find histogram" << endl; return; } TF1* sig = new TF1("sig", "gaus", r_min, r_max); sig->SetLineColor(kGreen); sig->SetNpx(npx); // height sig->SetParameter(0, 0.5 * h->GetMaximum()); // position if(fixOmegaMass) sig->FixParameter(1, omega_mass); else sig->SetParameter(1, omega_mass); // width sig->SetParameter(2, expected_width); TF1* bg = new TF1("bg", "pol2", r_min, r_max); bg->SetLineColor(kBlue); bg->SetParameter(0,0); bg->SetParName(0, "BG p_{0}"); bg->SetParameter(1,0); bg->SetParName(1, "BG p_{1}"); bg->SetParameter(2,0); bg->SetParName(2, "BG p_{2}"); TFSum::FitRanged(h, bg, 650, 730, 830, 900); //bg->FixParameter(0, bg->GetParameter(0)); //bg->FixParameter(1, bg->GetParameter(1)); //bg->FixParameter(2, bg->GetParameter(2)); TFSum* sum = new TFSum("sum", sig, bg, r_min, r_max); sum->SetNpx(npx); TCanvas* c = new TCanvas(); c->SetTitle(Form("Fit to %s", hist_name)); h->SetStats(true); gStyle->SetOptFit(1); h->Draw(); h->Fit(sum->Function(), "REM0NB"); sum->SyncToFcts(); sum->Draw(); const double total_area = sum->Function()->Integral(r_min, r_max); const double bg_area = bg->Integral(r_min, r_max); const double sig_area = total_area - bg_area; const double sig_to_bg = sig_area / bg_area; const double peak_pos = sig->GetParameter(1); cout << "Mass offset = " << peak_pos - omega_mass << " MeV\n"; cout << "Sig/BG = " << sig_to_bg << "\n"; cout << "Sig = " << sig_area << endl; // TODO: choose a position. Positions for TLatex are histogram coordinates. TLatex* label = new TLatex(r_min, h->GetMaximum(),Form("Signal content = %lf", sig_area)); label->Draw(); }
float PurityFit::fit_specific( const TH1* h_, const TH1* sig_, const TH1* bkg_, string name, // unique name of the result string outname , // output file name, where to save results map<string,float> *pars // to gather additional params ) { // 1) perform preliminary checks if ( h_ == NULL ) { cout<<"[PurityFit]::[fit_specific]::[ERROR] no target histogram"<<endl; return -1;} if ( sig_ == NULL ) { cout<<"[PurityFit]::[fit_specific]::[ERROR] no sig histogram"<<endl; return -1;} if ( bkg_ == NULL ) { cout<<"[PurityFit]::[fit_specific]::[ERROR] no bkg histogram"<<endl; return -1;} if (sig_ -> Integral() == 0 ) { cout<<"[PurityFit]::[fit_specific]::[ERROR] sig integrall is NULL"<<endl; return -2;} if (bkg_ -> Integral() == 0 ) { cout<<"[PurityFit]::[fit_specific]::[ERROR] bkg integrall is NULL"<<endl; return -2;} if (verbose_ >0) cout <<"[PurityFit]::[fit_specific]::[INFO] fitting "<<h_->GetName() << " " << sig_->GetName()<<" "<<bkg_->GetName()<<endl; // 1.5) Clone TH1 * sig = (TH1*)sig_ -> Clone(Form("%s_fitspecific_clone",sig_->GetName())); TH1 * bkg = (TH1*)bkg_ -> Clone(Form("%s_fitspecific_clone",bkg_->GetName())); TH1 * h = (TH1*)h_ -> Clone(Form("%s_fitspecific_clone",h_->GetName())); // 1.6) check no negative entries otherwise 0 for(int i=1;i<=sig->GetNbinsX();++i) if(sig->GetBinContent(i) <0) sig->SetBinContent(i,0); for(int i=1;i<=bkg->GetNbinsX();++i) if(bkg->GetBinContent(i) <0) bkg->SetBinContent(i,0); // 2) scale templates: template normalization is meaningless sig->Sumw2(); bkg->Sumw2(); if (bkg->Integral() <=0) { for(int i=1;i<=bkg->GetNbinsX();++i) bkg->SetBinContent(i,1.0); } // 2.5) fit background with exponential int nbins = h->GetNbinsX(); float xmin = h->GetBinLowEdge(1); float xmax = h->GetBinLowEdge(nbins+1); double prevChi2=-1; vector<TCanvas*> cbkgs; vector<TF1> expos; double cached_pars[50]; //cache for(int i=0;i< sizeof(cached_pars)/sizeof(double); ++i) cached_pars[i]=0; int poln=0; for( poln=0;poln<5; ++poln) { string formula = "TMath::Exp(-[0]*x) * ( "; for(int i=0;i<=poln;++i) { if (i>0 ) formula += " + "; formula += Form("[%d]",i+1); if (i>0) formula += Form("*TMath::Power(x,%d)",i); } formula += ")"; cout <<"Considering Formula"<<formula<<endl; TF1 expo(Form("expo%d",poln),formula.c_str(),xmin,xmax); expo.SetParameter(0,0.01); expo.SetParameter(1,0.05); expo.SetParLimits(0,TMath::Min(bkg->Integral()*.1,0.001), bkg->Integral()*10); expo.SetParLimits(1,1e-9, 1.); if (poln>0)for(int k=0;k < poln+1;++k) expo.SetParameter(k, cached_pars[k]); bkg->Fit( &expo ,"QN") ; bkg->Fit( &expo ,"QNM") ; expos.push_back(expo); //cache parameters for(int k=0;k < poln+1;++k) cached_pars[k]=expo.GetParameter(k); double chi2=expo.GetChisquare(); double prob = 0 ; if (poln > 0) { int n = 0; for(int i=1;i<=bkg->GetNbinsX();++i) if ( bkg->GetBinContent(i)> 0 ) ++n; int dof = n - (poln+2) + 1; double f = (prevChi2 - chi2) / ( chi2 /dof) ; prob= 1.- TMath::FDistI (f , 1, dof ) ; } prevChi2 = chi2; cout<<"----------- BKG PARAMETERS ARE -------"<<endl; cout << "Prob = "<<prob<<endl; cout << "chi2 = "<<chi2<<endl; cout<<" 0 : "<< expo.GetParameter(0) <<endl; for(int i=0; i<=poln;++i) cout<<" "<< i+1 <<" : "<< expo.GetParameter(i+1) <<endl; cout<<"--------------------------------------"<<endl; TCanvas *cbkg=new TCanvas( (string(name)+"_bkgfit"+ Form("pol%d",poln)).c_str(),"Canvas"); cbkgs.push_back(cbkg); bkg->Clone("bkgForDraw")->Draw("P E"); // FIXME, memory leak expo.DrawClone("L SAME"); if (prob >0.05 and poln> 0) break; // ---------------------- EXIT BEFORE UPDATING } poln -= 1; // the last has a negligible improvement for(int i=1;i<=bkg->GetNbinsX() ;++i) bkg->SetBinContent(i,expos[poln].Integral( bkg->GetBinLowEdge(i),bkg->GetBinLowEdge(i+1) ) ) ; if (sig->Integral() >0) sig -> Scale( 1./sig->Integral() ); if (bkg->Integral() >0) bkg -> Scale( 1./bkg->Integral() ); // 3) estimate paramaters // float fracEstimator=0.5; // { // // 3.1) compute frac as around the max of sig // float sigMax= sig->GetMaximum(); // int sigBinMax= sig->GetMaximumBin(); // float sigInt= sig->Integral(); // float bkgUnderMax=bkg->GetBinContent(sigBinMax); // float targetMax = h->GetMaximum(); // float targetInt = h->Integral(); // float frac1=(targetMax/targetInt)/( (sigMax-bkgUnderMax)/sigInt); // // 3.2) compute frac as tail // float bkgInt= bkg->Integral(); // int bkgN=bkg->GetNbinsX(); // int nTailSum= bkgN/10; // float bkgTail=0;for(int i=0;i<nTailSum;i++) bkgTail+= bkg->GetBinContent(bkgN-i); // int targetN=h->GetNbinsX(); // float targetTail=0;for(int i=0;i<nTailSum;i++) targetTail+= h->GetBinContent(targetN-i); // float frac2=1.- (targetTail/targetInt)/(bkgTail/bkgInt); // // 3.3) set estimator // fracEstimator = frac1; // if(fracEstimator<0.05 or fracEstimator>0.95) fracEstimator=frac2; // if(fracEstimator<0.05 or fracEstimator>0.95) fracEstimator=0.8; // } // 4) create roofit variables RooRealVar f("f","fraction",0.95,0.3,1.0); //if ( TMath::IsNaN( fracEstimator ) ) // f.setVal(0.05); //else // f.setVal(fracEstimator); f.setRange(0.3,1.0); f.setConstant(false); RooRealVar x("x","EtMiss",xmin,xmax); // 5) create roo data hist RooDataHist HistSig("sig","hist sig",x,sig); RooDataHist HistBkg("bkg","hist bkg",x,bkg); RooDataHist HistToFit("target","hist target",x,h); // 6) create roo hist pdf RooHistPdf PdfSig("pdfsig","pdfsig",x,HistSig,0); RooHistPdf PdfBkg("pdfbkg","pdfbkg",x,HistBkg,10); //last number is interpolation // 7) create model RooAddPdf PdfModel("model","model",RooArgList(PdfSig,PdfBkg),f); // 8) fit RooFitResult *r; RooPlot *frame=x.frame(); RooMsgService::instance().setSilentMode(true); PdfModel.fitTo(HistToFit, SumW2Error(kTRUE), Save(), PrintEvalErrors(-1), PrintLevel(-1), //Minos(kTRUE), Warnings(0) ); r = PdfModel.fitTo(HistToFit, SumW2Error(kTRUE), Save(), PrintEvalErrors(-1), PrintLevel(-1), Minos(kTRUE), Warnings(0) ); cout <<" -------------- FLOATING -------------"<<endl; r-> floatParsInit() . Print("V"); cout <<" -------------- FINAL ----------------"<<endl; r-> floatParsFinal() . Print("V"); cout <<" -------------------------------------"<<endl; // 8.5) save additional results if (pars != NULL ) { (*pars)["fracErrorHigh"] = f.getAsymErrorHi(); (*pars)["fracErrorLow" ] = f.getAsymErrorLo(); } // 9) plot HistToFit.plotOn(frame,DataError(RooAbsData::SumW2)); PdfModel.plotOn(frame, LineColor(kBlack)); PdfModel.plotOn(frame, Components(PdfBkg),LineColor(kRed)); PdfModel.plotOn(frame, Components(PdfSig),LineColor(kBlue),LineStyle(kDashed)); TCanvas *c=new TCanvas((string(name)+"_canvas").c_str(),"Canvas"); c->cd(); c->Draw(); frame->Draw(); TLatex* txt = new TLatex();//Form("Fraction=%.1f\%",f.getVal()*100) ; txt->SetTextSize(0.03) ; txt->SetTextColor(kBlack) ; txt->SetNDC(); txt->SetTextAlign(22); //txt->AddText(Form("Fraction=%.1f\%",f.getVal()*100) ); txt->DrawLatex(.3,.85,Form("Fraction=%.1f%%",float(f.getVal()*100))); // get pt from name { size_t n = name.find("pt"); float ptmin = -1; float ptmax = -1; if (n != string::npos) { string pts = ""; //name[n+0] == 'p' //name[n+1] =='t' n +=2; //all string are null terminated in C/C++ while ( name[n] != '_' and name[n] != '\0' ) { pts+=name[n]; ++n;} ptmin = atof( pts.c_str() ) ; pts=""; ++n; while ( name[n] != '_' and name[n] != '\0' ) { pts+=name[n]; ++n;} ptmax = atof( pts.c_str() ) ; txt->DrawLatex(.3,.82,Form("%.1f<P_{T}<%.1f",ptmin,ptmax)); } } // end get pt from name if ( outname != "") { TFile *fOut=TFile::Open(outname.c_str(),"UPDATE"); fOut->cd(); c->Write(); for( auto c : cbkgs ) c->Write(); r->Write(Form("%s_roofit",name.c_str() ) ); fOut->Close(); } // delete the clone for( auto c : cbkgs ) c->Delete(); cbkgs.clear(); sig -> Delete(); bkg -> Delete(); h -> Delete(); return f.getVal(); }
TH1 * YieldMean(TH1 *hstat, TH1 *hsys, TF1 *f = NULL, Double_t min = 0., Double_t max = 10., Double_t loprecision = 0.01, Double_t hiprecision = 0.1, Option_t *opt = "0q",TString logfilename="log.root",Double_t minfit=0.0,Double_t maxfit=10.0) { if(maxfit>max) max=maxfit; if(minfit<min) min=minfit; /* set many iterations when fitting the data so we don't stop minimization with MAX_CALLS */ TVirtualFitter::SetMaxIterations(1000000); /* create output histo */ Double_t integral, mean, extra; TH1 *hout = new TH1D("hout", "", 9, 0, 9); TH1 *hlo, *hhi; /* create histo with stat+sys errors */ TH1 *htot = (TH1 *)hstat->Clone(Form("%sfittedwith%s",hstat->GetName(),f->GetName())); for (Int_t ibin = 0; ibin < htot->GetNbinsX(); ibin++) { htot->SetBinError(ibin + 1, TMath::Sqrt(hsys->GetBinError(ibin + 1) * hsys->GetBinError(ibin + 1) + hstat->GetBinError(ibin + 1) * hstat->GetBinError(ibin + 1))); } /* * measure the central value */ Int_t fitres; Int_t trials = 0; trials = 0; do { fitres = htot->Fit(f, opt,"",minfit,maxfit); Printf("Trial: %d", trials++); if(trials > 10) { Printf("FIT DOES NOT CONVERGE IN LINE %d",__LINE__); break; } } while (fitres != 0); TFile* filewithfits=TFile::Open(logfilename.Data(),"UPDATE"); htot->Write(); filewithfits->Close(); delete filewithfits; cout<<" Fit sys+stat for " <<f->GetName()<<endl; cout<<"NDF="<<f->GetNDF()<<" Chi^2="<<f->GetChisquare()<<" Chi^2/NDF="<<f->GetChisquare()/f->GetNDF()<<endl; hlo = YieldMean_LowExtrapolationHisto(htot, f, min, loprecision); hhi = YieldMean_HighExtrapolationHisto(htot, f, max, hiprecision); YieldMean_IntegralMean(htot, hlo, hhi, integral, mean, extra, kTRUE); hout->SetBinContent(kYield, integral); hout->SetBinContent(kMean, mean); hout->SetBinContent(kExtra, extra); /* * STATISTICS */ TCanvas *cCanvasStat = new TCanvas("cCanvasStat"); cCanvasStat->Divide(2, 1); /* * measure statistical error */ /* fit with stat error */ trials = 0; do { fitres = hstat->Fit(f, opt,"",minfit,maxfit); Printf("Trial: %d", trials++); if(trials > 10) { Printf("FIT DOES NOT CONVERGE IN LINE %d",__LINE__); break; } } while (fitres != 0); hlo = YieldMean_LowExtrapolationHisto(hstat, f, min, loprecision); hhi = YieldMean_HighExtrapolationHisto(hstat, f, max, hiprecision); /* random generation with integration (coarse) */ TH1 *hIntegral_tmp = new TH1F("hIntegral_tmp", "", 1000, 0.75 * integral, 1.25 * integral); TH1 *hMean_tmp = new TH1F("hMean_tmp", "", 1000, 0.75 * mean, 1.25 * mean); for (Int_t irnd = 0; irnd < 100; irnd++) { /* get random histogram */ TH1 *hrnd = YieldMean_ReturnRandom(hstat); /* fit */ TH1 *hrndlo = YieldMean_ReturnCoherentRandom(hlo); TH1 *hrndhi = YieldMean_ReturnCoherentRandom(hhi); /* integrate */ YieldMean_IntegralMean(hrnd, hrndlo, hrndhi, integral, mean, extra); hIntegral_tmp->Fill(integral); hMean_tmp->Fill(mean); delete hrnd; delete hrndlo; delete hrndhi; } /* random generation with integration (fine) */ TH1 *hIntegral = new TH1F("hIntegral", "", 100, hIntegral_tmp->GetMean() - 10. * hIntegral_tmp->GetRMS(), hIntegral_tmp->GetMean() + 10. * hIntegral_tmp->GetRMS()); TH1 *hMean = new TH1F("hMean", "", 100, hMean_tmp->GetMean() - 10. * hMean_tmp->GetRMS(), hMean_tmp->GetMean() + 10. * hMean_tmp->GetRMS()); for (Int_t irnd = 0; irnd < 1000; irnd++) { /* get random histogram */ TH1 *hrnd = YieldMean_ReturnRandom(hstat); /* fit */ TH1 *hrndlo = YieldMean_ReturnCoherentRandom(hlo); TH1 *hrndhi = YieldMean_ReturnCoherentRandom(hhi); /* integrate */ YieldMean_IntegralMean(hrnd, hrndlo, hrndhi, integral, mean, extra); hIntegral->Fill(integral); hMean->Fill(mean); delete hrnd; delete hrndlo; delete hrndhi; } TF1 *gaus = (TF1 *)gROOT->GetFunction("gaus"); cCanvasStat->cd(1); hIntegral->Fit(gaus, "q"); integral = hout->GetBinContent(kYield) * gaus->GetParameter(2) / gaus->GetParameter(1); hout->SetBinContent(kYieldStat, integral); cCanvasStat->cd(2); hMean->Fit(gaus, "q"); mean = hout->GetBinContent(kMean) * gaus->GetParameter(2) / gaus->GetParameter(1); hout->SetBinContent(kMeanStat, mean); /* * SYSTEMATICS */ TCanvas *cCanvasSys = new TCanvas("cCanvasYieldSys"); cCanvasSys->Divide(2, 1); cCanvasSys->cd(1)->DrawFrame(min, 1.e-3, max, 1.e3); hsys->SetMarkerStyle(20); hsys->SetMarkerColor(1); hsys->SetMarkerSize(1); hsys->Draw("same"); cCanvasSys->cd(2)->DrawFrame(min, 1.e-3, max, 1.e3); hsys->Draw("same"); /* * systematic error high */ TH1 *hhigh = YieldMean_ReturnExtremeHighHisto(hsys); trials = 0; do { fitres = hhigh->Fit(f, opt,"",minfit,maxfit); Printf("Trial: %d", trials++); if(trials > 10) { Printf("FIT DOES NOT CONVERGE IN LINE %d",__LINE__); break; } } while (fitres != 0); hlo = YieldMean_LowExtrapolationHisto(hhigh, f, min, loprecision); hhi = YieldMean_HighExtrapolationHisto(hhigh, f, max, hiprecision); YieldMean_IntegralMean(hhigh, hlo, hhi, integral, mean, extra); integral = TMath::Abs(integral - hout->GetBinContent(kYield)); hout->SetBinContent(kYieldSysHi, integral); cCanvasSys->cd(1); f->SetLineColor(2); f->DrawCopy("same"); /* * systematic error hard */ TH1 *hhard = YieldMean_ReturnExtremeHardHisto(hsys); trials = 0; do { fitres = hhard->Fit(f, opt,"",minfit,maxfit); Printf("Trial: %d", trials++); if(trials > 10) { Printf("FIT DOES NOT CONVERGE IN LINE %d",__LINE__); break; } } while (fitres != 0); hlo = YieldMean_LowExtrapolationHisto(hhard, f, min, loprecision); hhi = YieldMean_HighExtrapolationHisto(hhard, f, max, hiprecision); YieldMean_IntegralMean(hhard, hlo, hhi, integral, mean, extra); mean = TMath::Abs(mean - hout->GetBinContent(kMean)); hout->SetBinContent(kMeanSysHi, mean); cCanvasSys->cd(2); f->SetLineColor(2); f->DrawCopy("same"); /* * systematic error low */ TH1 *hlow = YieldMean_ReturnExtremeLowHisto(hsys); trials = 0; do { fitres = hlow->Fit(f, opt,"",minfit,maxfit); Printf("Trial: %d", trials++); if(trials > 10) { Printf("FIT DOES NOT CONVERGE IN LINE %d",__LINE__); break; } } while (fitres != 0); hlo = YieldMean_LowExtrapolationHisto(hlow, f, min, loprecision); hhi = YieldMean_HighExtrapolationHisto(hlow, f, max, hiprecision); YieldMean_IntegralMean(hlow, hlo, hhi, integral, mean, extra); integral = TMath::Abs(integral - hout->GetBinContent(kYield)); hout->SetBinContent(kYieldSysLo, integral); cCanvasSys->cd(1); f->SetLineColor(4); f->DrawCopy("same"); /* * systematic error soft */ TH1 *hsoft = YieldMean_ReturnExtremeSoftHisto(hsys); trials = 0; do { fitres = hsoft->Fit(f, opt,"",minfit,maxfit); Printf("Trial: %d", trials++); if(trials > 10) { Printf("FIT DOES NOT CONVERGE IN LINE %d",__LINE__); break; } } while (fitres != 0); hlo = YieldMean_LowExtrapolationHisto(hsoft, f, min, loprecision); hhi = YieldMean_HighExtrapolationHisto(hsoft, f, max, hiprecision); YieldMean_IntegralMean(hsoft, hlo, hhi, integral, mean, extra); mean = TMath::Abs(mean - hout->GetBinContent(kMean)); hout->SetBinContent(kMeanSysLo, mean); cCanvasSys->cd(2); f->SetLineColor(4); f->DrawCopy("same"); return hout; }
//______________________________________________________________________________ void CalibrateFit(Int_t nPar, Double_t time_limit, Double_t bad_frac) { // Calibrate using iterative fitting. const Double_t convergence_factor = 0.05; // iterate calibrations for (Int_t i = 0; i >= 0; i++) { // create new histogram TH2* h = CreateHisto("fit_histo", nPar, gOff); // user info printf("Calibration iteration %d\n", i+1); // loop over elements Int_t n = 0; Int_t outside_n = 0; for (Int_t j = 0; j < nPar; j++) { // create projection TH1* hProj = (TH1*) h->ProjectionX(TString::Format("Proj_%d", j).Data(), j+1, j+1, "e"); // check for filled histograms if (hProj->GetEntries()) { // create fitting function TF1* func = new TF1(TString::Format("Func_%d", j).Data(), "gaus", -5, 5); func->SetParameter(0, 1); func->SetParameter(1, hProj->GetXaxis()->GetBinCenter(hProj->GetMaximumBin())); func->SetParameter(2, 0.1); // fit histogram hProj->GetXaxis()->SetRangeUser(-5, 5); hProj->Fit(func, "0Q"); Double_t mean = func->GetParameter(1); // update offset gOff[j] = gOff[j] + convergence_factor * mean / gGain[j]; n++; if (TMath::Abs(mean) > time_limit) outside_n++; // clean-up delete func; } // clean-up delete hProj; } // clean-up delete h; // user info Double_t outside_frac = (Double_t)outside_n/(Double_t)n; printf("Element outside limits: %.1f%%\n", outside_frac*100.); if (outside_frac < bad_frac) break; } }
//______________________________________________________________________________ void CheckTime(const Char_t* loc) { // Check time. Char_t t[256]; // number of runs Int_t nRuns = gFiles->GetSize(); // create arrays const Int_t nCh = 352; Double_t** pedPos = new Double_t*[nCh]; Double_t* runNumbersD = new Double_t[nRuns]; for (Int_t i = 0; i < nCh; i++) pedPos[i] = new Double_t[nRuns]; // open the output files TFile* fROOTout = new TFile("/tmp/tagger_time.root", "RECREATE"); // create directories for (Int_t i = 0; i < nCh; i++) { sprintf(t, "%03d", i); fROOTout->mkdir(t); } TF1* func = new TF1("func", "gaus(0)+pol1(3)", -1000 , 1000); // loop over runs for (Int_t i = 0; i < nRuns; i++) { // get the file TFile* f = (TFile*) gFiles->At(i); // extract run number Int_t runNumber; sprintf(t, "%s/ARHistograms_CB_%%d.root", loc); sscanf(f->GetName(), t, &runNumber); runNumbersD[i] = (Double_t)runNumber; printf("Processing run %d (%d/%d)\n", runNumber, i+1, nRuns); fROOTout->cd(); TH2* h2 = (TH2*) f->Get("CaLib_Tagger_Time"); // loop over channels for (Int_t j = 0; j < nCh; j++) { // load histogram sprintf(t, "%03d", j); fROOTout->cd(t); sprintf(t, "%d_%d", i, j); TH1* h = h2->ProjectionX(t, j+1, j+1); h->Rebin(2); sprintf(t, "Run_%d", runNumber); TCanvas* c = new TCanvas(t, t); TLine* tline = 0; // check entries if (h->GetEntries()) { // fit gaussian to peak Double_t maxPos = h->GetXaxis()->GetBinCenter(h->GetMaximumBin()); func->SetParameters(1, maxPos, 0.5, 1, 0.1); func->SetRange(maxPos - 2, maxPos + 2); func->SetParLimits(0, 0, 1000); for (Int_t k = 0; k < 10; k++) if (!h->Fit(func, "RBQ")) break; // save position in file and memory maxPos = func->GetParameter(1); pedPos[j][i] = maxPos; h->GetXaxis()->SetRangeUser(maxPos - 10, maxPos + 10); h->Draw(); tline = new TLine(maxPos, 0, maxPos, 10000); tline->SetLineColor(kRed); tline->SetLineWidth(2); tline->Draw(); } else { h->Draw(); } c->Write(c->GetName(), TObject::kOverwrite); delete h; delete c; if (tline) delete tline; } delete h2; } // create pedestal evolution graphs fROOTout->cd(); // loop over channels for (Int_t j = 0; j < nCh; j++) { printf("Creating time graph for channel %d\n", j); TGraph* g = new TGraph(nRuns, runNumbersD, pedPos[j]); sprintf(t, "Overview_%03d", j); g->SetName(t); g->SetTitle(t); //g->GetYaxis()->SetRangeUser(1200, 1300); g->Write(g->GetName(), TObject::kOverwrite); delete g; } printf("Saving output file\n"); delete fROOTout; // cleanup for (Int_t i = 0; i < nCh; i++) delete [] pedPos[i]; delete [] pedPos; delete [] runNumbersD; }
void AnalyzeData(char *DataFile = "drs4_peds_5buffers.dat", Int_t nevt, Int_t startEv = 1, char *PedFile, Int_t DrawExtraGraphs = 0) { // Redefine DOMINO Depth in ADC counts const Float_t DominoDepthADC = pow(2, DOMINO_DEPTH); // open file FILE *fdata = OpenDataFile(DataFile); struct channel_struct *p; struct channel_struct *dep; // create histograms // create list of histograms for channels and distribution TList *DistChList = new TList(); TH1F *distch; // histo with distribution of cell-charge, for each channel TList *DistChSubList = new TList(); TH1F *distchsub; // histo with distribution of cell-charge, pedestals subtracted, for each channel TList *DistCh0SubList = new TList(); TH1F *distch0sub; // histo with distribution of cell-charge, pedestals subtracted, // channel 0 subtracted for each channel TList *grPedList = new TList(); TGraphErrors *grPed; // for each channel, pedestal value and RMS for each cell is plotted TList *hCellList = new TList(); TH1F *hCell; // charge distribution for each cell (DOMINO_NCELL x DOMINO_NCH histos) TList *hCellSubList = new TList(); TH1F *hCellSub; // charge distribution for each cell (DOMINO_NCELL x DOMINO_NCH histos), pedestal subtracted TList *hRMSList = new TList(); TH1F *hRMSdist; // histo with RMS distribution (statistical RMS of distribution) TList *hRMSFitList = new TList(); TH1F *hRMSFitdist; // histo with RMS distribution (RMS of Gaussian fit) TList *grDataList = new TList(); TGraphErrors *grData; // charge-cell and RMS for each cell is plotted TList *grDataSubList = new TList(); TGraphErrors *grDataSub; // pedestal subtracted charge-cell and RMS for each cell is plotted for (int h = 0; h < DOMINO_NCH; h++) { // TString title = "Data Dist channel"; title += h; distch = new TH1F(title, title, DominoDepthADC, 0., DominoDepthADC); DistChList->Add(distch); // TString title = "Data Dist Ped Sub channel"; title += h; distchsub = new TH1F(title, title, DominoDepthADC, -DominoDepthADC/2, DominoDepthADC/2); DistChSubList->Add(distchsub); // TString title = "Data Dist Ped Ch0 Sub channel"; title += h; distch0sub = new TH1F(title, title, DominoDepthADC, -DominoDepthADC/2, DominoDepthADC/2); DistCh0SubList->Add(distch0sub); // TString title = "Pedestal ch"; title += h; grPed = new TGraphErrors(DOMINO_NCELL); grPed->SetTitle(title); grPedList->Add(grPed); // TString title = "Data ch"; title += h; grData = new TGraphErrors(DOMINO_NCELL); grData->SetTitle(title); grDataList->Add(grData); // // Mean data and RMS for each channel and cell TString title = "Data PedSubtracted ch"; title += h; grDataSub = new TGraphErrors(DOMINO_NCELL); grDataSub->SetTitle(title); grDataSubList->Add(grDataSub); // for (int ch = 0; ch < DOMINO_NCELL; ch++) { // data distribution histos TString title = "Data ch"; title += h; title += " cell"; title += ch; hCell = new TH1F(title, title, DominoDepthADC, 0., DominoDepthADC); hCellList->Add(hCell); // data (ped subtracted) distribution histos TString title = "Data PedSub ch"; title += h; title += " cell "; title += ch; hCellSub = new TH1F(title, title, 2 * DominoDepthADC, -1 * DominoDepthADC, DominoDepthADC); hCellSubList->Add(hCellSub); } // Data-RMS distribution histos TString title = "RMSDist channel"; title += h; hRMSdist = new TH1F(title, title, 100, 0, 20.); hRMSList->Add(hRMSdist); // Data-RMS (calculated through a fit) distribution histos TString title = "RMSFitDist channel"; title += h; hRMSFitdist = new TH1F(title, title, 100, 0, 20.); hRMSFitList->Add(hRMSFitdist); } //-------------- // // calculate or read pedestals from file grPedList = OpenPedestals(PedFile); // return; // // ====== Read data file and subtract the pedestals // // Count number of events in data file int nevtDataMax = 0; while (!feof(fdata)) { fread((void *) &event_data, 1, sizeof(event_data), fdata); nevtDataMax++; } printf("nevtDataMax: %d\n", nevtDataMax); if (nevt > (nevtDataMax - startEv) || nevt == 0) nevt = nevtDataMax - startEv; cout << endl << "==>> Processing " << nevt << " events from file " << DataFile << endl; rewind(fdata); Int_t ievt = 1; // go to first event (startEv) while (ievt < startEv) { fread((void *) &event_data, 1, sizeof(event_data), fdata); if (feof(fdata)) break; ievt++; } // filling ievt = 1; Int_t flagEnd = 0; Double_t chtmp; Double_t PedVal, itmp, Ch0Val; // loop on events cout << endl << " --- read DATA file:" << fdata << endl; while (ievt <= nevt && !flagEnd) { fread((void *) &event_data, 1, sizeof(event_data), fdata); if (feof(fdata)) flagEnd = 1; if (ievt % (nevt / 10 + 1) == 0) cout << "*" << endl; p = (struct channel_struct *) &event_data.ch[0]; // read bunch of data dep = (struct channel_struct *) &event_data.ch[1]; // read bunch of data TGraphErrors *grCh0 = new TGraphErrors(DOMINO_NCELL); // loop on channels for (int h = 0; h < DOMINO_NCH; h++) { // loop on cells distch = (TH1F *) DistChList->At(h); distchsub = (TH1F *) DistChSubList->At(h); grPed = (TGraphErrors *) grPedList->At(h); distch0sub = (TH1F *) DistCh0SubList->At(h); if(h==0) { for(i = 0; i < DOMINO_NCELL;i++) { grPed->GetPoint(i, itmp, PedVal); chtmp = (Double_t)(p->data[i]); chtmp = chtmp - PedVal; grCh0->SetPoint(i,itmp, chtmp); } } for (int i = 0; i < DOMINO_NCELL; i++) { // Read pedestal value for this cell grPed->GetPoint(i, itmp, PedVal); grCh0->GetPoint(i, itmp, Ch0Val); // cout << itmp << ", " << PedVal << endl; // Read calibration correction for this cell // CalFact = //charge distribution for each cell, pedestal subtracted chtmp = (Double_t)(p->data[i]); // data value // cout << "tcell, tcell, depth: " << chtmp << "," << p->data[i] << "," << deptmp << endl; distch->Fill(chtmp); // Check data value: must be within DOMINO Depth // if(chtmp > DominoDepthADC) // cout << " === WARNING!!! Channel " << h << " Cell " << i << " has value " << chtmp << endl; // cout << "Charge: " << p->data[i] << endl; ((TH1 *) hCellList->At(h * DOMINO_NCELL + i))->Fill(chtmp); // Now the pedestal is subtracted chtmp = chtmp - PedVal; distchsub->Fill(chtmp); ((TH1 *) hCellSubList->At(h * DOMINO_NCELL + i))->Fill(chtmp); chtmp = chtmp - Ch0Val; distch0sub->Fill(chtmp); } p++; // next channel } ievt++; // next event } cout << endl; // now mean and RMS for each cell are computed and save in histos and graphs cout << " --- filling data histos and grphs " << endl; TF1 *fgauss = new TF1("fgauss", Gauss, -10., 10., 3); fgauss->SetParLimits(0, 0.1, 10000.); fgauss->SetParLimits(1, 0., 4096.); fgauss->SetParLimits(2, 0.1, 20.); Float_t mean, rms, meansub, rmssub; for (int h = 0; h < DOMINO_NCH; h++) { // for (int h=5; h<6; h++){ cout << " Channel:" << h << endl; hRMSdist = (TH1F *) hRMSList->At(h); hRMSFitdist = (TH1F *) hRMSFitList->At(h); grData = (TGraphErrors *) grDataList->At(h); grDataSub = (TGraphErrors *) grDataSubList->At(h); for (int ch = 0; ch < DOMINO_NCELL; ch++) { // data distribution histos // cout << "cell:" << ch << " index:" << h*DOMINO_NCELL+ch << " Mean,RMS:"<<hCell->GetMean()<< "," << hCell->GetRMS()<<endl; hCell = (TH1F *) hCellList->At(h * DOMINO_NCELL + ch); mean = hCell->GetMean(); rms = hCell->GetRMS(); hCellSub = (TH1F *) hCellSubList->At(h * DOMINO_NCELL + ch); meansub = hCellSub->GetMean(); rmssub = hCellSub->GetRMS(); fgauss->SetParameter(0, (Double_t) nevt / 4.); fgauss->SetParameter(1, mean); fgauss->SetParameter(2, rms); // hCell->Fit("fgauss","QN0"); grData->SetPoint(ch, ch, mean); grData->SetPointError(ch, 0, rms); grDataSub->SetPoint(ch, ch, meansub); // grDataSub->SetPointError(ch,0.5,rmssub); grDataSub->SetPointError(ch, 0.5, 2.1); hRMSdist->Fill(rms); hRMSFitdist->Fill(fgauss->GetParameter(2)); // cout << "cell:" << ch << " index:" << h*DOMINO_NCELL+ch << " Mean,RMS:"<< mean << "," << rms<<endl; } } Double_t x, y, chtmp, x1, x2, y1, y2; /*TList *grCellCalibList = OpenCalibFile("CalibrationData1000events.root"); TGraphErrors *grCellCalib; TGraphErrors *grDataSubCalib = new TGraphErrors(DOMINO_NCELL); grDataSubCalib->SetTitle("Data after calibration correction"); grDataSub = (TGraphErrors *) grDataSubList->At(anaChannel); for(ch = 0; ch < DOMINO_NCELL; ch++) { grCellCalib = ((TGraphErrors *) grCellCalibList->At(ch)); grCellCalib->Fit("pol3", "Q"); TF1 *pol3fit = ((TF1 *) grCellCalib->GetFunction("pol3")); grDataSub->GetPoint(ch, x, y); chtmp = y - (Double_t)(pol3fit->Eval(y/3.25)); grDataSubCalib->SetPoint(ch, x, chtmp); } TCanvas *cGrTest = new TCanvas("grTest", "test per vedere i dati", 1000,1000); grDataSubCalib->Draw("APEL");*/ TString Title = "Charge Distribution per channel"; gStyle->SetOptFit(111); TCanvas *cdistch = new TCanvas("cdistch", Title, 1000, 1000); cdistch->Divide(3, 3); for (int i = 0; i < DOMINO_NCH; i++) { cdistch->cd(i + 1); TH1 *dhist = (TH1 *) DistChList->At(i); dhist->DrawCopy(); dhist->SetLineWidth(1); dhist->Fit("gaus", "Q"); dhist->GetFunction("gaus")->SetLineColor(4); dhist->GetFunction("gaus")->SetLineWidth(2); } TString Title = "Charge Distribution Pedestals Subtracted per channel"; TCanvas *cdistchsub = new TCanvas("cdistchsub", Title, 1000, 1000); cdistchsub->Divide(3, 3); for (int i = 0; i < DOMINO_NCH; i++) { cdistchsub->cd(i + 1); TH1 *dsubhist = (TH1 *) DistChSubList->At(i); dsubhist->DrawCopy(); dsubhist->SetLineWidth(1); dsubhist->Fit("gaus", "Q"); dsubhist->GetFunction("gaus")->SetLineColor(4); dsubhist->GetFunction("gaus")->SetLineWidth(2); } TString Title = "Charge Distribution Pedestals and Ch0 Subtracted per channel"; TCanvas *cdistch0sub = new TCanvas("cdistch0sub", Title, 1000, 1000); cdistch0sub->Divide(3, 3); for (int i = 0; i < DOMINO_NCH; i++) { cdistch0sub->cd(i + 1); TH1 *dch0subhist = (TH1 *) DistCh0SubList->At(i); dch0subhist->DrawCopy(); dch0subhist->SetLineWidth(1); dch0subhist->Fit("gaus", "Q"); dch0subhist->GetFunction("gaus")->SetLineColor(4); dch0subhist->GetFunction("gaus")->SetLineWidth(2); } TCanvas *cDataSubTest = new TCanvas("cDataSubTest", "Data after pedestal subtraction", 1000, 1000); cDataSubTest->Divide(1,8); for (h = 0; h< DOMINO_NCH; h++) { grDataSub = (TGraphErrors *) grDataSubList->At(h); cDataSubTest->cd(h+1); grDataSub->GetYaxis()->SetLabelSize(0.06); grDataSub->GetXaxis()->SetLabelSize(0.06); grDataSub->Draw("APE"); } TCanvas *cDataSubTestCh5 = new TCanvas("cDataSubTestCh5", "Data after pedestal subtraction Ch5", 1200, 800); grDataSub = (TGraphErrors *) grDataSubList->At(anaChannel); grDataSub->GetYaxis()->SetLabelSize(0.06); grDataSub->GetYaxis()->SetTitle("ADC Counts"); grDataSub->GetXaxis()->SetTitle("Cell"); grDataSub->GetXaxis()->SetLabelSize(0.06); TLine *refval = new TLine(0,350,1024,350); refval->SetLineWidth(3); refval->SetLineStyle(2); refval->SetLineColor(2); TLine *i1 = new TLine(121,-50,121,800); i1->SetLineStyle(2); TLine *i2 = new TLine(291,-50,291,800); i2->SetLineStyle(2); TLine *i3 = new TLine(461,-50,461,800); i3->SetLineStyle(2); TLine *i4 = new TLine(632,-50,632,800); i4->SetLineStyle(2); TLine *i5 = new TLine(803,-50,803,800); i5->SetLineStyle(2); TLine *i6 = new TLine(975,-50,975,800); i6->SetLineStyle(2); TLine *ireal1 = new TLine(121+20,600,121+20,800); ireal1->SetLineWidth(3); ireal1->SetLineColor(4); TLine *ireal2 = new TLine(291-20,600,291-20,800); ireal2->SetLineWidth(3); ireal2->SetLineColor(4); TLine *ireal3 = new TLine(461+20,600,461+20,800); ireal3->SetLineWidth(3); ireal3->SetLineColor(4); TLine *ireal4 = new TLine(632-20,600,632-20,800); ireal4->SetLineWidth(3); ireal4->SetLineColor(4); TLine *ireal5 = new TLine(803+20,600,803+20,800); ireal5->SetLineWidth(3); ireal5->SetLineColor(4); TLine *ireal6 = new TLine(975-20,600,975-20,800); ireal6->SetLineWidth(3); ireal6->SetLineColor(4); grDataSub->Draw("APE"); refval->Draw("SAME"); i1->Draw("SAME"); i2->Draw("SAME"); i3->Draw("SAME"); i4->Draw("SAME"); i5->Draw("SAME"); i6->Draw("SAME"); ireal1->Draw("SAME"); ireal2->Draw("SAME"); ireal3->Draw("SAME"); ireal4->Draw("SAME"); ireal5->Draw("SAME"); ireal6->Draw("SAME"); TCanvas *cDataTest = new TCanvas("cDataTest", "Raw Data", 1000,1000); cDataTest->Divide(1,8); for(h = 0; h < DOMINO_NCH; h++) { cDataTest->cd(h+1); grData = (TGraphErrors *) grDataList->At(h); grData->SetMarkerStyle(20); grData->SetMarkerSize(0.5); grData->Draw("APE"); } // save root file with graph containing channel 5 data after pedestals subtraction. /* cout << "test" << endl; TString OutFile = DataSubFile; TFile *f = new TFile(OutFile,"RECREATE"); int h = anaChannel; TString key="DataSubGraph"; key += h; ((TGraphErrors*)grDataSubList->At(h))->Write(key); f->Close(); cout << " ---- Write data on file " << endl; */ // =======================================================// // =====================Matteo's Code=====================// // =======================================================// /* Int_t cht, incCht, decCht, xflag, nPeriods, iMax, iMin; Double_t xdiff, incDiff, decDiff, incDiffTemp, decDiffTemp, incXDiff, decXDiff; Double_t fitMax, fitMin, fitPeriod, chisquare; Double_t DominoXval[DOMINO_NCELL]; Double_t DominoYval[DOMINO_NCELL]; Double_t FitXval[DOMINO_NCELL]; Double_t FitYval[DOMINO_NCELL]; // opens grDataSub.root TString FileName = DataSubFile; TGraphErrors *grDataSub; int h = anaChannel; TFile *f = new TFile(FileName); TString key = "DataSubGraph"; key += h; grDataSub = (TGraphErrors *) f->Get(key); f->Close(); // Create a new graph with channel 5 data TGraphErrors *grDataSubAnaCh; int h = anaChannel; grDataSubAnaCh = (TGraphErrors *) grDataSubList->At(h); TGraphErrors *grDataSubFix = grDataSubAnaCh->Clone(); TGraphErrors *grRes = new TGraphErrors(DOMINO_NCELL); TList *grResPeriodList = new TList(); Double_t xtemp, ytemp, DominoMax, DominoMin; for (int ch = 0; ch < DOMINO_NCELL; ch++){ // get domino-output point and save in array grDataSubAnaCh->GetPoint(ch, DominoXval[ch], DominoYval[ch]); } // find the domino point with max y-value iMax = 0; for(int ch = 0; ch < DOMINO_NCELL; ch++) { if(DominoYval[ch] > DominoYval[iMax]) { DominoMax = DominoYval[ch]; iMax = ch; } } cout << "DominoMax e': " << DominoMax << endl; // find the domino point with min y-value iMin = 0; for (int ch = 0; ch < DOMINO_NCELL; ch++) { if(DominoYval[ch] < DominoYval[iMin]) { DominoMin = DominoYval[ch]; iMin = ch; } } cout << "DominoMin e': " << DominoMin << endl; // remove points from the graph that will be used for fit for (int ch = 0; ch < DOMINO_NCELL; ch++){ grDataSubFix->GetPoint(ch, xtemp, ytemp); if(ytemp > 0.8*DominoMax || ytemp < 0.2*DominoMin) grDataSubFix->RemovePoint(ch); } TF1 *fsin = new TF1("fsin", sigSin, 0., 1024., 4); fsin->SetParameters(600., DOMINO_NCELL / 4., 150., 150.); fsin->SetParNames("amplitude", "Period", "Phase", "DC-Offset"); grDataSubFix->Fit("fsin"); TF1 *fsinFit = grDataSubFix->GetFunction("fsin"); fsinFit->SetParNames("amplitude", "Period", "Phase", "DC-Offset"); chisquare = grDataSub->Chisquare(fsinFit); cout << "il chi quadro della funzione di fit e' : " << chisquare << endl; for (int ch = 0; ch < DOMINO_NCELL; ch++) { // get Fit-value and save in array FitXval[ch] = DominoXval[ch]; FitYval[ch] = fsinFit->Eval(FitXval[ch]); } fitPeriod = fsinFit->GetParameter("Period"); cout << "il periodo della funzione e': " << fitPeriod << endl; nPeriods = (Int_t) (DOMINO_NCELL/fitPeriod); cout << "il numero di periodi della funzione e': " << nPeriods << endl; fitMax = fsinFit->GetMaximum(); cout << "il massimo della funzione e': " << fitMax << endl; fitMin = fsinFit->GetMinimum(); cout << "il minimo della funzione e': " << fitMin << endl; // computes the y difference between the ch-domino point and the i-fit point // and stops when the difference changes sign // // first and last points are not included in the cicle // // if the fit point y-value is bigger or smaller than the fit function max*0.8 or min*0.2 // the point is removed for (int ch = 1; ch < DOMINO_NCELL - 1; ch++) { if(FitYval[ch] > 0.8*fitMax || FitYval[ch] < 0.2*fitMin) { grRes->RemovePoint(ch); continue; } incDiff = DominoYval[ch] - FitYval[ch]; incDiffTemp = DominoYval[ch] - FitYval[ch + 1]; decDiff = DominoYval[ch] - FitYval[ch]; decDiffTemp = DominoYval[ch] - FitYval[ch - 1]; if(abs(incDiffTemp) < abs(incDiff) || (sign(incDiff) != sign(incDiffTemp) && abs(decDiffTemp) > abs(decDiff))) { for (int i = ch; i < DOMINO_NCELL; i++, incDiff = incDiffTemp) { incDiffTemp = DominoYval[ch] - FitYval[i]; if (sign(incDiff) != sign(incDiffTemp)) { if(abs(incDiffTemp) < abs(incDiff)) incCht = i; else incCht = i - 1; break; } } xflag = 1; } else if(abs(decDiffTemp) < abs(decDiff) || (sign(decDiff) != sign(decDiffTemp) && abs(incDiffTemp) > abs(incDiff))) { for (int j = ch; j >= 0 ; j--, decDiff = decDiffTemp) { decDiffTemp = DominoYval[ch] - FitYval[j]; if (sign(decDiff) != sign(decDiffTemp)) { if(abs(decDiffTemp) < abs(decDiff)) decCht = j; else decCht = j + 1; break; } } xflag = -1; } if(xflag == 1) xdiff = FitXval[incCht] - DominoXval[ch]; else xdiff = FitXval[decCht] - DominoXval[ch]; grRes->SetPoint(ch, (Double_t) ch, xdiff); } cout << "Draw Time Residuals" << endl; TString Title = "Time Residuals"; TCanvas *timeres = new TCanvas("timeres", Title, 1200, 780); grRes->SetMarkerStyle(20); grRes->SetMarkerSize(0.3); grRes->GetYaxis()->SetLabelSize(0.12); grRes->GetXaxis()->SetLabelSize(0.12); grRes->Draw("APE"); // The previous graph is now split in N graphs, where N is the number of fit periods // this will be needed to set the function phase // // iMax = 0; // // for(ch = 0; ch < fitPeriod - 1; ch++) { // if(FitYval[ch] > FitYval[iMax]) iMax = ch; // } cout << "il primo massimo ha l'indice : " << iMax << endl; for (i = 0; i < nPeriods; i++) { TGraphErrors *grResPeriod = new TGraphErrors((Int_t) fitPeriod); grResPeriodList->Add(grResPeriod); for(ch = i*fitPeriod + 1; ch < fitPeriod + (i*fitPeriod); ch++) { if(FitYval[ch] > 0.8*fitMax || FitYval[ch] < 0.2*fitMin) { grResPeriod->RemovePoint(ch); continue; } incDiff = DominoYval[ch] - FitYval[ch]; incDiffTemp = DominoYval[ch] - FitYval[ch + 1]; decDiff = DominoYval[ch] - FitYval[ch]; decDiffTemp = DominoYval[ch] - FitYval[ch - 1]; if(abs(incDiffTemp) < abs(incDiff) || (sign(incDiff) != sign(incDiffTemp) && abs(decDiffTemp) > abs(decDiff))) { for (int k = ch; k < k*fitPeriod + fitPeriod; k++, incDiff = incDiffTemp) { incDiffTemp = DominoYval[ch] - FitYval[k]; if (sign(incDiff) != sign(incDiffTemp)) { if(abs(incDiffTemp) < abs(incDiff)) incCht = k; else incCht = k - 1; break; } } xflag = 1; } else if(abs(decDiffTemp) < abs(decDiff) || (sign(decDiff) != sign(decDiffTemp) && abs(incDiffTemp) > abs(incDiff))) { for (int j = ch; j > i*fitPeriod; j--, decDiff = decDiffTemp) { decDiffTemp = DominoYval[ch] - FitYval[j]; if (sign(decDiff) != sign(decDiffTemp)) { if(abs(decDiffTemp) < abs(decDiff)) decCht = j; else decCht = j + 1; break; } } xflag = -1; } if(xflag == 1) xdiff = FitXval[incCht] - DominoXval[ch]; else xdiff = FitXval[decCht] - DominoXval[ch]; grResPeriod->SetPoint(ch - i*fitPeriod, (Double_t) (ch - i*fitPeriod), xdiff); } } TCanvas *timeresperiod = new TCanvas("timeresperiod", "Time Residuals Period", 1200, 780); for(i = 0; i < nPeriods; i++) { grResPeriod = ((TGraphErrors *) grResPeriodList->At(i)); grResPeriod->SetMarkerStyle(20); grResPeriod->SetMarkerSize(0.3); grResPeriod->GetYaxis()->SetLabelSize(0.12); grResPeriod->GetXaxis()->SetLabelSize(0.12); grResPeriod->Draw("APEsame"); } cout << "Draw Data - Pedestals Subtracted" << endl; TString Title = "Average Charge - Pedestal subtracted"; TCanvas *csubdata = new TCanvas("csubdata", Title, 1200, 780); grDataSubAnaCh->SetMarkerStyle(20); grDataSubAnaCh->SetMarkerSize(0.3); grDataSubAnaCh->GetYaxis()->SetLabelSize(0.12); grDataSubAnaCh->GetXaxis()->SetLabelSize(0.12); grDataSubAnaCh->Draw("APE"); fsinFit->Draw("same"); */ // draw extra graphs if (DrawExtraGraphs == 1) { cout << " ----- DRAW Results ------" << endl; //================ DRAW Results ================== TCanvas *c = new TCanvas("ctmp", "test", 800, 800); c->Divide(3, 3); for (int pad = 1; pad < 10; pad++) { c->cd(pad); ((TH1 *) hCellList->At(pad * 512 + 219))->DrawCopy(); hCellSub = (TH1F *) hCellSubList->At(pad * 512 + 219); hCellSub->SetLineColor(2); hCellSub->DrawCopy("same"); } cout << "Draw RMS distributions" << endl; TString Title = "RMS distributions per channel"; TCanvas *c4 = new TCanvas("c4", Title, 700, 700); c4->Divide(3, 3); for (int i = 0; i < DOMINO_NCH; i++) { c4->cd(i + 2); hRMSdist = (TH1F *) hRMSList->At(i); hRMSFitdist = (TH1F *) hRMSFitList->At(i); hRMSFitdist->SetLineColor(2); hRMSFitdist->DrawCopy(); hRMSdist->DrawCopy("same"); } TList *grDataCh0SubList = new TList(); TGraphErrors *grDataCh0Sub; for(h = 0; h< DOMINO_NCELL; h++) { grDataCh0Sub = new TGraphErrors(DOMINO_NCELL); grDataCh0SubList->Add(grDataCh0Sub); } TGraphErrors *grDataSubCh0 = (TGraphErrors *) grDataSubList->At(6); for(h = 0; h < DOMINO_NCH; h++) { grDataSub = (TGraphErrors *) grDataSubList->At(h); grDataCh0Sub = (TGraphErrors *) grDataCh0SubList->At(h); for(ch = 0; ch < DOMINO_NCELL; ch++) { grDataSubCh0->GetPoint(ch, x1, y1); grDataSub->GetPoint(ch, x2, y2); grDataCh0Sub->SetPoint(ch, x1 , y2 - y1); } } TCanvas *cDataCH0Sub = new TCanvas("cDataCH0Sub","cDataCH0Sub", 1000,1000); cDataCH0Sub->Divide(1,8); for(h = 0; h < DOMINO_NCH; h++) { cDataCH0Sub->cd(h+1); grDataCh0Sub = (TGraphErrors *) grDataCh0SubList->At(h); grDataCh0Sub->GetYaxis()->SetLabelSize(0.12); grDataCh0Sub->GetXaxis()->SetLabelSize(0.12); grDataCh0Sub->Draw("APEL"); } cout << "Draw Data - Pedestals Subtracted" << endl; TString Title = "Average Charge - Pedestal subtracted"; TCanvas *csubdata = new TCanvas("csubdata", Title, 1000, 1000); csubdata->Divide(3,3); for(h = 0; h < DOMINO_NCH; h++) { csubdata->cd(h+1); TString title = "DataSub channel "; title += h; TH1F *hCellDataSub = new TH1F(title, title, 100, -20, 20); grDataSub = (TGraphErrors *) grDataSubList->At(h); for(ch = 0; ch < DOMINO_NCELL; ch++) { grDataSub->GetPoint(ch, x, y); hCellDataSub->Fill(y); } hCellDataSub->Fit("gaus", "Q"); hCellDataSub->GetXaxis()->SetTitle("ADC Counts"); hCellDataSub->GetFunction("gaus")->SetLineColor(4); hCellDataSub->DrawCopy(); } cout << "breakpoint" << endl; TCanvas *csubdata2 = new TCanvas("csubdata2", "DataSub for every channel", 1000, 1000); TString title = "DataSub every channel "; TH1F *hCellChDataSubTot = new TH1F(title, title, 100, -20, 20); for(h = 0; h < DOMINO_NCH; h++) { grDataSub = (TGraphErrors *) grDataSubList->At(h); for(ch = 0; ch < DOMINO_NCELL; ch++) { grDataSub->GetPoint(ch, x, y); hCellChDataSubTot->Fill(y); } hCellChDataSubTot->Fit("gaus", "Q"); hCellChDataSubTot->GetXaxis()->SetTitle("ADC Counts"); hCellChDataSubTot->GetFunction("gaus")->SetLineColor(4); hCellChDataSubTot->Draw(); } cout << "Draw Pedestals" << endl; TString Title = "Pedestals"; TCanvas *c2 = new TCanvas("c2", Title, 1050, 780); c2->SetBorderMode(0); c2->SetBorderSize(0.); c2->Divide(1, 8); // gStyle->SetCanvasBorderMode(0.); // gStyle->SetCanvasBorderSize(0.); Double_t x, y; for (int h = 0; h < DOMINO_NCH; h++) { c2->cd(h + 1); grPed = ((TGraphErrors *) grPedList->At(h)); grPed->SetMarkerStyle(20); grPed->SetMarkerSize(0.5); grPed->GetYaxis()->SetLabelSize(0.12); grPed->GetXaxis()->SetLabelSize(0.12); // cout << " err:" << grPed->GetErrorY(102) << " " ; // cout << x << "--" << y << endl; grPed->Draw("APE"); } cout << "Draw Data - Average charge" << endl; TString Title = "Average_Charge"; TCanvas *cdata = new TCanvas("cdata", Title, 1050, 780); cdata->Divide(1, 8); Double_t x, y; for (int h = 0; h < DOMINO_NCH; h++) { cdata->cd(h + 1); grData = ((TGraphErrors *) grDataList->At(h)); grData->SetMarkerStyle(20); grData->SetMarkerSize(0.3); grData->GetYaxis()->SetLabelSize(0.12); grData->GetXaxis()->SetLabelSize(0.12); grData->GetPoint(10, x, y); // cout << x << "-" << y << endl; grData->Draw("APE"); } cout << "Draw Data - Pedestals Subtracted" << endl; TString Title = "Average Charge - Pedestal subtracted"; TCanvas *csubdata = new TCanvas("csubdata", Title, 1200, 780); csubdata->Divide(1, 8); TF1 *fsin = new TF1("fsin", sigSin, 0., 1024., 4); TH1D *resDist = new TH1D("resDist", "Residuals Signal", 100, -100., 100.); cout << "Draw Data - Pedestals Subtracted" << endl; TString Title = "Residuals"; TCanvas *residuals = new TCanvas("residuals", Title, 1200, 780); resDist->DrawCopy(); } fclose(fdata); hCellList->Delete(); hCellSubList->Delete(); hRMSList->Delete(); hRMSFitList->Delete(); }
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 gaus2peakfit(Char_t *s, Float_t x1, Float_t x2, Float_t x3, Float_t x4) { Double_t par[8],epar[8],x[2],y[2]; TH1 *hist; hist = (TH1 *) gROOT->FindObject(s); TCanvas *c1=(TCanvas*) gROOT->FindObject("c1"); if(c1==NULL)setcanvas(1); c1->Clear(); hist->SetAxisRange(x1-30,x4+30); hist->Draw(); //--**-- Linear background estimation --**--// x[0] = x1; x[1] = x4; Int_t bin1 = hist->FindBin(x1); y[0] = hist->GetBinContent(bin1); Int_t bin2 = hist->FindBin(x4); y[1] = hist->GetBinContent(bin2); TGraph *g = new TGraph(2,x,y); TF1 *fpol1 = new TF1("POL1","pol1",x1,x4); g->Fit(fpol1,"RQN"); par[6]=fpol1->GetParameter(0); par[7]=fpol1->GetParameter(1); //--**-- Two Gaussian Peak estimation without background --**--// fgaus1 = new TF1("m1","gaus",x1,x2); fgaus2 = new TF1("m2","gaus",x3,x4); hist->Fit(fgaus1,"R+QN"); hist->Fit(fgaus2,"R+QN"); fgaus1->GetParameters(&par[0]); fgaus2->GetParameters(&par[3]); //--**-- Final Peak Fit with Background --**--// func = new TF1("m","gaus(0)+gaus(3)+pol1(6)",x1,x4); func->SetParameters(par); hist->Fit(func,"R+QN"); func->SetLineWidth(0.5); func->SetLineStyle(1); func->SetLineColor(4); func->SetFillColor(4); func->Draw("same"); func->GetParameters(par); epar[0]=func->GetParError(0); epar[1]=func->GetParError(1); epar[2]=func->GetParError(2); epar[3]=func->GetParError(3); epar[4]=func->GetParError(4); epar[5]=func->GetParError(5); Double_t fwhm1 = par[2]*TMath::Sqrt(8*TMath::Log(2)); Double_t efwhm1 = epar[2]*TMath::Sqrt(8*TMath::Log(2)); Double_t N10 = par[0]*(TMath::Sqrt(TMath::TwoPi())*par[2]); Double_t r10 = epar[0]/par[0]; Double_t r12 = epar[2]/par[2]; Double_t eN10= N10*TMath::Sqrt(r10*r10+r12*r12); Double_t fwhm2 = par[5]*TMath::Sqrt(8*TMath::Log(2)); Double_t efwhm2 = epar[5]*TMath::Sqrt(8*TMath::Log(2)); Double_t N20 = par[3]*(TMath::Sqrt(TMath::TwoPi())*par[5]); Double_t r20 = epar[3]/par[3]; Double_t r22 = epar[5]/par[5]; Double_t eN20= N20*TMath::Sqrt(r20*r20+r22*r22); //printf("Peak = %f +- %f; FFHM = %f +- %f; Area = %f +- %f\n", // par[1],epar[1],fwhm1,efwhm1,N10,eN10); //printf("Peak = %f +- %f; FFHM = %f +- %f; Area = %f +- %f\n", // par[4],epar[4],fwhm2,efwhm2,N20,eN20); printf("%11.4f %11.4f %11.0f %11.0f\n", par[1],epar[1],N10,eN10); printf("%11.4f %11.4f %11.0f %11.0f\n", par[4],epar[4],N20,eN20); }
TH2 * ReturnCorrFromFit(TH2 *hcorr) { gStyle->SetOptStat(kFALSE); gStyle->SetOptFit(kTRUE); TObjArray *oa = new TObjArray(); hcorr->FitSlicesX(0, 0, -1, 0, "QNR", oa); TCanvas *cFit = new TCanvas("cFit", "cFit"); cFit->Divide(2, 2); TF1 *fMean = new TF1("fMean", "[0] + [1] * TMath::Power(x, [2])", 1., 100.); fMean->SetParameter(0, 0.); fMean->SetParameter(1, 1.); fMean->SetParameter(2, 1.); TH1 *hMean = (TH1 *)oa->At(1); hMean->Fit(fMean, "0q", "I", 1., 100.); cFit->cd(1)->SetLogx(); cFit->cd(1)->SetLogy(); hMean->Draw(); fMean->Draw("same"); TF1 *fSigma = new TF1("fSigma", "[0] + [1] * TMath::Power(x, [2])", 1., 100.); fSigma->SetParameter(0, 0.); fSigma->SetParameter(1, 1.); fSigma->SetParameter(2, 0.5); TH1 *hSigma = (TH1 *)oa->At(2); hSigma->Fit(fSigma, "0q", "", 1., 100.); cFit->cd(3)->SetLogx(); cFit->cd(3)->SetLogy(); hSigma->Draw(); fSigma->Draw("same"); cFit->cd(2)->SetLogx(); cFit->cd(2)->SetLogy(); cFit->cd(2)->SetLogz(); hcorr->Draw("colz"); TH2 *hcorrfit = (TH2 *)hcorr->Clone("hcorrfit"); // hcorrfit->Reset(); for (Int_t i = 0; i < hcorr->GetNbinsX(); i++) { Float_t cent = hcorr->GetXaxis()->GetBinCenter(i + 1); Float_t mean = fMean->Eval(cent); Float_t sigma = fSigma->Eval(cent); if (cent < 25 || cent > 100) continue; for (Int_t j = 0; j < 10000; j++) { Float_t val = gRandom->Gaus(mean, sigma); if (val <= 0.) continue; hcorrfit->Fill(val, cent); } } cFit->cd(4)->SetLogx(); cFit->cd(4)->SetLogy(); cFit->cd(4)->SetLogz(); hcorrfit->Draw("colz"); return hcorrfit; }
// //---------------------------------------------------------------------- // 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 } }