]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWG/muondep/AliAnalysisMuMuJpsiResult.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'feature-movesplit'
[u/mrichter/AliRoot.git] / PWG / muondep / AliAnalysisMuMuJpsiResult.cxx
CommitLineData
81190958 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///
cb690a12 17/// Class to hold results about J/psi
81190958 18/// like number of of J/psi (before and after Acc x Eff correction),
19/// Acc x Eff correction, Yield, RAB, etc...
20///
cb690a12 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///
81190958 28/// author: Laurent Aphecetche (Subatech)
29///
30
31#include "AliAnalysisMuMuJpsiResult.h"
32
33ClassImp(AliAnalysisMuMuJpsiResult)
34
35#include "TF1.h"
cb690a12 36#include "TProfile.h"
81190958 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"
cb690a12 45#include "TMethodCall.h"
81190958 46#include "TObjArray.h"
47#include "TParameter.h"
48#include "AliAnalysisMuMuBinning.h"
49#include "AliLog.h"
50#include <map>
51
cb690a12 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
81190958 61namespace {
62
cb690a12 63 //____________________________________________________________________________
81190958 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 {
cb690a12 72 massMap["JPsi"] = 3.096916e+00;
73 massMap["PsiP"] = 3.68609e+00;
81190958 74 massMap["Upsilon"] = 9.46030e+00;
75 massMap["UpsilonPrime"] = 1.00233e+01;
76 }
77 return massMap;
78 }
cb690a12 79
80 //____________________________________________________________________________
81 Bool_t GetKeyValue(const TString& str, const char separator, TString& key, TString& value)
81190958 82 {
cb690a12 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;
81190958 90 }
81190958 91
cb690a12 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
81190958 102
81190958 103}
104
105//_____________________________________________________________________________
106AliAnalysisMuMuJpsiResult::AliAnalysisMuMuJpsiResult(TRootIOCtor* /*io*/) :
107AliAnalysisMuMuResult("",""),
108fNofRuns(),
109fNofTriggers(-1),
cb690a12 110fHisto(0x0),
81190958 111fBin(),
81190958 112fTriggerClass(),
113fEventSelection(),
114fPairSelection(),
cb690a12 115fCentralitySelection(),
116fFitFunction(),
117fFitRejectRangeLow(TMath::Limits<Double_t>::Max()),
118fFitRejectRangeHigh(TMath::Limits<Double_t>::Max()),
119fRejectFitPoints(kFALSE),
120fParticle(""),
121fMinvRS("")
81190958 122{
81190958 123}
124
125//_____________________________________________________________________________
cb690a12 126AliAnalysisMuMuJpsiResult::AliAnalysisMuMuJpsiResult(const char* particle,
127 const TH1& h,
128 const char* fitType)
81190958 129:
cb690a12 130AliAnalysisMuMuResult(fitType,""),
81190958 131fNofRuns(1),
132fNofTriggers(-1),
cb690a12 133fHisto(0x0),
81190958 134fBin(),
81190958 135fTriggerClass(),
136fEventSelection(),
137fPairSelection(),
cb690a12 138fCentralitySelection(),
139fFitFunction(),
140fFitRejectRangeLow(TMath::Limits<Double_t>::Max()),
141fFitRejectRangeHigh(TMath::Limits<Double_t>::Max()),
142fRejectFitPoints(kFALSE),
143fParticle(particle),
144fMinvRS("")
81190958 145{
cb690a12 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 }
81190958 190}
191
192//_____________________________________________________________________________
cb690a12 193AliAnalysisMuMuJpsiResult::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)
81190958 200:
201AliAnalysisMuMuResult(Form("%s-%s-%s-%s",triggerName,eventSelection,pairSelection,centSelection),""),
202fNofRuns(1),
203fNofTriggers(-1),
cb690a12 204fHisto(0x0),
81190958 205fBin(bin),
81190958 206fTriggerClass(triggerName),
207fEventSelection(eventSelection),
208fPairSelection(pairSelection),
cb690a12 209fCentralitySelection(centSelection),
210fFitFunction(),
211fFitRejectRangeLow(TMath::Limits<Double_t>::Max()),
212fFitRejectRangeHigh(TMath::Limits<Double_t>::Max()),
213fRejectFitPoints(kFALSE),
214fParticle(particle),
215fMinvRS("")
81190958 216{
cb690a12 217 SetHisto(h);
81190958 218}
219
220//_____________________________________________________________________________
221AliAnalysisMuMuJpsiResult::AliAnalysisMuMuJpsiResult(const AliAnalysisMuMuJpsiResult& rhs)
222:
223AliAnalysisMuMuResult(rhs),
224fNofRuns(rhs.NofRuns()),
225fNofTriggers(rhs.NofTriggers()),
cb690a12 226fHisto(0x0),
81190958 227fBin(rhs.Bin()),
81190958 228fTriggerClass(rhs.fTriggerClass),
229fEventSelection(rhs.fEventSelection),
230fPairSelection(rhs.fPairSelection),
cb690a12 231fCentralitySelection(rhs.fCentralitySelection),
232fFitFunction(rhs.fFitFunction),
233fFitRejectRangeLow(rhs.fFitRejectRangeLow),
234fFitRejectRangeHigh(rhs.fFitRejectRangeHigh),
235fRejectFitPoints(rhs.fRejectFitPoints),
236fParticle(rhs.fParticle),
237fMinvRS(rhs.fMinvRS)
81190958 238{
239 /// copy ctor
240 /// Note that the mother is lost
241 /// fKeys remains 0x0 so it will be recomputed if need be
242
cb690a12 243 if ( rhs.fHisto )
81190958 244 {
cb690a12 245 fHisto = static_cast<TH1*>(rhs.fHisto->Clone());
81190958 246 }
247}
248
249//_____________________________________________________________________________
250AliAnalysisMuMuJpsiResult& 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);
cb690a12 257 delete fHisto;
81190958 258
cb690a12 259 if ( rhs.fHisto )
81190958 260 {
cb690a12 261 fHisto = static_cast<TH1*>(rhs.fHisto->Clone());
81190958 262 }
263
264 fNofRuns = rhs.NofRuns();
265 fNofTriggers = rhs.NofTriggers();
266 fBin = rhs.Bin();
cb690a12 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
81190958 278 }
279
280 return *this;
281}
282
283//_____________________________________________________________________________
284AliAnalysisMuMuJpsiResult::~AliAnalysisMuMuJpsiResult()
285{
286 // dtor
cb690a12 287 delete fHisto;
288}
289
290//_____________________________________________________________________________
291void 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//_____________________________________________________________________________
325void 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);
81190958 363}
364
cb690a12 365
81190958 366//_____________________________________________________________________________
367const 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//_____________________________________________________________________________
375TObject* AliAnalysisMuMuJpsiResult::Clone(const char* /*newname*/) const
376{
377 /// Clone this result
378 return new AliAnalysisMuMuJpsiResult(*this);
379}
380
381//_____________________________________________________________________________
382Bool_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
cb690a12 415//_____________________________________________________________________________
416void AliAnalysisMuMuJpsiResult::Draw(Option_t* opt)
417{
418 /// short cut method to draw our internal histogram
419 if (fHisto) fHisto->Draw(opt);
420}
421
81190958 422//_____________________________________________________________________________
423Double_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
700a5a26 445 const TAxis* x = hminv.GetXaxis();
81190958 446
700a5a26 447 Int_t b1 = x->FindFixBin(mass-sigma);
448 Int_t b2 = x->FindFixBin(mass+sigma);
81190958 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
cb690a12 455//____________________________________________________________________________
456Double_t AliAnalysisMuMuJpsiResult::FitFunctionBackgroundLin(Double_t *x, Double_t *par)
81190958 457{
cb690a12 458 // Linear function for Bkg 2 params
81190958 459
cb690a12 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//____________________________________________________________________________
469Double_t AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2(Double_t *x, Double_t *par)
470{
471 // pol2 3 params
81190958 472
cb690a12 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//____________________________________________________________________________
482Double_t AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol3(Double_t *x, Double_t *par)
483{
484 // pol2 4 params
81190958 485
cb690a12 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//____________________________________________________________________________
495Double_t AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol4(Double_t *x, Double_t *par)
496{
497 // pol2 5 params
81190958 498
cb690a12 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//____________________________________________________________________________
508Double_t AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2Exp(Double_t *x, Double_t *par)
509{
510 // pol2 x exp : 4 params
81190958 511
cb690a12 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//____________________________________________________________________________
522Double_t AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol4Exp(Double_t *x, Double_t *par)
523{
524 // pol4 x exp : 6 params
81190958 525
cb690a12 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//____________________________________________________________________________
538Double_t AliAnalysisMuMuJpsiResult::FitFunctionBackgroundVWG(Double_t *x, Double_t *par)
539{
540 // gaussian variable width : 4 params
81190958 541
cb690a12 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//____________________________________________________________________________
552Double_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 }
81190958 574
cb690a12 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 }
81190958 581
cb690a12 582 if (t >= absAlpha2) //right tail
81190958 583 {
cb690a12 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]));
81190958 588 }
589
cb690a12 590 return 0. ;
591}
592
593//____________________________________________________________________________
594Double_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];
81190958 612
cb690a12 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]) ) );
81190958 617
cb690a12 618 return par[0]*TMath::Exp( -(1/2.)*TMath::Power(t/sigmaRatio,2.));
81190958 619
81190958 620}
621
cb690a12 622//____________________________________________________________________________
623Double_t AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoNA60NewVWG(Double_t *x, Double_t *par)
81190958 624{
cb690a12 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}
81190958 645
cb690a12 646//____________________________________________________________________________
647Double_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}
81190958 669
81190958 670
cb690a12 671//____________________________________________________________________________
672Double_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}
81190958 694
cb690a12 695//____________________________________________________________________________
696Double_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//____________________________________________________________________________
716Double_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}
81190958 734
cb690a12 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//}
81190958 752
cb690a12 753//____________________________________________________________________________
754Double_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);
81190958 771}
772
cb690a12 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//____________________________________________________________________________
792Double_t AliAnalysisMuMuJpsiResult::FitFunctionTotalTwoCB2VWG(Double_t *x, Double_t *par)
81190958 793{
cb690a12 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}
81190958 810
cb690a12 811//____________________________________________________________________________
812Double_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//------------------------------------------------------------------------------
834Double_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//------------------------------------------------------------------------------
840Double_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//------------------------------------------------------------------------------
846Double_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//------------------------------------------------------------------------------
852Double_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//------------------------------------------------------------------------------
859Double_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//____________________________________________________________________________
866Double_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//------------------------------------------------------------------------------
891Double_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//____________________________________________________________________________
898Double_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//____________________________________________________________________________
922Double_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//____________________________________________________________________________
946Double_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//____________________________________________________________________________
971Double_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//____________________________________________________________________________
996Double_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//____________________________________________________________________________
1024Double_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//____________________________________________________________________________
1053Double_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//____________________________________________________________________________
1081Double_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//____________________________________________________________________________
1109Double_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//____________________________________________________________________________
1133Double_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//------------------------------------------------------------------------------
1157Double_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//_____________________________________________________________________________
1180void 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//_____________________________________________________________________________
1188void 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//_____________________________________________________________________________
1318void 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//_____________________________________________________________________________
1473void 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 }
81190958 1563
81190958 1564
cb690a12 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
81190958 1577
1578 fitTotal->SetParameter(5, 3.1); // mean
1579 fitTotal->SetParLimits(5, 3.0, 3.2);
1580
1581 fitTotal->SetParameter(6, 0.08); // sigma
cb690a12 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.);
81190958 1626
cb690a12 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 }
81190958 1659
cb690a12 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 }
81190958 1669
cb690a12 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// }
81190958 1686
cb690a12 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 }
81190958 1743
cb690a12 1744 delete bckInit;
81190958 1745
cb690a12 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));
81190958 1751
cb690a12 1752 TF1* signalJPsi = new TF1("signalJPsi",this,&AliAnalysisMuMuJpsiResult::FitFunctionSignalCrystalBallExtended,fHisto->GetXaxis()->GetXmin(),fHisto->GetXaxis()->GetXmax(),7,"AliAnalysisMuMuJpsiResult","FitFunctionSignalCrystalBallExtended");
1753 signalJPsi->SetParameters(fitTotal->GetParameter(4),
81190958 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
cb690a12 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//_____________________________________________________________________________
1864void 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);
81190958 2182
81190958 2183
2184 Double_t cbParameters[7];
2185 Double_t covarianceMatrix[7][7];
2186
2187 for ( int ix = 0; ix < 7; ++ix )
2188 {
cb690a12 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//_____________________________________________________________________________
2216void 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//_____________________________________________________________________________
2850void 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//_____________________________________________________________________________
3513void 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//_____________________________________________________________________________
3910void 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//_____________________________________________________________________________
4272void 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//_____________________________________________________________________________
4616void 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//_____________________________________________________________________________
4798void 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//_____________________________________________________________________________
4989void 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//_____________________________________________________________________________
5169void 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//_____________________________________________________________________________
5358void 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//_____________________________________________________________________________
5562void 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//_____________________________________________________________________________
5765void 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//_____________________________________________________________________________
5959void 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//_____________________________________________________________________________
6163void 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;
81190958 6208 }
6209
cb690a12 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++ )
81190958 6215 {
cb690a12 6216 if ( p->GetBinEffectiveEntries(i) < 10 )
81190958 6217 {
cb690a12 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 }
81190958 6235 }
6236 }
cb690a12 6237 //_____________
81190958 6238
cb690a12 6239 TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol3,fitRangeLow,fitRangeHigh,4,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol3");
81190958 6240
cb690a12 6241 bck->SetParameters(3.,1.,-0.4,0.05);
81190958 6242
cb690a12 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);
81190958 6247
cb690a12 6248 SetFitRejectRange(2.3,4.0);
81190958 6249
cb690a12 6250 p->Fit(bck,"SER","",fitRangeLow,fitRangeHigh);
81190958 6251
cb690a12 6252 SetFitRejectRange();
81190958 6253
81190958 6254
81190958 6255
cb690a12 6256 TF1* fitMeanpt = new TF1("fitMeanpt",this,&AliAnalysisMuMuJpsiResult::FitFunctionMeanPtS2CB2VWGPOL3,fitRangeLow,fitRangeHigh,18,"AliAnalysisMuMuJpsiResult","FitFunctionMeanPtS2CB2VWGPOL3");
81190958 6257
cb690a12 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");
81190958 6266
cb690a12 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);
81190958 6279
cb690a12 6280 fitMeanpt->SetParameter(12, 3.);
6281 fitMeanpt->SetParLimits(12, 1.0,5.);
81190958 6282
cb690a12 6283 for ( Int_t i = 0; i < 4; ++i )
81190958 6284 {
cb690a12 6285 fitMeanpt->SetParameter(i + 13, bck->GetParameter(i));
81190958 6286 }
6287
cb690a12 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.);
81190958 6296
cb690a12 6297 fitMeanpt->SetParameter(17, 3.);
6298 fitMeanpt->SetParLimits(17, 0.,10.);
81190958 6299
81190958 6300
cb690a12 6301 // TProfile::Approximate();
81190958 6302
cb690a12 6303 const char* fitOption = "SER"; //+";//SER
81190958 6304
cb690a12 6305 TFitResultPtr fitResult = p->Fit(fitMeanpt,fitOption,"");
81190958 6306
cb690a12 6307 std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
81190958 6308
cb690a12 6309 if ( static_cast<int>(fitResult) )
81190958 6310 {
cb690a12 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;
81190958 6318 }
cb690a12 6319 else if ( fitMeanpt->GetParameter(17) <= fitMeanpt->GetParError(17) || fitMeanpt->GetParError(17) >= 0.75*fitMeanpt->GetParameter(17) )
81190958 6320 {
cb690a12 6321 fitMeanpt->FixParameter(17, 0.);
6322 for ( Int_t i = 0; i < 4; ++i )
81190958 6323 {
cb690a12 6324 fitMeanpt->SetParameter(i + 13, bck->GetParameter(i)*0.6);
81190958 6325 }
cb690a12 6326 fitResult = p->Fit(fitMeanpt,fitOption,"");
6327
6328 std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
81190958 6329 }
6330
cb690a12 6331 // TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
81190958 6332
cb690a12 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));
81190958 6340
81190958 6341}
6342
6343//_____________________________________________________________________________
cb690a12 6344void AliAnalysisMuMuJpsiResult::FitMPTPSIPSIPRIMECB2VWG_BKGMPTLIN()
81190958 6345{
cb690a12 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 }
81190958 6430
cb690a12 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.);
81190958 6439
cb690a12 6440 fitMeanpt->SetParameter(15, 3.);
6441 fitMeanpt->SetParLimits(15, 0.5,6.);
81190958 6442
81190958 6443
cb690a12 6444 // TProfile::Approximate();
81190958 6445
cb690a12 6446 const char* fitOption = "SER"; //+";
81190958 6447
cb690a12 6448 TFitResultPtr fitResult = fHisto->Fit(fitMeanpt,fitOption,"");
81190958 6449
cb690a12 6450 // TF1* bck = new TF1("bck",this,&AliAnalysisMuMuJpsiResult::FitFunctionBackgroundPol2,fitRangeLow,fitRangeHigh,3,"AliAnalysisMuMuJpsiResult","FitFunctionBackgroundPol2");
81190958 6451
cb690a12 6452 bck->SetParameters(fitMeanpt->GetParameter(13),fitMeanpt->GetParameter(14));
81190958 6453
cb690a12 6454 AttachFunctionsToHisto(0x0,bck,fitMeanpt,fitRangeLow,fitRangeHigh);//
81190958 6455
cb690a12 6456 Set("NofJPsi",NofJPsi,ErrStatNofJPsi);
6457 Set("MeanPtJPsi",fitMeanpt->GetParameter(12),fitMeanpt->GetParError(12));
6458 Set("MeanPtPsiP",fitMeanpt->GetParameter(15),fitMeanpt->GetParError(15));
81190958 6459
cb690a12 6460}
81190958 6461
cb690a12 6462//_____________________________________________________________________________
6463void 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));
81190958 6575
cb690a12 6576}
81190958 6577
cb690a12 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//_____________________________________________________________________________
6677void 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");
81190958 6755
cb690a12 6756 bck->SetParameters(3.,-0.5,-0.5,1.5,-0.01);
81190958 6757
cb690a12 6758 bck->SetParLimits(0, 1.,8.0);
81190958 6759
cb690a12 6760 SetFitRejectRange(2.7,4.0);
81190958 6761
cb690a12 6762 p->Fit(bck,"SER","");
81190958 6763
cb690a12 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 }
81190958 6798
cb690a12 6799 fitMeanpt->SetParameter(18, 3.);
6800 fitMeanpt->SetParLimits(18, 0.,10.);
6801
6802 const char* fitOption = "SER"; //+";//SER
81190958 6803
cb690a12 6804 TFitResultPtr fitResult = p->Fit(fitMeanpt,fitOption,"");
6805
6806 std::cout << "FitResultt=" << static_cast<int>(fitResult) << std::endl;
81190958 6807
cb690a12 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 }
81190958 6834
cb690a12 6835 AttachFunctionsToHisto(0x0,bck,fitMeanpt,fitRangeLow,fitRangeHigh);//
81190958 6836
cb690a12 6837 Set("NofJPsi",NofJPsi,ErrStatNofJPsi);
6838 Set("MeanPtJPsi",fitMeanpt->GetParameter(12),fitMeanpt->GetParError(12));
6839 Set("MeanPtPsiP",fitMeanpt->GetParameter(16),fitMeanpt->GetParError(16));
6840
81190958 6841}
6842
cb690a12 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
81190958 7196//_____________________________________________________________________________
cb690a12 7197Bool_t AliAnalysisMuMuJpsiResult::AddFit(const char* fitType)
81190958 7198{
7199 // Add a fit to this result
7200
cb690a12 7201 if ( !fHisto ) return kFALSE;
7202
7203 TH1* histo = static_cast<TH1*>(fHisto->Clone(fitType));
81190958 7204
cb690a12 7205 AliAnalysisMuMuJpsiResult* r = new AliAnalysisMuMuJpsiResult(GetParticle(),*histo,fitType);
7206
7207 if ( !r->IsValid() )
81190958 7208 {
cb690a12 7209 delete r;
7210 return kFALSE;
81190958 7211 }
7212
cb690a12 7213 TMethodCall callEnv;
7214
7215 TString fittingMethod(r->GetFitFunctionMethodName().Data());
81190958 7216
cb690a12 7217 std::cout << "+Using fitting method " << fittingMethod.Data() << "..." << std::endl;
7218 std::cout << "" << std::endl;
81190958 7219
cb690a12 7220 callEnv.InitWithPrototype(IsA(),fittingMethod.Data(),"");
81190958 7221
cb690a12 7222 if (callEnv.IsValid())
7223 {
7224 callEnv.Execute(r);
7225 }
7226 else
81190958 7227 {
cb690a12 7228 AliError(Form("Could not get the method %s",fittingMethod.Data()));
7229 delete r;
7230 return kFALSE;
81190958 7231 }
7232
cb690a12 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// }
81190958 7255
cb690a12 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// }
81190958 7293
cb690a12 7294 if ( r->IsValid() )
7295 {
7296 StdoutToAliDebug(1,r->Print(););
7297 r->SetBin(Bin());
7298 r->SetNofTriggers(NofTriggers());
7299 r->SetNofRuns(NofRuns());
81190958 7300
cb690a12 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 }
81190958 7310
cb690a12 7311 return (r!=0x0);
7312}
7313
7314//_____________________________________________________________________________
7315void 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.
81190958 7333
cb690a12 7334 TString resultName("");
81190958 7335
cb690a12 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;
81190958 7344
cb690a12 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()) ) )
81190958 7354 {
cb690a12 7355 TString key,value;
7356 Bool_t ok = GetKeyValue(str->String(),'=',key,value);
7357 if (!ok)
81190958 7358 {
cb690a12 7359 AliErrorClass(Form("Invalid key=value pair %s",str->String().Data()));
7360 continue;
81190958 7361 }
cb690a12 7362
7363 if ( key.CompareTo(kKeyFunc,TString::kIgnoreCase) == 0 )
81190958 7364 {
cb690a12 7365 fitFunction = value;
7366 resultName += fitFunction;
81190958 7367 }
cb690a12 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 )
81190958 7407 {
cb690a12 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();
81190958 7425 }
7426 else
7427 {
cb690a12 7428 Set(key.Data(),value.Atof(),0.0);
81190958 7429 }
7430 }
cb690a12 7431
7432 if ( fitFunction.CountChar('-') )
81190958 7433 {
cb690a12 7434 AliError(Form("Invalid fit function name : %s",fitFunction.Data()));
7435 Invalidate();
81190958 7436 }
cb690a12 7437 else
81190958 7438 {
cb690a12 7439
7440 fFitFunction = fitFunction;
81190958 7441
cb690a12 7442 Set(kKeySPsiP,paramSPsiP,0.0);
7443 Set(kKeyRebin,rebin,0.0);
7444 Set(kFitRangeLow,fitMinvMin,0.0);
7445 Set(kFitRangeHigh,fitMinvMax,0.0);
81190958 7446 }
7447
cb690a12 7448 delete parts;
7449}
7450
7451//_____________________________________________________________________________
7452TString 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());
81190958 7462}
7463
7464//_____________________________________________________________________________
7465Long64_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//_____________________________________________________________________________
7486Int_t AliAnalysisMuMuJpsiResult::NofRuns() const
7487{
7488 /// Get the number of runs
7489 if ( !Mother() ) return fNofRuns;
7490 else return Mother()->NofRuns();
7491}
7492
7493//_____________________________________________________________________________
7494Int_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//_____________________________________________________________________________
7503void 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//_____________________________________________________________________________
7516void 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//_____________________________________________________________________________
7538void 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//_____________________________________________________________________________
7563void AliAnalysisMuMuJpsiResult::SetBin(const AliAnalysisMuMuBinning::Range& bin)
7564{
7565 /// Set the bin
7566
7567 if (!Mother()) fBin = bin;
7568 else Mother()->SetBin(bin);
7569}
7570
cb690a12 7571//_____________________________________________________________________________
7572void 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//_____________________________________________________________________________
7587void 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
81190958 7597//_____________________________________________________________________________
7598void AliAnalysisMuMuJpsiResult::SetNofInputParticles(const TH1& hminv)
7599{
7600 /// Set the number of input particle from the invariant mass spectra
7601
cb690a12 7602 static const char* particleNames[] = { "JPsi" , "PsiP", "Upsilon","UpsilonPrime" };
81190958 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//_____________________________________________________________________________
7629void 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//_____________________________________________________________________________
7669void AliAnalysisMuMuJpsiResult::SetNofRuns(Int_t n)
7670{
7671 if ( !Mother() ) fNofRuns=n;
7672 else Mother()->SetNofRuns(n);
7673}
7674
7675//_____________________________________________________________________________
7676void AliAnalysisMuMuJpsiResult::SetNofTriggers(Int_t n)
7677{
7678 if ( !Mother() ) fNofTriggers=n;
7679 else Mother()->SetNofTriggers(n);
7680}
7681
cb690a12 7682
81190958 7683//_____________________________________________________________________________
cb690a12 7684void AliAnalysisMuMuJpsiResult::SetParameter(TF1* func, Int_t npar, Double_t fix, Double_t initialValue,
7685 Double_t min, Double_t max) const
81190958 7686{
cb690a12 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//_____________________________________________________________________________
7701Bool_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;
81190958 7712
cb690a12 7713 if ( strongCorrelation )
7714 {
7715 fitFunction->FixParameter(npar2,fixValueIfWrong);
7716 return kTRUE;
7717 }
7718 return kFALSE;
7719}
7720
7721//_____________________________________________________________________________
7722Bool_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;
81190958 7743}