[u/mrichter/AliRoot.git] / EMCAL / macros / RecParamDB / AliEMCALSetRecParamCDB.C

// Script to create reconstruction parameters and store them into CDB
// Author: Yuri Kharlov

/* $Id$ */

#if !defined(__CINT__)
#include "TControlBar.h"
#include "TString.h"

#include "AliEMCALRecParam.h"
#include "AliCDBMetaData.h"
#include "AliCDBId.h"
#include "AliCDBEntry.h"
#include "AliCDBManager.h"
#include "AliCDBStorage.h"
#endif


void AliEMCALSetRecParamCDB(AliRecoParam::EventSpecie_t default = AliRecoParam::kLowMult)
{
  
  // Create an object AliEMCALRecParam and store it to OCDB
  
  //Activate CDB storage
  AliCDBManager* cdb = AliCDBManager::Instance();
  if(!cdb->IsDefaultStorageSet()) cdb->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
  
  // Create reconstruction parameter object and set parameter values
  TObjArray* recParamArray = new TObjArray();
  
  {
    //default
    //AliEMCALRecParam *recParamDB = AliEMCALRecParam::GetDefaultParameters();
    AliEMCALRecParam *recParamDB = GetLowMultiplicityParameters();
    recParamDB->SetName("Default - p+p");
    recParamDB->SetTitle("Default - p+p");
    //Add to the recParamArray
    recParamDB->SetEventSpecie(AliRecoParam::kDefault);
    recParamArray->AddLast(recParamDB);
	  
  }
  
  //Add other options here, if desired, for
  //Cosmic, LowMult and HighMult type events
  //and add them to the array
  
  {
    //For now, default is Pb+Pb, but let's add it again as
    //the "high mult" version too...
    //AliEMCALRecParam *recParamDB = AliEMCALRecParam::GetHighFluxParam();
    AliEMCALRecParam *recParamDB = GetHighMultiplicityParameters();
    recParamDB->SetName("High Flux - Pb+Pb");
    recParamDB->SetTitle("High Flux - Pb+Pb");
    recParamDB->SetEventSpecie(AliRecoParam::kHighMult);
    recParamArray->AddLast(recParamDB);
  }
  
  {
    //Low multiplicity parameter modifications:
    //AliEMCALRecParam *recParamDB = AliEMCALRecParam::GetLowFluxParam();
    AliEMCALRecParam *recParamDB = GetLowMultiplicityParameters();
    recParamDB->SetName("Low Flux - p+p");
    recParamDB->SetTitle("Low Flux - p+p");
    recParamDB->SetEventSpecie(AliRecoParam::kLowMult);
    recParamArray->AddLast(recParamDB);
    
  }
  
  {
    //Cosmic parameter modifications (same as low multiplicity):
    //AliEMCALRecParam *recParamDB = AliEMCALRecParam::GetLowFluxParam();
    AliEMCALRecParam *recParamDB = GetLowMultiplicityParameters();
    recParamDB->SetName("Cosmic");
    recParamDB->SetTitle("Cosmic");
    recParamDB->SetEventSpecie(AliRecoParam::kCosmic);
    recParamArray->AddLast(recParamDB);
    
  }
  
  {
    //Calib parameter modifications (same as low multiplicity):
    //AliEMCALRecParam *recParamDB = AliEMCALRecParam::GetLowFluxParam();
    AliEMCALRecParam *recParamDB = GetLowMultiplicityParameters();
    recParamDB->SetName("Calibration - LED");
    recParamDB->SetTitle("Calibration - LED");
    recParamDB->SetEventSpecie(AliRecoParam::kCalib);
    recParamArray->AddLast(recParamDB);
    
  }
  
  //Set the default version in the array
  Bool_t defaultIsSet = kFALSE;
  for(Int_t i = 0; i < recParamArray->GetEntriesFast(); i++) {
    AliDetectorRecoParam* param = (AliDetectorRecoParam*)recParamArray->UncheckedAt(i);
    if(!param) continue;
    if(default & param->GetEventSpecie()) {
      param->SetAsDefault();
      defaultIsSet = kTRUE;
    }
  }
  
  if(!defaultIsSet) {
    AliError("The default reconstruction parameters are not set!  Exiting...");
    return;
  }
  
  // Store calibration data into database  
  AliCDBMetaData *md = new AliCDBMetaData();
  md->SetResponsible("J. Klay");
  md->SetComment("Reconstruction Parameters: EMCAL");
  md->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
  md->SetBeamPeriod(0);
  
  AliCDBId id("EMCAL/Calib/RecoParam",0,AliCDBRunRange::Infinity());
  cdb->GetDefaultStorage()->Put(recParamArray, id, md);
  
  return;
}

//-----------------------------------------------------------------------------
AliEMCALRecParam* GetHighMultiplicityParameters()
{
  //Set here the high flux/multiplicity ("Pb+Pb") parameters for the reconstruction
  //Right now it should be the same settings as with
  //AliEMCALRecParam *recParamDB = AliEMCALRecParam::GetHighFluxParam();
  //or
  //AliEMCALRecParam *recParamDB = AliEMCALRecParam::GetDefaultParameters();
  
  AliEMCALRecParam* params =  AliEMCALRecParam::GetDefaultParameters();
  //Clusterization

  // params->SetClusterizerFlag(AliEMCALRecParam::kClusterizerv1);
  // params->SetClusteringThreshold(0.5);
  // params->SetMinECut(0.45);

  params->SetClusterizerFlag(AliEMCALRecParam::kClusterizerv2);
  params->SetClusteringThreshold(0.1); // 100 MeV                                             
  params->SetMinECut(0.05);  //50 MeV    
   
  params->SetUnfold(kFALSE);

  params->SetW0(4.5);

  params->SetTimeCut(250e-9);//250 ns
  params->SetTimeMin(425e-9);//425 ns
  params->SetTimeMax(825e-9);//825 ns

  //Track matching

  params->SetTrkCutNITS(1.0);
  params->SetTrkCutNTPC(20.0);
  params->SetExtrapolateStep(20.);
  
  //PID
	
  // as a first step, all array elements are initialized to 0.0
  Int_t i, j;
  for (i = 0; i < 6; i++) {
    params->SetGammaEnergyProb(i,0.);
    params->SetHadronEnergyProb(i,0.); 
    params->SetPiZeroEnergyProb(i,0.);
    
    for (j = 0; j < 6; j++) {
      
      params->SetGamma(i,j,0.);
      params->SetHadron(i,j,0.);
      params->SetPiZero(i,j, 0.);
      params->SetGamma1to10(i,j,0.);
      params->SetHadron1to10(i,j,0.);
    }
  } 
  
  params->SetGamma(0,0, -7.656908e-01); 
  params->SetGamma(0,1,  2.352536e-01); 
  params->SetGamma(0,2,  1.555996e-02);
  params->SetGamma(0,3,  2.243525e-04);
  params->SetGamma(0,4, -2.560087e-06);
  
  params->SetGamma(1,0,  6.500216e+00);
  params->SetGamma(1,1, -2.564958e-01);
  params->SetGamma(1,2,  1.967894e-01);
  params->SetGamma(1,3, -3.982273e-04);
  params->SetGamma(1,4,  2.797737e-06);
  
  params->SetGamma(2,0,  2.416489e+00);
  params->SetGamma(2,1, -1.601258e-01);
  params->SetGamma(2,2,  3.126839e-02);
  params->SetGamma(2,3,  3.387532e-04);
  params->SetGamma(2,4, -4.089145e-06);
  
  params->SetGamma(3,0,  0.);
  params->SetGamma(3,1, -2.696008e+00);
  params->SetGamma(3,2,  6.920305e-01);
  params->SetGamma(3,3, -2.281122e-03);
  params->SetGamma(3,4,  0.);
  
  params->SetGamma(4,0,  2.281564e-01);
  params->SetGamma(4,1, -7.575040e-02);
  params->SetGamma(4,2,  3.813423e-01);
  params->SetGamma(4,3, -1.243854e-04);
  params->SetGamma(4,4,  1.232045e-06);
  
  params->SetGamma(5,0, -3.290107e-01);
  params->SetGamma(5,1,  3.707545e-02);
  params->SetGamma(5,2,  2.917397e-03);
  params->SetGamma(5,3,  4.695306e-05);
  params->SetGamma(5,4, -3.572981e-07);
  
  params->SetHadron(0,0,   1.519112e-01);
  params->SetHadron(0,1, -8.267603e-02);
  params->SetHadron(0,2,  1.914574e-02);
  params->SetHadron(0,3, -2.677921e-04);
  params->SetHadron(0,4,  5.447939e-06);
  
  params->SetHadron(1,0,  0.);
  params->SetHadron(1,1, -7.549870e-02); 
  params->SetHadron(1,2,  3.930087e-01);
  params->SetHadron(1,3, -2.368500e-03); 
  params->SetHadron(1,4,  0.);
  
  params->SetHadron(2,0,  0.);
  params->SetHadron(2,1, -2.463152e-02);
  params->SetHadron(2,2,  1.349257e-01);
  params->SetHadron(2,3, -1.089440e-03);
  params->SetHadron(2,4,  0.);
  
  params->SetHadron(3,0, 0.);
  params->SetHadron(3,1, 5.101560e-01);
  params->SetHadron(3,2, 1.458679e-01);
  params->SetHadron(3,3, 4.903068e-04);
  params->SetHadron(3,4, 0.);
  
  params->SetHadron(4,0, 0.);
  params->SetHadron(4,1, -6.693943e-03); 
  params->SetHadron(4,2,  2.444753e-01);
  params->SetHadron(4,3, -5.553749e-05);
  params->SetHadron(4,4, 0.);
  
  params->SetHadron(5,0, -4.414030e-01);
  params->SetHadron(5,1, 2.292277e-01);
  params->SetHadron(5,2, -2.433737e-02);
  params->SetHadron(5,3,  1.758422e-03);
  params->SetHadron(5,4, -3.001493e-05);
  
  params->SetPiZero(0,0,  5.072157e-01);
  params->SetPiZero(0,1, -5.352747e-01);
  params->SetPiZero(0,2,  8.499259e-02);
  params->SetPiZero(0,3, -3.687401e-03);
  params->SetPiZero(0,4,  5.482280e-05);
  
  params->SetPiZero(1,0,  4.590137e+02); 
  params->SetPiZero(1,1, -7.079341e+01);
  params->SetPiZero(1,2,  4.990735e+00);
  params->SetPiZero(1,3, -1.241302e-01);
  params->SetPiZero(1,4,  1.065772e-03);
  
  params->SetPiZero(2,0,  1.376415e+02);
  params->SetPiZero(2,1, -3.031577e+01);
  params->SetPiZero(2,2,  2.474338e+00);
  params->SetPiZero(2,3, -6.903410e-02);
  params->SetPiZero(2,4,  6.244089e-04);
  
  params->SetPiZero(3,0, 0.);
  params->SetPiZero(3,1,  1.145983e+00);
  params->SetPiZero(3,2, -2.476052e-01);
  params->SetPiZero(3,3,  1.367373e-02);
  params->SetPiZero(3,4, 0.);
  
  params->SetPiZero(4,0, -2.097586e+02);
  params->SetPiZero(4,1,  6.300800e+01);
  params->SetPiZero(4,2, -4.038906e+00);
  params->SetPiZero(4,3,  1.088543e-01);
  params->SetPiZero(4,4, -9.362485e-04);
  
  params->SetPiZero(5,0, -1.671477e+01); 
  params->SetPiZero(5,1,  2.995415e+00);
  params->SetPiZero(5,2, -6.040360e-02);
  params->SetPiZero(5,3, -6.137459e-04);
  params->SetPiZero(5,4,  1.847328e-05);
  
  // High flux ones pp 
  
  params->SetHadronEnergyProb(0, 0.);
  params->SetHadronEnergyProb(1, 0.);
  params->SetHadronEnergyProb(2,  6.188452e-02);
  params->SetHadronEnergyProb(3,  2.030230e+00);
  params->SetHadronEnergyProb(4, -6.402242e-02);
  
  // raw signal fitting
  params->SetHighLowGainFactor(16.);
  params->SetOrderParameter(2);
  params->SetTau(2.35);
  params->SetNoiseThreshold(3);
  params->SetNPedSamples(5);
  params->SetRemoveBadChannels(kFALSE);
  params->SetFittingAlgorithm(0);//(AliCaloConstants::kStandard);  
  params->SetFALTROUsage(kTRUE); 
  params->SetLEDFit(kFALSE);   

  return params ;
}	

//-----------------------------------------------------------------------------
AliEMCALRecParam* GetLowMultiplicityParameters()
{
  // Set here the low flux/multiplicity ("p+p") parameters for the reconstruction
  //Right now it should be the same settings as with
  //AliEMCALRecParam *recParamDB = AliEMCALRecParam::GetLowFluxParam();
  
  AliEMCALRecParam* params =  AliEMCALRecParam::GetDefaultParameters();
  //params->SetClusterizerFlag(AliEMCALRecParam::kClusterizerNxN);
  params->SetClusterizerFlag(AliEMCALRecParam::kClusterizerv1);
  params->SetClusteringThreshold(0.1); // 100 MeV                                             
  params->SetMinECut(0.05);  //50 MeV       	

  params->SetUnfold(kFALSE);

  params->SetW0(4.5);

  params->SetTimeCut(250e-9);//250 ns
  params->SetTimeMin(425e-9);//425 ns
  params->SetTimeMax(825e-9);//825 ns

  // Track Matching
  
  params->SetTrkCutNITS(1.0);
  params->SetTrkCutNTPC(20.0);
  params->SetExtrapolateStep(20.);  
  
  //PID parameters for pp  implemented 
  // as a first step, all array elements are initialized to 0.0
  Int_t i, j;
  for (i = 0; i < 6; i++) {
    for (j = 0; j < 6; j++) {
      params->SetGamma(i,j,0.);
      params->SetGamma1to10(i,j,0.);
      params->SetHadron(i,j,0.);
      params->SetHadron1to10(i,j,0.);
      params->SetPiZero(i,j,0.);
      
    }
    params->SetGammaEnergyProb(i,0.); // not yet implemented
    params->SetHadronEnergyProb(i,0.);
    params->SetPiZeroEnergyProb(i,0.); // not yet implemented
  }
  
  params->SetGamma(0,0, -7.656908e-01);
  params->SetGamma(0,1,  2.352536e-01);
  params->SetGamma(0,2,  1.555996e-02);
  params->SetGamma(0,3,  2.243525e-04);
  params->SetGamma(0,4, -2.560087e-06);
  
  params->SetGamma(1,0,  6.500216e+00);
  params->SetGamma(1,1, -2.564958e-01);
  params->SetGamma(1,2,  1.967894e-01);
  params->SetGamma(1,3, -3.982273e-04);
  params->SetGamma(1,4,  2.797737e-06);
  
  params->SetGamma(2,0,  2.416489e+00);
  params->SetGamma(2,1, -1.601258e-01);
  params->SetGamma(2,2,  3.126839e-02);
  params->SetGamma(2,3,  3.387532e-04);
  params->SetGamma(2,4, -4.089145e-06);
  
  params->SetGamma(3,0,0.);
  params->SetGamma(3,1,-2.696008e+00); 
  params->SetGamma(3,2, 6.920305e-01);
  params->SetGamma(3,3,-2.281122e-03);
  params->SetGamma(3,4,0.);
  
  params->SetGamma(4,0,  2.281564e-01); 
  params->SetGamma(4,1, -7.575040e-02);
  params->SetGamma(4,2,  3.813423e-01);
  params->SetGamma(4,3, -1.243854e-04);
  params->SetGamma(4,4,  1.232045e-06);
  
  params->SetGamma(5,0, -3.290107e-01);
  params->SetGamma(5,1,  3.707545e-02);
  params->SetGamma(5,2,  2.917397e-03);
  params->SetGamma(5,3,  4.695306e-05);
  params->SetGamma(5,4, -3.572981e-07);
  
  params->SetHadron(0,0,  9.482243e-01); 
  params->SetHadron(0,1, -2.780896e-01);
  params->SetHadron(0,2,  2.223507e-02);
  params->SetHadron(0,3,  7.294263e-04);
  params->SetHadron(0,4, -5.665872e-06); 
  
  params->SetHadron(1,0,  0.);
  params->SetHadron(1,1,  0.);
  params->SetHadron(1,2,  2.483298e-01);
  params->SetHadron(1,3,  0.);
  params->SetHadron(1,4,  0.);
  
  params->SetHadron(2,0, -5.601199e+00);
  params->SetHadron(2,1,  2.097382e+00);
  params->SetHadron(2,2, -2.307965e-01);
  params->SetHadron(2,3,  9.206871e-03);
  params->SetHadron(2,4, -8.887548e-05);
  
  params->SetHadron(3,0,  6.543101e+00);
  params->SetHadron(3,1, -2.305203e+00);
  params->SetHadron(3,2,  2.761673e-01);
  params->SetHadron(3,3, -5.465855e-03);
  params->SetHadron(3,4,  2.784329e-05);
  
  params->SetHadron(4,0, -2.443530e+01);
  params->SetHadron(4,1,  8.902578e+00);
  params->SetHadron(4,2, -5.265901e-01);
  params->SetHadron(4,3,  2.549111e-02);
  params->SetHadron(4,4, -2.196801e-04);
  
  params->SetHadron(5,0,  2.102007e-01);
  params->SetHadron(5,1, -3.844418e-02);
  params->SetHadron(5,2,  1.234682e-01);
  params->SetHadron(5,3, -3.866733e-03);
  params->SetHadron(5,4,  3.362719e-05);
  
  params->SetPiZero(0,0,  5.07215e-01);
  params->SetPiZero(0,1, -5.35274e-01);
  params->SetPiZero(0,2,  8.49925e-02);
  params->SetPiZero(0,3, -3.68740e-03);
  params->SetPiZero(0,4,  5.48228e-05);
  
  params->SetPiZero(1,0,  4.590137e+02);
  params->SetPiZero(1,1, -7.079341e+01);
  params->SetPiZero(1,2,  4.990735e+00);
  params->SetPiZero(1,3, -1.241302e-01);
  params->SetPiZero(1,4,  1.065772e-03);
  
  params->SetPiZero(2,0,  1.376415e+02); 
  params->SetPiZero(2,1, -3.031577e+01);
  params->SetPiZero(2,2,  2.474338e+00);
  params->SetPiZero(2,3, -6.903410e-02); 
  params->SetPiZero(2,4,  6.244089e-04);
  
  params->SetPiZero(3,0,  0.);
  params->SetPiZero(3,1,  1.145983e+00);
  params->SetPiZero(3,2, -2.476052e-01);
  params->SetPiZero(3,3,  1.367373e-02);
  params->SetPiZero(3,4,  0.);
  
  params->SetPiZero(4,0, -2.09758e+02);
  params->SetPiZero(4,1,  6.30080e+01);
  params->SetPiZero(4,2, -4.03890e+00);
  params->SetPiZero(4,3,  1.08854e-01);
  params->SetPiZero(4,4, -9.36248e-04);
  
  params->SetPiZero(5,0, -1.671477e+01);
  params->SetPiZero(5,1,  2.995415e+00);
  params->SetPiZero(5,2, -6.040360e-02);
  params->SetPiZero(5,3,  -6.137459e-04);
  params->SetPiZero(5,4, 1.847328e-05);
  
  //     params->SetHadronEnergyProb(0,0.);
  //     params->SetHadronEnergyProb(1,0.);
  //     params->SetHadronEnergyProb(2,1.);
  //     params->SetHadronEnergyProb(3,0.);
  //     params->SetHadronEnergyProb(4,0.);
  
  params->SetHadronEnergyProb(0,  4.767543e-02);
  params->SetHadronEnergyProb(1, -1.537523e+00);
  params->SetHadronEnergyProb(2,  2.956727e-01);
  params->SetHadronEnergyProb(3, -3.051022e+01);
  params->SetHadronEnergyProb(4, -6.036931e-02);

  // raw signal fitting
  params->SetHighLowGainFactor(16.);
  params->SetOrderParameter(2);
  params->SetTau(2.35);
  params->SetNoiseThreshold(3);
  params->SetNPedSamples(5);
  params->SetRemoveBadChannels(kFALSE);
  params->SetFittingAlgorithm(0);//(AliCaloConstants::kStandard);  
  params->SetFALTROUsage(kTRUE); 
  params->SetLEDFit(kFALSE);   

  return params;
  
}
Commit	Line	Data
3a8be91c	1	// Script to create reconstruction parameters and store them into CDB
	2	// Author: Yuri Kharlov
	3
	4	/* $Id$ */
	5
	6	#if !defined(__CINT__)
	7	#include "TControlBar.h"
	8	#include "TString.h"
	9
	10	#include "AliEMCALRecParam.h"
	11	#include "AliCDBMetaData.h"
	12	#include "AliCDBId.h"
	13	#include "AliCDBEntry.h"
	14	#include "AliCDBManager.h"
	15	#include "AliCDBStorage.h"
	16	#endif
	17
	18
