PWG/muondep/AliAnalysisMuMuJpsiResult.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 ///
  17 /// Class to hold results about J/psi
  18 /// like number of of J/psi (before and after Acc x Eff correction),
  19 /// Acc x Eff correction, Yield, RAB, etc...
  20 ///
  21 /// A note on "naming conventions"
  22 ///
  23 /// FitFunctionXY : denotes a function with a prototype double func(double*,double*)
  24 /// which can be used in a fit. X = Background, Signal or Total for Background+Signal
  25 /// Y is the functio name
  26 ///
  27 ///
  28 /// author: Laurent Aphecetche (Subatech)
  29 ///
  30
  31 #include "AliAnalysisMuMuJpsiResult.h"
  32
  33 ClassImp(AliAnalysisMuMuJpsiResult)
  34
  35 #include "TF1.h"
  36 #include "TProfile.h"
  37 #include "TFitResult.h"
  38 #include "TH1.h"
  39 #include "TH2.h"
  40 #include "THashList.h"
  41 #include "TLine.h"
  42 #include "TList.h"
  43 #include "TMap.h"
  44 #include "TMath.h"
  45 #include "TMethodCall.h"
  46 #include "TObjArray.h"
  47 #include "TParameter.h"
  48 #include "AliAnalysisMuMuBinning.h"
  49 #include "AliLog.h"
  50 #include <map>
  51
  52 #include "Fit/Fitter.h"
  53 #include "Fit/BinData.h"
  54 #include "Fit/Chi2FCN.h"
  55 #include "Math/WrappedMultiTF1.h"
  56 #include "HFitInterface.h"
  57 #include "TCanvas.h"
  58 #include "TStyle.h"
  59
  60
  61 namespace {
  62
  63   //____________________________________________________________________________
  64   const std::map<std::string,Double_t>& MassMap()
  65   {
  66     /// a simple map of masses...
  67     static std::map<std::string,Double_t> massMap;
  68     // not super elegant, but that way we do not depend on TDatabasePDG and thus
  69     // can decide on our particle naming
  70     if (massMap.empty())
  71     {
  72       massMap["JPsi"] = 3.096916e+00;
  73       massMap["PsiP"] = 3.68609e+00;
  74       massMap["Upsilon"] = 9.46030e+00;
  75       massMap["UpsilonPrime"] = 1.00233e+01;
  76     }
  77     return massMap;
  78   }
  79
  80   //____________________________________________________________________________
  81   Bool_t GetKeyValue(const TString& str, const char separator, TString& key, TString& value)
  82   {
  83     /// Get a key value pair, separated by separator character
  84     key=value="";
  85     if ( !str.CountChar(separator) ) return kFALSE;
  86     Int_t index = str.Index(separator);
  87     key = str(0,index);
  88     value = str(index+1,str.Length()-index-1);
  89     return kTRUE;
  90   }
  91
  92   const TString kKeyFunc = "Func";
  93   const TString kKeyRange = "Range";
  94   const TString kKeyRebin = "Rebin";
  95   const TString kFitRangeLow = "FitRangeLow";
  96   const TString kFitRangeHigh = "FitRangeHigh";
  97   const TString kKeyCount = "Count";
  98   const TString kKeyHistoType = "HistoType";
  99   const TString kKeyTails = "Tails";
 100   const TString kKeySPsiP = "FSigmaPsiP"; //Factor to fix the psi' sigma to sigmaJPsi*SigmaPsiP (Usually factor SigmaPsiP = 1, 0.9 and 1.1)
 101   const TString kKeyMinvRS = "MinvRS"; // FIXME: not very correct since "MinvRS" is in AliAnalysisMuMu::GetParametersFromResult
 102
 103 }
 104
 105 //_____________________________________________________________________________
 106 AliAnalysisMuMuJpsiResult::AliAnalysisMuMuJpsiResult(TRootIOCtor* /*io*/) :
 107 AliAnalysisMuMuResult("",""),
 108 fNofRuns(),
 109 fNofTriggers(-1),
 110 fHisto(0x0),
 111 fBin(),
 112 fTriggerClass(),
 113 fEventSelection(),
 114 fPairSelection(),
 115 fCentralitySelection(),
 116 fFitFunction(),
 117 fFitRejectRangeLow(TMath::Limits<Double_t>::Max()),
 118 fFitRejectRangeHigh(TMath::Limits<Double_t>::Max()),
 119 fRejectFitPoints(kFALSE),
 120 fParticle(""),
 121 fMinvRS("")
 122 {
 123 }
 124
 125 //_____________________________________________________________________________
 126 AliAnalysisMuMuJpsiResult::AliAnalysisMuMuJpsiResult(const char* particle,
 127                                                      const TH1& h,
 128                                                      const char* fitType)
 129 :
 130 AliAnalysisMuMuResult(fitType,""),
 131 fNofRuns(1),
 132 fNofTriggers(-1),
 133 fHisto(0x0),
 134 fBin(),
 135 fTriggerClass(),
 136 fEventSelection(),
 137 fPairSelection(),
 138 fCentralitySelection(),
 139 fFitFunction(),
 140 fFitRejectRangeLow(TMath::Limits<Double_t>::Max()),
 141 fFitRejectRangeHigh(TMath::Limits<Double_t>::Max()),
 142 fRejectFitPoints(kFALSE),
 143 fParticle(particle),
 144 fMinvRS("")
 145 {
 146   SetHisto(h);
 147
 148   DecodeFitType(fitType);
 149
 150   TString name(fFitFunction);
 151   if ( !name.Contains("PSICB2") && !name.Contains("PSINA60NEW") && !name.Contains("PSICOUNT") ) //To avoid adding things to the name of simu results
 152   {
 153     Bool_t isMPt = kFALSE;
 154
 155     if ( name.BeginsWith("PSI") ) name.ReplaceAll("PSIPSIPRIME","");
 156     else if ( name.BeginsWith("MPT") )
 157     {
 158       name.ReplaceAll("MPTPSIPSIPRIME","");
 159       isMPt = kTRUE;
 160     }
 161     name += "_";
 162     name += Form("%1.1f",GetValue(kFitRangeLow));
 163     name += "_";
 164     name += Form("%1.1f",GetValue(kFitRangeHigh));
 165     if ( !isMPt )
 166     {
 167       name += "_";
 168       name += Form("SP%1.1f",GetValue(kKeySPsiP));
 169     }
 170     else
 171     {
 172       name += Form("(Sig:%s)",fMinvRS.Data());
 173     }
 174   }
 175   SetName(name.Data());
 176
 177   Int_t rebin = TMath::Nint(GetValue(kKeyRebin));
 178
 179   if (rebin>0)
 180   {
 181     fHisto->Rebin(rebin);
 182   }
 183
 184   if ( fHisto->GetEntries()<100 && !TString(GetName()).Contains(kKeyCount) )
 185   {
 186     // not enough statistics to perform a fit.
 187     Invalidate();
 188     std::cout << "Fit Excluded: Not enough statistics to perform a fit" << std::endl;
 189   }
 190 }
 191
 192 //_____________________________________________________________________________
 193 AliAnalysisMuMuJpsiResult::AliAnalysisMuMuJpsiResult(const char* particle,
 194                                                      const TH1& h,
 195                                                      const char* triggerName,
 196                                                      const char* eventSelection,
 197                                                      const char* pairSelection,
 198                                                      const char* centSelection,
 199                                                      const AliAnalysisMuMuBinning::Range& bin)
 200 :
 201 AliAnalysisMuMuResult(Form("%s-%s-%s-%s",triggerName,eventSelection,pairSelection,centSelection),""),
 202 fNofRuns(1),
 203 fNofTriggers(-1),
 204 fHisto(0x0),
 205 fBin(bin),
 206 fTriggerClass(triggerName),
 207 fEventSelection(eventSelection),
 208 fPairSelection(pairSelection),
 209 fCentralitySelection(centSelection),
 210 fFitFunction(),
 211 fFitRejectRangeLow(TMath::Limits<Double_t>::Max()),
 212 fFitRejectRangeHigh(TMath::Limits<Double_t>::Max()),
 213 fRejectFitPoints(kFALSE),
 214 fParticle(particle),
 215 fMinvRS("")
 216 {
 217   SetHisto(h);
 218 }
 219
 220 //_____________________________________________________________________________
 221 AliAnalysisMuMuJpsiResult::AliAnalysisMuMuJpsiResult(const AliAnalysisMuMuJpsiResult& rhs)
 222 :
 223 AliAnalysisMuMuResult(rhs),
 224 fNofRuns(rhs.NofRuns()),
 225 fNofTriggers(rhs.NofTriggers()),
 226 fHisto(0x0),
 227 fBin(rhs.Bin()),
 228 fTriggerClass(rhs.fTriggerClass),
 229 fEventSelection(rhs.fEventSelection),
 230 fPairSelection(rhs.fPairSelection),
 231 fCentralitySelection(rhs.fCentralitySelection),
 232 fFitFunction(rhs.fFitFunction),
 233 fFitRejectRangeLow(rhs.fFitRejectRangeLow),
 234 fFitRejectRangeHigh(rhs.fFitRejectRangeHigh),
 235 fRejectFitPoints(rhs.fRejectFitPoints),
 236 fParticle(rhs.fParticle),
 237 fMinvRS(rhs.fMinvRS)
 238 {
 239   /// copy ctor
 240   /// Note that the mother is lost
 241   /// fKeys remains 0x0 so it will be recomputed if need be
 242
 243   if ( rhs.fHisto )
 244   {
 245     fHisto = static_cast<TH1*>(rhs.fHisto->Clone());
 246   }
 247 }
 248
 249 //_____________________________________________________________________________
 250 AliAnalysisMuMuJpsiResult& AliAnalysisMuMuJpsiResult::operator=(const AliAnalysisMuMuJpsiResult& rhs)
 251 {
 252   /// Assignment operator
 253
 254   if (this!=&rhs)
 255   {
 256     static_cast<AliAnalysisMuMuResult&>(*this) = static_cast<const AliAnalysisMuMuResult&>(rhs);
 257     delete fHisto;
 258
 259     if ( rhs.fHisto )
 260     {
 261       fHisto = static_cast<TH1*>(rhs.fHisto->Clone());
 262     }
 263
 264     fNofRuns = rhs.NofRuns();
 265     fNofTriggers = rhs.NofTriggers();
 266     fBin = rhs.Bin();
 267     fTriggerClass = rhs.fTriggerClass;
 268     fEventSelection = rhs.fEventSelection;
 269     fPairSelection = rhs.fPairSelection;
 270     fCentralitySelection = rhs.fCentralitySelection;
 271     fFitFunction = rhs.fFitFunction;
 272     fFitRejectRangeLow = rhs.fFitRejectRangeLow;
 273     fFitRejectRangeHigh = rhs.fFitRejectRangeHigh;
 274     fRejectFitPoints = rhs.fRejectFitPoints;
 275     fParticle = rhs.fParticle;
 276     fMinvRS = rhs.fMinvRS;
 277
 278   }
 279
 280   return *this;
 281 }
 282
 283 //_____________________________________________________________________________
 284 AliAnalysisMuMuJpsiResult::~AliAnalysisMuMuJpsiResult()
 285 {
 286   // dtor
 287   delete fHisto;
 288 }
 289
 290 //_____________________________________________________________________________
 291 void AliAnalysisMuMuJpsiResult::AttachFunctionsToHisto(TF1* signal, TF1* bck, TF1* total,
 292                                                        Double_t xmin, Double_t xmax)
 293 {
 294   /// Add some fit functions and some lines to the histogram
 295   if (signal)
 296   {
 297     signal->SetLineColor(1);
 298     signal->SetNpx(1000);
 299     fHisto->GetListOfFunctions()->Add(signal);
 300   }
 301
 302   if ( bck )
 303   {
 304     bck->SetLineColor(2);
 305     bck->SetNpx(1000);
 306     fHisto->GetListOfFunctions()->Add(bck);
 307   }
 308
 309   if ( total )
 310   {
 311     total->SetLineColor(4);
 312     total->SetNpx(1000);
 313     fHisto->GetListOfFunctions()->Add(total);
 314   }
 315
 316   TLine* l1 = new TLine(xmin,0,xmin,fHisto->GetMaximum()*0.8);
 317   TLine* l2 = new TLine(xmax,0,xmax,fHisto->GetMaximum()*0.8);
 318   l1->SetLineColor(6);
 319   l2->SetLineColor(6);
 320   fHisto->GetListOfFunctions()->Add(l1);
 321   fHisto->GetListOfFunctions()->Add(l2);
 322 }
 323
 324 //_____________________________________________________________________________
 325 void AliAnalysisMuMuJpsiResult::AttachFunctionsToHisto(TF1* signal1, TF1* signal2, TF1* bck, TF1* total,
 326                                                        Double_t xmin, Double_t xmax)
 327 {
 328   /// Add some fit functions and some lines to the histogram
 329   if (signal1)
 330   {
 331     signal1->SetLineColor(1);
 332     signal1->SetNpx(1000);
 333     fHisto->GetListOfFunctions()->Add(signal1);
 334   }
 335
 336   if (signal2)
 337   {
 338     signal2->SetLineColor(3);
 339     signal2->SetNpx(1000);
 340     fHisto->GetListOfFunctions()->Add(signal2);
 341   }
 342
 343   if ( bck )
 344   {
 345     bck->SetLineColor(2);
 346     bck->SetNpx(1000);
 347     fHisto->GetListOfFunctions()->Add(bck);
 348   }
 349
 350   if ( total )
 351   {
 352     total->SetLineColor(4);
 353     total->SetNpx(1000);
 354     fHisto->GetListOfFunctions()->Add(total);
 355   }
 356
 357   TLine* l1 = new TLine(xmin,0,xmin,fHisto->GetMaximum()*0.8);
 358   TLine* l2 = new TLine(xmax,0,xmax,fHisto->GetMaximum()*0.8);
 359   l1->SetLineColor(6);
 360   l2->SetLineColor(6);
 361   fHisto->GetListOfFunctions()->Add(l1);
 362   fHisto->GetListOfFunctions()->Add(l2);
 363 }
 364
 365
 366 //_____________________________________________________________________________
 367 const AliAnalysisMuMuBinning::Range& AliAnalysisMuMuJpsiResult::Bin() const
 368 {
 369   /// Get the bin of this result
 370   if ( !Mother() ) return fBin;
 371   else return Mother()->Bin();
 372 }
 373
 374 //_____________________________________________________________________________
 375 TObject* AliAnalysisMuMuJpsiResult::Clone(const char* /*newname*/) const
 376 {
 377   /// Clone this result
 378   return new AliAnalysisMuMuJpsiResult(*this);
 379 }
 380
 381 //_____________________________________________________________________________
 382 Bool_t AliAnalysisMuMuJpsiResult::Correct(const AliAnalysisMuMuJpsiResult& other, const char* particle, const char* subResultName)
 383 {
 384   /// Assuming other has an AccxEff entry, correct this value by AccxEff of other
 385
 386   if ( HasValue(Form("Nof%s",particle)) )
 387   {
 388     if (!other.HasValue(Form("AccEff%s",particle),subResultName))
 389     {
 390       AliError(Form("Cannot correct as I do not find the AccEff%s value (subResultName=%s)!",particle,subResultName));
 391       return kFALSE;
 392     }
 393
 394     Double_t acc = other.GetValue(Form("AccEff%s",particle),subResultName);
 395     Double_t value = 0.0;
 396
 397     if ( acc > 0 ) value = GetValue(Form("Nof%s",particle)) / acc;
 398
 399     Double_t error = ErrorAB( GetValue(Form("Nof%s",particle)),
 400                               GetErrorStat(Form("Nof%s",particle)),
 401                               other.GetValue(Form("AccEff%s",particle),subResultName),
 402                               other.GetErrorStat(Form("AccEff%s",particle),subResultName) );
 403
 404     Set(Form("CorrNof%s",particle),value,error*value);
 405
 406     return kTRUE;
 407   }
 408   else
 409   {
 410     AliError(Form("Result does not have Nof%s : cannot correct it !",particle));
 411   }
 412   return kFALSE;
 413 }
 414
 415 //_____________________________________________________________________________
 416 void AliAnalysisMuMuJpsiResult::Draw(Option_t* opt)
 417 {
 418   /// short cut method to draw our internal histogram
 419   if (fHisto) fHisto->Draw(opt);
 420 }
 421
 422 //_____________________________________________________________________________
 423 Double_t AliAnalysisMuMuJpsiResult::CountParticle(const TH1& hminv, const char* particle, Double_t sigma)
 424 {
 425   /// Count the number of entries in an invariant mass range
 426
 427   const std::map<std::string,Double_t>& m = MassMap();
 428
 429   std::map<std::string,Double_t>::const_iterator it = m.find(particle);
 430
 431   if ( it == m.end() )
 432   {
 433     AliErrorClass(Form("Don't know the mass of particle %s",particle));
 434     return 0.0;
 435   }
 436
 437   Double_t mass = it->second;
 438
 439   if ( sigma < 0 )
 440   {
 441     AliDebugClass(1,Form("Oups. Got a sigma of %e for particle %s !",sigma,particle));
 442     return hminv.Integral();
 443   }
 444
 445   const TAxis* x = hminv.GetXaxis();
 446
 447   Int_t b1 = x->FindFixBin(mass-sigma);
 448   Int_t b2 = x->FindFixBin(mass+sigma);
 449
 450   AliDebugClass(1,Form("hminv getentries %e integral %e",hminv.GetEntries(),hminv.Integral(b1,b2)));
 451
 452   return hminv.Integral(b1,b2);
 453 }
 454
 455 //____________________________________________________________________________
 456 Double_t AliAnalysisMuMuJpsiResult::FitFunctionBackgroundLin(Double_t *x, Double_t *par)
 457 {
 458   // Linear function for Bkg 2 params
 459
 460   if (fRejectFitPoints &&  x[0] > fFitRejectRangeLow && x[0] < fFitRejectRangeHigh )
 461   {
 462     TF1::RejectPoint();
 463     return 0.;
 464   }
 465   return par[0]+par[1]*x[0];
 466 }
 467
 468 //____________________________________________________________________________
 469 Double_t AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2(Double_t *x, Double_t *par)
 470 {
 471   // pol2 3 params
 472
 473   if (fRejectFitPoints &&  x[0] > fFitRejectRangeLow && x[0] < fFitRejectRangeHigh )
 474   {
 475     TF1::RejectPoint();
 476     return 0.;
 477   }
 478   return par[0]+par[1]*x[0]+par[2]*x[0]*x[0];
 479 }
 480
 481 //____________________________________________________________________________
 482 Double_t AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol3(Double_t *x, Double_t *par)
 483 {
 484   // pol2 4 params
 485
 486   if (fRejectFitPoints &&  x[0] > fFitRejectRangeLow && x[0] < fFitRejectRangeHigh )
 487   {
 488     TF1::RejectPoint();
 489     return 0.;
 490   }
 491   return par[0]+par[1]*x[0]+par[2]*x[0]*x[0]+par[3]*x[0]*x[0]*x[0];
 492 }
 493
 494 //____________________________________________________________________________
 495 Double_t AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol4(Double_t *x, Double_t *par)
 496 {
 497   // pol2 5 params
 498
 499   if (fRejectFitPoints &&  x[0] > fFitRejectRangeLow && x[0] < fFitRejectRangeHigh )
 500   {
 501     TF1::RejectPoint();
 502     return 0.;
 503   }
 504   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];
 505 }
 506
 507 //____________________________________________________________________________
 508 Double_t AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2Exp(Double_t *x, Double_t *par)
 509 {
 510   // pol2 x exp : 4 params
 511
 512   if (fRejectFitPoints &&  x[0] > fFitRejectRangeLow && x[0] < fFitRejectRangeHigh )
 513   {
 514     TF1::RejectPoint();
 515     return 0.;
 516   }
 517 //  return par[0]*(par[1]+par[2]*x[0]+par[3]*x[0]*x[0])*TMath::Exp(par[4]/x[0]);
 518   return (par[0]+par[1]*x[0]+par[2]*x[0]*x[0])*TMath::Exp(par[3]*x[0]);
 519 }
 520
 521 //____________________________________________________________________________
 522 Double_t AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol4Exp(Double_t *x, Double_t *par)
 523 {
 524   // pol4 x exp : 6 params
 525
 526   if (fRejectFitPoints &&  x[0] > fFitRejectRangeLow && x[0] < fFitRejectRangeHigh )
 527   {
 528     TF1::RejectPoint();
 529     return 0.;
 530   }
 531 //  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]);
 532 //  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]);
 533   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]);
 534
 535 }
 536
 537 //____________________________________________________________________________
 538 Double_t AliAnalysisMuMuJpsiResult::FitFunctionBackgroundVWG(Double_t *x, Double_t *par)
 539 {
 540   // gaussian variable width : 4 params
 541
 542   if (fRejectFitPoints && x[0] > fFitRejectRangeLow && x[0] < fFitRejectRangeHigh )
 543   {
 544     TF1::RejectPoint();
 545     return 0.;
 546   }
 547   Double_t sigma = par[2]+par[3]*((x[0]-par[1])/par[1]);
 548   return par[0]*TMath::Exp(-(x[0]-par[1])*(x[0]-par[1])/(2.*sigma*sigma));
 549 }
 550
 551 //____________________________________________________________________________
 552 Double_t AliAnalysisMuMuJpsiResult::FitFunctionSignalCrystalBallExtended(Double_t *x,Double_t *par)
 553 {
 554   // Extended Crystal Ball : 7 parameters
 555   //
 556   // par[0] = Normalization
 557   // par[1] = mean
 558   // par[2] = sigma
 559   // par[3] = alpha
 560   // par[4] = n
 561   // par[5] = alpha'
 562   // par[6] = n'
 563
 564   Double_t t = (x[0]-par[1])/par[2];
 565   if (par[3] < 0) t = -t;
 566
 567   Double_t absAlpha = fabs((Double_t)par[3]);
 568   Double_t absAlpha2 = fabs((Double_t)par[5]);
 569
 570   if (t >= -absAlpha && t < absAlpha2) // gaussian core
 571   {
 572     return par[0]*(exp(-0.5*t*t));
 573   }
 574
 575   if (t < -absAlpha) //left tail
 576   {
 577     Double_t a =  TMath::Power(par[4]/absAlpha,par[4])*exp(-0.5*absAlpha*absAlpha);
 578     Double_t b = par[4]/absAlpha - absAlpha;
 579     return par[0]*(a/TMath::Power(b - t, par[4]));
 580   }
 581
 582   if (t >= absAlpha2) //right tail
 583   {
 584
 585     Double_t c =  TMath::Power(par[6]/absAlpha2,par[6])*exp(-0.5*absAlpha2*absAlpha2);
 586     Double_t d = par[6]/absAlpha2 - absAlpha2;
 587     return par[0]*(c/TMath::Power(d + t, par[6]));
 588   }
 589
 590   return 0. ;
 591 }
 592
 593 //____________________________________________________________________________
 594 Double_t AliAnalysisMuMuJpsiResult::FitFunctionNA60New(Double_t *x,Double_t *par)
 595 {
 596   // New Formulation of NA60 : 11 parameters
 597   //
 598   // par[0] = Normalization
 599   // par[1] = mean
 600   // par[2] = sigma
 601   // par[3] = p1Left
 602   // par[4] = p2Left
 603   // par[5] = p3Left
 604   // par[6] = p1Right
 605   // par[7] = p2Right
 606   // par[8] = p3Right
 607   // par[9] = alphaLeft
 608   // par[10] = alphaRight
 609
 610
 611   const Double_t t = (x[0]-par[1])/par[2];
 612
 613   Double_t sigmaRatio;
 614   if( t < par[9] ) sigmaRatio = ( 1.0 + TMath::Power( par[3]*(par[9]-t), par[4]-par[5]*TMath::Sqrt(par[9] - t) ) );
 615   else if( t >= par[9] && t < par[10] ) sigmaRatio = 1;
 616   else if( t >= par[10] ) sigmaRatio = ( 1.0 + TMath::Power( par[6]*(t-par[10]), par[7]-par[8]*TMath::Sqrt(t - par[10]) ) );
 617
 618   return par[0]*TMath::Exp( -(1/2.)*TMath::Power(t/sigmaRatio,2.));
 619
 620 }
 621
 622 //____________________________________________________________________________
 623 Double_t AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoNA60NewVWG(Double_t *x, Double_t *par)
 624 {
 625   /// 2 NA60 (new) + pol2 x exp
 626   /// width of the second NA60 related to the first (free) one.
 627
 628   Double_t SPsiPFactor = GetValue(kKeySPsiP);
 629
 630   Double_t par2[11] = {
 631     par[15],
 632     3.68609+(par[5]-3.096916)/3.096916*3.68609,
 633     par[6]*SPsiPFactor, // /3.096916*3.68609
 634     par[7],
 635     par[8],
 636     par[9],
 637     par[10],
 638     par[11],
 639     par[12],
 640     par[13],
 641     par[14],
 642   };
 643   return FitFunctionBackgroundVWG(x, par) + FitFunctionNA60New(x, &par[4]) + FitFunctionNA60New(x, par2);
 644 }
 645
 646 //____________________________________________________________________________
 647 Double_t AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoNA60NewPol2Exp(Double_t *x, Double_t *par)
 648 {
 649   /// 2 NA60 (new) + pol2 x exp
 650   /// width of the second NA60 related to the first (free) one.
 651
 652   Double_t SPsiPFactor = GetValue(kKeySPsiP);
 653
 654   Double_t par2[11] = {
 655     par[15],
 656     3.68609+(par[5]-3.096916)/3.096916*3.68609,
 657     par[6]*SPsiPFactor,  // /3.096916*3.68609,
 658     par[7],
 659     par[8],
 660     par[9],
 661     par[10],
 662     par[11],
 663     par[12],
 664     par[13],
 665     par[14],
 666   };
 667   return FitFunctionBackgroundPol2Exp(x, par) + FitFunctionNA60New(x, &par[4]) + FitFunctionNA60New(x, par2);
 668 }
 669
 670
 671 //____________________________________________________________________________
 672 Double_t AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoNA60NewPol4Exp(Double_t *x, Double_t *par)
 673 {
 674   /// 2 NA60 (new) + pol4 x exp
 675   /// width of the second NA60 related to the first (free) one.
 676
 677   Double_t SPsiPFactor = GetValue(kKeySPsiP);
 678
 679   Double_t par2[11] = {
 680     par[17],
 681     3.68609+(par[7]-3.096916)/3.096916*3.68609,
 682     par[8]*SPsiPFactor, // /3.096916*3.68609,
 683     par[9],
 684     par[10],
 685     par[11],
 686     par[12],
 687     par[13],
 688     par[14],
 689     par[15],
 690     par[16],
 691   };
 692   return FitFunctionBackgroundPol4Exp(x, par) + FitFunctionNA60New(x, &par[6]) + FitFunctionNA60New(x, par2);
 693 }
 694
 695 //____________________________________________________________________________
 696 Double_t AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2Lin(Double_t *x, Double_t *par)
 697 {
 698   /// 2 extended crystal balls + Pol1
 699   /// width of the second CB related to the first (free) one.
 700
 701   Double_t SPsiPFactor = GetValue(kKeySPsiP);
 702
 703   Double_t par2[7] = {
 704     par[9],
 705     3.68609+(par[3]-3.096916)/3.096916*3.68609,
 706     par[4]*SPsiPFactor, // /3.096916*3.68609,
 707     par[5],
 708     par[6],
 709     par[7],
 710     par[8]
 711   };
 712   return FitFunctionBackgroundLin(x, par) + FitFunctionSignalCrystalBallExtended(x, &par[2]) + FitFunctionSignalCrystalBallExtended(x, par2);
 713 }
 714
 715 //____________________________________________________________________________
 716 Double_t AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2Pol2Exp(Double_t *x, Double_t *par)
 717 {
 718   /// 2 extended crystal balls + pol2 x exp
 719   /// width of the second CB related to the first (free) one.
 720
 721   Double_t SPsiPFactor = GetValue(kKeySPsiP);
 722
 723   Double_t par2[7] = {
 724     par[11],
 725     3.68609+(par[5]-3.096916)/3.096916*3.68609,
 726     par[6]*SPsiPFactor, // /3.096916*3.68609,
 727     par[7],
 728     par[8],
 729     par[9],
 730     par[10]
 731   };
 732   return FitFunctionBackgroundPol2Exp(x, par) + FitFunctionSignalCrystalBallExtended(x, &par[4]) + FitFunctionSignalCrystalBallExtended(x, par2);
 733 }
 734
 735 ////____________________________________________________________________________
 736 //Double_t AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2Pol2Exp(Double_t *x, Double_t *par)
 737 //{
 738 //  /// 2 extended crystal balls + pol2 x exp
 739 //  /// width of the second CB related to the first (free) one.
 740 //
 741 //  Double_t par2[7] = {
 742 //    par[12],
 743 //    3.68609+(par[6]-3.096916)/3.096916*3.68609,
 744 //    par[7]/3.096916*3.68609,
 745 //    par[8],
 746 //    par[9],
 747 //    par[10],
 748 //    par[11]
 749 //  };
 750 //  return FitFunctionBackgroundPol2Exp(x, par) + FitFunctionSignalCrystalBallExtended(x, &par[5]) + FitFunctionSignalCrystalBallExtended(x, par2);
 751 //}
 752
 753 //____________________________________________________________________________
 754 Double_t AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2Pol4Exp(Double_t *x, Double_t *par)
 755 {
 756   /// 2 extended crystal balls + pol4 x exp
 757   /// width of the second CB related to the first (free) one.
 758
 759   Double_t SPsiPFactor = GetValue(kKeySPsiP);
 760
 761   Double_t par2[7] = {
 762     par[13],
 763     3.68609+(par[7]-3.096916)/3.096916*3.68609,
 764     par[8]*SPsiPFactor, // /3.096916*3.68609,
 765     par[9],
 766     par[10],
 767     par[11],
 768     par[12]
 769   };
 770   return FitFunctionBackgroundPol4Exp(x, par) + FitFunctionSignalCrystalBallExtended(x, &par[6]) + FitFunctionSignalCrystalBallExtended(x, par2);
 771 }
 772
 773 ////____________________________________________________________________________
 774 //Double_t AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2Pol4Exp(Double_t *x, Double_t *par)
 775 //{
 776 //  /// 2 extended crystal balls + pol4 x exp
 777 //  /// width of the second CB related to the first (free) one.
 778 //
 779 //  Double_t par2[7] = {
 780 //    par[14],
 781 //    3.68609+(par[8]-3.096916)/3.096916*3.68609,
 782 //    par[9]/3.096916*3.68609,
 783 //    par[10],
 784 //    par[11],
 785 //    par[12],
 786 //    par[13]
 787 //  };
 788 //  return FitFunctionBackgroundPol4Exp(x, par) + FitFunctionSignalCrystalBallExtended(x, &par[7]) + FitFunctionSignalCrystalBallExtended(x, par2);
 789 //}
 790
 791 //____________________________________________________________________________
 792 Double_t AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2VWG(Double_t *x, Double_t *par)
 793 {
 794   /// 2 extended crystal balls + VWG
 795   /// width of the second CB related to the first (free) one.
 796
 797   Double_t SPsiPFactor = GetValue(kKeySPsiP);
 798
 799   Double_t par2[7] = {
 800     par[11],
 801     3.68609+(par[5]-3.096916)/3.096916*3.68609,
 802     par[6]*SPsiPFactor, // /3.096916*3.68609,
 803     par[7],
 804     par[8],
 805     par[9],
 806     par[10]
 807   };
 808   return FitFunctionBackgroundVWG(x, par) + FitFunctionSignalCrystalBallExtended(x, &par[4]) + FitFunctionSignalCrystalBallExtended(x, par2);
 809 }
 810
 811 //____________________________________________________________________________
 812 Double_t AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2VWGINDEPTAILS(Double_t *x, Double_t *par)
 813 {
 814   /// 2 extended crystal balls + pol2 x exp
 815   /// The tail parameters are independent but the sPsiP and mPsiP are fixed to the one of the JPsi
 816
 817   Double_t SPsiPFactor = GetValue(kKeySPsiP);
 818
 819   Double_t par2[7] = {
 820     par[11],
 821     3.68609+(par[5]-3.096916)/3.096916*3.68609,
 822     par[6]*SPsiPFactor, // /3.096916*3.68609,
 823     par[12],
 824     par[13],
 825     par[14],
 826     par[15]
 827   };
 828   return FitFunctionBackgroundVWG(x, par) + FitFunctionSignalCrystalBallExtended(x, &par[4]) + FitFunctionSignalCrystalBallExtended(x, par2);
 829
 830 //  return FitFunctionBackgroundVWG(x, par) + FitFunctionSignalCrystalBallExtended(x, &par[4]) + FitFunctionSignalCrystalBallExtended(x, &par[11]);
 831 }
 832
 833 //------------------------------------------------------------------------------
 834 Double_t AliAnalysisMuMuJpsiResult::alphaCB2VWG(Double_t*x, Double_t* par)
 835 {
 836   return FitFunctionSignalCrystalBallExtended(x, &par[4])/(FitFunctionSignalCrystalBallExtended(x, &par[4]) + FitFunctionBackgroundVWG(x,par));
 837 }
 838
 839 //------------------------------------------------------------------------------
 840 Double_t AliAnalysisMuMuJpsiResult::alphaCB2POL2EXP(Double_t*x, Double_t* par)
 841 {
 842   return FitFunctionSignalCrystalBallExtended(x, &par[4])/(FitFunctionSignalCrystalBallExtended(x, &par[4]) + FitFunctionBackgroundPol2Exp(x,par));
 843 }
 844
 845 //------------------------------------------------------------------------------
 846 Double_t AliAnalysisMuMuJpsiResult::alphaNA60NEWVWG(Double_t*x, Double_t* par)
 847 {
 848   return FitFunctionNA60New(x, &par[4])/(FitFunctionNA60New(x, &par[4]) + FitFunctionBackgroundVWG(x,par));
 849 }
 850
 851 //------------------------------------------------------------------------------
 852 Double_t AliAnalysisMuMuJpsiResult::alphaNA60NEWPOL2EXP(Double_t*x, Double_t* par)
 853 {
 854   return FitFunctionNA60New(x, &par[4])/(FitFunctionNA60New(x, &par[4]) + FitFunctionBackgroundPol2Exp(x,par));
 855 }
 856
 857
 858 //------------------------------------------------------------------------------
 859 Double_t AliAnalysisMuMuJpsiResult::FitFunctionMeanPtSCB2Lin(Double_t* x, Double_t* par)
 860 {
 861   // Fit function for Jpsi(Psip) mean pt with alphaJpsi
 862   return alphaCB2VWG(x,par)*par[12] + (1. - alphaCB2VWG(x,par))*FitFunctionBackgroundPol2(x,&par[13]);
 863 }
 864
 865 //____________________________________________________________________________
 866 Double_t AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2CB2Lin(Double_t *x, Double_t *par)
 867 {
 868   // Fit function for Jpsi(Psip) mean pt with alphaJpsi and alphaPsiP
 869   Double_t SPsiPFactor = GetValue(kKeySPsiP);
 870
 871   Double_t par2[11] = {
 872     par[0],
 873     par[1],
 874     par[2],
 875     par[3],
 876     par[11], //kPsi'
 877     3.68609+(par[5]-3.096916)/3.096916*3.68609,
 878     par[6]*SPsiPFactor, // /3.096916*3.68609,
 879     par[7],
 880     par[8],
 881     par[9],
 882     par[10]
 883   };
 884
 885
 886   return alphaCB2VWG(x,par)*par[12] + alphaCB2VWG(x,par2)*par[15] + (1. - alphaCB2VWG(x,par) - alphaCB2VWG(x,par2))*FitFunctionBackgroundPol2(x,&par[13]);
 887 }
 888
 889
 890 //------------------------------------------------------------------------------
 891 Double_t AliAnalysisMuMuJpsiResult::FitFunctionMeanPtSCB2VWGPOL2(Double_t* x, Double_t* par)
 892 {
 893   // Fit function for Jpsi(Psip) mean pt with alphaJpsi
 894   return alphaCB2VWG(x,par)*par[12] + (1. - alphaCB2VWG(x,par))*FitFunctionBackgroundPol2(x,&par[13]);
 895 }
 896
 897 //____________________________________________________________________________
 898 Double_t AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2CB2VWGPOL2(Double_t *x, Double_t *par)
 899 {
 900   // Fit function for Jpsi(Psip) mean pt with alphaJpsi and alphaPsiP
 901   Double_t SPsiPFactor = GetValue(kKeySPsiP);
 902
 903   Double_t par2[11] = {
 904     par[0],
 905     par[1],
 906     par[2],
 907     par[3],
 908     par[11], //kPsi'
 909     3.68609+(par[5]-3.096916)/3.096916*3.68609,
 910     par[6]*SPsiPFactor, // /3.096916*3.68609,
 911     par[7],
 912     par[8],
 913     par[9],
 914     par[10]
 915   };
 916
 917
 918   return alphaCB2VWG(x,par)*par[12] + alphaCB2VWG(x,par2)*par[16] + (1. - alphaCB2VWG(x,par) - alphaCB2VWG(x,par2))*FitFunctionBackgroundPol2(x,&par[13]);
 919 }
 920
 921 //____________________________________________________________________________
 922 Double_t AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2CB2VWGPOL2EXP(Double_t *x, Double_t *par)
 923 {
 924   // Fit function for Jpsi(Psip) mean pt with alphaJpsi and alphaPsiP
 925   Double_t SPsiPFactor = GetValue(kKeySPsiP);
 926
 927   Double_t par2[11] = {
 928     par[0],
 929     par[1],
 930     par[2],
 931     par[3],
 932     par[11], //kPsi'
 933     3.68609+(par[5]-3.096916)/3.096916*3.68609,
 934     par[6]*SPsiPFactor, // /3.096916*3.68609,
 935     par[7],
 936     par[8],
 937     par[9],
 938     par[10]
 939   };
 940
 941
 942   return alphaCB2VWG(x,par)*par[12] + alphaCB2VWG(x,par2)*par[17] + (1. - alphaCB2VWG(x,par) - alphaCB2VWG(x,par2))*FitFunctionBackgroundPol2Exp(x,&par[13]);
 943 }
 944
 945 //____________________________________________________________________________
 946 Double_t AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2CB2POL2EXPPOL2(Double_t *x, Double_t *par)
 947 {
 948   // Fit function for Jpsi(Psip) mean pt with alphaJpsi and alphaPsiP
 949   Double_t SPsiPFactor = GetValue(kKeySPsiP);
 950
 951   Double_t par2[11] = {
 952     par[0],
 953     par[1],
 954     par[2],
 955     par[3],
 956     par[11], //kPsi'
 957     3.68609+(par[5]-3.096916)/3.096916*3.68609,
 958     par[6]*SPsiPFactor, // /3.096916*3.68609,
 959     par[7],
 960     par[8],
 961     par[9],
 962     par[10]
 963   };
 964
 965
 966   return alphaCB2POL2EXP(x,par)*par[12] + alphaCB2POL2EXP(x,par2)*par[16] + (1. - alphaCB2POL2EXP(x,par) - alphaCB2POL2EXP(x,par2))*FitFunctionBackgroundPol2(x,&par[13]);
 967
 968 }
 969
 970 //____________________________________________________________________________
 971 Double_t AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2CB2POL2EXPPOL2EXP(Double_t *x, Double_t *par)
 972 {
 973   // Fit function for Jpsi(Psip) mean pt with alphaJpsi and alphaPsiP
 974   Double_t SPsiPFactor = GetValue(kKeySPsiP);
 975
 976   Double_t par2[11] = {
 977     par[0],
 978     par[1],
 979     par[2],
 980     par[3],
 981     par[11], //kPsi'
 982     3.68609+(par[5]-3.096916)/3.096916*3.68609,
 983     par[6]*SPsiPFactor, // /3.096916*3.68609,
 984     par[7],
 985     par[8],
 986     par[9],
 987     par[10]
 988   };
 989
 990
 991   return alphaCB2POL2EXP(x,par)*par[12] + alphaCB2POL2EXP(x,par2)*par[17] + (1. - alphaCB2POL2EXP(x,par) - alphaCB2POL2EXP(x,par2))*FitFunctionBackgroundPol2Exp(x,&par[13]);
 992
 993 }
 994
 995 //____________________________________________________________________________
 996 Double_t AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2NA60NEWVWGPOL2(Double_t *x, Double_t *par)
 997 {
 998   // Fit function for Jpsi(Psip) mean pt with alphaJpsi and alphaPsiP
 999   Double_t SPsiPFactor = GetValue(kKeySPsiP);
1000
1001   Double_t par2[15] = {
1002     par[0],
1003     par[1],
1004     par[2],
1005     par[3],
1006     par[15],
1007     3.68609+(par[5]-3.096916)/3.096916*3.68609,
1008     par[6]*SPsiPFactor, // /3.096916*3.68609,
1009     par[7],
1010     par[8],
1011     par[9],
1012     par[10],
1013     par[11],
1014     par[12],
1015     par[13],
1016     par[14],
1017   };
1018
1019   return alphaNA60NEWVWG(x,par)*par[16] + alphaNA60NEWVWG(x,par2)*par[20] + (1. - alphaNA60NEWVWG(x,par) - alphaNA60NEWVWG(x,par2))*FitFunctionBackgroundPol2(x,&par[17]);
1020
1021 }
1022
1023 //____________________________________________________________________________
1024 Double_t AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2NA60NEWVWGPOL2EXP(Double_t *x, Double_t *par)
1025 {
1026   // Fit function for Jpsi(Psip) mean pt with alphaJpsi and alphaPsiP
1027   Double_t SPsiPFactor = GetValue(kKeySPsiP);
1028
1029   Double_t par2[15] = {
1030     par[0],
1031     par[1],
1032     par[2],
1033     par[3],
1034     par[15],
1035     3.68609+(par[5]-3.096916)/3.096916*3.68609,
1036     par[6]*SPsiPFactor, // /3.096916*3.68609,
1037     par[7],
1038     par[8],
1039     par[9],
1040     par[10],
1041     par[11],
1042     par[12],
1043     par[13],
1044     par[14],
1045   };
1046
1047
1048   return alphaNA60NEWVWG(x,par)*par[16] + alphaNA60NEWVWG(x,par2)*par[21] + (1. - alphaNA60NEWVWG(x,par) - alphaNA60NEWVWG(x,par2))*FitFunctionBackgroundPol2Exp(x,&par[17]);
1049
1050 }
1051
1052 //____________________________________________________________________________
1053 Double_t AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2NA60NEWPOL2EXPPOL2(Double_t *x, Double_t *par)
1054 {
1055   // Fit function for Jpsi(Psip) mean pt with alphaJpsi and alphaPsiP
1056   Double_t SPsiPFactor = GetValue(kKeySPsiP);
1057
1058   Double_t par2[15] = {
1059     par[0],
1060     par[1],
1061     par[2],
1062     par[3],
1063     par[15],
1064     3.68609+(par[5]-3.096916)/3.096916*3.68609,
1065     par[6]*SPsiPFactor, // /3.096916*3.68609,
1066     par[7],
1067     par[8],
1068     par[9],
1069     par[10],
1070     par[11],
1071     par[12],
1072     par[13],
1073     par[14],
1074   };
1075
1076   return alphaNA60NEWPOL2EXP(x,par)*par[16] + alphaNA60NEWPOL2EXP(x,par2)*par[20] + (1. - alphaNA60NEWPOL2EXP(x,par) - alphaNA60NEWPOL2EXP(x,par2))*FitFunctionBackgroundPol2(x,&par[17]);
1077
1078 }
1079
1080 //____________________________________________________________________________
1081 Double_t AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2NA60NEWPOL2EXPPOL2EXP(Double_t *x, Double_t *par)
1082 {
1083   // Fit function for Jpsi(Psip) mean pt with alphaJpsi and alphaPsiP
1084   Double_t SPsiPFactor = GetValue(kKeySPsiP);
1085
1086   Double_t par2[15] = {
1087     par[0],
1088     par[1],
1089     par[2],
1090     par[3],
1091     par[15],
1092     3.68609+(par[5]-3.096916)/3.096916*3.68609,
1093     par[6]*SPsiPFactor, // /3.096916*3.68609,
1094     par[7],
1095     par[8],
1096     par[9],
1097     par[10],
1098     par[11],
1099     par[12],
1100     par[13],
1101     par[14],
1102   };
1103
1104   return alphaNA60NEWPOL2EXP(x,par)*par[16] + alphaNA60NEWPOL2EXP(x,par2)*par[21] + (1. - alphaNA60NEWPOL2EXP(x,par) - alphaNA60NEWPOL2EXP(x,par2))*FitFunctionBackgroundPol2Exp(x,&par[17]);
1105
1106 }
1107
1108 //____________________________________________________________________________
1109 Double_t AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2CB2VWGPOL3(Double_t *x, Double_t *par)
1110 {
1111   // Fit function for Jpsi(Psip) mean pt with alphaJpsi and alphaPsiP
1112   Double_t SPsiPFactor = GetValue(kKeySPsiP);
1113
1114   Double_t par2[11] = {
1115     par[0],
1116     par[1],
1117     par[2],
1118     par[3],
1119     par[11], //kPsi'
1120     3.68609+(par[5]-3.096916)/3.096916*3.68609,
1121     par[6]*SPsiPFactor, // /3.096916*3.68609,
1122     par[7],
1123     par[8],
1124     par[9],
1125     par[10]
1126   };
1127
1128
1129   return alphaCB2VWG(x,par)*par[12] + alphaCB2VWG(x,par2)*par[17] + (1. - alphaCB2VWG(x,par) - alphaCB2VWG(x,par2))*FitFunctionBackgroundPol2(x,&par[13]);
1130 }
1131
1132 //____________________________________________________________________________
1133 Double_t AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2CB2VWGPOL4(Double_t *x, Double_t *par)
1134 {
1135   // Fit function for Jpsi(Psip) mean pt with alphaJpsi and alphaPsiP
1136   Double_t SPsiPFactor = GetValue(kKeySPsiP);
1137
1138   Double_t par2[11] = {
1139     par[0],
1140     par[1],
1141     par[2],
1142     par[3],
1143     par[11], //kPsi'
1144     3.68609+(par[5]-3.096916)/3.096916*3.68609,
1145     par[6]*SPsiPFactor, // /3.096916*3.68609,
1146     par[7],
1147     par[8],
1148     par[9],
1149     par[10]
1150   };
1151
1152
1153   return alphaCB2VWG(x,par)*par[12] + alphaCB2VWG(x,par2)*par[18] + (1. - alphaCB2VWG(x,par) - alphaCB2VWG(x,par2))*FitFunctionBackgroundPol4(x,&par[13]);
1154 }
1155
1156 //------------------------------------------------------------------------------
1157 Double_t AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2CB2VWGPOL2INDEPTAILS(Double_t* x, Double_t* par)
1158 {
1159   // Fit function for Jpsi(Psip) mean pt with alphaJpsi and alphaPsiP with independent tails
1160   Double_t SPsiPFactor = GetValue(kKeySPsiP);
1161
1162   Double_t par2[11] = {
1163     par[0],
1164     par[1],
1165     par[2],
1166     par[3],
1167     par[11], //kPsi'
1168    3.68609+(par[5]-3.096916)/3.096916*3.68609,
1169     par[6]*SPsiPFactor, // /3.096916*3.68609,
1170     par[12],
1171     par[13],
1172     par[14],
1173     par[15]
1174   };
1175
1176   return alphaCB2VWG(x,par)*par[16] + alphaCB2VWG(x,par2)*par[20] + (1. - alphaCB2VWG(x,par) - alphaCB2VWG(x,par2))*FitFunctionBackgroundPol2(x,&par[17]);
1177 }
1178
1179 //_____________________________________________________________________________
1180 void AliAnalysisMuMuJpsiResult::FitPSICOUNT()
1181 {
1182   /// Simple counting of the number of j/psi ...
1183   Double_t n = CountParticle(*fHisto,Form("%s",GetParticle()));
1184   Set(Form("Nof%s",GetParticle()),n,TMath::Sqrt(n));
1185 }
1186
1187 //_____________________________________________________________________________
1188 void AliAnalysisMuMuJpsiResult::FitPSICB2()
1189 {
1190   /// Fit using 1 extended crystal balls (pure signal)
1191   TString particleName(GetParticle());
1192
1193   fHisto->GetListOfFunctions()->Delete();
1194
1195   Double_t alphaLow = GetValue(Form("al%s",particleName.Data()));
1196   Double_t nLow = GetValue(Form("nl%s",particleName.Data()));
1197   Double_t alphaUp = GetValue(Form("au%s",particleName.Data()));
1198   Double_t nUp = GetValue(Form("nu%s",particleName.Data()));
1199   Double_t fitRangeLow = GetValue(kFitRangeLow);
1200   Double_t fitRangeHigh = GetValue(kFitRangeHigh);
1201
1202   TString msg;
1203
1204   if (IsValidValue(alphaLow)) msg += TString::Format("alphaLow=%e ",alphaLow);
1205   if (IsValidValue(nLow)) msg += TString::Format("nLow=%e ",nLow);
1206   if (IsValidValue(alphaUp)) msg += TString::Format("alphaUp=%e ",alphaUp);
1207   if (IsValidValue(nUp)) msg += TString::Format("nUp=%e ",nUp);
1208
1209   AliDebug(1,Form("Fit with jpsi CB2 %s",msg.Data()));
1210
1211   // Extended Crystal Ball : 7 parameters
1212   //
1213   // par[0] = Normalization
1214   // par[1] = mean
1215   // par[2] = sigma
1216   // par[3] = alpha
1217   // par[4] = n
1218   // par[5] = alpha'
1219   // par[6] = n'
1220
1221   TF1* fitTotal = new TF1("signal",this,&AliAnalysisMuMuJpsiResult::FitFunctionSignalCrystalBallExtended,fitRangeLow,fitRangeHigh,7,"AliAnalysisMuMuJpsiResult","FitFunctionSignalCrystalBallExtended");
1222
1223   fitTotal->SetParNames(Form("k%s",particleName.Data()),Form("m%s",particleName.Data()),Form("s%s",particleName.Data()),Form("al%s",particleName.Data()),
1224   //                                 0                                1                              2                                 3
1225                         Form("nl%s",particleName.Data()),Form("au%s",particleName.Data()),Form("nu%s",particleName.Data()));
1226   //                                   4                                 5                              6
1227
1228   fitTotal->SetParameter(0, fHisto->GetMaximum()); // norm
1229
1230   if (particleName.Contains("JPsi"))
1231   {
1232     fitTotal->SetParameter(1, 3.1);
1233     fitTotal->SetParLimits(1, 3.08, 3.2);
1234     fitTotal->SetParameter(2, 0.08);
1235     fitTotal->SetParLimits(2, 0.05, 0.15);
1236   }
1237   else if (particleName.Contains("PsiP"))
1238   {
1239     fitTotal->SetParameter(1, 3.7);
1240     fitTotal->SetParLimits(1, 3.63, 3.72);
1241     fitTotal->SetParameter(2, 0.08);
1242     fitTotal->SetParLimits(2, 0.05, 0.15);
1243   }
1244   else AliError(Form("Could not set initial fit parameters for particle %s: The fit might not converge",particleName.Data()));
1245
1246   SetParameter(fitTotal,3,alphaLow,0.9,0.1,10.0);
1247   SetParameter(fitTotal,4,nLow,5.0,0.0,10.0);
1248   SetParameter(fitTotal,5,alphaUp,2.0,0.1,10.0);
1249   SetParameter(fitTotal,6,nUp,3.0,0.0,10.0);
1250
1251 //  fitTotal->FixParameter(3, alphaLow);
1252 //  fitTotal->FixParameter(4, nLow);
1253 //  fitTotal->FixParameter(5, alphaUp);
1254 //  fitTotal->FixParameter(6, nUp);
1255
1256   TFitResultPtr fitResult = fHisto->Fit(fitTotal,"SER","");
1257
1258   // Check parameters...
1259   if (
1260       StrongCorrelation(fitResult,fitTotal,3,4,2) ||
1261       StrongCorrelation(fitResult,fitTotal,5,6,2) ||
1262       WrongParameter(fitTotal,3,1) ||
1263       WrongParameter(fitTotal,4,0)  ||
1264       WrongParameter(fitTotal,5,1)  ||
1265       WrongParameter(fitTotal,6,0)
1266       )
1267   {
1268     // try again...
1269     fitResult = fHisto->Fit(fitTotal,"SER","");
1270   }
1271
1272   TF1* signal = new TF1("signal",this,&AliAnalysisMuMuJpsiResult::FitFunctionSignalCrystalBallExtended,fHisto->GetXaxis()->GetXmin(),fHisto->GetXaxis()->GetXmax(),7,"AliAnalysisMuMuJpsiResult","SignalCB2");
1273
1274   signal->SetParameters(fitTotal->GetParameter(0),fitTotal->GetParameter(1),fitTotal->GetParameter(2),fitTotal->GetParameter(3),fitTotal->GetParameter(4),fitTotal->GetParameter(5),fitTotal->GetParameter(6));
1275
1276   Set("FitResult",static_cast<int>(fitResult)*1.0,0.0);
1277   Set("FitChi2PerNDF",fitTotal->GetChisquare()/fitTotal->GetNDF(),0.0);
1278   Set("FitNDF",fitTotal->GetNDF(),0.0);
1279
1280   Set(Form("m%s",particleName.Data()),fitTotal->GetParameter(1),fitTotal->GetParError(1));
1281   Set(Form("s%s",particleName.Data()),fitTotal->GetParameter(2),fitTotal->GetParError(2));
1282
1283   Set(Form("al%s",particleName.Data()),fitTotal->GetParameter(3),fitTotal->GetParError(3));
1284   Set(Form("nl%s",particleName.Data()),fitTotal->GetParameter(4),fitTotal->GetParError(4));
1285   Set(Form("au%s",particleName.Data()),fitTotal->GetParameter(5),fitTotal->GetParError(5));
1286   Set(Form("nu%s",particleName.Data()),fitTotal->GetParameter(6),fitTotal->GetParError(6));
1287
1288   AttachFunctionsToHisto(signal,0x0,fitTotal,fitRangeLow,fitRangeHigh);
1289
1290   Double_t a = fHisto->GetXaxis()->GetXmin();
1291   Double_t b = fHisto->GetXaxis()->GetXmax();
1292   double njpsi = fitTotal->Integral(a,b)/fHisto->GetBinWidth(1);
1293   double nerr = fitTotal->IntegralError(a,b)/fHisto->GetBinWidth(1);
1294
1295   Set(Form("Nof%s",particleName.Data()),njpsi,nerr);
1296
1297   double m = GetValue(Form("m%s",particleName.Data()));
1298   double s = GetValue(Form("s%s",particleName.Data()));
1299   double al = GetValue(Form("al%s",particleName.Data()));
1300   double au = GetValue(Form("au%s",particleName.Data()));
1301
1302   double njpsiCore = fitTotal->Integral(m-al*s,m+au*s)/fHisto->GetBinWidth(1);
1303   double nerrCore = fitTotal->IntegralError(m-al*s,m+au*s)/fHisto->GetBinWidth(1);
1304
1305   double njpsiTailL = fitTotal->Integral(a,m-al*s)/fHisto->GetBinWidth(1);
1306   double nerrTailL = fitTotal->IntegralError(a,m-al*s)/fHisto->GetBinWidth(1);
1307
1308   double njpsiTailR = fitTotal->Integral(m+au*s,b)/fHisto->GetBinWidth(1);
1309   double nerrTailR = fitTotal->IntegralError(m+au*s,b)/fHisto->GetBinWidth(1);
1310
1311   Set(Form("Nof%sCore",particleName.Data()),njpsiCore,nerrCore);
1312   Set(Form("Nof%sTailL",particleName.Data()),njpsiTailL,nerrTailL);
1313   Set(Form("Nof%sTailR",particleName.Data()),njpsiTailR,nerrTailR);
1314
1315 }
1316
1317 //_____________________________________________________________________________
1318 void AliAnalysisMuMuJpsiResult::FitPSINA60NEW()
1319 {
1320   /// Fit using 1 new NA60 (pure signal)
1321
1322   TString particleName(GetParticle());
1323
1324   fHisto->GetListOfFunctions()->Delete();
1325
1326   Double_t p1Left = GetValue(Form("p1L%s",particleName.Data()));
1327   Double_t p2Left = GetValue(Form("p2L%s",particleName.Data()));
1328   Double_t p3Left = GetValue(Form("p3L%s",particleName.Data()));
1329   Double_t p1Right = GetValue(Form("p1R%s",particleName.Data()));
1330   Double_t p2Right = GetValue(Form("p2R%s",particleName.Data()));
1331   Double_t p3Right = GetValue(Form("p3R%s",particleName.Data()));
1332
1333   Double_t alphaLeft = GetValue(Form("aL%s",particleName.Data()));
1334   Double_t alphaRight = GetValue(Form("aR%s",particleName.Data()));
1335
1336
1337   Double_t fitRangeLow = GetValue(kFitRangeLow);
1338   Double_t fitRangeHigh = GetValue(kFitRangeHigh);
1339
1340   TString msg;
1341
1342   if (IsValidValue(p1Left)) msg += TString::Format("p1L=%e ",p1Left);
1343   if (IsValidValue(p2Left)) msg += TString::Format("p2L=%e ",p2Left);
1344   if (IsValidValue(p3Left)) msg += TString::Format("p3L=%e ",p3Left);
1345   if (IsValidValue(p1Right)) msg += TString::Format("p1R=%e ",p1Right);
1346   if (IsValidValue(p2Right)) msg += TString::Format("p2R=%e ",p2Right);
1347   if (IsValidValue(p3Right)) msg += TString::Format("p3R=%e ",p3Right);
1348
1349   if (IsValidValue(alphaLeft)) msg += TString::Format("aL=%e ",alphaLeft);
1350   if (IsValidValue(alphaRight)) msg += TString::Format("aR=%e ",alphaRight);
1351
1352   AliDebug(1,Form("Fit with jpsi NA60 new %s",msg.Data()));
1353
1354   // New NA60 : 11 parameters
1355   //
1356   // par[0] = Normalization
1357   // par[1] = mean
1358   // par[2] = sigma
1359   // par[3] = p1Left
1360   // par[4] = p2Left
1361   // par[5] = p3Left
1362   // par[6] = p1Right
1363   // par[7] = p2Right
1364   // par[8] = p3Right
1365   // par[9] = alphaLeft
1366   // par[10] = alphaRight
1367
1368   TF1* fitTotal = new TF1("fitSignal",this,&AliAnalysisMuMuJpsiResult::FitFunctionNA60New,fitRangeLow,fitRangeHigh,11,"AliAnalysisMuMuJpsiResult","FitFunctionNA60New");
1369
1370   fitTotal->SetParNames(Form("k%s",particleName.Data()),Form("m%s",particleName.Data()),Form("s%s",particleName.Data()),Form("p1L%s",particleName.Data()),
1371         //                                 0                                1                              2                                 3
1372                         Form("p2L%s",particleName.Data()),Form("p3L%s",particleName.Data()),Form("p1R%s",particleName.Data()),Form("p2R%s",particleName.Data()),
1373         //                                   4                                 5                              6                            7
1374                         Form("p3R%s",particleName.Data()),Form("aL%s",particleName.Data()),Form("aR%s",particleName.Data()));
1375         //                                   8                                 9                              10
1376
1377   fitTotal->SetParameter(0, fHisto->GetMaximum()); // norm
1378
1379   if (particleName.Contains("JPsi"))
1380   {
1381     fitTotal->SetParameter(1, 3.1);
1382     fitTotal->SetParLimits(1, 3.08, 3.2);
1383     fitTotal->SetParameter(2, 0.08);
1384     fitTotal->SetParLimits(2, 0.05, 0.15);
1385   }
1386   else if (particleName.Contains("PsiP"))
1387   {
1388     fitTotal->SetParameter(1, 3.7);
1389     fitTotal->SetParLimits(1, 3.63, 3.72);
1390     fitTotal->SetParameter(2, 0.08);
1391     fitTotal->SetParLimits(2, 0.05, 0.15);
1392   }
1393   else AliError(Form("Could not set initial fit parameters for particle %s: The fit might not converge",particleName.Data()));
1394
1395   SetParameter(fitTotal,3,p1Left,0.02,0.001,2.0);
1396   SetParameter(fitTotal,4,p2Left,0.4,0.2,0.6);
1397   SetParameter(fitTotal,5,p3Left,0.2,0.05,0.4);
1398   SetParameter(fitTotal,6,p1Right,0.2,0.001,0.4);
1399   SetParameter(fitTotal,7,p2Right,1.0,0.0,1.4);
1400   SetParameter(fitTotal,8,p3Right,0.02,0.005,0.4);
1401
1402   SetParameter(fitTotal,9,alphaLeft,0.0,-1.5,1.5);
1403   SetParameter(fitTotal,10,alphaRight,2.3,2.0,2.5);
1404
1405 //  fitTotal->SetParameter(3, 0.2);
1406 //  fitTotal->SetParameter(4, 2.0);
1407 //  fitTotal->SetParameter(5, 1.);
1408 //  fitTotal->SetParameter(6, 0.1);
1409 //  fitTotal->SetParameter(7, 2.4);
1410 //  fitTotal->SetParameter(8, 1.1);
1411 //
1412 //  fitTotal->SetParameter(9, 1.0);
1413 //  fitTotal->SetParameter(10, 1.0);
1414
1415 //  SetParameter(fitTotal,3,p1Left,0.1,-1.E5,1.E5);
1416 //  SetParameter(fitTotal,4,p2Left,1.6,-1.E5,1.E5);
1417 //  SetParameter(fitTotal,5,p3Left,0.06,-1.E5,1.E5);
1418 //  SetParameter(fitTotal,6,p1Right,0.1,-1.E5,1.E5);
1419 //  SetParameter(fitTotal,7,p2Right,1.5,-1.E5,1.E5);
1420 //  SetParameter(fitTotal,8,p3Right,0.1,-1.E5,1.E5);
1421 //
1422 //  SetParameter(fitTotal,9,alphaLeft,1.,-1.E8,1.E5);
1423 //  SetParameter(fitTotal,10,alphaRight,1.0,-1.E5,1.E5);
1424
1425   TFitResultPtr fitResult = fHisto->Fit(fitTotal,"SER","");
1426
1427   // Check parameters...
1428 //  if (
1429 //      StrongCorrelation(fitResult,fitTotal,3,4,2) ||
1430 //      StrongCorrelation(fitResult,fitTotal,5,6,2) ||
1431 //      WrongParameter(fitTotal,3,1) ||
1432 //      WrongParameter(fitTotal,4,0)  ||
1433 //      WrongParameter(fitTotal,5,1)  ||
1434 //      WrongParameter(fitTotal,6,0)
1435 //      )
1436 //  {
1437 //    // try again...
1438 //    fitResult = fHisto->Fit(fitTotal,"SER","");
1439 //  }
1440   TF1* signal = new TF1("signal",this,&AliAnalysisMuMuJpsiResult::FitFunctionNA60New,fHisto->GetXaxis()->GetXmin(),fHisto->GetXaxis()->GetXmax(),11,"AliAnalysisMuMuJpsiResult","SignalNA60New");
1441
1442   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));
1443   signal->SetParameter(10,fitTotal->GetParameter(10));
1444
1445   Set("FitResult",static_cast<int>(fitResult)*1.0,0.0);
1446   Set("FitChi2PerNDF",fitTotal->GetChisquare()/fitTotal->GetNDF(),0.0);
1447   Set("FitNDF",fitTotal->GetNDF(),0.0);
1448
1449   Set(Form("m%s",particleName.Data()),fitTotal->GetParameter(1),fitTotal->GetParError(1));
1450   Set(Form("s%s",particleName.Data()),fitTotal->GetParameter(2),fitTotal->GetParError(2));
1451
1452   Set(Form("p1L%s",particleName.Data()),fitTotal->GetParameter(3),fitTotal->GetParError(3));
1453   Set(Form("p2L%s",particleName.Data()),fitTotal->GetParameter(4),fitTotal->GetParError(4));
1454   Set(Form("p3L%s",particleName.Data()),fitTotal->GetParameter(5),fitTotal->GetParError(5));
1455   Set(Form("p1R%s",particleName.Data()),fitTotal->GetParameter(6),fitTotal->GetParError(6));
1456   Set(Form("p2R%s",particleName.Data()),fitTotal->GetParameter(7),fitTotal->GetParError(7));
1457   Set(Form("p3R%s",particleName.Data()),fitTotal->GetParameter(8),fitTotal->GetParError(8));
1458
1459   Set(Form("aL%s",particleName.Data()),fitTotal->GetParameter(9),fitTotal->GetParError(9));
1460   Set(Form("aR%s",particleName.Data()),fitTotal->GetParameter(10),fitTotal->GetParError(10));
1461
1462   AttachFunctionsToHisto(signal,0x0,fitTotal,fitRangeLow,fitRangeHigh);
1463
1464   Double_t a = fHisto->GetXaxis()->GetXmin();
1465   Double_t b = fHisto->GetXaxis()->GetXmax();
1466   double njpsi = fitTotal->Integral(a,b)/fHisto->GetBinWidth(1);
1467   double nerr = fitTotal->IntegralError(a,b)/fHisto->GetBinWidth(1);
1468
1469   Set(Form("Nof%s",particleName.Data()),njpsi,nerr);
1470 }
1471
1472 //_____________________________________________________________________________
1473 void AliAnalysisMuMuJpsiResult::FitPSIPSIPRIMECB2VWG()
1474 {
1475   /// Fit using 2 extended crystal balls (signal) + variable width gaussian (background)
1476
1477   fHisto->GetListOfFunctions()->Delete();
1478
1479   Double_t alphaLow = GetValue("alJPsi");
1480   Double_t nLow = GetValue("nlJPsi");
1481   Double_t alphaUp = GetValue("auJPsi");
1482   Double_t nUp = GetValue("nuJPsi");
1483   Double_t fitRangeLow = GetValue(kFitRangeLow);
1484   Double_t fitRangeHigh = GetValue(kFitRangeHigh);
1485   Double_t paramSPsiP = GetValue("FSigmaPsiP");
1486
1487   TString msg;
1488
1489   if (IsValidValue(alphaLow)) msg += TString::Format("alphaLow=%e ",alphaLow);
1490   if (IsValidValue(nLow)) msg += TString::Format("nLow=%e ",nLow);
1491   if (IsValidValue(alphaUp)) msg += TString::Format("alphaUp=%e ",alphaUp);
1492   if (IsValidValue(nUp)) msg += TString::Format("nUp=%e ",nUp);
1493
1494   AliDebug(1,Form("Fit with jpsi + psiprime VWG %s",msg.Data()));
1495
1496 //  std::cout << "Tails parameters: " << msg.Data() << std::endl;
1497
1498   TF1* fitTotal = new TF1("signal+bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2VWG,fitRangeLow,fitRangeHigh,12,"AliAnalysisMuMuJpsiResult","FitFunctionTotalTwoCB2VWG");
1499
1500   fitTotal->SetParNames("kVWG","mVWG","sVWG1","sVWG2","kJPsi","mJPsi","sJPsi",
1501 //                        0      1       2       3       4      5      6
1502                         "alJPsi","nlJPsi","auJPsi","nuJPsi");
1503 //                         7        8        9        10
1504   fitTotal->SetParName(11, "kPsiP");
1505 //                            11
1506
1507
1508   TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundVWG,fitRangeLow,fitRangeHigh,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundVWG");
1509
1510   const char* fitOption = "SER"; //We can add NO to avoid plotting
1511
1512 #if 0
1513   bck->SetParameter(0,fHisto->GetMaximum());
1514   bck->SetParameter(1,3);
1515   bck->SetParameter(2,10);
1516   bck->SetParameter(3,10);
1517
1518   bck->SetParLimits(1, 0., 100.);
1519   bck->SetParLimits(2, 0., 100.);
1520   bck->SetParLimits(3, 0., 100.);
1521
1522   SetFitRejectRange(2.7,3.5);
1523
1524   fHisto->Fit(bck,fitOption,"");
1525
1526   for ( Int_t i = 0; i < 4; ++i )
1527   {
1528     Double_t a,b;
1529     bck->GetParLimits(i,a,b);
1530     fitTotal->SetParameter(i,bck->GetParameter(i));
1531     fitTotal->SetParLimits(i,a,b);
1532   }
1533 #endif
1534   TF1* bckInit = new TF1("bckInit",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundVWG,1.7,6.,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundVWG");
1535
1536   Int_t bin = fHisto->FindBin(0.26);
1537
1538   bckInit->SetParameters(fHisto->GetBinContent(bin),2.,0.5,0.3);
1539
1540   SetFitRejectRange(2.7,4.0);
1541
1542   TFitResultPtr fitResultInit = fHisto->Fit(bckInit,"SR");
1543
1544   std::cout << "FitResultBkgInit=" << static_cast<int>(fitResultInit) << std::endl;
1545
1546   if ( static_cast<int>(fitResultInit) )
1547   {
1548     bin = fHisto->FindBin(0.82);
1549     bckInit->SetParameters(fHisto->GetBinContent(bin),2.,0.5,0.3);
1550     fitResultInit = fHisto->Fit(bckInit,"SR");
1551   }
1552   else if ( bckInit->GetParameter(0) < 0 )
1553   {
1554     bckInit->SetParameters(fHisto->GetBinContent(bin),2.,0.5,0.3);
1555   }
1556
1557   SetFitRejectRange();
1558
1559   for ( Int_t i = 0; i < 4; ++i )
1560   {
1561     fitTotal->SetParameter(i, bckInit->GetParameter(i));
1562   }
1563
1564
1565
1566 //  fitTotal->SetParameter(0, fHisto->GetMaximum()); // kVWG
1567 //  fitTotal->SetParameter(1, 1.9); // mVWG
1568 //
1569 //  fitTotal->SetParameter(2, 0.5); // sVWG1
1570 //  fitTotal->SetParLimits(2, 0., 100.);
1571 //
1572 //  fitTotal->SetParameter(3, 0.3); // sVWG2
1573 //  fitTotal->SetParLimits(3, 0., 100.);
1574
1575   bin = fHisto->FindBin(3.09);
1576   fitTotal->SetParameter(4, fHisto->GetBinContent(bin)); // norm
1577
1578   fitTotal->SetParameter(5, 3.1); // mean
1579   fitTotal->SetParLimits(5, 3.0, 3.2);
1580
1581   fitTotal->SetParameter(6, 0.08); // sigma
1582   fitTotal->SetParLimits(6, 0.05, 0.09);
1583
1584   if ( IsValidValue(alphaLow) )
1585   {
1586     fitTotal->FixParameter(7, alphaLow);
1587   }
1588   else
1589   {
1590     fitTotal->SetParameter(7,0.9);
1591     fitTotal->SetParLimits(7,0.1,10.0);
1592   }
1593
1594   if ( IsValidValue(nLow) )
1595   {
1596     fitTotal->FixParameter(8, nLow);
1597   }
1598   else
1599   {
1600     fitTotal->SetParameter(8,5.0);
1601     fitTotal->SetParLimits(8,0.0,10.0);
1602   }
1603
1604   if ( IsValidValue(alphaUp) )
1605   {
1606     fitTotal->FixParameter(9, alphaUp);
1607   }
1608   else
1609   {
1610     fitTotal->SetParameter(9, 2.0);
1611     fitTotal->SetParLimits(9,0.1,10.0);
1612   }
1613
1614   if ( IsValidValue(nUp) )
1615   {
1616     fitTotal->FixParameter(10, nUp);
1617   }
1618   else
1619   {
1620     fitTotal->SetParameter(10,3.0);
1621     fitTotal->SetParLimits(10,0.0,10.0);
1622   }
1623
1624   fitTotal->SetParameter(11, 10.); //kPsi'
1625   fitTotal->SetParLimits(11, 0.,100000.);
1626
1627   SetFitRejectRange();
1628
1629 //  std::cout << fitTotal->GetParameter(0) << std::endl; //Just a xcheck
1630
1631   TFitResultPtr fitResult = fHisto->Fit(fitTotal,fitOption,"");
1632
1633 //  std::cout << fitTotal->GetParameter(0) << " ?= " << fitResult->Parameter(0) << std::endl; //Just a xcheck
1634
1635   std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
1636    std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
1637
1638 //  std::cout << fitTotal->GetParameter(0) << std::endl; //Just a xcheck
1639
1640   if ( static_cast<int>(fitResult) )
1641   {
1642     if ( 0.5*fitTotal->GetParameter(11) <= fitTotal->GetParError(11) ) //kPsi'
1643     {
1644       std::cout << "//-------Refitting again (setting Psi'norm=0)" << std::endl;
1645        bin = fHisto->FindBin(3.68);
1646       fitTotal->SetParameter(11, fHisto->GetBinContent(bin)/2.);
1647     }
1648
1649     if ( 0.5*fitTotal->GetParameter(0) <= fitTotal->GetParError(0) )
1650     {
1651       std::cout << "//-------Refitting again (setting kVWG=kVWG/2)" << std::endl;
1652
1653       fitTotal->SetParameter(0, fHisto->GetMaximum()/2.); // kVWG
1654     }
1655
1656     fitResult = fHisto->Fit(fitTotal,fitOption,"");
1657     std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
1658   }
1659
1660   if ( static_cast<int>(fitResult) )
1661   {
1662     std::cout << "//-------Refitting again (setting kVWG=kVWG*2)" << std::endl;
1663
1664     fitTotal->SetParameter(0, fHisto->GetMaximum()*2.); // kVWG
1665
1666     fitResult = fHisto->Fit(fitTotal,fitOption,"");
1667     std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
1668   }
1669
1670   if ( static_cast<int>(fitResult) )
1671   {
1672     std::cout << "//-------Refitting again (setting kVWG=kVWG/2)" << std::endl;
1673
1674     fitTotal->SetParameter(0, fHisto->GetMaximum()/2.); // kVWG
1675
1676     fitResult = fHisto->Fit(fitTotal,fitOption,"");
1677     std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
1678   }
1679
1680 //  if ( fitResult->CovMatrixStatus() != 3 )
1681 //  {
1682 //    std::cout << "//-------Refitting again (setting Bkg norm= Bkg norm/2)" << std::endl;
1683 //    fitTotal->SetParameter(0, fHisto->GetMaximum()/2.); // kVWG
1684 //    fitResult = fHisto->Fit(fitTotal,fitOption,"");
1685 //  }
1686
1687 //  if ( fitResult->CovMatrixStatus() != 3 )
1688 //  {
1689 //    std::cout << "//-------Refitting again (setting Psi'norm= Psi'norm/2)" << std::endl;
1690 //    fitTotal->SetParameter(11, 5.); // //kPsi'
1691 //    fitResult = fHisto->Fit(fitTotal,fitOption,"");
1692 //
1693 //    std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
1694 //  }
1695 //
1696 //  if ( fitResult->CovMatrixStatus() != 3 )
1697 //  {
1698 //    std::cout << "//-------Refitting again (refitting Bkg)" << std::endl;
1699 //
1700 //    for ( Int_t i = 0; i < 4; ++i )
1701 //    {
1702 //      bck->SetParameter(i, fitTotal->GetParameter(i));
1703 //    }
1704 //
1705 //    SetFitRejectRange(2.7,3.5);
1706 //
1707 //    fHisto->Fit(bck,"R");
1708 //
1709 //    SetFitRejectRange();
1710 //
1711 //    for ( Int_t i = 0; i < 4; ++i )
1712 //    {
1713 //      fitTotal->SetParameter(i, bck->GetParameter(i));
1714 //    }
1715 //
1716 //    fitResult = fHisto->Fit(fitTotal,fitOption,"");
1717 //    std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
1718 //    std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
1719 //  }
1720 //  if ( static_cast<int>(fitResult) )
1721 //  {
1722 //    fitTotal->SetParameter(0, fHisto->GetMaximum()); // kVWG
1723 //    fitTotal->SetParameter(1, 1.9); // mVWG
1724 //
1725 //    fitTotal->SetParameter(2, 0.5); // sVWG1
1726 //    fitTotal->SetParLimits(2, 0., 100.);
1727 //
1728 //    fitResult = fHisto->Fit(fitTotal,fitOption,"");
1729 //    std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
1730 //    std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
1731 //
1732 //  }
1733   if ( static_cast<int>(fitResult) )
1734   {
1735     for ( Int_t i = 0; i < 4; ++i )
1736     {
1737       fitTotal->SetParameter(i, bckInit->GetParameter(i));
1738     }
1739     fitResult = fHisto->Fit(fitTotal,fitOption,"");
1740
1741     if ( static_cast<int>(fitResult) ) std::cout << "//-------Cannot fit properly, try something else..." << std::endl;
1742   }
1743
1744   delete bckInit;
1745
1746   Set("FitChi2PerNDF",fitTotal->GetChisquare()/fitTotal->GetNDF(),0.0);
1747   Set("FitNDF",fitTotal->GetNDF(),0.0);
1748
1749   Set("mJPsi",fitTotal->GetParameter(5),fitTotal->GetParError(5));
1750   Set("sJPsi",fitTotal->GetParameter(6),fitTotal->GetParError(6));
1751
1752   TF1* signalJPsi = new TF1("signalJPsi",this,&AliAnalysisMuMuJpsiResult::FitFunctionSignalCrystalBallExtended,fHisto->GetXaxis()->GetXmin(),fHisto->GetXaxis()->GetXmax(),7,"AliAnalysisMuMuJpsiResult","FitFunctionSignalCrystalBallExtended");
1753   signalJPsi->SetParameters(fitTotal->GetParameter(4),
1754                      fitTotal->GetParameter(5),
1755                      fitTotal->GetParameter(6),
1756                      fitTotal->GetParameter(7),
1757                      fitTotal->GetParameter(8),
1758                      fitTotal->GetParameter(9),
1759                      fitTotal->GetParameter(10));
1760
1761   TF1* signalPsiP = new TF1("signalPsiP",this,&AliAnalysisMuMuJpsiResult::FitFunctionSignalCrystalBallExtended,fHisto->GetXaxis()->GetXmin(),fHisto->GetXaxis()->GetXmax(),7,"AliAnalysisMuMuJpsiResult","FitFunctionSignalCrystalBallExtended");
1762   signalPsiP->SetParameters(fitTotal->GetParameter(11),
1763                         3.68609+(fitTotal->GetParameter(5)-3.096916)/3.096916*3.68609,
1764                         fitTotal->GetParameter(6)*paramSPsiP, // /3.096916*3.68609,
1765                         fitTotal->GetParameter(7),
1766                         fitTotal->GetParameter(8),
1767                         fitTotal->GetParameter(9),
1768                         fitTotal->GetParameter(10));
1769
1770   bck->SetParameters(fitTotal->GetParameter(0),
1771                      fitTotal->GetParameter(1),
1772                      fitTotal->GetParameter(2),
1773                      fitTotal->GetParameter(3));
1774
1775
1776   Set("kVWG",fitTotal->GetParameter(0),fitTotal->GetParError(0));
1777   Set("mVWG",fitTotal->GetParameter(1),fitTotal->GetParError(1));
1778   Set("sVWG1",fitTotal->GetParameter(2),fitTotal->GetParError(2));
1779   Set("sVWG2",fitTotal->GetParameter(3),fitTotal->GetParError(3));
1780   Set("kJPsi",fitTotal->GetParameter(4),fitTotal->GetParError(4));
1781
1782   Set("alJPsi",fitTotal->GetParameter(7),fitTotal->GetParError(7));
1783   Set("nlJPsi",fitTotal->GetParameter(8),fitTotal->GetParError(8));
1784   Set("auJPsi",fitTotal->GetParameter(9),fitTotal->GetParError(9));
1785   Set("nuJPsi",fitTotal->GetParameter(10),fitTotal->GetParError(10));
1786
1787 //  Set("alPsi",fitTotal->GetParameter(7),fitTotal->GetParError(7));
1788 //  Set("nlPsi",fitTotal->GetParameter(8),fitTotal->GetParError(8));
1789 //  Set("auPsi",fitTotal->GetParameter(9),fitTotal->GetParError(9));
1790 //  Set("nuPsi",fitTotal->GetParameter(10),fitTotal->GetParError(10));
1791   Set("kPsiP",fitTotal->GetParameter(11),fitTotal->GetParError(11));
1792
1793
1794   SetFitRejectRange();
1795
1796   AttachFunctionsToHisto(signalJPsi,signalPsiP,bck,fitTotal,fitRangeLow,fitRangeHigh);
1797
1798
1799   Double_t cbParameters[7];
1800   Double_t covarianceMatrix[7][7];
1801
1802   for ( int ix = 0; ix < 7; ++ix )
1803   {
1804     cbParameters[ix] = fitTotal->GetParameter(ix+4);
1805   }
1806
1807   for ( int iy = 0; iy < 7; ++iy )
1808   {
1809     for ( int ix = 0; ix < 7; ++ix )
1810     {
1811       covarianceMatrix[ix][iy] = (fitResult->GetCovarianceMatrix())(ix+4,iy+4);
1812     }
1813   }
1814
1815   Double_t a = fHisto->GetXaxis()->GetXmin();
1816   Double_t b = fHisto->GetXaxis()->GetXmax();
1817   double njpsi = signalJPsi->Integral(a,b)/fHisto->GetBinWidth(1);
1818   double nerr = signalJPsi->IntegralError(a,b,&cbParameters[0],&covarianceMatrix[0][0])/fHisto->GetBinWidth(1);
1819
1820   Set("NofJPsi",njpsi,nerr);
1821
1822   double m = GetValue("mJPsi");
1823   double s = GetValue("sJPsi");
1824   double njpsi3s = signalJPsi->Integral(m-3*s,m+3*s)/fHisto->GetBinWidth(1);
1825   double nerr3s = signalJPsi->IntegralError(m-3*s,m+3*s,&cbParameters[0],&covarianceMatrix[0][0])/fHisto->GetBinWidth(1);
1826
1827   Set("NofJPsi3s",njpsi3s,nerr3s);
1828
1829   //Computation of bin significance and signal over background
1830
1831   Double_t bkgParameters[4];
1832   Double_t bkgcovarianceMatrix[4][4];
1833
1834   for ( int ix = 0; ix < 4; ++ix )
1835   {
1836     bkgParameters[ix] = fitTotal->GetParameter(ix);
1837   }
1838
1839   for ( int iy = 0; iy < 4; ++iy )
1840   {
1841     for ( int ix = 0; ix < 4; ++ix )
1842     {
1843       bkgcovarianceMatrix[ix][iy] = (fitResult->GetCovarianceMatrix())(ix,iy);
1844     }
1845   }
1846
1847   double nbck3s = bck->Integral(m-3.*s,m+3.*s)/fHisto->GetBinWidth(1);
1848   double nbck3sErr = bck->IntegralError(m-3.*s,m+3.*s,&bkgParameters[0],&bkgcovarianceMatrix[0][0])/fHisto->GetBinWidth(1);
1849
1850   double sOverB3s = njpsi3s / nbck3s;
1851   double sOverB3sErr = sOverB3s*TMath::Sqrt(TMath::Power(nerr3s/njpsi3s,2.) + TMath::Power(nbck3sErr/nbck3s,2.));
1852
1853   Set("SignalOverBkg3s",sOverB3s,sOverB3sErr);
1854
1855   double sig = njpsi3s/TMath::Sqrt(njpsi3s + nbck3s);
1856   double sigErr = TMath::Sqrt( TMath::Power((1. - (1./2.)*njpsi3s/(njpsi3s + nbck3s) )*nerr3s/TMath::Sqrt(njpsi3s + nbck3s),2.) +
1857                                TMath::Power(njpsi3s*nbck3sErr/(2.*TMath::Power(njpsi3s + nbck3s,3./2.)),2.) );
1858
1859   Set("Significance3s",sig,sigErr);
1860
1861 }
1862
1863 //_____________________________________________________________________________
1864 void AliAnalysisMuMuJpsiResult::FitPSIPSIPRIMECB2VWGINDEPTAILS()
1865 {
1866   /// Fit using 2 extended crystal balls with independent tails (signal) + variable width gaussian (background)
1867
1868   fHisto->GetListOfFunctions()->Delete();
1869
1870   Double_t alphaLow = GetValue("alJPsi");
1871   Double_t nLow = GetValue("nlJPsi");
1872   Double_t alphaUp = GetValue("auJPsi");
1873   Double_t nUp = GetValue("nuJPsi");
1874
1875   Double_t alphaLowP = GetValue("alPsiP");
1876   Double_t nLowP = GetValue("nlPsiP");
1877   Double_t alphaUpP = GetValue("auPsiP");
1878   Double_t nUpP = GetValue("nuPsiP");
1879
1880   Double_t fitRangeLow = GetValue(kFitRangeLow);
1881   Double_t fitRangeHigh = GetValue(kFitRangeHigh);
1882
1883   Double_t paramSPsiP = GetValue("FSigmaPsiP");
1884
1885   TString msg;
1886
1887   if (IsValidValue(alphaLow)) msg += TString::Format("alphaLow=%e ",alphaLow);
1888   if (IsValidValue(nLow)) msg += TString::Format("nLow=%e ",nLow);
1889   if (IsValidValue(alphaUp)) msg += TString::Format("alphaUp=%e ",alphaUp);
1890   if (IsValidValue(nUp)) msg += TString::Format("nUp=%e ",nUp);
1891
1892   if (IsValidValue(alphaLowP)) msg += TString::Format("alphaLowP=%e ",alphaLowP);
1893   if (IsValidValue(nLowP)) msg += TString::Format("nLowP=%e ",nLowP);
1894   if (IsValidValue(alphaUpP)) msg += TString::Format("alphaUpP=%e ",alphaUpP);
1895   if (IsValidValue(nUpP)) msg += TString::Format("nUpP=%e ",nUpP);
1896
1897   AliDebug(1,Form("Fit with jpsi + psiprime VWG %s",msg.Data()));
1898
1899   // Add fit with indep tails
1900
1901   TF1* fitTotal = new TF1("signal+bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2VWGINDEPTAILS,fitRangeLow,fitRangeHigh,16,"AliAnalysisMuMuJpsiResult","FitFunctionTotalTwoCB2VWGINDEPTAILS");
1902
1903   fitTotal->SetParNames("kVWG","mVWG","sVWG1","sVWG2","kJPsi","mJPsi","sJPsi",
1904   //                        0      1       2       3       4      5      6
1905                         "alJPsi","nlJPsi","auJPsi","nuJPsi");
1906   //                       7        8        9        10
1907 //  fitTotal->SetParName(11, "kPsiP");
1908 //  //                            11
1909 //  fitTotal->SetParName(12, "mPsiP");
1910 //  //                            12
1911 //  fitTotal->SetParName(13, "sPsiP");
1912 //  //                            13
1913 //  fitTotal->SetParName(14, "alPsiP");
1914 //  //                            14
1915 //  fitTotal->SetParName(15, "nlPsiP");
1916 //  //                            15
1917 //  fitTotal->SetParName(16, "auPsiP");
1918 //  //                            16
1919 //  fitTotal->SetParName(17, "nuPsiP");
1920 //  //                            17
1921
1922   fitTotal->SetParName(11, "kPsiP");
1923   //                            11
1924    fitTotal->SetParName(12, "alPsiP");
1925   //                            12
1926   fitTotal->SetParName(13, "nlPsiP");
1927   //                            13
1928   fitTotal->SetParName(14, "auPsiP");
1929   //                            14
1930   fitTotal->SetParName(15, "nuPsiP");
1931   //                            15
1932
1933
1934   TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundVWG,fitRangeLow,fitRangeHigh,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundVWG");
1935
1936   const char* fitOption = "SER";
1937
1938 #if 0
1939   bck->SetParameter(0,fHisto->GetMaximum());
1940   bck->SetParameter(1,3);
1941   bck->SetParameter(2,10);
1942   bck->SetParameter(3,10);
1943
1944   bck->SetParLimits(1, 0., 100.);
1945   bck->SetParLimits(2, 0., 100.);
1946   bck->SetParLimits(3, 0., 100.);
1947
1948   SetFitRejectRange(2.7,3.5);
1949
1950   fHisto->Fit(bck,fitOption,"");
1951
1952   for ( Int_t i = 0; i < 4; ++i )
1953   {
1954     Double_t a,b;
1955     bck->GetParLimits(i,a,b);
1956     fitTotal->SetParameter(i,bck->GetParameter(i));
1957     fitTotal->SetParLimits(i,a,b);
1958   }
1959 #endif
1960
1961   Int_t bin = fHisto->FindBin(fitRangeLow);
1962   fitTotal->SetParameter(0, fHisto->GetBinContent(bin)); // kVWG
1963   fitTotal->SetParameter(1, 1.9); // mVWG
1964
1965   fitTotal->SetParameter(2, 0.5); // sVWG1
1966   fitTotal->SetParLimits(2, 0., 100.);
1967
1968   fitTotal->SetParameter(3, 0.3); // sVWG2
1969   fitTotal->SetParLimits(3, 0., 100.);
1970
1971   bin = fHisto->FindBin(3.09);
1972   fitTotal->SetParameter(4, fHisto->GetBinContent(bin)); // norm(kJPsi)
1973
1974   fitTotal->SetParameter(5, 3.1); // mean
1975   fitTotal->SetParLimits(5, 3.0, 3.2);
1976
1977   fitTotal->SetParameter(6, 0.08); // sigma
1978   fitTotal->SetParLimits(6, 0.03, 0.15);
1979
1980   if ( IsValidValue(alphaLow) )
1981   {
1982     fitTotal->FixParameter(7, alphaLow);
1983   }
1984   else
1985   {
1986     fitTotal->SetParameter(7,0.9);
1987     fitTotal->SetParLimits(7,0.1,10.0);
1988   }
1989
1990   if ( IsValidValue(nLow) )
1991   {
1992     fitTotal->FixParameter(8, nLow);
1993   }
1994   else
1995   {
1996     fitTotal->SetParameter(8,5.0);
1997     fitTotal->SetParLimits(8,0.0,10.0);
1998   }
1999
2000   if ( IsValidValue(alphaUp) )
2001   {
2002     fitTotal->FixParameter(9, alphaUp);
2003   }
2004   else
2005   {
2006     fitTotal->SetParameter(9, 2.0);
2007     fitTotal->SetParLimits(9,0.1,10.0);
2008   }
2009
2010   if ( IsValidValue(nUp) )
2011   {
2012     fitTotal->FixParameter(10, nUp);
2013   }
2014   else
2015   {
2016     fitTotal->SetParameter(10,3.0);
2017     fitTotal->SetParLimits(10,0.0,10.0);
2018   }
2019
2020   bin = fHisto->FindBin(3.68);
2021   fitTotal->SetParameter(11, fHisto->GetBinContent(bin)); //kPsiP
2022   fitTotal->SetParLimits(11, 0., fHisto->GetBinContent(bin)*2); //kPsiP
2023
2024 //  fitTotal->SetParameter(12, 3.7); // mean PsiP
2025 //  fitTotal->SetParLimits(12, 3.6, 3.71);
2026 //
2027 //  fitTotal->SetParameter(13, 0.08/3.096916*3.68609); // sigma PsiP
2028 //  fitTotal->SetParLimits(13, 0.03/3.096916*3.68609, 0.15/3.096916*3.68609);
2029
2030   if ( IsValidValue(alphaLowP) )
2031   {
2032     fitTotal->FixParameter(12, alphaLowP);
2033   }
2034   else
2035   {
2036     fitTotal->SetParameter(12,0.9);
2037     fitTotal->SetParLimits(12,0.1,10.0);
2038   }
2039
2040   if ( IsValidValue(nLowP) )
2041   {
2042     fitTotal->FixParameter(13, nLowP);
2043   }
2044   else
2045   {
2046     fitTotal->SetParameter(13,5.0);
2047     fitTotal->SetParLimits(13,0.0,10.0);
2048   }
2049
2050   if ( IsValidValue(alphaUpP) )
2051   {
2052     fitTotal->FixParameter(14, alphaUpP);
2053   }
2054   else
2055   {
2056     fitTotal->SetParameter(14, 2.0);
2057     fitTotal->SetParLimits(14,0.1,10.0);
2058   }
2059
2060   if ( IsValidValue(nUpP) )
2061   {
2062     fitTotal->FixParameter(15, nUpP);
2063   }
2064   else
2065   {
2066     fitTotal->SetParameter(15,3.0);
2067     fitTotal->SetParLimits(15,0.0,10.0);
2068   }
2069
2070   //  SetFitRejectRange();
2071
2072   TFitResultPtr fitResult = fHisto->Fit(fitTotal,fitOption,"");
2073
2074   std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
2075
2076   if ( static_cast<int>(fitResult) )
2077   {
2078     if ( fitTotal->GetParameter(11) <= fitTotal->GetParError(11) ) //kPsi'
2079     {
2080       std::cout << "//-------Refitting again (setting Psi'norm= Psi'norm/2)" << std::endl;
2081
2082       fitTotal->SetParameter(11, fHisto->GetBinContent(bin)/2.);
2083     }
2084
2085     if ( fitTotal->GetParameter(0) <= fitTotal->GetParError(0) ) //kVWG
2086     {
2087       std::cout << "//-------Refitting again (setting VWG norm= VWG norm /2)" << std::endl;
2088       bin = fHisto->FindBin(fitRangeLow);
2089
2090       fitTotal->SetParameter(0, fHisto->GetBinContent(bin)/2.);
2091     }
2092
2093     fitResult = fHisto->Fit(fitTotal,fitOption,"");
2094     std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
2095   }
2096
2097
2098   if ( static_cast<int>(fitResult) )
2099   {
2100     if ( fitTotal->GetParameter(11) <= fitTotal->GetParError(11) ) //kPsi'
2101     {
2102       std::cout << "//-------Refitting again (setting Psi'norm=0)" << std::endl;
2103
2104       fitTotal->FixParameter(11, 0.);
2105     }
2106
2107     fitResult = fHisto->Fit(fitTotal,fitOption,"");
2108     std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
2109   }
2110
2111   if ( static_cast<int>(fitResult) )
2112   {
2113     std::cout << "//-------Refitting again (setting kVWG=kVWG/2)" << std::endl;
2114
2115     fitTotal->SetParameter(0, fHisto->GetMaximum()/2.); // kVWG
2116
2117     fitResult = fHisto->Fit(fitTotal,fitOption,"");
2118     std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
2119   }
2120
2121   if ( static_cast<int>(fitResult) )
2122   {
2123     std::cout << "//-------Cannot fit properly, try something else..." << std::endl;
2124   }
2125
2126
2127   Set("FitChi2PerNDF",fitTotal->GetChisquare()/fitTotal->GetNDF(),0.0);
2128   Set("FitNDF",fitTotal->GetNDF(),0.0);
2129
2130   Set("mJPsi",fitTotal->GetParameter(5),fitTotal->GetParError(5));
2131   Set("sJPsi",fitTotal->GetParameter(6),fitTotal->GetParError(6));
2132
2133   Set("mPsiP",3.68609+(fitTotal->GetParameter(5)-3.096916)/3.096916*3.68609,fitTotal->GetParError(5)/3.096916*3.68609);
2134   Set("sPsiP",fitTotal->GetParameter(6)*paramSPsiP,fitTotal->GetParError(6)*paramSPsiP);
2135
2136   TF1* signalJPsi = new TF1("signalJPsi",this,&AliAnalysisMuMuJpsiResult::FitFunctionSignalCrystalBallExtended,fHisto->GetXaxis()->GetXmin(),fHisto->GetXaxis()->GetXmax(),7,"AliAnalysisMuMuJpsiResult","FitFunctionSignalCrystalBallExtended");
2137   signalJPsi->SetParameters(fitTotal->GetParameter(4),
2138                         fitTotal->GetParameter(5),
2139                         fitTotal->GetParameter(6),
2140                         fitTotal->GetParameter(7),
2141                         fitTotal->GetParameter(8),
2142                         fitTotal->GetParameter(9),
2143                         fitTotal->GetParameter(10));
2144
2145   TF1* signalPsiP = new TF1("signalPsiP",this,&AliAnalysisMuMuJpsiResult::FitFunctionSignalCrystalBallExtended,fHisto->GetXaxis()->GetXmin(),fHisto->GetXaxis()->GetXmax(),7,"AliAnalysisMuMuJpsiResult","FitFunctionSignalCrystalBallExtended");
2146   signalPsiP->SetParameters(fitTotal->GetParameter(11),
2147                             3.68609+(fitTotal->GetParameter(5)-3.096916)/3.096916*3.68609,
2148                             fitTotal->GetParameter(6)*paramSPsiP, // /3.096916*3.68609,
2149                             fitTotal->GetParameter(12),
2150                             fitTotal->GetParameter(13),
2151                             fitTotal->GetParameter(14),
2152                             fitTotal->GetParameter(15));
2153
2154   bck->SetParameters(fitTotal->GetParameter(0),
2155                      fitTotal->GetParameter(1),
2156                      fitTotal->GetParameter(2),
2157                      fitTotal->GetParameter(3));
2158
2159
2160   Set("kVWG",fitTotal->GetParameter(0),fitTotal->GetParError(0));
2161   Set("mVWG",fitTotal->GetParameter(1),fitTotal->GetParError(1));
2162   Set("sVWG1",fitTotal->GetParameter(2),fitTotal->GetParError(2));
2163   Set("sVWG2",fitTotal->GetParameter(3),fitTotal->GetParError(3));
2164
2165   Set("kJPsi",fitTotal->GetParameter(4),fitTotal->GetParError(4));
2166   Set("alJPsi",fitTotal->GetParameter(7),fitTotal->GetParError(7));
2167   Set("nlJPsi",fitTotal->GetParameter(8),fitTotal->GetParError(8));
2168   Set("auJPsi",fitTotal->GetParameter(9),fitTotal->GetParError(9));
2169   Set("nuJPsi",fitTotal->GetParameter(10),fitTotal->GetParError(10));
2170
2171   Set("kPsiP",fitTotal->GetParameter(11),fitTotal->GetParError(11));
2172   Set("alPsiP",fitTotal->GetParameter(12),fitTotal->GetParError(12));
2173   Set("nlPsiP",fitTotal->GetParameter(13),fitTotal->GetParError(13));
2174   Set("auPsiP",fitTotal->GetParameter(14),fitTotal->GetParError(14));
2175   Set("nuPsiP",fitTotal->GetParameter(15),fitTotal->GetParError(15));
2176
2177
2178
2179 //  SetFitRejectRange();
2180
2181   AttachFunctionsToHisto(signalJPsi,signalPsiP,bck,fitTotal,fitRangeLow,fitRangeHigh);
2182
2183
2184   Double_t cbParameters[7];
2185   Double_t covarianceMatrix[7][7];
2186
2187   for ( int ix = 0; ix < 7; ++ix )
2188   {
2189     cbParameters[ix] = fitTotal->GetParameter(ix+4);
2190   }
2191
2192   for ( int iy = 0; iy < 7; ++iy )
2193   {
2194     for ( int ix = 0; ix < 7; ++ix )
2195     {
2196       covarianceMatrix[ix][iy] = (fitResult->GetCovarianceMatrix())(ix+4,iy+4);
2197     }
2198   }
2199
2200   Double_t a = fHisto->GetXaxis()->GetXmin();
2201   Double_t b = fHisto->GetXaxis()->GetXmax();
2202   double njpsi = signalJPsi->Integral(a,b)/fHisto->GetBinWidth(1);
2203   double nerr = signalJPsi->IntegralError(a,b,&cbParameters[0],&covarianceMatrix[0][0])/fHisto->GetBinWidth(1);
2204
2205   Set("NofJPsi",njpsi,nerr);
2206
2207   double m = GetValue("mJPsi");
2208   double s = GetValue("sJPsi");
2209   double njpsi3s = signalJPsi->Integral(m-3*s,m+3*s)/fHisto->GetBinWidth(1);
2210   double nerr3s = signalJPsi->IntegralError(m-3*s,m+3*s,&cbParameters[0],&covarianceMatrix[0][0])/fHisto->GetBinWidth(1);
2211
2212   Set("NofJPsi3s",njpsi3s,nerr3s);
2213 }
2214
2215 //_____________________________________________________________________________
2216 void AliAnalysisMuMuJpsiResult::FitPSIPSIPRIMECB2POL2EXP()
2217 {
2218   /// Fit using 2 extended crystal balls (signal) + pol2 x exp (background)
2219   /// 13 parameters
2220
2221   Double_t alphaLow = GetValue("alJPsi");
2222   Double_t nLow = GetValue("nlJPsi");
2223   Double_t alphaUp = GetValue("auJPsi");
2224   Double_t nUp = GetValue("nuJPsi");
2225   Double_t fitRangeLow = GetValue(kFitRangeLow);
2226   Double_t fitRangeHigh = GetValue(kFitRangeHigh);
2227
2228   Double_t paramSPsiP = GetValue("FSigmaPsiP");
2229
2230   TString msg;
2231
2232   if (IsValidValue(alphaLow)) msg += TString::Format("alphaLow=%e ",alphaLow);
2233   if (IsValidValue(nLow)) msg += TString::Format("nLow=%e ",nLow);
2234   if (IsValidValue(alphaUp)) msg += TString::Format("alphaUp=%e ",alphaUp);
2235   if (IsValidValue(nUp)) msg += TString::Format("nUp=%e ",nUp);
2236
2237   AliDebug(1,Form("Fit with jpsi + psiprime Pol2 x Exp %s",msg.Data()));
2238
2239   TF1* fitTotal = new TF1("signal+bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2Pol2Exp,fitRangeLow,fitRangeHigh,12,"AliAnalysisMuMuJpsiResult","FitFunctionTotalTwoCB2Pol2Exp");
2240
2241   fitTotal->SetParNames("pol0","pol1","pol2","exp","kJPsi","mJPsi","sJPsi","alJPsi",
2242   //                      0      1       2     3      4      5       6       7
2243                         "nlJPsi","auJPsi","nuJPsi");
2244   //                          8       9        10
2245   fitTotal->SetParName(11,"kPsiP");
2246   //                            11
2247
2248   TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2Exp,fitRangeLow,fitRangeHigh,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2Exp");
2249
2250
2251   //___
2252   TF1* bckInit = new TF1("bckInit",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2Exp,1.7,6.,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2Exp");
2253
2254   Int_t bin = fHisto->FindBin(0.26);
2255
2256   bckInit->SetParameters(fHisto->GetBinContent(bin),-fHisto->GetBinContent(bin)/3.,100.,0.05);//fHisto->GetBinContent(bin)
2257
2258   SetFitRejectRange(2.7,4.0);
2259
2260   TFitResultPtr fitResultInit = fHisto->Fit(bckInit,"SR");
2261
2262   std::cout << "FitResultBkgInit=" << static_cast<int>(fitResultInit) << std::endl;
2263
2264   if ( static_cast<int>(fitResultInit) )
2265   {
2266     bin = fHisto->FindBin(0.82);
2267     bckInit->SetParameters(fHisto->GetBinContent(bin),2.,0.5,0.3);
2268     fitResultInit = fHisto->Fit(bckInit,"SR");
2269   }
2270
2271   SetFitRejectRange();
2272
2273   for ( Int_t i = 0; i < 4; ++i )
2274   {
2275     fitTotal->SetParameter(i, bckInit->GetParameter(i));
2276   }
2277
2278   delete bckInit;
2279   //__
2280   //
2281   //  bck->SetParameters(fHisto->GetMaximum(),0.05,0.05,0.05,1.);
2282   //
2283   //  SetFitRejectRange(2.7,3.5);
2284   //
2285   //  fHisto->Fit(bck,"R");
2286   //
2287   //  SetFitRejectRange();
2288   //
2289   //  for ( Int_t i = 0; i < 5; ++i )
2290   //  {
2291   //    fitTotal->SetParameter(i, bck->GetParameter(i));
2292   //  }
2293
2294   bin = fHisto->FindBin(3.09);
2295   fitTotal->SetParameter(4, fHisto->GetBinContent(bin)); // norm(kJPsi)
2296
2297   fitTotal->SetParameter(5, 3.1);
2298   fitTotal->SetParLimits(5, 3.07, 3.2);
2299   fitTotal->SetParameter(6, 0.08);
2300   fitTotal->SetParLimits(6, 0.05, 0.15);
2301
2302   if ( IsValidValue(alphaLow) )
2303   {
2304     fitTotal->FixParameter(7, alphaLow);
2305   }
2306   else
2307   {
2308     fitTotal->SetParameter(7,0.9);
2309     fitTotal->SetParLimits(7,0.1,10.0);
2310   }
2311
2312   if ( IsValidValue(nLow) )
2313   {
2314     fitTotal->FixParameter(8, nLow);
2315   }
2316   else
2317   {
2318     fitTotal->SetParameter(8,5.0);
2319     fitTotal->SetParLimits(8,0.0,10.0);
2320   }
2321
2322   if ( IsValidValue(alphaUp) )
2323   {
2324     fitTotal->FixParameter(9, alphaUp);
2325   }
2326   else
2327   {
2328     fitTotal->SetParameter(9, 2.0);
2329     fitTotal->SetParLimits(9,0.1,10.0);
2330   }
2331
2332   if ( IsValidValue(nUp) )
2333   {
2334     fitTotal->FixParameter(10, nUp);
2335   }
2336   else
2337   {
2338     fitTotal->SetParameter(10,3.0);
2339     fitTotal->SetParLimits(10,0.0,10.0);
2340   }
2341
2342   fitTotal->SetParameter(11, 10.);
2343
2344   const char* fitOption = "SER";
2345
2346   TFitResultPtr fitResult = fHisto->Fit(fitTotal,fitOption,"");
2347
2348   std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
2349   std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
2350
2351   if ( static_cast<int>(fitResult) )
2352   {
2353     if ( 0.5*fitTotal->GetParameter(11) <= fitTotal->GetParError(11) ) //kPsi'
2354     {
2355       std::cout << "//-------Refitting again (setting Psi'norm= Psi'norm/2)" << std::endl;
2356
2357       bin = fHisto->FindBin(3.68);
2358       fitTotal->SetParameter(11, fHisto->GetBinContent(bin)/2.);
2359     }
2360
2361     if ( 0.5*fitTotal->GetParameter(0) <= fitTotal->GetParError(0) ) //kPol2Exp
2362     {
2363       std::cout << "//-------Refitting again (setting kPol2Exp norm= kPol2Exp norm /2)" << std::endl;
2364       bin = fHisto->FindBin(fitRangeLow);
2365
2366       fitTotal->SetParameter(0, fHisto->GetBinContent(bin)/2.);
2367     }
2368
2369     fitResult = fHisto->Fit(fitTotal,fitOption,"");
2370     std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
2371   }
2372
2373   //  if ( fitResult->CovMatrixStatus() != 3 )
2374   //  {
2375   //    std::cout << "//-------Refitting again (setting Bkg norm= Bkg norm/2)" << std::endl;
2376   //    fitTotal->SetParameter(0, fHisto->GetMaximum()/2.); // kVWG
2377   //    fitResult = fHisto->Fit(fitTotal,fitOption,"");
2378   //  }
2379
2380   if ( fitResult->CovMatrixStatus() != 3 )
2381   {
2382     if ( 0.5*fitTotal->GetParameter(11) <= fitTotal->GetParError(11) ) //kPsi'
2383     {
2384       std::cout << "//-------Refitting again (setting Psi'norm= Psi'norm/2)" << std::endl;
2385
2386       bin = fHisto->FindBin(3.68);
2387       fitTotal->FixParameter(11, 0.);
2388     }
2389
2390     else
2391     {
2392       std::cout << "//-------Refitting again (setting Psi'norm= Psi'norm/2)" << std::endl;
2393
2394       fHisto->FindBin(3.68);
2395       fitTotal->SetParameter(11, fHisto->GetBinContent(bin)/2.); // kVWG
2396     }
2397
2398     fitResult = fHisto->Fit(fitTotal,fitOption,"");
2399
2400     std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
2401   }
2402
2403   //  if ( fitResult->CovMatrixStatus() != 3 )
2404   //  {
2405   //    std::cout << "//-------Refitting again (refitting Bkg)" << std::endl;
2406   //
2407   //    if( fitTotal->GetParameter(9) >= 0.09 || fitTotal->GetParameter(9) <= 0.06 || fitTotal->GetParameter(6) >= 3.11 || fitTotal->GetParameter(6) <= 3.08)
2408   //    {
2409   //      bck->SetParameters(0.01,fHisto->GetMaximum(),0.01,0.05,0.05,0.05,1.);
2410   //      //      for ( Int_t i = 0; i < 7; ++i )
2411   //      //      {
2412   //      //        bck->SetParameter(i, 0.);
2413   //      //      }
2414   //    }
2415   //    else
2416   //    {
2417   //      for ( Int_t i = 0; i < 7; ++i )
2418   //      {
2419   //        bck->SetParameter(i, fitTotal->GetParameter(i));
2420   //      }
2421   //    }
2422
2423   //
2424   //    for ( Int_t i = 0; i < 5; ++i )
2425   //    {
2426   //      bck->SetParameter(i, fitTotal->GetParameter(i));
2427   //    }
2428   //
2429   //    SetFitRejectRange(2.7,3.5);
2430   //
2431   //    fHisto->Fit(bck,"R");
2432   //
2433   //    SetFitRejectRange();
2434   //
2435   //    for ( Int_t i = 0; i < 5; ++i )
2436   //    {
2437   //      fitTotal->SetParameter(i, bck->GetParameter(i));
2438   //    }
2439   //
2440   //    fitResult = fHisto->Fit(fitTotal,fitOption,"");
2441   //  }
2442   //  std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
2443
2444   Set("FitChi2PerNDF",fitTotal->GetChisquare()/fitTotal->GetNDF(),0.0);
2445   Set("FitNDF",fitTotal->GetNDF(),0.0);
2446
2447   Set("mJPsi",fitTotal->GetParameter(5),fitTotal->GetParError(5));
2448   Set("sJPsi",fitTotal->GetParameter(6),fitTotal->GetParError(6));
2449
2450   TF1* signalJPsi = new TF1("signalJPsi",this,&AliAnalysisMuMuJpsiResult::FitFunctionSignalCrystalBallExtended,fHisto->GetXaxis()->GetXmin(),fHisto->GetXaxis()->GetXmax(),7,"AliAnalysisMuMuJpsiResult","FitFunctionSignalCrystalBallExtended");
2451   signalJPsi->SetParameters(fitTotal->GetParameter(4),
2452                             fitTotal->GetParameter(5),
2453                             fitTotal->GetParameter(6),
2454                             fitTotal->GetParameter(7),
2455                             fitTotal->GetParameter(8),
2456                             fitTotal->GetParameter(9),
2457                             fitTotal->GetParameter(10));
2458
2459   TF1* signalPsiP = new TF1("signalPsiP",this,&AliAnalysisMuMuJpsiResult::FitFunctionSignalCrystalBallExtended,fHisto->GetXaxis()->GetXmin(),fHisto->GetXaxis()->GetXmax(),7,"AliAnalysisMuMuJpsiResult","FitFunctionSignalCrystalBallExtended");
2460   signalPsiP->SetParameters(fitTotal->GetParameter(11),
2461                             3.68609+(fitTotal->GetParameter(5)-3.096916)/3.096916*3.68609,
2462                             fitTotal->GetParameter(6)*paramSPsiP, // /3.096916*3.68609,
2463                             fitTotal->GetParameter(7),
2464                             fitTotal->GetParameter(8),
2465                             fitTotal->GetParameter(9),
2466                             fitTotal->GetParameter(10));
2467
2468   for ( Int_t i = 0; i < 4; ++i )
2469   {
2470     bck->SetParameter(i, fitTotal->GetParameter(i));
2471   }
2472
2473 //  Set("kPol2Exp",fitTotal->GetParameter(0),fitTotal->GetParError(0));
2474   Set("pol0",fitTotal->GetParameter(0),fitTotal->GetParError(0));
2475   Set("pol1",fitTotal->GetParameter(1),fitTotal->GetParError(1));
2476   Set("pol2",fitTotal->GetParameter(2),fitTotal->GetParError(2));
2477   Set("exp",fitTotal->GetParameter(3),fitTotal->GetParError(3));
2478   Set("kJPsi",fitTotal->GetParameter(4),fitTotal->GetParError(4));
2479
2480   Set("alJPsi",fitTotal->GetParameter(7),fitTotal->GetParError(7));
2481   Set("nlJPsi",fitTotal->GetParameter(8),fitTotal->GetParError(8));
2482   Set("auJPsi",fitTotal->GetParameter(9),fitTotal->GetParError(9));
2483   Set("nuJPsi",fitTotal->GetParameter(10),fitTotal->GetParError(10));
2484
2485   Set("kPsiP",fitTotal->GetParameter(11),fitTotal->GetParError(11));
2486
2487   AttachFunctionsToHisto(signalJPsi,signalPsiP,bck,fitTotal,fitRangeLow,fitRangeHigh);
2488
2489   Double_t cbParameters[7];
2490   Double_t covarianceMatrix[7][7];
2491
2492   for ( int ix = 0; ix < 7; ++ix )
2493   {
2494     cbParameters[ix] = fitTotal->GetParameter(ix+4);
2495   }
2496
2497   for ( int iy = 0; iy < 7; ++iy )
2498   {
2499     for ( int ix = 0; ix < 7; ++ix )
2500     {
2501       covarianceMatrix[ix][iy] = (fitResult->GetCovarianceMatrix())(ix+4,iy+4);
2502     }
2503   }
2504
2505   Double_t a = fHisto->GetXaxis()->GetXmin();
2506   Double_t b = fHisto->GetXaxis()->GetXmax();
2507   double njpsi = signalJPsi->Integral(a,b)/fHisto->GetBinWidth(1);
2508   double nerr = signalJPsi->IntegralError(a,b,&cbParameters[0],&covarianceMatrix[0][0])/fHisto->GetBinWidth(1);
2509
2510   Set("NofJPsi",njpsi,nerr);
2511
2512   double m = GetValue("mJPsi");
2513   double s = GetValue("sJPsi");
2514   double njpsi3s = signalJPsi->Integral(m-3*s,m+3*s)/fHisto->GetBinWidth(1);
2515   double nerr3s = signalJPsi->IntegralError(m-3*s,m+3*s,&cbParameters[0],&covarianceMatrix[0][0])/fHisto->GetBinWidth(1);
2516
2517   Set("NofJPsi3s",njpsi3s,nerr3s);
2518
2519   //Computation of bin significance and signal over background
2520
2521   Double_t bkgParameters[4];
2522   Double_t bkgcovarianceMatrix[4][4];
2523
2524   for ( int ix = 0; ix < 4; ++ix )
2525   {
2526     bkgParameters[ix] = fitTotal->GetParameter(ix);
2527   }
2528
2529   for ( int iy = 0; iy < 4; ++iy )
2530   {
2531     for ( int ix = 0; ix < 4; ++ix )
2532     {
2533       bkgcovarianceMatrix[ix][iy] = (fitResult->GetCovarianceMatrix())(ix,iy);
2534     }
2535   }
2536
2537   double nbck3s = bck->Integral(m-3.*s,m+3.*s)/fHisto->GetBinWidth(1);
2538   double nbck3sErr = bck->IntegralError(m-3.*s,m+3.*s,&bkgParameters[0],&bkgcovarianceMatrix[0][0])/fHisto->GetBinWidth(1);
2539
2540   double sOverB3s = njpsi3s / nbck3s;
2541   double sOverB3sErr = sOverB3s*TMath::Sqrt(TMath::Power(nerr3s/njpsi3s,2.) + TMath::Power(nbck3sErr/nbck3s,2.));
2542
2543   Set("SignalOverBkg3s",sOverB3s,sOverB3sErr);
2544
2545   double sig = njpsi3s/TMath::Sqrt(njpsi3s + nbck3s);
2546   double sigErr = TMath::Sqrt( TMath::Power((1. - (1./2.)*njpsi3s/(njpsi3s + nbck3s) )*nerr3s/TMath::Sqrt(njpsi3s + nbck3s),2.) +
2547                               TMath::Power(njpsi3s*nbck3sErr/(2.*TMath::Power(njpsi3s + nbck3s,3./2.)),2.) );
2548
2549   Set("Significance3s",sig,sigErr);
2550 }
2551
2552 ////_____________________________________________________________________________
2553 //void AliAnalysisMuMuJpsiResult::FitPSIPSIPRIMECB2POL2EXP()
2554 //{
2555 //  /// Fit using 2 extended crystal balls (signal) + pol2 x exp (background)
2556 //  /// 13 parameters
2557 //
2558 //  Double_t alphaLow = GetValue("alJPsi");
2559 //  Double_t nLow = GetValue("nlJPsi");
2560 //  Double_t alphaUp = GetValue("auJPsi");
2561 //  Double_t nUp = GetValue("nuJPsi");
2562 //  Double_t fitRangeLow = GetValue(kFitRangeLow);
2563 //  Double_t fitRangeHigh = GetValue(kFitRangeHigh);
2564 //
2565 //  TString msg;
2566 //
2567 //  if (IsValidValue(alphaLow)) msg += TString::Format("alphaLow=%e ",alphaLow);
2568 //  if (IsValidValue(nLow)) msg += TString::Format("nLow=%e ",nLow);
2569 //  if (IsValidValue(alphaUp)) msg += TString::Format("alphaUp=%e ",alphaUp);
2570 //  if (IsValidValue(nUp)) msg += TString::Format("nUp=%e ",nUp);
2571 //
2572 //  AliDebug(1,Form("Fit with jpsi + psiprime Pol2 x Exp %s",msg.Data()));
2573 //
2574 //  TF1* fitTotal = new TF1("signal+bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2Pol2Exp,fitRangeLow,fitRangeHigh,13,"AliAnalysisMuMuJpsiResult","FitFunctionTotalTwoCB2Pol2Exp");
2575 //
2576 //  fitTotal->SetParNames("kPol2Exp","pol0","pol1","pol2","exp","kJPsi","mJPsi","sJPsi",
2577 ////                           0      1       2      3     4      5       6       7
2578 //                        "alJPsi","nlJPsi","auJPsi");
2579 ////                          8       9        10
2580 //  fitTotal->SetParName(11,"nuJPsi");
2581 ////                            11
2582 //  fitTotal->SetParName(12, "kPsiP");
2583 ////                            12
2584 //
2585 //  TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2Exp,fitRangeLow,fitRangeHigh,5,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2Exp");
2586 //
2587 //
2588 //  //___
2589 //  TF1* bckInit = new TF1("bckInit",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2Exp,1.7,6.,5,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2Exp");
2590 //
2591 //  Int_t bin = fHisto->FindBin(0.26);
2592 //
2593 //  bckInit->SetParameters(-0.1,1.,0.5,0.3,1.);//fHisto->GetBinContent(bin)
2594 //
2595 //  SetFitRejectRange(2.7,4.0);
2596 //
2597 //  TFitResultPtr fitResultInit = fHisto->Fit(bckInit,"SR");
2598 //
2599 //  std::cout << "FitResultBkgInit=" << static_cast<int>(fitResultInit) << std::endl;
2600 //
2601 //  if ( static_cast<int>(fitResultInit) )
2602 //  {
2603 //    bin = fHisto->FindBin(0.82);
2604 //    bckInit->SetParameters(fHisto->GetBinContent(bin),2.,0.5,0.3);
2605 //    fitResultInit = fHisto->Fit(bckInit,"SR");
2606 //  }
2607 //
2608 //  SetFitRejectRange();
2609 //
2610 //  for ( Int_t i = 0; i < 5; ++i )
2611 //  {
2612 //    fitTotal->SetParameter(i, bckInit->GetParameter(i));
2613 //  }
2614 //
2615 //  delete bckInit;
2616 ////__
2617 ////
2618 ////  bck->SetParameters(fHisto->GetMaximum(),0.05,0.05,0.05,1.);
2619 ////
2620 ////  SetFitRejectRange(2.7,3.5);
2621 ////
2622 ////  fHisto->Fit(bck,"R");
2623 ////
2624 ////  SetFitRejectRange();
2625 ////
2626 ////  for ( Int_t i = 0; i < 5; ++i )
2627 ////  {
2628 ////    fitTotal->SetParameter(i, bck->GetParameter(i));
2629 ////  }
2630 //
2631 //  bin = fHisto->FindBin(3.09);
2632 //  fitTotal->SetParameter(5, fHisto->GetBinContent(bin)); // norm(kJPsi)
2633 //
2634 //  fitTotal->SetParameter(6, 3.1);
2635 //  fitTotal->SetParLimits(6, 3.07, 3.2);
2636 //  fitTotal->SetParameter(7, 0.08);
2637 //  fitTotal->SetParLimits(7, 0.05, 0.15);
2638 //
2639 //  if ( IsValidValue(alphaLow) )
2640 //  {
2641 //    fitTotal->FixParameter(8, alphaLow);
2642 //  }
2643 //  else
2644 //  {
2645 //    fitTotal->SetParameter(8,0.9);
2646 //    fitTotal->SetParLimits(8,0.1,10.0);
2647 //  }
2648 //
2649 //  if ( IsValidValue(nLow) )
2650 //  {
2651 //    fitTotal->FixParameter(9, nLow);
2652 //  }
2653 //  else
2654 //  {
2655 //    fitTotal->SetParameter(9,5.0);
2656 //    fitTotal->SetParLimits(9,0.0,10.0);
2657 //  }
2658 //
2659 //  if ( IsValidValue(alphaUp) )
2660 //  {
2661 //    fitTotal->FixParameter(10, alphaUp);
2662 //  }
2663 //  else
2664 //  {
2665 //    fitTotal->SetParameter(10, 2.0);
2666 //    fitTotal->SetParLimits(10,0.1,10.0);
2667 //  }
2668 //
2669 //  if ( IsValidValue(nUp) )
2670 //  {
2671 //    fitTotal->FixParameter(11, nUp);
2672 //  }
2673 //  else
2674 //  {
2675 //    fitTotal->SetParameter(11,3.0);
2676 //    fitTotal->SetParLimits(11,0.0,10.0);
2677 //  }
2678 //
2679 //  fitTotal->SetParameter(12, 10.);
2680 //
2681 //  const char* fitOption = "SER";
2682 //
2683 //  TFitResultPtr fitResult = fHisto->Fit(fitTotal,fitOption,"");
2684 //
2685 //  std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
2686 //  std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
2687 //
2688 //  if ( static_cast<int>(fitResult) )
2689 //  {
2690 //    if ( fitTotal->GetParameter(12) <= fitTotal->GetParError(12) ) //kPsi'
2691 //    {
2692 //      std::cout << "//-------Refitting again (setting Psi'norm= Psi'norm/2)" << std::endl;
2693 //
2694 //      bin = fHisto->FindBin(3.68);
2695 //      fitTotal->SetParameter(12, fHisto->GetBinContent(bin)/2.);
2696 //    }
2697 //
2698 //    if ( fitTotal->GetParameter(0) <= fitTotal->GetParError(0) ) //kPol2Exp
2699 //    {
2700 //      std::cout << "//-------Refitting again (setting kPol2Exp norm= kPol2Exp norm /2)" << std::endl;
2701 //      bin = fHisto->FindBin(fitRangeLow);
2702 //
2703 //      fitTotal->SetParameter(0, fHisto->GetBinContent(bin)/2.);
2704 //    }
2705 //
2706 //    fitResult = fHisto->Fit(fitTotal,fitOption,"");
2707 //    std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
2708 //  }
2709 //
2710 ////  if ( fitResult->CovMatrixStatus() != 3 )
2711 ////  {
2712 ////    std::cout << "//-------Refitting again (setting Bkg norm= Bkg norm/2)" << std::endl;
2713 ////    fitTotal->SetParameter(0, fHisto->GetMaximum()/2.); // kVWG
2714 ////    fitResult = fHisto->Fit(fitTotal,fitOption,"");
2715 ////  }
2716 //
2717 //  if ( fitResult->CovMatrixStatus() != 3 )
2718 //  {
2719 //    if ( fitTotal->GetParameter(12) <= fitTotal->GetParError(12) ) //kPsi'
2720 //    {
2721 //      std::cout << "//-------Refitting again (setting Psi'norm= Psi'norm/2)" << std::endl;
2722 //
2723 //      bin = fHisto->FindBin(3.68);
2724 //      fitTotal->FixParameter(12, 0.);
2725 //    }
2726 //
2727 //    else
2728 //    {
2729 //      std::cout << "//-------Refitting again (setting Psi'norm= Psi'norm/2)" << std::endl;
2730 //
2731 //      fHisto->FindBin(3.68);
2732 //      fitTotal->SetParameter(12, fHisto->GetBinContent(bin)/2.); // kVWG
2733 //    }
2734 //
2735 //    fitResult = fHisto->Fit(fitTotal,fitOption,"");
2736 //
2737 //     std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
2738 //  }
2739 //
2740 ////  if ( fitResult->CovMatrixStatus() != 3 )
2741 ////  {
2742 ////    std::cout << "//-------Refitting again (refitting Bkg)" << std::endl;
2743 ////
2744 ////    if( fitTotal->GetParameter(9) >= 0.09 || fitTotal->GetParameter(9) <= 0.06 || fitTotal->GetParameter(6) >= 3.11 || fitTotal->GetParameter(6) <= 3.08)
2745 ////    {
2746 ////      bck->SetParameters(0.01,fHisto->GetMaximum(),0.01,0.05,0.05,0.05,1.);
2747 ////      //      for ( Int_t i = 0; i < 7; ++i )
2748 ////      //      {
2749 ////      //        bck->SetParameter(i, 0.);
2750 ////      //      }
2751 ////    }
2752 ////    else
2753 ////    {
2754 ////      for ( Int_t i = 0; i < 7; ++i )
2755 ////      {
2756 ////        bck->SetParameter(i, fitTotal->GetParameter(i));
2757 ////      }
2758 ////    }
2759 //
2760 ////
2761 ////    for ( Int_t i = 0; i < 5; ++i )
2762 ////    {
2763 ////      bck->SetParameter(i, fitTotal->GetParameter(i));
2764 ////    }
2765 ////
2766 ////    SetFitRejectRange(2.7,3.5);
2767 ////
2768 ////    fHisto->Fit(bck,"R");
2769 ////
2770 ////    SetFitRejectRange();
2771 ////
2772 ////    for ( Int_t i = 0; i < 5; ++i )
2773 ////    {
2774 ////      fitTotal->SetParameter(i, bck->GetParameter(i));
2775 ////    }
2776 ////
2777 ////    fitResult = fHisto->Fit(fitTotal,fitOption,"");
2778 ////  }
2779 ////  std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
2780 //
2781 //  Set("FitChi2PerNDF",fitTotal->GetChisquare()/fitTotal->GetNDF(),0.0);
2782 //  Set("FitNDF",fitTotal->GetNDF(),0.0);
2783 //
2784 //  Set("mJPsi",fitTotal->GetParameter(6),fitTotal->GetParError(6));
2785 //  Set("sJPsi",fitTotal->GetParameter(7),fitTotal->GetParError(7));
2786 //
2787 //  TF1* signalJPsi = new TF1("signalJPsi",this,&AliAnalysisMuMuJpsiResult::FitFunctionSignalCrystalBallExtended,fHisto->GetXaxis()->GetXmin(),fHisto->GetXaxis()->GetXmax(),7,"AliAnalysisMuMuJpsiResult","FitFunctionSignalCrystalBallExtended");
2788 //  signalJPsi->SetParameters(fitTotal->GetParameter(5),
2789 //                            fitTotal->GetParameter(6),
2790 //                            fitTotal->GetParameter(7),
2791 //                            fitTotal->GetParameter(8),
2792 //                            fitTotal->GetParameter(9),
2793 //                            fitTotal->GetParameter(10),
2794 //                            fitTotal->GetParameter(11));
2795 //
2796 //  TF1* signalPsiP = new TF1("signalPsiP",this,&AliAnalysisMuMuJpsiResult::FitFunctionSignalCrystalBallExtended,fHisto->GetXaxis()->GetXmin(),fHisto->GetXaxis()->GetXmax(),7,"AliAnalysisMuMuJpsiResult","FitFunctionSignalCrystalBallExtended");
2797 //  signalPsiP->SetParameters(fitTotal->GetParameter(12),
2798 //                            3.68609+(fitTotal->GetParameter(6)-3.096916)/3.096916*3.68609,
2799 //                            fitTotal->GetParameter(7)/3.096916*3.68609,
2800 //                            fitTotal->GetParameter(8),
2801 //                            fitTotal->GetParameter(9),
2802 //                            fitTotal->GetParameter(10),
2803 //                            fitTotal->GetParameter(11));
2804 //
2805 //  for ( Int_t i = 0; i < 5; ++i )
2806 //  {
2807 //    bck->SetParameter(i, fitTotal->GetParameter(i));
2808 //  }
2809 //
2810 //  Set("kPol2Exp",fitTotal->GetParameter(0),fitTotal->GetParError(0));
2811 //  Set("pol0",fitTotal->GetParameter(1),fitTotal->GetParError(1));
2812 //  Set("pol1",fitTotal->GetParameter(2),fitTotal->GetParError(2));
2813 //  Set("pol2",fitTotal->GetParameter(3),fitTotal->GetParError(3));
2814 //  Set("exp",fitTotal->GetParameter(4),fitTotal->GetParError(4));
2815 //
2816 //  Set("alJPsi",fitTotal->GetParameter(8),fitTotal->GetParError(8));
2817 //  Set("nlJPsi",fitTotal->GetParameter(9),fitTotal->GetParError(9));
2818 //  Set("auJPsi",fitTotal->GetParameter(10),fitTotal->GetParError(10));
2819 //  Set("nuJPsi",fitTotal->GetParameter(11),fitTotal->GetParError(11));
2820 //
2821 //  Set("kPsiP",fitTotal->GetParameter(12),fitTotal->GetParError(12));
2822 //
2823 //  AttachFunctionsToHisto(signalJPsi,signalPsiP,bck,fitTotal,fitRangeLow,fitRangeHigh);
2824 //
2825 //  Double_t cbParameters[7];
2826 //  Double_t covarianceMatrix[7][7];
2827 //
2828 //  for ( int ix = 0; ix < 7; ++ix )
2829 //  {
2830 //    cbParameters[ix] = fitTotal->GetParameter(ix+5);
2831 //  }
2832 //
2833 //  for ( int iy = 0; iy < 7; ++iy )
2834 //  {
2835 //    for ( int ix = 0; ix < 7; ++ix )
2836 //    {
2837 //      covarianceMatrix[ix][iy] = (fitResult->GetCovarianceMatrix())(ix+5,iy+5);
2838 //    }
2839 //  }
2840 //
2841 //  Double_t a = fHisto->GetXaxis()->GetXmin();
2842 //  Double_t b = fHisto->GetXaxis()->GetXmax();
2843 //  double njpsi = signalJPsi->Integral(a,b)/fHisto->GetBinWidth(1);
2844 //  double nerr = signalJPsi->IntegralError(a,b,&cbParameters[0],&covarianceMatrix[0][0])/fHisto->GetBinWidth(1);
2845 //
2846 //  Set("NofJPsi",njpsi,nerr);
2847 //}
2848
2849 //_____________________________________________________________________________
2850 void AliAnalysisMuMuJpsiResult::FitPSIPSIPRIMECB2POL4EXP()
2851 {
2852   /// Fit using 2 extended crystal balls (signal) + pol4 x exp (background)
2853   /// 15 parameters
2854
2855   Double_t alphaLow = GetValue("alJPsi");
2856   Double_t nLow = GetValue("nlJPsi");
2857   Double_t alphaUp = GetValue("auJPsi");
2858   Double_t nUp = GetValue("nuJPsi");
2859   Double_t fitRangeLow = GetValue(kFitRangeLow);
2860   Double_t fitRangeHigh = GetValue(kFitRangeHigh);
2861
2862   Double_t paramSPsiP = GetValue("FSigmaPsiP");
2863
2864   TString msg;
2865
2866   if (IsValidValue(alphaLow)) msg += TString::Format("alphaLow=%e ",alphaLow);
2867   if (IsValidValue(nLow)) msg += TString::Format("nLow=%e ",nLow);
2868   if (IsValidValue(alphaUp)) msg += TString::Format("alphaUp=%e ",alphaUp);
2869   if (IsValidValue(nUp)) msg += TString::Format("nUp=%e ",nUp);
2870
2871   AliDebug(1,Form("Fit with jpsi + psiprime Pol4 x Exp %s",msg.Data()));
2872
2873   TF1* fitTotal = new TF1("signal+bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2Pol4Exp,fitRangeLow,fitRangeHigh,14,"AliAnalysisMuMuJpsiResult","FitFunctionTotalTwoCB2Pol4Exp");
2874
2875   fitTotal->SetParNames("pol0","pol1","pol2","pol3","pol4","exp","kJPsi",
2876   //                      0       1      2      3     4       5     6
2877                         "mJPsi","sJPsi","alJPsi","nlJPsi");
2878   //                       7      8       9         10
2879   fitTotal->SetParName(11,"auJPsi");
2880   //                        11
2881   fitTotal->SetParName(12,"nuJPsi");
2882   //                         12
2883   fitTotal->SetParName(13,"kPsiP");
2884   //                         13
2885
2886
2887   TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol4Exp,fitRangeLow,fitRangeHigh,6,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol4Exp");
2888
2889   //    bck->SetParameters(fHisto->GetMaximum(),0.01,0.01,0.01,0.01,0.01,1.);
2890   //
2891   //  SetFitRejectRange(2.7,3.5);
2892   //
2893   //  fHisto->Fit(bck,"R");
2894   //
2895   //  SetFitRejectRange();
2896   //
2897   //  for ( Int_t i = 0; i < 7; ++i )
2898   //  {
2899   //    fitTotal->SetParameter(i, bck->GetParameter(i));
2900   //  }
2901
2902   //___
2903   TF1* bckInit = new TF1("bckInit",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol4Exp,1.6,7.,6,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol4Exp");
2904
2905   Int_t bin = fHisto->FindBin(1.6);
2906
2907   bckInit->SetParameters(fHisto->GetBinContent(bin),-fHisto->GetBinContent(bin),fHisto->GetBinContent(bin)/2.,-fHisto->GetBinContent(bin)/10.,fHisto->GetBinContent(bin)/100.,-2.);
2908
2909   SetFitRejectRange(2.6,4.0);
2910
2911   TFitResultPtr fitResultInit = fHisto->Fit(bckInit,"SR");
2912
2913   std::cout << "FitResultBkgInit=" << static_cast<int>(fitResultInit) << std::endl;
2914
2915   if ( static_cast<int>(fitResultInit) )
2916   {
2917     bin = fHisto->FindBin(0.82);
2918     bckInit->SetParameters(0.,1.,1.,1.,2.,0.5);
2919     fitResultInit = fHisto->Fit(bckInit,"SR");
2920   }
2921
2922   SetFitRejectRange();
2923
2924   for ( Int_t i = 0; i < 6; ++i )
2925   {
2926     fitTotal->SetParameter(i, bckInit->GetParameter(i));
2927   }
2928
2929   delete bckInit;
2930   //___
2931
2932   //  bck->SetRange(fitRangeLow,fitRangeHigh);
2933
2934   bin = fHisto->FindBin(3.09);
2935   fitTotal->SetParameter(6, fHisto->GetBinContent(bin)); // norm(kJPsi)
2936
2937   fitTotal->SetParameter(7, 3.1); // mean
2938   fitTotal->SetParLimits(7, 3.0, 3.2);
2939
2940   fitTotal->SetParameter(8, 0.08); // sigma
2941   fitTotal->SetParLimits(8, 0.03, 0.15);
2942
2943   if ( IsValidValue(alphaLow) )
2944   {
2945     fitTotal->FixParameter(9, alphaLow);
2946   }
2947   else
2948   {
2949     fitTotal->SetParameter(9,0.9);
2950     fitTotal->SetParLimits(9,0.1,10.0);
2951   }
2952
2953   if ( IsValidValue(nLow) )
2954   {
2955     fitTotal->FixParameter(10, nLow);
2956   }
2957   else
2958   {
2959     fitTotal->SetParameter(10,5.0);
2960     fitTotal->SetParLimits(10,0.0,10.0);
2961   }
2962
2963   if ( IsValidValue(alphaUp) )
2964   {
2965     fitTotal->FixParameter(11, alphaUp);
2966   }
2967   else
2968   {
2969     fitTotal->SetParameter(11, 2.0);
2970     fitTotal->SetParLimits(11,0.1,10.0);
2971   }
2972
2973   if ( IsValidValue(nUp) )
2974   {
2975     fitTotal->FixParameter(12, nUp);
2976   }
2977   else
2978   {
2979     fitTotal->SetParameter(12,3.0);
2980     fitTotal->SetParLimits(12,0.0,10.0);
2981   }
2982
2983   bin = fHisto->FindBin(3.68);
2984   fitTotal->SetParameter(13, fHisto->GetBinContent(bin)); //kPsiP
2985   fitTotal->SetParLimits(13, 0., fHisto->GetBinContent(bin)*2); //kPsiP
2986
2987   //  fitTotal->SetParameter(12, 3.7); // mean PsiP
2988   //  fitTotal->SetParLimits(12, 3.6, 3.71);
2989   //
2990   //  fitTotal->SetParameter(13, 0.08/3.096916*3.68609); // sigma PsiP
2991   //  fitTotal->SetParLimits(13, 0.03/3.096916*3.68609, 0.15/3.096916*3.68609);
2992
2993   const char* fitOption = "SER";
2994
2995   TFitResultPtr fitResult = fHisto->Fit(fitTotal,fitOption,"");
2996
2997   std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
2998   std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
2999
3000   if ( static_cast<int>(fitResult) )
3001   {
3002     if ( fitTotal->GetParameter(13) <= fitTotal->GetParError(13) ) //kPsi'
3003     {
3004       std::cout << "//-------Refitting again (setting Psi'norm= Psi'norm/2)" << std::endl;
3005
3006       fitTotal->SetParameter(13, fHisto->GetBinContent(bin)/2.);
3007     }
3008
3009     if ( fitTotal->GetParameter(0) <= fitTotal->GetParError(0) ) //kPol4Exp
3010     {
3011       std::cout << "//-------Refitting again (setting kPol4Exp norm= kPol4Exp norm /2)" << std::endl;
3012       bin = fHisto->FindBin(fitRangeLow);
3013
3014       fitTotal->SetParameter(0, fHisto->GetBinContent(bin)/2.);
3015     }
3016
3017     fitResult = fHisto->Fit(fitTotal,fitOption,"");
3018     std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
3019   }
3020
3021   if ( fitResult->CovMatrixStatus() != 3 )
3022   {
3023     std::cout << "//-------Refitting again (setting Bkg norm= Bkg norm/2)" << std::endl;
3024     fitTotal->SetParameter(0, fHisto->GetMaximum()/2.); // kVWG
3025     fitResult = fHisto->Fit(fitTotal,fitOption,"");
3026   }
3027
3028 //  if ( fitResult->CovMatrixStatus() != 3 )
3029 //  {
3030 //    bin = fHisto->FindBin(3.68);
3031 //    std::cout << "//-------Refitting again (setting Psi'norm= Psi'norm/2)" << std::endl;
3032 //    fitTotal->SetParameter(13, fHisto->GetBinContent(bin)/2.); // kVWG
3033 //    fitResult = fHisto->Fit(fitTotal,fitOption,"");
3034 //
3035 //    std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
3036 //  }
3037
3038   //  if ( fitResult->CovMatrixStatus() != 3 )
3039   //  {
3040   //    std::cout << "//-------Refitting again (refitting Bkg)" << std::endl;
3041   //    if( fitTotal->GetParameter(9) >= 0.09 || fitTotal->GetParameter(9) <= 0.06 )
3042   //    {
3043   //      bck->SetParameters(0.01,fHisto->GetMaximum(),0.01,0.01,0.01,0.01,1.);
3044   ////      for ( Int_t i = 0; i < 7; ++i )
3045   ////      {
3046   ////        bck->SetParameter(i, 0.);
3047   ////      }
3048   //    }
3049   //    else
3050   //    {
3051   //      for ( Int_t i = 0; i < 7; ++i )
3052   //      {
3053   //        bck->SetParameter(i, fitTotal->GetParameter(i));
3054   //      }
3055   //    }
3056   //
3057   //    SetFitRejectRange(2.7,3.5);
3058   //
3059   //    fHisto->Fit(bck,"R");
3060   //
3061   //    SetFitRejectRange();
3062   //
3063   //    for ( Int_t i = 0; i < 7; ++i )
3064   //    {
3065   //      fitTotal->SetParameter(i, bck->GetParameter(i));
3066   //    }
3067   //
3068   //    fitResult = fHisto->Fit(fitTotal,fitOption,"");
3069   //  }
3070   //  std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
3071
3072
3073
3074   Set("FitChi2PerNDF",fitTotal->GetChisquare()/fitTotal->GetNDF(),0.0);
3075   Set("FitNDF",fitTotal->GetNDF(),0.0);
3076
3077   Set("mJPsi",fitTotal->GetParameter(7),fitTotal->GetParError(7));
3078   Set("sJPsi",fitTotal->GetParameter(8),fitTotal->GetParError(8));
3079
3080   TF1* signalJPsi = new TF1("signalJPsi",this,&AliAnalysisMuMuJpsiResult::FitFunctionSignalCrystalBallExtended,fHisto->GetXaxis()->GetXmin(),fHisto->GetXaxis()->GetXmax(),7,"AliAnalysisMuMuJpsiResult","FitFunctionSignalCrystalBallExtended");
3081   signalJPsi->SetParameters(fitTotal->GetParameter(6),
3082                             fitTotal->GetParameter(7),
3083                             fitTotal->GetParameter(8),
3084                             fitTotal->GetParameter(9),
3085                             fitTotal->GetParameter(10),
3086                             fitTotal->GetParameter(11),
3087                             fitTotal->GetParameter(12));
3088
3089   TF1* signalPsiP = new TF1("signalPsiP",this,&AliAnalysisMuMuJpsiResult::FitFunctionSignalCrystalBallExtended,fHisto->GetXaxis()->GetXmin(),fHisto->GetXaxis()->GetXmax(),7,"AliAnalysisMuMuJpsiResult","FitFunctionSignalCrystalBallExtended");
3090   signalPsiP->SetParameters(fitTotal->GetParameter(13),
3091                             3.68609+(fitTotal->GetParameter(7)-3.096916)/3.096916*3.68609,
3092                             fitTotal->GetParameter(8)*paramSPsiP, // /3.096916*3.68609,
3093                             fitTotal->GetParameter(9),
3094                             fitTotal->GetParameter(10),
3095                             fitTotal->GetParameter(11),
3096                             fitTotal->GetParameter(12));
3097
3098   for ( Int_t i = 0; i < 7; ++i )
3099   {
3100     bck->SetParameter(i, fitTotal->GetParameter(i));
3101   }
3102
3103   Set("alJPsi",fitTotal->GetParameter(9),fitTotal->GetParError(9));
3104   Set("nlJPsi",fitTotal->GetParameter(10),fitTotal->GetParError(10));
3105   Set("auJPsi",fitTotal->GetParameter(11),fitTotal->GetParError(11));
3106   Set("nuJPsi",fitTotal->GetParameter(12),fitTotal->GetParError(12));
3107
3108 //  Set("kPol4Exp",fitTotal->GetParameter(0),fitTotal->GetParError(0));
3109   Set("pol0",fitTotal->GetParameter(0),fitTotal->GetParError(0));
3110   Set("pol1",fitTotal->GetParameter(1),fitTotal->GetParError(1));
3111   Set("pol2",fitTotal->GetParameter(2),fitTotal->GetParError(2));
3112   Set("pol3",fitTotal->GetParameter(3),fitTotal->GetParError(3));
3113   Set("pol4",fitTotal->GetParameter(4),fitTotal->GetParError(4));
3114   Set("exp",fitTotal->GetParameter(5),fitTotal->GetParError(5));
3115
3116   Set("kJPsi",fitTotal->GetParameter(6),fitTotal->GetParError(6));
3117   Set("kPsiP",fitTotal->GetParameter(13),fitTotal->GetParError(13));
3118
3119
3120
3121   AttachFunctionsToHisto(signalJPsi,signalPsiP,bck,fitTotal,fitRangeLow,fitRangeHigh);
3122
3123   Double_t cbParameters[7];
3124   Double_t covarianceMatrix[7][7];
3125
3126   for ( int ix = 0; ix < 7; ++ix )
3127   {
3128     cbParameters[ix] = fitTotal->GetParameter(ix+6);
3129   }
3130
3131   for ( int iy = 0; iy < 7; ++iy )
3132   {
3133     for ( int ix = 0; ix < 7; ++ix )
3134     {
3135       covarianceMatrix[ix][iy] = (fitResult->GetCovarianceMatrix())(ix+6,iy+6);
3136     }
3137   }
3138
3139   Double_t a = fHisto->GetXaxis()->GetXmin();
3140   Double_t b = fHisto->GetXaxis()->GetXmax();
3141   double njpsi = signalJPsi->Integral(a,b)/fHisto->GetBinWidth(1);
3142   double nerr = signalJPsi->IntegralError(a,b,&cbParameters[0],&covarianceMatrix[0][0])/fHisto->GetBinWidth(1);
3143
3144   Set("NofJPsi",njpsi,nerr);
3145
3146   double m = GetValue("mJPsi");
3147   double s = GetValue("sJPsi");
3148   double njpsi3s = signalJPsi->Integral(m-3*s,m+3*s)/fHisto->GetBinWidth(1);
3149   double nerr3s = signalJPsi->IntegralError(m-3*s,m+3*s,&cbParameters[0],&covarianceMatrix[0][0])/fHisto->GetBinWidth(1);
3150
3151   Set("NofJPsi3s",njpsi3s,nerr3s);
3152
3153   //Computation of bin significance and signal over background
3154
3155   Double_t bkgParameters[6];
3156   Double_t bkgcovarianceMatrix[6][6];
3157
3158   for ( int ix = 0; ix < 6; ++ix )
3159   {
3160     bkgParameters[ix] = fitTotal->GetParameter(ix);
3161   }
3162
3163   for ( int iy = 0; iy < 6; ++iy )
3164   {
3165     for ( int ix = 0; ix < 6; ++ix )
3166     {
3167       bkgcovarianceMatrix[ix][iy] = (fitResult->GetCovarianceMatrix())(ix,iy);
3168     }
3169   }
3170
3171   double nbck3s = bck->Integral(m-3.*s,m+3.*s)/fHisto->GetBinWidth(1);
3172   double nbck3sErr = bck->IntegralError(m-3.*s,m+3.*s,&bkgParameters[0],&bkgcovarianceMatrix[0][0])/fHisto->GetBinWidth(1);
3173
3174   double sOverB3s = njpsi3s / nbck3s;
3175   double sOverB3sErr = sOverB3s*TMath::Sqrt(TMath::Power(nerr3s/njpsi3s,2.) + TMath::Power(nbck3sErr/nbck3s,2.));
3176
3177   Set("SignalOverBkg3s",sOverB3s,sOverB3sErr);
3178
3179   double sig = njpsi3s/TMath::Sqrt(njpsi3s + nbck3s);
3180   double sigErr = TMath::Sqrt( TMath::Power((1. - (1./2.)*njpsi3s/(njpsi3s + nbck3s) )*nerr3s/TMath::Sqrt(njpsi3s + nbck3s),2.) +
3181                               TMath::Power(njpsi3s*nbck3sErr/(2.*TMath::Power(njpsi3s + nbck3s,3./2.)),2.) );
3182
3183   Set("Significance3s",sig,sigErr);
3184
3185
3186 }
3187
3188 //_____________________________________________________________________________
3189 //void AliAnalysisMuMuJpsiResult::FitPSIPSIPRIMECB2POL4EXP()
3190 //{
3191 //  /// Fit using 2 extended crystal balls (signal) + pol4 x exp (background)
3192 //  /// 15 parameters
3193 //
3194 //  Double_t alphaLow = GetValue("alJPsi");
3195 //  Double_t nLow = GetValue("nlJPsi");
3196 //  Double_t alphaUp = GetValue("auJPsi");
3197 //  Double_t nUp = GetValue("nuJPsi");
3198 //  Double_t fitRangeLow = GetValue(kFitRangeLow);
3199 //  Double_t fitRangeHigh = GetValue(kFitRangeHigh);
3200 //
3201 //  TString msg;
3202 //
3203 //  if (IsValidValue(alphaLow)) msg += TString::Format("alphaLow=%e ",alphaLow);
3204 //  if (IsValidValue(nLow)) msg += TString::Format("nLow=%e ",nLow);
3205 //  if (IsValidValue(alphaUp)) msg += TString::Format("alphaUp=%e ",alphaUp);
3206 //  if (IsValidValue(nUp)) msg += TString::Format("nUp=%e ",nUp);
3207 //
3208 //  AliDebug(1,Form("Fit with jpsi + psiprime Pol4 x Exp %s",msg.Data()));
3209 //
3210 //  TF1* fitTotal = new TF1("signal+bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2Pol4Exp,fitRangeLow,fitRangeHigh,15,"AliAnalysisMuMuJpsiResult","FitFunctionTotalTwoCB2Pol4Exp");
3211 //
3212 //  fitTotal->SetParNames("kPol4Exp","pol0","pol1","pol2","pol3","pol4","exp","kJPsi",
3213 ////                          0         1      2      3     4       5     6      7
3214 //                        "mJPsi","sJPsi","alJPsi");
3215 //  //                      8       9         10
3216 //  fitTotal->SetParName(11,"nlJPsi");
3217 //  //                        11
3218 //  fitTotal->SetParName(12,"auJPsi");
3219 //  //                         12
3220 //  fitTotal->SetParName(13,"nuJPsi");
3221 //  //                         13
3222 //  fitTotal->SetParName(14,"kPsiP");
3223 //  //                        14
3224 //
3225 //  TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol4Exp,fitRangeLow,fitRangeHigh,7,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol4Exp");
3226 //
3227 ////    bck->SetParameters(fHisto->GetMaximum(),0.01,0.01,0.01,0.01,0.01,1.);
3228 ////
3229 ////  SetFitRejectRange(2.7,3.5);
3230 ////
3231 ////  fHisto->Fit(bck,"R");
3232 ////
3233 ////  SetFitRejectRange();
3234 ////
3235 ////  for ( Int_t i = 0; i < 7; ++i )
3236 ////  {
3237 ////    fitTotal->SetParameter(i, bck->GetParameter(i));
3238 ////  }
3239 //
3240 //  TF1* bckInit = new TF1("bckInit",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol4Exp,1.6,7.,6,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol4Exp");
3241 //
3242 //  Int_t bin = fHisto->FindBin(1.6);
3243 //
3244 //  bckInit->SetParameters(fHisto->GetBinContent(bin),-fHisto->GetBinContent(bin)/2.,fHisto->GetBinContent(bin)/2.,-fHisto->GetBinContent(bin)/20,fHisto->GetBinContent(bin/100.),-2.);
3245 //
3246 //  SetFitRejectRange(2.6,4.0);
3247 //
3248 //  TFitResultPtr fitResultInit = fHisto->Fit(bckInit,"SR");
3249 //
3250 //  std::cout << "FitResultBkgInit=" << static_cast<int>(fitResultInit) << std::endl;
3251 //
3252 //  if ( static_cast<int>(fitResultInit) )
3253 //  {
3254 //    bin = fHisto->FindBin(0.82);
3255 //    bckInit->SetParameters(0.,1.,1.,1.,2.,0.5);
3256 //    fitResultInit = fHisto->Fit(bckInit,"SR");
3257 //  }
3258 //
3259 //  SetFitRejectRange();
3260 //
3261 //  for ( Int_t i = 0; i < 6; ++i )
3262 //  {
3263 //    fitTotal->SetParameter(i, bckInit->GetParameter(i));
3264 //  }
3265 //
3266 //
3267 //  TF1* bckInit = new TF1("bckInit",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol4Exp,1.2,6.,7,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol4Exp");
3268 //
3269 //  Int_t bin = fHisto->FindBin(1.2);
3270 //
3271 //  bckInit->SetParameters(-1.,fHisto->GetBinContent(bin),-fHisto->GetBinContent(bin),fHisto->GetBinContent(bin)/10,-fHisto->GetBinContent(bin/10),10.,1.);
3272 //
3273 //  SetFitRejectRange(2.7,4.0);
3274 //
3275 //  TFitResultPtr fitResultInit = fHisto->Fit(bckInit,"SR");
3276 //
3277 //  std::cout << "FitResultBkgInit=" << static_cast<int>(fitResultInit) << std::endl;
3278 //
3279 //  if ( static_cast<int>(fitResultInit) )
3280 //  {
3281 //    bin = fHisto->FindBin(0.82);
3282 //    bckInit->SetParameters(0.,1.,1.,1.,2.,0.5,0.3);
3283 //    fitResultInit = fHisto->Fit(bckInit,"SR");
3284 //  }
3285 //
3286 //  SetFitRejectRange();
3287 //
3288 //  for ( Int_t i = 0; i < 7; ++i )
3289 //  {
3290 //    fitTotal->SetParameter(i, bckInit->GetParameter(i));
3291 //  }
3292 //
3293 //  delete bckInit;
3294 //
3295 //
3296 ////  bck->SetRange(fitRangeLow,fitRangeHigh);
3297 //
3298 //  bin = fHisto->FindBin(3.09);
3299 //  fitTotal->SetParameter(7, fHisto->GetBinContent(bin)); // norm(kJPsi)
3300 //
3301 //  fitTotal->SetParameter(8, 3.1); // mean
3302 //  fitTotal->SetParLimits(8, 3.0, 3.2);
3303 //
3304 //  fitTotal->SetParameter(9, 0.08); // sigma
3305 //  fitTotal->SetParLimits(9, 0.03, 0.15);
3306 //
3307 //  if ( IsValidValue(alphaLow) )
3308 //  {
3309 //    fitTotal->FixParameter(10, alphaLow);
3310 //  }
3311 //  else
3312 //  {
3313 //    fitTotal->SetParameter(10,0.9);
3314 //    fitTotal->SetParLimits(10,0.1,10.0);
3315 //  }
3316 //
3317 //  if ( IsValidValue(nLow) )
3318 //  {
3319 //    fitTotal->FixParameter(11, nLow);
3320 //  }
3321 //  else
3322 //  {
3323 //    fitTotal->SetParameter(11,5.0);
3324 //    fitTotal->SetParLimits(11,0.0,10.0);
3325 //  }
3326 //
3327 //  if ( IsValidValue(alphaUp) )
3328 //  {
3329 //    fitTotal->FixParameter(12, alphaUp);
3330 //  }
3331 //  else
3332 //  {
3333 //    fitTotal->SetParameter(12, 2.0);
3334 //    fitTotal->SetParLimits(12,0.1,10.0);
3335 //  }
3336 //
3337 //  if ( IsValidValue(nUp) )
3338 //  {
3339 //    fitTotal->FixParameter(13, nUp);
3340 //  }
3341 //  else
3342 //  {
3343 //    fitTotal->SetParameter(13,3.0);
3344 //    fitTotal->SetParLimits(13,0.0,10.0);
3345 //  }
3346 //
3347 //  bin = fHisto->FindBin(3.68);
3348 //  fitTotal->SetParameter(14, fHisto->GetBinContent(bin)); //kPsiP
3349 //  fitTotal->SetParLimits(14, 0., fHisto->GetBinContent(bin)*2); //kPsiP
3350 //
3351 //  //  fitTotal->SetParameter(12, 3.7); // mean PsiP
3352 //  //  fitTotal->SetParLimits(12, 3.6, 3.71);
3353 //  //
3354 //  //  fitTotal->SetParameter(13, 0.08/3.096916*3.68609); // sigma PsiP
3355 //  //  fitTotal->SetParLimits(13, 0.03/3.096916*3.68609, 0.15/3.096916*3.68609);
3356 //
3357 //  const char* fitOption = "SER";
3358 //
3359 //  TFitResultPtr fitResult = fHisto->Fit(fitTotal,fitOption,"");
3360 //
3361 //  std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
3362 //   std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
3363 //
3364 //  if ( static_cast<int>(fitResult) )
3365 //  {
3366 //    if ( fitTotal->GetParameter(14) <= fitTotal->GetParError(14) ) //kPsi'
3367 //    {
3368 //      std::cout << "//-------Refitting again (setting Psi'norm= Psi'norm/2)" << std::endl;
3369 //
3370 //      fitTotal->SetParameter(14, fHisto->GetBinContent(bin)/2.);
3371 //    }
3372 //
3373 //    if ( fitTotal->GetParameter(0) <= fitTotal->GetParError(0) ) //kPol4Exp
3374 //    {
3375 //      std::cout << "//-------Refitting again (setting kPol4Exp norm= kPol4Exp norm /2)" << std::endl;
3376 //      bin = fHisto->FindBin(fitRangeLow);
3377 //
3378 //      fitTotal->SetParameter(0, fHisto->GetBinContent(bin)/2.);
3379 //    }
3380 //
3381 //    fitResult = fHisto->Fit(fitTotal,fitOption,"");
3382 //    std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
3383 //  }
3384 //
3385 //  if ( fitResult->CovMatrixStatus() != 3 )
3386 //  {
3387 //    std::cout << "//-------Refitting again (setting Bkg norm= Bkg norm/2)" << std::endl;
3388 //    fitTotal->SetParameter(0, fHisto->GetMaximum()/2.); // kVWG
3389 //    fitResult = fHisto->Fit(fitTotal,fitOption,"");
3390 //  }
3391 //
3392 //  if ( fitResult->CovMatrixStatus() != 3 )
3393 //  {
3394 //    bin = fHisto->FindBin(3.68);
3395 //    std::cout << "//-------Refitting again (setting Psi'norm= Psi'norm/2)" << std::endl;
3396 //    fitTotal->SetParameter(14, fHisto->GetBinContent(bin)/2.); // kVWG
3397 //    fitResult = fHisto->Fit(fitTotal,fitOption,"");
3398 //
3399 //    std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
3400 //  }
3401 //
3402 ////  if ( fitResult->CovMatrixStatus() != 3 )
3403 ////  {
3404 ////    std::cout << "//-------Refitting again (refitting Bkg)" << std::endl;
3405 ////    if( fitTotal->GetParameter(9) >= 0.09 || fitTotal->GetParameter(9) <= 0.06 )
3406 ////    {
3407 ////      bck->SetParameters(0.01,fHisto->GetMaximum(),0.01,0.01,0.01,0.01,1.);
3408 //////      for ( Int_t i = 0; i < 7; ++i )
3409 //////      {
3410 //////        bck->SetParameter(i, 0.);
3411 //////      }
3412 ////    }
3413 ////    else
3414 ////    {
3415 ////      for ( Int_t i = 0; i < 7; ++i )
3416 ////      {
3417 ////        bck->SetParameter(i, fitTotal->GetParameter(i));
3418 ////      }
3419 ////    }
3420 ////
3421 ////    SetFitRejectRange(2.7,3.5);
3422 ////
3423 ////    fHisto->Fit(bck,"R");
3424 ////
3425 ////    SetFitRejectRange();
3426 ////
3427 ////    for ( Int_t i = 0; i < 7; ++i )
3428 ////    {
3429 ////      fitTotal->SetParameter(i, bck->GetParameter(i));
3430 ////    }
3431 ////
3432 ////    fitResult = fHisto->Fit(fitTotal,fitOption,"");
3433 ////  }
3434 ////  std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
3435 //
3436 //
3437 //
3438 //  Set("FitChi2PerNDF",fitTotal->GetChisquare()/fitTotal->GetNDF(),0.0);
3439 //  Set("FitNDF",fitTotal->GetNDF(),0.0);
3440 //
3441 //  Set("mJPsi",fitTotal->GetParameter(8),fitTotal->GetParError(8));
3442 //  Set("sJPsi",fitTotal->GetParameter(9),fitTotal->GetParError(9));
3443 //
3444 //  TF1* signalJPsi = new TF1("signalJPsi",this,&AliAnalysisMuMuJpsiResult::FitFunctionSignalCrystalBallExtended,fHisto->GetXaxis()->GetXmin(),fHisto->GetXaxis()->GetXmax(),7,"AliAnalysisMuMuJpsiResult","FitFunctionSignalCrystalBallExtended");
3445 //  signalJPsi->SetParameters(fitTotal->GetParameter(7),
3446 //                            fitTotal->GetParameter(8),
3447 //                            fitTotal->GetParameter(9),
3448 //                            fitTotal->GetParameter(10),
3449 //                            fitTotal->GetParameter(11),
3450 //                            fitTotal->GetParameter(12),
3451 //                            fitTotal->GetParameter(13));
3452 //
3453 //  TF1* signalPsiP = new TF1("signalPsiP",this,&AliAnalysisMuMuJpsiResult::FitFunctionSignalCrystalBallExtended,fHisto->GetXaxis()->GetXmin(),fHisto->GetXaxis()->GetXmax(),7,"AliAnalysisMuMuJpsiResult","FitFunctionSignalCrystalBallExtended");
3454 //  signalPsiP->SetParameters(fitTotal->GetParameter(14),
3455 //                            3.68609+(fitTotal->GetParameter(8)-3.096916)/3.096916*3.68609,
3456 //                            fitTotal->GetParameter(9)/3.096916*3.68609,
3457 //                            fitTotal->GetParameter(10),
3458 //                            fitTotal->GetParameter(11),
3459 //                            fitTotal->GetParameter(12),
3460 //                            fitTotal->GetParameter(13));
3461 //
3462 //  for ( Int_t i = 0; i < 7; ++i )
3463 //  {
3464 //    bck->SetParameter(i, fitTotal->GetParameter(i));
3465 //  }
3466 //
3467 //  Set("alJPsi",fitTotal->GetParameter(10),fitTotal->GetParError(10));
3468 //  Set("nlJPsi",fitTotal->GetParameter(11),fitTotal->GetParError(11));
3469 //  Set("auJPsi",fitTotal->GetParameter(12),fitTotal->GetParError(12));
3470 //  Set("nuJPsi",fitTotal->GetParameter(13),fitTotal->GetParError(13));
3471 //
3472 //  Set("kPol4Exp",fitTotal->GetParameter(0),fitTotal->GetParError(0));
3473 //  Set("pol0",fitTotal->GetParameter(1),fitTotal->GetParError(1));
3474 //  Set("pol1",fitTotal->GetParameter(2),fitTotal->GetParError(2));
3475 //  Set("pol2",fitTotal->GetParameter(3),fitTotal->GetParError(3));
3476 //  Set("pol3",fitTotal->GetParameter(4),fitTotal->GetParError(4));
3477 //  Set("pol4",fitTotal->GetParameter(5),fitTotal->GetParError(5));
3478 //  Set("exp",fitTotal->GetParameter(6),fitTotal->GetParError(6));
3479 //
3480 //  Set("kJPsi",fitTotal->GetParameter(7),fitTotal->GetParError(7));
3481 //  Set("kPsiP",fitTotal->GetParameter(14),fitTotal->GetParError(14));
3482 //
3483 //
3484 //
3485 //  AttachFunctionsToHisto(signalJPsi,signalPsiP,bck,fitTotal,fitRangeLow,fitRangeHigh);
3486 //
3487 //  Double_t cbParameters[7];
3488 //  Double_t covarianceMatrix[7][7];
3489 //
3490 //  for ( int ix = 0; ix < 7; ++ix )
3491 //  {
3492 //    cbParameters[ix] = fitTotal->GetParameter(ix+7);
3493 //  }
3494 //
3495 //  for ( int iy = 0; iy < 7; ++iy )
3496 //  {
3497 //    for ( int ix = 0; ix < 7; ++ix )
3498 //    {
3499 //      covarianceMatrix[ix][iy] = (fitResult->GetCovarianceMatrix())(ix+7,iy+7);
3500 //    }
3501 //  }
3502 //
3503 //  Double_t a = fHisto->GetXaxis()->GetXmin();
3504 //  Double_t b = fHisto->GetXaxis()->GetXmax();
3505 //  double njpsi = signalJPsi->Integral(a,b)/fHisto->GetBinWidth(1);
3506 //  double nerr = signalJPsi->IntegralError(a,b,&cbParameters[0],&covarianceMatrix[0][0])/fHisto->GetBinWidth(1);
3507 //
3508 //  Set("NofJPsi",njpsi,nerr);
3509 //
3510 //}
3511
3512 //_____________________________________________________________________________
3513 void AliAnalysisMuMuJpsiResult::FitPSIPSIPRIMENA60NEWVWG()
3514 {
3515   /// Fit using 2 NA60(new) (signal) + variable width gaussian (background)
3516
3517   fHisto->GetListOfFunctions()->Delete();
3518
3519   Double_t p1Left = GetValue("p1LJPsi");
3520   Double_t p2Left = GetValue("p2LJPsi");
3521   Double_t p3Left = GetValue("p3LJPsi");
3522   Double_t p1Right = GetValue("p1RJPsi");
3523   Double_t p2Right = GetValue("p2RJPsi");
3524   Double_t p3Right = GetValue("p3RJPsi");
3525
3526   Double_t alphaLeft = GetValue("aLJPsi");
3527   Double_t alphaRight = GetValue("aRJPsi");
3528
3529   Double_t paramSPsiP = GetValue("FSigmaPsiP");
3530
3531   Double_t fitRangeLow = GetValue(kFitRangeLow);
3532   Double_t fitRangeHigh = GetValue(kFitRangeHigh);
3533
3534   TString msg;
3535
3536   if (IsValidValue(p1Left)) msg += TString::Format("p1L=%e ",p1Left);
3537   if (IsValidValue(p2Left)) msg += TString::Format("p2L=%e ",p2Left);
3538   if (IsValidValue(p3Left)) msg += TString::Format("p3L=%e ",p3Left);
3539   if (IsValidValue(p1Right)) msg += TString::Format("p1R=%e ",p1Right);
3540   if (IsValidValue(p2Right)) msg += TString::Format("p2R=%e ",p2Right);
3541   if (IsValidValue(p3Right)) msg += TString::Format("p3R=%e ",p3Right);
3542
3543   if (IsValidValue(alphaLeft)) msg += TString::Format("aL=%e ",alphaLeft);
3544   if (IsValidValue(alphaRight)) msg += TString::Format("aR=%e ",alphaRight);
3545
3546   AliDebug(1,Form("Fit with jpsi + psiprime NA60 new and VWG %s",msg.Data()));
3547
3548   TF1* fitTotal = new TF1("signal+bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoNA60NewVWG,fitRangeLow,fitRangeHigh,16,"AliAnalysisMuMuJpsiResult","FitFunctionTotalTwoNA60NewVWG");
3549
3550   fitTotal->SetParNames("kVWG","mVWG","sVWG1","sVWG2","kJPsi","mJPsi","sJPsi",
3551   //                       0      1      2       3       4       5       6
3552                         "p1LJPsi","p2LJPsi","p3LJPsi","p1RJPsi");
3553   //                        7         8         9        10
3554   fitTotal->SetParName(11, "p2RJPsi");
3555   //                           11
3556   fitTotal->SetParName(12, "p3RJPsi");
3557   //                           12
3558   fitTotal->SetParName(13, "aLJPsi");
3559   //                           13
3560   fitTotal->SetParName(14, "aRJPsi");
3561   //                           14
3562   fitTotal->SetParName(15, "kPsiP");
3563   //                           15
3564
3565
3566   TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundVWG,fitRangeLow,fitRangeHigh,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundVWG");
3567
3568
3569   TF1* bckInit = new TF1("bckInit",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundVWG,1.7,6.,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundVWG");
3570
3571   Int_t bin = fHisto->FindBin(0.26);
3572
3573   bckInit->SetParameters(fHisto->GetBinContent(bin),2.,0.5,0.3);
3574
3575   SetFitRejectRange(2.7,4.0);
3576
3577   TFitResultPtr fitResultInit = fHisto->Fit(bckInit,"SR");
3578
3579   std::cout << "FitResultBkgInit=" << static_cast<int>(fitResultInit) << std::endl;
3580
3581   if ( static_cast<int>(fitResultInit) )
3582   {
3583     bin = fHisto->FindBin(0.82);
3584     bckInit->SetParameters(fHisto->GetBinContent(bin),2.,0.5,0.3);
3585     fitResultInit = fHisto->Fit(bckInit,"SR");
3586   }
3587   else if ( bckInit->GetParameter(0) < 0 )
3588   {
3589     bckInit->SetParameters(fHisto->GetBinContent(bin),2.,0.5,0.3);
3590   }
3591
3592   SetFitRejectRange();
3593
3594   for ( Int_t i = 0; i < 4; ++i )
3595   {
3596     TString name(GetName());
3597     if (name.Contains("NA60NEWVWG_2.2_4.7_SP1.0"))
3598     {
3599       fitTotal->SetParameter(i, bckInit->GetParameter(i)*0.8);
3600     }
3601     else fitTotal->SetParameter(i, bckInit->GetParameter(i));
3602   }
3603
3604   delete bckInit;
3605
3606
3607
3608 //  fitTotal->SetParameter(0, fHisto->GetMaximum()); // kVWG
3609 //  fitTotal->SetParameter(1, 1.9); // mVWG
3610 //
3611 //  fitTotal->SetParameter(2, 0.5); // sVWG1
3612 //  fitTotal->SetParLimits(2, 0., 100.);
3613 //
3614 //  fitTotal->SetParameter(3, 0.3); // sVWG2
3615 //  fitTotal->SetParLimits(3, 0., 100.);
3616 //
3617 //  Int_t bin = fHisto->FindBin(3.09);
3618 //  fitTotal->SetParameter(4, fHisto->GetBinContent(bin)); // norm
3619
3620   fitTotal->SetParameter(5, 3.1); // mean
3621   fitTotal->SetParLimits(5, 3.0, 3.2);
3622
3623   fitTotal->SetParameter(6, 0.08); // sigma
3624   fitTotal->SetParLimits(6, 0.05, 0.15);
3625
3626   fitTotal->FixParameter(7, p1Left);
3627   fitTotal->FixParameter(8, p2Left);
3628   fitTotal->FixParameter(9, p3Left);
3629   fitTotal->FixParameter(10, p1Right);
3630   fitTotal->FixParameter(11, p2Right);
3631   fitTotal->FixParameter(12, p3Right);
3632
3633   fitTotal->FixParameter(13, alphaLeft);
3634   fitTotal->FixParameter(14, alphaRight);
3635
3636   bin = fHisto->FindBin(3.68);
3637   fitTotal->SetParameter(15, fHisto->GetBinContent(bin)); //kPsiP
3638   fitTotal->SetParLimits(15, 0., fHisto->GetBinContent(bin)*2); //kPsiP
3639
3640   const char* fitOption = "SER";
3641
3642   TFitResultPtr fitResult = fHisto->Fit(fitTotal,fitOption,"");
3643
3644   std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
3645    std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
3646
3647   // Check parameters...
3648   //  if (
3649   //      StrongCorrelation(fitResult,fitTotal,3,4,2) ||
3650   //      StrongCorrelation(fitResult,fitTotal,5,6,2) ||
3651   //      WrongParameter(fitTotal,3,1) ||
3652   //      WrongParameter(fitTotal,4,0)  ||
3653   //      WrongParameter(fitTotal,5,1)  ||
3654   //      WrongParameter(fitTotal,6,0)
3655   //      )
3656   //  {
3657   //    // try again...
3658   //    fitResult = fHisto->Fit(fitTotal,"SER","");
3659   //  }
3660
3661   if ( static_cast<int>(fitResult) )
3662   {
3663     if ( 0.5*fitTotal->GetParameter(15) <= fitTotal->GetParError(15) ) //kPsi'
3664     {
3665       std::cout << "//-------Refitting again (setting Psi'norm= Psi'norm/2)" << std::endl;
3666
3667       fitTotal->SetParameter(15, fHisto->GetBinContent(bin)/2.);
3668     }
3669
3670     if ( 0.5*fitTotal->GetParameter(0) <= fitTotal->GetParError(0) ) //kVWG
3671     {
3672       std::cout << "//-------Refitting again (setting kVWG norm= kVWG norm /2)" << std::endl;
3673       bin = fHisto->FindBin(fitRangeLow);
3674
3675       fitTotal->SetParameter(0, fHisto->GetBinContent(bin)/2.);
3676     }
3677
3678     fitResult = fHisto->Fit(fitTotal,fitOption,"");
3679     std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
3680   }
3681
3682   if ( static_cast<int>(fitResult) )
3683   {
3684     std::cout << "//-------Refitting again (setting kVWG=kVWG*2)" << std::endl;
3685
3686     fitTotal->SetParameter(0, fHisto->GetMaximum()*2.); // kVWG
3687
3688     fitResult = fHisto->Fit(fitTotal,fitOption,"");
3689     std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
3690   }
3691
3692   if ( static_cast<int>(fitResult) )
3693   {
3694     std::cout << "//-------Refitting again (setting kVWG=kVWG/2)" << std::endl;
3695
3696     fitTotal->SetParameter(0, fHisto->GetMaximum()/2.); // kVWG
3697
3698     fitResult = fHisto->Fit(fitTotal,fitOption,"");
3699     std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
3700   }
3701
3702 //  if ( fitResult->CovMatrixStatus() != 3 )
3703 //  {
3704 //    std::cout << "//-------Refitting again (setting Bkg norm= Bkg norm/2)" << std::endl;
3705 //    fitTotal->SetParameter(0, fHisto->GetMaximum()/2.); // kVWG
3706 //    fitResult = fHisto->Fit(fitTotal,fitOption,"");
3707 //  }
3708 //
3709 //  if ( fitResult->CovMatrixStatus() != 3 )
3710 //  {
3711 //    bin = fHisto->FindBin(3.68);
3712 //    std::cout << "//-------Refitting again (setting Psi'norm= Psi'norm/2)" << std::endl;
3713 //    fitTotal->SetParameter(15, fHisto->GetBinContent(bin)/2.); // kVWG
3714 //    fitResult = fHisto->Fit(fitTotal,fitOption,"");
3715 //
3716 //    std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
3717 //  }
3718 //
3719 //  if ( fitResult->CovMatrixStatus() != 3 )
3720 //  {
3721 //    std::cout << "//-------Refitting again (refitting Bkg)" << std::endl;
3722 //
3723 //    for ( Int_t i = 0; i < 4; ++i )
3724 //    {
3725 //      bck->SetParameter(i, fitTotal->GetParameter(i));
3726 //    }
3727 //
3728 //    SetFitRejectRange(2.7,3.5);
3729 //
3730 //    fHisto->Fit(bck,"R");
3731 //
3732 //    SetFitRejectRange();
3733 //
3734 //    for ( Int_t i = 0; i < 4; ++i )
3735 //    {
3736 //      fitTotal->SetParameter(i, bck->GetParameter(i));
3737 //    }
3738 //
3739 //    fitResult = fHisto->Fit(fitTotal,fitOption,"");
3740 //  }
3741 //  std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
3742 //  std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
3743 //  if ( static_cast<int>(fitResult) )
3744 //  {
3745 //    fitTotal->SetParameter(0, fHisto->GetMaximum()); // kVWG
3746 //    fitTotal->SetParameter(1, 1.9); // mVWG
3747 //
3748 //    fitTotal->SetParameter(2, 0.5); // sVWG1
3749 //    fitTotal->SetParLimits(2, 0., 100.);
3750 //
3751 //    fitTotal->SetParameter(3, 0.3); // sVWG2
3752 //    fitTotal->SetParLimits(3, 0., 100.);
3753 //
3754 //    fitResult = fHisto->Fit(fitTotal,fitOption,"");
3755 //
3756 //    std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
3757 //    std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
3758 //
3759 //    if ( static_cast<int>(fitResult) )
3760 //    {
3761 //      if ( fitTotal->GetParameter(15) <= fitTotal->GetParError(15) ) //kPsi'
3762 //      {
3763 //        std::cout << "//-------Refitting again (setting Psi'norm= Psi'norm/2)" << std::endl;
3764 //
3765 //        fitTotal->SetParameter(15, fHisto->GetBinContent(bin)/2.);
3766 //      }
3767 //
3768 //      if ( fitTotal->GetParameter(0) <= fitTotal->GetParError(0) ) //kVWG
3769 //      {
3770 //        std::cout << "//-------Refitting again (setting kVWG norm= kVWG norm /2)" << std::endl;
3771 //        bin = fHisto->FindBin(fitRangeLow);
3772 //
3773 //        fitTotal->SetParameter(0, fHisto->GetBinContent(bin)/2.);
3774 //      }
3775 //
3776 //      fitResult = fHisto->Fit(fitTotal,fitOption,"");
3777 //      std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
3778 //    }
3779 //
3780 //  }
3781
3782   TF1* signalJPsi = new TF1("signalJPsi",this,&AliAnalysisMuMuJpsiResult::FitFunctionNA60New,fHisto->GetXaxis()->GetXmin(),fHisto->GetXaxis()->GetXmax(),11,"AliAnalysisMuMuJpsiResult","FitFunctionNA60New");
3783
3784   signalJPsi->SetParameters(fitTotal->GetParameter(4),
3785                             fitTotal->GetParameter(5),
3786                             fitTotal->GetParameter(6),
3787                             fitTotal->GetParameter(7),
3788                             fitTotal->GetParameter(8),
3789                             fitTotal->GetParameter(9),
3790                             fitTotal->GetParameter(10),
3791                             fitTotal->GetParameter(11),
3792                             fitTotal->GetParameter(12),
3793                             fitTotal->GetParameter(13));
3794
3795   signalJPsi->SetParameter(10,fitTotal->GetParameter(14));
3796
3797   TF1* signalPsiP = new TF1("signalPsiP",this,&AliAnalysisMuMuJpsiResult::FitFunctionNA60New,fHisto->GetXaxis()->GetXmin(),fHisto->GetXaxis()->GetXmax(),11,"AliAnalysisMuMuJpsiResult","FitFunctionNA60New");
3798
3799   signalPsiP->SetParameters(fitTotal->GetParameter(15),
3800                             3.68609+(fitTotal->GetParameter(5)-3.096916)/3.096916*3.68609,
3801                             fitTotal->GetParameter(6)*paramSPsiP, // /3.096916*3.68609,
3802                             fitTotal->GetParameter(7),
3803                             fitTotal->GetParameter(8),
3804                             fitTotal->GetParameter(9),
3805                             fitTotal->GetParameter(10),
3806                             fitTotal->GetParameter(11),
3807                             fitTotal->GetParameter(12),
3808                             fitTotal->GetParameter(13));
3809
3810   signalPsiP->SetParameter(10,fitTotal->GetParameter(14));
3811
3812   bck->SetParameter(0,fitTotal->GetParameter(0));
3813   bck->SetParameter(1,fitTotal->GetParameter(1));
3814   bck->SetParameter(2,fitTotal->GetParameter(2));
3815   bck->SetParameter(3,fitTotal->GetParameter(3));
3816
3817   Set("FitResult",static_cast<int>(fitResult)*1.0,0.0);
3818   Set("FitChi2PerNDF",fitTotal->GetChisquare()/fitTotal->GetNDF(),0.0);
3819   Set("FitNDF",fitTotal->GetNDF(),0.0);
3820
3821   Set("kVWG",fitTotal->GetParameter(0),fitTotal->GetParError(0));
3822   Set("mVWG",fitTotal->GetParameter(1),fitTotal->GetParError(1));
3823   Set("sVWG1",fitTotal->GetParameter(2),fitTotal->GetParError(2));
3824   Set("sVWG2",fitTotal->GetParameter(3),fitTotal->GetParError(3));
3825
3826   Set("kJPsi",fitTotal->GetParameter(4),fitTotal->GetParError(4));
3827   Set("kPsiP",fitTotal->GetParameter(15),fitTotal->GetParError(15));
3828
3829   Set("mJPsi",fitTotal->GetParameter(5),fitTotal->GetParError(5));
3830   Set("sJPsi",fitTotal->GetParameter(6),fitTotal->GetParError(6));
3831
3832   Set("p1LJPsi",fitTotal->GetParameter(7),fitTotal->GetParError(7));
3833   Set("p2LJPsi",fitTotal->GetParameter(8),fitTotal->GetParError(8));
3834   Set("p3LJPsi",fitTotal->GetParameter(9),fitTotal->GetParError(9));
3835   Set("p1RJPsi",fitTotal->GetParameter(10),fitTotal->GetParError(10));
3836   Set("p2RJPsi",fitTotal->GetParameter(11),fitTotal->GetParError(11));
3837   Set("p3RJPsi",fitTotal->GetParameter(12),fitTotal->GetParError(12));
3838
3839   Set("aLJPsi",fitTotal->GetParameter(13),fitTotal->GetParError(13));
3840   Set("aRJPsi",fitTotal->GetParameter(14),fitTotal->GetParError(14));
3841
3842   AttachFunctionsToHisto(signalJPsi,signalPsiP,bck,fitTotal,fitRangeLow,fitRangeHigh);
3843
3844   Double_t na60Parameters[11];
3845   Double_t covarianceMatrix[11][11];
3846
3847   for ( int ix = 0; ix < 11; ++ix )
3848   {
3849     na60Parameters[ix] = fitTotal->GetParameter(ix+4);
3850   }
3851
3852   for ( int iy = 0; iy < 11; ++iy )
3853   {
3854     for ( int ix = 0; ix < 11; ++ix )
3855     {
3856       covarianceMatrix[ix][iy] = (fitResult->GetCovarianceMatrix())(ix+4,iy+4);
3857     }
3858   }
3859
3860
3861   Double_t a = fHisto->GetXaxis()->GetXmin();
3862   Double_t b = fHisto->GetXaxis()->GetXmax();
3863   double njpsi = signalJPsi->Integral(a,b)/fHisto->GetBinWidth(1);
3864   double nerr = signalJPsi->IntegralError(a,b,&na60Parameters[0],&covarianceMatrix[0][0])/fHisto->GetBinWidth(1);
3865
3866   Set("NofJPsi",njpsi,nerr);
3867
3868   double m = GetValue("mJPsi");
3869   double s = GetValue("sJPsi");
3870   double njpsi3s = signalJPsi->Integral(m-3*s,m+3*s)/fHisto->GetBinWidth(1);
3871   double nerr3s = signalJPsi->IntegralError(m-3*s,m+3*s,&na60Parameters[0],&covarianceMatrix[0][0])/fHisto->GetBinWidth(1);
3872
3873   Set("NofJPsi3s",njpsi3s,nerr3s);
3874
3875   //Computation of bin significance and signal over background
3876
3877   Double_t bkgParameters[4];
3878   Double_t bkgcovarianceMatrix[4][4];
3879
3880   for ( int ix = 0; ix < 4; ++ix )
3881   {
3882     bkgParameters[ix] = fitTotal->GetParameter(ix);
3883   }
3884
3885   for ( int iy = 0; iy < 4; ++iy )
3886   {
3887     for ( int ix = 0; ix < 4; ++ix )
3888     {
3889       bkgcovarianceMatrix[ix][iy] = (fitResult->GetCovarianceMatrix())(ix,iy);
3890     }
3891   }
3892
3893   double nbck3s = bck->Integral(m-3.*s,m+3.*s)/fHisto->GetBinWidth(1);
3894   double nbck3sErr = bck->IntegralError(m-3.*s,m+3.*s,&bkgParameters[0],&bkgcovarianceMatrix[0][0])/fHisto->GetBinWidth(1);
3895
3896   double sOverB3s = njpsi3s / nbck3s;
3897   double sOverB3sErr = sOverB3s*TMath::Sqrt(TMath::Power(nerr3s/njpsi3s,2.) + TMath::Power(nbck3sErr/nbck3s,2.));
3898
3899   Set("SignalOverBkg3s",sOverB3s,sOverB3sErr);
3900
3901   double sig = njpsi3s/TMath::Sqrt(njpsi3s + nbck3s);
3902   double sigErr = TMath::Sqrt( TMath::Power((1. - (1./2.)*njpsi3s/(njpsi3s + nbck3s) )*nerr3s/TMath::Sqrt(njpsi3s + nbck3s),2.) +
3903                               TMath::Power(njpsi3s*nbck3sErr/(2.*TMath::Power(njpsi3s + nbck3s,3./2.)),2.) );
3904
3905   Set("Significance3s",sig,sigErr);
3906
3907 }
3908
3909 //_____________________________________________________________________________
3910 void AliAnalysisMuMuJpsiResult::FitPSIPSIPRIMENA60NEWPOL2EXP()
3911 {
3912   /// Fit using 2 NA60(new) (signal) + pol2 x exp (background)
3913
3914   fHisto->GetListOfFunctions()->Delete();
3915
3916   Double_t p1Left = GetValue("p1LJPsi");
3917   Double_t p2Left = GetValue("p2LJPsi");
3918   Double_t p3Left = GetValue("p3LJPsi");
3919   Double_t p1Right = GetValue("p1RJPsi");
3920   Double_t p2Right = GetValue("p2RJPsi");
3921   Double_t p3Right = GetValue("p3RJPsi");
3922
3923   Double_t alphaLeft = GetValue("aLJPsi");
3924   Double_t alphaRight = GetValue("aRJPsi");
3925
3926   Double_t paramSPsiP = GetValue("FSigmaPsiP");
3927
3928   Double_t fitRangeLow = GetValue(kFitRangeLow);
3929   Double_t fitRangeHigh = GetValue(kFitRangeHigh);
3930
3931   TString msg;
3932
3933   if (IsValidValue(p1Left)) msg += TString::Format("p1L=%e ",p1Left);
3934   if (IsValidValue(p2Left)) msg += TString::Format("p2L=%e ",p2Left);
3935   if (IsValidValue(p3Left)) msg += TString::Format("p3L=%e ",p3Left);
3936   if (IsValidValue(p1Right)) msg += TString::Format("p1R=%e ",p1Right);
3937   if (IsValidValue(p2Right)) msg += TString::Format("p2R=%e ",p2Right);
3938   if (IsValidValue(p3Right)) msg += TString::Format("p3R=%e ",p3Right);
3939
3940   if (IsValidValue(alphaLeft)) msg += TString::Format("aL=%e ",alphaLeft);
3941   if (IsValidValue(alphaRight)) msg += TString::Format("aR=%e ",alphaRight);
3942
3943   AliDebug(1,Form("Fit with jpsi + psiprime NA60 new and pol4 x exp %s",msg.Data()));
3944
3945   TF1* fitTotal = new TF1("signal+bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoNA60NewPol2Exp,fitRangeLow,fitRangeHigh,16,"AliAnalysisMuMuJpsiResult","FitFunctionTotalTwoNA60NewPol2Exp");
3946
3947   fitTotal->SetParNames("pol0","pol1","pol2","exp","kJPsi","mJPsi","sJPsi",
3948   //                      0      1       2      3     4      5       6
3949                         "p1LJPsi","p2LJPsi","p3LJPsi","p1RJPsi");
3950   //                        7         8         9        10
3951
3952   fitTotal->SetParName(11, "p2RJPsi");
3953   //                           11
3954   fitTotal->SetParName(12, "p3RJPsi");
3955   //                           12
3956   fitTotal->SetParName(13, "aLJPsi");
3957   //                           13
3958   fitTotal->SetParName(14, "aRJPsi");
3959   //                           14
3960   fitTotal->SetParName(15, "kPsiP");
3961   //                           15
3962
3963
3964   TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2Exp,fitRangeLow,fitRangeHigh,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2Exp");
3965
3966   //___
3967   TF1* bckInit = new TF1("bckInit",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2Exp,1.7,6.,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2Exp");
3968
3969   Int_t bin = fHisto->FindBin(0.26);
3970
3971   bckInit->SetParameters(fHisto->GetBinContent(bin),-fHisto->GetBinContent(bin)/3.,100.,0.05);//fHisto->GetBinContent(bin)
3972
3973   SetFitRejectRange(2.7,4.0);
3974
3975   TFitResultPtr fitResultInit = fHisto->Fit(bckInit,"SR");
3976
3977   std::cout << "FitResultBkgInit=" << static_cast<int>(fitResultInit) << std::endl;
3978
3979   if ( static_cast<int>(fitResultInit) )
3980   {
3981     bin = fHisto->FindBin(0.82);
3982     bckInit->SetParameters(fHisto->GetBinContent(bin),2.,0.5,0.3);
3983     fitResultInit = fHisto->Fit(bckInit,"SR");
3984   }
3985
3986   SetFitRejectRange();
3987
3988   for ( Int_t i = 0; i < 4; ++i )
3989   {
3990     fitTotal->SetParameter(i, bckInit->GetParameter(i));
3991   }
3992
3993   delete bckInit;
3994   //__
3995
3996
3997 //  bck->SetParameters(fHisto->GetMaximum(),0.,0.,0.,1.);
3998 //
3999 //  SetFitRejectRange(2.7,3.5);
4000 //
4001 //  fHisto->Fit(bck,"R");
4002 //
4003 //  SetFitRejectRange();
4004 //
4005 //  for ( Int_t i = 0; i < 5; ++i )
4006 //  {
4007 //    fitTotal->SetParameter(i, bck->GetParameter(i));
4008 //  }
4009
4010
4011   bin = fHisto->FindBin(3.09);
4012   fitTotal->SetParameter(4, fHisto->GetBinContent(bin)); // kJPsi
4013
4014   fitTotal->SetParameter(5, 3.1); // mean
4015   fitTotal->SetParLimits(5, 3.0, 3.2);
4016
4017   fitTotal->SetParameter(6, 0.08); // sigma
4018   fitTotal->SetParLimits(6, 0.05, 0.15);
4019
4020   fitTotal->FixParameter(7, p1Left);
4021   fitTotal->FixParameter(8, p2Left);
4022   fitTotal->FixParameter(9, p3Left);
4023   fitTotal->FixParameter(10, p1Right);
4024   fitTotal->FixParameter(11, p2Right);
4025   fitTotal->FixParameter(12, p3Right);
4026
4027   fitTotal->FixParameter(13, alphaLeft);
4028   fitTotal->FixParameter(14, alphaRight);
4029
4030   bin = fHisto->FindBin(3.68);
4031   fitTotal->SetParameter(15, fHisto->GetBinContent(bin)); //kPsiP
4032   fitTotal->SetParLimits(15, 0., fHisto->GetBinContent(bin)*2); //kPsiP
4033
4034   const char* fitOption = "SER";
4035
4036   TFitResultPtr fitResult = fHisto->Fit(fitTotal,fitOption,"");
4037
4038   std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
4039    std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
4040
4041   // Check parameters...
4042   //  if (
4043   //      StrongCorrelation(fitResult,fitTotal,3,4,2) ||
4044   //      StrongCorrelation(fitResult,fitTotal,5,6,2) ||
4045   //      WrongParameter(fitTotal,3,1) ||
4046   //      WrongParameter(fitTotal,4,0)  ||
4047   //      WrongParameter(fitTotal,5,1)  ||
4048   //      WrongParameter(fitTotal,6,0)
4049   //      )
4050   //  {
4051   //    // try again...
4052   //    fitResult = fHisto->Fit(fitTotal,"SER","");
4053   //  }
4054
4055   if ( static_cast<int>(fitResult) )
4056   {
4057     if ( 0.5*fitTotal->GetParameter(15) <= fitTotal->GetParError(15) ) //kPsi'
4058     {
4059       std::cout << "//-------Refitting again (setting Psi'norm= Psi'norm/2)" << std::endl;
4060       bin = fHisto->FindBin(3.68);
4061       fitTotal->SetParameter(15, fHisto->GetBinContent(bin)/2.);
4062     }
4063
4064     if ( 0.5*fitTotal->GetParameter(0) <= fitTotal->GetParError(0) ) //kPol2Exp
4065     {
4066       std::cout << "//-------Refitting again (setting kPol2Exp norm= kPol2Exp norm /2)" << std::endl;
4067       bin = fHisto->FindBin(fitRangeLow);
4068
4069       fitTotal->SetParameter(0, fHisto->GetBinContent(bin)/2.);
4070     }
4071
4072     fitResult = fHisto->Fit(fitTotal,fitOption,"");
4073     std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
4074   }
4075
4076   if ( fitResult->CovMatrixStatus() != 3 )
4077   {
4078     if ( 0.5*fitTotal->GetParameter(15) <= fitTotal->GetParError(15) ) //kPsi'
4079     {
4080       std::cout << "//-------Refitting again (setting Psi'norm= Psi'norm/2)" << std::endl;
4081
4082       bin = fHisto->FindBin(3.68);
4083       fitTotal->FixParameter(15, 0.);
4084     }
4085
4086     else
4087     {
4088       std::cout << "//-------Refitting again (setting Psi'norm= Psi'norm/2)" << std::endl;
4089
4090       fHisto->FindBin(3.68);
4091       fitTotal->SetParameter(15, fHisto->GetBinContent(bin)/2.);
4092     }
4093
4094     fitResult = fHisto->Fit(fitTotal,fitOption,"");
4095
4096     std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
4097   }
4098
4099
4100 //  if ( fitResult->CovMatrixStatus() != 3 )
4101 //  {
4102 //    std::cout << "//-------Refitting again (setting Bkg norm= Bkg norm/2)" << std::endl;
4103 //    fitTotal->SetParameter(0, fHisto->GetMaximum()/2.); // kVWG
4104 //    fitResult = fHisto->Fit(fitTotal,fitOption,"");
4105 //  }
4106 //
4107 //  if ( fitResult->CovMatrixStatus() != 3 )
4108 //  {
4109 //    bin = fHisto->FindBin(3.68);
4110 //    std::cout << "//-------Refitting again (setting Psi'norm= Psi'norm/2)" << std::endl;
4111 //    fitTotal->SetParameter(16, fHisto->GetBinContent(bin)/2.); // kVWG
4112 //    fitResult = fHisto->Fit(fitTotal,fitOption,"");
4113 //
4114 //    std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
4115 //  }
4116 //
4117 //  if ( fitResult->CovMatrixStatus() != 3 )
4118 //  {
4119 //    std::cout << "//-------Refitting again (refitting Bkg)" << std::endl;
4120 //
4121 //    for ( Int_t i = 0; i < 5; ++i )
4122 //    {
4123 //      bck->SetParameter(i, fitTotal->GetParameter(i));
4124 //    }
4125 //
4126 //    SetFitRejectRange(2.7,3.5);
4127 //
4128 //    fHisto->Fit(bck,"R");
4129 //
4130 //    SetFitRejectRange();
4131 //
4132 //    for ( Int_t i = 0; i < 5; ++i )
4133 //    {
4134 //      fitTotal->SetParameter(i, bck->GetParameter(i));
4135 //    }
4136 //
4137 //    fitResult = fHisto->Fit(fitTotal,fitOption,"");
4138 //  }
4139 //  std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
4140
4141
4142
4143   TF1* signalJPsi = new TF1("signalJPsi",this,&AliAnalysisMuMuJpsiResult::FitFunctionNA60New,fHisto->GetXaxis()->GetXmin(),fHisto->GetXaxis()->GetXmax(),11,"AliAnalysisMuMuJpsiResult","SignalNA60New");
4144
4145   signalJPsi->SetParameters(fitTotal->GetParameter(4),
4146                             fitTotal->GetParameter(5),
4147                             fitTotal->GetParameter(6),
4148                             fitTotal->GetParameter(7),
4149                             fitTotal->GetParameter(8),
4150                             fitTotal->GetParameter(9),
4151                             fitTotal->GetParameter(10),
4152                             fitTotal->GetParameter(11),
4153                             fitTotal->GetParameter(12),
4154                             fitTotal->GetParameter(13));
4155
4156   signalJPsi->SetParameter(10,fitTotal->GetParameter(14));
4157
4158   TF1* signalPsiP = new TF1("signalPsiP",this,&AliAnalysisMuMuJpsiResult::FitFunctionNA60New,fHisto->GetXaxis()->GetXmin(),fHisto->GetXaxis()->GetXmax(),11,"AliAnalysisMuMuJpsiResult","SignalNA60New");
4159
4160   signalPsiP->SetParameters(fitTotal->GetParameter(15),
4161                             3.68609+(fitTotal->GetParameter(5)-3.096916)/3.096916*3.68609,
4162                             fitTotal->GetParameter(6)*paramSPsiP, // /3.096916*3.68609,
4163                             fitTotal->GetParameter(7),
4164                             fitTotal->GetParameter(8),
4165                             fitTotal->GetParameter(9),
4166                             fitTotal->GetParameter(10),
4167                             fitTotal->GetParameter(11),
4168                             fitTotal->GetParameter(12),
4169                             fitTotal->GetParameter(13));
4170
4171   signalPsiP->SetParameter(10,fitTotal->GetParameter(14));
4172
4173   for ( Int_t i = 0; i < 4; ++i )
4174   {
4175     bck->SetParameter(i, fitTotal->GetParameter(i));
4176   }
4177
4178
4179   Set("FitResult",static_cast<int>(fitResult)*1.0,0.0);
4180   Set("FitChi2PerNDF",fitTotal->GetChisquare()/fitTotal->GetNDF(),0.0);
4181   Set("FitNDF",fitTotal->GetNDF(),0.0);
4182
4183 //  Set("kPol2Exp",fitTotal->GetParameter(0),fitTotal->GetParError(0));
4184   Set("pol0",fitTotal->GetParameter(0),fitTotal->GetParError(0));
4185   Set("pol1",fitTotal->GetParameter(1),fitTotal->GetParError(1));
4186   Set("pol2",fitTotal->GetParameter(2),fitTotal->GetParError(2));
4187   Set("exp",fitTotal->GetParameter(3),fitTotal->GetParError(3));
4188
4189   Set("kJPsi",fitTotal->GetParameter(4),fitTotal->GetParError(4));
4190   Set("kPsiP",fitTotal->GetParameter(15),fitTotal->GetParError(15));
4191
4192   Set("mJPsi",fitTotal->GetParameter(5),fitTotal->GetParError(5));
4193   Set("sJPsi",fitTotal->GetParameter(6),fitTotal->GetParError(6));
4194
4195   Set("p1LJPsi",fitTotal->GetParameter(7),fitTotal->GetParError(7));
4196   Set("p2LJPsi",fitTotal->GetParameter(8),fitTotal->GetParError(8));
4197   Set("p3LJPsi",fitTotal->GetParameter(9),fitTotal->GetParError(9));
4198   Set("p1RJPsi",fitTotal->GetParameter(10),fitTotal->GetParError(10));
4199   Set("p2RJPsi",fitTotal->GetParameter(11),fitTotal->GetParError(11));
4200   Set("p3RJPsi",fitTotal->GetParameter(12),fitTotal->GetParError(12));
4201
4202   Set("aLJPsi",fitTotal->GetParameter(13),fitTotal->GetParError(13));
4203   Set("aRJPsi",fitTotal->GetParameter(14),fitTotal->GetParError(14));
4204
4205   AttachFunctionsToHisto(signalJPsi,signalPsiP,bck,fitTotal,fitRangeLow,fitRangeHigh);
4206
4207   Double_t na60Parameters[11];
4208   Double_t covarianceMatrix[11][11];
4209
4210   for ( int ix = 0; ix < 11; ++ix )
4211   {
4212     na60Parameters[ix] = fitTotal->GetParameter(ix+4);
4213   }
4214
4215   for ( int iy = 0; iy < 11; ++iy )
4216   {
4217     for ( int ix = 0; ix < 11; ++ix )
4218     {
4219       covarianceMatrix[ix][iy] = (fitResult->GetCovarianceMatrix())(ix+4,iy+4);
4220     }
4221   }
4222
4223   Double_t a = fHisto->GetXaxis()->GetXmin();
4224   Double_t b = fHisto->GetXaxis()->GetXmax();
4225   double njpsi = signalJPsi->Integral(a,b)/fHisto->GetBinWidth(1);
4226   double nerr = signalJPsi->IntegralError(a,b,&na60Parameters[0],&covarianceMatrix[0][0])/fHisto->GetBinWidth(1);
4227
4228   Set("NofJPsi",njpsi,nerr);
4229
4230   double m = GetValue("mJPsi");
4231   double s = GetValue("sJPsi");
4232   double njpsi3s = signalJPsi->Integral(m-3*s,m+3*s)/fHisto->GetBinWidth(1);
4233   double nerr3s = signalJPsi->IntegralError(m-3*s,m+3*s,&na60Parameters[0],&covarianceMatrix[0][0])/fHisto->GetBinWidth(1);
4234
4235   Set("NofJPsi3s",njpsi3s,nerr3s);
4236
4237   //Computation of bin significance and signal over background
4238
4239   Double_t bkgParameters[4];
4240   Double_t bkgcovarianceMatrix[4][4];
4241
4242   for ( int ix = 0; ix < 4; ++ix )
4243   {
4244     bkgParameters[ix] = fitTotal->GetParameter(ix);
4245   }
4246
4247   for ( int iy = 0; iy < 4; ++iy )
4248   {
4249     for ( int ix = 0; ix < 4; ++ix )
4250     {
4251       bkgcovarianceMatrix[ix][iy] = (fitResult->GetCovarianceMatrix())(ix,iy);
4252     }
4253   }
4254
4255   double nbck3s = bck->Integral(m-3.*s,m+3.*s)/fHisto->GetBinWidth(1);
4256   double nbck3sErr = bck->IntegralError(m-3.*s,m+3.*s,&bkgParameters[0],&bkgcovarianceMatrix[0][0])/fHisto->GetBinWidth(1);
4257
4258   double sOverB3s = njpsi3s / nbck3s;
4259   double sOverB3sErr = sOverB3s*TMath::Sqrt(TMath::Power(nerr3s/njpsi3s,2.) + TMath::Power(nbck3sErr/nbck3s,2.));
4260
4261   Set("SignalOverBkg3s",sOverB3s,sOverB3sErr);
4262
4263   double sig = njpsi3s/TMath::Sqrt(njpsi3s + nbck3s);
4264   double sigErr = TMath::Sqrt( TMath::Power((1. - (1./2.)*njpsi3s/(njpsi3s + nbck3s) )*nerr3s/TMath::Sqrt(njpsi3s + nbck3s),2.) +
4265                               TMath::Power(njpsi3s*nbck3sErr/(2.*TMath::Power(njpsi3s + nbck3s,3./2.)),2.) );
4266
4267   Set("Significance3s",sig,sigErr);
4268
4269 }
4270
4271 //_____________________________________________________________________________
4272 void AliAnalysisMuMuJpsiResult::FitPSIPSIPRIMENA60NEWPOL4EXP()
4273 {
4274   /// Fit using 2 NA60(new) (signal) + pol4 x exp (background)
4275
4276   fHisto->GetListOfFunctions()->Delete();
4277
4278   Double_t p1Left = GetValue("p1LJPsi");
4279   Double_t p2Left = GetValue("p2LJPsi");
4280   Double_t p3Left = GetValue("p3LJPsi");
4281   Double_t p1Right = GetValue("p1RJPsi");
4282   Double_t p2Right = GetValue("p2RJPsi");
4283   Double_t p3Right = GetValue("p3RJPsi");
4284
4285   Double_t alphaLeft = GetValue("aLJPsi");
4286   Double_t alphaRight = GetValue("aRJPsi");
4287
4288   Double_t paramSPsiP = GetValue("FSigmaPsiP");
4289
4290   Double_t fitRangeLow = GetValue(kFitRangeLow);
4291   Double_t fitRangeHigh = GetValue(kFitRangeHigh);
4292
4293   TString msg;
4294
4295   if (IsValidValue(p1Left)) msg += TString::Format("p1L=%e ",p1Left);
4296   if (IsValidValue(p2Left)) msg += TString::Format("p2L=%e ",p2Left);
4297   if (IsValidValue(p3Left)) msg += TString::Format("p3L=%e ",p3Left);
4298   if (IsValidValue(p1Right)) msg += TString::Format("p1R=%e ",p1Right);
4299   if (IsValidValue(p2Right)) msg += TString::Format("p2R=%e ",p2Right);
4300   if (IsValidValue(p3Right)) msg += TString::Format("p3R=%e ",p3Right);
4301
4302   if (IsValidValue(alphaLeft)) msg += TString::Format("aL=%e ",alphaLeft);
4303   if (IsValidValue(alphaRight)) msg += TString::Format("aR=%e ",alphaRight);
4304
4305   AliDebug(1,Form("Fit with jpsi + psiprime NA60 new and pol4 x exp %s",msg.Data()));
4306
4307   TF1* fitTotal = new TF1("signal+bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoNA60NewPol4Exp,fitRangeLow,fitRangeHigh,18,"AliAnalysisMuMuJpsiResult","FitFunctionTotalTwoNA60NewPol4Exp");
4308
4309   fitTotal->SetParNames("pol0","pol1","pol2","pol3","pol4","exp","kJPsi",
4310   //                        0    1       2      3      4     5      6
4311                         "mJPsi","sJPsi","p1LJPsi","p2LJPsi");
4312   //                       7       8       9       10
4313
4314   fitTotal->SetParName(11, "p3LJPsi");
4315   //                           11
4316   fitTotal->SetParName(12, "p1RJPsi");
4317   //                           12
4318   fitTotal->SetParName(13, "p2RJPsi");
4319   //                           13
4320   fitTotal->SetParName(14, "p3RJPsi");
4321   //                           14
4322   fitTotal->SetParName(15, "aLJPsi");
4323   //                           15
4324   fitTotal->SetParName(16, "aRJPsi");
4325   //                           16
4326   fitTotal->SetParName(17, "kPsiP");
4327   //                           17
4328
4329
4330   TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol4Exp,fitRangeLow,fitRangeHigh,6,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol4Exp");
4331
4332   //___
4333   TF1* bckInit = new TF1("bckInit",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol4Exp,1.6,7.,6,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol4Exp");
4334
4335   Int_t bin = fHisto->FindBin(1.6);
4336
4337   bckInit->SetParameters(fHisto->GetBinContent(bin),-fHisto->GetBinContent(bin),fHisto->GetBinContent(bin)/2.,-fHisto->GetBinContent(bin)/10.,fHisto->GetBinContent(bin)/100.,-2.);
4338
4339   SetFitRejectRange(2.6,4.0);
4340
4341   TFitResultPtr fitResultInit = fHisto->Fit(bckInit,"SR");
4342
4343   std::cout << "FitResultBkgInit=" << static_cast<int>(fitResultInit) << std::endl;
4344
4345   if ( static_cast<int>(fitResultInit) )
4346   {
4347     bin = fHisto->FindBin(0.82);
4348     bckInit->SetParameters(0.,1.,1.,1.,2.,0.5);
4349     fitResultInit = fHisto->Fit(bckInit,"SR");
4350   }
4351
4352   SetFitRejectRange();
4353
4354   for ( Int_t i = 0; i < 6; ++i )
4355   {
4356     fitTotal->SetParameter(i, bckInit->GetParameter(i));
4357   }
4358
4359   delete bckInit;
4360   //___
4361
4362 //
4363 //  bck->SetParameters(fHisto->GetMaximum(),0.,0.,0.,0.,0.,1.);
4364 //
4365 //  SetFitRejectRange(2.7,3.5);
4366 //
4367 //  fHisto->Fit(bck,"R");
4368 //
4369 //  SetFitRejectRange();
4370 //
4371 //  for ( Int_t i = 0; i < 7; ++i )
4372 //  {
4373 //    fitTotal->SetParameter(i, bck->GetParameter(i));
4374 //  }
4375
4376
4377   bin = fHisto->FindBin(3.09);
4378   fitTotal->SetParameter(6, fHisto->GetBinContent(bin)); // kJPsi
4379
4380   fitTotal->SetParameter(7, 3.1); // mean
4381   fitTotal->SetParLimits(7, 3.0, 3.2);
4382
4383   fitTotal->SetParameter(8, 0.08); // sigma
4384   fitTotal->SetParLimits(8, 0.05, 0.15);
4385
4386   fitTotal->FixParameter(9, p1Left);
4387   fitTotal->FixParameter(10, p2Left);
4388   fitTotal->FixParameter(11, p3Left);
4389   fitTotal->FixParameter(12, p1Right);
4390   fitTotal->FixParameter(13, p2Right);
4391   fitTotal->FixParameter(14, p3Right);
4392
4393   fitTotal->FixParameter(15, alphaLeft);
4394   fitTotal->FixParameter(16, alphaRight);
4395
4396   bin = fHisto->FindBin(3.68);
4397   fitTotal->SetParameter(17, fHisto->GetBinContent(bin)); //kPsiP
4398   fitTotal->SetParLimits(17, 0., fHisto->GetBinContent(bin)*2); //kPsiP
4399
4400   const char* fitOption = "SER";
4401
4402   TFitResultPtr fitResult = fHisto->Fit(fitTotal,fitOption,"");
4403
4404   std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
4405    std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
4406
4407   // Check parameters...
4408   //  if (
4409   //      StrongCorrelation(fitResult,fitTotal,3,4,2) ||
4410   //      StrongCorrelation(fitResult,fitTotal,5,6,2) ||
4411   //      WrongParameter(fitTotal,3,1) ||
4412   //      WrongParameter(fitTotal,4,0)  ||
4413   //      WrongParameter(fitTotal,5,1)  ||
4414   //      WrongParameter(fitTotal,6,0)
4415   //      )
4416   //  {
4417   //    // try again...
4418   //    fitResult = fHisto->Fit(fitTotal,"SER","");
4419   //  }
4420
4421
4422   if ( static_cast<int>(fitResult) )
4423   {
4424     if ( 0.5*fitTotal->GetParameter(17) <= fitTotal->GetParError(17) ) //kPsi'
4425     {
4426       std::cout << "//-------Refitting again (setting Psi'norm= Psi'norm/2)" << std::endl;
4427
4428       fitTotal->SetParameter(17, fHisto->GetBinContent(bin)/2.);
4429     }
4430
4431     if ( 0.5*fitTotal->GetParameter(0) <= fitTotal->GetParError(0) ) //kPol4Exp
4432     {
4433       std::cout << "//-------Refitting again (setting kPol4Exp norm= kPol4Exp norm /2)" << std::endl;
4434       bin = fHisto->FindBin(fitRangeLow);
4435
4436       fitTotal->SetParameter(0, fHisto->GetBinContent(bin)/2.);
4437     }
4438
4439     fitResult = fHisto->Fit(fitTotal,fitOption,"");
4440     std::cout << "FitResult=" << static_cast<int>(fitResult) << std::endl;
4441   }
4442
4443   if ( fitResult->CovMatrixStatus() != 3 )
4444   {
4445     std::cout << "//-------Refitting again (setting Bkg norm= Bkg norm/2)" << std::endl;
4446     fitTotal->SetParameter(0, fHisto->GetMaximum()/2.); // kVWG
4447     fitResult = fHisto->Fit(fitTotal,fitOption,"");
4448   }
4449
4450 //  if ( fitResult->CovMatrixStatus() != 3 )
4451 //  {
4452 //    bin = fHisto->FindBin(3.68);
4453 //    std::cout << "//-------Refitting again (setting Psi'norm= Psi'norm/2)" << std::endl;
4454 //    fitTotal->SetParameter(18, fHisto->GetBinContent(bin)/2.); // kVWG
4455 //    fitResult = fHisto->Fit(fitTotal,fitOption,"");
4456 //
4457 //    std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
4458 //  }
4459 //
4460 //  if ( fitResult->CovMatrixStatus() != 3 )
4461 //  {
4462 //    std::cout << "//-------Refitting again (refitting Bkg)" << std::endl;
4463 //
4464 //    for ( Int_t i = 0; i < 7; ++i )
4465 //    {
4466 //      bck->SetParameter(i, fitTotal->GetParameter(i));
4467 //    }
4468 //
4469 //    SetFitRejectRange(2.7,3.5);
4470 //
4471 //    fHisto->Fit(bck,"R");
4472 //
4473 //    SetFitRejectRange();
4474 //
4475 //    for ( Int_t i = 0; i < 7; ++i )
4476 //    {
4477 //      fitTotal->SetParameter(i, bck->GetParameter(i));
4478 //    }
4479 //
4480 //    fitResult = fHisto->Fit(fitTotal,fitOption,"");
4481 //  }
4482 //  std::cout << "CovMatrixStatus=" << fitResult->CovMatrixStatus() << std::endl;
4483
4484
4485   TF1* signalJPsi = new TF1("signalJPsi",this,&AliAnalysisMuMuJpsiResult::FitFunctionNA60New,fHisto->GetXaxis()->GetXmin(),fHisto->GetXaxis()->GetXmax(),11,"AliAnalysisMuMuJpsiResult","SignalNA60New");
4486
4487   signalJPsi->SetParameters(fitTotal->GetParameter(6),
4488                             fitTotal->GetParameter(7),
4489                             fitTotal->GetParameter(8),
4490                             fitTotal->GetParameter(9),
4491                             fitTotal->GetParameter(10),
4492                             fitTotal->GetParameter(11),
4493                             fitTotal->GetParameter(12),
4494                             fitTotal->GetParameter(13),
4495                             fitTotal->GetParameter(14),
4496                             fitTotal->GetParameter(15));
4497
4498   signalJPsi->SetParameter(10,fitTotal->GetParameter(16));
4499
4500   TF1* signalPsiP = new TF1("signalPsiP",this,&AliAnalysisMuMuJpsiResult::FitFunctionNA60New,fHisto->GetXaxis()->GetXmin(),fHisto->GetXaxis()->GetXmax(),11,"AliAnalysisMuMuJpsiResult","SignalNA60New");
4501
4502   signalPsiP->SetParameters(fitTotal->GetParameter(17),
4503                             3.68609+(fitTotal->GetParameter(7)-3.096916)/3.096916*3.68609,
4504                             fitTotal->GetParameter(8)*paramSPsiP, // /3.096916*3.68609,
4505                             fitTotal->GetParameter(9),
4506                             fitTotal->GetParameter(10),
4507                             fitTotal->GetParameter(11),
4508                             fitTotal->GetParameter(12),
4509                             fitTotal->GetParameter(13),
4510                             fitTotal->GetParameter(14),
4511                             fitTotal->GetParameter(15));
4512
4513   signalPsiP->SetParameter(10,fitTotal->GetParameter(16));
4514
4515   for ( Int_t i = 0; i < 6; ++i )
4516   {
4517     bck->SetParameter(i, fitTotal->GetParameter(i));
4518   }
4519
4520
4521   Set("FitResult",static_cast<int>(fitResult)*1.0,0.0);
4522   Set("FitChi2PerNDF",fitTotal->GetChisquare()/fitTotal->GetNDF(),0.0);
4523   Set("FitNDF",fitTotal->GetNDF(),0.0);
4524
4525 //  Set("kPol4Exp",fitTotal->GetParameter(0),fitTotal->GetParError(0));
4526   Set("pol0",fitTotal->GetParameter(0),fitTotal->GetParError(0));
4527   Set("pol1",fitTotal->GetParameter(1),fitTotal->GetParError(1));
4528   Set("pol2",fitTotal->GetParameter(2),fitTotal->GetParError(2));
4529   Set("pol3",fitTotal->GetParameter(3),fitTotal->GetParError(3));
4530   Set("pol4",fitTotal->GetParameter(4),fitTotal->GetParError(4));
4531   Set("exp",fitTotal->GetParameter(5),fitTotal->GetParError(5));
4532
4533   Set("kJPsi",fitTotal->GetParameter(4),fitTotal->GetParError(4));
4534   Set("kPsiP",fitTotal->GetParameter(17),fitTotal->GetParError(17));
4535
4536   Set("mJPsi",fitTotal->GetParameter(7),fitTotal->GetParError(7));
4537   Set("sJPsi",fitTotal->GetParameter(8),fitTotal->GetParError(8));
4538
4539   Set("p1LJPsi",fitTotal->GetParameter(9),fitTotal->GetParError(9));
4540   Set("p2LJPsi",fitTotal->GetParameter(10),fitTotal->GetParError(10));
4541   Set("p3LJPsi",fitTotal->GetParameter(11),fitTotal->GetParError(11));
4542   Set("p1RJPsi",fitTotal->GetParameter(12),fitTotal->GetParError(12));
4543   Set("p2RJPsi",fitTotal->GetParameter(13),fitTotal->GetParError(13));
4544   Set("p3RJPsi",fitTotal->GetParameter(14),fitTotal->GetParError(14));
4545
4546   Set("aLJPsi",fitTotal->GetParameter(15),fitTotal->GetParError(15));
4547   Set("aRJPsi",fitTotal->GetParameter(16),fitTotal->GetParError(16));
4548
4549   AttachFunctionsToHisto(signalJPsi,signalPsiP,bck,fitTotal,fitRangeLow,fitRangeHigh);
4550
4551   Double_t na60Parameters[11];
4552   Double_t covarianceMatrix[11][11];
4553
4554   for ( int ix = 0; ix < 11; ++ix )
4555   {
4556     na60Parameters[ix] = fitTotal->GetParameter(ix+6);
4557   }
4558
4559   for ( int iy = 0; iy < 11; ++iy )
4560   {
4561     for ( int ix = 0; ix < 11; ++ix )
4562     {
4563       covarianceMatrix[ix][iy] = (fitResult->GetCovarianceMatrix())(ix+6,iy+6);
4564     }
4565   }
4566
4567   Double_t a = fHisto->GetXaxis()->GetXmin();
4568   Double_t b = fHisto->GetXaxis()->GetXmax();
4569   double njpsi = signalJPsi->Integral(a,b)/fHisto->GetBinWidth(1);
4570   double nerr = signalJPsi->IntegralError(a,b,&na60Parameters[0],&covarianceMatrix[0][0])/fHisto->GetBinWidth(1);
4571
4572   Set("NofJPsi",njpsi,nerr);
4573
4574   double m = GetValue("mJPsi");
4575   double s = GetValue("sJPsi");
4576   double njpsi3s = signalJPsi->Integral(m-3*s,m+3*s)/fHisto->GetBinWidth(1);
4577   double nerr3s = signalJPsi->IntegralError(m-3*s,m+3*s,&na60Parameters[0],&covarianceMatrix[0][0])/fHisto->GetBinWidth(1);
4578
4579   Set("NofJPsi3s",njpsi3s,nerr3s);
4580
4581   //Computation of bin significance and signal over background
4582
4583   Double_t bkgParameters[6];
4584   Double_t bkgcovarianceMatrix[6][6];
4585
4586   for ( int ix = 0; ix < 6; ++ix )
4587   {
4588     bkgParameters[ix] = fitTotal->GetParameter(ix);
4589   }
4590
4591   for ( int iy = 0; iy < 6; ++iy )
4592   {
4593     for ( int ix = 0; ix < 6; ++ix )
4594     {
4595       bkgcovarianceMatrix[ix][iy] = (fitResult->GetCovarianceMatrix())(ix,iy);
4596     }
4597   }
4598
4599   double nbck3s = bck->Integral(m-3.*s,m+3.*s)/fHisto->GetBinWidth(1);
4600   double nbck3sErr = bck->IntegralError(m-3.*s,m+3.*s,&bkgParameters[0],&bkgcovarianceMatrix[0][0])/fHisto->GetBinWidth(1);
4601
4602   double sOverB3s = njpsi3s / nbck3s;
4603   double sOverB3sErr = sOverB3s*TMath::Sqrt(TMath::Power(nerr3s/njpsi3s,2.) + TMath::Power(nbck3sErr/nbck3s,2.));
4604
4605   Set("SignalOverBkg3s",sOverB3s,sOverB3sErr);
4606
4607   double sig = njpsi3s/TMath::Sqrt(njpsi3s + nbck3s);
4608   double sigErr = TMath::Sqrt( TMath::Power((1. - (1./2.)*njpsi3s/(njpsi3s + nbck3s) )*nerr3s/TMath::Sqrt(njpsi3s + nbck3s),2.) +
4609                               TMath::Power(njpsi3s*nbck3sErr/(2.*TMath::Power(njpsi3s + nbck3s,3./2.)),2.) );
4610
4611   Set("Significance3s",sig,sigErr);
4612
4613 }
4614
4615 //_____________________________________________________________________________
4616 void AliAnalysisMuMuJpsiResult::FitMPTPSIPSIPRIMECB2VWG_BKGMPTPOL2()
4617 {
4618   //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
4619   fHisto->GetListOfFunctions()->Delete();
4620
4621   Double_t alphaLow = GetValue("alJPsi");
4622   Double_t nLow = GetValue("nlJPsi");
4623   Double_t alphaUp = GetValue("auJPsi");
4624   Double_t nUp = GetValue("nuJPsi");
4625
4626   Double_t kVWG = GetValue("kVWG");
4627   Double_t mVWG = GetValue("mVWG");
4628   Double_t sVWG1 = GetValue("sVWG1");
4629   Double_t sVWG2 = GetValue("sVWG2");
4630   Double_t kJPsi = GetValue("kJPsi");
4631   Double_t kPsiP = GetValue("kPsiP");
4632   Double_t mJPsi = GetValue("mJPsi");
4633   Double_t sJPsi = GetValue("sJPsi");
4634   Double_t NofJPsi = GetValue("NofJPsi");
4635   Double_t ErrStatNofJPsi = GetErrorStat("NofJPsi");
4636
4637   Double_t fitRangeLow = GetValue(kFitRangeLow);
4638   Double_t fitRangeHigh = GetValue(kFitRangeHigh);
4639
4640 //  TString msg;
4641 //
4642 //  if (IsValidValue(alphaLow)) msg += TString::Format("alphaLow=%e ",alphaLow);
4643 //  if (IsValidValue(nLow)) msg += TString::Format("nLow=%e ",nLow);
4644 //  if (IsValidValue(alphaUp)) msg += TString::Format("alphaUp=%e ",alphaUp);
4645 //  if (IsValidValue(nUp)) msg += TString::Format("nUp=%e ",nUp);
4646 //
4647 //  AliDebug(1,Form("Mean pt fit with jpsi + psiprime (CB2),Bkg VWG and Pol2 for Bkg <pt> %s",msg.Data()));
4648 //
4649 //  TF1* fitTotal = new TF1("signal+bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2VWG,fitRangeLow,fitRangeHigh,17,"AliAnalysisMuMuJpsiResult","FitFunctionTotalTwoCB2VWG");
4650 //
4651 //TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
4652
4653
4654 //  TString resultName(Form("MEANPTFIT_%salphalow=%5.2fnlow=%5.2falphaup=%5.2fnup=%5.2f",fitName.Data(),par[7],par[8],par[9],par[10]));
4655   TProfile* p(0x0);
4656   if ( fHisto->IsA() == TProfile::Class() ) p = static_cast<TProfile*>(fHisto);
4657   else
4658   {
4659     AliError("Mean pt histo has to be a TProfile");
4660     return;
4661   }
4662
4663   //_____________
4664   Int_t minBin = p->FindBin(fitRangeLow);
4665   Int_t maxBin = p->FindBin(fitRangeHigh);
4666
4667   for ( Int_t i = minBin ; i <= maxBin ; i++ )
4668   {
4669     if ( p->GetBinEffectiveEntries(i) < 10 )
4670     {
4671       Double_t effEntries(0.),sumErr(0.);
4672       for ( Int_t j = i - 5 ; j < i ; j++ )
4673       {
4674         if ( j <= 0 ) continue;
4675 //        if ( j > p->GetNbinsX() ) break;
4676
4677         effEntries += p->GetBinEffectiveEntries(j);
4678         sumErr += p->GetBinEffectiveEntries(j)*p->GetBinError(j);
4679       }
4680
4681       Double_t meanErr = sumErr/effEntries;
4682
4683       if ( p->GetBinError(i) < meanErr/2. )
4684       {
4685         std::cout << "Resetting bin " << i << " error" <<std::endl;
4686         p->SetBinError(i,meanErr);
4687       }
4688     }
4689   }
4690   //_____________
4691
4692   TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
4693
4694   bck->SetParameters(3.,1.,0.);
4695
4696   bck->SetParLimits(0, 1.,8.0);
4697 //  TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2Exp,fitRangeLow,fitRangeHigh,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2Exp");
4698 //
4699 //  bck->SetParameters(1,0,0,0);
4700
4701   SetFitRejectRange(2.3,4.0);
4702
4703   p->Fit(bck,"SER","",fitRangeLow,fitRangeHigh);
4704
4705   SetFitRejectRange();
4706
4707
4708
4709   TF1* fitMeanpt = new TF1("fitMeanpt",this,&AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2CB2VWGPOL2,fitRangeLow,fitRangeHigh,17,"AliAnalysisMuMuJpsiResult","FitFunctionMeanPtS2CB2VWGPOL2");
4710
4711   fitMeanpt->SetParNames("kVWG","mVWG","sVWG1","sVWG2","kJPsi","mJPsi","sJPsi","alJPsi","nlJPsi","auJPsi","nuJPsi");
4712   fitMeanpt->SetParName(11,"kPsiP");
4713   fitMeanpt->SetParName(12,"<pt>JPsi");
4714   fitMeanpt->SetParName(13,"<pt>BG0");
4715   fitMeanpt->SetParName(14,"<pt>BG1");
4716   fitMeanpt->SetParName(15,"<pt>BG2");
4717   fitMeanpt->SetParName(16,"<pt>PsiP");
4718
4719   fitMeanpt->FixParameter(0,kVWG);
4720   fitMeanpt->FixParameter(1,mVWG);
4721   fitMeanpt->FixParameter(2,sVWG1);
4722   fitMeanpt->FixParameter(3,sVWG2);
4723   fitMeanpt->FixParameter(4,kJPsi);
4724   fitMeanpt->FixParameter(5,mJPsi);
4725   fitMeanpt->FixParameter(6,sJPsi);
4726   fitMeanpt->FixParameter(7,alphaLow);
4727   fitMeanpt->FixParameter(8,nLow);
4728   fitMeanpt->FixParameter(9,alphaUp);
4729   fitMeanpt->FixParameter(10,nUp);
4730   fitMeanpt->FixParameter(11,kPsiP);
4731
4732   fitMeanpt->SetParameter(12, 3.);
4733   fitMeanpt->SetParLimits(12, 1.0,5.);
4734
4735   for ( Int_t i = 0; i < 3; ++i )
4736   {
4737     fitMeanpt->SetParameter(i + 13, bck->GetParameter(i));
4738   }
4739
4740 //  fitMeanpt->SetParameter(13, 3.);
4741 //  fitMeanpt->SetParLimits(13, 0.5,10.);
4742 //
4743 //  fitMeanpt->SetParameter(14, 0.2);
4744 //  //  fitMeanpt->SetParLimits(14, 0.1,0.2);
4745 //
4746 //  fitMeanpt->SetParameter(15, 0.1);
4747 //  //  fitMeanpt->SetParLimits(15, 0.,1.);
4748
4749   fitMeanpt->SetParameter(16, 3.);
4750   Double_t psipPtLim = 10.;
4751   fitMeanpt->SetParLimits(16, 0.,psipPtLim);
4752
4753
4754 //  TProfile::Approximate();
4755
4756   const char* fitOption = "SER"; //+";//SER
4757
4758   TFitResultPtr fitResult = p->Fit(fitMeanpt,fitOption,"");
4759
4760   std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
4761
4762   if ( static_cast<int>(fitResult) )
4763   {
4764     for ( Int_t i = 0; i < 3; ++i )
4765     {
4766       fitMeanpt->SetParameter(i + 13, bck->GetParameter(i)*0.9);
4767     }
4768     fitResult = p->Fit(fitMeanpt,fitOption,"");
4769
4770     std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
4771   }
4772   else if ( fitMeanpt->GetParameter(16) <= fitMeanpt->GetParError(16) || fitMeanpt->GetParError(16) >= 0.75*fitMeanpt->GetParameter(16) || (fitMeanpt->GetParameter(16)/psipPtLim > 0.9) )
4773   {
4774     fitMeanpt->FixParameter(16, bck->Eval(3.68));
4775     for ( Int_t i = 0; i < 3; ++i )
4776     {
4777       fitMeanpt->SetParameter(i + 13, bck->GetParameter(i)*0.6);
4778     }
4779     fitResult = p->Fit(fitMeanpt,fitOption,"");
4780
4781     std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
4782   }
4783
4784
4785 //  TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
4786
4787   bck->SetParameters(fitMeanpt->GetParameter(13),fitMeanpt->GetParameter(14),fitMeanpt->GetParameter(15));
4788
4789   AttachFunctionsToHisto(0x0,bck,fitMeanpt,fitRangeLow,fitRangeHigh);//
4790
4791   Set("NofJPsi",NofJPsi,ErrStatNofJPsi);
4792   Set("MeanPtJPsi",fitMeanpt->GetParameter(12),fitMeanpt->GetParError(12));
4793   Set("MeanPtPsiP",fitMeanpt->GetParameter(16),fitMeanpt->GetParError(16));
4794
4795 }
4796
4797 //_____________________________________________________________________________
4798 void AliAnalysisMuMuJpsiResult::FitMPTPSIPSIPRIMECB2VWG_BKGMPTPOL2EXP()
4799 {
4800   //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
4801   fHisto->GetListOfFunctions()->Delete();
4802
4803   Double_t alphaLow = GetValue("alJPsi");
4804   Double_t nLow = GetValue("nlJPsi");
4805   Double_t alphaUp = GetValue("auJPsi");
4806   Double_t nUp = GetValue("nuJPsi");
4807
4808   Double_t kVWG = GetValue("kVWG");
4809   Double_t mVWG = GetValue("mVWG");
4810   Double_t sVWG1 = GetValue("sVWG1");
4811   Double_t sVWG2 = GetValue("sVWG2");
4812   Double_t kJPsi = GetValue("kJPsi");
4813   Double_t kPsiP = GetValue("kPsiP");
4814   Double_t mJPsi = GetValue("mJPsi");
4815   Double_t sJPsi = GetValue("sJPsi");
4816   Double_t NofJPsi = GetValue("NofJPsi");
4817   Double_t ErrStatNofJPsi = GetErrorStat("NofJPsi");
4818
4819   Double_t fitRangeLow = GetValue(kFitRangeLow);
4820   Double_t fitRangeHigh = GetValue(kFitRangeHigh);
4821
4822   //  TString msg;
4823   //
4824   //  if (IsValidValue(alphaLow)) msg += TString::Format("alphaLow=%e ",alphaLow);
4825   //  if (IsValidValue(nLow)) msg += TString::Format("nLow=%e ",nLow);
4826   //  if (IsValidValue(alphaUp)) msg += TString::Format("alphaUp=%e ",alphaUp);
4827   //  if (IsValidValue(nUp)) msg += TString::Format("nUp=%e ",nUp);
4828   //
4829   //  AliDebug(1,Form("Mean pt fit with jpsi + psiprime (CB2),Bkg VWG and Pol2 for Bkg <pt> %s",msg.Data()));
4830   //
4831   //  TF1* fitTotal = new TF1("signal+bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2VWG,fitRangeLow,fitRangeHigh,17,"AliAnalysisMuMuJpsiResult","FitFunctionTotalTwoCB2VWG");
4832   //
4833   //TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
4834
4835
4836   //  TString resultName(Form("MEANPTFIT_%salphalow=%5.2fnlow=%5.2falphaup=%5.2fnup=%5.2f",fitName.Data(),par[7],par[8],par[9],par[10]));
4837   TProfile* p(0x0);
4838   if ( fHisto->IsA() == TProfile::Class() ) p = static_cast<TProfile*>(fHisto);
4839   else
4840   {
4841     AliError("Mean pt histo has to be a TProfile");
4842     return;
4843   }
4844
4845   //_____________
4846   Int_t minBin = p->FindBin(fitRangeLow);
4847   Int_t maxBin = p->FindBin(fitRangeHigh);
4848
4849   for ( Int_t i = minBin ; i <= maxBin ; i++ )
4850   {
4851     if ( p->GetBinEffectiveEntries(i) < 10 )
4852     {
4853       Double_t effEntries(0.),sumErr(0.);
4854       for ( Int_t j = i - 5 ; j < i ; j++ )
4855       {
4856         if ( j <= 0 ) continue;
4857         //        if ( j > p->GetNbinsX() ) break;
4858
4859         effEntries += p->GetBinEffectiveEntries(j);
4860         sumErr += p->GetBinEffectiveEntries(j)*p->GetBinError(j);
4861       }
4862
4863       Double_t meanErr = sumErr/effEntries;
4864
4865       if ( p->GetBinError(i) < meanErr/2. )
4866       {
4867         std::cout << "Resetting bin " << i << " error" <<std::endl;
4868         p->SetBinError(i,meanErr);
4869       }
4870     }
4871   }
4872   //_____________
4873
4874   TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2Exp,fitRangeLow,fitRangeHigh,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2Exp");
4875
4876   bck->SetParameters(3.,-2.,0.4,-0.0);
4877
4878   bck->SetParLimits(0, 1.,10.0);
4879   //  TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2Exp,fitRangeLow,fitRangeHigh,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2Exp");
4880   //
4881   //  bck->SetParameters(1,0,0,0);
4882
4883   SetFitRejectRange(2.3,4.0);
4884
4885   p->Fit(bck,"SER","",fitRangeLow,fitRangeHigh);
4886
4887   SetFitRejectRange();
4888
4889
4890
4891   TF1* fitMeanpt = new TF1("fitMeanpt",this,&AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2CB2VWGPOL2EXP,fitRangeLow,fitRangeHigh,18,"AliAnalysisMuMuJpsiResult","FitFunctionMeanPtS2CB2VWGPOL2EXP");
4892
4893   fitMeanpt->SetParNames("kVWG","mVWG","sVWG1","sVWG2","kJPsi","mJPsi","sJPsi","alJPsi","nlJPsi","auJPsi","nuJPsi");
4894   fitMeanpt->SetParName(11,"kPsiP");
4895   fitMeanpt->SetParName(12,"<pt>JPsi");
4896   fitMeanpt->SetParName(13,"<pt>BG0");
4897   fitMeanpt->SetParName(14,"<pt>BG1");
4898   fitMeanpt->SetParName(15,"<pt>BG2");
4899   fitMeanpt->SetParName(16,"<pt>BGEXP");
4900   fitMeanpt->SetParName(17,"<pt>PsiP");
4901
4902   fitMeanpt->FixParameter(0,kVWG);
4903   fitMeanpt->FixParameter(1,mVWG);
4904   fitMeanpt->FixParameter(2,sVWG1);
4905   fitMeanpt->FixParameter(3,sVWG2);
4906   fitMeanpt->FixParameter(4,kJPsi);
4907   fitMeanpt->FixParameter(5,mJPsi);
4908   fitMeanpt->FixParameter(6,sJPsi);
4909   fitMeanpt->FixParameter(7,alphaLow);
4910   fitMeanpt->FixParameter(8,nLow);
4911   fitMeanpt->FixParameter(9,alphaUp);
4912   fitMeanpt->FixParameter(10,nUp);
4913   fitMeanpt->FixParameter(11,kPsiP);
4914
4915   fitMeanpt->SetParameter(12, 3.);
4916   fitMeanpt->SetParLimits(12, 1.0,5.);
4917
4918   for ( Int_t i = 0; i < 4; ++i )
4919   {
4920     fitMeanpt->SetParameter(i + 13, bck->GetParameter(i));
4921   }
4922
4923   //  fitMeanpt->SetParameter(13, 3.);
4924   //  fitMeanpt->SetParLimits(13, 0.5,10.);
4925   //
4926   //  fitMeanpt->SetParameter(14, 0.2);
4927   //  //  fitMeanpt->SetParLimits(14, 0.1,0.2);
4928   //
4929   //  fitMeanpt->SetParameter(15, 0.1);
4930   //  //  fitMeanpt->SetParLimits(15, 0.,1.);
4931
4932   fitMeanpt->SetParameter(17, 3.);
4933   Double_t psipPtLim = 10.;
4934   fitMeanpt->SetParLimits(17, 0.,psipPtLim);
4935
4936
4937   //  TProfile::Approximate();
4938
4939   const char* fitOption = "SER"; //+";//SER
4940
4941   TFitResultPtr fitResult = p->Fit(fitMeanpt,fitOption,"");
4942
4943   std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
4944
4945   if ( static_cast<int>(fitResult) )
4946   {
4947     for ( Int_t i = 0; i < 4; ++i )
4948     {
4949       fitMeanpt->SetParameter(i + 13, bck->GetParameter(i)*0.9);
4950     }
4951     fitResult = p->Fit(fitMeanpt,fitOption,"");
4952
4953     std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
4954   }
4955   else if ( fitMeanpt->GetParameter(17) <= fitMeanpt->GetParError(17) || fitMeanpt->GetParError(17) >= 0.75*fitMeanpt->GetParameter(17) || (fitMeanpt->GetParameter(17)/psipPtLim > 0.9) )
4956   {
4957     fitMeanpt->FixParameter(17, bck->Eval(3.68));
4958     for ( Int_t i = 0; i < 4; ++i )
4959     {
4960       fitMeanpt->SetParameter(i + 13, bck->GetParameter(i)*0.6);
4961     }
4962     fitResult = p->Fit(fitMeanpt,fitOption,"");
4963
4964     std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
4965   }
4966
4967   if ( fitMeanpt->GetParameter(13) <= fitMeanpt->GetParError(13) || fitMeanpt->GetParError(13) >= 0.75*fitMeanpt->GetParameter(13) )
4968   {
4969     fitMeanpt->SetParameter(13, 2.);
4970
4971     fitResult = p->Fit(fitMeanpt,fitOption,"");
4972
4973     std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
4974   }
4975
4976   //  TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
4977
4978   bck->SetParameters(fitMeanpt->GetParameter(13),fitMeanpt->GetParameter(14),fitMeanpt->GetParameter(15),fitMeanpt->GetParameter(16));
4979
4980   AttachFunctionsToHisto(0x0,bck,fitMeanpt,fitRangeLow,fitRangeHigh);//
4981
4982   Set("NofJPsi",NofJPsi,ErrStatNofJPsi);
4983   Set("MeanPtJPsi",fitMeanpt->GetParameter(12),fitMeanpt->GetParError(12));
4984   Set("MeanPtPsiP",fitMeanpt->GetParameter(17),fitMeanpt->GetParError(17));
4985
4986 }
4987
4988 //_____________________________________________________________________________
4989 void AliAnalysisMuMuJpsiResult::FitMPTPSIPSIPRIMECB2POL2EXP_BKGMPTPOL2()
4990 {
4991   //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
4992   fHisto->GetListOfFunctions()->Delete();
4993
4994   Double_t alphaLow = GetValue("alJPsi");
4995   Double_t nLow = GetValue("nlJPsi");
4996   Double_t alphaUp = GetValue("auJPsi");
4997   Double_t nUp = GetValue("nuJPsi");
4998
4999   Double_t pol0 = GetValue("pol0");
5000   Double_t pol1 = GetValue("pol1");
5001   Double_t pol2 = GetValue("pol2");
5002   Double_t exp = GetValue("exp");
5003   Double_t kJPsi = GetValue("kJPsi");
5004   Double_t kPsiP = GetValue("kPsiP");
5005   Double_t mJPsi = GetValue("mJPsi");
5006   Double_t sJPsi = GetValue("sJPsi");
5007   Double_t NofJPsi = GetValue("NofJPsi");
5008   Double_t ErrStatNofJPsi = GetErrorStat("NofJPsi");
5009
5010   Double_t fitRangeLow = GetValue(kFitRangeLow);
5011   Double_t fitRangeHigh = GetValue(kFitRangeHigh);
5012
5013   //  TString msg;
5014   //
5015   //  if (IsValidValue(alphaLow)) msg += TString::Format("alphaLow=%e ",alphaLow);
5016   //  if (IsValidValue(nLow)) msg += TString::Format("nLow=%e ",nLow);
5017   //  if (IsValidValue(alphaUp)) msg += TString::Format("alphaUp=%e ",alphaUp);
5018   //  if (IsValidValue(nUp)) msg += TString::Format("nUp=%e ",nUp);
5019   //
5020   //  AliDebug(1,Form("Mean pt fit with jpsi + psiprime (CB2),Bkg VWG and Pol2 for Bkg <pt> %s",msg.Data()));
5021   //
5022   //  TF1* fitTotal = new TF1("signal+bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2VWG,fitRangeLow,fitRangeHigh,17,"AliAnalysisMuMuJpsiResult","FitFunctionTotalTwoCB2VWG");
5023   //
5024   //TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
5025
5026
5027   //  TString resultName(Form("MEANPTFIT_%salphalow=%5.2fnlow=%5.2falphaup=%5.2fnup=%5.2f",fitName.Data(),par[7],par[8],par[9],par[10]));
5028   TProfile* p(0x0);
5029   if ( fHisto->IsA() == TProfile::Class() ) p = static_cast<TProfile*>(fHisto);
5030   else
5031   {
5032     AliError("Mean pt histo has to be a TProfile");
5033     return;
5034   }
5035
5036   //_____________
5037   Int_t minBin = p->FindBin(fitRangeLow);
5038   Int_t maxBin = p->FindBin(fitRangeHigh);
5039
5040   for ( Int_t i = minBin ; i <= maxBin ; i++ )
5041   {
5042     if ( p->GetBinEffectiveEntries(i) < 10 )
5043     {
5044       Double_t effEntries(0.),sumErr(0.);
5045       for ( Int_t j = i - 5 ; j < i ; j++ )
5046       {
5047         if ( j <= 0 ) continue;
5048         //        if ( j > p->GetNbinsX() ) break;
5049
5050         effEntries += p->GetBinEffectiveEntries(j);
5051         sumErr += p->GetBinEffectiveEntries(j)*p->GetBinError(j);
5052       }
5053
5054       Double_t meanErr = sumErr/effEntries;
5055
5056       if ( p->GetBinError(i) < meanErr/2. )
5057       {
5058         std::cout << "Resetting bin " << i << " error" <<std::endl;
5059         p->SetBinError(i,meanErr);
5060       }
5061     }
5062   }
5063   //_____________
5064
5065   TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
5066
5067   bck->SetParameters(3.,1.,0.);
5068
5069   bck->SetParLimits(0, 1.,8.0);
5070   //  TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2Exp,fitRangeLow,fitRangeHigh,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2Exp");
5071   //
5072   //  bck->SetParameters(1,0,0,0);
5073
5074   SetFitRejectRange(2.3,4.0);
5075
5076   p->Fit(bck,"SER","",fitRangeLow,fitRangeHigh);
5077
5078   SetFitRejectRange();
5079
5080
5081   TF1* fitMeanpt = new TF1("fitMeanpt",this,&AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2CB2POL2EXPPOL2,fitRangeLow,fitRangeHigh,17,"AliAnalysisMuMuJpsiResult","FitFunctionMeanPtS2CB2POL2EXPPOL2");
5082
5083   fitMeanpt->SetParNames("pol0","pol1","pol2","exp","kJPsi","mJPsi","sJPsi","alJPsi","nlJPsi","auJPsi","nuJPsi");
5084   fitMeanpt->SetParName(11,"kPsiP");
5085   fitMeanpt->SetParName(12,"<pt>JPsi");
5086   fitMeanpt->SetParName(13,"<pt>BG0");
5087   fitMeanpt->SetParName(14,"<pt>BG1");
5088   fitMeanpt->SetParName(15,"<pt>BG2");
5089   fitMeanpt->SetParName(16,"<pt>PsiP");
5090
5091   fitMeanpt->FixParameter(0,pol0);
5092   fitMeanpt->FixParameter(1,pol1);
5093   fitMeanpt->FixParameter(2,pol2);
5094   fitMeanpt->FixParameter(3,exp);
5095   fitMeanpt->FixParameter(4,kJPsi);
5096   fitMeanpt->FixParameter(5,mJPsi);
5097   fitMeanpt->FixParameter(6,sJPsi);
5098   fitMeanpt->FixParameter(7,alphaLow);
5099   fitMeanpt->FixParameter(8,nLow);
5100   fitMeanpt->FixParameter(9,alphaUp);
5101   fitMeanpt->FixParameter(10,nUp);
5102   fitMeanpt->FixParameter(11,kPsiP);
5103
5104   fitMeanpt->SetParameter(12, 3.);
5105   fitMeanpt->SetParLimits(12, 1.0,5.);
5106
5107   for ( Int_t i = 0; i < 3; ++i )
5108   {
5109     fitMeanpt->SetParameter(i + 13, bck->GetParameter(i));
5110   }
5111
5112   //  fitMeanpt->SetParameter(13, 3.);
5113   //  fitMeanpt->SetParLimits(13, 0.5,10.);
5114   //
5115   //  fitMeanpt->SetParameter(14, 0.2);
5116   //  //  fitMeanpt->SetParLimits(14, 0.1,0.2);
5117   //
5118   //  fitMeanpt->SetParameter(15, 0.1);
5119   //  //  fitMeanpt->SetParLimits(15, 0.,1.);
5120
5121   fitMeanpt->SetParameter(16, 3.);
5122   Double_t psipPtLim = 10.;
5123   fitMeanpt->SetParLimits(16, 0.,psipPtLim);
5124
5125
5126   //  TProfile::Approximate();
5127
5128   const char* fitOption = "SER"; //+";//SER
5129
5130   TFitResultPtr fitResult = p->Fit(fitMeanpt,fitOption,"");
5131
5132   std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
5133
5134   if ( static_cast<int>(fitResult) )
5135   {
5136     for ( Int_t i = 0; i < 3; ++i )
5137     {
5138       fitMeanpt->SetParameter(i + 13, bck->GetParameter(i)*0.9);
5139     }
5140     fitResult = p->Fit(fitMeanpt,fitOption,"");
5141
5142     std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
5143   }
5144   else if ( fitMeanpt->GetParameter(16) <= fitMeanpt->GetParError(16) || fitMeanpt->GetParError(16) >= 0.75*fitMeanpt->GetParameter(16) || (fitMeanpt->GetParameter(16)/psipPtLim > 0.9) )
5145   {
5146     fitMeanpt->FixParameter(16, bck->Eval(3.68));
5147     for ( Int_t i = 0; i < 3; ++i )
5148     {
5149       fitMeanpt->SetParameter(i + 13, bck->GetParameter(i)*0.6);
5150     }
5151     fitResult = p->Fit(fitMeanpt,fitOption,"");
5152
5153     std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
5154   }
5155
5156   //  TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
5157
5158   bck->SetParameters(fitMeanpt->GetParameter(13),fitMeanpt->GetParameter(14),fitMeanpt->GetParameter(15));
5159
5160   AttachFunctionsToHisto(0x0,bck,fitMeanpt,fitRangeLow,fitRangeHigh);//
5161
5162   Set("NofJPsi",NofJPsi,ErrStatNofJPsi);
5163   Set("MeanPtJPsi",fitMeanpt->GetParameter(12),fitMeanpt->GetParError(12));
5164   Set("MeanPtPsiP",fitMeanpt->GetParameter(16),fitMeanpt->GetParError(16));
5165
5166 }
5167
5168 //_____________________________________________________________________________
5169 void AliAnalysisMuMuJpsiResult::FitMPTPSIPSIPRIMECB2POL2EXP_BKGMPTPOL2EXP()
5170 {
5171   //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
5172   fHisto->GetListOfFunctions()->Delete();
5173
5174   Double_t alphaLow = GetValue("alJPsi");
5175   Double_t nLow = GetValue("nlJPsi");
5176   Double_t alphaUp = GetValue("auJPsi");
5177   Double_t nUp = GetValue("nuJPsi");
5178
5179   Double_t pol0 = GetValue("pol0");
5180   Double_t pol1 = GetValue("pol1");
5181   Double_t pol2 = GetValue("pol2");
5182   Double_t exp = GetValue("exp");
5183   Double_t kJPsi = GetValue("kJPsi");
5184   Double_t kPsiP = GetValue("kPsiP");
5185   Double_t mJPsi = GetValue("mJPsi");
5186   Double_t sJPsi = GetValue("sJPsi");
5187   Double_t NofJPsi = GetValue("NofJPsi");
5188   Double_t ErrStatNofJPsi = GetErrorStat("NofJPsi");
5189
5190   Double_t fitRangeLow = GetValue(kFitRangeLow);
5191   Double_t fitRangeHigh = GetValue(kFitRangeHigh);
5192
5193   //  TString msg;
5194   //
5195   //  if (IsValidValue(alphaLow)) msg += TString::Format("alphaLow=%e ",alphaLow);
5196   //  if (IsValidValue(nLow)) msg += TString::Format("nLow=%e ",nLow);
5197   //  if (IsValidValue(alphaUp)) msg += TString::Format("alphaUp=%e ",alphaUp);
5198   //  if (IsValidValue(nUp)) msg += TString::Format("nUp=%e ",nUp);
5199   //
5200   //  AliDebug(1,Form("Mean pt fit with jpsi + psiprime (CB2),Bkg VWG and Pol2 for Bkg <pt> %s",msg.Data()));
5201   //
5202   //  TF1* fitTotal = new TF1("signal+bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2VWG,fitRangeLow,fitRangeHigh,17,"AliAnalysisMuMuJpsiResult","FitFunctionTotalTwoCB2VWG");
5203   //
5204   //TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
5205
5206
5207   //  TString resultName(Form("MEANPTFIT_%salphalow=%5.2fnlow=%5.2falphaup=%5.2fnup=%5.2f",fitName.Data(),par[7],par[8],par[9],par[10]));
5208   TProfile* p(0x0);
5209   if ( fHisto->IsA() == TProfile::Class() ) p = static_cast<TProfile*>(fHisto);
5210   else
5211   {
5212     AliError("Mean pt histo has to be a TProfile");
5213     return;
5214   }
5215
5216   //_____________
5217   Int_t minBin = p->FindBin(fitRangeLow);
5218   Int_t maxBin = p->FindBin(fitRangeHigh);
5219
5220   for ( Int_t i = minBin ; i <= maxBin ; i++ )
5221   {
5222     if ( p->GetBinEffectiveEntries(i) < 10 )
5223     {
5224       Double_t effEntries(0.),sumErr(0.);
5225       for ( Int_t j = i - 5 ; j < i ; j++ )
5226       {
5227         if ( j <= 0 ) continue;
5228         //        if ( j > p->GetNbinsX() ) break;
5229
5230         effEntries += p->GetBinEffectiveEntries(j);
5231         sumErr += p->GetBinEffectiveEntries(j)*p->GetBinError(j);
5232       }
5233
5234       Double_t meanErr = sumErr/effEntries;
5235
5236       if ( p->GetBinError(i) < meanErr/2. )
5237       {
5238         std::cout << "Resetting bin " << i << " error" <<std::endl;
5239         p->SetBinError(i,meanErr);
5240       }
5241     }
5242   }
5243   //_____________
5244
5245   TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2Exp,fitRangeLow,fitRangeHigh,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2Exp");
5246
5247   bck->SetParameters(3.,-1.,0.4,-0.1);
5248
5249   bck->SetParLimits(0, 1.,10.0);
5250   //  TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2Exp,fitRangeLow,fitRangeHigh,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2Exp");
5251   //
5252   //  bck->SetParameters(1,0,0,0);
5253
5254   SetFitRejectRange(2.3,4.0);
5255
5256   p->Fit(bck,"SER","",fitRangeLow,fitRangeHigh);
5257
5258   SetFitRejectRange();
5259
5260
5261   TF1* fitMeanpt = new TF1("fitMeanpt",this,&AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2CB2POL2EXPPOL2EXP,fitRangeLow,fitRangeHigh,18,"AliAnalysisMuMuJpsiResult","FitFunctionMeanPtS2CB2POL2EXPPOL2EXP");
5262
5263   fitMeanpt->SetParNames("pol0","pol1","pol2","exp","kJPsi","mJPsi","sJPsi","alJPsi","nlJPsi","auJPsi","nuJPsi");
5264   fitMeanpt->SetParName(11,"kPsiP");
5265   fitMeanpt->SetParName(12,"<pt>JPsi");
5266   fitMeanpt->SetParName(13,"<pt>BG0");
5267   fitMeanpt->SetParName(14,"<pt>BG1");
5268   fitMeanpt->SetParName(15,"<pt>BG2");
5269   fitMeanpt->SetParName(16,"<pt>BGEXP");
5270   fitMeanpt->SetParName(17,"<pt>PsiP");
5271
5272   fitMeanpt->FixParameter(0,pol0);
5273   fitMeanpt->FixParameter(1,pol1);
5274   fitMeanpt->FixParameter(2,pol2);
5275   fitMeanpt->FixParameter(3,exp);
5276   fitMeanpt->FixParameter(4,kJPsi);
5277   fitMeanpt->FixParameter(5,mJPsi);
5278   fitMeanpt->FixParameter(6,sJPsi);
5279   fitMeanpt->FixParameter(7,alphaLow);
5280   fitMeanpt->FixParameter(8,nLow);
5281   fitMeanpt->FixParameter(9,alphaUp);
5282   fitMeanpt->FixParameter(10,nUp);
5283   fitMeanpt->FixParameter(11,kPsiP);
5284
5285   fitMeanpt->SetParameter(12, 3.);
5286   fitMeanpt->SetParLimits(12, 1.0,5.);
5287
5288   for ( Int_t i = 0; i < 4; ++i )
5289   {
5290     fitMeanpt->SetParameter(i + 13, bck->GetParameter(i));
5291   }
5292
5293   //  fitMeanpt->SetParameter(13, 3.);
5294   //  fitMeanpt->SetParLimits(13, 0.5,10.);
5295   //
5296   //  fitMeanpt->SetParameter(14, 0.2);
5297   //  //  fitMeanpt->SetParLimits(14, 0.1,0.2);
5298   //
5299   //  fitMeanpt->SetParameter(15, 0.1);
5300   //  //  fitMeanpt->SetParLimits(15, 0.,1.);
5301
5302   fitMeanpt->SetParameter(17, 3.);
5303   Double_t psipPtLim = 10.;
5304   fitMeanpt->SetParLimits(17, 0.,psipPtLim);
5305
5306
5307   //  TProfile::Approximate();
5308
5309   const char* fitOption = "SER"; //+";//SER
5310
5311   TFitResultPtr fitResult = p->Fit(fitMeanpt,fitOption,"");
5312
5313   std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
5314
5315   if ( static_cast<int>(fitResult) )
5316   {
5317     for ( Int_t i = 0; i < 4; ++i )
5318     {
5319       fitMeanpt->SetParameter(i + 13, bck->GetParameter(i)*0.9);
5320     }
5321     fitResult = p->Fit(fitMeanpt,fitOption,"");
5322
5323     std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
5324   }
5325   else if ( fitMeanpt->GetParameter(17) <= fitMeanpt->GetParError(17) || fitMeanpt->GetParError(17) >= 0.75*fitMeanpt->GetParameter(17) || (fitMeanpt->GetParameter(17)/psipPtLim > 0.9) )
5326   {
5327     fitMeanpt->FixParameter(17, bck->Eval(3.68));
5328     for ( Int_t i = 0; i < 4; ++i )
5329     {
5330       fitMeanpt->SetParameter(i + 13, bck->GetParameter(i)*0.6);
5331     }
5332     fitResult = p->Fit(fitMeanpt,fitOption,"");
5333
5334     std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
5335   }
5336   if ( fitMeanpt->GetParameter(13) <= fitMeanpt->GetParError(13) || fitMeanpt->GetParError(13) >= 0.75*fitMeanpt->GetParameter(13) )
5337   {
5338     fitMeanpt->SetParameter(13, 2.);
5339
5340     fitResult = p->Fit(fitMeanpt,fitOption,"");
5341
5342     std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
5343   }
5344
5345   //  TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
5346
5347   bck->SetParameters(fitMeanpt->GetParameter(13),fitMeanpt->GetParameter(14),fitMeanpt->GetParameter(15),fitMeanpt->GetParameter(16));
5348
5349   AttachFunctionsToHisto(0x0,bck,fitMeanpt,fitRangeLow,fitRangeHigh);//
5350
5351   Set("NofJPsi",NofJPsi,ErrStatNofJPsi);
5352   Set("MeanPtJPsi",fitMeanpt->GetParameter(12),fitMeanpt->GetParError(12));
5353   Set("MeanPtPsiP",fitMeanpt->GetParameter(17),fitMeanpt->GetParError(17));
5354
5355 }
5356
5357 //_____________________________________________________________________________
5358 void AliAnalysisMuMuJpsiResult::FitMPTPSIPSIPRIMENA60NEWVWG_BKGMPTPOL2()
5359 {
5360   //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
5361   fHisto->GetListOfFunctions()->Delete();
5362
5363   Double_t p1Left = GetValue("p1LJPsi");
5364   Double_t p2Left = GetValue("p2LJPsi");
5365   Double_t p3Left = GetValue("p3LJPsi");
5366   Double_t p1Right = GetValue("p1RJPsi");
5367   Double_t p2Right = GetValue("p2RJPsi");
5368   Double_t p3Right = GetValue("p3RJPsi");
5369
5370   Double_t alphaLeft = GetValue("aLJPsi");
5371   Double_t alphaRight = GetValue("aRJPsi");
5372
5373   Double_t kVWG = GetValue("kVWG");
5374   Double_t mVWG = GetValue("mVWG");
5375   Double_t sVWG1 = GetValue("sVWG1");
5376   Double_t sVWG2 = GetValue("sVWG2");
5377   Double_t kJPsi = GetValue("kJPsi");
5378   Double_t kPsiP = GetValue("kPsiP");
5379   Double_t mJPsi = GetValue("mJPsi");
5380   Double_t sJPsi = GetValue("sJPsi");
5381   Double_t NofJPsi = GetValue("NofJPsi");
5382   Double_t ErrStatNofJPsi = GetErrorStat("NofJPsi");
5383
5384   Double_t fitRangeLow = GetValue(kFitRangeLow);
5385   Double_t fitRangeHigh = GetValue(kFitRangeHigh);
5386
5387   //  TString msg;
5388   //
5389   //  if (IsValidValue(alphaLow)) msg += TString::Format("alphaLow=%e ",alphaLow);
5390   //  if (IsValidValue(nLow)) msg += TString::Format("nLow=%e ",nLow);
5391   //  if (IsValidValue(alphaUp)) msg += TString::Format("alphaUp=%e ",alphaUp);
5392   //  if (IsValidValue(nUp)) msg += TString::Format("nUp=%e ",nUp);
5393   //
5394   //  AliDebug(1,Form("Mean pt fit with jpsi + psiprime (CB2),Bkg VWG and Pol2 for Bkg <pt> %s",msg.Data()));
5395   //
5396   //  TF1* fitTotal = new TF1("signal+bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2VWG,fitRangeLow,fitRangeHigh,17,"AliAnalysisMuMuJpsiResult","FitFunctionTotalTwoCB2VWG");
5397   //
5398   //TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
5399
5400
5401   //  TString resultName(Form("MEANPTFIT_%salphalow=%5.2fnlow=%5.2falphaup=%5.2fnup=%5.2f",fitName.Data(),par[7],par[8],par[9],par[10]));
5402   TProfile* p(0x0);
5403   if ( fHisto->IsA() == TProfile::Class() ) p = static_cast<TProfile*>(fHisto);
5404   else
5405   {
5406     AliError("Mean pt histo has to be a TProfile");
5407     return;
5408   }
5409
5410   //_____________
5411   Int_t minBin = p->FindBin(fitRangeLow);
5412   Int_t maxBin = p->FindBin(fitRangeHigh);
5413
5414   for ( Int_t i = minBin ; i <= maxBin ; i++ )
5415   {
5416     if ( p->GetBinEffectiveEntries(i) < 10 )
5417     {
5418       Double_t effEntries(0.),sumErr(0.);
5419       for ( Int_t j = i - 5 ; j < i ; j++ )
5420       {
5421         if ( j <= 0 ) continue;
5422         //        if ( j > p->GetNbinsX() ) break;
5423
5424         effEntries += p->GetBinEffectiveEntries(j);
5425         sumErr += p->GetBinEffectiveEntries(j)*p->GetBinError(j);
5426       }
5427
5428       Double_t meanErr = sumErr/effEntries;
5429
5430       if ( p->GetBinError(i) < meanErr/2. )
5431       {
5432         std::cout << "Resetting bin " << i << " error" <<std::endl;
5433         p->SetBinError(i,meanErr);
5434       }
5435     }
5436   }
5437   //_____________
5438
5439   TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
5440
5441   bck->SetParameters(3.,1.,0.);
5442
5443   bck->SetParLimits(0, 1.,8.0);
5444   //  TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2Exp,fitRangeLow,fitRangeHigh,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2Exp");
5445   //
5446   //  bck->SetParameters(1,0,0,0);
5447
5448   SetFitRejectRange(2.3,4.0);
5449
5450   p->Fit(bck,"SER","",fitRangeLow,fitRangeHigh);
5451
5452   SetFitRejectRange();
5453
5454
5455
5456   TF1* fitMeanpt = new TF1("fitMeanpt",this,&AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2NA60NEWVWGPOL2,fitRangeLow,fitRangeHigh,21,"AliAnalysisMuMuJpsiResult","FitFunctionMeanPtS2NA60NEWVWGPOL2");
5457
5458   fitMeanpt->SetParNames("kVWG","mVWG","sVWG1","sVWG2","kJPsi","mJPsi","sJPsi","p1LJPsi","p2LJPsi","p3LJPsi","p1RJPsi");
5459   fitMeanpt->SetParName(11,"p2RJPsi");
5460   fitMeanpt->SetParName(12,"p3RJPsi");
5461   fitMeanpt->SetParName(13,"aLJPsi");
5462   fitMeanpt->SetParName(14,"aRJPsi");
5463   fitMeanpt->SetParName(15,"kPsiP");
5464   fitMeanpt->SetParName(16,"<pt>JPsi");
5465   fitMeanpt->SetParName(17,"<pt>BG0");
5466   fitMeanpt->SetParName(18,"<pt>BG1");
5467   fitMeanpt->SetParName(19,"<pt>BG2");
5468   fitMeanpt->SetParName(20,"<pt>PsiP");
5469
5470   fitMeanpt->FixParameter(0,kVWG);
5471   fitMeanpt->FixParameter(1,mVWG);
5472   fitMeanpt->FixParameter(2,sVWG1);
5473   fitMeanpt->FixParameter(3,sVWG2);
5474   fitMeanpt->FixParameter(4,kJPsi);
5475   fitMeanpt->FixParameter(5,mJPsi);
5476   fitMeanpt->FixParameter(6,sJPsi);
5477   fitMeanpt->FixParameter(7,p1Left);
5478   fitMeanpt->FixParameter(8,p2Left);
5479   fitMeanpt->FixParameter(9,p3Left);
5480   fitMeanpt->FixParameter(10,p1Right);
5481   fitMeanpt->FixParameter(11,p2Right);
5482   fitMeanpt->FixParameter(12,p3Right);
5483   fitMeanpt->FixParameter(13,alphaLeft);
5484   fitMeanpt->FixParameter(14,alphaRight);
5485   fitMeanpt->FixParameter(15,kPsiP);
5486
5487   fitMeanpt->SetParameter(16, 3.);
5488   fitMeanpt->SetParLimits(16, 1.0,5.);
5489
5490
5491   for ( Int_t i = 0; i < 3; ++i )
5492   {
5493 //    TString name(GetName());
5494 //    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)") )
5495 //    {
5496 //      fitMeanpt->SetParameter(i + 17, bck->GetParameter(i)/2.);
5497 //      fitMeanpt->SetParameter(16, 4.);
5498 ////      if (fitMeanpt->GetParameter(3) < 2.e-06) fitMeanpt->FixParameter(3,3e-6);
5499 //
5500 //    }
5501 //    else
5502       fitMeanpt->SetParameter(i + 17, bck->GetParameter(i));
5503   }
5504
5505   //  fitMeanpt->SetParameter(13, 3.);
5506   //  fitMeanpt->SetParLimits(13, 0.5,10.);
5507   //
5508   //  fitMeanpt->SetParameter(14, 0.2);
5509   //  //  fitMeanpt->SetParLimits(14, 0.1,0.2);
5510   //
5511   //  fitMeanpt->SetParameter(15, 0.1);
5512   //  //  fitMeanpt->SetParLimits(15, 0.,1.);
5513
5514   fitMeanpt->SetParameter(20, 3.);
5515   Double_t psipPtLim = 10.;
5516   fitMeanpt->SetParLimits(20, 0.,psipPtLim);
5517
5518
5519   //  TProfile::Approximate();
5520
5521   const char* fitOption = "SER"; //+";//SER
5522
5523   TFitResultPtr fitResult = p->Fit(fitMeanpt,fitOption,"");
5524
5525   std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
5526
5527   if ( static_cast<int>(fitResult) )
5528   {
5529     for ( Int_t i = 0; i < 3; ++i )
5530     {
5531       fitMeanpt->SetParameter(i + 17, bck->GetParameter(i)*0.9);
5532     }
5533     fitResult = p->Fit(fitMeanpt,fitOption,"");
5534
5535     std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
5536   }
5537   else if ( fitMeanpt->GetParameter(20) <= fitMeanpt->GetParError(20) || fitMeanpt->GetParError(20) >= 0.75*fitMeanpt->GetParameter(20) || (fitMeanpt->GetParameter(20)/psipPtLim > 0.9) )
5538   {
5539     fitMeanpt->FixParameter(20, bck->Eval(3.68));
5540     for ( Int_t i = 0; i < 3; ++i )
5541     {
5542       fitMeanpt->SetParameter(i + 17, bck->GetParameter(i)*0.6);
5543     }
5544     fitResult = p->Fit(fitMeanpt,fitOption,"");
5545
5546     std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
5547   }
5548
5549   //  TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
5550
5551   bck->SetParameters(fitMeanpt->GetParameter(17),fitMeanpt->GetParameter(18),fitMeanpt->GetParameter(19));
5552
5553   AttachFunctionsToHisto(0x0,bck,fitMeanpt,fitRangeLow,fitRangeHigh);//
5554
5555   Set("NofJPsi",NofJPsi,ErrStatNofJPsi);
5556   Set("MeanPtJPsi",fitMeanpt->GetParameter(16),fitMeanpt->GetParError(16));
5557   Set("MeanPtPsiP",fitMeanpt->GetParameter(20),fitMeanpt->GetParError(20));
5558
5559 }
5560
5561 //_____________________________________________________________________________
5562 void AliAnalysisMuMuJpsiResult::FitMPTPSIPSIPRIMENA60NEWVWG_BKGMPTPOL2EXP()
5563 {
5564   //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
5565   fHisto->GetListOfFunctions()->Delete();
5566
5567   Double_t p1Left = GetValue("p1LJPsi");
5568   Double_t p2Left = GetValue("p2LJPsi");
5569   Double_t p3Left = GetValue("p3LJPsi");
5570   Double_t p1Right = GetValue("p1RJPsi");
5571   Double_t p2Right = GetValue("p2RJPsi");
5572   Double_t p3Right = GetValue("p3RJPsi");
5573
5574   Double_t alphaLeft = GetValue("aLJPsi");
5575   Double_t alphaRight = GetValue("aRJPsi");
5576
5577   Double_t kVWG = GetValue("kVWG");
5578   Double_t mVWG = GetValue("mVWG");
5579   Double_t sVWG1 = GetValue("sVWG1");
5580   Double_t sVWG2 = GetValue("sVWG2");
5581   Double_t kJPsi = GetValue("kJPsi");
5582   Double_t kPsiP = GetValue("kPsiP");
5583   Double_t mJPsi = GetValue("mJPsi");
5584   Double_t sJPsi = GetValue("sJPsi");
5585   Double_t NofJPsi = GetValue("NofJPsi");
5586   Double_t ErrStatNofJPsi = GetErrorStat("NofJPsi");
5587
5588   Double_t fitRangeLow = GetValue(kFitRangeLow);
5589   Double_t fitRangeHigh = GetValue(kFitRangeHigh);
5590
5591   //  TString msg;
5592   //
5593   //  if (IsValidValue(alphaLow)) msg += TString::Format("alphaLow=%e ",alphaLow);
5594   //  if (IsValidValue(nLow)) msg += TString::Format("nLow=%e ",nLow);
5595   //  if (IsValidValue(alphaUp)) msg += TString::Format("alphaUp=%e ",alphaUp);
5596   //  if (IsValidValue(nUp)) msg += TString::Format("nUp=%e ",nUp);
5597   //
5598   //  AliDebug(1,Form("Mean pt fit with jpsi + psiprime (CB2),Bkg VWG and Pol2 for Bkg <pt> %s",msg.Data()));
5599   //
5600   //  TF1* fitTotal = new TF1("signal+bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2VWG,fitRangeLow,fitRangeHigh,17,"AliAnalysisMuMuJpsiResult","FitFunctionTotalTwoCB2VWG");
5601   //
5602   //TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
5603
5604
5605   //  TString resultName(Form("MEANPTFIT_%salphalow=%5.2fnlow=%5.2falphaup=%5.2fnup=%5.2f",fitName.Data(),par[7],par[8],par[9],par[10]));
5606   TProfile* p(0x0);
5607   if ( fHisto->IsA() == TProfile::Class() ) p = static_cast<TProfile*>(fHisto);
5608   else
5609   {
5610     AliError("Mean pt histo has to be a TProfile");
5611     return;
5612   }
5613
5614   //_____________
5615   Int_t minBin = p->FindBin(fitRangeLow);
5616   Int_t maxBin = p->FindBin(fitRangeHigh);
5617
5618   for ( Int_t i = minBin ; i <= maxBin ; i++ )
5619   {
5620     if ( p->GetBinEffectiveEntries(i) < 10 )
5621     {
5622       Double_t effEntries(0.),sumErr(0.);
5623       for ( Int_t j = i - 5 ; j < i ; j++ )
5624       {
5625         if ( j <= 0 ) continue;
5626         //        if ( j > p->GetNbinsX() ) break;
5627
5628         effEntries += p->GetBinEffectiveEntries(j);
5629         sumErr += p->GetBinEffectiveEntries(j)*p->GetBinError(j);
5630       }
5631
5632       Double_t meanErr = sumErr/effEntries;
5633
5634       if ( p->GetBinError(i) < meanErr/2. )
5635       {
5636         std::cout << "Resetting bin " << i << " error" <<std::endl;
5637         p->SetBinError(i,meanErr);
5638       }
5639     }
5640   }
5641   //_____________
5642
5643   TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2Exp,fitRangeLow,fitRangeHigh,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2Exp");
5644
5645   bck->SetParameters(2.5,-1.,0.2,-0.05);
5646
5647   bck->SetParLimits(0, 1.,10.0);
5648   //  TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2Exp,fitRangeLow,fitRangeHigh,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2Exp");
5649   //
5650   //  bck->SetParameters(1,0,0,0);
5651
5652   SetFitRejectRange(2.3,4.0);
5653
5654   p->Fit(bck,"SER","",fitRangeLow,fitRangeHigh);
5655
5656   SetFitRejectRange();
5657
5658   TF1* fitMeanpt = new TF1("fitMeanpt",this,&AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2NA60NEWVWGPOL2EXP,fitRangeLow,fitRangeHigh,22,"AliAnalysisMuMuJpsiResult","FitFunctionMeanPtS2NA60NEWVWGPOL2EXP");
5659
5660   fitMeanpt->SetParNames("kVWG","mVWG","sVWG1","sVWG2","kJPsi","mJPsi","sJPsi","p1LJPsi","p2LJPsi","p3LJPsi","p1RJPsi");
5661   fitMeanpt->SetParName(11,"p2RJPsi");
5662   fitMeanpt->SetParName(12,"p3RJPsi");
5663   fitMeanpt->SetParName(13,"aLJPsi");
5664   fitMeanpt->SetParName(14,"aRJPsi");
5665   fitMeanpt->SetParName(15,"kPsiP");
5666   fitMeanpt->SetParName(16,"<pt>JPsi");
5667   fitMeanpt->SetParName(17,"<pt>BG0");
5668   fitMeanpt->SetParName(18,"<pt>BG1");
5669   fitMeanpt->SetParName(19,"<pt>BG2");
5670   fitMeanpt->SetParName(20,"<pt>BGEXP");
5671   fitMeanpt->SetParName(21,"<pt>PsiP");
5672
5673   fitMeanpt->FixParameter(0,kVWG);
5674   fitMeanpt->FixParameter(1,mVWG);
5675   fitMeanpt->FixParameter(2,sVWG1);
5676   fitMeanpt->FixParameter(3,sVWG2);
5677   fitMeanpt->FixParameter(4,kJPsi);
5678   fitMeanpt->FixParameter(5,mJPsi);
5679   fitMeanpt->FixParameter(6,sJPsi);
5680   fitMeanpt->FixParameter(7,p1Left);
5681   fitMeanpt->FixParameter(8,p2Left);
5682   fitMeanpt->FixParameter(9,p3Left);
5683   fitMeanpt->FixParameter(10,p1Right);
5684   fitMeanpt->FixParameter(11,p2Right);
5685   fitMeanpt->FixParameter(12,p3Right);
5686   fitMeanpt->FixParameter(13,alphaLeft);
5687   fitMeanpt->FixParameter(14,alphaRight);
5688   fitMeanpt->FixParameter(15,kPsiP);
5689
5690   fitMeanpt->SetParameter(16, 3.);
5691   fitMeanpt->SetParLimits(16, 1.0,5.);
5692
5693   for ( Int_t i = 0; i < 4; ++i )
5694   {
5695 //    TString name(GetName());
5696 //    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)") )
5697 //    {
5698 //      fitMeanpt->SetParameter(i + 17, bck->GetParameter(i)/2.);
5699 //      fitMeanpt->SetParameter(16, 4.);
5700 ////      if (fitMeanpt->GetParameter(3) < 2.e-06) fitMeanpt->FixParameter(3,3e-4);
5701 //
5702 //    }
5703 //    else
5704       fitMeanpt->SetParameter(i + 17, bck->GetParameter(i));
5705 //    fitMeanpt->SetParameter(i + 17, bck->GetParameter(i));
5706   }
5707
5708   fitMeanpt->SetParameter(21, 3.);
5709   Double_t psipPtLim = 10.;
5710   fitMeanpt->SetParLimits(21, 0.,psipPtLim);
5711
5712
5713   //  TProfile::Approximate();
5714
5715   const char* fitOption = "SER"; //+";//SER
5716
5717   TFitResultPtr fitResult = p->Fit(fitMeanpt,fitOption,"");
5718
5719   std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
5720
5721   if ( static_cast<int>(fitResult) )
5722   {
5723     for ( Int_t i = 0; i < 4; ++i )
5724     {
5725       fitMeanpt->SetParameter(i + 17, bck->GetParameter(i)*0.9);
5726     }
5727     fitResult = p->Fit(fitMeanpt,fitOption,"");
5728
5729     std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
5730   }
5731   else if ( fitMeanpt->GetParameter(21) <= fitMeanpt->GetParError(21) || fitMeanpt->GetParError(21) >= 0.75*fitMeanpt->GetParameter(21) || (fitMeanpt->GetParameter(21)/psipPtLim > 0.9) )
5732   {
5733     fitMeanpt->FixParameter(21, bck->Eval(3.68));
5734     for ( Int_t i = 0; i < 4; ++i )
5735     {
5736       fitMeanpt->SetParameter(i + 17, bck->GetParameter(i)*0.6);
5737     }
5738     fitResult = p->Fit(fitMeanpt,fitOption,"");
5739
5740     std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
5741   }
5742   if ( fitMeanpt->GetParameter(17) <= fitMeanpt->GetParError(17) || fitMeanpt->GetParError(17) >= 0.75*fitMeanpt->GetParameter(13) )
5743   {
5744     fitMeanpt->SetParameter(17, 2.);
5745
5746     fitResult = p->Fit(fitMeanpt,fitOption,"");
5747
5748     std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
5749   }
5750
5751
5752   //  TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
5753
5754   bck->SetParameters(fitMeanpt->GetParameter(17),fitMeanpt->GetParameter(18),fitMeanpt->GetParameter(19),fitMeanpt->GetParameter(20));
5755
5756   AttachFunctionsToHisto(0x0,bck,fitMeanpt,fitRangeLow,fitRangeHigh);//
5757
5758   Set("NofJPsi",NofJPsi,ErrStatNofJPsi);
5759   Set("MeanPtJPsi",fitMeanpt->GetParameter(16),fitMeanpt->GetParError(16));
5760   Set("MeanPtPsiP",fitMeanpt->GetParameter(21),fitMeanpt->GetParError(21));
5761
5762 }
5763
5764 //_____________________________________________________________________________
5765 void AliAnalysisMuMuJpsiResult::FitMPTPSIPSIPRIMENA60NEWPOL2EXP_BKGMPTPOL2()
5766 {
5767   //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
5768   fHisto->GetListOfFunctions()->Delete();
5769
5770   Double_t p1Left = GetValue("p1LJPsi");
5771   Double_t p2Left = GetValue("p2LJPsi");
5772   Double_t p3Left = GetValue("p3LJPsi");
5773   Double_t p1Right = GetValue("p1RJPsi");
5774   Double_t p2Right = GetValue("p2RJPsi");
5775   Double_t p3Right = GetValue("p3RJPsi");
5776
5777   Double_t alphaLeft = GetValue("aLJPsi");
5778   Double_t alphaRight = GetValue("aRJPsi");
5779
5780   Double_t pol0 = GetValue("pol0");
5781   Double_t pol1 = GetValue("pol1");
5782   Double_t pol2 = GetValue("pol2");
5783   Double_t exp = GetValue("exp");
5784   Double_t kJPsi = GetValue("kJPsi");
5785   Double_t kPsiP = GetValue("kPsiP");
5786   Double_t mJPsi = GetValue("mJPsi");
5787   Double_t sJPsi = GetValue("sJPsi");
5788   Double_t NofJPsi = GetValue("NofJPsi");
5789   Double_t ErrStatNofJPsi = GetErrorStat("NofJPsi");
5790
5791   Double_t fitRangeLow = GetValue(kFitRangeLow);
5792   Double_t fitRangeHigh = GetValue(kFitRangeHigh);
5793
5794   //  TString msg;
5795   //
5796   //  if (IsValidValue(alphaLow)) msg += TString::Format("alphaLow=%e ",alphaLow);
5797   //  if (IsValidValue(nLow)) msg += TString::Format("nLow=%e ",nLow);
5798   //  if (IsValidValue(alphaUp)) msg += TString::Format("alphaUp=%e ",alphaUp);
5799   //  if (IsValidValue(nUp)) msg += TString::Format("nUp=%e ",nUp);
5800   //
5801   //  AliDebug(1,Form("Mean pt fit with jpsi + psiprime (CB2),Bkg VWG and Pol2 for Bkg <pt> %s",msg.Data()));
5802   //
5803   //  TF1* fitTotal = new TF1("signal+bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2VWG,fitRangeLow,fitRangeHigh,17,"AliAnalysisMuMuJpsiResult","FitFunctionTotalTwoCB2VWG");
5804   //
5805   //TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
5806
5807
5808   //  TString resultName(Form("MEANPTFIT_%salphalow=%5.2fnlow=%5.2falphaup=%5.2fnup=%5.2f",fitName.Data(),par[7],par[8],par[9],par[10]));
5809   TProfile* p(0x0);
5810   if ( fHisto->IsA() == TProfile::Class() ) p = static_cast<TProfile*>(fHisto);
5811   else
5812   {
5813     AliError("Mean pt histo has to be a TProfile");
5814     return;
5815   }
5816
5817   //_____________
5818   Int_t minBin = p->FindBin(fitRangeLow);
5819   Int_t maxBin = p->FindBin(fitRangeHigh);
5820
5821   for ( Int_t i = minBin ; i <= maxBin ; i++ )
5822   {
5823     if ( p->GetBinEffectiveEntries(i) < 10 )
5824     {
5825       Double_t effEntries(0.),sumErr(0.);
5826       for ( Int_t j = i - 5 ; j < i ; j++ )
5827       {
5828         if ( j <= 0 ) continue;
5829         //        if ( j > p->GetNbinsX() ) break;
5830
5831         effEntries += p->GetBinEffectiveEntries(j);
5832         sumErr += p->GetBinEffectiveEntries(j)*p->GetBinError(j);
5833       }
5834
5835       Double_t meanErr = sumErr/effEntries;
5836
5837       if ( p->GetBinError(i) < meanErr/2. )
5838       {
5839         std::cout << "Resetting bin " << i << " error" <<std::endl;
5840         p->SetBinError(i,meanErr);
5841       }
5842     }
5843   }
5844   //_____________
5845
5846   TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
5847
5848   bck->SetParameters(3.,1.,0.);
5849
5850   bck->SetParLimits(0, 1.,8.0);
5851   //  TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2Exp,fitRangeLow,fitRangeHigh,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2Exp");
5852   //
5853   //  bck->SetParameters(1,0,0,0);
5854
5855   SetFitRejectRange(2.3,4.0);
5856
5857   p->Fit(bck,"SER","",fitRangeLow,fitRangeHigh);
5858
5859   SetFitRejectRange();
5860
5861
5862   TF1* fitMeanpt = new TF1("fitMeanpt",this,&AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2NA60NEWPOL2EXPPOL2,fitRangeLow,fitRangeHigh,21,"AliAnalysisMuMuJpsiResult","FitFunctionMeanPtS2NA60NEWPOL2EXPPOL2");
5863
5864   fitMeanpt->SetParNames("pol0","pol1","pol2","exp","kJPsi","mJPsi","sJPsi","p1LJPsi","p2LJPsi","p3LJPsi","p1RJPsi");
5865   fitMeanpt->SetParName(11,"p2RJPsi");
5866   fitMeanpt->SetParName(12,"p3RJPsi");
5867   fitMeanpt->SetParName(13,"aLJPsi");
5868   fitMeanpt->SetParName(14,"aRJPsi");
5869   fitMeanpt->SetParName(15,"kPsiP");
5870   fitMeanpt->SetParName(16,"<pt>JPsi");
5871   fitMeanpt->SetParName(17,"<pt>BG0");
5872   fitMeanpt->SetParName(18,"<pt>BG1");
5873   fitMeanpt->SetParName(19,"<pt>BG2");
5874   fitMeanpt->SetParName(20,"<pt>PsiP");
5875
5876   fitMeanpt->FixParameter(0,pol0);
5877   fitMeanpt->FixParameter(1,pol1);
5878   fitMeanpt->FixParameter(2,pol2);
5879   fitMeanpt->FixParameter(3,exp);
5880   fitMeanpt->FixParameter(4,kJPsi);
5881   fitMeanpt->FixParameter(5,mJPsi);
5882   fitMeanpt->FixParameter(6,sJPsi);
5883   fitMeanpt->FixParameter(7,p1Left);
5884   fitMeanpt->FixParameter(8,p2Left);
5885   fitMeanpt->FixParameter(9,p3Left);
5886   fitMeanpt->FixParameter(10,p1Right);
5887   fitMeanpt->FixParameter(11,p2Right);
5888   fitMeanpt->FixParameter(12,p3Right);
5889   fitMeanpt->FixParameter(13,alphaLeft);
5890   fitMeanpt->FixParameter(14,alphaRight);
5891
5892   fitMeanpt->FixParameter(15,kPsiP);
5893
5894   fitMeanpt->SetParameter(16, 3.);
5895   fitMeanpt->SetParLimits(16, 1.0,5.);
5896
5897   for ( Int_t i = 0; i < 3; ++i )
5898   {
5899     fitMeanpt->SetParameter(i + 17, bck->GetParameter(i));
5900   }
5901
5902   //  fitMeanpt->SetParameter(13, 3.);
5903   //  fitMeanpt->SetParLimits(13, 0.5,10.);
5904   //
5905   //  fitMeanpt->SetParameter(14, 0.2);
5906   //  //  fitMeanpt->SetParLimits(14, 0.1,0.2);
5907   //
5908   //  fitMeanpt->SetParameter(15, 0.1);
5909   //  //  fitMeanpt->SetParLimits(15, 0.,1.);
5910
5911   fitMeanpt->SetParameter(20, 3.);
5912   Double_t psipPtLim = 10.;
5913   fitMeanpt->SetParLimits(20, 0.,psipPtLim);
5914
5915
5916   //  TProfile::Approximate();
5917
5918   const char* fitOption = "SER"; //+";//SER
5919
5920   TFitResultPtr fitResult = p->Fit(fitMeanpt,fitOption,"");
5921
5922   std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
5923
5924   if ( static_cast<int>(fitResult) )
5925   {
5926     for ( Int_t i = 0; i < 3; ++i )
5927     {
5928       fitMeanpt->SetParameter(i + 17, bck->GetParameter(i)*0.9);
5929     }
5930     fitResult = p->Fit(fitMeanpt,fitOption,"");
5931
5932     std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
5933   }
5934   else if ( fitMeanpt->GetParameter(20) <= fitMeanpt->GetParError(20) || fitMeanpt->GetParError(20) >= 0.75*fitMeanpt->GetParameter(20) || (fitMeanpt->GetParameter(20)/psipPtLim > 0.9) )
5935   {
5936     fitMeanpt->FixParameter(20, bck->Eval(3.68));
5937     for ( Int_t i = 0; i < 3; ++i )
5938     {
5939       fitMeanpt->SetParameter(i + 17, bck->GetParameter(i)*0.6);
5940     }
5941     fitResult = p->Fit(fitMeanpt,fitOption,"");
5942
5943     std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
5944   }
5945
5946   //  TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
5947
5948   bck->SetParameters(fitMeanpt->GetParameter(17),fitMeanpt->GetParameter(18),fitMeanpt->GetParameter(19));
5949
5950   AttachFunctionsToHisto(0x0,bck,fitMeanpt,fitRangeLow,fitRangeHigh);//
5951
5952   Set("NofJPsi",NofJPsi,ErrStatNofJPsi);
5953   Set("MeanPtJPsi",fitMeanpt->GetParameter(16),fitMeanpt->GetParError(16));
5954   Set("MeanPtPsiP",fitMeanpt->GetParameter(20),fitMeanpt->GetParError(20));
5955
5956 }
5957
5958 //_____________________________________________________________________________
5959 void AliAnalysisMuMuJpsiResult::FitMPTPSIPSIPRIMENA60NEWPOL2EXP_BKGMPTPOL2EXP()
5960 {
5961   //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
5962   fHisto->GetListOfFunctions()->Delete();
5963
5964   Double_t p1Left = GetValue("p1LJPsi");
5965   Double_t p2Left = GetValue("p2LJPsi");
5966   Double_t p3Left = GetValue("p3LJPsi");
5967   Double_t p1Right = GetValue("p1RJPsi");
5968   Double_t p2Right = GetValue("p2RJPsi");
5969   Double_t p3Right = GetValue("p3RJPsi");
5970
5971   Double_t alphaLeft = GetValue("aLJPsi");
5972   Double_t alphaRight = GetValue("aRJPsi");
5973
5974   Double_t pol0 = GetValue("pol0");
5975   Double_t pol1 = GetValue("pol1");
5976   Double_t pol2 = GetValue("pol2");
5977   Double_t exp = GetValue("exp");
5978   Double_t kJPsi = GetValue("kJPsi");
5979   Double_t kPsiP = GetValue("kPsiP");
5980   Double_t mJPsi = GetValue("mJPsi");
5981   Double_t sJPsi = GetValue("sJPsi");
5982   Double_t NofJPsi = GetValue("NofJPsi");
5983   Double_t ErrStatNofJPsi = GetErrorStat("NofJPsi");
5984
5985   Double_t fitRangeLow = GetValue(kFitRangeLow);
5986   Double_t fitRangeHigh = GetValue(kFitRangeHigh);
5987
5988   //  TString msg;
5989   //
5990   //  if (IsValidValue(alphaLow)) msg += TString::Format("alphaLow=%e ",alphaLow);
5991   //  if (IsValidValue(nLow)) msg += TString::Format("nLow=%e ",nLow);
5992   //  if (IsValidValue(alphaUp)) msg += TString::Format("alphaUp=%e ",alphaUp);
5993   //  if (IsValidValue(nUp)) msg += TString::Format("nUp=%e ",nUp);
5994   //
5995   //  AliDebug(1,Form("Mean pt fit with jpsi + psiprime (CB2),Bkg VWG and Pol2 for Bkg <pt> %s",msg.Data()));
5996   //
5997   //  TF1* fitTotal = new TF1("signal+bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2VWG,fitRangeLow,fitRangeHigh,17,"AliAnalysisMuMuJpsiResult","FitFunctionTotalTwoCB2VWG");
5998   //
5999   //TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
6000
6001
6002   //  TString resultName(Form("MEANPTFIT_%salphalow=%5.2fnlow=%5.2falphaup=%5.2fnup=%5.2f",fitName.Data(),par[7],par[8],par[9],par[10]));
6003   TProfile* p(0x0);
6004   if ( fHisto->IsA() == TProfile::Class() ) p = static_cast<TProfile*>(fHisto);
6005   else
6006   {
6007     AliError("Mean pt histo has to be a TProfile");
6008     return;
6009   }
6010
6011   //_____________
6012   Int_t minBin = p->FindBin(fitRangeLow);
6013   Int_t maxBin = p->FindBin(fitRangeHigh);
6014
6015   for ( Int_t i = minBin ; i <= maxBin ; i++ )
6016   {
6017     if ( p->GetBinEffectiveEntries(i) < 10 )
6018     {
6019       Double_t effEntries(0.),sumErr(0.);
6020       for ( Int_t j = i - 5 ; j < i ; j++ )
6021       {
6022         if ( j <= 0 ) continue;
6023         //        if ( j > p->GetNbinsX() ) break;
6024
6025         effEntries += p->GetBinEffectiveEntries(j);
6026         sumErr += p->GetBinEffectiveEntries(j)*p->GetBinError(j);
6027       }
6028
6029       Double_t meanErr = sumErr/effEntries;
6030
6031       if ( p->GetBinError(i) < meanErr/2. )
6032       {
6033         std::cout << "Resetting bin " << i << " error" <<std::endl;
6034         p->SetBinError(i,meanErr);
6035       }
6036     }
6037   }
6038   //_____________
6039
6040   TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2Exp,fitRangeLow,fitRangeHigh,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2Exp");
6041
6042   bck->SetParameters(2.8,-0.5,0.2,0.05);
6043
6044   bck->SetParLimits(0, 1.,10.0);
6045   //  TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2Exp,fitRangeLow,fitRangeHigh,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2Exp");
6046   //
6047   //  bck->SetParameters(1,0,0,0);
6048
6049   SetFitRejectRange(2.3,4.0);
6050
6051   p->Fit(bck,"SER","",fitRangeLow,fitRangeHigh);
6052
6053   SetFitRejectRange();
6054
6055
6056   TF1* fitMeanpt = new TF1("fitMeanpt",this,&AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2NA60NEWPOL2EXPPOL2EXP,fitRangeLow,fitRangeHigh,22,"AliAnalysisMuMuJpsiResult","FitFunctionMeanPtS2NA60NEWPOL2EXPPOL2EXP");
6057
6058   fitMeanpt->SetParNames("pol0","pol1","pol2","exp","kJPsi","mJPsi","sJPsi","p1LJPsi","p2LJPsi","p3LJPsi","p1RJPsi");
6059   fitMeanpt->SetParName(11,"p2RJPsi");
6060   fitMeanpt->SetParName(12,"p3RJPsi");
6061   fitMeanpt->SetParName(13,"aLJPsi");
6062   fitMeanpt->SetParName(14,"aRJPsi");
6063   fitMeanpt->SetParName(15,"kPsiP");
6064   fitMeanpt->SetParName(16,"<pt>JPsi");
6065   fitMeanpt->SetParName(17,"<pt>BG0");
6066   fitMeanpt->SetParName(18,"<pt>BG1");
6067   fitMeanpt->SetParName(19,"<pt>BG2");
6068   fitMeanpt->SetParName(20,"<pt>BGEXP");
6069   fitMeanpt->SetParName(21,"<pt>PsiP");
6070
6071   fitMeanpt->FixParameter(0,pol0);
6072   fitMeanpt->FixParameter(1,pol1);
6073   fitMeanpt->FixParameter(2,pol2);
6074   fitMeanpt->FixParameter(3,exp);
6075   fitMeanpt->FixParameter(4,kJPsi);
6076   fitMeanpt->FixParameter(5,mJPsi);
6077   fitMeanpt->FixParameter(6,sJPsi);
6078   fitMeanpt->FixParameter(7,p1Left);
6079   fitMeanpt->FixParameter(8,p2Left);
6080   fitMeanpt->FixParameter(9,p3Left);
6081   fitMeanpt->FixParameter(10,p1Right);
6082   fitMeanpt->FixParameter(11,p2Right);
6083   fitMeanpt->FixParameter(12,p3Right);
6084   fitMeanpt->FixParameter(13,alphaLeft);
6085   fitMeanpt->FixParameter(14,alphaRight);
6086
6087   fitMeanpt->FixParameter(15,kPsiP);
6088
6089   fitMeanpt->SetParameter(16, 3.);
6090   fitMeanpt->SetParLimits(16, 1.0,5.);
6091
6092   for ( Int_t i = 0; i < 4; ++i )
6093   {
6094     fitMeanpt->SetParameter(i + 17, bck->GetParameter(i));
6095   }
6096
6097   //  fitMeanpt->SetParameter(13, 3.);
6098   //  fitMeanpt->SetParLimits(13, 0.5,10.);
6099   //
6100   //  fitMeanpt->SetParameter(14, 0.2);
6101   //  //  fitMeanpt->SetParLimits(14, 0.1,0.2);
6102   //
6103   //  fitMeanpt->SetParameter(15, 0.1);
6104   //  //  fitMeanpt->SetParLimits(15, 0.,1.);
6105
6106   fitMeanpt->SetParameter(21, 3.);
6107   Double_t psipPtLim = 10.;
6108   fitMeanpt->SetParLimits(21, 0.,psipPtLim);
6109
6110
6111
6112   //  TProfile::Approximate();
6113
6114   const char* fitOption = "SER"; //+";//SER
6115
6116   TFitResultPtr fitResult = p->Fit(fitMeanpt,fitOption,"");
6117
6118   std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
6119
6120   if ( static_cast<int>(fitResult) )
6121   {
6122     for ( Int_t i = 0; i < 4; ++i )
6123     {
6124       fitMeanpt->SetParameter(i + 17, bck->GetParameter(i)*0.9);
6125     }
6126     fitResult = p->Fit(fitMeanpt,fitOption,"");
6127
6128     std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
6129   }
6130   else if ( fitMeanpt->GetParameter(21) <= fitMeanpt->GetParError(21) || fitMeanpt->GetParError(21) >= 0.75*fitMeanpt->GetParameter(21) || (fitMeanpt->GetParameter(21)/psipPtLim > 0.9) )
6131   {
6132     fitMeanpt->FixParameter(21, bck->Eval(3.68));
6133     for ( Int_t i = 0; i < 4; ++i )
6134     {
6135       fitMeanpt->SetParameter(i + 17, bck->GetParameter(i)*0.6);
6136     }
6137     fitResult = p->Fit(fitMeanpt,fitOption,"");
6138
6139     std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
6140   }
6141   if ( fitMeanpt->GetParameter(17) <= fitMeanpt->GetParError(17) || fitMeanpt->GetParError(17) >= 0.75*fitMeanpt->GetParameter(13) )
6142   {
6143     fitMeanpt->SetParameter(17, 2.);
6144
6145     fitResult = p->Fit(fitMeanpt,fitOption,"");
6146
6147     std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
6148   }
6149
6150   //  TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
6151
6152   bck->SetParameters(fitMeanpt->GetParameter(17),fitMeanpt->GetParameter(18),fitMeanpt->GetParameter(19),fitMeanpt->GetParameter(20));
6153
6154   AttachFunctionsToHisto(0x0,bck,fitMeanpt,fitRangeLow,fitRangeHigh);//
6155
6156   Set("NofJPsi",NofJPsi,ErrStatNofJPsi);
6157   Set("MeanPtJPsi",fitMeanpt->GetParameter(16),fitMeanpt->GetParError(16));
6158   Set("MeanPtPsiP",fitMeanpt->GetParameter(21),fitMeanpt->GetParError(21));
6159
6160 }
6161
6162 //_____________________________________________________________________________
6163 void AliAnalysisMuMuJpsiResult::FitMPTPSIPSIPRIMECB2VWG_BKGMPTPOL3()
6164 {
6165   //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
6166   fHisto->GetListOfFunctions()->Delete();
6167
6168   Double_t alphaLow = GetValue("alJPsi");
6169   Double_t nLow = GetValue("nlJPsi");
6170   Double_t alphaUp = GetValue("auJPsi");
6171   Double_t nUp = GetValue("nuJPsi");
6172
6173   Double_t kVWG = GetValue("kVWG");
6174   Double_t mVWG = GetValue("mVWG");
6175   Double_t sVWG1 = GetValue("sVWG1");
6176   Double_t sVWG2 = GetValue("sVWG2");
6177   Double_t kJPsi = GetValue("kJPsi");
6178   Double_t kPsiP = GetValue("kPsiP");
6179   Double_t mJPsi = GetValue("mJPsi");
6180   Double_t sJPsi = GetValue("sJPsi");
6181   Double_t NofJPsi = GetValue("NofJPsi");
6182   Double_t ErrStatNofJPsi = GetErrorStat("NofJPsi");
6183
6184   Double_t fitRangeLow = GetValue(kFitRangeLow);
6185   Double_t fitRangeHigh = GetValue(kFitRangeHigh);
6186
6187   //  TString msg;
6188   //
6189   //  if (IsValidValue(alphaLow)) msg += TString::Format("alphaLow=%e ",alphaLow);
6190   //  if (IsValidValue(nLow)) msg += TString::Format("nLow=%e ",nLow);
6191   //  if (IsValidValue(alphaUp)) msg += TString::Format("alphaUp=%e ",alphaUp);
6192   //  if (IsValidValue(nUp)) msg += TString::Format("nUp=%e ",nUp);
6193   //
6194   //  AliDebug(1,Form("Mean pt fit with jpsi + psiprime (CB2),Bkg VWG and Pol2 for Bkg <pt> %s",msg.Data()));
6195   //
6196   //  TF1* fitTotal = new TF1("signal+bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2VWG,fitRangeLow,fitRangeHigh,17,"AliAnalysisMuMuJpsiResult","FitFunctionTotalTwoCB2VWG");
6197   //
6198   //TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
6199
6200
6201   //  TString resultName(Form("MEANPTFIT_%salphalow=%5.2fnlow=%5.2falphaup=%5.2fnup=%5.2f",fitName.Data(),par[7],par[8],par[9],par[10]));
6202   TProfile* p(0x0);
6203   if ( fHisto->IsA() == TProfile::Class() ) p = static_cast<TProfile*>(fHisto);
6204   else
6205   {
6206     AliError("Mean pt histo has to be a TProfile");
6207     return;
6208   }
6209
6210   //_____________
6211   Int_t minBin = p->FindBin(fitRangeLow);
6212   Int_t maxBin = p->FindBin(fitRangeHigh);
6213
6214   for ( Int_t i = minBin ; i <= maxBin ; i++ )
6215   {
6216     if ( p->GetBinEffectiveEntries(i) < 10 )
6217     {
6218       Double_t effEntries(0.),sumErr(0.);
6219       for ( Int_t j = i - 5 ; j < i ; j++ )
6220       {
6221         if ( j <= 0 ) continue;
6222         //        if ( j > p->GetNbinsX() ) break;
6223
6224         effEntries += p->GetBinEffectiveEntries(j);
6225         sumErr += p->GetBinEffectiveEntries(j)*p->GetBinError(j);
6226       }
6227
6228       Double_t meanErr = sumErr/effEntries;
6229
6230       if ( p->GetBinError(i) < meanErr/2. )
6231       {
6232         std::cout << "Resetting bin " << i << " error" <<std::endl;
6233         p->SetBinError(i,meanErr);
6234       }
6235     }
6236   }
6237   //_____________
6238
6239   TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol3,fitRangeLow,fitRangeHigh,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol3");
6240
6241   bck->SetParameters(3.,1.,-0.4,0.05);
6242
6243   bck->SetParLimits(0, 1.,8.0);
6244   //  TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2Exp,fitRangeLow,fitRangeHigh,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2Exp");
6245   //
6246   //  bck->SetParameters(1,0,0,0);
6247
6248   SetFitRejectRange(2.3,4.0);
6249
6250   p->Fit(bck,"SER","",fitRangeLow,fitRangeHigh);
6251
6252   SetFitRejectRange();
6253
6254
6255
6256   TF1* fitMeanpt = new TF1("fitMeanpt",this,&AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2CB2VWGPOL3,fitRangeLow,fitRangeHigh,18,"AliAnalysisMuMuJpsiResult","FitFunctionMeanPtS2CB2VWGPOL3");
6257
6258   fitMeanpt->SetParNames("kVWG","mVWG","sVWG1","sVWG2","kJPsi","mJPsi","sJPsi","alJPsi","nlJPsi","auJPsi","nuJPsi");
6259   fitMeanpt->SetParName(11,"kPsiP");
6260   fitMeanpt->SetParName(12,"<pt>JPsi");
6261   fitMeanpt->SetParName(13,"<pt>BG0");
6262   fitMeanpt->SetParName(14,"<pt>BG1");
6263   fitMeanpt->SetParName(15,"<pt>BG2");
6264   fitMeanpt->SetParName(16,"<pt>BG3");
6265   fitMeanpt->SetParName(17,"<pt>PsiP");
6266
6267   fitMeanpt->FixParameter(0,kVWG);
6268   fitMeanpt->FixParameter(1,mVWG);
6269   fitMeanpt->FixParameter(2,sVWG1);
6270   fitMeanpt->FixParameter(3,sVWG2);
6271   fitMeanpt->FixParameter(4,kJPsi);
6272   fitMeanpt->FixParameter(5,mJPsi);
6273   fitMeanpt->FixParameter(6,sJPsi);
6274   fitMeanpt->FixParameter(7,alphaLow);
6275   fitMeanpt->FixParameter(8,nLow);
6276   fitMeanpt->FixParameter(9,alphaUp);
6277   fitMeanpt->FixParameter(10,nUp);
6278   fitMeanpt->FixParameter(11,kPsiP);
6279
6280   fitMeanpt->SetParameter(12, 3.);
6281   fitMeanpt->SetParLimits(12, 1.0,5.);
6282
6283   for ( Int_t i = 0; i < 4; ++i )
6284   {
6285     fitMeanpt->SetParameter(i + 13, bck->GetParameter(i));
6286   }
6287
6288   //  fitMeanpt->SetParameter(13, 3.);
6289   //  fitMeanpt->SetParLimits(13, 0.5,10.);
6290   //
6291   //  fitMeanpt->SetParameter(14, 0.2);
6292   //  //  fitMeanpt->SetParLimits(14, 0.1,0.2);
6293   //
6294   //  fitMeanpt->SetParameter(15, 0.1);
6295   //  //  fitMeanpt->SetParLimits(15, 0.,1.);
6296
6297   fitMeanpt->SetParameter(17, 3.);
6298   fitMeanpt->SetParLimits(17, 0.,10.);
6299
6300
6301   //  TProfile::Approximate();
6302
6303   const char* fitOption = "SER"; //+";//SER
6304
6305   TFitResultPtr fitResult = p->Fit(fitMeanpt,fitOption,"");
6306
6307   std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
6308
6309   if ( static_cast<int>(fitResult) )
6310   {
6311     for ( Int_t i = 0; i < 4; ++i )
6312     {
6313       fitMeanpt->SetParameter(i + 13, bck->GetParameter(i)*0.9);
6314     }
6315     fitResult = p->Fit(fitMeanpt,fitOption,"");
6316
6317     std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
6318   }
6319   else if ( fitMeanpt->GetParameter(17) <= fitMeanpt->GetParError(17) || fitMeanpt->GetParError(17) >= 0.75*fitMeanpt->GetParameter(17) )
6320   {
6321     fitMeanpt->FixParameter(17, 0.);
6322     for ( Int_t i = 0; i < 4; ++i )
6323     {
6324       fitMeanpt->SetParameter(i + 13, bck->GetParameter(i)*0.6);
6325     }
6326     fitResult = p->Fit(fitMeanpt,fitOption,"");
6327
6328     std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
6329   }
6330
6331   //  TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
6332
6333   bck->SetParameters(fitMeanpt->GetParameter(13),fitMeanpt->GetParameter(14),fitMeanpt->GetParameter(15),fitMeanpt->GetParameter(16));
6334
6335   AttachFunctionsToHisto(0x0,bck,fitMeanpt,fitRangeLow,fitRangeHigh);//
6336
6337   Set("NofJPsi",NofJPsi,ErrStatNofJPsi);
6338   Set("MeanPtJPsi",fitMeanpt->GetParameter(12),fitMeanpt->GetParError(12));
6339   Set("MeanPtPsiP",fitMeanpt->GetParameter(17),fitMeanpt->GetParError(17));
6340
6341 }
6342
6343 //_____________________________________________________________________________
6344 void AliAnalysisMuMuJpsiResult::FitMPTPSIPSIPRIMECB2VWG_BKGMPTLIN()
6345 {
6346   //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
6347   fHisto->GetListOfFunctions()->Delete();
6348
6349   Double_t alphaLow = GetValue("alJPsi");
6350   Double_t nLow = GetValue("nlJPsi");
6351   Double_t alphaUp = GetValue("auJPsi");
6352   Double_t nUp = GetValue("nuJPsi");
6353
6354   Double_t kVWG = GetValue("kVWG");
6355   Double_t mVWG = GetValue("mVWG");
6356   Double_t sVWG1 = GetValue("sVWG1");
6357   Double_t sVWG2 = GetValue("sVWG2");
6358   Double_t kJPsi = GetValue("kJPsi");
6359   Double_t kPsiP = GetValue("kPsiP");
6360   Double_t mJPsi = GetValue("mJPsi");
6361   Double_t sJPsi = GetValue("sJPsi");
6362   Double_t NofJPsi = GetValue("NofJPsi");
6363   Double_t ErrStatNofJPsi = GetErrorStat("NofJPsi");
6364
6365   Double_t fitRangeLow = GetValue(kFitRangeLow);
6366   Double_t fitRangeHigh = GetValue(kFitRangeHigh);
6367
6368   //  TString msg;
6369   //
6370   //  if (IsValidValue(alphaLow)) msg += TString::Format("alphaLow=%e ",alphaLow);
6371   //  if (IsValidValue(nLow)) msg += TString::Format("nLow=%e ",nLow);
6372   //  if (IsValidValue(alphaUp)) msg += TString::Format("alphaUp=%e ",alphaUp);
6373   //  if (IsValidValue(nUp)) msg += TString::Format("nUp=%e ",nUp);
6374   //
6375   //  AliDebug(1,Form("Mean pt fit with jpsi + psiprime (CB2),Bkg VWG and Pol2 for Bkg <pt> %s",msg.Data()));
6376   //
6377   //  TF1* fitTotal = new TF1("signal+bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2VWG,fitRangeLow,fitRangeHigh,17,"AliAnalysisMuMuJpsiResult","FitFunctionTotalTwoCB2VWG");
6378   //
6379   //TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
6380
6381
6382   //  TString resultName(Form("MEANPTFIT_%salphalow=%5.2fnlow=%5.2falphaup=%5.2fnup=%5.2f",fitName.Data(),par[7],par[8],par[9],par[10]));
6383
6384   TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundLin,fitRangeLow,fitRangeHigh,2,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundLin");
6385
6386   bck->SetParameters(3.,0.);
6387
6388   bck->SetParLimits(0, 2.0,4.0);
6389   //  TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2Exp,fitRangeLow,fitRangeHigh,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2Exp");
6390   //
6391   //  bck->SetParameters(1,0,0,0);
6392
6393   SetFitRejectRange(2.0,4.0);
6394
6395   fHisto->Fit(bck,"SER","",fitRangeLow,fitRangeHigh);
6396
6397   SetFitRejectRange();
6398
6399
6400
6401   TF1* fitMeanpt = new TF1("fitMeanpt",this,&AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2CB2Lin,fitRangeLow,fitRangeHigh,16,"AliAnalysisMuMuJpsiResult","FitFunctionMeanPtS2CB2Lin");
6402
6403   fitMeanpt->SetParNames("kVWG","mVWG","sVWG1","sVWG2","kJPsi","mJPsi","sJPsi","alJPsi","nlJPsi","auJPsi","nuJPsi");
6404   fitMeanpt->SetParName(11,"kPsiP");
6405   fitMeanpt->SetParName(12,"<pt>JPsi");
6406   fitMeanpt->SetParName(13,"<pt>BG0");
6407   fitMeanpt->SetParName(14,"<pt>BG1");
6408   fitMeanpt->SetParName(15,"<pt>PsiP");
6409
6410   fitMeanpt->FixParameter(0,kVWG);
6411   fitMeanpt->FixParameter(1,mVWG);
6412   fitMeanpt->FixParameter(2,sVWG1);
6413   fitMeanpt->FixParameter(3,sVWG2);
6414   fitMeanpt->FixParameter(4,kJPsi);
6415   fitMeanpt->FixParameter(5,mJPsi);
6416   fitMeanpt->FixParameter(6,sJPsi);
6417   fitMeanpt->FixParameter(7,alphaLow);
6418   fitMeanpt->FixParameter(8,nLow);
6419   fitMeanpt->FixParameter(9,alphaUp);
6420   fitMeanpt->FixParameter(10,nUp);
6421   fitMeanpt->FixParameter(11,kPsiP);
6422
6423   fitMeanpt->SetParameter(12, 3.);
6424   fitMeanpt->SetParLimits(12, 2.0,4.);
6425
6426   for ( Int_t i = 0; i < 2; ++i )
6427   {
6428     fitMeanpt->SetParameter(i + 13, bck->GetParameter(i));
6429   }
6430
6431   //  fitMeanpt->SetParameter(13, 3.);
6432   //  fitMeanpt->SetParLimits(13, 0.5,10.);
6433   //
6434   //  fitMeanpt->SetParameter(14, 0.2);
6435   //  //  fitMeanpt->SetParLimits(14, 0.1,0.2);
6436   //
6437   //  fitMeanpt->SetParameter(15, 0.1);
6438   //  //  fitMeanpt->SetParLimits(15, 0.,1.);
6439
6440   fitMeanpt->SetParameter(15, 3.);
6441   fitMeanpt->SetParLimits(15, 0.5,6.);
6442
6443
6444   //  TProfile::Approximate();
6445
6446   const char* fitOption = "SER"; //+";
6447
6448   TFitResultPtr fitResult = fHisto->Fit(fitMeanpt,fitOption,"");
6449
6450   //  TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
6451
6452   bck->SetParameters(fitMeanpt->GetParameter(13),fitMeanpt->GetParameter(14));
6453
6454   AttachFunctionsToHisto(0x0,bck,fitMeanpt,fitRangeLow,fitRangeHigh);//
6455
6456   Set("NofJPsi",NofJPsi,ErrStatNofJPsi);
6457   Set("MeanPtJPsi",fitMeanpt->GetParameter(12),fitMeanpt->GetParError(12));
6458   Set("MeanPtPsiP",fitMeanpt->GetParameter(15),fitMeanpt->GetParError(15));
6459
6460 }
6461
6462 //_____________________________________________________________________________
6463 void AliAnalysisMuMuJpsiResult::FitMPTPSIPSIPRIMECB2VWGINDEPTAILS_BKGMPTPOL2()
6464 {
6465   //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
6466   fHisto->GetListOfFunctions()->Delete();
6467
6468   Double_t alphaLow = GetValue("alJPsi");
6469   Double_t nLow = GetValue("nlJPsi");
6470   Double_t alphaUp = GetValue("auJPsi");
6471   Double_t nUp = GetValue("nuJPsi");
6472
6473   Double_t alphaLowP = GetValue("alPsiP");
6474   Double_t nLowP = GetValue("nlPsiP");
6475   Double_t alphaUpP = GetValue("auPsiP");
6476   Double_t nUpP = GetValue("nuPsiP");
6477
6478   Double_t kVWG = GetValue("kVWG");
6479   Double_t mVWG = GetValue("mVWG");
6480   Double_t sVWG1 = GetValue("sVWG1");
6481   Double_t sVWG2 = GetValue("sVWG2");
6482   Double_t kJPsi = GetValue("kJPsi");
6483   Double_t kPsiP = GetValue("kPsiP");
6484   Double_t mJPsi = GetValue("mJPsi");
6485   Double_t sJPsi = GetValue("sJPsi");
6486 //  Double_t mPsiP = GetValue("mPsiP");
6487 //  Double_t sPsiP = GetValue("sPsiP");
6488   Double_t NofJPsi = GetValue("NofJPsi");
6489   Double_t ErrStatNofJPsi = GetErrorStat("NofJPsi");
6490
6491   Double_t fitRangeLow = GetValue(kFitRangeLow);
6492   Double_t fitRangeHigh = GetValue(kFitRangeHigh);
6493
6494   //  TString msg;
6495   //
6496   //  if (IsValidValue(alphaLow)) msg += TString::Format("alphaLow=%e ",alphaLow);
6497   //  if (IsValidValue(nLow)) msg += TString::Format("nLow=%e ",nLow);
6498   //  if (IsValidValue(alphaUp)) msg += TString::Format("alphaUp=%e ",alphaUp);
6499   //  if (IsValidValue(nUp)) msg += TString::Format("nUp=%e ",nUp);
6500   //
6501   //  AliDebug(1,Form("Mean pt fit with jpsi + psiprime (CB2),Bkg VWG and Pol2 for Bkg <pt> %s",msg.Data()));
6502   //
6503   //  TF1* fitTotal = new TF1("signal+bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2VWG,fitRangeLow,fitRangeHigh,17,"AliAnalysisMuMuJpsiResult","FitFunctionTotalTwoCB2VWG");
6504   //
6505   //  TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2Exp,fitRangeLow,fitRangeHigh,5,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2Exp");
6506
6507
6508   //  TString resultName(Form("MEANPTFIT_%salphalow=%5.2fnlow=%5.2falphaup=%5.2fnup=%5.2f",fitName.Data(),par[7],par[8],par[9],par[10]));
6509
6510   TF1* fitMeanpt = new TF1("fitMeanpt",this,&AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2CB2VWGPOL2INDEPTAILS,fitRangeLow,fitRangeHigh,21,"AliAnalysisMuMuJpsiResult","FitFunctionMeanPtS2CB2VWGPOL2INDEPTAILS");
6511
6512   fitMeanpt->SetParNames("kVWG","mVWG","sVWG1","sVWG2","kJPsi","mJPsi","sJPsi","alJPsi","nlJPsi","auJPsi","nuJPsi");
6513   fitMeanpt->SetParName(11,"kPsiP");
6514 //  fitMeanpt->SetParName(12,"mPsiP");
6515 //  fitMeanpt->SetParName(13,"sPsiP");
6516   fitMeanpt->SetParName(12,"alPsiP");
6517   fitMeanpt->SetParName(13,"nlPsiP");
6518   fitMeanpt->SetParName(14,"auPsiP");
6519   fitMeanpt->SetParName(15,"nuPsiP");
6520   fitMeanpt->SetParName(16,"<pt>JPsi");//12
6521   fitMeanpt->SetParName(17,"<pt>BG0");//13
6522   fitMeanpt->SetParName(18,"<pt>BG1");//14
6523   fitMeanpt->SetParName(19,"<pt>BG2");//15
6524   fitMeanpt->SetParName(20,"<pt>PsiP");//16
6525
6526   fitMeanpt->FixParameter(0,kVWG);
6527   fitMeanpt->FixParameter(1,mVWG);
6528   fitMeanpt->FixParameter(2,sVWG1);
6529   fitMeanpt->FixParameter(3,sVWG2);
6530   fitMeanpt->FixParameter(4,kJPsi);
6531   fitMeanpt->FixParameter(5,mJPsi);
6532   fitMeanpt->FixParameter(6,sJPsi);
6533   fitMeanpt->FixParameter(7,alphaLow);
6534   fitMeanpt->FixParameter(8,nLow);
6535   fitMeanpt->FixParameter(9,alphaUp);
6536   fitMeanpt->FixParameter(10,nUp);
6537   fitMeanpt->FixParameter(11,kPsiP);
6538 //  fitMeanpt->FixParameter(12,mPsiP);
6539 //  fitMeanpt->FixParameter(13,sPsiP);
6540   fitMeanpt->FixParameter(12,alphaLowP);
6541   fitMeanpt->FixParameter(13,nLowP);
6542   fitMeanpt->FixParameter(14,alphaUpP);
6543   fitMeanpt->FixParameter(15,nUpP);
6544
6545   fitMeanpt->SetParameter(16, 3.);
6546   fitMeanpt->SetParLimits(16, 2.,3.);
6547
6548   fitMeanpt->SetParameter(17, 1.);
6549   //  fitMeanpt->SetParLimits(13, 0.01,1.5);
6550
6551   fitMeanpt->SetParameter(18, 0.2);
6552   //  fitMeanpt->SetParLimits(14, 0.1,0.2);
6553
6554   fitMeanpt->SetParameter(19, 0.1);
6555   //  fitMeanpt->SetParLimits(15, 0.,1.);
6556
6557   fitMeanpt->SetParameter(20, 3.);
6558   fitMeanpt->SetParLimits(20, 2.5,8.);
6559
6560
6561
6562   const char* fitOption = "SER"; //+";
6563
6564   TFitResultPtr fitResult = fHisto->Fit(fitMeanpt,fitOption,"");
6565
6566   TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
6567
6568   bck->SetParameters(fitMeanpt->GetParameter(17),fitMeanpt->GetParameter(18),fitMeanpt->GetParameter(19));
6569
6570   AttachFunctionsToHisto(0x0,bck,fitMeanpt,fitRangeLow,fitRangeHigh);
6571
6572   Set("NofJPsi",NofJPsi,ErrStatNofJPsi);
6573   Set("MeanPtJPsi",fitMeanpt->GetParameter(16),fitMeanpt->GetParError(16));
6574   Set("MeanPtPsiP",fitMeanpt->GetParameter(20),fitMeanpt->GetParError(20));
6575
6576 }
6577
6578 ////_____________________________________________________________________________
6579 //void AliAnalysisMuMuJpsiResult::FitMPT2CB2VWG_BKGMPTPOL2EXP()
6580 //{
6581 //  //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
6582 //  fHisto->GetListOfFunctions()->Delete();
6583 //
6584 //  Double_t alphaLow = GetValue("alJPsi");
6585 //  Double_t nLow = GetValue("nlJPsi");
6586 //  Double_t alphaUp = GetValue("auJPsi");
6587 //  Double_t nUp = GetValue("nuJPsi");
6588 //
6589 //  Double_t kVWG = GetValue("kVWG");
6590 //  Double_t mVWG = GetValue("mVWG");
6591 //  Double_t sVWG1 = GetValue("sVWG1");
6592 //  Double_t sVWG2 = GetValue("sVWG2");
6593 //  Double_t kJPsi = GetValue("kJPsi");
6594 //  Double_t kPsiP = GetValue("kPsiP");
6595 //  Double_t mJPsi = GetValue("mJPsi");
6596 //  Double_t sJPsi = GetValue("sJPsi");
6597 //  Double_t NofJPsi = GetValue("NofJPsi");
6598 //  Double_t ErrStatNofJPsi = GetErrorStat("NofJPsi");
6599 //
6600 //  Double_t fitRangeLow = GetValue(kFitRangeLow);
6601 //  Double_t fitRangeHigh = GetValue(kFitRangeHigh);
6602 //
6603 //  //  TString msg;
6604 //  //
6605 //  //  if (IsValidValue(alphaLow)) msg += TString::Format("alphaLow=%e ",alphaLow);
6606 //  //  if (IsValidValue(nLow)) msg += TString::Format("nLow=%e ",nLow);
6607 //  //  if (IsValidValue(alphaUp)) msg += TString::Format("alphaUp=%e ",alphaUp);
6608 //  //  if (IsValidValue(nUp)) msg += TString::Format("nUp=%e ",nUp);
6609 //  //
6610 //  //  AliDebug(1,Form("Mean pt fit with jpsi + psiprime (CB2),Bkg VWG and Pol2 for Bkg <pt> %s",msg.Data()));
6611 //  //
6612 //  //  TF1* fitTotal = new TF1("signal+bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2VWG,fitRangeLow,fitRangeHigh,17,"AliAnalysisMuMuJpsiResult","FitFunctionTotalTwoCB2VWG");
6613 //  //
6614 //  //TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
6615 //
6616 //
6617 //  //  TString resultName(Form("MEANPTFIT_%salphalow=%5.2fnlow=%5.2falphaup=%5.2fnup=%5.2f",fitName.Data(),par[7],par[8],par[9],par[10]));
6618 //
6619 //  TF1* fitMeanpt = new TF1("fitMeanpt",this,&AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2CB2VWGPOL2EXP,fitRangeLow,fitRangeHigh,17,"AliAnalysisMuMuJpsiResult","FitFunctionMeanPtS2CB2VWGPOL2EXP");
6620 //
6621 //  fitMeanpt->SetParNames("kVWG","mVWG","sVWG1","sVWG2","kJPsi","mJPsi","sJPsi","alJPsi","nlJPsi","auJPsi","nuJPsi");
6622 //  fitMeanpt->SetParName(11,"kPsiP");
6623 //  fitMeanpt->SetParName(12,"<pt>JPsi");
6624 //  fitMeanpt->SetParName(13,"<pt>BG0");
6625 //  fitMeanpt->SetParName(14,"<pt>BG1");
6626 //  fitMeanpt->SetParName(15,"<pt>BG2");
6627 //  fitMeanpt->SetParName(16,"<pt>PsiP");
6628 //
6629 //  fitMeanpt->FixParameter(0,kVWG);
6630 //  fitMeanpt->FixParameter(1,mVWG);
6631 //  fitMeanpt->FixParameter(2,sVWG1);
6632 //  fitMeanpt->FixParameter(3,sVWG2);
6633 //  fitMeanpt->FixParameter(4,kJPsi);
6634 //  fitMeanpt->FixParameter(5,mJPsi);
6635 //  fitMeanpt->FixParameter(6,sJPsi);
6636 //  fitMeanpt->FixParameter(7,alphaLow);
6637 //  fitMeanpt->FixParameter(8,nLow);
6638 //  fitMeanpt->FixParameter(9,alphaUp);
6639 //  fitMeanpt->FixParameter(10,nUp);
6640 //  fitMeanpt->FixParameter(11,kPsiP);
6641 //
6642 //  fitMeanpt->SetParameter(12, 3.);
6643 //  fitMeanpt->SetParLimits(12, 2.0,4.);
6644 //
6645 //  fitMeanpt->SetParameter(13, 3.);
6646 //  fitMeanpt->SetParLimits(13, 3.,10.);
6647 //
6648 //  fitMeanpt->SetParameter(14, 0.2);
6649 //  //  fitMeanpt->SetParLimits(14, 0.1,0.2);
6650 //
6651 //  fitMeanpt->SetParameter(15, 0.1);
6652 //  //  fitMeanpt->SetParLimits(15, 0.,1.);
6653 //
6654 //  fitMeanpt->SetParameter(16, 3.);
6655 //  fitMeanpt->SetParLimits(16, 1.5,6.);
6656 //
6657 //
6658 //  TProfile::Approximate();
6659 //
6660 //  const char* fitOption = "SER"; //+";
6661 //
6662 //  TFitResultPtr fitResult = fHisto->Fit(fitMeanpt,fitOption,"");
6663 //
6664 //  TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2Exp,fitRangeLow,fitRangeHigh,5,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2Exp");
6665 //
6666 //  bck->SetParameters(fitMeanpt->GetParameter(13),fitMeanpt->GetParameter(14),fitMeanpt->GetParameter(15));
6667 //
6668 //  AttachFunctionsToHisto(0x0,bck,fitMeanpt,fitRangeLow,fitRangeHigh);
6669 //
6670 //  Set("NofJPsi",NofJPsi,ErrStatNofJPsi);
6671 //  Set("MeanPtJPsi",fitMeanpt->GetParameter(12),fitMeanpt->GetParError(12));
6672 //  Set("MeanPtPsiP",fitMeanpt->GetParameter(16),fitMeanpt->GetParError(16));
6673 //
6674 //}
6675
6676 //_____________________________________________________________________________
6677 void AliAnalysisMuMuJpsiResult::FitMPTPSIPSIPRIMECB2VWG_BKGMPTPOL4()
6678 {
6679   //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
6680   //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
6681   fHisto->GetListOfFunctions()->Delete();
6682
6683   Double_t alphaLow = GetValue("alJPsi");
6684   Double_t nLow = GetValue("nlJPsi");
6685   Double_t alphaUp = GetValue("auJPsi");
6686   Double_t nUp = GetValue("nuJPsi");
6687
6688   Double_t kVWG = GetValue("kVWG");
6689   Double_t mVWG = GetValue("mVWG");
6690   Double_t sVWG1 = GetValue("sVWG1");
6691   Double_t sVWG2 = GetValue("sVWG2");
6692   Double_t kJPsi = GetValue("kJPsi");
6693   Double_t kPsiP = GetValue("kPsiP");
6694   Double_t mJPsi = GetValue("mJPsi");
6695   Double_t sJPsi = GetValue("sJPsi");
6696   Double_t NofJPsi = GetValue("NofJPsi");
6697   Double_t ErrStatNofJPsi = GetErrorStat("NofJPsi");
6698
6699   Double_t fitRangeLow = GetValue(kFitRangeLow);
6700   Double_t fitRangeHigh = GetValue(kFitRangeHigh);
6701
6702   //  TString msg;
6703   //
6704   //  if (IsValidValue(alphaLow)) msg += TString::Format("alphaLow=%e ",alphaLow);
6705   //  if (IsValidValue(nLow)) msg += TString::Format("nLow=%e ",nLow);
6706   //  if (IsValidValue(alphaUp)) msg += TString::Format("alphaUp=%e ",alphaUp);
6707   //  if (IsValidValue(nUp)) msg += TString::Format("nUp=%e ",nUp);
6708   //
6709   //  AliDebug(1,Form("Mean pt fit with jpsi + psiprime (CB2),Bkg VWG and Pol2 for Bkg <pt> %s",msg.Data()));
6710   //
6711   //  TF1* fitTotal = new TF1("signal+bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2VWG,fitRangeLow,fitRangeHigh,17,"AliAnalysisMuMuJpsiResult","FitFunctionTotalTwoCB2VWG");
6712   //
6713   //TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
6714
6715
6716   //  TString resultName(Form("MEANPTFIT_%salphalow=%5.2fnlow=%5.2falphaup=%5.2fnup=%5.2f",fitName.Data(),par[7],par[8],par[9],par[10]));
6717   TProfile* p(0x0);
6718   if ( fHisto->IsA() == TProfile::Class() ) p = static_cast<TProfile*>(fHisto);
6719   else
6720   {
6721     AliError("Mean pt histo has to be a TProfile");
6722     return;
6723   }
6724
6725   //_____________
6726   Int_t minBin = p->FindBin(fitRangeLow);
6727   Int_t maxBin = p->FindBin(fitRangeHigh);
6728
6729   for ( Int_t i = minBin ; i <= maxBin ; i++ )
6730   {
6731     if ( p->GetBinEffectiveEntries(i) < 10 )
6732     {
6733       Double_t effEntries(0.),sumErr(0.);
6734       for ( Int_t j = i - 5 ; j < i ; j++ )
6735       {
6736         if ( j <= 0 ) continue;
6737         //        if ( j > p->GetNbinsX() ) break;
6738
6739         effEntries += p->GetBinEffectiveEntries(j);
6740         sumErr += p->GetBinEffectiveEntries(j)*p->GetBinError(j);
6741       }
6742
6743       Double_t meanErr = sumErr/effEntries;
6744
6745       if ( p->GetBinError(i) < meanErr/2. )
6746       {
6747         std::cout << "Resetting bin " << i << " error" <<std::endl;
6748         p->SetBinError(i,meanErr);
6749       }
6750     }
6751   }
6752   //_____________
6753
6754   TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol4,fitRangeLow,fitRangeHigh,5,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol4");
6755
6756   bck->SetParameters(3.,-0.5,-0.5,1.5,-0.01);
6757
6758   bck->SetParLimits(0, 1.,8.0);
6759
6760   SetFitRejectRange(2.7,4.0);
6761
6762   p->Fit(bck,"SER","");
6763
6764   SetFitRejectRange();
6765
6766   TF1* fitMeanpt = new TF1("fitMeanpt",this,&AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2CB2VWGPOL4,fitRangeLow,fitRangeHigh,19,"AliAnalysisMuMuJpsiResult","FitFunctionMeanPtS2CB2VWGPOL4");
6767
6768   fitMeanpt->SetParNames("kVWG","mVWG","sVWG1","sVWG2","kJPsi","mJPsi","sJPsi","alJPsi","nlJPsi","auJPsi","nuJPsi");
6769   fitMeanpt->SetParName(11,"kPsiP");
6770   fitMeanpt->SetParName(12,"<pt>JPsi");
6771   fitMeanpt->SetParName(13,"<pt>BG0");
6772   fitMeanpt->SetParName(14,"<pt>BG1");
6773   fitMeanpt->SetParName(15,"<pt>BG2");
6774   fitMeanpt->SetParName(16,"<pt>BG3");
6775   fitMeanpt->SetParName(17,"<pt>BG4");
6776   fitMeanpt->SetParName(18,"<pt>PsiP");
6777
6778   fitMeanpt->FixParameter(0,kVWG);
6779   fitMeanpt->FixParameter(1,mVWG);
6780   fitMeanpt->FixParameter(2,sVWG1);
6781   fitMeanpt->FixParameter(3,sVWG2);
6782   fitMeanpt->FixParameter(4,kJPsi);
6783   fitMeanpt->FixParameter(5,mJPsi);
6784   fitMeanpt->FixParameter(6,sJPsi);
6785   fitMeanpt->FixParameter(7,alphaLow);
6786   fitMeanpt->FixParameter(8,nLow);
6787   fitMeanpt->FixParameter(9,alphaUp);
6788   fitMeanpt->FixParameter(10,nUp);
6789   fitMeanpt->FixParameter(11,kPsiP);
6790
6791   fitMeanpt->SetParameter(12, 3.);
6792   fitMeanpt->SetParLimits(12, 2.0,4.);
6793
6794   for ( Int_t i = 0; i < 5; ++i )
6795   {
6796     fitMeanpt->SetParameter(i + 13, bck->GetParameter(i));
6797   }
6798
6799   fitMeanpt->SetParameter(18, 3.);
6800   fitMeanpt->SetParLimits(18, 0.,10.);
6801
6802   const char* fitOption = "SER"; //+";//SER
6803
6804   TFitResultPtr fitResult = p->Fit(fitMeanpt,fitOption,"");
6805
6806   std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
6807
6808   if ( static_cast<int>(fitResult) )
6809   {
6810     for ( Int_t i = 0; i < 5; ++i )
6811     {
6812       fitMeanpt->SetParameter(i + 13, bck->GetParameter(i)*0.9);
6813     }
6814     fitResult = p->Fit(fitMeanpt,fitOption,"");
6815
6816     std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
6817   }
6818   else if ( fitMeanpt->GetParameter(18) <= fitMeanpt->GetParError(18) || fitMeanpt->GetParError(18) >= 0.75*fitMeanpt->GetParameter(18) )
6819   {
6820     fitMeanpt->FixParameter(18, 0.);
6821     for ( Int_t i = 0; i < 5; ++i )
6822     {
6823       fitMeanpt->SetParameter(i + 13, bck->GetParameter(i)*0.6);
6824     }
6825     fitResult = p->Fit(fitMeanpt,fitOption,"");
6826
6827     std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
6828   }
6829
6830   for ( Int_t i = 0; i < 5; ++i )
6831   {
6832     bck->SetParameter(i, fitMeanpt->GetParameter(i+13));
6833   }
6834
6835   AttachFunctionsToHisto(0x0,bck,fitMeanpt,fitRangeLow,fitRangeHigh);//
6836
6837   Set("NofJPsi",NofJPsi,ErrStatNofJPsi);
6838   Set("MeanPtJPsi",fitMeanpt->GetParameter(12),fitMeanpt->GetParError(12));
6839   Set("MeanPtPsiP",fitMeanpt->GetParameter(16),fitMeanpt->GetParError(16));
6840
6841 }
6842
6843 //Int_t iparMinv[12] ={0,1,2,3,4,5,6,7,8,9,10,11};
6844 //Int_t iparMpt[17] ={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
6845 //
6846 //struct GlobalChi2 {
6847 //  GlobalChi2(  vector< ROOT::Fit::Chi2Function * > & fVec)
6848 //  {
6849 //    for(unsigned int i = 0; i < fVec.size(); i++){
6850 //      fChi2_Vec.push_back( fVec[i] );
6851 //    }
6852 //  }
6853 //
6854 //  // parameter vector is first background (in common 1 and 2)
6855 //  // and then is signal (only in 2)
6856 //  double operator() (const double *par) const {
6857 //    vector< vector<double> > pVec;
6858 //    vector< double > dummyVec;
6859 //    for (int i = 0; i < 2; ++i) dummyVec.push_back(par[iparMinv[i] ]);
6860 //    pVec.push_back(dummyVec);
6861 //
6862 //    dummyVec.clear();
6863 //    for (int i = 0; i < 5; ++i) dummyVec.push_back(par[iparMpt[i] ]);
6864 //    pVec.push_back(dummyVec);
6865 //
6866 //    double val = 0;
6867 //    for( size_t i = 0; i < fChi2_Vec.size(); i++ ){
6868 //      val += (*fChi2_Vec[i])(&(pVec[i][0]));
6869 //    }
6870 //
6871 //    return val;
6872 //  }
6873 //
6874 //  vector< const ROOT::Math::IMultiGenFunction * > fChi2_Vec;
6875 //};
6876
6877 ////_____________________________________________________________________________
6878 //void AliAnalysisMuMuJpsiResult::FitPSIPSIPRIMECOMB_CB2VWG_MPTCB2VWG_BKGMPTPOL2()
6879 //{
6880 //
6881 //  //============== Take the initial parameters if any
6882 //  fHisto->GetListOfFunctions()->Delete(); //Minv Histo
6883 //
6884 //  Double_t alphaLow = GetValue("alJPsi"); //Initial parameters for Minv Fit
6885 //  Double_t nLow = GetValue("nlJPsi");
6886 //  Double_t alphaUp = GetValue("auJPsi");
6887 //  Double_t nUp = GetValue("nuJPsi");
6888 //  Double_t fitRangeLow = GetValue(kFitRangeLow);
6889 //  Double_t fitRangeHigh = GetValue(kFitRangeHigh);
6890 //  Double_t paramSPsiP = GetValue("FSigmaPsiP");
6891 //
6892 //  TString msg;
6893 //
6894 //  if (IsValidValue(alphaLow)) msg += TString::Format("alphaLow=%e ",alphaLow);
6895 //  if (IsValidValue(nLow)) msg += TString::Format("nLow=%e ",nLow);
6896 //  if (IsValidValue(alphaUp)) msg += TString::Format("alphaUp=%e ",alphaUp);
6897 //  if (IsValidValue(nUp)) msg += TString::Format("nUp=%e ",nUp);
6898 //
6899 //  AliDebug(1,Form("Fit with jpsi + psiprime VWG %s",msg.Data()));
6900 //
6901 //  //==============
6902 //
6903 //  //============== Definition of the Minv and Mpt fitting funtions
6904 //     //_____Minv
6905 //  TF1* fitTotalMinv = new TF1("signal+bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2VWG,fitRangeLow,fitRangeHigh,12,"AliAnalysisMuMuJpsiResult","FitFunctionTotalTwoCB2VWG");
6906 //
6907 //  fitTotalMinv->SetParNames("kVWG","mVWG","sVWG1","sVWG2","kJPsi","mJPsi","sJPsi",
6908 //  //                        0      1       2       3       4      5      6
6909 //                        "alJPsi","nlJPsi","auJPsi","nuJPsi");
6910 //  //                         7        8        9        10
6911 //  fitTotalMinv->SetParName(11, "kPsiP");
6912 //  //                             11
6913 //
6914 //
6915 //  TF1* bckMinv = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundVWG,fitRangeLow,fitRangeHigh,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundVWG");
6916 //
6917 //  const char* fitOption = "SER"; //We can add NO to avoid plotting
6918 //
6919 //  Int_t bin = fHisto->FindBin(0.26);
6920 //
6921 //  bckMinv->SetParameters(fHisto->GetBinContent(bin),2.,0.5,0.3);
6922 //
6923 //  SetFitRejectRange(2.7,4.0);
6924 //
6925 //  TFitResultPtr fitResultInit = fHisto->Fit(bckMinv,"SR");
6926 //
6927 //  std::cout << "FitResultBkgInit=" << static_cast<int>(fitResultInit) << std::endl;
6928 //
6929 //  if ( static_cast<int>(fitResultInit) )
6930 //  {
6931 //    bin = fHisto->FindBin(0.82);
6932 //    bckMinv->SetParameters(fHisto->GetBinContent(bin),2.,0.5,0.3);
6933 //    fitResultInit = fHisto->Fit(bckMinv,"SR");
6934 //  }
6935 //  else if ( bckMinv->GetParameter(0) < 0 )
6936 //  {
6937 //    bckMinv->SetParameters(fHisto->GetBinContent(bin),2.,0.5,0.3);
6938 //  }
6939 //
6940 //  SetFitRejectRange();
6941 //
6942 //  TH1* fHistoMpt(0x0);
6943 //      //______Mpt
6944 //  TProfile* p(0x0);
6945 //  if ( fHistoMpt->IsA() == TProfile::Class() ) p = static_cast<TProfile*>(fHistoMpt);
6946 //  else
6947 //  {
6948 //    AliError("Mean pt histo has to be a TProfile");
6949 //    return;
6950 //  }
6951 //
6952 //                 //_____________ To assing a correct error to bins with low nEntries
6953 //  Int_t minBin = p->FindBin(fitRangeLow);
6954 //  Int_t maxBin = p->FindBin(fitRangeHigh);
6955 //
6956 //  for ( Int_t i = minBin ; i <= maxBin ; i++ )
6957 //  {
6958 //    if ( p->GetBinEffectiveEntries(i) < 10 )
6959 //    {
6960 //      Double_t effEntries(0.),sumErr(0.);
6961 //      for ( Int_t j = i - 5 ; j < i ; j++ )
6962 //      {
6963 //        if ( j <= 0 ) continue;
6964 //
6965 //        effEntries += p->GetBinEffectiveEntries(j);
6966 //        sumErr += p->GetBinEffectiveEntries(j)*p->GetBinError(j);
6967 //      }
6968 //
6969 //      Double_t meanErr = sumErr/effEntries;
6970 //
6971 //      if ( p->GetBinError(i) < meanErr/2. )
6972 //      {
6973 //        std::cout << "Resetting bin " << i << " error" <<std::endl;
6974 //        p->SetBinError(i,meanErr);
6975 //      }
6976 //    }
6977 //  }
6978 //               //_____________
6979 //
6980 //  TF1* bckMpt = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
6981 //
6982 //  bckMpt->SetParameters(3.,1.,0.);
6983 //
6984 //  bckMpt->SetParLimits(0, 1.,8.0);
6985 //
6986 //  SetFitRejectRange(2.3,4.0);
6987 //
6988 //  p->Fit(bckMpt,"SER","",fitRangeLow,fitRangeHigh);
6989 //
6990 //  SetFitRejectRange();
6991 //
6992 //  TF1* fitMeanpt = new TF1("fitMeanpt",this,&AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2CB2VWGPOL2,fitRangeLow,fitRangeHigh,17,"AliAnalysisMuMuJpsiResult","FitFunctionMeanPtS2CB2VWGPOL2");
6993 //
6994 //  fitMeanpt->SetParNames("kVWG","mVWG","sVWG1","sVWG2","kJPsi","mJPsi","sJPsi","alJPsi","nlJPsi","auJPsi","nuJPsi");
6995 //  fitMeanpt->SetParName(11,"kPsiP");
6996 //  fitMeanpt->SetParName(12,"<pt>JPsi");
6997 //  fitMeanpt->SetParName(13,"<pt>BG0");
6998 //  fitMeanpt->SetParName(14,"<pt>BG1");
6999 //  fitMeanpt->SetParName(15,"<pt>BG2");
7000 //  fitMeanpt->SetParName(16,"<pt>PsiP");
7001 //  //___________
7002 //
7003 //  //============== End of definition of the Minv and Mpt fitting funtions
7004 //
7005 //
7006 //
7007 //  //============== Set the initial parameters in the Minv and Mpt fitting funtions
7008 //  Double_t parMinv[12] ={0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.};
7009 //  Double_t parMpt[17] ={0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.};
7010 //
7011 //
7012 //  for ( Int_t i = 0; i < 4; ++i )
7013 //  {
7014 //    fitTotalMinv->SetParameter(i, bckMinv->GetParameter(i));
7015 //    fitMeanpt->SetParameter(i, bckMinv->GetParameter(i));
7016 //    parMinv[i] = bckMinv->GetParameter(i);
7017 //    parMpt[i] = bckMinv->GetParameter(i);
7018 //  }
7019 //
7020 //  bin = fHisto->FindBin(3.09);
7021 //  fitTotalMinv->SetParameter(4, fHisto->GetBinContent(bin)); // norm
7022 //  fitMeanpt->SetParameter(4, fHisto->GetBinContent(bin)); // norm
7023 //  parMinv[4] = fHisto->GetBinContent(bin);
7024 //  parMpt[4] = fHisto->GetBinContent(bin);
7025 //
7026 //  fitTotalMinv->SetParameter(5, 3.1); // mean
7027 //  fitTotalMinv->SetParLimits(5, 3.0, 3.2);
7028 //  fitMeanpt->SetParameter(5, 3.1); // mean
7029 //  fitMeanpt->SetParLimits(5, 3.0, 3.2);
7030 //  parMinv[5] = 3.1;
7031 //  parMpt[5] = 3.1;
7032 //
7033 //  fitTotalMinv->SetParameter(6, 0.08); // sigma
7034 //  fitTotalMinv->SetParLimits(6, 0.05, 0.09);
7035 //  fitMeanpt->SetParameter(6, 0.08); // sigma
7036 //  fitMeanpt->SetParLimits(6, 0.05, 0.09);
7037 //  parMinv[6] = 0.08;
7038 //  parMpt[6] = 0.08;
7039 //
7040 //
7041 //  fitTotalMinv->SetParameter(7,0.9);
7042 //  fitTotalMinv->SetParLimits(7,0.1,10.0);
7043 //  fitMeanpt->SetParameter(7,0.9);
7044 //  fitMeanpt->SetParLimits(7,0.1,10.0);
7045 //  parMinv[7] = 0.9;
7046 //  parMpt[7] = 0.9;
7047 //
7048 //  fitTotalMinv->SetParameter(8,5.0);
7049 //  fitTotalMinv->SetParLimits(8,0.0,10.0);
7050 //  fitMeanpt->SetParameter(8,5.0);
7051 //  fitMeanpt->SetParLimits(8,0.0,10.0);
7052 //  parMinv[8] = 5.0;
7053 //  parMpt[8] = 5.0;
7054 //
7055 //
7056 //  fitTotalMinv->SetParameter(9, 2.0);
7057 //  fitTotalMinv->SetParLimits(9,0.1,10.0);
7058 //  fitMeanpt->SetParameter(9, 2.0);
7059 //  fitMeanpt->SetParLimits(9,0.1,10.0);
7060 //  parMinv[9] = 2.0;
7061 //  parMpt[9] = 2.0;
7062 //
7063 //  fitTotalMinv->SetParameter(10,3.0);
7064 //  fitTotalMinv->SetParLimits(10,0.0,10.0);
7065 //  fitMeanpt->SetParameter(10,3.0);
7066 //  fitMeanpt->SetParLimits(10,0.0,10.0);
7067 //  parMinv[10] = 3.0;
7068 //  parMpt[10] = 3.0;
7069 //
7070 //
7071 //  fitTotalMinv->SetParameter(11, 10.); //kPsi'
7072 //  fitTotalMinv->SetParLimits(11, 0.,100000.);
7073 //  fitMeanpt->SetParameter(11, 10.); //kPsi'
7074 //  fitMeanpt->SetParLimits(11, 0.,100000.);
7075 //  parMinv[11] = 10.;
7076 //  parMpt[11] = 10.;
7077 //
7078 //
7079 //  fitMeanpt->SetParameter(12, 3.);
7080 //  fitMeanpt->SetParLimits(12, 1.0,5.);
7081 //  parMpt[12] = 3.;
7082 //
7083 //  for ( Int_t i = 0; i < 3; ++i )
7084 //  {
7085 //    fitMeanpt->SetParameter(i + 13, bckMpt->GetParameter(i));
7086 //    parMpt[i + 13] = bckMpt->GetParameter(i);
7087 //  }
7088 //
7089 //  fitMeanpt->SetParameter(16, 3.);
7090 //  parMpt[16] = 3.;
7091 //  Double_t psipPtLim = 10.;
7092 //  fitMeanpt->SetParLimits(16, 0.,psipPtLim);
7093 //
7094 //  //================== End of setting Minv and Mpt initial parameters
7095 //
7096 //  //================== Chi2 definition for the global fit
7097 //
7098 //
7099 //
7100 ////  struct GlobalChi2 {
7101 ////    GlobalChi2(  ROOT::Math::IMultiGenFunction & f1,
7102 ////               ROOT::Math::IMultiGenFunction & f2) :
7103 ////    fChi2_1(&f1), fChi2_2(&f2) {}
7104 ////
7105 ////    // parameter vector is first background (in common 1 and 2)
7106 ////    // and then is signal (only in 2)
7107 ////    double operator() (const double *par) const {
7108 ////      double p1[12];
7109 ////      for (int i = 0; i < 12; ++i) p1[i] = par[iparMinv[i] ];
7110 ////
7111 ////      double p2[17];
7112 ////      for (int i = 0; i < 17; ++i) p2[i] = par[iparMpt[i] ];
7113 ////
7114 ////      return (*fChi2_1)(p1) + (*fChi2_2)(p2);
7115 ////    }
7116 ////
7117 ////    const  ROOT::Math::IMultiGenFunction * fChi2_1;
7118 ////    const  ROOT::Math::IMultiGenFunction * fChi2_2;
7119 ////  };
7120 //  //================== End of chi2 definition for the global fit
7121 //
7122 //
7123 //
7124 //  //================== Combined fit
7125 //  ROOT::Math::WrappedMultiTF1 wfMinv(*fitTotalMinv,1);
7126 //  ROOT::Math::WrappedMultiTF1 wfMpt(*fitMeanpt,1);
7127 //
7128 //  ROOT::Fit::DataOptions opt;
7129 //  ROOT::Fit::DataRange rangeMinv;
7130 //  // set the data range
7131 //  rangeMinv.SetRange(fitRangeLow,fitRangeHigh);
7132 //  ROOT::Fit::BinData dataMinv(opt,rangeMinv);
7133 //  ROOT::Fit::FillData(dataMinv, fHisto);
7134 //
7135 //  ROOT::Fit::DataRange rangeMpt;
7136 //  rangeMpt.SetRange(fitRangeLow,fitRangeHigh);
7137 //  ROOT::Fit::BinData dataMpt(opt,rangeMpt);
7138 //  ROOT::Fit::FillData(dataMpt, fHistoMpt);
7139 //
7140 ////  ROOT::Fit::Chi2Function chi2_Minv(dataMinv, wfMinv);
7141 ////  ROOT::Fit::Chi2Function chi2_Mpt(dataMpt, wfMpt);
7142 //
7143 //  vector< ROOT::Fit::Chi2Function * > chi2_vec;
7144 //  chi2_vec.push_back( new ROOT::Fit::Chi2Function(dataMinv, wfMinv) );
7145 //  chi2_vec.push_back( new ROOT::Fit::Chi2Function(dataMpt, wfMpt) );
7146 //
7147 //  GlobalChi2 globalChi2(chi2_vec);
7148 //
7149 ////  GlobalChi2 globalChi2(chi2_Minv, chi2_Mpt);
7150 //
7151 //  ROOT::Fit::Fitter fitter;
7152 //
7153 ////  const int Npar = 6;
7154 ////  double par0[Npar] = { 5,5,-0.1,100, 30,10};
7155 ////
7156 ////  // create before the parameter settings in order to fix or set range on them
7157 ////  fitter.Config().SetParamsSettings(6,par0);
7158 //  // fix 5-th parameter
7159 ////  fitter.Config().ParSettings(4).Fix();
7160 ////  // set limits on the third and 4-th parameter
7161 ////  fitter.Config().ParSettings(2).SetLimits(-10,-1.E-4);
7162 ////  fitter.Config().ParSettings(3).SetLimits(0,10000);
7163 ////  fitter.Config().ParSettings(3).SetStepSize(5);
7164 //
7165 //  fitter.Config().MinimizerOptions().SetPrintLevel(0);
7166 //  fitter.Config().SetMinimizer("Minuit2","Migrad");
7167 //
7168 //  // fit FCN function directly
7169 //  // (specify optionally data size and flag to indicate that is a chi2 fit)
7170 //  fitter.FitFCN(6,globalChi2,0,dataMinv.Size()+dataMpt.Size(),true);
7171 //  ROOT::Fit::FitResult result = fitter.Result();
7172 //  result.Print(std::cout);
7173 //
7174 //  TCanvas * c1 = new TCanvas("Simfit","Simultaneous fit of two histograms",
7175 //                             10,10,700,700);
7176 //  c1->Divide(1,2);
7177 //  c1->cd(1);
7178 //  gStyle->SetOptFit(1111);
7179 //
7180 //  fitTotalMinv->SetFitResult( result, iparMinv);
7181 //  fitTotalMinv->SetRange(rangeMinv().first, rangeMinv().second);
7182 //  fitTotalMinv->SetLineColor(kBlue);
7183 ////  hB->GetListOfFunctions()->Add(fB);
7184 //  fitTotalMinv->Draw();
7185 //
7186 //  c1->cd(2);
7187 //  fitMeanpt->SetFitResult( result, iparMpt);
7188 //  fitMeanpt->SetRange(rangeMpt().first, rangeMpt().second);
7189 //  fitMeanpt->SetLineColor(kRed);
7190 ////  fitMeanpt->GetListOfFunctions()->Add(fSB);
7191 //  fitMeanpt->Draw();
7192 //
7193 ////==============
7194 //}
7195
7196 //_____________________________________________________________________________
7197 Bool_t AliAnalysisMuMuJpsiResult::AddFit(const char* fitType)
7198 {
7199   // Add a fit to this result
7200
7201   if ( !fHisto ) return kFALSE;
7202
7203   TH1* histo = static_cast<TH1*>(fHisto->Clone(fitType));
7204
7205   AliAnalysisMuMuJpsiResult* r = new AliAnalysisMuMuJpsiResult(GetParticle(),*histo,fitType);
7206
7207   if ( !r->IsValid() )
7208   {
7209     delete r;
7210     return kFALSE;
7211   }
7212
7213   TMethodCall callEnv;
7214
7215   TString fittingMethod(r->GetFitFunctionMethodName().Data());
7216
7217   std::cout << "+Using fitting method " << fittingMethod.Data() << "..." << std::endl;
7218   std::cout << "" << std::endl;
7219
7220   callEnv.InitWithPrototype(IsA(),fittingMethod.Data(),"");
7221
7222   if (callEnv.IsValid())
7223   {
7224     callEnv.Execute(r);
7225   }
7226   else
7227   {
7228     AliError(Form("Could not get the method %s",fittingMethod.Data()));
7229     delete r;
7230     return kFALSE;
7231   }
7232
7233 //  Float_t lpar[] = { -1.0, -1.0, -1.0, -1.0 }; // free tails by default
7234 //
7235 //  Bool_t ok(kTRUE);
7236 //
7237 //  if ( fitFunction.Contains("CB2") )
7238 //  {
7239 //    if ( extra.Length() )
7240 //    {
7241 //      AliDebug(1,Form("sFitType=%s",fitType));
7242 //
7243 //      sscanf(extra,"ALPHALOW%fNLOW%fALPHAUP%fNUP%f",
7244 //             &lpar[0],&lpar[1],&lpar[2],&lpar[3]);
7245 //
7246 //      AliDebug(1,Form("PSILOW ALPHALOW=%f NLOW=%f ALPHAUP=%f NUP=%f",lpar[0],lpar[1],lpar[2],lpar[3]));
7247 //    }
7248 //
7249 //    if ( lpar[0] == 0.0 && lpar[1] == 0.0 && lpar[0] == 0.0 && lpar[1] == 0.0 )
7250 //    {
7251 //      AliError("Cannot work with zero tails !");
7252 //      ok = kFALSE;
7253 //    }
7254 //  }
7255
7256 //  if ( ok == kTRUE )
7257 //  {
7258 //
7259 //    if ( fitFunction=="PSICB2" )
7260 //    {
7261 //      r = FitPSICB2(*hminv,fitMinvMin,fitMinvMax);
7262 //    }
7263 //    else if ( fitFunction == "PSIPSIPRIMECB2VWG")
7264 //    {
7265 //      r = FitPSIPSIPRIMECB2VWG(*hminv,fitMinvMin,fitMinvMax,lpar[0],lpar[1],lpar[2],lpar[3]);
7266 //    }
7267 ////    else if ( fitFunction == "PSIPSIPRIMECB2POL2EXP")
7268 ////    {
7269 ////      r = FitPSIPSIPRIMECB2POL2EXP(*hminv,fitMinvMin,fitMinvMax,lpar[0],lpar[1],lpar[2],lpar[3]);
7270 ////    }
7271 //    else if ( fitFunction == "PSILOWMCTAILS" )
7272 //    {
7273 //      if ( npar!= 4 )
7274 //      {
7275 //        AliError("Cannot use PSILOWMCTAILS without being given the MC tails !");
7276 //        delete hminv;
7277 //        return kFALSE;
7278 //      }
7279 //      r = FitPSIPSIPRIMECB2VWG(*hminv,fitMinvMin,fitMinvMax,par[0],par[1],par[2],par[3]);
7280 //      if (r)
7281 //      {
7282 //        r->SetAlias("MCTAILS");
7283 //      }
7284 //    }
7285 //    else if ( fitFunction == "COUNTJPSI" )
7286 //    {
7287 //      r = new AliAnalysisMuMuJpsiResult(*hminv,"COUNTJPSI");
7288 //      Double_t n = CountParticle(*hminv,"Jpsi");
7289 //      r->Set("NofJPsi",n,TMath::Sqrt(n));
7290 //    }
7291 //
7292 //  }
7293
7294   if ( r->IsValid() )
7295   {
7296     StdoutToAliDebug(1,r->Print(););
7297     r->SetBin(Bin());
7298     r->SetNofTriggers(NofTriggers());
7299     r->SetNofRuns(NofRuns());
7300
7301     Bool_t adoptOK = AdoptSubResult(r);
7302     if ( adoptOK ) std::cout << "Subresult " << r->GetName() << " adopted in " << GetName() <<  std::endl;
7303     else AliError(Form("Could not adopt subresult %s",r->GetName()));
7304   }
7305   else
7306   {
7307     delete r;
7308     r=0x0;
7309   }
7310
7311   return (r!=0x0);
7312 }
7313
7314 //_____________________________________________________________________________
7315 void AliAnalysisMuMuJpsiResult::DecodeFitType(const char* fitType)
7316 {
7317   /// decode the string containing all the information for the fit to be done
7318   ///
7319   /// the fittype is a combination of key=value pairs separated by ":"
7320   ///     +func=Name fo the function used in the fit(See ? to read the naming convention)
7321   ///     +rebin=Rebin of the histo(1,2...)
7322   ///     +histoType=The type of histo we wan to fit(minv,mpt ???or minv&mpt for a combined fit???)
7323   ///     +tails=from where we take the particle tails(mctails,mctailsJPsi&PsiP to use an indep sets of tails for each particle, predefined tails)
7324   ///     +alJpsi , nlPsiP ... = Fit parameters (they carry the parameter name and the particle name)
7325   ///
7326   /// e.g.
7327   /// func=gaus:rebin=2:range=2.3;4.7;nsigmas=3
7328   /// func=vwm+cb2:range=2;5;alphalow=5.2;alphahigh=6.2
7329   ///
7330   /// except from the func key, all the other ones have default values
7331   /// if the key is different from func,rebin,range,histoType it is assumed
7332   /// to be the value for a parameter of the fit function.
7333
7334   TString resultName("");
7335
7336   // default values
7337   TString fitFunction;
7338   TString histoType("minv");
7339   TString tails("");
7340   Int_t rebin=1;
7341   Double_t fitMinvMin=2.0;
7342   Double_t fitMinvMax=5.0;
7343   Double_t paramSPsiP= 3.68609/3.096916;
7344
7345   TString sFitType(fitType);
7346
7347   if (!sFitType.Contains(kKeyFunc,TString::kIgnoreCase)) return;
7348
7349   TObjArray* parts = sFitType.Tokenize(":");
7350   TObjString* str;
7351   TIter next(parts);
7352
7353   while ( ( str = static_cast<TObjString*>(next()) ) )
7354   {
7355     TString key,value;
7356     Bool_t ok = GetKeyValue(str->String(),'=',key,value);
7357     if (!ok)
7358     {
7359       AliErrorClass(Form("Invalid key=value pair %s",str->String().Data()));
7360       continue;
7361     }
7362
7363     if ( key.CompareTo(kKeyFunc,TString::kIgnoreCase) == 0 )
7364     {
7365       fitFunction = value;
7366       resultName += fitFunction;
7367     }
7368     else if ( key.CompareTo(kKeyRange,TString::kIgnoreCase) == 0 )
7369     {
7370       TString xmin,xmax;
7371       if (GetKeyValue(value,';',xmin,xmax))
7372       {
7373         fitMinvMin = xmin.Atof();
7374         fitMinvMax = xmax.Atof();
7375         AliInfoClass(Form("xmin=%e xmax=%e",fitMinvMin,fitMinvMax));
7376
7377         resultName += "_";
7378         resultName += xmin.Data();
7379         resultName += "-";
7380         resultName += xmax.Data();
7381       }
7382       else
7383       {
7384         AliErrorClass(Form("Improper range specification %s",value.Data()));
7385         continue;
7386       }
7387     }
7388     else if ( key.CompareTo(kKeyRebin,TString::kIgnoreCase) == 0 )
7389     {
7390       rebin = value.Atoi();
7391     }
7392     else if ( key.CompareTo(kKeyHistoType,TString::kIgnoreCase) == 0 ) //FIXME::Is really necesary to save the histoType? I think I dont use it
7393     {
7394       histoType = value;
7395
7396       if ( histoType.CompareTo("minv",TString::kIgnoreCase) == 0 ) Set(kKeyHistoType,0.,0.0); //histoType=0 means minv histo
7397       else if ( histoType.CompareTo("mpt",TString::kIgnoreCase) == 0 ) Set(kKeyHistoType,1.,0.0); //histoType=1 means mpt histo
7398       else if ( histoType.CompareTo("minv&mpt",TString::kIgnoreCase) == 0 ) Set(kKeyHistoType,2.,0.0); //histoType=1 means combined fit minv and mpt
7399       else
7400       {
7401         AliErrorClass(Form("Improper histoType specification %s",value.Data()));
7402         continue;
7403       }
7404
7405     }
7406     else if ( key.CompareTo(kKeyTails,TString::kIgnoreCase) == 0 )
7407     {
7408       tails = value;
7409       if ( tails.CompareTo("mctails",TString::kIgnoreCase) == 0 ) Set(kKeyTails,0.,0.0);
7410       else if ( tails.CompareTo("mctailsJPsi&PsiP",TString::kIgnoreCase) == 0 ) Set(kKeyTails,1.,0.0);
7411       else if ( tails.CompareTo("",TString::kIgnoreCase) == 0 ) Set(kKeyTails,2.,0.0); // Predefined tails
7412       else
7413       {
7414         AliErrorClass(Form("Improper tails specification %s",value.Data()));
7415         continue;
7416       }
7417     }
7418     else if ( key.CompareTo(kKeySPsiP,TString::kIgnoreCase) == 0 )
7419     {
7420       paramSPsiP = value.Atof();
7421     }
7422     else if ( key.CompareTo(kKeyMinvRS,TString::kIgnoreCase) == 0 )
7423     {
7424       fMinvRS = value.Data();
7425     }
7426     else
7427     {
7428       Set(key.Data(),value.Atof(),0.0);
7429     }
7430   }
7431
7432   if ( fitFunction.CountChar('-') )
7433   {
7434     AliError(Form("Invalid fit function name : %s",fitFunction.Data()));
7435     Invalidate();
7436   }
7437   else
7438   {
7439
7440     fFitFunction = fitFunction;
7441
7442     Set(kKeySPsiP,paramSPsiP,0.0);
7443     Set(kKeyRebin,rebin,0.0);
7444     Set(kFitRangeLow,fitMinvMin,0.0);
7445     Set(kFitRangeHigh,fitMinvMax,0.0);
7446   }
7447
7448   delete parts;
7449 }
7450
7451 //_____________________________________________________________________________
7452 TString AliAnalysisMuMuJpsiResult::GetFitFunctionMethodName() const
7453 {
7454     /// Get the name of the function used to fit this result (if any)
7455   TString name(FitFunctionName());
7456   if ( name.CountChar('-') )
7457   {
7458     return "";
7459   }
7460   if ( GetValue("tails") == 1. ) name += "INDEPTAILS";
7461   return TString::Format("Fit%s",name.Data());
7462 }
7463
7464 //_____________________________________________________________________________
7465 Long64_t AliAnalysisMuMuJpsiResult::Merge(TCollection* list)
7466 {
7467   /// Merge method
7468   ///
7469   /// Merge a list of AliAnalysisMuMuJpsiResult objects with this
7470   /// Returns the number of merged objects (including this).
7471   ///
7472   /// Note that the merging is to be understood here as an weighted mean operation
7473   ///
7474   /// FIXME ! (compared to base class Merge, should only Minv merging ?)
7475
7476   AliError("Implement me !");
7477   if (!list) return 0;
7478
7479   if (list->IsEmpty()) return 1;
7480
7481   return 0;
7482
7483 }
7484
7485 //_____________________________________________________________________________
7486 Int_t AliAnalysisMuMuJpsiResult::NofRuns() const
7487 {
7488   /// Get the number of runs
7489   if ( !Mother() ) return fNofRuns;
7490   else return Mother()->NofRuns();
7491 }
7492
7493 //_____________________________________________________________________________
7494 Int_t AliAnalysisMuMuJpsiResult::NofTriggers() const
7495 {
7496   /// Get the number of triggers
7497
7498   if ( !Mother() ) return fNofTriggers;
7499   else return Mother()->NofTriggers();
7500 }
7501
7502 //_____________________________________________________________________________
7503 void AliAnalysisMuMuJpsiResult::Print(Option_t* opt) const
7504 {
7505   /// printout
7506
7507   std::cout << Form("NRUNS %d - NTRIGGER %10d - %s",
7508                                       NofRuns(),
7509                                       NofTriggers(),
7510                                       fBin.AsString().Data());
7511
7512   AliAnalysisMuMuResult::Print(opt);
7513 }
7514
7515 //_____________________________________________________________________________
7516 void AliAnalysisMuMuJpsiResult::PrintValue(const char* key, const char* opt, Double_t value, Double_t errorStat,
7517                                            Double_t rms) const
7518 {
7519   /// exclude the particles with zero stat
7520
7521   const std::map<std::string,Double_t>& m = MassMap();
7522
7523   for( std::map<std::string,Double_t>::const_iterator it = m.begin(); it != m.end(); ++it )
7524   {
7525     TString particle(it->first.c_str());
7526
7527     if (TString(key).Contains(particle.Data()))
7528     {
7529       if ( GetValue("Nof%s",particle.Data()) <= 0.0 ) return;
7530     }
7531   }
7532
7533   AliAnalysisMuMuResult::PrintValue(key,opt,value,errorStat,rms);
7534
7535 }
7536
7537 //_____________________________________________________________________________
7538 void AliAnalysisMuMuJpsiResult::PrintParticle(const char* particle, const char* opt) const
7539 {
7540   /// Print all information about one particule type
7541
7542   Double_t npart = GetValue(Form("Nof%s",particle));
7543   if (npart<=0) return;
7544
7545
7546   std::cout << opt << Form("\t%s",particle) << std::endl;
7547
7548   //  Double_t npartError = GetErrorStat(Form("Nof%s",particle));
7549 //  std::cout << opt << Form("\t\t%20s %9.2f +- %5.2f","Count",npart,npartError) << std::endl;
7550
7551   TIter next(Keys());
7552   TObjString* key;
7553
7554   while ( ( key = static_cast<TObjString*>(next()) ) )
7555   {
7556     if ( !key->String().Contains(particle) ) continue;
7557
7558     PrintValue(key->String(),opt,GetValue(key->String()),GetErrorStat(key->String()),GetRMS(key->String()));
7559   }
7560 }
7561
7562 //_____________________________________________________________________________
7563 void AliAnalysisMuMuJpsiResult::SetBin(const AliAnalysisMuMuBinning::Range& bin)
7564 {
7565   /// Set the bin
7566
7567   if (!Mother()) fBin = bin;
7568   else Mother()->SetBin(bin);
7569 }
7570
7571 //_____________________________________________________________________________
7572 void AliAnalysisMuMuJpsiResult::SetFitRejectRange(Double_t a, Double_t b)
7573 {
7574   /// Set a range the fit function(s) can ignore
7575
7576   fRejectFitPoints = kFALSE;
7577
7578   fFitRejectRangeLow = a;
7579   fFitRejectRangeHigh = b;
7580   if ( a <= TMath::Limits<Double_t>::Max() && b <= TMath::Limits<Double_t>::Max() )
7581   {
7582     fRejectFitPoints = kTRUE;
7583   }
7584 }
7585
7586 //_____________________________________________________________________________
7587 void AliAnalysisMuMuJpsiResult::SetHisto(const TH1& h)
7588 {
7589   /// Set the spectrum to be fitted.
7590   static UInt_t n(0);
7591
7592   delete fHisto;
7593   fHisto = static_cast<TH1*>(h.Clone(Form("AliAnalysisMuMuJpsiResultHisto%u",n++)));
7594   fHisto->SetDirectory(0);
7595 }
7596
7597 //_____________________________________________________________________________
7598 void AliAnalysisMuMuJpsiResult::SetNofInputParticles(const TH1& hminv)
7599 {
7600   /// Set the number of input particle from the invariant mass spectra
7601
7602   static const char* particleNames[] = { "JPsi" , "PsiP", "Upsilon","UpsilonPrime" };
7603
7604   const std::map<std::string,Double_t>& m = MassMap();
7605
7606   for ( Int_t i = 0; i < 4; ++i )
7607   {
7608     std::map<std::string,Double_t>::const_iterator it = m.find(particleNames[i]);
7609
7610     Double_t sigma(-1.0);
7611
7612     if (it != m.end() )
7613     {
7614       sigma = it->second*0.1;
7615     }
7616
7617     Double_t n = CountParticle(hminv,particleNames[i],sigma);
7618
7619     AliDebug(1,Form("i=%d particle %s n %e",i,particleNames[i],n));
7620
7621     if ( n > 0 )
7622     {
7623       SetNofInputParticles(particleNames[i],TMath::Nint(n));
7624     }
7625   }
7626 }
7627
7628 //_____________________________________________________________________________
7629 void AliAnalysisMuMuJpsiResult::SetNofInputParticles(const char* particle, int n)
7630 {
7631   /// Set the number of input particles (so it is a MC result)
7632   /// and (re)compute the AccxEff values
7633
7634   Set(Form("NofInput%s",particle),n,TMath::Sqrt(n));
7635
7636   if (n<=0)
7637   {
7638     Set(Form("AccEff%s",particle),0,0);
7639     return;
7640   }
7641
7642   Double_t npart = GetValue(Form("Nof%s",particle));
7643   Double_t npartErr  = GetErrorStat(Form("Nof%s",particle));
7644   Double_t ninput = GetValue(Form("NofInput%s",particle));
7645   Double_t ninputErr = GetErrorStat(Form("NofInput%s",particle));
7646
7647   Set(Form("AccEff%s",particle),
7648       npart/ninput,
7649       (npart/ninput)*ErrorAB(npart,npartErr,ninput,ninputErr));
7650
7651   TIter next(SubResults());
7652   AliAnalysisMuMuJpsiResult* r;
7653
7654   while ( ( r = static_cast<AliAnalysisMuMuJpsiResult*>(next())) )
7655   {
7656     r->Set(Form("NofInput%s",particle),n,TMath::Sqrt(n));
7657
7658     npart = r->GetValue(Form("Nof%s",particle));
7659     npartErr = r->GetErrorStat(Form("Nof%s",particle));
7660
7661     r->Set(Form("AccEff%s",particle),
7662            npart/ninput,
7663            (npart/ninput)*ErrorAB(npart,npartErr,ninput,ninputErr));
7664
7665   }
7666 }
7667
7668 //_____________________________________________________________________________
7669 void AliAnalysisMuMuJpsiResult::SetNofRuns(Int_t n)
7670 {
7671   if ( !Mother() ) fNofRuns=n;
7672   else Mother()->SetNofRuns(n);
7673 }
7674
7675 //_____________________________________________________________________________
7676 void AliAnalysisMuMuJpsiResult::SetNofTriggers(Int_t n)
7677 {
7678   if ( !Mother() ) fNofTriggers=n;
7679   else Mother()->SetNofTriggers(n);
7680 }
7681
7682
7683 //_____________________________________________________________________________
7684 void AliAnalysisMuMuJpsiResult::SetParameter(TF1* func, Int_t npar, Double_t fix, Double_t initialValue,
7685                                              Double_t min, Double_t max) const
7686 {
7687   /// Fix one parameter or set its initial value and limits
7688
7689   if ( IsValidValue(fix) )
7690   {
7691     func->FixParameter(npar, fix);
7692   }
7693   else
7694   {
7695     func->SetParameter(npar,initialValue);
7696     func->SetParLimits(npar,min,max);
7697   }
7698 }
7699
7700 //_____________________________________________________________________________
7701 Bool_t AliAnalysisMuMuJpsiResult::StrongCorrelation(TFitResultPtr& r,
7702                                                     TF1* fitFunction,
7703                                                     Int_t npar1,
7704                                                     Int_t npar2,
7705                                                     Double_t fixValueIfWrong)
7706 {
7707   // return kTRUE if the npar1-th and npar2-th parameters of the fit function
7708   // are too strongly correlated,
7709   // and in that case fix the npar2-th parameter's value to fixValueIfWrong
7710
7711   Bool_t strongCorrelation = TMath::Abs(r->GetCorrelationMatrix()(npar1,npar2)) > 0.90;
7712
7713   if ( strongCorrelation )
7714   {
7715     fitFunction->FixParameter(npar2,fixValueIfWrong);
7716     return kTRUE;
7717   }
7718   return kFALSE;
7719 }
7720
7721 //_____________________________________________________________________________
7722 Bool_t AliAnalysisMuMuJpsiResult::WrongParameter(TF1* fitFunction, Int_t npar,
7723                                                  Double_t fixValueIfWrong)
7724 {
7725   // return kTRUE if npar-th parameter of fit function has a big error,
7726   // and in that case fix the parameter's value to fixValueIfWrong
7727
7728   Bool_t wrong = (fitFunction->GetParError(npar) > 0.8*TMath::Abs(fitFunction->GetParameter(npar)));
7729
7730   AliWarning(Form("npar %d error %e val %e wrong %d",
7731                   npar,fitFunction->GetParError(npar),
7732                   fitFunction->GetParameter(npar),wrong));
7733
7734   if ( wrong )
7735   {
7736     AliWarning(Form("Fixing parameter %d of %s to %e",
7737                     npar,fitFunction->GetName(),fixValueIfWrong));
7738
7739     fitFunction->FixParameter(npar,fixValueIfWrong);
7740     return kTRUE;
7741   }
7742   return kFALSE;
7743 }