Extracting PHOS and EMCAL trackers from the correspondig reconstructors (Yu.Belikov)
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 18 Oct 2004 12:40:44 +0000 (12:40 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 18 Oct 2004 12:40:44 +0000 (12:40 +0000)
17 files changed:
EMCAL/AliEMCALReconstructor.cxx
EMCAL/AliEMCALReconstructor.h
EMCAL/AliEMCALTracker.cxx [new file with mode: 0644]
EMCAL/AliEMCALTracker.h [new file with mode: 0644]
EMCAL/EMCALLinkDef.h
EMCAL/libEMCAL.pkg
PHOS/AliPHOSReconstructor.cxx
PHOS/AliPHOSReconstructor.h
PHOS/AliPHOSTrackSegmentMakerv1.cxx
PHOS/AliPHOSTracker.cxx [new file with mode: 0644]
PHOS/AliPHOSTracker.h [new file with mode: 0644]
PHOS/PHOSLinkDef.h
PHOS/libPHOS.pkg
STEER/AliESDtrack.cxx
STEER/AliESDtrack.h
STEER/AliReconstruction.cxx
STEER/AliReconstruction.h

index d5caade..204a0dc 100644 (file)
@@ -31,6 +31,7 @@
 #include "AliEMCALClusterizerv1.h"
 #include "AliEMCALPIDv1.h"
 #include "AliEMCALGetter.h"
+#include "AliEMCALTracker.h"
 #include "AliRawReaderFile.h"
 
 ClassImp(AliEMCALReconstructor)
@@ -99,19 +100,6 @@ void AliEMCALReconstructor::FillESD(AliRunLoader* runLoader, AliESD* esd) const
   
   Int_t eventNumber = runLoader->GetEventNumber() ;
 
-  TString headerFile(runLoader->GetFileName()) ; 
-  TString branchName(runLoader->GetEventFolder()->GetName()) ;  
-
-  AliEMCALPIDv1 pid(headerFile, branchName);
-
-
-  // do current event; the loop over events is done by AliReconstruction::Run()
-  pid.SetEventRange(eventNumber, eventNumber) ; 
-  if ( Debug() ) 
-    pid.ExecuteTask("deb all") ;
-  else 
-    pid.ExecuteTask("") ;
   // Creates AliESDtrack from AliEMCALRecParticles 
   AliEMCALGetter::Instance()->Event(eventNumber, "P") ; 
   TClonesArray *recParticles = AliEMCALGetter::Instance()->RecParticles();
@@ -135,3 +123,10 @@ void AliEMCALReconstructor::FillESD(AliRunLoader* runLoader, AliESD* esd) const
     delete et;
   }
 }
+
+AliTracker* AliEMCALReconstructor::CreateTracker(AliRunLoader* runLoader) const
+{
+// creates the EMCAL tracker
+  if (!runLoader) return NULL; 
+  return new AliEMCALTracker(runLoader);
+}
index fad0518..dbe71eb 100644 (file)
@@ -40,7 +40,8 @@ public:
   virtual ~AliEMCALReconstructor() ; //dtor
 
   Bool_t                     Debug() const { return fDebug ; }
-  virtual void               FillESD(AliRunLoader* runLoader, AliESD* esd) const ;
+  AliTracker *CreateTracker(AliRunLoader* runLoader) const;  
+  virtual void FillESD(AliRunLoader* runLoader, AliESD* esd) const ;
   virtual void               Reconstruct(AliRunLoader* runLoader) const ;
   virtual void               Reconstruct(AliRunLoader* runLoader, AliRawReaderFile * rawreader) const ;
   
diff --git a/EMCAL/AliEMCALTracker.cxx b/EMCAL/AliEMCALTracker.cxx
new file mode 100644 (file)
index 0000000..afd476f
--- /dev/null
@@ -0,0 +1,37 @@
+#include "AliEMCALTracker.h"
+#include "AliEMCALPIDv1.h"
+#include "AliRunLoader.h"
+#include "AliESD.h"
+
+//-------------------------------------------------------------------------
+//                          EMCAL tracker.
+// Matches ESD tracks with the EMCAL and makes the PID.  
+// Currently, has only one function implemented : PropagateBack(AliESD*)
+//-------------------------------------------------------------------------
+
+ClassImp(AliEMCALTracker)
+
+Bool_t AliEMCALTracker::fgDebug = kFALSE ; 
+
+Int_t AliEMCALTracker::PropagateBack(AliESD *esd) {
+  // Makes the Particle Identification
+
+  esd=0; // This is to avoid a compilation warning. 
+         // This pointer is reserved for future needs
+
+  Int_t eventNumber = fRunLoader->GetEventNumber() ;
+
+  TString headerFile(fRunLoader->GetFileName()) ; 
+  TString branchName(fRunLoader->GetEventFolder()->GetName()) ;  
+
+  AliEMCALPIDv1 pid(headerFile, branchName);
+
+  // do current event; the loop over events is done by AliReconstruction::Run()
+  pid.SetEventRange(eventNumber, eventNumber) ; 
+  if ( Debug() ) 
+    pid.ExecuteTask("deb all") ;
+  else 
+    pid.ExecuteTask("") ;
+  return 0;
+}
diff --git a/EMCAL/AliEMCALTracker.h b/EMCAL/AliEMCALTracker.h
new file mode 100644 (file)
index 0000000..d53cb7b
--- /dev/null
@@ -0,0 +1,42 @@
+#ifndef AliEMCALTracker_h
+#define AliEMCALTracker_h
+
+//-------------------------------------------------------------------------
+//                          EMCAL tracker.
+// Matches ESD tracks with the EMCAL and makes the PID.  
+// Currently, has only one function implemented : PropagateBack(AliESD*).
+//-------------------------------------------------------------------------
+
+#include <AliTracker.h>
+#include <AliLog.h>
+
+class AliCluster;
+class AliESD;
+class TTree;
+class AliRunLoader;
+
+class AliEMCALTracker : public AliTracker
+{
+public:
+  AliEMCALTracker():AliTracker()   {fRunLoader=0;}
+  AliEMCALTracker(AliRunLoader *loader):AliTracker() {fRunLoader=loader;}
+  virtual ~AliEMCALTracker()       {AliDebug(1,"Start.");}
+
+  Int_t Clusters2Tracks(AliESD *) {AliDebug(1,"Start.");return 0;}
+  Int_t RefitInward(AliESD *)     {AliDebug(1,"Start.");return 0;}
+  void UnloadClusters()           {AliDebug(1,"Start.");}
+  AliCluster *GetCluster(Int_t ) const {AliDebug(1,"Start.");return 0;}
+  Int_t PropagateBack(AliESD *);
+  Int_t LoadClusters(TTree *) {AliDebug(1,"Start.");return 0;}
+
+  static void                SetDebug()   { fgDebug = kTRUE ; }
+  static void                ResetDebug() { fgDebug = kFALSE ; }
+  static Bool_t              Debug() { return fgDebug ; }
+
+private:
+  static Bool_t fgDebug ;    //! Verbosity controller
+  AliRunLoader *fRunLoader;  //! Pointer to the run loader
+  ClassDef(AliEMCALTracker,0)
+};
+
+#endif
index f303783..14aa33f 100644 (file)
@@ -49,6 +49,7 @@
 #pragma link C++ class AliEMCALFastRecParticle+;               
 #pragma link C++ class AliEMCALPID+;           
 #pragma link C++ class AliEMCALPIDv1+;
+#pragma link C++ class AliEMCALTracker+;
 #pragma link C++ class AliEMCALLoader+;        
 #pragma link C++ class AliEMCALReconstructor+;
 #pragma link C++ class AliEMCALRawStream+;
index 2464e3d..a2022e4 100644 (file)
@@ -38,6 +38,7 @@ AliEMCALRecParticle.cxx \
 AliEMCALFastRecParticle.cxx \
 AliEMCALPID.cxx \
 AliEMCALPIDv1.cxx \
+AliEMCALTracker.cxx \
 AliEMCALLoader.cxx \
 AliEMCALReconstructor.cxx \
 AliEMCALRawStream.cxx
index 69c4d62..1ceef1a 100644 (file)
@@ -32,6 +32,7 @@
 #include "AliPHOSTrackSegmentMakerv1.h"
 #include "AliPHOSPIDv1.h"
 #include "AliPHOSGetter.h"
+#include "AliPHOSTracker.h"
 #include "AliRawReaderFile.h"
 
  
@@ -98,31 +99,12 @@ void AliPHOSReconstructor::Reconstruct(AliRunLoader* runLoader, AliRawReaderFile
 //____________________________________________________________________________
 void AliPHOSReconstructor::FillESD(AliRunLoader* runLoader, AliESD* esd) const
 {
-  // Called by AliReconstruct after Reconstruct() and global tracking and vertxing 
-  //Creates the tracksegments and Recparticles
-  
-  Int_t eventNumber = runLoader->GetEventNumber() ;
+  // This function creates AliESDtracks from AliPHOSRecParticles
+  //         and
+  // writes them to the ESD
 
-  TString headerFile(runLoader->GetFileName()) ; 
-  TString branchName(runLoader->GetEventFolder()->GetName()) ;  
-
-  AliPHOSTrackSegmentMakerv1 tsm(headerFile, branchName);
-  tsm.SetESD(esd) ; 
-  AliPHOSPIDv1 pid(headerFile, branchName);
+  Int_t eventNumber = runLoader->GetEventNumber() ;
 
-  // do current event; the loop over events is done by AliReconstruction::Run()
-  tsm.SetEventRange(eventNumber, eventNumber) ; 
-  pid.SetEventRange(eventNumber, eventNumber) ; 
-  if ( Debug() ) {
-   tsm.ExecuteTask("deb all") ;
-   pid.ExecuteTask("deb all") ;
-  }
-  else {
-    tsm.ExecuteTask("") ;
-    pid.ExecuteTask("") ;
-  }
-  
-  // Creates AliESDtrack from AliPHOSRecParticles 
   AliPHOSGetter::Instance()->Event(eventNumber, "P") ; 
   TClonesArray *recParticles = AliPHOSGetter::Instance()->RecParticles();
   Int_t nOfRecParticles = recParticles->GetEntries();
@@ -146,3 +128,11 @@ void AliPHOSReconstructor::FillESD(AliRunLoader* runLoader, AliESD* esd) const
     delete et;
   }
 }
+
+AliTracker* AliPHOSReconstructor::CreateTracker(AliRunLoader* runLoader) const
+{
+// creates the PHOS tracker
+  if (!runLoader) return NULL; 
+  return new AliPHOSTracker(runLoader);
+}
+
index 5026de0..3576424 100644 (file)
@@ -42,6 +42,7 @@ public:
   static void                SetDebug()   { fgDebug = kTRUE ; }
   static void                ResetDebug() { fgDebug = kFALSE ; }
   static Bool_t              Debug() { return fgDebug ; }
+  AliTracker *CreateTracker(AliRunLoader* runLoader) const;
   virtual void               FillESD(AliRunLoader* runLoader, AliESD* esd) const ;
   virtual void               Reconstruct(AliRunLoader* runLoader) const ;
   virtual void               Reconstruct(AliRunLoader* runLoader, AliRawReaderFile * rawreader) const ;
index 4eec910..c382bb5 100644 (file)
@@ -156,15 +156,18 @@ Float_t  AliPHOSTrackSegmentMakerv1::GetDistanceInPHOSPlane(AliPHOSEmcRecPoint *
       Int_t iClosestTrack = -1;
       Double_t minDistance = 1e6;
       Double_t pxyz[3], xyz[3];
+      Double_t rPHOS=460.;
       AliESDtrack *track;
       for (Int_t iTrack=0; iTrack<nTracks; iTrack++) {
        track = fESD->GetTrack(iTrack);
        if (track->IsPHOS()) 
          continue ; 
-       track->GetOuterXYZPHOS(xyz);     // track coord on the cylinder of PHOS radius
+       if (!track->GetXYZAt(rPHOS,xyz))
+           continue; //track coord on the cylinder of PHOS radius
        if ((TMath::Abs(xyz[0])+TMath::Abs(xyz[1])+TMath::Abs(xyz[2]))<=0)
-         continue;
-       track->GetOuterPxPyPzPHOS(pxyz); // track momentum ibid.
+          continue;
+       if (!track->GetPxPyPzAt(rPHOS,pxyz))
+           continue; // track momentum ibid.
        vecDist = PropagateToPlane(xyz,pxyz,"CPV",cpvClu->GetPHOSMod());
        //      Info("GetDistanceInPHOSPlane","Track %d propagation to CPV = (%f,%f,%f)",
        //     iTrack,vecDist.X(),vecDist.Y(),vecDist.Z());
@@ -179,7 +182,7 @@ Float_t  AliPHOSTrackSegmentMakerv1::GetDistanceInPHOSPlane(AliPHOSEmcRecPoint *
 
       if (iClosestTrack != -1) {
        track = fESD->GetTrack(iClosestTrack);
-       track->GetOuterPxPyPzPHOS(pxyz); // track momentum ibid.
+       if (track->GetPxPyPzAt(rPHOS,pxyz)) { // track momentum ibid.
        TVector3 vecCpvGlobal; // Global position of the CPV recpoint
        AliPHOSGetter * gime = AliPHOSGetter::Instance() ; 
        const AliPHOSGeometry * geom = gime->PHOSGeometry() ; 
@@ -191,6 +194,7 @@ Float_t  AliPHOSTrackSegmentMakerv1::GetDistanceInPHOSPlane(AliPHOSEmcRecPoint *
 //          iClosestTrack,vecDist.X(),vecDist.Y(),vecDist.Z());
        vecDist -= vecEmc;
        distance2Track = TMath::Sqrt(vecDist.X()*vecDist.X() + vecDist.Z()*vecDist.Z());
+       }
       }
 //     } else {
 //       // If no ESD exists, than simply find EMC-CPV distance
diff --git a/PHOS/AliPHOSTracker.cxx b/PHOS/AliPHOSTracker.cxx
new file mode 100644 (file)
index 0000000..3b3bf36
--- /dev/null
@@ -0,0 +1,44 @@
+#include "AliPHOSTracker.h"
+#include "AliPHOSTrackSegmentMakerv1.h"
+#include "AliPHOSPIDv1.h"
+#include "AliRunLoader.h"
+#include "AliESD.h"
+
+//-------------------------------------------------------------------------
+//                          PHOS tracker.
+// Matches ESD tracks with the PHOS and makes the PID.  
+// Currently, has only one function implemented : PropagateBack(AliESD*)
+//-------------------------------------------------------------------------
+
+ClassImp(AliPHOSTracker)
+
+Bool_t AliPHOSTracker::fgDebug = kFALSE ; 
+
+Int_t AliPHOSTracker::PropagateBack(AliESD *esd) {
+  // Called by AliReconstruction 
+  // Creates the tracksegments and Recparticles
+  // Makes the PID
+  
+  Int_t eventNumber = fRunLoader->GetEventNumber() ;
+
+  TString headerFile(fRunLoader->GetFileName()) ; 
+  TString branchName(fRunLoader->GetEventFolder()->GetName()) ;  
+
+  AliPHOSTrackSegmentMakerv1 tsm(headerFile, branchName);
+  tsm.SetESD(esd) ; 
+  AliPHOSPIDv1 pid(headerFile, branchName);
+
+  // do current event; the loop over events is done by AliReconstruction::Run()
+  tsm.SetEventRange(eventNumber, eventNumber) ; 
+  pid.SetEventRange(eventNumber, eventNumber) ; 
+  if ( Debug() ) {
+   tsm.ExecuteTask("deb all") ;
+   pid.ExecuteTask("deb all") ;
+  }
+  else {
+    tsm.ExecuteTask("") ;
+    pid.ExecuteTask("") ;
+  }
+  
+  return 0;
+}
diff --git a/PHOS/AliPHOSTracker.h b/PHOS/AliPHOSTracker.h
new file mode 100644 (file)
index 0000000..a1ab184
--- /dev/null
@@ -0,0 +1,42 @@
+#ifndef AliPHOSTracker_h
+#define AliPHOSTracker_h
+
+//-------------------------------------------------------------------------
+//                          PHOS tracker.
+// Matches ESD tracks with the PHOS and makes the PID.  
+// Currently, has only one function implemented : PropagateBack(AliESD*).
+//-------------------------------------------------------------------------
+
+#include <AliTracker.h>
+#include <AliLog.h>
+
+class AliCluster;
+class AliESD;
+class TTree;
+class AliRunLoader;
+
+class AliPHOSTracker : public AliTracker
+{
+public:
+  AliPHOSTracker():AliTracker()   {fRunLoader=0;}
+  AliPHOSTracker(AliRunLoader *loader):AliTracker() {fRunLoader=loader;}
+  virtual ~AliPHOSTracker()       {AliDebug(1,"Start.");}
+
+  Int_t Clusters2Tracks(AliESD *) {AliDebug(1,"Start.");return 0;}
+  Int_t RefitInward(AliESD *)     {AliDebug(1,"Start.");return 0;}
+  void UnloadClusters()           {AliDebug(1,"Start.");}
+  AliCluster *GetCluster(Int_t ) const {AliDebug(1,"Start.");return 0;}
+  Int_t PropagateBack(AliESD *);
+  Int_t LoadClusters(TTree *) {AliDebug(1,"Start.");return 0;}
+
+  static void                SetDebug()   { fgDebug = kTRUE ; }
+  static void                ResetDebug() { fgDebug = kFALSE ; }
+  static Bool_t              Debug() { return fgDebug ; }
+
+private:
+  static Bool_t fgDebug ;    //! Verbosity controller
+  AliRunLoader *fRunLoader;  //! Pointer to the run loader
+  ClassDef(AliPHOSTracker,0)
+};
+
+#endif
index d3b69af..a359e12 100644 (file)
@@ -69,5 +69,6 @@
 #pragma link C++ class AliPHOSRawStream+;
 #pragma link C++ class AliPHOSOnlineMonitor+;
 #pragma link C++ class AliPHOSGetterLight+;
+#pragma link C++ class AliPHOSTracker+;
 
 #endif
index 3a8117d..97154b4 100644 (file)
@@ -28,7 +28,7 @@ SRCS          =    AliPHOS.cxx AliPHOSv0.cxx AliPHOSv1.cxx AliPHOSv2.cxx \
                 AliPHOSFastGlobalReconstruction.cxx AliPHOSGetter.cxx \
                 AliPHOSGammaJet.cxx \
                 AliPHOSGridFile.cxx AliPHOSRawStream.cxx AliPHOSRawReaderDate.cxx \
-                 AliPHOSGetterLight.cxx AliPHOSOnlineMonitor.cxx
+                 AliPHOSGetterLight.cxx AliPHOSOnlineMonitor.cxx AliPHOSTracker.cxx
 
 HDRS:= $(SRCS:.cxx=.h) 
 
index 3b7d410..d635689 100644 (file)
@@ -43,8 +43,6 @@ fIalpha(0),
 fIx(0),
 fTalpha(0),
 fTx(0),
-fOalpha(0),
-fOx(0),
 fITSchi2(0),
 fITSncls(0),
 fITSsignal(0),
@@ -87,10 +85,10 @@ fRICHsignal(-1)
   fEMCALpos[0]=fEMCALpos[1]=fEMCALpos[2]=0.;
   Int_t i;
   for (i=0; i<5; i++)  { 
-    fRp[i]=fCp[i]=fIp[i]=fOp[i]=fXp[i]=fTp[i]=0.;
+    fRp[i]=fCp[i]=fIp[i]=fTp[i]=0.;
   }
   for (i=0; i<15; i++) { 
-    fRc[i]=fCc[i]=fIc[i]=fOc[i]=fXc[i]=fTc[i]=0.;  
+    fRc[i]=fCc[i]=fIc[i]=fTc[i]=0.;  
   }
   for (i=0; i<6; i++)  { fITSindex[i]=0; }
   for (i=0; i<180; i++){ fTPCindex[i]=0; }
@@ -142,16 +140,6 @@ AliESDtrack::AliESDtrack(const AliESDtrack& track):TObject(track){
   for (Int_t i=0;i<5;i++) fTp[i] =track.fTp[i];
   for (Int_t i=0;i<15;i++)  fTc[i] =track.fTc[i];
   //
-  fOalpha =track.fOalpha;
-  fOx =track.fOx;
-  for (Int_t i=0;i<5;i++) fOp[i] =track.fOp[i];
-  for (Int_t i=0;i<15;i++)  fOc[i] =track.fOc[i];
-  //
-  fXalpha =track.fXalpha;
-  fXx =track.fXx;
-  for (Int_t i=0;i<5;i++) fXp[i] =track.fXp[i];
-  for (Int_t i=0;i<15;i++) fXc[i] =track.fXc[i];
-  //
   fITSchi2 =track.fITSchi2;
   for (Int_t i=0;i<12;i++) fITSchi2MIP[i] =track.fITSchi2MIP[i];
   fITSncls =track.fITSncls;       
@@ -338,19 +326,7 @@ Bool_t AliESDtrack::UpdateTrackParams(const AliKalmanTrack *t, ULong_t flags) {
                      //
     break;
 
-  case kTRDout:
-    //requested by the PHOS/EMCAL  ("temporary solution")
-    if (GetExternalParametersAt(460.,fOp)) {
-       fOalpha=t->GetAlpha();
-       fOx=460.;
-       t->GetExternalCovariance(fOc); //can be done better
-    }
-    if (GetExternalParametersAt(450.,fXp)) {
-       fXalpha=t->GetAlpha();
-       fXx=450.;
-       t->GetExternalCovariance(fXc); //can be done better
-    }
-  case kTRDin: case kTRDrefit:
+  case kTRDout: case kTRDin: case kTRDrefit:
     fTRDLabel = t->GetLabel(); 
     fTRDncls=t->GetNumberOfClusters();
     fTRDchi2=t->GetChi2();
@@ -524,8 +500,8 @@ void AliESDtrack::GetCovariance(Double_t cv[21]) const {
   // Cov(y,x) ... :   cv[1]  cv[2]
   // Cov(z,x) ... :   cv[3]  cv[4]  cv[5]
   // Cov(px,x)... :   cv[6]  cv[7]  cv[8]  cv[9]
-  // Cov(py,y)... :   cv[10] cv[11] cv[12] cv[13] cv[14]
-  // Cov(pz,z)... :   cv[15] cv[16] cv[17] cv[18] cv[19] cv[20]
+  // Cov(py,x)... :   cv[10] cv[11] cv[12] cv[13] cv[14]
+  // Cov(pz,x)... :   cv[15] cv[16] cv[17] cv[18] cv[19] cv[20]
   //
   // Results for (nearly) straight tracks are meaningless !
   //---------------------------------------------------------------------
@@ -621,59 +597,44 @@ void  AliESDtrack::GetTRDExternalParameters(Double_t &x, Double_t&alpha, Double_
   for (Int_t i=0; i<15; i++) cov[i]=fTc[i];
 }
 
-void AliESDtrack::GetOuterPxPyPzPHOS(Double_t *p) const {
-  //---------------------------------------------------------------------
-  // This function returns the global track momentum components
-  // af the radius of the PHOS
-  //---------------------------------------------------------------------
-  p[0]=p[1]=p[2]=0. ; 
-  if (fOx==0) 
-    return;
-  Double_t phi=TMath::ASin(fOp[2]) + fOalpha;
-  Double_t pt=1./TMath::Abs(fOp[4]);
-  p[0]=pt*TMath::Cos(phi); 
-  p[1]=pt*TMath::Sin(phi); 
-  p[2]=pt*fOp[3];
-} 
-void AliESDtrack::GetOuterPxPyPzEMCAL(Double_t *p) const {
+Bool_t AliESDtrack::GetPxPyPzAt(Double_t x,Double_t *p) const {
   //---------------------------------------------------------------------
   // This function returns the global track momentum components
-  // af the radius of the EMCAL
+  // at the position "x" using the helix track approximation
   //---------------------------------------------------------------------
-  if (fXx==0)
-    return;
-  Double_t phi=TMath::ASin(fXp[2]) + fXalpha;
-  Double_t pt=1./TMath::Abs(fXp[4]);
-  p[0]=pt*TMath::Cos(phi); 
-  p[1]=pt*TMath::Sin(phi); 
-  p[2]=pt*fXp[3];
+  Double_t dx=x-fRx;
+  Double_t f1=fRp[2], f2=f1 + dx*fRp[4]/AliKalmanTrack::GetConvConst();
+
+  if (TMath::Abs(f2) >= 0.9999) return kFALSE;
+  
+  Double_t r2=TMath::Sqrt(1.- f2*f2);
+
+  Double_t pt=1./TMath::Abs(fRp[4]);
+  Double_t cs=TMath::Cos(fRalpha), sn=TMath::Sin(fRalpha);
+  p[0]=pt*(r2*cs - f2*sn); p[1]=pt*(f2*cs + r2*sn); p[2]=pt*fRp[3];
+
+  return kTRUE;
 }
 
-void AliESDtrack::GetOuterXYZPHOS(Double_t *xyz) const {
-  //---------------------------------------------------------------------
-  // This function returns the global track position
-  // af the radius of the PHOS
-  //---------------------------------------------------------------------
-  xyz[0]=xyz[1]=xyz[2]=0.;
-  if (fOx==0) 
-    return;
-  Double_t phi=TMath::ATan2(fOp[0],fOx) + fOalpha;
-  Double_t r=TMath::Sqrt(fOx*fOx + fOp[0]*fOp[0]);
-  xyz[0]=r*TMath::Cos(phi); xyz[1]=r*TMath::Sin(phi); xyz[2]=fOp[1]; 
-} 
-void AliESDtrack::GetOuterXYZEMCAL(Double_t *xyz) const {
+Bool_t AliESDtrack::GetXYZAt(Double_t x, Double_t *xyz) const {
   //---------------------------------------------------------------------
   // This function returns the global track position
-  // af the radius of the EMCAL
+  // af the radius "x" using the helix track approximation
   //---------------------------------------------------------------------
-  if (fXx==0) 
-    return;
-  Double_t phi=TMath::ATan2(fXp[0],fOx) + fXalpha;
-  Double_t r=TMath::Sqrt(fXx*fXx + fXp[0]*fXp[0]);
-  xyz[0]=r*TMath::Cos(phi); 
-  xyz[1]=r*TMath::Sin(phi); 
-  xyz[2]=fXp[1]; 
-} 
+  Double_t dx=x-fRx;
+  Double_t f1=fRp[2], f2=f1 + dx*fRp[4]/AliKalmanTrack::GetConvConst();
+
+  if (TMath::Abs(f2) >= 0.9999) return kFALSE;
+  
+  Double_t r1=TMath::Sqrt(1.- f1*f1), r2=TMath::Sqrt(1.- f2*f2);
+  Double_t y = fRp[0] + dx*(f1+f2)/(r1+r2);
+  Double_t z = fRp[1] + dx*(f1+f2)/(f1*r2 + f2*r1)*fRp[3];
+
+  Double_t cs=TMath::Cos(fRalpha), sn=TMath::Sin(fRalpha);
+  xyz[0]=x*cs - y*sn; xyz[1]=x*sn + y*cs; xyz[2]=z;
+
+  return kTRUE;
+}
 
 //_______________________________________________________________________
 void AliESDtrack::GetIntegratedTimes(Double_t *times) const {
index 9f235a2..c9b0227 100644 (file)
 //      
 //         Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch 
 //-------------------------------------------------------------------------
+/*****************************************************************************
+ *  Use GetExternalParameters() and GetExternalCovariance() to access the    *
+ *      track information regardless of its internal representation.         *
+ * 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 azimuthal angle  *
+ *      external param3:   tangent of the track momentum dip angle           *
+ *      external param4:   1/pt (1/(GeV/c))                                  *
+ *****************************************************************************/
 
 #include <TBits.h>
 #include <TObject.h>
@@ -35,8 +45,12 @@ public:
   Int_t GetLabel() const {return fLabel;}
   Double_t GetAlpha() const {return fRalpha;}
   void GetExternalParameters(Double_t &x, Double_t p[5]) const;
-  Bool_t GetExternalParametersAt(Double_t x, Double_t p[5]) const;
   void GetExternalCovariance(Double_t cov[15]) const;
+
+  Bool_t GetExternalParametersAt(Double_t x, Double_t p[5]) const;
+  Bool_t GetPxPyPzAt(Double_t x, Double_t p[3]) const;
+  Bool_t GetXYZAt(Double_t x, Double_t r[3]) const;
+
   Double_t GetIntegratedLength() const {return fTrackLength;}
   void GetIntegratedTimes(Double_t *times) const;
   Double_t GetMass() const;
@@ -62,12 +76,6 @@ public:
   void GetInnerExternalCovariance(Double_t cov[15]) const;//skowron
   Double_t GetInnerAlpha() const {return fIalpha;}
   
-  
-  void GetOuterPxPyPzPHOS(Double_t *p) const;
-  void GetOuterPxPyPzEMCAL(Double_t *p) const;
-  void GetOuterXYZPHOS(Double_t *r) const;
-  void GetOuterXYZEMCAL(Double_t *r) const;
-
   void SetITSpid(const Double_t *p);
   void SetITSChi2MIP(const Float_t *chi2mip);
   void SetITStrack(AliKalmanTrack * track){fITStrack=track;}
@@ -196,24 +204,13 @@ protected:
   Double_t fIx;       // x-coordinate of the track reference plane
   Double_t fIp[5];    // external track parameters
   Double_t fIc[15];   // external cov. matrix of the track parameters
+
 //Track parameters at the inner wall of the TRD 
   Double_t fTalpha;   // Track rotation angle
   Double_t fTx;       // x-coordinate of the track reference plane
   Double_t fTp[5];    // external track parameters
   Double_t fTc[15];   // external cov. matrix of the track parameters
 
-//Track parameters at the radius of the PHOS
-  Double_t fOalpha;   //! Track rotation angle
-  Double_t fOx;       //! x-coordinate of the track reference plane
-  Double_t fOp[5];    //! external track parameters
-  Double_t fOc[15];   //! external cov. matrix of the track parameters
-
-//Track parameters at the radius of the EMCAL
-  Double_t fXalpha;   //! Track rotation angle
-  Double_t fXx;       //! x-coordinate of the track reference plane
-  Double_t fXp[5];    //! external track parameters
-  Double_t fXc[15];   //! external cov. matrix of the track parameters
-
   // ITS related track information
   Float_t fITSchi2;        // chi2 in the ITS
   Float_t fITSchi2MIP[12];     // chi2s in the ITS
@@ -236,6 +233,7 @@ protected:
   Float_t fTPCPoints[4];   // TPC points -first, max. dens, last and max density
   Int_t   fKinkIndexes[3]; // array of indexes of posible kink candidates 
   Int_t   fV0Indexes[3]; // array of indexes of posible kink candidates 
+
   // TRD related track information
   Float_t fTRDchi2;        // chi2 in the TRD
   Int_t   fTRDncls;        // number of clusters assigned in the TRD
@@ -245,6 +243,7 @@ protected:
   Float_t fTRDr[kSPECIES]; // "detector response probabilities" (for the PID)
   Int_t   fTRDLabel;       // label according TRD
   AliKalmanTrack * fTRDtrack; //! OWNER: pointer to the TRD track -- currently for debug purpose
+
   // TOF related track information
   Float_t fTOFchi2;        // chi2 in the TOF
   UInt_t  fTOFindex;       // index of the assigned TOF cluster
@@ -252,6 +251,7 @@ protected:
   Float_t fTOFr[kSPECIES]; // "detector response probabilities" (for the PID)
   Int_t   fTOFLabel[3];       // TOF label 
   Float_t fTOFInfo[10];       //! TOF informations
+
   // PHOS related track information 
   Float_t fPHOSpos[3]; // position localised by PHOS in global coordinate system
   Float_t fPHOSsignal; // energy measured by PHOS
index 36ba637..fd6b888 100644 (file)
@@ -138,6 +138,10 @@ AliReconstruction::AliReconstruction(const char* gAliceFilename,
   fTRDTracker(NULL),
   fTOFLoader(NULL),
   fTOFTracker(NULL),
+  fPHOSLoader(NULL),
+  fPHOSTracker(NULL),
+  fEMCALLoader(NULL),
+  fEMCALTracker(NULL),
   fRICHLoader(NULL),
   fRICHTracker(NULL),
 
@@ -172,6 +176,10 @@ AliReconstruction::AliReconstruction(const AliReconstruction& rec) :
   fTRDTracker(NULL),
   fTOFLoader(NULL),
   fTOFTracker(NULL),
+  fPHOSLoader(NULL),
+  fPHOSTracker(NULL),
+  fEMCALLoader(NULL),
+  fEMCALTracker(NULL),
   fRICHLoader(NULL),
   fRICHTracker(NULL),
 
@@ -543,7 +551,7 @@ Bool_t AliReconstruction::RunTracking(AliESD*& esd)
     }
     if (fCheckPointLevel > 1) WriteESD(esd, "ITS.tracking");
 
-    if (fTRDTracker || fTOFTracker) {
+    if (fTRDTracker||fTOFTracker||fPHOSTracker||fEMCALTracker||fRICHTracker) {
       // ITS back propagation
       AliDebug(1, "ITS back propagation");
       if (fITSTracker->PropagateBack(esd) != 0) {
@@ -599,6 +607,48 @@ Bool_t AliReconstruction::RunTracking(AliESD*& esd)
        fTOFTracker->UnloadClusters();
        fTOFLoader->UnloadDigits();
 
+       if (!fPHOSTracker) {
+         AliWarning("no PHOS tracker");
+       } else {
+         // PHOS back propagation
+         AliDebug(1, "PHOS back propagation");
+         fPHOSLoader->LoadRecPoints("read");
+         TTree* phosTree = fPHOSLoader->TreeR();
+         if (!phosTree) {
+           AliError("Can't get the PHOS cluster tree");
+           return kFALSE;
+         }
+         fPHOSTracker->LoadClusters(phosTree);
+         if (fPHOSTracker->PropagateBack(esd) != 0) {
+           AliError("PHOS backward propagation failed");
+           return kFALSE;
+         }
+         if (fCheckPointLevel > 1) WriteESD(esd, "PHOS.back");
+         fPHOSTracker->UnloadClusters();
+         fPHOSLoader->UnloadRecPoints();
+       }
+
+       if (!fEMCALTracker) {
+         AliWarning("no EMCAL tracker");
+       } else {
+         // EMCAL back propagation
+         AliDebug(1, "EMCAL back propagation");
+         fEMCALLoader->LoadRecPoints("read");
+         TTree* emcalTree = fEMCALLoader->TreeR();
+         if (!emcalTree) {
+           AliError("Can't get the EMCAL cluster tree");
+           return kFALSE;
+         }
+         fEMCALTracker->LoadClusters(emcalTree);
+         if (fEMCALTracker->PropagateBack(esd) != 0) {
+           AliError("EMCAL backward propagation failed");
+           return kFALSE;
+         }
+         if (fCheckPointLevel > 1) WriteESD(esd, "EMCAL.back");
+         fEMCALTracker->UnloadClusters();
+         fEMCALLoader->UnloadRecPoints();
+       }
+
        if (!fRICHTracker) {
          AliWarning("no RICH tracker");
        } else {
@@ -649,7 +699,7 @@ Bool_t AliReconstruction::RunTracking(AliESD*& esd)
       }
       if (fCheckPointLevel > 1) WriteESD(esd, "ITS.refit");
 
-    }  // if TRD tracker
+    }  // if TRD tracker or TOF tracker or PHOS tracker ... 
     fITSTracker->UnloadClusters();
     fITSLoader->UnloadRecPoints();
 
@@ -838,6 +888,38 @@ Bool_t AliReconstruction::CreateTrackers()
     }
   }
 
+  fPHOSTracker = NULL;
+  fPHOSLoader = fRunLoader->GetLoader("PHOSLoader");
+  if (!fPHOSLoader) {
+    AliWarning("no PHOS loader found");
+    if (fStopOnError) return kFALSE;
+  } else {
+    AliReconstructor* phosReconstructor = GetReconstructor("PHOS");
+    if (phosReconstructor) {
+      fPHOSTracker = phosReconstructor->CreateTracker(fRunLoader);
+    }
+    if (!fPHOSTracker) {
+      AliWarning("couldn't create a tracker for PHOS");
+      if (fStopOnError) return kFALSE;
+    }
+  }
+
+  fEMCALTracker = NULL;
+  fEMCALLoader = fRunLoader->GetLoader("EMCALLoader");
+  if (!fEMCALLoader) {
+    AliWarning("no EMCAL loader found");
+    if (fStopOnError) return kFALSE;
+  } else {
+    AliReconstructor* emcalReconstructor = GetReconstructor("EMCAL");
+    if (emcalReconstructor) {
+      fEMCALTracker = emcalReconstructor->CreateTracker(fRunLoader);
+    }
+    if (!fEMCALTracker) {
+      AliWarning("couldn't create a tracker for EMCAL");
+      if (fStopOnError) return kFALSE;
+    }
+  }
+
   fRICHTracker = NULL;
   fRICHLoader = fRunLoader->GetLoader("RICHLoader");
   if (!fRICHLoader) {
@@ -874,6 +956,10 @@ void AliReconstruction::CleanUp(TFile* file)
   fTRDTracker = NULL;
   delete fTOFTracker;
   fTOFTracker = NULL;
+  delete fPHOSTracker;
+  fPHOSTracker = NULL;
+  delete fEMCALTracker;
+  fEMCALTracker = NULL;
   delete fRICHTracker;
   fRICHTracker = NULL;
 
index 520625c..0289de7 100644 (file)
@@ -118,6 +118,10 @@ private:
   AliTracker*    fTRDTracker;         //! tracker for TRD
   AliLoader*     fTOFLoader;          //! loader for TOF
   AliTracker*    fTOFTracker;         //! tracker for TOF
+  AliLoader*     fPHOSLoader;         //! loader for PHOS
+  AliTracker*    fPHOSTracker;        //! tracker for PHOS
+  AliLoader*     fEMCALLoader;        //! loader for EMCAL
+  AliTracker*    fEMCALTracker;       //! tracker for EMCAL
   AliLoader*     fRICHLoader;         //! loader for RICH
   AliTracker*    fRICHTracker;        //! tracker for RICH