Track points are moved according to vertex position so vertex is in (0,0,0)

[u/mrichter/AliRoot.git] / HBTAN / AliHBTTrackPoints.cxx

diff --git a/HBTAN/AliHBTTrackPoints.cxx b/HBTAN/AliHBTTrackPoints.cxx
index 82552b38a09864ca4c6f0612e5c8282506494928..b7795cdbfa68166cbe884d660a1611b68394325d 100644 (file)
--- a/HBTAN/AliHBTTrackPoints.cxx
+++ b/HBTAN/AliHBTTrackPoints.cxx
@@ -12,13 +12,15 @@
 // different events (that are use to fill deniminators)   //
 //                                                        //
 ////////////////////////////////////////////////////////////
-#include "AliTrackReference.h"
-
-#include "AliTPCtrack.h"
-#include "AliESDtrack.h"
 
-#include <TMath.h>
 #include <TClonesArray.h>
+#include <TFile.h>
+#include <TMath.h>
+
+#include "AliESDtrack.h"
+#include "AliTPCtrack.h"
+#include "AliTrackReference.h"
+#include "AliITStrackV2.h"
 
 ClassImp(AliHBTTrackPoints)
 
@@ -33,6 +35,32 @@ AliHBTTrackPoints::AliHBTTrackPoints():
 }
 /***************************************************************/
 
+AliHBTTrackPoints::AliHBTTrackPoints(AliHBTTrackPoints::ETypes type, AliESDtrack* track):
+ fN(0),
+ fX(0x0),
+ fY(0x0),
+ fZ(0x0)
+{
+  //constructor
+  switch (type)
+   {
+     case kITS:
+       //Up to now we keep only point in pixels
+       //Used only in non-id analysis
+       fN = 1;
+       fX = new Float_t[fN];
+       fY = new Float_t[fN];
+       fZ = new Float_t[fN];
+       MakeITSPoints(track);
+       break;
+
+     default:
+       Info("AliHBTTrackPoints","Not recognized type");
+   }
+   
+}
+/***************************************************************/
+
 AliHBTTrackPoints::AliHBTTrackPoints(Int_t n, AliESDtrack* track, Float_t mf, Float_t dr, Float_t r0):
  fN(n),
  fX(new Float_t[fN]),
@@ -54,12 +82,28 @@ AliHBTTrackPoints::AliHBTTrackPoints(Int_t n, AliESDtrack* track, Float_t mf, Fl
      return;
    }
 
+  if ( ((track->GetStatus() & AliESDtrack::kTPCrefit) == kFALSE)&& 
+       ((track->GetStatus() & AliESDtrack::kTPCin) == kFALSE)  )
+   {
+     //could happend: its stand alone tracking
+     if (GetDebug() > 3) 
+       Warning("AliHBTTrackPoints","This ESD track does not contain TPC information");
+       
+     fN = 0;
+     delete [] fX;
+     delete [] fY;
+     delete [] fZ;
+     fX = fY = fZ = 0x0;
+     
+     return;
+   }
+  
   Double_t x;
   Double_t par[5];
   track->GetInnerExternalParameters(x,par);     //get properties of the track
-  if (x == 0)
+  if (par[4] == 0)
    {
-     Error("AliHBTTrackPoints","This ESD track does not contain TPC information");
+     Error("AliHBTTrackPoints","This ESD track seem not to contain TPC information (curv is 0)");
      return;
    }
 
@@ -114,6 +158,16 @@ AliHBTTrackPoints::AliHBTTrackPoints(Int_t n, AliTPCtrack* track, Float_t dr, Fl
   Double_t c=track->GetC();
   MakePoints(dr,r0,x,par,c,alpha);
 }  
