Partial fix for bug #59809: putting HLT trigger decision in the ESD, not yet in stand...

[u/mrichter/AliRoot.git] / STEER / AliTrackPointArray.cxx

diff --git a/STEER/AliTrackPointArray.cxx b/STEER/AliTrackPointArray.cxx
index 8f877ed1ad1e16ecfb2f240dac1e9f222608b094..5572817e12d02680e32ebdc183bf97f2f634b6cf 100644 (file)
--- a/STEER/AliTrackPointArray.cxx
+++ b/STEER/AliTrackPointArray.cxx
@@ -25,6 +25,8 @@
 #include <TMath.h>
 #include <TMatrixD.h>
 #include <TMatrixDSym.h>
+#include <TGeoMatrix.h>
+#include <TMatrixDSymEigen.h>
 
 #include "AliTrackPointArray.h"
 
@@ -38,6 +40,11 @@ AliTrackPointArray::AliTrackPointArray() :
   fX(0),
   fY(0),
   fZ(0),
+  fCharge(0),
+  fDriftTime(0),
+  fChargeRatio(0),
+  fClusterType(0),
+  fIsExtra(0),
   fSize(0),
   fCov(0),
   fVolumeID(0)
@@ -52,12 +59,30 @@ AliTrackPointArray::AliTrackPointArray(Int_t npoints):
   fX(new Float_t[npoints]),
   fY(new Float_t[npoints]),
   fZ(new Float_t[npoints]),
+  fCharge(new Float_t[npoints]),
+  fDriftTime(new Float_t[npoints]),
+  fChargeRatio(new Float_t[npoints]),
+  fClusterType(new Int_t[npoints]),
+  fIsExtra(new Bool_t[npoints]),
   fSize(6*npoints),
   fCov(new Float_t[fSize]),
   fVolumeID(new UShort_t[npoints])
 {
   // Constructor
   //
+  for (Int_t ip=0; ip<npoints;ip++){
+    fX[ip]=0;
+    fY[ip]=0;
+    fZ[ip]=0;
+    fCharge[ip]=0;
+    fDriftTime[ip]=0;
+    fChargeRatio[ip]=0;
+    fClusterType[ip]=0;
+    fIsExtra[ip]=kFALSE;
+    fVolumeID[ip]=0;
+    for (Int_t icov=0;icov<6; icov++)
+      fCov[6*ip+icov]=0;
+  }
 }
 
 //______________________________________________________________________________
@@ -68,6 +93,11 @@ AliTrackPointArray::AliTrackPointArray(const AliTrackPointArray &array):
   fX(new Float_t[fNPoints]),
   fY(new Float_t[fNPoints]),
   fZ(new Float_t[fNPoints]),
+  fCharge(new Float_t[fNPoints]),
+  fDriftTime(new Float_t[fNPoints]),
+  fChargeRatio(new Float_t[fNPoints]),
+  fClusterType(new Int_t[fNPoints]),
+  fIsExtra(new Bool_t[fNPoints]),
   fSize(array.fSize),
   fCov(new Float_t[fSize]),
   fVolumeID(new UShort_t[fNPoints])
@@ -77,6 +107,31 @@ AliTrackPointArray::AliTrackPointArray(const AliTrackPointArray &array):
   memcpy(fX,array.fX,fNPoints*sizeof(Float_t));
   memcpy(fY,array.fY,fNPoints*sizeof(Float_t));
   memcpy(fZ,array.fZ,fNPoints*sizeof(Float_t));
+  if (array.fCharge) {
+    memcpy(fCharge,array.fCharge,fNPoints*sizeof(Float_t));
+  } else {
+    memset(fCharge, 0, fNPoints*sizeof(Float_t));
+  }
+  if (array.fDriftTime) {
+    memcpy(fDriftTime,array.fDriftTime,fNPoints*sizeof(Float_t));
+  } else {
+    memset(fDriftTime, 0, fNPoints*sizeof(Float_t));
+  }
+  if (array.fChargeRatio) {
+    memcpy(fChargeRatio,array.fChargeRatio,fNPoints*sizeof(Float_t));
+  } else {
+    memset(fChargeRatio, 0, fNPoints*sizeof(Float_t));
+  }
+  if (array.fClusterType) {
+    memcpy(fClusterType,array.fClusterType,fNPoints*sizeof(Int_t));
+  } else {
+    memset(fClusterType, 0, fNPoints*sizeof(Int_t));
+  }
+  if (array.fIsExtra) {
+    memcpy(fIsExtra,array.fIsExtra,fNPoints*sizeof(Bool_t));
+  } else {
+    memset(fIsExtra, 0, fNPoints*sizeof(Bool_t));
+  }
   memcpy(fVolumeID,array.fVolumeID,fNPoints*sizeof(UShort_t));
   memcpy(fCov,array.fCov,fSize*sizeof(Float_t));
 }