88cf6bfb	19	void AliEMCALSetRecParamCDB(AliRecoParam::EventSpecie_t default = AliRecoParam::kLowMult)
3a8be91c	20	{
1e7c9b89	21
3a8be91c	22	// Create an object AliEMCALRecParam and store it to OCDB
1e7c9b89	23
413e6b81	24	//Activate CDB storage
413e6b81	25	AliCDBManager* cdb = AliCDBManager::Instance();
3aa21746	26	if(!cdb->IsDefaultStorageSet()) cdb->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
1e7c9b89	27
3a8be91c	28	// Create reconstruction parameter object and set parameter values
413e6b81	29	TObjArray* recParamArray = new TObjArray();
1e7c9b89	30
c8a7579b	31	{
c8a7579b	32	//default
1e7c9b89	33	//AliEMCALRecParam *recParamDB = AliEMCALRecParam::GetDefaultParameters();
e658398a	34	AliEMCALRecParam *recParamDB = GetLowMultiplicityParameters();
	35	recParamDB->SetName("Default - p+p");
	36	recParamDB->SetTitle("Default - p+p");
c8a7579b	37	//Add to the recParamArray
	38	recParamDB->SetEventSpecie(AliRecoParam::kDefault);
	39	recParamArray->AddLast(recParamDB);
88cf6bfb	40
c8a7579b	41	}
1e7c9b89	42
413e6b81	43	//Add other options here, if desired, for
	44	//Cosmic, LowMult and HighMult type events
	45	//and add them to the array
1e7c9b89	46
c8a7579b	47	{
	48	//For now, default is Pb+Pb, but let's add it again as
	49	//the "high mult" version too...
1e7c9b89	50	//AliEMCALRecParam *recParamDB = AliEMCALRecParam::GetHighFluxParam();
	51	AliEMCALRecParam *recParamDB = GetHighMultiplicityParameters();
	52	recParamDB->SetName("High Flux - Pb+Pb");
	53	recParamDB->SetTitle("High Flux - Pb+Pb");
c8a7579b	54	recParamDB->SetEventSpecie(AliRecoParam::kHighMult);
	55	recParamArray->AddLast(recParamDB);
	56	}
1e7c9b89	57
c8a7579b	58	{
c8a7579b	59	//Low multiplicity parameter modifications:
1e7c9b89	60	//AliEMCALRecParam *recParamDB = AliEMCALRecParam::GetLowFluxParam();
	61	AliEMCALRecParam *recParamDB = GetLowMultiplicityParameters();
	62	recParamDB->SetName("Low Flux - p+p");
	63	recParamDB->SetTitle("Low Flux - p+p");
c8a7579b	64	recParamDB->SetEventSpecie(AliRecoParam::kLowMult);
	65	recParamArray->AddLast(recParamDB);
	66
	67	}
1e7c9b89	68
98cf874d	69	{
1e7c9b89	70	//Cosmic parameter modifications (same as low multiplicity):
	71	//AliEMCALRecParam *recParamDB = AliEMCALRecParam::GetLowFluxParam();
	72	AliEMCALRecParam *recParamDB = GetLowMultiplicityParameters();
	73	recParamDB->SetName("Cosmic");
	74	recParamDB->SetTitle("Cosmic");
	75	recParamDB->SetEventSpecie(AliRecoParam::kCosmic);
	76	recParamArray->AddLast(recParamDB);
	77
98cf874d	78	}
1e7c9b89	79
98cf874d	80	{
1e7c9b89	81	//Calib parameter modifications (same as low multiplicity):
	82	//AliEMCALRecParam *recParamDB = AliEMCALRecParam::GetLowFluxParam();
	83	AliEMCALRecParam *recParamDB = GetLowMultiplicityParameters();
	84	recParamDB->SetName("Calibration - LED");
	85	recParamDB->SetTitle("Calibration - LED");
	86	recParamDB->SetEventSpecie(AliRecoParam::kCalib);
	87	recParamArray->AddLast(recParamDB);
	88
	89	}
	90
413e6b81	91	//Set the default version in the array
	92	Bool_t defaultIsSet = kFALSE;
	93	for(Int_t i = 0; i < recParamArray->GetEntriesFast(); i++) {
	94	AliDetectorRecoParam* param = (AliDetectorRecoParam*)recParamArray->UncheckedAt(i);
	95	if(!param) continue;
	96	if(default & param->GetEventSpecie()) {
	97	param->SetAsDefault();
	98	defaultIsSet = kTRUE;
	99	}
	100	}
1e7c9b89	101
413e6b81	102	if(!defaultIsSet) {
413e6b81	103	AliError("The default reconstruction parameters are not set! Exiting...");
3a8be91c	104	return;
3a8be91c	105	}
1e7c9b89	106
413e6b81	107	// Store calibration data into database
	108	AliCDBMetaData *md = new AliCDBMetaData();
	109	md->SetResponsible("J. Klay");
	110	md->SetComment("Reconstruction Parameters: EMCAL");
	111	md->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
	112	md->SetBeamPeriod(0);
	113
	114	AliCDBId id("EMCAL/Calib/RecoParam",0,AliCDBRunRange::Infinity());
c8a7579b	115	cdb->GetDefaultStorage()->Put(recParamArray, id, md);
1e7c9b89	116
413e6b81	117	return;
3a8be91c	118	}
1e7c9b89	119
	120	//-----------------------------------------------------------------------------
	121	AliEMCALRecParam* GetHighMultiplicityParameters()
	122	{
	123	//Set here the high flux/multiplicity ("Pb+Pb") parameters for the reconstruction
	124	//Right now it should be the same settings as with
	125	//AliEMCALRecParam *recParamDB = AliEMCALRecParam::GetHighFluxParam();
	126	//or
	127	//AliEMCALRecParam *recParamDB = AliEMCALRecParam::GetDefaultParameters();
	128
	129	AliEMCALRecParam* params = AliEMCALRecParam::GetDefaultParameters();
1e7c9b89	130	//Clusterization
2b3e9461	131
	132	// params->SetClusterizerFlag(AliEMCALRecParam::kClusterizerv1);
	133	// params->SetClusteringThreshold(0.5);
	134	// params->SetMinECut(0.45);
	135
a0945e6f	136	params->SetClusterizerFlag(AliEMCALRecParam::kClusterizerv2);
2b3e9461	137	params->SetClusteringThreshold(0.1); // 100 MeV
a0945e6f	138	params->SetMinECut(0.05); //50 MeV
2b3e9461	139
	140	params->SetUnfold(kFALSE);
	141
1e7c9b89	142	params->SetW0(4.5);
2b3e9461	143
f0a6dc6f	144	params->SetTimeCut(250e-9);//250 ns
	145	params->SetTimeMin(425e-9);//425 ns
	146	params->SetTimeMax(825e-9);//825 ns
829ba234	147
1e7c9b89	148	//Track matching
a0945e6f	149
a0945e6f	150	params->SetTrkCutNITS(1.0);
1e7c9b89	151	params->SetTrkCutNTPC(20.0);
a0945e6f	152	params->SetExtrapolateStep(20.);
1e7c9b89	153
	154	//PID
	155
	156	// as a first step, all array elements are initialized to 0.0
	157	Int_t i, j;
	158	for (i = 0; i < 6; i++) {
	159	params->SetGammaEnergyProb(i,0.);
	160	params->SetHadronEnergyProb(i,0.);
	161	params->SetPiZeroEnergyProb(i,0.);
	162
	163	for (j = 0; j < 6; j++) {
	164
	165	params->SetGamma(i,j,0.);
	166	params->SetHadron(i,j,0.);
	167	params->SetPiZero(i,j, 0.);
	168	params->SetGamma1to10(i,j,0.);
	169	params->SetHadron1to10(i,j,0.);
	170	}
	171	}
	172
	173	params->SetGamma(0,0, -7.656908e-01);
	174	params->SetGamma(0,1, 2.352536e-01);
	175	params->SetGamma(0,2, 1.555996e-02);
	176	params->SetGamma(0,3, 2.243525e-04);
	177	params->SetGamma(0,4, -2.560087e-06);
	178
	179	params->SetGamma(1,0, 6.500216e+00);
	180	params->SetGamma(1,1, -2.564958e-01);
	181	params->SetGamma(1,2, 1.967894e-01);
	182	params->SetGamma(1,3, -3.982273e-04);
	183	params->SetGamma(1,4, 2.797737e-06);
	184
	185	params->SetGamma(2,0, 2.416489e+00);
	186	params->SetGamma(2,1, -1.601258e-01);
	187	params->SetGamma(2,2, 3.126839e-02);
	188	params->SetGamma(2,3, 3.387532e-04);
	189	params->SetGamma(2,4, -4.089145e-06);
	190
	191	params->SetGamma(3,0, 0.);
	192	params->SetGamma(3,1, -2.696008e+00);
	193	params->SetGamma(3,2, 6.920305e-01);
	194	params->SetGamma(3,3, -2.281122e-03);
	195	params->SetGamma(3,4, 0.);
	196
	197	params->SetGamma(4,0, 2.281564e-01);
	198	params->SetGamma(4,1, -7.575040e-02);
	199	params->SetGamma(4,2, 3.813423e-01);
	200	params->SetGamma(4,3, -1.243854e-04);
	201	params->SetGamma(4,4, 1.232045e-06);
	202
	203	params->SetGamma(5,0, -3.290107e-01);
	204	params->SetGamma(5,1, 3.707545e-02);
	205	params->SetGamma(5,2, 2.917397e-03);
	206	params->SetGamma(5,3, 4.695306e-05);
	207	params->SetGamma(5,4, -3.572981e-07);
	208
	209	params->SetHadron(0,0, 1.519112e-01);
	210	params->SetHadron(0,1, -8.267603e-02);
	211	params->SetHadron(0,2, 1.914574e-02);
	212	params->SetHadron(0,3, -2.677921e-04);
	213	params->SetHadron(0,4, 5.447939e-06);
	214
	215	params->SetHadron(1,0, 0.);
	216	params->SetHadron(1,1, -7.549870e-02);
217	params->SetHadron(1,2, 3.930087e-01);
218	params->SetHadron(1,3, -2.368500e-03);
219	params->SetHadron(1,4, 0.);
220
221	params->SetHadron(2,0, 0.);
222	params->SetHadron(2,1, -2.463152e-02);
223	params->SetHadron(2,2, 1.349257e-01);
224	params->SetHadron(2,3, -1.089440e-03);
225	params->SetHadron(2,4, 0.);
226
227	params->SetHadron(3,0, 0.);
228	params->SetHadron(3,1, 5.101560e-01);
229	params->SetHadron(3,2, 1.458679e-01);
230	params->SetHadron(3,3, 4.903068e-04);
231	params->SetHadron(3,4, 0.);
232
233	params->SetHadron(4,0, 0.);
234	params->SetHadron(4,1, -6.693943e-03);
235	params->SetHadron(4,2, 2.444753e-01);
236	params->SetHadron(4,3, -5.553749e-05);
237	params->SetHadron(4,4, 0.);
238
239	params->SetHadron(5,0, -4.414030e-01);
240	params->SetHadron(5,1, 2.292277e-01);
241	params->SetHadron(5,2, -2.433737e-02);
242	params->SetHadron(5,3, 1.758422e-03);
243	params->SetHadron(5,4, -3.001493e-05);
244
245	params->SetPiZero(0,0, 5.072157e-01);
246	params->SetPiZero(0,1, -5.352747e-01);
247	params->SetPiZero(0,2, 8.499259e-02);
248	params->SetPiZero(0,3, -3.687401e-03);
249	params->SetPiZero(0,4, 5.482280e-05);
250
251	params->SetPiZero(1,0, 4.590137e+02);
252	params->SetPiZero(1,1, -7.079341e+01);
253	params->SetPiZero(1,2, 4.990735e+00);
254	params->SetPiZero(1,3, -1.241302e-01);
255	params->SetPiZero(1,4, 1.065772e-03);
256
257	params->SetPiZero(2,0, 1.376415e+02);
258	params->SetPiZero(2,1, -3.031577e+01);
259	params->SetPiZero(2,2, 2.474338e+00);
260	params->SetPiZero(2,3, -6.903410e-02);
261	params->SetPiZero(2,4, 6.244089e-04);
262
263	params->SetPiZero(3,0, 0.);
264	params->SetPiZero(3,1, 1.145983e+00);
265	params->SetPiZero(3,2, -2.476052e-01);
266	params->SetPiZero(3,3, 1.367373e-02);
267	params->SetPiZero(3,4, 0.);
268
269	params->SetPiZero(4,0, -2.097586e+02);
270	params->SetPiZero(4,1, 6.300800e+01);
271	params->SetPiZero(4,2, -4.038906e+00);
272	params->SetPiZero(4,3, 1.088543e-01);
273	params->SetPiZero(4,4, -9.362485e-04);
274
275	params->SetPiZero(5,0, -1.671477e+01);
276	params->SetPiZero(5,1, 2.995415e+00);
277	params->SetPiZero(5,2, -6.040360e-02);
278	params->SetPiZero(5,3, -6.137459e-04);
279	params->SetPiZero(5,4, 1.847328e-05);
280
281	// High flux ones pp
282
283	params->SetHadronEnergyProb(0, 0.);
284	params->SetHadronEnergyProb(1, 0.);
285	params->SetHadronEnergyProb(2, 6.188452e-02);
286	params->SetHadronEnergyProb(3, 2.030230e+00);
287	params->SetHadronEnergyProb(4, -6.402242e-02);
288
289	// raw signal fitting
290	params->SetHighLowGainFactor(16.);
291	params->SetOrderParameter(2);
292	params->SetTau(2.35);
293	params->SetNoiseThreshold(3);
294	params->SetNPedSamples(5);
f0a6dc6f	295	params->SetRemoveBadChannels(kFALSE);
e3968910	296	params->SetFittingAlgorithm(0);//(AliCaloConstants::kStandard);
64c98165	297	params->SetFALTROUsage(kTRUE);
	298	params->SetLEDFit(kFALSE);
	299
1e7c9b89	300	return params ;
	301	}
	302
	303	//-----------------------------------------------------------------------------
	304	AliEMCALRecParam* GetLowMultiplicityParameters()
	305	{
	306	// Set here the low flux/multiplicity ("p+p") parameters for the reconstruction
	307	//Right now it should be the same settings as with
	308	//AliEMCALRecParam *recParamDB = AliEMCALRecParam::GetLowFluxParam();
	309
	310	AliEMCALRecParam* params = AliEMCALRecParam::GetDefaultParameters();
ee08edde	311	//params->SetClusterizerFlag(AliEMCALRecParam::kClusterizerNxN);
ee08edde	312	params->SetClusterizerFlag(AliEMCALRecParam::kClusterizerv1);
e658398a	313	params->SetClusteringThreshold(0.1); // 100 MeV
a0945e6f	314	params->SetMinECut(0.05); //50 MeV
2b3e9461	315
	316	params->SetUnfold(kFALSE);
	317
	318	params->SetW0(4.5);
	319
f0a6dc6f	320	params->SetTimeCut(250e-9);//250 ns
	321	params->SetTimeMin(425e-9);//425 ns
	322	params->SetTimeMax(825e-9);//825 ns
9dce5a21	323
a0945e6f	324	// Track Matching
	325
	326	params->SetTrkCutNITS(1.0);
	327	params->SetTrkCutNTPC(20.0);
	328	params->SetExtrapolateStep(20.);
	329
1e7c9b89	330	//PID parameters for pp implemented
	331	// as a first step, all array elements are initialized to 0.0
	332	Int_t i, j;
	333	for (i = 0; i < 6; i++) {
	334	for (j = 0; j < 6; j++) {
	335	params->SetGamma(i,j,0.);
	336	params->SetGamma1to10(i,j,0.);
	337	params->SetHadron(i,j,0.);
	338	params->SetHadron1to10(i,j,0.);
	339	params->SetPiZero(i,j,0.);
	340
	341	}
	342	params->SetGammaEnergyProb(i,0.); // not yet implemented
	343	params->SetHadronEnergyProb(i,0.);
	344	params->SetPiZeroEnergyProb(i,0.); // not yet implemented
	345	}
	346
	347	params->SetGamma(0,0, -7.656908e-01);
	348	params->SetGamma(0,1, 2.352536e-01);
	349	params->SetGamma(0,2, 1.555996e-02);
	350	params->SetGamma(0,3, 2.243525e-04);
	351	params->SetGamma(0,4, -2.560087e-06);
	352
	353	params->SetGamma(1,0, 6.500216e+00);
	354	params->SetGamma(1,1, -2.564958e-01);
	355	params->SetGamma(1,2, 1.967894e-01);
	356	params->SetGamma(1,3, -3.982273e-04);
	357	params->SetGamma(1,4, 2.797737e-06);
	358
	359	params->SetGamma(2,0, 2.416489e+00);
	360	params->SetGamma(2,1, -1.601258e-01);
	361	params->SetGamma(2,2, 3.126839e-02);
	362	params->SetGamma(2,3, 3.387532e-04);
	363	params->SetGamma(2,4, -4.089145e-06);
	364
	365	params->SetGamma(3,0,0.);
	366	params->SetGamma(3,1,-2.696008e+00);
	367	params->SetGamma(3,2, 6.920305e-01);
	368	params->SetGamma(3,3,-2.281122e-03);
	369	params->SetGamma(3,4,0.);
	370
	371	params->SetGamma(4,0, 2.281564e-01);
	372	params->SetGamma(4,1, -7.575040e-02);
	373	params->SetGamma(4,2, 3.813423e-01);
	374	params->SetGamma(4,3, -1.243854e-04);
	375	params->SetGamma(4,4, 1.232045e-06);
	376
	377	params->SetGamma(5,0, -3.290107e-01);
	378	params->SetGamma(5,1, 3.707545e-02);
	379	params->SetGamma(5,2, 2.917397e-03);
	380	params->SetGamma(5,3, 4.695306e-05);
	381	params->SetGamma(5,4, -3.572981e-07);
	382
	383	params->SetHadron(0,0, 9.482243e-01);
	384	params->SetHadron(0,1, -2.780896e-01);
	385	params->SetHadron(0,2, 2.223507e-02);
	386	params->SetHadron(0,3, 7.294263e-04);
	387	params->SetHadron(0,4, -5.665872e-06);
	388
	389	params->SetHadron(1,0, 0.);
	390	params->SetHadron(1,1, 0.);
	391	params->SetHadron(1,2, 2.483298e-01);
	392	params->SetHadron(1,3, 0.);
	393	params->SetHadron(1,4, 0.);
394
395	params->SetHadron(2,0, -5.601199e+00);
396	params->SetHadron(2,1, 2.097382e+00);
397	params->SetHadron(2,2, -2.307965e-01);
398	params->SetHadron(2,3, 9.206871e-03);
399	params->SetHadron(2,4, -8.887548e-05);
400
401	params->SetHadron(3,0, 6.543101e+00);
402	params->SetHadron(3,1, -2.305203e+00);
403	params->SetHadron(3,2, 2.761673e-01);
404	params->SetHadron(3,3, -5.465855e-03);
405	params->SetHadron(3,4, 2.784329e-05);
406
407	params->SetHadron(4,0, -2.443530e+01);
408	params->SetHadron(4,1, 8.902578e+00);
409	params->SetHadron(4,2, -5.265901e-01);
410	params->SetHadron(4,3, 2.549111e-02);
411	params->SetHadron(4,4, -2.196801e-04);
412
413	params->SetHadron(5,0, 2.102007e-01);
414	params->SetHadron(5,1, -3.844418e-02);
415	params->SetHadron(5,2, 1.234682e-01);
416	params->SetHadron(5,3, -3.866733e-03);
417	params->SetHadron(5,4, 3.362719e-05);
418
419	params->SetPiZero(0,0, 5.07215e-01);
420	params->SetPiZero(0,1, -5.35274e-01);
421	params->SetPiZero(0,2, 8.49925e-02);
422	params->SetPiZero(0,3, -3.68740e-03);
423	params->SetPiZero(0,4, 5.48228e-05);
424
425	params->SetPiZero(1,0, 4.590137e+02);
426	params->SetPiZero(1,1, -7.079341e+01);
427	params->SetPiZero(1,2, 4.990735e+00);
428	params->SetPiZero(1,3, -1.241302e-01);
429	params->SetPiZero(1,4, 1.065772e-03);
430
431	params->SetPiZero(2,0, 1.376415e+02);
432	params->SetPiZero(2,1, -3.031577e+01);
433	params->SetPiZero(2,2, 2.474338e+00);
434	params->SetPiZero(2,3, -6.903410e-02);
435	params->SetPiZero(2,4, 6.244089e-04);
436
437	params->SetPiZero(3,0, 0.);
438	params->SetPiZero(3,1, 1.145983e+00);
439	params->SetPiZero(3,2, -2.476052e-01);
440	params->SetPiZero(3,3, 1.367373e-02);
441	params->SetPiZero(3,4, 0.);
442
443	params->SetPiZero(4,0, -2.09758e+02);
444	params->SetPiZero(4,1, 6.30080e+01);
445	params->SetPiZero(4,2, -4.03890e+00);
446	params->SetPiZero(4,3, 1.08854e-01);
447	params->SetPiZero(4,4, -9.36248e-04);
448
449	params->SetPiZero(5,0, -1.671477e+01);
450	params->SetPiZero(5,1, 2.995415e+00);
451	params->SetPiZero(5,2, -6.040360e-02);
452	params->SetPiZero(5,3, -6.137459e-04);
453	params->SetPiZero(5,4, 1.847328e-05);
454
455	// params->SetHadronEnergyProb(0,0.);
456	// params->SetHadronEnergyProb(1,0.);
457	// params->SetHadronEnergyProb(2,1.);
458	// params->SetHadronEnergyProb(3,0.);
459	// params->SetHadronEnergyProb(4,0.);
460
461	params->SetHadronEnergyProb(0, 4.767543e-02);
462	params->SetHadronEnergyProb(1, -1.537523e+00);
463	params->SetHadronEnergyProb(2, 2.956727e-01);
464	params->SetHadronEnergyProb(3, -3.051022e+01);
465	params->SetHadronEnergyProb(4, -6.036931e-02);
64c98165	466
	467	// raw signal fitting
	468	params->SetHighLowGainFactor(16.);
	469	params->SetOrderParameter(2);
	470	params->SetTau(2.35);
	471	params->SetNoiseThreshold(3);
	472	params->SetNPedSamples(5);
f0a6dc6f	473	params->SetRemoveBadChannels(kFALSE);
e3968910	474	params->SetFittingAlgorithm(0);//(AliCaloConstants::kStandard);
64c98165	475	params->SetFALTROUsage(kTRUE);
	476	params->SetLEDFit(kFALSE);
	477
1e7c9b89	478	return params;
	479
	480	}
	481
	482