+/***************************************************************/
+
+AliHBTTrackPoints::~AliHBTTrackPoints()
+{
+  //destructor
+  delete [] fX;
+  delete [] fY;
+  delete [] fZ;
+}
+/***************************************************************/
 
 void AliHBTTrackPoints::MakePoints( Float_t dr, Float_t r0, Double_t x, Double_t* par, Double_t c, Double_t alpha)
 {
@@ -169,12 +223,14 @@ void AliHBTTrackPoints::MakePoints( Float_t dr, Float_t r0, Double_t x, Double_t
      Double_t ftmp = (c2*rc + cst1/rc)/cst2;
      if (ftmp > 1.0) 
       {
-        Warning("AliHBTTrackPoints","ASin argument > 1 %f:",ftmp);
+        if (GetDebug() > 1) 
+          Warning("AliHBTTrackPoints","ASin argument > 1 %f:",ftmp);
         ftmp=1.0;
       }
      else if (ftmp < -1.0) 
       {
-        Warning("AliHBTTrackPoints","ASin argument < -1 %f:",ftmp);
+        if (GetDebug() > 1) 
+          Warning("AliHBTTrackPoints","ASin argument < -1 %f:",ftmp);
         ftmp=-1.0;
       }
       
@@ -184,19 +240,22 @@ void AliHBTTrackPoints::MakePoints( Float_t dr, Float_t r0, Double_t x, Double_t
      ftmp = (rc*rc-dcasq)/cst2;
      if (ftmp < 0.0) 
       {
-        Warning("AliHBTTrackPoints","Sqrt argument < 0: %f",ftmp);
-        ftmp=1.0;
+        if (GetDebug() > 1) 
+          Warning("AliHBTTrackPoints","Sqrt argument < 0: %f",ftmp);
+        ftmp=0.0;
       }
      
      ftmp = c2*TMath::Sqrt(ftmp);
      if (ftmp > 1.0) 
       {
-        Warning("AliHBTTrackPoints","ASin argument > 1: %f",ftmp);
+        if (GetDebug() > 1) 
+          Warning("AliHBTTrackPoints","ASin argument > 1: %f",ftmp);
         ftmp=1.0;
       }
      else if (ftmp < -1.0) 
       {
-        Warning("AliHBTTrackPoints","ASin argument < -1: %f",ftmp);
+        if (GetDebug() > 1) 
+          Warning("AliHBTTrackPoints","ASin argument < -1: %f",ftmp);
         ftmp=-1.0;
       }
      Double_t factorZ = TMath::ASin(ftmp)*par[3]/c2;
@@ -213,15 +272,23 @@ void AliHBTTrackPoints::MakePoints( Float_t dr, Float_t r0, Double_t x, Double_t
 }
 /***************************************************************/
 
-AliHBTTrackPoints::~AliHBTTrackPoints()
+void AliHBTTrackPoints::MakeITSPoints(AliESDtrack* track)
 {
-  //destructor
-  delete [] fX;
-  delete [] fY;
-  delete [] fZ;
+//Calculates points in ITS
+// z=R*Pz/Pt
+ AliITStrackV2 itstrack(*track,kTRUE);
+ Double_t x,y,z;
+ itstrack.GetGlobalXYZat(4.0,x,y,z);
+ fX[0] = x;
+ fY[0] = y;
+ fZ[0] = z;
+ 
+//  Info("MakeITSPoints","X %f Y %f Z %f R asked %f R obtained %f",
+//             fX[0],fY[0],fZ[0],4.0,TMath::Hypot(fX[0],fY[0]));
+ 
 }
-/***************************************************************/
 
+/***************************************************************/
 void AliHBTTrackPoints::PositionAt(Int_t n, Float_t &x,Float_t &y,Float_t &z)
 {
   //returns position at point n
@@ -241,17 +308,31 @@ void AliHBTTrackPoints::PositionAt(Int_t n, Float_t &x,Float_t &y,Float_t &z)
 }
 /***************************************************************/
 
+void AliHBTTrackPoints::Move(Float_t x, Float_t y, Float_t z)
+{
+//Moves all points about vector
+ for (Int_t i = 0; i<fN; i++)
+   {
+     fX[i]+=x;
+     fY[i]+=y;
+     fZ[i]+=z;
+   }   
+}
+/***************************************************************/
+
 Double_t AliHBTTrackPoints::AvarageDistance(const AliHBTTrackPoints& tr)
 {
   //returns the aritmethic avarage distance between two tracks
-  if (fN != tr.fN)
+//  Info("AvarageDistance","Entered");
+  if ( (fN <= 0) || (tr.fN <=0) )
    {
-     Error("AvarageDistance","Number of points is not equal");
+     if (GetDebug()) Warning("AvarageDistance","One of tracks is empty");
      return -1;
    }
-  if ( (fN <= 0) || (tr.fN <=0) )
+
+  if (fN != tr.fN)
    {
-     Error("AvarageDistance","One of tracks is empty");
+     Warning("AvarageDistance","Number of points is not equal");
      return -1;
    }
    
@@ -273,7 +354,7 @@ Double_t AliHBTTrackPoints::AvarageDistance(const AliHBTTrackPoints& tr)
      Double_t dz = fZ[i]-tr.fZ[i];
      sum+=TMath::Sqrt(dx*dx + dy*dy + dz*dz);
      
-     if (GetDebug()>0)
+     if (GetDebug()>1)
       {
        Info("AvarageDistance","Diff: x ,y z: %f , %f, %f",dx,dy,dz);
        Info("AvarageDistance","xxyyzz %f %f %f %f %f %f",
@@ -561,3 +642,4 @@ void AliHBTTrackPoints::testtpc(Int_t entr)
   
   delete rl;
 }
+