class AliComplexCluster : public TObject {
public:
+ friend class AliTPC;
+ friend class AliTPCClusterFinder;
+ friend class AliClusters;
+
+ AliComplexCluster() {
+ fTracks[0]=fTracks[1]=fTracks[2]=0;
+ fX=fY=fQ=fSigmaX2=fSigmaY2=fSigmaXY=fArea=fMax=0.;
+ }
+ virtual ~AliComplexCluster() {;}
+ Bool_t IsSortable() const;
+ Int_t Compare(const TObject *o) const;
+private:
Int_t fTracks[3];//labels of overlapped tracks
Float_t fX ; //Y of cluster
Float_t fY ; //Z of cluster
Float_t fSigmaXY; // XY moment
Float_t fArea; //area of cluster
Float_t fMax; //amplitude at maximum
-public:
- AliComplexCluster() {
- fTracks[0]=fTracks[1]=fTracks[2]=0;
- fX=fY=fQ=fSigmaX2=fSigmaY2=fSigmaXY=fArea=fMax=0.;
- }
- virtual ~AliComplexCluster() {;}
- Bool_t IsSortable() const;
- Int_t Compare(const TObject *o) const;
- ClassDef(AliComplexCluster,1) // Cluster manager
+
+ ClassDef(AliComplexCluster,1)
+ // Cluster manager
};
class AliDigitCluster : public AliComplexCluster {
public:
+ friend class AliTPCClusterFinder;
+private:
Int_t fNx; //number of accepted x bins
Int_t fNy; //number of accepted y bins
Float_t fMaxX; //maximum x bin
Float_t fMaxY; //maximum y bin
-public:
+
ClassDef(AliDigitCluster,1) // Tclusters
};
class AliTPCTrackerPoint {
- private:
- Short_t fTX; // x position of the cluster in cm - 10 mum prec
- Short_t fTZ; // current prolongation in Z in cm - 10 mum prec.
- Short_t fTY; // current prolongation in Y in cm - 10 mum prec.
- Char_t fTAngleZ; // angle
- Char_t fTAngleY; // angle
- UShort_t fSigmaZ; // shape Z - normalised shape - normaliziation 1 - precision 2 percent
- UShort_t fSigmaY; // shape Y - normalised shape - normaliziation 1 - precision 2 percent
- UShort_t fErrZ; // z error estimate - in mm - 50 mum precision
- UShort_t fErrY; // y error estimate - in mm - 50 mum precision
public:
Char_t fIsShared; // indicate sharing of the point between several tracks
AliTPCTrackerPoint(){fTX=0; fTY=0; fTZ=0; fTAngleZ=0; fTAngleY=0; fIsShared = 0;}
- inline Float_t GetX() {return (fTX*0.01);}
- inline Float_t GetZ() {return (fTZ*0.01);}
- inline Float_t GetY() {return (fTY*0.01);}
- inline Float_t GetAngleZ() {return (Float_t(fTAngleZ)*0.02);}
- inline Float_t GetAngleY() {return (Float_t(fTAngleY)*0.02);}
+ Float_t GetX() const {return (fTX*0.01);}
+ Float_t GetZ() const {return (fTZ*0.01);}
+ Float_t GetY() const {return (fTY*0.01);}
+ Float_t GetAngleZ() const {return (Float_t(fTAngleZ)*0.02);}
+ Float_t GetAngleY() const {return (Float_t(fTAngleY)*0.02);}
//
- void SetX(Float_t x){ fTX = Short_t(TMath::Nint(x*100.));}
- void SetY(Float_t y){ fTY = Short_t(TMath::Nint(y*100.));}
- void SetZ(Float_t z){ fTZ = Short_t(TMath::Nint(z*100.));}
+ void SetX(Float_t x) { fTX = Short_t(TMath::Nint(x*100.));}
+ void SetY(Float_t y) { fTY = Short_t(TMath::Nint(y*100.));}
+ void SetZ(Float_t z) { fTZ = Short_t(TMath::Nint(z*100.));}
void SetAngleZ(Float_t anglez) {fTAngleZ = Char_t(TMath::Nint(anglez*50.));}
void SetAngleY(Float_t angley) {fTAngleY = Char_t(TMath::Nint(angley*50.));}
- inline Float_t GetSigmaZ() {return (fSigmaZ*0.02);}
- inline Float_t GetSigmaY() {return (fSigmaY*0.02);}
- inline Float_t GetErrZ() {return (fErrZ*0.005);}
- inline Float_t GetErrY() {return (fErrY*0.005);}
+ Float_t GetSigmaZ() const {return (fSigmaZ*0.02);}
+ Float_t GetSigmaY() const {return (fSigmaY*0.02);}
+ Float_t GetErrZ() const {return (fErrZ*0.005);}
+ Float_t GetErrY() const {return (fErrY*0.005);}
void SetErrZ(Float_t errz) {fErrZ = UChar_t(TMath::Nint(errz*200.));}
void SetErrY(Float_t erry) {fErrY = UChar_t(TMath::Nint(erry*200.));}
void SetSigmaZ(Float_t sigmaz) {fSigmaZ = UChar_t(TMath::Nint(sigmaz*50.));}
void SetSigmaY(Float_t sigmay) {fSigmaY = UChar_t(TMath::Nint(sigmay*50.));}
//
- public:
+ private:
+ Short_t fTX; // x position of the cluster in cm - 10 mum prec
+ Short_t fTZ; // current prolongation in Z in cm - 10 mum prec.
+ Short_t fTY; // current prolongation in Y in cm - 10 mum prec.
+ Char_t fTAngleZ; // angle
+ Char_t fTAngleY; // angle
+ UShort_t fSigmaZ; // shape Z - normalised shape - normaliziation 1 - precision 2 percent
+ UShort_t fSigmaY; // shape Y - normalised shape - normaliziation 1 - precision 2 percent
+ UShort_t fErrZ; // z error estimate - in mm - 50 mum precision
+ UShort_t fErrY; // y error estimate - in mm - 50 mum precision
+
ClassDef(AliTPCTrackerPoint,1)
};
class AliTPCClusterPoint {
- private:
- Short_t fCZ; // current cluster position Z in cm - 100 mum precision
- Short_t fCY; // current cluster position Y in cm - 100 mum precision
- UChar_t fSigmaZ; // shape Z - normalised shape - normaliziation 1 - precision 2 percent
- UChar_t fSigmaY; // shape Y - normalised shape - normaliziation 1 - precision 2 percent
- UShort_t fQ; // total charge in cluster
- UShort_t fMax; // charge at maximum
- Char_t fCType; // type of the cluster
public:
AliTPCClusterPoint(){fCZ=fCY=fSigmaZ=fSigmaY=fQ=fMax=fCType=0;}
- inline Float_t GetZ() {return (fCZ*0.01);}
- inline Float_t GetY() {return (fCY*0.01);}
- inline Float_t GetSigmaZ() {return (fSigmaZ*0.02);}
- inline Float_t GetSigmaY() {return (fSigmaY*0.02);}
- inline Int_t GetType() {return fCType;}
- inline Int_t GetMax() {return fMax;}
- inline Float_t GetQ() {return fQ;}
+ inline Float_t GetZ() const {return (fCZ*0.01);}
+ inline Float_t GetY() const {return (fCY*0.01);}
+ inline Float_t GetSigmaZ() const {return (fSigmaZ*0.02);}
+ inline Float_t GetSigmaY() const {return (fSigmaY*0.02);}
+ inline Int_t GetType() const {return fCType;}
+ inline Int_t GetMax() const {return fMax;}
+ inline Float_t GetQ() const {return fQ;}
//
void SetY(Float_t y){ fCY = Short_t(TMath::Nint(y*100.));}
void SetQ(Float_t q) {fQ = UShort_t(q);}
void SetMax(Float_t max) {fMax = UShort_t(max);}
void SetType(Char_t type) {fCType = type;}
+ private:
+ Short_t fCZ; // current cluster position Z in cm - 100 mum precision
+ Short_t fCY; // current cluster position Y in cm - 100 mum precision
+ UChar_t fSigmaZ; // shape Z - normalised shape - normaliziation 1 - precision 2 percent
+ UChar_t fSigmaY; // shape Y - normalised shape - normaliziation 1 - precision 2 percent
+ UShort_t fQ; // total charge in cluster
+ UShort_t fMax; // charge at maximum
+ Char_t fCType; // type of the cluster
//
- public:
ClassDef(AliTPCClusterPoint,1)
};
class AliTPCExactPoint : public TObject{
public:
AliTPCExactPoint(){fEZ=fEY=fEAngleZ=fEAngleY=fEAmp=fEPrim=fTrackID=0;}
+ private:
Float_t fEZ; // current "exact" position according simulation
Float_t fEY; // current "exact" position according simulation
Float_t fEX; // x poistion of the cluster
Int_t fTrackID; // id of the track
Int_t fRow; // row
Int_t fSec; //sector
+ friend class AliTPCtrackerMI;
ClassDef(AliTPCExactPoint,1)
};
class AliTPCTrackPoint: public TObject{
public:
+ friend class AliTPCtrackerMI;
AliTPCTrackPoint(){}
// AliTPCClusterPoint & GetCPoint(){return fCPoint;}
AliTPCTrackerPoint & GetTPoint(){return fTPoint;}
AliTPCclusterMI & GetCPoint(){return fCPoint;}
- public:
+ private:
// AliTPCClusterPoint fCPoint;
//Char_t fIsShared;
- AliTPCTrackerPoint fTPoint;
- AliTPCclusterMI fCPoint;
+ AliTPCTrackerPoint fTPoint; // track point
+ AliTPCclusterMI fCPoint; // cluster point
ClassDef(AliTPCTrackPoint,1)
};
class AliTPCTrackPoint2: public AliTPCTrackPoint{
public:
+ friend class AliTPCtrackerMI;
AliTPCTrackPoint2(){}
+ private:
Float_t fGX; //global poition of the point
Float_t fGY; //global poition of the point
Float_t fGZ; //global poition of the point
//
Int_t fID; //id of the corresponding track
Int_t fLab; //MC label of the track
- public:
ClassDef(AliTPCTrackPoint2,1)
};
class AliTPCTrackPointRef: public AliTPCTrackPoint{
public:
+ friend class AliTPCtrackerMI;
AliTPCExactPoint & GetExactPoint(){return fEPoint;}
AliTPCExactPoint & GetNearestPoint(){return fNPoint;}
- public:
+ private:
AliTPCExactPoint fEPoint; //exact point belonging to track
AliTPCExactPoint fNPoint; //nearest point
ClassDef(AliTPCTrackPointRef,1)
// //
///////////////////////////////////////////////////////////////////////////////
-#include "TVector3.h"
-#include "TClonesArray.h"
+//#include "TVector3.h"
+//#include "TClonesArray.h"
#include "AliTPCTrackHits.h"
#include "AliTPC.h"
-#include <Riostream.h>
+//#include <Riostream.h>
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
}
+AliTPCTrackHits::AliTPCTrackHits(const AliTPCTrackHits& r) : TObject(r)
+{
+}
+
+
AliTPCTrackHits::~AliTPCTrackHits()
{
//
void AliTPCTrackHits::AddHitKartez(Int_t volumeID, Int_t trackID, Double_t x,
Double_t y, Double_t z,Int_t q)
{
+ //add hits (cartesian)
Double_t r = TMath::Sqrt(x*x+y*y);
Double_t fi = TMath::ACos(x/r);
if (y<0) fi*=-1.;
}
*/
-AliTPChit * AliTPCTrackHits::GetHit()
+AliTPChit * AliTPCTrackHits::GetHit() const
{
//
return (fCurrentHit->fStatus)? &fCurrentHit->fHit:0;
////////////////////////////////////////////////
#include "AliCTypes.h"
-#include "AliSegmentID.h"
-#include "AliArrayS.h"
-#include "AliTPC.h"
-#include "TVector3.h"
-#include "AliObjectArray.h"
+//#include "AliSegmentID.h"
+//#include "AliArrayS.h"
+//#include "AliTPC.h"
+//#include "TVector3.h"
+//#include "AliObjectArray.h"
#include "TArrayOfArray.h"
class TClonesArray;
class AliTPChit;
class AliTPCTempHitInfo;
class AliTPCCurrentHit;
+class AliObjectArray;
-
-class AliTrackHitsInfo {
+class AliTrackHitsInfo {
+ friend class AliTPCTrackHits;
+ friend class AliTPC;
public:
AliTrackHitsInfo(){fgCounter1++;fgCounter2++;}
~AliTrackHitsInfo(){fgCounter1--;}
+ private:
Int_t fTrackID; //track ID
Int_t fVolumeID; //volume ID
UInt_t fHitParamIndex; //corresponding index
- static Int_t fgCounter1;
- static Int_t fgCounter2;
+ static Int_t fgCounter1; //counter
+ static Int_t fgCounter2; //counter
+
LClassDef(AliTrackHitsInfo,1)
};
class AliTrackHitsParam {
+ friend class AliTPCTrackHits;
+ friend struct AliTPCTempHitInfo;
public:
AliTrackHitsParam(){fgCounter1++;fgCounter2++;}
~AliTrackHitsParam(){fgCounter1--;}
+ private:
Float_t fR; //radius
Float_t fZ; //z position
Float_t fFi; //radial angle
Float_t fAd; //derivation of angle
Float_t fTheta; //theta angle
Float_t fThetaD; //theta angle derivation
- static Int_t fgCounter1;
- static Int_t fgCounter2;
+ static Int_t fgCounter1; //counter
+ static Int_t fgCounter2; //counter
+
LClassDef(AliTrackHitsParam,1)
};
class AliHitInfo {
+ friend class AliTPCTrackHits;
+ friend struct AliTPCTempHitInfo;
public:
AliHitInfo(){fgCounter1++;fgCounter2++;}
~AliHitInfo(){fgCounter1--;}
+ private:
Short_t fHitDistance; //distance to previous hit
Short_t fCharge; //deponed charge
- static Int_t fgCounter1;
- static Int_t fgCounter2;
+ static Int_t fgCounter1; //counter
+ static Int_t fgCounter2; //counter
+
LClassDef(AliHitInfo,1)
};
class AliTPCTrackHits : public TObject{
+ friend class AliTPC;
+ friend struct AliTPCTempHitInfo;
public:
AliTPCTrackHits();
~AliTPCTrackHits();
Bool_t First(); //set current hit to first hit
Bool_t Next(Int_t id = -1); //set current hit to next
- AliTPChit * GetHit();
+ AliTPChit * GetHit() const;
AliTrackHitsParam * GetParam();
AliHitInfo * GetHitInfo();
Int_t GetEntriesFast() { return fHitsPosAndQ ? fHitsPosAndQ->ArraySize():0;}
void SetStepPrecision(Double_t prec) {fStep=prec;}
void SetMaxDistance(UInt_t distance) {fMaxDistance = distance;}
Bool_t FlushHitStack(Bool_t force=kTRUE); //
-public:
+private:
void FlushHitStack2(Int_t index1, Int_t index2); //
AliObjectArray * fTrackHitsInfo; //quick information about track
AliObjectArray * fTrackHitsParam; //hit information
Double_t fPrecision; // required precision
Double_t fStep; //unit step size
UInt_t fMaxDistance; //maximal distance between two connected hits
+ AliTPCTrackHits(const AliTPCTrackHits& r);
AliTPCTempHitInfo * fTempInfo; //!information about track
AliTPCCurrentHit * fCurrentHit; //!information about current hit
static const Double_t fgkPrecision; //precision
static const Double_t fgkPrecision2; //precision
static Int_t fgCounter1;
static Int_t fgCounter2;
+
ClassDef(AliTPCTrackHits,1)
};