PWGDQ/dielectron/AliDielectronBtoJPSItoEleCDFfitFCN.h

   1 #ifndef ALIDIELECTRONBTOJPSITOELECDFFITFCN_H\r
   2 #define ALIDIELECTRONBTOJPSITOELECDFFITFCN_H\r
   3 /* Copyright(c) 1998-2009, ALICE Experiment at CERN, All rights reserved. *\r
   4  * See cxx source for full Copyright notice                               */\r
   5 \r
   6 //_________________________________________________________________________\r
   7 //                      Class AliDielectronBtoJPSItoEleCDFfitFCN\r
   8 //                    Definition of main function used in \r
   9 //                     unbinned log-likelihood fit for\r
  10 //                 the channel B -> JPsi + X -> e+e- + X\r
  11 //      \r
  12 //                          Origin: C.Di Giglio\r
  13 //     Contact: Carmelo.Digiglio@ba.infn.it , Giuseppe.Bruno@ba.infn.it\r
  14 //_________________________________________________________________________\r
  15 \r
  16 #include <TNamed.h>\r
  17 #include <TDatabasePDG.h>\r
  18 #include <TH1F.h>\r
  19 \r
  20 \r
  21 class TRandom3;\r
  22 class TF1;\r
  23 \r
  24 //_________________________________________________________________________________________________\r
  25 class AliDielectronBtoJPSItoEleCDFfitFCN : public TNamed {\r
  26         public:\r
  27                 //\r
  28                 AliDielectronBtoJPSItoEleCDFfitFCN();\r
  29                 AliDielectronBtoJPSItoEleCDFfitFCN(const AliDielectronBtoJPSItoEleCDFfitFCN& source); \r
  30                 AliDielectronBtoJPSItoEleCDFfitFCN& operator=(const AliDielectronBtoJPSItoEleCDFfitFCN& source);  \r
  31                 virtual ~AliDielectronBtoJPSItoEleCDFfitFCN();\r
  32 \r
  33                 Double_t EvaluateLikelihood(const Double_t* pseudoproperdecaytime,\r
  34                                 const Double_t* invariantmass, const Double_t* pt, const Int_t* type, const Int_t ncand) const;\r
  35 \r
  36                 // getters for parameters\r
  37                 Double_t GetResWeight()                    const { return fParameters[0]; }\r
  38                 Double_t GetFPlus()                        const { return fParameters[1]; }\r
  39                 Double_t GetFMinus()                       const { return fParameters[2]; }\r
  40                 Double_t GetFSym()                         const { return fParameters[3]; } \r
  41                 Double_t GetFSym1()                        const { return fParameters[46]; }\r
  42                 Double_t GetLamPlus()                      const { return fParameters[4]; }\r
  43                 Double_t GetLamMinus()                     const { return fParameters[5]; }\r
  44                 Double_t GetLamSym()                       const { return fParameters[6]; }\r
  45                 Double_t GetLamSym1()                      const { return fParameters[45]; }\r
  46                 Double_t GetFractionJpsiFromBeauty()       const { return fParameters[7]; }\r
  47                 Double_t GetFsig()                         const { return fParameters[8]; }\r
  48                 Double_t GetCrystalBallMmean()             const { return fParameters[9]; }\r
  49                 Double_t GetCrystalBallNexp()              const { return fParameters[10]; }\r
  50                 Double_t GetCrystalBallSigma()             const { return fParameters[11]; }\r
  51                 Double_t GetCrystalBallAlpha()             const { return fParameters[12]; }\r
  52                 Double_t GetCrystalBallNorm()              const { return fParameters[13]; }\r
  53                 Double_t GetBkgInvMassNorm()               const { return fParameters[14]; }\r
  54                 Double_t GetBkgInvMassMean()               const { return fParameters[15]; }\r
  55                 Double_t GetBkgInvMassSlope()              const { return fParameters[16]; }  \r
  56                 Double_t GetBkgInvMassConst()              const { return fParameters[17]; } \r
  57                 Double_t GetNormGaus1ResFunc(Int_t type)   const { return fParameters[18+(2-type)*9]; }\r
  58                 Double_t GetNormGaus2ResFunc(Int_t type)   const { return fParameters[19+(2-type)*9]; }\r
  59                 Double_t GetIntegralMassSig()              const { return fintmMassSig; }\r
  60                 Double_t GetIntegralMassBkg()              const { return fintmMassBkg; }\r
  61                 Double_t GetResMean1(Int_t type)           const { return fParameters[20+(2-type)*9]; } \r
  62                 Double_t GetResSigma1(Int_t type)          const { return fParameters[21+(2-type)*9]; }\r
  63                 Double_t GetResMean2(Int_t type)           const { return fParameters[22+(2-type)*9]; }\r
  64                 Double_t GetResSigma2(Int_t type)          const { return fParameters[23+(2-type)*9]; }\r
  65                 Double_t GetResAlfa(Int_t type)            const { return fParameters[24+(2-type)*9]; }   \r
  66                 Double_t GetResLambda(Int_t type)          const { return fParameters[25+(2-type)*9]; } \r
  67                 Double_t GetResNormExp(Int_t type)         const { return fParameters[26+(2-type)*9]; }\r
  68                 Double_t GetPolyn4()                       const { return fParameters[47]; }\r
  69                 Double_t GetPolyn5()                       const { return fParameters[48]; }\r
  70                 Bool_t GetCrystalBallParam()               const { return fCrystalBallParam; }\r
  71                 Bool_t GetExponentialParam()               const { return fExponentialParam; }\r
  72                 TH1F * GetCsiMcHisto()                     const { return fhCsiMC; }\r
  73                 Double_t GetResWeight(Int_t iW)            const { return fWeightType[iW]; }\r
  74 \r
  75                 // return pointer to likelihood functions  \r
  76                 TF1* GetCsiMC(Double_t xmin, Double_t xmax,Double_t normalization);\r
  77                 TF1* GetResolutionFunc(Double_t xmin, Double_t xmax,Double_t normalization, Double_t pt, Int_t type=2);\r
  78                 TF1* GetResolutionFuncAllTypes(Double_t xmin, Double_t xmax,Double_t normalization);\r
  79                 TF1* GetFunB(Double_t xmin, Double_t xmax, Double_t normalization, Double_t pt, Int_t type=2, Int_t npx = 5000);\r
  80                 TF1* GetFunBAllTypes(Double_t xmin, Double_t xmax, Double_t normalization);\r
  81                 TF1* GetEvaluateCDFDecayTimeBkgDistr(Double_t xmin, Double_t xmax, Double_t normalization, Int_t type = 2, Double_t mass = 3.09, Double_t pt = 200.,Int_t npx = 5000);\r
  82                 TF1* GetEvaluateCDFDecayTimeBkgDistrAllTypes(Double_t xmin, Double_t xmax, Double_t normalization);\r
  83                 TF1* GetEvaluateCDFDecayTimeSigDistr(Double_t xmin, Double_t xmax, Double_t normalization, Double_t type);\r
  84                 TF1* GetEvaluateCDFInvMassBkgDistr(Double_t mMin, Double_t mMax, Double_t normalization);\r
  85                 TF1* GetEvaluateCDFInvMassSigDistr(Double_t mMin, Double_t mMax, Double_t normalization);\r
  86                 TF1* GetEvaluateCDFInvMassTotalDistr(Double_t mMin, Double_t mMax, Double_t normalization);\r
  87                 TF1* GetEvaluateCDFDecayTimeTotalDistr(Double_t xMin, Double_t xMax, Double_t normalization,Double_t pt = 200., Int_t type=2);\r
  88                 TF1 *GetEvaluateCDFDecayTimeTotalDistrAllTypes(Double_t xMin, Double_t xMax, Double_t normalization);\r
  89 \r
  90                 void SetResWeight(Double_t resWgt) {fParameters[0] = resWgt;}\r
  91                 void SetFPlus(Double_t plus) {fParameters[1] = plus;}\r
  92                 void SetFMinus(Double_t minus) {fParameters[2]  = minus;}\r
  93                 void SetFSym(Double_t sym) {fParameters[3] = sym;}\r
  94                 void SetFSym1(Double_t sym) {fParameters[46] = sym;}\r
  95                 void SetLamPlus(Double_t lamplus) {fParameters[4] = lamplus;}\r
  96                 void SetLamMinus(Double_t lamminus) {fParameters[5] = lamminus;}\r
  97                 void SetLamSym(Double_t lamsym) {fParameters[6] = lamsym;}\r
  98                 void SetLamSym1(Double_t lamsym) {fParameters[45] = lamsym;}\r
  99                 void SetFractionJpsiFromBeauty(Double_t B) {fParameters[7] = B;}\r
 100                 void SetFsig(Double_t Fsig) {fParameters[8] = Fsig;}\r
 101                 void SetCrystalBallMmean(Double_t CrystalBallMmean) {fParameters[9] = CrystalBallMmean;}\r
 102                 void SetCrystalBallNexp(Double_t CrystalBallNexp) {fParameters[10] = CrystalBallNexp;}\r
 103                 void SetCrystalBallSigma(Double_t CrystalBallSigma) {fParameters[11] = CrystalBallSigma;}\r
 104                 void SetCrystalBallAlpha(Double_t CrystalBallAlpha) {fParameters[12] = CrystalBallAlpha;}\r
 105                 void SetCrystalBallNorm(Double_t CrystalBallNorm) {fParameters[13] = CrystalBallNorm;}\r
 106                 void SetBkgInvMassNorm(Double_t BkgInvMassNorm) {fParameters[14] = BkgInvMassNorm;}\r
 107                 void SetBkgInvMassMean(Double_t BkgInvMassMean) {fParameters[15] = BkgInvMassMean;}\r
 108                 void SetBkgInvMassSlope(Double_t BkgInvMassSlope) {fParameters[16] = BkgInvMassSlope;}\r
 109                 void SetBkgInvMassConst(Double_t BkgInvMassConst) {fParameters[17] = BkgInvMassConst;}\r
 110                 void SetBkgInvMassPolyn4(Double_t coeffPol4) {fParameters[47] = coeffPol4;}\r
 111                 void SetBkgInvMassPolyn5(Double_t coeffPol5) {fParameters[48] = coeffPol5;}\r
 112                 void SetNormGaus1ResFunc(Double_t norm1) {fParameters[18] = norm1;}\r
 113                 void SetNormGaus2ResFunc(Double_t norm2) {fParameters[19] = norm2;}\r
 114                 void SetAllParameters(const Double_t* parameters);\r
 115                 void SetIntegralMassSig(Double_t integral) { fintmMassSig = integral; }\r
 116                 void SetIntegralMassBkg(Double_t integral) { fintmMassBkg = integral; }\r
 117                 void SetCsiMC(const TH1F* MCtemplate) {fhCsiMC = (TH1F*)MCtemplate->Clone("fhCsiMC");}\r
 118                 void SetTemplateShift(Double_t shift = 0.){fShiftTemplate = shift;}\r
 119  \r
 120                 void SetResolutionConstants(const Double_t* resolutionConst, Int_t type);\r
 121                 void SetMassWndHigh(Double_t limit) { fMassWndHigh = TDatabasePDG::Instance()->GetParticle(443)->Mass() + limit ;}\r
 122                 void SetMassWndLow(Double_t limit) { fMassWndLow = TDatabasePDG::Instance()->GetParticle(443)->Mass() - limit ;}\r
 123                 void SetCrystalBallFunction(Bool_t okCB) {fCrystalBallParam = okCB;}\r
 124                 void SetExponentialFunction(Bool_t okExp) {fExponentialParam = okExp;}\r
 125  \r
 126                 void SetWeightType(Double_t wFF, Double_t wFS, Double_t wSS) {fWeightType[0]= wSS; fWeightType[1]= wFS; fWeightType[2]= wFF;}\r
 127 \r
 128                 void SetChangeResolution(Double_t change){fChangeResolution = change;}   \r
 129                 void SetChangeMass(Double_t change){fChangeMass = change;}   \r
 130                 void ComputeMassIntegral(); \r
 131                 void ReadMCtemplates(Int_t BinNum);\r
 132                 void PrintStatus();\r
 133 \r
 134                 //specific methods for multi-variational fit\r
 135                 void SetBkgWeights(Double_t ***bkgWgt){for(int kpt=0; kpt<(fPtWindows->GetSize()-1); kpt++){for(int k=0; k<(fMassWindows->GetSize()-2); k++) { for(int ktype=0; ktype<3; ktype++) fWeights[k][kpt][ktype]=bkgWgt[k][kpt][ktype]; }}}\r
 136  \r
 137                 void SetBkgFunction(Int_t massRange,Int_t type, Int_t ptB, TF1 *histBkg){\r
 138                 fFunBkgSaved[ptB][massRange][type] = histBkg;\r
 139                 }\r
 140                 TF1 *GetBkgFunction(Int_t massRange, Int_t ptB, Int_t type) const {return fFunBkgSaved[ptB][massRange][type];} \r
 141                 void SetFunBFunction(Int_t type, Int_t ptB, TF1 *histSec) { fFunBSaved[ptB][type] = histSec; }\r
 142                 void SetBackgroundSpecificParameters(Int_t pt, Int_t mb, Int_t tp);\r
 143                 void SetExtrapolationRegion(Int_t extrRegion){fSignalBinForExtrapolation = extrRegion;}                                            void SetLoadFunction(Bool_t loadFunc) { fLoadFunctions = loadFunc;}\r
 144                 void SetMultivariateFit(Bool_t multVar) { fMultivariate = multVar;}\r
 145                 Bool_t GetMultivariate() const { return fMultivariate;} \r
 146                 void SetFunctionsSaved(Int_t npxFunB=5000, Int_t npxFunBkg=5000, Double_t funBLimits = 20000., Double_t funBkgLimits = 40000., Int_t signalRegion=2);\r
 147                 void SetResParams(Double_t ***pars){ fResParams = pars;}\r
 148                 void SetBkgParams(Float_t ****pars){ fBkgParams = pars;}\r
 149                 void SetMassWindows(TArrayD *msWnd){ fMassWindows = msWnd;}\r
 150                 void SetPtWindows(TArrayD *ptWnd){ fPtWindows = ptWnd;}\r
 151                 void InitializeFunctions(Int_t ptSize, Int_t massSize);\r
 152                 Double_t EvaluateCDFInvMassSigDistr(Double_t m) const ;\r
 153                 Double_t EvaluateCDFInvMassBkgDistr(Double_t m) const;\r
 154                 Double_t ResolutionFunc(Double_t x, Double_t pt, Int_t type) const;\r
 155                 Double_t EvaluateCDFDecayTimeBkgDistr(Double_t x, Int_t type, Double_t m=3.09, Double_t pt=200.) const ;\r
 156         \r
 157 \r
 158         private:  \r
 159                 Double_t fParameters[49];        /*  par[0]  = weightRes;                \r
 160                                                      par[1]  = fPos;\r
 161                                                      par[2]  = fNeg;\r
 162                                                      par[3]  = fSym\r
 163                                                      par[4]  = fOneOvLamPlus;\r
 164                                                      par[5]  = fOneOvLamMinus;\r
 165                                                      par[6]  = fOneOvLamSym;\r
 166                                                      par[7]  = fFractionJpsiFromBeauty;\r
 167                                                      par[8]  = fFsig;\r
 168                                                      par[9]  = fCrystalBallMmean;\r
 169                                                      par[10] = fCrystalBallNexp;\r
 170                                                      par[11] = fCrystalBallSigma;\r
 171                                                      par[12] = fCrystalBallAlpha;\r
 172                                                      par[13] = fCrystalBallNorm;\r
 173                                                      par[14] = fBkgNorm;\r
 174                                                      par[15] = fBkgMean; \r
 175                                                      par[16] = fBkgSlope;\r
 176                                                      par[17] = fBkgConst;\r
 177                                                      par[18] = norm1Gaus; // resolution param used for First-First\r
 178                                                      par[19] = norm2Gaus;\r
 179                                                      par[20] = fMean1ResFunc;\r
 180                                                      par[21] = fSigma1ResFunc;\r
 181                                                      par[22] = fMean2ResFunc;\r
 182                                                      par[23] = fSigma2ResFunc;\r
 183                                                      par[24] = fResAlfa;  \r
 184                                                      par[25] = fResLambda;\r
 185                                                      par[26] = fResNormExp;\r
 186                                                      par[27] = norm1Gaus;    // resolution param used for First-Second\r
 187                                                      par[28] = norm2Gaus;\r
 188                                                      par[29] = fMean1ResFunc;\r
 189                                                      par[30] = fSigma1ResFunc;\r
 190                                                      par[31] = fMean2ResFunc;\r
 191                                                      par[32] = fSigma2ResFunc;\r
 192                                                      par[33] = fResAlfa;  \r
 193                                                      par[34] = fResLambda;\r
 194                                                      par[35] = fResNormExp;\r
 195                                                      par[36] = norm1Gaus;    // resolution param used for Second-Second\r
 196                                                      par[37] = norm2Gaus;\r
 197                                                      par[38] = fMean1ResFunc;\r
 198                                                      par[39] = fSigma1ResFunc;\r
 199                                                      par[40] = fMean2ResFunc;\r
 200                                                      par[41] = fSigma2ResFunc;\r
 201                                                      par[42] = fResAlfa; \r
 202                                                      par[43] = fResLambda;\r
 203                                                      par[44] = fResNormExp;   \r
 204                                                      ------------------------------> parameters to describe x and m à la CDF\r
 205                                                      // additional parameters below (added for PbPb analysis): if not used should be fixed\r
 206                                                      // by the FitHandler pointer\r
 207                                                      par[45] = fOneOvLamSym1; //  additional parameter for background\r
 208                                                      par[46] = fSym1;         //  additional parameter for background\r
 209                                                      par[47] = fPolyn4; //additional parameter for inv. mass background\r
 210                                                      par[48] = fPolyn5; //additional parameter for inv. mass background */\r
 211                                                    \r
 212                 Double_t fFPlus;                     // parameter of the log-likelihood function\r
 213                 Double_t fFMinus;                    // slopes of the x distributions of the background \r
 214                 Double_t fFSym;                      // functions \r
 215 \r
 216                 Double_t fintmMassSig;               // integral of invariant mass distribution for the signal\r
 217                 Double_t fintmMassBkg;               // integral of invariant mass distribution for the bkg\r
 218 \r
 219                 TH1F *fhCsiMC;                       // X distribution used as MC template for JPSI from B\r
 220 \r
 221                 Double_t fShiftTemplate;             // to shift the MC template\r
 222                 Double_t fMassWndHigh;               // JPSI Mass window higher limit\r
 223                 Double_t fMassWndLow;                // JPSI Mass window lower limit\r
 224                 Bool_t fCrystalBallParam;            // Boolean to switch to Crystall Ball parameterisation\r
 225 \r
 226                 Double_t fWeightType[3];             // vector with weights of candidates types (used to draw functions)            \r
 227                 Double_t fChangeResolution;          // constant to change the RMS of the resolution function\r
 228                 Double_t fChangeMass;                // constant to change the RMS of the signal mass function\r
 229                 \r
 230                 // data members for multivariate fit\r
 231                 Double_t ***fWeights;                // weights to interpolate bkg shape in pt, mass, type bins under signal region\r
 232                 Bool_t fLoadFunctions;               // boolean to load functions saved \r
 233                 Bool_t fMultivariate;                // switch-on multivariate fit\r
 234                 TF1 ***fFunBSaved;                   // pointers to save functions for x of non-prompt J/psi in pt, mass, type bins\r
 235                 TF1 ****fFunBkgSaved;                // pointers to save functions for x of background in pt, mass, type bins\r
 236                 Double_t ***fResParams;              // resolution function parameters in pt and type bins\r
 237                 Float_t ****fBkgParams;              // x background parameters in pt, mass, type bins\r
 238                 TArrayD *fMassWindows;               // limits for invariant mass bins\r
 239                 TArrayD *fPtWindows;                 // limits for pt bins\r
 240                 Bool_t fExponentialParam;            // Boolean to switch to Exponential parameterisation\r
 241                 Double_t fSignalBinForExtrapolation; // inv. mass region in which extrapolate the background shape\r
 242                                                      // starting from background shapes in the near inv. mass regions\r
 243 \r
 244 \r
 245                 Double_t EvaluateCDFfunc(Double_t x, Double_t m, Double_t pt, Int_t type) const ;\r
 246                 Double_t EvaluateCDFfuncNorm(Double_t x, Double_t m, Double_t pt, Int_t type) const ;\r
 247                 Double_t EvaluateCDFfuncSignalPart(Double_t x, Double_t m, Double_t pt, Int_t type) const ;      // Signal part \r
 248                 Double_t EvaluateCDFDecayTimeSigDistr(Double_t x, Double_t pt, Int_t type) const ;\r
 249                 Double_t EvaluateCDFDecayTimeSigDistrFunc(const Double_t* x, const Double_t *par) const { return par[0]*EvaluateCDFDecayTimeSigDistr(x[0],par[1],(Int_t)par[2]);}\r
 250                 Double_t EvaluateCDFInvMassSigDistrFunc(const Double_t* x, const Double_t *par) const {return par[0]*EvaluateCDFInvMassSigDistr(x[0])/fintmMassSig;}\r
 251                 Double_t EvaluateCDFfuncBkgPart(Double_t x,Double_t m, Double_t pt, Int_t type) const ;          // Background part\r
 252                 Double_t EvaluateCDFDecayTimeBkgDistrFunc(const Double_t* x, const Double_t *par) const { return EvaluateCDFDecayTimeBkgDistr(x[0],(Int_t)par[1],par[2],par[3])*par[0];}\r
 253                 Double_t EvaluateCDFDecayTimeBkgDistrFuncAllTypes(const Double_t* x, const Double_t *par) const {return (fWeightType[2]*EvaluateCDFDecayTimeBkgDistr(x[0],2)+fWeightType[1]*EvaluateCDFDecayTimeBkgDistr(x[0],1)+fWeightType[0]*EvaluateCDFDecayTimeBkgDistr(x[0],0))*par[0];}\r
 254                 Double_t EvaluateCDFInvMassBkgDistrFunc(const Double_t* x, const Double_t *par) const {return par[0]*EvaluateCDFInvMassBkgDistr(x[0])/fintmMassBkg;} \r
 255                   \r
 256                 Double_t EvaluateCDFInvMassTotalDistr(const Double_t* x, const Double_t *par) const;\r
 257                 Double_t EvaluateCDFDecayTimeTotalDistr(const Double_t* x, const Double_t *par) const;  \r
 258                 ////\r
 259                 Double_t EvaluateCDFDecayTimeTotalDistrAllTypes(const Double_t* x, const Double_t *par) const;\r
 260 \r
 261                 Double_t FunB(Double_t x, Double_t pt, Int_t type) const;\r
 262                 Double_t FunBfunc(const Double_t *x, const Double_t *par) const {return FunB(x[0],par[1],(Int_t)par[2])*par[0];}\r
 263                 Double_t FunBfuncAllTypes(const Double_t *x, const Double_t *par) const {return (fWeightType[2]*FunB(x[0],200.,2)+fWeightType[1]*FunB(x[0],200.,1)+fWeightType[0]*FunB(x[0],200.,0))*par[0];}\r
 264                 Double_t FunP(Double_t x, Double_t pt,Int_t type) const ;\r
 265                 Double_t CsiMC(Double_t x) const;\r
 266                 Double_t CsiMCfunc(const Double_t* x, const Double_t *par) const {  return CsiMC(x[0])*par[0];}\r
 267                 Double_t FunBkgPos(Double_t x, Double_t pt, Int_t type) const ;\r
 268                 Double_t FunBkgNeg(Double_t x, Double_t pt, Int_t type) const ;\r
 269                 Double_t FunBkgSym(Double_t x, Double_t pt, Int_t type) const ;\r
 270                 Double_t FunBkgSym1(Double_t x, Double_t pt, Int_t type) const ;\r
 271                 Double_t ResolutionFuncf(const Double_t* x, const Double_t *par) const { return ResolutionFunc(x[0],par[1],(Int_t)par[2])*par[0];}\r
 272                 Double_t ResolutionFuncAllTypes(const Double_t* x, const Double_t *par) const { return (fWeightType[2]*ResolutionFunc(x[0],200.,2)+fWeightType[1]*ResolutionFunc(x[0],200.,1)+fWeightType[0]*ResolutionFunc(x[0],200.,0))*par[0]; }                 \r
 273 \r
 274                 // private methods for multivariate fit \r
 275                 Double_t EvaluateCDFDecayTimeBkgDistrSaved(Double_t x, Int_t type, Double_t m=3.09, Double_t pt = 200.) const ;\r
 276                 Double_t EvaluateCDFDecayTimeBkgDistrDifferential(Double_t x, Int_t type, Double_t m=3.09, Double_t pt = 200.) const;\r
 277                 Double_t FunBsaved(Double_t x, Double_t pt, Int_t type) const;\r
 278 \r
 279                 ClassDef (AliDielectronBtoJPSItoEleCDFfitFCN,1);         // Unbinned log-likelihood fit \r
 280 \r
 281 };\r
 282 \r
 283 #endif\r