-//Simplified TParticle class
#include "AliHBTParticle.h"
+//___________________________________________________________
+/////////////////////////////////////////////////////////////
+//
+// class AliHBTParticle
+//
+// Ali HBT Particle: simplified class TParticle
+// Simplified in order to minimize the size of object
+// - we want to keep a lot of such a objects in memory
+// Additionaly adjusted for HBT Analysies purposes
+//
+/////////////////////////////////////////////////////////////
#include <TParticle.h>
#include <TClass.h>
+#include "AliHBTTrackPoints.h"
ClassImp(AliHBTParticle)
//______________________________________________________________________________
AliHBTParticle::AliHBTParticle():
fPdgIdx(0), fIdxInEvent(0),fNPids(0),fPids(0x0),fPidProb(0x0),
- fCalcMass(0),fPx(0), fPy(0),fPz(0),fE(0), fVx(0), fVy(0),fVz(0),fVt(0)
+ fCalcMass(0),fPx(0), fPy(0),fPz(0),fE(0), fVx(0), fVy(0),fVz(0),fVt(0),
+ fTrackPoints(0x0)
{//empty particle
}
//______________________________________________________________________________
fPdgIdx(0), fIdxInEvent(idx),fNPids(0),fPids(0x0),fPidProb(0x0),
fCalcMass(0),
fPx(px), fPy(py),fPz(pz),fE(etot),
- fVx(vx), fVy(vy),fVz(vz),fVt(time)
+ fVx(vx), fVy(vy),fVz(vz),fVt(time),
+ fTrackPoints(0x0)
{
//mormal constructor
SetPdgCode(pdg);
fPdgIdx(0), fIdxInEvent(idx),fNPids(0),fPids(0x0),fPidProb(0x0),
fCalcMass(0),
fPx(px), fPy(py),fPz(pz),fE(etot),
- fVx(vx), fVy(vy),fVz(vz),fVt(time)
+ fVx(vx), fVy(vy),fVz(vz),fVt(time),
+ fTrackPoints(0x0)
{
//mormal constructor
SetPdgCode(pdg,prob);
fPids[i] = in.fPids[i];
fPidProb[i] = in.fPidProb[i];
}
+
+ fTrackPoints = (in.fTrackPoints)?(AliHBTTrackPoints*)fTrackPoints->Clone():0x0;
+
}
//______________________________________________________________________________
fNPids(0),fPids(0x0),fPidProb(0x0),
fCalcMass(p.GetCalcMass()),
fPx(p.Px()),fPy(p.Py()),fPz(p.Pz()),fE(p.Energy()),
- fVx(p.Vx()),fVy(p.Vy()),fVz(p.Vz()),fVt(p.T())
+ fVx(p.Vx()),fVy(p.Vy()),fVz(p.Vz()),fVt(p.T()),
+ fTrackPoints(0x0)
{
//all copied in the initialization
SetPdgCode(p.GetPdgCode());
//dtor
delete [] fPids;
delete [] fPidProb;
+ delete fTrackPoints;
}
//______________________________________________________________________________
fVz = in.Vz();
fVt = in.T();
+ delete fTrackPoints;
+ fTrackPoints = (in.fTrackPoints)?(AliHBTTrackPoints*)fTrackPoints->Clone():0x0;
+
return *this;
}
//______________________________________________________________________________
#include "AliConst.h"
class TParticle;
-//class AliHBTTrackPoints;
+class AliHBTTrackPoints;
class AliHBTParticle : public TObject
{
const Char_t* GetName() const;
void Print() const;
-
+
+ void SetTrackPoints(AliHBTTrackPoints* tpts){fTrackPoints = tpts;}
+ AliHBTTrackPoints* GetTrackPoints() const {return fTrackPoints;}
+
static void SetDebug(Int_t dbg=1){fgDebug=dbg;}
static Int_t GetDebug(){return fgDebug;}
static Int_t fgDebug; //debug printout level
Double_t fVz; // z of production vertex
Double_t fVt; // t of production vertex
- ClassDef(AliHBTParticle,2) // TParticle vertex particle information
+ AliHBTTrackPoints* fTrackPoints; // track positions along trajectory - used by anti-merging cut
+ ClassDef(AliHBTParticle,3) // TParticle vertex particle information
};
#endif
void SetBlend(Bool_t flag = kTRUE){fBlend=flag;}
virtual Int_t GetNumberOfDirs() const {return (fDirs)?fDirs->GetEntries():0;}
void ReadEventsFromTo(Int_t first,Int_t last){fFirst = first; fLast = last;}
- TH1I* GetTrackCounter() const {return fTrackCounter;}
- void WriteTrackCounter() const;
+ virtual TH1I* GetTrackCounter() const {return fTrackCounter;}
+ virtual void WriteTrackCounter() const;
protected:
TObjArray* fCuts;//array with particle cuts
private:
public:
- ClassDef(AliHBTReader,3)//version 2 - TNamed as parental class
+ ClassDef(AliHBTReader,4)//version 2 - TNamed as parental class
//version 3 - Blending added
};
#include "AliHBTEvent.h"
#include "AliHBTParticle.h"
#include "AliHBTParticleCut.h"
+#include "AliHBTTrackPoints.h"
fTPCLoader(0x0),
fMagneticField(0.0),
fUseMagFFromRun(kTRUE),
+ fNTrackPoints(0),
+ fdR(0.0),
fNClustMin(0),
- fNClustMax(190),
+ fNClustMax(150),
fNChi2PerClustMin(0.0),
fNChi2PerClustMax(10e5),
+ fC00Min(0.0),
+ fC00Max(10e5),
+ fC11Min(0.0),
+ fC11Max(10e5),
+ fC22Min(0.0),
+ fC22Max(10e5),
+ fC33Min(0.0),
+ fC33Max(10e5),
fC44Min(0.0),
fC44Max(10e5)
{
- //constructor,
- //Defaults:
- // galicefilename = "" - this means: Do not open gAlice file -
- // just leave the global pointer untouched
+ //constructor
}
+/********************************************************************/
AliHBTReaderTPC::AliHBTReaderTPC(const Char_t* galicefilename):
fFileName(galicefilename),
fTPCLoader(0x0),
fMagneticField(0.0),
fUseMagFFromRun(kTRUE),
+ fNTrackPoints(0),
+ fdR(0.0),
fNClustMin(0),
- fNClustMax(190),
+ fNClustMax(150),
fNChi2PerClustMin(0.0),
fNChi2PerClustMax(10e5),
+ fC00Min(0.0),
+ fC00Max(10e5),
+ fC11Min(0.0),
+ fC11Max(10e5),
+ fC22Min(0.0),
+ fC22Max(10e5),
+ fC33Min(0.0),
+ fC33Max(10e5),
fC44Min(0.0),
fC44Max(10e5)
{
//constructor,
//Defaults:
- // galicefilename = "" - this means: Do not open gAlice file -
- // just leave the global pointer untouched
-
}
/********************************************************************/
+
AliHBTReaderTPC::AliHBTReaderTPC(TObjArray* dirs, const Char_t* galicefilename):
AliHBTReader(dirs),
fFileName(galicefilename),
fTPCLoader(0x0),
fMagneticField(0.0),
fUseMagFFromRun(kTRUE),
+ fNTrackPoints(0),
+ fdR(0.0),
fNClustMin(0),
- fNClustMax(190),
+ fNClustMax(150),
fNChi2PerClustMin(0.0),
fNChi2PerClustMax(10e5),
+ fC00Min(0.0),
+ fC00Max(10e5),
+ fC11Min(0.0),
+ fC11Max(10e5),
+ fC22Min(0.0),
+ fC22Max(10e5),
+ fC33Min(0.0),
+ fC33Max(10e5),
fC44Min(0.0),
fC44Max(10e5)
{
delete part;
continue;
}
+
+ if (fNTrackPoints > 0)
+ {
+ AliHBTTrackPoints* tpts = new AliHBTTrackPoints(fNTrackPoints,iotrack,fdR);
+ track->SetTrackPoints(tpts);
+ }
+
fParticlesEvent->AddParticle(part);
fTracksEvent->AddParticle(track);
}
//Performs check of the track
if ( (t->GetNumberOfClusters() > fNClustMax) || (t->GetNumberOfClusters() < fNClustMin) ) return kTRUE;
+ Float_t chisqpercl = t->GetChi2()/((Double_t)t->GetNumberOfClusters());
+ if ( (chisqpercl < fNChi2PerClustMin) || (chisqpercl > fNChi2PerClustMax) ) return kTRUE;
+
Double_t cc[15];
t->GetCovariance(cc);
- if ( (cc[9] < fC44Min) || (cc[9] > fC44Max) ) return kTRUE;
+
+ if ( (cc[0] < fC00Min) || (cc[0] > fC00Max) ) return kTRUE;
+ if ( (cc[2] < fC11Min) || (cc[2] > fC11Max) ) return kTRUE;
+ if ( (cc[5] < fC22Min) || (cc[5] > fC22Max) ) return kTRUE;
+ if ( (cc[9] < fC33Min) || (cc[9] > fC33Max) ) return kTRUE;
+ if ( (cc[14] < fC44Min) || (cc[14] > fC44Max) ) return kTRUE;
- Float_t chisqpercl = t->GetChi2()/((Double_t)t->GetNumberOfClusters());
- if ( (chisqpercl < fNChi2PerClustMin) || (chisqpercl > fNChi2PerClustMax) ) return kTRUE;
return kFALSE;
}
/********************************************************************/
+void AliHBTReaderTPC::SetC00Range(Float_t min, Float_t max)
+{
+ //Sets range of C00 parameter of covariance matrix of the track
+ //it defines uncertainty of the momentum
+ fC00Min = min;
+ fC00Max = max;
+}
+/********************************************************************/
+
+void AliHBTReaderTPC::SetC11Range(Float_t min, Float_t max)
+{
+ //Sets range of C11 parameter of covariance matrix of the track
+ //it defines uncertainty of the momentum
+ fC11Min = min;
+ fC11Max = max;
+}
+/********************************************************************/
+
+void AliHBTReaderTPC::SetC22Range(Float_t min, Float_t max)
+{
+ //Sets range of C22 parameter of covariance matrix of the track
+ //it defines uncertainty of the momentum
+ fC22Min = min;
+ fC22Max = max;
+}
+/********************************************************************/
+
+void AliHBTReaderTPC::SetC33Range(Float_t min, Float_t max)
+{
+ //Sets range of C33 parameter of covariance matrix of the track
+ //it defines uncertainty of the momentum
+ fC33Min = min;
+ fC33Max = max;
+}
+/********************************************************************/
+
void AliHBTReaderTPC::SetC44Range(Float_t min, Float_t max)
{
//Sets range of C44 parameter of covariance matrix of the track
void SetNClustersRange(Int_t min,Int_t max);
void SetChi2PerCluserRange(Float_t min, Float_t max);
+ void SetC00Range(Float_t min, Float_t max);
+ void SetC11Range(Float_t min, Float_t max);
+ void SetC22Range(Float_t min, Float_t max);
+ void SetC33Range(Float_t min, Float_t max);
void SetC44Range(Float_t min, Float_t max);
-
+ void SetNumberOfTrackPoints(Int_t n = 5,Float_t dr = 30.0) {fNTrackPoints = n; fdR = dr;}
+ Int_t GetNumberOfTrackPoints() const {return fNTrackPoints;}
protected:
//in the future this class is will read global tracking
Int_t ReadNext();
Bool_t fUseMagFFromRun;//flag indicating if using field specified in gAlice (kTRUE)
// or enforece other defined by fMagneticField
- Int_t fNClustMin;
- Int_t fNClustMax;
+ Int_t fNTrackPoints;//number of track points
+ Float_t fdR;//spacing between points (along radius) in cm
+
+ Int_t fNClustMin;//Number of clusters min value
+ Int_t fNClustMax;//Number of clusters max value
+
+ Float_t fNChi2PerClustMin;//Chi^2 per number of clusters min value
+ Float_t fNChi2PerClustMax;//Chi^2 per number of clusters max value
+
+ Float_t fC00Min;//C00 (0th diagonal element of covariance matrix) min value
+ Float_t fC00Max;//C00 (0th diagonal element of covariance matrix) max value
+
+ Float_t fC11Min;//C11 (1th diagonal element of covariance matrix) min value
+ Float_t fC11Max;//C11 (1th diagonal element of covariance matrix) max value
- Float_t fNChi2PerClustMin;
- Float_t fNChi2PerClustMax;
+ Float_t fC22Min;//C22 (2th diagonal element of covariance matrix) min value
+ Float_t fC22Max;//C22 (2th diagonal element of covariance matrix) max value
- Float_t fC44Min;
- Float_t fC44Max;
+ Float_t fC33Min;//C33 (3th diagonal element of covariance matrix) min value
+ Float_t fC33Max;//C33 (3th diagonal element of covariance matrix) max value
+ Float_t fC44Min;//C44 (4th diagonal element of covariance matrix) min value
+ Float_t fC44Max;//C44 (4th diagonal element of covariance matrix) max value
+
private:
Bool_t CheckTrack(AliTPCtrack* t);
--- /dev/null
+#include "AliHBTTrackPoints.h"
+#include "AliTPCtrack.h"
+#include <TMath.h>
+#include "AliTrackReference.h"
+#include <TClonesArray.h>
+
+ClassImp(AliHBTTrackPoints)
+
+AliHBTTrackPoints::AliHBTTrackPoints():
+ fN(0),
+ fX(0x0),
+ fY(0x0),
+ fZ(0x0)
+{
+ //constructor
+}
+
+AliHBTTrackPoints::AliHBTTrackPoints(Int_t n, AliTPCtrack* track, Float_t dr, Float_t r0):
+ fN(n),
+ fX(new Float_t[fN]),
+ fY(new Float_t[fN]),
+ fZ(new Float_t[fN])
+{
+ //constructor
+ //r0 starting radius
+ //dr - calculate points every dr cm, default every 30cm
+ if (track == 0x0)
+ {
+ Error("AliHBTTrackPoints","TPC track is null");
+ fN = 0;
+ delete [] fX;
+ delete [] fY;
+ delete [] fZ;
+ fX = fY = fZ = 0x0;
+ return;
+ }
+ track->PropagateTo(r0);
+
+ //* This formation is now fixed in the following way: *
+ //* external param0: local Y-coordinate of a track (cm) *
+ //* external param1: local Z-coordinate of a track (cm) *
+ //* external param2: local sine of the track momentum azimuth angle *
+ //* external param3: tangent of the track momentum dip angle *
+ //* external param4: 1/pt (1/(GeV/c)) *
+
+ Double_t xk;
+ Double_t par[5];
+ track->GetExternalParameters(xk,par); //get properties of the track
+
+ Double_t x = track->GetX();
+ Double_t y = track->GetY();
+ Double_t z0 = track->GetZ();
+
+ Double_t phi0local = TMath::ATan2(y,x);
+ Double_t phi0global = phi0local + track->GetAlpha();
+
+ if (phi0local<0) phi0local+=2*TMath::Pi();
+ if (phi0local>=2.*TMath::Pi()) phi0local-=2*TMath::Pi();
+
+ if (phi0global<0) phi0global+=2*TMath::Pi();
+ if (phi0global>=2.*TMath::Pi()) phi0global-=2*TMath::Pi();
+
+ Double_t r = TMath::Hypot(x,y);
+
+
+ if (GetDebug())
+ Info("AliHBTTrackPoints","Radius0 %f, Real Radius %f",r0,r);
+
+ if (GetDebug())
+ Info("AliHBTTrackPoints","Phi Global at first padraw %f, Phi locat %f",phi0global,phi0local);
+ Double_t c=track->GetC();
+ Double_t eta = track->GetEta();
+
+ //this calculattions are assuming new (current) model
+ Double_t tmp = c*x - eta;
+ tmp = 1. - tmp*tmp;
+ tmp = c*y + TMath::Sqrt(tmp);
+ Double_t dca=(TMath::Hypot(eta,tmp) - 1. )/TMath::Abs(c);
+
+ //Here is old model Cold=Cnew/2.
+ Double_t dcasq = dca*dca;
+ Double_t c2 = c/2.;
+ Double_t cst1 = (1.+c2*dca)*dca;//first constant
+ Double_t cst2 = 1. + 2.*c2*dca;//second constant
+
+ Double_t factorPhi0 = TMath::ASin((c2*r + cst1/r)/cst2);
+ Double_t factorZ0 = TMath::ASin(c2*TMath::Sqrt((r*r-dcasq)/cst2))*par[3]/c2;
+
+ for(Int_t i = 0; i<fN; i++)
+ {
+ Double_t rc = r0 + i*dr;
+ Double_t factorPhi = TMath::ASin( (c2*rc + cst1/rc)/cst2 );//factor phi od rc
+ Double_t phi = phi0global + factorPhi - factorPhi0;
+
+ Double_t factorZ = TMath::ASin(c2*TMath::Sqrt((rc*rc-dcasq)/cst2))*par[3]/c2;
+ fZ[i] = z0 + factorZ - factorZ0;
+ fX[i] = rc*TMath::Cos(phi);
+ fY[i] = rc*TMath::Sin(phi);
+
+ if ( GetDebug() )
+ {
+ Info("AliHBTTrackPoints","X %f Y %f Z %f R asked %f R obtained %f",
+ fX[i],fY[i],fZ[i],rc,TMath::Hypot(fX[i],fY[i]));
+ }
+ }
+}
+
+
+AliHBTTrackPoints::~AliHBTTrackPoints()
+{
+ //destructor
+ delete [] fX;
+ delete [] fY;
+ delete [] fZ;
+}
+
+void AliHBTTrackPoints::PositionAt(Int_t n, Float_t &x,Float_t &y,Float_t &z)
+{
+ //returns position at point n
+ if ((n<0) || (n>fN))
+ {
+ Error("PositionAt","Point %d out of range",n);
+ return;
+ }
+
+ x = fX[n];
+ y = fY[n];
+ z = fZ[n];
+ if ( GetDebug() )
+ {
+ Info("AliHBTTrackPoints","n %d; X %f; Y %f; Z %f",n,x,y,z);
+ }
+
+}
+
+
+Double_t AliHBTTrackPoints::AvarageDistance(const AliHBTTrackPoints& tr)
+{
+ //returns the aritmethic avarage distance between two tracks
+ if (fN != tr.fN)
+ {
+ Error("AvarageDistance","Number of points is not equal");
+ return -1;
+ }
+ if ( (fN <= 0) || (tr.fN <=0) )
+ {
+ Error("AvarageDistance","One of tracks is empty");
+ return -1;
+ }
+
+ Double_t sum;
+ for (Int_t i = 0; i<fN; i++)
+ {
+ if (fR[i] != tr.fR[i])
+ {
+ Error("AvarageDistance","Different radii");
+ return -1;
+ }
+ Double_t dx = fX-tr.fX;
+ Double_t dy = fY-tr.fY;
+ Double_t dz = fZ-tr.fZ;
+ sum+=TMath::Sqrt(dx*dx + dy*dy + dz*dz);
+ }
+ return sum/((Double_t)fN);
+}
+
+#include "AliRun.h"
+#include "AliRunLoader.h"
+#include "AliTPCtrack.h"
+#include "TTree.h"
+#include "TBranch.h"
+#include "TH2D.h"
+#include "TCanvas.h"
+#include "AliMagF.h"
+
+
+
+void AliHBTTrackPoints::tp(Int_t entr)
+{
+ delete gAlice;
+ gAlice = 0x0;
+ AliRunLoader* rl = AliRunLoader::Open();
+ AliLoader* l = rl->GetLoader("TPCLoader");
+ rl->LoadgAlice();
+ AliKalmanTrack::SetConvConst(100/0.299792458/0.2/rl->GetAliRun()->Field()->Factor());
+ l->LoadTracks();
+ AliTPCtrack* t = new AliTPCtrack();
+ TBranch* b=l->TreeT()->GetBranch("tracks");
+ b->SetAddress(&t);
+ l->TreeT()->GetEntry(entr);
+ Int_t N = 160;
+ AliHBTTrackPoints* tp = new AliHBTTrackPoints(N,t,1.);
+
+ TH2D* hxy = new TH2D("hxy","hxy",1000,150,250,1000,150,250);
+ TH2D* hxyt = new TH2D("hxyt","hxyt",1000,150,250,1000,150,250);
+ TH2D* hxyTR = new TH2D("hxyTR","hxyTR",1000,150,250,1000,150,250);
+
+ TH2D* hxz = new TH2D("hxz","hxz",1000,150,250,1000,151,251);
+ TH2D* hxzt = new TH2D("hxzt","hxzt",1000,150,250,1000,151,251);
+ TH2D* hxzTR = new TH2D("hxzTR","hxzTR",1000,150,250,1000,151,251);
+
+ hxyt->SetDirectory(0x0);
+ hxy->SetDirectory(0x0);
+ hxyTR->SetDirectory(0x0);
+
+ hxzt->SetDirectory(0x0);
+ hxz->SetDirectory(0x0);
+ hxzTR->SetDirectory(0x0);
+
+ Float_t x,y,z;
+
+ for (Int_t i = 0;i<N;i++)
+ {
+ Double_t r = 84.1+i;
+ tp->PositionAt(i,x,y,z);
+ hxy->Fill(x,y);
+ hxz->Fill(x,z);
+ printf("Rdemanded %f\n",r);
+ printf("tpx %f tpy %f tpz %f Rt =%f\n", x,y,z,TMath::Hypot(x,y));
+
+ //BUT they are local!!!!
+ t->PropagateTo(r);
+ Double_t phi = t->Phi();
+ Double_t rl = TMath::Hypot(t->GetX(),t->GetY());//real radius
+
+ Double_t alpha = t->GetAlpha();
+ Double_t salpha = TMath::Sin(alpha);
+ Double_t calpha = TMath::Cos(alpha);
+ x = t->GetX()*calpha - t->GetY()*salpha;
+ y = t->GetX()*salpha + t->GetY()*calpha;
+ z = t->GetZ();
+
+ printf("tx %f ty %f tz %f Rt = %f R from XY %f\n",x,y,z,TMath::Hypot(x,y),rl);
+
+ printf("tpz - tz %f\n",z-t->GetZ());
+ printf("\n");
+ hxyt->Fill(x,y);
+ hxzt->Fill(x,z);
+
+ }
+
+ rl->LoadTrackRefs();
+ TTree* treeTR = rl->TreeTR();
+ b = treeTR->GetBranch("TPC");
+
+ TClonesArray* trackrefs = new TClonesArray("AliTrackReference", 100);
+ AliTrackReference* tref;
+ b->SetAddress(&trackrefs);
+
+ Int_t tlab = TMath::Abs(t->GetLabel());
+
+ Int_t netr = treeTR->GetEntries();
+ printf("Found %d entries in TR tree\n",netr);
+
+ for (Int_t e = 0; e < netr; e++)
+ {
+ treeTR->GetEntry(e);
+ tref = (AliTrackReference*)trackrefs->At(0);
+ if (tref == 0x0) continue;
+ if (tref->GetTrack() != tlab) continue;
+
+ printf("Found %d entries in TR array\n",trackrefs->GetEntries());
+
+ for (Int_t i = 0; i < trackrefs->GetEntries(); i++)
+ {
+ tref = (AliTrackReference*)trackrefs->At(i);
+ if (tref->GetTrack() != tlab) continue;
+ x = tref->X();
+ y = tref->Y();
+ z = tref->Z();
+ printf("Track Ref: x %f y %f z %f\n",tref->X(),tref->Y(),tref->Z());
+
+ hxzTR->Fill(x,z);
+ hxyTR->Fill(x,y);
+ for (Int_t j = 1; j < 10; j++)
+ {
+ hxyTR->Fill(x, y+j*0.1);
+ hxyTR->Fill(x, y-j*0.1);
+ hxyTR->Fill(x+j*0.1,y);
+ hxyTR->Fill(x-j*0.1,y);
+
+ hxzTR->Fill(x,z-j*0.1);
+ hxzTR->Fill(x,z+j*0.1);
+ hxzTR->Fill(x-j*0.1,z);
+ hxzTR->Fill(x+j*0.1,z);
+ }
+ }
+ break;
+ }
+ hxz->Draw("");
+// hxzt->Draw("same");
+ hxzTR->Draw("same");
+
+ delete rl;
+}
--- /dev/null
+#ifndef ALIHBTTRACKPOINTS_H
+#define ALIHBTTRACKPOINTS_H
+
+#include <TObject.h>
+
+class AliTPCtrack;
+class AliESDtrack;
+
+class AliHBTTrackPoints: public TObject
+{
+ public:
+ AliHBTTrackPoints();
+ AliHBTTrackPoints(Int_t n, AliTPCtrack* track, Float_t dr=30,Float_t r0 = 84.1); //min TPC R = 84.1; max TPC R = 246.6cm,
+
+ virtual ~AliHBTTrackPoints();
+
+ Double_t AvarageDistance(const AliHBTTrackPoints& tr);
+ void PositionAt(Int_t n, Float_t &x, Float_t &y, Float_t &z);
+ Int_t GetDebug() const {return 10;}
+ static void tp(Int_t entr);
+ protected:
+ private:
+ Int_t fN;//number of points
+ Float_t* fX;//[fN]
+ Float_t* fY;//[fN]
+ Float_t* fZ;//[fN]
+ Float_t* fR;//! [fN] radii
+
+ ClassDef(AliHBTTrackPoints,1)
+};
+#endif
#pragma link C++ class AliHBTReaderKineTree+;
#pragma link C++ class AliHBTReaderInternal+;
+#pragma link C++ class AliHBTTrackPoints+;
+
#pragma link C++ class AliHBTQInvCorrelFctn+;
#pragma link C++ class AliHBTTwoKStarCorrelFctn+;
#pragma link C++ class AliHBTQOutCMSLCCorrelFctn+;
AliHBTLLWeights.cxx AliHBTWeightFctn.cxx \
AliHBTWeightsPID.cxx AliHBTWeightTheorFctn.cxx \
AliHBTPositionRandomizer.cxx AliHBTEventBuffer.cxx \
-AliHBTCorrFitFctn.cxx AliHBTCorrectCorrelFctn.cxx
-
+AliHBTCorrFitFctn.cxx AliHBTCorrectCorrelFctn.cxx \
+AliHBTTrackPoints.cxx
FSRCS = fsiini.F fsiw.F led_bldata.F ltran12.F
HDRS:= $(SRCS:.cxx=.h)
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff