* provided "as is" without express or implied warranty. *
**************************************************************************/
-/*
-$Log$
-Revision 1.6 2002/10/14 14:57:43 hristov
-Merging the VirtualMC branch to the main development branch (HEAD)
-
-Revision 1.4.10.1 2002/08/28 15:06:52 alibrary
-Updating to v3-09-01
-
-Revision 1.5 2002/08/25 15:54:29 kowal2
-Protection against overflows in TMath::Nint.
-
-Revision 1.4 2001/01/10 09:35:27 kowal2
-Changes to obey the coding rules.
+/* $Id$ */
-Revision 1.3 2000/11/02 10:22:50 kowal2
-Logs added
-
-*/
///////////////////////////////////////////////////////////////////////////////
// //
// Time Projection Chamber track hits object //
// //
///////////////////////////////////////////////////////////////////////////////
-#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 = 10000};
- 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 fSumX4, Int_t n,
Double_t &a, Double_t &b, Double_t &c);
void Fit(AliTrackHitsParam * param);
- Double_t fSumDr; //
- Double_t fSumDr2; //
- Double_t fSumDr3; //
- Double_t fSumDr4; //
- Double_t fSumDFi; //
- Double_t fSumDFiDr; //
- Double_t fSumDFiDr2;//
- Double_t fSumDZ; //
- Double_t fSumDZDr; //
- Double_t fSumDZDr2; //
+ Double_t fSumDr; //fSumDr
+ Double_t fSumDr2; //fSumDr2
+ Double_t fSumDr3; // fSumDr3
+ Double_t fSumDr4; //fSumDr4
+ Double_t fSumDFi; //fSumDFi
+ Double_t fSumDFiDr; // fSumDFiDr
+ Double_t fSumDFiDr2;//fSumDFiDr2
+ Double_t fSumDZ; //fSumDZ
+ 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;
return fCurrentHit->fStatus = kTRUE;
}
+
+/*
Bool_t AliTPCTrackHits::Next()
{
//
}
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.SetZ(z);
return kTRUE;
}
-
-AliTPChit * AliTPCTrackHits::GetHit()
+
+*/
+AliTPChit * AliTPCTrackHits::GetHit() const
{
//
return (fCurrentHit->fStatus)? &fCurrentHit->fHit:0;
}
+
+
+Bool_t AliTPCTrackHits::Next(Int_t id)
+{
+ //
+ //
+ if (!(fCurrentHit->fStatus))
+ return kFALSE;
+
+ // fCurrentHit->fStackIndex++;
+ AliHitInfo * hinfo = (AliHitInfo *)fHitsPosAndQ->At(fCurrentHit->fParamIndex,
+ fCurrentHit->fStackIndex);
+ AliTrackHitsInfo *info = (AliTrackHitsInfo *)fTrackHitsInfo->At(fCurrentHit->fInfoIndex);
+ if (!info) {
+ fCurrentHit->fStatus = kFALSE;
+ return kFALSE;
+ }
+ AliTrackHitsParam *param = (AliTrackHitsParam *)fTrackHitsParam->At(fCurrentHit->fParamIndex);
+
+ if ( (id>=0) && (info!=0) && (info->fVolumeID!=id)){
+ fCurrentHit->fInfoIndex++;
+ info = (AliTrackHitsInfo *)fTrackHitsInfo->At(fCurrentHit->fInfoIndex);
+ if (!info) {
+ fCurrentHit->fStatus = kFALSE;
+ return kFALSE;
+ }
+ fCurrentHit->fParamIndex = info->fHitParamIndex;
+ param = (AliTrackHitsParam *)fTrackHitsParam->At(fCurrentHit->fParamIndex);
+ fCurrentHit->fStackIndex =0;
+ fCurrentHit->fR = param->fR;
+ return Next(id);
+ }
+ if (!info) {
+ fCurrentHit->fStatus = kFALSE;
+ return kFALSE;
+ }
+ if (!hinfo) {
+ hinfo = (AliHitInfo *)fHitsPosAndQ->At(fCurrentHit->fParamIndex+1, 0);
+ if (!hinfo){
+ fCurrentHit->fStatus = kFALSE;
+ return kFALSE;
+ }
+ if (hinfo){
+ fCurrentHit->fParamIndex++;
+ fCurrentHit->fStackIndex = 0;
+ param = (AliTrackHitsParam *)fTrackHitsParam->At(fCurrentHit->fParamIndex);
+ if (!param){
+ fCurrentHit->fStatus = kFALSE;
+ return kFALSE;
+ }
+ fCurrentHit->fR = param->fR;
+
+ if ((fCurrentHit->fInfoIndex+1<fTrackHitsInfo->GetSize())
+ &&((info+1)->fHitParamIndex<=fCurrentHit->fParamIndex)){
+ fCurrentHit->fInfoIndex++;
+ info = (AliTrackHitsInfo *)fTrackHitsInfo->At(fCurrentHit->fInfoIndex);
+ if (!info){
+ fCurrentHit->fStatus = kFALSE;
+ return kFALSE;
+ }
+ if ( (id>=0) && (info!=0) && (info->fVolumeID!=id)){
+ return Next(id);
+ }
+ fCurrentHit->fHit.fSector = info->fVolumeID;
+ fCurrentHit->fHit.SetTrack(info->fTrackID);
+ }
+ }
+ }
+ Double_t ratio;
+ {
+ // Double_t dfi2 = param->fAn+2*param->fAd*(fCurrentHit->fR-param->fR);
+ Double_t dfi2 = param->fAn;
+ dfi2*=dfi2*fCurrentHit->fR*fCurrentHit->fR;
+ // Double_t ddz2 = param->fTheta+2*param->fThetaD*(fCurrentHit->fR-param->fR);
+ Double_t ddz2 = param->fTheta;
+ ddz2*=ddz2;
+ ratio = TMath::Sqrt(1.+ dfi2+ ddz2);
+ }
+
+ 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;
+ Double_t fi = param->fFi + (param->fAn*dR+param->fAd*dR*dR);
+ Double_t z = param->fZ + (param->fTheta*dR+param->fThetaD*dR*dR);
+
+ fCurrentHit->fHit.SetX(fCurrentHit->fR*TMath::Cos(fi));
+ fCurrentHit->fHit.SetY(fCurrentHit->fR*TMath::Sin(fi));
+ fCurrentHit->fHit.SetZ(z);
+ fCurrentHit->fHit.fSector = info->fVolumeID;
+ fCurrentHit->fHit.SetTrack(info->fTrackID);
+ //
+ fCurrentHit->fStatus = kTRUE;
+ fCurrentHit->fStackIndex++;
+ return kTRUE;
+}
+
+
AliTrackHitsParam * AliTPCTrackHits::GetParam()
{
//
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff