Change from Int_t/SHort_t to smaller data types, the change from Float_t/Double_t...
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 9 Oct 2007 09:00:06 +0000 (09:00 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 9 Oct 2007 09:00:06 +0000 (09:00 +0000)
12 files changed:
STEER/AliESDcascade.cxx
STEER/AliESDcascade.h
STEER/AliESDkink.cxx
STEER/AliESDkink.h
STEER/AliESDtrack.cxx
STEER/AliESDtrack.h
STEER/AliESDv0.cxx
STEER/AliESDv0.h
STEER/AliKalmanTrack.cxx
STEER/AliKalmanTrack.h
STEER/AliReconstruction.cxx
STEER/AliVertex.h

index c16afb5..97c6949 100644 (file)
@@ -35,10 +35,10 @@ ClassImp(AliESDcascade)
 
 AliESDcascade::AliESDcascade() : 
   AliESDv0(),
-  fPdgCodeXi(kXiMinus),
   fEffMassXi(TDatabasePDG::Instance()->GetParticle(kXiMinus)->Mass()),
-  fChi2Xi(1.e+33),
-  fDcaXiDaughters(999),
+  fChi2Xi(1024),
+  fDcaXiDaughters(1024),
+  fPdgCodeXi(kXiMinus),
   fBachIdx(-1)
 {
   //--------------------------------------------------------------------
@@ -49,17 +49,17 @@ AliESDcascade::AliESDcascade() :
     fBachMom[j]=0.;
   }
 
-  fPosCovXi[0]=1e10;
+  fPosCovXi[0]=1024;
   fPosCovXi[1]=fPosCovXi[2]=0.;
-  fPosCovXi[3]=1e10;
+  fPosCovXi[3]=1024;
   fPosCovXi[4]=0.;
-  fPosCovXi[5]=1e10;
+  fPosCovXi[5]=1024;
 
-  fBachMomCov[0]=1e10;
+  fBachMomCov[0]=1024;
   fBachMomCov[1]=fBachMomCov[2]=0.;
-  fBachMomCov[3]=1e10;
+  fBachMomCov[3]=1024;
   fBachMomCov[4]=0.;
-  fBachMomCov[5]=1e10;
+  fBachMomCov[5]=1024;
 }
 
 AliESDcascade::~AliESDcascade() {
@@ -68,10 +68,10 @@ AliESDcascade::~AliESDcascade() {
 AliESDcascade::AliESDcascade(const AliESDv0 &v,
                             const AliExternalTrackParam &t, Int_t i) : 
   AliESDv0(v),
+  fEffMassXi(TDatabasePDG::Instance()->GetParticle(kXiMinus)->Mass()),
+  fChi2Xi(1024),
+  fDcaXiDaughters(1024),
   fPdgCodeXi(kXiMinus),
-  fEffMassXi(-1),
-  fChi2Xi(1.e+33),
-  fDcaXiDaughters(-1),
   fBachIdx(i)
 {
   //---------------------------------------------------------------------------------------------
@@ -117,19 +117,19 @@ AliESDcascade::AliESDcascade(const AliESDv0 &v,
   fBachMom[0]=px1; fBachMom[1]=py1; fBachMom[2]=pz1; 
 
   //PH Covariance matrices: to be calculated correctly in the future
-  fPosCovXi[0]=1e10;
+  fPosCovXi[0]=1024;
   fPosCovXi[1]=fPosCovXi[2]=0.;
-  fPosCovXi[3]=1e10;
+  fPosCovXi[3]=1024;
   fPosCovXi[4]=0.;
-  fPosCovXi[5]=1e10;
+  fPosCovXi[5]=1024;
 
-  fBachMomCov[0]=1e10;
+  fBachMomCov[0]=1024;
   fBachMomCov[1]=fBachMomCov[2]=0.;
-  fBachMomCov[3]=1e10;
+  fBachMomCov[3]=1024;
   fBachMomCov[4]=0.;
-  fBachMomCov[5]=1e10;
+  fBachMomCov[5]=1024;
 
-  fChi2Xi=7.;   
+  fChi2Xi=1024.;   
 
 }
 
index dc4c276..b16b83f 100644 (file)
 
 class AliExternalTrackParam;
 
-#define kXiMinus       3312
-#define kXiPlusBar    -3312
-#define kOmegaMinus    3334
-#define kOmegaPlusBar -3334
 
 class AliESDcascade : public AliESDv0 {
 
+  enum  { kOmegaPlusBar =  -3334,
+         kXiPlusBar    =  -3312,
+         kXiMinus      =   3312,
+         kOmegaMinus   =   3334};
+
 public:
   AliESDcascade();
   AliESDcascade(const AliESDcascade&);
@@ -55,21 +56,22 @@ public:
   void GetPosCovXi(Double_t cov[6]) const;
 
 protected: 
-  Int_t      fPdgCodeXi;      // reconstructed cascade type (PDG code)
+
   Double32_t fEffMassXi;      // reconstructed cascade effective mass
   Double32_t fChi2Xi;         // chi2 value
   Double32_t fDcaXiDaughters; // dca between Xi's daughters
   Double32_t fPosXi[3];       // cascade vertex position (global)
   Double32_t fPosCovXi[6];    // covariance matrix of the vertex position
-
-  Int_t      fBachIdx;        // label of the bachelor track
   Double32_t fBachMom[3];     // bachelor momentum (global)
   Double32_t fBachMomCov[6];  // covariance matrix of the bachelor momentum.
+  Int_t      fPdgCodeXi;      // reconstructed cascade type (PDG code)
+  Int_t      fBachIdx;        // label of the bachelor track
+
 
 private:
   AliESDcascade& operator=(const AliESDcascade&);
 
-  ClassDef(AliESDcascade,4) // reconstructed cascade vertex
+  ClassDef(AliESDcascade,5) // reconstructed cascade vertex
 };
 
 inline
index 6985d95..8c7d0e6 100644 (file)
@@ -30,23 +30,22 @@ ClassImp(AliESDkink)
 //____________________________________________________________________
 AliESDkink::AliESDkink() :
   TObject(),
-  fID(0),
   fParamDaughter(),
   fParamMother(),
   fDist1(-1),
   fDist2(-1),
-  fRr(-1),
+  fRr(0),
   fShapeFactor(0),
-  fRow0(-1)
+  fID(0),
+  fRow0(0)
 {
   //
-  //Dafault constructor
+  //Default constructor
   //
   for (Int_t i=0;i<12;i++) fStatus[i]=0;
   for (Int_t i=0;i<2;i++)
     for (Int_t j=0;j<2;j++){
-      fTPCdensity[i][j]=-1;
-      fTPCdensity2[i][j]=-1;
+      fTPCdensity[i][j]=0;
     }
   fTPCncls[0]=fTPCncls[1]=0;
 
@@ -56,12 +55,81 @@ AliESDkink::AliESDkink() :
     fPm[i] = 0;
     fAngle[i] = 0;
   }
-  
-  fLab[0]=fLab[1]=-1;
+  fLab[0]=fLab[1]=0;
   fIndex[0]=fIndex[1]=-1;
   fMultiple[0]=fMultiple[1]=0;
 }
 
+AliESDkink::AliESDkink(const AliESDkink &source):
+  TObject(source),
+  fParamDaughter(source.fParamDaughter),
+  fParamMother(source.fParamMother),
+  fDist1(source.fDist1),
+  fDist2(source.fDist1),
+  fRr(source.fRr),
+  fShapeFactor(source.fShapeFactor),
+  fID(source.fID),
+  fRow0(source.fRow0)
+{
+  //
+  //Copy constructor
+  //
+  for (Int_t i=0;i<12;i++) fStatus[i]=source.fStatus[i];
+  for (Int_t i=0;i<2;i++){
+    fTPCncls[i] = source.fTPCncls[i];
+    fLab[i]     = source.fLab[i];
+    fIndex[i]   = source.fIndex[i];
+    fMultiple[i]= source.fMultiple[i];
+    for (Int_t j=0;j<2;j++){
+      fTPCdensity[i][j] = source.fTPCdensity[i][j];
+    }
+  }
+  for (Int_t i=0; i<3; i++) {
+    fPdr[i] = source.fPdr[i];
+    fXr[i] = source.fXr[i];
+    fPm[i] = source.fPm[i];
+    fAngle[i] = source.fAngle[i];
+  }
+}
+
+//_____________________________________________________________________________
+AliESDkink& AliESDkink::operator=(const AliESDkink &source)
+{
+  //
+  // assignment operator
+  //
+  
+  if (this!=&source) {
+    TObject::operator=(source);
+    fParamDaughter = source.fParamDaughter;
+    fParamMother = source.fParamMother;
+    fDist1 = source.fDist1;
+    fDist2 = source.fDist1;
+    fRr = source.fRr;
+    fShapeFactor = source.fShapeFactor;
+    fID = source.fID;
+    fRow0 = source.fRow0;
+    for (Int_t i=0;i<12;i++) fStatus[i]=source.fStatus[i];
+    for (Int_t i=0;i<2;i++){
+      fTPCncls[i] = source.fTPCncls[i];
+      fLab[i]     = source.fLab[i];
+      fIndex[i]   = source.fIndex[i];
+      fMultiple[i]= source.fMultiple[i];
+      for (Int_t j=0;j<2;j++){
+       fTPCdensity[i][j] = source.fTPCdensity[i][j];
+      }
+    }
+    for (Int_t i=0; i<3; i++) {
+      fPdr[i] = source.fPdr[i];
+      fXr[i] = source.fXr[i];
+      fPm[i] = source.fPm[i];
+      fAngle[i] = source.fAngle[i];
+    }
+  }
+
+  return *this;
+}
+
 void AliESDkink::SetMother(const AliExternalTrackParam & pmother)  {
   //
   // set mother
@@ -77,11 +145,11 @@ void AliESDkink::SetDaughter(const AliExternalTrackParam & pdaughter){
 
 }
   
-Float_t AliESDkink::GetTPCDensityFactor() const
+Double_t AliESDkink::GetTPCDensityFactor() const
 {
   //
   //
-  return fTPCdensity[0][0]+fTPCdensity[1][1]-TMath::Max(fTPCdensity[0][1],Float_t(0.0))-TMath::Max(fTPCdensity[1][0],Float_t(0.0)); 
+  return fTPCdensity[0][0]+fTPCdensity[1][1]-TMath::Max(fTPCdensity[0][1],Double_t(0.0))-TMath::Max(fTPCdensity[1][0],Double_t(0.0)); 
 }
 
 Float_t AliESDkink::GetQt() const
index f0c5b87..217369f 100644 (file)
@@ -21,18 +21,20 @@ class AliESDtrack;
 class AliESDkink : public TObject {
 public:
   AliESDkink();             //constructor
+  AliESDkink(const AliESDkink &source);             //constructor
+  AliESDkink& operator=(const AliESDkink &source);
   //
-  void SetID(Int_t id){fID=id;}
-  Int_t GetID(){return fID;}
+  void SetID(Short_t id){fID=id;}
+  Short_t GetID(){return fID;}
   void SetMother(const AliExternalTrackParam & pmother); 
   void SetDaughter(const AliExternalTrackParam & pdaughter);
-  Float_t GetTPCDensityFactor() const;
+  Double_t GetTPCDensityFactor() const;
   Float_t GetQt() const;    
   //
-  Float_t GetR() const {return fRr;}
-  Float_t GetDistance() const {return fDist2;}
-  Int_t   GetTPCRow0() const {return fRow0;}
-  Float_t GetAngle(Int_t i) const {return fAngle[i];}
+  Double_t GetR() const {return fRr;}
+  Double_t GetDistance() const {return fDist2;}
+  UChar_t   GetTPCRow0() const {return fRow0;}
+  Double_t GetAngle(Int_t i) const {return fAngle[i];}
   const Double_t *GetPosition() const   {return fXr;}
   const Double_t *GetMotherP()  const   {return fPm;}
   const Double_t *GetDaughterP()  const {return fPdr;}
@@ -41,25 +43,24 @@ public:
   void SetLabel(Int_t label, Int_t pos) {fLab[pos]=label;}
   Int_t GetIndex(Int_t i) const {return fIndex[i];}
   void SetIndex(Int_t index, Int_t pos){fIndex[pos]=index;}
-  void SetStatus(Int_t status, Int_t pos){fStatus[pos]=status;}
-  Int_t GetStatus(Int_t pos) const {return fStatus[pos];}
-  void SetTPCncls(Int_t ncls,Int_t pos) {fTPCncls[pos]=ncls;}
-  const Int_t *GetTPCncls() const {return fTPCncls;} 
+  void SetStatus(Char_t status, Int_t pos){fStatus[pos]=status;}
+  Char_t GetStatus(Int_t pos) const {return fStatus[pos];}
+  void SetTPCncls(UChar_t ncls,Int_t pos) {fTPCncls[pos]=ncls;}
+  const UChar_t *GetTPCncls() const {return fTPCncls;} 
   void  SetTPCDensity(Float_t dens, Int_t pos0,Int_t pos1){fTPCdensity[pos0][pos1]=dens;}
-  Float_t GetTPCDensity(Int_t pos0,Int_t pos1) const {return fTPCdensity[pos0][pos1];}
-  void    SetTPCDensity2(Float_t dens, Int_t pos0,Int_t pos1){fTPCdensity[pos0][pos1]=dens;}
-  Float_t GetTPCDensity2(Int_t pos0,Int_t pos1) const {return fTPCdensity[pos0][pos1];}
-  Float_t GetShapeFactor() const {return fShapeFactor;}
+  Double_t GetTPCDensity(Int_t pos0,Int_t pos1) const {return fTPCdensity[pos0][pos1];}
+  Double_t GetShapeFactor() const {return fShapeFactor;}
   void    SetShapeFactor(Float_t factor){fShapeFactor = factor;}
-  void  SetMultiple(Int_t mult,Int_t pos){fMultiple[pos]=mult;}
-  const Int_t * GetMultiple() const {return fMultiple;}
+  void  SetMultiple(UChar_t mult,Int_t pos){fMultiple[pos]=mult;}
+  const UChar_t * GetMultiple() const {return fMultiple;}
   //  
   const AliExternalTrackParam& RefParamDaughter() {return fParamDaughter;}
   const AliExternalTrackParam& RefParamMother()   {return fParamMother;}
  protected:
-  Int_t          fID;       // kink ID
+
   AliExternalTrackParam fParamDaughter;
   AliExternalTrackParam fParamMother;
+
   Double32_t       fDist1;    //info about closest distance according closest MC - linear DCA
   Double32_t       fDist2;    //info about closest distance parabolic DCA
   //
@@ -67,18 +68,25 @@ public:
   Double32_t       fXr[3];     //rec. position according helix
   //
   Double32_t       fPm[3];    //momentum at the vertex mother
-  Double32_t       fAngle[3]; //three angles
   Double32_t       fRr;       // rec position of the vertex 
-  Int_t          fLab[2];   //MC label of the partecle
-  Int_t          fIndex[2]; //reconstructed labels of the tracks
-  Char_t         fStatus[12];       //status of kink - first 4 mother (ITS,TPC,TRD,TOF)  other daughter
-  Float_t        fTPCdensity[2][2];  //tpc cluster density before and after kink
-  Float_t        fTPCdensity2[2][2];  //tpc cluster density before and after kink - after second iteration
-  Float_t        fShapeFactor;       // tpc clusters shape factor
-  Int_t          fRow0;              // critical pad row number
-  Int_t          fMultiple[2];       //how many times the track's were used
-  Int_t          fTPCncls[2];     //number of clusters for mother particle
-  ClassDef(AliESDkink,3)      // ESD V0 vertex
+
+  Double32_t       fShapeFactor;       // tpc clusters shape factor
+  Double32_t       fTPCdensity[2][2];  //[0,1,16]tpc cluster density before and after kink
+  Double32_t       fAngle[3]; //[-2*pi,2*pi,16]three angles
+
+  Int_t            fLab[2];   //MC label of the partecle
+  Int_t            fIndex[2]; //reconstructed labels of the tracks
+
+  Short_t          fID;       // kink ID
+
+  UChar_t          fRow0;              // critical pad row number
+  UChar_t          fMultiple[2];       //how many times the track's were used
+  UChar_t          fTPCncls[2];     //number of clusters for mother particle
+
+  Char_t           fStatus[12];       //status of kink - first 4 mother (ITS,TPC,TRD,TOF)  other daughter
+
+
+  ClassDef(AliESDkink,4)      // ESD V0 vertex
 };
 
 #endif
index 226afd1..4ed8ca6 100644 (file)
@@ -31,7 +31,7 @@
 
 ClassImp(AliESDtrack)
 
-void SetPIDValues(Float_t * dest, const Double_t * src, Int_t n) {
+void SetPIDValues(Double_t * dest, const Double_t * src, Int_t n) {
   // This function copies "n" PID weights from "scr" to "dest"
   // and normalizes their sum to 1 thus producing conditional probabilities.
   // The negative weights are set to 0.
@@ -61,58 +61,58 @@ void SetPIDValues(Float_t * dest, const Double_t * src, Int_t n) {
 //_______________________________________________________________________
 AliESDtrack::AliESDtrack() : 
   AliExternalTrackParam(),
+  fCp(0),
+  fIp(0),
+  fTPCInner(0),
+  fOp(0),
+  fFriendTrack(new AliESDfriendTrack()),
+  fTPCClusterMap(159),//number of padrows
+  fTPCSharedMap(159),//number of padrows
   fFlags(0),
-  fLabel(0),
   fID(0),
+  fLabel(0),
+  fITSLabel(0),
+  fTPCLabel(0),
+  fTRDLabel(0),
+  fTOFCalChannel(0),
+  fTOFindex(0),
+  fHMPIDqn(0),
+  fHMPIDcluIdx(0),
+  fEMCALindex(kEMCALNoMatch),
+  fHMPIDtrkTheta(0),
+  fHMPIDtrkPhi(0),
+  fHMPIDsignal(0),
   fTrackLength(0),
   fD(0),fZ(0),
   fCdd(0),fCdz(0),fCzz(0),
-  fStopVertex(0),
-  fCp(0),
-  fCchi2(1e10),
-  fIp(0),
-  fTPCInner(0),
-  fOp(0),
+  fCchi2(0),
   fITSchi2(0),
-  fITSncls(0),
-  fITSClusterMap(0),
-  fITSsignal(0),
-  fITSLabel(0),
   fTPCchi2(0),
-  fTPCncls(0),
-  fTPCnclsF(0),
-  fTPCClusterMap(159),//number of padrows
-  fTPCSharedMap(159),//number of padrows
+  fTRDchi2(0),
+  fTOFchi2(0),
+  fHMPIDchi2(0),
+  fITSsignal(0),
   fTPCsignal(0),
-  fTPCsignalN(0),
   fTPCsignalS(0),
-  fTPCLabel(0),
-  fTRDchi2(0),
-  fTRDncls(0),
-  fTRDncls0(0),
   fTRDsignal(0),
-  fTRDLabel(0),
   fTRDQuality(0),
   fTRDBudget(0),
-  fTOFchi2(0),
-  fTOFindex(0),
-  fTOFCalChannel(-1),
-  fTOFsignal(-1),
+  fTOFsignal(0),
   fTOFsignalToT(0),
   fTOFsignalRaw(0),
   fTOFsignalDz(0),
-  fHMPIDchi2(1e10),
-  fHMPIDqn(-1),
-  fHMPIDcluIdx(-1),
-  fHMPIDsignal(-1),
-  fHMPIDtrkTheta(-1),
-  fHMPIDtrkPhi(-1),
-  fHMPIDtrkX(-1),
-  fHMPIDtrkY(-1),
-  fHMPIDmipX(-1),
-  fHMPIDmipY(-1),
-  fEMCALindex(kEMCALNoMatch),
-  fFriendTrack(new AliESDfriendTrack())
+  fHMPIDtrkX(0),
+  fHMPIDtrkY(0),
+  fHMPIDmipX(0),
+  fHMPIDmipY(0),
+  fTPCncls(0),
+  fTPCnclsF(0),
+  fTPCsignalN(0),
+  fITSncls(0),
+  fITSClusterMap(0),
+  fTRDncls(0),
+  fTRDncls0(0),
+  fTRDpidQuality(0)
 {
   //
   // The default ESD constructor 
@@ -120,82 +120,82 @@ AliESDtrack::AliESDtrack() :
   Int_t i, j;
   for (i=0; i<AliPID::kSPECIES; i++) {
     fTrackTime[i]=0.;
-    fR[i]=1.;
-    fITSr[i]=1.;
-    fTPCr[i]=1.;
-    fTRDr[i]=1.;
-    fTOFr[i]=1.;
-    fHMPIDr[i]=1.;
+    fR[i]=0.;
+    fITSr[i]=0.;
+    fTPCr[i]=0.;
+    fTRDr[i]=0.;
+    fTOFr[i]=0.;
+    fHMPIDr[i]=0.;
   }
   
   for (i=0; i<3; i++)   { fKinkIndexes[i]=0;}
-  for (i=0; i<3; i++)   { fV0Indexes[i]=-1;}
+  for (i=0; i<3; i++)   { fV0Indexes[i]=0;}
   for (i=0;i<kNPlane;i++) {
     for (j=0;j<kNSlice;j++) {
       fTRDsignals[i][j]=0.; 
     }
-    fTRDTimBin[i]=-1;
+    fTRDTimBin[i]=0;
   }
-  for (i=0;i<4;i++) {fTPCPoints[i]=-1;}
-  for (i=0;i<3;i++) {fTOFLabel[i]=-1;}
-  for (i=0;i<10;i++) {fTOFInfo[i]=-1;}
+  for (i=0;i<4;i++) {fTPCPoints[i]=0;}
+  for (i=0;i<3;i++) {fTOFLabel[i]=0;}
+  for (i=0;i<10;i++) {fTOFInfo[i]=0;}
 }
 
 //_______________________________________________________________________
 AliESDtrack::AliESDtrack(const AliESDtrack& track):
   AliExternalTrackParam(track),
+  fCp(0),
+  fIp(0),
+  fTPCInner(0),
+  fOp(0),
+  fFriendTrack(0),
+  fTPCClusterMap(track.fTPCClusterMap),
+  fTPCSharedMap(track.fTPCSharedMap),
   fFlags(track.fFlags),
-  fLabel(track.fLabel),
   fID(track.fID),
+  fLabel(track.fLabel),
+  fITSLabel(track.fITSLabel),
+  fTPCLabel(track.fTPCLabel),
+  fTRDLabel(track.fTRDLabel),
+  fTOFCalChannel(track.fTOFCalChannel),
+  fTOFindex(track.fTOFindex),
+  fHMPIDqn(track.fHMPIDqn),
+  fHMPIDcluIdx(track.fHMPIDcluIdx),
+  fEMCALindex(track.fEMCALindex),
+  fHMPIDtrkTheta(track.fHMPIDtrkTheta),
+  fHMPIDtrkPhi(track.fHMPIDtrkPhi),
+  fHMPIDsignal(track.fHMPIDsignal),
   fTrackLength(track.fTrackLength),
   fD(track.fD),fZ(track.fZ),
   fCdd(track.fCdd),fCdz(track.fCdz),fCzz(track.fCzz),
-  fStopVertex(track.fStopVertex),
-  fCp(0),
   fCchi2(track.fCchi2),
-  fIp(0),
-  fTPCInner(0),
-  fOp(0),
   fITSchi2(track.fITSchi2),
-  fITSncls(track.fITSncls),
-  fITSClusterMap(track.fITSClusterMap),
-  fITSsignal(track.fITSsignal),
-  fITSLabel(track.fITSLabel),
   fTPCchi2(track.fTPCchi2),
-  fTPCncls(track.fTPCncls),
-  fTPCnclsF(track.fTPCnclsF),
-  fTPCClusterMap(track.fTPCClusterMap),
-  fTPCSharedMap(track.fTPCSharedMap),
+  fTRDchi2(track.fTRDchi2),
+  fTOFchi2(track.fTOFchi2),
+  fHMPIDchi2(track.fHMPIDchi2),
+  fITSsignal(track.fITSsignal),
   fTPCsignal(track.fTPCsignal),
-  fTPCsignalN(track.fTPCsignalN),
   fTPCsignalS(track.fTPCsignalS),
-  fTPCLabel(track.fTPCLabel),
-  fTRDchi2(track.fTRDchi2),
-  fTRDncls(track.fTRDncls),
-  fTRDncls0(track.fTRDncls0),
   fTRDsignal(track.fTRDsignal),
-  fTRDLabel(track.fTRDLabel),
   fTRDQuality(track.fTRDQuality),
   fTRDBudget(track.fTRDBudget),
-  fTOFchi2(track.fTOFchi2),
-  fTOFindex(track.fTOFindex),
-  fTOFCalChannel(track.fTOFCalChannel),
   fTOFsignal(track.fTOFsignal),
   fTOFsignalToT(track.fTOFsignalToT),
   fTOFsignalRaw(track.fTOFsignalRaw),
   fTOFsignalDz(track.fTOFsignalDz),
-  fHMPIDchi2(track.fHMPIDchi2),
-  fHMPIDqn(track.fHMPIDqn),
-  fHMPIDcluIdx(track.fHMPIDcluIdx),
-  fHMPIDsignal(track.fHMPIDsignal),
-  fHMPIDtrkTheta(track.fHMPIDtrkTheta),
-  fHMPIDtrkPhi(track.fHMPIDtrkPhi),
   fHMPIDtrkX(track.fHMPIDtrkX),
   fHMPIDtrkY(track.fHMPIDtrkY),
   fHMPIDmipX(track.fHMPIDmipX),
   fHMPIDmipY(track.fHMPIDmipY),
-  fEMCALindex(track.fEMCALindex),
-  fFriendTrack(0)
+  fTPCncls(track.fTPCncls),
+  fTPCnclsF(track.fTPCnclsF),
+  fTPCsignalN(track.fTPCsignalN),
+  fITSncls(track.fITSncls),
+  fITSClusterMap(track.fITSClusterMap),
+  fTRDncls(track.fTRDncls),
+  fTRDncls0(track.fTRDncls0),
+  fTRDpidQuality(track.fTRDpidQuality)
 {
   //
   //copy constructor
@@ -233,58 +233,58 @@ AliESDtrack::AliESDtrack(const AliESDtrack& track):
 //_______________________________________________________________________
 AliESDtrack::AliESDtrack(TParticle * part) : 
   AliExternalTrackParam(),
+  fCp(0),
+  fIp(0),
+  fTPCInner(0),
+  fOp(0),
+  fFriendTrack(0),
+  fTPCClusterMap(159),//number of padrows
+  fTPCSharedMap(159),//number of padrows
   fFlags(0),
-  fLabel(0),
   fID(0),
+  fLabel(0),
+  fITSLabel(0),
+  fTPCLabel(0),
+  fTRDLabel(0),
+  fTOFCalChannel(0),
+  fTOFindex(0),
+  fHMPIDqn(0),
+  fHMPIDcluIdx(0),
+  fEMCALindex(kEMCALNoMatch),
+  fHMPIDtrkTheta(0),
+  fHMPIDtrkPhi(0),
+  fHMPIDsignal(0),
   fTrackLength(0),
   fD(0),fZ(0),
   fCdd(0),fCdz(0),fCzz(0),
-  fStopVertex(0),
-  fCp(0),
-  fCchi2(1e10),
-  fIp(0),
-  fTPCInner(0),
-  fOp(0),
+  fCchi2(0),
   fITSchi2(0),
-  fITSncls(0),
-  fITSClusterMap(0),
-  fITSsignal(0),
-  fITSLabel(0),
   fTPCchi2(0),
-  fTPCncls(0),
-  fTPCnclsF(0),
-  fTPCClusterMap(159),//number of padrows
-  fTPCSharedMap(159),//number of padrows
+  fTRDchi2(0),
+  fTOFchi2(0),
+  fHMPIDchi2(0),
+  fITSsignal(0),
   fTPCsignal(0),
-  fTPCsignalN(0),
   fTPCsignalS(0),
-  fTPCLabel(0),
-  fTRDchi2(0),
-  fTRDncls(0),
-  fTRDncls0(0),
   fTRDsignal(0),
-  fTRDLabel(0),
   fTRDQuality(0),
   fTRDBudget(0),
-  fTOFchi2(0),
-  fTOFindex(0),
-  fTOFCalChannel(-1),
-  fTOFsignal(-1),
+  fTOFsignal(0),
   fTOFsignalToT(0),
   fTOFsignalRaw(0),
   fTOFsignalDz(0),
-  fHMPIDchi2(1e10),
-  fHMPIDqn(-1),
-  fHMPIDcluIdx(-1),
-  fHMPIDsignal(-1),
-  fHMPIDtrkTheta(-1),
-  fHMPIDtrkPhi(-1),
-  fHMPIDtrkX(-1),
-  fHMPIDtrkY(-1),
-  fHMPIDmipX(-1),
-  fHMPIDmipY(-1),
-  fEMCALindex(kEMCALNoMatch),
-  fFriendTrack(0)
+  fHMPIDtrkX(0),
+  fHMPIDtrkY(0),
+  fHMPIDmipX(0),
+  fHMPIDmipY(0),
+  fTPCncls(0),
+  fTPCnclsF(0),
+  fTPCsignalN(0),
+  fITSncls(0),
+  fITSClusterMap(0),
+  fTRDncls(0),
+  fTRDncls0(0),
+  fTRDpidQuality(0)
 {
   //
   // ESD track from TParticle
@@ -308,11 +308,11 @@ AliESDtrack::AliESDtrack(TParticle * part) :
     for (j=0;j<kNSlice;j++) {
       fTRDsignals[i][j]=0.; 
     }
-    fTRDTimBin[i]=-1;
+    fTRDTimBin[i]=0;
   }
-  for (i=0;i<4;i++) {fTPCPoints[i]=-1;}
-  for (i=0;i<3;i++) {fTOFLabel[i]=-1;}
-  for (i=0;i<10;i++) {fTOFInfo[i]=-1;}
+  for (i=0;i<4;i++) {fTPCPoints[i]=0;}
+  for (i=0;i<3;i++) {fTOFLabel[i]=0;}
+  for (i=0;i<10;i++) {fTOFInfo[i]=0;}
 
   // Calculate the AliExternalTrackParam content
 
@@ -445,18 +445,19 @@ void AliESDtrack::MakeMiniESDtrack(){
   // Running track parameters in the base class (AliExternalTrackParam)
   
   fTrackLength = 0;
+
   for (Int_t i=0;i<AliPID::kSPECIES;i++) fTrackTime[i] = 0;
-  fStopVertex = 0;
 
   // Reset track parameters constrained to the primary vertex
-  fCp = 0;
+  delete fCp;fCp = 0;
   fCchi2 = 0;
 
   // Reset track parameters at the inner wall of TPC
-  fIp = 0;
-  fTPCInner=0;
+  delete fIp;fIp = 0;
+  delete fTPCInner;fTPCInner=0;
   // Reset track parameters at the inner wall of the TRD
-  fOp = 0;
+  delete fOp;fOp = 0;
+
 
   // Reset ITS track related information
   fITSchi2 = 0;
@@ -495,13 +496,14 @@ void AliESDtrack::MakeMiniESDtrack(){
   for (Int_t i=0;i<AliPID::kSPECIES;i++) fTRDr[i] = 0; 
   fTRDLabel = 0;       
   fTRDQuality  = 0;
+  fTRDpidQuality = 0;
   fTRDBudget  = 0;
 
   // Reset TOF related track information
   fTOFchi2 = 0;        
   fTOFindex = 0;       
   fTOFsignal = 0;      
-  fTOFCalChannel = -1;
+  fTOFCalChannel = 0;
   fTOFsignalToT = 0;
   fTOFsignalRaw = 0;
   fTOFsignalDz = 0;
@@ -511,16 +513,16 @@ void AliESDtrack::MakeMiniESDtrack(){
 
   // Reset HMPID related track information
   fHMPIDchi2 = 0;     
-  fHMPIDqn = -1;     
-  fHMPIDcluIdx = -1;     
+  fHMPIDqn = 0;     
+  fHMPIDcluIdx = 0;     
   fHMPIDsignal = 0;     
   for (Int_t i=0;i<AliPID::kSPECIES;i++) fHMPIDr[i] = 0;
-  fHMPIDtrkTheta = -1;     
-  fHMPIDtrkPhi = -1;      
-  fHMPIDtrkX = -1;     
-  fHMPIDtrkY = -1;      
-  fHMPIDmipX = -1;
-  fHMPIDmipY = -1;
+  fHMPIDtrkTheta = 0;     
+  fHMPIDtrkPhi = 0;      
+  fHMPIDtrkX = 0;     
+  fHMPIDtrkY = 0;      
+  fHMPIDmipX = 0;
+  fHMPIDmipY = 0;
   fEMCALindex = kEMCALNoMatch;
 
   delete fFriendTrack; fFriendTrack = 0;
@@ -878,7 +880,7 @@ void AliESDtrack::GetITSpid(Double_t *p) const {
 }
 
 //_______________________________________________________________________
-Int_t AliESDtrack::GetITSclusters(Int_t *idx) const {
+Char_t AliESDtrack::GetITSclusters(Int_t *idx) const {
   //---------------------------------------------------------------------
   // This function returns indices of the assgined ITS clusters 
   //---------------------------------------------------------------------
@@ -890,7 +892,7 @@ Int_t AliESDtrack::GetITSclusters(Int_t *idx) const {
 }
 
 //_______________________________________________________________________
-Int_t AliESDtrack::GetTPCclusters(Int_t *idx) const {
+UShort_t AliESDtrack::GetTPCclusters(Int_t *idx) const {
   //---------------------------------------------------------------------
   // This function returns indices of the assgined ITS clusters 
   //---------------------------------------------------------------------
@@ -901,7 +903,7 @@ Int_t AliESDtrack::GetTPCclusters(Int_t *idx) const {
   return fTPCncls;
 }
 
-Float_t AliESDtrack::GetTPCdensity(Int_t row0, Int_t row1) const{
+Double_t AliESDtrack::GetTPCdensity(Int_t row0, Int_t row1) const{
   //
   // GetDensity of the clusters on given region between row0 and row1
   // Dead zone effect takin into acoount
@@ -934,7 +936,7 @@ void AliESDtrack::GetTPCpid(Double_t *p) const {
 }
 
 //_______________________________________________________________________
-Int_t AliESDtrack::GetTRDclusters(Int_t *idx) const {
+UChar_t AliESDtrack::GetTRDclusters(Int_t *idx) const {
   //---------------------------------------------------------------------
   // This function returns indices of the assgined TRD clusters 
   //---------------------------------------------------------------------
@@ -965,7 +967,7 @@ void    AliESDtrack::SetTRDpid(Int_t iSpecies, Float_t p)
   fTRDr[iSpecies] = p;
 }
 
-Float_t AliESDtrack::GetTRDpid(Int_t iSpecies) const
+Double_t AliESDtrack::GetTRDpid(Int_t iSpecies) const
 {
   // Returns the probability of particle type iSpecies (in TRD)
   return fTRDr[iSpecies];
index f53ad55..1680268 100644 (file)
@@ -123,9 +123,9 @@ public:
  
   void    SetITSpid(const Double_t *p);
   void    GetITSpid(Double_t *p) const;
-  Float_t GetITSsignal() const {return fITSsignal;}
-  Float_t GetITSchi2() const {return fITSchi2;}
-  Int_t   GetITSclusters(Int_t *idx) const;
+  Double_t GetITSsignal() const {return fITSsignal;}
+  Double_t GetITSchi2() const {return fITSchi2;}
+  Char_t   GetITSclusters(Int_t *idx) const;
   UChar_t GetITSClusterMap() const {return fITSClusterMap;}
   Int_t   GetITSLabel() const {return fITSLabel;}
   void    SetITStrack(AliKalmanTrack * track){
@@ -141,9 +141,9 @@ public:
      for (Int_t i=0;i<4;i++) fTPCPoints[i]=points[i];
   }
   void    SetTPCPointsF(UChar_t  findable){fTPCnclsF = findable;}
-  Int_t   GetTPCNcls() const { return fTPCncls;}
-  Int_t   GetTPCNclsF() const { return fTPCnclsF;}
-  Float_t GetTPCPoints(Int_t i) const {return fTPCPoints[i];}
+  UShort_t   GetTPCNcls() const { return fTPCncls;}
+  UShort_t   GetTPCNclsF() const { return fTPCnclsF;}
+  Double_t GetTPCPoints(Int_t i) const {return fTPCPoints[i];}
   void    SetKinkIndexes(Int_t points[3]) {
      for (Int_t i=0;i<3;i++) fKinkIndexes[i] = points[i];
   }
@@ -153,12 +153,12 @@ public:
   void    SetTPCsignal(Float_t signal, Float_t sigma, UChar_t npoints){ 
      fTPCsignal = signal; fTPCsignalS = sigma; fTPCsignalN = npoints;
   }
-  Float_t GetTPCsignal() const {return fTPCsignal;}
-  Float_t GetTPCsignalSigma() const {return fTPCsignalS;}
+  Double_t GetTPCsignal() const {return fTPCsignal;}
+  Double_t GetTPCsignalSigma() const {return fTPCsignalS;}
   UShort_t GetTPCsignalN() const {return fTPCsignalN;}
-  Float_t GetTPCchi2() const {return fTPCchi2;}
-  Int_t   GetTPCclusters(Int_t *idx) const;
-  Float_t GetTPCdensity(Int_t row0, Int_t row1) const;
+  Double_t GetTPCchi2() const {return fTPCchi2;}
+  UShort_t   GetTPCclusters(Int_t *idx) const;
+  Double_t GetTPCdensity(Int_t row0, Int_t row1) const;
   Int_t   GetTPCLabel() const {return fTPCLabel;}
   Int_t   GetKinkIndex(Int_t i) const { return fKinkIndexes[i];}
   Int_t   GetV0Index(Int_t i) const { return fV0Indexes[i];}
@@ -174,23 +174,23 @@ public:
 // end A.Bercuci
        
        void    SetTRDQuality(Float_t quality){fTRDQuality=quality;}
-  Float_t GetTRDQuality()const {return fTRDQuality;}
+  Double_t GetTRDQuality()const {return fTRDQuality;}
   void    SetTRDBudget(Float_t budget){fTRDBudget=budget;}
-  Float_t GetTRDBudget()const {return fTRDBudget;}
+  Double_t GetTRDBudget()const {return fTRDBudget;}
   void    SetTRDsignals(Float_t dedx, Int_t i, Int_t j) {fTRDsignals[i][j]=dedx;}
   void    SetTRDTimBin(Int_t timbin, Int_t i) {fTRDTimBin[i]=timbin;}
   void    GetTRDpid(Double_t *p) const;
-  Float_t GetTRDsignal() const {return fTRDsignal;}
-  Float_t GetTRDsignals(Int_t iPlane, Int_t iSlice=-1) const { if (iSlice == -1) 
+  Double_t GetTRDsignal() const {return fTRDsignal;}
+  Double_t GetTRDsignals(Int_t iPlane, Int_t iSlice=-1) const { if (iSlice == -1) 
     return (fTRDsignals[iPlane][0] + fTRDsignals[iPlane][1] + fTRDsignals[iPlane][2])/3.0;
     return fTRDsignals[iPlane][iSlice];
   }
-  Int_t   GetTRDTimBin(Int_t i) const {return fTRDTimBin[i];}
-  Float_t GetTRDchi2() const {return fTRDchi2;}
-  Int_t   GetTRDclusters(Int_t *idx) const;
-  Int_t   GetTRDncls() const {return fTRDncls;}
+  Char_t   GetTRDTimBin(Int_t i) const {return fTRDTimBin[i];}
+  Double_t GetTRDchi2() const {return fTRDchi2;}
+  UChar_t   GetTRDclusters(Int_t *idx) const;
+ UChar_t   GetTRDncls() const {return fTRDncls;}
   void    SetTRDpid(Int_t iSpecies, Float_t p);
-  Float_t GetTRDpid(Int_t iSpecies) const;
+  Double_t GetTRDpid(Int_t iSpecies) const;
   Int_t   GetTRDLabel() const {return fTRDLabel;}
 
   void    SetTRDtrack(AliKalmanTrack * track){
@@ -201,14 +201,14 @@ public:
   }
 
   void    SetTOFsignal(Double_t tof) {fTOFsignal=tof;}
-  Float_t GetTOFsignal() const {return fTOFsignal;}
+  Double_t GetTOFsignal() const {return fTOFsignal;}
   void    SetTOFsignalToT(Double_t ToT) {fTOFsignalToT=ToT;}
-  Float_t GetTOFsignalToT() const {return fTOFsignalToT;}
+  Double_t GetTOFsignalToT() const {return fTOFsignalToT;}
   void    SetTOFsignalRaw(Double_t tof) {fTOFsignalRaw=tof;}
-  Float_t GetTOFsignalRaw() const {return fTOFsignalRaw;}
+  Double_t GetTOFsignalRaw() const {return fTOFsignalRaw;}
   void    SetTOFsignalDz(Double_t dz) {fTOFsignalDz=dz;}
-  Float_t GetTOFsignalDz() const {return fTOFsignalDz;}
-  Float_t GetTOFchi2() const {return fTOFchi2;}
+  Double_t GetTOFsignalDz() const {return fTOFsignalDz;}
+  Double_t GetTOFchi2() const {return fTOFchi2;}
   void    SetTOFpid(const Double_t *p);
   void    SetTOFLabel(const Int_t *p);
   void    GetTOFpid(Double_t *p) const;
@@ -222,11 +222,11 @@ public:
 
 // HMPID methodes +++++++++++++++++++++++++++++++++ (kir)
   void    SetHMPIDsignal(Double_t theta) {fHMPIDsignal=theta;}
-  Float_t GetHMPIDsignal() const {return fHMPIDsignal;}
+  Double_t GetHMPIDsignal() const {return fHMPIDsignal;}
   void    SetHMPIDpid(const Double_t *p);
   void    GetHMPIDpid(Double_t *p) const;  
   void    SetHMPIDchi2(Double_t chi2) {fHMPIDchi2=chi2;}
-  Float_t GetHMPIDchi2() const {return fHMPIDchi2;}
+  Double_t GetHMPIDchi2() const {return fHMPIDchi2;}
   void    SetHMPIDcluIdx(Int_t ch,Int_t idx) {fHMPIDcluIdx=ch*1000000+idx;}
   Int_t   GetHMPIDcluIdx() const {return fHMPIDcluIdx;}
   void    SetHMPIDtrk(Float_t  x, Float_t  y, Float_t  th, Float_t  ph) {
@@ -276,106 +276,104 @@ public:
   enum {
     kNPlane = 6,
     kNSlice = 3,
-    kEMCALNoMatch = -999999999
+    kEMCALNoMatch = -4096
   };
 protected:
   
+  AliExternalTrackParam *fCp; // Track parameters constrained to the primary vertex
+  AliExternalTrackParam *fIp; // Track parameters at the first measured point (TPC)
+  AliExternalTrackParam *fTPCInner; // Track parameters at the first measured point (TPC) - first itteration
+  AliExternalTrackParam *fOp; // Track parameters at the last measured point (TPC or TRD) 
+  AliESDfriendTrack *fFriendTrack; //! All the complementary information
 
-  ULong_t   fFlags;         // Reconstruction status flags 
-  Int_t     fLabel;         // Track label
-  Int_t     fID;            // Unique ID of the track
-  Float_t   fTrackLength;   // Track length
-  Float_t   fD;             // Impact parameter in XY plane
-  Float_t   fZ;             // Impact parameter in Z
-  Float_t   fCdd,fCdz,fCzz; // Covariance matrix of the impact parameters 
-  Float_t   fTrackTime[AliPID::kSPECIES]; // TOFs estimated by the tracking
-  Float_t   fR[AliPID::kSPECIES]; // combined "detector response probability"
+  TBits    fTPCClusterMap; // Map of clusters, one bit per padrow; 1 if has a cluster on given padrow
+  TBits    fTPCSharedMap;  // Map of clusters, one bit per padrow; 1 if has a shared cluster on given padrow
 
-  Int_t   fStopVertex;  // Index of the stop vertex
 
-  AliExternalTrackParam *fCp; // Track parameters constrained to the primary vertex
-  Double32_t fCchi2; // chi2 at the primary vertex
 
+  ULong_t   fFlags;          // Reconstruction status flags 
+  Int_t     fID;             // Unique ID of the track
+  Int_t     fLabel;          // Track label
+  Int_t     fITSLabel;       // label according TPC
+  Int_t     fTPCLabel;       // label according TPC
+  Int_t     fTRDLabel;       // label according TRD
+  Int_t     fTOFLabel[3];    // TOF label 
+  Int_t     fTOFCalChannel;  // Channel Index of the TOF Signal 
+  Int_t     fTOFindex;       // index of the assigned TOF cluster
+  Int_t     fHMPIDqn;         // 1000000*QDC + number of photon clusters
+  Int_t     fHMPIDcluIdx;     // 1000000*chamber id + cluster idx of the assigned MIP cluster
+  Int_t     fEMCALindex;     // index of associated EMCAL cluster (AliESDCaloCluster)
 
-  AliExternalTrackParam *fIp; // Track parameters at the first measured point (TPC)
-  AliExternalTrackParam *fTPCInner; // Track parameters at the first measured point (TPC) - first itteration
 
+  Int_t     fKinkIndexes[3]; // array of indexes of posible kink candidates 
+  Int_t     fV0Indexes[3];   // array of indexes of posible kink candidates 
 
-  AliExternalTrackParam *fOp; // Track parameters at the last measured point (TPC or TRD) 
+  Double32_t   fR[AliPID::kSPECIES]; //[0.,1.,8] combined "detector response probability"
+  Double32_t   fITSr[AliPID::kSPECIES]; //[0.,1.,8] "detector response probabilities" (for the PID)
+  Double32_t   fTPCr[AliPID::kSPECIES]; //[0.,1.,8] "detector response probabilities" (for the PID)
+  Double32_t   fTRDr[AliPID::kSPECIES]; //[0.,1.,8] "detector response probabilities" (for the PID)  
+  Double32_t   fTOFr[AliPID::kSPECIES]; //[0.,1.,8] "detector response probabilities" (for the PID)
+  Double32_t   fHMPIDr[AliPID::kSPECIES];//[0.,1.,8] "detector response probabilities" (for the PID)
+
+  Double32_t fHMPIDtrkTheta;//[-2*pi,2*pi,16] theta of the track extrapolated to the HMPID, LORS
+  // how much of this is needed?
+  Double32_t fHMPIDtrkPhi;     //[-2*pi,2*pi,16] phi of the track extrapolated to the HMPID, LORS
+  Double32_t fHMPIDsignal;  // HMPID PID signal (Theta ckov, rad)
+
+  Double32_t   fTrackTime[AliPID::kSPECIES]; // TOFs estimated by the tracking
+  Double32_t   fTrackLength;   // Track length
+  Double32_t   fD;             // Impact parameter in XY plane
+  Double32_t   fZ;             // Impact parameter in Z
+  Double32_t   fCdd,fCdz,fCzz; // Covariance matrix of the impact parameters 
+
+  Double32_t   fCchi2; // chi2 at the primary vertex
+  Double32_t   fITSchi2;        // chi2 in the ITS
+  Double32_t   fTPCchi2;        // chi2 in the TPC
+  Double32_t   fTRDchi2;        // chi2 in the TRD
+  Double32_t   fTOFchi2;        // chi2 in the TOF
+  Double32_t fHMPIDchi2;       // chi2 in the HMPID
 
-  // ITS related track information
-  Float_t fITSchi2;        // chi2 in the ITS
-  Int_t   fITSncls;        // number of clusters assigned in the ITS
-  UChar_t fITSClusterMap;  // map of clusters, one bit per a layer 
-  Float_t fITSsignal;      // detector's PID signal
-  Float_t fITSr[AliPID::kSPECIES]; // "detector response probabilities" (for the PID)
-  Int_t   fITSLabel;       // label according TPC
 
-  // TPC related track information
-  Float_t  fTPCchi2;       // chi2 in the TPC
-  Int_t    fTPCncls;       // number of clusters assigned in the TPC
+  Double32_t  fITSsignal;      // detector's PID signal
+  Double32_t  fTPCsignal;     // detector's PID signal
+  Double32_t  fTPCsignalS;    // RMS of dEdx measurement
+  Double32_t  fTPCPoints[4];  // TPC points -first, max. dens, last and max density
+
+  Double32_t fTRDsignal;      // detector's PID signal
+  Double32_t fTRDsignals[kNPlane][kNSlice];  // TRD signals from all six planes in 3 slices each
+  Double32_t fTRDQuality;     // trd quality factor for TOF
+  Double32_t fTRDBudget;      // trd material budget
+
+  Double32_t fTOFsignal;      // detector's PID signal
+  Double32_t fTOFsignalToT;   // detector's ToT signal
+  Double32_t fTOFsignalRaw;   // detector's uncorrected time signal
+  Double32_t fTOFsignalDz;    // local z  of track's impact on the TOF pad 
+  Double32_t fTOFInfo[10];    //! TOF informations
+
+  Double32_t fHMPIDtrkX;       // x of the track impact, LORS 
+  Double32_t fHMPIDtrkY;       // y of the track impact, LORS 
+  Double32_t fHMPIDmipX;       // x of the MIP in LORS
+  Double32_t fHMPIDmipY;       // y of the MIP in LORS
+
+
+
+
+  UShort_t fTPCncls;       // number of clusters assigned in the TPC
   UShort_t fTPCnclsF;      // number of findable clusters in the TPC
-  TBits    fTPCClusterMap; // Map of clusters, one bit per padrow; 1 if has a cluster on given padrow
-  TBits    fTPCSharedMap;  // Map of clusters, one bit per padrow; 1 if has a shared cluster on given padrow
-  Float_t  fTPCsignal;     // detector's PID signal
   UShort_t fTPCsignalN;    // number of points used for dEdx
-  Float_t  fTPCsignalS;    // RMS of dEdx measurement
-  Float_t  fTPCr[AliPID::kSPECIES]; // "detector response probabilities" (for the PID)
-  Int_t    fTPCLabel;      // label according TPC
-  Float_t  fTPCPoints[4];  // TPC points -first, max. dens, last and max density
-  Int_t    fKinkIndexes[3];// array of indexes of posible kink candidates 
-  Int_t    fV0Indexes[3];  // array of indexes of posible kink candidates 
-
-  // TRD related track information
-  Float_t fTRDchi2;        // chi2 in the TRD
+
+  Char_t  fITSncls;        // number of clusters assigned in the ITS
+  UChar_t fITSClusterMap;  // map of clusters, one bit per a layer 
   UChar_t fTRDncls;        // number of clusters assigned in the TRD
   UChar_t fTRDncls0;       // number of clusters assigned in the TRD before first material cross
-  Float_t fTRDsignal;      // detector's PID signal
-  Float_t fTRDsignals[kNPlane][kNSlice];  // TRD signals from all six planes in 3 slices each
-  Int_t   fTRDTimBin[kNPlane];   // Time bin of Max cluster from all six planes
-  Float_t fTRDr[AliPID::kSPECIES]; // "detector response probabilities" (for the PID)
-       // A.Bercuci
-       UChar_t fTRDpidQuality;   // TRD PID quality according to number of planes. 6 is the best
-  Int_t   fTRDLabel;       // label according TRD
-  Float_t fTRDQuality;     // trd quality factor for TOF
-  Float_t fTRDBudget;      // trd material budget
-
-
-  // TOF related track information
-  Float_t fTOFchi2;        // chi2 in the TOF
-  Int_t   fTOFindex;       // index of the assigned TOF cluster
-  Int_t   fTOFCalChannel;  // Channel Index of the TOF Signal 
-  Float_t fTOFsignal;      // detector's PID signal
-  Float_t fTOFsignalToT;   // detector's ToT signal
-  Float_t fTOFsignalRaw;   // detector's uncorrected time signal
-  Float_t fTOFsignalDz;    // local z  of track's impact on the TOF pad 
-  Float_t fTOFr[AliPID::kSPECIES]; // "detector response probabilities" (for the PID)
-  Int_t   fTOFLabel[3];    // TOF label 
-  Float_t fTOFInfo[10];    //! TOF informations
-
-  // HMPID related track information                 (kir)
-  Float_t fHMPIDchi2;       // chi2 in the HMPID
-  Int_t   fHMPIDqn;         // 1000000*QDC + number of photon clusters
-  Int_t   fHMPIDcluIdx;     // 1000000*chamber id + cluster idx of the assigned MIP cluster
-  Float_t fHMPIDsignal;     // HMPID PID signal (Theta ckov, rad)
-  Float_t fHMPIDr[AliPID::kSPECIES];// "detector response probabilities" (for the PID)
-  Float_t fHMPIDtrkTheta;   // theta of the track extrapolated to the HMPID, LORS
-  Float_t fHMPIDtrkPhi;     // phi of the track extrapolated to the HMPID, LORS
-  Float_t fHMPIDtrkX;       // x of the track impact, LORS 
-  Float_t fHMPIDtrkY;       // y of the track impact, LORS 
-  Float_t fHMPIDmipX;       // x of the MIP in LORS
-  Float_t fHMPIDmipY;       // y of the MIP in LORS
-  
-  // EMCAL related track information
-  Int_t fEMCALindex;   // index of associated EMCAL cluster (AliESDCaloCluster)
-
-  AliESDfriendTrack *fFriendTrack; //! All the complementary information
+  UChar_t fTRDpidQuality;   // TRD PID quality according to number of planes. 6 is the best
+  Char_t  fTRDTimBin[kNPlane];   // Time bin of Max cluster from all six planes
 
  private:
 
   AliESDtrack & operator=(const AliESDtrack & ) {return *this;}
 
-  ClassDef(AliESDtrack,39)  //ESDtrack 
+  ClassDef(AliESDtrack,40)  //ESDtrack 
 };
 
 #endif 
index b24d51c..eba32ce 100644 (file)
 
 ClassImp(AliESDv0)
 
-AliESDV0Params  AliESDv0::fgkParams;
+const AliESDV0Params  AliESDv0::fgkParams;
 
 AliESDv0::AliESDv0() :
   TObject(),
-  fOnFlyStatus(kFALSE),
-  fPdgCode(kK0Short),
-  fEffMass(TDatabasePDG::Instance()->GetParticle(kK0Short)->Mass()),
-  fDcaV0Daughters(0),
-  fPointAngle(0),
-  fChi2V0(31.),
-  fNidx(-1),
   fParamN(),
-  fPidx(-1),
   fParamP(),
-  fRr(-1),
-  fStatus(0),
+  fEffMass(TDatabasePDG::Instance()->GetParticle(kK0Short)->Mass()),
+  fDcaV0Daughters(0),
+  fChi2V0(0.),
+  fRr(0),
   fDistSigma(0),
   fChi2Before(0),
-  fNBefore(0),
   fChi2After(0),
-  fNAfter(0),
   fPointAngleFi(0),
-  fPointAngleTh(0)
+  fPointAngleTh(0),
+  fPointAngle(0),
+  fPdgCode(kK0Short),
+  fNidx(0),
+  fPidx(0),
+  fStatus(0),
+  fNBefore(0),
+  fNAfter(0),
+  fOnFlyStatus(kFALSE)
 {
   //--------------------------------------------------------------------
   // Default constructor  (K0s)
@@ -83,25 +83,25 @@ AliESDv0::AliESDv0() :
 
 AliESDv0::AliESDv0(const AliESDv0& v0) :
   TObject(v0),
-  fOnFlyStatus(v0.fOnFlyStatus),
-  fPdgCode(v0.fPdgCode),
+  fParamN(v0.fParamN),
+  fParamP(v0.fParamP),
   fEffMass(v0.fEffMass),
   fDcaV0Daughters(v0.fDcaV0Daughters),
-  fPointAngle(v0.fPointAngle),
   fChi2V0(v0.fChi2V0),
-  fNidx(v0.fNidx),
-  fParamN(v0.fParamN),
-  fPidx(v0.fPidx),
-  fParamP(v0.fParamP),
   fRr(v0.fRr),
-  fStatus(v0.fStatus),
   fDistSigma(v0.fDistSigma),
   fChi2Before(v0.fChi2Before),
-  fNBefore(v0.fNBefore),
   fChi2After(v0.fChi2After),
-  fNAfter(v0.fNAfter),
   fPointAngleFi(v0.fPointAngleFi),
-  fPointAngleTh(v0.fPointAngleTh)
+  fPointAngleTh(v0.fPointAngleTh),
+  fPointAngle(v0.fPointAngle),
+  fPdgCode(v0.fPdgCode),
+  fNidx(v0.fNidx),
+  fPidx(v0.fPidx),
+  fStatus(v0.fStatus),
+  fNBefore(v0.fNBefore),
+  fNAfter(v0.fNAfter),
+  fOnFlyStatus(v0.fOnFlyStatus)
 {
   //--------------------------------------------------------------------
   // The copy constructor
@@ -132,25 +132,25 @@ AliESDv0::AliESDv0(const AliESDv0& v0) :
 AliESDv0::AliESDv0(const AliExternalTrackParam &t1, Int_t i1,
                    const AliExternalTrackParam &t2, Int_t i2) :
   TObject(),
-  fOnFlyStatus(kFALSE),
-  fPdgCode(kK0Short),
+  fParamN(t1),
+  fParamP(t2),
   fEffMass(TDatabasePDG::Instance()->GetParticle(kK0Short)->Mass()),
   fDcaV0Daughters(0),
+  fChi2V0(0.),
+  fRr(0),
+  fDistSigma(0),
+  fChi2Before(0),
+  fChi2After(0),
+  fPointAngleFi(0),
+  fPointAngleTh(0),
   fPointAngle(0),
-  fChi2V0(31.),
+  fPdgCode(kK0Short),
   fNidx(i1),
-  fParamN(t1),
   fPidx(i2),
-  fParamP(t2),
-  fRr(-1),
   fStatus(0),
-  fDistSigma(0),
-  fChi2Before(0),
   fNBefore(0),
-  fChi2After(0),
   fNAfter(0),
-  fPointAngleFi(0),
-  fPointAngleTh(0)
+  fOnFlyStatus(kFALSE)
 {
   //--------------------------------------------------------------------
   // Main constructor  (K0s)
index f06e533..8da2738 100644 (file)
@@ -32,8 +32,8 @@ public:
 
   Int_t    GetPdgCode() const {return fPdgCode;}
   Float_t  GetEffMass(UInt_t p1, UInt_t p2);
-  Float_t  GetEffMass() const {return fEffMass;}
-  Float_t  GetChi2V0()  const {return fChi2V0;}
+  Double_t  GetEffMass() const {return fEffMass;}
+  Double_t  GetChi2V0()  const {return fChi2V0;}
   void     GetPxPyPz(Double_t &px, Double_t &py, Double_t &pz) const;
   void     GetNPxPyPz(Double_t &px, Double_t &py, Double_t &pz) const;
   void     GetPPxPyPz(Double_t &px, Double_t &py, Double_t &pz) const;
@@ -42,9 +42,9 @@ public:
   Int_t    GetNindex() const {return fNidx;}
   Int_t    GetPindex() const {return fPidx;}
   void     SetDcaV0Daughters(Double_t rDcaV0Daughters=0.);
-  Float_t  GetDcaV0Daughters() {return fDcaV0Daughters;}
+  Double_t  GetDcaV0Daughters() {return fDcaV0Daughters;}
   Float_t  GetV0CosineOfPointingAngle(Double_t&, Double_t&, Double_t&) const;
-  Float_t  GetV0CosineOfPointingAngle() const {return fPointAngle;}
+  Double_t  GetV0CosineOfPointingAngle() const {return fPointAngle;}
   void     SetV0CosineOfPointingAngle(Double_t cpa) {fPointAngle=cpa;}
   void     SetOnFlyStatus(Bool_t status){fOnFlyStatus=status;}
   Bool_t   GetOnFlyStatus() const {return fOnFlyStatus;}
@@ -85,62 +85,65 @@ public:
   Float_t GetChi2After() const {return fChi2After;}
   void SetChi2After(Float_t ca) {fChi2After=ca;}
   Float_t GetNAfter() const {return fNAfter;}
-  void SetNAfter(Float_t na) {fNAfter=na;}
-  Float_t GetNBefore() const {return fNBefore;}
-  void SetNBefore(Float_t nb) {fNBefore=nb;}  
+  void SetNAfter(Short_t na) {fNAfter=na;}
+  Short_t GetNBefore() const {return fNBefore;}
+  void SetNBefore(Short_t nb) {fNBefore=nb;}  
   void SetCausality(Float_t pb0, Float_t pb1, Float_t pa0, Float_t pa1);
-  const Float_t * GetCausalityP() const {return fCausality;}
+  const Double_t * GetCausalityP() const {return fCausality;}
   void SetClusters(Int_t *clp, Int_t *clm);
   const Int_t * GetClusters(Int_t i) const {return fClusters[i];}
   void SetNormDCAPrim(Float_t nd0, Float_t nd1){fNormDCAPrim[0] = nd0; fNormDCAPrim[1]=nd1;}
-  const Float_t  *GetNormDCAPrimP() const {return fNormDCAPrim;}
+  const Double_t  *GetNormDCAPrimP() const {return fNormDCAPrim;}
 
 protected:
-  Bool_t   fOnFlyStatus;    // if kTRUE, then this V0 is recontructed
-                            // "on fly" during the tracking
+  AliExternalTrackParam fParamN;  // external parameters of negative particle
+  AliExternalTrackParam fParamP;  // external parameters of positive particle
+
+  // CKBrev: tkink about revision
 
-  Int_t    fPdgCode;          // reconstructed V0's type (PDG code)
-  Float_t  fEffMass;          // reconstructed V0's effective mass
-  Float_t  fDcaV0Daughters;   // dca between V0's daughters
-  Float_t  fPointAngle;       //cosine of the pointing angle
-  Float_t  fChi2V0;           // V0's chi2 value
+  Double32_t   fEffMass;          // reconstructed V0's effective mass
+  Double32_t   fDcaV0Daughters;   // dca between V0's daughters
+  Double32_t   fChi2V0;           // V0's chi2 value
+  Double32_t   fPos[3];         // V0's position (global)
+  Double32_t   fPosCov[6];      // covariance matrix of the vertex position
+  Double32_t   fNmom[3];        // momentum of the negative daughter (global)
+  Double32_t   fPmom[3];        // momentum of the positive daughter (global)
+  Double32_t   fNormDCAPrim[2];  // normalize distance to the priary vertex CKBrev
+  Double32_t   fRr;         //rec position of the vertex CKBrev
+  Double32_t   fDistSigma; //sigma of distance CKBrev
+  Double32_t        fChi2Before;   //chi2 of the tracks before V0 CKBrev
+  Double32_t        fChi2After;   // chi2 of the tracks after V0 CKBrev
 
-  Double32_t fPos[3];         // V0's position (global)
-  Double32_t fPosCov[6];      // covariance matrix of the vertex position
 
+  Double32_t        fCausality[4]; //[0,1,8] causality information - see comments in SetCausality CKBrev
+  Double32_t        fAngle[3];   //[-2*pi,2*pi,16]three angles CKBrev
+  Double32_t        fPointAngleFi; //[-1,1,16]point angle fi CKBrev
+  Double32_t        fPointAngleTh; //[-1,1,16]point angle theta CKBrev
+  Double32_t        fPointAngle;   //[-1,1,16] cosine of the pointing angle
+
+
+  Int_t fPdgCode;             // reconstructed V0's type (PDG code)
+  Int_t fClusters[2][6];      //! its clusters CKBrev  
   Int_t fNidx;                // index of the negative daughter
-  Double32_t fNmom[3];        // momentum of the negative daughter (global)
-  AliExternalTrackParam fParamN;  // external parameters of negative particle
   Int_t fPidx;                // index of the positive daughter
-  Double32_t fPmom[3];        // momentum of the positive daughter (global)
-  AliExternalTrackParam fParamP;  // external parameters of positive particle
 
 
-  // **** The following data members need to be revised ***
 
-  Int_t          fClusters[2][6]; //! its clusters 
-  //
-  Float_t        fNormDCAPrim[2];  // normalize distance to the priary vertex
-  //
-  Double32_t     fAngle[3];   //three angles
-  Float_t        fRr;         //rec position of the vertex 
-  Int_t          fStatus;       //status
-  Float_t        fDistSigma; //sigma of distance
-  Float_t        fCausality[4];  // causality information - see comments in SetCausality
-  Float_t        fChi2Before;   //chi2 of the tracks before V0
-  Float_t        fNBefore;      // number of possible points before V0
-  Float_t        fChi2After;   // chi2 of the tracks after V0
-  Float_t        fNAfter;      // number of possible points after V0
-  Float_t        fPointAngleFi; //point angle fi
-  Float_t        fPointAngleTh; //point angle theta
+  Short_t    fStatus;     //status CKBrev
+  Short_t    fNBefore;      // number of possible points before V0 CKBrev
+  Short_t    fNAfter;      // number of possible points after V0 CKBrev
+
+  Bool_t     fOnFlyStatus;    // if kTRUE, then this V0 is recontructed
+                            // "on fly" during the tracking
+
   //
   // parameterization coefficients
-  static AliESDV0Params fgkParams;  // resolution and likelihood parameterization  
+  static const AliESDV0Params fgkParams;  //! resolution and likelihood parameterization  
 
 private:
   AliESDv0& operator=(const AliESDv0&);
 
-  ClassDef(AliESDv0,3)      // ESD V0 vertex
+  ClassDef(AliESDv0,4)      // ESD V0 vertex
 };
 
 inline 
index c6548e6..3912a2f 100644 (file)
@@ -28,11 +28,11 @@ ClassImp(AliKalmanTrack)
 
 //_______________________________________________________________________
   AliKalmanTrack::AliKalmanTrack():AliExternalTrackParam(),
-  fLab(-3141593),
   fFakeRatio(0),
   fChi2(0),
   fMass(AliPID::ParticleMass(AliPID::kPion)),
   fN(0),
+  fLab(-3141593),
   fStartTimeIntegral(kFALSE),
   fIntegratedLength(0)
 {
@@ -45,11 +45,11 @@ ClassImp(AliKalmanTrack)
 
 AliKalmanTrack::AliKalmanTrack(const AliKalmanTrack &t):
   AliExternalTrackParam(t),
-  fLab(t.fLab),
   fFakeRatio(t.fFakeRatio),
   fChi2(t.fChi2),
   fMass(t.fMass),
   fN(t.fN),
+  fLab(t.fLab),
   fStartTimeIntegral(t.fStartTimeIntegral),
   fIntegratedLength(t.fIntegratedLength)
 {
index db57443..8a1b423 100644 (file)
@@ -74,19 +74,19 @@ public:
 protected:
   void SetChi2(Double_t chi2) {fChi2=chi2;} 
 
+  Double32_t fFakeRatio;  // fake ratio
+  Double32_t fChi2;       // total chi2 value for this track
+  Double32_t fMass;       // mass hypothesis
   Int_t fLab;             // track label
-  Float_t fFakeRatio;     // fake ratio
-  Double_t fChi2;         // total chi2 value for this track
-  Double_t fMass;         // mass hypothesis
   Int_t fN;               // number of associated clusters
 
 private:
-  // variables for time integration (S.Radomski@gsi.de)
   Bool_t  fStartTimeIntegral;       // indicator wether integrate time
-  Double_t fIntegratedTime[AliPID::kSPECIES];       // integrated time
-  Double_t fIntegratedLength;        // integrated length
+  // variables for time integration (S.Radomski@gsi.de)
+  Double32_t fIntegratedTime[AliPID::kSPECIES];       // integrated time
+  Double32_t fIntegratedLength;        // integrated length
   
-  ClassDef(AliKalmanTrack,6)    // Reconstructed track
+  ClassDef(AliKalmanTrack,7)    // Reconstructed track
 };
 
 #endif
index 1668793..3c0a0aa 100644 (file)
@@ -878,10 +878,12 @@ Bool_t AliReconstruction::Run(const char* input)
                continue;
     AliQualAssDataMaker * qadm = GetQualAssDataMaker(iDet);
     if (!qadm) continue;
+    
     qadm->EndOfCycle(AliQualAss::kRECPOINTS);
     qadm->EndOfCycle(AliQualAss::kESDS);
     qadm->Finish(AliQualAss::kRECPOINTS);
     qadm->Finish(AliQualAss::kESDS) ; 
+    
   }
 
   tree->GetUserInfo()->Add(esd);
@@ -899,7 +901,8 @@ Bool_t AliReconstruction::Run(const char* input)
   file->cd();
   if (fWriteESDfriend)
     tree->SetBranchStatus("ESDfriend*",0);
-  tree->Write();
+  // we want to have only one tree version number
+  tree->Write(tree->GetName(),TObject::kOverwrite);
   hlttree->Write();
 
   if (fWriteAOD) {
@@ -1039,11 +1042,12 @@ Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors)
       AliCodeTimerStart(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
       AliInfo(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
          
-    if (qadm->IsCycleDone() ) {
-      qadm->EndOfCycle(AliQualAss::kRECPOINTS) ; 
-         qadm->EndOfCycle(AliQualAss::kESDS) ; 
+      if (qadm->IsCycleDone() ) {
+       
+       qadm->EndOfCycle(AliQualAss::kRECPOINTS) ; 
+       qadm->EndOfCycle(AliQualAss::kESDS) ; 
       qadm->StartOfCycle(AliQualAss::kRECPOINTS) ; 
-         qadm->StartOfCycle(AliQualAss::kESDS, "same") ; 
+      qadm->StartOfCycle(AliQualAss::kESDS, "same") ; 
    }
       qadm->Exec(AliQualAss::kRECPOINTS, clustersTree) ; 
       AliCodeTimerStop(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
@@ -2506,15 +2510,15 @@ void AliReconstruction::ESDFile2AODFile(TFile* esdFile, TFile* aodFile)
       AliAODTrack *primTrack = NULL;
       Char_t ttype=AliAODCluster::kUndef;
 
-      if (cluster->IsPHOS()) ttype=AliAODCluster::kPHOSNeutral;
-      else if (cluster->IsEMCAL()) {
-
-       if (cluster->GetClusterType() == AliESDCaloCluster::kPseudoCluster)
-         ttype = AliAODCluster::kEMCALPseudoCluster;
-       else
-         ttype = AliAODCluster::kEMCALClusterv1;
-
+      if (cluster->GetClusterType() == AliESDCaloCluster::kPHOSCluster){
+       ttype = AliAODCluster::kPHOSNeutral;
       }
+      else if (cluster->GetClusterType() == AliESDCaloCluster::kEMCALClusterv1){
+       ttype = AliAODCluster::kEMCALClusterv1;
+      }      
+      else if (cluster->GetClusterType() == AliESDCaloCluster::kEMCALPseudoCluster){
+       ttype = AliAODCluster::kEMCALPseudoCluster;
+      }    
 
       new(clusters[jClusters++]) AliAODCluster(id,
                                               label,
@@ -2729,7 +2733,7 @@ AliQualAssDataMaker * AliReconstruction::GetQualAssDataMaker(Int_t iDet)
     qadm->Init(AliQualAss::kRECPOINTS, fRunLoader->GetHeader()->GetRun(), GetQACycles(fgkDetectorName[iDet]));
     qadm->Init(AliQualAss::kESDS, fRunLoader->GetHeader()->GetRun(), GetQACycles(fgkDetectorName[iDet]));
     qadm->StartOfCycle(AliQualAss::kRECPOINTS);
-    qadm->StartOfCycle(AliQualAss::kESDS, "same") ;    
+        qadm->StartOfCycle(AliQualAss::kESDS, "same") ;        
     fQualAssDataMaker[iDet] = qadm;
   }
 
@@ -2752,8 +2756,8 @@ Bool_t AliReconstruction::RunQualAss(const char* detectors, AliESDEvent *& esd)
    AliCodeTimerStart(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
    AliInfo(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
     
-   qadm->Exec(AliQualAss::kESDS, esd) ; 
-   qadm->Increment() ; 
+      qadm->Exec(AliQualAss::kESDS, esd) ; 
+      qadm->Increment() ; 
 
    AliCodeTimerStop(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
  }
index c70c873..f7e5b84 100644 (file)
@@ -54,14 +54,14 @@ class AliVertex : public TNamed {
 
  protected:
 
-  Double_t fPosition[3];    // vertex position
-  Double_t fSigma;          // track dispersion around found vertex
+  Double32_t fPosition[3];    // vertex position
+  Double32_t fSigma;          // track dispersion around found vertex
   Int_t    fNContributors;  // # of tracklets/tracks used for the estimate 
   Int_t    fNIndices;       // # of indices 
   UShort_t *fIndices;       //[fNIndices] indices of tracks used for vertex
 
 
-  ClassDef(AliVertex,2)  // Class for Primary Vertex
+  ClassDef(AliVertex,3)  // Class for Primary Vertex
 };
 
 #endif