**************************************************************************/
///
-/// Class to hold results about J/psi
+/// Class to hold results about J/psi
/// like number of of J/psi (before and after Acc x Eff correction),
/// Acc x Eff correction, Yield, RAB, etc...
///
+/// A note on "naming conventions"
+///
+/// FitFunctionXY : denotes a function with a prototype double func(double*,double*)
+/// which can be used in a fit. X = Background, Signal or Total for Background+Signal
+/// Y is the functio name
+///
+///
/// author: Laurent Aphecetche (Subatech)
///
ClassImp(AliAnalysisMuMuJpsiResult)
#include "TF1.h"
+#include "TProfile.h"
#include "TFitResult.h"
#include "TH1.h"
#include "TH2.h"
#include "TList.h"
#include "TMap.h"
#include "TMath.h"
+#include "TMethodCall.h"
#include "TObjArray.h"
#include "TParameter.h"
#include "AliAnalysisMuMuBinning.h"
#include "AliLog.h"
#include <map>
+#include "Fit/Fitter.h"
+#include "Fit/BinData.h"
+#include "Fit/Chi2FCN.h"
+#include "Math/WrappedMultiTF1.h"
+#include "HFitInterface.h"
+#include "TCanvas.h"
+#include "TStyle.h"
+
+
namespace {
+ //____________________________________________________________________________
const std::map<std::string,Double_t>& MassMap()
{
/// a simple map of masses...
// can decide on our particle naming
if (massMap.empty())
{
- massMap["Jpsi"] = 3.096916e+00;
- massMap["PsiPrime"] = 3.68609e+00;
+ massMap["JPsi"] = 3.096916e+00;
+ massMap["PsiP"] = 3.68609e+00;
massMap["Upsilon"] = 9.46030e+00;
massMap["UpsilonPrime"] = 1.00233e+01;
}
return massMap;
}
-
-
- Double_t funcCB(Double_t* xx, Double_t* par)
- {
- /// Crystal ball
-
- Double_t norm = par[0];
- Double_t alpha = par[1];
- Double_t n = par[2];
- Double_t mean = par[3];
- Double_t sigma = par[4];
-
- Double_t x = xx[0];
-
- Double_t a = TMath::Power(n/TMath::Abs(alpha),n)*TMath::Exp(-0.5*alpha*alpha);
- Double_t b = n/TMath::Abs(alpha) - TMath::Abs(alpha);
-
- Double_t y = ( TMath::Abs(sigma) > 1E-12 ? (x-mean)/sigma : 0 );
-
- if ( y > alpha*-1.0 )
- {
- return norm*TMath::Exp(-0.5*y*y);
- }
- else
- {
- return norm*a*TMath::Power(b-y,-n);
- }
- }
-
- Double_t funcJpsiGCBE(Double_t* xx, Double_t* par)
- {
- /// crystal ball + expo + gaussian
- Double_t x = xx[0];
-
- Double_t g = par[0]*TMath::Gaus(x,par[1],par[2]);
-
- Double_t jpsi = funcCB(xx,par+3);
-
- Double_t expo = par[8]*TMath::Exp(par[9]*x);
-
- return g+expo+jpsi;
- }
-
- Double_t funcCB2(Double_t* xx, Double_t* par)
- {
- /// CB2 = extended crystal ball
-
- Double_t norm = par[0];
- Double_t alpha = par[1];
- Double_t n = par[2];
- Double_t mean = par[3];
- Double_t sigma = par[4];
- Double_t alphaprime = par[5];
- Double_t nprime = par[6];
-
- Double_t x = xx[0];
-
- Double_t a = TMath::Power(n/TMath::Abs(alpha),n)*TMath::Exp(-0.5*alpha*alpha);
- Double_t b = n/TMath::Abs(alpha) - TMath::Abs(alpha);
- Double_t c = TMath::Power(nprime/TMath::Abs(alphaprime),nprime)*TMath::Exp(-0.5*alphaprime*alphaprime);
- Double_t d = nprime/TMath::Abs(alphaprime) - TMath::Abs(alphaprime);
-
- Double_t y = ( TMath::Abs(sigma) > 1E-12 ? (x-mean)/sigma : 0 );
-
- if ( y > alphaprime )
- {
- return norm*c*TMath::Power(d+y,-nprime);
- }
- else if ( y > alpha*-1.0 )
- {
- return norm*TMath::Exp(-0.5*y*y);
- }
- else
- {
- return norm*a*TMath::Power(b-y,-n);
- }
- }
-
-
- Double_t funcJpsiNA48(Double_t*x, Double_t* par)
- {
- /// Fit function from e.q. 4.8 of Ruben's PhD.
- Double_t c1 = par[0];
- Double_t c2 = par[1];
- Double_t d1 = par[2];
- Double_t d2 = par[3];
- Double_t g1 = par[4];
- Double_t g2 = par[5];
- Double_t m0 = par[6];
- Double_t sigma1 = par[7];
- Double_t sigma2 = par[8];
- Double_t b1 = par[9];
- Double_t b2 = par[10];
- Double_t norm = par[11];
-
- Double_t m = x[0];
-
- Double_t rv(0);
-
- if ( m <= c1*m0 )
- {
- Double_t e = d1-g1*TMath::Sqrt(c1*m0-m);
- rv = TMath::Power(b1*(c1*m0-m),e);
- rv += sigma1;
- }
- else if( m >= c1*m0 && m <= m0 )
- {
- rv = sigma1;
- }
- else if ( m >= m0 && m < c2*m0 )
- {
- rv = sigma2;
- }
- else if( m >= c2*m0 )
- {
- Double_t e = d2-g2*TMath::Sqrt(m-c2*m0);
- rv = TMath::Power(b2*(m-c2*m0),e);
- rv += sigma2;
- }
-
- return norm*TMath::Exp(-(m-m0)*(m-m0)/(2.0*rv*rv));
- }
-
- //------------------------------------------------------------------------------
- Double_t BackgroundVWG(Double_t *x, Double_t *par)
+
+ //____________________________________________________________________________
+ Bool_t GetKeyValue(const TString& str, const char separator, TString& key, TString& value)
{
- // gaussian variable width
- Double_t sigma = par[2]+par[3]*((x[0]-par[1])/par[1]);
- return par[0]*TMath::Exp(-(x[0]-par[1])*(x[0]-par[1])/(2.*sigma*sigma));
-
+ /// Get a key value pair, separated by separator character
+ key=value="";
+ if ( !str.CountChar(separator) ) return kFALSE;
+ Int_t index = str.Index(separator);
+ key = str(0,index);
+ value = str(index+1,str.Length()-index-1);
+ return kTRUE;
}
-
- //------------------------------------------------------------------------------
- Double_t CrystalBallExtended(Double_t *x,Double_t *par)
- {
- //par[0] = Normalization
- //par[1] = mean
- //par[2] = sigma
- //par[3] = alpha
- //par[4] = n
- //par[5] = alpha'
- //par[6] = n'
-
- Double_t t = (x[0]-par[1])/par[2];
- if (par[3] < 0) t = -t;
-
- Double_t absAlpha = fabs((Double_t)par[3]);
- Double_t absAlpha2 = fabs((Double_t)par[5]);
-
- if (t >= -absAlpha && t < absAlpha2) // gaussian core
- {
- return par[0]*(exp(-0.5*t*t));
- }
-
- if (t < -absAlpha) //left tail
- {
- Double_t a = TMath::Power(par[4]/absAlpha,par[4])*exp(-0.5*absAlpha*absAlpha);
- Double_t b = par[4]/absAlpha - absAlpha;
- return par[0]*(a/TMath::Power(b - t, par[4]));
- }
-
- if (t >= absAlpha2) //right tail
- {
-
- Double_t c = TMath::Power(par[6]/absAlpha2,par[6])*exp(-0.5*absAlpha2*absAlpha2);
- Double_t d = par[6]/absAlpha2 - absAlpha2;
- return par[0]*(c/TMath::Power(d + t, par[6]));
- }
- return 0. ;
- }
-
-
- //---------------------------------------------------------------------------
-// Double_t fitFunctionVWG(Double_t *x, Double_t *par)
-// {
-// if (x[0] > 2.9 && x[0] < 3.3) TF1::RejectPoint();
-// return BackgroundVWG(x, par);
-// }
-
- //---------------------------------------------------------------------------
- Double_t fitFunctionCB2VWG(Double_t *x, Double_t *par)
- {
- return BackgroundVWG(x, par) + CrystalBallExtended(x, &par[4]);
- }
+ const TString kKeyFunc = "Func";
+ const TString kKeyRange = "Range";
+ const TString kKeyRebin = "Rebin";
+ const TString kFitRangeLow = "FitRangeLow";
+ const TString kFitRangeHigh = "FitRangeHigh";
+ const TString kKeyCount = "Count";
+ const TString kKeyHistoType = "HistoType";
+ const TString kKeyTails = "Tails";
+ const TString kKeySPsiP = "FSigmaPsiP"; //Factor to fix the psi' sigma to sigmaJPsi*SigmaPsiP (Usually factor SigmaPsiP = 1, 0.9 and 1.1)
+ const TString kKeyMinvRS = "MinvRS"; // FIXME: not very correct since "MinvRS" is in AliAnalysisMuMu::GetParametersFromResult
- //---------------------------------------------------------------------------
- Double_t func2CB2VWG(Double_t *x, Double_t *par)
- {
- /// 2 extended crystal balls + variable width gaussian
- /// width of the second CB related to the first (free) one.
-
- Double_t par2[7] = {
- par[11],
- 3.68609+(par[5]-3.096916)/3.096916*3.68609,
- par[6]/3.096916*3.68609,
- par[7],
- par[8],
- par[9],
- par[10]
- };
- return BackgroundVWG(x, par) + CrystalBallExtended(x, &par[4]) + CrystalBallExtended(x, par2);
- }
}
//_____________________________________________________________________________
AliAnalysisMuMuResult("",""),
fNofRuns(),
fNofTriggers(-1),
-fMinv(0x0),
-fBin(),
-fRebin(0),
-fTriggerClass(),
-fEventSelection(),
-fPairSelection(),
-fCentralitySelection()
-{
-}
-
-//_____________________________________________________________________________
-AliAnalysisMuMuJpsiResult::AliAnalysisMuMuJpsiResult(const TH1& hminv) :
-AliAnalysisMuMuResult("",""),
-fNofRuns(1),
-fNofTriggers(-1),
-fMinv(0x0),
+fHisto(0x0),
fBin(),
-fRebin(0),
fTriggerClass(),
fEventSelection(),
fPairSelection(),
-fCentralitySelection()
+fCentralitySelection(),
+fFitFunction(),
+fFitRejectRangeLow(TMath::Limits<Double_t>::Max()),
+fFitRejectRangeHigh(TMath::Limits<Double_t>::Max()),
+fRejectFitPoints(kFALSE),
+fParticle(""),
+fMinvRS("")
{
- SetMinv(hminv);
}
//_____________________________________________________________________________
-AliAnalysisMuMuJpsiResult::AliAnalysisMuMuJpsiResult(const TH1& hminv,
- const char* fitType,
- Int_t nrebin)
+AliAnalysisMuMuJpsiResult::AliAnalysisMuMuJpsiResult(const char* particle,
+ const TH1& h,
+ const char* fitType)
:
-AliAnalysisMuMuResult(Form("%s:%d",fitType,nrebin),""),
+AliAnalysisMuMuResult(fitType,""),
fNofRuns(1),
fNofTriggers(-1),
-fMinv(0x0),
+fHisto(0x0),
fBin(),
-fRebin(nrebin),
fTriggerClass(),
fEventSelection(),
fPairSelection(),
-fCentralitySelection()
+fCentralitySelection(),
+fFitFunction(),
+fFitRejectRangeLow(TMath::Limits<Double_t>::Max()),
+fFitRejectRangeHigh(TMath::Limits<Double_t>::Max()),
+fRejectFitPoints(kFALSE),
+fParticle(particle),
+fMinvRS("")
{
- SetMinv(hminv);
+ SetHisto(h);
+
+ DecodeFitType(fitType);
+
+ TString name(fFitFunction);
+ if ( !name.Contains("PSICB2") && !name.Contains("PSINA60NEW") && !name.Contains("PSICOUNT") ) //To avoid adding things to the name of simu results
+ {
+ Bool_t isMPt = kFALSE;
+
+ if ( name.BeginsWith("PSI") ) name.ReplaceAll("PSIPSIPRIME","");
+ else if ( name.BeginsWith("MPT") )
+ {
+ name.ReplaceAll("MPTPSIPSIPRIME","");
+ isMPt = kTRUE;
+ }
+ name += "_";
+ name += Form("%1.1f",GetValue(kFitRangeLow));
+ name += "_";
+ name += Form("%1.1f",GetValue(kFitRangeHigh));
+ if ( !isMPt )
+ {
+ name += "_";
+ name += Form("SP%1.1f",GetValue(kKeySPsiP));
+ }
+ else
+ {
+ name += Form("(Sig:%s)",fMinvRS.Data());
+ }
+ }
+ SetName(name.Data());
+
+ Int_t rebin = TMath::Nint(GetValue(kKeyRebin));
+
+ if (rebin>0)
+ {
+ fHisto->Rebin(rebin);
+ }
+
+ if ( fHisto->GetEntries()<100 && !TString(GetName()).Contains(kKeyCount) )
+ {
+ // not enough statistics to perform a fit.
+ Invalidate();
+ std::cout << "Fit Excluded: Not enough statistics to perform a fit" << std::endl;
+ }
}
//_____________________________________________________________________________
-AliAnalysisMuMuJpsiResult::AliAnalysisMuMuJpsiResult(const TH1& hminv,
- const char* triggerName,
- const char* eventSelection,
- const char* pairSelection,
- const char* centSelection,
- const AliAnalysisMuMuBinning::Range& bin)
+AliAnalysisMuMuJpsiResult::AliAnalysisMuMuJpsiResult(const char* particle,
+ const TH1& h,
+ const char* triggerName,
+ const char* eventSelection,
+ const char* pairSelection,
+ const char* centSelection,
+ const AliAnalysisMuMuBinning::Range& bin)
:
AliAnalysisMuMuResult(Form("%s-%s-%s-%s",triggerName,eventSelection,pairSelection,centSelection),""),
fNofRuns(1),
fNofTriggers(-1),
-fMinv(0x0),
+fHisto(0x0),
fBin(bin),
-fRebin(1),
fTriggerClass(triggerName),
fEventSelection(eventSelection),
fPairSelection(pairSelection),
-fCentralitySelection(centSelection)
+fCentralitySelection(centSelection),
+fFitFunction(),
+fFitRejectRangeLow(TMath::Limits<Double_t>::Max()),
+fFitRejectRangeHigh(TMath::Limits<Double_t>::Max()),
+fRejectFitPoints(kFALSE),
+fParticle(particle),
+fMinvRS("")
{
- SetMinv(hminv);
+ SetHisto(h);
}
//_____________________________________________________________________________
AliAnalysisMuMuResult(rhs),
fNofRuns(rhs.NofRuns()),
fNofTriggers(rhs.NofTriggers()),
-fMinv(0x0),
+fHisto(0x0),
fBin(rhs.Bin()),
-fRebin(rhs.fRebin),
fTriggerClass(rhs.fTriggerClass),
fEventSelection(rhs.fEventSelection),
fPairSelection(rhs.fPairSelection),
-fCentralitySelection(rhs.fCentralitySelection)
+fCentralitySelection(rhs.fCentralitySelection),
+fFitFunction(rhs.fFitFunction),
+fFitRejectRangeLow(rhs.fFitRejectRangeLow),
+fFitRejectRangeHigh(rhs.fFitRejectRangeHigh),
+fRejectFitPoints(rhs.fRejectFitPoints),
+fParticle(rhs.fParticle),
+fMinvRS(rhs.fMinvRS)
{
/// copy ctor
/// Note that the mother is lost
/// fKeys remains 0x0 so it will be recomputed if need be
- if ( rhs.fMinv )
+ if ( rhs.fHisto )
{
- fMinv = static_cast<TH1*>(rhs.fMinv->Clone());
+ fHisto = static_cast<TH1*>(rhs.fHisto->Clone());
}
}
if (this!=&rhs)
{
static_cast<AliAnalysisMuMuResult&>(*this) = static_cast<const AliAnalysisMuMuResult&>(rhs);
- delete fMinv;
+ delete fHisto;
- if ( rhs.fMinv )
+ if ( rhs.fHisto )
{
- fMinv = static_cast<TH1*>(rhs.fMinv->Clone());
+ fHisto = static_cast<TH1*>(rhs.fHisto->Clone());
}
fNofRuns = rhs.NofRuns();
fNofTriggers = rhs.NofTriggers();
fBin = rhs.Bin();
- fRebin = rhs.fRebin;
+ fTriggerClass = rhs.fTriggerClass;
+ fEventSelection = rhs.fEventSelection;
+ fPairSelection = rhs.fPairSelection;
+ fCentralitySelection = rhs.fCentralitySelection;
+ fFitFunction = rhs.fFitFunction;
+ fFitRejectRangeLow = rhs.fFitRejectRangeLow;
+ fFitRejectRangeHigh = rhs.fFitRejectRangeHigh;
+ fRejectFitPoints = rhs.fRejectFitPoints;
+ fParticle = rhs.fParticle;
+ fMinvRS = rhs.fMinvRS;
+
}
return *this;
AliAnalysisMuMuJpsiResult::~AliAnalysisMuMuJpsiResult()
{
// dtor
- delete fMinv;
+ delete fHisto;
+}
+
+//_____________________________________________________________________________
+void AliAnalysisMuMuJpsiResult::AttachFunctionsToHisto(TF1* signal, TF1* bck, TF1* total,
+ Double_t xmin, Double_t xmax)
+{
+ /// Add some fit functions and some lines to the histogram
+ if (signal)
+ {
+ signal->SetLineColor(1);
+ signal->SetNpx(1000);
+ fHisto->GetListOfFunctions()->Add(signal);
+ }
+
+ if ( bck )
+ {
+ bck->SetLineColor(2);
+ bck->SetNpx(1000);
+ fHisto->GetListOfFunctions()->Add(bck);
+ }
+
+ if ( total )
+ {
+ total->SetLineColor(4);
+ total->SetNpx(1000);
+ fHisto->GetListOfFunctions()->Add(total);
+ }
+
+ TLine* l1 = new TLine(xmin,0,xmin,fHisto->GetMaximum()*0.8);
+ TLine* l2 = new TLine(xmax,0,xmax,fHisto->GetMaximum()*0.8);
+ l1->SetLineColor(6);
+ l2->SetLineColor(6);
+ fHisto->GetListOfFunctions()->Add(l1);
+ fHisto->GetListOfFunctions()->Add(l2);
+}
+
+//_____________________________________________________________________________
+void AliAnalysisMuMuJpsiResult::AttachFunctionsToHisto(TF1* signal1, TF1* signal2, TF1* bck, TF1* total,
+ Double_t xmin, Double_t xmax)
+{
+ /// Add some fit functions and some lines to the histogram
+ if (signal1)
+ {
+ signal1->SetLineColor(1);
+ signal1->SetNpx(1000);
+ fHisto->GetListOfFunctions()->Add(signal1);
+ }
+
+ if (signal2)
+ {
+ signal2->SetLineColor(3);
+ signal2->SetNpx(1000);
+ fHisto->GetListOfFunctions()->Add(signal2);
+ }
+
+ if ( bck )
+ {
+ bck->SetLineColor(2);
+ bck->SetNpx(1000);
+ fHisto->GetListOfFunctions()->Add(bck);
+ }
+
+ if ( total )
+ {
+ total->SetLineColor(4);
+ total->SetNpx(1000);
+ fHisto->GetListOfFunctions()->Add(total);
+ }
+
+ TLine* l1 = new TLine(xmin,0,xmin,fHisto->GetMaximum()*0.8);
+ TLine* l2 = new TLine(xmax,0,xmax,fHisto->GetMaximum()*0.8);
+ l1->SetLineColor(6);
+ l2->SetLineColor(6);
+ fHisto->GetListOfFunctions()->Add(l1);
+ fHisto->GetListOfFunctions()->Add(l2);
}
+
//_____________________________________________________________________________
const AliAnalysisMuMuBinning::Range& AliAnalysisMuMuJpsiResult::Bin() const
{
return kFALSE;
}
+//_____________________________________________________________________________
+void AliAnalysisMuMuJpsiResult::Draw(Option_t* opt)
+{
+ /// short cut method to draw our internal histogram
+ if (fHisto) fHisto->Draw(opt);
+}
+
//_____________________________________________________________________________
Double_t AliAnalysisMuMuJpsiResult::CountParticle(const TH1& hminv, const char* particle, Double_t sigma)
{
return hminv.Integral();
}
- TAxis* x = hminv.GetXaxis();
+ const TAxis* x = hminv.GetXaxis();
- Int_t b1 = x->FindBin(mass-sigma);
- Int_t b2 = x->FindBin(mass+sigma);
+ Int_t b1 = x->FindFixBin(mass-sigma);
+ Int_t b2 = x->FindFixBin(mass+sigma);
AliDebugClass(1,Form("hminv getentries %e integral %e",hminv.GetEntries(),hminv.Integral(b1,b2)));
return hminv.Integral(b1,b2);
}
-//_____________________________________________________________________________
-AliAnalysisMuMuJpsiResult* AliAnalysisMuMuJpsiResult::FitJpsiGCBE(TH1& h)
+//____________________________________________________________________________
+Double_t AliAnalysisMuMuJpsiResult::FitFunctionBackgroundLin(Double_t *x, Double_t *par)
{
- /// Fit Jpsi spectra with crystal ball + gaussian + exponential
-
- std::cout << "Fit with jpsi alone (gaus + CB + expo)" << std::endl;
-
- Int_t nrebin = fMinv->GetXaxis()->GetNbins() / h.GetXaxis()->GetNbins();
-
- AliAnalysisMuMuJpsiResult* r = new AliAnalysisMuMuJpsiResult(h,"JPSIGCBE",nrebin);
-
- TH1* hfit = r->Minv();
-
- const Double_t xmin(1.0);
- const Double_t xmax(8.0);
-
- TF1* fitTotal = new TF1("fitTotal",funcJpsiGCBE,xmin,xmax,10);
- fitTotal->SetParNames("cste","x0","sigma0","N","alpha","n","mean","sigma","expocste","exposlope");
+ // Linear function for Bkg 2 params
- fitTotal->SetParLimits(3,0,h.GetMaximum()*2); // N
-
- const Double_t cbalpha(0.98);
- const Double_t cbn(5.2);
-
- fitTotal->FixParameter(4,cbalpha);
- fitTotal->FixParameter(5,cbn);
-
- fitTotal->SetParLimits(6,2.8,3.2); // mean
- fitTotal->SetParLimits(7,0.02,0.3); // sigma
-
- TF1* fg = new TF1("fg","gaus",xmin,xmax);
-
- hfit->Fit(fg,"","",0.75,3.0);
-
- fitTotal->SetParameter(0,fg->GetParameter(0));
- fitTotal->SetParameter(1,fg->GetParameter(1));
- fitTotal->SetParameter(2,fg->GetParameter(2));
-
- TF1* fexpo = new TF1("expo","expo",xmin,xmax);
-
- hfit->Fit(fexpo,"","",3.5,5);
-
- fitTotal->SetParameter(8,fexpo->GetParameter(0));
- fitTotal->SetParameter(9,fexpo->GetParameter(1));
-
- fitTotal->SetParameter(3,h.GetMaximum()),
- fitTotal->SetParameter(4,cbalpha);
- fitTotal->SetParameter(5,cbn);
- fitTotal->SetParameter(6,3.15);
- fitTotal->SetParameter(7,0.1);
-
- const char* fitOption = "QSI+";
-
- TFitResultPtr fitResult = hfit->Fit(fitTotal,fitOption,"",2,5);
+ if (fRejectFitPoints && x[0] > fFitRejectRangeLow && x[0] < fFitRejectRangeHigh )
+ {
+ TF1::RejectPoint();
+ return 0.;
+ }
+ return par[0]+par[1]*x[0];
+}
+
+//____________________________________________________________________________
+Double_t AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2(Double_t *x, Double_t *par)
+{
+ // pol2 3 params
- r->Set("MeanJpsi",fitTotal->GetParameter(6),fitTotal->GetParError(6));
- r->Set("SigmaJpsi",fitTotal->GetParameter(7),fitTotal->GetParError(7));
+ if (fRejectFitPoints && x[0] > fFitRejectRangeLow && x[0] < fFitRejectRangeHigh )
+ {
+ TF1::RejectPoint();
+ return 0.;
+ }
+ return par[0]+par[1]*x[0]+par[2]*x[0]*x[0];
+}
+
+//____________________________________________________________________________
+Double_t AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol3(Double_t *x, Double_t *par)
+{
+ // pol2 4 params
- double m = r->GetValue("MeanJpsi");
- double s = r->GetValue("SigmaJpsi");
- double n = 3.0;
+ if (fRejectFitPoints && x[0] > fFitRejectRangeLow && x[0] < fFitRejectRangeHigh )
+ {
+ TF1::RejectPoint();
+ return 0.;
+ }
+ return par[0]+par[1]*x[0]+par[2]*x[0]*x[0]+par[3]*x[0]*x[0]*x[0];
+}
+
+//____________________________________________________________________________
+Double_t AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol4(Double_t *x, Double_t *par)
+{
+ // pol2 5 params
- TF1* fcb = new TF1("fcb",funcCB,xmin,xmax,5);
- fcb->SetParameters(fitTotal->GetParameter(3),
- fitTotal->GetParameter(4),
- fitTotal->GetParameter(5),
- fitTotal->GetParameter(6),
- fitTotal->GetParameter(7));
+ if (fRejectFitPoints && x[0] > fFitRejectRangeLow && x[0] < fFitRejectRangeHigh )
+ {
+ TF1::RejectPoint();
+ return 0.;
+ }
+ return par[0]+par[1]*x[0]+par[2]*x[0]*x[0]+par[3]*x[0]*x[0]*x[0]+par[4]*x[0]*x[0]*x[0]*x[0];
+}
+
+//____________________________________________________________________________
+Double_t AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2Exp(Double_t *x, Double_t *par)
+{
+ // pol2 x exp : 4 params
- fcb->SetLineColor(6);
- fcb->SetNpx(100);
- TLine* l1 = new TLine(m-n*s,0,m-n*s,fitTotal->GetParameter(3));
- TLine* l2 = new TLine(m+n*s,0,m+n*s,fitTotal->GetParameter(3));
- l1->SetLineColor(6);
- l2->SetLineColor(6);
- h.GetListOfFunctions()->Add(fcb);
- h.GetListOfFunctions()->Add(l1);
- h.GetListOfFunctions()->Add(l2);
+ if (fRejectFitPoints && x[0] > fFitRejectRangeLow && x[0] < fFitRejectRangeHigh )
+ {
+ TF1::RejectPoint();
+ return 0.;
+ }
+// return par[0]*(par[1]+par[2]*x[0]+par[3]*x[0]*x[0])*TMath::Exp(par[4]/x[0]);
+ return (par[0]+par[1]*x[0]+par[2]*x[0]*x[0])*TMath::Exp(par[3]*x[0]);
+}
+
+//____________________________________________________________________________
+Double_t AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol4Exp(Double_t *x, Double_t *par)
+{
+ // pol4 x exp : 6 params
+ if (fRejectFitPoints && x[0] > fFitRejectRangeLow && x[0] < fFitRejectRangeHigh )
+ {
+ TF1::RejectPoint();
+ return 0.;
+ }
+// return par[0]*(par[1]+par[2]*x[0]+par[3]*x[0]*x[0]+par[4]*x[0]*x[0]*x[0]+par[5]*x[0]*x[0]*x[0]*x[0])*TMath::Exp(par[6]/x[0]);
+// return (par[0]+par[1]*x[0]+par[2]*x[0]*x[0]+par[3]*x[0]*x[0]*x[0]+par[4]*x[0]*x[0]*x[0]*x[0])*TMath::Exp(par[5]/x[0]);
+ return (par[0]+par[1]*x[0]+par[2]*x[0]*x[0]+par[3]*x[0]*x[0]*x[0]+par[4]*x[0]*x[0]*x[0]*x[0])*TMath::Exp(par[5]*x[0]);
+
+}
+
+//____________________________________________________________________________
+Double_t AliAnalysisMuMuJpsiResult::FitFunctionBackgroundVWG(Double_t *x, Double_t *par)
+{
+ // gaussian variable width : 4 params
- Double_t cbParameters[5];
- Double_t covarianceMatrix[5][5];
+ if (fRejectFitPoints && x[0] > fFitRejectRangeLow && x[0] < fFitRejectRangeHigh )
+ {
+ TF1::RejectPoint();
+ return 0.;
+ }
+ Double_t sigma = par[2]+par[3]*((x[0]-par[1])/par[1]);
+ return par[0]*TMath::Exp(-(x[0]-par[1])*(x[0]-par[1])/(2.*sigma*sigma));
+}
+
+//____________________________________________________________________________
+Double_t AliAnalysisMuMuJpsiResult::FitFunctionSignalCrystalBallExtended(Double_t *x,Double_t *par)
+{
+ // Extended Crystal Ball : 7 parameters
+ //
+ // par[0] = Normalization
+ // par[1] = mean
+ // par[2] = sigma
+ // par[3] = alpha
+ // par[4] = n
+ // par[5] = alpha'
+ // par[6] = n'
+
+ Double_t t = (x[0]-par[1])/par[2];
+ if (par[3] < 0) t = -t;
+
+ Double_t absAlpha = fabs((Double_t)par[3]);
+ Double_t absAlpha2 = fabs((Double_t)par[5]);
+
+ if (t >= -absAlpha && t < absAlpha2) // gaussian core
+ {
+ return par[0]*(exp(-0.5*t*t));
+ }
- cbParameters[0] = fitTotal->GetParameter(3);
- cbParameters[1] = fitTotal->GetParameter(4);
- cbParameters[2] = fitTotal->GetParameter(5);
- cbParameters[3] = fitTotal->GetParameter(6);
- cbParameters[4] = fitTotal->GetParameter(7);
+ if (t < -absAlpha) //left tail
+ {
+ Double_t a = TMath::Power(par[4]/absAlpha,par[4])*exp(-0.5*absAlpha*absAlpha);
+ Double_t b = par[4]/absAlpha - absAlpha;
+ return par[0]*(a/TMath::Power(b - t, par[4]));
+ }
- for ( int iy = 0; iy < 5; ++iy )
+ if (t >= absAlpha2) //right tail
{
- for ( int ix = 0; ix < 5; ++ix )
- {
- covarianceMatrix[ix][iy] = (fitResult->GetCovarianceMatrix())(ix+3,iy+3);
- }
+
+ Double_t c = TMath::Power(par[6]/absAlpha2,par[6])*exp(-0.5*absAlpha2*absAlpha2);
+ Double_t d = par[6]/absAlpha2 - absAlpha2;
+ return par[0]*(c/TMath::Power(d + t, par[6]));
}
- double njpsi = fcb->Integral(m-n*s,m+n*s)/h.GetBinWidth(1);
+ return 0. ;
+}
+
+//____________________________________________________________________________
+Double_t AliAnalysisMuMuJpsiResult::FitFunctionNA60New(Double_t *x,Double_t *par)
+{
+ // New Formulation of NA60 : 11 parameters
+ //
+ // par[0] = Normalization
+ // par[1] = mean
+ // par[2] = sigma
+ // par[3] = p1Left
+ // par[4] = p2Left
+ // par[5] = p3Left
+ // par[6] = p1Right
+ // par[7] = p2Right
+ // par[8] = p3Right
+ // par[9] = alphaLeft
+ // par[10] = alphaRight
+
+
+ const Double_t t = (x[0]-par[1])/par[2];
- double nerr = fcb->IntegralError(m-n*s,m+n*s,&cbParameters[0],&covarianceMatrix[0][0])/h.GetBinWidth(1);
+ Double_t sigmaRatio;
+ if( t < par[9] ) sigmaRatio = ( 1.0 + TMath::Power( par[3]*(par[9]-t), par[4]-par[5]*TMath::Sqrt(par[9] - t) ) );
+ else if( t >= par[9] && t < par[10] ) sigmaRatio = 1;
+ else if( t >= par[10] ) sigmaRatio = ( 1.0 + TMath::Power( par[6]*(t-par[10]), par[7]-par[8]*TMath::Sqrt(t - par[10]) ) );
- r->Set("NofJpsi",njpsi,nerr);
+ return par[0]*TMath::Exp( -(1/2.)*TMath::Power(t/sigmaRatio,2.));
- return r;
}
-//_____________________________________________________________________________
-AliAnalysisMuMuJpsiResult* AliAnalysisMuMuJpsiResult::FitJpsi(TH1& h)
+//____________________________________________________________________________
+Double_t AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoNA60NewVWG(Double_t *x, Double_t *par)
{
- /// Fit Jpsi spectra using extended crystall ball (CB2) with free tails
-
- StdoutToAliDebug(1,std::cout << "Fit with jpsi alone" << std::endl;);
+ /// 2 NA60 (new) + pol2 x exp
+ /// width of the second NA60 related to the first (free) one.
+
+ Double_t SPsiPFactor = GetValue(kKeySPsiP);
+
+ Double_t par2[11] = {
+ par[15],
+ 3.68609+(par[5]-3.096916)/3.096916*3.68609,
+ par[6]*SPsiPFactor, // /3.096916*3.68609
+ par[7],
+ par[8],
+ par[9],
+ par[10],
+ par[11],
+ par[12],
+ par[13],
+ par[14],
+ };
+ return FitFunctionBackgroundVWG(x, par) + FitFunctionNA60New(x, &par[4]) + FitFunctionNA60New(x, par2);
+}
- Int_t nrebin = fMinv->GetXaxis()->GetNbins() / h.GetXaxis()->GetNbins();
-
- AliAnalysisMuMuJpsiResult* r = new AliAnalysisMuMuJpsiResult(h,"JPSI",nrebin);
-
- TH1* hfit = r->Minv();
+//____________________________________________________________________________
+Double_t AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoNA60NewPol2Exp(Double_t *x, Double_t *par)
+{
+ /// 2 NA60 (new) + pol2 x exp
+ /// width of the second NA60 related to the first (free) one.
+
+ Double_t SPsiPFactor = GetValue(kKeySPsiP);
+
+ Double_t par2[11] = {
+ par[15],
+ 3.68609+(par[5]-3.096916)/3.096916*3.68609,
+ par[6]*SPsiPFactor, // /3.096916*3.68609,
+ par[7],
+ par[8],
+ par[9],
+ par[10],
+ par[11],
+ par[12],
+ par[13],
+ par[14],
+ };
+ return FitFunctionBackgroundPol2Exp(x, par) + FitFunctionNA60New(x, &par[4]) + FitFunctionNA60New(x, par2);
+}
- const Double_t xmin(1.5);
- const Double_t xmax(8.0);
- TF1* fitTotal = new TF1("fitTotal",funcCB2,xmin,xmax,7);
- fitTotal->SetParNames("N","alphaLow","nLow","mean","sigma","alphaUp","nUp");
- fitTotal->SetParameters(h.GetMaximum(),1,5,3.1,0.07,1.5,3);
- fitTotal->SetParLimits(0,0,h.GetMaximum()*2); // N
- fitTotal->SetParLimits(1,0,10); // alpha
- fitTotal->SetParLimits(2,0.1,10); // n
- fitTotal->SetParLimits(3,3,3.15); // mean
- fitTotal->SetParLimits(4,0.01,1); // sigma
- fitTotal->SetParLimits(5,0,10); // alpha
- fitTotal->SetParLimits(6,0.1,10); // n
-
- hfit->Fit(fitTotal,"QSER+","",2,5);
-
-
- r->Set("MeanJpsi",fitTotal->GetParameter(3),fitTotal->GetParError(3));
- r->Set("SigmaJpsi",fitTotal->GetParameter(4),fitTotal->GetParError(4));
+//____________________________________________________________________________
+Double_t AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoNA60NewPol4Exp(Double_t *x, Double_t *par)
+{
+ /// 2 NA60 (new) + pol4 x exp
+ /// width of the second NA60 related to the first (free) one.
+
+ Double_t SPsiPFactor = GetValue(kKeySPsiP);
+
+ Double_t par2[11] = {
+ par[17],
+ 3.68609+(par[7]-3.096916)/3.096916*3.68609,
+ par[8]*SPsiPFactor, // /3.096916*3.68609,
+ par[9],
+ par[10],
+ par[11],
+ par[12],
+ par[13],
+ par[14],
+ par[15],
+ par[16],
+ };
+ return FitFunctionBackgroundPol4Exp(x, par) + FitFunctionNA60New(x, &par[6]) + FitFunctionNA60New(x, par2);
+}
- double m = r->GetValue("MeanJpsi");
- double s = r->GetValue("SigmaJpsi");
- double n = 10.0;
+//____________________________________________________________________________
+Double_t AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2Lin(Double_t *x, Double_t *par)
+{
+ /// 2 extended crystal balls + Pol1
+ /// width of the second CB related to the first (free) one.
+
+ Double_t SPsiPFactor = GetValue(kKeySPsiP);
+
+ Double_t par2[7] = {
+ par[9],
+ 3.68609+(par[3]-3.096916)/3.096916*3.68609,
+ par[4]*SPsiPFactor, // /3.096916*3.68609,
+ par[5],
+ par[6],
+ par[7],
+ par[8]
+ };
+ return FitFunctionBackgroundLin(x, par) + FitFunctionSignalCrystalBallExtended(x, &par[2]) + FitFunctionSignalCrystalBallExtended(x, par2);
+}
+
+//____________________________________________________________________________
+Double_t AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2Pol2Exp(Double_t *x, Double_t *par)
+{
+ /// 2 extended crystal balls + pol2 x exp
+ /// width of the second CB related to the first (free) one.
+
+ Double_t SPsiPFactor = GetValue(kKeySPsiP);
+
+ Double_t par2[7] = {
+ par[11],
+ 3.68609+(par[5]-3.096916)/3.096916*3.68609,
+ par[6]*SPsiPFactor, // /3.096916*3.68609,
+ par[7],
+ par[8],
+ par[9],
+ par[10]
+ };
+ return FitFunctionBackgroundPol2Exp(x, par) + FitFunctionSignalCrystalBallExtended(x, &par[4]) + FitFunctionSignalCrystalBallExtended(x, par2);
+}
- r->Set("NofJpsi",fitTotal->Integral(m-n*s,m+n*s)/h.GetBinWidth(1),fitTotal->IntegralError(m-n*s,m+n*s)/h.GetBinWidth(1));
+////____________________________________________________________________________
+//Double_t AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2Pol2Exp(Double_t *x, Double_t *par)
+//{
+// /// 2 extended crystal balls + pol2 x exp
+// /// width of the second CB related to the first (free) one.
+//
+// Double_t par2[7] = {
+// par[12],
+// 3.68609+(par[6]-3.096916)/3.096916*3.68609,
+// par[7]/3.096916*3.68609,
+// par[8],
+// par[9],
+// par[10],
+// par[11]
+// };
+// return FitFunctionBackgroundPol2Exp(x, par) + FitFunctionSignalCrystalBallExtended(x, &par[5]) + FitFunctionSignalCrystalBallExtended(x, par2);
+//}
- return r;
+//____________________________________________________________________________
+Double_t AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2Pol4Exp(Double_t *x, Double_t *par)
+{
+ /// 2 extended crystal balls + pol4 x exp
+ /// width of the second CB related to the first (free) one.
+
+ Double_t SPsiPFactor = GetValue(kKeySPsiP);
+
+ Double_t par2[7] = {
+ par[13],
+ 3.68609+(par[7]-3.096916)/3.096916*3.68609,
+ par[8]*SPsiPFactor, // /3.096916*3.68609,
+ par[9],
+ par[10],
+ par[11],
+ par[12]
+ };
+ return FitFunctionBackgroundPol4Exp(x, par) + FitFunctionSignalCrystalBallExtended(x, &par[6]) + FitFunctionSignalCrystalBallExtended(x, par2);
}
-//_____________________________________________________________________________
-AliAnalysisMuMuJpsiResult* AliAnalysisMuMuJpsiResult::FitJpsiCB2VWG(const TH1& h)
+////____________________________________________________________________________
+//Double_t AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2Pol4Exp(Double_t *x, Double_t *par)
+//{
+// /// 2 extended crystal balls + pol4 x exp
+// /// width of the second CB related to the first (free) one.
+//
+// Double_t par2[7] = {
+// par[14],
+// 3.68609+(par[8]-3.096916)/3.096916*3.68609,
+// par[9]/3.096916*3.68609,
+// par[10],
+// par[11],
+// par[12],
+// par[13]
+// };
+// return FitFunctionBackgroundPol4Exp(x, par) + FitFunctionSignalCrystalBallExtended(x, &par[7]) + FitFunctionSignalCrystalBallExtended(x, par2);
+//}
+
+//____________________________________________________________________________
+Double_t AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2VWG(Double_t *x, Double_t *par)
{
- /// Fit Jpsi spectra using extended crystal ball (CB2) + variable width gaussian (VWG)
-
- StdoutToAliDebug(1,std::cout << "Fit with jpsi VWG" << std::endl;);
-
- Int_t nrebin = fMinv->GetXaxis()->GetNbins() / h.GetXaxis()->GetNbins();
-
- AliAnalysisMuMuJpsiResult* r = new AliAnalysisMuMuJpsiResult(h,"JPSICB2VWG",nrebin);
-
-
- TH1* hfit = r->Minv();
-
- const Double_t xmin(2.0);
- const Double_t xmax(5.0);
-
-// // gaussian variable width
-// Double_t sigma = par[2]+par[3]*((x[0]-par[1])/par[1]);
-// return par[0]*TMath::Exp(-(x[0]-par[1])*(x[0]-par[1])/(2.*sigma*sigma));
-// Double_t CrystalBallExtended(Double_t *x,Double_t *par)
-// //par[0] = Normalization
-// //par[1] = mean
-// //par[2] = sigma
-// //par[3] = alpha
-// //par[4] = n
-// //par[5] = alpha'
-// //par[6] = n'
+ /// 2 extended crystal balls + VWG
+ /// width of the second CB related to the first (free) one.
+
+ Double_t SPsiPFactor = GetValue(kKeySPsiP);
+
+ Double_t par2[7] = {
+ par[11],
+ 3.68609+(par[5]-3.096916)/3.096916*3.68609,
+ par[6]*SPsiPFactor, // /3.096916*3.68609,
+ par[7],
+ par[8],
+ par[9],
+ par[10]
+ };
+ return FitFunctionBackgroundVWG(x, par) + FitFunctionSignalCrystalBallExtended(x, &par[4]) + FitFunctionSignalCrystalBallExtended(x, par2);
+}
- TF1* fitTotal = new TF1("fitTotal",fitFunctionCB2VWG,xmin,xmax,11);
- fitTotal->SetParNames("kVWG","mVWG","sVWG1","sVWG2","norm","mean","sigma","alpha","n","alpha'","n'");
-
- fitTotal->SetParameter(0, 10000.); // kVWG
- fitTotal->SetParameter(1, 1.9); // mVWG
-
- fitTotal->SetParameter(2, 0.5); // sVWG1
- fitTotal->SetParLimits(2, 0., 100.);
+//____________________________________________________________________________
+Double_t AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2VWGINDEPTAILS(Double_t *x, Double_t *par)
+{
+ /// 2 extended crystal balls + pol2 x exp
+ /// The tail parameters are independent but the sPsiP and mPsiP are fixed to the one of the JPsi
+
+ Double_t SPsiPFactor = GetValue(kKeySPsiP);
+
+ Double_t par2[7] = {
+ par[11],
+ 3.68609+(par[5]-3.096916)/3.096916*3.68609,
+ par[6]*SPsiPFactor, // /3.096916*3.68609,
+ par[12],
+ par[13],
+ par[14],
+ par[15]
+ };
+ return FitFunctionBackgroundVWG(x, par) + FitFunctionSignalCrystalBallExtended(x, &par[4]) + FitFunctionSignalCrystalBallExtended(x, par2);
+
+// return FitFunctionBackgroundVWG(x, par) + FitFunctionSignalCrystalBallExtended(x, &par[4]) + FitFunctionSignalCrystalBallExtended(x, &par[11]);
+}
+
+//------------------------------------------------------------------------------
+Double_t AliAnalysisMuMuJpsiResult::alphaCB2VWG(Double_t*x, Double_t* par)
+{
+ return FitFunctionSignalCrystalBallExtended(x, &par[4])/(FitFunctionSignalCrystalBallExtended(x, &par[4]) + FitFunctionBackgroundVWG(x,par));
+}
+
+//------------------------------------------------------------------------------
+Double_t AliAnalysisMuMuJpsiResult::alphaCB2POL2EXP(Double_t*x, Double_t* par)
+{
+ return FitFunctionSignalCrystalBallExtended(x, &par[4])/(FitFunctionSignalCrystalBallExtended(x, &par[4]) + FitFunctionBackgroundPol2Exp(x,par));
+}
+
+//------------------------------------------------------------------------------
+Double_t AliAnalysisMuMuJpsiResult::alphaNA60NEWVWG(Double_t*x, Double_t* par)
+{
+ return FitFunctionNA60New(x, &par[4])/(FitFunctionNA60New(x, &par[4]) + FitFunctionBackgroundVWG(x,par));
+}
+
+//------------------------------------------------------------------------------
+Double_t AliAnalysisMuMuJpsiResult::alphaNA60NEWPOL2EXP(Double_t*x, Double_t* par)
+{
+ return FitFunctionNA60New(x, &par[4])/(FitFunctionNA60New(x, &par[4]) + FitFunctionBackgroundPol2Exp(x,par));
+}
+
+
+//------------------------------------------------------------------------------
+Double_t AliAnalysisMuMuJpsiResult::FitFunctionMeanPtSCB2Lin(Double_t* x, Double_t* par)
+{
+ // Fit function for Jpsi(Psip) mean pt with alphaJpsi
+ return alphaCB2VWG(x,par)*par[12] + (1. - alphaCB2VWG(x,par))*FitFunctionBackgroundPol2(x,&par[13]);
+}
+
+//____________________________________________________________________________
+Double_t AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2CB2Lin(Double_t *x, Double_t *par)
+{
+ // Fit function for Jpsi(Psip) mean pt with alphaJpsi and alphaPsiP
+ Double_t SPsiPFactor = GetValue(kKeySPsiP);
+
+ Double_t par2[11] = {
+ par[0],
+ par[1],
+ par[2],
+ par[3],
+ par[11], //kPsi'
+ 3.68609+(par[5]-3.096916)/3.096916*3.68609,
+ par[6]*SPsiPFactor, // /3.096916*3.68609,
+ par[7],
+ par[8],
+ par[9],
+ par[10]
+ };
+
+
+ return alphaCB2VWG(x,par)*par[12] + alphaCB2VWG(x,par2)*par[15] + (1. - alphaCB2VWG(x,par) - alphaCB2VWG(x,par2))*FitFunctionBackgroundPol2(x,&par[13]);
+}
+
+
+//------------------------------------------------------------------------------
+Double_t AliAnalysisMuMuJpsiResult::FitFunctionMeanPtSCB2VWGPOL2(Double_t* x, Double_t* par)
+{
+ // Fit function for Jpsi(Psip) mean pt with alphaJpsi
+ return alphaCB2VWG(x,par)*par[12] + (1. - alphaCB2VWG(x,par))*FitFunctionBackgroundPol2(x,&par[13]);
+}
+
+//____________________________________________________________________________
+Double_t AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2CB2VWGPOL2(Double_t *x, Double_t *par)
+{
+ // Fit function for Jpsi(Psip) mean pt with alphaJpsi and alphaPsiP
+ Double_t SPsiPFactor = GetValue(kKeySPsiP);
+
+ Double_t par2[11] = {
+ par[0],
+ par[1],
+ par[2],
+ par[3],
+ par[11], //kPsi'
+ 3.68609+(par[5]-3.096916)/3.096916*3.68609,
+ par[6]*SPsiPFactor, // /3.096916*3.68609,
+ par[7],
+ par[8],
+ par[9],
+ par[10]
+ };
+
+
+ return alphaCB2VWG(x,par)*par[12] + alphaCB2VWG(x,par2)*par[16] + (1. - alphaCB2VWG(x,par) - alphaCB2VWG(x,par2))*FitFunctionBackgroundPol2(x,&par[13]);
+}
+
+//____________________________________________________________________________
+Double_t AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2CB2VWGPOL2EXP(Double_t *x, Double_t *par)
+{
+ // Fit function for Jpsi(Psip) mean pt with alphaJpsi and alphaPsiP
+ Double_t SPsiPFactor = GetValue(kKeySPsiP);
+
+ Double_t par2[11] = {
+ par[0],
+ par[1],
+ par[2],
+ par[3],
+ par[11], //kPsi'
+ 3.68609+(par[5]-3.096916)/3.096916*3.68609,
+ par[6]*SPsiPFactor, // /3.096916*3.68609,
+ par[7],
+ par[8],
+ par[9],
+ par[10]
+ };
+
+
+ return alphaCB2VWG(x,par)*par[12] + alphaCB2VWG(x,par2)*par[17] + (1. - alphaCB2VWG(x,par) - alphaCB2VWG(x,par2))*FitFunctionBackgroundPol2Exp(x,&par[13]);
+}
+
+//____________________________________________________________________________
+Double_t AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2CB2POL2EXPPOL2(Double_t *x, Double_t *par)
+{
+ // Fit function for Jpsi(Psip) mean pt with alphaJpsi and alphaPsiP
+ Double_t SPsiPFactor = GetValue(kKeySPsiP);
+
+ Double_t par2[11] = {
+ par[0],
+ par[1],
+ par[2],
+ par[3],
+ par[11], //kPsi'
+ 3.68609+(par[5]-3.096916)/3.096916*3.68609,
+ par[6]*SPsiPFactor, // /3.096916*3.68609,
+ par[7],
+ par[8],
+ par[9],
+ par[10]
+ };
+
+
+ return alphaCB2POL2EXP(x,par)*par[12] + alphaCB2POL2EXP(x,par2)*par[16] + (1. - alphaCB2POL2EXP(x,par) - alphaCB2POL2EXP(x,par2))*FitFunctionBackgroundPol2(x,&par[13]);
+
+}
+
+//____________________________________________________________________________
+Double_t AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2CB2POL2EXPPOL2EXP(Double_t *x, Double_t *par)
+{
+ // Fit function for Jpsi(Psip) mean pt with alphaJpsi and alphaPsiP
+ Double_t SPsiPFactor = GetValue(kKeySPsiP);
+
+ Double_t par2[11] = {
+ par[0],
+ par[1],
+ par[2],
+ par[3],
+ par[11], //kPsi'
+ 3.68609+(par[5]-3.096916)/3.096916*3.68609,
+ par[6]*SPsiPFactor, // /3.096916*3.68609,
+ par[7],
+ par[8],
+ par[9],
+ par[10]
+ };
+
+
+ return alphaCB2POL2EXP(x,par)*par[12] + alphaCB2POL2EXP(x,par2)*par[17] + (1. - alphaCB2POL2EXP(x,par) - alphaCB2POL2EXP(x,par2))*FitFunctionBackgroundPol2Exp(x,&par[13]);
+
+}
+
+//____________________________________________________________________________
+Double_t AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2NA60NEWVWGPOL2(Double_t *x, Double_t *par)
+{
+ // Fit function for Jpsi(Psip) mean pt with alphaJpsi and alphaPsiP
+ Double_t SPsiPFactor = GetValue(kKeySPsiP);
+
+ Double_t par2[15] = {
+ par[0],
+ par[1],
+ par[2],
+ par[3],
+ par[15],
+ 3.68609+(par[5]-3.096916)/3.096916*3.68609,
+ par[6]*SPsiPFactor, // /3.096916*3.68609,
+ par[7],
+ par[8],
+ par[9],
+ par[10],
+ par[11],
+ par[12],
+ par[13],
+ par[14],
+ };
+
+ return alphaNA60NEWVWG(x,par)*par[16] + alphaNA60NEWVWG(x,par2)*par[20] + (1. - alphaNA60NEWVWG(x,par) - alphaNA60NEWVWG(x,par2))*FitFunctionBackgroundPol2(x,&par[17]);
+
+}
+
+//____________________________________________________________________________
+Double_t AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2NA60NEWVWGPOL2EXP(Double_t *x, Double_t *par)
+{
+ // Fit function for Jpsi(Psip) mean pt with alphaJpsi and alphaPsiP
+ Double_t SPsiPFactor = GetValue(kKeySPsiP);
+
+ Double_t par2[15] = {
+ par[0],
+ par[1],
+ par[2],
+ par[3],
+ par[15],
+ 3.68609+(par[5]-3.096916)/3.096916*3.68609,
+ par[6]*SPsiPFactor, // /3.096916*3.68609,
+ par[7],
+ par[8],
+ par[9],
+ par[10],
+ par[11],
+ par[12],
+ par[13],
+ par[14],
+ };
+
+
+ return alphaNA60NEWVWG(x,par)*par[16] + alphaNA60NEWVWG(x,par2)*par[21] + (1. - alphaNA60NEWVWG(x,par) - alphaNA60NEWVWG(x,par2))*FitFunctionBackgroundPol2Exp(x,&par[17]);
+
+}
+
+//____________________________________________________________________________
+Double_t AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2NA60NEWPOL2EXPPOL2(Double_t *x, Double_t *par)
+{
+ // Fit function for Jpsi(Psip) mean pt with alphaJpsi and alphaPsiP
+ Double_t SPsiPFactor = GetValue(kKeySPsiP);
+
+ Double_t par2[15] = {
+ par[0],
+ par[1],
+ par[2],
+ par[3],
+ par[15],
+ 3.68609+(par[5]-3.096916)/3.096916*3.68609,
+ par[6]*SPsiPFactor, // /3.096916*3.68609,
+ par[7],
+ par[8],
+ par[9],
+ par[10],
+ par[11],
+ par[12],
+ par[13],
+ par[14],
+ };
+
+ return alphaNA60NEWPOL2EXP(x,par)*par[16] + alphaNA60NEWPOL2EXP(x,par2)*par[20] + (1. - alphaNA60NEWPOL2EXP(x,par) - alphaNA60NEWPOL2EXP(x,par2))*FitFunctionBackgroundPol2(x,&par[17]);
+
+}
+
+//____________________________________________________________________________
+Double_t AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2NA60NEWPOL2EXPPOL2EXP(Double_t *x, Double_t *par)
+{
+ // Fit function for Jpsi(Psip) mean pt with alphaJpsi and alphaPsiP
+ Double_t SPsiPFactor = GetValue(kKeySPsiP);
+
+ Double_t par2[15] = {
+ par[0],
+ par[1],
+ par[2],
+ par[3],
+ par[15],
+ 3.68609+(par[5]-3.096916)/3.096916*3.68609,
+ par[6]*SPsiPFactor, // /3.096916*3.68609,
+ par[7],
+ par[8],
+ par[9],
+ par[10],
+ par[11],
+ par[12],
+ par[13],
+ par[14],
+ };
+
+ return alphaNA60NEWPOL2EXP(x,par)*par[16] + alphaNA60NEWPOL2EXP(x,par2)*par[21] + (1. - alphaNA60NEWPOL2EXP(x,par) - alphaNA60NEWPOL2EXP(x,par2))*FitFunctionBackgroundPol2Exp(x,&par[17]);
+
+}
+
+//____________________________________________________________________________
+Double_t AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2CB2VWGPOL3(Double_t *x, Double_t *par)
+{
+ // Fit function for Jpsi(Psip) mean pt with alphaJpsi and alphaPsiP
+ Double_t SPsiPFactor = GetValue(kKeySPsiP);
+
+ Double_t par2[11] = {
+ par[0],
+ par[1],
+ par[2],
+ par[3],
+ par[11], //kPsi'
+ 3.68609+(par[5]-3.096916)/3.096916*3.68609,
+ par[6]*SPsiPFactor, // /3.096916*3.68609,
+ par[7],
+ par[8],
+ par[9],
+ par[10]
+ };
+
+
+ return alphaCB2VWG(x,par)*par[12] + alphaCB2VWG(x,par2)*par[17] + (1. - alphaCB2VWG(x,par) - alphaCB2VWG(x,par2))*FitFunctionBackgroundPol2(x,&par[13]);
+}
+
+//____________________________________________________________________________
+Double_t AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2CB2VWGPOL4(Double_t *x, Double_t *par)
+{
+ // Fit function for Jpsi(Psip) mean pt with alphaJpsi and alphaPsiP
+ Double_t SPsiPFactor = GetValue(kKeySPsiP);
+
+ Double_t par2[11] = {
+ par[0],
+ par[1],
+ par[2],
+ par[3],
+ par[11], //kPsi'
+ 3.68609+(par[5]-3.096916)/3.096916*3.68609,
+ par[6]*SPsiPFactor, // /3.096916*3.68609,
+ par[7],
+ par[8],
+ par[9],
+ par[10]
+ };
+
+
+ return alphaCB2VWG(x,par)*par[12] + alphaCB2VWG(x,par2)*par[18] + (1. - alphaCB2VWG(x,par) - alphaCB2VWG(x,par2))*FitFunctionBackgroundPol4(x,&par[13]);
+}
+
+//------------------------------------------------------------------------------
+Double_t AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2CB2VWGPOL2INDEPTAILS(Double_t* x, Double_t* par)
+{
+ // Fit function for Jpsi(Psip) mean pt with alphaJpsi and alphaPsiP with independent tails
+ Double_t SPsiPFactor = GetValue(kKeySPsiP);
+
+ Double_t par2[11] = {
+ par[0],
+ par[1],
+ par[2],
+ par[3],
+ par[11], //kPsi'
+ 3.68609+(par[5]-3.096916)/3.096916*3.68609,
+ par[6]*SPsiPFactor, // /3.096916*3.68609,
+ par[12],
+ par[13],
+ par[14],
+ par[15]
+ };
+
+ return alphaCB2VWG(x,par)*par[16] + alphaCB2VWG(x,par2)*par[20] + (1. - alphaCB2VWG(x,par) - alphaCB2VWG(x,par2))*FitFunctionBackgroundPol2(x,&par[17]);
+}
+
+//_____________________________________________________________________________
+void AliAnalysisMuMuJpsiResult::FitPSICOUNT()
+{
+ /// Simple counting of the number of j/psi ...
+ Double_t n = CountParticle(*fHisto,Form("%s",GetParticle()));
+ Set(Form("Nof%s",GetParticle()),n,TMath::Sqrt(n));
+}
+
+//_____________________________________________________________________________
+void AliAnalysisMuMuJpsiResult::FitPSICB2()
+{
+ /// Fit using 1 extended crystal balls (pure signal)
+ TString particleName(GetParticle());
+
+ fHisto->GetListOfFunctions()->Delete();
+
+ Double_t alphaLow = GetValue(Form("al%s",particleName.Data()));
+ Double_t nLow = GetValue(Form("nl%s",particleName.Data()));
+ Double_t alphaUp = GetValue(Form("au%s",particleName.Data()));
+ Double_t nUp = GetValue(Form("nu%s",particleName.Data()));
+ Double_t fitRangeLow = GetValue(kFitRangeLow);
+ Double_t fitRangeHigh = GetValue(kFitRangeHigh);
+
+ TString msg;
+
+ if (IsValidValue(alphaLow)) msg += TString::Format("alphaLow=%e ",alphaLow);
+ if (IsValidValue(nLow)) msg += TString::Format("nLow=%e ",nLow);
+ if (IsValidValue(alphaUp)) msg += TString::Format("alphaUp=%e ",alphaUp);
+ if (IsValidValue(nUp)) msg += TString::Format("nUp=%e ",nUp);
+
+ AliDebug(1,Form("Fit with jpsi CB2 %s",msg.Data()));
+
+ // Extended Crystal Ball : 7 parameters
+ //
+ // par[0] = Normalization
+ // par[1] = mean
+ // par[2] = sigma
+ // par[3] = alpha
+ // par[4] = n
+ // par[5] = alpha'
+ // par[6] = n'
+
+ TF1* fitTotal = new TF1("signal",this,&AliAnalysisMuMuJpsiResult::FitFunctionSignalCrystalBallExtended,fitRangeLow,fitRangeHigh,7,"AliAnalysisMuMuJpsiResult","FitFunctionSignalCrystalBallExtended");
+
+ fitTotal->SetParNames(Form("k%s",particleName.Data()),Form("m%s",particleName.Data()),Form("s%s",particleName.Data()),Form("al%s",particleName.Data()),
+ // 0 1 2 3
+ Form("nl%s",particleName.Data()),Form("au%s",particleName.Data()),Form("nu%s",particleName.Data()));
+ // 4 5 6
+
+ fitTotal->SetParameter(0, fHisto->GetMaximum()); // norm
+
+ if (particleName.Contains("JPsi"))
+ {
+ fitTotal->SetParameter(1, 3.1);
+ fitTotal->SetParLimits(1, 3.08, 3.2);
+ fitTotal->SetParameter(2, 0.08);
+ fitTotal->SetParLimits(2, 0.05, 0.15);
+ }
+ else if (particleName.Contains("PsiP"))
+ {
+ fitTotal->SetParameter(1, 3.7);
+ fitTotal->SetParLimits(1, 3.63, 3.72);
+ fitTotal->SetParameter(2, 0.08);
+ fitTotal->SetParLimits(2, 0.05, 0.15);
+ }
+ else AliError(Form("Could not set initial fit parameters for particle %s: The fit might not converge",particleName.Data()));
+
+ SetParameter(fitTotal,3,alphaLow,0.9,0.1,10.0);
+ SetParameter(fitTotal,4,nLow,5.0,0.0,10.0);
+ SetParameter(fitTotal,5,alphaUp,2.0,0.1,10.0);
+ SetParameter(fitTotal,6,nUp,3.0,0.0,10.0);
+
+// fitTotal->FixParameter(3, alphaLow);
+// fitTotal->FixParameter(4, nLow);
+// fitTotal->FixParameter(5, alphaUp);
+// fitTotal->FixParameter(6, nUp);
+
+ TFitResultPtr fitResult = fHisto->Fit(fitTotal,"SER","");
+
+ // Check parameters...
+ if (
+ StrongCorrelation(fitResult,fitTotal,3,4,2) ||
+ StrongCorrelation(fitResult,fitTotal,5,6,2) ||
+ WrongParameter(fitTotal,3,1) ||
+ WrongParameter(fitTotal,4,0) ||
+ WrongParameter(fitTotal,5,1) ||
+ WrongParameter(fitTotal,6,0)
+ )
+ {
+ // try again...
+ fitResult = fHisto->Fit(fitTotal,"SER","");
+ }
+
+ TF1* signal = new TF1("signal",this,&AliAnalysisMuMuJpsiResult::FitFunctionSignalCrystalBallExtended,fHisto->GetXaxis()->GetXmin(),fHisto->GetXaxis()->GetXmax(),7,"AliAnalysisMuMuJpsiResult","SignalCB2");
+
+ signal->SetParameters(fitTotal->GetParameter(0),fitTotal->GetParameter(1),fitTotal->GetParameter(2),fitTotal->GetParameter(3),fitTotal->GetParameter(4),fitTotal->GetParameter(5),fitTotal->GetParameter(6));
+
+ Set("FitResult",static_cast<int>(fitResult)*1.0,0.0);
+ Set("FitChi2PerNDF",fitTotal->GetChisquare()/fitTotal->GetNDF(),0.0);
+ Set("FitNDF",fitTotal->GetNDF(),0.0);
+
+ Set(Form("m%s",particleName.Data()),fitTotal->GetParameter(1),fitTotal->GetParError(1));
+ Set(Form("s%s",particleName.Data()),fitTotal->GetParameter(2),fitTotal->GetParError(2));
+
+ Set(Form("al%s",particleName.Data()),fitTotal->GetParameter(3),fitTotal->GetParError(3));
+ Set(Form("nl%s",particleName.Data()),fitTotal->GetParameter(4),fitTotal->GetParError(4));
+ Set(Form("au%s",particleName.Data()),fitTotal->GetParameter(5),fitTotal->GetParError(5));
+ Set(Form("nu%s",particleName.Data()),fitTotal->GetParameter(6),fitTotal->GetParError(6));
+
+ AttachFunctionsToHisto(signal,0x0,fitTotal,fitRangeLow,fitRangeHigh);
+
+ Double_t a = fHisto->GetXaxis()->GetXmin();
+ Double_t b = fHisto->GetXaxis()->GetXmax();
+ double njpsi = fitTotal->Integral(a,b)/fHisto->GetBinWidth(1);
+ double nerr = fitTotal->IntegralError(a,b)/fHisto->GetBinWidth(1);
+
+ Set(Form("Nof%s",particleName.Data()),njpsi,nerr);
+
+ double m = GetValue(Form("m%s",particleName.Data()));
+ double s = GetValue(Form("s%s",particleName.Data()));
+ double al = GetValue(Form("al%s",particleName.Data()));
+ double au = GetValue(Form("au%s",particleName.Data()));
+
+ double njpsiCore = fitTotal->Integral(m-al*s,m+au*s)/fHisto->GetBinWidth(1);
+ double nerrCore = fitTotal->IntegralError(m-al*s,m+au*s)/fHisto->GetBinWidth(1);
+
+ double njpsiTailL = fitTotal->Integral(a,m-al*s)/fHisto->GetBinWidth(1);
+ double nerrTailL = fitTotal->IntegralError(a,m-al*s)/fHisto->GetBinWidth(1);
+
+ double njpsiTailR = fitTotal->Integral(m+au*s,b)/fHisto->GetBinWidth(1);
+ double nerrTailR = fitTotal->IntegralError(m+au*s,b)/fHisto->GetBinWidth(1);
+
+ Set(Form("Nof%sCore",particleName.Data()),njpsiCore,nerrCore);
+ Set(Form("Nof%sTailL",particleName.Data()),njpsiTailL,nerrTailL);
+ Set(Form("Nof%sTailR",particleName.Data()),njpsiTailR,nerrTailR);
+
+}
+
+//_____________________________________________________________________________
+void AliAnalysisMuMuJpsiResult::FitPSINA60NEW()
+{
+ /// Fit using 1 new NA60 (pure signal)
+
+ TString particleName(GetParticle());
+
+ fHisto->GetListOfFunctions()->Delete();
+
+ Double_t p1Left = GetValue(Form("p1L%s",particleName.Data()));
+ Double_t p2Left = GetValue(Form("p2L%s",particleName.Data()));
+ Double_t p3Left = GetValue(Form("p3L%s",particleName.Data()));
+ Double_t p1Right = GetValue(Form("p1R%s",particleName.Data()));
+ Double_t p2Right = GetValue(Form("p2R%s",particleName.Data()));
+ Double_t p3Right = GetValue(Form("p3R%s",particleName.Data()));
+
+ Double_t alphaLeft = GetValue(Form("aL%s",particleName.Data()));
+ Double_t alphaRight = GetValue(Form("aR%s",particleName.Data()));
+
+
+ Double_t fitRangeLow = GetValue(kFitRangeLow);
+ Double_t fitRangeHigh = GetValue(kFitRangeHigh);
+
+ TString msg;
+
+ if (IsValidValue(p1Left)) msg += TString::Format("p1L=%e ",p1Left);
+ if (IsValidValue(p2Left)) msg += TString::Format("p2L=%e ",p2Left);
+ if (IsValidValue(p3Left)) msg += TString::Format("p3L=%e ",p3Left);
+ if (IsValidValue(p1Right)) msg += TString::Format("p1R=%e ",p1Right);
+ if (IsValidValue(p2Right)) msg += TString::Format("p2R=%e ",p2Right);
+ if (IsValidValue(p3Right)) msg += TString::Format("p3R=%e ",p3Right);
+
+ if (IsValidValue(alphaLeft)) msg += TString::Format("aL=%e ",alphaLeft);
+ if (IsValidValue(alphaRight)) msg += TString::Format("aR=%e ",alphaRight);
+
+ AliDebug(1,Form("Fit with jpsi NA60 new %s",msg.Data()));
+
+ // New NA60 : 11 parameters
+ //
+ // par[0] = Normalization
+ // par[1] = mean
+ // par[2] = sigma
+ // par[3] = p1Left
+ // par[4] = p2Left
+ // par[5] = p3Left
+ // par[6] = p1Right
+ // par[7] = p2Right
+ // par[8] = p3Right
+ // par[9] = alphaLeft
+ // par[10] = alphaRight
+
+ TF1* fitTotal = new TF1("fitSignal",this,&AliAnalysisMuMuJpsiResult::FitFunctionNA60New,fitRangeLow,fitRangeHigh,11,"AliAnalysisMuMuJpsiResult","FitFunctionNA60New");
+
+ fitTotal->SetParNames(Form("k%s",particleName.Data()),Form("m%s",particleName.Data()),Form("s%s",particleName.Data()),Form("p1L%s",particleName.Data()),
+ // 0 1 2 3
+ Form("p2L%s",particleName.Data()),Form("p3L%s",particleName.Data()),Form("p1R%s",particleName.Data()),Form("p2R%s",particleName.Data()),
+ // 4 5 6 7
+ Form("p3R%s",particleName.Data()),Form("aL%s",particleName.Data()),Form("aR%s",particleName.Data()));
+ // 8 9 10
+
+ fitTotal->SetParameter(0, fHisto->GetMaximum()); // norm
+
+ if (particleName.Contains("JPsi"))
+ {
+ fitTotal->SetParameter(1, 3.1);
+ fitTotal->SetParLimits(1, 3.08, 3.2);
+ fitTotal->SetParameter(2, 0.08);
+ fitTotal->SetParLimits(2, 0.05, 0.15);
+ }
+ else if (particleName.Contains("PsiP"))
+ {
+ fitTotal->SetParameter(1, 3.7);
+ fitTotal->SetParLimits(1, 3.63, 3.72);
+ fitTotal->SetParameter(2, 0.08);
+ fitTotal->SetParLimits(2, 0.05, 0.15);
+ }
+ else AliError(Form("Could not set initial fit parameters for particle %s: The fit might not converge",particleName.Data()));
+
+ SetParameter(fitTotal,3,p1Left,0.02,0.001,2.0);
+ SetParameter(fitTotal,4,p2Left,0.4,0.2,0.6);
+ SetParameter(fitTotal,5,p3Left,0.2,0.05,0.4);
+ SetParameter(fitTotal,6,p1Right,0.2,0.001,0.4);
+ SetParameter(fitTotal,7,p2Right,1.0,0.0,1.4);
+ SetParameter(fitTotal,8,p3Right,0.02,0.005,0.4);
+
+ SetParameter(fitTotal,9,alphaLeft,0.0,-1.5,1.5);
+ SetParameter(fitTotal,10,alphaRight,2.3,2.0,2.5);
+
+// fitTotal->SetParameter(3, 0.2);
+// fitTotal->SetParameter(4, 2.0);
+// fitTotal->SetParameter(5, 1.);
+// fitTotal->SetParameter(6, 0.1);
+// fitTotal->SetParameter(7, 2.4);
+// fitTotal->SetParameter(8, 1.1);
+//
+// fitTotal->SetParameter(9, 1.0);
+// fitTotal->SetParameter(10, 1.0);
+
+// SetParameter(fitTotal,3,p1Left,0.1,-1.E5,1.E5);
+// SetParameter(fitTotal,4,p2Left,1.6,-1.E5,1.E5);
+// SetParameter(fitTotal,5,p3Left,0.06,-1.E5,1.E5);
+// SetParameter(fitTotal,6,p1Right,0.1,-1.E5,1.E5);
+// SetParameter(fitTotal,7,p2Right,1.5,-1.E5,1.E5);
+// SetParameter(fitTotal,8,p3Right,0.1,-1.E5,1.E5);
+//
+// SetParameter(fitTotal,9,alphaLeft,1.,-1.E8,1.E5);
+// SetParameter(fitTotal,10,alphaRight,1.0,-1.E5,1.E5);
+
+ TFitResultPtr fitResult = fHisto->Fit(fitTotal,"SER","");
+
+ // Check parameters...
+// if (
+// StrongCorrelation(fitResult,fitTotal,3,4,2) ||
+// StrongCorrelation(fitResult,fitTotal,5,6,2) ||
+// WrongParameter(fitTotal,3,1) ||
+// WrongParameter(fitTotal,4,0) ||
+// WrongParameter(fitTotal,5,1) ||
+// WrongParameter(fitTotal,6,0)
+// )
+// {
+// // try again...
+// fitResult = fHisto->Fit(fitTotal,"SER","");
+// }
+ TF1* signal = new TF1("signal",this,&AliAnalysisMuMuJpsiResult::FitFunctionNA60New,fHisto->GetXaxis()->GetXmin(),fHisto->GetXaxis()->GetXmax(),11,"AliAnalysisMuMuJpsiResult","SignalNA60New");
+
+ signal->SetParameters(fitTotal->GetParameter(0),fitTotal->GetParameter(1),fitTotal->GetParameter(2),fitTotal->GetParameter(3),fitTotal->GetParameter(4),fitTotal->GetParameter(5),fitTotal->GetParameter(6),fitTotal->GetParameter(7),fitTotal->GetParameter(8),fitTotal->GetParameter(9));
+ signal->SetParameter(10,fitTotal->GetParameter(10));
+
+ Set("FitResult",static_cast<int>(fitResult)*1.0,0.0);
+ Set("FitChi2PerNDF",fitTotal->GetChisquare()/fitTotal->GetNDF(),0.0);
+ Set("FitNDF",fitTotal->GetNDF(),0.0);
+
+ Set(Form("m%s",particleName.Data()),fitTotal->GetParameter(1),fitTotal->GetParError(1));
+ Set(Form("s%s",particleName.Data()),fitTotal->GetParameter(2),fitTotal->GetParError(2));
+
+ Set(Form("p1L%s",particleName.Data()),fitTotal->GetParameter(3),fitTotal->GetParError(3));
+ Set(Form("p2L%s",particleName.Data()),fitTotal->GetParameter(4),fitTotal->GetParError(4));
+ Set(Form("p3L%s",particleName.Data()),fitTotal->GetParameter(5),fitTotal->GetParError(5));
+ Set(Form("p1R%s",particleName.Data()),fitTotal->GetParameter(6),fitTotal->GetParError(6));
+ Set(Form("p2R%s",particleName.Data()),fitTotal->GetParameter(7),fitTotal->GetParError(7));
+ Set(Form("p3R%s",particleName.Data()),fitTotal->GetParameter(8),fitTotal->GetParError(8));
+
+ Set(Form("aL%s",particleName.Data()),fitTotal->GetParameter(9),fitTotal->GetParError(9));
+ Set(Form("aR%s",particleName.Data()),fitTotal->GetParameter(10),fitTotal->GetParError(10));
+
+ AttachFunctionsToHisto(signal,0x0,fitTotal,fitRangeLow,fitRangeHigh);
+
+ Double_t a = fHisto->GetXaxis()->GetXmin();
+ Double_t b = fHisto->GetXaxis()->GetXmax();
+ double njpsi = fitTotal->Integral(a,b)/fHisto->GetBinWidth(1);
+ double nerr = fitTotal->IntegralError(a,b)/fHisto->GetBinWidth(1);
+
+ Set(Form("Nof%s",particleName.Data()),njpsi,nerr);
+}
+
+//_____________________________________________________________________________
+void AliAnalysisMuMuJpsiResult::FitPSIPSIPRIMECB2VWG()
+{
+ /// Fit using 2 extended crystal balls (signal) + variable width gaussian (background)
+
+ fHisto->GetListOfFunctions()->Delete();
+
+ Double_t alphaLow = GetValue("alJPsi");
+ Double_t nLow = GetValue("nlJPsi");
+ Double_t alphaUp = GetValue("auJPsi");
+ Double_t nUp = GetValue("nuJPsi");
+ Double_t fitRangeLow = GetValue(kFitRangeLow);
+ Double_t fitRangeHigh = GetValue(kFitRangeHigh);
+ Double_t paramSPsiP = GetValue("FSigmaPsiP");
+
+ TString msg;
+
+ if (IsValidValue(alphaLow)) msg += TString::Format("alphaLow=%e ",alphaLow);
+ if (IsValidValue(nLow)) msg += TString::Format("nLow=%e ",nLow);
+ if (IsValidValue(alphaUp)) msg += TString::Format("alphaUp=%e ",alphaUp);
+ if (IsValidValue(nUp)) msg += TString::Format("nUp=%e ",nUp);
+
+ AliDebug(1,Form("Fit with jpsi + psiprime VWG %s",msg.Data()));
+
+// std::cout << "Tails parameters: " << msg.Data() << std::endl;
+
+ TF1* fitTotal = new TF1("signal+bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2VWG,fitRangeLow,fitRangeHigh,12,"AliAnalysisMuMuJpsiResult","FitFunctionTotalTwoCB2VWG");
+
+ fitTotal->SetParNames("kVWG","mVWG","sVWG1","sVWG2","kJPsi","mJPsi","sJPsi",
+// 0 1 2 3 4 5 6
+ "alJPsi","nlJPsi","auJPsi","nuJPsi");
+// 7 8 9 10
+ fitTotal->SetParName(11, "kPsiP");
+// 11
+
+
+ TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundVWG,fitRangeLow,fitRangeHigh,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundVWG");
+
+ const char* fitOption = "SER"; //We can add NO to avoid plotting
+
+#if 0
+ bck->SetParameter(0,fHisto->GetMaximum());
+ bck->SetParameter(1,3);
+ bck->SetParameter(2,10);
+ bck->SetParameter(3,10);
+
+ bck->SetParLimits(1, 0., 100.);
+ bck->SetParLimits(2, 0., 100.);
+ bck->SetParLimits(3, 0., 100.);
+
+ SetFitRejectRange(2.7,3.5);
+
+ fHisto->Fit(bck,fitOption,"");
+
+ for ( Int_t i = 0; i < 4; ++i )
+ {
+ Double_t a,b;
+ bck->GetParLimits(i,a,b);
+ fitTotal->SetParameter(i,bck->GetParameter(i));
+ fitTotal->SetParLimits(i,a,b);
+ }
+#endif
+ TF1* bckInit = new TF1("bckInit",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundVWG,1.7,6.,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundVWG");
+
+ Int_t bin = fHisto->FindBin(0.26);
+
+ bckInit->SetParameters(fHisto->GetBinContent(bin),2.,0.5,0.3);
+
+ SetFitRejectRange(2.7,4.0);
+
+ TFitResultPtr fitResultInit = fHisto->Fit(bckInit,"SR");
+
+ std::cout << "FitResultBkgInit=" << static_cast<int>(fitResultInit) << std::endl;
+
+ if ( static_cast<int>(fitResultInit) )
+ {
+ bin = fHisto->FindBin(0.82);
+ bckInit->SetParameters(fHisto->GetBinContent(bin),2.,0.5,0.3);
+ fitResultInit = fHisto->Fit(bckInit,"SR");
+ }
+ else if ( bckInit->GetParameter(0) < 0 )
+ {
+ bckInit->SetParameters(fHisto->GetBinContent(bin),2.,0.5,0.3);
+ }
+
+ SetFitRejectRange();
+
+ for ( Int_t i = 0; i < 4; ++i )
+ {
+ fitTotal->SetParameter(i, bckInit->GetParameter(i));
+ }
- fitTotal->SetParameter(3, 0.3); // sVWG2
- fitTotal->SetParLimits(3, 0., 100.);
- fitTotal->SetParameter(4, h.GetMaximum()); // norm
+
+// fitTotal->SetParameter(0, fHisto->GetMaximum()); // kVWG
+// fitTotal->SetParameter(1, 1.9); // mVWG
+//
+// fitTotal->SetParameter(2, 0.5); // sVWG1
+// fitTotal->SetParLimits(2, 0., 100.);
+//
+// fitTotal->SetParameter(3, 0.3); // sVWG2
+// fitTotal->SetParLimits(3, 0., 100.);
+
+ bin = fHisto->FindBin(3.09);
+ fitTotal->SetParameter(4, fHisto->GetBinContent(bin)); // norm
fitTotal->SetParameter(5, 3.1); // mean
fitTotal->SetParLimits(5, 3.0, 3.2);
fitTotal->SetParameter(6, 0.08); // sigma
- fitTotal->SetParLimits(6, 0.04, 0.20);
+ fitTotal->SetParLimits(6, 0.05, 0.09);
+
+ if ( IsValidValue(alphaLow) )
+ {
+ fitTotal->FixParameter(7, alphaLow);
+ }
+ else
+ {
+ fitTotal->SetParameter(7,0.9);
+ fitTotal->SetParLimits(7,0.1,10.0);
+ }
+
+ if ( IsValidValue(nLow) )
+ {
+ fitTotal->FixParameter(8, nLow);
+ }
+ else
+ {
+ fitTotal->SetParameter(8,5.0);
+ fitTotal->SetParLimits(8,0.0,10.0);
+ }
+
+ if ( IsValidValue(alphaUp) )
+ {
+ fitTotal->FixParameter(9, alphaUp);
+ }
+ else
+ {
+ fitTotal->SetParameter(9, 2.0);
+ fitTotal->SetParLimits(9,0.1,10.0);
+ }
+
+ if ( IsValidValue(nUp) )
+ {
+ fitTotal->FixParameter(10, nUp);
+ }
+ else
+ {
+ fitTotal->SetParameter(10,3.0);
+ fitTotal->SetParLimits(10,0.0,10.0);
+ }
+
+ fitTotal->SetParameter(11, 10.); //kPsi'
+ fitTotal->SetParLimits(11, 0.,100000.);
- fitTotal->SetParameter(7,1.0); // alpha
- fitTotal->SetParameter(8,5); // n
- fitTotal->SetParameter(9,2.0); // alpha'
- fitTotal->SetParameter(10,4); // n'
+ SetFitRejectRange();
+
+// std::cout << fitTotal->GetParameter(0) << std::endl; //Just a xcheck
+
+ TFitResultPtr fitResult = fHisto->Fit(fitTotal,fitOption,"");
+
+// std::cout << fitTotal->GetParameter(0) << " ?= " << fitResult->Parameter(0) << std::endl; //Just a xcheck
+
+ std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
+ std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
+
+// std::cout << fitTotal->GetParameter(0) << std::endl; //Just a xcheck
+
+ if ( static_cast<int>(fitResult) )
+ {
+ if ( 0.5*fitTotal->GetParameter(11) <= fitTotal->GetParError(11) ) //kPsi'
+ {
+ std::cout << "//-------Refitting again (setting Psi'norm=0)" << std::endl;
+ bin = fHisto->FindBin(3.68);
+ fitTotal->SetParameter(11, fHisto->GetBinContent(bin)/2.);
+ }
+
+ if ( 0.5*fitTotal->GetParameter(0) <= fitTotal->GetParError(0) )
+ {
+ std::cout << "//-------Refitting again (setting kVWG=kVWG/2)" << std::endl;
+
+ fitTotal->SetParameter(0, fHisto->GetMaximum()/2.); // kVWG
+ }
+
+ fitResult = fHisto->Fit(fitTotal,fitOption,"");
+ std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
+ }
-// fitTotal->FixParameter(7, 0.93);
-// fitTotal->FixParameter(8, 5.59);
-// fitTotal->FixParameter(9, 2.32);
-// fitTotal->FixParameter(10, 3.39);
-// fitTotal->SetParameter(11, 10.);
+ if ( static_cast<int>(fitResult) )
+ {
+ std::cout << "//-------Refitting again (setting kVWG=kVWG*2)" << std::endl;
+
+ fitTotal->SetParameter(0, fHisto->GetMaximum()*2.); // kVWG
+
+ fitResult = fHisto->Fit(fitTotal,fitOption,"");
+ std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
+ }
- const char* fitOption = "QSIER"; //+";
+ if ( static_cast<int>(fitResult) )
+ {
+ std::cout << "//-------Refitting again (setting kVWG=kVWG/2)" << std::endl;
+
+ fitTotal->SetParameter(0, fHisto->GetMaximum()/2.); // kVWG
+
+ fitResult = fHisto->Fit(fitTotal,fitOption,"");
+ std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
+ }
+
+// if ( fitResult->CovMatrixStatus() != 3 )
+// {
+// std::cout << "//-------Refitting again (setting Bkg norm= Bkg norm/2)" << std::endl;
+// fitTotal->SetParameter(0, fHisto->GetMaximum()/2.); // kVWG
+// fitResult = fHisto->Fit(fitTotal,fitOption,"");
+// }
- TFitResultPtr fitResult = hfit->Fit(fitTotal,fitOption,"");
+// if ( fitResult->CovMatrixStatus() != 3 )
+// {
+// std::cout << "//-------Refitting again (setting Psi'norm= Psi'norm/2)" << std::endl;
+// fitTotal->SetParameter(11, 5.); // //kPsi'
+// fitResult = fHisto->Fit(fitTotal,fitOption,"");
+//
+// std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
+// }
+//
+// if ( fitResult->CovMatrixStatus() != 3 )
+// {
+// std::cout << "//-------Refitting again (refitting Bkg)" << std::endl;
+//
+// for ( Int_t i = 0; i < 4; ++i )
+// {
+// bck->SetParameter(i, fitTotal->GetParameter(i));
+// }
+//
+// SetFitRejectRange(2.7,3.5);
+//
+// fHisto->Fit(bck,"R");
+//
+// SetFitRejectRange();
+//
+// for ( Int_t i = 0; i < 4; ++i )
+// {
+// fitTotal->SetParameter(i, bck->GetParameter(i));
+// }
+//
+// fitResult = fHisto->Fit(fitTotal,fitOption,"");
+// std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
+// std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
+// }
+// if ( static_cast<int>(fitResult) )
+// {
+// fitTotal->SetParameter(0, fHisto->GetMaximum()); // kVWG
+// fitTotal->SetParameter(1, 1.9); // mVWG
+//
+// fitTotal->SetParameter(2, 0.5); // sVWG1
+// fitTotal->SetParLimits(2, 0., 100.);
+//
+// fitResult = fHisto->Fit(fitTotal,fitOption,"");
+// std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
+// std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
+//
+// }
+ if ( static_cast<int>(fitResult) )
+ {
+ for ( Int_t i = 0; i < 4; ++i )
+ {
+ fitTotal->SetParameter(i, bckInit->GetParameter(i));
+ }
+ fitResult = fHisto->Fit(fitTotal,fitOption,"");
+
+ if ( static_cast<int>(fitResult) ) std::cout << "//-------Cannot fit properly, try something else..." << std::endl;
+ }
- r->Set("MeanJpsi",fitTotal->GetParameter(5),fitTotal->GetParError(5));
- r->Set("SigmaJpsi",fitTotal->GetParameter(6),fitTotal->GetParError(6));
+ delete bckInit;
- double m = r->GetValue("MeanJpsi");
- double s = r->GetValue("SigmaJpsi");
- double n = 3.0;
+ Set("FitChi2PerNDF",fitTotal->GetChisquare()/fitTotal->GetNDF(),0.0);
+ Set("FitNDF",fitTotal->GetNDF(),0.0);
+
+ Set("mJPsi",fitTotal->GetParameter(5),fitTotal->GetParError(5));
+ Set("sJPsi",fitTotal->GetParameter(6),fitTotal->GetParError(6));
- TF1* fcb = new TF1("fcb",CrystalBallExtended,xmin,xmax,7);
- fcb->SetParameters(fitTotal->GetParameter(4),
+ TF1* signalJPsi = new TF1("signalJPsi",this,&AliAnalysisMuMuJpsiResult::FitFunctionSignalCrystalBallExtended,fHisto->GetXaxis()->GetXmin(),fHisto->GetXaxis()->GetXmax(),7,"AliAnalysisMuMuJpsiResult","FitFunctionSignalCrystalBallExtended");
+ signalJPsi->SetParameters(fitTotal->GetParameter(4),
fitTotal->GetParameter(5),
fitTotal->GetParameter(6),
fitTotal->GetParameter(7),
fitTotal->GetParameter(9),
fitTotal->GetParameter(10));
+ TF1* signalPsiP = new TF1("signalPsiP",this,&AliAnalysisMuMuJpsiResult::FitFunctionSignalCrystalBallExtended,fHisto->GetXaxis()->GetXmin(),fHisto->GetXaxis()->GetXmax(),7,"AliAnalysisMuMuJpsiResult","FitFunctionSignalCrystalBallExtended");
+ signalPsiP->SetParameters(fitTotal->GetParameter(11),
+ 3.68609+(fitTotal->GetParameter(5)-3.096916)/3.096916*3.68609,
+ fitTotal->GetParameter(6)*paramSPsiP, // /3.096916*3.68609,
+ fitTotal->GetParameter(7),
+ fitTotal->GetParameter(8),
+ fitTotal->GetParameter(9),
+ fitTotal->GetParameter(10));
+
+ bck->SetParameters(fitTotal->GetParameter(0),
+ fitTotal->GetParameter(1),
+ fitTotal->GetParameter(2),
+ fitTotal->GetParameter(3));
+
+
+ Set("kVWG",fitTotal->GetParameter(0),fitTotal->GetParError(0));
+ Set("mVWG",fitTotal->GetParameter(1),fitTotal->GetParError(1));
+ Set("sVWG1",fitTotal->GetParameter(2),fitTotal->GetParError(2));
+ Set("sVWG2",fitTotal->GetParameter(3),fitTotal->GetParError(3));
+ Set("kJPsi",fitTotal->GetParameter(4),fitTotal->GetParError(4));
+
+ Set("alJPsi",fitTotal->GetParameter(7),fitTotal->GetParError(7));
+ Set("nlJPsi",fitTotal->GetParameter(8),fitTotal->GetParError(8));
+ Set("auJPsi",fitTotal->GetParameter(9),fitTotal->GetParError(9));
+ Set("nuJPsi",fitTotal->GetParameter(10),fitTotal->GetParError(10));
+
+// Set("alPsi",fitTotal->GetParameter(7),fitTotal->GetParError(7));
+// Set("nlPsi",fitTotal->GetParameter(8),fitTotal->GetParError(8));
+// Set("auPsi",fitTotal->GetParameter(9),fitTotal->GetParError(9));
+// Set("nuPsi",fitTotal->GetParameter(10),fitTotal->GetParError(10));
+ Set("kPsiP",fitTotal->GetParameter(11),fitTotal->GetParError(11));
+
+
+ SetFitRejectRange();
+
+ AttachFunctionsToHisto(signalJPsi,signalPsiP,bck,fitTotal,fitRangeLow,fitRangeHigh);
+
+
+ Double_t cbParameters[7];
+ Double_t covarianceMatrix[7][7];
+
+ for ( int ix = 0; ix < 7; ++ix )
+ {
+ cbParameters[ix] = fitTotal->GetParameter(ix+4);
+ }
+
+ for ( int iy = 0; iy < 7; ++iy )
+ {
+ for ( int ix = 0; ix < 7; ++ix )
+ {
+ covarianceMatrix[ix][iy] = (fitResult->GetCovarianceMatrix())(ix+4,iy+4);
+ }
+ }
+
+ Double_t a = fHisto->GetXaxis()->GetXmin();
+ Double_t b = fHisto->GetXaxis()->GetXmax();
+ double njpsi = signalJPsi->Integral(a,b)/fHisto->GetBinWidth(1);
+ double nerr = signalJPsi->IntegralError(a,b,&cbParameters[0],&covarianceMatrix[0][0])/fHisto->GetBinWidth(1);
+
+ Set("NofJPsi",njpsi,nerr);
+
+ double m = GetValue("mJPsi");
+ double s = GetValue("sJPsi");
+ double njpsi3s = signalJPsi->Integral(m-3*s,m+3*s)/fHisto->GetBinWidth(1);
+ double nerr3s = signalJPsi->IntegralError(m-3*s,m+3*s,&cbParameters[0],&covarianceMatrix[0][0])/fHisto->GetBinWidth(1);
+
+ Set("NofJPsi3s",njpsi3s,nerr3s);
+
+ //Computation of bin significance and signal over background
+
+ Double_t bkgParameters[4];
+ Double_t bkgcovarianceMatrix[4][4];
+
+ for ( int ix = 0; ix < 4; ++ix )
+ {
+ bkgParameters[ix] = fitTotal->GetParameter(ix);
+ }
+
+ for ( int iy = 0; iy < 4; ++iy )
+ {
+ for ( int ix = 0; ix < 4; ++ix )
+ {
+ bkgcovarianceMatrix[ix][iy] = (fitResult->GetCovarianceMatrix())(ix,iy);
+ }
+ }
+
+ double nbck3s = bck->Integral(m-3.*s,m+3.*s)/fHisto->GetBinWidth(1);
+ double nbck3sErr = bck->IntegralError(m-3.*s,m+3.*s,&bkgParameters[0],&bkgcovarianceMatrix[0][0])/fHisto->GetBinWidth(1);
+
+ double sOverB3s = njpsi3s / nbck3s;
+ double sOverB3sErr = sOverB3s*TMath::Sqrt(TMath::Power(nerr3s/njpsi3s,2.) + TMath::Power(nbck3sErr/nbck3s,2.));
+
+ Set("SignalOverBkg3s",sOverB3s,sOverB3sErr);
+
+ double sig = njpsi3s/TMath::Sqrt(njpsi3s + nbck3s);
+ double sigErr = TMath::Sqrt( TMath::Power((1. - (1./2.)*njpsi3s/(njpsi3s + nbck3s) )*nerr3s/TMath::Sqrt(njpsi3s + nbck3s),2.) +
+ TMath::Power(njpsi3s*nbck3sErr/(2.*TMath::Power(njpsi3s + nbck3s,3./2.)),2.) );
+
+ Set("Significance3s",sig,sigErr);
+
+}
+
+//_____________________________________________________________________________
+void AliAnalysisMuMuJpsiResult::FitPSIPSIPRIMECB2VWGINDEPTAILS()
+{
+ /// Fit using 2 extended crystal balls with independent tails (signal) + variable width gaussian (background)
+
+ fHisto->GetListOfFunctions()->Delete();
+
+ Double_t alphaLow = GetValue("alJPsi");
+ Double_t nLow = GetValue("nlJPsi");
+ Double_t alphaUp = GetValue("auJPsi");
+ Double_t nUp = GetValue("nuJPsi");
+
+ Double_t alphaLowP = GetValue("alPsiP");
+ Double_t nLowP = GetValue("nlPsiP");
+ Double_t alphaUpP = GetValue("auPsiP");
+ Double_t nUpP = GetValue("nuPsiP");
+
+ Double_t fitRangeLow = GetValue(kFitRangeLow);
+ Double_t fitRangeHigh = GetValue(kFitRangeHigh);
+
+ Double_t paramSPsiP = GetValue("FSigmaPsiP");
+
+ TString msg;
+
+ if (IsValidValue(alphaLow)) msg += TString::Format("alphaLow=%e ",alphaLow);
+ if (IsValidValue(nLow)) msg += TString::Format("nLow=%e ",nLow);
+ if (IsValidValue(alphaUp)) msg += TString::Format("alphaUp=%e ",alphaUp);
+ if (IsValidValue(nUp)) msg += TString::Format("nUp=%e ",nUp);
+
+ if (IsValidValue(alphaLowP)) msg += TString::Format("alphaLowP=%e ",alphaLowP);
+ if (IsValidValue(nLowP)) msg += TString::Format("nLowP=%e ",nLowP);
+ if (IsValidValue(alphaUpP)) msg += TString::Format("alphaUpP=%e ",alphaUpP);
+ if (IsValidValue(nUpP)) msg += TString::Format("nUpP=%e ",nUpP);
+
+ AliDebug(1,Form("Fit with jpsi + psiprime VWG %s",msg.Data()));
+
+ // Add fit with indep tails
+
+ TF1* fitTotal = new TF1("signal+bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2VWGINDEPTAILS,fitRangeLow,fitRangeHigh,16,"AliAnalysisMuMuJpsiResult","FitFunctionTotalTwoCB2VWGINDEPTAILS");
+
+ fitTotal->SetParNames("kVWG","mVWG","sVWG1","sVWG2","kJPsi","mJPsi","sJPsi",
+ // 0 1 2 3 4 5 6
+ "alJPsi","nlJPsi","auJPsi","nuJPsi");
+ // 7 8 9 10
+// fitTotal->SetParName(11, "kPsiP");
+// // 11
+// fitTotal->SetParName(12, "mPsiP");
+// // 12
+// fitTotal->SetParName(13, "sPsiP");
+// // 13
+// fitTotal->SetParName(14, "alPsiP");
+// // 14
+// fitTotal->SetParName(15, "nlPsiP");
+// // 15
+// fitTotal->SetParName(16, "auPsiP");
+// // 16
+// fitTotal->SetParName(17, "nuPsiP");
+// // 17
+
+ fitTotal->SetParName(11, "kPsiP");
+ // 11
+ fitTotal->SetParName(12, "alPsiP");
+ // 12
+ fitTotal->SetParName(13, "nlPsiP");
+ // 13
+ fitTotal->SetParName(14, "auPsiP");
+ // 14
+ fitTotal->SetParName(15, "nuPsiP");
+ // 15
+
+
+ TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundVWG,fitRangeLow,fitRangeHigh,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundVWG");
+
+ const char* fitOption = "SER";
+
+#if 0
+ bck->SetParameter(0,fHisto->GetMaximum());
+ bck->SetParameter(1,3);
+ bck->SetParameter(2,10);
+ bck->SetParameter(3,10);
+
+ bck->SetParLimits(1, 0., 100.);
+ bck->SetParLimits(2, 0., 100.);
+ bck->SetParLimits(3, 0., 100.);
+
+ SetFitRejectRange(2.7,3.5);
+
+ fHisto->Fit(bck,fitOption,"");
+
+ for ( Int_t i = 0; i < 4; ++i )
+ {
+ Double_t a,b;
+ bck->GetParLimits(i,a,b);
+ fitTotal->SetParameter(i,bck->GetParameter(i));
+ fitTotal->SetParLimits(i,a,b);
+ }
+#endif
+
+ Int_t bin = fHisto->FindBin(fitRangeLow);
+ fitTotal->SetParameter(0, fHisto->GetBinContent(bin)); // kVWG
+ fitTotal->SetParameter(1, 1.9); // mVWG
+
+ fitTotal->SetParameter(2, 0.5); // sVWG1
+ fitTotal->SetParLimits(2, 0., 100.);
+
+ fitTotal->SetParameter(3, 0.3); // sVWG2
+ fitTotal->SetParLimits(3, 0., 100.);
+
+ bin = fHisto->FindBin(3.09);
+ fitTotal->SetParameter(4, fHisto->GetBinContent(bin)); // norm(kJPsi)
+
+ fitTotal->SetParameter(5, 3.1); // mean
+ fitTotal->SetParLimits(5, 3.0, 3.2);
+
+ fitTotal->SetParameter(6, 0.08); // sigma
+ fitTotal->SetParLimits(6, 0.03, 0.15);
+
+ if ( IsValidValue(alphaLow) )
+ {
+ fitTotal->FixParameter(7, alphaLow);
+ }
+ else
+ {
+ fitTotal->SetParameter(7,0.9);
+ fitTotal->SetParLimits(7,0.1,10.0);
+ }
+
+ if ( IsValidValue(nLow) )
+ {
+ fitTotal->FixParameter(8, nLow);
+ }
+ else
+ {
+ fitTotal->SetParameter(8,5.0);
+ fitTotal->SetParLimits(8,0.0,10.0);
+ }
+
+ if ( IsValidValue(alphaUp) )
+ {
+ fitTotal->FixParameter(9, alphaUp);
+ }
+ else
+ {
+ fitTotal->SetParameter(9, 2.0);
+ fitTotal->SetParLimits(9,0.1,10.0);
+ }
+
+ if ( IsValidValue(nUp) )
+ {
+ fitTotal->FixParameter(10, nUp);
+ }
+ else
+ {
+ fitTotal->SetParameter(10,3.0);
+ fitTotal->SetParLimits(10,0.0,10.0);
+ }
+
+ bin = fHisto->FindBin(3.68);
+ fitTotal->SetParameter(11, fHisto->GetBinContent(bin)); //kPsiP
+ fitTotal->SetParLimits(11, 0., fHisto->GetBinContent(bin)*2); //kPsiP
+
+// fitTotal->SetParameter(12, 3.7); // mean PsiP
+// fitTotal->SetParLimits(12, 3.6, 3.71);
+//
+// fitTotal->SetParameter(13, 0.08/3.096916*3.68609); // sigma PsiP
+// fitTotal->SetParLimits(13, 0.03/3.096916*3.68609, 0.15/3.096916*3.68609);
+
+ if ( IsValidValue(alphaLowP) )
+ {
+ fitTotal->FixParameter(12, alphaLowP);
+ }
+ else
+ {
+ fitTotal->SetParameter(12,0.9);
+ fitTotal->SetParLimits(12,0.1,10.0);
+ }
+
+ if ( IsValidValue(nLowP) )
+ {
+ fitTotal->FixParameter(13, nLowP);
+ }
+ else
+ {
+ fitTotal->SetParameter(13,5.0);
+ fitTotal->SetParLimits(13,0.0,10.0);
+ }
+
+ if ( IsValidValue(alphaUpP) )
+ {
+ fitTotal->FixParameter(14, alphaUpP);
+ }
+ else
+ {
+ fitTotal->SetParameter(14, 2.0);
+ fitTotal->SetParLimits(14,0.1,10.0);
+ }
+
+ if ( IsValidValue(nUpP) )
+ {
+ fitTotal->FixParameter(15, nUpP);
+ }
+ else
+ {
+ fitTotal->SetParameter(15,3.0);
+ fitTotal->SetParLimits(15,0.0,10.0);
+ }
+
+ // SetFitRejectRange();
+
+ TFitResultPtr fitResult = fHisto->Fit(fitTotal,fitOption,"");
+
+ std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
+
+ if ( static_cast<int>(fitResult) )
+ {
+ if ( fitTotal->GetParameter(11) <= fitTotal->GetParError(11) ) //kPsi'
+ {
+ std::cout << "//-------Refitting again (setting Psi'norm= Psi'norm/2)" << std::endl;
+
+ fitTotal->SetParameter(11, fHisto->GetBinContent(bin)/2.);
+ }
+
+ if ( fitTotal->GetParameter(0) <= fitTotal->GetParError(0) ) //kVWG
+ {
+ std::cout << "//-------Refitting again (setting VWG norm= VWG norm /2)" << std::endl;
+ bin = fHisto->FindBin(fitRangeLow);
+
+ fitTotal->SetParameter(0, fHisto->GetBinContent(bin)/2.);
+ }
+
+ fitResult = fHisto->Fit(fitTotal,fitOption,"");
+ std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
+ }
+
+
+ if ( static_cast<int>(fitResult) )
+ {
+ if ( fitTotal->GetParameter(11) <= fitTotal->GetParError(11) ) //kPsi'
+ {
+ std::cout << "//-------Refitting again (setting Psi'norm=0)" << std::endl;
+
+ fitTotal->FixParameter(11, 0.);
+ }
+
+ fitResult = fHisto->Fit(fitTotal,fitOption,"");
+ std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
+ }
+
+ if ( static_cast<int>(fitResult) )
+ {
+ std::cout << "//-------Refitting again (setting kVWG=kVWG/2)" << std::endl;
+
+ fitTotal->SetParameter(0, fHisto->GetMaximum()/2.); // kVWG
+
+ fitResult = fHisto->Fit(fitTotal,fitOption,"");
+ std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
+ }
+
+ if ( static_cast<int>(fitResult) )
+ {
+ std::cout << "//-------Cannot fit properly, try something else..." << std::endl;
+ }
+
+
+ Set("FitChi2PerNDF",fitTotal->GetChisquare()/fitTotal->GetNDF(),0.0);
+ Set("FitNDF",fitTotal->GetNDF(),0.0);
+
+ Set("mJPsi",fitTotal->GetParameter(5),fitTotal->GetParError(5));
+ Set("sJPsi",fitTotal->GetParameter(6),fitTotal->GetParError(6));
+
+ Set("mPsiP",3.68609+(fitTotal->GetParameter(5)-3.096916)/3.096916*3.68609,fitTotal->GetParError(5)/3.096916*3.68609);
+ Set("sPsiP",fitTotal->GetParameter(6)*paramSPsiP,fitTotal->GetParError(6)*paramSPsiP);
+
+ TF1* signalJPsi = new TF1("signalJPsi",this,&AliAnalysisMuMuJpsiResult::FitFunctionSignalCrystalBallExtended,fHisto->GetXaxis()->GetXmin(),fHisto->GetXaxis()->GetXmax(),7,"AliAnalysisMuMuJpsiResult","FitFunctionSignalCrystalBallExtended");
+ signalJPsi->SetParameters(fitTotal->GetParameter(4),
+ fitTotal->GetParameter(5),
+ fitTotal->GetParameter(6),
+ fitTotal->GetParameter(7),
+ fitTotal->GetParameter(8),
+ fitTotal->GetParameter(9),
+ fitTotal->GetParameter(10));
+
+ TF1* signalPsiP = new TF1("signalPsiP",this,&AliAnalysisMuMuJpsiResult::FitFunctionSignalCrystalBallExtended,fHisto->GetXaxis()->GetXmin(),fHisto->GetXaxis()->GetXmax(),7,"AliAnalysisMuMuJpsiResult","FitFunctionSignalCrystalBallExtended");
+ signalPsiP->SetParameters(fitTotal->GetParameter(11),
+ 3.68609+(fitTotal->GetParameter(5)-3.096916)/3.096916*3.68609,
+ fitTotal->GetParameter(6)*paramSPsiP, // /3.096916*3.68609,
+ fitTotal->GetParameter(12),
+ fitTotal->GetParameter(13),
+ fitTotal->GetParameter(14),
+ fitTotal->GetParameter(15));
+
+ bck->SetParameters(fitTotal->GetParameter(0),
+ fitTotal->GetParameter(1),
+ fitTotal->GetParameter(2),
+ fitTotal->GetParameter(3));
+
+
+ Set("kVWG",fitTotal->GetParameter(0),fitTotal->GetParError(0));
+ Set("mVWG",fitTotal->GetParameter(1),fitTotal->GetParError(1));
+ Set("sVWG1",fitTotal->GetParameter(2),fitTotal->GetParError(2));
+ Set("sVWG2",fitTotal->GetParameter(3),fitTotal->GetParError(3));
+
+ Set("kJPsi",fitTotal->GetParameter(4),fitTotal->GetParError(4));
+ Set("alJPsi",fitTotal->GetParameter(7),fitTotal->GetParError(7));
+ Set("nlJPsi",fitTotal->GetParameter(8),fitTotal->GetParError(8));
+ Set("auJPsi",fitTotal->GetParameter(9),fitTotal->GetParError(9));
+ Set("nuJPsi",fitTotal->GetParameter(10),fitTotal->GetParError(10));
+
+ Set("kPsiP",fitTotal->GetParameter(11),fitTotal->GetParError(11));
+ Set("alPsiP",fitTotal->GetParameter(12),fitTotal->GetParError(12));
+ Set("nlPsiP",fitTotal->GetParameter(13),fitTotal->GetParError(13));
+ Set("auPsiP",fitTotal->GetParameter(14),fitTotal->GetParError(14));
+ Set("nuPsiP",fitTotal->GetParameter(15),fitTotal->GetParError(15));
+
+
+
+// SetFitRejectRange();
+
+ AttachFunctionsToHisto(signalJPsi,signalPsiP,bck,fitTotal,fitRangeLow,fitRangeHigh);
- fcb->SetLineColor(1);
- fcb->SetNpx(1000);
- TLine* l1 = new TLine(m-n*s,0,m-n*s,fitTotal->GetParameter(4));
- TLine* l2 = new TLine(m+n*s,0,m+n*s,fitTotal->GetParameter(4));
- l1->SetLineColor(6);
- l2->SetLineColor(6);
- hfit->GetListOfFunctions()->Add(fcb);
- hfit->GetListOfFunctions()->Add(l1);
- hfit->GetListOfFunctions()->Add(l2);
Double_t cbParameters[7];
Double_t covarianceMatrix[7][7];
for ( int ix = 0; ix < 7; ++ix )
{
- cbParameters[ix] = fitTotal->GetParameter(ix+4);
+ cbParameters[ix] = fitTotal->GetParameter(ix+4);
+ }
+
+ for ( int iy = 0; iy < 7; ++iy )
+ {
+ for ( int ix = 0; ix < 7; ++ix )
+ {
+ covarianceMatrix[ix][iy] = (fitResult->GetCovarianceMatrix())(ix+4,iy+4);
+ }
+ }
+
+ Double_t a = fHisto->GetXaxis()->GetXmin();
+ Double_t b = fHisto->GetXaxis()->GetXmax();
+ double njpsi = signalJPsi->Integral(a,b)/fHisto->GetBinWidth(1);
+ double nerr = signalJPsi->IntegralError(a,b,&cbParameters[0],&covarianceMatrix[0][0])/fHisto->GetBinWidth(1);
+
+ Set("NofJPsi",njpsi,nerr);
+
+ double m = GetValue("mJPsi");
+ double s = GetValue("sJPsi");
+ double njpsi3s = signalJPsi->Integral(m-3*s,m+3*s)/fHisto->GetBinWidth(1);
+ double nerr3s = signalJPsi->IntegralError(m-3*s,m+3*s,&cbParameters[0],&covarianceMatrix[0][0])/fHisto->GetBinWidth(1);
+
+ Set("NofJPsi3s",njpsi3s,nerr3s);
+}
+
+//_____________________________________________________________________________
+void AliAnalysisMuMuJpsiResult::FitPSIPSIPRIMECB2POL2EXP()
+{
+ /// Fit using 2 extended crystal balls (signal) + pol2 x exp (background)
+ /// 13 parameters
+
+ Double_t alphaLow = GetValue("alJPsi");
+ Double_t nLow = GetValue("nlJPsi");
+ Double_t alphaUp = GetValue("auJPsi");
+ Double_t nUp = GetValue("nuJPsi");
+ Double_t fitRangeLow = GetValue(kFitRangeLow);
+ Double_t fitRangeHigh = GetValue(kFitRangeHigh);
+
+ Double_t paramSPsiP = GetValue("FSigmaPsiP");
+
+ TString msg;
+
+ if (IsValidValue(alphaLow)) msg += TString::Format("alphaLow=%e ",alphaLow);
+ if (IsValidValue(nLow)) msg += TString::Format("nLow=%e ",nLow);
+ if (IsValidValue(alphaUp)) msg += TString::Format("alphaUp=%e ",alphaUp);
+ if (IsValidValue(nUp)) msg += TString::Format("nUp=%e ",nUp);
+
+ AliDebug(1,Form("Fit with jpsi + psiprime Pol2 x Exp %s",msg.Data()));
+
+ TF1* fitTotal = new TF1("signal+bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2Pol2Exp,fitRangeLow,fitRangeHigh,12,"AliAnalysisMuMuJpsiResult","FitFunctionTotalTwoCB2Pol2Exp");
+
+ fitTotal->SetParNames("pol0","pol1","pol2","exp","kJPsi","mJPsi","sJPsi","alJPsi",
+ // 0 1 2 3 4 5 6 7
+ "nlJPsi","auJPsi","nuJPsi");
+ // 8 9 10
+ fitTotal->SetParName(11,"kPsiP");
+ // 11
+
+ TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2Exp,fitRangeLow,fitRangeHigh,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2Exp");
+
+
+ //___
+ TF1* bckInit = new TF1("bckInit",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2Exp,1.7,6.,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2Exp");
+
+ Int_t bin = fHisto->FindBin(0.26);
+
+ bckInit->SetParameters(fHisto->GetBinContent(bin),-fHisto->GetBinContent(bin)/3.,100.,0.05);//fHisto->GetBinContent(bin)
+
+ SetFitRejectRange(2.7,4.0);
+
+ TFitResultPtr fitResultInit = fHisto->Fit(bckInit,"SR");
+
+ std::cout << "FitResultBkgInit=" << static_cast<int>(fitResultInit) << std::endl;
+
+ if ( static_cast<int>(fitResultInit) )
+ {
+ bin = fHisto->FindBin(0.82);
+ bckInit->SetParameters(fHisto->GetBinContent(bin),2.,0.5,0.3);
+ fitResultInit = fHisto->Fit(bckInit,"SR");
+ }
+
+ SetFitRejectRange();
+
+ for ( Int_t i = 0; i < 4; ++i )
+ {
+ fitTotal->SetParameter(i, bckInit->GetParameter(i));
+ }
+
+ delete bckInit;
+ //__
+ //
+ // bck->SetParameters(fHisto->GetMaximum(),0.05,0.05,0.05,1.);
+ //
+ // SetFitRejectRange(2.7,3.5);
+ //
+ // fHisto->Fit(bck,"R");
+ //
+ // SetFitRejectRange();
+ //
+ // for ( Int_t i = 0; i < 5; ++i )
+ // {
+ // fitTotal->SetParameter(i, bck->GetParameter(i));
+ // }
+
+ bin = fHisto->FindBin(3.09);
+ fitTotal->SetParameter(4, fHisto->GetBinContent(bin)); // norm(kJPsi)
+
+ fitTotal->SetParameter(5, 3.1);
+ fitTotal->SetParLimits(5, 3.07, 3.2);
+ fitTotal->SetParameter(6, 0.08);
+ fitTotal->SetParLimits(6, 0.05, 0.15);
+
+ if ( IsValidValue(alphaLow) )
+ {
+ fitTotal->FixParameter(7, alphaLow);
+ }
+ else
+ {
+ fitTotal->SetParameter(7,0.9);
+ fitTotal->SetParLimits(7,0.1,10.0);
+ }
+
+ if ( IsValidValue(nLow) )
+ {
+ fitTotal->FixParameter(8, nLow);
+ }
+ else
+ {
+ fitTotal->SetParameter(8,5.0);
+ fitTotal->SetParLimits(8,0.0,10.0);
+ }
+
+ if ( IsValidValue(alphaUp) )
+ {
+ fitTotal->FixParameter(9, alphaUp);
+ }
+ else
+ {
+ fitTotal->SetParameter(9, 2.0);
+ fitTotal->SetParLimits(9,0.1,10.0);
+ }
+
+ if ( IsValidValue(nUp) )
+ {
+ fitTotal->FixParameter(10, nUp);
+ }
+ else
+ {
+ fitTotal->SetParameter(10,3.0);
+ fitTotal->SetParLimits(10,0.0,10.0);
+ }
+
+ fitTotal->SetParameter(11, 10.);
+
+ const char* fitOption = "SER";
+
+ TFitResultPtr fitResult = fHisto->Fit(fitTotal,fitOption,"");
+
+ std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
+ std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
+
+ if ( static_cast<int>(fitResult) )
+ {
+ if ( 0.5*fitTotal->GetParameter(11) <= fitTotal->GetParError(11) ) //kPsi'
+ {
+ std::cout << "//-------Refitting again (setting Psi'norm= Psi'norm/2)" << std::endl;
+
+ bin = fHisto->FindBin(3.68);
+ fitTotal->SetParameter(11, fHisto->GetBinContent(bin)/2.);
+ }
+
+ if ( 0.5*fitTotal->GetParameter(0) <= fitTotal->GetParError(0) ) //kPol2Exp
+ {
+ std::cout << "//-------Refitting again (setting kPol2Exp norm= kPol2Exp norm /2)" << std::endl;
+ bin = fHisto->FindBin(fitRangeLow);
+
+ fitTotal->SetParameter(0, fHisto->GetBinContent(bin)/2.);
+ }
+
+ fitResult = fHisto->Fit(fitTotal,fitOption,"");
+ std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
+ }
+
+ // if ( fitResult->CovMatrixStatus() != 3 )
+ // {
+ // std::cout << "//-------Refitting again (setting Bkg norm= Bkg norm/2)" << std::endl;
+ // fitTotal->SetParameter(0, fHisto->GetMaximum()/2.); // kVWG
+ // fitResult = fHisto->Fit(fitTotal,fitOption,"");
+ // }
+
+ if ( fitResult->CovMatrixStatus() != 3 )
+ {
+ if ( 0.5*fitTotal->GetParameter(11) <= fitTotal->GetParError(11) ) //kPsi'
+ {
+ std::cout << "//-------Refitting again (setting Psi'norm= Psi'norm/2)" << std::endl;
+
+ bin = fHisto->FindBin(3.68);
+ fitTotal->FixParameter(11, 0.);
+ }
+
+ else
+ {
+ std::cout << "//-------Refitting again (setting Psi'norm= Psi'norm/2)" << std::endl;
+
+ fHisto->FindBin(3.68);
+ fitTotal->SetParameter(11, fHisto->GetBinContent(bin)/2.); // kVWG
+ }
+
+ fitResult = fHisto->Fit(fitTotal,fitOption,"");
+
+ std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
+ }
+
+ // if ( fitResult->CovMatrixStatus() != 3 )
+ // {
+ // std::cout << "//-------Refitting again (refitting Bkg)" << std::endl;
+ //
+ // if( fitTotal->GetParameter(9) >= 0.09 || fitTotal->GetParameter(9) <= 0.06 || fitTotal->GetParameter(6) >= 3.11 || fitTotal->GetParameter(6) <= 3.08)
+ // {
+ // bck->SetParameters(0.01,fHisto->GetMaximum(),0.01,0.05,0.05,0.05,1.);
+ // // for ( Int_t i = 0; i < 7; ++i )
+ // // {
+ // // bck->SetParameter(i, 0.);
+ // // }
+ // }
+ // else
+ // {
+ // for ( Int_t i = 0; i < 7; ++i )
+ // {
+ // bck->SetParameter(i, fitTotal->GetParameter(i));
+ // }
+ // }
+
+ //
+ // for ( Int_t i = 0; i < 5; ++i )
+ // {
+ // bck->SetParameter(i, fitTotal->GetParameter(i));
+ // }
+ //
+ // SetFitRejectRange(2.7,3.5);
+ //
+ // fHisto->Fit(bck,"R");
+ //
+ // SetFitRejectRange();
+ //
+ // for ( Int_t i = 0; i < 5; ++i )
+ // {
+ // fitTotal->SetParameter(i, bck->GetParameter(i));
+ // }
+ //
+ // fitResult = fHisto->Fit(fitTotal,fitOption,"");
+ // }
+ // std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
+
+ Set("FitChi2PerNDF",fitTotal->GetChisquare()/fitTotal->GetNDF(),0.0);
+ Set("FitNDF",fitTotal->GetNDF(),0.0);
+
+ Set("mJPsi",fitTotal->GetParameter(5),fitTotal->GetParError(5));
+ Set("sJPsi",fitTotal->GetParameter(6),fitTotal->GetParError(6));
+
+ TF1* signalJPsi = new TF1("signalJPsi",this,&AliAnalysisMuMuJpsiResult::FitFunctionSignalCrystalBallExtended,fHisto->GetXaxis()->GetXmin(),fHisto->GetXaxis()->GetXmax(),7,"AliAnalysisMuMuJpsiResult","FitFunctionSignalCrystalBallExtended");
+ signalJPsi->SetParameters(fitTotal->GetParameter(4),
+ fitTotal->GetParameter(5),
+ fitTotal->GetParameter(6),
+ fitTotal->GetParameter(7),
+ fitTotal->GetParameter(8),
+ fitTotal->GetParameter(9),
+ fitTotal->GetParameter(10));
+
+ TF1* signalPsiP = new TF1("signalPsiP",this,&AliAnalysisMuMuJpsiResult::FitFunctionSignalCrystalBallExtended,fHisto->GetXaxis()->GetXmin(),fHisto->GetXaxis()->GetXmax(),7,"AliAnalysisMuMuJpsiResult","FitFunctionSignalCrystalBallExtended");
+ signalPsiP->SetParameters(fitTotal->GetParameter(11),
+ 3.68609+(fitTotal->GetParameter(5)-3.096916)/3.096916*3.68609,
+ fitTotal->GetParameter(6)*paramSPsiP, // /3.096916*3.68609,
+ fitTotal->GetParameter(7),
+ fitTotal->GetParameter(8),
+ fitTotal->GetParameter(9),
+ fitTotal->GetParameter(10));
+
+ for ( Int_t i = 0; i < 4; ++i )
+ {
+ bck->SetParameter(i, fitTotal->GetParameter(i));
+ }
+
+// Set("kPol2Exp",fitTotal->GetParameter(0),fitTotal->GetParError(0));
+ Set("pol0",fitTotal->GetParameter(0),fitTotal->GetParError(0));
+ Set("pol1",fitTotal->GetParameter(1),fitTotal->GetParError(1));
+ Set("pol2",fitTotal->GetParameter(2),fitTotal->GetParError(2));
+ Set("exp",fitTotal->GetParameter(3),fitTotal->GetParError(3));
+ Set("kJPsi",fitTotal->GetParameter(4),fitTotal->GetParError(4));
+
+ Set("alJPsi",fitTotal->GetParameter(7),fitTotal->GetParError(7));
+ Set("nlJPsi",fitTotal->GetParameter(8),fitTotal->GetParError(8));
+ Set("auJPsi",fitTotal->GetParameter(9),fitTotal->GetParError(9));
+ Set("nuJPsi",fitTotal->GetParameter(10),fitTotal->GetParError(10));
+
+ Set("kPsiP",fitTotal->GetParameter(11),fitTotal->GetParError(11));
+
+ AttachFunctionsToHisto(signalJPsi,signalPsiP,bck,fitTotal,fitRangeLow,fitRangeHigh);
+
+ Double_t cbParameters[7];
+ Double_t covarianceMatrix[7][7];
+
+ for ( int ix = 0; ix < 7; ++ix )
+ {
+ cbParameters[ix] = fitTotal->GetParameter(ix+4);
+ }
+
+ for ( int iy = 0; iy < 7; ++iy )
+ {
+ for ( int ix = 0; ix < 7; ++ix )
+ {
+ covarianceMatrix[ix][iy] = (fitResult->GetCovarianceMatrix())(ix+4,iy+4);
+ }
+ }
+
+ Double_t a = fHisto->GetXaxis()->GetXmin();
+ Double_t b = fHisto->GetXaxis()->GetXmax();
+ double njpsi = signalJPsi->Integral(a,b)/fHisto->GetBinWidth(1);
+ double nerr = signalJPsi->IntegralError(a,b,&cbParameters[0],&covarianceMatrix[0][0])/fHisto->GetBinWidth(1);
+
+ Set("NofJPsi",njpsi,nerr);
+
+ double m = GetValue("mJPsi");
+ double s = GetValue("sJPsi");
+ double njpsi3s = signalJPsi->Integral(m-3*s,m+3*s)/fHisto->GetBinWidth(1);
+ double nerr3s = signalJPsi->IntegralError(m-3*s,m+3*s,&cbParameters[0],&covarianceMatrix[0][0])/fHisto->GetBinWidth(1);
+
+ Set("NofJPsi3s",njpsi3s,nerr3s);
+
+ //Computation of bin significance and signal over background
+
+ Double_t bkgParameters[4];
+ Double_t bkgcovarianceMatrix[4][4];
+
+ for ( int ix = 0; ix < 4; ++ix )
+ {
+ bkgParameters[ix] = fitTotal->GetParameter(ix);
+ }
+
+ for ( int iy = 0; iy < 4; ++iy )
+ {
+ for ( int ix = 0; ix < 4; ++ix )
+ {
+ bkgcovarianceMatrix[ix][iy] = (fitResult->GetCovarianceMatrix())(ix,iy);
+ }
+ }
+
+ double nbck3s = bck->Integral(m-3.*s,m+3.*s)/fHisto->GetBinWidth(1);
+ double nbck3sErr = bck->IntegralError(m-3.*s,m+3.*s,&bkgParameters[0],&bkgcovarianceMatrix[0][0])/fHisto->GetBinWidth(1);
+
+ double sOverB3s = njpsi3s / nbck3s;
+ double sOverB3sErr = sOverB3s*TMath::Sqrt(TMath::Power(nerr3s/njpsi3s,2.) + TMath::Power(nbck3sErr/nbck3s,2.));
+
+ Set("SignalOverBkg3s",sOverB3s,sOverB3sErr);
+
+ double sig = njpsi3s/TMath::Sqrt(njpsi3s + nbck3s);
+ double sigErr = TMath::Sqrt( TMath::Power((1. - (1./2.)*njpsi3s/(njpsi3s + nbck3s) )*nerr3s/TMath::Sqrt(njpsi3s + nbck3s),2.) +
+ TMath::Power(njpsi3s*nbck3sErr/(2.*TMath::Power(njpsi3s + nbck3s,3./2.)),2.) );
+
+ Set("Significance3s",sig,sigErr);
+}
+
+////_____________________________________________________________________________
+//void AliAnalysisMuMuJpsiResult::FitPSIPSIPRIMECB2POL2EXP()
+//{
+// /// Fit using 2 extended crystal balls (signal) + pol2 x exp (background)
+// /// 13 parameters
+//
+// Double_t alphaLow = GetValue("alJPsi");
+// Double_t nLow = GetValue("nlJPsi");
+// Double_t alphaUp = GetValue("auJPsi");
+// Double_t nUp = GetValue("nuJPsi");
+// Double_t fitRangeLow = GetValue(kFitRangeLow);
+// Double_t fitRangeHigh = GetValue(kFitRangeHigh);
+//
+// TString msg;
+//
+// if (IsValidValue(alphaLow)) msg += TString::Format("alphaLow=%e ",alphaLow);
+// if (IsValidValue(nLow)) msg += TString::Format("nLow=%e ",nLow);
+// if (IsValidValue(alphaUp)) msg += TString::Format("alphaUp=%e ",alphaUp);
+// if (IsValidValue(nUp)) msg += TString::Format("nUp=%e ",nUp);
+//
+// AliDebug(1,Form("Fit with jpsi + psiprime Pol2 x Exp %s",msg.Data()));
+//
+// TF1* fitTotal = new TF1("signal+bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2Pol2Exp,fitRangeLow,fitRangeHigh,13,"AliAnalysisMuMuJpsiResult","FitFunctionTotalTwoCB2Pol2Exp");
+//
+// fitTotal->SetParNames("kPol2Exp","pol0","pol1","pol2","exp","kJPsi","mJPsi","sJPsi",
+//// 0 1 2 3 4 5 6 7
+// "alJPsi","nlJPsi","auJPsi");
+//// 8 9 10
+// fitTotal->SetParName(11,"nuJPsi");
+//// 11
+// fitTotal->SetParName(12, "kPsiP");
+//// 12
+//
+// TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2Exp,fitRangeLow,fitRangeHigh,5,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2Exp");
+//
+//
+// //___
+// TF1* bckInit = new TF1("bckInit",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2Exp,1.7,6.,5,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2Exp");
+//
+// Int_t bin = fHisto->FindBin(0.26);
+//
+// bckInit->SetParameters(-0.1,1.,0.5,0.3,1.);//fHisto->GetBinContent(bin)
+//
+// SetFitRejectRange(2.7,4.0);
+//
+// TFitResultPtr fitResultInit = fHisto->Fit(bckInit,"SR");
+//
+// std::cout << "FitResultBkgInit=" << static_cast<int>(fitResultInit) << std::endl;
+//
+// if ( static_cast<int>(fitResultInit) )
+// {
+// bin = fHisto->FindBin(0.82);
+// bckInit->SetParameters(fHisto->GetBinContent(bin),2.,0.5,0.3);
+// fitResultInit = fHisto->Fit(bckInit,"SR");
+// }
+//
+// SetFitRejectRange();
+//
+// for ( Int_t i = 0; i < 5; ++i )
+// {
+// fitTotal->SetParameter(i, bckInit->GetParameter(i));
+// }
+//
+// delete bckInit;
+////__
+////
+//// bck->SetParameters(fHisto->GetMaximum(),0.05,0.05,0.05,1.);
+////
+//// SetFitRejectRange(2.7,3.5);
+////
+//// fHisto->Fit(bck,"R");
+////
+//// SetFitRejectRange();
+////
+//// for ( Int_t i = 0; i < 5; ++i )
+//// {
+//// fitTotal->SetParameter(i, bck->GetParameter(i));
+//// }
+//
+// bin = fHisto->FindBin(3.09);
+// fitTotal->SetParameter(5, fHisto->GetBinContent(bin)); // norm(kJPsi)
+//
+// fitTotal->SetParameter(6, 3.1);
+// fitTotal->SetParLimits(6, 3.07, 3.2);
+// fitTotal->SetParameter(7, 0.08);
+// fitTotal->SetParLimits(7, 0.05, 0.15);
+//
+// if ( IsValidValue(alphaLow) )
+// {
+// fitTotal->FixParameter(8, alphaLow);
+// }
+// else
+// {
+// fitTotal->SetParameter(8,0.9);
+// fitTotal->SetParLimits(8,0.1,10.0);
+// }
+//
+// if ( IsValidValue(nLow) )
+// {
+// fitTotal->FixParameter(9, nLow);
+// }
+// else
+// {
+// fitTotal->SetParameter(9,5.0);
+// fitTotal->SetParLimits(9,0.0,10.0);
+// }
+//
+// if ( IsValidValue(alphaUp) )
+// {
+// fitTotal->FixParameter(10, alphaUp);
+// }
+// else
+// {
+// fitTotal->SetParameter(10, 2.0);
+// fitTotal->SetParLimits(10,0.1,10.0);
+// }
+//
+// if ( IsValidValue(nUp) )
+// {
+// fitTotal->FixParameter(11, nUp);
+// }
+// else
+// {
+// fitTotal->SetParameter(11,3.0);
+// fitTotal->SetParLimits(11,0.0,10.0);
+// }
+//
+// fitTotal->SetParameter(12, 10.);
+//
+// const char* fitOption = "SER";
+//
+// TFitResultPtr fitResult = fHisto->Fit(fitTotal,fitOption,"");
+//
+// std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
+// std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
+//
+// if ( static_cast<int>(fitResult) )
+// {
+// if ( fitTotal->GetParameter(12) <= fitTotal->GetParError(12) ) //kPsi'
+// {
+// std::cout << "//-------Refitting again (setting Psi'norm= Psi'norm/2)" << std::endl;
+//
+// bin = fHisto->FindBin(3.68);
+// fitTotal->SetParameter(12, fHisto->GetBinContent(bin)/2.);
+// }
+//
+// if ( fitTotal->GetParameter(0) <= fitTotal->GetParError(0) ) //kPol2Exp
+// {
+// std::cout << "//-------Refitting again (setting kPol2Exp norm= kPol2Exp norm /2)" << std::endl;
+// bin = fHisto->FindBin(fitRangeLow);
+//
+// fitTotal->SetParameter(0, fHisto->GetBinContent(bin)/2.);
+// }
+//
+// fitResult = fHisto->Fit(fitTotal,fitOption,"");
+// std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
+// }
+//
+//// if ( fitResult->CovMatrixStatus() != 3 )
+//// {
+//// std::cout << "//-------Refitting again (setting Bkg norm= Bkg norm/2)" << std::endl;
+//// fitTotal->SetParameter(0, fHisto->GetMaximum()/2.); // kVWG
+//// fitResult = fHisto->Fit(fitTotal,fitOption,"");
+//// }
+//
+// if ( fitResult->CovMatrixStatus() != 3 )
+// {
+// if ( fitTotal->GetParameter(12) <= fitTotal->GetParError(12) ) //kPsi'
+// {
+// std::cout << "//-------Refitting again (setting Psi'norm= Psi'norm/2)" << std::endl;
+//
+// bin = fHisto->FindBin(3.68);
+// fitTotal->FixParameter(12, 0.);
+// }
+//
+// else
+// {
+// std::cout << "//-------Refitting again (setting Psi'norm= Psi'norm/2)" << std::endl;
+//
+// fHisto->FindBin(3.68);
+// fitTotal->SetParameter(12, fHisto->GetBinContent(bin)/2.); // kVWG
+// }
+//
+// fitResult = fHisto->Fit(fitTotal,fitOption,"");
+//
+// std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
+// }
+//
+//// if ( fitResult->CovMatrixStatus() != 3 )
+//// {
+//// std::cout << "//-------Refitting again (refitting Bkg)" << std::endl;
+////
+//// if( fitTotal->GetParameter(9) >= 0.09 || fitTotal->GetParameter(9) <= 0.06 || fitTotal->GetParameter(6) >= 3.11 || fitTotal->GetParameter(6) <= 3.08)
+//// {
+//// bck->SetParameters(0.01,fHisto->GetMaximum(),0.01,0.05,0.05,0.05,1.);
+//// // for ( Int_t i = 0; i < 7; ++i )
+//// // {
+//// // bck->SetParameter(i, 0.);
+//// // }
+//// }
+//// else
+//// {
+//// for ( Int_t i = 0; i < 7; ++i )
+//// {
+//// bck->SetParameter(i, fitTotal->GetParameter(i));
+//// }
+//// }
+//
+////
+//// for ( Int_t i = 0; i < 5; ++i )
+//// {
+//// bck->SetParameter(i, fitTotal->GetParameter(i));
+//// }
+////
+//// SetFitRejectRange(2.7,3.5);
+////
+//// fHisto->Fit(bck,"R");
+////
+//// SetFitRejectRange();
+////
+//// for ( Int_t i = 0; i < 5; ++i )
+//// {
+//// fitTotal->SetParameter(i, bck->GetParameter(i));
+//// }
+////
+//// fitResult = fHisto->Fit(fitTotal,fitOption,"");
+//// }
+//// std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
+//
+// Set("FitChi2PerNDF",fitTotal->GetChisquare()/fitTotal->GetNDF(),0.0);
+// Set("FitNDF",fitTotal->GetNDF(),0.0);
+//
+// Set("mJPsi",fitTotal->GetParameter(6),fitTotal->GetParError(6));
+// Set("sJPsi",fitTotal->GetParameter(7),fitTotal->GetParError(7));
+//
+// TF1* signalJPsi = new TF1("signalJPsi",this,&AliAnalysisMuMuJpsiResult::FitFunctionSignalCrystalBallExtended,fHisto->GetXaxis()->GetXmin(),fHisto->GetXaxis()->GetXmax(),7,"AliAnalysisMuMuJpsiResult","FitFunctionSignalCrystalBallExtended");
+// signalJPsi->SetParameters(fitTotal->GetParameter(5),
+// fitTotal->GetParameter(6),
+// fitTotal->GetParameter(7),
+// fitTotal->GetParameter(8),
+// fitTotal->GetParameter(9),
+// fitTotal->GetParameter(10),
+// fitTotal->GetParameter(11));
+//
+// TF1* signalPsiP = new TF1("signalPsiP",this,&AliAnalysisMuMuJpsiResult::FitFunctionSignalCrystalBallExtended,fHisto->GetXaxis()->GetXmin(),fHisto->GetXaxis()->GetXmax(),7,"AliAnalysisMuMuJpsiResult","FitFunctionSignalCrystalBallExtended");
+// signalPsiP->SetParameters(fitTotal->GetParameter(12),
+// 3.68609+(fitTotal->GetParameter(6)-3.096916)/3.096916*3.68609,
+// fitTotal->GetParameter(7)/3.096916*3.68609,
+// fitTotal->GetParameter(8),
+// fitTotal->GetParameter(9),
+// fitTotal->GetParameter(10),
+// fitTotal->GetParameter(11));
+//
+// for ( Int_t i = 0; i < 5; ++i )
+// {
+// bck->SetParameter(i, fitTotal->GetParameter(i));
+// }
+//
+// Set("kPol2Exp",fitTotal->GetParameter(0),fitTotal->GetParError(0));
+// Set("pol0",fitTotal->GetParameter(1),fitTotal->GetParError(1));
+// Set("pol1",fitTotal->GetParameter(2),fitTotal->GetParError(2));
+// Set("pol2",fitTotal->GetParameter(3),fitTotal->GetParError(3));
+// Set("exp",fitTotal->GetParameter(4),fitTotal->GetParError(4));
+//
+// Set("alJPsi",fitTotal->GetParameter(8),fitTotal->GetParError(8));
+// Set("nlJPsi",fitTotal->GetParameter(9),fitTotal->GetParError(9));
+// Set("auJPsi",fitTotal->GetParameter(10),fitTotal->GetParError(10));
+// Set("nuJPsi",fitTotal->GetParameter(11),fitTotal->GetParError(11));
+//
+// Set("kPsiP",fitTotal->GetParameter(12),fitTotal->GetParError(12));
+//
+// AttachFunctionsToHisto(signalJPsi,signalPsiP,bck,fitTotal,fitRangeLow,fitRangeHigh);
+//
+// Double_t cbParameters[7];
+// Double_t covarianceMatrix[7][7];
+//
+// for ( int ix = 0; ix < 7; ++ix )
+// {
+// cbParameters[ix] = fitTotal->GetParameter(ix+5);
+// }
+//
+// for ( int iy = 0; iy < 7; ++iy )
+// {
+// for ( int ix = 0; ix < 7; ++ix )
+// {
+// covarianceMatrix[ix][iy] = (fitResult->GetCovarianceMatrix())(ix+5,iy+5);
+// }
+// }
+//
+// Double_t a = fHisto->GetXaxis()->GetXmin();
+// Double_t b = fHisto->GetXaxis()->GetXmax();
+// double njpsi = signalJPsi->Integral(a,b)/fHisto->GetBinWidth(1);
+// double nerr = signalJPsi->IntegralError(a,b,&cbParameters[0],&covarianceMatrix[0][0])/fHisto->GetBinWidth(1);
+//
+// Set("NofJPsi",njpsi,nerr);
+//}
+
+//_____________________________________________________________________________
+void AliAnalysisMuMuJpsiResult::FitPSIPSIPRIMECB2POL4EXP()
+{
+ /// Fit using 2 extended crystal balls (signal) + pol4 x exp (background)
+ /// 15 parameters
+
+ Double_t alphaLow = GetValue("alJPsi");
+ Double_t nLow = GetValue("nlJPsi");
+ Double_t alphaUp = GetValue("auJPsi");
+ Double_t nUp = GetValue("nuJPsi");
+ Double_t fitRangeLow = GetValue(kFitRangeLow);
+ Double_t fitRangeHigh = GetValue(kFitRangeHigh);
+
+ Double_t paramSPsiP = GetValue("FSigmaPsiP");
+
+ TString msg;
+
+ if (IsValidValue(alphaLow)) msg += TString::Format("alphaLow=%e ",alphaLow);
+ if (IsValidValue(nLow)) msg += TString::Format("nLow=%e ",nLow);
+ if (IsValidValue(alphaUp)) msg += TString::Format("alphaUp=%e ",alphaUp);
+ if (IsValidValue(nUp)) msg += TString::Format("nUp=%e ",nUp);
+
+ AliDebug(1,Form("Fit with jpsi + psiprime Pol4 x Exp %s",msg.Data()));
+
+ TF1* fitTotal = new TF1("signal+bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2Pol4Exp,fitRangeLow,fitRangeHigh,14,"AliAnalysisMuMuJpsiResult","FitFunctionTotalTwoCB2Pol4Exp");
+
+ fitTotal->SetParNames("pol0","pol1","pol2","pol3","pol4","exp","kJPsi",
+ // 0 1 2 3 4 5 6
+ "mJPsi","sJPsi","alJPsi","nlJPsi");
+ // 7 8 9 10
+ fitTotal->SetParName(11,"auJPsi");
+ // 11
+ fitTotal->SetParName(12,"nuJPsi");
+ // 12
+ fitTotal->SetParName(13,"kPsiP");
+ // 13
+
+
+ TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol4Exp,fitRangeLow,fitRangeHigh,6,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol4Exp");
+
+ // bck->SetParameters(fHisto->GetMaximum(),0.01,0.01,0.01,0.01,0.01,1.);
+ //
+ // SetFitRejectRange(2.7,3.5);
+ //
+ // fHisto->Fit(bck,"R");
+ //
+ // SetFitRejectRange();
+ //
+ // for ( Int_t i = 0; i < 7; ++i )
+ // {
+ // fitTotal->SetParameter(i, bck->GetParameter(i));
+ // }
+
+ //___
+ TF1* bckInit = new TF1("bckInit",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol4Exp,1.6,7.,6,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol4Exp");
+
+ Int_t bin = fHisto->FindBin(1.6);
+
+ bckInit->SetParameters(fHisto->GetBinContent(bin),-fHisto->GetBinContent(bin),fHisto->GetBinContent(bin)/2.,-fHisto->GetBinContent(bin)/10.,fHisto->GetBinContent(bin)/100.,-2.);
+
+ SetFitRejectRange(2.6,4.0);
+
+ TFitResultPtr fitResultInit = fHisto->Fit(bckInit,"SR");
+
+ std::cout << "FitResultBkgInit=" << static_cast<int>(fitResultInit) << std::endl;
+
+ if ( static_cast<int>(fitResultInit) )
+ {
+ bin = fHisto->FindBin(0.82);
+ bckInit->SetParameters(0.,1.,1.,1.,2.,0.5);
+ fitResultInit = fHisto->Fit(bckInit,"SR");
+ }
+
+ SetFitRejectRange();
+
+ for ( Int_t i = 0; i < 6; ++i )
+ {
+ fitTotal->SetParameter(i, bckInit->GetParameter(i));
+ }
+
+ delete bckInit;
+ //___
+
+ // bck->SetRange(fitRangeLow,fitRangeHigh);
+
+ bin = fHisto->FindBin(3.09);
+ fitTotal->SetParameter(6, fHisto->GetBinContent(bin)); // norm(kJPsi)
+
+ fitTotal->SetParameter(7, 3.1); // mean
+ fitTotal->SetParLimits(7, 3.0, 3.2);
+
+ fitTotal->SetParameter(8, 0.08); // sigma
+ fitTotal->SetParLimits(8, 0.03, 0.15);
+
+ if ( IsValidValue(alphaLow) )
+ {
+ fitTotal->FixParameter(9, alphaLow);
+ }
+ else
+ {
+ fitTotal->SetParameter(9,0.9);
+ fitTotal->SetParLimits(9,0.1,10.0);
+ }
+
+ if ( IsValidValue(nLow) )
+ {
+ fitTotal->FixParameter(10, nLow);
+ }
+ else
+ {
+ fitTotal->SetParameter(10,5.0);
+ fitTotal->SetParLimits(10,0.0,10.0);
+ }
+
+ if ( IsValidValue(alphaUp) )
+ {
+ fitTotal->FixParameter(11, alphaUp);
+ }
+ else
+ {
+ fitTotal->SetParameter(11, 2.0);
+ fitTotal->SetParLimits(11,0.1,10.0);
+ }
+
+ if ( IsValidValue(nUp) )
+ {
+ fitTotal->FixParameter(12, nUp);
+ }
+ else
+ {
+ fitTotal->SetParameter(12,3.0);
+ fitTotal->SetParLimits(12,0.0,10.0);
+ }
+
+ bin = fHisto->FindBin(3.68);
+ fitTotal->SetParameter(13, fHisto->GetBinContent(bin)); //kPsiP
+ fitTotal->SetParLimits(13, 0., fHisto->GetBinContent(bin)*2); //kPsiP
+
+ // fitTotal->SetParameter(12, 3.7); // mean PsiP
+ // fitTotal->SetParLimits(12, 3.6, 3.71);
+ //
+ // fitTotal->SetParameter(13, 0.08/3.096916*3.68609); // sigma PsiP
+ // fitTotal->SetParLimits(13, 0.03/3.096916*3.68609, 0.15/3.096916*3.68609);
+
+ const char* fitOption = "SER";
+
+ TFitResultPtr fitResult = fHisto->Fit(fitTotal,fitOption,"");
+
+ std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
+ std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
+
+ if ( static_cast<int>(fitResult) )
+ {
+ if ( fitTotal->GetParameter(13) <= fitTotal->GetParError(13) ) //kPsi'
+ {
+ std::cout << "//-------Refitting again (setting Psi'norm= Psi'norm/2)" << std::endl;
+
+ fitTotal->SetParameter(13, fHisto->GetBinContent(bin)/2.);
+ }
+
+ if ( fitTotal->GetParameter(0) <= fitTotal->GetParError(0) ) //kPol4Exp
+ {
+ std::cout << "//-------Refitting again (setting kPol4Exp norm= kPol4Exp norm /2)" << std::endl;
+ bin = fHisto->FindBin(fitRangeLow);
+
+ fitTotal->SetParameter(0, fHisto->GetBinContent(bin)/2.);
+ }
+
+ fitResult = fHisto->Fit(fitTotal,fitOption,"");
+ std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
+ }
+
+ if ( fitResult->CovMatrixStatus() != 3 )
+ {
+ std::cout << "//-------Refitting again (setting Bkg norm= Bkg norm/2)" << std::endl;
+ fitTotal->SetParameter(0, fHisto->GetMaximum()/2.); // kVWG
+ fitResult = fHisto->Fit(fitTotal,fitOption,"");
+ }
+
+// if ( fitResult->CovMatrixStatus() != 3 )
+// {
+// bin = fHisto->FindBin(3.68);
+// std::cout << "//-------Refitting again (setting Psi'norm= Psi'norm/2)" << std::endl;
+// fitTotal->SetParameter(13, fHisto->GetBinContent(bin)/2.); // kVWG
+// fitResult = fHisto->Fit(fitTotal,fitOption,"");
+//
+// std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
+// }
+
+ // if ( fitResult->CovMatrixStatus() != 3 )
+ // {
+ // std::cout << "//-------Refitting again (refitting Bkg)" << std::endl;
+ // if( fitTotal->GetParameter(9) >= 0.09 || fitTotal->GetParameter(9) <= 0.06 )
+ // {
+ // bck->SetParameters(0.01,fHisto->GetMaximum(),0.01,0.01,0.01,0.01,1.);
+ //// for ( Int_t i = 0; i < 7; ++i )
+ //// {
+ //// bck->SetParameter(i, 0.);
+ //// }
+ // }
+ // else
+ // {
+ // for ( Int_t i = 0; i < 7; ++i )
+ // {
+ // bck->SetParameter(i, fitTotal->GetParameter(i));
+ // }
+ // }
+ //
+ // SetFitRejectRange(2.7,3.5);
+ //
+ // fHisto->Fit(bck,"R");
+ //
+ // SetFitRejectRange();
+ //
+ // for ( Int_t i = 0; i < 7; ++i )
+ // {
+ // fitTotal->SetParameter(i, bck->GetParameter(i));
+ // }
+ //
+ // fitResult = fHisto->Fit(fitTotal,fitOption,"");
+ // }
+ // std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
+
+
+
+ Set("FitChi2PerNDF",fitTotal->GetChisquare()/fitTotal->GetNDF(),0.0);
+ Set("FitNDF",fitTotal->GetNDF(),0.0);
+
+ Set("mJPsi",fitTotal->GetParameter(7),fitTotal->GetParError(7));
+ Set("sJPsi",fitTotal->GetParameter(8),fitTotal->GetParError(8));
+
+ TF1* signalJPsi = new TF1("signalJPsi",this,&AliAnalysisMuMuJpsiResult::FitFunctionSignalCrystalBallExtended,fHisto->GetXaxis()->GetXmin(),fHisto->GetXaxis()->GetXmax(),7,"AliAnalysisMuMuJpsiResult","FitFunctionSignalCrystalBallExtended");
+ signalJPsi->SetParameters(fitTotal->GetParameter(6),
+ fitTotal->GetParameter(7),
+ fitTotal->GetParameter(8),
+ fitTotal->GetParameter(9),
+ fitTotal->GetParameter(10),
+ fitTotal->GetParameter(11),
+ fitTotal->GetParameter(12));
+
+ TF1* signalPsiP = new TF1("signalPsiP",this,&AliAnalysisMuMuJpsiResult::FitFunctionSignalCrystalBallExtended,fHisto->GetXaxis()->GetXmin(),fHisto->GetXaxis()->GetXmax(),7,"AliAnalysisMuMuJpsiResult","FitFunctionSignalCrystalBallExtended");
+ signalPsiP->SetParameters(fitTotal->GetParameter(13),
+ 3.68609+(fitTotal->GetParameter(7)-3.096916)/3.096916*3.68609,
+ fitTotal->GetParameter(8)*paramSPsiP, // /3.096916*3.68609,
+ fitTotal->GetParameter(9),
+ fitTotal->GetParameter(10),
+ fitTotal->GetParameter(11),
+ fitTotal->GetParameter(12));
+
+ for ( Int_t i = 0; i < 7; ++i )
+ {
+ bck->SetParameter(i, fitTotal->GetParameter(i));
+ }
+
+ Set("alJPsi",fitTotal->GetParameter(9),fitTotal->GetParError(9));
+ Set("nlJPsi",fitTotal->GetParameter(10),fitTotal->GetParError(10));
+ Set("auJPsi",fitTotal->GetParameter(11),fitTotal->GetParError(11));
+ Set("nuJPsi",fitTotal->GetParameter(12),fitTotal->GetParError(12));
+
+// Set("kPol4Exp",fitTotal->GetParameter(0),fitTotal->GetParError(0));
+ Set("pol0",fitTotal->GetParameter(0),fitTotal->GetParError(0));
+ Set("pol1",fitTotal->GetParameter(1),fitTotal->GetParError(1));
+ Set("pol2",fitTotal->GetParameter(2),fitTotal->GetParError(2));
+ Set("pol3",fitTotal->GetParameter(3),fitTotal->GetParError(3));
+ Set("pol4",fitTotal->GetParameter(4),fitTotal->GetParError(4));
+ Set("exp",fitTotal->GetParameter(5),fitTotal->GetParError(5));
+
+ Set("kJPsi",fitTotal->GetParameter(6),fitTotal->GetParError(6));
+ Set("kPsiP",fitTotal->GetParameter(13),fitTotal->GetParError(13));
+
+
+
+ AttachFunctionsToHisto(signalJPsi,signalPsiP,bck,fitTotal,fitRangeLow,fitRangeHigh);
+
+ Double_t cbParameters[7];
+ Double_t covarianceMatrix[7][7];
+
+ for ( int ix = 0; ix < 7; ++ix )
+ {
+ cbParameters[ix] = fitTotal->GetParameter(ix+6);
+ }
+
+ for ( int iy = 0; iy < 7; ++iy )
+ {
+ for ( int ix = 0; ix < 7; ++ix )
+ {
+ covarianceMatrix[ix][iy] = (fitResult->GetCovarianceMatrix())(ix+6,iy+6);
+ }
+ }
+
+ Double_t a = fHisto->GetXaxis()->GetXmin();
+ Double_t b = fHisto->GetXaxis()->GetXmax();
+ double njpsi = signalJPsi->Integral(a,b)/fHisto->GetBinWidth(1);
+ double nerr = signalJPsi->IntegralError(a,b,&cbParameters[0],&covarianceMatrix[0][0])/fHisto->GetBinWidth(1);
+
+ Set("NofJPsi",njpsi,nerr);
+
+ double m = GetValue("mJPsi");
+ double s = GetValue("sJPsi");
+ double njpsi3s = signalJPsi->Integral(m-3*s,m+3*s)/fHisto->GetBinWidth(1);
+ double nerr3s = signalJPsi->IntegralError(m-3*s,m+3*s,&cbParameters[0],&covarianceMatrix[0][0])/fHisto->GetBinWidth(1);
+
+ Set("NofJPsi3s",njpsi3s,nerr3s);
+
+ //Computation of bin significance and signal over background
+
+ Double_t bkgParameters[6];
+ Double_t bkgcovarianceMatrix[6][6];
+
+ for ( int ix = 0; ix < 6; ++ix )
+ {
+ bkgParameters[ix] = fitTotal->GetParameter(ix);
+ }
+
+ for ( int iy = 0; iy < 6; ++iy )
+ {
+ for ( int ix = 0; ix < 6; ++ix )
+ {
+ bkgcovarianceMatrix[ix][iy] = (fitResult->GetCovarianceMatrix())(ix,iy);
+ }
+ }
+
+ double nbck3s = bck->Integral(m-3.*s,m+3.*s)/fHisto->GetBinWidth(1);
+ double nbck3sErr = bck->IntegralError(m-3.*s,m+3.*s,&bkgParameters[0],&bkgcovarianceMatrix[0][0])/fHisto->GetBinWidth(1);
+
+ double sOverB3s = njpsi3s / nbck3s;
+ double sOverB3sErr = sOverB3s*TMath::Sqrt(TMath::Power(nerr3s/njpsi3s,2.) + TMath::Power(nbck3sErr/nbck3s,2.));
+
+ Set("SignalOverBkg3s",sOverB3s,sOverB3sErr);
+
+ double sig = njpsi3s/TMath::Sqrt(njpsi3s + nbck3s);
+ double sigErr = TMath::Sqrt( TMath::Power((1. - (1./2.)*njpsi3s/(njpsi3s + nbck3s) )*nerr3s/TMath::Sqrt(njpsi3s + nbck3s),2.) +
+ TMath::Power(njpsi3s*nbck3sErr/(2.*TMath::Power(njpsi3s + nbck3s,3./2.)),2.) );
+
+ Set("Significance3s",sig,sigErr);
+
+
+}
+
+//_____________________________________________________________________________
+//void AliAnalysisMuMuJpsiResult::FitPSIPSIPRIMECB2POL4EXP()
+//{
+// /// Fit using 2 extended crystal balls (signal) + pol4 x exp (background)
+// /// 15 parameters
+//
+// Double_t alphaLow = GetValue("alJPsi");
+// Double_t nLow = GetValue("nlJPsi");
+// Double_t alphaUp = GetValue("auJPsi");
+// Double_t nUp = GetValue("nuJPsi");
+// Double_t fitRangeLow = GetValue(kFitRangeLow);
+// Double_t fitRangeHigh = GetValue(kFitRangeHigh);
+//
+// TString msg;
+//
+// if (IsValidValue(alphaLow)) msg += TString::Format("alphaLow=%e ",alphaLow);
+// if (IsValidValue(nLow)) msg += TString::Format("nLow=%e ",nLow);
+// if (IsValidValue(alphaUp)) msg += TString::Format("alphaUp=%e ",alphaUp);
+// if (IsValidValue(nUp)) msg += TString::Format("nUp=%e ",nUp);
+//
+// AliDebug(1,Form("Fit with jpsi + psiprime Pol4 x Exp %s",msg.Data()));
+//
+// TF1* fitTotal = new TF1("signal+bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2Pol4Exp,fitRangeLow,fitRangeHigh,15,"AliAnalysisMuMuJpsiResult","FitFunctionTotalTwoCB2Pol4Exp");
+//
+// fitTotal->SetParNames("kPol4Exp","pol0","pol1","pol2","pol3","pol4","exp","kJPsi",
+//// 0 1 2 3 4 5 6 7
+// "mJPsi","sJPsi","alJPsi");
+// // 8 9 10
+// fitTotal->SetParName(11,"nlJPsi");
+// // 11
+// fitTotal->SetParName(12,"auJPsi");
+// // 12
+// fitTotal->SetParName(13,"nuJPsi");
+// // 13
+// fitTotal->SetParName(14,"kPsiP");
+// // 14
+//
+// TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol4Exp,fitRangeLow,fitRangeHigh,7,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol4Exp");
+//
+//// bck->SetParameters(fHisto->GetMaximum(),0.01,0.01,0.01,0.01,0.01,1.);
+////
+//// SetFitRejectRange(2.7,3.5);
+////
+//// fHisto->Fit(bck,"R");
+////
+//// SetFitRejectRange();
+////
+//// for ( Int_t i = 0; i < 7; ++i )
+//// {
+//// fitTotal->SetParameter(i, bck->GetParameter(i));
+//// }
+//
+// TF1* bckInit = new TF1("bckInit",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol4Exp,1.6,7.,6,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol4Exp");
+//
+// Int_t bin = fHisto->FindBin(1.6);
+//
+// bckInit->SetParameters(fHisto->GetBinContent(bin),-fHisto->GetBinContent(bin)/2.,fHisto->GetBinContent(bin)/2.,-fHisto->GetBinContent(bin)/20,fHisto->GetBinContent(bin/100.),-2.);
+//
+// SetFitRejectRange(2.6,4.0);
+//
+// TFitResultPtr fitResultInit = fHisto->Fit(bckInit,"SR");
+//
+// std::cout << "FitResultBkgInit=" << static_cast<int>(fitResultInit) << std::endl;
+//
+// if ( static_cast<int>(fitResultInit) )
+// {
+// bin = fHisto->FindBin(0.82);
+// bckInit->SetParameters(0.,1.,1.,1.,2.,0.5);
+// fitResultInit = fHisto->Fit(bckInit,"SR");
+// }
+//
+// SetFitRejectRange();
+//
+// for ( Int_t i = 0; i < 6; ++i )
+// {
+// fitTotal->SetParameter(i, bckInit->GetParameter(i));
+// }
+//
+//
+// TF1* bckInit = new TF1("bckInit",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol4Exp,1.2,6.,7,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol4Exp");
+//
+// Int_t bin = fHisto->FindBin(1.2);
+//
+// bckInit->SetParameters(-1.,fHisto->GetBinContent(bin),-fHisto->GetBinContent(bin),fHisto->GetBinContent(bin)/10,-fHisto->GetBinContent(bin/10),10.,1.);
+//
+// SetFitRejectRange(2.7,4.0);
+//
+// TFitResultPtr fitResultInit = fHisto->Fit(bckInit,"SR");
+//
+// std::cout << "FitResultBkgInit=" << static_cast<int>(fitResultInit) << std::endl;
+//
+// if ( static_cast<int>(fitResultInit) )
+// {
+// bin = fHisto->FindBin(0.82);
+// bckInit->SetParameters(0.,1.,1.,1.,2.,0.5,0.3);
+// fitResultInit = fHisto->Fit(bckInit,"SR");
+// }
+//
+// SetFitRejectRange();
+//
+// for ( Int_t i = 0; i < 7; ++i )
+// {
+// fitTotal->SetParameter(i, bckInit->GetParameter(i));
+// }
+//
+// delete bckInit;
+//
+//
+//// bck->SetRange(fitRangeLow,fitRangeHigh);
+//
+// bin = fHisto->FindBin(3.09);
+// fitTotal->SetParameter(7, fHisto->GetBinContent(bin)); // norm(kJPsi)
+//
+// fitTotal->SetParameter(8, 3.1); // mean
+// fitTotal->SetParLimits(8, 3.0, 3.2);
+//
+// fitTotal->SetParameter(9, 0.08); // sigma
+// fitTotal->SetParLimits(9, 0.03, 0.15);
+//
+// if ( IsValidValue(alphaLow) )
+// {
+// fitTotal->FixParameter(10, alphaLow);
+// }
+// else
+// {
+// fitTotal->SetParameter(10,0.9);
+// fitTotal->SetParLimits(10,0.1,10.0);
+// }
+//
+// if ( IsValidValue(nLow) )
+// {
+// fitTotal->FixParameter(11, nLow);
+// }
+// else
+// {
+// fitTotal->SetParameter(11,5.0);
+// fitTotal->SetParLimits(11,0.0,10.0);
+// }
+//
+// if ( IsValidValue(alphaUp) )
+// {
+// fitTotal->FixParameter(12, alphaUp);
+// }
+// else
+// {
+// fitTotal->SetParameter(12, 2.0);
+// fitTotal->SetParLimits(12,0.1,10.0);
+// }
+//
+// if ( IsValidValue(nUp) )
+// {
+// fitTotal->FixParameter(13, nUp);
+// }
+// else
+// {
+// fitTotal->SetParameter(13,3.0);
+// fitTotal->SetParLimits(13,0.0,10.0);
+// }
+//
+// bin = fHisto->FindBin(3.68);
+// fitTotal->SetParameter(14, fHisto->GetBinContent(bin)); //kPsiP
+// fitTotal->SetParLimits(14, 0., fHisto->GetBinContent(bin)*2); //kPsiP
+//
+// // fitTotal->SetParameter(12, 3.7); // mean PsiP
+// // fitTotal->SetParLimits(12, 3.6, 3.71);
+// //
+// // fitTotal->SetParameter(13, 0.08/3.096916*3.68609); // sigma PsiP
+// // fitTotal->SetParLimits(13, 0.03/3.096916*3.68609, 0.15/3.096916*3.68609);
+//
+// const char* fitOption = "SER";
+//
+// TFitResultPtr fitResult = fHisto->Fit(fitTotal,fitOption,"");
+//
+// std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
+// std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
+//
+// if ( static_cast<int>(fitResult) )
+// {
+// if ( fitTotal->GetParameter(14) <= fitTotal->GetParError(14) ) //kPsi'
+// {
+// std::cout << "//-------Refitting again (setting Psi'norm= Psi'norm/2)" << std::endl;
+//
+// fitTotal->SetParameter(14, fHisto->GetBinContent(bin)/2.);
+// }
+//
+// if ( fitTotal->GetParameter(0) <= fitTotal->GetParError(0) ) //kPol4Exp
+// {
+// std::cout << "//-------Refitting again (setting kPol4Exp norm= kPol4Exp norm /2)" << std::endl;
+// bin = fHisto->FindBin(fitRangeLow);
+//
+// fitTotal->SetParameter(0, fHisto->GetBinContent(bin)/2.);
+// }
+//
+// fitResult = fHisto->Fit(fitTotal,fitOption,"");
+// std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
+// }
+//
+// if ( fitResult->CovMatrixStatus() != 3 )
+// {
+// std::cout << "//-------Refitting again (setting Bkg norm= Bkg norm/2)" << std::endl;
+// fitTotal->SetParameter(0, fHisto->GetMaximum()/2.); // kVWG
+// fitResult = fHisto->Fit(fitTotal,fitOption,"");
+// }
+//
+// if ( fitResult->CovMatrixStatus() != 3 )
+// {
+// bin = fHisto->FindBin(3.68);
+// std::cout << "//-------Refitting again (setting Psi'norm= Psi'norm/2)" << std::endl;
+// fitTotal->SetParameter(14, fHisto->GetBinContent(bin)/2.); // kVWG
+// fitResult = fHisto->Fit(fitTotal,fitOption,"");
+//
+// std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
+// }
+//
+//// if ( fitResult->CovMatrixStatus() != 3 )
+//// {
+//// std::cout << "//-------Refitting again (refitting Bkg)" << std::endl;
+//// if( fitTotal->GetParameter(9) >= 0.09 || fitTotal->GetParameter(9) <= 0.06 )
+//// {
+//// bck->SetParameters(0.01,fHisto->GetMaximum(),0.01,0.01,0.01,0.01,1.);
+////// for ( Int_t i = 0; i < 7; ++i )
+////// {
+////// bck->SetParameter(i, 0.);
+////// }
+//// }
+//// else
+//// {
+//// for ( Int_t i = 0; i < 7; ++i )
+//// {
+//// bck->SetParameter(i, fitTotal->GetParameter(i));
+//// }
+//// }
+////
+//// SetFitRejectRange(2.7,3.5);
+////
+//// fHisto->Fit(bck,"R");
+////
+//// SetFitRejectRange();
+////
+//// for ( Int_t i = 0; i < 7; ++i )
+//// {
+//// fitTotal->SetParameter(i, bck->GetParameter(i));
+//// }
+////
+//// fitResult = fHisto->Fit(fitTotal,fitOption,"");
+//// }
+//// std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
+//
+//
+//
+// Set("FitChi2PerNDF",fitTotal->GetChisquare()/fitTotal->GetNDF(),0.0);
+// Set("FitNDF",fitTotal->GetNDF(),0.0);
+//
+// Set("mJPsi",fitTotal->GetParameter(8),fitTotal->GetParError(8));
+// Set("sJPsi",fitTotal->GetParameter(9),fitTotal->GetParError(9));
+//
+// TF1* signalJPsi = new TF1("signalJPsi",this,&AliAnalysisMuMuJpsiResult::FitFunctionSignalCrystalBallExtended,fHisto->GetXaxis()->GetXmin(),fHisto->GetXaxis()->GetXmax(),7,"AliAnalysisMuMuJpsiResult","FitFunctionSignalCrystalBallExtended");
+// signalJPsi->SetParameters(fitTotal->GetParameter(7),
+// fitTotal->GetParameter(8),
+// fitTotal->GetParameter(9),
+// fitTotal->GetParameter(10),
+// fitTotal->GetParameter(11),
+// fitTotal->GetParameter(12),
+// fitTotal->GetParameter(13));
+//
+// TF1* signalPsiP = new TF1("signalPsiP",this,&AliAnalysisMuMuJpsiResult::FitFunctionSignalCrystalBallExtended,fHisto->GetXaxis()->GetXmin(),fHisto->GetXaxis()->GetXmax(),7,"AliAnalysisMuMuJpsiResult","FitFunctionSignalCrystalBallExtended");
+// signalPsiP->SetParameters(fitTotal->GetParameter(14),
+// 3.68609+(fitTotal->GetParameter(8)-3.096916)/3.096916*3.68609,
+// fitTotal->GetParameter(9)/3.096916*3.68609,
+// fitTotal->GetParameter(10),
+// fitTotal->GetParameter(11),
+// fitTotal->GetParameter(12),
+// fitTotal->GetParameter(13));
+//
+// for ( Int_t i = 0; i < 7; ++i )
+// {
+// bck->SetParameter(i, fitTotal->GetParameter(i));
+// }
+//
+// Set("alJPsi",fitTotal->GetParameter(10),fitTotal->GetParError(10));
+// Set("nlJPsi",fitTotal->GetParameter(11),fitTotal->GetParError(11));
+// Set("auJPsi",fitTotal->GetParameter(12),fitTotal->GetParError(12));
+// Set("nuJPsi",fitTotal->GetParameter(13),fitTotal->GetParError(13));
+//
+// Set("kPol4Exp",fitTotal->GetParameter(0),fitTotal->GetParError(0));
+// Set("pol0",fitTotal->GetParameter(1),fitTotal->GetParError(1));
+// Set("pol1",fitTotal->GetParameter(2),fitTotal->GetParError(2));
+// Set("pol2",fitTotal->GetParameter(3),fitTotal->GetParError(3));
+// Set("pol3",fitTotal->GetParameter(4),fitTotal->GetParError(4));
+// Set("pol4",fitTotal->GetParameter(5),fitTotal->GetParError(5));
+// Set("exp",fitTotal->GetParameter(6),fitTotal->GetParError(6));
+//
+// Set("kJPsi",fitTotal->GetParameter(7),fitTotal->GetParError(7));
+// Set("kPsiP",fitTotal->GetParameter(14),fitTotal->GetParError(14));
+//
+//
+//
+// AttachFunctionsToHisto(signalJPsi,signalPsiP,bck,fitTotal,fitRangeLow,fitRangeHigh);
+//
+// Double_t cbParameters[7];
+// Double_t covarianceMatrix[7][7];
+//
+// for ( int ix = 0; ix < 7; ++ix )
+// {
+// cbParameters[ix] = fitTotal->GetParameter(ix+7);
+// }
+//
+// for ( int iy = 0; iy < 7; ++iy )
+// {
+// for ( int ix = 0; ix < 7; ++ix )
+// {
+// covarianceMatrix[ix][iy] = (fitResult->GetCovarianceMatrix())(ix+7,iy+7);
+// }
+// }
+//
+// Double_t a = fHisto->GetXaxis()->GetXmin();
+// Double_t b = fHisto->GetXaxis()->GetXmax();
+// double njpsi = signalJPsi->Integral(a,b)/fHisto->GetBinWidth(1);
+// double nerr = signalJPsi->IntegralError(a,b,&cbParameters[0],&covarianceMatrix[0][0])/fHisto->GetBinWidth(1);
+//
+// Set("NofJPsi",njpsi,nerr);
+//
+//}
+
+//_____________________________________________________________________________
+void AliAnalysisMuMuJpsiResult::FitPSIPSIPRIMENA60NEWVWG()
+{
+ /// Fit using 2 NA60(new) (signal) + variable width gaussian (background)
+
+ fHisto->GetListOfFunctions()->Delete();
+
+ Double_t p1Left = GetValue("p1LJPsi");
+ Double_t p2Left = GetValue("p2LJPsi");
+ Double_t p3Left = GetValue("p3LJPsi");
+ Double_t p1Right = GetValue("p1RJPsi");
+ Double_t p2Right = GetValue("p2RJPsi");
+ Double_t p3Right = GetValue("p3RJPsi");
+
+ Double_t alphaLeft = GetValue("aLJPsi");
+ Double_t alphaRight = GetValue("aRJPsi");
+
+ Double_t paramSPsiP = GetValue("FSigmaPsiP");
+
+ Double_t fitRangeLow = GetValue(kFitRangeLow);
+ Double_t fitRangeHigh = GetValue(kFitRangeHigh);
+
+ TString msg;
+
+ if (IsValidValue(p1Left)) msg += TString::Format("p1L=%e ",p1Left);
+ if (IsValidValue(p2Left)) msg += TString::Format("p2L=%e ",p2Left);
+ if (IsValidValue(p3Left)) msg += TString::Format("p3L=%e ",p3Left);
+ if (IsValidValue(p1Right)) msg += TString::Format("p1R=%e ",p1Right);
+ if (IsValidValue(p2Right)) msg += TString::Format("p2R=%e ",p2Right);
+ if (IsValidValue(p3Right)) msg += TString::Format("p3R=%e ",p3Right);
+
+ if (IsValidValue(alphaLeft)) msg += TString::Format("aL=%e ",alphaLeft);
+ if (IsValidValue(alphaRight)) msg += TString::Format("aR=%e ",alphaRight);
+
+ AliDebug(1,Form("Fit with jpsi + psiprime NA60 new and VWG %s",msg.Data()));
+
+ TF1* fitTotal = new TF1("signal+bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoNA60NewVWG,fitRangeLow,fitRangeHigh,16,"AliAnalysisMuMuJpsiResult","FitFunctionTotalTwoNA60NewVWG");
+
+ fitTotal->SetParNames("kVWG","mVWG","sVWG1","sVWG2","kJPsi","mJPsi","sJPsi",
+ // 0 1 2 3 4 5 6
+ "p1LJPsi","p2LJPsi","p3LJPsi","p1RJPsi");
+ // 7 8 9 10
+ fitTotal->SetParName(11, "p2RJPsi");
+ // 11
+ fitTotal->SetParName(12, "p3RJPsi");
+ // 12
+ fitTotal->SetParName(13, "aLJPsi");
+ // 13
+ fitTotal->SetParName(14, "aRJPsi");
+ // 14
+ fitTotal->SetParName(15, "kPsiP");
+ // 15
+
+
+ TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundVWG,fitRangeLow,fitRangeHigh,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundVWG");
+
+
+ TF1* bckInit = new TF1("bckInit",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundVWG,1.7,6.,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundVWG");
+
+ Int_t bin = fHisto->FindBin(0.26);
+
+ bckInit->SetParameters(fHisto->GetBinContent(bin),2.,0.5,0.3);
+
+ SetFitRejectRange(2.7,4.0);
+
+ TFitResultPtr fitResultInit = fHisto->Fit(bckInit,"SR");
+
+ std::cout << "FitResultBkgInit=" << static_cast<int>(fitResultInit) << std::endl;
+
+ if ( static_cast<int>(fitResultInit) )
+ {
+ bin = fHisto->FindBin(0.82);
+ bckInit->SetParameters(fHisto->GetBinContent(bin),2.,0.5,0.3);
+ fitResultInit = fHisto->Fit(bckInit,"SR");
+ }
+ else if ( bckInit->GetParameter(0) < 0 )
+ {
+ bckInit->SetParameters(fHisto->GetBinContent(bin),2.,0.5,0.3);
+ }
+
+ SetFitRejectRange();
+
+ for ( Int_t i = 0; i < 4; ++i )
+ {
+ TString name(GetName());
+ if (name.Contains("NA60NEWVWG_2.2_4.7_SP1.0"))
+ {
+ fitTotal->SetParameter(i, bckInit->GetParameter(i)*0.8);
+ }
+ else fitTotal->SetParameter(i, bckInit->GetParameter(i));
+ }
+
+ delete bckInit;
+
+
+
+// fitTotal->SetParameter(0, fHisto->GetMaximum()); // kVWG
+// fitTotal->SetParameter(1, 1.9); // mVWG
+//
+// fitTotal->SetParameter(2, 0.5); // sVWG1
+// fitTotal->SetParLimits(2, 0., 100.);
+//
+// fitTotal->SetParameter(3, 0.3); // sVWG2
+// fitTotal->SetParLimits(3, 0., 100.);
+//
+// Int_t bin = fHisto->FindBin(3.09);
+// fitTotal->SetParameter(4, fHisto->GetBinContent(bin)); // norm
+
+ fitTotal->SetParameter(5, 3.1); // mean
+ fitTotal->SetParLimits(5, 3.0, 3.2);
+
+ fitTotal->SetParameter(6, 0.08); // sigma
+ fitTotal->SetParLimits(6, 0.05, 0.15);
+
+ fitTotal->FixParameter(7, p1Left);
+ fitTotal->FixParameter(8, p2Left);
+ fitTotal->FixParameter(9, p3Left);
+ fitTotal->FixParameter(10, p1Right);
+ fitTotal->FixParameter(11, p2Right);
+ fitTotal->FixParameter(12, p3Right);
+
+ fitTotal->FixParameter(13, alphaLeft);
+ fitTotal->FixParameter(14, alphaRight);
+
+ bin = fHisto->FindBin(3.68);
+ fitTotal->SetParameter(15, fHisto->GetBinContent(bin)); //kPsiP
+ fitTotal->SetParLimits(15, 0., fHisto->GetBinContent(bin)*2); //kPsiP
+
+ const char* fitOption = "SER";
+
+ TFitResultPtr fitResult = fHisto->Fit(fitTotal,fitOption,"");
+
+ std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
+ std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
+
+ // Check parameters...
+ // if (
+ // StrongCorrelation(fitResult,fitTotal,3,4,2) ||
+ // StrongCorrelation(fitResult,fitTotal,5,6,2) ||
+ // WrongParameter(fitTotal,3,1) ||
+ // WrongParameter(fitTotal,4,0) ||
+ // WrongParameter(fitTotal,5,1) ||
+ // WrongParameter(fitTotal,6,0)
+ // )
+ // {
+ // // try again...
+ // fitResult = fHisto->Fit(fitTotal,"SER","");
+ // }
+
+ if ( static_cast<int>(fitResult) )
+ {
+ if ( 0.5*fitTotal->GetParameter(15) <= fitTotal->GetParError(15) ) //kPsi'
+ {
+ std::cout << "//-------Refitting again (setting Psi'norm= Psi'norm/2)" << std::endl;
+
+ fitTotal->SetParameter(15, fHisto->GetBinContent(bin)/2.);
+ }
+
+ if ( 0.5*fitTotal->GetParameter(0) <= fitTotal->GetParError(0) ) //kVWG
+ {
+ std::cout << "//-------Refitting again (setting kVWG norm= kVWG norm /2)" << std::endl;
+ bin = fHisto->FindBin(fitRangeLow);
+
+ fitTotal->SetParameter(0, fHisto->GetBinContent(bin)/2.);
+ }
+
+ fitResult = fHisto->Fit(fitTotal,fitOption,"");
+ std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
+ }
+
+ if ( static_cast<int>(fitResult) )
+ {
+ std::cout << "//-------Refitting again (setting kVWG=kVWG*2)" << std::endl;
+
+ fitTotal->SetParameter(0, fHisto->GetMaximum()*2.); // kVWG
+
+ fitResult = fHisto->Fit(fitTotal,fitOption,"");
+ std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
+ }
+
+ if ( static_cast<int>(fitResult) )
+ {
+ std::cout << "//-------Refitting again (setting kVWG=kVWG/2)" << std::endl;
+
+ fitTotal->SetParameter(0, fHisto->GetMaximum()/2.); // kVWG
+
+ fitResult = fHisto->Fit(fitTotal,fitOption,"");
+ std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
+ }
+
+// if ( fitResult->CovMatrixStatus() != 3 )
+// {
+// std::cout << "//-------Refitting again (setting Bkg norm= Bkg norm/2)" << std::endl;
+// fitTotal->SetParameter(0, fHisto->GetMaximum()/2.); // kVWG
+// fitResult = fHisto->Fit(fitTotal,fitOption,"");
+// }
+//
+// if ( fitResult->CovMatrixStatus() != 3 )
+// {
+// bin = fHisto->FindBin(3.68);
+// std::cout << "//-------Refitting again (setting Psi'norm= Psi'norm/2)" << std::endl;
+// fitTotal->SetParameter(15, fHisto->GetBinContent(bin)/2.); // kVWG
+// fitResult = fHisto->Fit(fitTotal,fitOption,"");
+//
+// std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
+// }
+//
+// if ( fitResult->CovMatrixStatus() != 3 )
+// {
+// std::cout << "//-------Refitting again (refitting Bkg)" << std::endl;
+//
+// for ( Int_t i = 0; i < 4; ++i )
+// {
+// bck->SetParameter(i, fitTotal->GetParameter(i));
+// }
+//
+// SetFitRejectRange(2.7,3.5);
+//
+// fHisto->Fit(bck,"R");
+//
+// SetFitRejectRange();
+//
+// for ( Int_t i = 0; i < 4; ++i )
+// {
+// fitTotal->SetParameter(i, bck->GetParameter(i));
+// }
+//
+// fitResult = fHisto->Fit(fitTotal,fitOption,"");
+// }
+// std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
+// std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
+// if ( static_cast<int>(fitResult) )
+// {
+// fitTotal->SetParameter(0, fHisto->GetMaximum()); // kVWG
+// fitTotal->SetParameter(1, 1.9); // mVWG
+//
+// fitTotal->SetParameter(2, 0.5); // sVWG1
+// fitTotal->SetParLimits(2, 0., 100.);
+//
+// fitTotal->SetParameter(3, 0.3); // sVWG2
+// fitTotal->SetParLimits(3, 0., 100.);
+//
+// fitResult = fHisto->Fit(fitTotal,fitOption,"");
+//
+// std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
+// std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
+//
+// if ( static_cast<int>(fitResult) )
+// {
+// if ( fitTotal->GetParameter(15) <= fitTotal->GetParError(15) ) //kPsi'
+// {
+// std::cout << "//-------Refitting again (setting Psi'norm= Psi'norm/2)" << std::endl;
+//
+// fitTotal->SetParameter(15, fHisto->GetBinContent(bin)/2.);
+// }
+//
+// if ( fitTotal->GetParameter(0) <= fitTotal->GetParError(0) ) //kVWG
+// {
+// std::cout << "//-------Refitting again (setting kVWG norm= kVWG norm /2)" << std::endl;
+// bin = fHisto->FindBin(fitRangeLow);
+//
+// fitTotal->SetParameter(0, fHisto->GetBinContent(bin)/2.);
+// }
+//
+// fitResult = fHisto->Fit(fitTotal,fitOption,"");
+// std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
+// }
+//
+// }
+
+ TF1* signalJPsi = new TF1("signalJPsi",this,&AliAnalysisMuMuJpsiResult::FitFunctionNA60New,fHisto->GetXaxis()->GetXmin(),fHisto->GetXaxis()->GetXmax(),11,"AliAnalysisMuMuJpsiResult","FitFunctionNA60New");
+
+ signalJPsi->SetParameters(fitTotal->GetParameter(4),
+ fitTotal->GetParameter(5),
+ fitTotal->GetParameter(6),
+ fitTotal->GetParameter(7),
+ fitTotal->GetParameter(8),
+ fitTotal->GetParameter(9),
+ fitTotal->GetParameter(10),
+ fitTotal->GetParameter(11),
+ fitTotal->GetParameter(12),
+ fitTotal->GetParameter(13));
+
+ signalJPsi->SetParameter(10,fitTotal->GetParameter(14));
+
+ TF1* signalPsiP = new TF1("signalPsiP",this,&AliAnalysisMuMuJpsiResult::FitFunctionNA60New,fHisto->GetXaxis()->GetXmin(),fHisto->GetXaxis()->GetXmax(),11,"AliAnalysisMuMuJpsiResult","FitFunctionNA60New");
+
+ signalPsiP->SetParameters(fitTotal->GetParameter(15),
+ 3.68609+(fitTotal->GetParameter(5)-3.096916)/3.096916*3.68609,
+ fitTotal->GetParameter(6)*paramSPsiP, // /3.096916*3.68609,
+ fitTotal->GetParameter(7),
+ fitTotal->GetParameter(8),
+ fitTotal->GetParameter(9),
+ fitTotal->GetParameter(10),
+ fitTotal->GetParameter(11),
+ fitTotal->GetParameter(12),
+ fitTotal->GetParameter(13));
+
+ signalPsiP->SetParameter(10,fitTotal->GetParameter(14));
+
+ bck->SetParameter(0,fitTotal->GetParameter(0));
+ bck->SetParameter(1,fitTotal->GetParameter(1));
+ bck->SetParameter(2,fitTotal->GetParameter(2));
+ bck->SetParameter(3,fitTotal->GetParameter(3));
+
+ Set("FitResult",static_cast<int>(fitResult)*1.0,0.0);
+ Set("FitChi2PerNDF",fitTotal->GetChisquare()/fitTotal->GetNDF(),0.0);
+ Set("FitNDF",fitTotal->GetNDF(),0.0);
+
+ Set("kVWG",fitTotal->GetParameter(0),fitTotal->GetParError(0));
+ Set("mVWG",fitTotal->GetParameter(1),fitTotal->GetParError(1));
+ Set("sVWG1",fitTotal->GetParameter(2),fitTotal->GetParError(2));
+ Set("sVWG2",fitTotal->GetParameter(3),fitTotal->GetParError(3));
+
+ Set("kJPsi",fitTotal->GetParameter(4),fitTotal->GetParError(4));
+ Set("kPsiP",fitTotal->GetParameter(15),fitTotal->GetParError(15));
+
+ Set("mJPsi",fitTotal->GetParameter(5),fitTotal->GetParError(5));
+ Set("sJPsi",fitTotal->GetParameter(6),fitTotal->GetParError(6));
+
+ Set("p1LJPsi",fitTotal->GetParameter(7),fitTotal->GetParError(7));
+ Set("p2LJPsi",fitTotal->GetParameter(8),fitTotal->GetParError(8));
+ Set("p3LJPsi",fitTotal->GetParameter(9),fitTotal->GetParError(9));
+ Set("p1RJPsi",fitTotal->GetParameter(10),fitTotal->GetParError(10));
+ Set("p2RJPsi",fitTotal->GetParameter(11),fitTotal->GetParError(11));
+ Set("p3RJPsi",fitTotal->GetParameter(12),fitTotal->GetParError(12));
+
+ Set("aLJPsi",fitTotal->GetParameter(13),fitTotal->GetParError(13));
+ Set("aRJPsi",fitTotal->GetParameter(14),fitTotal->GetParError(14));
+
+ AttachFunctionsToHisto(signalJPsi,signalPsiP,bck,fitTotal,fitRangeLow,fitRangeHigh);
+
+ Double_t na60Parameters[11];
+ Double_t covarianceMatrix[11][11];
+
+ for ( int ix = 0; ix < 11; ++ix )
+ {
+ na60Parameters[ix] = fitTotal->GetParameter(ix+4);
+ }
+
+ for ( int iy = 0; iy < 11; ++iy )
+ {
+ for ( int ix = 0; ix < 11; ++ix )
+ {
+ covarianceMatrix[ix][iy] = (fitResult->GetCovarianceMatrix())(ix+4,iy+4);
+ }
+ }
+
+
+ Double_t a = fHisto->GetXaxis()->GetXmin();
+ Double_t b = fHisto->GetXaxis()->GetXmax();
+ double njpsi = signalJPsi->Integral(a,b)/fHisto->GetBinWidth(1);
+ double nerr = signalJPsi->IntegralError(a,b,&na60Parameters[0],&covarianceMatrix[0][0])/fHisto->GetBinWidth(1);
+
+ Set("NofJPsi",njpsi,nerr);
+
+ double m = GetValue("mJPsi");
+ double s = GetValue("sJPsi");
+ double njpsi3s = signalJPsi->Integral(m-3*s,m+3*s)/fHisto->GetBinWidth(1);
+ double nerr3s = signalJPsi->IntegralError(m-3*s,m+3*s,&na60Parameters[0],&covarianceMatrix[0][0])/fHisto->GetBinWidth(1);
+
+ Set("NofJPsi3s",njpsi3s,nerr3s);
+
+ //Computation of bin significance and signal over background
+
+ Double_t bkgParameters[4];
+ Double_t bkgcovarianceMatrix[4][4];
+
+ for ( int ix = 0; ix < 4; ++ix )
+ {
+ bkgParameters[ix] = fitTotal->GetParameter(ix);
+ }
+
+ for ( int iy = 0; iy < 4; ++iy )
+ {
+ for ( int ix = 0; ix < 4; ++ix )
+ {
+ bkgcovarianceMatrix[ix][iy] = (fitResult->GetCovarianceMatrix())(ix,iy);
+ }
+ }
+
+ double nbck3s = bck->Integral(m-3.*s,m+3.*s)/fHisto->GetBinWidth(1);
+ double nbck3sErr = bck->IntegralError(m-3.*s,m+3.*s,&bkgParameters[0],&bkgcovarianceMatrix[0][0])/fHisto->GetBinWidth(1);
+
+ double sOverB3s = njpsi3s / nbck3s;
+ double sOverB3sErr = sOverB3s*TMath::Sqrt(TMath::Power(nerr3s/njpsi3s,2.) + TMath::Power(nbck3sErr/nbck3s,2.));
+
+ Set("SignalOverBkg3s",sOverB3s,sOverB3sErr);
+
+ double sig = njpsi3s/TMath::Sqrt(njpsi3s + nbck3s);
+ double sigErr = TMath::Sqrt( TMath::Power((1. - (1./2.)*njpsi3s/(njpsi3s + nbck3s) )*nerr3s/TMath::Sqrt(njpsi3s + nbck3s),2.) +
+ TMath::Power(njpsi3s*nbck3sErr/(2.*TMath::Power(njpsi3s + nbck3s,3./2.)),2.) );
+
+ Set("Significance3s",sig,sigErr);
+
+}
+
+//_____________________________________________________________________________
+void AliAnalysisMuMuJpsiResult::FitPSIPSIPRIMENA60NEWPOL2EXP()
+{
+ /// Fit using 2 NA60(new) (signal) + pol2 x exp (background)
+
+ fHisto->GetListOfFunctions()->Delete();
+
+ Double_t p1Left = GetValue("p1LJPsi");
+ Double_t p2Left = GetValue("p2LJPsi");
+ Double_t p3Left = GetValue("p3LJPsi");
+ Double_t p1Right = GetValue("p1RJPsi");
+ Double_t p2Right = GetValue("p2RJPsi");
+ Double_t p3Right = GetValue("p3RJPsi");
+
+ Double_t alphaLeft = GetValue("aLJPsi");
+ Double_t alphaRight = GetValue("aRJPsi");
+
+ Double_t paramSPsiP = GetValue("FSigmaPsiP");
+
+ Double_t fitRangeLow = GetValue(kFitRangeLow);
+ Double_t fitRangeHigh = GetValue(kFitRangeHigh);
+
+ TString msg;
+
+ if (IsValidValue(p1Left)) msg += TString::Format("p1L=%e ",p1Left);
+ if (IsValidValue(p2Left)) msg += TString::Format("p2L=%e ",p2Left);
+ if (IsValidValue(p3Left)) msg += TString::Format("p3L=%e ",p3Left);
+ if (IsValidValue(p1Right)) msg += TString::Format("p1R=%e ",p1Right);
+ if (IsValidValue(p2Right)) msg += TString::Format("p2R=%e ",p2Right);
+ if (IsValidValue(p3Right)) msg += TString::Format("p3R=%e ",p3Right);
+
+ if (IsValidValue(alphaLeft)) msg += TString::Format("aL=%e ",alphaLeft);
+ if (IsValidValue(alphaRight)) msg += TString::Format("aR=%e ",alphaRight);
+
+ AliDebug(1,Form("Fit with jpsi + psiprime NA60 new and pol4 x exp %s",msg.Data()));
+
+ TF1* fitTotal = new TF1("signal+bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoNA60NewPol2Exp,fitRangeLow,fitRangeHigh,16,"AliAnalysisMuMuJpsiResult","FitFunctionTotalTwoNA60NewPol2Exp");
+
+ fitTotal->SetParNames("pol0","pol1","pol2","exp","kJPsi","mJPsi","sJPsi",
+ // 0 1 2 3 4 5 6
+ "p1LJPsi","p2LJPsi","p3LJPsi","p1RJPsi");
+ // 7 8 9 10
+
+ fitTotal->SetParName(11, "p2RJPsi");
+ // 11
+ fitTotal->SetParName(12, "p3RJPsi");
+ // 12
+ fitTotal->SetParName(13, "aLJPsi");
+ // 13
+ fitTotal->SetParName(14, "aRJPsi");
+ // 14
+ fitTotal->SetParName(15, "kPsiP");
+ // 15
+
+
+ TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2Exp,fitRangeLow,fitRangeHigh,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2Exp");
+
+ //___
+ TF1* bckInit = new TF1("bckInit",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2Exp,1.7,6.,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2Exp");
+
+ Int_t bin = fHisto->FindBin(0.26);
+
+ bckInit->SetParameters(fHisto->GetBinContent(bin),-fHisto->GetBinContent(bin)/3.,100.,0.05);//fHisto->GetBinContent(bin)
+
+ SetFitRejectRange(2.7,4.0);
+
+ TFitResultPtr fitResultInit = fHisto->Fit(bckInit,"SR");
+
+ std::cout << "FitResultBkgInit=" << static_cast<int>(fitResultInit) << std::endl;
+
+ if ( static_cast<int>(fitResultInit) )
+ {
+ bin = fHisto->FindBin(0.82);
+ bckInit->SetParameters(fHisto->GetBinContent(bin),2.,0.5,0.3);
+ fitResultInit = fHisto->Fit(bckInit,"SR");
+ }
+
+ SetFitRejectRange();
+
+ for ( Int_t i = 0; i < 4; ++i )
+ {
+ fitTotal->SetParameter(i, bckInit->GetParameter(i));
+ }
+
+ delete bckInit;
+ //__
+
+
+// bck->SetParameters(fHisto->GetMaximum(),0.,0.,0.,1.);
+//
+// SetFitRejectRange(2.7,3.5);
+//
+// fHisto->Fit(bck,"R");
+//
+// SetFitRejectRange();
+//
+// for ( Int_t i = 0; i < 5; ++i )
+// {
+// fitTotal->SetParameter(i, bck->GetParameter(i));
+// }
+
+
+ bin = fHisto->FindBin(3.09);
+ fitTotal->SetParameter(4, fHisto->GetBinContent(bin)); // kJPsi
+
+ fitTotal->SetParameter(5, 3.1); // mean
+ fitTotal->SetParLimits(5, 3.0, 3.2);
+
+ fitTotal->SetParameter(6, 0.08); // sigma
+ fitTotal->SetParLimits(6, 0.05, 0.15);
+
+ fitTotal->FixParameter(7, p1Left);
+ fitTotal->FixParameter(8, p2Left);
+ fitTotal->FixParameter(9, p3Left);
+ fitTotal->FixParameter(10, p1Right);
+ fitTotal->FixParameter(11, p2Right);
+ fitTotal->FixParameter(12, p3Right);
+
+ fitTotal->FixParameter(13, alphaLeft);
+ fitTotal->FixParameter(14, alphaRight);
+
+ bin = fHisto->FindBin(3.68);
+ fitTotal->SetParameter(15, fHisto->GetBinContent(bin)); //kPsiP
+ fitTotal->SetParLimits(15, 0., fHisto->GetBinContent(bin)*2); //kPsiP
+
+ const char* fitOption = "SER";
+
+ TFitResultPtr fitResult = fHisto->Fit(fitTotal,fitOption,"");
+
+ std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
+ std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
+
+ // Check parameters...
+ // if (
+ // StrongCorrelation(fitResult,fitTotal,3,4,2) ||
+ // StrongCorrelation(fitResult,fitTotal,5,6,2) ||
+ // WrongParameter(fitTotal,3,1) ||
+ // WrongParameter(fitTotal,4,0) ||
+ // WrongParameter(fitTotal,5,1) ||
+ // WrongParameter(fitTotal,6,0)
+ // )
+ // {
+ // // try again...
+ // fitResult = fHisto->Fit(fitTotal,"SER","");
+ // }
+
+ if ( static_cast<int>(fitResult) )
+ {
+ if ( 0.5*fitTotal->GetParameter(15) <= fitTotal->GetParError(15) ) //kPsi'
+ {
+ std::cout << "//-------Refitting again (setting Psi'norm= Psi'norm/2)" << std::endl;
+ bin = fHisto->FindBin(3.68);
+ fitTotal->SetParameter(15, fHisto->GetBinContent(bin)/2.);
+ }
+
+ if ( 0.5*fitTotal->GetParameter(0) <= fitTotal->GetParError(0) ) //kPol2Exp
+ {
+ std::cout << "//-------Refitting again (setting kPol2Exp norm= kPol2Exp norm /2)" << std::endl;
+ bin = fHisto->FindBin(fitRangeLow);
+
+ fitTotal->SetParameter(0, fHisto->GetBinContent(bin)/2.);
+ }
+
+ fitResult = fHisto->Fit(fitTotal,fitOption,"");
+ std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
+ }
+
+ if ( fitResult->CovMatrixStatus() != 3 )
+ {
+ if ( 0.5*fitTotal->GetParameter(15) <= fitTotal->GetParError(15) ) //kPsi'
+ {
+ std::cout << "//-------Refitting again (setting Psi'norm= Psi'norm/2)" << std::endl;
+
+ bin = fHisto->FindBin(3.68);
+ fitTotal->FixParameter(15, 0.);
+ }
+
+ else
+ {
+ std::cout << "//-------Refitting again (setting Psi'norm= Psi'norm/2)" << std::endl;
+
+ fHisto->FindBin(3.68);
+ fitTotal->SetParameter(15, fHisto->GetBinContent(bin)/2.);
+ }
+
+ fitResult = fHisto->Fit(fitTotal,fitOption,"");
+
+ std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
+ }
+
+
+// if ( fitResult->CovMatrixStatus() != 3 )
+// {
+// std::cout << "//-------Refitting again (setting Bkg norm= Bkg norm/2)" << std::endl;
+// fitTotal->SetParameter(0, fHisto->GetMaximum()/2.); // kVWG
+// fitResult = fHisto->Fit(fitTotal,fitOption,"");
+// }
+//
+// if ( fitResult->CovMatrixStatus() != 3 )
+// {
+// bin = fHisto->FindBin(3.68);
+// std::cout << "//-------Refitting again (setting Psi'norm= Psi'norm/2)" << std::endl;
+// fitTotal->SetParameter(16, fHisto->GetBinContent(bin)/2.); // kVWG
+// fitResult = fHisto->Fit(fitTotal,fitOption,"");
+//
+// std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
+// }
+//
+// if ( fitResult->CovMatrixStatus() != 3 )
+// {
+// std::cout << "//-------Refitting again (refitting Bkg)" << std::endl;
+//
+// for ( Int_t i = 0; i < 5; ++i )
+// {
+// bck->SetParameter(i, fitTotal->GetParameter(i));
+// }
+//
+// SetFitRejectRange(2.7,3.5);
+//
+// fHisto->Fit(bck,"R");
+//
+// SetFitRejectRange();
+//
+// for ( Int_t i = 0; i < 5; ++i )
+// {
+// fitTotal->SetParameter(i, bck->GetParameter(i));
+// }
+//
+// fitResult = fHisto->Fit(fitTotal,fitOption,"");
+// }
+// std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
+
+
+
+ TF1* signalJPsi = new TF1("signalJPsi",this,&AliAnalysisMuMuJpsiResult::FitFunctionNA60New,fHisto->GetXaxis()->GetXmin(),fHisto->GetXaxis()->GetXmax(),11,"AliAnalysisMuMuJpsiResult","SignalNA60New");
+
+ signalJPsi->SetParameters(fitTotal->GetParameter(4),
+ fitTotal->GetParameter(5),
+ fitTotal->GetParameter(6),
+ fitTotal->GetParameter(7),
+ fitTotal->GetParameter(8),
+ fitTotal->GetParameter(9),
+ fitTotal->GetParameter(10),
+ fitTotal->GetParameter(11),
+ fitTotal->GetParameter(12),
+ fitTotal->GetParameter(13));
+
+ signalJPsi->SetParameter(10,fitTotal->GetParameter(14));
+
+ TF1* signalPsiP = new TF1("signalPsiP",this,&AliAnalysisMuMuJpsiResult::FitFunctionNA60New,fHisto->GetXaxis()->GetXmin(),fHisto->GetXaxis()->GetXmax(),11,"AliAnalysisMuMuJpsiResult","SignalNA60New");
+
+ signalPsiP->SetParameters(fitTotal->GetParameter(15),
+ 3.68609+(fitTotal->GetParameter(5)-3.096916)/3.096916*3.68609,
+ fitTotal->GetParameter(6)*paramSPsiP, // /3.096916*3.68609,
+ fitTotal->GetParameter(7),
+ fitTotal->GetParameter(8),
+ fitTotal->GetParameter(9),
+ fitTotal->GetParameter(10),
+ fitTotal->GetParameter(11),
+ fitTotal->GetParameter(12),
+ fitTotal->GetParameter(13));
+
+ signalPsiP->SetParameter(10,fitTotal->GetParameter(14));
+
+ for ( Int_t i = 0; i < 4; ++i )
+ {
+ bck->SetParameter(i, fitTotal->GetParameter(i));
+ }
+
+
+ Set("FitResult",static_cast<int>(fitResult)*1.0,0.0);
+ Set("FitChi2PerNDF",fitTotal->GetChisquare()/fitTotal->GetNDF(),0.0);
+ Set("FitNDF",fitTotal->GetNDF(),0.0);
+
+// Set("kPol2Exp",fitTotal->GetParameter(0),fitTotal->GetParError(0));
+ Set("pol0",fitTotal->GetParameter(0),fitTotal->GetParError(0));
+ Set("pol1",fitTotal->GetParameter(1),fitTotal->GetParError(1));
+ Set("pol2",fitTotal->GetParameter(2),fitTotal->GetParError(2));
+ Set("exp",fitTotal->GetParameter(3),fitTotal->GetParError(3));
+
+ Set("kJPsi",fitTotal->GetParameter(4),fitTotal->GetParError(4));
+ Set("kPsiP",fitTotal->GetParameter(15),fitTotal->GetParError(15));
+
+ Set("mJPsi",fitTotal->GetParameter(5),fitTotal->GetParError(5));
+ Set("sJPsi",fitTotal->GetParameter(6),fitTotal->GetParError(6));
+
+ Set("p1LJPsi",fitTotal->GetParameter(7),fitTotal->GetParError(7));
+ Set("p2LJPsi",fitTotal->GetParameter(8),fitTotal->GetParError(8));
+ Set("p3LJPsi",fitTotal->GetParameter(9),fitTotal->GetParError(9));
+ Set("p1RJPsi",fitTotal->GetParameter(10),fitTotal->GetParError(10));
+ Set("p2RJPsi",fitTotal->GetParameter(11),fitTotal->GetParError(11));
+ Set("p3RJPsi",fitTotal->GetParameter(12),fitTotal->GetParError(12));
+
+ Set("aLJPsi",fitTotal->GetParameter(13),fitTotal->GetParError(13));
+ Set("aRJPsi",fitTotal->GetParameter(14),fitTotal->GetParError(14));
+
+ AttachFunctionsToHisto(signalJPsi,signalPsiP,bck,fitTotal,fitRangeLow,fitRangeHigh);
+
+ Double_t na60Parameters[11];
+ Double_t covarianceMatrix[11][11];
+
+ for ( int ix = 0; ix < 11; ++ix )
+ {
+ na60Parameters[ix] = fitTotal->GetParameter(ix+4);
+ }
+
+ for ( int iy = 0; iy < 11; ++iy )
+ {
+ for ( int ix = 0; ix < 11; ++ix )
+ {
+ covarianceMatrix[ix][iy] = (fitResult->GetCovarianceMatrix())(ix+4,iy+4);
+ }
+ }
+
+ Double_t a = fHisto->GetXaxis()->GetXmin();
+ Double_t b = fHisto->GetXaxis()->GetXmax();
+ double njpsi = signalJPsi->Integral(a,b)/fHisto->GetBinWidth(1);
+ double nerr = signalJPsi->IntegralError(a,b,&na60Parameters[0],&covarianceMatrix[0][0])/fHisto->GetBinWidth(1);
+
+ Set("NofJPsi",njpsi,nerr);
+
+ double m = GetValue("mJPsi");
+ double s = GetValue("sJPsi");
+ double njpsi3s = signalJPsi->Integral(m-3*s,m+3*s)/fHisto->GetBinWidth(1);
+ double nerr3s = signalJPsi->IntegralError(m-3*s,m+3*s,&na60Parameters[0],&covarianceMatrix[0][0])/fHisto->GetBinWidth(1);
+
+ Set("NofJPsi3s",njpsi3s,nerr3s);
+
+ //Computation of bin significance and signal over background
+
+ Double_t bkgParameters[4];
+ Double_t bkgcovarianceMatrix[4][4];
+
+ for ( int ix = 0; ix < 4; ++ix )
+ {
+ bkgParameters[ix] = fitTotal->GetParameter(ix);
+ }
+
+ for ( int iy = 0; iy < 4; ++iy )
+ {
+ for ( int ix = 0; ix < 4; ++ix )
+ {
+ bkgcovarianceMatrix[ix][iy] = (fitResult->GetCovarianceMatrix())(ix,iy);
+ }
+ }
+
+ double nbck3s = bck->Integral(m-3.*s,m+3.*s)/fHisto->GetBinWidth(1);
+ double nbck3sErr = bck->IntegralError(m-3.*s,m+3.*s,&bkgParameters[0],&bkgcovarianceMatrix[0][0])/fHisto->GetBinWidth(1);
+
+ double sOverB3s = njpsi3s / nbck3s;
+ double sOverB3sErr = sOverB3s*TMath::Sqrt(TMath::Power(nerr3s/njpsi3s,2.) + TMath::Power(nbck3sErr/nbck3s,2.));
+
+ Set("SignalOverBkg3s",sOverB3s,sOverB3sErr);
+
+ double sig = njpsi3s/TMath::Sqrt(njpsi3s + nbck3s);
+ double sigErr = TMath::Sqrt( TMath::Power((1. - (1./2.)*njpsi3s/(njpsi3s + nbck3s) )*nerr3s/TMath::Sqrt(njpsi3s + nbck3s),2.) +
+ TMath::Power(njpsi3s*nbck3sErr/(2.*TMath::Power(njpsi3s + nbck3s,3./2.)),2.) );
+
+ Set("Significance3s",sig,sigErr);
+
+}
+
+//_____________________________________________________________________________
+void AliAnalysisMuMuJpsiResult::FitPSIPSIPRIMENA60NEWPOL4EXP()
+{
+ /// Fit using 2 NA60(new) (signal) + pol4 x exp (background)
+
+ fHisto->GetListOfFunctions()->Delete();
+
+ Double_t p1Left = GetValue("p1LJPsi");
+ Double_t p2Left = GetValue("p2LJPsi");
+ Double_t p3Left = GetValue("p3LJPsi");
+ Double_t p1Right = GetValue("p1RJPsi");
+ Double_t p2Right = GetValue("p2RJPsi");
+ Double_t p3Right = GetValue("p3RJPsi");
+
+ Double_t alphaLeft = GetValue("aLJPsi");
+ Double_t alphaRight = GetValue("aRJPsi");
+
+ Double_t paramSPsiP = GetValue("FSigmaPsiP");
+
+ Double_t fitRangeLow = GetValue(kFitRangeLow);
+ Double_t fitRangeHigh = GetValue(kFitRangeHigh);
+
+ TString msg;
+
+ if (IsValidValue(p1Left)) msg += TString::Format("p1L=%e ",p1Left);
+ if (IsValidValue(p2Left)) msg += TString::Format("p2L=%e ",p2Left);
+ if (IsValidValue(p3Left)) msg += TString::Format("p3L=%e ",p3Left);
+ if (IsValidValue(p1Right)) msg += TString::Format("p1R=%e ",p1Right);
+ if (IsValidValue(p2Right)) msg += TString::Format("p2R=%e ",p2Right);
+ if (IsValidValue(p3Right)) msg += TString::Format("p3R=%e ",p3Right);
+
+ if (IsValidValue(alphaLeft)) msg += TString::Format("aL=%e ",alphaLeft);
+ if (IsValidValue(alphaRight)) msg += TString::Format("aR=%e ",alphaRight);
+
+ AliDebug(1,Form("Fit with jpsi + psiprime NA60 new and pol4 x exp %s",msg.Data()));
+
+ TF1* fitTotal = new TF1("signal+bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoNA60NewPol4Exp,fitRangeLow,fitRangeHigh,18,"AliAnalysisMuMuJpsiResult","FitFunctionTotalTwoNA60NewPol4Exp");
+
+ fitTotal->SetParNames("pol0","pol1","pol2","pol3","pol4","exp","kJPsi",
+ // 0 1 2 3 4 5 6
+ "mJPsi","sJPsi","p1LJPsi","p2LJPsi");
+ // 7 8 9 10
+
+ fitTotal->SetParName(11, "p3LJPsi");
+ // 11
+ fitTotal->SetParName(12, "p1RJPsi");
+ // 12
+ fitTotal->SetParName(13, "p2RJPsi");
+ // 13
+ fitTotal->SetParName(14, "p3RJPsi");
+ // 14
+ fitTotal->SetParName(15, "aLJPsi");
+ // 15
+ fitTotal->SetParName(16, "aRJPsi");
+ // 16
+ fitTotal->SetParName(17, "kPsiP");
+ // 17
+
+
+ TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol4Exp,fitRangeLow,fitRangeHigh,6,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol4Exp");
+
+ //___
+ TF1* bckInit = new TF1("bckInit",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol4Exp,1.6,7.,6,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol4Exp");
+
+ Int_t bin = fHisto->FindBin(1.6);
+
+ bckInit->SetParameters(fHisto->GetBinContent(bin),-fHisto->GetBinContent(bin),fHisto->GetBinContent(bin)/2.,-fHisto->GetBinContent(bin)/10.,fHisto->GetBinContent(bin)/100.,-2.);
+
+ SetFitRejectRange(2.6,4.0);
+
+ TFitResultPtr fitResultInit = fHisto->Fit(bckInit,"SR");
+
+ std::cout << "FitResultBkgInit=" << static_cast<int>(fitResultInit) << std::endl;
+
+ if ( static_cast<int>(fitResultInit) )
+ {
+ bin = fHisto->FindBin(0.82);
+ bckInit->SetParameters(0.,1.,1.,1.,2.,0.5);
+ fitResultInit = fHisto->Fit(bckInit,"SR");
+ }
+
+ SetFitRejectRange();
+
+ for ( Int_t i = 0; i < 6; ++i )
+ {
+ fitTotal->SetParameter(i, bckInit->GetParameter(i));
+ }
+
+ delete bckInit;
+ //___
+
+//
+// bck->SetParameters(fHisto->GetMaximum(),0.,0.,0.,0.,0.,1.);
+//
+// SetFitRejectRange(2.7,3.5);
+//
+// fHisto->Fit(bck,"R");
+//
+// SetFitRejectRange();
+//
+// for ( Int_t i = 0; i < 7; ++i )
+// {
+// fitTotal->SetParameter(i, bck->GetParameter(i));
+// }
+
+
+ bin = fHisto->FindBin(3.09);
+ fitTotal->SetParameter(6, fHisto->GetBinContent(bin)); // kJPsi
+
+ fitTotal->SetParameter(7, 3.1); // mean
+ fitTotal->SetParLimits(7, 3.0, 3.2);
+
+ fitTotal->SetParameter(8, 0.08); // sigma
+ fitTotal->SetParLimits(8, 0.05, 0.15);
+
+ fitTotal->FixParameter(9, p1Left);
+ fitTotal->FixParameter(10, p2Left);
+ fitTotal->FixParameter(11, p3Left);
+ fitTotal->FixParameter(12, p1Right);
+ fitTotal->FixParameter(13, p2Right);
+ fitTotal->FixParameter(14, p3Right);
+
+ fitTotal->FixParameter(15, alphaLeft);
+ fitTotal->FixParameter(16, alphaRight);
+
+ bin = fHisto->FindBin(3.68);
+ fitTotal->SetParameter(17, fHisto->GetBinContent(bin)); //kPsiP
+ fitTotal->SetParLimits(17, 0., fHisto->GetBinContent(bin)*2); //kPsiP
+
+ const char* fitOption = "SER";
+
+ TFitResultPtr fitResult = fHisto->Fit(fitTotal,fitOption,"");
+
+ std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
+ std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
+
+ // Check parameters...
+ // if (
+ // StrongCorrelation(fitResult,fitTotal,3,4,2) ||
+ // StrongCorrelation(fitResult,fitTotal,5,6,2) ||
+ // WrongParameter(fitTotal,3,1) ||
+ // WrongParameter(fitTotal,4,0) ||
+ // WrongParameter(fitTotal,5,1) ||
+ // WrongParameter(fitTotal,6,0)
+ // )
+ // {
+ // // try again...
+ // fitResult = fHisto->Fit(fitTotal,"SER","");
+ // }
+
+
+ if ( static_cast<int>(fitResult) )
+ {
+ if ( 0.5*fitTotal->GetParameter(17) <= fitTotal->GetParError(17) ) //kPsi'
+ {
+ std::cout << "//-------Refitting again (setting Psi'norm= Psi'norm/2)" << std::endl;
+
+ fitTotal->SetParameter(17, fHisto->GetBinContent(bin)/2.);
+ }
+
+ if ( 0.5*fitTotal->GetParameter(0) <= fitTotal->GetParError(0) ) //kPol4Exp
+ {
+ std::cout << "//-------Refitting again (setting kPol4Exp norm= kPol4Exp norm /2)" << std::endl;
+ bin = fHisto->FindBin(fitRangeLow);
+
+ fitTotal->SetParameter(0, fHisto->GetBinContent(bin)/2.);
+ }
+
+ fitResult = fHisto->Fit(fitTotal,fitOption,"");
+ std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
+ }
+
+ if ( fitResult->CovMatrixStatus() != 3 )
+ {
+ std::cout << "//-------Refitting again (setting Bkg norm= Bkg norm/2)" << std::endl;
+ fitTotal->SetParameter(0, fHisto->GetMaximum()/2.); // kVWG
+ fitResult = fHisto->Fit(fitTotal,fitOption,"");
+ }
+
+// if ( fitResult->CovMatrixStatus() != 3 )
+// {
+// bin = fHisto->FindBin(3.68);
+// std::cout << "//-------Refitting again (setting Psi'norm= Psi'norm/2)" << std::endl;
+// fitTotal->SetParameter(18, fHisto->GetBinContent(bin)/2.); // kVWG
+// fitResult = fHisto->Fit(fitTotal,fitOption,"");
+//
+// std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
+// }
+//
+// if ( fitResult->CovMatrixStatus() != 3 )
+// {
+// std::cout << "//-------Refitting again (refitting Bkg)" << std::endl;
+//
+// for ( Int_t i = 0; i < 7; ++i )
+// {
+// bck->SetParameter(i, fitTotal->GetParameter(i));
+// }
+//
+// SetFitRejectRange(2.7,3.5);
+//
+// fHisto->Fit(bck,"R");
+//
+// SetFitRejectRange();
+//
+// for ( Int_t i = 0; i < 7; ++i )
+// {
+// fitTotal->SetParameter(i, bck->GetParameter(i));
+// }
+//
+// fitResult = fHisto->Fit(fitTotal,fitOption,"");
+// }
+// std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
+
+
+ TF1* signalJPsi = new TF1("signalJPsi",this,&AliAnalysisMuMuJpsiResult::FitFunctionNA60New,fHisto->GetXaxis()->GetXmin(),fHisto->GetXaxis()->GetXmax(),11,"AliAnalysisMuMuJpsiResult","SignalNA60New");
+
+ signalJPsi->SetParameters(fitTotal->GetParameter(6),
+ fitTotal->GetParameter(7),
+ fitTotal->GetParameter(8),
+ fitTotal->GetParameter(9),
+ fitTotal->GetParameter(10),
+ fitTotal->GetParameter(11),
+ fitTotal->GetParameter(12),
+ fitTotal->GetParameter(13),
+ fitTotal->GetParameter(14),
+ fitTotal->GetParameter(15));
+
+ signalJPsi->SetParameter(10,fitTotal->GetParameter(16));
+
+ TF1* signalPsiP = new TF1("signalPsiP",this,&AliAnalysisMuMuJpsiResult::FitFunctionNA60New,fHisto->GetXaxis()->GetXmin(),fHisto->GetXaxis()->GetXmax(),11,"AliAnalysisMuMuJpsiResult","SignalNA60New");
+
+ signalPsiP->SetParameters(fitTotal->GetParameter(17),
+ 3.68609+(fitTotal->GetParameter(7)-3.096916)/3.096916*3.68609,
+ fitTotal->GetParameter(8)*paramSPsiP, // /3.096916*3.68609,
+ fitTotal->GetParameter(9),
+ fitTotal->GetParameter(10),
+ fitTotal->GetParameter(11),
+ fitTotal->GetParameter(12),
+ fitTotal->GetParameter(13),
+ fitTotal->GetParameter(14),
+ fitTotal->GetParameter(15));
+
+ signalPsiP->SetParameter(10,fitTotal->GetParameter(16));
+
+ for ( Int_t i = 0; i < 6; ++i )
+ {
+ bck->SetParameter(i, fitTotal->GetParameter(i));
+ }
+
+
+ Set("FitResult",static_cast<int>(fitResult)*1.0,0.0);
+ Set("FitChi2PerNDF",fitTotal->GetChisquare()/fitTotal->GetNDF(),0.0);
+ Set("FitNDF",fitTotal->GetNDF(),0.0);
+
+// Set("kPol4Exp",fitTotal->GetParameter(0),fitTotal->GetParError(0));
+ Set("pol0",fitTotal->GetParameter(0),fitTotal->GetParError(0));
+ Set("pol1",fitTotal->GetParameter(1),fitTotal->GetParError(1));
+ Set("pol2",fitTotal->GetParameter(2),fitTotal->GetParError(2));
+ Set("pol3",fitTotal->GetParameter(3),fitTotal->GetParError(3));
+ Set("pol4",fitTotal->GetParameter(4),fitTotal->GetParError(4));
+ Set("exp",fitTotal->GetParameter(5),fitTotal->GetParError(5));
+
+ Set("kJPsi",fitTotal->GetParameter(4),fitTotal->GetParError(4));
+ Set("kPsiP",fitTotal->GetParameter(17),fitTotal->GetParError(17));
+
+ Set("mJPsi",fitTotal->GetParameter(7),fitTotal->GetParError(7));
+ Set("sJPsi",fitTotal->GetParameter(8),fitTotal->GetParError(8));
+
+ Set("p1LJPsi",fitTotal->GetParameter(9),fitTotal->GetParError(9));
+ Set("p2LJPsi",fitTotal->GetParameter(10),fitTotal->GetParError(10));
+ Set("p3LJPsi",fitTotal->GetParameter(11),fitTotal->GetParError(11));
+ Set("p1RJPsi",fitTotal->GetParameter(12),fitTotal->GetParError(12));
+ Set("p2RJPsi",fitTotal->GetParameter(13),fitTotal->GetParError(13));
+ Set("p3RJPsi",fitTotal->GetParameter(14),fitTotal->GetParError(14));
+
+ Set("aLJPsi",fitTotal->GetParameter(15),fitTotal->GetParError(15));
+ Set("aRJPsi",fitTotal->GetParameter(16),fitTotal->GetParError(16));
+
+ AttachFunctionsToHisto(signalJPsi,signalPsiP,bck,fitTotal,fitRangeLow,fitRangeHigh);
+
+ Double_t na60Parameters[11];
+ Double_t covarianceMatrix[11][11];
+
+ for ( int ix = 0; ix < 11; ++ix )
+ {
+ na60Parameters[ix] = fitTotal->GetParameter(ix+6);
+ }
+
+ for ( int iy = 0; iy < 11; ++iy )
+ {
+ for ( int ix = 0; ix < 11; ++ix )
+ {
+ covarianceMatrix[ix][iy] = (fitResult->GetCovarianceMatrix())(ix+6,iy+6);
+ }
+ }
+
+ Double_t a = fHisto->GetXaxis()->GetXmin();
+ Double_t b = fHisto->GetXaxis()->GetXmax();
+ double njpsi = signalJPsi->Integral(a,b)/fHisto->GetBinWidth(1);
+ double nerr = signalJPsi->IntegralError(a,b,&na60Parameters[0],&covarianceMatrix[0][0])/fHisto->GetBinWidth(1);
+
+ Set("NofJPsi",njpsi,nerr);
+
+ double m = GetValue("mJPsi");
+ double s = GetValue("sJPsi");
+ double njpsi3s = signalJPsi->Integral(m-3*s,m+3*s)/fHisto->GetBinWidth(1);
+ double nerr3s = signalJPsi->IntegralError(m-3*s,m+3*s,&na60Parameters[0],&covarianceMatrix[0][0])/fHisto->GetBinWidth(1);
+
+ Set("NofJPsi3s",njpsi3s,nerr3s);
+
+ //Computation of bin significance and signal over background
+
+ Double_t bkgParameters[6];
+ Double_t bkgcovarianceMatrix[6][6];
+
+ for ( int ix = 0; ix < 6; ++ix )
+ {
+ bkgParameters[ix] = fitTotal->GetParameter(ix);
+ }
+
+ for ( int iy = 0; iy < 6; ++iy )
+ {
+ for ( int ix = 0; ix < 6; ++ix )
+ {
+ bkgcovarianceMatrix[ix][iy] = (fitResult->GetCovarianceMatrix())(ix,iy);
+ }
+ }
+
+ double nbck3s = bck->Integral(m-3.*s,m+3.*s)/fHisto->GetBinWidth(1);
+ double nbck3sErr = bck->IntegralError(m-3.*s,m+3.*s,&bkgParameters[0],&bkgcovarianceMatrix[0][0])/fHisto->GetBinWidth(1);
+
+ double sOverB3s = njpsi3s / nbck3s;
+ double sOverB3sErr = sOverB3s*TMath::Sqrt(TMath::Power(nerr3s/njpsi3s,2.) + TMath::Power(nbck3sErr/nbck3s,2.));
+
+ Set("SignalOverBkg3s",sOverB3s,sOverB3sErr);
+
+ double sig = njpsi3s/TMath::Sqrt(njpsi3s + nbck3s);
+ double sigErr = TMath::Sqrt( TMath::Power((1. - (1./2.)*njpsi3s/(njpsi3s + nbck3s) )*nerr3s/TMath::Sqrt(njpsi3s + nbck3s),2.) +
+ TMath::Power(njpsi3s*nbck3sErr/(2.*TMath::Power(njpsi3s + nbck3s,3./2.)),2.) );
+
+ Set("Significance3s",sig,sigErr);
+
+}
+
+//_____________________________________________________________________________
+void AliAnalysisMuMuJpsiResult::FitMPTPSIPSIPRIMECB2VWG_BKGMPTPOL2()
+{
+ //Fit mean dimuon mean pt to get Jpsi mean pt using the CB2 signal parameters, VWG for the Bkg, Jpsi mpt = cte and Bkg mpt = pol2
+ fHisto->GetListOfFunctions()->Delete();
+
+ Double_t alphaLow = GetValue("alJPsi");
+ Double_t nLow = GetValue("nlJPsi");
+ Double_t alphaUp = GetValue("auJPsi");
+ Double_t nUp = GetValue("nuJPsi");
+
+ Double_t kVWG = GetValue("kVWG");
+ Double_t mVWG = GetValue("mVWG");
+ Double_t sVWG1 = GetValue("sVWG1");
+ Double_t sVWG2 = GetValue("sVWG2");
+ Double_t kJPsi = GetValue("kJPsi");
+ Double_t kPsiP = GetValue("kPsiP");
+ Double_t mJPsi = GetValue("mJPsi");
+ Double_t sJPsi = GetValue("sJPsi");
+ Double_t NofJPsi = GetValue("NofJPsi");
+ Double_t ErrStatNofJPsi = GetErrorStat("NofJPsi");
+
+ Double_t fitRangeLow = GetValue(kFitRangeLow);
+ Double_t fitRangeHigh = GetValue(kFitRangeHigh);
+
+// TString msg;
+//
+// if (IsValidValue(alphaLow)) msg += TString::Format("alphaLow=%e ",alphaLow);
+// if (IsValidValue(nLow)) msg += TString::Format("nLow=%e ",nLow);
+// if (IsValidValue(alphaUp)) msg += TString::Format("alphaUp=%e ",alphaUp);
+// if (IsValidValue(nUp)) msg += TString::Format("nUp=%e ",nUp);
+//
+// AliDebug(1,Form("Mean pt fit with jpsi + psiprime (CB2),Bkg VWG and Pol2 for Bkg <pt> %s",msg.Data()));
+//
+// TF1* fitTotal = new TF1("signal+bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2VWG,fitRangeLow,fitRangeHigh,17,"AliAnalysisMuMuJpsiResult","FitFunctionTotalTwoCB2VWG");
+//
+//TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
+
+
+// TString resultName(Form("MEANPTFIT_%salphalow=%5.2fnlow=%5.2falphaup=%5.2fnup=%5.2f",fitName.Data(),par[7],par[8],par[9],par[10]));
+ TProfile* p(0x0);
+ if ( fHisto->IsA() == TProfile::Class() ) p = static_cast<TProfile*>(fHisto);
+ else
+ {
+ AliError("Mean pt histo has to be a TProfile");
+ return;
+ }
+
+ //_____________
+ Int_t minBin = p->FindBin(fitRangeLow);
+ Int_t maxBin = p->FindBin(fitRangeHigh);
+
+ for ( Int_t i = minBin ; i <= maxBin ; i++ )
+ {
+ if ( p->GetBinEffectiveEntries(i) < 10 )
+ {
+ Double_t effEntries(0.),sumErr(0.);
+ for ( Int_t j = i - 5 ; j < i ; j++ )
+ {
+ if ( j <= 0 ) continue;
+// if ( j > p->GetNbinsX() ) break;
+
+ effEntries += p->GetBinEffectiveEntries(j);
+ sumErr += p->GetBinEffectiveEntries(j)*p->GetBinError(j);
+ }
+
+ Double_t meanErr = sumErr/effEntries;
+
+ if ( p->GetBinError(i) < meanErr/2. )
+ {
+ std::cout << "Resetting bin " << i << " error" <<std::endl;
+ p->SetBinError(i,meanErr);
+ }
+ }
+ }
+ //_____________
+
+ TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
+
+ bck->SetParameters(3.,1.,0.);
+
+ bck->SetParLimits(0, 1.,8.0);
+// TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2Exp,fitRangeLow,fitRangeHigh,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2Exp");
+//
+// bck->SetParameters(1,0,0,0);
+
+ SetFitRejectRange(2.3,4.0);
+
+ p->Fit(bck,"SER","",fitRangeLow,fitRangeHigh);
+
+ SetFitRejectRange();
+
+
+
+ TF1* fitMeanpt = new TF1("fitMeanpt",this,&AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2CB2VWGPOL2,fitRangeLow,fitRangeHigh,17,"AliAnalysisMuMuJpsiResult","FitFunctionMeanPtS2CB2VWGPOL2");
+
+ fitMeanpt->SetParNames("kVWG","mVWG","sVWG1","sVWG2","kJPsi","mJPsi","sJPsi","alJPsi","nlJPsi","auJPsi","nuJPsi");
+ fitMeanpt->SetParName(11,"kPsiP");
+ fitMeanpt->SetParName(12,"<pt>JPsi");
+ fitMeanpt->SetParName(13,"<pt>BG0");
+ fitMeanpt->SetParName(14,"<pt>BG1");
+ fitMeanpt->SetParName(15,"<pt>BG2");
+ fitMeanpt->SetParName(16,"<pt>PsiP");
+
+ fitMeanpt->FixParameter(0,kVWG);
+ fitMeanpt->FixParameter(1,mVWG);
+ fitMeanpt->FixParameter(2,sVWG1);
+ fitMeanpt->FixParameter(3,sVWG2);
+ fitMeanpt->FixParameter(4,kJPsi);
+ fitMeanpt->FixParameter(5,mJPsi);
+ fitMeanpt->FixParameter(6,sJPsi);
+ fitMeanpt->FixParameter(7,alphaLow);
+ fitMeanpt->FixParameter(8,nLow);
+ fitMeanpt->FixParameter(9,alphaUp);
+ fitMeanpt->FixParameter(10,nUp);
+ fitMeanpt->FixParameter(11,kPsiP);
+
+ fitMeanpt->SetParameter(12, 3.);
+ fitMeanpt->SetParLimits(12, 1.0,5.);
+
+ for ( Int_t i = 0; i < 3; ++i )
+ {
+ fitMeanpt->SetParameter(i + 13, bck->GetParameter(i));
+ }
+
+// fitMeanpt->SetParameter(13, 3.);
+// fitMeanpt->SetParLimits(13, 0.5,10.);
+//
+// fitMeanpt->SetParameter(14, 0.2);
+// // fitMeanpt->SetParLimits(14, 0.1,0.2);
+//
+// fitMeanpt->SetParameter(15, 0.1);
+// // fitMeanpt->SetParLimits(15, 0.,1.);
+
+ fitMeanpt->SetParameter(16, 3.);
+ Double_t psipPtLim = 10.;
+ fitMeanpt->SetParLimits(16, 0.,psipPtLim);
+
+
+// TProfile::Approximate();
+
+ const char* fitOption = "SER"; //+";//SER
+
+ TFitResultPtr fitResult = p->Fit(fitMeanpt,fitOption,"");
+
+ std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
+
+ if ( static_cast<int>(fitResult) )
+ {
+ for ( Int_t i = 0; i < 3; ++i )
+ {
+ fitMeanpt->SetParameter(i + 13, bck->GetParameter(i)*0.9);
+ }
+ fitResult = p->Fit(fitMeanpt,fitOption,"");
+
+ std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
+ }
+ else if ( fitMeanpt->GetParameter(16) <= fitMeanpt->GetParError(16) || fitMeanpt->GetParError(16) >= 0.75*fitMeanpt->GetParameter(16) || (fitMeanpt->GetParameter(16)/psipPtLim > 0.9) )
+ {
+ fitMeanpt->FixParameter(16, bck->Eval(3.68));
+ for ( Int_t i = 0; i < 3; ++i )
+ {
+ fitMeanpt->SetParameter(i + 13, bck->GetParameter(i)*0.6);
+ }
+ fitResult = p->Fit(fitMeanpt,fitOption,"");
+
+ std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
+ }
+
+
+// TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
+
+ bck->SetParameters(fitMeanpt->GetParameter(13),fitMeanpt->GetParameter(14),fitMeanpt->GetParameter(15));
+
+ AttachFunctionsToHisto(0x0,bck,fitMeanpt,fitRangeLow,fitRangeHigh);//
+
+ Set("NofJPsi",NofJPsi,ErrStatNofJPsi);
+ Set("MeanPtJPsi",fitMeanpt->GetParameter(12),fitMeanpt->GetParError(12));
+ Set("MeanPtPsiP",fitMeanpt->GetParameter(16),fitMeanpt->GetParError(16));
+
+}
+
+//_____________________________________________________________________________
+void AliAnalysisMuMuJpsiResult::FitMPTPSIPSIPRIMECB2VWG_BKGMPTPOL2EXP()
+{
+ //Fit mean dimuon mean pt to get Jpsi mean pt using the CB2 signal parameters, VWG for the Bkg, Jpsi mpt = cte and Bkg mpt = pol2
+ fHisto->GetListOfFunctions()->Delete();
+
+ Double_t alphaLow = GetValue("alJPsi");
+ Double_t nLow = GetValue("nlJPsi");
+ Double_t alphaUp = GetValue("auJPsi");
+ Double_t nUp = GetValue("nuJPsi");
+
+ Double_t kVWG = GetValue("kVWG");
+ Double_t mVWG = GetValue("mVWG");
+ Double_t sVWG1 = GetValue("sVWG1");
+ Double_t sVWG2 = GetValue("sVWG2");
+ Double_t kJPsi = GetValue("kJPsi");
+ Double_t kPsiP = GetValue("kPsiP");
+ Double_t mJPsi = GetValue("mJPsi");
+ Double_t sJPsi = GetValue("sJPsi");
+ Double_t NofJPsi = GetValue("NofJPsi");
+ Double_t ErrStatNofJPsi = GetErrorStat("NofJPsi");
+
+ Double_t fitRangeLow = GetValue(kFitRangeLow);
+ Double_t fitRangeHigh = GetValue(kFitRangeHigh);
+
+ // TString msg;
+ //
+ // if (IsValidValue(alphaLow)) msg += TString::Format("alphaLow=%e ",alphaLow);
+ // if (IsValidValue(nLow)) msg += TString::Format("nLow=%e ",nLow);
+ // if (IsValidValue(alphaUp)) msg += TString::Format("alphaUp=%e ",alphaUp);
+ // if (IsValidValue(nUp)) msg += TString::Format("nUp=%e ",nUp);
+ //
+ // AliDebug(1,Form("Mean pt fit with jpsi + psiprime (CB2),Bkg VWG and Pol2 for Bkg <pt> %s",msg.Data()));
+ //
+ // TF1* fitTotal = new TF1("signal+bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2VWG,fitRangeLow,fitRangeHigh,17,"AliAnalysisMuMuJpsiResult","FitFunctionTotalTwoCB2VWG");
+ //
+ //TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
+
+
+ // TString resultName(Form("MEANPTFIT_%salphalow=%5.2fnlow=%5.2falphaup=%5.2fnup=%5.2f",fitName.Data(),par[7],par[8],par[9],par[10]));
+ TProfile* p(0x0);
+ if ( fHisto->IsA() == TProfile::Class() ) p = static_cast<TProfile*>(fHisto);
+ else
+ {
+ AliError("Mean pt histo has to be a TProfile");
+ return;
+ }
+
+ //_____________
+ Int_t minBin = p->FindBin(fitRangeLow);
+ Int_t maxBin = p->FindBin(fitRangeHigh);
+
+ for ( Int_t i = minBin ; i <= maxBin ; i++ )
+ {
+ if ( p->GetBinEffectiveEntries(i) < 10 )
+ {
+ Double_t effEntries(0.),sumErr(0.);
+ for ( Int_t j = i - 5 ; j < i ; j++ )
+ {
+ if ( j <= 0 ) continue;
+ // if ( j > p->GetNbinsX() ) break;
+
+ effEntries += p->GetBinEffectiveEntries(j);
+ sumErr += p->GetBinEffectiveEntries(j)*p->GetBinError(j);
+ }
+
+ Double_t meanErr = sumErr/effEntries;
+
+ if ( p->GetBinError(i) < meanErr/2. )
+ {
+ std::cout << "Resetting bin " << i << " error" <<std::endl;
+ p->SetBinError(i,meanErr);
+ }
+ }
+ }
+ //_____________
+
+ TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2Exp,fitRangeLow,fitRangeHigh,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2Exp");
+
+ bck->SetParameters(3.,-2.,0.4,-0.0);
+
+ bck->SetParLimits(0, 1.,10.0);
+ // TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2Exp,fitRangeLow,fitRangeHigh,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2Exp");
+ //
+ // bck->SetParameters(1,0,0,0);
+
+ SetFitRejectRange(2.3,4.0);
+
+ p->Fit(bck,"SER","",fitRangeLow,fitRangeHigh);
+
+ SetFitRejectRange();
+
+
+
+ TF1* fitMeanpt = new TF1("fitMeanpt",this,&AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2CB2VWGPOL2EXP,fitRangeLow,fitRangeHigh,18,"AliAnalysisMuMuJpsiResult","FitFunctionMeanPtS2CB2VWGPOL2EXP");
+
+ fitMeanpt->SetParNames("kVWG","mVWG","sVWG1","sVWG2","kJPsi","mJPsi","sJPsi","alJPsi","nlJPsi","auJPsi","nuJPsi");
+ fitMeanpt->SetParName(11,"kPsiP");
+ fitMeanpt->SetParName(12,"<pt>JPsi");
+ fitMeanpt->SetParName(13,"<pt>BG0");
+ fitMeanpt->SetParName(14,"<pt>BG1");
+ fitMeanpt->SetParName(15,"<pt>BG2");
+ fitMeanpt->SetParName(16,"<pt>BGEXP");
+ fitMeanpt->SetParName(17,"<pt>PsiP");
+
+ fitMeanpt->FixParameter(0,kVWG);
+ fitMeanpt->FixParameter(1,mVWG);
+ fitMeanpt->FixParameter(2,sVWG1);
+ fitMeanpt->FixParameter(3,sVWG2);
+ fitMeanpt->FixParameter(4,kJPsi);
+ fitMeanpt->FixParameter(5,mJPsi);
+ fitMeanpt->FixParameter(6,sJPsi);
+ fitMeanpt->FixParameter(7,alphaLow);
+ fitMeanpt->FixParameter(8,nLow);
+ fitMeanpt->FixParameter(9,alphaUp);
+ fitMeanpt->FixParameter(10,nUp);
+ fitMeanpt->FixParameter(11,kPsiP);
+
+ fitMeanpt->SetParameter(12, 3.);
+ fitMeanpt->SetParLimits(12, 1.0,5.);
+
+ for ( Int_t i = 0; i < 4; ++i )
+ {
+ fitMeanpt->SetParameter(i + 13, bck->GetParameter(i));
+ }
+
+ // fitMeanpt->SetParameter(13, 3.);
+ // fitMeanpt->SetParLimits(13, 0.5,10.);
+ //
+ // fitMeanpt->SetParameter(14, 0.2);
+ // // fitMeanpt->SetParLimits(14, 0.1,0.2);
+ //
+ // fitMeanpt->SetParameter(15, 0.1);
+ // // fitMeanpt->SetParLimits(15, 0.,1.);
+
+ fitMeanpt->SetParameter(17, 3.);
+ Double_t psipPtLim = 10.;
+ fitMeanpt->SetParLimits(17, 0.,psipPtLim);
+
+
+ // TProfile::Approximate();
+
+ const char* fitOption = "SER"; //+";//SER
+
+ TFitResultPtr fitResult = p->Fit(fitMeanpt,fitOption,"");
+
+ std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
+
+ if ( static_cast<int>(fitResult) )
+ {
+ for ( Int_t i = 0; i < 4; ++i )
+ {
+ fitMeanpt->SetParameter(i + 13, bck->GetParameter(i)*0.9);
+ }
+ fitResult = p->Fit(fitMeanpt,fitOption,"");
+
+ std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
+ }
+ else if ( fitMeanpt->GetParameter(17) <= fitMeanpt->GetParError(17) || fitMeanpt->GetParError(17) >= 0.75*fitMeanpt->GetParameter(17) || (fitMeanpt->GetParameter(17)/psipPtLim > 0.9) )
+ {
+ fitMeanpt->FixParameter(17, bck->Eval(3.68));
+ for ( Int_t i = 0; i < 4; ++i )
+ {
+ fitMeanpt->SetParameter(i + 13, bck->GetParameter(i)*0.6);
+ }
+ fitResult = p->Fit(fitMeanpt,fitOption,"");
+
+ std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
+ }
+
+ if ( fitMeanpt->GetParameter(13) <= fitMeanpt->GetParError(13) || fitMeanpt->GetParError(13) >= 0.75*fitMeanpt->GetParameter(13) )
+ {
+ fitMeanpt->SetParameter(13, 2.);
+
+ fitResult = p->Fit(fitMeanpt,fitOption,"");
+
+ std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
+ }
+
+ // TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
+
+ bck->SetParameters(fitMeanpt->GetParameter(13),fitMeanpt->GetParameter(14),fitMeanpt->GetParameter(15),fitMeanpt->GetParameter(16));
+
+ AttachFunctionsToHisto(0x0,bck,fitMeanpt,fitRangeLow,fitRangeHigh);//
+
+ Set("NofJPsi",NofJPsi,ErrStatNofJPsi);
+ Set("MeanPtJPsi",fitMeanpt->GetParameter(12),fitMeanpt->GetParError(12));
+ Set("MeanPtPsiP",fitMeanpt->GetParameter(17),fitMeanpt->GetParError(17));
+
+}
+
+//_____________________________________________________________________________
+void AliAnalysisMuMuJpsiResult::FitMPTPSIPSIPRIMECB2POL2EXP_BKGMPTPOL2()
+{
+ //Fit mean dimuon mean pt to get Jpsi mean pt using the CB2 signal parameters, VWG for the Bkg, Jpsi mpt = cte and Bkg mpt = pol2
+ fHisto->GetListOfFunctions()->Delete();
+
+ Double_t alphaLow = GetValue("alJPsi");
+ Double_t nLow = GetValue("nlJPsi");
+ Double_t alphaUp = GetValue("auJPsi");
+ Double_t nUp = GetValue("nuJPsi");
+
+ Double_t pol0 = GetValue("pol0");
+ Double_t pol1 = GetValue("pol1");
+ Double_t pol2 = GetValue("pol2");
+ Double_t exp = GetValue("exp");
+ Double_t kJPsi = GetValue("kJPsi");
+ Double_t kPsiP = GetValue("kPsiP");
+ Double_t mJPsi = GetValue("mJPsi");
+ Double_t sJPsi = GetValue("sJPsi");
+ Double_t NofJPsi = GetValue("NofJPsi");
+ Double_t ErrStatNofJPsi = GetErrorStat("NofJPsi");
+
+ Double_t fitRangeLow = GetValue(kFitRangeLow);
+ Double_t fitRangeHigh = GetValue(kFitRangeHigh);
+
+ // TString msg;
+ //
+ // if (IsValidValue(alphaLow)) msg += TString::Format("alphaLow=%e ",alphaLow);
+ // if (IsValidValue(nLow)) msg += TString::Format("nLow=%e ",nLow);
+ // if (IsValidValue(alphaUp)) msg += TString::Format("alphaUp=%e ",alphaUp);
+ // if (IsValidValue(nUp)) msg += TString::Format("nUp=%e ",nUp);
+ //
+ // AliDebug(1,Form("Mean pt fit with jpsi + psiprime (CB2),Bkg VWG and Pol2 for Bkg <pt> %s",msg.Data()));
+ //
+ // TF1* fitTotal = new TF1("signal+bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2VWG,fitRangeLow,fitRangeHigh,17,"AliAnalysisMuMuJpsiResult","FitFunctionTotalTwoCB2VWG");
+ //
+ //TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
+
+
+ // TString resultName(Form("MEANPTFIT_%salphalow=%5.2fnlow=%5.2falphaup=%5.2fnup=%5.2f",fitName.Data(),par[7],par[8],par[9],par[10]));
+ TProfile* p(0x0);
+ if ( fHisto->IsA() == TProfile::Class() ) p = static_cast<TProfile*>(fHisto);
+ else
+ {
+ AliError("Mean pt histo has to be a TProfile");
+ return;
+ }
+
+ //_____________
+ Int_t minBin = p->FindBin(fitRangeLow);
+ Int_t maxBin = p->FindBin(fitRangeHigh);
+
+ for ( Int_t i = minBin ; i <= maxBin ; i++ )
+ {
+ if ( p->GetBinEffectiveEntries(i) < 10 )
+ {
+ Double_t effEntries(0.),sumErr(0.);
+ for ( Int_t j = i - 5 ; j < i ; j++ )
+ {
+ if ( j <= 0 ) continue;
+ // if ( j > p->GetNbinsX() ) break;
+
+ effEntries += p->GetBinEffectiveEntries(j);
+ sumErr += p->GetBinEffectiveEntries(j)*p->GetBinError(j);
+ }
+
+ Double_t meanErr = sumErr/effEntries;
+
+ if ( p->GetBinError(i) < meanErr/2. )
+ {
+ std::cout << "Resetting bin " << i << " error" <<std::endl;
+ p->SetBinError(i,meanErr);
+ }
+ }
+ }
+ //_____________
+
+ TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
+
+ bck->SetParameters(3.,1.,0.);
+
+ bck->SetParLimits(0, 1.,8.0);
+ // TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2Exp,fitRangeLow,fitRangeHigh,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2Exp");
+ //
+ // bck->SetParameters(1,0,0,0);
+
+ SetFitRejectRange(2.3,4.0);
+
+ p->Fit(bck,"SER","",fitRangeLow,fitRangeHigh);
+
+ SetFitRejectRange();
+
+
+ TF1* fitMeanpt = new TF1("fitMeanpt",this,&AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2CB2POL2EXPPOL2,fitRangeLow,fitRangeHigh,17,"AliAnalysisMuMuJpsiResult","FitFunctionMeanPtS2CB2POL2EXPPOL2");
+
+ fitMeanpt->SetParNames("pol0","pol1","pol2","exp","kJPsi","mJPsi","sJPsi","alJPsi","nlJPsi","auJPsi","nuJPsi");
+ fitMeanpt->SetParName(11,"kPsiP");
+ fitMeanpt->SetParName(12,"<pt>JPsi");
+ fitMeanpt->SetParName(13,"<pt>BG0");
+ fitMeanpt->SetParName(14,"<pt>BG1");
+ fitMeanpt->SetParName(15,"<pt>BG2");
+ fitMeanpt->SetParName(16,"<pt>PsiP");
+
+ fitMeanpt->FixParameter(0,pol0);
+ fitMeanpt->FixParameter(1,pol1);
+ fitMeanpt->FixParameter(2,pol2);
+ fitMeanpt->FixParameter(3,exp);
+ fitMeanpt->FixParameter(4,kJPsi);
+ fitMeanpt->FixParameter(5,mJPsi);
+ fitMeanpt->FixParameter(6,sJPsi);
+ fitMeanpt->FixParameter(7,alphaLow);
+ fitMeanpt->FixParameter(8,nLow);
+ fitMeanpt->FixParameter(9,alphaUp);
+ fitMeanpt->FixParameter(10,nUp);
+ fitMeanpt->FixParameter(11,kPsiP);
+
+ fitMeanpt->SetParameter(12, 3.);
+ fitMeanpt->SetParLimits(12, 1.0,5.);
+
+ for ( Int_t i = 0; i < 3; ++i )
+ {
+ fitMeanpt->SetParameter(i + 13, bck->GetParameter(i));
+ }
+
+ // fitMeanpt->SetParameter(13, 3.);
+ // fitMeanpt->SetParLimits(13, 0.5,10.);
+ //
+ // fitMeanpt->SetParameter(14, 0.2);
+ // // fitMeanpt->SetParLimits(14, 0.1,0.2);
+ //
+ // fitMeanpt->SetParameter(15, 0.1);
+ // // fitMeanpt->SetParLimits(15, 0.,1.);
+
+ fitMeanpt->SetParameter(16, 3.);
+ Double_t psipPtLim = 10.;
+ fitMeanpt->SetParLimits(16, 0.,psipPtLim);
+
+
+ // TProfile::Approximate();
+
+ const char* fitOption = "SER"; //+";//SER
+
+ TFitResultPtr fitResult = p->Fit(fitMeanpt,fitOption,"");
+
+ std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
+
+ if ( static_cast<int>(fitResult) )
+ {
+ for ( Int_t i = 0; i < 3; ++i )
+ {
+ fitMeanpt->SetParameter(i + 13, bck->GetParameter(i)*0.9);
+ }
+ fitResult = p->Fit(fitMeanpt,fitOption,"");
+
+ std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
+ }
+ else if ( fitMeanpt->GetParameter(16) <= fitMeanpt->GetParError(16) || fitMeanpt->GetParError(16) >= 0.75*fitMeanpt->GetParameter(16) || (fitMeanpt->GetParameter(16)/psipPtLim > 0.9) )
+ {
+ fitMeanpt->FixParameter(16, bck->Eval(3.68));
+ for ( Int_t i = 0; i < 3; ++i )
+ {
+ fitMeanpt->SetParameter(i + 13, bck->GetParameter(i)*0.6);
+ }
+ fitResult = p->Fit(fitMeanpt,fitOption,"");
+
+ std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
+ }
+
+ // TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
+
+ bck->SetParameters(fitMeanpt->GetParameter(13),fitMeanpt->GetParameter(14),fitMeanpt->GetParameter(15));
+
+ AttachFunctionsToHisto(0x0,bck,fitMeanpt,fitRangeLow,fitRangeHigh);//
+
+ Set("NofJPsi",NofJPsi,ErrStatNofJPsi);
+ Set("MeanPtJPsi",fitMeanpt->GetParameter(12),fitMeanpt->GetParError(12));
+ Set("MeanPtPsiP",fitMeanpt->GetParameter(16),fitMeanpt->GetParError(16));
+
+}
+
+//_____________________________________________________________________________
+void AliAnalysisMuMuJpsiResult::FitMPTPSIPSIPRIMECB2POL2EXP_BKGMPTPOL2EXP()
+{
+ //Fit mean dimuon mean pt to get Jpsi mean pt using the CB2 signal parameters, VWG for the Bkg, Jpsi mpt = cte and Bkg mpt = pol2
+ fHisto->GetListOfFunctions()->Delete();
+
+ Double_t alphaLow = GetValue("alJPsi");
+ Double_t nLow = GetValue("nlJPsi");
+ Double_t alphaUp = GetValue("auJPsi");
+ Double_t nUp = GetValue("nuJPsi");
+
+ Double_t pol0 = GetValue("pol0");
+ Double_t pol1 = GetValue("pol1");
+ Double_t pol2 = GetValue("pol2");
+ Double_t exp = GetValue("exp");
+ Double_t kJPsi = GetValue("kJPsi");
+ Double_t kPsiP = GetValue("kPsiP");
+ Double_t mJPsi = GetValue("mJPsi");
+ Double_t sJPsi = GetValue("sJPsi");
+ Double_t NofJPsi = GetValue("NofJPsi");
+ Double_t ErrStatNofJPsi = GetErrorStat("NofJPsi");
+
+ Double_t fitRangeLow = GetValue(kFitRangeLow);
+ Double_t fitRangeHigh = GetValue(kFitRangeHigh);
+
+ // TString msg;
+ //
+ // if (IsValidValue(alphaLow)) msg += TString::Format("alphaLow=%e ",alphaLow);
+ // if (IsValidValue(nLow)) msg += TString::Format("nLow=%e ",nLow);
+ // if (IsValidValue(alphaUp)) msg += TString::Format("alphaUp=%e ",alphaUp);
+ // if (IsValidValue(nUp)) msg += TString::Format("nUp=%e ",nUp);
+ //
+ // AliDebug(1,Form("Mean pt fit with jpsi + psiprime (CB2),Bkg VWG and Pol2 for Bkg <pt> %s",msg.Data()));
+ //
+ // TF1* fitTotal = new TF1("signal+bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2VWG,fitRangeLow,fitRangeHigh,17,"AliAnalysisMuMuJpsiResult","FitFunctionTotalTwoCB2VWG");
+ //
+ //TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
+
+
+ // TString resultName(Form("MEANPTFIT_%salphalow=%5.2fnlow=%5.2falphaup=%5.2fnup=%5.2f",fitName.Data(),par[7],par[8],par[9],par[10]));
+ TProfile* p(0x0);
+ if ( fHisto->IsA() == TProfile::Class() ) p = static_cast<TProfile*>(fHisto);
+ else
+ {
+ AliError("Mean pt histo has to be a TProfile");
+ return;
+ }
+
+ //_____________
+ Int_t minBin = p->FindBin(fitRangeLow);
+ Int_t maxBin = p->FindBin(fitRangeHigh);
+
+ for ( Int_t i = minBin ; i <= maxBin ; i++ )
+ {
+ if ( p->GetBinEffectiveEntries(i) < 10 )
+ {
+ Double_t effEntries(0.),sumErr(0.);
+ for ( Int_t j = i - 5 ; j < i ; j++ )
+ {
+ if ( j <= 0 ) continue;
+ // if ( j > p->GetNbinsX() ) break;
+
+ effEntries += p->GetBinEffectiveEntries(j);
+ sumErr += p->GetBinEffectiveEntries(j)*p->GetBinError(j);
+ }
+
+ Double_t meanErr = sumErr/effEntries;
+
+ if ( p->GetBinError(i) < meanErr/2. )
+ {
+ std::cout << "Resetting bin " << i << " error" <<std::endl;
+ p->SetBinError(i,meanErr);
+ }
+ }
+ }
+ //_____________
+
+ TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2Exp,fitRangeLow,fitRangeHigh,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2Exp");
+
+ bck->SetParameters(3.,-1.,0.4,-0.1);
+
+ bck->SetParLimits(0, 1.,10.0);
+ // TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2Exp,fitRangeLow,fitRangeHigh,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2Exp");
+ //
+ // bck->SetParameters(1,0,0,0);
+
+ SetFitRejectRange(2.3,4.0);
+
+ p->Fit(bck,"SER","",fitRangeLow,fitRangeHigh);
+
+ SetFitRejectRange();
+
+
+ TF1* fitMeanpt = new TF1("fitMeanpt",this,&AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2CB2POL2EXPPOL2EXP,fitRangeLow,fitRangeHigh,18,"AliAnalysisMuMuJpsiResult","FitFunctionMeanPtS2CB2POL2EXPPOL2EXP");
+
+ fitMeanpt->SetParNames("pol0","pol1","pol2","exp","kJPsi","mJPsi","sJPsi","alJPsi","nlJPsi","auJPsi","nuJPsi");
+ fitMeanpt->SetParName(11,"kPsiP");
+ fitMeanpt->SetParName(12,"<pt>JPsi");
+ fitMeanpt->SetParName(13,"<pt>BG0");
+ fitMeanpt->SetParName(14,"<pt>BG1");
+ fitMeanpt->SetParName(15,"<pt>BG2");
+ fitMeanpt->SetParName(16,"<pt>BGEXP");
+ fitMeanpt->SetParName(17,"<pt>PsiP");
+
+ fitMeanpt->FixParameter(0,pol0);
+ fitMeanpt->FixParameter(1,pol1);
+ fitMeanpt->FixParameter(2,pol2);
+ fitMeanpt->FixParameter(3,exp);
+ fitMeanpt->FixParameter(4,kJPsi);
+ fitMeanpt->FixParameter(5,mJPsi);
+ fitMeanpt->FixParameter(6,sJPsi);
+ fitMeanpt->FixParameter(7,alphaLow);
+ fitMeanpt->FixParameter(8,nLow);
+ fitMeanpt->FixParameter(9,alphaUp);
+ fitMeanpt->FixParameter(10,nUp);
+ fitMeanpt->FixParameter(11,kPsiP);
+
+ fitMeanpt->SetParameter(12, 3.);
+ fitMeanpt->SetParLimits(12, 1.0,5.);
+
+ for ( Int_t i = 0; i < 4; ++i )
+ {
+ fitMeanpt->SetParameter(i + 13, bck->GetParameter(i));
+ }
+
+ // fitMeanpt->SetParameter(13, 3.);
+ // fitMeanpt->SetParLimits(13, 0.5,10.);
+ //
+ // fitMeanpt->SetParameter(14, 0.2);
+ // // fitMeanpt->SetParLimits(14, 0.1,0.2);
+ //
+ // fitMeanpt->SetParameter(15, 0.1);
+ // // fitMeanpt->SetParLimits(15, 0.,1.);
+
+ fitMeanpt->SetParameter(17, 3.);
+ Double_t psipPtLim = 10.;
+ fitMeanpt->SetParLimits(17, 0.,psipPtLim);
+
+
+ // TProfile::Approximate();
+
+ const char* fitOption = "SER"; //+";//SER
+
+ TFitResultPtr fitResult = p->Fit(fitMeanpt,fitOption,"");
+
+ std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
+
+ if ( static_cast<int>(fitResult) )
+ {
+ for ( Int_t i = 0; i < 4; ++i )
+ {
+ fitMeanpt->SetParameter(i + 13, bck->GetParameter(i)*0.9);
+ }
+ fitResult = p->Fit(fitMeanpt,fitOption,"");
+
+ std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
+ }
+ else if ( fitMeanpt->GetParameter(17) <= fitMeanpt->GetParError(17) || fitMeanpt->GetParError(17) >= 0.75*fitMeanpt->GetParameter(17) || (fitMeanpt->GetParameter(17)/psipPtLim > 0.9) )
+ {
+ fitMeanpt->FixParameter(17, bck->Eval(3.68));
+ for ( Int_t i = 0; i < 4; ++i )
+ {
+ fitMeanpt->SetParameter(i + 13, bck->GetParameter(i)*0.6);
+ }
+ fitResult = p->Fit(fitMeanpt,fitOption,"");
+
+ std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
+ }
+ if ( fitMeanpt->GetParameter(13) <= fitMeanpt->GetParError(13) || fitMeanpt->GetParError(13) >= 0.75*fitMeanpt->GetParameter(13) )
+ {
+ fitMeanpt->SetParameter(13, 2.);
+
+ fitResult = p->Fit(fitMeanpt,fitOption,"");
+
+ std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
+ }
+
+ // TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
+
+ bck->SetParameters(fitMeanpt->GetParameter(13),fitMeanpt->GetParameter(14),fitMeanpt->GetParameter(15),fitMeanpt->GetParameter(16));
+
+ AttachFunctionsToHisto(0x0,bck,fitMeanpt,fitRangeLow,fitRangeHigh);//
+
+ Set("NofJPsi",NofJPsi,ErrStatNofJPsi);
+ Set("MeanPtJPsi",fitMeanpt->GetParameter(12),fitMeanpt->GetParError(12));
+ Set("MeanPtPsiP",fitMeanpt->GetParameter(17),fitMeanpt->GetParError(17));
+
+}
+
+//_____________________________________________________________________________
+void AliAnalysisMuMuJpsiResult::FitMPTPSIPSIPRIMENA60NEWVWG_BKGMPTPOL2()
+{
+ //Fit mean dimuon mean pt to get Jpsi mean pt using the CB2 signal parameters, VWG for the Bkg, Jpsi mpt = cte and Bkg mpt = pol2
+ fHisto->GetListOfFunctions()->Delete();
+
+ Double_t p1Left = GetValue("p1LJPsi");
+ Double_t p2Left = GetValue("p2LJPsi");
+ Double_t p3Left = GetValue("p3LJPsi");
+ Double_t p1Right = GetValue("p1RJPsi");
+ Double_t p2Right = GetValue("p2RJPsi");
+ Double_t p3Right = GetValue("p3RJPsi");
+
+ Double_t alphaLeft = GetValue("aLJPsi");
+ Double_t alphaRight = GetValue("aRJPsi");
+
+ Double_t kVWG = GetValue("kVWG");
+ Double_t mVWG = GetValue("mVWG");
+ Double_t sVWG1 = GetValue("sVWG1");
+ Double_t sVWG2 = GetValue("sVWG2");
+ Double_t kJPsi = GetValue("kJPsi");
+ Double_t kPsiP = GetValue("kPsiP");
+ Double_t mJPsi = GetValue("mJPsi");
+ Double_t sJPsi = GetValue("sJPsi");
+ Double_t NofJPsi = GetValue("NofJPsi");
+ Double_t ErrStatNofJPsi = GetErrorStat("NofJPsi");
+
+ Double_t fitRangeLow = GetValue(kFitRangeLow);
+ Double_t fitRangeHigh = GetValue(kFitRangeHigh);
+
+ // TString msg;
+ //
+ // if (IsValidValue(alphaLow)) msg += TString::Format("alphaLow=%e ",alphaLow);
+ // if (IsValidValue(nLow)) msg += TString::Format("nLow=%e ",nLow);
+ // if (IsValidValue(alphaUp)) msg += TString::Format("alphaUp=%e ",alphaUp);
+ // if (IsValidValue(nUp)) msg += TString::Format("nUp=%e ",nUp);
+ //
+ // AliDebug(1,Form("Mean pt fit with jpsi + psiprime (CB2),Bkg VWG and Pol2 for Bkg <pt> %s",msg.Data()));
+ //
+ // TF1* fitTotal = new TF1("signal+bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2VWG,fitRangeLow,fitRangeHigh,17,"AliAnalysisMuMuJpsiResult","FitFunctionTotalTwoCB2VWG");
+ //
+ //TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
+
+
+ // TString resultName(Form("MEANPTFIT_%salphalow=%5.2fnlow=%5.2falphaup=%5.2fnup=%5.2f",fitName.Data(),par[7],par[8],par[9],par[10]));
+ TProfile* p(0x0);
+ if ( fHisto->IsA() == TProfile::Class() ) p = static_cast<TProfile*>(fHisto);
+ else
+ {
+ AliError("Mean pt histo has to be a TProfile");
+ return;
+ }
+
+ //_____________
+ Int_t minBin = p->FindBin(fitRangeLow);
+ Int_t maxBin = p->FindBin(fitRangeHigh);
+
+ for ( Int_t i = minBin ; i <= maxBin ; i++ )
+ {
+ if ( p->GetBinEffectiveEntries(i) < 10 )
+ {
+ Double_t effEntries(0.),sumErr(0.);
+ for ( Int_t j = i - 5 ; j < i ; j++ )
+ {
+ if ( j <= 0 ) continue;
+ // if ( j > p->GetNbinsX() ) break;
+
+ effEntries += p->GetBinEffectiveEntries(j);
+ sumErr += p->GetBinEffectiveEntries(j)*p->GetBinError(j);
+ }
+
+ Double_t meanErr = sumErr/effEntries;
+
+ if ( p->GetBinError(i) < meanErr/2. )
+ {
+ std::cout << "Resetting bin " << i << " error" <<std::endl;
+ p->SetBinError(i,meanErr);
+ }
+ }
+ }
+ //_____________
+
+ TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
+
+ bck->SetParameters(3.,1.,0.);
+
+ bck->SetParLimits(0, 1.,8.0);
+ // TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2Exp,fitRangeLow,fitRangeHigh,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2Exp");
+ //
+ // bck->SetParameters(1,0,0,0);
+
+ SetFitRejectRange(2.3,4.0);
+
+ p->Fit(bck,"SER","",fitRangeLow,fitRangeHigh);
+
+ SetFitRejectRange();
+
+
+
+ TF1* fitMeanpt = new TF1("fitMeanpt",this,&AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2NA60NEWVWGPOL2,fitRangeLow,fitRangeHigh,21,"AliAnalysisMuMuJpsiResult","FitFunctionMeanPtS2NA60NEWVWGPOL2");
+
+ fitMeanpt->SetParNames("kVWG","mVWG","sVWG1","sVWG2","kJPsi","mJPsi","sJPsi","p1LJPsi","p2LJPsi","p3LJPsi","p1RJPsi");
+ fitMeanpt->SetParName(11,"p2RJPsi");
+ fitMeanpt->SetParName(12,"p3RJPsi");
+ fitMeanpt->SetParName(13,"aLJPsi");
+ fitMeanpt->SetParName(14,"aRJPsi");
+ fitMeanpt->SetParName(15,"kPsiP");
+ fitMeanpt->SetParName(16,"<pt>JPsi");
+ fitMeanpt->SetParName(17,"<pt>BG0");
+ fitMeanpt->SetParName(18,"<pt>BG1");
+ fitMeanpt->SetParName(19,"<pt>BG2");
+ fitMeanpt->SetParName(20,"<pt>PsiP");
+
+ fitMeanpt->FixParameter(0,kVWG);
+ fitMeanpt->FixParameter(1,mVWG);
+ fitMeanpt->FixParameter(2,sVWG1);
+ fitMeanpt->FixParameter(3,sVWG2);
+ fitMeanpt->FixParameter(4,kJPsi);
+ fitMeanpt->FixParameter(5,mJPsi);
+ fitMeanpt->FixParameter(6,sJPsi);
+ fitMeanpt->FixParameter(7,p1Left);
+ fitMeanpt->FixParameter(8,p2Left);
+ fitMeanpt->FixParameter(9,p3Left);
+ fitMeanpt->FixParameter(10,p1Right);
+ fitMeanpt->FixParameter(11,p2Right);
+ fitMeanpt->FixParameter(12,p3Right);
+ fitMeanpt->FixParameter(13,alphaLeft);
+ fitMeanpt->FixParameter(14,alphaRight);
+ fitMeanpt->FixParameter(15,kPsiP);
+
+ fitMeanpt->SetParameter(16, 3.);
+ fitMeanpt->SetParLimits(16, 1.0,5.);
+
+
+ for ( Int_t i = 0; i < 3; ++i )
+ {
+// TString name(GetName());
+// if (name.Contains("NA60NEWVWG_BKGMPTPOL2_2.0_5.0(Sig:2.2_4.7_SP0.9)") || name.Contains("NA60NEWVWG_BKGMPTPOL2_2.2_4.7(Sig:2.2_4.7_SP0.9)") )
+// {
+// fitMeanpt->SetParameter(i + 17, bck->GetParameter(i)/2.);
+// fitMeanpt->SetParameter(16, 4.);
+//// if (fitMeanpt->GetParameter(3) < 2.e-06) fitMeanpt->FixParameter(3,3e-6);
+//
+// }
+// else
+ fitMeanpt->SetParameter(i + 17, bck->GetParameter(i));
+ }
+
+ // fitMeanpt->SetParameter(13, 3.);
+ // fitMeanpt->SetParLimits(13, 0.5,10.);
+ //
+ // fitMeanpt->SetParameter(14, 0.2);
+ // // fitMeanpt->SetParLimits(14, 0.1,0.2);
+ //
+ // fitMeanpt->SetParameter(15, 0.1);
+ // // fitMeanpt->SetParLimits(15, 0.,1.);
+
+ fitMeanpt->SetParameter(20, 3.);
+ Double_t psipPtLim = 10.;
+ fitMeanpt->SetParLimits(20, 0.,psipPtLim);
+
+
+ // TProfile::Approximate();
+
+ const char* fitOption = "SER"; //+";//SER
+
+ TFitResultPtr fitResult = p->Fit(fitMeanpt,fitOption,"");
+
+ std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
+
+ if ( static_cast<int>(fitResult) )
+ {
+ for ( Int_t i = 0; i < 3; ++i )
+ {
+ fitMeanpt->SetParameter(i + 17, bck->GetParameter(i)*0.9);
+ }
+ fitResult = p->Fit(fitMeanpt,fitOption,"");
+
+ std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
+ }
+ else if ( fitMeanpt->GetParameter(20) <= fitMeanpt->GetParError(20) || fitMeanpt->GetParError(20) >= 0.75*fitMeanpt->GetParameter(20) || (fitMeanpt->GetParameter(20)/psipPtLim > 0.9) )
+ {
+ fitMeanpt->FixParameter(20, bck->Eval(3.68));
+ for ( Int_t i = 0; i < 3; ++i )
+ {
+ fitMeanpt->SetParameter(i + 17, bck->GetParameter(i)*0.6);
+ }
+ fitResult = p->Fit(fitMeanpt,fitOption,"");
+
+ std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
+ }
+
+ // TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
+
+ bck->SetParameters(fitMeanpt->GetParameter(17),fitMeanpt->GetParameter(18),fitMeanpt->GetParameter(19));
+
+ AttachFunctionsToHisto(0x0,bck,fitMeanpt,fitRangeLow,fitRangeHigh);//
+
+ Set("NofJPsi",NofJPsi,ErrStatNofJPsi);
+ Set("MeanPtJPsi",fitMeanpt->GetParameter(16),fitMeanpt->GetParError(16));
+ Set("MeanPtPsiP",fitMeanpt->GetParameter(20),fitMeanpt->GetParError(20));
+
+}
+
+//_____________________________________________________________________________
+void AliAnalysisMuMuJpsiResult::FitMPTPSIPSIPRIMENA60NEWVWG_BKGMPTPOL2EXP()
+{
+ //Fit mean dimuon mean pt to get Jpsi mean pt using the CB2 signal parameters, VWG for the Bkg, Jpsi mpt = cte and Bkg mpt = pol2
+ fHisto->GetListOfFunctions()->Delete();
+
+ Double_t p1Left = GetValue("p1LJPsi");
+ Double_t p2Left = GetValue("p2LJPsi");
+ Double_t p3Left = GetValue("p3LJPsi");
+ Double_t p1Right = GetValue("p1RJPsi");
+ Double_t p2Right = GetValue("p2RJPsi");
+ Double_t p3Right = GetValue("p3RJPsi");
+
+ Double_t alphaLeft = GetValue("aLJPsi");
+ Double_t alphaRight = GetValue("aRJPsi");
+
+ Double_t kVWG = GetValue("kVWG");
+ Double_t mVWG = GetValue("mVWG");
+ Double_t sVWG1 = GetValue("sVWG1");
+ Double_t sVWG2 = GetValue("sVWG2");
+ Double_t kJPsi = GetValue("kJPsi");
+ Double_t kPsiP = GetValue("kPsiP");
+ Double_t mJPsi = GetValue("mJPsi");
+ Double_t sJPsi = GetValue("sJPsi");
+ Double_t NofJPsi = GetValue("NofJPsi");
+ Double_t ErrStatNofJPsi = GetErrorStat("NofJPsi");
+
+ Double_t fitRangeLow = GetValue(kFitRangeLow);
+ Double_t fitRangeHigh = GetValue(kFitRangeHigh);
+
+ // TString msg;
+ //
+ // if (IsValidValue(alphaLow)) msg += TString::Format("alphaLow=%e ",alphaLow);
+ // if (IsValidValue(nLow)) msg += TString::Format("nLow=%e ",nLow);
+ // if (IsValidValue(alphaUp)) msg += TString::Format("alphaUp=%e ",alphaUp);
+ // if (IsValidValue(nUp)) msg += TString::Format("nUp=%e ",nUp);
+ //
+ // AliDebug(1,Form("Mean pt fit with jpsi + psiprime (CB2),Bkg VWG and Pol2 for Bkg <pt> %s",msg.Data()));
+ //
+ // TF1* fitTotal = new TF1("signal+bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2VWG,fitRangeLow,fitRangeHigh,17,"AliAnalysisMuMuJpsiResult","FitFunctionTotalTwoCB2VWG");
+ //
+ //TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
+
+
+ // TString resultName(Form("MEANPTFIT_%salphalow=%5.2fnlow=%5.2falphaup=%5.2fnup=%5.2f",fitName.Data(),par[7],par[8],par[9],par[10]));
+ TProfile* p(0x0);
+ if ( fHisto->IsA() == TProfile::Class() ) p = static_cast<TProfile*>(fHisto);
+ else
+ {
+ AliError("Mean pt histo has to be a TProfile");
+ return;
+ }
+
+ //_____________
+ Int_t minBin = p->FindBin(fitRangeLow);
+ Int_t maxBin = p->FindBin(fitRangeHigh);
+
+ for ( Int_t i = minBin ; i <= maxBin ; i++ )
+ {
+ if ( p->GetBinEffectiveEntries(i) < 10 )
+ {
+ Double_t effEntries(0.),sumErr(0.);
+ for ( Int_t j = i - 5 ; j < i ; j++ )
+ {
+ if ( j <= 0 ) continue;
+ // if ( j > p->GetNbinsX() ) break;
+
+ effEntries += p->GetBinEffectiveEntries(j);
+ sumErr += p->GetBinEffectiveEntries(j)*p->GetBinError(j);
+ }
+
+ Double_t meanErr = sumErr/effEntries;
+
+ if ( p->GetBinError(i) < meanErr/2. )
+ {
+ std::cout << "Resetting bin " << i << " error" <<std::endl;
+ p->SetBinError(i,meanErr);
+ }
+ }
+ }
+ //_____________
+
+ TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2Exp,fitRangeLow,fitRangeHigh,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2Exp");
+
+ bck->SetParameters(2.5,-1.,0.2,-0.05);
+
+ bck->SetParLimits(0, 1.,10.0);
+ // TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2Exp,fitRangeLow,fitRangeHigh,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2Exp");
+ //
+ // bck->SetParameters(1,0,0,0);
+
+ SetFitRejectRange(2.3,4.0);
+
+ p->Fit(bck,"SER","",fitRangeLow,fitRangeHigh);
+
+ SetFitRejectRange();
+
+ TF1* fitMeanpt = new TF1("fitMeanpt",this,&AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2NA60NEWVWGPOL2EXP,fitRangeLow,fitRangeHigh,22,"AliAnalysisMuMuJpsiResult","FitFunctionMeanPtS2NA60NEWVWGPOL2EXP");
+
+ fitMeanpt->SetParNames("kVWG","mVWG","sVWG1","sVWG2","kJPsi","mJPsi","sJPsi","p1LJPsi","p2LJPsi","p3LJPsi","p1RJPsi");
+ fitMeanpt->SetParName(11,"p2RJPsi");
+ fitMeanpt->SetParName(12,"p3RJPsi");
+ fitMeanpt->SetParName(13,"aLJPsi");
+ fitMeanpt->SetParName(14,"aRJPsi");
+ fitMeanpt->SetParName(15,"kPsiP");
+ fitMeanpt->SetParName(16,"<pt>JPsi");
+ fitMeanpt->SetParName(17,"<pt>BG0");
+ fitMeanpt->SetParName(18,"<pt>BG1");
+ fitMeanpt->SetParName(19,"<pt>BG2");
+ fitMeanpt->SetParName(20,"<pt>BGEXP");
+ fitMeanpt->SetParName(21,"<pt>PsiP");
+
+ fitMeanpt->FixParameter(0,kVWG);
+ fitMeanpt->FixParameter(1,mVWG);
+ fitMeanpt->FixParameter(2,sVWG1);
+ fitMeanpt->FixParameter(3,sVWG2);
+ fitMeanpt->FixParameter(4,kJPsi);
+ fitMeanpt->FixParameter(5,mJPsi);
+ fitMeanpt->FixParameter(6,sJPsi);
+ fitMeanpt->FixParameter(7,p1Left);
+ fitMeanpt->FixParameter(8,p2Left);
+ fitMeanpt->FixParameter(9,p3Left);
+ fitMeanpt->FixParameter(10,p1Right);
+ fitMeanpt->FixParameter(11,p2Right);
+ fitMeanpt->FixParameter(12,p3Right);
+ fitMeanpt->FixParameter(13,alphaLeft);
+ fitMeanpt->FixParameter(14,alphaRight);
+ fitMeanpt->FixParameter(15,kPsiP);
+
+ fitMeanpt->SetParameter(16, 3.);
+ fitMeanpt->SetParLimits(16, 1.0,5.);
+
+ for ( Int_t i = 0; i < 4; ++i )
+ {
+// TString name(GetName());
+// if ( name.Contains("NA60NEWVWG_BKGMPTPOL2EXP_2.0_5.0(Sig:2.2_4.7_SP0.9)") ||name.Contains("NA60NEWVWG_BKGMPTPOL2EXP_2.2_4.7(Sig:2.2_4.7_SP0.9)") )
+// {
+// fitMeanpt->SetParameter(i + 17, bck->GetParameter(i)/2.);
+// fitMeanpt->SetParameter(16, 4.);
+//// if (fitMeanpt->GetParameter(3) < 2.e-06) fitMeanpt->FixParameter(3,3e-4);
+//
+// }
+// else
+ fitMeanpt->SetParameter(i + 17, bck->GetParameter(i));
+// fitMeanpt->SetParameter(i + 17, bck->GetParameter(i));
+ }
+
+ fitMeanpt->SetParameter(21, 3.);
+ Double_t psipPtLim = 10.;
+ fitMeanpt->SetParLimits(21, 0.,psipPtLim);
+
+
+ // TProfile::Approximate();
+
+ const char* fitOption = "SER"; //+";//SER
+
+ TFitResultPtr fitResult = p->Fit(fitMeanpt,fitOption,"");
+
+ std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
+
+ if ( static_cast<int>(fitResult) )
+ {
+ for ( Int_t i = 0; i < 4; ++i )
+ {
+ fitMeanpt->SetParameter(i + 17, bck->GetParameter(i)*0.9);
+ }
+ fitResult = p->Fit(fitMeanpt,fitOption,"");
+
+ std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
+ }
+ else if ( fitMeanpt->GetParameter(21) <= fitMeanpt->GetParError(21) || fitMeanpt->GetParError(21) >= 0.75*fitMeanpt->GetParameter(21) || (fitMeanpt->GetParameter(21)/psipPtLim > 0.9) )
+ {
+ fitMeanpt->FixParameter(21, bck->Eval(3.68));
+ for ( Int_t i = 0; i < 4; ++i )
+ {
+ fitMeanpt->SetParameter(i + 17, bck->GetParameter(i)*0.6);
+ }
+ fitResult = p->Fit(fitMeanpt,fitOption,"");
+
+ std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
+ }
+ if ( fitMeanpt->GetParameter(17) <= fitMeanpt->GetParError(17) || fitMeanpt->GetParError(17) >= 0.75*fitMeanpt->GetParameter(13) )
+ {
+ fitMeanpt->SetParameter(17, 2.);
+
+ fitResult = p->Fit(fitMeanpt,fitOption,"");
+
+ std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
+ }
+
+
+ // TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
+
+ bck->SetParameters(fitMeanpt->GetParameter(17),fitMeanpt->GetParameter(18),fitMeanpt->GetParameter(19),fitMeanpt->GetParameter(20));
+
+ AttachFunctionsToHisto(0x0,bck,fitMeanpt,fitRangeLow,fitRangeHigh);//
+
+ Set("NofJPsi",NofJPsi,ErrStatNofJPsi);
+ Set("MeanPtJPsi",fitMeanpt->GetParameter(16),fitMeanpt->GetParError(16));
+ Set("MeanPtPsiP",fitMeanpt->GetParameter(21),fitMeanpt->GetParError(21));
+
+}
+
+//_____________________________________________________________________________
+void AliAnalysisMuMuJpsiResult::FitMPTPSIPSIPRIMENA60NEWPOL2EXP_BKGMPTPOL2()
+{
+ //Fit mean dimuon mean pt to get Jpsi mean pt using the CB2 signal parameters, VWG for the Bkg, Jpsi mpt = cte and Bkg mpt = pol2
+ fHisto->GetListOfFunctions()->Delete();
+
+ Double_t p1Left = GetValue("p1LJPsi");
+ Double_t p2Left = GetValue("p2LJPsi");
+ Double_t p3Left = GetValue("p3LJPsi");
+ Double_t p1Right = GetValue("p1RJPsi");
+ Double_t p2Right = GetValue("p2RJPsi");
+ Double_t p3Right = GetValue("p3RJPsi");
+
+ Double_t alphaLeft = GetValue("aLJPsi");
+ Double_t alphaRight = GetValue("aRJPsi");
+
+ Double_t pol0 = GetValue("pol0");
+ Double_t pol1 = GetValue("pol1");
+ Double_t pol2 = GetValue("pol2");
+ Double_t exp = GetValue("exp");
+ Double_t kJPsi = GetValue("kJPsi");
+ Double_t kPsiP = GetValue("kPsiP");
+ Double_t mJPsi = GetValue("mJPsi");
+ Double_t sJPsi = GetValue("sJPsi");
+ Double_t NofJPsi = GetValue("NofJPsi");
+ Double_t ErrStatNofJPsi = GetErrorStat("NofJPsi");
+
+ Double_t fitRangeLow = GetValue(kFitRangeLow);
+ Double_t fitRangeHigh = GetValue(kFitRangeHigh);
+
+ // TString msg;
+ //
+ // if (IsValidValue(alphaLow)) msg += TString::Format("alphaLow=%e ",alphaLow);
+ // if (IsValidValue(nLow)) msg += TString::Format("nLow=%e ",nLow);
+ // if (IsValidValue(alphaUp)) msg += TString::Format("alphaUp=%e ",alphaUp);
+ // if (IsValidValue(nUp)) msg += TString::Format("nUp=%e ",nUp);
+ //
+ // AliDebug(1,Form("Mean pt fit with jpsi + psiprime (CB2),Bkg VWG and Pol2 for Bkg <pt> %s",msg.Data()));
+ //
+ // TF1* fitTotal = new TF1("signal+bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2VWG,fitRangeLow,fitRangeHigh,17,"AliAnalysisMuMuJpsiResult","FitFunctionTotalTwoCB2VWG");
+ //
+ //TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
+
+
+ // TString resultName(Form("MEANPTFIT_%salphalow=%5.2fnlow=%5.2falphaup=%5.2fnup=%5.2f",fitName.Data(),par[7],par[8],par[9],par[10]));
+ TProfile* p(0x0);
+ if ( fHisto->IsA() == TProfile::Class() ) p = static_cast<TProfile*>(fHisto);
+ else
+ {
+ AliError("Mean pt histo has to be a TProfile");
+ return;
+ }
+
+ //_____________
+ Int_t minBin = p->FindBin(fitRangeLow);
+ Int_t maxBin = p->FindBin(fitRangeHigh);
+
+ for ( Int_t i = minBin ; i <= maxBin ; i++ )
+ {
+ if ( p->GetBinEffectiveEntries(i) < 10 )
+ {
+ Double_t effEntries(0.),sumErr(0.);
+ for ( Int_t j = i - 5 ; j < i ; j++ )
+ {
+ if ( j <= 0 ) continue;
+ // if ( j > p->GetNbinsX() ) break;
+
+ effEntries += p->GetBinEffectiveEntries(j);
+ sumErr += p->GetBinEffectiveEntries(j)*p->GetBinError(j);
+ }
+
+ Double_t meanErr = sumErr/effEntries;
+
+ if ( p->GetBinError(i) < meanErr/2. )
+ {
+ std::cout << "Resetting bin " << i << " error" <<std::endl;
+ p->SetBinError(i,meanErr);
+ }
+ }
+ }
+ //_____________
+
+ TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
+
+ bck->SetParameters(3.,1.,0.);
+
+ bck->SetParLimits(0, 1.,8.0);
+ // TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2Exp,fitRangeLow,fitRangeHigh,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2Exp");
+ //
+ // bck->SetParameters(1,0,0,0);
+
+ SetFitRejectRange(2.3,4.0);
+
+ p->Fit(bck,"SER","",fitRangeLow,fitRangeHigh);
+
+ SetFitRejectRange();
+
+
+ TF1* fitMeanpt = new TF1("fitMeanpt",this,&AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2NA60NEWPOL2EXPPOL2,fitRangeLow,fitRangeHigh,21,"AliAnalysisMuMuJpsiResult","FitFunctionMeanPtS2NA60NEWPOL2EXPPOL2");
+
+ fitMeanpt->SetParNames("pol0","pol1","pol2","exp","kJPsi","mJPsi","sJPsi","p1LJPsi","p2LJPsi","p3LJPsi","p1RJPsi");
+ fitMeanpt->SetParName(11,"p2RJPsi");
+ fitMeanpt->SetParName(12,"p3RJPsi");
+ fitMeanpt->SetParName(13,"aLJPsi");
+ fitMeanpt->SetParName(14,"aRJPsi");
+ fitMeanpt->SetParName(15,"kPsiP");
+ fitMeanpt->SetParName(16,"<pt>JPsi");
+ fitMeanpt->SetParName(17,"<pt>BG0");
+ fitMeanpt->SetParName(18,"<pt>BG1");
+ fitMeanpt->SetParName(19,"<pt>BG2");
+ fitMeanpt->SetParName(20,"<pt>PsiP");
+
+ fitMeanpt->FixParameter(0,pol0);
+ fitMeanpt->FixParameter(1,pol1);
+ fitMeanpt->FixParameter(2,pol2);
+ fitMeanpt->FixParameter(3,exp);
+ fitMeanpt->FixParameter(4,kJPsi);
+ fitMeanpt->FixParameter(5,mJPsi);
+ fitMeanpt->FixParameter(6,sJPsi);
+ fitMeanpt->FixParameter(7,p1Left);
+ fitMeanpt->FixParameter(8,p2Left);
+ fitMeanpt->FixParameter(9,p3Left);
+ fitMeanpt->FixParameter(10,p1Right);
+ fitMeanpt->FixParameter(11,p2Right);
+ fitMeanpt->FixParameter(12,p3Right);
+ fitMeanpt->FixParameter(13,alphaLeft);
+ fitMeanpt->FixParameter(14,alphaRight);
+
+ fitMeanpt->FixParameter(15,kPsiP);
+
+ fitMeanpt->SetParameter(16, 3.);
+ fitMeanpt->SetParLimits(16, 1.0,5.);
+
+ for ( Int_t i = 0; i < 3; ++i )
+ {
+ fitMeanpt->SetParameter(i + 17, bck->GetParameter(i));
+ }
+
+ // fitMeanpt->SetParameter(13, 3.);
+ // fitMeanpt->SetParLimits(13, 0.5,10.);
+ //
+ // fitMeanpt->SetParameter(14, 0.2);
+ // // fitMeanpt->SetParLimits(14, 0.1,0.2);
+ //
+ // fitMeanpt->SetParameter(15, 0.1);
+ // // fitMeanpt->SetParLimits(15, 0.,1.);
+
+ fitMeanpt->SetParameter(20, 3.);
+ Double_t psipPtLim = 10.;
+ fitMeanpt->SetParLimits(20, 0.,psipPtLim);
+
+
+ // TProfile::Approximate();
+
+ const char* fitOption = "SER"; //+";//SER
+
+ TFitResultPtr fitResult = p->Fit(fitMeanpt,fitOption,"");
+
+ std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
+
+ if ( static_cast<int>(fitResult) )
+ {
+ for ( Int_t i = 0; i < 3; ++i )
+ {
+ fitMeanpt->SetParameter(i + 17, bck->GetParameter(i)*0.9);
+ }
+ fitResult = p->Fit(fitMeanpt,fitOption,"");
+
+ std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
+ }
+ else if ( fitMeanpt->GetParameter(20) <= fitMeanpt->GetParError(20) || fitMeanpt->GetParError(20) >= 0.75*fitMeanpt->GetParameter(20) || (fitMeanpt->GetParameter(20)/psipPtLim > 0.9) )
+ {
+ fitMeanpt->FixParameter(20, bck->Eval(3.68));
+ for ( Int_t i = 0; i < 3; ++i )
+ {
+ fitMeanpt->SetParameter(i + 17, bck->GetParameter(i)*0.6);
+ }
+ fitResult = p->Fit(fitMeanpt,fitOption,"");
+
+ std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
+ }
+
+ // TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
+
+ bck->SetParameters(fitMeanpt->GetParameter(17),fitMeanpt->GetParameter(18),fitMeanpt->GetParameter(19));
+
+ AttachFunctionsToHisto(0x0,bck,fitMeanpt,fitRangeLow,fitRangeHigh);//
+
+ Set("NofJPsi",NofJPsi,ErrStatNofJPsi);
+ Set("MeanPtJPsi",fitMeanpt->GetParameter(16),fitMeanpt->GetParError(16));
+ Set("MeanPtPsiP",fitMeanpt->GetParameter(20),fitMeanpt->GetParError(20));
+
+}
+
+//_____________________________________________________________________________
+void AliAnalysisMuMuJpsiResult::FitMPTPSIPSIPRIMENA60NEWPOL2EXP_BKGMPTPOL2EXP()
+{
+ //Fit mean dimuon mean pt to get Jpsi mean pt using the CB2 signal parameters, VWG for the Bkg, Jpsi mpt = cte and Bkg mpt = pol2
+ fHisto->GetListOfFunctions()->Delete();
+
+ Double_t p1Left = GetValue("p1LJPsi");
+ Double_t p2Left = GetValue("p2LJPsi");
+ Double_t p3Left = GetValue("p3LJPsi");
+ Double_t p1Right = GetValue("p1RJPsi");
+ Double_t p2Right = GetValue("p2RJPsi");
+ Double_t p3Right = GetValue("p3RJPsi");
+
+ Double_t alphaLeft = GetValue("aLJPsi");
+ Double_t alphaRight = GetValue("aRJPsi");
+
+ Double_t pol0 = GetValue("pol0");
+ Double_t pol1 = GetValue("pol1");
+ Double_t pol2 = GetValue("pol2");
+ Double_t exp = GetValue("exp");
+ Double_t kJPsi = GetValue("kJPsi");
+ Double_t kPsiP = GetValue("kPsiP");
+ Double_t mJPsi = GetValue("mJPsi");
+ Double_t sJPsi = GetValue("sJPsi");
+ Double_t NofJPsi = GetValue("NofJPsi");
+ Double_t ErrStatNofJPsi = GetErrorStat("NofJPsi");
+
+ Double_t fitRangeLow = GetValue(kFitRangeLow);
+ Double_t fitRangeHigh = GetValue(kFitRangeHigh);
+
+ // TString msg;
+ //
+ // if (IsValidValue(alphaLow)) msg += TString::Format("alphaLow=%e ",alphaLow);
+ // if (IsValidValue(nLow)) msg += TString::Format("nLow=%e ",nLow);
+ // if (IsValidValue(alphaUp)) msg += TString::Format("alphaUp=%e ",alphaUp);
+ // if (IsValidValue(nUp)) msg += TString::Format("nUp=%e ",nUp);
+ //
+ // AliDebug(1,Form("Mean pt fit with jpsi + psiprime (CB2),Bkg VWG and Pol2 for Bkg <pt> %s",msg.Data()));
+ //
+ // TF1* fitTotal = new TF1("signal+bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2VWG,fitRangeLow,fitRangeHigh,17,"AliAnalysisMuMuJpsiResult","FitFunctionTotalTwoCB2VWG");
+ //
+ //TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
+
+
+ // TString resultName(Form("MEANPTFIT_%salphalow=%5.2fnlow=%5.2falphaup=%5.2fnup=%5.2f",fitName.Data(),par[7],par[8],par[9],par[10]));
+ TProfile* p(0x0);
+ if ( fHisto->IsA() == TProfile::Class() ) p = static_cast<TProfile*>(fHisto);
+ else
+ {
+ AliError("Mean pt histo has to be a TProfile");
+ return;
+ }
+
+ //_____________
+ Int_t minBin = p->FindBin(fitRangeLow);
+ Int_t maxBin = p->FindBin(fitRangeHigh);
+
+ for ( Int_t i = minBin ; i <= maxBin ; i++ )
+ {
+ if ( p->GetBinEffectiveEntries(i) < 10 )
+ {
+ Double_t effEntries(0.),sumErr(0.);
+ for ( Int_t j = i - 5 ; j < i ; j++ )
+ {
+ if ( j <= 0 ) continue;
+ // if ( j > p->GetNbinsX() ) break;
+
+ effEntries += p->GetBinEffectiveEntries(j);
+ sumErr += p->GetBinEffectiveEntries(j)*p->GetBinError(j);
+ }
+
+ Double_t meanErr = sumErr/effEntries;
+
+ if ( p->GetBinError(i) < meanErr/2. )
+ {
+ std::cout << "Resetting bin " << i << " error" <<std::endl;
+ p->SetBinError(i,meanErr);
+ }
+ }
+ }
+ //_____________
+
+ TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2Exp,fitRangeLow,fitRangeHigh,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2Exp");
+
+ bck->SetParameters(2.8,-0.5,0.2,0.05);
+
+ bck->SetParLimits(0, 1.,10.0);
+ // TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2Exp,fitRangeLow,fitRangeHigh,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2Exp");
+ //
+ // bck->SetParameters(1,0,0,0);
+
+ SetFitRejectRange(2.3,4.0);
+
+ p->Fit(bck,"SER","",fitRangeLow,fitRangeHigh);
+
+ SetFitRejectRange();
+
+
+ TF1* fitMeanpt = new TF1("fitMeanpt",this,&AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2NA60NEWPOL2EXPPOL2EXP,fitRangeLow,fitRangeHigh,22,"AliAnalysisMuMuJpsiResult","FitFunctionMeanPtS2NA60NEWPOL2EXPPOL2EXP");
+
+ fitMeanpt->SetParNames("pol0","pol1","pol2","exp","kJPsi","mJPsi","sJPsi","p1LJPsi","p2LJPsi","p3LJPsi","p1RJPsi");
+ fitMeanpt->SetParName(11,"p2RJPsi");
+ fitMeanpt->SetParName(12,"p3RJPsi");
+ fitMeanpt->SetParName(13,"aLJPsi");
+ fitMeanpt->SetParName(14,"aRJPsi");
+ fitMeanpt->SetParName(15,"kPsiP");
+ fitMeanpt->SetParName(16,"<pt>JPsi");
+ fitMeanpt->SetParName(17,"<pt>BG0");
+ fitMeanpt->SetParName(18,"<pt>BG1");
+ fitMeanpt->SetParName(19,"<pt>BG2");
+ fitMeanpt->SetParName(20,"<pt>BGEXP");
+ fitMeanpt->SetParName(21,"<pt>PsiP");
+
+ fitMeanpt->FixParameter(0,pol0);
+ fitMeanpt->FixParameter(1,pol1);
+ fitMeanpt->FixParameter(2,pol2);
+ fitMeanpt->FixParameter(3,exp);
+ fitMeanpt->FixParameter(4,kJPsi);
+ fitMeanpt->FixParameter(5,mJPsi);
+ fitMeanpt->FixParameter(6,sJPsi);
+ fitMeanpt->FixParameter(7,p1Left);
+ fitMeanpt->FixParameter(8,p2Left);
+ fitMeanpt->FixParameter(9,p3Left);
+ fitMeanpt->FixParameter(10,p1Right);
+ fitMeanpt->FixParameter(11,p2Right);
+ fitMeanpt->FixParameter(12,p3Right);
+ fitMeanpt->FixParameter(13,alphaLeft);
+ fitMeanpt->FixParameter(14,alphaRight);
+
+ fitMeanpt->FixParameter(15,kPsiP);
+
+ fitMeanpt->SetParameter(16, 3.);
+ fitMeanpt->SetParLimits(16, 1.0,5.);
+
+ for ( Int_t i = 0; i < 4; ++i )
+ {
+ fitMeanpt->SetParameter(i + 17, bck->GetParameter(i));
+ }
+
+ // fitMeanpt->SetParameter(13, 3.);
+ // fitMeanpt->SetParLimits(13, 0.5,10.);
+ //
+ // fitMeanpt->SetParameter(14, 0.2);
+ // // fitMeanpt->SetParLimits(14, 0.1,0.2);
+ //
+ // fitMeanpt->SetParameter(15, 0.1);
+ // // fitMeanpt->SetParLimits(15, 0.,1.);
+
+ fitMeanpt->SetParameter(21, 3.);
+ Double_t psipPtLim = 10.;
+ fitMeanpt->SetParLimits(21, 0.,psipPtLim);
+
+
+
+ // TProfile::Approximate();
+
+ const char* fitOption = "SER"; //+";//SER
+
+ TFitResultPtr fitResult = p->Fit(fitMeanpt,fitOption,"");
+
+ std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
+
+ if ( static_cast<int>(fitResult) )
+ {
+ for ( Int_t i = 0; i < 4; ++i )
+ {
+ fitMeanpt->SetParameter(i + 17, bck->GetParameter(i)*0.9);
+ }
+ fitResult = p->Fit(fitMeanpt,fitOption,"");
+
+ std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
+ }
+ else if ( fitMeanpt->GetParameter(21) <= fitMeanpt->GetParError(21) || fitMeanpt->GetParError(21) >= 0.75*fitMeanpt->GetParameter(21) || (fitMeanpt->GetParameter(21)/psipPtLim > 0.9) )
+ {
+ fitMeanpt->FixParameter(21, bck->Eval(3.68));
+ for ( Int_t i = 0; i < 4; ++i )
+ {
+ fitMeanpt->SetParameter(i + 17, bck->GetParameter(i)*0.6);
+ }
+ fitResult = p->Fit(fitMeanpt,fitOption,"");
+
+ std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
+ }
+ if ( fitMeanpt->GetParameter(17) <= fitMeanpt->GetParError(17) || fitMeanpt->GetParError(17) >= 0.75*fitMeanpt->GetParameter(13) )
+ {
+ fitMeanpt->SetParameter(17, 2.);
+
+ fitResult = p->Fit(fitMeanpt,fitOption,"");
+
+ std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
+ }
+
+ // TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
+
+ bck->SetParameters(fitMeanpt->GetParameter(17),fitMeanpt->GetParameter(18),fitMeanpt->GetParameter(19),fitMeanpt->GetParameter(20));
+
+ AttachFunctionsToHisto(0x0,bck,fitMeanpt,fitRangeLow,fitRangeHigh);//
+
+ Set("NofJPsi",NofJPsi,ErrStatNofJPsi);
+ Set("MeanPtJPsi",fitMeanpt->GetParameter(16),fitMeanpt->GetParError(16));
+ Set("MeanPtPsiP",fitMeanpt->GetParameter(21),fitMeanpt->GetParError(21));
+
+}
+
+//_____________________________________________________________________________
+void AliAnalysisMuMuJpsiResult::FitMPTPSIPSIPRIMECB2VWG_BKGMPTPOL3()
+{
+ //Fit mean dimuon mean pt to get Jpsi mean pt using the CB2 signal parameters, VWG for the Bkg, Jpsi mpt = cte and Bkg mpt = pol2
+ fHisto->GetListOfFunctions()->Delete();
+
+ Double_t alphaLow = GetValue("alJPsi");
+ Double_t nLow = GetValue("nlJPsi");
+ Double_t alphaUp = GetValue("auJPsi");
+ Double_t nUp = GetValue("nuJPsi");
+
+ Double_t kVWG = GetValue("kVWG");
+ Double_t mVWG = GetValue("mVWG");
+ Double_t sVWG1 = GetValue("sVWG1");
+ Double_t sVWG2 = GetValue("sVWG2");
+ Double_t kJPsi = GetValue("kJPsi");
+ Double_t kPsiP = GetValue("kPsiP");
+ Double_t mJPsi = GetValue("mJPsi");
+ Double_t sJPsi = GetValue("sJPsi");
+ Double_t NofJPsi = GetValue("NofJPsi");
+ Double_t ErrStatNofJPsi = GetErrorStat("NofJPsi");
+
+ Double_t fitRangeLow = GetValue(kFitRangeLow);
+ Double_t fitRangeHigh = GetValue(kFitRangeHigh);
+
+ // TString msg;
+ //
+ // if (IsValidValue(alphaLow)) msg += TString::Format("alphaLow=%e ",alphaLow);
+ // if (IsValidValue(nLow)) msg += TString::Format("nLow=%e ",nLow);
+ // if (IsValidValue(alphaUp)) msg += TString::Format("alphaUp=%e ",alphaUp);
+ // if (IsValidValue(nUp)) msg += TString::Format("nUp=%e ",nUp);
+ //
+ // AliDebug(1,Form("Mean pt fit with jpsi + psiprime (CB2),Bkg VWG and Pol2 for Bkg <pt> %s",msg.Data()));
+ //
+ // TF1* fitTotal = new TF1("signal+bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2VWG,fitRangeLow,fitRangeHigh,17,"AliAnalysisMuMuJpsiResult","FitFunctionTotalTwoCB2VWG");
+ //
+ //TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
+
+
+ // TString resultName(Form("MEANPTFIT_%salphalow=%5.2fnlow=%5.2falphaup=%5.2fnup=%5.2f",fitName.Data(),par[7],par[8],par[9],par[10]));
+ TProfile* p(0x0);
+ if ( fHisto->IsA() == TProfile::Class() ) p = static_cast<TProfile*>(fHisto);
+ else
+ {
+ AliError("Mean pt histo has to be a TProfile");
+ return;
}
- for ( int iy = 0; iy < 5; ++iy )
+ //_____________
+ Int_t minBin = p->FindBin(fitRangeLow);
+ Int_t maxBin = p->FindBin(fitRangeHigh);
+
+ for ( Int_t i = minBin ; i <= maxBin ; i++ )
{
- for ( int ix = 0; ix < 5; ++ix )
+ if ( p->GetBinEffectiveEntries(i) < 10 )
{
- covarianceMatrix[ix][iy] = (fitResult->GetCovarianceMatrix())(ix+4,iy+4);
+ Double_t effEntries(0.),sumErr(0.);
+ for ( Int_t j = i - 5 ; j < i ; j++ )
+ {
+ if ( j <= 0 ) continue;
+ // if ( j > p->GetNbinsX() ) break;
+
+ effEntries += p->GetBinEffectiveEntries(j);
+ sumErr += p->GetBinEffectiveEntries(j)*p->GetBinError(j);
+ }
+
+ Double_t meanErr = sumErr/effEntries;
+
+ if ( p->GetBinError(i) < meanErr/2. )
+ {
+ std::cout << "Resetting bin " << i << " error" <<std::endl;
+ p->SetBinError(i,meanErr);
+ }
}
}
+ //_____________
- double njpsi = fcb->Integral(m-n*s,m+n*s)/h.GetBinWidth(1);
- double nerr = fcb->IntegralError(m-n*s,m+n*s,&cbParameters[0],&covarianceMatrix[0][0])/h.GetBinWidth(1);
+ TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol3,fitRangeLow,fitRangeHigh,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol3");
- r->Set("NofJpsi",njpsi,nerr);
+ bck->SetParameters(3.,1.,-0.4,0.05);
- return r;
-}
-
-//_____________________________________________________________________________
-AliAnalysisMuMuJpsiResult* AliAnalysisMuMuJpsiResult::FitJpsi2CB2VWG(const TH1& h,
- Double_t alphaLow,
- Double_t nLow,
- Double_t alphaUp,
- Double_t nUp)
-{
- /// Fit using extended crystal ball + variable width gaussian
+ bck->SetParLimits(0, 1.,8.0);
+ // TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2Exp,fitRangeLow,fitRangeHigh,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2Exp");
+ //
+ // bck->SetParameters(1,0,0,0);
- StdoutToAliDebug(1,std::cout << Form("Fit with jpsi + psiprime VWG alphaLow=%5.2f nLow=%5.2f alphaUp=%5.2f nUp=%5.2f",
- alphaLow,nLow,alphaUp,nUp) << std::endl;);
+ SetFitRejectRange(2.3,4.0);
- Int_t nrebin = fMinv->GetXaxis()->GetNbins() / h.GetXaxis()->GetNbins();
+ p->Fit(bck,"SER","",fitRangeLow,fitRangeHigh);
- TString resultName("JPSI2CB2VWG");
- if ( alphaLow > 0 )
- {
- resultName += TString::Format("alphaLow=%5.2f",alphaLow);
- }
- if ( nLow > 0 )
- {
- resultName += TString::Format("nLow=%5.2f",nLow);
- }
- if ( alphaUp > 0 )
- {
- resultName += TString::Format("alphaUp=%5.2f",alphaUp);
- }
- if ( nUp > 0 )
- {
- resultName += TString::Format("nUp=%5.2f",nUp);
- }
- resultName.ReplaceAll(" ","");
+ SetFitRejectRange();
- AliAnalysisMuMuJpsiResult* r = new AliAnalysisMuMuJpsiResult(h,resultName.Data(),nrebin);
- TH1* hfit = r->Minv();
- const Double_t xmin(2.2);
- const Double_t xmax(5.0);
+ TF1* fitMeanpt = new TF1("fitMeanpt",this,&AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2CB2VWGPOL3,fitRangeLow,fitRangeHigh,18,"AliAnalysisMuMuJpsiResult","FitFunctionMeanPtS2CB2VWGPOL3");
- TF1* fitTotal = new TF1("fitTotal",func2CB2VWG,xmin,xmax,12);
- fitTotal->SetParNames("kVWG","mVWG","sVWG1","sVWG2","kPsi","mPsi","sPsi","alPsi","nlPsi","auPsi","nuPsi");
- fitTotal->SetParName(11, "kPsi'");
-
- fitTotal->SetParameter(0, 10000.);
- fitTotal->SetParameter(1, 1.9);
- fitTotal->SetParameter(2, 0.5);
- fitTotal->SetParLimits(2, 0., 100.);
- fitTotal->SetParameter(3, 0.3);
- fitTotal->SetParLimits(3, 0., 100.);
- fitTotal->SetParameter(4, 100.);
- fitTotal->SetParameter(5, 3.1);
- fitTotal->SetParLimits(5, 3.08, 3.2);
- fitTotal->SetParameter(6, 0.08);
- fitTotal->SetParLimits(6, 0.05, 0.15);
+ fitMeanpt->SetParNames("kVWG","mVWG","sVWG1","sVWG2","kJPsi","mJPsi","sJPsi","alJPsi","nlJPsi","auJPsi","nuJPsi");
+ fitMeanpt->SetParName(11,"kPsiP");
+ fitMeanpt->SetParName(12,"<pt>JPsi");
+ fitMeanpt->SetParName(13,"<pt>BG0");
+ fitMeanpt->SetParName(14,"<pt>BG1");
+ fitMeanpt->SetParName(15,"<pt>BG2");
+ fitMeanpt->SetParName(16,"<pt>BG3");
+ fitMeanpt->SetParName(17,"<pt>PsiP");
-// r = FitJpsi2CB2VWG(*hminv,0.93,5.59,2.32,3.39);
-
- if ( alphaLow > 0 )
- {
- fitTotal->FixParameter(7, alphaLow);
- }
- else
- {
- fitTotal->SetParameter(7,0.9);
- fitTotal->SetParLimits(7,0.1,10.0);
- }
+ fitMeanpt->FixParameter(0,kVWG);
+ fitMeanpt->FixParameter(1,mVWG);
+ fitMeanpt->FixParameter(2,sVWG1);
+ fitMeanpt->FixParameter(3,sVWG2);
+ fitMeanpt->FixParameter(4,kJPsi);
+ fitMeanpt->FixParameter(5,mJPsi);
+ fitMeanpt->FixParameter(6,sJPsi);
+ fitMeanpt->FixParameter(7,alphaLow);
+ fitMeanpt->FixParameter(8,nLow);
+ fitMeanpt->FixParameter(9,alphaUp);
+ fitMeanpt->FixParameter(10,nUp);
+ fitMeanpt->FixParameter(11,kPsiP);
- if ( nLow > 0 )
- {
- fitTotal->FixParameter(8, nLow);
- }
- else
- {
- fitTotal->SetParameter(8,5.0);
- fitTotal->SetParLimits(8,0.0,10.0);
- }
+ fitMeanpt->SetParameter(12, 3.);
+ fitMeanpt->SetParLimits(12, 1.0,5.);
- if ( alphaUp > 0 )
- {
- fitTotal->FixParameter(9, alphaUp);
- }
- else
+ for ( Int_t i = 0; i < 4; ++i )
{
- fitTotal->SetParameter(9, 2.0);
- fitTotal->SetParLimits(9,0.1,10.0);
+ fitMeanpt->SetParameter(i + 13, bck->GetParameter(i));
}
- if ( nUp > 0 )
- {
- fitTotal->FixParameter(10, nUp);
- }
- else
- {
- fitTotal->SetParameter(10,3.0);
- fitTotal->SetParLimits(10,0.0,10.0);
- }
+ // fitMeanpt->SetParameter(13, 3.);
+ // fitMeanpt->SetParLimits(13, 0.5,10.);
+ //
+ // fitMeanpt->SetParameter(14, 0.2);
+ // // fitMeanpt->SetParLimits(14, 0.1,0.2);
+ //
+ // fitMeanpt->SetParameter(15, 0.1);
+ // // fitMeanpt->SetParLimits(15, 0.,1.);
- fitTotal->SetParameter(11, 10.);
-
- const char* fitOption = "QSER"; //+";
+ fitMeanpt->SetParameter(17, 3.);
+ fitMeanpt->SetParLimits(17, 0.,10.);
- TFitResultPtr fitResult = hfit->Fit(fitTotal,fitOption,"");
- r->Set("MeanJpsi",fitTotal->GetParameter(5),fitTotal->GetParError(5));
- r->Set("SigmaJpsi",fitTotal->GetParameter(6),fitTotal->GetParError(6));
+ // TProfile::Approximate();
- double m = r->GetValue("MeanJpsi");
- double s = r->GetValue("SigmaJpsi");
- double n = 3.0;
-
- TF1* fcb = new TF1("fcb",CrystalBallExtended,xmin,xmax,7);
- fcb->SetParameters(fitTotal->GetParameter(4),
- fitTotal->GetParameter(5),
- fitTotal->GetParameter(6),
- fitTotal->GetParameter(7),
- fitTotal->GetParameter(8),
- fitTotal->GetParameter(9),
- fitTotal->GetParameter(10));
-
+ const char* fitOption = "SER"; //+";//SER
- fcb->SetLineColor(1);
- fcb->SetNpx(1000);
- TLine* l1 = new TLine(m-n*s,0,m-n*s,fitTotal->GetParameter(4));
- TLine* l2 = new TLine(m+n*s,0,m+n*s,fitTotal->GetParameter(4));
- l1->SetLineColor(6);
- l2->SetLineColor(6);
- hfit->GetListOfFunctions()->Add(fcb);
- hfit->GetListOfFunctions()->Add(l1);
- hfit->GetListOfFunctions()->Add(l2);
+ TFitResultPtr fitResult = p->Fit(fitMeanpt,fitOption,"");
- Double_t cbParameters[7];
- Double_t covarianceMatrix[7][7];
+ std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
- for ( int ix = 0; ix < 7; ++ix )
+ if ( static_cast<int>(fitResult) )
{
- cbParameters[ix] = fitTotal->GetParameter(ix+4);
+ for ( Int_t i = 0; i < 4; ++i )
+ {
+ fitMeanpt->SetParameter(i + 13, bck->GetParameter(i)*0.9);
+ }
+ fitResult = p->Fit(fitMeanpt,fitOption,"");
+
+ std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
}
-
- for ( int iy = 0; iy < 5; ++iy )
+ else if ( fitMeanpt->GetParameter(17) <= fitMeanpt->GetParError(17) || fitMeanpt->GetParError(17) >= 0.75*fitMeanpt->GetParameter(17) )
{
- for ( int ix = 0; ix < 5; ++ix )
+ fitMeanpt->FixParameter(17, 0.);
+ for ( Int_t i = 0; i < 4; ++i )
{
- covarianceMatrix[ix][iy] = (fitResult->GetCovarianceMatrix())(ix+4,iy+4);
+ fitMeanpt->SetParameter(i + 13, bck->GetParameter(i)*0.6);
}
+ fitResult = p->Fit(fitMeanpt,fitOption,"");
+
+ std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
}
- double njpsi = fcb->Integral(m-n*s,m+n*s)/h.GetBinWidth(1);
- double nerr = fcb->IntegralError(m-n*s,m+n*s,&cbParameters[0],&covarianceMatrix[0][0])/h.GetBinWidth(1);
+ // TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
- r->Set("NofJpsi",njpsi,nerr);
+ bck->SetParameters(fitMeanpt->GetParameter(13),fitMeanpt->GetParameter(14),fitMeanpt->GetParameter(15),fitMeanpt->GetParameter(16));
+
+ AttachFunctionsToHisto(0x0,bck,fitMeanpt,fitRangeLow,fitRangeHigh);//
+
+ Set("NofJPsi",NofJPsi,ErrStatNofJPsi);
+ Set("MeanPtJPsi",fitMeanpt->GetParameter(12),fitMeanpt->GetParError(12));
+ Set("MeanPtPsiP",fitMeanpt->GetParameter(17),fitMeanpt->GetParError(17));
- return r;
}
//_____________________________________________________________________________
-AliAnalysisMuMuJpsiResult* AliAnalysisMuMuJpsiResult::FitJpsiNA48(const TH1& h)
+void AliAnalysisMuMuJpsiResult::FitMPTPSIPSIPRIMECB2VWG_BKGMPTLIN()
{
- /// fit using functional form from Ruben Shahoyan's thesis (2001) (eq. 4.8.)
-
- StdoutToAliDebug(1,std::cout << "Fit with jpsi NA50 Ruben eq. 4.8" << std::endl;);
-
- Int_t nrebin = fMinv->GetXaxis()->GetNbins() / h.GetXaxis()->GetNbins();
+ //Fit mean dimuon mean pt to get Jpsi mean pt using the CB2 signal parameters, VWG for the Bkg, Jpsi mpt = cte and Bkg mpt = pol2
+ fHisto->GetListOfFunctions()->Delete();
+
+ Double_t alphaLow = GetValue("alJPsi");
+ Double_t nLow = GetValue("nlJPsi");
+ Double_t alphaUp = GetValue("auJPsi");
+ Double_t nUp = GetValue("nuJPsi");
+
+ Double_t kVWG = GetValue("kVWG");
+ Double_t mVWG = GetValue("mVWG");
+ Double_t sVWG1 = GetValue("sVWG1");
+ Double_t sVWG2 = GetValue("sVWG2");
+ Double_t kJPsi = GetValue("kJPsi");
+ Double_t kPsiP = GetValue("kPsiP");
+ Double_t mJPsi = GetValue("mJPsi");
+ Double_t sJPsi = GetValue("sJPsi");
+ Double_t NofJPsi = GetValue("NofJPsi");
+ Double_t ErrStatNofJPsi = GetErrorStat("NofJPsi");
+
+ Double_t fitRangeLow = GetValue(kFitRangeLow);
+ Double_t fitRangeHigh = GetValue(kFitRangeHigh);
+
+ // TString msg;
+ //
+ // if (IsValidValue(alphaLow)) msg += TString::Format("alphaLow=%e ",alphaLow);
+ // if (IsValidValue(nLow)) msg += TString::Format("nLow=%e ",nLow);
+ // if (IsValidValue(alphaUp)) msg += TString::Format("alphaUp=%e ",alphaUp);
+ // if (IsValidValue(nUp)) msg += TString::Format("nUp=%e ",nUp);
+ //
+ // AliDebug(1,Form("Mean pt fit with jpsi + psiprime (CB2),Bkg VWG and Pol2 for Bkg <pt> %s",msg.Data()));
+ //
+ // TF1* fitTotal = new TF1("signal+bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2VWG,fitRangeLow,fitRangeHigh,17,"AliAnalysisMuMuJpsiResult","FitFunctionTotalTwoCB2VWG");
+ //
+ //TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
+
+
+ // TString resultName(Form("MEANPTFIT_%salphalow=%5.2fnlow=%5.2falphaup=%5.2fnup=%5.2f",fitName.Data(),par[7],par[8],par[9],par[10]));
+
+ TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundLin,fitRangeLow,fitRangeHigh,2,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundLin");
+
+ bck->SetParameters(3.,0.);
+
+ bck->SetParLimits(0, 2.0,4.0);
+ // TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2Exp,fitRangeLow,fitRangeHigh,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2Exp");
+ //
+ // bck->SetParameters(1,0,0,0);
+
+ SetFitRejectRange(2.0,4.0);
+
+ fHisto->Fit(bck,"SER","",fitRangeLow,fitRangeHigh);
+
+ SetFitRejectRange();
+
+
+
+ TF1* fitMeanpt = new TF1("fitMeanpt",this,&AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2CB2Lin,fitRangeLow,fitRangeHigh,16,"AliAnalysisMuMuJpsiResult","FitFunctionMeanPtS2CB2Lin");
+
+ fitMeanpt->SetParNames("kVWG","mVWG","sVWG1","sVWG2","kJPsi","mJPsi","sJPsi","alJPsi","nlJPsi","auJPsi","nuJPsi");
+ fitMeanpt->SetParName(11,"kPsiP");
+ fitMeanpt->SetParName(12,"<pt>JPsi");
+ fitMeanpt->SetParName(13,"<pt>BG0");
+ fitMeanpt->SetParName(14,"<pt>BG1");
+ fitMeanpt->SetParName(15,"<pt>PsiP");
+
+ fitMeanpt->FixParameter(0,kVWG);
+ fitMeanpt->FixParameter(1,mVWG);
+ fitMeanpt->FixParameter(2,sVWG1);
+ fitMeanpt->FixParameter(3,sVWG2);
+ fitMeanpt->FixParameter(4,kJPsi);
+ fitMeanpt->FixParameter(5,mJPsi);
+ fitMeanpt->FixParameter(6,sJPsi);
+ fitMeanpt->FixParameter(7,alphaLow);
+ fitMeanpt->FixParameter(8,nLow);
+ fitMeanpt->FixParameter(9,alphaUp);
+ fitMeanpt->FixParameter(10,nUp);
+ fitMeanpt->FixParameter(11,kPsiP);
+
+ fitMeanpt->SetParameter(12, 3.);
+ fitMeanpt->SetParLimits(12, 2.0,4.);
+
+ for ( Int_t i = 0; i < 2; ++i )
+ {
+ fitMeanpt->SetParameter(i + 13, bck->GetParameter(i));
+ }
- AliAnalysisMuMuJpsiResult* r = new AliAnalysisMuMuJpsiResult(h,"JPSINA",nrebin);
+ // fitMeanpt->SetParameter(13, 3.);
+ // fitMeanpt->SetParLimits(13, 0.5,10.);
+ //
+ // fitMeanpt->SetParameter(14, 0.2);
+ // // fitMeanpt->SetParLimits(14, 0.1,0.2);
+ //
+ // fitMeanpt->SetParameter(15, 0.1);
+ // // fitMeanpt->SetParLimits(15, 0.,1.);
- TH1* hfit = r->Minv();
+ fitMeanpt->SetParameter(15, 3.);
+ fitMeanpt->SetParLimits(15, 0.5,6.);
- const Double_t xmin(2.0);
- const Double_t xmax(5.0);
- TF1* fitTotal = new TF1("fitTotal",funcJpsiNA48,xmin,xmax,12);
+ // TProfile::Approximate();
- fitTotal->SetParName( 0, "c1");
- fitTotal->FixParameter(0,0.97);
+ const char* fitOption = "SER"; //+";
- fitTotal->SetParName( 1, "c2");
- fitTotal->FixParameter(1,1.05);
+ TFitResultPtr fitResult = fHisto->Fit(fitMeanpt,fitOption,"");
- fitTotal->SetParName( 2, "d1");
- fitTotal->SetParameter(2,0.0);
- fitTotal->SetParLimits(2,0,1);
+ // TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
- fitTotal->SetParName( 3, "d2");
- fitTotal->SetParameter(3,0.0);
- fitTotal->SetParLimits(3,0,1);
+ bck->SetParameters(fitMeanpt->GetParameter(13),fitMeanpt->GetParameter(14));
- fitTotal->SetParName( 4, "g1");
- fitTotal->SetParameter(4,0.0);
- fitTotal->SetParLimits(4,0.0,1);
+ AttachFunctionsToHisto(0x0,bck,fitMeanpt,fitRangeLow,fitRangeHigh);//
- fitTotal->SetParName( 5, "g2");
- fitTotal->SetParameter(5,0.0);
- fitTotal->SetParLimits(5,0.0,1);
+ Set("NofJPsi",NofJPsi,ErrStatNofJPsi);
+ Set("MeanPtJPsi",fitMeanpt->GetParameter(12),fitMeanpt->GetParError(12));
+ Set("MeanPtPsiP",fitMeanpt->GetParameter(15),fitMeanpt->GetParError(15));
- fitTotal->SetParName( 6, "m0");
- fitTotal->SetParameter(6,3.1);
- fitTotal->SetParLimits(6,2.8,3.4);
+}
- fitTotal->SetParName( 7, "sigma1");
- fitTotal->SetParameter(7,0.05);
- fitTotal->SetParLimits(7,0.01,0.2);
+//_____________________________________________________________________________
+void AliAnalysisMuMuJpsiResult::FitMPTPSIPSIPRIMECB2VWGINDEPTAILS_BKGMPTPOL2()
+{
+ //Fit mean dimuon mean pt to get Jpsi mean pt using the CB2 signal parameters, VWG for the Bkg, Jpsi mpt = cte and Bkg mpt = pol2
+ fHisto->GetListOfFunctions()->Delete();
+
+ Double_t alphaLow = GetValue("alJPsi");
+ Double_t nLow = GetValue("nlJPsi");
+ Double_t alphaUp = GetValue("auJPsi");
+ Double_t nUp = GetValue("nuJPsi");
+
+ Double_t alphaLowP = GetValue("alPsiP");
+ Double_t nLowP = GetValue("nlPsiP");
+ Double_t alphaUpP = GetValue("auPsiP");
+ Double_t nUpP = GetValue("nuPsiP");
+
+ Double_t kVWG = GetValue("kVWG");
+ Double_t mVWG = GetValue("mVWG");
+ Double_t sVWG1 = GetValue("sVWG1");
+ Double_t sVWG2 = GetValue("sVWG2");
+ Double_t kJPsi = GetValue("kJPsi");
+ Double_t kPsiP = GetValue("kPsiP");
+ Double_t mJPsi = GetValue("mJPsi");
+ Double_t sJPsi = GetValue("sJPsi");
+// Double_t mPsiP = GetValue("mPsiP");
+// Double_t sPsiP = GetValue("sPsiP");
+ Double_t NofJPsi = GetValue("NofJPsi");
+ Double_t ErrStatNofJPsi = GetErrorStat("NofJPsi");
+
+ Double_t fitRangeLow = GetValue(kFitRangeLow);
+ Double_t fitRangeHigh = GetValue(kFitRangeHigh);
+
+ // TString msg;
+ //
+ // if (IsValidValue(alphaLow)) msg += TString::Format("alphaLow=%e ",alphaLow);
+ // if (IsValidValue(nLow)) msg += TString::Format("nLow=%e ",nLow);
+ // if (IsValidValue(alphaUp)) msg += TString::Format("alphaUp=%e ",alphaUp);
+ // if (IsValidValue(nUp)) msg += TString::Format("nUp=%e ",nUp);
+ //
+ // AliDebug(1,Form("Mean pt fit with jpsi + psiprime (CB2),Bkg VWG and Pol2 for Bkg <pt> %s",msg.Data()));
+ //
+ // TF1* fitTotal = new TF1("signal+bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2VWG,fitRangeLow,fitRangeHigh,17,"AliAnalysisMuMuJpsiResult","FitFunctionTotalTwoCB2VWG");
+ //
+ // TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2Exp,fitRangeLow,fitRangeHigh,5,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2Exp");
+
+
+ // TString resultName(Form("MEANPTFIT_%salphalow=%5.2fnlow=%5.2falphaup=%5.2fnup=%5.2f",fitName.Data(),par[7],par[8],par[9],par[10]));
+
+ TF1* fitMeanpt = new TF1("fitMeanpt",this,&AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2CB2VWGPOL2INDEPTAILS,fitRangeLow,fitRangeHigh,21,"AliAnalysisMuMuJpsiResult","FitFunctionMeanPtS2CB2VWGPOL2INDEPTAILS");
+
+ fitMeanpt->SetParNames("kVWG","mVWG","sVWG1","sVWG2","kJPsi","mJPsi","sJPsi","alJPsi","nlJPsi","auJPsi","nuJPsi");
+ fitMeanpt->SetParName(11,"kPsiP");
+// fitMeanpt->SetParName(12,"mPsiP");
+// fitMeanpt->SetParName(13,"sPsiP");
+ fitMeanpt->SetParName(12,"alPsiP");
+ fitMeanpt->SetParName(13,"nlPsiP");
+ fitMeanpt->SetParName(14,"auPsiP");
+ fitMeanpt->SetParName(15,"nuPsiP");
+ fitMeanpt->SetParName(16,"<pt>JPsi");//12
+ fitMeanpt->SetParName(17,"<pt>BG0");//13
+ fitMeanpt->SetParName(18,"<pt>BG1");//14
+ fitMeanpt->SetParName(19,"<pt>BG2");//15
+ fitMeanpt->SetParName(20,"<pt>PsiP");//16
+
+ fitMeanpt->FixParameter(0,kVWG);
+ fitMeanpt->FixParameter(1,mVWG);
+ fitMeanpt->FixParameter(2,sVWG1);
+ fitMeanpt->FixParameter(3,sVWG2);
+ fitMeanpt->FixParameter(4,kJPsi);
+ fitMeanpt->FixParameter(5,mJPsi);
+ fitMeanpt->FixParameter(6,sJPsi);
+ fitMeanpt->FixParameter(7,alphaLow);
+ fitMeanpt->FixParameter(8,nLow);
+ fitMeanpt->FixParameter(9,alphaUp);
+ fitMeanpt->FixParameter(10,nUp);
+ fitMeanpt->FixParameter(11,kPsiP);
+// fitMeanpt->FixParameter(12,mPsiP);
+// fitMeanpt->FixParameter(13,sPsiP);
+ fitMeanpt->FixParameter(12,alphaLowP);
+ fitMeanpt->FixParameter(13,nLowP);
+ fitMeanpt->FixParameter(14,alphaUpP);
+ fitMeanpt->FixParameter(15,nUpP);
+
+ fitMeanpt->SetParameter(16, 3.);
+ fitMeanpt->SetParLimits(16, 2.,3.);
+
+ fitMeanpt->SetParameter(17, 1.);
+ // fitMeanpt->SetParLimits(13, 0.01,1.5);
+
+ fitMeanpt->SetParameter(18, 0.2);
+ // fitMeanpt->SetParLimits(14, 0.1,0.2);
+
+ fitMeanpt->SetParameter(19, 0.1);
+ // fitMeanpt->SetParLimits(15, 0.,1.);
+
+ fitMeanpt->SetParameter(20, 3.);
+ fitMeanpt->SetParLimits(20, 2.5,8.);
+
+
+
+ const char* fitOption = "SER"; //+";
+
+ TFitResultPtr fitResult = fHisto->Fit(fitMeanpt,fitOption,"");
+
+ TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
+
+ bck->SetParameters(fitMeanpt->GetParameter(17),fitMeanpt->GetParameter(18),fitMeanpt->GetParameter(19));
+
+ AttachFunctionsToHisto(0x0,bck,fitMeanpt,fitRangeLow,fitRangeHigh);
+
+ Set("NofJPsi",NofJPsi,ErrStatNofJPsi);
+ Set("MeanPtJPsi",fitMeanpt->GetParameter(16),fitMeanpt->GetParError(16));
+ Set("MeanPtPsiP",fitMeanpt->GetParameter(20),fitMeanpt->GetParError(20));
- fitTotal->SetParName( 8, "sigma2");
- fitTotal->SetParameter(8,0.05);
- fitTotal->SetParLimits(8,0.01,0.2);
+}
- fitTotal->SetParName( 9, "b1");
- fitTotal->SetParameter(9,1.0);
- fitTotal->SetParLimits(9,0,1);
+////_____________________________________________________________________________
+//void AliAnalysisMuMuJpsiResult::FitMPT2CB2VWG_BKGMPTPOL2EXP()
+//{
+// //Fit mean dimuon mean pt to get Jpsi mean pt using the CB2 signal parameters, VWG for the Bkg, Jpsi mpt = cte and Bkg mpt = pol2
+// fHisto->GetListOfFunctions()->Delete();
+//
+// Double_t alphaLow = GetValue("alJPsi");
+// Double_t nLow = GetValue("nlJPsi");
+// Double_t alphaUp = GetValue("auJPsi");
+// Double_t nUp = GetValue("nuJPsi");
+//
+// Double_t kVWG = GetValue("kVWG");
+// Double_t mVWG = GetValue("mVWG");
+// Double_t sVWG1 = GetValue("sVWG1");
+// Double_t sVWG2 = GetValue("sVWG2");
+// Double_t kJPsi = GetValue("kJPsi");
+// Double_t kPsiP = GetValue("kPsiP");
+// Double_t mJPsi = GetValue("mJPsi");
+// Double_t sJPsi = GetValue("sJPsi");
+// Double_t NofJPsi = GetValue("NofJPsi");
+// Double_t ErrStatNofJPsi = GetErrorStat("NofJPsi");
+//
+// Double_t fitRangeLow = GetValue(kFitRangeLow);
+// Double_t fitRangeHigh = GetValue(kFitRangeHigh);
+//
+// // TString msg;
+// //
+// // if (IsValidValue(alphaLow)) msg += TString::Format("alphaLow=%e ",alphaLow);
+// // if (IsValidValue(nLow)) msg += TString::Format("nLow=%e ",nLow);
+// // if (IsValidValue(alphaUp)) msg += TString::Format("alphaUp=%e ",alphaUp);
+// // if (IsValidValue(nUp)) msg += TString::Format("nUp=%e ",nUp);
+// //
+// // AliDebug(1,Form("Mean pt fit with jpsi + psiprime (CB2),Bkg VWG and Pol2 for Bkg <pt> %s",msg.Data()));
+// //
+// // TF1* fitTotal = new TF1("signal+bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2VWG,fitRangeLow,fitRangeHigh,17,"AliAnalysisMuMuJpsiResult","FitFunctionTotalTwoCB2VWG");
+// //
+// //TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
+//
+//
+// // TString resultName(Form("MEANPTFIT_%salphalow=%5.2fnlow=%5.2falphaup=%5.2fnup=%5.2f",fitName.Data(),par[7],par[8],par[9],par[10]));
+//
+// TF1* fitMeanpt = new TF1("fitMeanpt",this,&AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2CB2VWGPOL2EXP,fitRangeLow,fitRangeHigh,17,"AliAnalysisMuMuJpsiResult","FitFunctionMeanPtS2CB2VWGPOL2EXP");
+//
+// fitMeanpt->SetParNames("kVWG","mVWG","sVWG1","sVWG2","kJPsi","mJPsi","sJPsi","alJPsi","nlJPsi","auJPsi","nuJPsi");
+// fitMeanpt->SetParName(11,"kPsiP");
+// fitMeanpt->SetParName(12,"<pt>JPsi");
+// fitMeanpt->SetParName(13,"<pt>BG0");
+// fitMeanpt->SetParName(14,"<pt>BG1");
+// fitMeanpt->SetParName(15,"<pt>BG2");
+// fitMeanpt->SetParName(16,"<pt>PsiP");
+//
+// fitMeanpt->FixParameter(0,kVWG);
+// fitMeanpt->FixParameter(1,mVWG);
+// fitMeanpt->FixParameter(2,sVWG1);
+// fitMeanpt->FixParameter(3,sVWG2);
+// fitMeanpt->FixParameter(4,kJPsi);
+// fitMeanpt->FixParameter(5,mJPsi);
+// fitMeanpt->FixParameter(6,sJPsi);
+// fitMeanpt->FixParameter(7,alphaLow);
+// fitMeanpt->FixParameter(8,nLow);
+// fitMeanpt->FixParameter(9,alphaUp);
+// fitMeanpt->FixParameter(10,nUp);
+// fitMeanpt->FixParameter(11,kPsiP);
+//
+// fitMeanpt->SetParameter(12, 3.);
+// fitMeanpt->SetParLimits(12, 2.0,4.);
+//
+// fitMeanpt->SetParameter(13, 3.);
+// fitMeanpt->SetParLimits(13, 3.,10.);
+//
+// fitMeanpt->SetParameter(14, 0.2);
+// // fitMeanpt->SetParLimits(14, 0.1,0.2);
+//
+// fitMeanpt->SetParameter(15, 0.1);
+// // fitMeanpt->SetParLimits(15, 0.,1.);
+//
+// fitMeanpt->SetParameter(16, 3.);
+// fitMeanpt->SetParLimits(16, 1.5,6.);
+//
+//
+// TProfile::Approximate();
+//
+// const char* fitOption = "SER"; //+";
+//
+// TFitResultPtr fitResult = fHisto->Fit(fitMeanpt,fitOption,"");
+//
+// TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2Exp,fitRangeLow,fitRangeHigh,5,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2Exp");
+//
+// bck->SetParameters(fitMeanpt->GetParameter(13),fitMeanpt->GetParameter(14),fitMeanpt->GetParameter(15));
+//
+// AttachFunctionsToHisto(0x0,bck,fitMeanpt,fitRangeLow,fitRangeHigh);
+//
+// Set("NofJPsi",NofJPsi,ErrStatNofJPsi);
+// Set("MeanPtJPsi",fitMeanpt->GetParameter(12),fitMeanpt->GetParError(12));
+// Set("MeanPtPsiP",fitMeanpt->GetParameter(16),fitMeanpt->GetParError(16));
+//
+//}
+
+//_____________________________________________________________________________
+void AliAnalysisMuMuJpsiResult::FitMPTPSIPSIPRIMECB2VWG_BKGMPTPOL4()
+{
+ //Fit mean dimuon mean pt to get Jpsi mean pt using the CB2 signal parameters, VWG for the Bkg, Jpsi mpt = cte and Bkg mpt = pol4
+ //Fit mean dimuon mean pt to get Jpsi mean pt using the CB2 signal parameters, VWG for the Bkg, Jpsi mpt = cte and Bkg mpt = pol2
+ fHisto->GetListOfFunctions()->Delete();
+
+ Double_t alphaLow = GetValue("alJPsi");
+ Double_t nLow = GetValue("nlJPsi");
+ Double_t alphaUp = GetValue("auJPsi");
+ Double_t nUp = GetValue("nuJPsi");
+
+ Double_t kVWG = GetValue("kVWG");
+ Double_t mVWG = GetValue("mVWG");
+ Double_t sVWG1 = GetValue("sVWG1");
+ Double_t sVWG2 = GetValue("sVWG2");
+ Double_t kJPsi = GetValue("kJPsi");
+ Double_t kPsiP = GetValue("kPsiP");
+ Double_t mJPsi = GetValue("mJPsi");
+ Double_t sJPsi = GetValue("sJPsi");
+ Double_t NofJPsi = GetValue("NofJPsi");
+ Double_t ErrStatNofJPsi = GetErrorStat("NofJPsi");
+
+ Double_t fitRangeLow = GetValue(kFitRangeLow);
+ Double_t fitRangeHigh = GetValue(kFitRangeHigh);
+
+ // TString msg;
+ //
+ // if (IsValidValue(alphaLow)) msg += TString::Format("alphaLow=%e ",alphaLow);
+ // if (IsValidValue(nLow)) msg += TString::Format("nLow=%e ",nLow);
+ // if (IsValidValue(alphaUp)) msg += TString::Format("alphaUp=%e ",alphaUp);
+ // if (IsValidValue(nUp)) msg += TString::Format("nUp=%e ",nUp);
+ //
+ // AliDebug(1,Form("Mean pt fit with jpsi + psiprime (CB2),Bkg VWG and Pol2 for Bkg <pt> %s",msg.Data()));
+ //
+ // TF1* fitTotal = new TF1("signal+bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2VWG,fitRangeLow,fitRangeHigh,17,"AliAnalysisMuMuJpsiResult","FitFunctionTotalTwoCB2VWG");
+ //
+ //TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
+
+
+ // TString resultName(Form("MEANPTFIT_%salphalow=%5.2fnlow=%5.2falphaup=%5.2fnup=%5.2f",fitName.Data(),par[7],par[8],par[9],par[10]));
+ TProfile* p(0x0);
+ if ( fHisto->IsA() == TProfile::Class() ) p = static_cast<TProfile*>(fHisto);
+ else
+ {
+ AliError("Mean pt histo has to be a TProfile");
+ return;
+ }
+
+ //_____________
+ Int_t minBin = p->FindBin(fitRangeLow);
+ Int_t maxBin = p->FindBin(fitRangeHigh);
+
+ for ( Int_t i = minBin ; i <= maxBin ; i++ )
+ {
+ if ( p->GetBinEffectiveEntries(i) < 10 )
+ {
+ Double_t effEntries(0.),sumErr(0.);
+ for ( Int_t j = i - 5 ; j < i ; j++ )
+ {
+ if ( j <= 0 ) continue;
+ // if ( j > p->GetNbinsX() ) break;
+
+ effEntries += p->GetBinEffectiveEntries(j);
+ sumErr += p->GetBinEffectiveEntries(j)*p->GetBinError(j);
+ }
+
+ Double_t meanErr = sumErr/effEntries;
+
+ if ( p->GetBinError(i) < meanErr/2. )
+ {
+ std::cout << "Resetting bin " << i << " error" <<std::endl;
+ p->SetBinError(i,meanErr);
+ }
+ }
+ }
+ //_____________
+
+ TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol4,fitRangeLow,fitRangeHigh,5,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol4");
- fitTotal->SetParName(10, "b2");
- fitTotal->SetParameter(10,1.0);
- fitTotal->SetParLimits(10,0,1);
+ bck->SetParameters(3.,-0.5,-0.5,1.5,-0.01);
- fitTotal->SetParName(11, "norm");
- fitTotal->SetParameter(11,h.GetMaximum());
+ bck->SetParLimits(0, 1.,8.0);
- const char* fitOption = "QSIER"; //+";
+ SetFitRejectRange(2.7,4.0);
- TFitResultPtr fitResult = hfit->Fit(fitTotal,fitOption,"");
+ p->Fit(bck,"SER","");
- r->Set("MeanJpsi",fitTotal->GetParameter(6),fitTotal->GetParError(6));
- r->Set("SigmaJpsi",
- fitTotal->GetParameter(7)+fitTotal->GetParameter(8),
- 0.0);
+ SetFitRejectRange();
+
+ TF1* fitMeanpt = new TF1("fitMeanpt",this,&AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2CB2VWGPOL4,fitRangeLow,fitRangeHigh,19,"AliAnalysisMuMuJpsiResult","FitFunctionMeanPtS2CB2VWGPOL4");
+
+ fitMeanpt->SetParNames("kVWG","mVWG","sVWG1","sVWG2","kJPsi","mJPsi","sJPsi","alJPsi","nlJPsi","auJPsi","nuJPsi");
+ fitMeanpt->SetParName(11,"kPsiP");
+ fitMeanpt->SetParName(12,"<pt>JPsi");
+ fitMeanpt->SetParName(13,"<pt>BG0");
+ fitMeanpt->SetParName(14,"<pt>BG1");
+ fitMeanpt->SetParName(15,"<pt>BG2");
+ fitMeanpt->SetParName(16,"<pt>BG3");
+ fitMeanpt->SetParName(17,"<pt>BG4");
+ fitMeanpt->SetParName(18,"<pt>PsiP");
+
+ fitMeanpt->FixParameter(0,kVWG);
+ fitMeanpt->FixParameter(1,mVWG);
+ fitMeanpt->FixParameter(2,sVWG1);
+ fitMeanpt->FixParameter(3,sVWG2);
+ fitMeanpt->FixParameter(4,kJPsi);
+ fitMeanpt->FixParameter(5,mJPsi);
+ fitMeanpt->FixParameter(6,sJPsi);
+ fitMeanpt->FixParameter(7,alphaLow);
+ fitMeanpt->FixParameter(8,nLow);
+ fitMeanpt->FixParameter(9,alphaUp);
+ fitMeanpt->FixParameter(10,nUp);
+ fitMeanpt->FixParameter(11,kPsiP);
+
+ fitMeanpt->SetParameter(12, 3.);
+ fitMeanpt->SetParLimits(12, 2.0,4.);
+
+ for ( Int_t i = 0; i < 5; ++i )
+ {
+ fitMeanpt->SetParameter(i + 13, bck->GetParameter(i));
+ }
- double m = r->GetValue("MeanJpsi");
- double s = r->GetValue("SigmaJpsi");
- double n = 3.0;
+ fitMeanpt->SetParameter(18, 3.);
+ fitMeanpt->SetParLimits(18, 0.,10.);
+
+ const char* fitOption = "SER"; //+";//SER
- TLine* l1 = new TLine(m-n*s,0,m-n*s,fitTotal->GetParameter(11));
- TLine* l2 = new TLine(m+n*s,0,m+n*s,fitTotal->GetParameter(11));
- l1->SetLineColor(6);
- l2->SetLineColor(6);
- hfit->GetListOfFunctions()->Add(l1);
- hfit->GetListOfFunctions()->Add(l2);
+ TFitResultPtr fitResult = p->Fit(fitMeanpt,fitOption,"");
+
+ std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
- double njpsi = fitTotal->Integral(m-n*s,m+n*s)/h.GetBinWidth(1);
- double nerr = fitTotal->IntegralError(m-n*s,m+n*s)/h.GetBinWidth(1);
+ if ( static_cast<int>(fitResult) )
+ {
+ for ( Int_t i = 0; i < 5; ++i )
+ {
+ fitMeanpt->SetParameter(i + 13, bck->GetParameter(i)*0.9);
+ }
+ fitResult = p->Fit(fitMeanpt,fitOption,"");
+
+ std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
+ }
+ else if ( fitMeanpt->GetParameter(18) <= fitMeanpt->GetParError(18) || fitMeanpt->GetParError(18) >= 0.75*fitMeanpt->GetParameter(18) )
+ {
+ fitMeanpt->FixParameter(18, 0.);
+ for ( Int_t i = 0; i < 5; ++i )
+ {
+ fitMeanpt->SetParameter(i + 13, bck->GetParameter(i)*0.6);
+ }
+ fitResult = p->Fit(fitMeanpt,fitOption,"");
+
+ std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
+ }
+
+ for ( Int_t i = 0; i < 5; ++i )
+ {
+ bck->SetParameter(i, fitMeanpt->GetParameter(i+13));
+ }
- r->Set("NofJpsi",njpsi,nerr);
+ AttachFunctionsToHisto(0x0,bck,fitMeanpt,fitRangeLow,fitRangeHigh);//
- return r;
+ Set("NofJPsi",NofJPsi,ErrStatNofJPsi);
+ Set("MeanPtJPsi",fitMeanpt->GetParameter(12),fitMeanpt->GetParError(12));
+ Set("MeanPtPsiP",fitMeanpt->GetParameter(16),fitMeanpt->GetParError(16));
+
}
+//Int_t iparMinv[12] ={0,1,2,3,4,5,6,7,8,9,10,11};
+//Int_t iparMpt[17] ={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
+//
+//struct GlobalChi2 {
+// GlobalChi2( vector< ROOT::Fit::Chi2Function * > & fVec)
+// {
+// for(unsigned int i = 0; i < fVec.size(); i++){
+// fChi2_Vec.push_back( fVec[i] );
+// }
+// }
+//
+// // parameter vector is first background (in common 1 and 2)
+// // and then is signal (only in 2)
+// double operator() (const double *par) const {
+// vector< vector<double> > pVec;
+// vector< double > dummyVec;
+// for (int i = 0; i < 2; ++i) dummyVec.push_back(par[iparMinv[i] ]);
+// pVec.push_back(dummyVec);
+//
+// dummyVec.clear();
+// for (int i = 0; i < 5; ++i) dummyVec.push_back(par[iparMpt[i] ]);
+// pVec.push_back(dummyVec);
+//
+// double val = 0;
+// for( size_t i = 0; i < fChi2_Vec.size(); i++ ){
+// val += (*fChi2_Vec[i])(&(pVec[i][0]));
+// }
+//
+// return val;
+// }
+//
+// vector< const ROOT::Math::IMultiGenFunction * > fChi2_Vec;
+//};
+
+////_____________________________________________________________________________
+//void AliAnalysisMuMuJpsiResult::FitPSIPSIPRIMECOMB_CB2VWG_MPTCB2VWG_BKGMPTPOL2()
+//{
+//
+// //============== Take the initial parameters if any
+// fHisto->GetListOfFunctions()->Delete(); //Minv Histo
+//
+// Double_t alphaLow = GetValue("alJPsi"); //Initial parameters for Minv Fit
+// Double_t nLow = GetValue("nlJPsi");
+// Double_t alphaUp = GetValue("auJPsi");
+// Double_t nUp = GetValue("nuJPsi");
+// Double_t fitRangeLow = GetValue(kFitRangeLow);
+// Double_t fitRangeHigh = GetValue(kFitRangeHigh);
+// Double_t paramSPsiP = GetValue("FSigmaPsiP");
+//
+// TString msg;
+//
+// if (IsValidValue(alphaLow)) msg += TString::Format("alphaLow=%e ",alphaLow);
+// if (IsValidValue(nLow)) msg += TString::Format("nLow=%e ",nLow);
+// if (IsValidValue(alphaUp)) msg += TString::Format("alphaUp=%e ",alphaUp);
+// if (IsValidValue(nUp)) msg += TString::Format("nUp=%e ",nUp);
+//
+// AliDebug(1,Form("Fit with jpsi + psiprime VWG %s",msg.Data()));
+//
+// //==============
+//
+// //============== Definition of the Minv and Mpt fitting funtions
+// //_____Minv
+// TF1* fitTotalMinv = new TF1("signal+bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2VWG,fitRangeLow,fitRangeHigh,12,"AliAnalysisMuMuJpsiResult","FitFunctionTotalTwoCB2VWG");
+//
+// fitTotalMinv->SetParNames("kVWG","mVWG","sVWG1","sVWG2","kJPsi","mJPsi","sJPsi",
+// // 0 1 2 3 4 5 6
+// "alJPsi","nlJPsi","auJPsi","nuJPsi");
+// // 7 8 9 10
+// fitTotalMinv->SetParName(11, "kPsiP");
+// // 11
+//
+//
+// TF1* bckMinv = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundVWG,fitRangeLow,fitRangeHigh,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundVWG");
+//
+// const char* fitOption = "SER"; //We can add NO to avoid plotting
+//
+// Int_t bin = fHisto->FindBin(0.26);
+//
+// bckMinv->SetParameters(fHisto->GetBinContent(bin),2.,0.5,0.3);
+//
+// SetFitRejectRange(2.7,4.0);
+//
+// TFitResultPtr fitResultInit = fHisto->Fit(bckMinv,"SR");
+//
+// std::cout << "FitResultBkgInit=" << static_cast<int>(fitResultInit) << std::endl;
+//
+// if ( static_cast<int>(fitResultInit) )
+// {
+// bin = fHisto->FindBin(0.82);
+// bckMinv->SetParameters(fHisto->GetBinContent(bin),2.,0.5,0.3);
+// fitResultInit = fHisto->Fit(bckMinv,"SR");
+// }
+// else if ( bckMinv->GetParameter(0) < 0 )
+// {
+// bckMinv->SetParameters(fHisto->GetBinContent(bin),2.,0.5,0.3);
+// }
+//
+// SetFitRejectRange();
+//
+// TH1* fHistoMpt(0x0);
+// //______Mpt
+// TProfile* p(0x0);
+// if ( fHistoMpt->IsA() == TProfile::Class() ) p = static_cast<TProfile*>(fHistoMpt);
+// else
+// {
+// AliError("Mean pt histo has to be a TProfile");
+// return;
+// }
+//
+// //_____________ To assing a correct error to bins with low nEntries
+// Int_t minBin = p->FindBin(fitRangeLow);
+// Int_t maxBin = p->FindBin(fitRangeHigh);
+//
+// for ( Int_t i = minBin ; i <= maxBin ; i++ )
+// {
+// if ( p->GetBinEffectiveEntries(i) < 10 )
+// {
+// Double_t effEntries(0.),sumErr(0.);
+// for ( Int_t j = i - 5 ; j < i ; j++ )
+// {
+// if ( j <= 0 ) continue;
+//
+// effEntries += p->GetBinEffectiveEntries(j);
+// sumErr += p->GetBinEffectiveEntries(j)*p->GetBinError(j);
+// }
+//
+// Double_t meanErr = sumErr/effEntries;
+//
+// if ( p->GetBinError(i) < meanErr/2. )
+// {
+// std::cout << "Resetting bin " << i << " error" <<std::endl;
+// p->SetBinError(i,meanErr);
+// }
+// }
+// }
+// //_____________
+//
+// TF1* bckMpt = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
+//
+// bckMpt->SetParameters(3.,1.,0.);
+//
+// bckMpt->SetParLimits(0, 1.,8.0);
+//
+// SetFitRejectRange(2.3,4.0);
+//
+// p->Fit(bckMpt,"SER","",fitRangeLow,fitRangeHigh);
+//
+// SetFitRejectRange();
+//
+// TF1* fitMeanpt = new TF1("fitMeanpt",this,&AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2CB2VWGPOL2,fitRangeLow,fitRangeHigh,17,"AliAnalysisMuMuJpsiResult","FitFunctionMeanPtS2CB2VWGPOL2");
+//
+// fitMeanpt->SetParNames("kVWG","mVWG","sVWG1","sVWG2","kJPsi","mJPsi","sJPsi","alJPsi","nlJPsi","auJPsi","nuJPsi");
+// fitMeanpt->SetParName(11,"kPsiP");
+// fitMeanpt->SetParName(12,"<pt>JPsi");
+// fitMeanpt->SetParName(13,"<pt>BG0");
+// fitMeanpt->SetParName(14,"<pt>BG1");
+// fitMeanpt->SetParName(15,"<pt>BG2");
+// fitMeanpt->SetParName(16,"<pt>PsiP");
+// //___________
+//
+// //============== End of definition of the Minv and Mpt fitting funtions
+//
+//
+//
+// //============== Set the initial parameters in the Minv and Mpt fitting funtions
+// Double_t parMinv[12] ={0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.};
+// Double_t parMpt[17] ={0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.};
+//
+//
+// for ( Int_t i = 0; i < 4; ++i )
+// {
+// fitTotalMinv->SetParameter(i, bckMinv->GetParameter(i));
+// fitMeanpt->SetParameter(i, bckMinv->GetParameter(i));
+// parMinv[i] = bckMinv->GetParameter(i);
+// parMpt[i] = bckMinv->GetParameter(i);
+// }
+//
+// bin = fHisto->FindBin(3.09);
+// fitTotalMinv->SetParameter(4, fHisto->GetBinContent(bin)); // norm
+// fitMeanpt->SetParameter(4, fHisto->GetBinContent(bin)); // norm
+// parMinv[4] = fHisto->GetBinContent(bin);
+// parMpt[4] = fHisto->GetBinContent(bin);
+//
+// fitTotalMinv->SetParameter(5, 3.1); // mean
+// fitTotalMinv->SetParLimits(5, 3.0, 3.2);
+// fitMeanpt->SetParameter(5, 3.1); // mean
+// fitMeanpt->SetParLimits(5, 3.0, 3.2);
+// parMinv[5] = 3.1;
+// parMpt[5] = 3.1;
+//
+// fitTotalMinv->SetParameter(6, 0.08); // sigma
+// fitTotalMinv->SetParLimits(6, 0.05, 0.09);
+// fitMeanpt->SetParameter(6, 0.08); // sigma
+// fitMeanpt->SetParLimits(6, 0.05, 0.09);
+// parMinv[6] = 0.08;
+// parMpt[6] = 0.08;
+//
+//
+// fitTotalMinv->SetParameter(7,0.9);
+// fitTotalMinv->SetParLimits(7,0.1,10.0);
+// fitMeanpt->SetParameter(7,0.9);
+// fitMeanpt->SetParLimits(7,0.1,10.0);
+// parMinv[7] = 0.9;
+// parMpt[7] = 0.9;
+//
+// fitTotalMinv->SetParameter(8,5.0);
+// fitTotalMinv->SetParLimits(8,0.0,10.0);
+// fitMeanpt->SetParameter(8,5.0);
+// fitMeanpt->SetParLimits(8,0.0,10.0);
+// parMinv[8] = 5.0;
+// parMpt[8] = 5.0;
+//
+//
+// fitTotalMinv->SetParameter(9, 2.0);
+// fitTotalMinv->SetParLimits(9,0.1,10.0);
+// fitMeanpt->SetParameter(9, 2.0);
+// fitMeanpt->SetParLimits(9,0.1,10.0);
+// parMinv[9] = 2.0;
+// parMpt[9] = 2.0;
+//
+// fitTotalMinv->SetParameter(10,3.0);
+// fitTotalMinv->SetParLimits(10,0.0,10.0);
+// fitMeanpt->SetParameter(10,3.0);
+// fitMeanpt->SetParLimits(10,0.0,10.0);
+// parMinv[10] = 3.0;
+// parMpt[10] = 3.0;
+//
+//
+// fitTotalMinv->SetParameter(11, 10.); //kPsi'
+// fitTotalMinv->SetParLimits(11, 0.,100000.);
+// fitMeanpt->SetParameter(11, 10.); //kPsi'
+// fitMeanpt->SetParLimits(11, 0.,100000.);
+// parMinv[11] = 10.;
+// parMpt[11] = 10.;
+//
+//
+// fitMeanpt->SetParameter(12, 3.);
+// fitMeanpt->SetParLimits(12, 1.0,5.);
+// parMpt[12] = 3.;
+//
+// for ( Int_t i = 0; i < 3; ++i )
+// {
+// fitMeanpt->SetParameter(i + 13, bckMpt->GetParameter(i));
+// parMpt[i + 13] = bckMpt->GetParameter(i);
+// }
+//
+// fitMeanpt->SetParameter(16, 3.);
+// parMpt[16] = 3.;
+// Double_t psipPtLim = 10.;
+// fitMeanpt->SetParLimits(16, 0.,psipPtLim);
+//
+// //================== End of setting Minv and Mpt initial parameters
+//
+// //================== Chi2 definition for the global fit
+//
+//
+//
+//// struct GlobalChi2 {
+//// GlobalChi2( ROOT::Math::IMultiGenFunction & f1,
+//// ROOT::Math::IMultiGenFunction & f2) :
+//// fChi2_1(&f1), fChi2_2(&f2) {}
+////
+//// // parameter vector is first background (in common 1 and 2)
+//// // and then is signal (only in 2)
+//// double operator() (const double *par) const {
+//// double p1[12];
+//// for (int i = 0; i < 12; ++i) p1[i] = par[iparMinv[i] ];
+////
+//// double p2[17];
+//// for (int i = 0; i < 17; ++i) p2[i] = par[iparMpt[i] ];
+////
+//// return (*fChi2_1)(p1) + (*fChi2_2)(p2);
+//// }
+////
+//// const ROOT::Math::IMultiGenFunction * fChi2_1;
+//// const ROOT::Math::IMultiGenFunction * fChi2_2;
+//// };
+// //================== End of chi2 definition for the global fit
+//
+//
+//
+// //================== Combined fit
+// ROOT::Math::WrappedMultiTF1 wfMinv(*fitTotalMinv,1);
+// ROOT::Math::WrappedMultiTF1 wfMpt(*fitMeanpt,1);
+//
+// ROOT::Fit::DataOptions opt;
+// ROOT::Fit::DataRange rangeMinv;
+// // set the data range
+// rangeMinv.SetRange(fitRangeLow,fitRangeHigh);
+// ROOT::Fit::BinData dataMinv(opt,rangeMinv);
+// ROOT::Fit::FillData(dataMinv, fHisto);
+//
+// ROOT::Fit::DataRange rangeMpt;
+// rangeMpt.SetRange(fitRangeLow,fitRangeHigh);
+// ROOT::Fit::BinData dataMpt(opt,rangeMpt);
+// ROOT::Fit::FillData(dataMpt, fHistoMpt);
+//
+//// ROOT::Fit::Chi2Function chi2_Minv(dataMinv, wfMinv);
+//// ROOT::Fit::Chi2Function chi2_Mpt(dataMpt, wfMpt);
+//
+// vector< ROOT::Fit::Chi2Function * > chi2_vec;
+// chi2_vec.push_back( new ROOT::Fit::Chi2Function(dataMinv, wfMinv) );
+// chi2_vec.push_back( new ROOT::Fit::Chi2Function(dataMpt, wfMpt) );
+//
+// GlobalChi2 globalChi2(chi2_vec);
+//
+//// GlobalChi2 globalChi2(chi2_Minv, chi2_Mpt);
+//
+// ROOT::Fit::Fitter fitter;
+//
+//// const int Npar = 6;
+//// double par0[Npar] = { 5,5,-0.1,100, 30,10};
+////
+//// // create before the parameter settings in order to fix or set range on them
+//// fitter.Config().SetParamsSettings(6,par0);
+// // fix 5-th parameter
+//// fitter.Config().ParSettings(4).Fix();
+//// // set limits on the third and 4-th parameter
+//// fitter.Config().ParSettings(2).SetLimits(-10,-1.E-4);
+//// fitter.Config().ParSettings(3).SetLimits(0,10000);
+//// fitter.Config().ParSettings(3).SetStepSize(5);
+//
+// fitter.Config().MinimizerOptions().SetPrintLevel(0);
+// fitter.Config().SetMinimizer("Minuit2","Migrad");
+//
+// // fit FCN function directly
+// // (specify optionally data size and flag to indicate that is a chi2 fit)
+// fitter.FitFCN(6,globalChi2,0,dataMinv.Size()+dataMpt.Size(),true);
+// ROOT::Fit::FitResult result = fitter.Result();
+// result.Print(std::cout);
+//
+// TCanvas * c1 = new TCanvas("Simfit","Simultaneous fit of two histograms",
+// 10,10,700,700);
+// c1->Divide(1,2);
+// c1->cd(1);
+// gStyle->SetOptFit(1111);
+//
+// fitTotalMinv->SetFitResult( result, iparMinv);
+// fitTotalMinv->SetRange(rangeMinv().first, rangeMinv().second);
+// fitTotalMinv->SetLineColor(kBlue);
+//// hB->GetListOfFunctions()->Add(fB);
+// fitTotalMinv->Draw();
+//
+// c1->cd(2);
+// fitMeanpt->SetFitResult( result, iparMpt);
+// fitMeanpt->SetRange(rangeMpt().first, rangeMpt().second);
+// fitMeanpt->SetLineColor(kRed);
+//// fitMeanpt->GetListOfFunctions()->Add(fSB);
+// fitMeanpt->Draw();
+//
+////==============
+//}
+
//_____________________________________________________________________________
-Bool_t AliAnalysisMuMuJpsiResult::AddFit(const char* fitType, Int_t npar, Double_t* par)
+Bool_t AliAnalysisMuMuJpsiResult::AddFit(const char* fitType)
{
// Add a fit to this result
- TString msg(Form("fitType=%s npar=%d par[]=",fitType,npar));
+ if ( !fHisto ) return kFALSE;
+
+ TH1* histo = static_cast<TH1*>(fHisto->Clone(fitType));
- for ( Int_t i = 0; i < npar; ++i )
+ AliAnalysisMuMuJpsiResult* r = new AliAnalysisMuMuJpsiResult(GetParticle(),*histo,fitType);
+
+ if ( !r->IsValid() )
{
- msg += TString::Format("%e,",par[i]);
+ delete r;
+ return kFALSE;
}
- msg += TString::Format(" minv=%p %d",fMinv,fMinv?TMath::Nint(fMinv->GetEntries()):0);
+ TMethodCall callEnv;
+
+ TString fittingMethod(r->GetFitFunctionMethodName().Data());
- if ( !fMinv ) return kFALSE;
+ std::cout << "+Using fitting method " << fittingMethod.Data() << "..." << std::endl;
+ std::cout << "" << std::endl;
- TString sFitType(fitType);
- sFitType.ToUpper();
- Int_t nrebin(1);
+ callEnv.InitWithPrototype(IsA(),fittingMethod.Data(),"");
- if (sFitType.CountChar(':'))
+ if (callEnv.IsValid())
+ {
+ callEnv.Execute(r);
+ }
+ else
{
- Int_t index = sFitType.Index(":");
- nrebin = TString(sFitType(index+1,sFitType.Length()-index-1)).Atoi();
- sFitType = sFitType(0,index);
+ AliError(Form("Could not get the method %s",fittingMethod.Data()));
+ delete r;
+ return kFALSE;
}
- msg += TString::Format(" nrebin=%d",nrebin);
+// Float_t lpar[] = { -1.0, -1.0, -1.0, -1.0 }; // free tails by default
+//
+// Bool_t ok(kTRUE);
+//
+// if ( fitFunction.Contains("CB2") )
+// {
+// if ( extra.Length() )
+// {
+// AliDebug(1,Form("sFitType=%s",fitType));
+//
+// sscanf(extra,"ALPHALOW%fNLOW%fALPHAUP%fNUP%f",
+// &lpar[0],&lpar[1],&lpar[2],&lpar[3]);
+//
+// AliDebug(1,Form("PSILOW ALPHALOW=%f NLOW=%f ALPHAUP=%f NUP=%f",lpar[0],lpar[1],lpar[2],lpar[3]));
+// }
+//
+// if ( lpar[0] == 0.0 && lpar[1] == 0.0 && lpar[0] == 0.0 && lpar[1] == 0.0 )
+// {
+// AliError("Cannot work with zero tails !");
+// ok = kFALSE;
+// }
+// }
- AliDebug(1,msg.Data());
+// if ( ok == kTRUE )
+// {
+//
+// if ( fitFunction=="PSICB2" )
+// {
+// r = FitPSICB2(*hminv,fitMinvMin,fitMinvMax);
+// }
+// else if ( fitFunction == "PSIPSIPRIMECB2VWG")
+// {
+// r = FitPSIPSIPRIMECB2VWG(*hminv,fitMinvMin,fitMinvMax,lpar[0],lpar[1],lpar[2],lpar[3]);
+// }
+//// else if ( fitFunction == "PSIPSIPRIMECB2POL2EXP")
+//// {
+//// r = FitPSIPSIPRIMECB2POL2EXP(*hminv,fitMinvMin,fitMinvMax,lpar[0],lpar[1],lpar[2],lpar[3]);
+//// }
+// else if ( fitFunction == "PSILOWMCTAILS" )
+// {
+// if ( npar!= 4 )
+// {
+// AliError("Cannot use PSILOWMCTAILS without being given the MC tails !");
+// delete hminv;
+// return kFALSE;
+// }
+// r = FitPSIPSIPRIMECB2VWG(*hminv,fitMinvMin,fitMinvMax,par[0],par[1],par[2],par[3]);
+// if (r)
+// {
+// r->SetAlias("MCTAILS");
+// }
+// }
+// else if ( fitFunction == "COUNTJPSI" )
+// {
+// r = new AliAnalysisMuMuJpsiResult(*hminv,"COUNTJPSI");
+// Double_t n = CountParticle(*hminv,"Jpsi");
+// r->Set("NofJPsi",n,TMath::Sqrt(n));
+// }
+//
+// }
+ if ( r->IsValid() )
+ {
+ StdoutToAliDebug(1,r->Print(););
+ r->SetBin(Bin());
+ r->SetNofTriggers(NofTriggers());
+ r->SetNofRuns(NofRuns());
- if ( fMinv->GetEntries()<100 && !sFitType.Contains("COUNT")) return kFALSE;
+ Bool_t adoptOK = AdoptSubResult(r);
+ if ( adoptOK ) std::cout << "Subresult " << r->GetName() << " adopted in " << GetName() << std::endl;
+ else AliError(Form("Could not adopt subresult %s",r->GetName()));
+ }
+ else
+ {
+ delete r;
+ r=0x0;
+ }
- TH1* hminv = static_cast<TH1*>(fMinv->Clone());
+ return (r!=0x0);
+}
+
+//_____________________________________________________________________________
+void AliAnalysisMuMuJpsiResult::DecodeFitType(const char* fitType)
+{
+ /// decode the string containing all the information for the fit to be done
+ ///
+ /// the fittype is a combination of key=value pairs separated by ":"
+ /// +func=Name fo the function used in the fit(See ? to read the naming convention)
+ /// +rebin=Rebin of the histo(1,2...)
+ /// +histoType=The type of histo we wan to fit(minv,mpt ???or minv&mpt for a combined fit???)
+ /// +tails=from where we take the particle tails(mctails,mctailsJPsi&PsiP to use an indep sets of tails for each particle, predefined tails)
+ /// +alJpsi , nlPsiP ... = Fit parameters (they carry the parameter name and the particle name)
+ ///
+ /// e.g.
+ /// func=gaus:rebin=2:range=2.3;4.7;nsigmas=3
+ /// func=vwm+cb2:range=2;5;alphalow=5.2;alphahigh=6.2
+ ///
+ /// except from the func key, all the other ones have default values
+ /// if the key is different from func,rebin,range,histoType it is assumed
+ /// to be the value for a parameter of the fit function.
- hminv->Rebin(nrebin);
- hminv->SetDirectory(0);
+ TString resultName("");
- AliAnalysisMuMuJpsiResult* r(0x0);
+ // default values
+ TString fitFunction;
+ TString histoType("minv");
+ TString tails("");
+ Int_t rebin=1;
+ Double_t fitMinvMin=2.0;
+ Double_t fitMinvMax=5.0;
+ Double_t paramSPsiP= 3.68609/3.096916;
- if ( sFitType=="PSI1")
- {
- r = FitJpsi(*hminv);
- }
- else if ( sFitType == "PSILOW")
- {
- r = FitJpsi2CB2VWG(*hminv,-1,-1,-1,-1); // free tails
- }
- else if ( sFitType == "PSILOWMCTAILS" )
+ TString sFitType(fitType);
+
+ if (!sFitType.Contains(kKeyFunc,TString::kIgnoreCase)) return;
+
+ TObjArray* parts = sFitType.Tokenize(":");
+ TObjString* str;
+ TIter next(parts);
+
+ while ( ( str = static_cast<TObjString*>(next()) ) )
{
- if ( npar!= 4 )
+ TString key,value;
+ Bool_t ok = GetKeyValue(str->String(),'=',key,value);
+ if (!ok)
{
- AliError("Cannot use PSILOWMCTAILS without being given the MC tails !");
- delete hminv;
- return kFALSE;
+ AliErrorClass(Form("Invalid key=value pair %s",str->String().Data()));
+ continue;
}
- r = FitJpsi2CB2VWG(*hminv,par[0],par[1],par[2],par[3]);
- if (r)
+
+ if ( key.CompareTo(kKeyFunc,TString::kIgnoreCase) == 0 )
{
- r->SetAlias("MCTAILS");
+ fitFunction = value;
+ resultName += fitFunction;
}
- }
- else if ( sFitType.BeginsWith("PSILOWALPHA") )
- {
- Float_t lpar[] = { 0.0, 0.0, 0.0, 0.0 };
-
- AliDebug(1,Form("sFitType=%s",sFitType.Data()));
-
- sscanf(sFitType.Data(),"PSILOWALPHALOW%fNLOW%fALPHAUP%fNUP%f",
- &lpar[0],&lpar[1],&lpar[2],&lpar[3]);
-
- AliDebug(1,Form("PSILOW ALPHALOW=%f NLOW=%f ALPHAUP=%f NUP=%f",lpar[0],lpar[1],lpar[2],lpar[3]));
-
- if ( lpar[0] == 0.0 && lpar[1] == 0.0 && lpar[0] == 0.0 && lpar[1] == 0.0 )
+ else if ( key.CompareTo(kKeyRange,TString::kIgnoreCase) == 0 )
+ {
+ TString xmin,xmax;
+ if (GetKeyValue(value,';',xmin,xmax))
+ {
+ fitMinvMin = xmin.Atof();
+ fitMinvMax = xmax.Atof();
+ AliInfoClass(Form("xmin=%e xmax=%e",fitMinvMin,fitMinvMax));
+
+ resultName += "_";
+ resultName += xmin.Data();
+ resultName += "-";
+ resultName += xmax.Data();
+ }
+ else
+ {
+ AliErrorClass(Form("Improper range specification %s",value.Data()));
+ continue;
+ }
+ }
+ else if ( key.CompareTo(kKeyRebin,TString::kIgnoreCase) == 0 )
+ {
+ rebin = value.Atoi();
+ }
+ else if ( key.CompareTo(kKeyHistoType,TString::kIgnoreCase) == 0 ) //FIXME::Is really necesary to save the histoType? I think I dont use it
+ {
+ histoType = value;
+
+ if ( histoType.CompareTo("minv",TString::kIgnoreCase) == 0 ) Set(kKeyHistoType,0.,0.0); //histoType=0 means minv histo
+ else if ( histoType.CompareTo("mpt",TString::kIgnoreCase) == 0 ) Set(kKeyHistoType,1.,0.0); //histoType=1 means mpt histo
+ else if ( histoType.CompareTo("minv&mpt",TString::kIgnoreCase) == 0 ) Set(kKeyHistoType,2.,0.0); //histoType=1 means combined fit minv and mpt
+ else
+ {
+ AliErrorClass(Form("Improper histoType specification %s",value.Data()));
+ continue;
+ }
+
+ }
+ else if ( key.CompareTo(kKeyTails,TString::kIgnoreCase) == 0 )
{
- AliError("Cannot work with zero tails !");
+ tails = value;
+ if ( tails.CompareTo("mctails",TString::kIgnoreCase) == 0 ) Set(kKeyTails,0.,0.0);
+ else if ( tails.CompareTo("mctailsJPsi&PsiP",TString::kIgnoreCase) == 0 ) Set(kKeyTails,1.,0.0);
+ else if ( tails.CompareTo("",TString::kIgnoreCase) == 0 ) Set(kKeyTails,2.,0.0); // Predefined tails
+ else
+ {
+ AliErrorClass(Form("Improper tails specification %s",value.Data()));
+ continue;
+ }
+ }
+ else if ( key.CompareTo(kKeySPsiP,TString::kIgnoreCase) == 0 )
+ {
+ paramSPsiP = value.Atof();
+ }
+ else if ( key.CompareTo(kKeyMinvRS,TString::kIgnoreCase) == 0 )
+ {
+ fMinvRS = value.Data();
}
else
{
- r = FitJpsi2CB2VWG(*hminv,lpar[0],lpar[1],lpar[2],lpar[3]);
+ Set(key.Data(),value.Atof(),0.0);
}
}
- else if ( sFitType == "COUNTJPSI" )
+
+ if ( fitFunction.CountChar('-') )
{
- r = new AliAnalysisMuMuJpsiResult(*hminv,"COUNTJPSI",1);
- Double_t n = CountParticle(*hminv,"Jpsi");
- r->Set("NofJpsi",n,TMath::Sqrt(n));
+ AliError(Form("Invalid fit function name : %s",fitFunction.Data()));
+ Invalidate();
}
-
-
- if ( r )
+ else
{
- StdoutToAliDebug(1,r->Print(););
- r->SetBin(Bin());
- r->SetNofTriggers(NofTriggers());
- r->SetNofRuns(NofRuns());
+
+ fFitFunction = fitFunction;
- AdoptSubResult(r);
+ Set(kKeySPsiP,paramSPsiP,0.0);
+ Set(kKeyRebin,rebin,0.0);
+ Set(kFitRangeLow,fitMinvMin,0.0);
+ Set(kFitRangeHigh,fitMinvMax,0.0);
}
- delete hminv;
-
- return (r!=0x0);
+ delete parts;
+}
+
+//_____________________________________________________________________________
+TString AliAnalysisMuMuJpsiResult::GetFitFunctionMethodName() const
+{
+ /// Get the name of the function used to fit this result (if any)
+ TString name(FitFunctionName());
+ if ( name.CountChar('-') )
+ {
+ return "";
+ }
+ if ( GetValue("tails") == 1. ) name += "INDEPTAILS";
+ return TString::Format("Fit%s",name.Data());
}
//_____________________________________________________________________________
else Mother()->SetBin(bin);
}
+//_____________________________________________________________________________
+void AliAnalysisMuMuJpsiResult::SetFitRejectRange(Double_t a, Double_t b)
+{
+ /// Set a range the fit function(s) can ignore
+
+ fRejectFitPoints = kFALSE;
+
+ fFitRejectRangeLow = a;
+ fFitRejectRangeHigh = b;
+ if ( a <= TMath::Limits<Double_t>::Max() && b <= TMath::Limits<Double_t>::Max() )
+ {
+ fRejectFitPoints = kTRUE;
+ }
+}
+
+//_____________________________________________________________________________
+void AliAnalysisMuMuJpsiResult::SetHisto(const TH1& h)
+{
+ /// Set the spectrum to be fitted.
+ static UInt_t n(0);
+
+ delete fHisto;
+ fHisto = static_cast<TH1*>(h.Clone(Form("AliAnalysisMuMuJpsiResultHisto%u",n++)));
+ fHisto->SetDirectory(0);
+}
+
//_____________________________________________________________________________
void AliAnalysisMuMuJpsiResult::SetNofInputParticles(const TH1& hminv)
{
/// Set the number of input particle from the invariant mass spectra
- static const char* particleNames[] = { "Jpsi" , "PsiPrime", "Upsilon","UpsilonPrime" };
+ static const char* particleNames[] = { "JPsi" , "PsiP", "Upsilon","UpsilonPrime" };
const std::map<std::string,Double_t>& m = MassMap();
else Mother()->SetNofTriggers(n);
}
+
//_____________________________________________________________________________
-void AliAnalysisMuMuJpsiResult::SetMinv(const TH1& hminv)
+void AliAnalysisMuMuJpsiResult::SetParameter(TF1* func, Int_t npar, Double_t fix, Double_t initialValue,
+ Double_t min, Double_t max) const
{
- /// Set the inv. mass spectrum to be fitted.
- static UInt_t n(0);
+ /// Fix one parameter or set its initial value and limits
+
+ if ( IsValidValue(fix) )
+ {
+ func->FixParameter(npar, fix);
+ }
+ else
+ {
+ func->SetParameter(npar,initialValue);
+ func->SetParLimits(npar,min,max);
+ }
+}
+
+//_____________________________________________________________________________
+Bool_t AliAnalysisMuMuJpsiResult::StrongCorrelation(TFitResultPtr& r,
+ TF1* fitFunction,
+ Int_t npar1,
+ Int_t npar2,
+ Double_t fixValueIfWrong)
+{
+ // return kTRUE if the npar1-th and npar2-th parameters of the fit function
+ // are too strongly correlated,
+ // and in that case fix the npar2-th parameter's value to fixValueIfWrong
+
+ Bool_t strongCorrelation = TMath::Abs(r->GetCorrelationMatrix()(npar1,npar2)) > 0.90;
- delete fMinv;
- fMinv = static_cast<TH1*>(hminv.Clone(Form("Minv%u",n++)));
- fMinv->SetDirectory(0);
+ if ( strongCorrelation )
+ {
+ fitFunction->FixParameter(npar2,fixValueIfWrong);
+ return kTRUE;
+ }
+ return kFALSE;
+}
+
+//_____________________________________________________________________________
+Bool_t AliAnalysisMuMuJpsiResult::WrongParameter(TF1* fitFunction, Int_t npar,
+ Double_t fixValueIfWrong)
+{
+ // return kTRUE if npar-th parameter of fit function has a big error,
+ // and in that case fix the parameter's value to fixValueIfWrong
+
+ Bool_t wrong = (fitFunction->GetParError(npar) > 0.8*TMath::Abs(fitFunction->GetParameter(npar)));
+
+ AliWarning(Form("npar %d error %e val %e wrong %d",
+ npar,fitFunction->GetParError(npar),
+ fitFunction->GetParameter(npar),wrong));
+
+ if ( wrong )
+ {
+ AliWarning(Form("Fixing parameter %d of %s to %e",
+ npar,fitFunction->GetName(),fixValueIfWrong));
+
+ fitFunction->FixParameter(npar,fixValueIfWrong);
+ return kTRUE;
+ }
+ return kFALSE;
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff