// //
///////////////////////////////////////////////////////////////////////////////
-//#include "TVector3.h"
-//#include "TClonesArray.h"
-#include "AliTPCTrackHits.h"
-#include "AliTPC.h"
-
-//#include <Riostream.h>
-
+#include <TError.h>
+#include "AliTPC.h"
+#include "AliTPCTrackHits.h"
+// Interface classes
+#include "AliTPCTrackHitsInterfaces.h"
ClassImp(AliTPCTrackHits)
LClassImp(AliTrackHitsInfo)
Int_t AliTPCTrackHits::fgCounter2 =0;
const Double_t AliTPCTrackHits::fgkPrecision=1e-6; //precision
const Double_t AliTPCTrackHits::fgkPrecision2=1e-20; //precision
+const Double_t AliTPCTrackHits::fgkTimePrecision=20.e-9; //hit time precision
-/************************************************************/
-// Interface classes //
-#include "AliTPCTrackHitsInterfaces.h"
-
-
-
-
-struct AliTPCCurrentHit {
- AliTPChit fHit;
+class AliTPCCurrentHit {
+private:
+ AliTPChit fHit; // - hit in "standard" representation
UInt_t fInfoIndex;// - current info pointer
UInt_t fParamIndex;// - current param pointer
UInt_t fStackIndex; // - current hit stack index
};
-struct AliTPCTempHitInfo {
- enum { fkStackSize = 100};
- AliTPCTempHitInfo();
- void NewParam(Double_t r, Double_t z, Double_t fi, Int_t q);
- void SetHit(Double_t r, Double_t z, Double_t fi, Int_t q);
+class AliTPCTempHitInfo {
+private:
+ enum { kStackSize = 100};
+ AliTPCTempHitInfo();
+ AliTPCTempHitInfo(const AliTPCTempHitInfo &)
+ {::Fatal("copy ctor","Not implemented\n");}
+ AliTPCTempHitInfo & operator = (const AliTPCTempHitInfo &)
+ {::Fatal("= operator","Not implemented\n");return *this;}
+
+ void NewParam(Double_t r, Double_t z, Double_t fi, Int_t q, Float_t time);
+ void SetHit(Double_t r, Double_t z, Double_t fi, Int_t q, Float_t time);
Double_t * GetPosition(Int_t index){return &fPositionStack[index*3];}
void UpdateParam(Double_t maxdelta); //recal
void Fit2(Double_t fSumY, Double_t fSumYX, Double_t fSumYX2,
Double_t fSumDZDr; //fSumDZDr
Double_t fSumDZDr2; //fSumDZDr2
Double_t fOldR; //previos r
- Double_t fPositionStack[3*fkStackSize]; //position stack
- UInt_t fQStack[fkStackSize]; //Q stack
+ Double_t fPositionStack[3*kStackSize]; //position stack
+ UInt_t fQStack[kStackSize]; //Q stack
+ Float_t fTimeStack[kStackSize]; //time stack
UInt_t fStackIndex; //current stack index
UInt_t fInfoIndex; //current track info index
UInt_t fParamIndex; //current track parameters index
}
-void AliTPCTempHitInfo::NewParam(Double_t r, Double_t z, Double_t fi, Int_t q)
+void AliTPCTempHitInfo::NewParam(Double_t r, Double_t z, Double_t fi, Int_t q, Float_t time)
{
//
//reset stack and sum parameters
fParam->fAd = 0.;
fParam->fTheta =0.;
fParam->fThetaD =0.;
- SetHit(r,z,fi,q);
+ SetHit(r,z,fi,q,time);
}
-void AliTPCTempHitInfo::SetHit(Double_t r, Double_t z, Double_t fi, Int_t q)
+void AliTPCTempHitInfo::SetHit(Double_t r, Double_t z, Double_t fi, Int_t q, Float_t time)
{
//
//add hit to the stack
f[1] = z;
f[2] = fi;
fQStack[fStackIndex]=q;
+ fTimeStack[fStackIndex]=time;
if (fStackIndex==0) return;
Double_t dr = (r-fParam->fR);
if (TMath::Abs(dr)<AliTPCTrackHits::fgkPrecision) dr =AliTPCTrackHits::fgkPrecision;
}
+//______________________________________________________________________
+AliTrackHitsInfo::AliTrackHitsInfo() :
+ fTrackID(0),
+ fVolumeID(0),
+ fHitParamIndex(0)
+{
+ //
+ // Default constructor
+ //
+ fgCounter1++;
+ fgCounter2++;
+}
+//______________________________________________________________________
+AliTrackHitsParam::AliTrackHitsParam() :
+ fR(0),
+ fZ(0),
+ fFi(0),
+ fAn(0),
+ fAd(0),
+ fTheta(0),
+ fThetaD(0)
+{
+ //
+ // Default constructor
+ //
+ fgCounter1++;
+ fgCounter2++;
+}
AliTPCTrackHits::AliTPCTrackHits()
AliTPCTrackHits::AliTPCTrackHits(const AliTPCTrackHits& r) : TObject(r)
{
+ //dummy
+}
+AliTPCTrackHits &AliTPCTrackHits::operator=(const AliTPCTrackHits& /* r */)
+{
+ //dummy
+ return *this;
}
-
AliTPCTrackHits::~AliTPCTrackHits()
{
void AliTPCTrackHits::AddHitKartez(Int_t volumeID, Int_t trackID, Double_t x,
- Double_t y, Double_t z,Int_t q)
+ Double_t y, Double_t z,Int_t q, Float_t time)
{
//add hits (cartesian)
Double_t r = TMath::Sqrt(x*x+y*y);
Double_t fi = TMath::ACos(x/r);
if (y<0) fi*=-1.;
- AddHit(volumeID,trackID,r,z,fi,q);
+ AddHit(volumeID,trackID,r,z,fi,q,time);
}
void AliTPCTrackHits::AddHit(Int_t volumeID, Int_t trackID,
- Double_t r, Double_t z, Double_t fi, Int_t q)
+ Double_t r, Double_t z, Double_t fi, Int_t q, Float_t time)
{
//
Bool_t diff=kFALSE;
fTempInfo->fParam =
(AliTrackHitsParam*) (fTrackHitsParam->At(0));
fTempInfo->fParamIndex = 0;
- fTempInfo->NewParam(r,z,fi,q);
+ fTempInfo->NewParam(r,z,fi,q,time);
return;
}
fTrackHitsParam->Resize(fTempInfo->fParamIndex+1);
fTempInfo->fParam =
(AliTrackHitsParam*) (fTrackHitsParam->At(fTempInfo->fParamIndex));
- fTempInfo->NewParam(r,z,fi,q);
+ fTempInfo->NewParam(r,z,fi,q,time);
return;
}
fTrackHitsParam->Resize(fTempInfo->fParamIndex+1);
fTempInfo->fParam =
(AliTrackHitsParam*) (fTrackHitsParam->At(fTempInfo->fParamIndex));
- fTempInfo->NewParam(r,z,fi,q);
+ fTempInfo->NewParam(r,z,fi,q,time);
return;
}
}
//safety factor 1.25
if ( ( (dd*1.25>fPrecision) ) ||
- (fTempInfo->fStackIndex+4>fTempInfo->fkStackSize) ||
+ (fTempInfo->fStackIndex+4>fTempInfo->kStackSize) ||
(TMath::Abs(dl/fStep)>fMaxDistance) )
diff=kTRUE;
else{
fTempInfo->fStackIndex++;
- fTempInfo->SetHit(r,z,fi,q);
+ fTempInfo->SetHit(r,z,fi,q,time);
return;
}
//if parameter changed
fTrackHitsParam->Resize(fTempInfo->fParamIndex+1);
fTempInfo->fParam =
(AliTrackHitsParam*) (fTrackHitsParam->At(fTempInfo->fParamIndex));
- fTempInfo->NewParam(r,z,fi,q);
+ fTempInfo->NewParam(r,z,fi,q,time);
}
else{
fTempInfo->fStackIndex++;
- fTempInfo->SetHit(r,z,fi,q);
+ fTempInfo->SetHit(r,z,fi,q,time);
}
}
info = (AliHitInfo*)(fHitsPosAndQ->At(fTempInfo->fParamIndex,i));
info->fHitDistance = (TMath::Abs(dl/fStep)<32000) ?Short_t(TMath::Nint(dl/fStep)):0;
info->fCharge = Short_t(fTempInfo->fQStack[i]);
+ info->fTime = TMath::Nint(fTempInfo->fTimeStack[i]/AliTPCTrackHits::fgkTimePrecision);
/*
cout<<"C2";
cout<<" "<<fTempInfo->fStackIndex<<" \t";
(AliTrackHitsParam*) (fTrackHitsParam->At(fTempInfo->fParamIndex));
Double_t * p = fTempInfo->GetPosition(i);
UInt_t index2 = fTempInfo->fStackIndex;
- fTempInfo->NewParam(p[0],p[1],p[2],fTempInfo->fQStack[i]);
+ fTempInfo->NewParam(p[0],p[1],p[2],fTempInfo->fQStack[i],fTempInfo->fTimeStack[i]);
if (i+1<=index2) FlushHitStack2(i+1,index2);
if (force) return FlushHitStack(kTRUE);
// call only for hits where first iteration were not succesfully interpolated
Double_t * positionstack = new Double_t[3*(index2-index1+1)];
UInt_t * qstack = new UInt_t[index2-index1+1];
+ Float_t * timestack = new Float_t[index2-index1+1];
memcpy(positionstack, &fTempInfo->fPositionStack[3*index1],
(3*(index2-index1+1))*sizeof(Double_t));
memcpy(qstack, &fTempInfo->fQStack[index1],(index2-index1+1)*sizeof(UInt_t));
+ memcpy(timestack, &fTempInfo->fTimeStack[index1],(index2-index1+1)*sizeof(Float_t));
Double_t *p = positionstack;
for (Int_t j=0; j<=index2-index1;j++){
fTempInfo->fStackIndex++;
- fTempInfo->SetHit(p[3*j+0],p[3*j+1],p[3*j+2],qstack[j]);
+ fTempInfo->SetHit(p[3*j+0],p[3*j+1],p[3*j+2],qstack[j],timestack[j]);
}
delete []positionstack;
delete []qstack;
+ delete []timestack;
}
fCurrentHit->fHit.SetX(param->fR*TMath::Cos(param->fFi));
fCurrentHit->fHit.SetY(param->fR*TMath::Sin(param->fFi));
fCurrentHit->fHit.SetZ(param->fZ);
- fCurrentHit->fHit.fQ = hinfo->fCharge;
+ fCurrentHit->fHit.fQ = (Float_t)(hinfo->fCharge*AliTPCTrackHits::fgkTimePrecision);
+ fCurrentHit->fHit.fTime = hinfo->fTime;
fCurrentHit->fR = param->fR;
}
fCurrentHit->fHit.fQ = hinfo->fCharge;
+ fCurrentHit->fHit.fTime = (Float_t)(hinfo->fTime*AliTPCTrackHits::fgkTimePrecision);
fCurrentHit->fR += fStep*hinfo->fHitDistance/ratio;
Double_t dR = fCurrentHit->fR - param->fR;
//Double_t dR =0;
}
fCurrentHit->fHit.fQ = hinfo->fCharge;
+ fCurrentHit->fHit.fTime = (Float_t)(hinfo->fTime*AliTPCTrackHits::fgkTimePrecision);
fCurrentHit->fR += fStep*hinfo->fHitDistance/ratio;
Double_t dR = fCurrentHit->fR - param->fR;
//Double_t dR =0;