Track Points Added. Class needed for Anti-Merging cut
authorskowron <skowron@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 9 Jan 2004 10:33:55 +0000 (10:33 +0000)
committerskowron <skowron@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 9 Jan 2004 10:33:55 +0000 (10:33 +0000)
HBTAN/AliHBTParticle.cxx
HBTAN/AliHBTParticle.h
HBTAN/AliHBTReader.h
HBTAN/AliHBTReaderTPC.cxx
HBTAN/AliHBTReaderTPC.h
HBTAN/AliHBTTrackPoints.cxx [new file with mode: 0644]
HBTAN/AliHBTTrackPoints.h [new file with mode: 0644]
HBTAN/HBTAnalysisLinkDef.h
HBTAN/libHBTAN.pkg

index babbee6a1e4cfae948172ac395683ed8510acc40..bc8380d69f0f2f4bb533ef2431d6dde455387023 100644 (file)
@@ -1,7 +1,18 @@
-//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)
 
@@ -9,7 +20,8 @@ Int_t AliHBTParticle::fgDebug = 0;
 //______________________________________________________________________________
 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
 }
 //______________________________________________________________________________
@@ -20,7 +32,8 @@ AliHBTParticle::AliHBTParticle(Int_t pdg, Int_t idx,
   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);
@@ -40,7 +53,8 @@ AliHBTParticle::AliHBTParticle(Int_t pdg, Float_t prob, Int_t idx,
   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);
@@ -67,6 +81,9 @@ AliHBTParticle::AliHBTParticle(const AliHBTParticle& in):
     fPids[i] =  in.fPids[i];
     fPidProb[i] = in.fPidProb[i];
   }
+  
+ fTrackPoints = (in.fTrackPoints)?(AliHBTTrackPoints*)fTrackPoints->Clone():0x0;
+  
 }
 
 //______________________________________________________________________________
@@ -75,7 +92,8 @@ AliHBTParticle::AliHBTParticle(const TParticle &p,Int_t idx):
    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());
@@ -87,6 +105,7 @@ AliHBTParticle::~AliHBTParticle()
 //dtor  
   delete [] fPids;
   delete [] fPidProb;
+  delete fTrackPoints;
 }
 //______________________________________________________________________________
 
@@ -117,6 +136,9 @@ AliHBTParticle& AliHBTParticle::operator=(const AliHBTParticle& in)
   fVz = in.Vz();
   fVt = in.T();
   
+  delete fTrackPoints;
+  fTrackPoints = (in.fTrackPoints)?(AliHBTTrackPoints*)fTrackPoints->Clone():0x0;
+  
   return *this;
 }
 //______________________________________________________________________________
index 72a55f713f578fec29ed815ce1b4b942832ba59a..9904aca2d041e65960298c9f3d2363b5e01aad32 100644 (file)
@@ -20,7 +20,7 @@
 #include "AliConst.h"
 
 class TParticle;
-//class AliHBTTrackPoints;
+class AliHBTTrackPoints;
 
 class AliHBTParticle : public TObject
 {
@@ -112,7 +112,10 @@ public:
   
   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
@@ -139,7 +142,8 @@ private:
   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
index 76796f1a8d330608512dc959e958d370b28d20c4..850544f0684da65af96082950cd4c7aade6ce2c0 100644 (file)
@@ -46,8 +46,8 @@ class AliHBTReader: public TNamed
     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
@@ -84,7 +84,7 @@ class AliHBTReader: public TNamed
   private:
   
   public:
-    ClassDef(AliHBTReader,3)//version 2 - TNamed as parental class
+    ClassDef(AliHBTReader,4)//version 2 - TNamed as parental class
                             //version 3 - Blending added
 };
 
index 1cab431c8481ac6ad97d9551fcc79973e7fe73e8..8a643511b09b3ee6fe3a919b24956c06c817ae8b 100644 (file)
@@ -30,6 +30,7 @@
 #include "AliHBTEvent.h"
 #include "AliHBTParticle.h"
 #include "AliHBTParticleCut.h"
+#include "AliHBTTrackPoints.h"
 
 
 
@@ -41,19 +42,27 @@ AliHBTReaderTPC::AliHBTReaderTPC():
  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),
@@ -61,20 +70,28 @@ AliHBTReaderTPC::AliHBTReaderTPC(const Char_t* 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),
@@ -82,10 +99,20 @@ AliHBTReaderTPC::AliHBTReaderTPC(TObjArray* dirs, const Char_t* 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)
 {
@@ -252,6 +279,13 @@ Int_t AliHBTReaderTPC::ReadNext()
           delete part;
           continue;
         }
+        
+       if (fNTrackPoints > 0) 
+        {
+          AliHBTTrackPoints* tpts = new AliHBTTrackPoints(fNTrackPoints,iotrack,fdR);
+          track->SetTrackPoints(tpts);
+        }
+        
        fParticlesEvent->AddParticle(part);
        fTracksEvent->AddParticle(track);
       }
@@ -373,12 +407,18 @@ Bool_t AliHBTReaderTPC::CheckTrack(AliTPCtrack* t)
   //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;
   
@@ -401,6 +441,42 @@ void AliHBTReaderTPC::SetChi2PerCluserRange(Float_t min, Float_t max)
 }
 /********************************************************************/
 
+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
index b29555fbcf3ea7c7ca456700b9918caac2a1ba6f..e61c3adf1c318a7fe41ff053a31481d8a0b078e3 100644 (file)
@@ -36,8 +36,13 @@ class AliHBTReaderTPC: public AliHBTReader
     
     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();
@@ -51,15 +56,30 @@ class AliHBTReaderTPC: public AliHBTReader
     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);
diff --git a/HBTAN/AliHBTTrackPoints.cxx b/HBTAN/AliHBTTrackPoints.cxx
new file mode 100644 (file)
index 0000000..d3f6455
--- /dev/null
@@ -0,0 +1,295 @@
+#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;
+}
diff --git a/HBTAN/AliHBTTrackPoints.h b/HBTAN/AliHBTTrackPoints.h
new file mode 100644 (file)
index 0000000..798d742
--- /dev/null
@@ -0,0 +1,31 @@
+#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
index 4a66fc127113a4c123c597286add1a872e064b3d..b2f01887b9ac3fbcb79f4fd3eaf595e411a655f1 100644 (file)
@@ -75,6 +75,8 @@
 #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+;
index 5004fe1117812644197e5ea898b37608e4396249..b5c394014b50d5f69e6339492e5393491b4eab16 100644 (file)
@@ -13,8 +13,8 @@ AliHBTMonDistributionFctns.cxx  AliHBTMonResolutionFctns.cxx \
 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)