@@ -98,6 +153,16 @@ AliTrackPointArray &AliTrackPointArray::operator =(const AliTrackPointArray& arr
   fY = new Float_t[fNPoints];
   delete [] fZ;
   fZ = new Float_t[fNPoints];
+  delete [] fCharge;
+  fCharge = new Float_t[fNPoints];
+  delete [] fDriftTime;
+  fDriftTime = new Float_t[fNPoints];
+  delete [] fChargeRatio;
+  fChargeRatio = new Float_t[fNPoints];
+  delete [] fClusterType;
+  fClusterType = new Int_t[fNPoints];
+  delete [] fIsExtra;
+  fIsExtra = new Bool_t[fNPoints];
   delete [] fVolumeID;
   fVolumeID = new UShort_t[fNPoints];
   delete [] fCov;
@@ -105,6 +170,11 @@ AliTrackPointArray &AliTrackPointArray::operator =(const AliTrackPointArray& arr
   memcpy(fX,array.fX,fNPoints*sizeof(Float_t));
   memcpy(fY,array.fY,fNPoints*sizeof(Float_t));
   memcpy(fZ,array.fZ,fNPoints*sizeof(Float_t));
+  memcpy(fCharge,array.fCharge,fNPoints*sizeof(Float_t));
+  memcpy(fDriftTime,array.fDriftTime,fNPoints*sizeof(Float_t));
+  memcpy(fChargeRatio,array.fChargeRatio,fNPoints*sizeof(Float_t));
+  memcpy(fClusterType,array.fClusterType,fNPoints*sizeof(Int_t));
+  memcpy(fIsExtra,array.fIsExtra,fNPoints*sizeof(Bool_t));
   memcpy(fVolumeID,array.fVolumeID,fNPoints*sizeof(UShort_t));
   memcpy(fCov,array.fCov,fSize*sizeof(Float_t));
 
@@ -119,6 +189,11 @@ AliTrackPointArray::~AliTrackPointArray()
   delete [] fX;
   delete [] fY;
   delete [] fZ;
+  delete [] fCharge;
+  delete [] fDriftTime;
+  delete [] fChargeRatio;
+  delete [] fClusterType;
+  delete [] fIsExtra;
   delete [] fVolumeID;
   delete [] fCov;
 }
@@ -133,6 +208,11 @@ Bool_t AliTrackPointArray::AddPoint(Int_t i, const AliTrackPoint *p)
   fX[i] = p->GetX();
   fY[i] = p->GetY();
   fZ[i] = p->GetZ();
+  fCharge[i] = p->GetCharge();
+  fDriftTime[i] = p->GetDriftTime();
+  fChargeRatio[i]=p->GetChargeRatio();
+  fClusterType[i]=p->GetClusterType();
+  fIsExtra[i] = p->IsExtra();
   fVolumeID[i] = p->GetVolumeID();
   memcpy(&fCov[6*i],p->GetCov(),6*sizeof(Float_t));
   return kTRUE;
@@ -147,6 +227,11 @@ Bool_t AliTrackPointArray::GetPoint(AliTrackPoint &p, Int_t i) const
   if (i >= fNPoints) return kFALSE;
   p.SetXYZ(fX[i],fY[i],fZ[i],&fCov[6*i]);
   p.SetVolumeID(fVolumeID[i]);
+  p.SetCharge(fCharge ? fCharge[i] : 0);
+  p.SetDriftTime(fDriftTime ? fDriftTime[i] : 0);
+  p.SetChargeRatio(fChargeRatio ? fChargeRatio[i] : 0);
+  p.SetClusterType(fClusterType ? fClusterType[i] : 0);
+  p.SetExtra(fIsExtra ? fIsExtra[i] : kFALSE);
   return kTRUE;
 }
 
@@ -194,6 +279,11 @@ AliTrackPoint::AliTrackPoint() :
   fX(0),
   fY(0),
   fZ(0),
