/*============================================================================*/
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");
}
void LongiProfile(int E, std::string runPeriod)
{
char inputFile[200];
sprintf(inputFile,"%s%d%s","/lyoserv/home/ilc/steen/resultRootFile/tb_data/DHCAL_",Run(E,runPeriod),".root");
std::cout << "inputFile = " << inputFile << std::endl;
PionTimeCalibration* timeCalib=new PionTimeCalibration(inputFile);
timeCalib->ShowerBarycenterCut(runPeriod);
timeCalib->Loop();
std::cout<< timeCalib->longitudinalVec.size()<<std::endl;
TF1 *func;
char outputFile[200];
sprintf(outputFile,"%s%d%s","/home/steen/timeCalib/LongiProfile/calib_",Run(E,runPeriod),".txt");
fstream out;
out.open(outputFile,ios::out);
for(unsigned int k=0; k<48; k++){
TH2D* hRadPro=new TH2D("hName","",100,0,10,4000,0,200);
func=new TF1("func","pol2",0,10);
for(unsigned int i=0; i<timeCalib->nhit1.size(); i++){
hRadPro->Fill(timeCalib->time.at(i),timeCalib->longitudinalVec.at(i).layer[k]);
}
hRadPro->ProfileX()->Fit(func,"NQ");
out << k
<< " " << func->GetParameter(0) << " " << func->GetParError(0)
<< " " << func->GetParameter(1) << " " << func->GetParError(1)
<< " " << func->GetParameter(2) << " " << func->GetParError(2)
<< " " << func->GetChisquare()/func->GetNDF() << std::endl;
delete hRadPro;
}
out.close();
delete func;
delete timeCalib;
}
/************************************************************
* Fit ADC spectrum
************************************************************/
int FitAdcHist(TH1F *h, float data[NDATA], const int print ) {
TF1 *fadc;
TPaveText *adcPT;
// Protect for null histograms
if( h == 0 || h->GetEntries()<1000. ) return -1;
printf("Fitting %s\n",h->GetName());
gStyle->SetOptStat("emr");
adcPT = new TPaveText(0.58,0.315,0.98,0.635,"NDC");
// Refit ADC
Double_t n = h->GetEntries();
Double_t rms = h->GetRMS();
Double_t mean = h->GetMean();
Double_t ymin = mean-2*rms;
if( ymin < 60. ) ymin=60.;
Double_t ymax = mean+1.5*rms;
fadc = new TF1("adc_fun",skewnormal,ymin,ymax,4);
fadc->SetParameters(n,mean,rms,1.5);
fadc->SetParLimits(1,mean-rms,mean+0.5*rms);
fadc->SetParLimits(2,rms*0.5,rms*1.5);
fadc->SetParLimits(3,1.,4.);
h->Fit("adc_fun","r");
// If skew is too high refit with fixed skew
if( fadc->GetParameter(3) > 2.5 ) {
printf("REFIT %s\n",h->GetName());
fadc->SetParameter(3,1.6);
fadc->SetParLimits(3,1.6,1.6);
h->Fit("adc_fun","r") ;
}
// if have enough hits use fit results
if( n > MINHITS ) {
data[13] = fadc->GetParameter(1);
data[14] = fadc->GetParError(1);
data[15] = fadc->GetParameter(2);
data[16] = fadc->GetParError(2);
data[17] = fadc->GetParameter(3);
data[18] = fadc->GetParError(3);
double dof = fadc->GetNDF();
if( dof > 0. ) data[19] = fadc->GetChisquare()/dof;
adcPT->AddText(Form("Peak %.1lf #pm %.1lf",data[13],data[14]));
adcPT->AddText(Form("Width %.1lf #pm %.1lf",data[15],data[16]));
adcPT->AddText(Form("Skew %.2lf #pm %.2lf", data[17],data[18]));
if( dof > 0. ) adcPT->AddText(Form("#Chi^{2}/DoF %.2lf",data[19]));
adcPT->SetTextColor(2);
adcPT->Draw();
// if have too few hits use fit stats instead of fit results
} else {
data[12] = mean;
data[13] = h->GetMeanError();
data[14] = rms;
data[15] = h->GetRMSError();
data[16] = h->GetSkewness();
}
if( print ) c1->Print(Form("%s_%s.png",fname,h->GetName()));
return 0;
} //end FitAdcHist
void FillFromFunction(TF1& infunc){
norm = normscale * infunc.GetParameter(0);
norm_err = normscale * infunc.GetParError(0);
gamma = infunc.GetParameter(2);
gamma_err = infunc.GetParError(2);
ang = infunc.GetParameter(1);
ang_err = infunc.GetParError(1);
chi2 = infunc.GetChisquare();
ndf = infunc.GetNDF();
}
// Loop through detector layers to report
// various parameters
residu(TString baseName, double min=-1.5, double max=1.5)
{
double xMin, xMax;
TString name;
name = baseName;
name += "_a"; TH1D * amp = new TH1D(name,name,55,0,54.);
name = baseName;
name += "_mean"; TH1D * mean = new TH1D(name,name,55,0,54.);
name = baseName;
name += "_rms"; TH1D * rms = new TH1D(name,name,55,0,54.);
TString thisL;
TH1D *h=0;
TF1 * f;
int ii;
for(int i=0; i<51;i++)
{
thisL=baseName+i;
if (i<6)
{
xMin = -0.2;
xMax = 0.2;
}
else
{
xMin = min;
xMax = max;
}
h=(TH1D*)gDirectory->Get(thisL);
h->Fit("gaus","","",xMin,xMax);
double entries = h->GetEntries();
if (entries>0)
{
ii = i+1;
f = h->GetFunction("gaus");
double a = f->GetParameter("Constant"); double ea = f->GetParError(0);
double m = f->GetParameter("Mean");double em = f->GetParError(1);
double r = f->GetParameter("Sigma");double er = f->GetParError(2);
amp->SetBinContent(ii,a);amp->SetBinError(ii,ea);
mean->SetBinContent(ii,m);mean->SetBinError(ii,em);
rms->SetBinContent(ii,r);rms->SetBinError(ii,er);
}
}
cout << "Fitting completed" << endl;
c1->Clear();
c1->Divide(1,3);
c1->cd(1); amp->Draw();
c1->cd(2); mean->Draw();
c1->cd(3); rms->Draw();
}
void fitBarea(TString infname="",bool doweight = 1)
{
if (doweight==0) weight="1";
if (infname=="") infname=inputdata.Data();
TFile *inf = new TFile(infname.Data());
TTree *nt = (TTree*) inf->Get("ntKp");
TFile *infMC = new TFile(inputmc.Data());
TTree *ntGen = (TTree*)infMC->Get("ntGen");
TTree *ntGen2 = (TTree*)inf->Get("ntGen");
TTree *ntMC = (TTree*)infMC->Get("ntKp");
ntGen->AddFriend(ntMC);
ntGen2->AddFriend(ntMC);
const int nBins = 1;
double ptBins[nBins+1] = {10,60};
// const int nBins = 1;
// double ptBins[nBins+1] = {10,60};
TH1D *hPt = new TH1D("hPt","",nBins,ptBins);
for (int i=0;i<nBins;i++)
{
TF1 *f = fit(nt,ntMC,ptBins[i],ptBins[i+1]);
double yield = f->Integral(5,6)/0.02;
double yieldErr = f->Integral(5,6)/0.02*f->GetParError(0)/f->GetParameter(0);
hPt->SetBinContent(i+1,yield/(ptBins[i+1]-ptBins[i]));
hPt->SetBinError(i+1,yieldErr/(ptBins[i+1]-ptBins[i]));
}
}
void ThrowPSEME(int me_i, bool use_old=false){
// ====================================================
// Create a fit
// ====================================================
TF1 *ftot = new TF1("fitFunction",fitFunction,-100,0,2);
//threw one data PSE and fill it
if (use_old){
cout<<"OLD"<<endl;
siggnal = MEWH_old[me_i];
background = MEWBB_old[me_i];
}else{
cout<<"NEW"<<endl;
siggnal = MEWH[me_i];
background = MEWBB[me_i];
}
TH1F * Err = new TH1F("Err","Err",1000,0,1);
for (int pse=0;pse<100;pse++){
//Get one PSE
TH1F * data = MakeOnePSE(siggnal,1000,background,2000);
//fit it
data->Fit("fitFunction","b");
Err->Fill(ftot->GetParError(1));
delete data;
}
Err->Draw();
}//ThrowPSEME
TF1* fit_xy_res(double &x, double &xe, double &max, bool do_fit, int idel, int ipad, TCanvas *tc,
TH1F* h, const char *meth, const char *var_tag, const char *det_tag, const char *var, const char *det_desc) {
tc->cd(1+ipad);
//cout << "var_tag = " << var_tag << endl;
TLatex *tt = new TLatex();
tt->SetTextSize(0.08);
tt->SetTextColor(4);
tt->SetNDC(true);
double fmx = 2.2;
double fit_min= h->GetMean()-fmx*h->GetRMS();
double fit_max= h->GetMean()+fmx*h->GetRMS();
TF1* f = new TF1(Form("fxres_%s_%d_%s",det_tag,idel,meth), "gaus",fit_min,fit_max);
if (do_fit) {
h->Fit(f,"R+Q");
x = f->GetParameter(2);
xe = f->GetParError(2);
if (f->GetParameter(1) < f->GetParError(1))
cout << " OK: ";
else
cout << " OOPS: ";
cout << var_tag << " " << meth << " " << det_tag << idel;
cout << " mean= " << f->GetParameter(1) << " pm " << f->GetParError(1);
cout << " sigma= " << f->GetParameter(2) << " pm " << f->GetParError(2) << endl;
} else {
max = TMath::Max(max, x);
h->Draw();
//tt->DrawLatex(0.12,0.15, h->GetTitle());
}
tt->DrawLatex(0.65,0.8, meth);
tt->DrawLatex(0.65,0.7, var);
tt->DrawLatex(0.65,0.6, det_desc);
tt->DrawLatex(0.65,0.5, Form("#delta = %d%%",idel-5 ));
max = TMath::Max(max, x);
gPad->SetGridx();
return f;
}
void histspec(TH1* hist, Double_t &mean, Double_t &ermean, Double_t &rms,
Double_t range=4, Double_t rangef=2.5, int mode=0) {
Double_t xmin,xmax,rmsmin,meanf,ermeanf,rmsf;
char ctit[145];
mean=hist->GetMean();
rms=hist->GetRMS();
xmin=hist->GetXaxis()->GetXmin();
xmax=hist->GetXaxis()->GetXmax();
int nb=hist->GetNbinsX();
rmsmin=(xmax-xmin)/(nb+1);
if (rms==0) rms=rmsmin;
for (int i=0;i<2;i++) {
hist->SetAxisRange(mean-range*rms,mean+range*rms);
mean=hist->GetMean();
rms=hist->GetRMS();
if (rms==0) rms=rmsmin;
}
if (rangef>0) {
for (int i=0;i<2;i++) {
hist->SetAxisRange(mean-rangef*rms,mean+rangef*rms);
mean=hist->GetMean();
rms=hist->GetRMS();
if (rms==0) rms=rmsmin;
}
}
ermean=hist->GetMeanError();
if (abs(mode)>0) {
if (mode<0) {
//sprintf(ctit,"cHistSpecs%4d",nHistSpecs++);
//TCanvas *ccxx = new TCanvas("ccxx","ccxx",900,0,450,450);
//hist->SetMinimum(0);
//hist->Draw();
hist->Fit("gaus","LI","same",mean-rangef*rms,mean+rangef*rms);
//ccxx->Update();
for (int i=0;i<1e3;i++) for (int j=0;j<1e3;j++) {}
}
else hist->Fit("gaus","LI0","",mean-rangef*rms,mean+rangef*rms);
TF1 *f = hist->GetFunction("gaus");
meanf=f->GetParameter(1);
ermeanf=f->GetParError(1);
rmsf=f->GetParameter(2);
if (fabs(mean-meanf)/(fabs(mean+meanf)+0.0001)<0.8 &&
fabs(ermean-ermeanf)/(fabs(ermean+ermeanf)+0.0001)<0.8) {
mean=meanf;
ermean=ermeanf;
rms=rmsf;
}
}
hist->SetAxisRange(xmin,xmax);
return;
}
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;
}
drawGraph( TGraph* gr, const Char_t* ytitle = 0 )
{
gr->Draw( "AP*" );
TH1* h = gr->GetHistogram( );
std::cout << gr->GetMean( ) << std::endl;
gr->Fit( "pol0", "Q", "SAME" );
TF1* fit = gr->GetFunction( "pol0" );
Double_t chi2 = fit->GetChisquare( );
Double_t par0 = fit->GetParameter( 0 );
Double_t err = fit->GetParError( 0 );
TLatex* l = new TLatex;
l->SetNDC( );
l->DrawLatex( 0.85, 0.80, Form( "#splitline{Entries = %i}{RMS = %2.3f}",
gr->GetN(), gr->GetMean(2)) );
TLatex* l2 = new TLatex;
l2->SetNDC( );
l2->DrawLatex( 0.85, 0.7, Form("#splitline{fit = %2.3f#pm%2.3f}{#chi^{2} = %2.3f}",
par0, chi2, err) );
// TLegend* leg = new TLegend( 0.8, 0.9, 0.95, 0.95 );
// leg->SetFillColor( kWhite );
// leg->SetBorderSize( 0 );
// leg->AddEntry( "gr", "CPU+AFAR+MBED+ATWD+AMPS", "P" );
// leg->Draw( );
if( h != 0 )
{
h->GetXaxis()->SetTimeFormat("%m/%d %H:%M");
h->GetXaxis()->SetNdivisions( 10, 10, 0 );
h->GetXaxis()->SetTimeDisplay( 1 );
h->GetXaxis()->SetTitle("Date / Time (UTC)");
h->GetXaxis()->SetLabelSize( 0.06 );
h->GetYaxis()->SetLabelSize(0.07);
h->GetYaxis()->SetTitleSize(0.06);
h->GetXaxis()->SetTitleSize(0.055);
h->GetYaxis()->SetTitleOffset( 0.9 );
h->GetXaxis()->SetTitleOffset( 0.9 );
h->SetMarkerSize( 5 );
if( ytitle != 0 )
{
h->GetYaxis()->SetTitle(ytitle);
}
}
if( gPad != 0 )
{
gPad->Update();
}
}
scalePair energyCorrectionDiff(TCut centCut1, float lowPt, float highPt, float lowEta, float highEta,TCut addCut) {
TString fname1 = "forest/barrelHiForestPhoton_MCphoton50_51k.root";
if ( lowPt > 90 )
fname1 = "forest/barrelHiForestPhoton_MCphoton80_28k.root";
TFile *f1 =new TFile(fname1.Data());
TTree *photon1 = (TTree*)f1->Get("yongsunPhotonTree");
photon1->AddFriend("yEvt=yongsunHiEvt" ,fname1.Data());
photon1->AddFriend("ySkim=yongsunSkimTree" ,fname1.Data());
photon1->AddFriend("yHlt=yongsunHltTree" ,fname1.Data());
TCut collisionCut = "ySkim.pcollisionEventSelection==1";
TCut hoeCut = "hadronicOverEm<0.2";
TCut isoCut = "cc4 + cr4 + ct4j20 < 5 && sigmaIetaIeta<0.011";
TCut ptCut = Form("genMatchedPt>%.f && genMatchedPt <%.f",lowPt, highPt);
TCut etaCut = Form("abs(eta)>%f && abs(eta)<%f",lowEta,highEta);
TCut finalCut1 = genMatchCut1 && collisionCut && centCut1 && hoeCut && isoCut && ptCut && etaCut && addCut ;
TString variable1 = "pt/genMatchedPt";
TH1D* hScale = new TH1D("hScale","",100,.5,1.5);
TH1D* hdpt = new TH1D("hdpt","",100,-20,20);
photon1->Draw(Form("%s>>%s",variable1.Data(),hScale->GetName()), finalCut1);
photon1->Draw(Form("pt-genMatchedPt>>%s",hdpt->GetName()), finalCut1);
cout << "cut = " << finalCut1.GetTitle() <<endl;
hScale->Draw();
hdpt->Draw();
TF1* ff = cleverGaus(hScale);
scalePair ret;
double *ps = ff->GetParameters();
ret.val = ps[1];
ret.err = ff->GetParError(1);
// resErr = ff->GetParError(2);
ret.res = ps[2];
ret.resErr = ff->GetParError(2);
ret.absVal = hdpt->GetMean();
cout <<"scale = " << ret.val << " +-" << ret.err << endl;
return ret;
}
TF1* getLandau(TH1* InputHisto, double* FitResults, double LowRange, double HighRange)
{
FitResults[0] = -0.5; //MPV
FitResults[1] = 0; //MPV error
FitResults[2] = -0.5; //Width
FitResults[3] = 0; //Width error
FitResults[4] = -0.5; //Fit Chi2/NDF
// perform fit with standard landau
TF1* MyLandau = new TF1("MyLandau","landau",LowRange, HighRange);
MyLandau->SetParameter(1,300);
InputHisto->Fit("MyLandau","0QR WW");
// MPV is parameter 1 (0=constant, 1=MPV, 2=Sigma)
FitResults[0] = MyLandau->GetParameter(1); //MPV
FitResults[1] = MyLandau->GetParError(1); //MPV error
FitResults[2] = MyLandau->GetParameter(2); //Width
FitResults[3] = MyLandau->GetParError(2); //Width error
FitResults[4] = MyLandau->GetChisquare() / MyLandau->GetNDF(); //Fit Chi2/NDF
return MyLandau;
}
double findDelPhiAngle(TH1D *input, int parorErr){
TF1 *fitter = new TF1("fitter","gaus",-2,2);
//input->Scale(1./(input->GetEntries()));
fitter->SetParameters(1./input->GetMaximum(),-0.1,1.0);
input->Fit("fitter","qN0","",-1.5,1.5);
if(parorErr==1){
return fitter->GetParameter(1);
}
else if(parorErr==2){
return fitter->GetParError(1);
}
else return 0;
}
void Nhit5by5Calibration(int E, std::string runPeriod)
{
char inputFile[200];
sprintf(inputFile,"%s%d%s","/lyoserv/home/ilc/steen/resultRootFile/tb_data/DHCAL_",Run(E,runPeriod),".root");
std::cout << "inputFile = " << inputFile << std::endl;
PionTimeCalibration* timeCalib=new PionTimeCalibration(inputFile);
timeCalib->ShowerBarycenterCut(runPeriod);
timeCalib->Loop();
std::cout<< timeCalib->nhit5by5.size()<<std::endl;
TF1 *func;
char outputFile[200];
sprintf(outputFile,"%s%d%s","/home/steen/timeCalib/Nhit5by5/calib_",Run(E,runPeriod),".txt");
fstream out;
out.open(outputFile,ios::out);
TH2D* hRadPro=new TH2D("hName","",100,0,10,600,0,600);
func=new TF1("func","pol1",0,10);
for(unsigned int i=0; i<timeCalib->nhit5by5.size(); i++){
hRadPro->Fill(timeCalib->time.at(i),timeCalib->nhit5by5.at(i));
}
//TCanvas *cc=new TCanvas();
//hRadPro->Draw("colz");
//cc->Update();
//cc->WaitPrimitive();
hRadPro->ProfileX()->Fit(func,"NQ");
//cc->Update();
//cc->WaitPrimitive();
out << func->GetParameter(0) << " " << func->GetParError(0)
<< " " << func->GetParameter(1) << " " << func->GetParError(1)
<< " " << func->GetChisquare()/func->GetNDF() << std::endl;
delete hRadPro;
out.close();
delete func;
delete timeCalib;
//delete cc;
}
void fitMassHisto(TString inputfile="outfiles/MassHisto", TString outputfile="outfiles/YieldHisto",
Float_t centmin=0., Float_t centmax=100.)
{
infname = inputfile;
centMin = centmin;
centMax = centmax;
gStyle->SetTextSize(0.05);
gStyle->SetTextFont(42);
gStyle->SetPadRightMargin(0.043);
gStyle->SetPadLeftMargin(0.18);
gStyle->SetPadTopMargin(0.1);
gStyle->SetPadBottomMargin(0.145);
gStyle->SetTitleX(.0f);
TF1* fit(TH1D* h, TH1D* hMCSignal, TH1D* hMCSwapped, Float_t ptmin, Float_t ptmax, Int_t j);
TH1D** hYield = new TH1D*[4];
for(int i=0;i<4;i++) hYield[i] = new TH1D(Form("hYield_%s",tfend[i].Data()),"",nPtBins,ptBins);
for(int i=0;i<nPtBins;i++)
{
TFile* infile = new TFile(Form("%s_cent_%.0f_%.0f_pt_%.0f_%.0f.root",infname.Data(),centMin,centMax,ptBins[i],ptBins[i+1]));
TH1D* hMCSignal = (TH1D*)infile->Get("hMCSignal");
TH1D* hMCSwapped = (TH1D*)infile->Get("hMCSwapped");
for(int j=0;j<4;j++)
{
TH1D* h = (TH1D*)infile->Get(Form("h_%s",tfend[j].Data()));
TF1* f = fit(h,hMCSignal,hMCSwapped,ptBins[i],ptBins[i+1],j);
Double_t yield = f->Integral(minhisto,maxhisto)/binwidthmass;
Double_t yieldErr = f->Integral(minhisto,maxhisto)/binwidthmass*f->GetParError(0)/f->GetParameter(0);
hYield[j]->SetBinContent(i+1,yield);
hYield[j]->SetBinError(i+1,yieldErr);
delete h;
}
delete hMCSwapped;
delete hMCSignal;
delete infile;
}
TFile* outf = new TFile(Form("%s_cent_%.0f_%.0f.root",outputfile.Data(),centmin,centmax),"recreate");
outf->cd();
for(int i=0;i<4;i++) hYield[i]->Write();
outf->Close();
delete []hYield;
delete outf;
cout<<endl;
}
TF1 *langaufit(TH1F *his, Double_t *fitrange, Double_t *startvalues, Double_t *parlimitslo, Double_t *parlimitshi, Double_t *fitparams, Double_t *fiterrors, Double_t *ChiSqr, Int_t *NDF)
{
// Once again, here are the Landau * Gaussian parameters:
// par[0]=Width (scale) parameter of Landau density
// par[1]=Most Probable (MP, location) parameter of Landau density
// par[2]=Total area (integral -inf to inf, normalization constant)
// par[3]=Width (sigma) of convoluted Gaussian function
//
// Variables for langaufit call:
// his histogram to fit
// fitrange[2] lo and hi boundaries of fit range
// startvalues[4] reasonable start values for the fit
// parlimitslo[4] lower parameter limits
// parlimitshi[4] upper parameter limits
// fitparams[4] returns the final fit parameters
// fiterrors[4] returns the final fit errors
// ChiSqr returns the chi square
// NDF returns ndf
Int_t i;
Char_t FunName[100];
sprintf(FunName,"Fitfcn_%s",his->GetName());
TF1 *ffitold = (TF1*)gROOT->GetListOfFunctions()->FindObject(FunName);
if (ffitold) delete ffitold;
TF1 *ffit = new TF1(FunName,langaufun,fitrange[0],fitrange[1],4);
ffit->SetParameters(startvalues);
ffit->SetParNames("Width","MP","Area","GSigma");
for (i=0; i<4; i++) {
ffit->SetParLimits(i, parlimitslo[i], parlimitshi[i]);
}
his->Fit(FunName,"RB0"); // fit within specified range, use ParLimits, do not plot
ffit->GetParameters(fitparams); // obtain fit parameters
for (i=0; i<4; i++) {
fiterrors[i] = ffit->GetParError(i); // obtain fit parameter errors
}
ChiSqr[0] = ffit->GetChisquare(); // obtain chi^2
NDF[0] = ffit->GetNDF(); // obtain ndf
return (ffit); // return fit function
}
void prefit() {
TFile *f = TFile::Open("/afs/cern.ch/user/x/xniu/WZXSection/CMSSW_7_6_3_patch2/src/MitEwk13TeV/XControl/f_bkgfail.root");
TFile *fbkg = new TFile("fbkg.root","RECREATE");
TH1D *h[24];
TH1D *hbkg[24];
// TF1 *fq = new TF1("fq","[0]+[1]*x+[2]*x*x",60.,120.);
// TF1 *fl = new TF1("fl","[0]+[1]*x",60.,120.);
// TF1 *fq = new TF1("fq",myfunction,60.,120.,3);
TF1 *fq = new TF1("fq","x**(-1.*[0])",60.,120.);
for(int i = 0; i < 24; i++) {
char name[20];
char namebkg[20];
sprintf(name, "histFail_%d", i);
sprintf(namebkg, "histbkgFail_%d", i);
h[i] = (TH1D*) f->Get(name);
hbkg[i] = new TH1D(namebkg, "", 60, 60., 120.);
for(int ib = 0; ib < 20; ib++) {
hbkg[i]->SetBinContent(ib+1, h[i]->GetBinContent(ib+1));
hbkg[i]->SetBinError(ib+1, h[i]->GetBinError(ib+1));
}
for(int ib = 40; ib < 60; ib++) {
hbkg[i]->SetBinContent(ib+1, h[i]->GetBinContent(ib+1));
hbkg[i]->SetBinError(ib+1, h[i]->GetBinError(ib+1));
}
//hbkg[i]->Write();
hbkg[i]->Fit("fq");
std::cout<<"ibin = "<<i<<": "<<fq->GetParameter(0)<<","<<fq->GetParError(0)<<" ,"<<fq->GetParameter(1)<<","<<fq->GetParError(1)<<","<<fq->GetParameter(2)<<","<<fq->GetParError(2)<<std::endl;
// if(i==10){
// hbkg[i]->Fit("fl");
// std::cout<<"ibin = "<<i<<": "<<fl->GetParameter(0)<<","<<fl->GetParError(0)<<","<<fl->GetParameter(1)<<","<<fl->GetParError(1)<<std::endl;
// }
}
fbkg->Write();
fbkg->Close();
f->Close();
}
void scan()
{
TFile *outf = new TFile("result.root","recreate");
TH1D *h = new TH1D("h","",6,20,50);
int bin=1;
for (int i=20;i<50;i+=5)
{
TF1 *f = bFeedDownFraction(i,i+5);
h->SetBinContent(bin,f->GetParameter(2));
h->SetBinError(bin,f->GetParError(2));
bin++;
}
TCanvas *cResult = new TCanvas("cResult","",600,600);
h->SetXTitle("D^{0} p_{T} (GeV/c)");
h->SetYTitle("Prompt Fraction");
h->Draw("e");
}
void GetFitParameterErrorDoubleFit(TH1* &histo, bool autorange = true, double innerRange=0.1 , double outerRange=1, bool excludeCenter=false){
Double_t errors[6] = {0,0,0,0,0,0};
TF1 * fit;
if(excludeCenter){
fit = andi::doubleGaussFitExcludeCenter(histo, false, innerRange, outerRange);
}
else{
fit = doubleGaussFit(histo, autorange, innerRange, outerRange);
}
for (int i=0; i<6; i++){
errors[i]=fit->GetParError(i);
}
//return parameter;
}
void Fithistograms(TH1D * histo[], TH1D * mc_matched_signal[], TH1D * mc_matched_kpiswapped[], TString MBorDtrig, int iptstart, int iptend, bool isPbPb, int centlow, int centhigh, TH1D * dNdpt, TString fitoption)
{
for(int ipt = iptstart; ipt < iptend; ipt++)
{
TF1* signalfittedfunc = NULL;
int iptmc = ipt;
// if( ipt > 2 )
// iptmc = ipt;
// else
// iptmc = 3;
if( fitoption == "poly3bkg_floatwidth")
signalfittedfunc = fit_histo_poly3bkg_floatwidth( isPbPb, centlow, centhigh, histo[ipt], mc_matched_signal[iptmc], mc_matched_kpiswapped[iptmc], ipt, MBorDtrig);
if( fitoption == "expobkg_2nd_floatwidth")
signalfittedfunc = fit_histo_expobkg_2nd_floatwidth( isPbPb, centlow, centhigh, histo[ipt], mc_matched_signal[iptmc], mc_matched_kpiswapped[iptmc], ipt, MBorDtrig);
if( fitoption == "poly2bkg_floatwidth")
signalfittedfunc = fit_histo_poly2bkg_floatwidth( isPbPb, centlow, centhigh, histo[ipt], mc_matched_signal[iptmc], mc_matched_kpiswapped[iptmc], ipt, MBorDtrig);
if( fitoption == "poly3bkg")
signalfittedfunc = fit_histo_poly3bkg( isPbPb, centlow, centhigh, histo[ipt], mc_matched_signal[iptmc], mc_matched_kpiswapped[iptmc], ipt, MBorDtrig);
if( fitoption == "expobkg_2nd")
signalfittedfunc = fit_histo_expobkg_2nd( isPbPb, centlow, centhigh, histo[ipt], mc_matched_signal[iptmc], mc_matched_kpiswapped[iptmc], ipt, MBorDtrig);
if( fitoption == "poly2bkg")
signalfittedfunc = fit_histo_poly2bkg( isPbPb, centlow, centhigh, histo[ipt], mc_matched_signal[iptmc], mc_matched_kpiswapped[iptmc], ipt, MBorDtrig);
double histomassbinsize = histo[ipt]->GetBinWidth(10);
double yield = signalfittedfunc->Integral(massmin,massmax)/histomassbinsize;
double yieldErr = signalfittedfunc->Integral(massmin,massmax)/histomassbinsize * signalfittedfunc->GetParError(0)/signalfittedfunc->GetParameter(0);
dNdpt->SetBinContent(ipt+1,yield/(ptbins[ipt+1]-ptbins[ipt]));
dNdpt->SetBinError(ipt+1,yieldErr/(ptbins[ipt+1]-ptbins[ipt]));
}
}
Double_t sr_fitError(Double_t *xx, Double_t *p) {
assert(_sr_fitError_func);
assert(_sr_fitError_emat);
double x = *xx;
double k = p[0];
TF1 *f = _sr_fitError_func;
int n = f->GetNpar();
TMatrixD &emat = (*_sr_fitError_emat);
assert(emat.GetNrows()==n);
assert(emat.GetNcols()==n);
vector<double> df(n);
for (int i = 0; i != n; ++i) {
double p = f->GetParameter(i);
double dp = 0.1*f->GetParError(i);
f->SetParameter(i, p+dp);
double fup = f->Eval(x);
f->SetParameter(i, p-dp);
double fdw = f->Eval(x);
f->SetParameter(i, p);
df[i] = (dp ? (fup - fdw) / (2.*dp) : 0);
}
double sumerr2(0);
for (int i = 0; i != n; ++i) {
for (int j = 0; j != n; ++j) {
sumerr2 += emat[i][j]*df[i]*df[j];
}
}
double err = sqrt(sumerr2);
return (f->Eval(x) + k*err);
}
void unfoldPt(int mode=0)
{
// Matched Tracklets
TFile *inf = new TFile("match-10TeV-12.root");
TNtuple *nt = (TNtuple*)inf->FindObjectAny("nt");
// Test sample
TFile *infTest = new TFile("./TrackletTree-Run123596.root");
TNtuple *ntTest = (TNtuple*)infTest->FindObjectAny("TrackletTree12");
TFile *pdfFile;
if (mode==0) pdfFile = new TFile("pdf.root","recreate");
else pdfFile = new TFile("pdf.root");
double nPtBin=15;
double minPt=log(0.05);
double maxPt=log(10);
double nDphiBin=600;
double maxDphi=0.4;
char* mycut = Form("abs(eta)<2&&log(pt)>%f&&log(pt)<%f",minPt,maxPt);
char* mycut1=Form("abs(eta)<2&&log(pt)>%f&&log(pt)<%f&&abs(eta-eta1)<0.01&&abs(deta)<0.01",minPt,maxPt);
TH2F *h;
TH1F *hdphi = new TH1F("hdphi","",nDphiBin,0,maxDphi);
TH1F *hdphi2;
TH1F *hpt;
TH1F *hptH = new TH1F("hptH","",nPtBin,minPt,maxPt);
TH1F *hptUnfold = new TH1F("hptUnfold","",nPtBin,minPt,maxPt);
TH1F *hptMC = new TH1F("hptMC","",nPtBin,minPt,maxPt);
TH1F *hptTemp = new TH1F("hptTemp","",nPtBin,minPt,maxPt);
// Delta phi as a function of matched genparticle transverse momentum
TCanvas *c = new TCanvas("c","",600,600);
if (mode == 0) {
h = new TH2F("h","",nPtBin,minPt,maxPt,nDphiBin,0,maxDphi);
hdphi2 = new TH1F("hdphiMC","",nDphiBin,0,maxDphi);
hpt = new TH1F("hpt","",nPtBin,minPt,maxPt);
h->SetXTitle("ln(P_{T}) GeV/c");
h->SetYTitle("|#Delta#phi|");
nt->Draw("abs(dphi):log(pt)>>h",mycut1,"col");
// used to generate pdf
nt->Draw("abs(dphi)>>hdphiMC",mycut,"");
nt->Draw("log(pt)>>hpt",mycut,"");
h->Write();
hpt->Write();
hdphi2->Write();
} else {
h = (TH2F*) pdfFile->FindObjectAny("h");
hdphi2 = (TH1F*) pdfFile->FindObjectAny("hdphiMC");
hpt = (TH1F*) pdfFile->FindObjectAny("hpt");
}
// Delta phi fit
TCanvas *c2 = new TCanvas("c2","",600,600);
c2->SetLogy();
c2->SetLogx();
// dphi for unfolding and MC truth:
ntTest->Draw("abs(dphi)>>hdphi","abs(eta1)<2&&abs(deta)<0.1","",200000);
ntTest->Draw("log(pt)>>hptH",mycut,"",200000);
histFunction2D *myfun = new histFunction2D(h);
TF1 *test = new TF1("histFun",myfun,&histFunction2D::evaluate,0,maxDphi,nPtBin+1);
TF1 *test2 = new TF1("histFunMC",myfun,&histFunction2D::evaluate,0,maxDphi,nPtBin+1);
for (int i=0;i<nPtBin+1;i++)
{
test->SetParameter(i,1);
}
hdphi2->SetXTitle("|#Delta#phi|");
hdphi2->SetYTitle("Arbitrary Normalization");
hdphi2->Fit("histFunMC","M");
hdphi->SetXTitle("|#Delta#phi|");
hdphi->SetYTitle("Arbitrary Normalization");
hdphi->Fit("histFun","M");
hdphi->SetStats(0);
hdphi->Draw();
for (int i=0;i<nPtBin+1;i++) {
TF1 *testPlot = new TF1(Form("histFun%d",i),myfun,&histFunction2D::evaluate,0,maxDphi,nPtBin+1);
testPlot->SetParameter(i,test->GetParameter(i));
testPlot->SetLineColor(i+2);
testPlot->Draw("same");
}
int total=0,totalMC=0;
for (int i=0;i<nPtBin;i++){
if (test->GetParameter(i)==0) continue;
hptUnfold->SetBinContent(i+1,fabs(test->GetParameter(i)));
hptUnfold->SetBinError(i+1,test->GetParError(i));
hptMC->SetBinContent(i+1,fabs(test2->GetParameter(i)));
hptMC->SetBinError(i+1,test2->GetParError(i));
total+=fabs(test->GetParameter(i));
totalMC+=fabs(test2->GetParameter(i));
}
hptUnfold->SetEntries(total);
hptMC->SetEntries(totalMC);
TCanvas *c3 = new TCanvas("c3","",600,600);
hpt->Sumw2();
hptH->Sumw2();
//hptMC->Sumw2();
double normMC=0;
double norm=0;
double normTruth=0;
hptUnfold->SetMarkerColor(2);
hptUnfold->SetMarkerStyle(4);
// hptUnfold->Scale(1./hptUnfold->GetEntries());
TH1F *hptCorrected = (TH1F*)hptUnfold->Clone();
hptCorrected->SetName("hptCorrected");
hptMC->Divide(hpt);
hptCorrected->Divide(hptMC);
for (int i=0;i<nPtBin;i++){
if (hptMC->GetBinContent(i)<=0.001)hptCorrected->SetBinContent(i,0);
}
hptCorrected->Scale(1./(hptCorrected->GetSum()));
hptCorrected->SetMarkerStyle(20);
hpt->Scale(1./hpt->GetEntries());
if (hptH->GetEntries())hptH->Scale(1./hptH->GetEntries());
hptTemp->SetXTitle("ln(P_{T}) GeV/c");
hptTemp->SetYTitle("Arbitrary Normalization");
hptTemp->Draw();
hptH->SetXTitle("ln(P_{T}) GeV/c");
hptH->SetYTitle("Arbitrary Normalization");
hptH->Draw("hist");
hptH->SetLineColor(4);
hpt->Draw("hist same ");
hptCorrected->Draw("same");
TH1F *hptUnfoldRatio = (TH1F*)hptUnfold->Clone();
hptUnfoldRatio->SetName("hptUnfoldRatio");
hptUnfoldRatio->Scale(1./hptUnfoldRatio->GetSum());
//hptUnfoldRatio->Divide(hptH);
TH1F *hptCorrectedRatio = (TH1F*)hptCorrected->Clone();
hptCorrectedRatio->SetName("hptCorrectedRatio");
hptCorrectedRatio->SetMarkerColor(2);
//hptCorrectedRatio->Divide(hptH);
TCanvas *c4 = new TCanvas("c4","",600,600);
TLine *l = new TLine(-2.5,1,2.5,1);
hptUnfoldRatio->Draw();
hptMC->Draw("same");
hptCorrectedRatio->Draw("same");
l->Draw("same");
}
//===============================
void FitSignalBG(Double_t nSigma, Int_t iRapBin, Int_t iPTBin){
gStyle->SetOptFit(kTRUE);
gStyle->SetOptStat(kFALSE);
Char_t name[100];
//1.) perform the fit to the continuum, using the sidebands
sprintf(name, "c1_rap%d_pT%d", iRapBin, iPTBin);
TCanvas *c1 = new TCanvas(name);
sprintf(name, "Counts per %1.0f MeV", 1000.*binWidth);
c1->SetFillColor(0);
c1->SetLeftMargin(0.15);
hMass->SetYTitle(name);
hMass->SetXTitle("M_{#mu#mu} [GeV]");
hMass->SetTitleOffset(1.5, "y");
hMass->SetStats(0);
hMass->Draw();
//starting values for fit:
Double_t a = -2.0e6, b = 5.e5, c = -2.4e4;
Double_t range_min = 8.6, range_max = 11.4;
Double_t normY1S = hMass->GetMaximum() / binWidth;
Double_t normY2S = 0.3*normY1S;
Double_t normY3S = 0.15*normY1S;
Double_t sigma1S = 0.1, mean1S = 9.45;
Double_t alpha = 1.33, n = 6.6; //CB-tail parameters
printf("will be fitting the continuum between %1.2f < M < %1.2f\n", range_min, range_max);
sprintf(name, "fCont");
TF1* fCONT = new TF1(name, fitContinuum, range_min, range_max, 3);
fCONT->SetParameters(a, b, c);
hMass->Fit(fCONT, "0", "", range_min, range_max);
fCONT = hMass->GetFunction(name);
Double_t chisqrd = fCONT->GetChisquare();
Int_t NDF = fCONT->GetNDF();
Double_t redChi2 = chisqrd/NDF;
printf("\nChisqrd = %1.3f, NDF = %d, Chisqrd/NDF = %1.3f, Prob = %1.3f\n\n", chisqrd, NDF, redChi2, TMath::Prob(chisqrd,NDF));
fCONT->GetParameters(fitParBG);
for(int iPar = 0; iPar < 3; iPar++){
fitParBGerr[iPar]=fCONT->GetParError(iPar);
}
//2.) fit the peaks on the top of a fixed continuum
sprintf(name,"fPeaks");
Int_t const npar = 10;
fRECO = new TF1(name, fitPolyCrystal3, peak_min, peak_max, npar);
fRECO->SetParNames("normY1S", "mass_Ups1S", "sigma_Ups1S", "normY2S", "normY3S", "n", "alpha", "a", "b", "c");
fRECO->SetParameters(normY1S, mean1S, sigma1S, normY2S, normY3S, n, alpha, a, b, c);
fRECO->FixParameter(7,fitParBG[0]);
fRECO->FixParameter(8,fitParBG[1]);
fRECO->FixParameter(9,fitParBG[2]);
//fix alpha and n from the fit to all bins
if(iPTBin > 0 && iRapBin > 0){
Char_t fileName[100];
if(iRapBin == 0)
sprintf(fileName, "tmpFiles/CBParameters.root");
else
sprintf(fileName, "tmpFiles/CBParameters_rap%d.root", iRapBin);
TFile *fIn = new TFile(fileName);
TTree *treeIn = (TTree *) gDirectory->Get("CBPars");
Double_t alphaAll, nAll;
TBranch *b_alphaAll, *b_nAll;
treeIn->SetBranchAddress("alphaAll", &alphaAll, &b_alphaAll);
treeIn->SetBranchAddress("nAll", &nAll, &b_nAll);
Long64_t iEntry = treeIn->LoadTree(0);
treeIn->GetEntry(0);
printf("alpha and n from File: %1.3f, %1.3f\n", alphaAll, nAll);
fRECO->FixParameter(5, nAll);
fRECO->FixParameter(6, alphaAll);
}
hMass->Fit(fRECO, "0", "", peak_min, peak_max);
fRECO = hMass->GetFunction(name);
fRECO->SetLineWidth(1);
Double_t fitParTot[npar];
fRECO->GetParameters(fitParTot);
normY1S = fitParTot[0]; printf("normY1S = %1.3e\n", normY1S);
mean1S = fitParTot[1];
sigma1S = fitParTot[2];
normY2S = fitParTot[3];
normY3S = fitParTot[4];
n = fitParTot[5]; printf("n = %1.3f\n", n);
alpha = fitParTot[6]; printf("alpha = %1.3f\n", alpha);
sigma1S_save[iRapBin][iPTBin]=sigma1S;
chisqrd = fRECO->GetChisquare();
NDF = fRECO->GetNDF();
redChi2 = chisqrd/NDF;
printf("\nChisqrd = %1.3f, NDF = %d, Chisqrd/NDF = %1.3f, Prob = %1.3e\n", chisqrd, NDF, redChi2, TMath::Prob(chisqrd,NDF));
//save alpha and n parameters if fit is
//for integrated bins in y and pT:
if(iPTBin == 0)
SaveCBParameters(iRapBin, iPTBin, alpha, n, fRECO->GetParError(6), fRECO->GetParError(5));
Double_t mean2S = mean1S*(massPDG2S/massPDG1S);
Double_t mean3S = mean1S*(massPDG3S/massPDG1S);
Double_t sigma2S = sigma1S*(massPDG2S/massPDG1S);
Double_t sigma3S = sigma1S*(massPDG3S/massPDG1S);
printf("=========================================\n");
printf("Calculate the number of Y's in the sample\n");
printf("=========================================\n");
TF1 *CB[kNbSpecies];
Double_t intCBFit[kNbSpecies]; //integral values of a CB with N=Nfit and fixed alpha, n, sigma, width
for(int iUps = 0; iUps < kNbSpecies; iUps++){
sprintf(name, "CB_%d", iUps);
CB[iUps] = new TF1(name, CBFunction, range_min, range_max, 5);
CB[iUps]->SetParameter(0, 1.);
if(iUps == 0){
CB[iUps]->FixParameter(1, mean1S);
CB[iUps]->FixParameter(2, sigma1S);
}
else if(iUps == 1){
CB[iUps]->FixParameter(1, mean2S);
CB[iUps]->FixParameter(2, sigma2S);
}
else if(iUps == 2){
CB[iUps]->FixParameter(1, mean3S);
CB[iUps]->FixParameter(2, sigma3S);
}
CB[iUps]->FixParameter(3, alpha);
CB[iUps]->FixParameter(4, n);
intCB[iUps] = CB[iUps]->Integral(range_min, range_max);
}
nY[UPS1S] = normY1S * intCB[UPS1S];
nY[UPS2S] = normY2S * intCB[UPS2S];
nY[UPS3S] = normY3S * intCB[UPS3S];
printf("rapidity bin %d, pT bin %d\n", iRapBin, iPTBin);
printf("the integral of the fitted CB for the %s is: %1.3e --> #%s = %1.3e\n", specName[UPS1S], intCB[UPS1S], specName[UPS1S], nY[UPS1S]);
printf("the integral of the fitted CB for the %s is: %1.3e --> #%s = %1.3e\n", specName[UPS2S], intCB[UPS2S], specName[UPS2S], nY[UPS2S]);
printf("the integral of the fitted CB for the %s is: %1.3e --> #%s = %1.3e\n", specName[UPS3S], intCB[UPS3S], specName[UPS3S], nY[UPS3S]);
//calculate the fraction of BG in a given mass interval
massMin[UPS1S] = mean1S - nSigma*sigma1S;
massMin[UPS2S] = mean2S - nSigma*sigma2S;
massMin[UPS3S] = mean3S - nSigma*sigma3S;
massMax[UPS1S] = mean1S + nSigma*sigma1S;
massMax[UPS2S] = mean2S + nSigma*sigma2S;
massMax[UPS3S] = mean3S + nSigma*sigma3S;
for(int iSpecies = 0; iSpecies < kNbSpecies; iSpecies++){
printf("integrating histos between %1.3f and %1.3f GeV (+- %1.1f sigma window)\n",
massMin[iSpecies], massMax[iSpecies], nSigma);
}
fUps1S = new TF1("fUps1S", CBFunction, range_min, range_max, 5);
fUps1S->FixParameter(0, normY1S * binWidth);
fUps1S->FixParameter(1, mean1S);
fUps1S->FixParameter(2, sigma1S);
fUps1S->FixParameter(3, alpha);
fUps1S->FixParameter(4, n);
fUps2S = new TF1("fUps2S", CBFunction, range_min, range_max, 5);
fUps2S->FixParameter(0, normY2S * binWidth);
fUps2S->FixParameter(1, mean2S);
fUps2S->FixParameter(2, sigma2S);
fUps2S->FixParameter(3, alpha);
fUps2S->FixParameter(4, n);
fUps3S = new TF1("fUps3S", CBFunction, range_min, range_max, 5);
fUps3S->FixParameter(0, normY3S * binWidth);
fUps3S->FixParameter(1, mean3S);
fUps3S->FixParameter(2, sigma3S);
fUps3S->FixParameter(3, alpha);
fUps3S->FixParameter(4, n);
Double_t nUps[kNbSpecies];
nUps[UPS1S] = fUps1S->Integral(massMin[UPS1S], massMax[UPS1S]);
nUps[UPS2S] = fUps2S->Integral(massMin[UPS2S], massMax[UPS2S]);
nUps[UPS3S] = fUps3S->Integral(massMin[UPS3S], massMax[UPS3S]);
fBG = new TF1("fBG", DrawContinuum, range_min, range_max, 3);
for(int iPar = 0; iPar < 3; iPar++){
fBG->FixParameter(iPar, fitParBG[iPar]);
fBG->SetParError(iPar, fitParBGerr[iPar]);
// printf("fBG par %f +- %f\n", fBG->GetParameter(iPar), fBG->GetParError(iPar));
}
Double_t nBG[kNbSpecies];
nBG[UPS1S] = fBG->Integral(massMin[UPS1S], massMax[UPS1S]);
nBG[UPS2S] = fBG->Integral(massMin[UPS2S], massMax[UPS2S]);
nBG[UPS3S] = fBG->Integral(massMin[UPS3S], massMax[UPS3S]);
/* intCB[UPS3S] = CB[UPS3S]->Integral(massMin[UPS3S], massMax[UPS3S]);
intCB[UPS2S] = CB[UPS2S]->Integral(massMin[UPS3S], massMax[UPS3S]);
intCB[UPS1S] = CB[UPS1S]->Integral(massMin[UPS3S], massMax[UPS3S]);
nY[UPS3S] = normY3S * intCB[UPS3S];
nY[UPS2S] = normY2S * intCB[UPS2S];
nY[UPS1S] = normY1S * intCB[UPS1S];
printf("3S region:::1sigma integral CB3S = %1.3f, normY3S = %1.3f, nY3S = %1.3f\n",intCB[UPS3S] ,normY3S,nY[UPS3S]);
printf("3S region:::1sigma integral CB2S = %1.3f, normY2S = %1.3f, nY2S = %1.3f\n",intCB[UPS2S] ,normY2S,nY[UPS2S]);
printf("3S region:::1sigma integral CB1S = %1.3f, normY1S = %1.3f, nY1S = %1.3f\n",intCB[UPS1S] ,normY1S,nY[UPS1S]);
printf("3S region:::1sigma integral BKG = %1.3f, normBkg = %1.3f, nBkg = %1.3f\n",fBG->Integral(massMin[UPS3S], massMax[UPS3S]) ,1/binWidth,fBG->Integral(massMin[UPS3S], massMax[UPS3S])/binWidth);
printf("3S region:::1sigma CB3S background fraction = %1.3f\n",fBG->Integral(massMin[UPS3S], massMax[UPS3S])/binWidth/(fBG->Integral(massMin[UPS3S], massMax[UPS3S])/binWidth+nY[UPS1S]+nY[UPS2S]+nY[UPS3S]));
printf("3S region:::1sigma NumEvents = %1.3f\n",fBG->Integral(massMin[UPS3S], massMax[UPS3S])/binWidth+nY[UPS1S]+nY[UPS2S]+nY[UPS3S]);
intCB[UPS3S] = CB[UPS3S]->Integral( range_min, range_max);
intCB[UPS2S] = CB[UPS2S]->Integral( range_min, range_max);
intCB[UPS1S] = CB[UPS1S]->Integral( range_min, range_max);
nY[UPS3S] = normY3S * intCB[UPS3S];
nY[UPS2S] = normY2S * intCB[UPS2S];
nY[UPS1S] = normY1S * intCB[UPS1S];
printf("3S region:::FullRegion integral CB3S = %1.3f, normY3S = %1.3f, nY3S = %1.3f\n",intCB[UPS3S] ,normY3S,nY[UPS3S]);
printf("3S region:::FullRegion integral CB2S = %1.3f, normY2S = %1.3f, nY2S = %1.3f\n",intCB[UPS2S] ,normY2S,nY[UPS2S]);
printf("3S region:::FullRegion integral CB1S = %1.3f, normY1S = %1.3f, nY1S = %1.3f\n",intCB[UPS1S] ,normY1S,nY[UPS1S]);
printf("3S region:::FullRegion integral background = %1.3f\n",fBG->Integral(range_min, range_max)/binWidth);
printf("3S region:::FullRegion NumEvents = %1.3f\n",fBG->Integral(range_min, range_max)/binWidth+nY[UPS1S]+nY[UPS2S]+nY[UPS3S]);
double tempBfrac=fBG->Integral(massMin[UPS3S], massMax[UPS3S])/(fBG->Integral(massMin[UPS3S], massMax[UPS3S])+fUps1S->Integral(massMin[UPS3S], massMax[UPS3S])+fUps2S->Integral(massMin[UPS3S], massMax[UPS3S])+fUps3S->Integral(massMin[UPS3S], massMax[UPS3S]));
printf("3S region:::1sigma fUps background fraction = %1.3f\n",tempBfrac);
*/
if(iRapBin == 0 || iPTBin == 0)
printf("rapidity bin %d, pTBin %d\n", iRapBin, iPTBin);
else{
printf("rapidity bin %d (%1.1f - %1.1f), pT bin %d (%1.0f - %1.0f GeV/c)\n",
iRapBin, onia::rapForPTRange[iRapBin-1], onia::rapForPTRange[iRapBin],
iPTBin, onia::pTRange[iRapBin][iPTBin-1], onia::pTRange[iRapBin][iPTBin]);
}
FILE *fInfo = fopen("tmpFiles/statistics.txt", "a");
if(iRapBin == 0 || iPTBin == 0)
fprintf(fInfo, "rapidity bin %d, pTBin %d\n", iRapBin, iPTBin);
else{
fprintf(fInfo, "rapidity bin %d (%1.1f - %1.1f), pT bin %d (%1.0f - %1.0f GeV/c)\n",
iRapBin, onia::rapForPTRange[iRapBin-1], onia::rapForPTRange[iRapBin],
iPTBin, onia::pTRange[iRapBin][iPTBin-1], onia::pTRange[iRapBin][iPTBin]);
}
for(int iSpecies = 0; iSpecies < kNbSpecies; iSpecies++){
fracBG[iSpecies] = nBG[iSpecies] / (nBG[iSpecies] + nUps[iSpecies]);
// printf("nUps = %1.3f\n", nUps[iSpecies]);
// printf("nBG = %1.3f\n", nBG[iSpecies]);
printf("%s: fraction of BG in a +- %1.1f sigma window is %1.3f (not correct)\n",specName[iSpecies], nSigma, fracBG[iSpecies]);
printf("%s: Number of BG events in a +- %1.1f sigma window is %1.3f, number of signal events is %1.3f\n",nSigma, nBG[iSpecies], nUps[iSpecies]);
fprintf(fInfo, "integral of the fitted CB for the %s is (norm factor= %1.3e): %7.0f\n", specName[iSpecies], intCB[iSpecies], nY[iSpecies]);
}
fclose(fInfo);
// if(iPTBin > 0 && iRapBin > 0)
if(iPTBin > -1 && iRapBin > -1)
SaveFitPars(iRapBin, iPTBin);
}
void fitGausExample()
{
int bins = 100;
int min = 0;
int max = 1600;
sigMin = 500;
sigMax = 800;
double bgMin = 100;
double bgMax = 1300;
double xpos;
TCanvas *testCanvas = new TCanvas("testCanvas","testCanvas",600,400); //x,y
pad1 = new TPad("pad1","pad1",0.0000,0.0000,1.0000,1.0000,0,0,0);
pad1->Draw();
pad1->cd();
TH1F *h1 = new TH1F("h1","Fitting Example",bins,min,max);
TH1F *h2 = new TH1F("h2","h2",bins,min,max);
TH1F *h3 = new TH1F("h3","Fitting Example",bins,min,max);
TH1F *bg = new TH1F("bg","bg",bins,min,max);
// The section below will fill h1 with a guassian
// function with a mean of 670 and a sigma of 20
// and fill h2 with a "uniform" random background
// from bgMin<x<bgMax
for (int i=0; i<10000000; i++)
{
// h1->Fill(gRandom->Uniform(10,1400));
h1->Fill(gRandom->Uniform(0,1600));
h1->Fill(gRandom->Exp(1400));
}
for (int i=0; i<100000; i++)
{
// h1->Fill(gRandom->Uniform(1400,1500));
}
for (int i=0; i<50000; i++)
{
h1->Fill(gRandom->Gaus(670,20));
}
for (int i=0; i<bins; i++)
{
// xpos = i*((max-min)/bins)+min;
// cout << "xpos: " << xpos << endl;
// h1->Fill(xpos,100*exp((-1)*xpos));
// h2->Fill(i*((max-min)/bins)+min,i*500);
}
// h1->Add(h2,-1);
h1->SetMinimum(0);
h1->SetMaximum(300000);
h1->Draw();
TF1 *bgFit = new TF1("bgFit","[0]+[1]*x",bgMin,bgMax);
// TF1 *bgFit = new TF1("bgFit","expo",bgMin,bgMax);
// TF1 *bgFit = new TF1("bgFit","exp([1]*x+[0])+[2]",bgMin,bgMax);
TF1 *bgFit = new TF1("bgFit",fline,bgMin,sigMin,3);
bgFit->SetLineColor(kOrange);
bgFit->SetParameter(0,1);
bgFit->SetParameter(1,1/1600);
bgFit->SetParameter(2,1);
bgFit->SetParName(0,"Offset");
bgFit->SetParName(1,"Tau");
bgFit->SetParName(2,"Background");
reject = kTRUE;
h1->Fit(bgFit,"R");
reject = kFALSE;
TF1 *fleft = new TF1("fleft",fline,bgMin,sigMin,3);
fleft->SetLineColor(kOrange);
fleft->SetParameters(bgFit->GetParameters());
h1->GetListOfFunctions()->Add(fleft);
gROOT->GetListOfFunctions()->Remove(fleft);
TF1 *fright = new TF1("fright",fline,sigMax,bgMax,3);
fright->SetLineColor(kOrange);
fright->SetParameters(bgFit->GetParameters());
h1->GetListOfFunctions()->Add(fright);
gROOT->GetListOfFunctions()->Remove(fright);
// h1->SetMaximum(300000);
h1->Draw();
double fitOffset = bgFit->GetParameter(0);
double fitTau = bgFit->GetParameter(1);
// double fitBackground = bgFit->GetParameter(2);
double fitOffsetErr = bgFit->GetParError(0);
double fitTauErr = bgFit->GetParError(1);
// double fitBackgroundErr = bgFit->GetParError(2);
cout << "Number of Bins: " << h1->GetSize()-2 << endl;;
cout << "fitOffset: " << fitOffset << endl;;
cout << "fitTau: " << fitTau << endl;;
for (int i=0; i<(h1->GetSize()-2); i++)
{
xpos = i*((max-min)/bins)+min;
// h2->Fill(xpos,i*500);
bg->Fill(xpos,(fitOffset + fitTau*xpos));
// bg->Fill(xpos,(exp(fitTau*xpos + fitOffset) + fitBackground));
}
bg->SetLineColor(kBlue);
bg->Draw("same");
h3->Add(h1);
h3->Add(bg,-1);
h3->SetLineColor(kRed);
h3->SetMinimum(0);
h3->Draw("same");
cout << "sigMin: " << sigMin << ", sigMax: " << sigMax << endl;
TF1 *sigFit = new TF1("sigFit","gaus",sigMin,sigMax);
sigFit->SetLineColor(kBlue);
sigFit->SetParameter(0,1000);
sigFit->SetParameter(1,690);
sigFit->SetParameter(2,20);
sigFit->SetParameter(3,1);
sigFit->SetParName(0,"Weight");
sigFit->SetParName(1,"Mean");
sigFit->SetParName(2,"Sigma");
// sigFit->SetParName(3,"Background");
h3->SetMaximum(300000);
h3->Fit(sigFit,"R");
sigFit->Draw("same");
double fitWeight = sigFit->GetParameter(0);
double fitMean = sigFit->GetParameter(1);
double fitSigma = sigFit->GetParameter(2);
double fitWeightErr = sigFit->GetParError(0);
double fitMeanErr = sigFit->GetParError(1);
double fitSigmaErr = sigFit->GetParError(2);
fitResults = new TPaveText(0.11,0.70,0.4,0.89,"NDC");
TString WeightStr = "Weight = ";
WeightStr += fitWeight;
WeightStr += " ± ";
WeightStr += fitWeightErr;
TString MeanStr = "Mean = ";
MeanStr += fitMean;
MeanStr += " ± ";
MeanStr += fitMeanErr;
TString SigmaStr = "Sigma = ";
SigmaStr += sqrt(fitSigma*fitSigma);
SigmaStr += " ± ";
SigmaStr += fitSigmaErr;
TString OffsetStr = "Offset = ";
OffsetStr += fitOffset;
OffsetStr += " ± ";
OffsetStr += fitOffsetErr;
TString TauStr = "Tau = ";
TauStr += fitTau;
TauStr += " ± ";
TauStr += fitTauErr;
TString BackgroundStr = "BackgroundConst = ";
BackgroundStr += fitBackground;
BackgroundStr += " ± ";
BackgroundStr += fitBackgroundErr;
TText *t1 = fitResults->AddText(WeightStr);
TText *t2 = fitResults->AddText(MeanStr);
TText *t3 = fitResults->AddText(SigmaStr);
TText *t4 = fitResults->AddText(BackgroundStr);
TText *t5 = fitResults->AddText(TauStr);
TText *t6 = fitResults->AddText(OffsetStr);
h1->Draw("same");
TString theFitStr = "(";
theFitStr += fitWeight;
theFitStr += "*exp(-0.5*((x-";
theFitStr += fitMean;
theFitStr += ")/";
theFitStr += fitSigma;
theFitStr += ")^2))+";
theFitStr += fitBackground;
theFitStr += "+exp(";
theFitStr += fitTau;
theFitStr += "*x+";
theFitStr += fitOffset;
theFitStr += ")";
TF1 *theFit = new TF1("theFit",theFitStr,bgMin,bgMax);
theFit->SetLineColor(kMagenta);
theFit->Draw("same");
double integralOfPeak;
integralOfPeak = sigFit->Integral((fitMean - 3*sqrt(fitSigma*fitSigma)),(fitMean + 3*sqrt(fitSigma*fitSigma)));
TString peakInt = "Integral of Peak: ";
peakInt += integralOfPeak;
cout << peakInt << endl;
TText *t7 = fitResults->AddText(peakInt);
pad1->Update();
TString outputPlotsHere = "/home/ellie/physics/e05-102/analysis-scripts/devel/test_stuff/";
TString testOutTitle = outputPlotsHere;
testOutTitle += "test_out_step_1";
testOutTitle += ".svg";
fitResults->Draw("same");
}
void fit(const char *run="428211_429133_5s",
int key=1, int bmin=10, bool draw=true, bool pa=false) {
int minentries=1000;
gSystem->Exec( Form("mkdir -p %s/SEN%03d",run,key/128) );
gSystem->Exec( Form("mkdir -p %s/SEN%03d",run,key/128) );
int state = findstate(key);
printf("state %d\n",state);
// data
TString inname = Form("%s/adc/HI_KEY%05d.root",run,key);
TString outname = Form("HI_KEY%05d",key);
TFile *file = new TFile( inname.Data() );
cout << inname.Data() << endl;
TH1D *out = (TH1D*) file->Get("out");
double xfit_min=out->GetBinLowEdge(bmin);
double xfit_max=122.5;
int bmax = out->GetXaxis()->FindBin(xfit_max);
int entries = out->Integral(bmin,bmax);
if(entries<minentries) {
cout << "not enough entries: ";
cout << entries << endl;
return;
}
// fit
TCanvas *main = new TCanvas("main","main");
int pkt=0;
if(pa)
pkt = (key%(8*4*12*64))/(4*12*64);
TF1 *fitH = GetFit( Form("%s/SEN%03d/%s.dat",run,key/128,outname.Data()) ,pkt,xfit_min);
out->Fit(fitH,"MELIR","",xfit_min,xfit_max);
TF1 *MIPH1 = GetMIP(fitH,1,kCyan-3);
TF1 *MIPH2 = GetMIP(fitH,2,kGreen-3);
TF1 *MIPH3 = GetMIP(fitH,3,kOrange-3);
TF1 *MIPH4 = GetMIP(fitH,4,kMagenta-3);
TF1 *BGR = GetBGR(fitH,xfit_min);
double amp = fitH->GetParameter(0);
double eamp= fitH->GetParError(0);
double lda = fitH->GetParameter(1);
double elda= fitH->GetParError(1);
double sg1 = fitH->GetParameter(2);
double esg1= fitH->GetParError(2);
double fr2 = fitH->GetParameter(3);
double efr2= fitH->GetParError(3);
double fr3 = fitH->GetParameter(4);
double efr3= fitH->GetParError(4);
double fr4 = fitH->GetParameter(5);
double efr4= fitH->GetParError(5);
double fr1 = 1 - fr2 - fr3 - fr4;
double ncs = fitH->GetChisquare()/fitH->GetNDF();
double ba = fitH->GetParameter(6);
double eba= fitH->GetParError(6);
double bsl = fitH->GetParameter(7);
double ebsl= fitH->GetParError(7);
// saving fit
ofstream outfit;
outfit.open( Form("%s/SEN%03d/%s.dat",run,key/128,outname.Data()) );
outfit << amp << " " << eamp << endl;
outfit << lda << " " << elda << endl;
outfit << sg1 << " " << esg1 << endl;
outfit << fr2 << " " << efr2 << endl;
outfit << fr3 << " " << efr3 << endl;
outfit << fr4 << " " << efr4 << endl;
outfit << ba << " " << eba << endl;
outfit << bsl << " " << ebsl << endl;
outfit << ncs << endl;
outfit.close();
cout << "Parameters saved to ";
cout << outname.Data() << ".dat" << endl;
// draw
if(!draw) return;
gStyle->SetOptFit(0);
gStyle->SetOptStat(0);
out->Draw("HE");
double ymax = out->GetBinContent( out->FindBin(xfit_min) )*1.5;
out->GetYaxis()->SetRangeUser(0.5,ymax);
out->GetXaxis()->SetRangeUser(-5,125);
out->Sumw2();
out->SetLineColor(kBlack);
out->SetMarkerStyle(20);
out->SetTitle("");
out->GetXaxis()->SetTitle("ADC-PED (a.u.)");
BGR->Draw("SAME");
MIPH1->Draw("SAME");
MIPH2->Draw("SAME");
MIPH3->Draw("SAME");
MIPH4->Draw("SAME");
fitH->SetRange(xfit_min,xfit_max);
fitH->Draw("SAME");
TLatex *text = new TLatex();
text->DrawLatex(0, (1.03*(ymax)), inname.Data() );
text->DrawLatex(30, (0.83*(ymax)), Form("Entries %d",entries) );
text->DrawLatex(30, (0.73*(ymax)), Form("State %d",state) );
text->DrawLatex(30, (0.53*(ymax)), Form("#lambda %.1f #pm %.1f",lda,elda) );
text->DrawLatex(30, (0.43*(ymax)), Form("#sigma %.1f #pm %.1f",sg1,esg1) );
text->SetTextColor(kRed-3);
text->DrawLatex(30, (0.63*(ymax)), Form("#Chi^{2} / NDF %.2f",ncs) );
text->SetTextColor(kBlue-3);
text->DrawLatex(75, (0.73*(ymax)), Form("#Alpha %.0f #pm %.0f",fitH->GetParameter(0),fitH->GetParError(0)) );
text->SetTextColor(kCyan-3);
text->DrawLatex(75, (0.63*(ymax)), Form("f_{1} %.2f",fr1) );
text->SetTextColor(kGreen-3);
text->DrawLatex(75, (0.53*(ymax)), Form("f_{2} %.2f #pm %.2f",fr2,efr2) );
text->SetTextColor(kOrange-3);
text->DrawLatex(75, (0.43*(ymax)), Form("f_{3} %.2f #pm %.2f",fr3,efr3) );
text->SetTextColor(kMagenta-3);
text->DrawLatex(75, (0.33*(ymax)), Form("f_{4} %.2f #pm %.2f",fr4,efr4) );
text->SetTextColor(kGray);
text->DrawLatex(75, (0.83*(ymax)), Form("b %.2f",bsl) );
text->SetTextColor(kBlack);
text->SetTextSize(0.035);
text->SetTextColor( kRed-3 );
text->DrawLatex(30, (0.93*(ymax)), "e^{bx} + #Alpha ( f_{1} L_{1}(x) + f_{2} L_{2}(x) + f_{3} L_{3}(x) + f_{4} L_{4}(x))");
main->SaveAs( Form("%s/SEN%03d/%s.eps",run,key/128,outname.Data()), "eps" );
return;
}
void SPEFit(char * fLEDname, char * fPEDname, int run, int LED_amp, double cutmax = 250.0)
{
//set plotting styles
gStyle->SetCanvasColor(0);
gStyle->SetPadColor(0);
gStyle->SetCanvasBorderMode(0);
gStyle->SetFrameBorderMode(0);
gStyle->SetStatColor(0);
gStyle->SetPadTickX(1);
gStyle->SetPadTickY(1);
//set file names
stringstream out_fname;
stringstream out_fname1;
out_fname<<"SPEconstants_Run_"<<run<<".txt";
out_fname1<<"SPEspec_Run_"<<run<<".txt";
ofstream constants_file(out_fname.str().c_str(),ios_base::trunc);
//ofstream constants_file1(out_fname1.str().c_str(),ios_base::trunc);
constants_file<<"Run "<<run<<endl;
constants_file<<"type SPE"<<endl;
constants_file<<"LED_amplitude "<<LED_amp<<endl<<endl;
constants_file<<endl<<"LED_amplitude Depth Phi Eta Ped_mean Ped_mean_err Ped_RMS Ped_RMS_err SPEPeak_RMS SPEPeak_RMS_err Gain Gain_err Normalized_Chi2 MeanPE_fit MeanPE_fit_err MeanPE_estimate PE5flag"<<endl;
out_fname.str("");
out_fname<<"SPEdistributions_Run_"<<run<<".txt";
out_fname.str("");
out_fname<<"SPEextra_Run_"<<run<<".txt";
//ofstream extra_file(out_fname.str().c_str(),ios_base::trunc);
double scale = 1.0;
scale = 2.6; //Need to scale up HF charge
double fC2electrons = 6240.; //convert fC to #electrons
char spename[128], pedname[128], spehistname[128];
TFile *tfLED = new TFile(fLEDname);
TFile *tfPED = new TFile(fPEDname);
//const int NnewBins = 106;
//double binsX[NnewBins] = {0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,38,40,42,44,46,48,50,52,54,56,58,60,62,64,66,68,70,72,74,76,78,80,82,84,86,88,90,92,94,96,98,100,102,104,106,108,110,112,114,116,118,120,122,124,126,128,130,132,134,136,138,140,142,144,146,148,150,152,154,156,158,160,162,164,166,168,170,180,190,200,210,220,230,240,250,266,282,298,316,336,356,378,404,430,456,482,500};
const int NnewBins = 80;
double binsX[NnewBins] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54,57,60,63,66,69,72,75,78,81,84,87,90,93,96,99,102,105,108,111,114,117,120,123,126,129,132,135,138,141,144,147,150,153,156,159,162,165,168,171,174,177,180,190,200,210,220,230,240,250,266,282,298,316,336,356,378,404,430,456,482,500};
TH1F* hspe = new TH1F("hspe","hspe",NnewBins-1,binsX);
int NDepth = 2; //number of depths
int MinDepth = 1;
int MaxDepth = 2;
int MinEta = 29;
int MaxEta = 41;
int MinPhi = 41;
int MaxPhi = 53;
TCanvas *Carray[NDepth+1][MaxPhi+1];
bool drawflag[NDepth+1][MaxPhi+1];
TH1F *LED[NDepth+1][MaxEta+1][MaxPhi+1];
TH1F *PED[NDepth+1][MaxEta+1][MaxPhi+1];
for(int iDepth = MinDepth; iDepth <= MaxDepth; iDepth++){
for(int iPhi = MinPhi; iPhi <= MaxPhi; iPhi++){
bool nonNull = false;
for(int iEta = MinEta; iEta <= MaxEta; iEta++){
sprintf(spename,"Analyzer/CommonDir/ResPlotDir/Histo_for_Depth_%d_Eta_%d_Phi_%d",iDepth,iEta,iPhi);
LED[iDepth][iEta][iPhi]=(TH1F *)tfLED->Get(spename);
if(LED[iDepth][iEta][iPhi]) nonNull = true;
sprintf(spename,"Analyzer/CommonDir/ResPlotDir/Histo_for_Depth_%d_Eta_%d_Phi_%d",iDepth,iEta,iPhi);
PED[iDepth][iEta][iPhi]=(TH1F *)tfPED->Get(spename);
}
drawflag[iDepth][iPhi] = false;
char canvname[16];
sprintf(canvname, "c_%d_%d", iDepth,iPhi);
if(nonNull){ //only create canvas if distributions exist
Carray[iDepth][iPhi] = new TCanvas(canvname,canvname,1200,700);
Carray[iDepth][iPhi]->Divide(5,3);
}
}
}
int HV=0;
for(int iDepth = MinDepth; iDepth <= MaxDepth; iDepth++){
for(int iPhi = MinPhi; iPhi <= MaxPhi; iPhi++){
for(int iEta = MinEta; iEta <= MaxEta; iEta++){
//cout<<iDepth<<" "<<iPhi<<" "<<iEta<<endl;
if(!LED[iDepth][iEta][iPhi]) continue;
sprintf(spehistname,"led %d %d %d",iDepth,iEta,iPhi);
TH1F *hspe_temp = (TH1F *)LED[iDepth][iEta][iPhi]->Clone(spehistname);
sprintf(spehistname,"ped %d %d %d",iDepth,iEta,iPhi);
TH1F *hped = (TH1F *)PED[iDepth][iEta][iPhi]->Clone(spehistname);
hspe->Reset();
sprintf (spehistname, "SumLED_Depth_%d_Eta_%d_Phi_%d",iDepth,iEta,iPhi);
hspe->SetTitle(spehistname);
//combine bins of original SPE histogram
for(int ib=1; ib<=hspe_temp->GetNbinsX(); ib++) {
double bin_center = hspe_temp->GetBinCenter(ib);
if(bin_center>hspe->GetXaxis()->GetXmax()) continue;
int newbin = hspe->FindBin(bin_center);
double new_content = hspe->GetBinContent(newbin) + hspe_temp->GetBinContent(ib);
double new_error = sqrt(pow(hspe->GetBinError(newbin),2)+pow(hspe_temp->GetBinError(ib),2));
hspe->SetBinContent(newbin,new_content);
hspe->SetBinError(newbin,new_error);
}
TH1F* hspe_unscaled = (TH1F*)hspe->Clone("hspe_unscaled");
//renormalize bins of new SPE histogram
for(int ib=1; ib<=hspe->GetNbinsX(); ib++) {
double new_content = hspe->GetBinContent(ib)/hspe->GetXaxis()->GetBinWidth(ib)*hspe_temp->GetXaxis()->GetBinWidth(1);
double new_error = hspe->GetBinError(ib)/hspe->GetXaxis()->GetBinWidth(ib)*hspe_temp->GetXaxis()->GetBinWidth(1);
hspe->SetBinContent(ib,new_content);
hspe->SetBinError(ib,new_error);
}
if(hspe_temp->Integral()==0) continue;
else drawflag[iDepth][iPhi] = true;
Nev = hspe_temp->Integral()*hspe_temp->GetXaxis()->GetBinWidth(1);
TF1 *fped = new TF1("fped","gaus",0, 80);
hped->Fit(fped,"NQR");
double pploc = fped->GetParameter(1), ppwidth = fped->GetParameter(2);
hspe->Fit(fped, "NQ", "", pploc - 3*ppwidth, pploc + ppwidth);
//estimate SPE peak location
int max_SPE_bin, maxbin, Nbins;
double max_SPE_height=0, minheight, max_SPE_location;
bool minflag = false;
maxbin=hspe->FindBin(fped->GetParameter(1)); //location of pedestal peak
minheight=hspe->GetBinContent(maxbin); //initialize minheight
Nbins = hspe->GetNbinsX();
for(int j=maxbin+1; j<Nbins-1; j++) { //start from pedestal peak and loop through bins
if(hspe->GetBinContent(j) > minheight && !minflag) minflag=true; //only look for SPE peak when minflag=true
if(hspe->GetBinContent(j) < minheight ) minheight = hspe->GetBinContent(j);
if(minflag && hspe->GetBinContent(j) > max_SPE_height){
max_SPE_bin = j;
max_SPE_location = hspe->GetBinCenter(max_SPE_bin);
max_SPE_height = hspe->GetBinContent(j);
}
} //start from pedestal peak and loop through bins
//find minimum bin between pedestal and SPE peaks
hspe->GetXaxis()->SetRange(maxbin,max_SPE_bin);
int minbin = hspe->GetMinimumBin();
double minbin_location = hspe->GetBinCenter(minbin);
hspe->GetXaxis()->SetRange(1,Nbins);
TF1 *fit = new TF1("fit", FitFun, 0, 500, 5);
double mu = - log(fped->Integral(0,100)/Nev);
if(mu<0) mu=0.01;
double gain_est = max_SPE_location-1.0*fped->GetParameter(1);
if(max_SPE_bin > (minbin+1)) fit->SetParameters(mu, 20, 1, gain_est, gain_est*0.5);
else fit->SetParameters(mu, 20, 1, 2.1*fped->GetParameter(2), 10); //case of no clear minimum; start looking for SPE peak at 2sigma away from pedestal peak
fit->SetParLimits(0, 0, 10);
fit->FixParameter(1, fped->GetParameter(1));
fit->FixParameter(2, fped->GetParameter(2));
fit->SetParLimits(3, fped->GetParameter(2)*2, 350);
fit->SetParLimits(4, fped->GetParameter(2)*1.01, 250);
double maxfitrange = 500.;
double minfitrange = 0.;
hspe->Fit(fit, "MNQL", "", minfitrange, maxfitrange);
maxfitrange = fped->GetParameter(1)+4*fit->GetParameter(3)+fit->GetParameter(4);
if(500<maxfitrange) maxfitrange = 500;
hspe->Fit(fit, "MNQL", "", minfitrange, maxfitrange);
//calculate NDOF of fit excluding bins with 0 entries
int myNDOF=-3; //three free parameters
for(int j=hspe->FindBin(minfitrange); j<=hspe->FindBin(maxfitrange); j++) { //loop through fitted spe bins
if(hspe->GetBinContent(j)) myNDOF++;
} //loop through fitted spe bins
//calculate means and integrals of the fit and data
double fint, fint_error, hint, favg, havg;
int temp_lowbin, temp_highbin;
temp_lowbin = hspe->FindBin(minfitrange);
temp_highbin = hspe->FindBin(maxfitrange);
hspe_unscaled->GetXaxis()->SetRangeUser(minfitrange, maxfitrange);
havg = hspe_unscaled->GetMean();
hint = hspe->Integral(temp_lowbin,temp_highbin,"width");
double min_frange = hspe->GetBinLowEdge(temp_lowbin);
favg = fit->Mean(min_frange, maxfitrange);
fint = fit->Integral(min_frange, maxfitrange);
//fint_error = fit->IntegralError(min_frange, maxfitrange);
double PE5int = 0; //integral of events with >=5 PE
double PE5loc = fped->GetParameter(1)+ 5*fit->GetParameter(3);
if(PE5loc>500) PE5int = 0;
else {
int PE5bin = hspe_temp->FindBin(PE5loc);
temp_highbin = hspe_temp->FindBin(maxfitrange)-1;
PE5int = hspe_temp->Integral(PE5bin,temp_highbin,"width");
}
int PE5flag = 0;
if(PE5int/hint>0.05) PE5flag = 1; //set flag if more than 5% of events in the fit correspond to >=5PE
//=========================================
//for(int i1=1;i1<hspe->GetNbinsX();i1++){
//constants_file1<<HV<<"\t"<<iDepth<<"\t"<<iEta<<"\t"<<iPhi<<"\t"<<2.6*hspe->GetBinCenter(i1)<<"\t"<<hspe->GetBinContent(i1)<<"\t"<<fit->Eval(hspe->GetBinCenter(i1))<<"\n";
//}
//=========================================
//printf("%d\n",myNDOF);
//output calibrations constants
//constants_file<<endl<<"LED_amplitude HV Spigot Channel Ped_mean Ped_mean_err Ped_RMS Ped_RMS_err SPEPeak_RMS SPEPeak_RMS_err Gain Gain_err Normalized_Chi2 MeanPE_fit MeanPE_fit_err MeanPE_estimate PE5flag"<<endl;
constants_file<<LED_amp<<" "<<iDepth<<" "<<iPhi<<" "<<iEta<<" "<<scale*fped->GetParameter(1)<<" "<<scale*fped->GetParError(1)<<" "<<scale*fped->GetParameter(2)<<" "<<scale*fped->GetParError(2)<<" "<<scale*fit->GetParameter(4)<<" "<<scale*fit->GetParError(4)<<" "<<scale*fit->GetParameter(3)*fC2electrons<<" "<<scale*fit->GetParError(3)*fC2electrons<<" "<<fit->GetChisquare()/myNDOF/*fit->GetNDF()*/<<" "<<fit->GetParameter(0)<<" "<<fit->GetParError(0)<<" "<<mu<<" "<<PE5flag<<endl;
/*
if(iDepth==2 && iPhi==53 && iEta==36){
cout<<iDepth<<" "<<iPhi<<" "<<iEta<<" "<<gain_est<<" "<<fit->GetParameter(3)<<endl;
cout<<LED_amp<<" "<<iDepth<<" "<<iPhi<<" "<<iEta<<" "<<scale*fped->GetParameter(1)<<" "<<scale*fped->GetParError(1)<<" "<<scale*fped->GetParameter(2)<<" "<<scale*fped->GetParError(2)<<" "<<scale*fit->GetParameter(4)<<" "<<scale*fit->GetParError(4)<<" "<<scale*fit->GetParameter(3)*fC2electrons<<" "<<scale*fit->GetParError(3)*fC2electrons<<" "<<fit->GetChisquare()/myNDOF<<" "<<fit->GetParameter(0)<<" "<<fit->GetParError(0)<<" "<<mu<<" "<<PE5flag<<endl;
}
*/
Carray[iDepth][iPhi]->cd(iEta-MinEta+1);
gPad->SetBorderMode(0);
gPad->SetBorderSize(0);
gPad->SetRightMargin(0.01);
gPad->SetBottomMargin(0.1);
gPad->SetLogy(true);
hspe->GetXaxis()->SetRangeUser(0, 200 /*300*//*508*/);
hspe->SetLineColor(kBlue);
hspe->DrawClone("hist");
fit->SetLineWidth(2);
fit->Draw("same");
}
if(drawflag[iDepth][iPhi]) { //draw plots of fit if data for the HV is present
stringstream plot_name;
plot_name<<"Plots/SPEFits_Run_"<<run<<"_Depth"<<iDepth<<"_Phi"<<iPhi<<".pdf";
Carray[iDepth][iPhi]->SaveAs(plot_name.str().c_str());
plot_name.str( std::string() );
}
}
}
constants_file.close();
//constants_file1.close();
}
//________________________________________________________________________________
void peaks(TH1* h, Int_t np=10, Int_t ij=0) {
if (! h) return;
npeaks = TMath::Abs(np);
if (! c1) c1 = new TCanvas();
else c1->Clear();
if (c2 && ij > 0) {c2->cd(ij); h->Draw(); c2->Update();}
c1->Divide(1,2);
c1->cd(1);
h->Draw();
TH1F *h2 = (TH1F*)h->Clone("h2");
//Use TSpectrum to find the peak candidates
TSpectrum *s = new TSpectrum(2*npeaks);
Int_t nfound = s->Search(h,5,"",0.05);
printf("Found %d candidate peaks to fit\n",nfound);
if (! nfound) return;
//Estimate background using TSpectrum::Background
TH1 *hb = s->Background(h,20,"same");
hb->Draw("same");
c1->Update();
if (c2 && ij > 0) {c2->cd(ij); h->Draw(); c2->Update();}
if (np <0) return;
//estimate linear background using a fitting method
c1->cd(2);
TF1 *fline = new TF1("fline","pol1",0,1000);
fline->FixParameter(1,0.);
h->Fit("fline","qnlw");
if (c2 && ij > 0) {c2->cd(ij+1); h->Draw(); c2->Update(); c1->cd(2);}
//Loop on all found peaks. Eliminate peaks at the background level
Double_t par[3000];
par[0] = fline->GetParameter(0);
par[1] = fline->GetParameter(1);
npeaks = 0;
Float_t *xpeaks = s->GetPositionX();
Float_t ymax = 0;
for (Int_t p=0;p<nfound;p++) {
Float_t xp = xpeaks[p];
Int_t bin = h->GetXaxis()->FindBin(xp);
Float_t yp = h->GetBinContent(bin);
if (yp-3*TMath::Sqrt(yp) < fline->Eval(xp)) continue;
par[3*npeaks+2] = yp;
if (yp > ymax) ymax = yp;
par[3*npeaks+3] = xp;
par[3*npeaks+4] = 3;
npeaks++;
}
cout << "Found " << npeaks << " useful peaks to fit" << endl;
Int_t NP = 0;
Int_t nbad = 0;
TString LineH(" {\""); LineH += h->GetName(); LineH += "\"";
TString Line("");
struct ParErr_t {Double_t par, err;};
ParErr_t parErr[10];
TF1 *fit = 0;
if (ymax > 2*par[0]) {
cout << "Now fitting: Be patient" << endl;
fit = new TF1("fit",fpeaks,0,1000,2+3*npeaks);
TVirtualFitter::Fitter(h2,10+3*npeaks); //we may have more than the default 25 parameters
fit->SetParameter(0,par[0]);
fit->FixParameter(1,0.);
for (Int_t p = 0; p < npeaks; p++) {
fit->SetParName(3*p+2,Form("A%i",p));
fit->SetParLimits(3*p+2,0,1e6);
fit->SetParameter(3*p+2,par[3*p+2]);
fit->SetParName(3*p+3,Form("#mu%i",p));
fit->SetParLimits(3*p+3,TMath::Max(0.,par[3*p+3]-2), TMath::Min(240.,par[3*p+3]+2));
fit->SetParameter(3*p+3,par[3*p+3]);
fit->SetParName(3*p+4,Form("#sigma%i",p));
fit->SetParLimits(3*p+4,0.01,20);
fit->SetParameter(3*p+4,par[3*p+4]);
}
fit->SetNpx(1000);
h2->SetStats(0);
h2->Fit("fit","l");
if (c2 && ij > 0) {c2->cd(ij); h2->Draw("same"); c2->Update(); c1->cd(2);}
fit->GetParameters(par);
for (Int_t p = 0; p<np;p++) {
if (p < npeaks && par[3*p+2] > 5*fit->GetParError(3*p+2) &&
par[3*p+2] > par[0]) {
if (TMath::Abs(par[3*p+4]) > 5.0) nbad++;
// Line += Form(",%f,%f,%7.2f,%5.2f",par[3*p+2],fit->GetParError(3*p+2),par[3*p+3],TMath::Abs(par[3*p+4]));
parErr[NP].par = par[3*p+3];
parErr[NP].err = TMath::Abs(par[3*p+4]);
for (Int_t i = 0; i < NP; i++) {
if (parErr[i].par > parErr[NP].par) {
ParErr_t temp = parErr[i];
parErr[i] = parErr[NP];
parErr[NP] = temp;
}
}
NP++;
}
}
}
for (Int_t p = 0; p < np; p++) {
if (p < NP) Line += Form(",%7.2f,%5.2f",parErr[p].par,parErr[p].err);
else Line += ",0,0";
}
Line += "},";
if (nbad > 1) NP = -NP; // reject whole hybrid
LineH += Form(",%3i",NP);
cout << LineH << Line << endl;
out << LineH << Line << endl;
c1->Update();
if (c2) c2->Update();
delete fit;
delete s;
}
int piRandom() {
TRandom r0;
TRandom1 r1;
TRandom2 r2;
TRandom3 r3;
//Random<GSLRngRand> r1;
// Random<GSLRngTaus> r2;
// Random<GSLRngRanLux> r3;
double n = NEVT;
int nloop = NLOOP;
double dy = 15/std::sqrt(n);
TH1D * h0 = new TH1D("h0","TRandom delta",100,-dy,dy);
TH1D * h1 = new TH1D("h1","TRandom1 delta",100,-dy,dy);
TH1D * h2 = new TH1D("h2","TRandom2 delta",100,-dy,dy);
TH1D * h3 = new TH1D("h3","TRandom3 delta",100,-dy,dy);
double sigma = std::sqrt( PI * (4 - PI)/n );
std::cout << "**********************************************************" << std::endl;
std::cout << " Generate " << int(n) << " for " << nloop << " times " << std::endl;
std::cout << "**********************************************************" << std::endl;
std::cout << "\tExpected Sigma = " << sigma << std::endl;
#define INTERACTIVE
#ifdef INTERACTIVE
double del, err;
TCanvas * c1 = new TCanvas("c1_piRandom","PI Residuals");
gStyle->SetOptFit(1111);
gStyle->SetOptLogy();
c1->Divide(2,2);
c1->cd(1);
generate(r0,h0);
h0->Fit("gaus");
h0->Draw();
TF1 * fg = (TF1*) h0->FindObject("gaus");
if (fg) {
del = (fg->GetParameter(2)-sigma);
err = fg->GetParError(2);
}
else { del = -999; err = 1; }
char text[20];
sprintf(text,"Spread %8.4f",del/err);
TPaveLabel * pl0 = new TPaveLabel(0.6,0.3,0.9,0.4,text,"brNDC");
pl0->Draw();
c1->cd(2);
generate(r1,h1);
h1->Fit("gaus");
h1->Draw();
fg = (TF1*) h1->FindObject("gaus");
if (fg) {
del = (fg->GetParameter(2)-sigma);
err = fg->GetParError(2);
}
else { del = -999; err = 1; }
sprintf(text,"Spread %8.4f",del/err);
TPaveLabel * pl1 = new TPaveLabel(0.6,0.3,0.9,0.4,text,"brNDC");
pl1->Draw();
c1->cd(3);
generate(r2,h2);
h2->Fit("gaus");
h2->Draw();
fg = (TF1*) h2->FindObject("gaus");
if (fg) {
del = (fg->GetParameter(2)-sigma);
err = fg->GetParError(2);
}
else { del = -999; err = 1; }
sprintf(text,"Spread %8.4f",del/err);
TPaveLabel * pl2 = new TPaveLabel(0.6,0.3,0.9,0.4,text,"brNDC");
pl2->Draw();
c1->cd(4);
generate(r3,h3);
h3->Fit("gaus");
h3->Draw();
fg = (TF1*) h3->FindObject("gaus");
if (fg) {
del = (fg->GetParameter(2)-sigma);
err = fg->GetParError(2);
}
else { del = -999; err = 1; }
sprintf(text,"Spread %8.4f",del/err);
TPaveLabel * pl3 = new TPaveLabel(0.6,0.3,0.9,0.4,text,"brNDC");
pl3->Draw();
#else
generate(r0,h0);
generate(r1,h1);
generate(r2,h2);
generate(r3,h3);
#endif
return 0;
}
I2GFvalues I2GFmainLoop(TH1F *htemp, int N_iter, float N_sigma_range, bool ShowFit)
//Arguments: (histo to be fit, N iterations to find peak using gaus fit, fit range param., do or do not plot fit on histo)
{
I2GFvalues myI2GFvalues;
//Set initial values...(in case fit fails)
myI2GFvalues.rchi2 = -100;
myI2GFvalues.mean = -100;
myI2GFvalues.mean_err = -100;
myI2GFvalues.sigma = -100;
myI2GFvalues.sigma_err = -100;
TSpectrum *s = new TSpectrum(); //TSpectrum(1,1)->Argument: (Number of peaks to find, Distance to neighboring peak: "1"-->3sigma)
Int_t NPeaks;
Float_t *Peak; //TSpectrum *s = new TSpectrum(); --> No warning message
Float_t *PeakAmp;
float peak_pos = 0;
float peak_pos_amp = 0; //Initial value, assuming positive going peaks
int peak_pos_bin = 0;
int binMaxCnt = 0;
float binMaxCnt_value = 0;
int binMaxCnt_counts = 0;
int Nbins = 0;
Int_t zero_value_bin = 0;
float low_limit = 0;
float high_limit = 0;
float peak_pos_count = 0;
float zero_bin_value = 0;
float max_bin_value = 0;
TF1 *func;
TF1 *func1;
TF1 *func2;
TF1 *func3;
float Chi2;
int NDF = 1;
float f_RChi2 = 1;
float f_const = 1;
float f_mean = 1;
float f_mean_err = 1;
float f_sigma = 1;
float f_sigma_err = 1;
float peak = 1;
float f_const2 = 1;
float f_mean2 = 1;
float f_mean_err2 = 1;
float f_sigma2 = 1;
float f_sigma_err2 = 1;
//---------Basic Histo Peak Finding Parameters----------
binMaxCnt = htemp->GetMaximumBin(); //Finds bin w/ max counts (can be dubious, so use TSpectrum)
binMaxCnt_value = (Double_t) htemp->GetXaxis()->GetBinCenter(binMaxCnt); //if the bin number is known and the bin value (in x-axis units) is wanted
binMaxCnt_counts = (Int_t) htemp->GetBinContent(binMaxCnt); //Finds counts within particular bin
//---------TSpectrum Peak Finding Parameters--------
if (ShowFit) NPeaks = s->Search(htemp, 2, "goff", 0.5); //opens a canvas (one time in a loop), even with: s->Search(htemp, 2, "nodraw", 0.9);
//else NPeaks = s->Search(htemp, 2, "", 0.5); //s->Search(htemp, 2, "nodraw", 0.9);
//Npeaks = s->GetNPeaks(); //If using this, need pointer in declaration above: Int_t *NPeaks
//N_peaks = Npeaks[0];
Peak = s->GetPositionX();
PeakAmp = s->GetPositionY();
for (int i=0; i<NPeaks; i++)
{
if (peak_pos_amp < PeakAmp[i])
{
peak_pos_amp = PeakAmp[i]; //TSpectrum finds peak counts
peak_pos = Peak[i]; //TSpectrum finds pos. of peak in x-axis units
}
}
peak_pos_bin = htemp->GetXaxis()->FindBin(peak_pos); //if the bin value (in x-axis units) is known and the bin number is wanted
peak_pos_count = htemp->GetBinContent(peak_pos_bin); //counts in particular bin
//------------------------------------------------------------------------------------------------------------------
zero_value_bin = htemp->GetXaxis()->FindBin(0.0); //if the bin value (in x-axis units) is known and the bin number is wanted
Nbins = htemp->GetSize() - 2; //total number of bins in histo
zero_bin_value = htemp->GetXaxis()->GetBinCenter(0); //if the bin number is known and the bin value (in x-axis units) is wanted.
max_bin_value = htemp->GetXaxis()->GetBinCenter(Nbins); //if the bin number is known and the bin value (in x-axis units) is wanted.
int TS = 0;
if (peak_pos >= zero_bin_value && peak_pos <= max_bin_value) //Make sure that TSpectrum peak is within histo range
{ //if not, use Par initial values from Basic Histo Peak Find
TS=1; //for cout below
low_limit = peak_pos - (0.1 * abs(max_bin_value-zero_bin_value)); //peakpos-10% of full range of histo
high_limit = peak_pos + (0.1 * abs(max_bin_value-zero_bin_value)); //peakpos+10% of full range of histo
func = new TF1("func", "gaus");
//func->FixParameter(1,0);
//func->SetParLimits(0, 0, 1000000);
func->SetParameter(0, peak_pos_count);
func->SetParameter(1, peak_pos);
}
else
{
low_limit = binMaxCnt_value - (0.1 * abs(max_bin_value-zero_bin_value)); //peakpos-10% of full range of histo
high_limit = binMaxCnt_value + (0.1 * abs(max_bin_value-zero_bin_value)); //peakpos+10% of full range of histo
func = new TF1("func", "gaus");
//func->SetParLimits(0, 0, 1000000);
func->SetParameter(0, binMaxCnt_counts);
func->SetParameter(1, binMaxCnt_value);
}
htemp->Fit("gaus", "Q0", "", low_limit, high_limit); //low_limit, high_limit); // To Show fit: htemp->Fit("gaus"); //better fit?-> Fit("gaus", "MQ", "", "", "");
func = htemp->GetFunction("gaus");
Chi2 = func->GetChisquare();
NDF = func->GetNDF();
if (NDF != 0) f_RChi2 = Chi2/NDF;
f_const = func->GetParameter(0);
f_mean = func->GetParameter(1);
f_mean_err = func->GetParError(1);
f_sigma = func->GetParameter(2);
f_sigma_err = func->GetParError(2);
/*
if (N_sigma_range == 7)
{
cout<<""<<endl;
cout<<"---Basic Histo Peak Find---"<<endl;
cout<<"binMaxCnt: "<<binMaxCnt<<endl;
cout<<"binMaxCnt_value: "<<binMaxCnt_value<<endl;
cout<<"binMaxCnt_counts: "<<binMaxCnt_counts<<endl;
cout<<""<<endl;
if (TS == 1) cout<<"---TSpectrum Peak Find: Succeeded!---"<<endl;
else cout<<"---TSpectrum Peak Find: Failed!---"<<endl;
cout<<"NPeaks: "<<NPeaks<<endl;
cout<<"peak_pos (find max peak): "<<peak_pos<<endl;
cout<<"peak_pos_amp (eval. amp of max peak) : "<<peak_pos_amp<<endl;
cout<<""<<endl;
cout<<"----------------------------------------"<<endl;
cout<<"peak_pos_bin: "<<peak_pos_bin<<endl;
cout<<"peak_pos_count: "<<peak_pos_count<<endl;
cout<<"zero_value_bin: "<<zero_value_bin<<", Nbins: "<<Nbins<<endl;
cout<<"zero_bin_value: "<<zero_bin_value<<", max_bin_value: "<<max_bin_value<<endl;
cout<<"low, high limit: "<<low_limit<<", "<<high_limit<<endl;
}
*/
//for (int i=0; i< (N_iter - 1); i++)
for (int i=0; i< 2; i++) //8 seems to work well, so let's keep it constant here.
{
//htemp->Fit("gaus", "", "",(f_mean - (N_sigma_range*f_sigma)), (f_mean + (N_sigma_range*f_sigma) ) ); //show fit
htemp->Fit("gaus", "Q0", "",(f_mean - (N_sigma_range*f_sigma)), (f_mean + (N_sigma_range*f_sigma) ) ); //don't show fit
func = htemp->GetFunction("gaus");
Chi2 = func->GetChisquare();
NDF = func->GetNDF();
if (NDF != 0) f_RChi2 = Chi2/NDF;
f_const = func->GetParameter(0);
f_mean = func->GetParameter(1);
f_mean_err = func->GetParError(1);
f_sigma = func->GetParameter(2);
cout << " sigma " << f_sigma << endl;
f_sigma_err = func->GetParError(2);
}
peak = func->GetParameter(0); //Amplitude
float bgd_h = 0.25; //background height ~ bgd_h*gaus_amp
func1 = new TF1("func1", "gaus");
//-----------Fit Parameter constraints not needed here (see below):
//func1->SetParLimits(0, 0, 1000000);
//func1->SetParameters(f_const, f_mean, f_sigma); //Here: (Par1 initial value, Par2 initial value, Par3 initial value, etc)
//func1->SetParameter(0, 200); //Here: Initial value of Par 0 = 200
//func1->SetParLimits(0, f_const*(1-bgd_h-0.2),f_const*(1-bgd_h+0.2) ); //Here: (Par_lower limit, Par upper limit)
//func1->SetParLimits(1, f_mean-(f_sigma/2),f_mean+(f_sigma/2) );
//func1->SetParLimits(2, f_sigma-(f_sigma/2),f_sigma+(f_sigma/2) );
func2 = new TF1("func2", "gaus");
//-----------Fit Parameter constraints not needed here (see below):
//func2->SetParameters(f_const/10, f_mean, 4*f_sigma); //(const, mean, sigma)
//func2->SetParLimits(0,-1,(0.1*peak_pos_amp) ); //(const)
//func2->SetParameters(1, f_mean, 4*f_sigma); //(mean)
//func2->SetParameters(2, 4*f_sigma); //(sigma)
//func2->SetParLimits(0, 0, f_const*(0.1) );
//func2->SetParLimits(1, f_mean-(4*f_sigma),f_mean+(4*f_sigma) );
//func2->SetParLimits(2, f_sigma-(10*f_sigma),f_sigma+(10*f_sigma) );
//func2->FixParameter(0, 40); //Test
//cout<<"peak amp: "<<0.1*peak_pos_amp<<endl;
//func2 = new TF1("func2", "pol2");
func3 = new TF1("func3", "func1 + func2", (f_mean - 3*f_sigma), (f_mean + 3*f_sigma) );
//-----------Fit Parameter constraints:
func3->SetParameters(f_const, f_mean, f_sigma, f_const/10, f_mean, 4*f_sigma); //Set Initial Valules
//func3->SetParLimits(0, 0, 1000000);
//func3->SetParLimits(1, 0, 1000000);
//func3->SetParLimits(2, 0, 1000000);
func3->SetParLimits(3, 0, (0.05*peak_pos_amp) ); //Max=5% of peak amp //************Set peak limit of background sigma*************
//func3->SetParLimits(4, 0, 1000000);
//func3->SetParLimits(5, 0, 1000000);
//htemp->Fit("func3");//, "", "",(f_mean - (N_sigma_range*f_sigma)), (f_mean + (N_sigma_range*f_sigma) ) ); //Show Fit
htemp->Fit("func3", "Q0"); //Don't show fit
func = htemp->GetFunction("func3");
Chi2 = func3->GetChisquare();
NDF = func->GetNDF();
if (NDF != 0) f_RChi2 = Chi2/NDF;
f_const = func3->GetParameter(0);
f_mean = func3->GetParameter(1);
f_mean_err = func3->GetParError(1);
f_sigma = func3->GetParameter(2);
f_sigma_err = func3->GetParError(2);
f_const2 = func3->GetParameter(3);
f_mean2 = func3->GetParameter(4);
f_mean_err2 = func3->GetParError(4);
f_sigma2 = func3->GetParameter(5);
f_sigma_err2 = func3->GetParError(5);
func3->SetParNames("Primary Constant", "Primary Mean", "Primary Sigma", "Background Constant", "Background Mean", "Background Sigma");
//for (int j=0; j< (N_iter - 1); j++)
for (int j=0; j<4; j++)
{
func3->SetParameters(f_const, f_mean, f_sigma, f_const2, f_mean2, f_sigma2);
//htemp->Fit("func3", "Q", "", "",(f_mean - (N_sigma_range*f_sigma)), (f_mean + (N_sigma_range*f_sigma) ) );
//----------------Show or don't show fit-----------------
if (ShowFit) htemp->Fit("func3", "Q");//*************Show Histo & Fit in quiet mode
else htemp->Fit("func3", "Q0"); //*****************Don't show Histo & Fit in quiet mode
//-------------------------------------------------------
func3 = htemp->GetFunction("func3");
func3->SetLineColor(2);
//htemp->SetLineColor(2);
Chi2 = func3->GetChisquare();
NDF = func3->GetNDF();
if (NDF != 0) f_RChi2 = Chi2/NDF;
f_const = func3->GetParameter(0);
f_mean = func3->GetParameter(1);
f_mean_err = func3->GetParError(1);
f_sigma = func3->GetParameter(2);
f_sigma_err = func3->GetParError(2);
f_const2 = func3->GetParameter(3);
f_mean2 = func3->GetParameter(4);
f_mean_err2 = func3->GetParError(4);
f_sigma2 = func3->GetParameter(5);
f_sigma_err2 = func3->GetParError(5);
}
//gStyle->SetOptFit(kTRUE);
//if (f_const > f_const2)
if (abs(f_const-peak) < abs(f_const2-peak))
{
myI2GFvalues.rchi2 = f_RChi2;
myI2GFvalues.mean = f_mean;
myI2GFvalues.mean_err = f_mean_err;
myI2GFvalues.sigma = abs(f_sigma);
myI2GFvalues.sigma_err = f_sigma_err;
//myI2GFvalues.fit_func = new TF1("fit_func", "func3"); //not needed
}
else
{
myI2GFvalues.rchi2 = f_RChi2;
myI2GFvalues.mean = f_mean2;
myI2GFvalues.mean_err = f_mean_err2;
myI2GFvalues.sigma = abs(f_sigma2);
myI2GFvalues.sigma_err = f_sigma_err2;
//myI2GFvalues.fit_func = new TF1("fit_func", "func3"); //not needed
}
return myI2GFvalues;
delete s;
delete func;
delete func1;
delete func2;
delete func3;
}
