/* History of cvs commits:
*
* $Log$
+ * Revision 1.15 2007/10/09 08:46:10 hristov
+ * The data members fEMCALClusterCluster and fPHOSCluster are removed from AliESDCaloCluster, the fClusterType is used to select PHOS or EMCAL clusters. Changes, needed to use correctly the new AliESDCaloCluster. (Christian)
+ *
* Revision 1.14 2007/07/26 16:54:53 morsch
* Changes in AliESDEvent fwd declarartions.
*
#include "AliLog.h"
#include "AliEMCALPID.h"
#include "AliESDCaloCluster.h"
+#include "AliEMCALRecParam.h"
+#include "AliEMCALReconstructor.h"
+
ClassImp(AliEMCALPID)
// set flag for printing to FALSE by default
fPrintInfo = kFALSE;
-
- // 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++) {
- fGamma[i][j] = fHadron[i][j] = fPiZero5to10[i][j] = fPiZero10to60[i][j] = 0.;
- }
- }
-
- // then, only the ones which must be not zero are initialized
- // while the others will remain to the value 0.0
-
- fGamma[0][0] = 0.038022;
- fGamma[0][1] = -0.0001883;
- fGamma[0][2] = 5.449e-06;
-
- fGamma[1][0] = 0.207313;
- fGamma[1][1] = -0.000978;
- fGamma[1][2] = 0.00001634;
-
- fGamma[2][0] = 0.043364;
- fGamma[2][1] = -0.0002048;
- fGamma[2][2] = 8.661e-06;
- fGamma[2][3] = -1.353e-07;
-
- fGamma[3][0] = 0.265004;
- fGamma[3][1] = 0.061298;
- fGamma[3][2] = -0.003203;
- fGamma[3][3] = 4.73e-05;
-
- fGamma[4][0] = 0.243579;
- fGamma[4][1] = -1.614e-05;
-
- fGamma[5][0] = 0.002942;
- fGamma[5][1] = -3.976e-05;
-
- fHadron[0][0] = 0.011945 / 3.;
- fHadron[0][1] = 0.000386 / 3.;
- fHadron[0][2] = -0.000014 / 3.;
- fHadron[0][3] = 1.336e-07 / 3.;
-
- fHadron[1][0] = 0.496544;
- fHadron[1][1] = -0.003226;
- fHadron[1][2] = 0.00001678;
-
- fHadron[2][0] = 0.144838;
- fHadron[2][1] = -0.002954;
- fHadron[2][2] = 0.00008754;
- fHadron[2][3] = -7.587e-07;
-
- fHadron[3][0] = 1.264461 / 7.;
- fHadron[3][1] = 0.002097 / 7.;
-
- fHadron[4][0] = 0.261950;
- fHadron[4][1] = -0.001078;
- fHadron[4][2] = 0.00003237;
- fHadron[4][3] = -3.241e-07;
- fHadron[4][4] = 0.;
- fHadron[4][5] = 0.;
- fHadron[5][0] = 0.010317;
- fHadron[5][1] = 0.;
- fHadron[5][2] = 0.;
- fHadron[5][3] = 0.;
- fHadron[5][4] = 0.;
- fHadron[5][5] = 0.;
-
- fPiZero5to10[0][0] = 0.009138;
- fPiZero5to10[0][1] = 0.0006377;
-
- fPiZero5to10[1][0] = 0.08;
-
- fPiZero5to10[2][0] = -0.061119;
- fPiZero5to10[2][1] = 0.019013;
-
- fPiZero5to10[3][0] = 0.2;
-
- fPiZero5to10[4][0] = 0.252044;
- fPiZero5to10[4][1] = -0.002315;
-
- fPiZero5to10[5][0] = 0.002942;
- fPiZero5to10[5][1] = -3.976e-05;
-
- fPiZero10to60[0][0] = 0.009138;
- fPiZero10to60[0][1] = 0.0006377;
-
- fPiZero10to60[1][0] = 1.272837;
- fPiZero10to60[1][1] = -0.069708;
- fPiZero10to60[1][2] = 0.001568;
- fPiZero10to60[1][3] = -1.162e-05;
-
- fPiZero10to60[2][0] = 0.139703;
- fPiZero10to60[2][1] = 0.003687;
- fPiZero10to60[2][2] = -0.000568;
- fPiZero10to60[2][3] = 1.498e-05;
- fPiZero10to60[2][4] = -1.174e-07;
-
- fPiZero10to60[3][0] = -0.826367;
- fPiZero10to60[3][1] = 0.096951;
- fPiZero10to60[3][2] = -0.002215;
- fPiZero10to60[3][3] = 2.523e-05;
-
- fPiZero10to60[4][0] = 0.249890;
- fPiZero10to60[4][1] = -0.000063;
-
- fPiZero10to60[5][0] = 0.002942;
- fPiZero10to60[5][1] = -3.976e-05;
-
+
fPIDWeight[0] = -1;
fPIDWeight[1] = -1;
fPIDWeight[2] = -1;
fReconstructor = kFALSE;
+
+ const AliEMCALRecParam* recParam = AliEMCALReconstructor::GetRecParam();
+if(!recParam) {
+ AliFatal("Reconstruction parameters for EMCAL not set!");
+ }
+ else {
+ for(Int_t i=0; i<6; i++){
+ for(Int_t j=0; i<6; i++){
+ fGamma[i][j] = recParam->GetGamma(i,j);
+ fHadron[i][j] = recParam->GetHadron(i,j);
+ fPiZero5to10[i][j] = recParam->GetPiZero5to10(i,j);
+ fPiZero10to60[i][j] = recParam->GetPiZero10to60(i,j);
+ AliDebug(1,Form("PID parameters: fGamma=%.3f, fPi=%.3f, fHAdron=%.3f",
+ fGamma[1][1],fPiZero5to10[1][1],fHadron[1][1] ));
+ }
+ }
+
+ }
+
+
}
//______________________________________________
// but just gamma/PiO/Hadron
//
// trivial check against NULL object passed
-
+
if (esd == 0x0) {
AliInfo("NULL ESD object passed !!" );
return ;
Int_t firstCluster = esd->GetFirstEMCALCluster();
Double_t energy, lambda0;
for (Int_t iCluster = firstCluster; iCluster < (nClusters + firstCluster); iCluster++) {
-
+
AliESDCaloCluster *clust = esd->GetCaloCluster(iCluster);
energy = clust->E();
lambda0 = clust->GetM02();
/* History of cvs commits:
*
* $Log$
+ * Revision 1.13 2007/07/11 13:43:29 hristov
+ * New class AliESDEvent, backward compatibility with the old AliESD (Christian)
+ *
* Revision 1.12 2007/02/20 20:17:43 hristov
* Corrected array size, removed warnings (icc)
*
};
#endif // ALIEMCALPID_H
+
//-----------------------------------------------------------------------------
AliEMCALRecParam::AliEMCALRecParam():
- fClusteringThreshold(0.5),fW0(4.5),fMinECut(0.45)
+ fClusteringThreshold(0.5),fW0(4.5),fMinECut(0.45), //clustering
+ fTrkCutX(6.0), fTrkCutY(6.0), fTrkCutZ(6.0), fTrkCutR(10.0),//track matching
+ fTrkCutAlphaMin(-50.0), fTrkCutAlphaMax(50.0), fTrkCutAngle(10000.0) //track matching
{
// default reco values
+
+ //PID parameters (Guenole)
+
+ // 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++) {
+ fGamma[i][j] = fHadron[i][j] = fPiZero5to10[i][j] = fPiZero10to60[i][j] = 0.;
+ }
+ }
+
+ // then, only the ones which must be not zero are initialized
+ // while the others will remain to the value 0.0
+
+ fGamma[0][0] = 0.038022;
+ fGamma[0][1] = -0.0001883;
+ fGamma[0][2] = 5.449e-06;
+
+ fGamma[1][0] = 0.207313;
+ fGamma[1][1] = -0.000978;
+ fGamma[1][2] = 0.00001634;
+
+ fGamma[2][0] = 0.043364;
+ fGamma[2][1] = -0.0002048;
+ fGamma[2][2] = 8.661e-06;
+ fGamma[2][3] = -1.353e-07;
+
+ fGamma[3][0] = 0.265004;
+ fGamma[3][1] = 0.061298;
+ fGamma[3][2] = -0.003203;
+ fGamma[3][3] = 4.73e-05;
+
+ fGamma[4][0] = 0.243579;
+ fGamma[4][1] = -1.614e-05;
+
+ fGamma[5][0] = 0.002942;
+ fGamma[5][1] = -3.976e-05;
+
+ fHadron[0][0] = 0.011945 / 3.;
+ fHadron[0][1] = 0.000386 / 3.;
+ fHadron[0][2] = -0.000014 / 3.;
+ fHadron[0][3] = 1.336e-07 / 3.;
+
+ fHadron[1][0] = 0.496544;
+ fHadron[1][1] = -0.003226;
+ fHadron[1][2] = 0.00001678;
+
+ fHadron[2][0] = 0.144838;
+ fHadron[2][1] = -0.002954;
+ fHadron[2][2] = 0.00008754;
+ fHadron[2][3] = -7.587e-07;
+
+ fHadron[3][0] = 1.264461 / 7.;
+ fHadron[3][1] = 0.002097 / 7.;
+
+ fHadron[4][0] = 0.261950;
+ fHadron[4][1] = -0.001078;
+ fHadron[4][2] = 0.00003237;
+ fHadron[4][3] = -3.241e-07;
+ fHadron[4][4] = 0.;
+ fHadron[4][5] = 0.;
+ fHadron[5][0] = 0.010317;
+ fHadron[5][1] = 0.;
+ fHadron[5][2] = 0.;
+ fHadron[5][3] = 0.;
+ fHadron[5][4] = 0.;
+ fHadron[5][5] = 0.;
+
+ fPiZero5to10[0][0] = 0.009138;
+ fPiZero5to10[0][1] = 0.0006377;
+
+ fPiZero5to10[1][0] = 0.08;
+
+ fPiZero5to10[2][0] = -0.061119;
+ fPiZero5to10[2][1] = 0.019013;
+
+ fPiZero5to10[3][0] = 0.2;
+
+ fPiZero5to10[4][0] = 0.252044;
+ fPiZero5to10[4][1] = -0.002315;
+
+ fPiZero5to10[5][0] = 0.002942;
+ fPiZero5to10[5][1] = -3.976e-05;
+
+ fPiZero10to60[0][0] = 0.009138;
+ fPiZero10to60[0][1] = 0.0006377;
+
+ fPiZero10to60[1][0] = 1.272837;
+ fPiZero10to60[1][1] = -0.069708;
+ fPiZero10to60[1][2] = 0.001568;
+ fPiZero10to60[1][3] = -1.162e-05;
+
+ fPiZero10to60[2][0] = 0.139703;
+ fPiZero10to60[2][1] = 0.003687;
+ fPiZero10to60[2][2] = -0.000568;
+ fPiZero10to60[2][3] = 1.498e-05;
+ fPiZero10to60[2][4] = -1.174e-07;
+
+ fPiZero10to60[3][0] = -0.826367;
+ fPiZero10to60[3][1] = 0.096951;
+ fPiZero10to60[3][2] = -0.002215;
+ fPiZero10to60[3][3] = 2.523e-05;
+
+ fPiZero10to60[4][0] = 0.249890;
+ fPiZero10to60[4][1] = -0.000063;
+
+ fPiZero10to60[5][0] = 0.002942;
+ fPiZero10to60[5][1] = -3.976e-05;
+
+ //track matching
+
+
+
}
//-----------------------------------------------------------------------------
{
printf("AliEMCALRecParam::Print()\n");
// Print reconstruction parameters to stdout
- AliInfo(Form("Reconstruction parameters:\n fClusteringThreshold=%.3f,\n fW0=%.3f,\n fMinECut=%.3f",
+ AliInfo(Form("Clusterization parameters :\n fClusteringThreshold=%.3f,\n fW0=%.3f,\n fMinECut=%.3f\n",
fClusteringThreshold,fW0,fMinECut));
+ AliInfo(Form("Track-matching cuts :\n x %f, y %f, z %f, R %f \n alphaMin %f, alphaMax %f, Angle %f\n", fTrkCutX, fTrkCutY, fTrkCutZ, fTrkCutR,fTrkCutAlphaMin,fTrkCutAlphaMax, fTrkCutAngle));
+
+ AliInfo(Form("PID parameters, Gamma :\n"));
+ for(Int_t i = 0; i < 6; i++){
+ for(Int_t j = 0; j < 6; j++){
+ printf(" %f, ", fGamma[i][j]);
+ }
+ printf("\n");
+ }
+
+ printf("\n");
+
+ AliInfo(Form("PID parameters, Hadron :\n"));
+ for(Int_t i = 0; i < 6; i++){
+ for(Int_t j = 0; j < 6; j++){
+ printf(" %f, ", fHadron[i][j]);
+ }
+ printf("\n");
+ }
+
+ printf("\n");
+
+ AliInfo(Form("PID parameters, Pi0zero5to10 :\n"));
+ for(Int_t i = 0; i < 6; i++){
+ for(Int_t j = 0; j < 6; j++){
+ printf(" %f, ", fPiZero5to10[i][j]);
+ }
+ printf("\n");
+ }
+
+ printf("\n");
+
+ AliInfo(Form("PID parameters, Pi0zero10to60 :\n"));
+ for(Int_t i = 0; i < 6; i++){
+ for(Int_t j = 0; j < 6; j++){
+ printf(" %f, ", fPiZero10to60[i][j]);
+ }
+ printf("\n");
+ }
+
+ printf("\n");
+
}
+
//-----------------------------------------------------------------------------
// Container of EMCAL reconstruction parameters
// The purpose of this object is to store it to OCDB
-// and retrieve it in AliEMCALClusterizerv1
+// and retrieve it in AliEMCALClusterizerv1, AliEMCALPID and AliEMCALTracker
// Author: Yuri Kharlov
//-----------------------------------------------------------------------------
AliEMCALRecParam() ;
virtual ~AliEMCALRecParam() {}
+
+ //Clustering
Float_t GetClusteringThreshold() const {return fClusteringThreshold;}
Float_t GetW0 () const {return fW0 ;}
Float_t GetMinECut () const {return fMinECut ;}
void SetClusteringThreshold(Float_t thrsh) {fClusteringThreshold = thrsh;}
void SetW0 (Float_t w0) {fW0 = w0 ;}
void SetMinECut (Float_t minEcut) {fMinECut = minEcut ;}
- virtual void Print(Option_t * option="") const ;
+
+ //PID (Guenole)
+ Double_t GetGamma(Int_t i, Int_t j) const {return fGamma[i][j];}
+ Double_t GetHadron(Int_t i, Int_t j) const {return fHadron[i][j];}
+ Double_t GetPiZero5to10(Int_t i, Int_t j) const {return fPiZero5to10[i][j];}
+ Double_t GetPiZero10to60(Int_t i, Int_t j) const {return fPiZero10to60[i][j];}
+
+ void SetGamma(Int_t i, Int_t j,Double_t param ) {fGamma[i][j]=param;}
+ void SetHadron(Int_t i, Int_t j,Double_t param ) {fHadron[i][j]=param;}
+ void SetPiZero5to10(Int_t i, Int_t j,Double_t param) {fPiZero5to10[i][j]=param;}
+ void SetPiZero10to60(Int_t i, Int_t j,Double_t param) {fPiZero10to60[i][j]=param;}
+
+ //Track Matching (Alberto)
+ /* track matching cut setters */
+ void SetTrkCutX(Double_t value) {fTrkCutX = value;}
+ void SetTrkCutY(Double_t value) {fTrkCutY = value;}
+ void SetTrkCutZ(Double_t value) {fTrkCutZ = value;}
+ void SetTrkCutR(Double_t value) {fTrkCutR = value;}
+ void SetTrkCutAlphaMin(Double_t value) {fTrkCutAlphaMin = value;}
+ void SetTrkCutAlphaMax(Double_t value) {fTrkCutAlphaMax = value;}
+ void SetTrkCutAngle(Double_t value) {fTrkCutAngle = value;}
+ /* track matching cut getters */
+ Double_t GetTrkCutX() const {return fTrkCutX;}
+ Double_t GetTrkCutY() const {return fTrkCutY;}
+ Double_t GetTrkCutZ() const {return fTrkCutZ;}
+ Double_t GetTrkCutR() const {return fTrkCutR;}
+ Double_t GetTrkCutAlphaMin() const {return fTrkCutAlphaMin;}
+ Double_t GetTrkCutAlphaMax() const {return fTrkCutAlphaMax;}
+ Double_t GetTrkCutAngle() const {return fTrkCutAngle;}
+
+ virtual void Print(Option_t * option="") const ;
+
private:
+ //Clustering
Float_t fClusteringThreshold ; // minimum energy to seed a EC digit in a cluster
Float_t fW0 ; // logarithmic weight for the cluster center of gravity calculation
Float_t fMinECut; // Minimum energy for a digit to be a member of a cluster
- ClassDef(AliEMCALRecParam,1) // Reconstruction parameters
+ //PID (Guenole)
+ Double_t fGamma[6][6]; // Parameter to Compute PID
+ Double_t fHadron[6][6]; // Parameter to Compute PID
+ Double_t fPiZero5to10[6][6]; // Parameter to Compute PID
+ Double_t fPiZero10to60[6][6]; // Parameter to Compute PID
+
+ //Track-Matching (Alberto)
+ Double_t fTrkCutX; // X-difference cut for track matching
+ Double_t fTrkCutY; // Y-difference cut for track matching
+ Double_t fTrkCutZ; // Z-difference cut for track matching
+ Double_t fTrkCutR; // cut on allowed track-cluster distance
+ Double_t fTrkCutAlphaMin; // cut on 'alpha' parameter for track matching (min)
+ Double_t fTrkCutAlphaMax; // cut on 'alpha' parameter for track matching (min)
+ Double_t fTrkCutAngle; // cut on relative angle between different track points for track matching
+
+ ClassDef(AliEMCALRecParam,2) // Reconstruction parameters
} ;
#endif // ALIEMCALRECPARAM_H
+
#include "AliEMCALTrack.h"
#include "AliEMCALLoader.h"
#include "AliEMCALGeometry.h"
+#include "AliEMCALReconstructor.h"
+#include "AliEMCALRecParam.h"
+#include "AliCDBEntry.h"
+#include "AliCDBManager.h"
#include "AliEMCALTracker.h"
ClassImp(AliEMCALTracker)
+
+AliEMCALRecParam* AliEMCALTracker::fgkRecParam = 0; // EMCAL rec. parameters
+
//
//------------------------------------------------------------------------------
//
// and all collections to NULL.
// Output file name is set to a default value.
//
+
+ InitParameters();
}
//
//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
//
+void AliEMCALTracker::InitParameters()
+{
+ //
+ // Retrieve initialization parameters
+ //
+
+ // Check if the instance of AliEMCALRecParam exists,
+ // if not, get it from OCDB if available, otherwise create a default one
+
+ if (!fgkRecParam && (AliCDBManager::Instance()->IsDefaultStorageSet())) {
+ AliCDBEntry *entry = (AliCDBEntry*)
+ AliCDBManager::Instance()->Get("EMCAL/Config/RecParam");
+ if (entry) fgkRecParam = (AliEMCALRecParam*) entry->GetObject();
+ }
+
+ if(!fgkRecParam){
+ AliWarning("The Track Matching parameters for EMCAL nonitialized - Used default one");
+ fgkRecParam = new AliEMCALRecParam;
+ }
+
+ fCutX = fgkRecParam->GetTrkCutX();
+ fCutY = fgkRecParam->GetTrkCutY();
+ fCutZ = fgkRecParam->GetTrkCutZ();
+ fMaxDist = fgkRecParam->GetTrkCutR();
+ fCutAngle = fgkRecParam->GetTrkCutAngle();
+ fCutAlphaMin = fgkRecParam->GetTrkCutAlphaMin();
+ fCutAlphaMax = fgkRecParam->GetTrkCutAlphaMax();
+
+}
+//
+//------------------------------------------------------------------------------
+//
TTree* AliEMCALTracker::SearchTrueMatches()
{
//Search through the list of
class AliEMCALTrack;
class AliEMCALRecPoint;
class AliEMCALGeometry;
+class AliEMCALRecParam;
class AliEMCALTracker : public AliTracker
{
virtual void Clear(Option_t *option="ALL");
virtual Int_t Clusters2Tracks(AliESDEvent*) {return -1;}
+ void InitParameters();
virtual Int_t LoadClusters(TTree*);
Int_t LoadClusters(AliESDEvent* esd);
Int_t LoadTracks(AliESDEvent* esd);
TList *fMatches; //! collection of matches between tracks and clusters
AliEMCALGeometry *fGeom; //! EMCAL geometry
+ static AliEMCALRecParam* fgkRecParam; // track-matching parameters for EMCAL
- ClassDef(AliEMCALTracker, 1) // EMCAL "tracker"
+ ClassDef(AliEMCALTracker, 2) // EMCAL "tracker"
};
#endif
// Create reconstruction parameter object and set parameter values
AliEMCALRecParam *recParamDB = new AliEMCALRecParam();
+ //Clusterization
recParamDB->SetClusteringThreshold(0.5);
recParamDB->SetW0(4.5);
recParamDB->SetMinECut(0.45);
+ //Track matching
+ recParamDB->SetTrkCutX(6.0);
+ recParamDB->SetTrkCutY(6.0);
+ recParamDB->SetTrkCutZ(6.0);
+ recParamDB->SetTrkCutR(10.0);
+ recParamDB->SetTrkCutAlphaMin(-50.0);
+ recParamDB->SetTrkCutAlphaMin( 50.0);
+ recParamDB->SetTrkCutAngle(10000.0); // i.e. exclude this for the moment
+
+ //PID
+ recParamDB->SetGamma(0,0, 0.038022);
+ recParamDB->SetGamma(0,1, -0.0001883);
+ recParamDB->SetGamma(0,2, 5.449e-06);
+
+ recParamDB->SetGamma(1,0, 0.207313);
+ recParamDB->SetGamma(1,1, -0.000978);
+ recParamDB->SetGamma(1,2, 0.00001634);
+
+ recParamDB->SetGamma(2,0, 0.043364);
+ recParamDB->SetGamma(2,1, -0.0002048);
+ recParamDB->SetGamma(2,2, 8.661e-06);
+ recParamDB->SetGamma(2,3, -1.353e-07);
+
+ recParamDB->SetGamma(3,0, 0.265004);
+ recParamDB->SetGamma(3,1, 0.061298);
+ recParamDB->SetGamma(3,2, -0.003203);
+ recParamDB->SetGamma(3,3, 4.73e-05);
+
+ recParamDB->SetGamma(4,0, 0.243579);
+ recParamDB->SetGamma(4,1, -1.614e-05);
+
+ recParamDB->SetGamma(5,0, 0.002942);
+ recParamDB->SetGamma(5,1, -3.976e-05);
+
+ recParamDB->SetHadron(0,0, 0.011945 / 3.);
+ recParamDB->SetHadron(0,1, 0.000386 / 3.);
+ recParamDB->SetHadron(0,2, -0.000014 / 3.);
+ recParamDB->SetHadron(0,3, 1.336e-07 / 3.);
+
+ recParamDB->SetHadron(1,0, 0.496544);
+ recParamDB->SetHadron(1,1, -0.003226);
+ recParamDB->SetHadron(1,2, 0.00001678);
+
+ recParamDB->SetHadron(2,0, 0.144838);
+ recParamDB->SetHadron(2,1, -0.002954);
+ recParamDB->SetHadron(2,2, 0.00008754);
+ recParamDB->SetHadron(2,3, -7.587e-07);
+
+ recParamDB->SetHadron(3,0, 1.264461 / 7.);
+ recParamDB->SetHadron(3,1, 0.002097 / 7.);
+
+ recParamDB->SetHadron(4,0, 0.261950);
+ recParamDB->SetHadron(4,1, -0.001078);
+ recParamDB->SetHadron(4,2, 0.00003237);
+ recParamDB->SetHadron(4,3, -3.241e-07);
+ recParamDB->SetHadron(4,4, 0.);
+ recParamDB->SetHadron(4,5, 0.);
+ recParamDB->SetHadron(5,0, 0.010317);
+ recParamDB->SetHadron(5,1, 0.);
+ recParamDB->SetHadron(5,2, 0.);
+ recParamDB->SetHadron(5,3, 0.);
+ recParamDB->SetHadron(5,4, 0.);
+ recParamDB->SetHadron(5,5, 0.);
+
+ recParamDB->SetPiZero5to10(0,0, 0.009138);
+ recParamDB->SetPiZero5to10(0,1, 0.0006377);
+
+ recParamDB->SetPiZero5to10(1,0, 0.08);
+
+ recParamDB->SetPiZero5to10(2,0, -0.061119);
+ recParamDB->SetPiZero5to10(2,1, 0.019013);
+
+ recParamDB->SetPiZero5to10(3,0, 0.2);
+
+ recParamDB->SetPiZero5to10(4,0, 0.252044);
+ recParamDB->SetPiZero5to10(4,1, -0.002315);
+
+ recParamDB->SetPiZero5to10(5,0, 0.002942);
+ recParamDB->SetPiZero5to10(5,1, -3.976e-05);
+
+ recParamDB->SetPiZero10to60(0,0, 0.009138);
+ recParamDB->SetPiZero10to60(0,1, 0.0006377);
+
+ recParamDB->SetPiZero10to60(1,0, 1.272837);
+ recParamDB->SetPiZero10to60(1,1, -0.069708);
+ recParamDB->SetPiZero10to60(1,2, 0.001568);
+ recParamDB->SetPiZero10to60(1,3, -1.162e-05);
+
+ recParamDB->SetPiZero10to60(2,0, 0.139703);
+ recParamDB->SetPiZero10to60(2,1, 0.003687);
+ recParamDB->SetPiZero10to60(2,2, -0.000568);
+ recParamDB->SetPiZero10to60(2,3, 1.498e-05);
+ recParamDB->SetPiZero10to60(2,4, -1.174e-07);
+
+ recParamDB->SetPiZero10to60(3,0, -0.826367);
+ recParamDB->SetPiZero10to60(3,1, 0.096951);
+ recParamDB->SetPiZero10to60(3,2, -0.002215);
+ recParamDB->SetPiZero10to60(3,3, 2.523e-05);
+
+ recParamDB->SetPiZero10to60(4,0, 0.249890);
+ recParamDB->SetPiZero10to60(4,1, -0.000063);
+
+ recParamDB->SetPiZero10to60(5,0, 0.002942);
+ recParamDB->SetPiZero10to60(5,1, -3.976e-05);
+
// Store calibration data into database
AliCDBMetaData md;
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff