#include <TMath.h>
#include <TMatrixD.h>
#include <TMatrixDSym.h>
+#include <TGeoMatrix.h>
+#include <TMatrixDSymEigen.h>
#include "AliTrackPointArray.h"
fX(0),
fY(0),
fZ(0),
+ fCharge(0),
+ fDriftTime(0),
+ fChargeRatio(0),
+ fClusterType(0),
+ fIsExtra(0),
fSize(0),
fCov(0),
fVolumeID(0)
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])
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;
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])
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));
}
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;
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));
delete [] fX;
delete [] fY;
delete [] fZ;
+ delete [] fCharge;
+ delete [] fDriftTime;
+ delete [] fChargeRatio;
+ delete [] fClusterType;
+ delete [] fIsExtra;
delete [] fVolumeID;
delete [] fCov;
}
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;
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;
}
fX(0),
fY(0),
fZ(0),
+ fCharge(0),
+ fDriftTime(0),
+ fChargeRatio(0),
+ fClusterType(0),
+ fIsExtra(kFALSE),
fVolumeID(0)
{
// Default constructor
//______________________________________________________________________________
-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);
}
//______________________________________________________________________________
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);
}
((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;
}
+//______________________________________________________________________________
+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
{
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");
}
}
+