////////////////////////////////////////////////
// Manager class for TPC hits //
////////////////////////////////////////////////
+//
#include "TObject.h"
+#include "TClonesArray.h"
+
-class TClonesArray;
-class AliArrayS;
class AliTPChit;
class AliTPCTempHitInfoV2;
class AliTPCCurrentHitV2;
-
+class AliHit;
class AliTrackHitsParamV2 : public TObject {
+
+
public:
AliTrackHitsParamV2();
+
+ AliTrackHitsParamV2(const AliTrackHitsParamV2 &hit): TObject(hit),
+ fTrackID(0),
+ fVolumeID(0),
+ fR(0.),
+ fZ(0.),
+ fFi(0.),
+ fAn(0.),
+ fAd(0.),
+ fTheta(0.),
+ fThetaD(0.),
+ fNHits(0),
+ fHitDistance(0),
+ fCharge(0),
+ fTime(0)
+ {hit.Copy(*this);}
+ AliTrackHitsParamV2& operator = (const AliTrackHitsParamV2 &hit)
+ {hit.Copy(*this); return (*this);}
~AliTrackHitsParamV2();
- Int_t fTrackID; // ID of the track
+
+ Int_t GetTrackID() const {return fTrackID;}
+ Int_t GetVolumeID() const {return fVolumeID;}
+ Float_t GetR() const {return fR;}
+ Float_t GetZ() const {return fZ;}
+ Float_t GetFi() const {return fFi;}
+ Float_t GetAn() const {return fAn;}
+ Float_t GetAd() const {return fAd;}
+ Float_t GetTheta() const {return fTheta;}
+ Float_t GetThetaD() const {return fThetaD;}
+ Int_t GetNHits() const {return fNHits;}
+
+ Short_t HitDistance(Int_t i) const {return fHitDistance[i];}
+ Short_t Charge(Int_t i) const {return fCharge[i];}
+ Short_t Time(Int_t i) const {return fTime[i];}
+
+ Short_t& HitDistance(Int_t i) {return fHitDistance[i];}
+ Short_t& Charge(Int_t i) {return fCharge[i];}
+ Short_t& Time(Int_t i) {return fTime[i];}
+
+ void SetHitDistance(Int_t i)
+ {Short_t *s=new Short_t[i];
+ delete [] fHitDistance; fHitDistance=s;}
+
+ void SetCharge(Int_t i)
+ {Short_t *s=new Short_t[i];
+ delete [] fCharge; fCharge=s;}
+
+ void SetTime(Int_t i)
+ {Short_t *s=new Short_t[i];
+ delete [] fTime; fTime=s;}
+
+ void ResizeHitDistance(Int_t i)
+ {Short_t *s=new Short_t[i];
+ memcpy(s, fHitDistance, sizeof(Short_t)*i);
+ delete [] fHitDistance; fHitDistance=s;}
+
+ void ResizeCharge(Int_t i)
+ {Short_t *s=new Short_t[i];
+ memcpy(s, fCharge, sizeof(Short_t)*i);
+ delete [] fCharge; fCharge=s;}
+
+ void ResizeTime(Int_t i)
+ {Short_t *s=new Short_t[i];
+ memcpy(s, fTime, sizeof(Short_t)*i);
+ delete [] fTime; fTime=s;}
+
+ void SetTrackID(Int_t id) {fTrackID=id;}
+ void SetVolumeID(Short_t id) {fVolumeID=id;}
+ void SetR(Float_t r) {fR=r;}
+ void SetZ(Float_t z) {fZ=z;}
+ void SetFi(Float_t fi) {fFi=fi;}
+ void SetAn(Float_t an) {fAn=an;}
+ void SetAd(Float_t ad) {fAd=ad;}
+ void SetTheta(Float_t t) {fTheta=t;}
+ void SetThetaD(Float_t t) {fThetaD=t;}
+ void SetNHits(Int_t n) {fNHits=n;}
+
+ Float_t Eta() const;
+
+ private:
+ Int_t fTrackID; // ID of the trac©k
Short_t fVolumeID;// volume ID
Float_t fR; //radius
Float_t fZ; //z position
Int_t fNHits; //nuber of thits
Short_t * fHitDistance; //[fNHits] array of hits distances
Short_t * fCharge; //[fNHits] array of charges
- static Int_t fgCounter1;
- static Int_t fgCounter2;
- ClassDef(AliTrackHitsParamV2,1)
-};
+ Short_t * fTime; //[fNHits] array of hits time
+ static Int_t fgCounter1; //First internal counter
+ static Int_t fgCounter2; // Second internal counter
+ void Copy(TObject &) const
+ {Error("Copy","Not Implemented");}
+
+ ClassDef(AliTrackHitsParamV2,2)
+};
class AliTPCTrackHitsV2 : public TObject {
+
public:
- AliTPCTrackHitsV2();
+ AliTPCTrackHitsV2();
~AliTPCTrackHitsV2();
- void Clear();
+ AliTPCTrackHitsV2(const AliTPCTrackHitsV2 &hit): TObject(hit),
+ fArray(0),
+ fSize(hit.fSize),
+ fPrecision(hit.fPrecision),
+ fStep(hit.fStep),
+ fMaxDistance(hit.fMaxDistance),
+ fNVolumes(hit.fNVolumes),
+ fVolumes(0),
+ fTempInfo(hit.fTempInfo),
+ fCurrentHit(hit.fCurrentHit),
+ fHit(hit.fHit)
+ { //
+ //copy constructor
+ //
+
+ (*fArray) = (*hit.fArray);
+ //
+ delete [] fVolumes;
+ fVolumes = new Int_t[fNVolumes];
+ memcpy(fVolumes,hit.fVolumes,fNVolumes*sizeof(Int_t));
+ }
+ AliTPCTrackHitsV2& operator = (const AliTPCTrackHitsV2 &hit)
+ {
+ if(this!=&hit){
+ TObject::operator=(hit);
+ fSize=hit.fSize;
+ fPrecision=hit.fPrecision;
+ fStep=hit.fStep;
+ fMaxDistance=hit.fMaxDistance;
+ fNVolumes=hit.fNVolumes;
+ fTempInfo=hit.fTempInfo;
+ fCurrentHit=hit.fCurrentHit;
+ fHit=hit.fHit;
+ //
+ //delete fArray;
+ fArray->Clear();
+ (*fArray)=(*hit.fArray);
+ //
+ delete [] fVolumes;
+ fVolumes = new Int_t[fNVolumes];
+ memcpy(fVolumes,hit.fVolumes,fNVolumes*sizeof(Int_t));
+ //
+ }
+
+ return *this;
+ }
+
+
+ void Clear(Option_t * /*option*/ ="");
void 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);
void AddHit(Int_t volumeID, Int_t trackID, Double_t r,
- Double_t z, Double_t fi,Int_t q);
+ Double_t z, Double_t fi,Int_t q,Float_t time);
Bool_t First(); //set current hit to first hit
Bool_t Next(); //set current hit to next
- AliTPChit * GetHit();
+ AliHit * GetHit() const;
AliTrackHitsParamV2 * GetParam();
TClonesArray * GetArray(){return fArray;}
- Int_t GetEntriesFast() { return fSize;}
+ Int_t GetEntriesFast() const { return fSize;}
void SetHitPrecision(Double_t prec) {fPrecision=prec;}
void SetStepPrecision(Double_t prec) {fStep=prec;}
void SetMaxDistance(UInt_t distance) {fMaxDistance = distance;}
Bool_t FlushHitStack(Bool_t force=kTRUE); //
Int_t * GetVolumes(){ return fVolumes;}
- Int_t GetNVolumes(){return fNVolumes;}
+ Int_t GetNVolumes() const {return fNVolumes;}
+ static Double_t GetKPrecision() {return fgkPrecision;}
+ static Double_t GetKPrecision2() {return fgkPrecision2;}
+
public:
void AddVolume(Int_t volume); //add volumes to tthe list of volumes
void FlushHitStack2(Int_t index1, Int_t index2); //
+
+protected:
TClonesArray * fArray; //array of compressed hits
Int_t fSize; //total number of hits in track
Double_t fPrecision; // required precision
Int_t * fVolumes; //[fNVolumes] list of volumes
AliTPCTempHitInfoV2 * fTempInfo; //!information about track
AliTPCCurrentHitV2 * fCurrentHit; //!information about current hit
+ AliHit * fHit; //! current hit information
static const Double_t fgkPrecision; //precision
static const Double_t fgkPrecision2; //precision
- static Int_t fgCounter1;
- static Int_t fgCounter2;
- ClassDef(AliTPCTrackHitsV2,1)
+ static const Double_t fgkTimePrecision; //hit time precision
+ static Int_t fgCounter1; // First internal counter
+ static Int_t fgCounter2; // Second internal counter
+
+private:
+ void Copy(TObject &) const
+ {Error("Copy","Not Implemented");}
+
+
+ ClassDef(AliTPCTrackHitsV2,2)
};
+class AliTPCCurrentHitV2 {
+public:
+ Int_t GetStackIndex() const {return fStackIndex;}
+ void SetStackIndex(Int_t i) {fStackIndex=i;}
+ Int_t GetParamIndex() const {return fParamIndex;}
+ void SetParamIndex(Int_t i) {fParamIndex=i;}
+ Double_t GetR() const {return fR;}
+ void SetR(Double_t r) {fR=r;}
+ Bool_t GetStatus() const {return fStatus;}
+ void SetStatus(Bool_t s) {fStatus=s;}
+private:
+ Int_t fParamIndex;// - current param pointer
+ Int_t fStackIndex; // - current hit stack index
+ Double_t fR; //current Radius
+ Bool_t fStatus; //current status
+};
+
+
#endif //ALITPCTRACKHITSV2_H
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff