EMCAL/AliEMCALRecParam.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /* $Id$ */
  17
  18 //-----------------------------------------------------------------------------
  19 // Container of EMCAL reconstruction parameters
  20 // The purpose of this object is to store it to OCDB
  21 // and retrieve it in the corresponding reconstruction class:
  22 // AliEMCALClusterizer, AliEMCALPID, AliEMCALTracker ...
  23 //
  24 // Author: Yuri Kharlov
  25 //-----------------------------------------------------------------------------
  26
  27 // --- Root header files
  28 //#include "TObjArray.h"
  29
  30 // --- AliRoot header files ---
  31 #include "AliCDBManager.h"
  32 #include "AliCDBEntry.h"
  33 #include "AliEMCALRecParam.h"
  34
  35 ClassImp(AliEMCALRecParam)
  36
  37 TObjArray* AliEMCALRecParam::fgkMaps =0; //ALTRO mappings
  38
  39 AliEMCALRecParam::AliEMCALRecParam() :
  40   AliDetectorRecoParam(),
  41   fClusteringThreshold(0.5),
  42   fW0(4.5),
  43   fMinECut(0.45),
  44   fUnfold(kFALSE),
  45   fLocMaxCut(0.03),
  46   fTimeCut(1.),// high value, accept all
  47   fTimeMin(-1.),// small value, accept all
  48   fTimeMax(1.),// high value, accept all//clustering
  49   fClusterizerFlag(AliEMCALRecParam::kClusterizerv1),
  50   fMthCutEta(0.025),
  51   fMthCutPhi(0.05),
  52   fStep(50),
  53   fTrkCutPt(0.0),
  54   fTrkCutNITS(0.0),
  55   fTrkCutNTPC(50.0), //track matching
  56   fHighLowGainFactor(16.0),
  57   fOrderParameter(2),
  58   fTau(2.35),
  59   fNoiseThreshold(3),
  60   fNPedSamples(5),
  61   fRemoveBadChannels(kFALSE),
  62   fFittingAlgorithm(0),
  63   fUseFALTRO(kTRUE),
  64   fFitLEDEvents(kFALSE)//raw signal
  65 {
  66   // default reco values
  67
  68   // PID parameters for Pb Pb from Lambda0 distributions fitted by
  69   // a landau inverted + Gaussian for Gammas
  70   // and a Landau +Gaussian for Pi0 and hadrons
  71   // New parametrisation for
  72   // lambda0^2 (=x): f(x) = normLandau*TMath::Landau(((1-mpvlandau)-x),mpvLandau,widthLandau)+normgaus*TMath::Gaus(x,meangaus,sigmagaus) for gammas
  73   // lambda0^2 (=x): f(x) = normLandau*TMath::Landau(x,mpvLandau,widthLandau)+normgaus*TMath::Gaus(x,meangaus,sigmagaus) for pi0 & hadrons
  74
  75   // See AliEMCALPid
  76   // (index i) refers to each parameters of the f(lambda0^2)
  77   // i=0: normGaus
  78   // i=1: meanGaus
  79   // i=2: sigmaGaus
  80   // i=3: normLandau
  81   // i=4: mpvLandau
  82   // i=5: sigmaLanda
  83   // (index j) refers to the polynomial parameters of the fit of each parameter vs energy
  84   // Pb Pb
  85
  86   // as a first step, all array elements are initialized to 0.0
  87   Int_t i=0, j=0;
  88   for (i = 0; i < 6; i++) {
  89     for (j = 0; j < 6; j++) {
  90       fGamma[i][j] =  fPiZero[i][j] = fHadron[i][j] = 0.;
  91       fGamma1to10[i][j] =  fHadron1to10[i][j]= 0.;
  92     }
  93     fGammaEnergyProb[i] =0.; // not yet implemented
  94     fHadronEnergyProb[i]=0.;
  95     fPiZeroEnergyProb[i]=0.; // not yet implemented
  96
  97
  98   }
  99   // Set here default parameters for Pb+Pb (high flux)
 100
 101   fGamma[0][0] = -7.656908e-01;
 102   fGamma[0][1] =  2.352536e-01;
 103   fGamma[0][2] =  1.555996e-02;
 104   fGamma[0][3] =  2.243525e-04;
 105   fGamma[0][4] = -2.560087e-06;
 106
 107   fGamma[1][0] =  6.500216e+00;
 108   fGamma[1][1] = -2.564958e-01;
 109   fGamma[1][2] =  1.967894e-01;
 110   fGamma[1][3] = -3.982273e-04;
 111   fGamma[1][4] =  2.797737e-06;
 112
 113   fGamma[2][0] =  2.416489e+00;
 114   fGamma[2][1] = -1.601258e-01;
 115   fGamma[2][2] =  3.126839e-02;
 116   fGamma[2][3] =  3.387532e-04;
 117   fGamma[2][4] = -4.089145e-06;
 118
 119
 120   fGamma[3][0] =  0.;
 121   fGamma[3][1] = -2.696008e+00;
 122   fGamma[3][2] =  6.920305e-01;
 123   fGamma[3][3] = -2.281122e-03;
 124   fGamma[3][4] =  0.;
 125
 126   fGamma[4][0] =  2.281564e-01;
 127   fGamma[4][1] = -7.575040e-02;
 128   fGamma[4][2] =  3.813423e-01;
 129   fGamma[4][3] = -1.243854e-04;
 130   fGamma[4][4] =  1.232045e-06;
 131
 132   fGamma[5][0] = -3.290107e-01;
 133   fGamma[5][1] =  3.707545e-02;
 134   fGamma[5][2] =  2.917397e-03;
 135   fGamma[5][3] =  4.695306e-05;
 136   fGamma[5][4] = -3.572981e-07;
 137
 138
 139   fHadron[0][0] =   1.519112e-01;
 140   fHadron[0][1] = -8.267603e-02;
 141   fHadron[0][2] =  1.914574e-02;
 142   fHadron[0][3] = -2.677921e-04;
 143   fHadron[0][4] =  5.447939e-06;
 144
 145
 146   fHadron[1][0] = 0.;
 147   fHadron[1][1] = -7.549870e-02;
 148   fHadron[1][2] = 3.930087e-01;
 149   fHadron[1][3] = -2.368500e-03;
 150   fHadron[1][4] = 0.;
 151
 152   fHadron[2][0] = 0.;
 153   fHadron[2][1] =  -2.463152e-02;
 154   fHadron[2][2] = 1.349257e-01;
 155   fHadron[2][3] = -1.089440e-03;
 156   fHadron[2][4] = 0.;
 157
 158   fHadron[3][0] = 0.;
 159   fHadron[3][1] = 5.101560e-01;
 160   fHadron[3][2] = 1.458679e-01;
 161   fHadron[3][3] = 4.903068e-04;
 162   fHadron[3][4] = 0.;
 163
 164   fHadron[4][0] = 0.;
 165   fHadron[4][1] = -6.693943e-03;
 166   fHadron[4][2] =  2.444753e-01;
 167   fHadron[4][3] = -5.553749e-05;
 168   fHadron[4][4] = 0.;
 169
 170   fHadron[5][0] = -4.414030e-01;
 171   fHadron[5][1] = 2.292277e-01;
 172   fHadron[5][2] = -2.433737e-02;
 173   fHadron[5][3] =  1.758422e-03;
 174   fHadron[5][4] = -3.001493e-05;
 175
 176
 177   fPiZero[0][0] =  5.072157e-01;
 178   fPiZero[0][1] = -5.352747e-01;
 179   fPiZero[0][2] =  8.499259e-02;
 180   fPiZero[0][3] = -3.687401e-03;
 181   fPiZero[0][4] =  5.482280e-05;
 182
 183
 184   fPiZero[1][0] =  4.590137e+02;
 185   fPiZero[1][1] = -7.079341e+01;
 186   fPiZero[1][2] =  4.990735e+00;
 187   fPiZero[1][3] = -1.241302e-01;
 188   fPiZero[1][4] =  1.065772e-03;
 189
 190
 191   fPiZero[2][0] =  1.376415e+02;
 192   fPiZero[2][1] = -3.031577e+01;
 193   fPiZero[2][2] =  2.474338e+00;
 194   fPiZero[2][3] = -6.903410e-02;
 195   fPiZero[2][4] =  6.244089e-04;
 196
 197   fPiZero[3][0] = 0.;
 198   fPiZero[3][1] =  1.145983e+00;
 199   fPiZero[3][2] = -2.476052e-01;
 200   fPiZero[3][3] =  1.367373e-02;
 201   fPiZero[3][4] = 0.;
 202
 203   fPiZero[4][0] = -2.097586e+02;
 204   fPiZero[4][1] =  6.300800e+01;
 205   fPiZero[4][2] = -4.038906e+00;
 206   fPiZero[4][3] =  1.088543e-01;
 207   fPiZero[4][4] = -9.362485e-04;
 208
 209   fPiZero[5][0] = -1.671477e+01;
 210   fPiZero[5][1] =  2.995415e+00;
 211   fPiZero[5][2] = -6.040360e-02;
 212   fPiZero[5][3] = -6.137459e-04;
 213   fPiZero[5][4] =  1.847328e-05;
 214
 215   fHadronEnergyProb[0]= 0.;
 216   fHadronEnergyProb[1]= 0.;
 217   fHadronEnergyProb[2]=  6.188452e-02;
 218   fHadronEnergyProb[3]=  2.030230e+00;
 219   fHadronEnergyProb[4]= -6.402242e-02;
 220
 221   //unfolding
 222   fSSPars[0] = 0.9262;
 223   fSSPars[1] = 3.365;
 224   fSSPars[2] = 1.548;
 225   fSSPars[3] = 0.1625;
 226   fSSPars[4] = -0.4195;
 227   fSSPars[5] = 0.;
 228   fSSPars[6] = 0.;
 229   fSSPars[7] = 2.332;
 230   fPar5[0] = 12.31;
 231   fPar5[1] = -0.007381;
 232   fPar5[2] = -0.06936;
 233   fPar6[0] = 0.05452;
 234   fPar6[1] = 0.0001228;
 235   fPar6[2] = 0.001361;
 236
 237 }
 238
 239 //-----------------------------------------------------------------------------
 240 AliEMCALRecParam::AliEMCALRecParam(const AliEMCALRecParam& rp) :
 241   AliDetectorRecoParam(),
 242   fClusteringThreshold(rp.fClusteringThreshold),
 243   fW0(rp.fW0),
 244   fMinECut(rp.fMinECut),
 245   fUnfold(rp.fUnfold),
 246   fLocMaxCut(rp.fLocMaxCut),
 247   fTimeCut(rp.fTimeCut),
 248   fTimeMin(rp.fTimeMin),
 249   fTimeMax(rp.fTimeMax),//clustering
 250   fClusterizerFlag(rp.fClusterizerFlag),
 251   fMthCutEta(rp.fMthCutEta),
 252   fMthCutPhi(rp.fMthCutPhi),
 253   fStep(rp.fStep),
 254   fTrkCutPt(rp.fTrkCutPt),
 255   fTrkCutNITS(rp.fTrkCutNITS),
 256   fTrkCutNTPC(rp.fTrkCutNTPC), // track matching
 257   fHighLowGainFactor(rp.fHighLowGainFactor),
 258   fOrderParameter(rp.fOrderParameter),
 259   fTau(rp.fTau),
 260   fNoiseThreshold(rp.fNoiseThreshold),
 261   fNPedSamples(rp.fNPedSamples),
 262   fRemoveBadChannels(rp.fRemoveBadChannels),
 263   fFittingAlgorithm(rp.fFittingAlgorithm),
 264   fUseFALTRO(rp.fUseFALTRO),
 265   fFitLEDEvents(rp.fFitLEDEvents) //raw signal
 266 {
 267   //copy constructor
 268
 269   //PID values
 270   Int_t i=0, j=0;
 271   for (i = 0; i < 6; i++) {
 272     for (j = 0; j < 6; j++) {
 273       fGamma[i][j]       = rp.fGamma[i][j];
 274       fGamma1to10[i][j]  = rp.fGamma1to10[i][j];
 275       fHadron[i][j]      = rp.fHadron[i][j];
 276       fHadron1to10[i][j] = rp.fHadron1to10[i][j];
 277       fPiZero[i][j]      = rp.fPiZero[i][j];
 278     }
 279     fGammaEnergyProb[i]  = rp.fGammaEnergyProb[i];
 280     fPiZeroEnergyProb[i] = rp.fPiZeroEnergyProb[i];
 281     fHadronEnergyProb[i] = rp.fHadronEnergyProb[i];
 282
 283   }
 284
 285   //unfolding
 286   for (i = 0; i < 8; i++) {
 287     fSSPars[i] = rp.fSSPars[i];
 288   }
 289   for (i = 0; i < 3; i++) {
 290     fPar5[i] = rp.fPar5[i];
 291     fPar6[i] = rp.fPar6[i];
 292   }
 293
 294 }
 295
 296 //-----------------------------------------------------------------------------
 297 AliEMCALRecParam& AliEMCALRecParam::operator = (const AliEMCALRecParam& rp)
 298 {
 299   //assignment operator
 300
 301   if(this != &rp) {
 302     fClusteringThreshold = rp.fClusteringThreshold;
 303     fW0        = rp.fW0;
 304     fMinECut   = rp.fMinECut;
 305     fUnfold    = rp.fUnfold;
 306     fLocMaxCut = rp.fLocMaxCut;
 307     fTimeCut   = rp.fTimeCut;
 308     fTimeMax   = rp.fTimeMax;
 309     fTimeMin   = rp.fTimeMin;//clustering
 310     fClusterizerFlag   = rp.fClusterizerFlag;
 311     fMthCutEta         = rp.fMthCutEta;
 312     fMthCutPhi         = rp.fMthCutPhi;
 313     fStep              = rp.fStep;
 314     fTrkCutPt          = rp.fTrkCutPt;
 315     fTrkCutNITS        = rp.fTrkCutNITS;
 316     fTrkCutNTPC        = rp.fTrkCutNTPC; //track matching
 317     fHighLowGainFactor = rp.fHighLowGainFactor;
 318     fOrderParameter    = rp.fOrderParameter;
 319     fTau               = rp.fTau;
 320     fNoiseThreshold    = rp.fNoiseThreshold;
 321     fNPedSamples       = rp.fNPedSamples;
 322     fRemoveBadChannels = rp.fRemoveBadChannels;
 323     fFittingAlgorithm  = rp.fFittingAlgorithm;
 324     fUseFALTRO         = rp.fUseFALTRO;
 325     fFitLEDEvents      = rp.fFitLEDEvents;//raw signal
 326
 327     //PID values
 328     Int_t i=0, j=0;
 329     for (i = 0; i < 6; i++) {
 330       for (j = 0; j < 6; j++) {
 331         fGamma[i][j]       = rp.fGamma[i][j];
 332         fGamma1to10[i][j]  = rp.fGamma1to10[i][j];
 333         fHadron[i][j]      = rp.fHadron[i][j];
 334         fHadron1to10[i][j] = rp.fHadron1to10[i][j];
 335         fPiZero[i][j]      = rp.fPiZero[i][j];
 336       }
 337       fGammaEnergyProb[i]  = rp.fGammaEnergyProb[i];
 338       fPiZeroEnergyProb[i] = rp.fPiZeroEnergyProb[i];
 339       fHadronEnergyProb[i] = rp.fHadronEnergyProb[i];
 340     }
 341     //unfolding
 342     for (i = 0; i < 8; i++) {
 343       fSSPars[i] = rp.fSSPars[i];
 344     }
 345     for (i = 0; i < 3; i++) {
 346       fPar5[i] = rp.fPar5[i];
 347       fPar6[i] = rp.fPar6[i];
 348     }
 349
 350   }
 351
 352   return *this;
 353
 354 }
 355
 356 //-----------------------------------------------------------------------------
 357 AliEMCALRecParam* AliEMCALRecParam::GetDefaultParameters()
 358 {
 359   //default parameters for the reconstruction
 360   AliEMCALRecParam* params = GetLowFluxParam();
 361   params->SetName("Default - p+p");
 362   params->SetTitle("Default - p+p");
 363   return params;
 364
 365 }
 366
 367 //-----------------------------------------------------------------------------
 368 AliEMCALRecParam* AliEMCALRecParam::GetCalibParam()
 369 {
 370   //parameters for the reconstruction of calibration runs
 371   AliEMCALRecParam* params = GetLowFluxParam();
 372   //params->SetClusteringThreshold(0.1); // 100 MeV
 373   //params->SetMinECut(0.01);  //10 MeV
 374   params->SetName("Calibration - LED");
 375   params->SetTitle("Calibration - LED");
 376   params->SetEventSpecie(AliRecoParam::kCalib);
 377
 378   return params;
 379
 380 }
 381
 382 //-----------------------------------------------------------------------------
 383 AliEMCALRecParam* AliEMCALRecParam::GetCosmicParam()
 384 {
 385   //parameters for the reconstruction of cosmic runs
 386   AliEMCALRecParam* params = GetLowFluxParam();
 387   //params->SetClusteringThreshold(0.1); // 100 MeV
 388   //params->SetMinECut(0.01);  //10 MeV
 389   params->SetName("Cosmic");
 390   params->SetTitle("Cosmic");
 391   params->SetEventSpecie(AliRecoParam::kCosmic);
 392
 393   return params;
 394
 395 }
 396
 397
 398 //-----------------------------------------------------------------------------
 399 AliEMCALRecParam* AliEMCALRecParam::GetLowFluxParam()
 400 {
 401   //low flux/multiplicity ("p+p") parameters for the reconstruction
 402   AliEMCALRecParam* params = new AliEMCALRecParam();
 403   params->SetClusteringThreshold(0.1); // 100 MeV
 404   params->SetMinECut(0.01);  //10 MeV
 405   params->SetName("Low Flux - p+p");
 406   params->SetTitle("Low Flux - p+p");
 407   params->SetEventSpecie(AliRecoParam::kLowMult);
 408
 409
 410   //PID parameters for pp  implemented
 411   // as a first step, all array elements are initialized to 0.0
 412   Int_t i=0, j=0;
 413   for (i = 0; i < 6; i++) {
 414     for (j = 0; j < 6; j++) {
 415       params->SetGamma(i,j,0.);
 416       params->SetGamma1to10(i,j,0.);
 417       params->SetHadron(i,j,0.);
 418       params->SetHadron1to10(i,j,0.);
 419       params->SetPiZero(i,j,0.);
 420
 421     }
 422     params->SetGammaEnergyProb(i,0.); // not yet implemented
 423     params->SetHadronEnergyProb(i,0.);
 424     params->SetPiZeroEnergyProb(i,0.); // not yet implemented
 425   }
 426
 427
 428   params->SetGamma(0,0,-7.656908e-01);
 429   params->SetGamma(0,1,2.352536e-01);
 430   params->SetGamma(0,2,1.555996e-02);
 431   params->SetGamma(0,3,2.243525e-04);
 432   params->SetGamma(0,4,-2.560087e-06);
 433
 434   params->SetGamma(1,0,6.500216e+00);
 435   params->SetGamma(1,1,-2.564958e-01);
 436   params->SetGamma(1,2,1.967894e-01);
 437   params->SetGamma(1,3,-3.982273e-04);
 438   params->SetGamma(1,4,2.797737e-06);
 439
 440   params->SetGamma(2,0,2.416489e+00);
 441   params->SetGamma(2,1,-1.601258e-01);
 442   params->SetGamma(2,2,3.126839e-02);
 443   params->SetGamma(2,3,3.387532e-04);
 444   params->SetGamma(2,4,-4.089145e-06);
 445
 446   params->SetGamma(3,0,0.);
 447   params->SetGamma(3,1,-2.696008e+00);
 448   params->SetGamma(3,2, 6.920305e-01);
 449   params->SetGamma(3,3,-2.281122e-03);
 450   params->SetGamma(3,4,0.);
 451
 452   params->SetGamma(4,0,2.281564e-01);
 453   params->SetGamma(4,1,-7.575040e-02);
 454   params->SetGamma(4,2,3.813423e-01);
 455   params->SetGamma(4,3,-1.243854e-04);
 456   params->SetGamma(4,4,1.232045e-06);
 457
 458   params->SetGamma(5,0,-3.290107e-01);
 459   params->SetGamma(5,1,3.707545e-02);
 460   params->SetGamma(5,2,2.917397e-03);
 461   params->SetGamma(5,3,4.695306e-05);
 462   params->SetGamma(5,4,-3.572981e-07);
 463
 464   params->SetHadron(0,0,9.482243e-01);
 465   params->SetHadron(0,1,-2.780896e-01);
 466   params->SetHadron(0,2, 2.223507e-02);
 467   params->SetHadron(0,3,7.294263e-04);
 468   params->SetHadron(0,4,-5.665872e-06);
 469
 470   params->SetHadron(1,0,0.);
 471   params->SetHadron(1,1,0.);
 472   params->SetHadron(1,2,2.483298e-01);
 473   params->SetHadron(1,3,0.);
 474   params->SetHadron(1,4,0.);
 475
 476   params->SetHadron(2,0,-5.601199e+00);
 477   params->SetHadron(2,1,2.097382e+00);
 478   params->SetHadron(2,2,-2.307965e-01);
 479   params->SetHadron(2,3,9.206871e-03);
 480   params->SetHadron(2,4,-8.887548e-05);
 481
 482   params->SetHadron(3,0,6.543101e+00);
 483   params->SetHadron(3,1,-2.305203e+00);
 484   params->SetHadron(3,2,2.761673e-01);
 485   params->SetHadron(3,3,-5.465855e-03);
 486   params->SetHadron(3,4,2.784329e-05);
 487
 488   params->SetHadron(4,0,-2.443530e+01);
 489   params->SetHadron(4,1,8.902578e+00);
 490   params->SetHadron(4,2,-5.265901e-01);
 491   params->SetHadron(4,3,2.549111e-02);
 492   params->SetHadron(4,4,-2.196801e-04);
 493
 494   params->SetHadron(5,0,2.102007e-01);
 495   params->SetHadron(5,1,-3.844418e-02);
 496   params->SetHadron(5,2,1.234682e-01);
 497   params->SetHadron(5,3,-3.866733e-03);
 498   params->SetHadron(5,4,3.362719e-05);
 499
 500   params->SetPiZero(0,0,5.07215e-01);
 501   params->SetPiZero(0,1,-5.35274e-01);
 502   params->SetPiZero(0,2,8.49925e-02);
 503   params->SetPiZero(0,3,-3.68740e-03);
 504   params->SetPiZero(0,4,5.48228e-05);
 505
 506   params->SetPiZero(1,0,4.590137e+02);
 507   params->SetPiZero(1,1,-7.079341e+01);
 508   params->SetPiZero(1,2,4.990735e+00);
 509   params->SetPiZero(1,3,-1.241302e-01);
 510   params->SetPiZero(1,4,1.065772e-03);
 511
 512   params->SetPiZero(2,0,1.376415e+02);
 513   params->SetPiZero(2,1,-3.031577e+01);
 514   params->SetPiZero(2,2,2.474338e+00);
 515   params->SetPiZero(2,3,-6.903410e-02);
 516   params->SetPiZero(2,4,6.244089e-04);
 517
 518   params->SetPiZero(3,0,0.);
 519   params->SetPiZero(3,1,1.145983e+00);
 520   params->SetPiZero(3,2,-2.476052e-01);
 521   params->SetPiZero(3,3,1.367373e-02);
 522   params->SetPiZero(3,4,0.);
 523
 524   params->SetPiZero(4,0,-2.09758e+02);
 525   params->SetPiZero(4,1,6.30080e+01);
 526   params->SetPiZero(4,2,-4.03890e+00);
 527   params->SetPiZero(4,3,1.08854e-01);
 528   params->SetPiZero(4,4,-9.36248e-04);
 529
 530   params->SetPiZero(5,0,-1.671477e+01);
 531   params->SetPiZero(5,1,2.995415e+00);
 532   params->SetPiZero(5,2,-6.040360e-02);
 533   params->SetPiZero(5,3,-6.137459e-04);
 534   params->SetPiZero(5,4,1.847328e-05);
 535
 536
 537 //     params->SetHadronEnergyProb(0,0.);
 538 //     params->SetHadronEnergyProb(1,0.);
 539 //     params->SetHadronEnergyProb(2,1.);
 540 //     params->SetHadronEnergyProb(3,0.);
 541 //     params->SetHadronEnergyProb(4,0.);
 542
 543   params->SetHadronEnergyProb(0, 4.767543e-02);
 544   params->SetHadronEnergyProb(1,-1.537523e+00);
 545   params->SetHadronEnergyProb(2,2.956727e-01);
 546   params->SetHadronEnergyProb(3,-3.051022e+01);
 547   params->SetHadronEnergyProb(4,-6.036931e-02);
 548
 549 //   Int_t ii= 0;
 550 //   Int_t jj= 3;
 551 //      AliDebug(1,Form("PID parameters (%d, %d): fGamma=%.3f, fPi=%.3f, fHadron=%.3f",
 552 //                      ii,jj, params->GetGamma(ii,jj), params->GetPiZero(ii,jj), params->GetHadron(ii,jj)));
 553 //      cout << " Low Flux Parameters fGamma [2][2] = " << params->GetGamma(2,2) << endl;
 554 //      cout << " Low Flux Parameters fHadron [2][2] = " << params->GetHadron(2,2) << endl;
 555
 556   return params;
 557
 558 }
 559
 560
 561 //-----------------------------------------------------------------------------
 562 AliEMCALRecParam* AliEMCALRecParam::GetHighFluxParam()
 563 {
 564   //high flux/multiplicity ("Pb+Pb") parameters for the reconstruction
 565   AliEMCALRecParam* params = new AliEMCALRecParam();
 566   //For now, same as default
 567   //if later these need to be modified, here's where it is done
 568   params->SetName("High Flux - Pb+Pb");
 569   params->SetTitle("High Flux - Pb+Pb");
 570   params->SetEventSpecie(AliRecoParam::kHighMult);
 571   params->SetTrkCutPt(0.15);//This value can be higher if necessary
 572
 573   return params;
 574
 575 }
 576
 577 //-----------------------------------------------------------------------------
 578 void AliEMCALRecParam::Print(Option_t * opt) const
 579 {
 580   // Print reconstruction parameters to stdout
 581   // if nothing is specified print all, if "reco" just clusterization/track matching
 582   // if "pid", just PID parameters, if "raw", just raw utils parameters.
 583   if(!strcmp("",opt) || !strcmp("reco",opt)){
 584     AliInfo(Form("Clusterizer selected: %d", fClusterizerFlag));
 585     AliInfo(Form("Clusterization parameters :\n fClusteringThreshold=%.3f,\n fW0=%.3f,\n fMinECut=%.3f,\n fUnfold=%d,\n fLocMaxCut=%.3f,\n fTimeCut=%2.1f ns\n fTimeMin=%2.1f ns\n fTimeMax=%2.1f ns\n",
 586                  fClusteringThreshold,fW0,fMinECut,fUnfold,fLocMaxCut,fTimeCut*1.e9,fTimeMin*1e9,fTimeMax*1e9));
 587
 588     AliInfo(Form("Track-matching cuts :\n dEta<%f, dPhi<%f, step=%f[cm], pT>%f, NITS>%f, NTPC>%f\n",
 589                  fMthCutEta, fMthCutPhi, fStep, fTrkCutPt, fTrkCutNITS,fTrkCutNTPC));
 590
 591     AliInfo(Form("Unfolding parameters, Shower shape function :\n"));
 592     for(Int_t i = 0; i < 8; i++){
 593         printf(" %f, ", fSSPars[i]);
 594     }
 595     printf("\n Parameter 5 : ");
 596     for(Int_t i = 0; i < 3; i++){
 597       printf(" %f, ", fPar5[i]);
 598     }
 599     printf("\n Parameter 6 : ");
 600     for(Int_t i = 0; i < 3; i++){
 601       printf(" %f, ", fPar6[i]);
 602     }
 603     printf("\n");
 604   }
 605
 606   if(!strcmp("",opt) || !strcmp("pid",opt)){
 607     AliInfo(Form("PID parameters, Gamma :\n"));
 608     for(Int_t i = 0; i < 6; i++){
 609       for(Int_t j = 0; j < 6; j++){
 610         printf(" %f, ", fGamma[i][j]);
 611       }
 612       printf("\n");
 613     }
 614
 615
 616     AliInfo(Form("PID parameters, Hadron :\n"));
 617     for(Int_t i = 0; i < 6; i++){
 618       for(Int_t j = 0; j < 6; j++){
 619         printf(" %f, ", fHadron[i][j]);
 620       }
 621       printf("\n");
 622     }
 623
 624     printf("\n");
 625
 626     AliInfo(Form("PID parameters, Pi0zero :\n"));
 627     for(Int_t i = 0; i < 6; i++){
 628       for(Int_t j = 0; j < 6; j++){
 629         printf(" %f, ", fPiZero[i][j]);
 630       }
 631       printf("\n");
 632     }
 633
 634     printf("\n");
 635
 636   }
 637
 638   if(!strcmp("",opt) || !strcmp("raw",opt)){
 639     AliInfo(Form("Raw signal parameters: \n gain factor=%f, order=%d, tau=%f, noise threshold=%d, nped samples=%d \n",
 640                  fHighLowGainFactor,fOrderParameter,fTau,fNoiseThreshold,fNPedSamples));
 641     AliInfo(Form("Raw signal: remove bad channels? %d, \n \t with fitting algorithm %d, \n \t Use FALTRO %d, Fit LED events %d \n",
 642                  fRemoveBadChannels, fFittingAlgorithm, fUseFALTRO, fFitLEDEvents));
 643   }
 644 }
 645
 646 //-----------------------------------------------------------------------------
 647 const TObjArray* AliEMCALRecParam::GetMappings()
 648 {
 649   //Returns array of AliAltroMappings for RCU0..RCUX.
 650   //If not found, read it from OCDB.
 651
 652   //Quick check as follows:
 653   //  root [0] AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT"
 654   //  root [1] AliCDBManager::Instance()->SetRun(1);
 655   //  root [2] TObjArray* maps = AliEMCALRecParam::GetMappings();
 656   //  root [3] maps->Print();
 657
 658   if(fgkMaps) return fgkMaps;
 659
 660   AliCDBEntry* entry = AliCDBManager::Instance()->Get("EMCAL/Calib/Mapping");
 661   if(entry)
 662     fgkMaps = (TObjArray*)entry->GetObject();
 663
 664   return fgkMaps;
 665
 666 }
 667