+  fCharge(0),
+  fDriftTime(0),
+  fChargeRatio(0),
+  fClusterType(0),
+  fIsExtra(kFALSE),
   fVolumeID(0)
 {
   // Default constructor
@@ -203,31 +293,49 @@ AliTrackPoint::AliTrackPoint() :
 
 
 //______________________________________________________________________________
-AliTrackPoint::AliTrackPoint(Float_t x, Float_t y, Float_t z, const Float_t *cov, UShort_t volid) :
+AliTrackPoint::AliTrackPoint(Float_t x, Float_t y, Float_t z, const Float_t *cov, UShort_t volid, Float_t charge, Float_t drifttime,Float_t chargeratio, Int_t clutyp) :
   TObject(),
   fX(0),
   fY(0),
   fZ(0),
+  fCharge(0),
+  fDriftTime(0),
+  fChargeRatio(0),
+  fClusterType(0),
+  fIsExtra(kFALSE),
   fVolumeID(0)
 {
   // Constructor
   //
   SetXYZ(x,y,z,cov);
+  SetCharge(charge);
+  SetDriftTime(drifttime);
+  SetChargeRatio(chargeratio);
+  SetClusterType(clutyp);
   SetVolumeID(volid);
 }
 
 //______________________________________________________________________________
-AliTrackPoint::AliTrackPoint(const Float_t *xyz, const Float_t *cov, UShort_t volid) :
+AliTrackPoint::AliTrackPoint(const Float_t *xyz, const Float_t *cov, UShort_t volid, Float_t charge, Float_t drifttime,Float_t chargeratio, Int_t clutyp) :
   TObject(),
   fX(0),
   fY(0),
   fZ(0),
+  fCharge(0),
+  fDriftTime(0),
+  fChargeRatio(0),
+  fClusterType(0),
+  fIsExtra(kFALSE),
   fVolumeID(0)
 {
   // Constructor
   //
   SetXYZ(xyz[0],xyz[1],xyz[2],cov);
+  SetCharge(charge);
+  SetDriftTime(drifttime);
+  SetChargeRatio(chargeratio);
   SetVolumeID(volid);
+  SetClusterType(clutyp);
 }
 
 //______________________________________________________________________________
@@ -236,11 +344,21 @@ AliTrackPoint::AliTrackPoint(const AliTrackPoint &p):
   fX(0),
   fY(0),
   fZ(0),
+  fCharge(0),
+  fDriftTime(0),
+  fChargeRatio(0),
+  fClusterType(0),
+  fIsExtra(kFALSE),
   fVolumeID(0)
 {
   // Copy constructor
   //
   SetXYZ(p.fX,p.fY,p.fZ,&(p.fCov[0]));
+  SetCharge(p.fCharge);
+  SetDriftTime(p.fDriftTime);
+  SetChargeRatio(p.fChargeRatio);
+  SetClusterType(p.fClusterType);
+  SetExtra(p.fIsExtra);
   SetVolumeID(p.fVolumeID);
 }
 
@@ -253,6 +371,11 @@ AliTrackPoint &AliTrackPoint::operator =(const AliTrackPoint& p)
   ((TObject *)this)->operator=(p);
 
   SetXYZ(p.fX,p.fY,p.fZ,&(p.fCov[0]));
+  SetCharge(p.fCharge);
+  SetDriftTime(p.fDriftTime);
+  SetChargeRatio(p.fChargeRatio);
+  SetClusterType(p.fClusterType);
+  SetExtra(p.fIsExtra);
   SetVolumeID(p.fVolumeID);
 
   return *this;
@@ -412,6 +535,32 @@ Float_t AliTrackPoint::GetAngle() const
 
 }
 
+//______________________________________________________________________________
+Bool_t AliTrackPoint::GetRotMatrix(TGeoRotation& rot) const
+{
+  // Returns the orientation of the
+  // sensitive layer (using cluster
+  // covariance matrix).
+  // Assumes that cluster has errors only in the layer's plane.
+  // Return value is kTRUE in case of success.
+
+  TMatrixDSym mcov(3);
+  {
+    const Float_t *cov=GetCov();
+    mcov(0,0)=cov[0]; mcov(0,1)=cov[1]; mcov(0,2)=cov[2];
+    mcov(1,0)=cov[1]; mcov(1,1)=cov[3]; mcov(1,2)=cov[4];
+    mcov(2,0)=cov[2]; mcov(2,1)=cov[4]; mcov(2,2)=cov[5];
+  }
+
+  TMatrixDSymEigen eigen(mcov);
+  TMatrixD eigenMatrix = eigen.GetEigenVectors();
+
+  rot.SetMatrix(eigenMatrix.GetMatrixArray());
+
+  return kTRUE;
+}
+
+
 //_____________________________________________________________________________
 AliTrackPoint& AliTrackPoint::Rotate(Float_t alpha) const
 {
@@ -475,6 +624,11 @@ void AliTrackPoint::Print(Option_t *) const
   printf("X = %12.6f    Tx = %12.6f%12.6f%12.6f\n", fX, fCov[0], fCov[1], fCov[2]);
   printf("Y = %12.6f    Ty = %12.6f%12.6f%12.6f\n", fY, fCov[1], fCov[3], fCov[4]);
   printf("Z = %12.6f    Tz = %12.6f%12.6f%12.6f\n", fZ, fCov[2], fCov[4], fCov[5]);
+  printf("Charge = %f\n", fCharge);
+  printf("Drift Time = %f\n", fDriftTime);
+  printf("Charge Ratio  = %f\n", fChargeRatio);
+  printf("Cluster Type  = %d\n", fClusterType);
+  if(fIsExtra) printf("This is an extra point\n");
 
 }
 
@@ -520,3 +674,4 @@ void AliTrackPoint::SetAlignCovMatrix(const TMatrixDSym alignparmtrx){
 
 }
 
+