New class AliESDEvent, backward compatibility with the old AliESD (Christian)
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 11 Jul 2007 13:43:31 +0000 (13:43 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 11 Jul 2007 13:43:31 +0000 (13:43 +0000)
146 files changed:
EMCAL/AliEMCALPID.cxx
EMCAL/AliEMCALPID.h
EMCAL/AliEMCALReconstructor.cxx
EMCAL/AliEMCALReconstructor.h
EMCAL/AliEMCALTracker.cxx
EMCAL/AliEMCALTracker.h
EVE/Alieve/EventAlieve.cxx
EVE/Alieve/EventAlieve.h
EVE/Alieve/MUONTrack.cxx
FMD/AliFMDReconstructor.cxx
FMD/AliFMDReconstructor.h
HLT/BASE/AliHLTOfflineDataSource.h
HLT/BASE/AliHLTOfflineInterface.cxx
HLT/BASE/AliHLTOfflineInterface.h
HLT/BASE/AliHLTSystem.cxx
HLT/BASE/AliHLTSystem.h
HLT/ITS/AliHLTITStracker.cxx
HLT/ITS/AliHLTITStracker.h
HLT/SampleLib/AliHLTSampleOfflineSinkComponent.cxx
HLT/SampleLib/AliHLTSampleOfflineSinkComponent.h
HLT/TPCLib/AliHLTTPCEsdWriterComponent.cxx
HLT/TPCLib/AliHLTTPCEsdWriterComponent.h
HLT/TPCLib/tracking/AliHLTTPCHough.cxx
HLT/TPCLib/tracking/AliHLTTPCHough.h
HLT/TPCLib/tracking/AliHLTTPCHoughTracker.cxx
HLT/TPCLib/tracking/AliHLTTPCHoughTracker.h
HLT/TRD/AliHLTTRDTrackerComponent.cxx
HLT/TRD/AliTRDtrackerHLT.cxx
HLT/TRD/AliTRDtrackerHLT.h
HLT/hough/AliHLTHough.cxx
HLT/hough/AliHLTHough.h
HLT/src/AliHLTReconstructor.cxx
HLT/src/AliHLTReconstructor.h
HLT/src/AliHLTTPCtracker.cxx
HLT/src/AliHLTTPCtracker.h
HMPID/AliHMPIDTracker.cxx
HMPID/AliHMPIDTracker.h
ITS/AliITSReconstructor.cxx
ITS/AliITSReconstructor.h
ITS/AliITSpidESD.h
ITS/AliITSpidESD1.cxx
ITS/AliITSpidESD1.h
ITS/AliITSpidESD2.cxx
ITS/AliITSpidESD2.h
ITS/AliITStrackerMI.cxx
ITS/AliITStrackerMI.h
ITS/AliITStrackerSA.cxx
ITS/AliITStrackerSA.h
ITS/AliITStrackerV2.cxx
ITS/AliITStrackerV2.h
MONITOR/AliMonitor.h
MONITOR/AliMonitorHLT.cxx
MONITOR/AliMonitorHLT.h
MONITOR/AliMonitorHLTHough.cxx
MONITOR/AliMonitorHLTHough.h
MONITOR/AliMonitorITS.cxx
MONITOR/AliMonitorITS.h
MONITOR/AliMonitorProcess.cxx
MONITOR/AliMonitorProcess.h
MONITOR/AliMonitorTPC.cxx
MONITOR/AliMonitorTPC.h
MONITOR/AliMonitorV0s.cxx
MONITOR/AliMonitorV0s.h
MONITOR/monitorGDC.cxx
MUON/AliMUONCheck.cxx
MUON/AliMUONCheck.h
MUON/AliMUONTracker.cxx
MUON/AliMUONTracker.h
PHOS/AliPHOSPID.h
PHOS/AliPHOSPIDv1.cxx
PHOS/AliPHOSReconstructor.cxx
PHOS/AliPHOSReconstructor.h
PHOS/AliPHOSTrackSegmentMaker.h
PHOS/AliPHOSTrackSegmentMakerv1.cxx
PHOS/AliPHOSTrackSegmentMakerv2.cxx
PHOS/AliPHOSTracker.cxx
PHOS/AliPHOSTracker.h
PMD/AliPMDReconstructor.cxx
PMD/AliPMDReconstructor.h
PMD/AliPMDtracker.cxx
PMD/AliPMDtracker.h
RAW/AliFilter.h
RAW/AliHoughFilter.cxx
RAW/AliHoughFilter.h
RAW/AliMDC.cxx
RAW/AliMDC.h
RAW/AliRawCastorDB.cxx
RAW/AliRawCastorDB.h
RAW/AliRawDB.cxx
RAW/AliRawDB.h
RAW/AliRawNullDB.cxx
RAW/AliRawNullDB.h
RAW/AliRawRFIODB.cxx
RAW/AliRawRFIODB.h
RAW/AliRawRootdDB.cxx
RAW/AliRawRootdDB.h
STEER/AliCascadeVertexer.cxx
STEER/AliCascadeVertexer.h
STEER/AliESD.cxx
STEER/AliESD.h
STEER/AliESDEvent.cxx [new file with mode: 0644]
STEER/AliESDEvent.h [new file with mode: 0644]
STEER/AliESDpid.cxx
STEER/AliESDpid.h
STEER/AliReconstruction.cxx
STEER/AliReconstruction.h
STEER/AliReconstructor.cxx
STEER/AliReconstructor.h
STEER/AliTracker.h
STEER/AliV0vertexer.cxx
STEER/AliV0vertexer.h
STEER/AliVertexerTracks.cxx
STEER/AliVertexerTracks.h
STEER/CheckESD.C
STEER/ESDLinkDef.h
STEER/libESD.pkg
T0/AliT0.cxx
T0/AliT0Reconstructor.cxx
T0/AliT0Reconstructor.h
TOF/AliTOFReconstructor.cxx
TOF/AliTOFReconstructor.h
TOF/AliTOFpidESD.cxx
TOF/AliTOFpidESD.h
TOF/AliTOFtracker.cxx
TOF/AliTOFtracker.h
TOF/AliTOFtrackerMI.cxx
TOF/AliTOFtrackerMI.h
TPC/AliTPCReconstructor.cxx
TPC/AliTPCReconstructor.h
TPC/AliTPCpidESD.cxx
TPC/AliTPCpidESD.h
TPC/AliTPCtracker.cxx
TPC/AliTPCtracker.h
TPC/AliTPCtrackerMI.cxx
TPC/AliTPCtrackerMI.h
TRD/AliTRDReconstructor.cxx
TRD/AliTRDReconstructor.h
TRD/AliTRDpidESD.cxx
TRD/AliTRDpidESD.h
TRD/AliTRDtracker.cxx
TRD/AliTRDtracker.h
TRD/AliTRDtrackingAnalysis.cxx
TRD/AliTRDtrackingAnalysis.h
ZDC/AliZDCReconstructor.cxx
ZDC/AliZDCReconstructor.h
test/genkine/sim/test.C

index d80f058..7717c74 100644 (file)
@@ -17,6 +17,9 @@
 /* History of cvs commits:
  *
  * $Log$
+ * Revision 1.12  2007/06/11 20:43:06  hristov
+ * Changes required by the updated AliESDCaloCluster (Gustavo)
+ *
  * Revision 1.11  2007/03/30 13:50:34  gustavo
  * PID for particles with E < 5 GeV was not done, temporal solution found (Guenole)
  *
 // #include "AliLoader.h"
 // #include "AliStack.h"
 // #include "AliESDtrack.h"
-// #include "AliESD.h"
+// #include "AliESDEvent.h"
 #include "AliLog.h"
 #include "AliEMCALPID.h"
   
@@ -232,7 +235,7 @@ ClassImp(AliEMCALPID)
 }
 
 //______________________________________________
-void AliEMCALPID::RunPID(AliESD *esd)
+void AliEMCALPID::RunPID(AliESDEvent *esd)
 {
 //
 // Make the PID for all the EMCAL clusters containedin the ESDs File
index bdf81d4..6e29f95 100644 (file)
@@ -5,6 +5,9 @@
 /* History of cvs commits:
  *
  * $Log$
+ * Revision 1.12  2007/02/20 20:17:43  hristov
+ * Corrected array size, removed warnings (icc)
+ *
  * Revision 1.11  2006/12/19 08:49:35  gustavo
  * New PID class for EMCAL, bayesian analysis done with ESD data, PID information filled when calling AliEMCALPID in AliEMCALReconstructor::FillESD()
  *
@@ -17,7 +20,7 @@
 
 #include "TTask.h"
 #include "TArrayD.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
 #include "AliPID.h" 
 
 class AliEMCALPID : public TTask {
@@ -27,7 +30,7 @@ public:
   AliEMCALPID();
   virtual ~AliEMCALPID() { }
   
-  void     RunPID(AliESD *esd);
+  void     RunPID(AliESDEvent *esd);
   void     ComputePID(Double_t energy, Double_t lambda0); // give the PID of a cluster
   TArrayD  DistLambda0(Double_t energy, Int_t nature); // compute lambda0 distributions
   
index 46221be..efaac7d 100644 (file)
@@ -29,7 +29,7 @@
 #include "AliEMCALReconstructor.h"
 
 #include "AliRun.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
 #include "AliESDtrack.h"
 #include "AliRunLoader.h"
 #include "AliEMCALLoader.h"
@@ -126,7 +126,7 @@ void AliEMCALReconstructor::Reconstruct(AliRunLoader* runLoader, AliRawReader* r
 }
 
 //____________________________________________________________________________
-void AliEMCALReconstructor::FillESD(AliRunLoader* runLoader, AliESD* esd) const
+void AliEMCALReconstructor::FillESD(AliRunLoader* runLoader, AliESDEvent* esd) const
 {
   // Called by AliReconstruct after Reconstruct() and global tracking and vertexing 
   const double timeScale = 1.e+11; // transition constant from sec to 0.01 ns 
index f7d3465..c89b663 100644 (file)
@@ -19,7 +19,7 @@
 class AliEMCALDigitizer ;
 class AliEMCALClusterizer ;
 class AliEMCALSDigitizer ;
-class AliESD ;
+class AliESDEvent ;
 class AliRawReader ;
 
 // --- Standard library ---
@@ -38,7 +38,7 @@ public:
   Bool_t       Debug() const { return fDebug ; }
 
   using AliReconstructor::FillESD;
-  virtual void FillESD(AliRunLoader* runLoader, AliESD* esd) const ;
+  virtual void FillESD(AliRunLoader* runLoader, AliESDEvent* esd) const ;
   AliTracker*  CreateTracker         (AliRunLoader*                      )const{return new AliEMCALTracker;} 
   using AliReconstructor::Reconstruct;
   virtual void Reconstruct(AliRunLoader* runLoader) const ;
index 71e32eb..a8c070b 100644 (file)
@@ -41,7 +41,7 @@
 #include <TGeoMatrix.h>
 
 #include "AliLog.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
 #include "AliESDtrack.h"
 #include "AliKalmanTrack.h"
 #include "AliEMCALRecPoint.h"
@@ -270,7 +270,7 @@ Int_t AliEMCALTracker::LoadClusters(TTree *cTree)
 //
 //------------------------------------------------------------------------------
 //
-Int_t AliEMCALTracker::LoadClusters(AliESD *esd) 
+Int_t AliEMCALTracker::LoadClusters(AliESDEvent *esd) 
 {
        //
        // Load EMCAL clusters in the form of AliESDCaloClusters,
@@ -306,7 +306,7 @@ Int_t AliEMCALTracker::LoadClusters(AliESD *esd)
 //
 //------------------------------------------------------------------------------
 //
-Int_t AliEMCALTracker::LoadTracks(AliESD *esd)
+Int_t AliEMCALTracker::LoadTracks(AliESDEvent *esd)
 {
        //
        // Load ESD tracks.
@@ -359,7 +359,7 @@ Int_t AliEMCALTracker::LoadTracks(AliESD *esd)
 //
 //------------------------------------------------------------------------------
 //
-Int_t AliEMCALTracker::PropagateBack(AliESD* esd)
+Int_t AliEMCALTracker::PropagateBack(AliESDEvent* esd)
 {
        //
        // Main operation method.
index 95f0582..2610d46 100644 (file)
@@ -27,7 +27,7 @@
 class TList;
 class TTree;
 class TObjArray;
-class AliESD;
+class AliESDEvent;
 class AliESDCaloCluster;
 class AliEMCALTrack;
 class AliEMCALRecPoint;
@@ -44,12 +44,12 @@ public:
        virtual ~AliEMCALTracker() {Clear();}
        
        virtual void        Clear(Option_t *option="ALL");
-       virtual Int_t       Clusters2Tracks(AliESD*) {return -1;}
+       virtual Int_t       Clusters2Tracks(AliESDEvent*) {return -1;}
        virtual Int_t       LoadClusters(TTree*);
-               Int_t       LoadClusters(AliESD* esd);
-               Int_t       LoadTracks(AliESD* esd);
-       virtual Int_t       PropagateBack(AliESD* esd);
-       virtual Int_t       RefitInward(AliESD*) {return -1;}
+               Int_t       LoadClusters(AliESDEvent* esd);
+               Int_t       LoadTracks(AliESDEvent* esd);
+       virtual Int_t       PropagateBack(AliESDEvent* esd);
+       virtual Int_t       RefitInward(AliESDEvent*) {return -1;}
        virtual void        UnloadClusters();
        virtual AliCluster* GetCluster(Int_t) const {return NULL;};
        TTree*              SearchTrueMatches();
index 63f35e8..86bf3c1 100644 (file)
@@ -6,7 +6,7 @@
 
 #include <AliRunLoader.h>
 #include <AliRun.h>
-#include <AliESD.h>
+#include <AliESDEvent.h>
 #include <AliESDfriend.h>
 #include <AliMagFMaps.h>
 #include <AliCDBManager.h>
@@ -129,7 +129,7 @@ void Event::Open()
     fESDFile = new TFile(esd_path);
     if(fESDFile->IsZombie() == kFALSE)
     {
-      fESD = new AliESD();
+      fESD = new AliESDEvent();
       fESDTree = (TTree*) fESDFile->Get("esdTree");
       if (fESDTree != 0)
       {
@@ -271,7 +271,7 @@ AliRunLoader* Event::AssertRunLoader()
   return gEvent->fRunLoader;
 }
 
-AliESD* Event::AssertESD()
+AliESDEvent* Event::AssertESD()
 {
   static const Exc_t eH("Event::AssertESD ");
 
index 7b09a4c..5b79a46 100644 (file)
@@ -8,7 +8,7 @@
 #include <Reve/EventBase.h>
 
 class AliRunLoader;
-class AliESD;
+class AliESDEvent;
 class AliESDfriend;
 
 class AliMagF;
@@ -33,7 +33,7 @@ protected:
 
   TFile*        fESDFile;
   TTree*        fESDTree;
-  AliESD*       fESD;
+  AliESDEvent*       fESD;
   AliESDfriend* fESDfriend;
   Bool_t        fESDfriendExists;
 
@@ -67,13 +67,13 @@ public:
   Int_t         GetEventId()   const { return fEventId; }
   AliRunLoader* GetRunLoader() const { return fRunLoader; }
   TTree*        GetESDTree()   const { return fESDTree; }
-  AliESD*       GetESD()       const { return fESD; }
+  AliESDEvent*       GetESD()       const { return fESD; }
   AliESDfriend* GetESDfriend()       const { return fESDfriend; }
   Bool_t        GetESDfriendExists() const { return fESDfriendExists; }
   virtual const Text_t* GetTitle()   const { return fPath.Data(); }
 
   static AliRunLoader* AssertRunLoader();
-  static AliESD*       AssertESD();
+  static AliESDEvent*       AssertESD();
   static AliESDfriend* AssertESDfriend();
 
   static AliMagF*      AssertMagField();
index 05fdf57..1200fa3 100644 (file)
@@ -7,7 +7,7 @@
 #include <AliLog.h>
 #include <AliESDMuonTrack.h>
 #include <AliTrackReference.h>
-#include <AliESD.h>
+#include <AliESDEvent.h>
 #include <AliRunLoader.h>
 #include <AliRun.h>
 
@@ -336,7 +336,7 @@ void MUONTrack::PrintESDTrackInfo()
     setw(8) << setprecision(4) <<
     mtp->P()  << "  GeV/c" << endl;
   
-  AliESD* esd = Alieve::Event::AssertESD();
+  AliESDEvent* esd = Alieve::Event::AssertESD();
   
   Double_t spdVertexX = 0;
   Double_t spdVertexY = 0;
@@ -432,7 +432,7 @@ void MUONTrack::MUONTriggerInfo()
   }
   if (fIsESDTrack) {
 
-    AliESD* esd = Alieve::Event::AssertESD();
+    AliESDEvent* esd = Alieve::Event::AssertESD();
     ULong64_t triggerMask = esd->GetTriggerMask();
 
     cout << endl;
index 69c979f..6fe70f4 100644 (file)
@@ -44,7 +44,7 @@
 #include "AliFMDReconstructor.h"           // ALIFMDRECONSTRUCTOR_H
 #include "AliFMDRawReader.h"               // ALIFMDRAWREADER_H
 #include "AliFMDRecPoint.h"               // ALIFMDMULTNAIIVE_H
-#include "AliESD.h"                       // ALIESD_H
+#include "AliESDEvent.h"                  // ALIESDEVENT_H
 #include <AliESDFMD.h>                    // ALIESDFMD_H
 #include <TH1.h>
 #include <TH2.h>
@@ -476,7 +476,7 @@ AliFMDReconstructor::PhysicalCoordinates(AliFMDDigit* digit,
 void 
 AliFMDReconstructor::FillESD(TTree*  /* digitsTree */, 
                             TTree*  /* clusterTree */,
-                            AliESD* esd) const
+                            AliESDEvent* esd) const
 {
   // nothing to be done
   // FIXME: The vertex may not be known when Reconstruct is executed,
@@ -546,7 +546,7 @@ AliFMDReconstructor::Reconstruct(AliRunLoader*, AliRawReader*) const
 }
 //____________________________________________________________________
 void 
-AliFMDReconstructor::FillESD(AliRawReader*,TTree*,AliESD*) const 
+AliFMDReconstructor::FillESD(AliRawReader*,TTree*,AliESDEvent*) const 
 {
   // Cannot be used.  See member function with same name but with 2
   // TTree arguments.   Make sure you do local reconstrucion 
@@ -555,7 +555,7 @@ AliFMDReconstructor::FillESD(AliRawReader*,TTree*,AliESD*) const
 }
 //____________________________________________________________________
 void 
-AliFMDReconstructor::FillESD(AliRunLoader*,AliESD*) const
+AliFMDReconstructor::FillESD(AliRunLoader*,AliESDEvent*) const
 {
   // Cannot be used.  See member function with same name but with 2
   // TTree arguments.   Make sure you do local reconstrucion 
@@ -564,7 +564,7 @@ AliFMDReconstructor::FillESD(AliRunLoader*,AliESD*) const
 }
 //____________________________________________________________________
 void 
-AliFMDReconstructor::FillESD(AliRunLoader*,AliRawReader*,AliESD*) const 
+AliFMDReconstructor::FillESD(AliRunLoader*,AliRawReader*,AliESDEvent*) const 
 {
   // Cannot be used.  See member function with same name but with 2
   // TTree arguments.   Make sure you do local reconstrucion 
index a2059d3..01db156 100644 (file)
@@ -31,7 +31,7 @@ class TClonesArray;
 class AliFMDDigit;
 class AliRawReader;
 class AliRunLoader;
-class AliESD;
+class AliESDEvent;
 class AliESDFMD;
 class TH1;
 
@@ -92,9 +92,9 @@ public:
       @param esd ESD object to store data in. 
   */
   virtual void   FillESD(TTree* digitsTree, TTree* clusterTree, 
-                        AliESD* esd) const;
+                        AliESDEvent* esd) const;
   /** Not used */
-  virtual void   SetESD(AliESD* esd) { fESD = esd; }
+  virtual void   SetESD(AliESDEvent* esd) { fESD = esd; }
   /** Set the noise factor 
       @param f Factor to use */
   virtual void SetNoiseFactor(Float_t f=3) { fNoiseFactor = f; }
@@ -186,7 +186,7 @@ protected:
   Bool_t                fAngleCorrect;  // Whether to angle correct
   mutable Vertex_t      fVertexType;    // What kind of vertex we got
   AliRunLoader*         fRunLoader;     // Run loader passed to Init  
-  AliESD*               fESD;           // ESD object(?)
+  AliESDEvent*          fESD;           // ESD object(?)
   Bool_t                fDiagnostics;   // Wheter to do diagnostics
   TH1*                  fDiagStep1;    // Diagnostics histogram
   TH1*                  fDiagStep2;    // Diagnostics histogram
@@ -201,13 +201,13 @@ private:
   /** Hide base classes unused function */
   void Reconstruct(AliRunLoader*, AliRawReader*) const;
   /** Hide base classes unused function */
-  void FillESD(AliRawReader*, TTree*, AliESD*) const;
+  void FillESD(AliRawReader*, TTree*, AliESDEvent*) const;
   /** Hide base classes unused function */
-  void FillESD(AliRunLoader*, AliESD*) const;
+  void FillESD(AliRunLoader*, AliESDEvent*) const;
   /** Hide base classes unused function */
-  void FillESD(AliRunLoader*, AliRawReader*, AliESD*) const;
+  void FillESD(AliRunLoader*, AliRawReader*, AliESDEvent*) const;
   
-  ClassDef(AliFMDReconstructor, 0)  // class for the FMD reconstruction
+  ClassDef(AliFMDReconstructor, 1)  // class for the FMD reconstruction
 }; 
 #endif
 //____________________________________________________________________
index 5f4ffc1..3e390ac 100644 (file)
@@ -54,7 +54,7 @@ class AliHLTOfflineDataSource
   /**
    * Default implementation as sources do not have a real FillESD method.
    */
-  int FillESD(int eventNo, AliRunLoader* runLoader, AliESD* esd) {
+  int FillESD(int eventNo, AliRunLoader* runLoader, AliESDEvent* esd) {
     if (esd==NULL && runLoader==NULL) {
       // get rid of 'unused parameter' warning
     }
index 56e64b2..da07963 100644 (file)
@@ -87,13 +87,13 @@ AliRawReader* AliHLTOfflineInterface::GetRawReader() const
   return fpRawReader!=NULL?fpRawReader:fgpRawReader;
 }
 
-int AliHLTOfflineInterface::SetESD(Int_t eventNo, AliESD* pESD)
+int AliHLTOfflineInterface::SetESD(Int_t eventNo, AliESDEvent* pESD)
 {
   fpESD=pESD;
   return 0;
 }
 
-AliESD* AliHLTOfflineInterface::GetESD() const
+AliESDEvent* AliHLTOfflineInterface::GetESD() const
 {
   return fpESD;
 }
@@ -166,7 +166,7 @@ int AliHLTOfflineInterface::ResetComponents()
   return iResult;
 }
 
-int AliHLTOfflineInterface::FillComponentESDs(int eventNo, AliRunLoader* runLoader, AliESD* esd)
+int AliHLTOfflineInterface::FillComponentESDs(int eventNo, AliRunLoader* runLoader, AliESDEvent* esd)
 {
   // see header file for class documentation
   int iResult=0;
index 22a6b64..25c5aa1 100644 (file)
@@ -23,7 +23,7 @@
 
 class AliRunLoader;
 class AliRawReader;
-class AliESD;
+class AliESDEvent;
 class TTree;
 
 /******************************************************************************/
@@ -33,9 +33,9 @@ class TTree;
  * The class implements the basic interface to the AliRoot objects during
  * reconstructions.
  * It serves as a base class for offline source and sink interface components
- * and provides access methods for the AliRunLoader, AliRawReader and AliESD
+ * and provides access methods for the AliRunLoader, AliRawReader and AliESDEvent
  * objects. The AliRunLoader and the AliRawReader are fixed during one run,
- * while the AliESD object will be changed from event to event.<br>
+ * while the AliESDEvent object will be changed from event to event.<br>
  * \em Note: The digits and clusters trees are not available through this
  * interface class as they are completetly detector (AliLoader) dependend.
  *
@@ -72,12 +72,12 @@ class AliHLTOfflineInterface : public TObject {
   /**
    * Set AliRoot ESD for the current event.
    */
-  int SetESD(Int_t eventNo, AliESD* pESD);
+  int SetESD(Int_t eventNo, AliESDEvent* pESD);
 
   /**
    * Get the AliRoot ESD
    */
-  AliESD* GetESD() const;
+  AliESDEvent* GetESD() const;
 
   /**
    * Set AliRoot external params.
@@ -109,10 +109,10 @@ class AliHLTOfflineInterface : public TObject {
    * @param eventNo       event No. \em Note: this is an internal enumeration of the
    *                      processed events.
    * @param runLoader     the AliRoot runloader
-   * @param esd           an AliESD instance
+   * @param esd           an AliESDEvent instance
    * @return neg. error code if failed 
    */
-  virtual int FillESD(int eventNo, AliRunLoader* runLoader, AliESD* esd)=0;
+  virtual int FillESD(int eventNo, AliRunLoader* runLoader, AliESDEvent* esd)=0;
 
   /**
    * Fill ESD for one event.
@@ -122,10 +122,10 @@ class AliHLTOfflineInterface : public TObject {
    * @param eventNo       event No. \em Note: this is an internal enumeration of the
    *                      processed events.
    * @param runLoader     the AliRoot runloader
-   * @param esd           an AliESD instance
+   * @param esd           an AliESDEvent instance
    * @return neg. error code if failed 
    */
-  static int FillComponentESDs(int eventNo, AliRunLoader* runLoader, AliESD* esd);
+  static int FillComponentESDs(int eventNo, AliRunLoader* runLoader, AliESDEvent* esd);
 
   /**
    * Reset AliRoot internal params of all active components.
@@ -159,7 +159,7 @@ protected:
   /** private AliRoot raw reader instance */
   AliRawReader* fpRawReader;                                      //! transient
   /** AliRoot HLT ESD instance */
-  AliESD* fpESD;                                                  //! transient
+  AliESDEvent* fpESD;                                                  //! transient
 
   /** the list of active interfaces */
   static AliHLTOfflineInterface* fAnchor;                         //! transient
@@ -173,7 +173,7 @@ protected:
   /** number of interfaces */
   static int fCount;                                              //! see above
 
-  ClassDef(AliHLTOfflineInterface, 2);
+  ClassDef(AliHLTOfflineInterface, 3);
 };
 
 #endif
index 0326275..d0e5222 100644 (file)
@@ -556,7 +556,7 @@ int AliHLTSystem::Reconstruct(int nofEvents, AliRunLoader* runLoader,
   return iResult;
 }
 
-int AliHLTSystem::FillESD(int eventNo, AliRunLoader* runLoader, AliESD* esd)
+int AliHLTSystem::FillESD(int eventNo, AliRunLoader* runLoader, AliESDEvent* esd)
 {
   // see header file for class documentation
   int iResult=0;
index 6478ef2..65caa9f 100644 (file)
@@ -33,7 +33,7 @@ class AliHLTConfigurationHandler;
 class AliHLTTask;
 class AliRunLoader;
 class AliRawReader;
-class AliESD;
+class AliESDEvent;
 class TObjArray;
 class TStopwatch;
 
@@ -230,10 +230,10 @@ class AliHLTSystem : public AliHLTLogging {
    *                      processing counter and is not related to the nature/
    *                      origin of the event
    * @param runLoader     the AliRoot runloader
-   * @param esd           an AliESD instance
+   * @param esd           an AliESDEvent instance
    * @return neg. error code if failed 
    */
-  int FillESD(int eventNo, AliRunLoader* runLoader, AliESD* esd);
+  int FillESD(int eventNo, AliRunLoader* runLoader, AliESDEvent* esd);
 
   /**
    * Load component libraries.
index 0aa4099..50a05b2 100644 (file)
@@ -20,7 +20,7 @@
 //          Origin: Cvetan Cheshkov, CERN, Cvetan.Cheshkov@cern.ch
 //-------------------------------------------------------------------------
 
-#include "AliESD.h"
+#include "AliESDEvent.h"
 #include "AliHLTITStrack.h"
 #include "AliHLTITStracker.h"
 
@@ -60,7 +60,7 @@ static Int_t CorrectForDeadZoneMaterial(AliITStrackV2 *t) {
   return 0;
 }
 
-Int_t AliHLTITStracker::Clusters2Tracks(AliESD *event) {
+Int_t AliHLTITStracker::Clusters2Tracks(AliESDEvent *event) {
   //--------------------------------------------------------------------
   // This functions reconstructs HLT ITS tracks
   //--------------------------------------------------------------------
@@ -148,7 +148,7 @@ Int_t AliHLTITStracker::Clusters2Tracks(AliESD *event) {
   return 0;
 }
 
-Int_t AliHLTITStracker::PropagateBack(AliESD *event) {
+Int_t AliHLTITStracker::PropagateBack(AliESDEvent *event) {
   //--------------------------------------------------------------------
   // This functions propagates reconstructed ITS tracks back
   //--------------------------------------------------------------------
@@ -157,7 +157,7 @@ Int_t AliHLTITStracker::PropagateBack(AliESD *event) {
   return 0;
 }
 
-Int_t AliHLTITStracker::RefitInward(AliESD *event) {
+Int_t AliHLTITStracker::RefitInward(AliESDEvent *event) {
   //--------------------------------------------------------------------
   // This functions refits ITS tracks using the 
   // "inward propagated" TPC tracks
index d6bfe61..edd4f08 100644 (file)
@@ -19,7 +19,7 @@
 
 #include "AliITStrackerV2.h"
 
-class AliESD;
+class AliESDEvent;
 class AliHLTITStrack;
 
 //-------------------------------------------------------------------------
@@ -28,9 +28,9 @@ public:
   AliHLTITStracker():AliITStrackerV2(){ fConstraint[0]=1; fConstraint[1]=0; }
   AliHLTITStracker(const Char_t *geom) : AliITStrackerV2(geom){ fConstraint[0]=1; fConstraint[1]=0; }
 
-  Int_t Clusters2Tracks(AliESD *event);
-  Int_t PropagateBack(AliESD *event);
-  Int_t RefitInward(AliESD *event);
+  Int_t Clusters2Tracks(AliESDEvent *event);
+  Int_t PropagateBack(AliESDEvent *event);
+  Int_t RefitInward(AliESDEvent *event);
 
   ClassDef(AliHLTITStracker,1)   //HLT ITS tracker
 };
index d0711aa..de67695 100644 (file)
@@ -95,7 +95,7 @@ int AliHLTSampleOfflineSinkComponent::DumpEvent(const AliHLTComponentEventData&
   return iResult;
 }
 
-int AliHLTSampleOfflineSinkComponent::FillESD(int eventNo, AliRunLoader* runLoader, AliESD* esd) 
+int AliHLTSampleOfflineSinkComponent::FillESD(int eventNo, AliRunLoader* runLoader, AliESDEvent* esd) 
 {
   // see header file for class documentation
   int iResult=0;
index 459788f..0863556 100644 (file)
@@ -62,10 +62,10 @@ class AliHLTSampleOfflineSinkComponent : public AliHLTOfflineDataSink {
    * @param eventNo       event No. \em Note: this is an internal enumeration of the
    *                      processed events.
    * @param runLoader     the AliRoot runloader
-   * @param esd           an AliESD instance
+   * @param esd           an AliESDEvent instance
    * @return neg. error code if failed 
    */
-  int FillESD(int eventNo, AliRunLoader* runLoader, AliESD* esd);
+  int FillESD(int eventNo, AliRunLoader* runLoader, AliESDEvent* esd);
 
  protected:
   /**
index 9c57702..66425ac 100644 (file)
@@ -24,7 +24,7 @@
 
                                                                           */
 #include "AliHLTTPCEsdWriterComponent.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
 #include "TTree.h"
 #include "AliHLTTPCTrack.h"
 #include "AliHLTTPCTrackArray.h"
@@ -58,11 +58,12 @@ int AliHLTTPCEsdWriterComponent::InitWriter()
 {
   // see header file for class documentation
   int iResult=0;
-  fESD = new AliESD;
+  fESD = new AliESDEvent;
+  fESD->CreateStdContent();
   if (fESD) {
     fTree = new TTree("esdTree", "Tree with HLT ESD objects");
     if (fTree) {
-      fTree->Branch("ESD", "AliESD", &fESD);
+      fESD->WriteToTree(fTree);
     }
     delete fESD;
     fESD=NULL;
@@ -97,9 +98,10 @@ int AliHLTTPCEsdWriterComponent::DumpEvent( const AliHLTComponentEventData& evtD
   int iResult=0;
   TTree* pTree=fTree;
   if (pTree) {
-    fESD = new AliESD;
+    fESD = new AliESDEvent;
+    fESD->CreateStdContent();
     if (fESD) {
-      AliESD* pESD=fESD;
+      AliESDEvent* pESD=fESD;
 
       const AliHLTComponentBlockData* iter = NULL;
       AliHLTTPCTrackletData* inPtr=NULL;
@@ -138,7 +140,7 @@ int AliHLTTPCEsdWriterComponent::DumpEvent( const AliHLTComponentEventData& evtD
        pTree->Fill();
       }
 
-      fESD=NULL;
+      fESD->Reset();
       delete pESD;
     } else {
       iResult=-ENOMEM;
@@ -154,7 +156,7 @@ int AliHLTTPCEsdWriterComponent::ScanArgument(int argc, const char** argv)
   return iResult;
 }
 
-int AliHLTTPCEsdWriterComponent::Tracks2ESD(AliHLTTPCTrackArray* pTracks, AliESD* pESD)
+int AliHLTTPCEsdWriterComponent::Tracks2ESD(AliHLTTPCTrackArray* pTracks, AliESDEvent* pESD)
 {
   // see header file for class documentation
   int iResult=0;
index 4d26c52..114290b 100644 (file)
@@ -16,7 +16,7 @@
 
 // forward declarations
 class TTree;
-class AliESD;
+class AliESDEvent;
 class AliHLTTPCTrackArray;
 
 /**
@@ -118,14 +118,14 @@ class AliHLTTPCEsdWriterComponent : public AliHLTRootFileWriterComponent
    * @param pESD     pointer to ESD
    * @return neg. error code if failed
    */
-  int Tracks2ESD(AliHLTTPCTrackArray* pTracks, AliESD* pESD);
+  int Tracks2ESD(AliHLTTPCTrackArray* pTracks, AliESDEvent* pESD);
 
   /** the ESD tree */
   TTree* fTree; //! transient value
 
   /** the ESD */
-  AliESD* fESD; //! transient value
+  AliESDEvent* fESD; //! transient value
 
-  ClassDef(AliHLTTPCEsdWriterComponent, 0)
+  ClassDef(AliHLTTPCEsdWriterComponent, 1)
 };
 #endif
index cca5297..62436d0 100644 (file)
@@ -90,7 +90,7 @@
 #endif // HAVE_THREAD
 #include <AliRunLoader.h>
 #include <AliRawEvent.h>
-#include <AliESD.h>
+#include <AliESDEvent.h>
 #include <AliESDHLTtrack.h>
 
 #if __GNUC__ >= 3
@@ -1393,7 +1393,7 @@ void AliHLTTPCHough::WriteTracks(Int_t slice,Char_t *path)
     }
 }
 
-Int_t AliHLTTPCHough::FillESD(AliESD *esd)
+Int_t AliHLTTPCHough::FillESD(AliESDEvent *esd)
 {
   // Fill the found hough transform tracks
   // into the ESD. The tracks are stored as
index d8d3c01..19eb717 100644 (file)
@@ -30,7 +30,7 @@ class TThread;
 #endif // HAVE_THREAD
 class AliRunLoader;
 class AliRawEvent;
-class AliESD;
+class AliESDEvent;
 class AliESDHLTtrack;
 
 /** 
@@ -79,7 +79,7 @@ class AliHLTTPCHough {
   void EvaluatePatch(Int_t i,Int_t roadwidth,Int_t nrowstomiss);
   void WriteTracks(Int_t slice,Char_t *path="./");
   void WriteTracks(Char_t *path);
-  Int_t FillESD(AliESD *esd);
+  Int_t FillESD(AliESDEvent *esd);
   void WriteDigits(Char_t *outfile="output_digits.root");
   void InitEvaluate();
   void DoBench(Char_t *filename);
index a789abc..d7d6eb7 100644 (file)
@@ -32,7 +32,7 @@
 //       Origin: Cvetan Cheshkov, CERN, Cvetan.Cheshkov@cern.ch
 //-------------------------------------------------------------------------
 
-#include "AliESD.h"
+#include "AliESDEvent.h"
 #include "AliRunLoader.h"
 #include "AliHLTTPCHoughTracker.h"
 #include "AliHLTTPCHough.h"
@@ -66,7 +66,7 @@ AliHLTTPCHoughTracker::AliHLTTPCHoughTracker(AliRunLoader *runLoader):AliTracker
   fRunLoader = runLoader;
 }
 
-Int_t AliHLTTPCHoughTracker::Clusters2Tracks(AliESD *event)
+Int_t AliHLTTPCHoughTracker::Clusters2Tracks(AliESDEvent *event)
 {
   //--------------------------------------------------------------------
   // This method reconstructs HLT TPC Hough tracks
index 995a078..fd0ad0f 100644 (file)
 #include "AliTracker.h"
 
 class AliRunLoader;
-class AliESD;
+class AliESDEvent;
 
 //-------------------------------------------------------------------------
 class AliHLTTPCHoughTracker : public AliTracker {
 public:
   AliHLTTPCHoughTracker(AliRunLoader *runLoader);
 
-  Int_t Clusters2Tracks(AliESD *event);
+  Int_t Clusters2Tracks(AliESDEvent *event);
 
-  Int_t PropagateBack(AliESD */*event*/) {return 0;}
-  Int_t RefitInward(AliESD */*event*/) {return 0;}
+  Int_t PropagateBack(AliESDEvent */*event*/) {return 0;}
+  Int_t RefitInward(AliESDEvent */*event*/) {return 0;}
   Int_t LoadClusters(TTree */*cf*/) {return 0;}
   void  UnloadClusters() {return;}
 
index 04b90eb..8991571 100644 (file)
@@ -33,7 +33,7 @@ using namespace std;
 
 #include "AliTRDclusterizerV1HLT.h"
 #include "AliTRDReconstructor.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
 #include "AliTRDtrackerHLT.h"
 #include "AliTRDCalibraFillHisto.h"
 #include "AliMagFMaps.h"
@@ -285,8 +285,8 @@ int AliHLTTRDTrackerComponent::DoEvent( const AliHLTComponentEventData & evtData
 
   AliTRDReconstructor::SetSeedingOn(kTRUE);
 
-  AliESD *esd = new AliESD();
-
+  AliESDEvent *esd = new AliESDEvent();
+  esd->CreateStdContent();
   //fTracker->MakeSeedsMI(3, 5, esd);
   fTracker->PropagateBack(esd);
 
index 26f3cc6..a7cb8be 100644 (file)
@@ -38,7 +38,7 @@
 #include <TTreeStream.h>
 
 #include "AliLog.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
 #include "AliAlignObj.h"
 #include "AliRieman.h"
 #include "AliTrackPointArray.h"
@@ -657,7 +657,7 @@ Int_t  AliTRDtrackerHLT::GetLastPlane(AliTRDtrack *track)
 }
 
 //_____________________________________________________________________________
-Int_t AliTRDtrackerHLT::Clusters2Tracks(AliESD *event)
+Int_t AliTRDtrackerHLT::Clusters2Tracks(AliESDEvent *event)
 {
   //
   // Finds tracks within the TRD. The ESD event is expected to contain seeds 
@@ -716,7 +716,7 @@ Int_t AliTRDtrackerHLT::Clusters2Tracks(AliESD *event)
 }     
      
 //_____________________________________________________________________________
-Int_t AliTRDtrackerHLT::PropagateBack(AliESD *event) 
+Int_t AliTRDtrackerHLT::PropagateBack(AliESDEvent *event) 
 {
   //
   // Gets seeds from ESD event. The seeds are AliTPCtrack's found and
@@ -1001,7 +1001,7 @@ Int_t AliTRDtrackerHLT::PropagateBack(AliESD *event)
 }
 
 //_____________________________________________________________________________
-Int_t AliTRDtrackerHLT::RefitInward(AliESD *event)
+Int_t AliTRDtrackerHLT::RefitInward(AliESDEvent *event)
 {
   //
   // Refits tracks within the TRD. The ESD event is expected to contain seeds 
@@ -1593,7 +1593,7 @@ void AliTRDtrackerHLT::UnloadClusters()
 }
 
 //_____________________________________________________________________________
-void AliTRDtrackerHLT::MakeSeedsMI(Int_t /*inner*/, Int_t /*outer*/, AliESD *esd)
+void AliTRDtrackerHLT::MakeSeedsMI(Int_t /*inner*/, Int_t /*outer*/, AliESDEvent *esd)
 {
   //
   // Creates  seeds using clusters between  position inner plane  and outer plane 
index 992c0ed..ae5e051 100644 (file)
@@ -27,7 +27,7 @@ class AliTRDtrack;
 class AliTRDtracklet;
 class AliTRDcluster;
 class AliTRDseed;
-class AliESD;
+class AliESDEvent;
 class TTreeSRedirector;
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -218,9 +218,9 @@ class AliTRDtrackerHLT : public AliTracker {
     return (AliCluster *) fClusters->UncheckedAt(index); }
   
   static  Int_t    Freq(Int_t n, const Int_t *inlist, Int_t *outlist, Bool_t down);    
-  Int_t    Clusters2Tracks(AliESD *event);
-  Int_t    PropagateBack(AliESD *event);
-  Int_t    RefitInward(AliESD *event);
+  Int_t    Clusters2Tracks(AliESDEvent *event);
+  Int_t    PropagateBack(AliESDEvent *event);
+  Int_t    RefitInward(AliESDEvent *event);
   
   virtual void     CookLabel(AliKalmanTrack *t, Float_t wrong) const;
   
@@ -236,7 +236,7 @@ class AliTRDtrackerHLT : public AliTracker {
   Int_t    FindClusters(Int_t sector, Int_t t0, Int_t t1, AliTRDtrack *track
                        , Int_t *clusters, AliTRDtracklet &tracklet);
 
-  void     MakeSeedsMI(Int_t inner, Int_t outer, AliESD *esd = 0);
+  void     MakeSeedsMI(Int_t inner, Int_t outer, AliESDEvent *esd = 0);
   
  protected:
       
index c65e541..2aff8ff 100644 (file)
@@ -1311,7 +1311,7 @@ void AliHLTHough::WriteTracks(Int_t slice,Char_t *path)
 }
 
 #ifdef use_aliroot
-Int_t AliHLTHough::FillESD(AliESD *esd)
+Int_t AliHLTHough::FillESD(AliESDEvent *esd)
 {
   // Fill the found hough transform tracks
   // into the ESD. The tracks are stored as
index bd36086..14743c3 100644 (file)
@@ -23,7 +23,7 @@ class AliHLTBenchmark;
 #include <../RAW/AliRawEvent.h>
 #endif
 #ifdef use_aliroot
-#include <AliESD.h>
+#include <AliESDEvent.h>
 #include <AliESDHLTtrack.h>
 #endif
 
@@ -61,7 +61,7 @@ class AliHLTHough {
   void WriteTracks(Int_t slice,Char_t *path="./");
   void WriteTracks(Char_t *path);
 #ifdef use_aliroot
-  Int_t FillESD(AliESD *esd);
+  Int_t FillESD(AliESDEvent *esd);
 #endif
   void WriteDigits(Char_t *outfile="output_digits.root");
   void InitEvaluate();
index 02ad44e..f26c4bb 100644 (file)
@@ -15,7 +15,7 @@
 #include <AliRunLoader.h>
 #include <AliHeader.h>
 #include <AliGenEventHeader.h>
-#include <AliESD.h>
+#include <AliESDEvent.h>
 #include <AliESDHLTtrack.h>
 
 #include "AliHLTStandardIncludes.h"
@@ -320,7 +320,7 @@ void AliHLTReconstructor::ReconstructWithHoughTransform(AliRunLoader* runLoader,
 }
 
 void AliHLTReconstructor::FillESD(AliRunLoader* runLoader, 
-                                 AliESD* esd) const
+                                 AliESDEvent* esd) const
 {
   //fill the esd file with found tracks
   if(!runLoader) {
@@ -345,7 +345,7 @@ void AliHLTReconstructor::FillESD(AliRunLoader* runLoader,
   */
 }
 
-void AliHLTReconstructor::FillESDforConformalMapping(AliESD* esd,Int_t iEvent) const
+void AliHLTReconstructor::FillESDforConformalMapping(AliESDEvent* esd,Int_t iEvent) const
 {
   //fill esd with tracks from conformal mapping
   /*
@@ -395,7 +395,7 @@ void AliHLTReconstructor::FillESDforConformalMapping(AliESD* esd,Int_t iEvent) c
   */
 }
 
-void AliHLTReconstructor::FillESDforHoughTransform(AliESD* esd,Int_t iEvent) const
+void AliHLTReconstructor::FillESDforHoughTransform(AliESDEvent* esd,Int_t iEvent) const
 {
   //fill esd with tracks from hough
   char filename[256];
index e3729d1..e60a8b1 100644 (file)
@@ -62,7 +62,7 @@ public:
 //  AliTracker*  CreateTracker(AliRunLoader*) const;
 
   /** fill esd for one event */
-  void FillESD(AliRunLoader* runLoader, AliESD* esd) const;
+  void FillESD(AliRunLoader* runLoader, AliESDEvent* esd) const;
 
   virtual void         Reconstruct(TTree* digitsTree, TTree* clustersTree) const{
     AliReconstructor::Reconstruct(digitsTree,clustersTree);
@@ -72,15 +72,15 @@ public:
   }
 
   virtual void         FillESD(TTree* digitsTree, TTree* clustersTree, 
-                              AliESD* esd) const {
+                              AliESDEvent* esd) const {
     AliReconstructor::FillESD(digitsTree,clustersTree,esd);
   }
   virtual void         FillESD(AliRawReader* rawReader, TTree* clustersTree, 
-                              AliESD* esd) const {
+                              AliESDEvent* esd) const {
     AliReconstructor::FillESD(rawReader,clustersTree,esd);
   }
   virtual void         FillESD(AliRunLoader* runLoader, 
-                              AliRawReader* rawReader, AliESD* esd) const {
+                              AliRawReader* rawReader, AliESDEvent* esd) const {
     AliReconstructor:: FillESD(runLoader,rawReader,esd);
   }
   void SetDoBench(Bool_t b){fDoBench=b;}
@@ -92,8 +92,8 @@ public:
 private:
   void ReconstructWithConformalMapping(AliRunLoader* runLoader,Int_t iEvent) const;
   void ReconstructWithHoughTransform(AliRunLoader* runLoader,Int_t iEvent) const;
-  void FillESDforConformalMapping(AliESD* esd,Int_t iEvent) const;
-  void FillESDforHoughTransform(AliESD* esd,Int_t iEvent) const;
+  void FillESDforConformalMapping(AliESDEvent* esd,Int_t iEvent) const;
+  void FillESDforHoughTransform(AliESDEvent* esd,Int_t iEvent) const;
 
   Bool_t fDoHough;   //do the hough transform
   Bool_t fDoTracker; //do the standard conformal tracker
index 842b35c..a4a1698 100644 (file)
@@ -24,7 +24,7 @@
 //       Origin: Cvetan Cheshkov, CERN, Cvetan.Cheshkov@cern.ch
 //-------------------------------------------------------------------------
 
-#include "AliESD.h"
+#include "AliESDEvent.h"
 #include "AliRunLoader.h"
 #include "AliHLTTPCtracker.h"
 #include "AliHLTHough.h"
@@ -45,7 +45,7 @@ AliHLTTPCtracker::AliHLTTPCtracker(AliRunLoader *runLoader):AliTracker()
   fRunLoader = runLoader;
 }
 
-Int_t AliHLTTPCtracker::Clusters2Tracks(AliESD *event)
+Int_t AliHLTTPCtracker::Clusters2Tracks(AliESDEvent *event)
 {
   //--------------------------------------------------------------------
   // This method reconstructs HLT TPC Hough tracks
index 0b74762..4ff25d8 100644 (file)
 #include "AliHLTTransform.h"
 
 class AliRunLoader;
-class AliESD;
+class AliESDEvent;
 
 //-------------------------------------------------------------------------
 class AliHLTTPCtracker : public AliTracker {
 public:
   AliHLTTPCtracker(AliRunLoader *runLoader);
 
-  Int_t Clusters2Tracks(AliESD *event);
+  Int_t Clusters2Tracks(AliESDEvent *event);
 
-  Int_t PropagateBack(AliESD */*event*/) {return 0;}
-  Int_t RefitInward(AliESD */*event*/) {return 0;}
+  Int_t PropagateBack(AliESDEvent */*event*/) {return 0;}
+  Int_t RefitInward(AliESDEvent */*event*/) {return 0;}
   Int_t LoadClusters(TTree */*cf*/) {return 0;}
   void  UnloadClusters() {return;}
 
index 0443f40..895971e 100644 (file)
@@ -2,7 +2,7 @@
 #include "AliHMPIDCluster.h"     //GetTrackPoint(),PropagateBack() 
 #include "AliHMPIDParam.h"       //GetTrackPoint(),PropagateBack()
 #include "AliHMPIDRecon.h"       //Recon()
-#include <AliESD.h>              //PropagateBack(),Recon()  
+#include <AliESDEvent.h>              //PropagateBack(),Recon()  
 #include <AliRun.h>              //GetTrackPoint(),PropagateBack()  
 #include <AliTrackPointArray.h>  //GetTrackPoint()
 #include <AliAlignObj.h>         //GetTrackPoint()
@@ -75,7 +75,7 @@ Int_t AliHMPIDTracker::LoadClusters(TTree *pCluTree)
   return 0;  
 }//LoadClusters()
 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-Int_t AliHMPIDTracker::PropagateBack(AliESD *pEsd)
+Int_t AliHMPIDTracker::PropagateBack(AliESDEvent *pEsd)
 {
 // Interface pure virtual in AliTracker. Invoked from AliReconstruction::RunTracking() after invocation of AliTracker::LoadClusters() once per event
 // Agruments: pEsd - pointer to ESD
@@ -88,7 +88,7 @@ Int_t AliHMPIDTracker::PropagateBack(AliESD *pEsd)
   return Recon(pEsd,fClu,(TObjArray*)pNmeanEnt->GetObject());  
 }//PropagateBack()
 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-Int_t AliHMPIDTracker::Recon(AliESD *pEsd,TObjArray *pClus,TObjArray *pNmean)
+Int_t AliHMPIDTracker::Recon(AliESDEvent *pEsd,TObjArray *pClus,TObjArray *pNmean)
 {
 // Static method to reconstruct Theta Ckov for all valid tracks of a given event.
 // Arguments: pEsd- pointer ESD; pClu- pointer to clusters for all chambers; pNmean - pointer to all function Nmean=f(time)
index a43bd8e..adb784c 100644 (file)
@@ -9,7 +9,7 @@
 // HMPID base class fo tracking
 //.
 
-class AliESD;      //Recon()     
+class AliESDEvent;      //Recon()     
 class AliESDtrack; //IntTrkCha()
 class AliHMPIDTracker : public AliTracker
 {
@@ -19,14 +19,14 @@ public:
 //framework part  
          AliCluster *GetCluster     (Int_t                      )const  {return 0;} //pure virtual from AliTracker 
          Bool_t      GetTrackPoint  (Int_t idx,AliTrackPoint &pt)const;             //             from AliTracker  
-         Int_t       Clusters2Tracks(AliESD *                   )       {return 0;} //pure virtual from AliTracker 
+         Int_t       Clusters2Tracks(AliESDEvent *                   )       {return 0;} //pure virtual from AliTracker 
          Int_t       LoadClusters   (TTree *pCluTr              );                  //pure virtual from AliTracker   
-         Int_t       PropagateBack  (AliESD *pEsd               );                  //pure virtual from AliTracker   
-         Int_t       RefitInward    (AliESD *                   )       {return 0;} //pure virtual from AliTracker 
+         Int_t       PropagateBack  (AliESDEvent *pEsd               );                  //pure virtual from AliTracker   
+         Int_t       RefitInward    (AliESDEvent *                   )       {return 0;} //pure virtual from AliTracker 
          void        UnloadClusters (                           )       {         } //pure virtual from AliTracker 
 //private part  
   static Int_t       IntTrkCha     (AliESDtrack *pTrk,Float_t &xPc,Float_t &yPc        );              //find track-PC intersection, retuns chamber ID
-  static Int_t       Recon         (AliESD *pEsd,TObjArray *pCluAll,TObjArray *pNmean=0);              //do actual job, returns status code  
+  static Int_t       Recon         (AliESDEvent *pEsd,TObjArray *pCluAll,TObjArray *pNmean=0);              //do actual job, returns status code  
   static Int_t       ReconHiddenTrk(Int_t iCh,AliESDtrack *pTrk,TClonesArray *pClus,TObjArray *pNmean);//do actual job with Hidden Track Algorithm    
 protected:
   TObjArray            *fClu;                     //! each chamber holds it's one list of clusters 
index 32d2e62..064dd22 100644 (file)
@@ -36,7 +36,7 @@
 #include "AliITSVertexer3D.h"
 #include "AliITSVertexerZ.h"
 #include "AliITSVertexerCosmics.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
 #include "AliITSpidESD.h"
 #include "AliITSpidESD1.h"
 #include "AliITSpidESD2.h"
@@ -235,7 +235,7 @@ AliVertexer* AliITSReconstructor::CreateVertexer(AliRunLoader* /*runLoader*/) co
 
 //_____________________________________________________________________________
 void AliITSReconstructor::FillESD(AliRunLoader* runLoader, 
-                                 AliESD* esd) const
+                                 AliESDEvent* esd) const
 {
 // make PID, find V0s and cascade
   AliITSLoader *loader = (AliITSLoader*)runLoader->GetLoader("ITSLoader");
index a216a8a..4f1bce7 100644 (file)
@@ -37,16 +37,16 @@ public:
 
   virtual AliTracker*  CreateTracker(AliRunLoader* runLoader) const;
   virtual AliVertexer* CreateVertexer(AliRunLoader* runLoader) const;
-  virtual void         FillESD(AliRunLoader* runLoader, AliESD* esd) const;
+  virtual void         FillESD(AliRunLoader* runLoader, AliESDEvent* esd) const;
 
   virtual void         FillESD(TTree* digitsTree, TTree* clustersTree, 
-                                AliESD* esd) const 
+                                AliESDEvent* esd) const 
     {AliReconstructor::FillESD(digitsTree, clustersTree, esd);}
   virtual void         FillESD(AliRawReader* rawReader, TTree* clustersTree, 
-                              AliESD* esd) const
+                              AliESDEvent* esd) const
     {AliReconstructor::FillESD(rawReader, clustersTree, esd);}
   virtual void         FillESD(AliRunLoader* runLoader, 
-                              AliRawReader* rawReader, AliESD* esd) const
+                              AliRawReader* rawReader, AliESDEvent* esd) const
     {AliReconstructor::FillESD(runLoader,rawReader, esd);}
 
   void SetRecoParam(AliITSRecoParam * param){ fgkRecoParam = param;}
index 06c0411..d880e8c 100644 (file)
 //#include <Rtypes.h>
 #include <TObject.h>
 
-class AliESD;
+class AliESDEvent;
 
 class AliITSpidESD : public TObject {
 public:
   AliITSpidESD();
   virtual ~AliITSpidESD() {}
-  virtual Int_t MakePID(AliESD *event) =0;
+  virtual Int_t MakePID(AliESDEvent *event) =0;
   static Double_t Bethe(Double_t p,Double_t mass);
 private:
   ClassDef(AliITSpidESD,1)   // ITS PID class
index 7455ba2..fbac039 100755 (executable)
@@ -21,7 +21,7 @@
 //-----------------------------------------------------------------
 #include "AliITSpidESD.h"
 #include "AliITSpidESD1.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
 #include "AliESDtrack.h"
 
 ClassImp(AliITSpidESD1)
@@ -44,7 +44,7 @@ fRange(param[1])
 
 
 //_________________________________________________________________________
-Int_t AliITSpidESD1::MakePID(AliESD *event)
+Int_t AliITSpidESD1::MakePID(AliESDEvent *event)
 {
   //
   //  This function calculates the "detector response" PID probabilities 
index a50efe8..1b84eb4 100755 (executable)
@@ -17,7 +17,7 @@ public:
   AliITSpidESD1();
   AliITSpidESD1(Double_t *param);
   virtual ~AliITSpidESD1() {}
-  virtual Int_t MakePID(AliESD *event);
+  virtual Int_t MakePID(AliESDEvent *event);
 
 private:
   Double_t fRes;          // relative dEdx resolution
index 3936844..cbf0966 100644 (file)
@@ -24,7 +24,7 @@
 //-----------------------------------------------------------------------//
 
 #include "AliITSpidESD2.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
 #include "AliESDtrack.h"
 #include "AliITStrackV2.h"
 #include "AliITSRecPoint.h"
@@ -81,7 +81,7 @@ AliITSpidESD2& AliITSpidESD2::operator=(const AliITSpidESD2& ob ){
 }
 
 //_________________________________________________________________________
-Int_t AliITSpidESD2::MakePID(AliESD *event)
+Int_t AliITSpidESD2::MakePID(AliESDEvent *event)
 {
 
   //
index f8c9168..9a83a86 100755 (executable)
@@ -23,7 +23,7 @@ public:
   AliITSpidESD2();
   AliITSpidESD2(AliITStrackerMI *tracker,AliITSLoader* loader);
   virtual ~AliITSpidESD2();
-  virtual Int_t MakePID(AliESD *event);
+  virtual Int_t MakePID(AliESDEvent *event);
   AliITSpidESD2(const AliITSpidESD2 &ob); // copy constructor
   AliITSpidESD2& operator=(const AliITSpidESD2 & source); // ass. op.
 
index 7b75bcf..bb64b9d 100644 (file)
@@ -29,7 +29,7 @@
 #include <TTreeStream.h>
 #include <TTree.h>
 
-#include "AliESD.h"
+#include "AliESDEvent.h"
 #include "AliV0.h"
 #include "AliHelix.h"
 #include "AliITSRecPoint.h"
@@ -303,7 +303,7 @@ static Int_t CorrectForDeadZoneMaterial(AliITStrackMI *t) {
   return 0;
 }
 //------------------------------------------------------------------------
-Int_t AliITStrackerMI::Clusters2Tracks(AliESD *event) {
+Int_t AliITStrackerMI::Clusters2Tracks(AliESDEvent *event) {
   //--------------------------------------------------------------------
   // This functions reconstructs ITS tracks
   // The clusters must be already loaded !
@@ -448,7 +448,7 @@ Int_t AliITStrackerMI::Clusters2Tracks(AliESD *event) {
   return 0;
 }
 //------------------------------------------------------------------------
-Int_t AliITStrackerMI::PropagateBack(AliESD *event) {
+Int_t AliITStrackerMI::PropagateBack(AliESDEvent *event) {
   //--------------------------------------------------------------------
   // This functions propagates reconstructed ITS tracks back
   // The clusters must be loaded !
@@ -507,7 +507,7 @@ Int_t AliITStrackerMI::PropagateBack(AliESD *event) {
   return 0;
 }
 //------------------------------------------------------------------------
-Int_t AliITStrackerMI::RefitInward(AliESD *event) {
+Int_t AliITStrackerMI::RefitInward(AliESDEvent *event) {
   //--------------------------------------------------------------------
   // This functions refits ITS tracks using the 
   // "inward propagated" TPC tracks
@@ -3507,7 +3507,7 @@ Int_t AliITStrackerMI::GetNearestLayer(const Double_t *xr) const{
   return res;
 }
 //------------------------------------------------------------------------
-void AliITStrackerMI::UpdateTPCV0(AliESD *event){
+void AliITStrackerMI::UpdateTPCV0(AliESDEvent *event){
   //
   //try to update, or reject TPC  V0s
   //
@@ -3618,7 +3618,7 @@ void AliITStrackerMI::UpdateTPCV0(AliESD *event){
   //
 }
 //------------------------------------------------------------------------
-void  AliITStrackerMI::FindV02(AliESD *event)
+void  AliITStrackerMI::FindV02(AliESDEvent *event)
 {
   //
   // V0 finder
@@ -4238,7 +4238,7 @@ void  AliITStrackerMI::FindV02(AliESD *event)
   delete   pvertex;
 }
 //------------------------------------------------------------------------
-void AliITStrackerMI::RefitV02(AliESD *event)
+void AliITStrackerMI::RefitV02(AliESDEvent *event)
 {
   //
   //try to refit  V0s in the third path of the reconstruction
index 1778c98..b29df85 100644 (file)
@@ -13,7 +13,7 @@
 
 class TTree;
 class TTreeSRedirector;
-class AliESD;
+class AliESDEvent;
 
 #include <TObjArray.h>
 #include "AliITSRecPoint.h"
@@ -34,9 +34,9 @@ public:
                         {return fgLayers[layn].GetNumberOfClusters();}
   Int_t LoadClusters(TTree *cf);
   void UnloadClusters();
-  Int_t Clusters2Tracks(AliESD *event);
-  Int_t PropagateBack(AliESD *event);
-  Int_t RefitInward(AliESD *event);
+  Int_t Clusters2Tracks(AliESDEvent *event);
+  Int_t PropagateBack(AliESDEvent *event);
+  Int_t RefitInward(AliESDEvent *event);
   Bool_t RefitAt(Double_t x, AliITStrackMI *seed, 
                 const AliITStrackMI *t, Bool_t extra=kFALSE);
   Bool_t RefitAt(Double_t x, AliITStrackMI *seed, const Int_t *clindex);
@@ -173,9 +173,9 @@ public:
 
 protected:
   Int_t GetNearestLayer(const Double_t *xr) const;  //get nearest upper layer close to the point xr
-  void FindV02(AliESD *event);  //try to find V0
-  void RefitV02(AliESD *event);  //try to refit  V0's
-  void UpdateTPCV0(AliESD *event);  //try to update, or reject TPC  V0s
+  void FindV02(AliESDEvent *event);  //try to find V0
+  void RefitV02(AliESDEvent *event);  //try to refit  V0's
+  void UpdateTPCV0(AliESDEvent *event);  //try to update, or reject TPC  V0s
   void CookLabel(AliKalmanTrack *t,Float_t wrong) const;
   void CookLabel(AliITStrackMI *t,Float_t wrong) const;
   Double_t GetEffectiveThickness(Double_t y, Double_t z) const;
@@ -229,12 +229,12 @@ protected:
   Int_t fLayersNotToSkip[kMaxLayer];     // layer masks
   Int_t fLastLayerToTrackTo;             // the innermost layer to track to
   Float_t * fCoeficients;                //! working array with errors and mean cluser shape
-  AliESD  * fEsd;                        //! pointer to the ESD event
+  AliESDEvent  * fEsd;                        //! pointer to the ESD event
   TTreeSRedirector *fDebugStreamer;     //!debug streamer
 private:
   AliITStrackerMI(const AliITStrackerMI &tracker);
   AliITStrackerMI & operator=(const AliITStrackerMI &tracker);
-  ClassDef(AliITStrackerMI,2)   //ITS tracker MI
+  ClassDef(AliITStrackerMI,3)   //ITS tracker MI
 };
 
 
index 257139f..80201cd 100644 (file)
@@ -29,7 +29,7 @@
 #include <TObjArray.h>
 #include <TTree.h>
 
-#include "AliESD.h"
+#include "AliESDEvent.h"
 #include "AliESDVertex.h"
 #include "AliESDtrack.h"
 #include "AliITSVertexer.h"
@@ -234,7 +234,7 @@ AliITStrackerSA::~AliITStrackerSA(){
 }
 
 //____________________________________________________________________________
-Int_t AliITStrackerSA::Clusters2Tracks(AliESD *event){
+Int_t AliITStrackerSA::Clusters2Tracks(AliESDEvent *event){
 // This method is used to find and fit the tracks. By default the corresponding
 // method in the parent class is invoked. In this way a combined tracking
 // TPC+ITS is performed. If the flag fITSStandAlone is true, the tracking
@@ -291,7 +291,7 @@ void AliITStrackerSA::ResetForFinding(){
  
 
 //______________________________________________________________________
-Int_t AliITStrackerSA::FindTracks(AliESD* event){
+Int_t AliITStrackerSA::FindTracks(AliESDEvent* event){
 
 // Track finder using the ESD object
 
index aa9344a..48691ee 100644 (file)
@@ -19,6 +19,7 @@ class AliITStrackSA;
 class AliESDVertex;
 class AliITSVertexer;
 class TTree;
+class AliESDEvent;
 class TArrayD;
 
 class AliITStrackerSA : public AliITStrackerMI {
@@ -33,8 +34,8 @@ class AliITStrackerSA : public AliITStrackerMI {
   AliITStrackerSA(const AliITStrackerSA& tracker);
   AliITStrackerSA& operator=(const AliITStrackerSA& source);
   virtual ~AliITStrackerSA();  
-  virtual Int_t Clusters2Tracks(AliESD *event);
-  Int_t FindTracks(AliESD* event);
+  virtual Int_t Clusters2Tracks(AliESDEvent *event);
+  Int_t FindTracks(AliESDEvent* event);
 
   AliITStrackV2* FitTrack(AliITStrackSA* tr,Double_t* primaryVertex);
 
@@ -107,7 +108,7 @@ class AliITStrackerSA : public AliITStrackerMI {
   TClonesArray** fCluLayer; //! array with clusters 
   TClonesArray** fCluCoord; //! array with cluster info
 
-  ClassDef(AliITStrackerSA,4)
+  ClassDef(AliITStrackerSA,5)
 };
 
 #endif
index 09e17ce..0f5abc8 100644 (file)
@@ -32,7 +32,7 @@
 #include "AliITSgeomTGeo.h"
 #include "AliAlignObj.h"
 #include "AliITSRecPoint.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
 #include "AliITSRecPoint.h"
 #include "AliITSReconstructor.h"
 #include "AliITStrackerV2.h"
@@ -263,7 +263,7 @@ static Int_t CorrectForDeadZoneMaterial(AliITStrackV2 *t) {
   return 0;
 }
 
-Int_t AliITStrackerV2::Clusters2Tracks(AliESD *event) {
+Int_t AliITStrackerV2::Clusters2Tracks(AliESDEvent *event) {
   //--------------------------------------------------------------------
   // This functions reconstructs ITS tracks
   // The clusters must be already loaded !
@@ -346,7 +346,7 @@ Int_t AliITStrackerV2::Clusters2Tracks(AliESD *event) {
   return 0;
 }
 
-Int_t AliITStrackerV2::PropagateBack(AliESD *event) {
+Int_t AliITStrackerV2::PropagateBack(AliESDEvent *event) {
   //--------------------------------------------------------------------
   // This functions propagates reconstructed ITS tracks back
   // The clusters must be loaded !
@@ -404,7 +404,7 @@ Int_t AliITStrackerV2::PropagateBack(AliESD *event) {
   return 0;
 }
 
-Int_t AliITStrackerV2::RefitInward(AliESD *event) {
+Int_t AliITStrackerV2::RefitInward(AliESDEvent *event) {
   //--------------------------------------------------------------------
   // This functions refits ITS tracks using the 
   // "inward propagated" TPC tracks
index a79ff5a..8277a3b 100644 (file)
@@ -13,7 +13,7 @@
 #include "AliITStrackV2.h"
 
 class AliITSRecPoint;
-class AliESD;
+class AliESDEvent;
 class TTree;
 
 
@@ -32,9 +32,9 @@ public:
   }   
   Int_t LoadClusters(TTree *cf);
   void UnloadClusters();
-  Int_t Clusters2Tracks(AliESD *event);
-  Int_t PropagateBack(AliESD *event);
-  Int_t RefitInward(AliESD *event);
+  Int_t Clusters2Tracks(AliESDEvent *event);
+  Int_t PropagateBack(AliESDEvent *event);
+  Int_t RefitInward(AliESDEvent *event);
   Bool_t RefitAt(Double_t x, AliITStrackV2 *seed, 
                  const AliITStrackV2 *t, Bool_t extra=kFALSE);
   void SetupFirstPass(Int_t *flags, Double_t *cuts=0);
index 02618c8..6e2970c 100644 (file)
@@ -12,7 +12,7 @@ class TFolder;
 class TTree;
 class AliRunLoader;
 class AliRawReader;
-class AliESD;
+class AliESDEvent;
 class AliMonitorTrend;
 
 
@@ -25,7 +25,7 @@ public:
   virtual void     CreateBranches(TTree* tree);
   virtual void     FillHistos(AliRunLoader* runLoader, 
                              AliRawReader* rawReader,
-                             AliESD* esd) = 0;
+                             AliESDEvent* esd) = 0;
 
 protected:
   TFolder*         fFolder;    // sub folder for monitor histograms
index 296e5a8..2b6ab6a 100644 (file)
@@ -148,7 +148,7 @@ void AliMonitorHLT::CreateHistos(TFolder* folder)
 
 //_____________________________________________________________________________
 void AliMonitorHLT::FillHistos(AliRunLoader* /*runLoader*/, 
-                              AliRawReader* /*rawReader*/, AliESD* /*esd*/)
+                              AliRawReader* /*rawReader*/, AliESDEvent* /*esd*/)
 {
 // fill the HLT monitor histogrms
 
index 85414f7..a0ded5d 100644 (file)
@@ -17,7 +17,7 @@ public:
 
   virtual void     CreateHistos(TFolder* folder);
   virtual void     FillHistos(AliRunLoader* runLoader, 
-                             AliRawReader* rawReader, AliESD* esd);
+                             AliRawReader* rawReader, AliESDEvent* esd);
 
 private:
   AliMonitorHLT(const AliMonitorHLT& monitor);
index 5b95e35..4f0d8fe 100644 (file)
@@ -126,7 +126,7 @@ void AliMonitorHLTHough::CreateHistos(TFolder* folder)
 //_____________________________________________________________________________
 void AliMonitorHLTHough::FillHistos(AliRunLoader* /*runLoader*/, 
                                    AliRawReader* /*rawReader*/, 
-                                   AliESD* /*esd*/)
+                                   AliESDEvent* /*esd*/)
 {
 // fill the HLT Hough transform monitor histograms
 
index 7d65e5b..cf010c7 100644 (file)
@@ -15,7 +15,7 @@ public:
 
   virtual void     CreateHistos(TFolder* folder);
   virtual void     FillHistos(AliRunLoader* runLoader, 
-                             AliRawReader* rawReader, AliESD* esd);
+                             AliRawReader* rawReader, AliESDEvent* esd);
 
 private:
   AliMonitorHLTHough(const AliMonitorHLTHough& monitor);
index 21344bd..95c6508 100644 (file)
@@ -26,7 +26,7 @@
 #include <TVector3.h>
 
 #include "AliLog.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
 #include "AliITSRawStreamSDD.h"
 #include "AliITSRawStreamSSD.h"
 #include "AliITSclusterV2.h"
@@ -150,7 +150,7 @@ void AliMonitorITS::CreateHistos(TFolder* folder)
 
 //_____________________________________________________________________________
 void AliMonitorITS::FillHistos(AliRunLoader* runLoader, 
-                              AliRawReader* rawReader, AliESD* esd)
+                              AliRawReader* rawReader, AliESDEvent* esd)
 {
 // fill the ITS monitor histogrms
 
index 6f7aa67..3ab401c 100644 (file)
@@ -17,7 +17,7 @@ public:
 
   virtual void     CreateHistos(TFolder* folder);
   virtual void     FillHistos(AliRunLoader* runLoader, 
-                             AliRawReader* rawReader, AliESD* esd);
+                             AliRawReader* rawReader, AliESDEvent* esd);
 
 private:
   AliMonitorITS(const AliMonitorITS& monitor);
index 779e067..ae24633 100644 (file)
@@ -34,7 +34,7 @@
 #include <TSocket.h>
 
 #include "AliLog.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
 #include "AliITSclustererV2.h"
 #include "AliITSgeom.h"
 #include "AliITStrackerV2.h"
@@ -458,7 +458,7 @@ Bool_t AliMonitorProcess::ProcessFile()
     AliInfo(Form("run: %d  event: %d %d\n", rawReader.GetRunNumber(),
                 rawReader.GetEventId()[0], rawReader.GetEventId()[1]));
 
-    AliESD esd;
+    AliESDEvent esd;
     if (IsSelected("TPC")) {
       CheckForConnections();
       if (!ReconstructTPC(&rawReader, &esd)) return kFALSE;
@@ -597,7 +597,7 @@ Int_t AliMonitorProcess::GetNumberOfEvents(const char* fileName) const
 }
 
 //_____________________________________________________________________________
-Bool_t AliMonitorProcess::ReconstructTPC(AliRawReader* rawReader, AliESD* esd)
+Bool_t AliMonitorProcess::ReconstructTPC(AliRawReader* rawReader, AliESDEvent* esd)
 {
 // find TPC clusters and tracks
 
@@ -631,7 +631,7 @@ Bool_t AliMonitorProcess::ReconstructTPC(AliRawReader* rawReader, AliESD* esd)
 }
 
 //_____________________________________________________________________________
-Bool_t AliMonitorProcess::ReconstructITS(AliRawReader* rawReader, AliESD* esd)
+Bool_t AliMonitorProcess::ReconstructITS(AliRawReader* rawReader, AliESDEvent* esd)
 {
 // find ITS clusters and tracks
 
@@ -663,7 +663,7 @@ Bool_t AliMonitorProcess::ReconstructITS(AliRawReader* rawReader, AliESD* esd)
 }
 
 //_____________________________________________________________________________
-Bool_t AliMonitorProcess::ReconstructV0s(AliESD* esd)
+Bool_t AliMonitorProcess::ReconstructV0s(AliESDEvent* esd)
 {
 // find V0s
 
index b833893..36fa68e 100644 (file)
@@ -18,7 +18,7 @@ class TTree;
 #include <TString.h>
 #include <TSystem.h>
 
-class AliESD;
+class AliESDEvent;
 class AliITSgeom;
 class AliRawReader;
 class AliRunLoader;
@@ -74,9 +74,9 @@ private:
   Bool_t           CheckForNewFile();
   Bool_t           ProcessFile();
   Int_t            GetNumberOfEvents(const char* fileName) const;
-  Bool_t           ReconstructTPC(AliRawReader* rawReader, AliESD* esd);
-  Bool_t           ReconstructITS(AliRawReader* rawReader, AliESD* esd);
-  Bool_t           ReconstructV0s(AliESD* esd);
+  Bool_t           ReconstructTPC(AliRawReader* rawReader, AliESDEvent* esd);
+  Bool_t           ReconstructITS(AliRawReader* rawReader, AliESDEvent* esd);
+  Bool_t           ReconstructV0s(AliESDEvent* esd);
   void             CreateHLT(const char* fileName);
   void             CreateHLTHough(const char* fileName);
   Bool_t           ReconstructHLT(Int_t iEvent);
index c1063cc..d29efdf 100644 (file)
@@ -26,7 +26,7 @@
 #include <TVector3.h>
 
 #include "AliLog.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
 #include "AliMonitorDataTPC.h"
 #include "AliMonitorHisto.h"
 #include "AliMonitorTPC.h"
@@ -155,7 +155,7 @@ void AliMonitorTPC::CreateBranches(TTree* tree)
 
 //_____________________________________________________________________________
 void AliMonitorTPC::FillHistos(AliRunLoader* runLoader, 
-                              AliRawReader* rawReader, AliESD* esd)
+                              AliRawReader* rawReader, AliESDEvent* esd)
 {
 // fill the TPC monitor histogrms
 
index 8a20727..3f374c0 100644 (file)
@@ -19,7 +19,7 @@ public:
   virtual void     CreateHistos(TFolder* folder);
   virtual void     CreateBranches(TTree* tree);
   virtual void     FillHistos(AliRunLoader* runLoader, 
-                             AliRawReader* rawReader, AliESD* esd);
+                             AliRawReader* rawReader, AliESDEvent* esd);
 
 private:
   AliMonitorTPC(const AliMonitorTPC& monitor);
index e894557..34d7bbf 100644 (file)
@@ -24,7 +24,7 @@
 
 #include "AliMonitorV0s.h"
 #include "AliMonitorHisto.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
 #include "AliLog.h"
 #include <TFolder.h>
 #include <TPDGCode.h>
@@ -75,7 +75,7 @@ void AliMonitorV0s::CreateHistos(TFolder* folder)
 
 //_____________________________________________________________________________
 void AliMonitorV0s::FillHistos(AliRunLoader* /*runLoader*/, 
-                              AliRawReader*, AliESD* esd)
+                              AliRawReader*, AliESDEvent* esd)
 {
 // fill the V0s monitor histogrms
 
index 5fee83e..fd9918b 100644 (file)
@@ -15,7 +15,7 @@ public:
 
   virtual void     CreateHistos(TFolder* folder);
   virtual void     FillHistos(AliRunLoader* runLoader, 
-                             AliRawReader* rawReader, AliESD* esd);
+                             AliRawReader* rawReader, AliESDEvent* esd);
 
 private:
   AliMonitorV0s(const AliMonitorV0s& monitor);
index c813b7c..823e090 100644 (file)
@@ -104,7 +104,8 @@ int main(int argc, char** argv)
   if (!AliHLTTransform::Init("./", kFALSE)) {
     ::Fatal("AliHLTTransform::Init", "HLT initialization failed");
   }
-  AliESD *esd = new AliESD;
+  AliESDEvent *esd = new AliESDEvent;
+  esd->CreateStdContent();
   //  AliKalmanTrack::SetConvConst(
   //     1000/0.299792458/AliHLTTransform::GetSolenoidField()
   //  );
index 68269e3..c4acc3d 100644 (file)
@@ -46,7 +46,7 @@
 #include "AliStack.h"
 #include "AliTrackReference.h"
 #include "AliTracker.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
 #include "AliESDMuonTrack.h"
 #include "AliMagFMaps.h"
 #include "AliLog.h"
@@ -150,7 +150,7 @@ AliMUONCheck::CheckESD(Bool_t pdc06TriggerResponse)
   Double_t fPxRec1, fPyRec1, fPzRec1, fE1;
   Int_t fZ1;
   
-  AliESD* fESD = new AliESD();
+  AliESDEvent* fESD = new AliESDEvent();
   TTree* tree = (TTree*) esdFile->Get("esdTree");
   if (!tree) 
   {
index 211e2a9..00912ac 100644 (file)
@@ -19,7 +19,7 @@
 #  include "TString.h"
 #endif
 
-class AliESD;
+class AliESDEvent;
 class TTree;
 class TH1F ;
 
index 0570f94..54ab081 100644 (file)
@@ -38,7 +38,7 @@
 #include "AliMUONVClusterStore.h"
 #include "AliMUONVTriggerStore.h"
 
-#include "AliESD.h"
+#include "AliESDEvent.h"
 #include "AliESDMuonTrack.h"
 #include "AliESDVertex.h"
 #include "AliLoader.h"
@@ -113,7 +113,7 @@ AliMUONTracker::LoadClusters(TTree* clustersTree)
 
 //_____________________________________________________________________________
 Int_t
-AliMUONTracker::Clusters2Tracks(AliESD* esd)
+AliMUONTracker::Clusters2Tracks(AliESDEvent* esd)
 {
   /// Performs the tracking and store the resulting tracks in both
   /// the TreeT and the ESD
@@ -145,7 +145,7 @@ AliMUONTracker::Clusters2Tracks(AliESD* esd)
 }
 
 //_____________________________________________________________________________
-Int_t AliMUONTracker::Clusters2Tracks(TTree& tracksTree, AliESD* esd)
+Int_t AliMUONTracker::Clusters2Tracks(TTree& tracksTree, AliESDEvent* esd)
 {
   /// Performs the tracking
   
@@ -195,7 +195,7 @@ Int_t AliMUONTracker::Clusters2Tracks(TTree& tracksTree, AliESD* esd)
 
 //_____________________________________________________________________________
 void 
-AliMUONTracker::FillESD(AliMUONVTrackStore& trackStore, AliESD* esd) const
+AliMUONTracker::FillESD(AliMUONVTrackStore& trackStore, AliESDEvent* esd) const
 {
   /// Fill the ESD from the trackStore
   
index 0d9f835..4f8e35f 100644 (file)
@@ -13,7 +13,7 @@
 #include "AliTracker.h"
 
 class AliCluster;
-class AliESD;
+class AliESDEvent;
 class AliLoader;
 class AliMUONDigitMaker;
 class AliMUONGeometryTransformer;
@@ -37,7 +37,7 @@ class AliMUONTracker : public AliTracker
   virtual ~AliMUONTracker();
   
   /// Main entry point.
-  virtual Int_t Clusters2Tracks(AliESD* esd);
+  virtual Int_t Clusters2Tracks(AliESDEvent* esd);
 
   /// 
   virtual Int_t LoadClusters(TTree* clustersTree);
@@ -46,9 +46,9 @@ class AliMUONTracker : public AliTracker
   virtual void  UnloadClusters();
 
   /// Dummy implementation
-  virtual Int_t PropagateBack(AliESD* /*event*/) {return 0;}
+  virtual Int_t PropagateBack(AliESDEvent* /*event*/) {return 0;}
   /// Dummy implementation
-  virtual Int_t RefitInward(AliESD* /*event*/) {return 0;}
+  virtual Int_t RefitInward(AliESDEvent* /*event*/) {return 0;}
   /// Dummy implementation
   virtual AliCluster *GetCluster(Int_t /*index*/) const {return 0;}
   /// Set option
@@ -60,9 +60,9 @@ private:
   /// Not implemented
   AliMUONTracker& operator=(const AliMUONTracker& rhs);
     
-  Int_t Clusters2Tracks(TTree& tracksTree, AliESD* esd);
+  Int_t Clusters2Tracks(TTree& tracksTree, AliESDEvent* esd);
 
-  void FillESD(AliMUONVTrackStore& trackStore, AliESD* esd) const;
+  void FillESD(AliMUONVTrackStore& trackStore, AliESDEvent* esd) const;
 
 private:
   AliLoader* fLoader; //!< loader to get access to trees
index 54fa111..b5f879c 100644 (file)
@@ -8,6 +8,9 @@
 /* History of cvs commits:
  *
  * $Log$
+ * Revision 1.38  2007/04/01 15:40:15  kharlov
+ * Correction for actual vertex position implemented
+ *
  * Revision 1.37  2006/08/29 11:41:19  kharlov
  * Missing implementation of ctors and = operator are added
  *
@@ -36,7 +39,7 @@ class TClonesArray ;
 // --- Standard library ---
 
 // --- AliRoot header files ---
-class AliESD ;
+class AliESDEvent ;
 class AliPHOSGeometry ;
 class AliPHOSClusterizer ;
 class AliPHOSTrackSegmentMaker ;
@@ -62,7 +65,7 @@ class AliPHOSPID : public TTask {
   Int_t   GetFirstEvent()      const {return fFirstEvent;     }
   Int_t   GetLastEvent()       const {return fLastEvent;      }
 
-  void SetESD(AliESD *esd) { fESD = esd; }
+  void SetESD(AliESDEvent *esd) { fESD = esd; }
 
   virtual const char * Version() const { Warning("Version", "not defined" ) ; return 0 ; }  
   virtual void WriteRecParticles() = 0;
@@ -71,12 +74,12 @@ protected:
   TString fEventFolderName ;  // event folder name
   Int_t   fFirstEvent;        // first event to process
   Int_t   fLastEvent;         // last  event to process
-  AliESD * fESD;              //! ESD object
+  AliESDEvent * fESD;              //! ESD object
 
 private: 
   virtual void Init() { Warning("Init", "not defined" ) ; } 
 
-  ClassDef(AliPHOSPID,4)  // Particle Identifier algorithm (base class)
+  ClassDef(AliPHOSPID,5)  // Particle Identifier algorithm (base class)
 
 } ;
 
index 48eabe6..3bf9e6c 100644 (file)
@@ -18,6 +18,9 @@
 /* History of cvs commits:
  *
  * $Log$
+ * Revision 1.111  2007/05/04 14:49:29  policheh
+ * AliPHOSRecPoint inheritance from AliCluster
+ *
  * Revision 1.110  2007/04/24 10:08:03  kharlov
  * Vertex extraction from GenHeader
  *
 #include "AliPHOS.h"
 #include "AliPHOSPIDv1.h"
 #include "AliPHOSGetter.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
 #include "AliESDVertex.h"
 #include "AliHeader.h"
 #include "AliGenEventHeader.h"
index 7c27fcb..d4bbcc3 100644 (file)
@@ -26,7 +26,7 @@
 // --- Standard library ---
 
 // --- AliRoot header files ---
-#include "AliESD.h"
+#include "AliESDEvent.h"
 #include "AliPHOSReconstructor.h"
 #include "AliPHOSClusterizerv1.h"
 #include "AliPHOSTrackSegmentMakerv1.h"
@@ -60,7 +60,7 @@ void AliPHOSReconstructor::Reconstruct(AliRunLoader* runLoader) const
 {
   // method called by AliReconstruction; 
   // Only the clusterization is performed,; the rest of the reconstruction is done in FillESD because the track
-  // segment maker needs access to the AliESD object to retrieve the tracks reconstructed by 
+  // segment maker needs access to the AliESDEvent object to retrieve the tracks reconstructed by 
   // the global tracking.
  
   TString headerFile(runLoader->GetFileName()) ; 
@@ -80,7 +80,7 @@ void AliPHOSReconstructor::Reconstruct(AliRunLoader* runLoader, AliRawReader* ra
 {
   // method called by AliReconstruction; 
   // Only the clusterization is performed,; the rest of the reconstruction is done in FillESD because the track
-  // segment maker needs access to the AliESD object to retrieve the tracks reconstructed by 
+  // segment maker needs access to the AliESDEvent object to retrieve the tracks reconstructed by 
   // the global tracking.
   // Here we reconstruct from Raw Data
 
@@ -104,7 +104,7 @@ void AliPHOSReconstructor::Reconstruct(AliRunLoader* runLoader, AliRawReader* ra
 }
 
 //____________________________________________________________________________
-void AliPHOSReconstructor::FillESD(AliRunLoader* runLoader, AliESD* esd) const
+void AliPHOSReconstructor::FillESD(AliRunLoader* runLoader, AliESDEvent* esd) const
 {
   // This function creates AliESDtracks from AliPHOSRecParticles
   //         and
@@ -263,7 +263,7 @@ void AliPHOSReconstructor::FillESD(AliRunLoader* runLoader, AliESD* esd) const
 
 //____________________________________________________________________________
 void AliPHOSReconstructor::FillESD(AliRunLoader* runLoader,
-                                  AliRawReader* rawReader, AliESD* esd) const
+                                  AliRawReader* rawReader, AliESDEvent* esd) const
 {
   //This function creates AliESDtracks from AliPHOSRecParticles 
   //and writes them to the ESD in the case of raw data reconstruction.
index 2d5ac84..2dc3486 100644 (file)
@@ -8,6 +8,9 @@
 /* History of cvs commits:
  *
  * $Log$
+ * Revision 1.9  2006/11/15 16:05:03  kharlov
+ * New FillESD() for raw data is added
+ *
  * Revision 1.8  2005/05/28 14:19:04  schutz
  * Compilation warnings fixed by T.P.
  *
@@ -29,7 +32,7 @@ class AliPHOSClusterizer ;
 class AliPHOSTrackSegmentMaker ;
 class AliPHOSPID ;
 class AliPHOSSDigitizer ;
-class AliESD ;
+class AliESDEvent ;
 class AliRawReader; 
 
 // --- Standard library ---
@@ -52,8 +55,8 @@ public:
   static Bool_t              Debug() { return fgDebug ; }
   AliTracker *CreateTracker(AliRunLoader* runLoader) const;
   using AliReconstructor::FillESD;
-  virtual void               FillESD(AliRunLoader* runLoader, AliESD* esd) const ;
-  virtual void FillESD(AliRunLoader* runLoader,AliRawReader* rawReader,AliESD* esd) const;
+  virtual void               FillESD(AliRunLoader* runLoader, AliESDEvent* esd) const ;
+  virtual void FillESD(AliRunLoader* runLoader,AliRawReader* rawReader,AliESDEvent* esd) const;
   using AliReconstructor::Reconstruct;
   virtual void               Reconstruct(AliRunLoader* runLoader) const ;
   virtual void               Reconstruct(AliRunLoader* runLoader, AliRawReader * rawreader) const ;
index 8042dbb..3deb8c5 100644 (file)
@@ -8,6 +8,9 @@
 /* History of cvs commits:
  *
  * $Log$
+ * Revision 1.40  2006/08/29 11:41:19  kharlov
+ * Missing implementation of ctors and = operator are added
+ *
  * Revision 1.39  2006/08/25 16:00:53  kharlov
  * Compliance with Effective C++AliPHOSHit.cxx
  *
@@ -36,7 +39,7 @@ class TFile ;
 
 class AliPHOSClusterizer ;
 class AliPHOSGeometry ;
-class AliESD ;
+class AliESDEvent ;
 
 class  AliPHOSTrackSegmentMaker : public TTask {
 
@@ -55,12 +58,12 @@ public:
 
   void SetEventRange(Int_t first=0, Int_t last=-1) {fFirstEvent=first; fLastEvent=last; }
   void SetEventFolderName(TString name) { fEventFolderName = name ; }
-  void SetESD(AliESD *esd) { fESD = esd; }
+  void SetESD(AliESDEvent *esd) { fESD = esd; }
 
   TString GetEventFolderName() const {return fEventFolderName;}
   Int_t   GetFirstEvent()      const {return fFirstEvent;     }
   Int_t   GetLastEvent()       const {return fLastEvent;      }
-  AliESD *GetESD()             const {return fESD;            }
+  AliESDEvent *GetESD()             const {return fESD;            }
 
   virtual void WriteTrackSegments() = 0;
   
@@ -68,9 +71,9 @@ protected:
   TString fEventFolderName ;  // event folder name
   Int_t   fFirstEvent;        // first event to process
   Int_t   fLastEvent;         // last  event to process
-  AliESD * fESD;              //! ESD object
+  AliESDEvent * fESD;              //! ESD object
 
-  ClassDef( AliPHOSTrackSegmentMaker,4)  // Algorithm class to make PHOS track segments (Base Class)
+  ClassDef( AliPHOSTrackSegmentMaker,5)  // Algorithm class to make PHOS track segments (Base Class)
 };
 
 #endif // ALIPHOSTRACKSEGMENTMAKER_H
index ae43b97..23a90d3 100644 (file)
@@ -17,6 +17,9 @@
 /* History of cvs commits:
  *
  * $Log$
+ * Revision 1.89  2007/07/03 08:13:04  kharlov
+ * Bug fix in CPV local coordinates
+ *
  * Revision 1.88  2007/06/27 09:11:07  kharlov
  * Bug fix for CPV-EMC distance
  *
 #include "AliPHOSTrackSegment.h"
 #include "AliPHOSLink.h"
 #include "AliPHOSGetter.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
 #include "AliESDtrack.h"
 
 ClassImp( AliPHOSTrackSegmentMakerv1) 
index 70900bb..e976b45 100644 (file)
@@ -17,6 +17,9 @@
 /* History of cvs commits:
  *
  * $Log$
+ * Revision 1.4  2007/05/04 14:49:29  policheh
+ * AliPHOSRecPoint inheritance from AliCluster
+ *
  * Revision 1.3  2007/04/25 19:39:42  kharlov
  * Track extracpolation improved
  *
@@ -68,7 +71,7 @@
 #include "AliPHOSTrackSegment.h"
 #include "AliPHOSLink.h"
 #include "AliPHOSGetter.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
 #include "AliESDtrack.h"
 
 ClassImp( AliPHOSTrackSegmentMakerv2) 
index dbb8053..4da6db5 100644 (file)
@@ -4,19 +4,19 @@
 #include "AliPHOSTrackSegmentMakerv2.h"
 #include "AliPHOSPIDv1.h"
 #include "AliRunLoader.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
 
 //-------------------------------------------------------------------------
 //                          PHOS tracker.
 // Matches ESD tracks with the PHOS and makes the PID.  
-// Currently, has only one function implemented : PropagateBack(AliESD*)
+// Currently, has only one function implemented : PropagateBack(AliESDEvent*)
 //-------------------------------------------------------------------------
 
 ClassImp(AliPHOSTracker)
 
 Bool_t AliPHOSTracker::fgDebug = kFALSE ; 
 
-Int_t AliPHOSTracker::PropagateBack(AliESD *esd) {
+Int_t AliPHOSTracker::PropagateBack(AliESDEvent *esd) {
   // Called by AliReconstruction 
   // Creates the tracksegments and Recparticles
   // Makes the PID
index c081b27..e3849e9 100644 (file)
@@ -11,7 +11,7 @@
 #include <AliLog.h>
 
 class AliCluster;
-class AliESD;
+class AliESDEvent;
 class TTree;
 class AliRunLoader;
 
@@ -30,11 +30,11 @@ public:
     return *this;
   }
 
-  Int_t Clusters2Tracks(AliESD *) {AliDebug(1,"Start.");return 0;}
-  Int_t RefitInward(AliESD *)     {AliDebug(1,"Start.");return 0;}
+  Int_t Clusters2Tracks(AliESDEvent *) {AliDebug(1,"Start.");return 0;}
+  Int_t RefitInward(AliESDEvent *)     {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 PropagateBack(AliESDEvent *);
   Int_t LoadClusters(TTree *) {AliDebug(1,"Start.");return 0;}
 
   static void                SetDebug()   { fgDebug = kTRUE ; }
index 10f1e2c..623faae 100644 (file)
@@ -27,7 +27,7 @@
 #include "AliPMDtracker.h"
 #include "AliRawReader.h"
 #include "AliESDPmdTrack.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
 #include "AliLog.h"
 
 ClassImp(AliPMDReconstructor)
@@ -104,7 +104,7 @@ void AliPMDReconstructor::Reconstruct(TTree *digitsTree,
 
 // ------------------------------------------------------------------------ //
 
-//void AliPMDReconstructor::FillESD(AliRunLoader* runLoader,AliESD* esd) const
+//void AliPMDReconstructor::FillESD(AliRunLoader* runLoader,AliESDEvent* esd) const
 //{
 //  AliLoader* loader = runLoader->GetLoader("PMDLoader");
 //  if (!loader) {
@@ -121,7 +121,7 @@ void AliPMDReconstructor::Reconstruct(TTree *digitsTree,
 
 // ------------------------------------------------------------------------ //
 void AliPMDReconstructor::FillESD(AliRawReader* /*rawReader*/,
-                                 TTree* clustersTree, AliESD* esd) const
+                                 TTree* clustersTree, AliESDEvent* esd) const
 {
   AliPMDtracker pmdtracker;
   pmdtracker.LoadClusters(clustersTree);
@@ -129,7 +129,7 @@ void AliPMDReconstructor::FillESD(AliRawReader* /*rawReader*/,
 }
 // ------------------------------------------------------------------------ //
 void AliPMDReconstructor::FillESD(TTree * /*digitsTree*/,
-                                 TTree* clustersTree, AliESD* esd) const
+                                 TTree* clustersTree, AliESDEvent* esd) const
 {
   AliPMDtracker pmdtracker;
   pmdtracker.LoadClusters(clustersTree);
index 09719d2..593fa7f 100644 (file)
@@ -17,18 +17,18 @@ public:
 
   virtual Bool_t HasLocalReconstruction() const { return kTRUE; }
 
-  //virtual void   FillESD(AliRunLoader* runLoader, AliESD* esd) const;
+  //virtual void   FillESD(AliRunLoader* runLoader, AliESDEvent* esd) const;
   virtual void   FillESD(AliRawReader* /*rawReader*/, TTree* clustersTree, 
-                        AliESD* esd) const;
+                        AliESDEvent* esd) const;
 
   virtual void   FillESD(TTree* /*digitsTree*/, TTree* clustersTree, 
-                        AliESD* esd) const;
+                        AliESDEvent* esd) const;
 
-  virtual void   FillESD(AliRunLoader* runLoader, AliESD* esd) const {
+  virtual void   FillESD(AliRunLoader* runLoader, AliESDEvent* esd) const {
     AliReconstructor::FillESD(runLoader,esd);
   }
   virtual void   FillESD(AliRunLoader* runLoader, 
-                        AliRawReader* rawReader, AliESD* esd) const {
+                        AliRawReader* rawReader, AliESDEvent* esd) const {
     AliReconstructor::FillESD(runLoader,rawReader,esd);
   }
  
index 1437645..7b96263 100644 (file)
@@ -44,7 +44,7 @@
 #include "AliPMDtracker.h"
 
 #include "AliESDPmdTrack.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
 #include "AliLog.h"
 
 ClassImp(AliPMDtracker)
@@ -129,7 +129,7 @@ void AliPMDtracker::LoadClusters(TTree *treein)
   fTreeR = treein;
 }
 //--------------------------------------------------------------------//
-void AliPMDtracker::Clusters2Tracks(AliESD *event)
+void AliPMDtracker::Clusters2Tracks(AliESDEvent *event)
 {
   // Converts digits to recpoints after running clustering
   // algorithm on CPV plane and PREshower plane
index 604153f..b666d66 100644 (file)
@@ -21,7 +21,7 @@ class AliPMDrecpoint1;
 class AliPMDUtility;
 class AliPMDDiscriminator;
 
-class AliESD;
+class AliESDEvent;
 
 class AliPMDtracker:public TObject
 {
@@ -35,7 +35,7 @@ class AliPMDtracker:public TObject
   virtual ~AliPMDtracker();
 
   void LoadClusters(TTree *treein);
-  void Clusters2Tracks(AliESD *event);
+  void Clusters2Tracks(AliESDEvent *event);
   void SetVertex(Double_t vtx[3], Double_t evtx[3]);
   void ResetClusters();
 
index e057a43..b205cf1 100644 (file)
 #include <TObject.h>
 
 class AliRawEvent;
-class AliESD;
+class AliESDEvent;
 
 
 class AliFilter: public TObject {
 public:
-  virtual Bool_t       Filter(AliRawEvent* event, AliESD* esd) = 0;
+  virtual Bool_t       Filter(AliRawEvent* event, AliESDEvent* esd) = 0;
 
 private:
   ClassDef(AliFilter, 0)   // base class for high level filter algorithms
index 5c1df45..bdca2af 100644 (file)
@@ -79,7 +79,7 @@ fITSgeom(NULL)
 }
 
 //_____________________________________________________________________________
-Bool_t AliHoughFilter::Filter(AliRawEvent* event, AliESD* esd)
+Bool_t AliHoughFilter::Filter(AliRawEvent* event, AliESDEvent* esd)
 {
   // Run fast online reconstruction
   // based on the HLT tracking algorithms
@@ -123,7 +123,7 @@ void AliHoughFilter::RunITSclusterer(AliRawEvent* event, TTree *treeClusters)
 
 
 //_____________________________________________________________________________
-void AliHoughFilter::RunITSvertexer(AliESD* esd, TTree *treeClusters)
+void AliHoughFilter::RunITSvertexer(AliESDEvent* esd, TTree *treeClusters)
 {
   // Run SPD vertexerZ
   // Store the result in the ESD
@@ -139,7 +139,7 @@ void AliHoughFilter::RunITSvertexer(AliESD* esd, TTree *treeClusters)
 }
 
 //_____________________________________________________________________________
-void AliHoughFilter::RunTPCtracking(AliRawEvent* event, AliESD* esd)
+void AliHoughFilter::RunTPCtracking(AliRawEvent* event, AliESDEvent* esd)
 {
   // Run hough transform tracking in TPC
   // The z of the vertex is taken from the ESD
@@ -213,7 +213,7 @@ void AliHoughFilter::RunTPCtracking(AliRawEvent* event, AliESD* esd)
 }
 
 //_____________________________________________________________________________
-void AliHoughFilter::RunITStracking(AliESD* esd, TTree *treeClusters)
+void AliHoughFilter::RunITStracking(AliESDEvent* esd, TTree *treeClusters)
 {
   // Run the ITS tracker
   // The tracks from the HT TPC tracking are used as seeds
index d00664c..0f9e955 100644 (file)
@@ -20,12 +20,12 @@ class AliHoughFilter: public AliFilter {
 public:
   AliHoughFilter();
 
-  virtual Bool_t       Filter(AliRawEvent* event, AliESD* esd);
+  virtual Bool_t       Filter(AliRawEvent* event, AliESDEvent* esd);
 
   void                 RunITSclusterer(AliRawEvent* event, TTree *treeClusters);
-  void                 RunITSvertexer(AliESD* esd, TTree *treeClusters);
-  void                 RunTPCtracking(AliRawEvent* event, AliESD* esd);
-  void                 RunITStracking(AliESD* esd, TTree *treeClusters);
+  void                 RunITSvertexer(AliESDEvent* esd, TTree *treeClusters);
+  void                 RunTPCtracking(AliRawEvent* event, AliESDEvent* esd);
+  void                 RunITStracking(AliESDEvent* esd, TTree *treeClusters);
 private:
   AliHoughFilter(const AliHoughFilter&);
   AliHoughFilter &operator=(const AliHoughFilter&);
index 2be7729..832163d 100644 (file)
 #include "libDateEb.h"
 #endif
 
+#include "AliMDC.h"
+
 #include <AliLog.h>
-#include <AliESD.h>
+#include <AliESDEvent.h>
 
 #include "AliRawEvent.h"
 #include "AliRawEventHeaderBase.h"
@@ -74,7 +76,7 @@
 #include "AliRawEventTag.h"
 #include "AliFilter.h"
 
-#include "AliMDC.h"
+
 
 ClassImp(AliMDC)
 
@@ -127,7 +129,7 @@ AliMDC::AliMDC(Int_t compress, Bool_t deleteFiles, EFilterMode filterMode,
                                        "TStreamerInfo()");
 
   if (fFilterMode != kFilterOff) {
-    fESD = new AliESD;
+    fESD = new AliESDEvent();
   }
 
   // Create the guid files folder if it does not exist
index d488848..da5b51d 100644 (file)
@@ -33,7 +33,16 @@ class AliRawDB;
 class AliTagDB;
 class AliRawEventTag;
 class AliStats;
-class AliESD;
+class AliESDEvent;
+
+#include "AliRawEvent.h"
+#include "AliESDEvent.h"
+#include "AliStats.h"
+#include "AliRawDB.h"
+#include "AliTagDB.h"
+#include "AliRawData.h"
+#include "AliRawDataArray.h"
+#include "AliRawEventTag.h"
 
 class AliMDC : public TObject {
 
@@ -87,7 +96,7 @@ private:
    };
 
    AliRawEvent *fEvent;       // produced AliRawEvent
-   AliESD      *fESD;         // pointer to HLT ESD object
+   AliESDEvent      *fESD;         // pointer to HLT ESD object
    AliStats    *fStats;       // statistics
    AliRawDB    *fRawDB;       // raw data DB
    AliTagDB    *fTagDB;       // tag DB
@@ -115,7 +124,7 @@ private:
                                  Bool_t isSwapped, char*& data);
    Int_t     ReadRawData(AliRawData &raw, Int_t size, char*& data);
 
-   ClassDef(AliMDC,0)  // MDC processor
+   ClassDef(AliMDC,1)  // MDC processor
 };
 
 #endif
index 9f81676..723761d 100644 (file)
@@ -33,7 +33,7 @@ ClassImp(AliRawCastorDB)
 
 //______________________________________________________________________________
 AliRawCastorDB::AliRawCastorDB(AliRawEvent *event,
-                              AliESD *esd,
+                              AliESDEvent *esd,
                               Int_t compress,
                               const char* fileName)
    : AliRawDB(event, esd, compress, fileName)
index e744bab..85d0e4e 100644 (file)
@@ -19,7 +19,7 @@ class AliRawCastorDB : public AliRawDB {
 
 public:
    AliRawCastorDB(AliRawEvent *event,
-                 AliESD *esd,
+                 AliESDEvent *esd,
                  Int_t compress,
                  const char* fileName = NULL);
    ~AliRawCastorDB() { Close(); }
index 2be8965..b66bc78 100644 (file)
@@ -36,7 +36,7 @@
 
 #include <TObjString.h>
 
-#include "AliESD.h"
+#include "AliESDEvent.h"
 #include "AliRawEvent.h"
 #include "AliRawDataArray.h"
 #include "AliRawEventHeaderBase.h"
@@ -53,7 +53,7 @@ const char *AliRawDB::fgkAliRootTag = "$Name$";
 
 //______________________________________________________________________________
 AliRawDB::AliRawDB(AliRawEvent *event,
-                  AliESD *esd, 
+                  AliESDEvent *esd, 
                   Int_t compress,
                    const char* fileName) :
   fRawDB(NULL),
@@ -279,7 +279,7 @@ void AliRawDB::MakeTree()
      fESDTree = new TTree("esdTree", Form("ALICE HLT ESD tree (%s)", GetAliRootTag()));
      fESDTree->SetAutoSave(2000000000);  // autosave when 2 Gbyte written
      split   = 0;
-     fESDTree->Branch("ESD", "AliESD", &fESD, bufsize, split);
+     fESDTree->Branch("ESD", "AliESDEvent", &fESD, bufsize, split);
    }
 
 }
index 04b1499..7cd3dc4 100644 (file)
@@ -35,13 +35,13 @@ class AliRawEvent;
 class AliRawDataArray;
 class AliStats;
 class TFile;
-class AliESD;
+class AliESDEvent;
 
 class AliRawDB : public TObject {
 
 public:
    AliRawDB(AliRawEvent *event,
-           AliESD *esd,
+           AliESDEvent *esd,
            Int_t compress,
             const char* fileName = NULL);
    virtual ~AliRawDB();
@@ -78,7 +78,7 @@ protected:
    AliRawEvent   *fEvent;         // AliRawEvent via which data is stored
    AliRawDataArray  *fDetRawData[AliDAQ::kNDetectors+1]; // Detectors raw-data payload
    TTree         *fESDTree;       // tree for storing HLT ESD information
-   AliESD        *fESD;           // pointer to HLT ESD object
+   AliESDEvent        *fESD;           // pointer to HLT ESD object
    Int_t          fCompress;      // compression mode (1 default)
    Double_t       fMaxSize;       // maximum size in bytes of the raw DB
    TString        fFS1;           // first raw DB file system location
@@ -95,7 +95,7 @@ private:
    AliRawDB(const AliRawDB& rawDB);
    AliRawDB& operator = (const AliRawDB& rawDB);
 
-   ClassDef(AliRawDB,0)  // Raw DB
+   ClassDef(AliRawDB,1)  // Raw DB
 };
 
 #endif
index eefde1c..f1bc318 100644 (file)
@@ -30,7 +30,7 @@ ClassImp(AliRawNullDB)
 
 //______________________________________________________________________________
 AliRawNullDB::AliRawNullDB(AliRawEvent *event,
-                          AliESD *esd,
+                          AliESDEvent *esd,
                           Int_t compress,
                           const char* fileName)
    : AliRawDB(event, esd, compress, fileName)
index 0d0ffb5..87aec62 100644 (file)
@@ -19,7 +19,7 @@ class AliRawNullDB : public AliRawDB {
 
 public:
    AliRawNullDB(AliRawEvent *event,
-               AliESD *esd,
+               AliESDEvent *esd,
                Int_t compress,
                const char* fileName);
    ~AliRawNullDB() { Close(); }
index 8b8dac2..16f05ad 100644 (file)
@@ -33,7 +33,7 @@ ClassImp(AliRawRFIODB)
 
 //______________________________________________________________________________
 AliRawRFIODB::AliRawRFIODB(AliRawEvent *event,
-                          AliESD *esd,
+                          AliESDEvent *esd,
                           Int_t compress,
                           const char* fileName)
    : AliRawDB(event, esd, compress, fileName)
index 436d56d..175df4f 100644 (file)
@@ -19,7 +19,7 @@ class AliRawRFIODB : public AliRawDB {
 
 public:
    AliRawRFIODB(AliRawEvent *event,
-               AliESD *esd,
+               AliESDEvent *esd,
                Int_t compress,
                const char* fileName = NULL);
    ~AliRawRFIODB() { Close(); }
index 542e3de..13d6d97 100644 (file)
@@ -32,7 +32,7 @@ ClassImp(AliRawRootdDB)
 
 //______________________________________________________________________________
 AliRawRootdDB::AliRawRootdDB(AliRawEvent *event,
-                            AliESD *esd,
+                            AliESDEvent *esd,
                             Int_t compress,
                             const char* fileName)
    : AliRawDB(event, esd, compress, fileName)
index 43532f3..5e7ad4b 100644 (file)
@@ -19,7 +19,7 @@ class AliRawRootdDB : public AliRawDB {
 
 public:
    AliRawRootdDB(AliRawEvent *event,
-                AliESD *esd,
+                AliESDEvent *esd,
                 Int_t compress,
                 const char* fileName = NULL);
    ~AliRawRootdDB() { Close(); }
index 6485460..4c6750a 100644 (file)
@@ -28,7 +28,7 @@
 #include <TObjArray.h>
 #include <TTree.h>
 
-#include "AliESD.h"
+#include "AliESDEvent.h"
 #include "AliESDv0.h"
 #include "AliESDcascade.h"
 #include "AliCascadeVertexer.h"
@@ -54,7 +54,7 @@ Double_t
   AliCascadeVertexer::fgRmax=100.;      //max radius of the fiducial volume
   
 
-Int_t AliCascadeVertexer::V0sTracks2CascadeVertices(AliESD *event) {
+Int_t AliCascadeVertexer::V0sTracks2CascadeVertices(AliESDEvent *event) {
   //--------------------------------------------------------------------
   // This function reconstructs cascade vertices
   //      Adapted to the ESD by I.Belikov (Jouri.Belikov@cern.ch)
index e5b8e69..0a6dcc7 100644 (file)
@@ -11,7 +11,7 @@
 
 #include "TObject.h"
 
-class AliESD;
+class AliESDEvent;
 class TTree;
 class AliESDv0;
 class AliExternalTrackParam;
@@ -23,7 +23,7 @@ public:
   void SetCuts(const Double_t cuts[8]);
   static void SetDefaultCuts(const Double_t cuts[8]);
 
-  Int_t V0sTracks2CascadeVertices(AliESD *event);
+  Int_t V0sTracks2CascadeVertices(AliESDEvent *event);
   Double_t PropagateToDCA(AliESDv0 *vtx,AliExternalTrackParam *trk,Double_t b);
 
   void GetCuts(Double_t cuts[8]) const;
index 7cc56d7..75280b0 100644 (file)
 //      Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch
 //-----------------------------------------------------------------
 
-#include "TList.h"
-#include <TNamed.h>
-
 #include "AliESD.h"
 #include "AliESDfriend.h"
-#include "AliESDVZERO.h"
-#include "AliESDHLTtrack.h"
-#include "AliESDFMD.h"
-
 
 ClassImp(AliESD)
 
 //______________________________________________________________________________
 AliESD::AliESD():
-  fESDObjects(new TList()),
-  fESDRun(0),
-  fHeader(0),
-  fESDZDC(0),
-  fESDFMD(0),
-  fESDVZERO(0),
-  fESDTZERO(0),
-  fSPDVertex(0),
-  fPrimaryVertex(0),
-  fSPDMult(0),
-  fPHOSTrigger(0),
-  fEMCALTrigger(0),
-  fTracks(0),
-  fMuonTracks(0),
-  fPmdTracks(0),
-  fTrdTracks(0),
-  fV0s(0),  
-  fCascades(0),
-  fKinks(0),
-  fCaloClusters(0),
-  fErrorLogs(0),
+  fEventNumberInFile(0),
+  fBunchCrossNumber(0),
+  fOrbitNumber(0),
+  fPeriodNumber(0),
+  fRunNumber(0),
+  fTimeStamp(0),
+  fEventType(0),
+  fTriggerMask(0),
+  fTriggerCluster(0),
+  fRecoVersion(0),
+  fMagneticField(0),
+  fZDCN1Energy(0),
+  fZDCP1Energy(0),
+  fZDCN2Energy(0),
+  fZDCP2Energy(0),
+  fZDCEMEnergy(0),
+  fZDCParticipants(0),
+  fT0zVertex(0),
+  fSPDVertex(),
+  fPrimaryVertex(),
+  fSPDMult(),
+  fT0timeStart(0),
+  fTracks("AliESDtrack",15000),
+  fHLTConfMapTracks("AliESDHLTtrack",25000),
+  fHLTHoughTracks("AliESDHLTtrack",15000),
+  fMuonTracks("AliESDMuonTrack",30),
+  fPmdTracks("AliESDPmdTrack",3000),
+  fTrdTracks("AliESDTrdTrack",300),
+  fV0s("AliESDv0",200),  
+  fCascades("AliESDcascade",20),
+  fKinks("AliESDkink",4000),
+  fCaloClusters("AliESDCaloCluster",10000),
   fEMCALClusters(0), 
   fFirstEMCALCluster(-1),
+  fEMCALTriggerPosition(0x0),
+  fEMCALTriggerAmplitudes(0x0),
   fPHOSClusters(0), 
-  fFirstPHOSCluster(-1)
+  fFirstPHOSCluster(-1),
+  fPHOSTriggerPosition(0x0),
+  fPHOSTriggerAmplitudes(0x0),
+  fESDFMD(0x0),
+  fESDVZERO(0x0),
+  fErrorLogs("AliRawDataErrorLog",5)
+
 {
+  for (Int_t i=0; i<24; i++) {
+    fT0time[i] = 0;
+    fT0amplitude[i] = 0;
+  }
+  for (Int_t i=0; i<2; i++) fDiamondXY[i]=0.;
+  for (Int_t i=0; i<3; i++) fDiamondCovXY[i]=0.;
 }
 //______________________________________________________________________________
 AliESD::AliESD(const AliESD& esd):
   TObject(esd),
-  fESDObjects(new TList()),
-  fESDRun(new AliESDRun(*esd.fESDRun)),
-  fHeader(new AliESDHeader(*esd.fHeader)),
-  fESDZDC(new AliESDZDC(*esd.fESDZDC)),
-  fESDFMD(new AliESDFMD(*esd.fESDFMD)),
-  fESDVZERO(new AliESDVZERO(*esd.fESDVZERO)),
-  fESDTZERO(new AliESDTZERO(*esd.fESDTZERO)),
-  fSPDVertex(new AliESDVertex(*esd.fSPDVertex)),
-  fPrimaryVertex(new AliESDVertex(*esd.fPrimaryVertex)),
-  fSPDMult(new AliMultiplicity(*esd.fSPDMult)),
-  fPHOSTrigger(new AliESDCaloTrigger(*esd.fPHOSTrigger)),
-  fEMCALTrigger(new AliESDCaloTrigger(*esd.fEMCALTrigger)),
-  fTracks(new TClonesArray(*esd.fTracks)),
-  fMuonTracks(new TClonesArray(*esd.fMuonTracks)),
-  fPmdTracks(new TClonesArray(*esd.fPmdTracks)),
-  fTrdTracks(new TClonesArray(*esd.fTrdTracks)),
-  fV0s(new TClonesArray(*esd.fV0s)),  
-  fCascades(new TClonesArray(*esd.fCascades)),
-  fKinks(new TClonesArray(*esd.fKinks)),
-  fCaloClusters(new TClonesArray(*esd.fCaloClusters)),
-  fErrorLogs(new TClonesArray(*esd.fErrorLogs)),
+  fEventNumberInFile(esd.fEventNumberInFile),
+  fBunchCrossNumber(esd.fBunchCrossNumber),
+  fOrbitNumber(esd.fOrbitNumber),
+  fPeriodNumber(esd.fPeriodNumber),
+  fRunNumber(esd.fRunNumber),
+  fTimeStamp(esd.fTimeStamp),
+  fEventType(esd.fEventType),
+  fTriggerMask(esd.fTriggerMask),
+  fTriggerCluster(esd.fTriggerCluster),
+  fRecoVersion(esd.fRecoVersion),
+  fMagneticField(esd.fMagneticField),
+  fZDCN1Energy(esd.fZDCN1Energy),
+  fZDCP1Energy(esd.fZDCP1Energy),
+  fZDCN2Energy(esd.fZDCN2Energy),
+  fZDCP2Energy(esd.fZDCP2Energy),
+  fZDCEMEnergy(esd.fZDCEMEnergy),
+  fZDCParticipants(esd.fZDCParticipants),
+  fT0zVertex(esd.fT0zVertex),
+  fSPDVertex(esd.fSPDVertex),
+  fPrimaryVertex(esd.fPrimaryVertex),
+  fSPDMult(esd.fSPDMult),
+  fT0timeStart(esd.fT0timeStart),
+  fTracks(*((TClonesArray*)esd.fTracks.Clone())),
+  fHLTConfMapTracks(*((TClonesArray*)esd.fHLTConfMapTracks.Clone())),
+  fHLTHoughTracks(*((TClonesArray*)esd.fHLTHoughTracks.Clone())),
+  fMuonTracks(*((TClonesArray*)esd.fMuonTracks.Clone())),
+  fPmdTracks(*((TClonesArray*)esd.fPmdTracks.Clone())),
+  fTrdTracks(*((TClonesArray*)esd.fTrdTracks.Clone())),
+  fV0s(*((TClonesArray*)esd.fV0s.Clone())),  
+  fCascades(*((TClonesArray*)esd.fCascades.Clone())),
+  fKinks(*((TClonesArray*)esd.fKinks.Clone())),
+  fCaloClusters(*((TClonesArray*)esd.fCaloClusters.Clone())),
   fEMCALClusters(esd.fEMCALClusters), 
   fFirstEMCALCluster(esd.fFirstEMCALCluster),
+  fEMCALTriggerPosition(esd. fEMCALTriggerPosition),
+  fEMCALTriggerAmplitudes(esd.fEMCALTriggerAmplitudes),
   fPHOSClusters(esd.fPHOSClusters), 
-  fFirstPHOSCluster(esd.fFirstPHOSCluster)
-
+  fFirstPHOSCluster(esd.fFirstPHOSCluster),
+  fPHOSTriggerPosition(esd.fPHOSTriggerPosition),
+  fPHOSTriggerAmplitudes(esd.fPHOSTriggerAmplitudes),
+  fESDFMD(esd.fESDFMD),
+  fESDVZERO(esd.fESDVZERO),
+  fErrorLogs(*((TClonesArray*)esd.fErrorLogs.Clone()))
 {
-  // CKB init in the constructor list and only add here ...
-  AddObject(fESDRun);
-  AddObject(fHeader);
-  AddObject(fESDZDC);
-  AddObject(fESDFMD);
-  AddObject(fESDVZERO);
-  AddObject(fESDTZERO);
-  AddObject(fSPDVertex);
-  AddObject(fPrimaryVertex);
-  AddObject(fSPDMult);
-  AddObject(fPHOSTrigger);
-  AddObject(fEMCALTrigger);
-  AddObject(fTracks);
-  AddObject(fMuonTracks);
-  AddObject(fPmdTracks);
-  AddObject(fTrdTracks);
-  AddObject(fV0s);
-  AddObject(fCascades);
-  AddObject(fKinks);
-  AddObject(fCaloClusters);
-  AddObject(fErrorLogs);
-
-  GetStdContent();
-
+  for (Int_t i=0; i<24; i++) {
+    fT0time[i] = esd.fT0time[i];
+    fT0amplitude[i] = esd.fT0amplitude[i];
+  }
+  for (Int_t i=0; i<2; i++) fDiamondXY[i]=esd.fDiamondXY[i];
+  for (Int_t i=0; i<3; i++) fDiamondCovXY[i]=esd.fDiamondCovXY[i];
 }
 
 //______________________________________________________________________________
@@ -125,61 +142,57 @@ AliESD & AliESD::operator=(const AliESD& source) {
   // Assignment operator
 
   if(&source == this) return *this;
-  TObject::operator=(source);
-
-  fESDRun = new AliESDRun(*source.fESDRun);
-  fHeader = new AliESDHeader(*source.fHeader);
-  fESDZDC = new AliESDZDC(*source.fESDZDC);
-  fESDFMD = new AliESDFMD(*source.fESDFMD);
-  fESDVZERO = new AliESDVZERO(*source.fESDVZERO);
-  fESDTZERO = new AliESDTZERO(*source.fESDTZERO);
-  fSPDVertex = new AliESDVertex(*source.fSPDVertex);
-  fPrimaryVertex = new AliESDVertex(*source.fPrimaryVertex);
-  fSPDMult = new AliMultiplicity(*source.fSPDMult);
-  fPHOSTrigger = new AliESDCaloTrigger(*source.fPHOSTrigger);
-  fEMCALTrigger = new AliESDCaloTrigger(*source.fEMCALTrigger);
-  fTracks = new TClonesArray(*source.fTracks);
-  fMuonTracks = new TClonesArray(*source.fMuonTracks);
-  fPmdTracks = new TClonesArray(*source.fPmdTracks);
-  fTrdTracks = new TClonesArray(*source.fTrdTracks);
-  fV0s = new TClonesArray(*source.fV0s);
-  fCascades = new TClonesArray(*source.fCascades);
-  fKinks = new TClonesArray(*source.fKinks);
-  fCaloClusters = new TClonesArray(*source.fCaloClusters);
-  fErrorLogs = new TClonesArray(*source.fErrorLogs);
-
-  // CKB this way?? or 
-  // or AddObject(  fESDZDC = new AliESDZDC(*source.fESDZDC));
-
-  fESDObjects = new TList();
-  AddObject(fESDRun);
-  AddObject(fHeader);
-  AddObject(fESDZDC);
-  AddObject(fESDFMD);
-  AddObject(fESDVZERO);
-  AddObject(fESDTZERO);
-  AddObject(fSPDVertex);
-  AddObject(fPrimaryVertex);
-  AddObject(fSPDMult);
-  AddObject(fPHOSTrigger);
-  AddObject(fEMCALTrigger);
-  AddObject(fTracks);
-  AddObject(fMuonTracks);
-  AddObject(fPmdTracks);
-  AddObject(fTrdTracks);
-  AddObject(fV0s);
-  AddObject(fCascades);
-  AddObject(fKinks);
-  AddObject(fCaloClusters);
-  AddObject(fErrorLogs);
-
 
+  fEventNumberInFile = source.fEventNumberInFile;
+  fBunchCrossNumber = source.fBunchCrossNumber;
+  fOrbitNumber = source.fOrbitNumber;
+  fPeriodNumber = source.fPeriodNumber;
+  fRunNumber = source.fRunNumber;
+  fTimeStamp   = source.fTimeStamp;
+  fEventType   = source.fEventType;
+  fTriggerMask = source.fTriggerMask;
+  fTriggerCluster = source.fTriggerCluster;
+  fRecoVersion = source.fRecoVersion;
+  fMagneticField = source.fMagneticField;
+  fZDCN1Energy = source.fZDCN1Energy;
+  fZDCP1Energy = source.fZDCP1Energy;
+  fZDCN2Energy = source.fZDCN2Energy;
+  fZDCP2Energy = source.fZDCP2Energy;
+  fZDCEMEnergy = source.fZDCEMEnergy;
+  fZDCParticipants = source.fZDCParticipants;
+  fT0zVertex = source.fT0zVertex;
+  fSPDVertex = source.fSPDVertex;
+  fPrimaryVertex = source.fPrimaryVertex;
+  fSPDMult = source.fSPDMult;
+  fT0timeStart = source.fT0timeStart;
+  fTracks = *((TClonesArray*)source.fTracks.Clone());
+  fHLTConfMapTracks = *((TClonesArray*)source.fHLTConfMapTracks.Clone());
+  fHLTHoughTracks = *((TClonesArray*)source.fHLTHoughTracks.Clone());
+  fMuonTracks = *((TClonesArray*)source.fMuonTracks.Clone());
+  fPmdTracks = *((TClonesArray*)source.fPmdTracks.Clone());
+  fTrdTracks = *((TClonesArray*)source.fTrdTracks.Clone());
+  fV0s = *((TClonesArray*)source.fV0s.Clone());
+  fCascades = *((TClonesArray*)source.fCascades.Clone());
+  fKinks = *((TClonesArray*)source.fKinks.Clone());
+  fCaloClusters = *((TClonesArray*)source.fCaloClusters.Clone());
   fEMCALClusters = source.fEMCALClusters;
   fFirstEMCALCluster = source.fFirstEMCALCluster;
   fPHOSClusters = source.fPHOSClusters;
   fFirstPHOSCluster = source.fFirstPHOSCluster;
-
-
+  fESDFMD = source.fESDFMD;
+  fESDVZERO = source.fESDVZERO;
+  fEMCALTriggerPosition=source. fEMCALTriggerPosition;
+  fEMCALTriggerAmplitudes=source.fEMCALTriggerAmplitudes;
+  fPHOSTriggerPosition=source.fPHOSTriggerPosition;
+  fPHOSTriggerAmplitudes=source.fPHOSTriggerAmplitudes;
+  fErrorLogs = *((TClonesArray*)source.fErrorLogs.Clone());
+
+  for (Int_t i=0; i<24; i++) {
+    fT0time[i] = source.fT0time[i];
+    fT0amplitude[i] = source.fT0amplitude[i];
+  }
+  for (Int_t i=0; i<2; i++) fDiamondXY[i]=source.fDiamondXY[i];
+  for (Int_t i=0; i<3; i++) fDiamondCovXY[i]=source.fDiamondCovXY[i];
 
   return *this;
 
@@ -192,23 +205,18 @@ AliESD::~AliESD()
   //
   // Standard destructor
   //
-
-  delete fESDObjects;
-  fESDObjects = 0;
-
-  // everthing on the list gets deleted automatically
-
-  /*
+  fTracks.Delete();
   fHLTConfMapTracks.Delete();
   fHLTHoughTracks.Delete();
-  fMuonTracks.Delete();  
+  fMuonTracks.Delete();
   fPmdTracks.Delete();
   fTrdTracks.Delete();
   fV0s.Delete();
   fCascades.Delete();
   fKinks.Delete();
   fCaloClusters.Delete();
-  */
+  delete fESDFMD;
+  delete fESDVZERO;
 //   fEMCALTriggerPosition->Delete();
 //   fEMCALTriggerAmplitudes->Delete();
 //   fPHOSTriggerPosition->Delete();
@@ -217,57 +225,63 @@ AliESD::~AliESD()
 //   delete fEMCALTriggerAmplitudes;
 //   delete fPHOSTriggerPosition;
 //   delete fPHOSTriggerAmplitudes;
+  fErrorLogs.Delete();
 
 }
 
 //______________________________________________________________________________
 void AliESD::Reset()
 {
-  // Reset the standard contents
-  if(fESDRun) fESDRun->Reset();
-  if(fHeader) fHeader->Reset();
-  if(fESDZDC) fESDZDC->Reset();
-  if(fESDFMD) fESDFMD->Clear(); // why clear.... need consistend names
-  // if(fESDVZERO) fESDVZERO->; // NOT IMPLEMENTED 
-  //  if(fESDVZERO) new (fESDVZERO) AliESDVZERO();
-  if(fESDTZERO) fESDTZERO->Reset(); 
-  // CKB no clear/reset implemented
-  if(fSPDVertex){
-    new (fSPDVertex) AliESDVertex();
-    fSPDVertex->SetName("SPDVertex");
-  }
-  if(fPrimaryVertex){
-    new (fPrimaryVertex) AliESDVertex();
-    fPrimaryVertex->SetName("PrimaryVertex");
-  }
-  if(fSPDMult)new (fSPDMult) AliMultiplicity();
-  if(fPHOSTrigger)fPHOSTrigger->Reset(); 
-  if(fEMCALTrigger)fEMCALTrigger->Reset(); 
-  if(fTracks)fTracks->Clear();
-  if(fMuonTracks)fMuonTracks->Clear();
-  if(fPmdTracks)fPmdTracks->Clear();
-  if(fTrdTracks)fTrdTracks->Clear();
-  if(fV0s)fV0s->Clear();
-  if(fCascades)fCascades->Clear();
-  if(fKinks)fKinks->Clear();
-  if(fCaloClusters)fCaloClusters->Clear();
-  if(fErrorLogs) fErrorLogs->Clear();
-
-
+  fEventNumberInFile=0;
+  fBunchCrossNumber=0;
+  fOrbitNumber=0;
+  fPeriodNumber=0;
+  fRunNumber=0;
+  fTimeStamp = 0;
+  fEventType = 0;
+  fTriggerMask=0;
+  fTriggerCluster=0;
+  fRecoVersion=0;
+  fMagneticField=0;
+  fZDCN1Energy=0;
+  fZDCP1Energy=0;
+  fZDCN2Energy=0;
+  fZDCP2Energy=0;
+  fZDCEMEnergy=0;
+  fZDCParticipants=0;
+  fT0zVertex=0;
+  fT0timeStart = 0;
+  new (&fSPDVertex) AliESDVertex();
+  new (&fPrimaryVertex) AliESDVertex();
+  new (&fSPDMult) AliMultiplicity();
+  fTracks.Clear();
+  fHLTConfMapTracks.Clear();
+  fHLTHoughTracks.Clear();
+  fMuonTracks.Clear();
+  fPmdTracks.Clear();
+  fTrdTracks.Clear();
+  fV0s.Clear();
+  fCascades.Clear();
+  fCaloClusters.Clear();
   fEMCALClusters=0; 
   fFirstEMCALCluster=-1; 
   fPHOSClusters=0; 
   fFirstPHOSCluster=-1; 
+  if (fESDFMD) fESDFMD->Clear();
+//   fEMCALTriggerPosition->Clear();
+//   fEMCALTriggerAmplitudes->Clear();
+//   fPHOSTriggerPosition->Clear();
+//   fPHOSTriggerAmplitudes->Clear();
+  fErrorLogs.Clear();
 }
 
 Int_t AliESD::AddV0(const AliESDv0 *v) {
   //
   // Add V0
   //
-  TClonesArray &fv = *fV0s;
-  Int_t idx=fV0s->GetEntriesFast();
-  new(fv[idx]) AliESDv0(*v);
-  return idx;
+    Int_t idx=fV0s.GetEntriesFast();
+    new(fV0s[idx]) AliESDv0(*v);
+    return idx;
 }  
 
 //______________________________________________________________________________
@@ -285,16 +299,19 @@ void AliESD::Print(Option_t *) const
         GetRunNumber(),
         GetTriggerMask(),
         GetMagneticField() );
-  printf("Vertex: (%.4f +- %.4f, %.4f +- %.4f, %.4f +- %.4f) cm\n",
-          fPrimaryVertex->GetXv(), fPrimaryVertex->GetXRes(),
-          fPrimaryVertex->GetYv(), fPrimaryVertex->GetYRes(),
-          fPrimaryVertex->GetZv(), fPrimaryVertex->GetZRes());
+    printf("Vertex: (%.4f +- %.4f, %.4f +- %.4f, %.4f +- %.4f) cm\n",
+          fPrimaryVertex.GetXv(), fPrimaryVertex.GetXRes(),
+          fPrimaryVertex.GetYv(), fPrimaryVertex.GetYRes(),
+          fPrimaryVertex.GetZv(), fPrimaryVertex.GetZRes());
     printf("Mean vertex in RUN: X=%.4f Y=%.4f cm\n",
           GetDiamondX(),GetDiamondY());
     printf("SPD Multiplicity. Number of tracklets %d \n",
-           fSPDMult->GetNumberOfTracklets());
+           fSPDMult.GetNumberOfTracklets());
+  printf("Event from reconstruction version %d \n",fRecoVersion);
   printf("Number of tracks: \n");
   printf("                 charged   %d\n", GetNumberOfTracks());
+  printf("                 hlt CF    %d\n", GetNumberOfHLTConfMapTracks());
+  printf("                 hlt HT    %d\n", GetNumberOfHLTHoughTracks());
   printf("                 muon      %d\n", GetNumberOfMuonTracks());
   printf("                 pmd       %d\n", GetNumberOfPmdTracks());
   printf("                 trd       %d\n", GetNumberOfTrdTracks());
@@ -315,51 +332,13 @@ void AliESD::SetESDfriend(const AliESDfriend *ev) {
   if (!ev) return;
 
   Int_t ntrk=ev->GetNumberOfTracks();
+
   for (Int_t i=0; i<ntrk; i++) {
     const AliESDfriendTrack *f=ev->GetTrack(i);
     GetTrack(i)->SetFriendTrack(f);
   }
 }
 
-Int_t  AliESD::AddTrack(const AliESDtrack *t) {
-    // Add track
-    TClonesArray &ftr = *fTracks;
-    AliESDtrack * track = new(ftr[fTracks->GetEntriesFast()])AliESDtrack(*t);
-    track->SetID(fTracks->GetEntriesFast()-1);
-    return  track->GetID();    
-}
-
-Int_t AliESD::AddKink(const AliESDkink *c) {
-    // Add kink
-    TClonesArray &fk = *fKinks;
-    AliESDkink * kink = new(fk[fKinks->GetEntriesFast()]) AliESDkink(*c);
-    kink->SetID(fKinks->GetEntriesFast()); // CKB different from the other imps..
-    return fKinks->GetEntriesFast()-1;
-}
-
-Int_t AliESD::AddCaloCluster(const AliESDCaloCluster *c) {
-    // Add calocluster
-    TClonesArray &fc = *fCaloClusters;
-    AliESDCaloCluster *clus = new(fc[fCaloClusters->GetEntriesFast()]) AliESDCaloCluster(*c);
-    clus->SetID(fCaloClusters->GetEntriesFast()-1);
-    return fCaloClusters->GetEntriesFast()-1;
-  }
-
-
-void AliESD::SetFMDData(AliESDFMD * obj) { 
-  // use already allocated space
-  if(fESDFMD){
-    new(fESDFMD) AliESDFMD(*obj); 
-  }
-}
-
-void AliESD::SetVZEROData(AliESDVZERO * obj){ 
-  // use already allocated space
-  if(fESDVZERO)
-    new(fESDVZERO) AliESDVZERO(*obj);
-}
-
 void AliESD::GetESDfriend(AliESDfriend *ev) const {
   //
   // Extracts the complementary info from the ESD
@@ -374,136 +353,3 @@ void AliESD::GetESDfriend(AliESDfriend *ev) const {
     ev->AddTrack(f);
   }
 }
-
-
-void AliESD::AddObject(TObject* obj) 
-{
-  // Add an object to the list of object.
-  // Please be aware that in order to increase performance you should
-  // refrain from using TObjArrays (if possible). Use TClonesArrays, instead.
-  fESDObjects->AddLast(obj);
-}
-
-
-void AliESD::GetStdContent() 
-{
-  // set pointers for standard content
-
-  fESDRun = (AliESDRun*)fESDObjects->At(kESDRun);
-  fHeader = (AliESDHeader*)fESDObjects->At(kHeader);
-  fESDZDC = (AliESDZDC*)fESDObjects->At(kESDZDC);
-  fESDFMD = (AliESDFMD*)fESDObjects->At(kESDFMD);
-  fESDVZERO = (AliESDVZERO*)fESDObjects->At(kESDVZERO);
-  fESDTZERO = (AliESDTZERO*)fESDObjects->At(kESDTZERO);
-  fSPDVertex = (AliESDVertex*)fESDObjects->At(kSPDVertex);
-  fPrimaryVertex = (AliESDVertex*)fESDObjects->At(kPrimaryVertex);
-  fSPDMult =       (AliMultiplicity*)fESDObjects->At(kSPDMult);
-  fPHOSTrigger = (AliESDCaloTrigger*)fESDObjects->At(kPHOSTrigger);
-  fEMCALTrigger = (AliESDCaloTrigger*)fESDObjects->At(kEMCALTrigger);
-  fTracks = (TClonesArray*)fESDObjects->At(kTracks);
-  fMuonTracks = (TClonesArray*)fESDObjects->At(kMuonTracks);
-  fPmdTracks = (TClonesArray*)fESDObjects->At(kPmdTracks);
-  fTrdTracks = (TClonesArray*)fESDObjects->At(kTrdTracks);
-  fV0s = (TClonesArray*)fESDObjects->At(kV0s);
-  fCascades = (TClonesArray*)fESDObjects->At(kCascades);
-  fKinks = (TClonesArray*)fESDObjects->At(kKinks);
-  fCaloClusters = (TClonesArray*)fESDObjects->At(kCaloClusters);
-  fErrorLogs = (TClonesArray*)fESDObjects->At(kErrorLogs);
-
-}
-
-void AliESD::SetStdNames(){
-  // Set the names of the standard contents
-  fSPDVertex->SetName("SPDVertex");
-  fPrimaryVertex->SetName("PrimaryVertex");
-  fPHOSTrigger->SetName("PHOSTrigger");
-  fEMCALTrigger->SetName("EMCALTrigger");
-  fTracks->SetName("Tracks");
-  fMuonTracks->SetName("MuonTracks");
-  fPmdTracks->SetName("PmdTracks");
-  fTrdTracks->SetName("TrdTracks");
-  fV0s->SetName("V0s");
-  fCascades->SetName("Cascades");
-  fKinks->SetName("Kinks");
-  fCaloClusters->SetName("CaloClusters");
-
-} 
-
-void AliESD::CreateStdContent() 
-{
-  // create the standard AOD content and set pointers
-
-  // create standard objects and add them to the TList of objects
-  AddObject(new AliESDRun());
-  AddObject(new AliESDHeader());
-  AddObject(new AliESDZDC());
-  AddObject(new AliESDFMD());
-  AddObject(new AliESDVZERO());
-  AddObject(new AliESDTZERO());
-  AddObject(new AliESDVertex());
-  AddObject(new AliESDVertex());
-  AddObject(new AliMultiplicity());
-  AddObject(new AliESDCaloTrigger());
-  AddObject(new AliESDCaloTrigger());
-  AddObject(new TClonesArray("AliESDtrack",0));
-  AddObject(new TClonesArray("AliESDMuonTrack",0));
-  AddObject(new TClonesArray("AliESDPmdTrack",0));
-  AddObject(new TClonesArray("AliESDTrdTrack",0));
-  AddObject(new TClonesArray("AliESDv0",0));
-  AddObject(new TClonesArray("AliESDcascade",0));
-  AddObject(new TClonesArray("AliESDkink",0));
-  AddObject(new TClonesArray("AliESDCaloCluster",0));
-  AddObject(new TClonesArray("AliRawDataErrorLog",0));
-
-  // check the order of the indices against enum...
-
-  // read back pointers
-  GetStdContent();
-  // set names
-  SetStdNames();
-
-}
-
-void AliESD::ReadFromTree(TTree *tree){
-  
-
-  // is this really so smart that an ESDObject has a pointer to a list
-  // of another ESDObject...
-
-  fESDObjects = (TList*)((AliESD*)tree->GetTree()->GetUserInfo()->FindObject("AliESD"))->GetList(); 
-
-  // if list is empty
-  // we could still set the branch adresses based on 
-  // tree->GetListOfBranches() CKB
-  // or create standard list 
-
-  if(fESDObjects->GetEntries()<kESDListN){
-    printf("%s %d AliESD::ReadFromTree() TList contains less than the standard contents %d < %d \n",(char*)__FILE__,__LINE__,fESDObjects->GetEntries(),kESDListN);
-  }
-
-
-
-  // set the branch addresses
-  TIter next(fESDObjects);
-  TNamed *el;
-  while((el=(TNamed*)next())){
-    TString bname(el->GetName());
-
-    if(bname.CompareTo("AliESDfriend")==0)
-      {
-       // AliESDfriend does not have a name ...
-      tree->SetBranchStatus("ESDfriend.*",1);
-      tree->SetBranchAddress("ESDfriend.",fESDObjects->GetObjectRef(el));
-
-
-    }
-    else{
-      tree->SetBranchAddress(bname.Data(),fESDObjects->GetObjectRef(el));
-    }
-  }
-
-  GetStdContent();
-}
-
-
-
index 85fa211..f94b11e 100644 (file)
 
 #include <TClonesArray.h>
 #include <TObject.h>
-#include <TTree.h>
 #include <TArrayF.h>
 
-class TList;
-
-
 #include "AliESDMuonTrack.h"
 #include "AliESDPmdTrack.h"
 #include "AliESDTrdTrack.h"
@@ -29,329 +25,288 @@ class TList;
 #include "AliESDcascade.h"
 #include "AliESDkink.h"
 #include "AliESDtrack.h"
+#include "AliESDHLTtrack.h"
 #include "AliESDCaloCluster.h"
 #include "AliESDv0.h"
 #include "AliESDFMD.h"
 #include "AliESDVZERO.h"
 #include "AliMultiplicity.h"
 #include "AliRawDataErrorLog.h"
-#include "AliESDRun.h"
-#include "AliESDHeader.h"
-#include "AliESDZDC.h"
-#include "AliESDTZERO.h"
-#include "AliESDCaloTrigger.h"
 
 class AliESDfriend;
-class AliESDVZERO;
-class AliESDHLTtrack;
-class AliESDFMD;
 
 class AliESD : public TObject {
 public:
-
-
-  enum ESDListIndex_t   {kESDRun,
-                      kHeader,
-                      kESDZDC,
-                      kESDFMD,
-                      kESDVZERO,
-                      kESDTZERO,
-                      kSPDVertex,
-                      kPrimaryVertex,
-                      kSPDMult,
-                      kPHOSTrigger,
-                      kEMCALTrigger,
-                      kTracks,
-                      kMuonTracks,
-                      kPmdTracks,
-                      kTrdTracks,
-                      kV0s,
-                      kCascades,
-                      kKinks,
-                      kCaloClusters,
-                      kErrorLogs,
-                      kESDListN
-  };
-
   AliESD();
   virtual ~AliESD(); 
 
-
-  // RUN
-  // move this to the UserData!!!
-  const AliESDRun*    GetESDRun() const {return fESDRun;}
-
-  // Delegated methods for fESDRun
-  void    SetRunNumber(Int_t n) {fESDRun->SetRunNumber(n);}
-  Int_t   GetRunNumber() const {return fESDRun->GetRunNumber();}
-  void    SetPeriodNumber(Int_t n){fESDRun->SetPeriodNumber(n);}
-  Int_t   GetPeriodNumber() const {return fESDRun->GetPeriodNumber();}
-  void    SetMagneticField(Float_t mf){fESDRun->SetMagneticField(mf);}
-  Float_t GetMagneticField() const {return fESDRun->GetMagneticField();}
-  void SetDiamond(const AliESDVertex *vertex) { fESDRun->SetDiamond(vertex);}
-  Float_t GetDiamondX() const {return fESDRun->GetDiamondX();}
-  Float_t GetDiamondY() const {return fESDRun->GetDiamondY();}
-  Float_t GetSigma2DiamondX() const {return  fESDRun->GetSigma2DiamondX();}
-  Float_t GetSigma2DiamondY() const {return  fESDRun->GetSigma2DiamondY();}
-  void GetDiamondCovXY(Float_t cov[3]) const {fESDRun->GetDiamondCovXY(cov);}   
-  
-
-  // HEADER
-  const AliESDHeader* GetHeader() const {return fHeader;}
-
-  // Delegated methods for fHeader
-  void      SetTriggerMask(ULong64_t n) {fHeader->SetTriggerMask(n);}
-  void      SetOrbitNumber(UInt_t n) {fHeader->SetOrbitNumber(n);}
-  void      SetTimeStamp(UInt_t timeStamp){fHeader->SetTimeStamp(timeStamp);}
-  void      SetEventType(UInt_t eventType){fHeader->SetEventType(eventType);}
-  void      SetEventNumberInFile(Int_t n) {fHeader->SetEventNumberInFile(n);}
-  //  void      SetRunNumber(Int_t n) {fHeader->SetRunNumber(n);}
-  void      SetBunchCrossNumber(UShort_t n) {fHeader->SetBunchCrossNumber(n);}
-  void      SetTriggerCluster(UChar_t n) {fHeader->SetTriggerCluster(n);}
-  ULong64_t GetTriggerMask() const {return fHeader->GetTriggerMask();}
-  UInt_t    GetOrbitNumber() const {return fHeader->GetOrbitNumber();}
-  UInt_t    GetTimeStamp()  const { return fHeader->GetTimeStamp();}
-  UInt_t    GetEventType()  const { return fHeader->GetEventType();}
-  Int_t     GetEventNumberInFile() const {return fHeader->GetEventNumberInFile();}
-  UShort_t  GetBunchCrossNumber() const {return fHeader->GetBunchCrossNumber();}
-  UChar_t   GetTriggerCluster() const {return fHeader->GetTriggerCluster();}
-
-  // ZDC CKB: put this in the header?
-  const AliESDZDC*    GetESDZDC() const {return fESDZDC;}
-
-  // Delegated methods for fESDZDC
-  Float_t GetZDCN1Energy() const {return fESDZDC->GetZDCN1Energy();}
-  Float_t GetZDCP1Energy() const {return fESDZDC->GetZDCP1Energy();}
-  Float_t GetZDCN2Energy() const {return fESDZDC->GetZDCN2Energy();}
-  Float_t GetZDCP2Energy() const {return fESDZDC->GetZDCP2Energy();}
-  Float_t GetZDCEMEnergy() const {return fESDZDC->GetZDCEMEnergy();}
-  Int_t   GetZDCParticipants() const {return fESDZDC->GetZDCParticipants();}
-  void    SetZDC(Float_t n1Energy, Float_t p1Energy, Float_t emEnergy,
-                 Float_t n2Energy, Float_t p2Energy, Int_t participants)
-  {fESDZDC->SetZDC(n1Energy, p1Energy, emEnergy, n2Energy, p2Energy, participants);}
-
-
-  // FMD
-  void SetFMDData(AliESDFMD * obj);
-  AliESDFMD *GetFMDData(){ return fESDFMD; }
-
-
-  // TZERO CKB: put this in the header?
-  const AliESDTZERO*    GetESDTZERO() const {return fESDTZERO;}
-  // delegetated methods for fESDTZERO
-
-  Float_t GetT0zVertex() const {return fESDTZERO->GetT0zVertex();}
-  void SetT0zVertex(Float_t z) {fESDTZERO->SetT0zVertex(z);}
-  Float_t GetT0() const {return fESDTZERO->GetT0();}
-  void SetT0(Float_t timeStart) {fESDTZERO->SetT0(timeStart);}
-  const Float_t * GetT0time() const {return fESDTZERO->GetT0time();}
-  void SetT0time(Float_t time[24]) {fESDTZERO->SetT0time(time);}
-  const Float_t * GetT0amplitude() const {return fESDTZERO->GetT0amplitude();}
-  void SetT0amplitude(Float_t amp[24]){fESDTZERO->SetT0amplitude(amp);}
-
-  // VZERO 
-  AliESDVZERO *GetVZEROData() const { return fESDVZERO; }
-  void SetVZEROData(AliESDVZERO * obj);
-
-
   void SetESDfriend(const AliESDfriend *f);
   void GetESDfriend(AliESDfriend *f) const;
 
-
-
-  void SetVertex(const AliESDVertex *vertex) {
-    *fSPDVertex  = *vertex;
-    fSPDVertex->SetName("fSPDVertex");// error prone use class wide names?
-    //CKB or new with placement
+  void SetEventNumberInFile(Int_t n) {fEventNumberInFile=n;}
+  void SetBunchCrossNumber(UShort_t n) {fBunchCrossNumber=n;}
+  void SetOrbitNumber(UInt_t n) {fOrbitNumber=n;}
+  void SetPeriodNumber(UInt_t n) {fPeriodNumber=n;}
+  void SetRunNumber(Int_t n) {fRunNumber=n;}
+  void SetTimeStamp(UInt_t timeStamp){fTimeStamp = timeStamp;}
+  void SetEventType(UInt_t eventType){fEventType = eventType;}
+  void SetTriggerMask(ULong64_t n) {fTriggerMask=n;}
+  void SetTriggerCluster(UChar_t n) {fTriggerCluster = n;}
+  void SetMagneticField(Float_t mf){fMagneticField = mf;}
+  Float_t GetMagneticField() const {return fMagneticField;}
+  
+  AliESDtrack *GetTrack(Int_t i) const {
+    return (AliESDtrack *)fTracks.UncheckedAt(i);
   }
-  const AliESDVertex *GetVertex() const {return fSPDVertex;}
-
-  void SetPrimaryVertex(const AliESDVertex *vertex) {
-    *fPrimaryVertex = *vertex;
-    fPrimaryVertex->SetName("fPrimaryVertex");// error prone use class wide names?
+  AliESDHLTtrack *GetHLTConfMapTrack(Int_t i) const {
+    return (AliESDHLTtrack *)fHLTConfMapTracks.UncheckedAt(i);
   }
-  const AliESDVertex *GetPrimaryVertex() const {return fPrimaryVertex;}
-
-  void SetMultiplicity(const AliMultiplicity *mul) {
-    *fSPDMult = *mul;
-    // CKB 
-    //     new (&fSPDMult) AliMultiplicity(*mul);
+  AliESDHLTtrack *GetHLTHoughTrack(Int_t i) const {
+    return (AliESDHLTtrack *)fHLTHoughTracks.UncheckedAt(i);
   }
-  const AliMultiplicity *GetMultiplicity() const {return fSPDMult;}
-  
-  AliESDtrack *GetTrack(Int_t i) const {
-    return (AliESDtrack *)fTracks->UncheckedAt(i);
+  AliESDMuonTrack *GetMuonTrack(Int_t i) const {
+    return (AliESDMuonTrack *)fMuonTracks.UncheckedAt(i);
   }
-  Int_t  AddTrack(const AliESDtrack *t);
-
-  
-  AliESDHLTtrack *GetHLTConfMapTrack(Int_t /*i*/) const {
-    //    return (AliESDHLTtrack *)fHLTConfMapTracks->UncheckedAt(i);
-    return 0;
+  AliESDPmdTrack *GetPmdTrack(Int_t i) const {
+    return (AliESDPmdTrack *)fPmdTracks.UncheckedAt(i);
   }
-  void AddHLTConfMapTrack(const AliESDHLTtrack */*t*/) {
-    printf("ESD:: AddHLTConfMapTrack do nothing \n");
-    //    TClonesArray &fhlt = *fHLTConfMapTracks;
-    //  new(fhlt[fHLTConfMapTracks->GetEntriesFast()]) AliESDHLTtrack(*t);
+  AliESDTrdTrack *GetTrdTrack(Int_t i) const {
+    return (AliESDTrdTrack *)fTrdTracks.UncheckedAt(i);
   }
-  
 
-  AliESDHLTtrack *GetHLTHoughTrack(Int_t /*i*/) const {
-    //    return (AliESDHLTtrack *)fHLTHoughTracks->UncheckedAt(i);
-    return 0;
+  Int_t  AddTrack(const AliESDtrack *t) {
+    AliESDtrack * track = new(fTracks[fTracks.GetEntriesFast()]) AliESDtrack(*t);
+    track->SetID(fTracks.GetEntriesFast()-1);
+    return  track->GetID();
+    
   }
-  void AddHLTHoughTrack(const AliESDHLTtrack */*t*/) {
-    printf("ESD:: AddHLTHoughTrack do nothing \n");
-    //    TClonesArray &fhlt = *fHLTHoughTracks;
-    //     new(fhlt[fHLTHoughTracks->GetEntriesFast()]) AliESDHLTtrack(*t);
+  void AddHLTConfMapTrack(const AliESDHLTtrack *t) {
+    new(fHLTConfMapTracks[fHLTConfMapTracks.GetEntriesFast()]) AliESDHLTtrack(*t);
   }
-  
-  AliESDMuonTrack *GetMuonTrack(Int_t i) const {
-    return (AliESDMuonTrack *)fMuonTracks->UncheckedAt(i);
+  void AddHLTHoughTrack(const AliESDHLTtrack *t) {
+    new(fHLTHoughTracks[fHLTHoughTracks.GetEntriesFast()]) AliESDHLTtrack(*t);
   }
   void AddMuonTrack(const AliESDMuonTrack *t) {
-    TClonesArray &fmu = *fMuonTracks;
-    new(fmu[fMuonTracks->GetEntriesFast()]) AliESDMuonTrack(*t);
-  }
-
-  AliESDPmdTrack *GetPmdTrack(Int_t i) const {
-    return (AliESDPmdTrack *)fPmdTracks->UncheckedAt(i);
+    new(fMuonTracks[fMuonTracks.GetEntriesFast()]) AliESDMuonTrack(*t);
   }
   void AddPmdTrack(const AliESDPmdTrack *t) {
-    TClonesArray &fpmd = *fPmdTracks;
-    new(fpmd[fPmdTracks->GetEntriesFast()]) AliESDPmdTrack(*t);
-  }
-
-  AliESDTrdTrack *GetTrdTrack(Int_t i) const {
-    return (AliESDTrdTrack *)fTrdTracks->UncheckedAt(i);
+    new(fPmdTracks[fPmdTracks.GetEntriesFast()]) AliESDPmdTrack(*t);
   }
   void AddTrdTrack(const AliESDTrdTrack *t) {
-    TClonesArray &ftrd = *fTrdTracks;
-    new(ftrd[fTrdTracks->GetEntriesFast()]) AliESDTrdTrack(*t);
+    new(fTrdTracks[fTrdTracks.GetEntriesFast()]) AliESDTrdTrack(*t);
   }
 
   AliESDv0 *GetV0(Int_t i) const {
-    return (AliESDv0*)fV0s->UncheckedAt(i);
+    return (AliESDv0 *)fV0s.UncheckedAt(i);
   }
   Int_t AddV0(const AliESDv0 *v);
 
   AliESDcascade *GetCascade(Int_t i) const {
-    return (AliESDcascade *)fCascades->UncheckedAt(i);
+    return (AliESDcascade *)fCascades.UncheckedAt(i);
   }
   void AddCascade(const AliESDcascade *c) {
-    TClonesArray &fc = *fCascades;
-    new(fc[fCascades->GetEntriesFast()]) AliESDcascade(*c);
+    new(fCascades[fCascades.GetEntriesFast()]) AliESDcascade(*c);
   }
 
   AliESDkink *GetKink(Int_t i) const {
-    return (AliESDkink *)fKinks->UncheckedAt(i);
+    return (AliESDkink *)fKinks.UncheckedAt(i);
+  }
+  Int_t AddKink(const AliESDkink *c) {
+    AliESDkink * kink = new(fKinks[fKinks.GetEntriesFast()]) AliESDkink(*c);
+    kink->SetID(fKinks.GetEntriesFast());
+    return fKinks.GetEntriesFast()-1;
   }
-  Int_t AddKink(const AliESDkink *c);
 
   AliESDCaloCluster *GetCaloCluster(Int_t i) const {
-    return (AliESDCaloCluster *)fCaloClusters->UncheckedAt(i);
+    return (AliESDCaloCluster *)fCaloClusters.UncheckedAt(i);
+  }
+  Int_t AddCaloCluster(const AliESDCaloCluster *c) {
+    AliESDCaloCluster *clus = new(fCaloClusters[fCaloClusters.GetEntriesFast()]) AliESDCaloCluster(*c);
+    clus->SetID(fCaloClusters.GetEntriesFast()-1);
+    return fCaloClusters.GetEntriesFast()-1;
   }
-  Int_t AddCaloCluster(const AliESDCaloCluster *c);
+    
+  void AddPHOSTriggerPosition(TArrayF array)   { fPHOSTriggerPosition    = new TArrayF(array) ; }
+  void AddPHOSTriggerAmplitudes(TArrayF array) { fPHOSTriggerAmplitudes  = new TArrayF(array) ; }
+  void AddEMCALTriggerPosition(TArrayF array)  { fEMCALTriggerPosition   = new TArrayF(array) ; }
+  void AddEMCALTriggerAmplitudes(TArrayF array){ fEMCALTriggerAmplitudes = new TArrayF(array) ; }
 
-  AliRawDataErrorLog *GetErrorLog(Int_t i) const {
-    return (AliRawDataErrorLog *)fErrorLogs->UncheckedAt(i);
+  void SetVertex(const AliESDVertex *vertex) {
+     new (&fSPDVertex) AliESDVertex(*vertex);
   }
-  void  AddRawDataErrorLog(const AliRawDataErrorLog *log) {
-    // CKB inline this??
-    TClonesArray &errlogs = *fErrorLogs;
-    new(errlogs[errlogs.GetEntriesFast()])  AliRawDataErrorLog(*log);
+  const AliESDVertex *GetVertex() const {return &fSPDVertex;}
+
+  void SetMultiplicity(const AliMultiplicity *mul) {
+     new (&fSPDMult) AliMultiplicity(*mul);
   }
-  Int_t GetNumberOfErrorLogs()   const {return fErrorLogs->GetEntriesFast();}
+  const AliMultiplicity *GetMultiplicity() const {return &fSPDMult;}
 
-    
-  void AddPHOSTriggerPosition(TArrayF array)   { fPHOSTrigger->AddTriggerPosition(array); }
-  void AddPHOSTriggerAmplitudes(TArrayF array) { fPHOSTrigger->AddTriggerAmplitudes(array);}
-  void AddEMCALTriggerPosition(TArrayF array)  { fEMCALTrigger->AddTriggerPosition(array); }
-  void AddEMCALTriggerAmplitudes(TArrayF array){ fEMCALTrigger->AddTriggerAmplitudes(array); }
-
-
-  Int_t GetNumberOfTracks()     const {return fTracks->GetEntriesFast();}
-  Int_t GetNumberOfHLTConfMapTracks()     const {return 0;} 
-  // fHLTConfMapTracks->GetEntriesFast();}
-  Int_t GetNumberOfHLTHoughTracks()     const {return  0;  }
-  //  fHLTHoughTracks->GetEntriesFast();  }
-
-  Int_t GetNumberOfMuonTracks() const {return fMuonTracks->GetEntriesFast();}
-  Int_t GetNumberOfPmdTracks() const {return fPmdTracks->GetEntriesFast();}
-  Int_t GetNumberOfTrdTracks() const {return fTrdTracks->GetEntriesFast();}
-  Int_t GetNumberOfV0s()      const {return fV0s->GetEntriesFast();}
-  Int_t GetNumberOfCascades() const {return fCascades->GetEntriesFast();}
-  Int_t GetNumberOfKinks() const {return fKinks->GetEntriesFast();}
-  Int_t GetNumberOfCaloClusters() const {return fCaloClusters->GetEntriesFast();}
+  void SetPrimaryVertex(const AliESDVertex *vertex) {
+     new (&fPrimaryVertex) AliESDVertex(*vertex);
+  }
+  const AliESDVertex *GetPrimaryVertex() const {return &fPrimaryVertex;}
+
+  void SetDiamond(const AliESDVertex *vertex) {
+    fDiamondXY[0]=vertex->GetXv();
+    fDiamondXY[1]=vertex->GetYv();
+    Double_t cov[6];
+    vertex->GetCovMatrix(cov);
+    fDiamondCovXY[0]=cov[0];
+    fDiamondCovXY[1]=cov[1];
+    fDiamondCovXY[2]=cov[2];
+  }
+  Float_t GetDiamondX() const {return fDiamondXY[0];}
+  Float_t GetDiamondY() const {return fDiamondXY[1];}
+  Float_t GetSigma2DiamondX() const {return fDiamondCovXY[0];}
+  Float_t GetSigma2DiamondY() const {return fDiamondCovXY[2];}
+  void GetDiamondCovXY(Float_t cov[3]) const {
+    for(Int_t i=0;i<3;i++) cov[i]=fDiamondCovXY[i]; return;
+  }
+
+  Int_t  GetEventNumberInFile() const {return fEventNumberInFile;}
+  UShort_t GetBunchCrossNumber() const {return fBunchCrossNumber;}
+  UInt_t GetOrbitNumber() const {return fOrbitNumber;}
+  UInt_t GetPeriodNumber() const {return fPeriodNumber;}
+  Int_t  GetRunNumber() const {return fRunNumber;}
+  UInt_t    GetTimeStamp()  const { return fTimeStamp;}
+  UInt_t    GetEventType()  const { return fEventType;}
+  ULong64_t GetTriggerMask() const {return fTriggerMask;}
+  UChar_t  GetTriggerCluster() const {return fTriggerCluster;}
+  
+  Int_t GetNumberOfTracks()     const {return fTracks.GetEntriesFast();}
+  Int_t GetNumberOfHLTConfMapTracks()     const {return fHLTConfMapTracks.GetEntriesFast();}
+  Int_t GetNumberOfHLTHoughTracks()     const {return fHLTHoughTracks.GetEntriesFast();}
+  Int_t GetNumberOfMuonTracks() const {return fMuonTracks.GetEntriesFast();}
+  Int_t GetNumberOfPmdTracks() const {return fPmdTracks.GetEntriesFast();}
+  Int_t GetNumberOfTrdTracks() const {return fTrdTracks.GetEntriesFast();}
+  Int_t GetNumberOfV0s()      const {return fV0s.GetEntriesFast();}
+  Int_t GetNumberOfCascades() const {return fCascades.GetEntriesFast();}
+  Int_t GetNumberOfKinks() const {return fKinks.GetEntriesFast();}
+  Int_t GetNumberOfCaloClusters() const {return fCaloClusters.GetEntriesFast();}
 
   Int_t GetNumberOfEMCALClusters() const {return fEMCALClusters;}
   void  SetNumberOfEMCALClusters(Int_t clus) {fEMCALClusters = clus;}
   Int_t GetFirstEMCALCluster() const {return fFirstEMCALCluster;}
   void  SetFirstEMCALCluster(Int_t index) {fFirstEMCALCluster = index;}
-  TArrayF *GetEMCALTriggerPosition() const {return  fEMCALTrigger->GetTriggerPosition();}
-  TArrayF *GetEMCALTriggerAmplitudes() const {return  fEMCALTrigger->GetTriggerAmplitudes();}
+  TArrayF *GetEMCALTriggerPosition() const {return  fEMCALTriggerPosition;}
+  TArrayF *GetEMCALTriggerAmplitudes() const {return  fEMCALTriggerAmplitudes;}
 
   Int_t GetNumberOfPHOSClusters() const {return fPHOSClusters;}
   void  SetNumberOfPHOSClusters(Int_t part) { fPHOSClusters = part ; }
   void  SetFirstPHOSCluster(Int_t index) { fFirstPHOSCluster = index ; } 
   Int_t GetFirstPHOSCluster() const  { return fFirstPHOSCluster ; }
-  TArrayF *GetPHOSTriggerPosition() const {return  fPHOSTrigger->GetTriggerPosition();}
-  TArrayF *GetPHOSTriggerAmplitudes() const {return  fPHOSTrigger->GetTriggerAmplitudes();}
+  TArrayF *GetPHOSTriggerPosition() const {return  fPHOSTriggerPosition;}
+  TArrayF *GetPHOSTriggerAmplitudes() const {return  fPHOSTriggerAmplitudes;}
+
+
+  Float_t GetT0zVertex() const {return fT0zVertex;}
+  void SetT0zVertex(Float_t z) {fT0zVertex=z;}
+  Float_t GetT0() const {return fT0timeStart;}
+  void SetT0(Float_t timeStart) {fT0timeStart = timeStart;}
+  const Float_t * GetT0time() const {return fT0time;}
+  void SetT0time(Float_t time[24]) {
+    for (Int_t i=0; i<24; i++) fT0time[i] = time[i];
+  }
+  const Float_t * GetT0amplitude() const {return fT0amplitude;}
+  void SetT0amplitude(Float_t amp[24]) {
+    for (Int_t i=0; i<24; i++) fT0amplitude[i] = amp[i];
+  }
+
+  Float_t GetZDCN1Energy() const {return fZDCN1Energy;}
+  Float_t GetZDCP1Energy() const {return fZDCP1Energy;}
+  Float_t GetZDCN2Energy() const {return fZDCN2Energy;}
+  Float_t GetZDCP2Energy() const {return fZDCP2Energy;}
+  Float_t GetZDCEMEnergy() const {return fZDCEMEnergy;}
+  Int_t   GetZDCParticipants() const {return fZDCParticipants;}
+  void    SetZDC(Float_t n1Energy, Float_t p1Energy, Float_t emEnergy,
+                 Float_t n2Energy, Float_t p2Energy, Int_t participants) 
+   {fZDCN1Energy=n1Energy; fZDCP1Energy=p1Energy; fZDCEMEnergy=emEnergy;
+    fZDCN2Energy=n2Energy; fZDCP2Energy=p2Energy; fZDCParticipants=participants;}
 
-  void ResetV0s() { fV0s->Clear(); }
-  void ResetCascades() { fCascades->Clear(); }
+  void ResetV0s() { fV0s.Clear(); }
+  void ResetCascades() { fCascades.Clear(); }
   void Reset();
 
   void  Print(Option_t *option="") const;
 
-  void AddObject(TObject* obj);
-  void ReadFromTree(TTree *tree);
-  const void WriteToTree(TTree* tree) const {tree->Branch(fESDObjects);}
-  void GetStdContent();
-  void CreateStdContent();
-  void SetStdNames();
-  TList* GetList(){return fESDObjects;}
+  void SetFMDData(AliESDFMD * obj) { fESDFMD = new AliESDFMD(*obj); }
+  AliESDFMD *GetFMDData(){ return fESDFMD; }
+   
+  void SetVZEROData(AliESDVZERO * obj) { fESDVZERO = new AliESDVZERO(*obj); }
+  AliESDVZERO *GetVZEROData(){ return fESDVZERO; }
 
-protected:
-  AliESD(const AliESD&);
+  AliRawDataErrorLog *GetErrorLog(Int_t i) const {
+    return (AliRawDataErrorLog *)fErrorLogs.UncheckedAt(i);
+  }
+  void  AddRawDataErrorLog(const AliRawDataErrorLog *log) {
+    new(fErrorLogs[fErrorLogs.GetEntriesFast()]) AliRawDataErrorLog(*log);
+  }
+  Int_t GetNumberOfErrorLogs()   const {return fErrorLogs.GetEntriesFast();}
+  AliESD(const AliESD&);  
   AliESD &operator=(const AliESD& source);
 
+protected:
+  
+
 
-  TList *fESDObjects;             // List of esd Objects
-
-  AliESDRun       *fESDRun;           //! Run information tmp put in the Userdata
-  AliESDHeader    *fHeader;           //! ESD Event Header
-  AliESDZDC       *fESDZDC;           //! ZDC information
-  AliESDFMD       *fESDFMD;           //! FMD object containing rough multiplicity
-  AliESDVZERO     *fESDVZERO;         //! VZERO object containing rough multiplicity
-  AliESDTZERO     *fESDTZERO;         //! TZEROObject
-  AliESDVertex    *fSPDVertex;        //! Primary vertex estimated by the SPD
-  AliESDVertex    *fPrimaryVertex;    //! Primary vertex estimated using ESD tracks
-  AliMultiplicity *fSPDMult;          //! SPD tracklet multiplicity
-  AliESDCaloTrigger* fPHOSTrigger;     //! PHOS Trigger information
-  AliESDCaloTrigger* fEMCALTrigger;    //! PHOS Trigger information
-
-  TClonesArray *fTracks;           //! ESD tracks 
-  //  TClonesArray *fHLTConfMapTracks; //! HLT ESD tracks from Conformal Mapper method
-  //  TClonesArray *fHLTHoughTracks;   //! HLT ESD tracks from Hough Transform method
-  TClonesArray *fMuonTracks;       //! MUON ESD tracks
-  TClonesArray *fPmdTracks;        //! PMD ESD tracks
-  TClonesArray *fTrdTracks;        //! TRD ESD tracks (triggered)
-  TClonesArray *fV0s;              //! V0 vertices
-  TClonesArray *fCascades;         //! Cascade vertices
-  TClonesArray *fKinks;            //! Kinks
-  TClonesArray *fCaloClusters;     //! Calorimeter clusters for PHOS/EMCAL
-  TClonesArray *fErrorLogs;        //! Raw-data reading error messages
-
-
-  // Remove this stuff CKB
+  // Event Identification
+
+  Int_t        fEventNumberInFile;// running Event count in the file
+  UShort_t     fBunchCrossNumber;// Bunch Crossing Number
+  UInt_t       fOrbitNumber;     // Orbit Number
+  UInt_t       fPeriodNumber;    // Period Number
+  Int_t        fRunNumber;       // Run Number
+  UInt_t       fTimeStamp;       // Time stamp
+  UInt_t       fEventType;       // Type of Event
+  ULong64_t    fTriggerMask;     // Trigger Type (mask)
+  UChar_t      fTriggerCluster;  // Trigger cluster (mask)
+  Int_t        fRecoVersion;     // Version of reconstruction 
+  Float_t      fMagneticField;   // Solenoid Magnetic Field in kG : for compatibility with AliMagF
+
+  Float_t      fZDCN1Energy;      // reconstructed energy in the neutron ZDC
+  Float_t      fZDCP1Energy;      // reconstructed energy in the proton ZDC
+  Float_t      fZDCN2Energy;      // reconstructed energy in the neutron ZDC
+  Float_t      fZDCP2Energy;      // reconstructed energy in the proton ZDC
+  Float_t      fZDCEMEnergy;     // reconstructed energy in the electromagnetic ZDC
+  Int_t        fZDCParticipants; // number of participants estimated by the ZDC
+
+  Float_t      fT0zVertex;       // vertex z position estimated by the T0
+  AliESDVertex fSPDVertex;       // Primary vertex estimated by the SPD
+  AliESDVertex fPrimaryVertex;   // Primary vertex estimated using ESD tracks
+  Float_t      fDiamondXY[2];    // Interaction diamond (x,y) in RUN
+  Float_t      fDiamondCovXY[3]; // Interaction diamond covariance (x,y) in RUN
+  AliMultiplicity fSPDMult;      // SPD tracklet multiplicity
+
+  Float_t      fT0timeStart;     // interaction time estimated by the T0
+  Float_t      fT0time[24];      // best TOF on each T0 PMT
+  Float_t      fT0amplitude[24]; // number of particles(MIPs) on each T0 PMT
+
+  TClonesArray fTracks;          // ESD tracks
+  TClonesArray fHLTConfMapTracks;// HLT ESD tracks from Conformal Mapper method
+  TClonesArray fHLTHoughTracks;  // HLT ESD tracks from Hough Transform method
+  TClonesArray fMuonTracks;      // MUON ESD tracks
+  TClonesArray fPmdTracks;       // PMD ESD tracks
+  TClonesArray fTrdTracks;       // TRD ESD tracks (triggered)
+  TClonesArray fV0s;             // V0 vertices
+  TClonesArray fCascades;        // Cascade vertices
+  TClonesArray fKinks;           // Kinks
+  TClonesArray fCaloClusters;    // Calorimeter clusters for PHOS/EMCAL
   Int_t        fEMCALClusters;   // Number of EMCAL clusters (subset of caloclusters)
   Int_t        fFirstEMCALCluster; // First EMCAL cluster in the fCaloClusters list 
+  TArrayF   *fEMCALTriggerPosition; ///(x,y,z of 2x2 and x,y,z of nxn) not position of centroid but of patch corner
+  TArrayF   *fEMCALTriggerAmplitudes; //(2x2 max ampl, 2x2 amp out of patch,  nxn max ampl, nxn amp out of patch)
 
   Int_t        fPHOSClusters;     // Number of PHOS clusters (subset of caloclusters)
   Int_t        fFirstPHOSCluster; // First PHOS cluster in the fCaloClusters list 
+  TArrayF   *fPHOSTriggerPosition; //(x,y,z of 2x2 and x,y,z of nxn), not position of centroid but of patch corner
+  TArrayF   *fPHOSTriggerAmplitudes; //(2x2 max ampl, 2x2 amp out of patch,  nxn max ampl, nxn amp out of patch)
+
+  AliESDFMD   *fESDFMD;   // FMD object containing rough multiplicity
+  AliESDVZERO *fESDVZERO; // VZERO object containing rough multiplicity
+
+  TClonesArray fErrorLogs;        // Raw-data reading error messages
 
-  ClassDef(AliESD,23)  //ESD class 
+  ClassDef(AliESD,21)  //ESD class 
 };
 #endif 
 
diff --git a/STEER/AliESDEvent.cxx b/STEER/AliESDEvent.cxx
new file mode 100644 (file)
index 0000000..bcdaffc
--- /dev/null
@@ -0,0 +1,656 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+/* $Id$ */
+
+//-----------------------------------------------------------------
+//           Implementation of the ESD class
+//   This is the class to deal with during the phisical analysis of data
+//   This class is generated directly by the reconstruction methods
+//      Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch
+//-----------------------------------------------------------------
+
+#include "TList.h"
+#include <TNamed.h>
+
+#include "AliESDEvent.h"
+#include "AliESDfriend.h"
+#include "AliESDVZERO.h"
+#include "AliESDHLTtrack.h"
+#include "AliESDFMD.h"
+#include "AliESD.h"
+
+
+ClassImp(AliESDEvent)
+
+//______________________________________________________________________________
+AliESDEvent::AliESDEvent():
+  fESDObjects(new TList()),
+  fESDRun(0),
+  fHeader(0),
+  fESDZDC(0),
+  fESDFMD(0),
+  fESDVZERO(0),
+  fESDTZERO(0),
+  fSPDVertex(0),
+  fPrimaryVertex(0),
+  fSPDMult(0),
+  fPHOSTrigger(0),
+  fEMCALTrigger(0),
+  fTracks(0),
+  fMuonTracks(0),
+  fPmdTracks(0),
+  fTrdTracks(0),
+  fV0s(0),  
+  fCascades(0),
+  fKinks(0),
+  fCaloClusters(0),
+  fErrorLogs(0),
+  fESDOld(0),
+  fEMCALClusters(0), 
+  fFirstEMCALCluster(-1),
+  fPHOSClusters(0), 
+  fFirstPHOSCluster(-1)
+{
+}
+//______________________________________________________________________________
+AliESDEvent::AliESDEvent(const AliESDEvent& esd):
+  TObject(esd),
+  fESDObjects(new TList()),
+  fESDRun(new AliESDRun(*esd.fESDRun)),
+  fHeader(new AliESDHeader(*esd.fHeader)),
+  fESDZDC(new AliESDZDC(*esd.fESDZDC)),
+  fESDFMD(new AliESDFMD(*esd.fESDFMD)),
+  fESDVZERO(new AliESDVZERO(*esd.fESDVZERO)),
+  fESDTZERO(new AliESDTZERO(*esd.fESDTZERO)),
+  fSPDVertex(new AliESDVertex(*esd.fSPDVertex)),
+  fPrimaryVertex(new AliESDVertex(*esd.fPrimaryVertex)),
+  fSPDMult(new AliMultiplicity(*esd.fSPDMult)),
+  fPHOSTrigger(new AliESDCaloTrigger(*esd.fPHOSTrigger)),
+  fEMCALTrigger(new AliESDCaloTrigger(*esd.fEMCALTrigger)),
+  fTracks(new TClonesArray(*esd.fTracks)),
+  fMuonTracks(new TClonesArray(*esd.fMuonTracks)),
+  fPmdTracks(new TClonesArray(*esd.fPmdTracks)),
+  fTrdTracks(new TClonesArray(*esd.fTrdTracks)),
+  fV0s(new TClonesArray(*esd.fV0s)),  
+  fCascades(new TClonesArray(*esd.fCascades)),
+  fKinks(new TClonesArray(*esd.fKinks)),
+  fCaloClusters(new TClonesArray(*esd.fCaloClusters)),
+  fErrorLogs(new TClonesArray(*esd.fErrorLogs)),
+  fESDOld(new AliESD(*esd.fESDOld)),
+  fEMCALClusters(esd.fEMCALClusters), 
+  fFirstEMCALCluster(esd.fFirstEMCALCluster),
+  fPHOSClusters(esd.fPHOSClusters), 
+  fFirstPHOSCluster(esd.fFirstPHOSCluster)
+
+{
+  // CKB init in the constructor list and only add here ...
+  AddObject(fESDRun);
+  AddObject(fHeader);
+  AddObject(fESDZDC);
+  AddObject(fESDFMD);
+  AddObject(fESDVZERO);
+  AddObject(fESDTZERO);
+  AddObject(fSPDVertex);
+  AddObject(fPrimaryVertex);
+  AddObject(fSPDMult);
+  AddObject(fPHOSTrigger);
+  AddObject(fEMCALTrigger);
+  AddObject(fTracks);
+  AddObject(fMuonTracks);
+  AddObject(fPmdTracks);
+  AddObject(fTrdTracks);
+  AddObject(fV0s);
+  AddObject(fCascades);
+  AddObject(fKinks);
+  AddObject(fCaloClusters);
+  AddObject(fErrorLogs);
+
+  GetStdContent();
+
+}
+
+//______________________________________________________________________________
+AliESDEvent & AliESDEvent::operator=(const AliESDEvent& source) {
+
+  // Assignment operator
+
+  if(&source == this) return *this;
+  TObject::operator=(source);
+
+  fESDRun = new AliESDRun(*source.fESDRun);
+  fHeader = new AliESDHeader(*source.fHeader);
+  fESDZDC = new AliESDZDC(*source.fESDZDC);
+  fESDFMD = new AliESDFMD(*source.fESDFMD);
+  fESDVZERO = new AliESDVZERO(*source.fESDVZERO);
+  fESDTZERO = new AliESDTZERO(*source.fESDTZERO);
+  fSPDVertex = new AliESDVertex(*source.fSPDVertex);
+  fPrimaryVertex = new AliESDVertex(*source.fPrimaryVertex);
+  fSPDMult = new AliMultiplicity(*source.fSPDMult);
+  fPHOSTrigger = new AliESDCaloTrigger(*source.fPHOSTrigger);
+  fEMCALTrigger = new AliESDCaloTrigger(*source.fEMCALTrigger);
+  fTracks = new TClonesArray(*source.fTracks);
+  fMuonTracks = new TClonesArray(*source.fMuonTracks);
+  fPmdTracks = new TClonesArray(*source.fPmdTracks);
+  fTrdTracks = new TClonesArray(*source.fTrdTracks);
+  fV0s = new TClonesArray(*source.fV0s);
+  fCascades = new TClonesArray(*source.fCascades);
+  fKinks = new TClonesArray(*source.fKinks);
+  fCaloClusters = new TClonesArray(*source.fCaloClusters);
+  fErrorLogs = new TClonesArray(*source.fErrorLogs);
+  fESDOld = new AliESD(*source.fESDOld);
+  // CKB this way?? or 
+  // or AddObject(  fESDZDC = new AliESDZDC(*source.fESDZDC));
+
+  fESDObjects = new TList();
+  AddObject(fESDRun);
+  AddObject(fHeader);
+  AddObject(fESDZDC);
+  AddObject(fESDFMD);
+  AddObject(fESDVZERO);
+  AddObject(fESDTZERO);
+  AddObject(fSPDVertex);
+  AddObject(fPrimaryVertex);
+  AddObject(fSPDMult);
+  AddObject(fPHOSTrigger);
+  AddObject(fEMCALTrigger);
+  AddObject(fTracks);
+  AddObject(fMuonTracks);
+  AddObject(fPmdTracks);
+  AddObject(fTrdTracks);
+  AddObject(fV0s);
+  AddObject(fCascades);
+  AddObject(fKinks);
+  AddObject(fCaloClusters);
+  AddObject(fErrorLogs);
+
+
+  fEMCALClusters = source.fEMCALClusters;
+  fFirstEMCALCluster = source.fFirstEMCALCluster;
+  fPHOSClusters = source.fPHOSClusters;
+  fFirstPHOSCluster = source.fFirstPHOSCluster;
+
+
+
+  return *this;
+
+}
+
+
+//______________________________________________________________________________
+AliESDEvent::~AliESDEvent()
+{
+  //
+  // Standard destructor
+  //
+
+  delete fESDObjects;
+  fESDObjects = 0;
+
+  // everthing on the list gets deleted automatically
+
+  /*
+  fHLTConfMapTracks.Delete();
+  fHLTHoughTracks.Delete();
+  fMuonTracks.Delete();  
+  fPmdTracks.Delete();
+  fTrdTracks.Delete();
+  fV0s.Delete();
+  fCascades.Delete();
+  fKinks.Delete();
+  fCaloClusters.Delete();
+  */
+//   fEMCALTriggerPosition->Delete();
+//   fEMCALTriggerAmplitudes->Delete();
+//   fPHOSTriggerPosition->Delete();
+//   fPHOSTriggerAmplitudes->Delete();
+//   delete fEMCALTriggerPosition;
+//   delete fEMCALTriggerAmplitudes;
+//   delete fPHOSTriggerPosition;
+//   delete fPHOSTriggerAmplitudes;
+
+}
+
+//______________________________________________________________________________
+void AliESDEvent::Reset()
+{
+
+  
+  // Reset the standard contents
+  ResetStdContent(); 
+
+  if(fESDOld)fESDOld->Reset();
+
+}
+
+void AliESDEvent::ResetStdContent()
+{
+  // Reset the standard contents
+  if(fESDRun) fESDRun->Reset();
+  if(fHeader) fHeader->Reset();
+  if(fESDZDC) fESDZDC->Reset();
+  if(fESDFMD) fESDFMD->Clear(); // why clear.... need consistend names
+  // if(fESDVZERO) fESDVZERO->; // NOT IMPLEMENTED 
+  //  if(fESDVZERO) new (fESDVZERO) AliESDVZERO();
+  if(fESDTZERO) fESDTZERO->Reset(); 
+  // CKB no clear/reset implemented
+  if(fSPDVertex){
+    new (fSPDVertex) AliESDVertex();
+    fSPDVertex->SetName("SPDVertex");
+  }
+  if(fPrimaryVertex){
+    new (fPrimaryVertex) AliESDVertex();
+    fPrimaryVertex->SetName("PrimaryVertex");
+  }
+  if(fSPDMult)new (fSPDMult) AliMultiplicity();
+  if(fPHOSTrigger)fPHOSTrigger->Reset(); 
+  if(fEMCALTrigger)fEMCALTrigger->Reset(); 
+  if(fTracks)fTracks->Clear();
+  if(fMuonTracks)fMuonTracks->Clear();
+  if(fPmdTracks)fPmdTracks->Clear();
+  if(fTrdTracks)fTrdTracks->Clear();
+  if(fV0s)fV0s->Clear();
+  if(fCascades)fCascades->Clear();
+  if(fKinks)fKinks->Clear();
+  if(fCaloClusters)fCaloClusters->Clear();
+  if(fErrorLogs) fErrorLogs->Clear();
+
+  fEMCALClusters=0; 
+  fFirstEMCALCluster=-1; 
+  fPHOSClusters=0; 
+  fFirstPHOSCluster=-1; 
+}
+
+
+Int_t AliESDEvent::AddV0(const AliESDv0 *v) {
+  //
+  // Add V0
+  //
+  TClonesArray &fv = *fV0s;
+  Int_t idx=fV0s->GetEntriesFast();
+  new(fv[idx]) AliESDv0(*v);
+  return idx;
+}  
+
+//______________________________________________________________________________
+void AliESDEvent::Print(Option_t *) const 
+{
+  //
+  // Print header information of the event
+  //
+  printf("ESD run information\n");
+  printf("Event # in file %d Bunch crossing # %d Orbit # %d Period # %d Run # %d Trigger %lld Magnetic field %f \n",
+        GetEventNumberInFile(),
+        GetBunchCrossNumber(),
+        GetOrbitNumber(),
+        GetPeriodNumber(),
+        GetRunNumber(),
+        GetTriggerMask(),
+        GetMagneticField() );
+  printf("Vertex: (%.4f +- %.4f, %.4f +- %.4f, %.4f +- %.4f) cm\n",
+          fPrimaryVertex->GetXv(), fPrimaryVertex->GetXRes(),
+          fPrimaryVertex->GetYv(), fPrimaryVertex->GetYRes(),
+          fPrimaryVertex->GetZv(), fPrimaryVertex->GetZRes());
+    printf("Mean vertex in RUN: X=%.4f Y=%.4f cm\n",
+          GetDiamondX(),GetDiamondY());
+    printf("SPD Multiplicity. Number of tracklets %d \n",
+           fSPDMult->GetNumberOfTracklets());
+  printf("Number of tracks: \n");
+  printf("                 charged   %d\n", GetNumberOfTracks());
+  printf("                 muon      %d\n", GetNumberOfMuonTracks());
+  printf("                 pmd       %d\n", GetNumberOfPmdTracks());
+  printf("                 trd       %d\n", GetNumberOfTrdTracks());
+  printf("                 v0        %d\n", GetNumberOfV0s());
+  printf("                 cascades  %d\n", GetNumberOfCascades());
+  printf("                 kinks     %d\n", GetNumberOfKinks());
+  printf("                 CaloClusters %d\n", GetNumberOfCaloClusters());
+  printf("                 phos      %d\n", GetNumberOfPHOSClusters());
+  printf("                 emcal     %d\n", GetNumberOfEMCALClusters());
+  printf("                 FMD       %s\n", (fESDFMD ? "yes" : "no"));
+  printf("                 VZERO     %s\n", (fESDVZERO ? "yes" : "no"));
+}
+
+void AliESDEvent::SetESDfriend(const AliESDfriend *ev) {
+  //
+  // Attaches the complementary info to the ESD
+  //
+  if (!ev) return;
+
+  Int_t ntrk=ev->GetNumberOfTracks();
+  for (Int_t i=0; i<ntrk; i++) {
+    const AliESDfriendTrack *f=ev->GetTrack(i);
+    GetTrack(i)->SetFriendTrack(f);
+  }
+}
+
+Int_t  AliESDEvent::AddTrack(const AliESDtrack *t) {
+    // Add track
+    TClonesArray &ftr = *fTracks;
+    AliESDtrack * track = new(ftr[fTracks->GetEntriesFast()])AliESDtrack(*t);
+    track->SetID(fTracks->GetEntriesFast()-1);
+    return  track->GetID();    
+}
+
+Int_t AliESDEvent::AddKink(const AliESDkink *c) {
+    // Add kink
+    TClonesArray &fk = *fKinks;
+    AliESDkink * kink = new(fk[fKinks->GetEntriesFast()]) AliESDkink(*c);
+    kink->SetID(fKinks->GetEntriesFast()); // CKB different from the other imps..
+    return fKinks->GetEntriesFast()-1;
+}
+
+Int_t AliESDEvent::AddCaloCluster(const AliESDCaloCluster *c) {
+    // Add calocluster
+    TClonesArray &fc = *fCaloClusters;
+    AliESDCaloCluster *clus = new(fc[fCaloClusters->GetEntriesFast()]) AliESDCaloCluster(*c);
+    clus->SetID(fCaloClusters->GetEntriesFast()-1);
+    return fCaloClusters->GetEntriesFast()-1;
+  }
+
+
+void AliESDEvent::SetFMDData(AliESDFMD * obj) { 
+  // use already allocated space
+  if(fESDFMD){
+    new(fESDFMD) AliESDFMD(*obj); 
+  }
+}
+
+void AliESDEvent::SetVZEROData(AliESDVZERO * obj){ 
+  // use already allocated space
+  if(fESDVZERO)
+    new(fESDVZERO) AliESDVZERO(*obj);
+}
+
+void AliESDEvent::GetESDfriend(AliESDfriend *ev) const {
+  //
+  // Extracts the complementary info from the ESD
+  //
+  if (!ev) return;
+
+  Int_t ntrk=GetNumberOfTracks();
+
+  for (Int_t i=0; i<ntrk; i++) {
+    const AliESDtrack *t=GetTrack(i);
+    const AliESDfriendTrack *f=t->GetFriendTrack();
+    ev->AddTrack(f);
+  }
+}
+
+
+void AliESDEvent::AddObject(TObject* obj) 
+{
+  // Add an object to the list of object.
+  // Please be aware that in order to increase performance you should
+  // refrain from using TObjArrays (if possible). Use TClonesArrays, instead.
+  fESDObjects->SetOwner(kTRUE);
+  fESDObjects->AddLast(obj);
+}
+
+
+void AliESDEvent::GetStdContent() 
+{
+  // set pointers for standard content
+
+  fESDRun = (AliESDRun*)fESDObjects->At(kESDRun);
+  fHeader = (AliESDHeader*)fESDObjects->At(kHeader);
+  fESDZDC = (AliESDZDC*)fESDObjects->At(kESDZDC);
+  fESDFMD = (AliESDFMD*)fESDObjects->At(kESDFMD);
+  fESDVZERO = (AliESDVZERO*)fESDObjects->At(kESDVZERO);
+  fESDTZERO = (AliESDTZERO*)fESDObjects->At(kESDTZERO);
+  fSPDVertex = (AliESDVertex*)fESDObjects->At(kSPDVertex);
+  fPrimaryVertex = (AliESDVertex*)fESDObjects->At(kPrimaryVertex);
+  fSPDMult =       (AliMultiplicity*)fESDObjects->At(kSPDMult);
+  fPHOSTrigger = (AliESDCaloTrigger*)fESDObjects->At(kPHOSTrigger);
+  fEMCALTrigger = (AliESDCaloTrigger*)fESDObjects->At(kEMCALTrigger);
+  fTracks = (TClonesArray*)fESDObjects->At(kTracks);
+  fMuonTracks = (TClonesArray*)fESDObjects->At(kMuonTracks);
+  fPmdTracks = (TClonesArray*)fESDObjects->At(kPmdTracks);
+  fTrdTracks = (TClonesArray*)fESDObjects->At(kTrdTracks);
+  fV0s = (TClonesArray*)fESDObjects->At(kV0s);
+  fCascades = (TClonesArray*)fESDObjects->At(kCascades);
+  fKinks = (TClonesArray*)fESDObjects->At(kKinks);
+  fCaloClusters = (TClonesArray*)fESDObjects->At(kCaloClusters);
+  fErrorLogs = (TClonesArray*)fESDObjects->At(kErrorLogs);
+
+}
+
+void AliESDEvent::SetStdNames(){
+  // Set the names of the standard contents
+  fSPDVertex->SetName("SPDVertex");
+  fPrimaryVertex->SetName("PrimaryVertex");
+  fPHOSTrigger->SetName("PHOSTrigger");
+  fEMCALTrigger->SetName("EMCALTrigger");
+  fTracks->SetName("Tracks");
+  fMuonTracks->SetName("MuonTracks");
+  fPmdTracks->SetName("PmdTracks");
+  fTrdTracks->SetName("TrdTracks");
+  fV0s->SetName("V0s");
+  fCascades->SetName("Cascades");
+  fKinks->SetName("Kinks");
+  fCaloClusters->SetName("CaloClusters");
+
+} 
+
+void AliESDEvent::CreateStdContent() 
+{
+  // create the standard AOD content and set pointers
+
+  // create standard objects and add them to the TList of objects
+  AddObject(new AliESDRun());
+  AddObject(new AliESDHeader());
+  AddObject(new AliESDZDC());
+  AddObject(new AliESDFMD());
+  AddObject(new AliESDVZERO());
+  AddObject(new AliESDTZERO());
+  AddObject(new AliESDVertex());
+  AddObject(new AliESDVertex());
+  AddObject(new AliMultiplicity());
+  AddObject(new AliESDCaloTrigger());
+  AddObject(new AliESDCaloTrigger());
+  AddObject(new TClonesArray("AliESDtrack",0));
+  AddObject(new TClonesArray("AliESDMuonTrack",0));
+  AddObject(new TClonesArray("AliESDPmdTrack",0));
+  AddObject(new TClonesArray("AliESDTrdTrack",0));
+  AddObject(new TClonesArray("AliESDv0",0));
+  AddObject(new TClonesArray("AliESDcascade",0));
+  AddObject(new TClonesArray("AliESDkink",0));
+  AddObject(new TClonesArray("AliESDCaloCluster",0));
+  AddObject(new TClonesArray("AliRawDataErrorLog",0));
+
+  // check the order of the indices against enum...
+
+  // read back pointers
+  GetStdContent();
+  // set names
+  SetStdNames();
+
+}
+
+void AliESDEvent::ReadFromTree(TTree *tree){
+  
+  // if we just replace the TList we produce a memory leak...
+  // so better replace the TList 
+
+  if(fESDObjects->GetEntries()!=0){
+    // this should not happen here put a warning?
+  }
+  // prevent a memory leak when reading back the TList
+  delete fESDObjects;
+  fESDObjects = 0;
+  
+
+
+  // if we find the esd on the tree we do have the old structuru
+  if(tree->GetBranch("ESD")){
+    printf("%s %d AliESDEvent::ReadFromTree() Reading old Tree \n",(char*)__FILE__,__LINE__);
+    tree->SetBranchAddress("ESD",&fESDOld);
+    fESDObjects = new TList();
+    CreateStdContent(); // create for copy
+    // when reading back we are not owner of the list 
+    // must not delete it
+    fESDObjects->SetOwner(kFALSE);
+    return;
+  }
+
+  fESDOld = 0;
+
+
+  // Try to find AliESDEvent
+  AliESDEvent *esdEvent = 0;
+  esdEvent = (AliESDEvent*)tree->GetTree()->GetUserInfo()->FindObject("AliESDEvent");
+
+
+  if(esdEvent){
+    // create a new TList from the UserInfo TList... 
+    // copy constructor does not work...
+    fESDObjects = (TList*)(esdEvent->GetList()->Clone());
+    // fESDObjects = esdEvent->GetList(); 
+    if(fESDObjects->GetEntries()<kESDListN){
+      printf("%s %d AliESDEvent::ReadFromTree() TList contains less than the standard contents %d < %d \n",(char*)__FILE__,__LINE__,fESDObjects->GetEntries(),kESDListN);
+    }
+    // set the branch addresses
+    TIter next(fESDObjects);
+    TNamed *el;
+    while((el=(TNamed*)next())){
+      TString bname(el->GetName());
+      
+      if(bname.CompareTo("AliESDfriend")==0)
+       {
+         // AliESDfriend does not have a name ...
+         // tree->SetBranchStatus("ESDfriend.*",1); // Use a flag to activate... 
+         tree->SetBranchAddress("ESDfriend.",fESDObjects->GetObjectRef(el));
+       }
+      else{
+       tree->SetBranchAddress(bname.Data(),fESDObjects->GetObjectRef(el));
+      }
+    }
+    GetStdContent();
+    // when reading back we are not owner of the list 
+    // must not delete it
+    fESDObjects->SetOwner(kFALSE);
+  }// no esdEvent
+  else {
+    // Hack.... we can't get the list from the user data try create and set it by hand...
+    fESDObjects = new TList(); 
+    CreateStdContent();
+    TIter next(fESDObjects);
+    TNamed *el;
+    while((el=(TNamed*)next())){
+      TString bname(el->GetName());    
+      tree->SetBranchAddress(bname.Data(),fESDObjects->GetObjectRef(el));
+    }
+    GetStdContent();
+    // when reading back we are not owner of the list 
+    // must not delete it
+    fESDObjects->SetOwner(kFALSE);
+  }
+
+
+
+}
+
+
+void AliESDEvent::CopyFromOldESD()
+{
+  // Method which copies over everthing from the old esd structure to the 
+  // new  
+
+  if(fESDOld){
+    ResetStdContent();
+     // Run
+    SetRunNumber(fESDOld->GetRunNumber());
+    SetPeriodNumber(fESDOld->GetPeriodNumber());
+    SetMagneticField(fESDRun->GetMagneticField());
+  
+    // leave out diamond ...
+    // SetDiamond(const AliESDVertex *vertex) { fESDRun->SetDiamond(vertex);}
+
+    // header
+    SetTriggerMask(fESDOld->GetTriggerMask());
+    SetOrbitNumber(fESDOld->GetOrbitNumber());
+    SetTimeStamp(fESDOld->GetTimeStamp());
+    SetEventType(fESDOld->GetEventType());
+    SetEventNumberInFile(fESDOld->GetEventNumberInFile());
+    SetBunchCrossNumber(fESDOld->GetBunchCrossNumber());
+    SetTriggerCluster(fESDOld->GetTriggerCluster());
+
+    // ZDC
+
+    SetZDC(fESDOld->GetZDCN1Energy(),
+          fESDOld->GetZDCP1Energy(),
+          fESDOld->GetZDCEMEnergy(),
+          fESDOld->GetZDCN2Energy(),
+          fESDOld->GetZDCP2Energy(),
+          fESDOld->GetZDCParticipants());
+
+    // FMD
+    
+    SetFMDData(fESDOld->GetFMDData());
+
+    // T0
+
+    SetT0zVertex(fESDOld->GetT0zVertex());
+    SetT0(fESDOld->GetT0());
+    //  leave amps out
+
+    // VZERO
+    SetVZEROData(fESDOld->GetVZEROData());
+
+    SetVertex(fESDOld->GetVertex());
+
+    SetPrimaryVertex(fESDOld->GetPrimaryVertex());
+
+    SetMultiplicity(fESDOld->GetMultiplicity());
+    
+    for(int i = 0;i<fESDOld->GetNumberOfTracks();i++){
+      AddTrack(fESDOld->GetTrack(i));
+    }
+
+    for(int i = 0;i<fESDOld->GetNumberOfMuonTracks();i++){
+      AddMuonTrack(fESDOld->GetMuonTrack(i));
+    }
+
+    for(int i = 0;i<fESDOld->GetNumberOfPmdTracks();i++){
+      AddPmdTrack(fESDOld->GetPmdTrack(i));
+    }
+
+    for(int i = 0;i<fESDOld->GetNumberOfTrdTracks();i++){
+      AddTrdTrack(fESDOld->GetTrdTrack(i));
+    }
+
+    for(int i = 0;i<fESDOld->GetNumberOfV0s();i++){
+      AddV0(fESDOld->GetV0(i));
+    }
+
+    for(int i = 0;i<fESDOld->GetNumberOfCascades();i++){
+      AddCascade(fESDOld->GetCascade(i));
+    }
+
+    for(int i = 0;i<fESDOld->GetNumberOfKinks();i++){
+      AddKink(fESDOld->GetKink(i));
+    }
+
+
+    for(int i = 0;i<fESDOld->GetNumberOfCaloClusters();i++){
+      AddCaloCluster(fESDOld->GetCaloCluster(i));
+    }
+  }// if fesdold
+}
+
+
+
diff --git a/STEER/AliESDEvent.h b/STEER/AliESDEvent.h
new file mode 100644 (file)
index 0000000..7b2a1c5
--- /dev/null
@@ -0,0 +1,363 @@
+// -*- mode: C++ -*- 
+#ifndef ALIESDEVENT_H
+#define ALIESDEVENT_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+
+/* $Id$ */
+
+//-------------------------------------------------------------------------
+//                          Class AliESD
+//   This is the class to deal with during the physical analysis of data
+//      
+//         Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch 
+//-------------------------------------------------------------------------
+
+#include <TClonesArray.h>
+#include <TObject.h>
+#include <TTree.h>
+#include <TArrayF.h>
+
+class TList;
+
+
+#include "AliESDMuonTrack.h"
+#include "AliESDPmdTrack.h"
+#include "AliESDTrdTrack.h"
+#include "AliESDVertex.h"
+#include "AliESDcascade.h"
+#include "AliESDkink.h"
+#include "AliESDtrack.h"
+#include "AliESDCaloCluster.h"
+#include "AliESDv0.h"
+#include "AliESDFMD.h"
+#include "AliESDVZERO.h"
+#include "AliMultiplicity.h"
+#include "AliRawDataErrorLog.h"
+#include "AliESDRun.h"
+#include "AliESDHeader.h"
+#include "AliESDZDC.h"
+#include "AliESDTZERO.h"
+#include "AliESDCaloTrigger.h"
+
+class AliESDfriend;
+class AliESDVZERO;
+class AliESDHLTtrack;
+class AliESDFMD;
+class AliESD;
+
+class AliESDEvent : public TObject {
+public:
+
+
+  enum ESDListIndex_t   {kESDRun,
+                      kHeader,
+                      kESDZDC,
+                      kESDFMD,
+                      kESDVZERO,
+                      kESDTZERO,
+                      kSPDVertex,
+                      kPrimaryVertex,
+                      kSPDMult,
+                      kPHOSTrigger,
+                      kEMCALTrigger,
+                      kTracks,
+                      kMuonTracks,
+                      kPmdTracks,
+                      kTrdTracks,
+                      kV0s,
+                      kCascades,
+                      kKinks,
+                      kCaloClusters,
+                      kErrorLogs,
+                      kESDListN
+  };
+
+  AliESDEvent();
+  virtual ~AliESDEvent(); 
+
+
+  // RUN
+  // move this to the UserData!!!
+  const AliESDRun*    GetESDRun() const {return fESDRun;}
+
+  // Delegated methods for fESDRun
+  void    SetRunNumber(Int_t n) {fESDRun->SetRunNumber(n);}
+  Int_t   GetRunNumber() const {return fESDRun->GetRunNumber();}
+  void    SetPeriodNumber(Int_t n){fESDRun->SetPeriodNumber(n);}
+  Int_t   GetPeriodNumber() const {return fESDRun->GetPeriodNumber();}
+  void    SetMagneticField(Float_t mf){fESDRun->SetMagneticField(mf);}
+  Float_t GetMagneticField() const {return fESDRun->GetMagneticField();}
+  void SetDiamond(const AliESDVertex *vertex) { fESDRun->SetDiamond(vertex);}
+  Float_t GetDiamondX() const {return fESDRun->GetDiamondX();}
+  Float_t GetDiamondY() const {return fESDRun->GetDiamondY();}
+  Float_t GetSigma2DiamondX() const {return  fESDRun->GetSigma2DiamondX();}
+  Float_t GetSigma2DiamondY() const {return  fESDRun->GetSigma2DiamondY();}
+  void GetDiamondCovXY(Float_t cov[3]) const {fESDRun->GetDiamondCovXY(cov);}   
+  
+
+  // HEADER
+  const AliESDHeader* GetHeader() const {return fHeader;}
+
+  // Delegated methods for fHeader
+  void      SetTriggerMask(ULong64_t n) {fHeader->SetTriggerMask(n);}
+  void      SetOrbitNumber(UInt_t n) {fHeader->SetOrbitNumber(n);}
+  void      SetTimeStamp(UInt_t timeStamp){fHeader->SetTimeStamp(timeStamp);}
+  void      SetEventType(UInt_t eventType){fHeader->SetEventType(eventType);}
+  void      SetEventNumberInFile(Int_t n) {fHeader->SetEventNumberInFile(n);}
+  //  void      SetRunNumber(Int_t n) {fHeader->SetRunNumber(n);}
+  void      SetBunchCrossNumber(UShort_t n) {fHeader->SetBunchCrossNumber(n);}
+  void      SetTriggerCluster(UChar_t n) {fHeader->SetTriggerCluster(n);}
+  ULong64_t GetTriggerMask() const {return fHeader->GetTriggerMask();}
+  UInt_t    GetOrbitNumber() const {return fHeader->GetOrbitNumber();}
+  UInt_t    GetTimeStamp()  const { return fHeader->GetTimeStamp();}
+  UInt_t    GetEventType()  const { return fHeader->GetEventType();}
+  Int_t     GetEventNumberInFile() const {return fHeader->GetEventNumberInFile();}
+  UShort_t  GetBunchCrossNumber() const {return fHeader->GetBunchCrossNumber();}
+  UChar_t   GetTriggerCluster() const {return fHeader->GetTriggerCluster();}
+
+  // ZDC CKB: put this in the header?
+  const AliESDZDC*    GetESDZDC() const {return fESDZDC;}
+
+  // Delegated methods for fESDZDC
+  Float_t GetZDCN1Energy() const {return fESDZDC->GetZDCN1Energy();}
+  Float_t GetZDCP1Energy() const {return fESDZDC->GetZDCP1Energy();}
+  Float_t GetZDCN2Energy() const {return fESDZDC->GetZDCN2Energy();}
+  Float_t GetZDCP2Energy() const {return fESDZDC->GetZDCP2Energy();}
+  Float_t GetZDCEMEnergy() const {return fESDZDC->GetZDCEMEnergy();}
+  Int_t   GetZDCParticipants() const {return fESDZDC->GetZDCParticipants();}
+  void    SetZDC(Float_t n1Energy, Float_t p1Energy, Float_t emEnergy,
+                 Float_t n2Energy, Float_t p2Energy, Int_t participants)
+  {fESDZDC->SetZDC(n1Energy, p1Energy, emEnergy, n2Energy, p2Energy, participants);}
+
+
+  // FMD
+  void SetFMDData(AliESDFMD * obj);
+  AliESDFMD *GetFMDData(){ return fESDFMD; }
+
+
+  // TZERO CKB: put this in the header?
+  const AliESDTZERO*    GetESDTZERO() const {return fESDTZERO;}
+  // delegetated methods for fESDTZERO
+
+  Float_t GetT0zVertex() const {return fESDTZERO->GetT0zVertex();}
+  void SetT0zVertex(Float_t z) {fESDTZERO->SetT0zVertex(z);}
+  Float_t GetT0() const {return fESDTZERO->GetT0();}
+  void SetT0(Float_t timeStart) {fESDTZERO->SetT0(timeStart);}
+  const Float_t * GetT0time() const {return fESDTZERO->GetT0time();}
+  void SetT0time(Float_t time[24]) {fESDTZERO->SetT0time(time);}
+  const Float_t * GetT0amplitude() const {return fESDTZERO->GetT0amplitude();}
+  void SetT0amplitude(Float_t amp[24]){fESDTZERO->SetT0amplitude(amp);}
+
+  // VZERO 
+  AliESDVZERO *GetVZEROData() const { return fESDVZERO; }
+  void SetVZEROData(AliESDVZERO * obj);
+
+
+  void SetESDfriend(const AliESDfriend *f);
+  void GetESDfriend(AliESDfriend *f) const;
+
+
+
+  void SetVertex(const AliESDVertex *vertex) {
+    *fSPDVertex  = *vertex;
+    fSPDVertex->SetName("SPDVertex");// error prone use class wide names?
+    //CKB or new with placement
+  }
+  const AliESDVertex *GetVertex() const {return fSPDVertex;}
+
+  void SetPrimaryVertex(const AliESDVertex *vertex) {
+    *fPrimaryVertex = *vertex;
+    fPrimaryVertex->SetName("PrimaryVertex");// error prone use class wide names?
+  }
+  const AliESDVertex *GetPrimaryVertex() const {return fPrimaryVertex;}
+
+  void SetMultiplicity(const AliMultiplicity *mul) {
+    *fSPDMult = *mul;
+    // CKB 
+    //     new (&fSPDMult) AliMultiplicity(*mul);
+  }
+  const AliMultiplicity *GetMultiplicity() const {return fSPDMult;}
+  
+  AliESDtrack *GetTrack(Int_t i) const {
+    return (AliESDtrack *)fTracks->UncheckedAt(i);
+  }
+  Int_t  AddTrack(const AliESDtrack *t);
+
+  
+  AliESDHLTtrack *GetHLTConfMapTrack(Int_t /*i*/) const {
+    //    return (AliESDHLTtrack *)fHLTConfMapTracks->UncheckedAt(i);
+    return 0;
+  }
+  void AddHLTConfMapTrack(const AliESDHLTtrack */*t*/) {
+    printf("ESD:: AddHLTConfMapTrack do nothing \n");
+    //    TClonesArray &fhlt = *fHLTConfMapTracks;
+    //  new(fhlt[fHLTConfMapTracks->GetEntriesFast()]) AliESDHLTtrack(*t);
+  }
+  
+
+  AliESDHLTtrack *GetHLTHoughTrack(Int_t /*i*/) const {
+    //    return (AliESDHLTtrack *)fHLTHoughTracks->UncheckedAt(i);
+    return 0;
+  }
+  void AddHLTHoughTrack(const AliESDHLTtrack */*t*/) {
+    printf("ESD:: AddHLTHoughTrack do nothing \n");
+    //    TClonesArray &fhlt = *fHLTHoughTracks;
+    //     new(fhlt[fHLTHoughTracks->GetEntriesFast()]) AliESDHLTtrack(*t);
+  }
+  
+  AliESDMuonTrack *GetMuonTrack(Int_t i) const {
+    return (AliESDMuonTrack *)fMuonTracks->UncheckedAt(i);
+  }
+  void AddMuonTrack(const AliESDMuonTrack *t) {
+    TClonesArray &fmu = *fMuonTracks;
+    new(fmu[fMuonTracks->GetEntriesFast()]) AliESDMuonTrack(*t);
+  }
+
+  AliESDPmdTrack *GetPmdTrack(Int_t i) const {
+    return (AliESDPmdTrack *)fPmdTracks->UncheckedAt(i);
+  }
+  void AddPmdTrack(const AliESDPmdTrack *t) {
+    TClonesArray &fpmd = *fPmdTracks;
+    new(fpmd[fPmdTracks->GetEntriesFast()]) AliESDPmdTrack(*t);
+  }
+
+  AliESDTrdTrack *GetTrdTrack(Int_t i) const {
+    return (AliESDTrdTrack *)fTrdTracks->UncheckedAt(i);
+  }
+  void AddTrdTrack(const AliESDTrdTrack *t) {
+    TClonesArray &ftrd = *fTrdTracks;
+    new(ftrd[fTrdTracks->GetEntriesFast()]) AliESDTrdTrack(*t);
+  }
+
+  AliESDv0 *GetV0(Int_t i) const {
+    return (AliESDv0*)fV0s->UncheckedAt(i);
+  }
+  Int_t AddV0(const AliESDv0 *v);
+
+  AliESDcascade *GetCascade(Int_t i) const {
+    return (AliESDcascade *)fCascades->UncheckedAt(i);
+  }
+  void AddCascade(const AliESDcascade *c) {
+    TClonesArray &fc = *fCascades;
+    new(fc[fCascades->GetEntriesFast()]) AliESDcascade(*c);
+  }
+
+  AliESDkink *GetKink(Int_t i) const {
+    return (AliESDkink *)fKinks->UncheckedAt(i);
+  }
+  Int_t AddKink(const AliESDkink *c);
+
+  AliESDCaloCluster *GetCaloCluster(Int_t i) const {
+    return (AliESDCaloCluster *)fCaloClusters->UncheckedAt(i);
+  }
+  Int_t AddCaloCluster(const AliESDCaloCluster *c);
+
+  AliRawDataErrorLog *GetErrorLog(Int_t i) const {
+    return (AliRawDataErrorLog *)fErrorLogs->UncheckedAt(i);
+  }
+  void  AddRawDataErrorLog(const AliRawDataErrorLog *log) {
+    // CKB inline this??
+    TClonesArray &errlogs = *fErrorLogs;
+    new(errlogs[errlogs.GetEntriesFast()])  AliRawDataErrorLog(*log);
+  }
+  Int_t GetNumberOfErrorLogs()   const {return fErrorLogs->GetEntriesFast();}
+
+    
+  void AddPHOSTriggerPosition(TArrayF array)   { fPHOSTrigger->AddTriggerPosition(array); }
+  void AddPHOSTriggerAmplitudes(TArrayF array) { fPHOSTrigger->AddTriggerAmplitudes(array);}
+  void AddEMCALTriggerPosition(TArrayF array)  { fEMCALTrigger->AddTriggerPosition(array); }
+  void AddEMCALTriggerAmplitudes(TArrayF array){ fEMCALTrigger->AddTriggerAmplitudes(array); }
+
+
+  Int_t GetNumberOfTracks()     const {return fTracks->GetEntriesFast();}
+  Int_t GetNumberOfHLTConfMapTracks()     const {return 0;} 
+  // fHLTConfMapTracks->GetEntriesFast();}
+  Int_t GetNumberOfHLTHoughTracks()     const {return  0;  }
+  //  fHLTHoughTracks->GetEntriesFast();  }
+
+  Int_t GetNumberOfMuonTracks() const {return fMuonTracks->GetEntriesFast();}
+  Int_t GetNumberOfPmdTracks() const {return fPmdTracks->GetEntriesFast();}
+  Int_t GetNumberOfTrdTracks() const {return fTrdTracks->GetEntriesFast();}
+  Int_t GetNumberOfV0s()      const {return fV0s->GetEntriesFast();}
+  Int_t GetNumberOfCascades() const {return fCascades->GetEntriesFast();}
+  Int_t GetNumberOfKinks() const {return fKinks->GetEntriesFast();}
+  Int_t GetNumberOfCaloClusters() const {return fCaloClusters->GetEntriesFast();}
+
+  Int_t GetNumberOfEMCALClusters() const {return fEMCALClusters;}
+  void  SetNumberOfEMCALClusters(Int_t clus) {fEMCALClusters = clus;}
+  Int_t GetFirstEMCALCluster() const {return fFirstEMCALCluster;}
+  void  SetFirstEMCALCluster(Int_t index) {fFirstEMCALCluster = index;}
+  TArrayF *GetEMCALTriggerPosition() const {return  fEMCALTrigger->GetTriggerPosition();}
+  TArrayF *GetEMCALTriggerAmplitudes() const {return  fEMCALTrigger->GetTriggerAmplitudes();}
+
+  Int_t GetNumberOfPHOSClusters() const {return fPHOSClusters;}
+  void  SetNumberOfPHOSClusters(Int_t part) { fPHOSClusters = part ; }
+  void  SetFirstPHOSCluster(Int_t index) { fFirstPHOSCluster = index ; } 
+  Int_t GetFirstPHOSCluster() const  { return fFirstPHOSCluster ; }
+  TArrayF *GetPHOSTriggerPosition() const {return  fPHOSTrigger->GetTriggerPosition();}
+  TArrayF *GetPHOSTriggerAmplitudes() const {return  fPHOSTrigger->GetTriggerAmplitudes();}
+
+  void ResetV0s() { fV0s->Clear(); }
+  void ResetCascades() { fCascades->Clear(); }
+  void Reset();
+
+  void  Print(Option_t *option="") const;
+
+  void AddObject(TObject* obj);
+  void ReadFromTree(TTree *tree);
+  AliESD *GetAliESDOld(){return fESDOld;}
+  const void WriteToTree(TTree* tree) const {tree->Branch(fESDObjects);}
+  void GetStdContent();
+  void ResetStdContent();
+  void CreateStdContent();
+  void SetStdNames();
+  void CopyFromOldESD();
+  TList* GetList(){return fESDObjects;}
+
+protected:
+  AliESDEvent(const AliESDEvent&);
+  AliESDEvent &operator=(const AliESDEvent& source);
+
+
+  TList *fESDObjects;             // List of esd Objects
+
+  AliESDRun       *fESDRun;           //! Run information tmp put in the Userdata
+  AliESDHeader    *fHeader;           //! ESD Event Header
+  AliESDZDC       *fESDZDC;           //! ZDC information
+  AliESDFMD       *fESDFMD;           //! FMD object containing rough multiplicity
+  AliESDVZERO     *fESDVZERO;         //! VZERO object containing rough multiplicity
+  AliESDTZERO     *fESDTZERO;         //! TZEROObject
+  AliESDVertex    *fSPDVertex;        //! Primary vertex estimated by the SPD
+  AliESDVertex    *fPrimaryVertex;    //! Primary vertex estimated using ESD tracks
+  AliMultiplicity *fSPDMult;          //! SPD tracklet multiplicity
+  AliESDCaloTrigger* fPHOSTrigger;     //! PHOS Trigger information
+  AliESDCaloTrigger* fEMCALTrigger;    //! PHOS Trigger information
+
+  TClonesArray *fTracks;           //! ESD tracks 
+  TClonesArray *fMuonTracks;       //! MUON ESD tracks
+  TClonesArray *fPmdTracks;        //! PMD ESD tracks
+  TClonesArray *fTrdTracks;        //! TRD ESD tracks (triggered)
+  TClonesArray *fV0s;              //! V0 vertices
+  TClonesArray *fCascades;         //! Cascade vertices
+  TClonesArray *fKinks;            //! Kinks
+  TClonesArray *fCaloClusters;     //! Calorimeter clusters for PHOS/EMCAL
+  TClonesArray *fErrorLogs;        //! Raw-data reading error messages
+
+
+  AliESD    *fESDOld;              //! Old esd Structure
+
+
+  // Remove this stuff CKB
+  Int_t        fEMCALClusters;   // Number of EMCAL clusters (subset of caloclusters)
+  Int_t        fFirstEMCALCluster; // First EMCAL cluster in the fCaloClusters list 
+
+  Int_t        fPHOSClusters;     // Number of PHOS clusters (subset of caloclusters)
+  Int_t        fFirstPHOSCluster; // First PHOS cluster in the fCaloClusters list 
+
+  ClassDef(AliESDEvent,1)  //ESDEvent class 
+};
+#endif 
+
index 693116d..8a3daa9 100644 (file)
 //-----------------------------------------------------------------
 
 #include "AliESDpid.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
 #include "AliESDtrack.h"
 
 ClassImp(AliESDpid)
 
 //_________________________________________________________________________
-Int_t AliESDpid::MakePID(AliESD *event)
+Int_t AliESDpid::MakePID(AliESDEvent *event)
 {
   //
   // Combine the information of various detectors
index 4ce5040..375bb24 100644 (file)
 //-------------------------------------------------------
 #include <Rtypes.h>
 
-class AliESD;
+class AliESDEvent;
 
 class AliESDpid {
 public:
   AliESDpid(){}
   virtual ~AliESDpid() {}
-  static Int_t MakePID(AliESD *event);
+  static Int_t MakePID(AliESDEvent *event);
 private:
-  ClassDef(AliESDpid,1)   // TPC PID class
+  ClassDef(AliESDpid,2)   // TPC PID class
 };
 
 #endif
index 2c976ca..95cc72d 100644 (file)
 #include "AliRawReaderDate.h"
 #include "AliRawReaderRoot.h"
 #include "AliRawEventHeaderBase.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
 #include "AliESDfriend.h"
 #include "AliESDVertex.h"
 #include "AliMultiplicity.h"
@@ -559,7 +559,7 @@ Bool_t AliReconstruction::Run(const char* input)
   }
 
   // get the possibly already existing ESD file and tree
-  AliESD* esd = new AliESD(); AliESD* hltesd = new AliESD();
+  AliESDEvent* esd = new AliESDEvent(); AliESDEvent* hltesd = new AliESDEvent();
   TFile* fileOld = NULL;
   TTree* treeOld = NULL; TTree *hlttreeOld = NULL;
   if (!gSystem->AccessPathName("AliESDs.root")){
@@ -582,12 +582,12 @@ Bool_t AliReconstruction::Run(const char* input)
   }
 
   TTree* tree = new TTree("esdTree", "Tree with ESD objects");
-  esd = new AliESD();
+  esd = new AliESDEvent();
   esd->CreateStdContent();
   esd->WriteToTree(tree);
 
   TTree* hlttree = new TTree("HLTesdTree", "Tree with HLT ESD objects");
-  hltesd = new AliESD();
+  hltesd = new AliESDEvent();
   hltesd->CreateStdContent();
   hltesd->WriteToTree(hlttree);
 
@@ -936,7 +936,7 @@ Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors)
 }
 
 //_____________________________________________________________________________
-Bool_t AliReconstruction::RunVertexFinder(AliESD*& esd)
+Bool_t AliReconstruction::RunVertexFinder(AliESDEvent*& esd)
 {
 // run the barrel tracking
 
@@ -992,7 +992,7 @@ Bool_t AliReconstruction::RunVertexFinder(AliESD*& esd)
 }
 
 //_____________________________________________________________________________
-Bool_t AliReconstruction::RunHLTTracking(AliESD*& esd)
+Bool_t AliReconstruction::RunHLTTracking(AliESDEvent*& esd)
 {
 // run the HLT barrel tracking
 
@@ -1048,7 +1048,7 @@ Bool_t AliReconstruction::RunHLTTracking(AliESD*& esd)
 }
 
 //_____________________________________________________________________________
-Bool_t AliReconstruction::RunMuonTracking(AliESD*& esd)
+Bool_t AliReconstruction::RunMuonTracking(AliESDEvent*& esd)
 {
 // run the muon spectrometer tracking
 
@@ -1108,7 +1108,7 @@ Bool_t AliReconstruction::RunMuonTracking(AliESD*& esd)
 
 
 //_____________________________________________________________________________
-Bool_t AliReconstruction::RunTracking(AliESD*& esd)
+Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd)
 {
 // run the barrel tracking
 
@@ -1232,7 +1232,7 @@ Bool_t AliReconstruction::RunTracking(AliESD*& esd)
 }
 
 //_____________________________________________________________________________
-Bool_t AliReconstruction::FillESD(AliESD*& esd, const TString& detectors)
+Bool_t AliReconstruction::FillESD(AliESDEvent*& esd, const TString& detectors)
 {
 // fill the event summary data
 
@@ -1295,7 +1295,7 @@ Bool_t AliReconstruction::FillESD(AliESD*& esd, const TString& detectors)
 }
 
 //_____________________________________________________________________________
-Bool_t AliReconstruction::FillTriggerESD(AliESD*& esd)
+Bool_t AliReconstruction::FillTriggerESD(AliESDEvent*& esd)
 {
   // Reads the trigger decision which is
   // stored in Trigger.root file and fills
@@ -1341,7 +1341,7 @@ Bool_t AliReconstruction::FillTriggerESD(AliESD*& esd)
 
 
 //_____________________________________________________________________________
-Bool_t AliReconstruction::FillRawEventHeaderESD(AliESD*& esd)
+Bool_t AliReconstruction::FillRawEventHeaderESD(AliESDEvent*& esd)
 {
   // 
   // Filling information from RawReader Header
@@ -1655,7 +1655,8 @@ void AliReconstruction::CleanUp(TFile* file, TFile* fileOld)
 
 
 //_____________________________________________________________________________
-Bool_t AliReconstruction::ReadESD(AliESD*& esd, const char* recStep) const
+
+Bool_t AliReconstruction::ReadESD(AliESDEvent*& esd, const char* recStep) const
 {
 // read the ESD event from a file
 
@@ -1676,14 +1677,17 @@ Bool_t AliReconstruction::ReadESD(AliESD*& esd, const char* recStep) const
 
   gROOT->cd();
   delete esd;
-  esd = (AliESD*) file->Get("ESD");
+  esd = (AliESDEvent*) file->Get("ESD");
   file->Close();
   delete file;
   return kTRUE;
+
 }
 
+
+
 //_____________________________________________________________________________
-void AliReconstruction::WriteESD(AliESD* esd, const char* recStep) const
+void AliReconstruction::WriteESD(AliESDEvent* esd, const char* recStep) const
 {
 // write the ESD event to a file
 
@@ -1763,7 +1767,7 @@ void AliReconstruction::CreateTag(TFile* file)
   }  
   Int_t lastEvent = 0;
   TTree *b = (TTree*) file->Get("esdTree");
-  AliESD *esd = new AliESD();
+  AliESDEvent *esd = new AliESDEvent();
   esd->ReadFromTree(b);
 
   b->GetEntry(fFirstEvent);
@@ -2017,7 +2021,7 @@ void AliReconstruction::ESDFile2AODFile(TFile* esdFile, TFile* aodFile)
 
   // connect to ESD
   TTree *t = (TTree*) esdFile->Get("esdTree");
-  AliESD *esd = new AliESD();
+  AliESDEvent *esd = new AliESDEvent();
   esd->ReadFromTree(t);
 
   Int_t nEvents = t->GetEntries();
@@ -2683,7 +2687,7 @@ void AliReconstruction::ESDFile2AODFile(TFile* esdFile, TFile* aodFile)
   return;
 }
 
-void AliReconstruction::WriteAlignmentData(AliESD* esd)
+void AliReconstruction::WriteAlignmentData(AliESDEvent* esd)
 {
   // Write space-points which are then used in the alignment procedures
   // For the moment only ITS, TRD and TPC
@@ -2736,7 +2740,7 @@ void AliReconstruction::WriteAlignmentData(AliESD* esd)
 }
 
 //_____________________________________________________________________________
-void AliReconstruction::FillRawDataErrorLog(Int_t iEvent, AliESD* esd)
+void AliReconstruction::FillRawDataErrorLog(Int_t iEvent, AliESDEvent* esd)
 {
   // The method reads the raw-data error log
   // accumulated within the rawReader.
index 27832c0..fe2988f 100644 (file)
@@ -28,7 +28,7 @@ class AliLoader;
 class AliTracker;
 class AliVertexer;
 class AliESDVertex;
-class AliESD;
+class AliESDEvent;
 class TFile;
 class TTree;
 
@@ -105,13 +105,13 @@ public:
 private:
   Bool_t         RunLocalReconstruction(const TString& detectors);
   Bool_t         RunLocalEventReconstruction(const TString& detectors);
-  Bool_t         RunVertexFinder(AliESD*& esd);
-  Bool_t         RunHLTTracking(AliESD*& esd);
-  Bool_t         RunMuonTracking(AliESD*& esd);
-  Bool_t         RunTracking(AliESD*& esd);
-  Bool_t         FillESD(AliESD*& esd, const TString& detectors);
-  Bool_t         FillTriggerESD(AliESD*& esd);
-  Bool_t         FillRawEventHeaderESD(AliESD*& esd);
+  Bool_t         RunVertexFinder(AliESDEvent*& esd);
+  Bool_t         RunHLTTracking(AliESDEvent*& esd);
+  Bool_t         RunMuonTracking(AliESDEvent*& esd);
+  Bool_t         RunTracking(AliESDEvent*& esd);
+  Bool_t         FillESD(AliESDEvent*& esd, const TString& detectors);
+  Bool_t         FillTriggerESD(AliESDEvent*& esd);
+  Bool_t         FillRawEventHeaderESD(AliESDEvent*& esd);
 
   Bool_t         IsSelected(TString detName, TString& detectors) const;
   Bool_t         InitRunLoader();
@@ -120,8 +120,8 @@ private:
   Bool_t         CreateTrackers(const TString& detectors);
   void           CleanUp(TFile* file = NULL, TFile* fileOld = NULL);
 
-  Bool_t         ReadESD(AliESD*& esd, const char* recStep) const;
-  void           WriteESD(AliESD* esd, const char* recStep) const;
+  Bool_t         ReadESD(AliESDEvent*& esd, const char* recStep) const;
+  void           WriteESD(AliESDEvent* esd, const char* recStep) const;
 
  
   //===========================================//
@@ -129,9 +129,9 @@ private:
   //==========================================//
   void           ESDFile2AODFile(TFile* esdFile, TFile* aodFile);
 
-  void           WriteAlignmentData(AliESD* esd);
+  void           WriteAlignmentData(AliESDEvent* esd);
 
-  void           FillRawDataErrorLog(Int_t iEvent, AliESD* esd);
+  void           FillRawDataErrorLog(Int_t iEvent, AliESDEvent* esd);
 
   //*** Global reconstruction flags *******************
   Bool_t         fUniformField;       // uniform field tracking flag
@@ -176,7 +176,7 @@ private:
   TString       fCDBUri;             // Uri of the default CDB storage
   TObjArray      fSpecCDBUri;         // Array with detector specific CDB storages
 
-  ClassDef(AliReconstruction, 10)      // class for running the reconstruction
+  ClassDef(AliReconstruction, 11)      // class for running the reconstruction
 };
 
 #endif
index 5f8fbfb..3aa7c68 100644 (file)
@@ -90,7 +90,7 @@ void AliReconstructor::Reconstruct(AliRunLoader* /*runLoader*/,
 
 //_____________________________________________________________________________
 void AliReconstructor::FillESD(TTree* /*digitsTree*/, TTree* /*clustersTree*/,
-                              AliESD* /*esd*/) const
+                              AliESDEvent* /*esd*/) const
 {
 // fill the ESD.
 // by default nothing is done
@@ -99,7 +99,7 @@ void AliReconstructor::FillESD(TTree* /*digitsTree*/, TTree* /*clustersTree*/,
 
 //_____________________________________________________________________________
 void AliReconstructor::FillESD(AliRawReader* /*rawReader*/, 
-                              TTree* clustersTree, AliESD* esd) const
+                              TTree* clustersTree, AliESDEvent* esd) const
 {
 // fill the ESD in case of raw data input.
 // by default the FillESD method for MC is called
@@ -109,7 +109,7 @@ void AliReconstructor::FillESD(AliRawReader* /*rawReader*/,
 
 //_____________________________________________________________________________
 void AliReconstructor::FillESD(AliRunLoader* /*runLoader*/, 
-                              AliESD* /*esd*/) const
+                              AliESDEvent* /*esd*/) const
 {
 // fill the ESD.
 // by default nothing is done
@@ -118,7 +118,7 @@ void AliReconstructor::FillESD(AliRunLoader* /*runLoader*/,
 
 //_____________________________________________________________________________
 void AliReconstructor::FillESD(AliRunLoader* runLoader, 
-                              AliRawReader* /*rawReader*/, AliESD* esd) const
+                              AliRawReader* /*rawReader*/, AliESDEvent* esd) const
 {
 // fill the ESD in case of raw data input.
 // by default the FillESD method for MC is called
index f378094..7d62e5e 100644 (file)
@@ -19,7 +19,7 @@ class AliRunLoader;
 class AliRawReader;
 class AliVertexer;
 class AliTracker;
-class AliESD;
+class AliESDEvent;
 
 
 class AliReconstructor: public TObject {
@@ -45,12 +45,12 @@ public:
     {return NULL;}
 
   virtual void         FillESD(TTree* digitsTree, TTree* clustersTree, 
-                              AliESD* esd) const;
+                              AliESDEvent* esd) const;
   virtual void         FillESD(AliRawReader* rawReader, TTree* clustersTree, 
-                              AliESD* esd) const;
-  virtual void         FillESD(AliRunLoader* runLoader, AliESD* esd) const;
+                              AliESDEvent* esd) const;
+  virtual void         FillESD(AliRunLoader* runLoader, AliESDEvent* esd) const;
   virtual void         FillESD(AliRunLoader* runLoader, 
-                              AliRawReader* rawReader, AliESD* esd) const;
+                              AliRawReader* rawReader, AliESDEvent* esd) const;
 
   virtual const char*  GetDetectorName() const;
 
index 0b5fbdf..654d4e1 100644 (file)
@@ -16,16 +16,16 @@ class AliMagF;
 class AliCluster;
 class TTree;
 class AliKalmanTrack;
-class AliESD;
+class AliESDEvent;
 class AliTrackPoint;
 
 class AliTracker : public TObject {
 public:
   AliTracker();
   virtual ~AliTracker(){}
-  virtual Int_t Clusters2Tracks(AliESD *event)=0;
-  virtual Int_t PropagateBack(AliESD *event)=0;
-  virtual Int_t RefitInward(AliESD *event)=0;
+  virtual Int_t Clusters2Tracks(AliESDEvent *event)=0;
+  virtual Int_t PropagateBack(AliESDEvent *event)=0;
+  virtual Int_t RefitInward(AliESDEvent *event)=0;
   void SetVertex(const Double_t *xyz, const Double_t *ers=0) { 
      fX=xyz[0]; fY=xyz[1]; fZ=xyz[2];
      if (ers) { fSigmaX=ers[0]; fSigmaY=ers[1]; fSigmaZ=ers[2]; } 
index 06d657a..451e5fb 100644 (file)
@@ -24,7 +24,7 @@
 #include <TObjArray.h>
 #include <TTree.h>
 
-#include "AliESD.h"
+#include "AliESDEvent.h"
 #include "AliESDv0.h"
 #include "AliESDtrack.h"
 #include "AliV0vertexer.h"
@@ -41,7 +41,7 @@ Double_t AliV0vertexer::fgCPAmax=0.99; //max cosine of V0's pointing angle
 Double_t AliV0vertexer::fgRmin=0.2;    //min radius of the fiducial volume
 Double_t AliV0vertexer::fgRmax=100.;   //max radius of the fiducial volume
 
-Int_t AliV0vertexer::Tracks2V0vertices(AliESD *event) {
+Int_t AliV0vertexer::Tracks2V0vertices(AliESDEvent *event) {
   //--------------------------------------------------------------------
   //This function reconstructs V0 vertices
   //--------------------------------------------------------------------
index 280e2a5..2366b7e 100644 (file)
@@ -12,7 +12,7 @@
 #include "TObject.h"
 
 class TTree;
-class AliESD;
+class AliESDEvent;
 
 //_____________________________________________________________________________
 class AliV0vertexer : public TObject {
@@ -21,7 +21,7 @@ public:
   void SetCuts(const Double_t cuts[7]);
   static void SetDefaultCuts(const Double_t cuts[7]);
 
-  Int_t Tracks2V0vertices(AliESD *event);
+  Int_t Tracks2V0vertices(AliESDEvent *event);
 
   void GetCuts(Double_t cuts[7]) const;
   static void GetDefaultCuts(Double_t cuts[7]);
index bb4a8c9..bccf450 100644 (file)
@@ -31,7 +31,7 @@
 //---- AliRoot headers -----
 #include "AliStrLine.h"
 #include "AliVertexerTracks.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
 #include "AliESDtrack.h"
 
 ClassImp(AliVertexerTracks)
@@ -112,7 +112,7 @@ AliVertexerTracks::~AliVertexerTracks()
   if(fTrksToSkip) { delete [] fTrksToSkip; fTrksToSkip=NULL; }
 }
 //----------------------------------------------------------------------------
-AliESDVertex* AliVertexerTracks::FindPrimaryVertex(const AliESD *esdEvent)
+AliESDVertex* AliVertexerTracks::FindPrimaryVertex(const AliESDEvent *esdEvent)
 {
 //
 // Primary vertex for current ESD event
@@ -944,7 +944,7 @@ Bool_t AliVertexerTracks::TrackToPoint(AliESDtrack *t,
   return kTRUE;
 } 
 //---------------------------------------------------------------------------
-void AliVertexerTracks::TooFewTracks(const AliESD* esdEvent) 
+void AliVertexerTracks::TooFewTracks(const AliESDEvent* esdEvent) 
 {
 //
 // When the number of tracks is < fMinTracks
index 72d91d2..2f6130f 100644 (file)
@@ -29,7 +29,7 @@
 #include <TMatrixD.h>
 
 class TTree; 
-class AliESD;
+class AliESDEvent;
 
 class AliVertexerTracks : public TObject {
   
@@ -38,7 +38,7 @@ class AliVertexerTracks : public TObject {
   AliVertexerTracks(Double_t fieldkG); 
   virtual ~AliVertexerTracks();
 
-  AliESDVertex* FindPrimaryVertex(const AliESD *esdEvent);
+  AliESDVertex* FindPrimaryVertex(const AliESDEvent *esdEvent);
   AliESDVertex* VertexForSelectedTracks(TTree *trkTree,Bool_t optUseFitter=kTRUE, Bool_t optPropagate=kTRUE);
   AliESDVertex* VertexForSelectedTracks(TObjArray *trkArray, Bool_t optUseFitter=kTRUE, Bool_t optPropagate=kTRUE);
   AliESDVertex* RemoveTracksFromVertex(AliESDVertex *inVtx,TTree *trksTree,Float_t *diamondxy); 
@@ -87,7 +87,7 @@ class AliVertexerTracks : public TObject {
   void     VertexFinder(Int_t optUseWeights=0);
   void     VertexFitter(Bool_t useConstraint=kFALSE);
   void     StrLinVertexFinderMinDist(Int_t optUseWeights=0);
-  void     TooFewTracks(const AliESD *esdEvent);
+  void     TooFewTracks(const AliESDEvent *esdEvent);
 
   AliESDVertex fVert;         // vertex after vertex finder
   AliESDVertex *fCurrentVertex;  // ESD vertex after fitter
index 9d823e3..6ea0c9f 100644 (file)
@@ -12,7 +12,7 @@
 
 #include "AliRunLoader.h"
 #include "AliLoader.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
 #include "AliRun.h"
 #include "AliStack.h"
 #include "AliHeader.h"
@@ -158,7 +158,7 @@ Bool_t CheckESD(const char* gAliceFileName = "galice.root",
     Error("CheckESD", "opening ESD file %s failed", esdFileName);
     return kFALSE;
   }
-  AliESD* esd = new AliESD;
+  AliESDEvent * esd = new AliESDEvent;
   TTree* tree = (TTree*) esdFile->Get("esdTree");
   if (!tree) {
     Error("CheckESD", "no ESD tree found");
@@ -166,7 +166,7 @@ Bool_t CheckESD(const char* gAliceFileName = "galice.root",
   }
   esd->ReadFromTree(tree);
 
-  // efficienc and resolution histograms
+  // efficiency and resolution histograms
   Int_t nBinsPt = 15;
   Float_t minPt = 0.1;
   Float_t maxPt = 3.1;
index bcbf9d5..1ca6f5a 100644 (file)
@@ -9,9 +9,11 @@
 #pragma link off all functions;
  
 #pragma link C++ enum   AliLog::EType_t;
-#pragma link C++ enum   AliESD::ESDListIndex_t;
+#pragma link C++ enum   AliESDEvent::ESDListIndex_t;
+
 
 #pragma link C++ class  AliESD+;
+#pragma link C++ class  AliESDEvent+;
 #pragma link C++ class  AliESDRun+;
 #pragma link C++ class  AliESDHeader+;
 #pragma link C++ class  AliESDZDC+;
index 45da58e..53b1564 100644 (file)
@@ -1,4 +1,4 @@
-SRCS = AliESD.cxx AliESDfriend.cxx\
+SRCS = AliESDEvent.cxx AliESDfriend.cxx AliESD.cxx \
        AliESDtrack.cxx AliESDfriendTrack.cxx\
        AliESDMuonTrack.cxx AliESDPmdTrack.cxx AliESDTrdTrack.cxx AliESDHLTtrack.cxx \
        AliESDv0.cxx AliESDcascade.cxx AliVertex.cxx AliESDVertex.cxx \
index 0fb1afa..b9403ee 100644 (file)
@@ -47,7 +47,6 @@
 #include <TRandom.h>
 #include <TTUBE.h>
 #include <TVirtualMC.h>
-#include <AliESD.h>
 
 #include "AliLog.h"
 #include "AliMC.h"
index 667f4a4..c49e32c 100644 (file)
@@ -20,7 +20,7 @@
 #include <TDirectory.h>
 
 #include "AliRunLoader.h"
-#include <AliESD.h>
+#include <AliESDEvent.h>
 #include "AliLog.h"
 #include "AliT0Loader.h"
 #include "AliT0RecPoint.h"
@@ -327,7 +327,7 @@ void AliT0Reconstructor::Reconstruct(AliRawReader* rawReader, TTree*recTree) con
 }
 //____________________________________________________________
 
-void AliT0Reconstructor::FillESD(AliRunLoader* runLoader, AliESD *pESD) const
+void AliT0Reconstructor::FillESD(AliRunLoader* runLoader, AliESDEvent *pESD) const
 {
 
   /***************************************************
index 40dc3b1..a26a2a0 100644 (file)
@@ -27,10 +27,10 @@ class AliT0Reconstructor: public AliReconstructor {
   virtual  void   Reconstruct(AliRawReader*rawReader , TTree* recTree) const;
   virtual  void   Reconstruct(AliRunLoader* ) const  {};
   
-  virtual void         FillESD(AliRunLoader* runLoader, AliESD* esd) const;
-  virtual void         FillESD(AliRunLoader* , AliRawReader*, AliESD* ) const  {};
-  virtual void         FillESD(  AliRawReader*,  TTree*, AliESD* ) const  {};
-  virtual void         FillESD( TTree*,  TTree*, AliESD* ) const  {};
+  virtual void         FillESD(AliRunLoader* runLoader, AliESDEvent* esd) const;
+  virtual void         FillESD(AliRunLoader* , AliRawReader*, AliESDEvent* ) const  {};
+  virtual void         FillESD(  AliRawReader*,  TTree*, AliESDEvent* ) const  {};
+  virtual void         FillESD( TTree*,  TTree*, AliESDEvent* ) const  {};
   virtual Bool_t       HasLocalReconstruction() const {return kTRUE;}
   virtual Bool_t       HasDigitConversion() const {return kFALSE;}
  public:
index 4e09480..70bad52 100644 (file)
@@ -37,7 +37,7 @@
 
 class TTree;
 
-class AliESD;
+class AliESDEvent;
 
 extern TDirectory *gDirectory;
 extern TFile *gFile;
@@ -172,7 +172,7 @@ AliTracker* AliTOFReconstructor::CreateTracker(AliRunLoader* /*runLoader*/) cons
 
 //_____________________________________________________________________________
 void AliTOFReconstructor::FillESD(AliRunLoader* /*runLoader*/, 
-                                 AliESD* /*esd*/) const
+                                 AliESDEvent* /*esd*/) const
 {
 // nothing to be done
 
index 11928e4..b191bb2 100644 (file)
@@ -16,7 +16,7 @@
 
 class TTree;
 
-class AliESD;
+class AliESDEvent;
 class AliRawReader;
 class AliRunLoader;
 
@@ -39,10 +39,10 @@ public:
   virtual void         Reconstruct(TTree* digitsTree, TTree* clusterTree) const;
   virtual void         ConvertDigits(AliRawReader* reader, TTree* digitsTree) const;
   virtual AliTracker*  CreateTracker(AliRunLoader* runLoader) const;
-  virtual void         FillESD(AliRunLoader*, AliRawReader*, AliESD*) const { };
-  virtual void         FillESD(AliRawReader*, TTree*, AliESD*) const { };
-  virtual void         FillESD(TTree*, TTree*, AliESD*) const { };
-  virtual void         FillESD(AliRunLoader* runLoader, AliESD* esd) const;
+  virtual void         FillESD(AliRunLoader*, AliRawReader*, AliESDEvent*) const { };
+  virtual void         FillESD(AliRawReader*, TTree*, AliESDEvent*) const { };
+  virtual void         FillESD(TTree*, TTree*, AliESDEvent*) const { };
+  virtual void         FillESD(AliRunLoader* runLoader, AliESDEvent* esd) const;
 
 private:
   AliTOFGeometry *fTOFGeometry; // pointer to TOF geometry
index 48265fe..61acc8f 100644 (file)
@@ -24,7 +24,7 @@
 #include "AliLog.h"
 
 #include "AliESDtrack.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
 
 #include "AliTOFpidESD.h"
 
@@ -54,7 +54,7 @@ AliTOFpidESD::AliTOFpidESD(Double_t *param):
 }
 
 //_________________________________________________________________________
-Int_t AliTOFpidESD::MakePID(AliESD *event, Double_t timeZero)
+Int_t AliTOFpidESD::MakePID(AliESDEvent *event, Double_t timeZero)
 {
   //
   //  This function calculates the "detector response" PID probabilities
@@ -100,7 +100,7 @@ Int_t AliTOFpidESD::MakePID(AliESD *event, Double_t timeZero)
 }
 
 //_________________________________________________________________________
-Int_t AliTOFpidESD::MakePID(AliESD *event)
+Int_t AliTOFpidESD::MakePID(AliESDEvent *event)
 {
   //
   //  This function calculates the "detector response" PID probabilities
index 0333547..281b365 100644 (file)
@@ -11,7 +11,7 @@
 
 #include "TObject.h"
 
-class AliESD;
+class AliESDEvent;
 
 class AliTOFGeometry;
 
@@ -22,8 +22,8 @@ public:
  AliTOFpidESD(Double_t *param);
  ~AliTOFpidESD(){}
 
-  Int_t MakePID(AliESD *event);
-  Int_t MakePID(AliESD *event, Double_t timeZero);
+  Int_t MakePID(AliESDEvent *event);
+  Int_t MakePID(AliESDEvent *event, Double_t timeZero);
   void  SetEventNumber(Int_t n) {fEventN=n;}
   Int_t GetEventNumber() const {return fEventN;}
 
index a89240b..e6ee92c 100644 (file)
@@ -37,7 +37,7 @@
 
 #include "AliAlignObj.h"
 #include "AliESDtrack.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
 #include "AliLog.h"
 #include "AliTrackPointArray.h"
 
@@ -194,7 +194,7 @@ AliTOFtracker::~AliTOFtracker() {
   delete fCalTree;
 }
 //_____________________________________________________________________________
-Int_t AliTOFtracker::PropagateBack(AliESD* event) {
+Int_t AliTOFtracker::PropagateBack(AliESDEvent* event) {
   //
   // Gets seeds from ESD event and Match with TOF Clusters
   //
@@ -961,14 +961,14 @@ Float_t AliTOFtracker::CorrectTimeWalk( Float_t dist, Float_t tof) {
   return tofcorr;
 }
 //_________________________________________________________________________
-Float_t AliTOFtracker::GetTimeZerofromT0(AliESD *event) const {
+Float_t AliTOFtracker::GetTimeZerofromT0(AliESDEvent *event) const {
 
   //Returns TimeZero as measured by T0 detector
 
   return event->GetT0();
 }
 //_________________________________________________________________________
-Float_t AliTOFtracker::GetTimeZerofromTOF(AliESD * /*event*/) const {
+Float_t AliTOFtracker::GetTimeZerofromTOF(AliESDEvent * /*event*/) const {
 
   //dummy, for the moment. T0 algorithm using tracks on TOF
   {
index 82119d7..ce15729 100644 (file)
@@ -24,7 +24,7 @@
 
 class TClonesArray;
 
-class AliESD;
+class AliESDEvent;
 
 class AliTOFcluster;
 class AliTOFRecoParam;
@@ -43,9 +43,9 @@ public:
  AliTOFtracker& operator=(const AliTOFtracker &source); // ass. op.
 
  virtual ~AliTOFtracker();
-  virtual Int_t Clusters2Tracks(AliESD* /*event*/) {return -1;};
-  virtual Int_t PropagateBack(AliESD* event);
-  virtual Int_t RefitInward(AliESD* /*event*/) {return -1;};
+  virtual Int_t Clusters2Tracks(AliESDEvent* /*event*/) {return -1;};
+  virtual Int_t PropagateBack(AliESDEvent* event);
+  virtual Int_t RefitInward(AliESDEvent* /*event*/) {return -1;};
   virtual Int_t LoadClusters(TTree * cTree); // Load Clusters
   virtual void  UnloadClusters();// UnLoad Clusters
   virtual AliCluster *GetCluster(Int_t /*index*/) const {return NULL;};
@@ -58,8 +58,8 @@ private:
   Int_t FindClusterIndex(Double_t z) const; // Returns cluster index 
   void  MatchTracks(Bool_t mLastStep); // Matching Algorithm 
   void  CollectESD(); // Select starting Set for Matching 
-  Float_t  GetTimeZerofromTOF(AliESD* /*event*/) const; // T0 from TOF
-  Float_t  GetTimeZerofromT0(AliESD* event) const; // T0 from T0
+  Float_t  GetTimeZerofromTOF(AliESDEvent* /*event*/) const; // T0 from TOF
+  Float_t  GetTimeZerofromT0(AliESDEvent* event) const; // T0 from T0
   Float_t  CorrectTimeWalk(Float_t dist,Float_t tof); // Time Walk correction
 
   AliTOFRecoParam* fRecoParam;           // Pointer to TOF Recon. Pars
index cb90005..e7856cb 100644 (file)
@@ -29,7 +29,7 @@
 #include "TTreeStream.h"
 
 #include "AliRun.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
 #include "AliESDtrack.h"
 
 #include "AliTOFRecoParam.h"
@@ -164,7 +164,7 @@ AliTOFtrackerMI::~AliTOFtrackerMI(){
 }
 
 //_____________________________________________________________________________
-Int_t AliTOFtrackerMI::PropagateBack(AliESD* event) {
+Int_t AliTOFtrackerMI::PropagateBack(AliESDEvent* event) {
   //
   // Gets seeds from ESD event and Match with TOF Clusters
   //
index 87fc7b8..4261088 100644 (file)
@@ -21,7 +21,7 @@
 class TTreeSRedirector;
 class TClonesArray;
 
-class AliESD;
+class AliESDEvent;
 
 class AliTOFcluster;
 class AliTOFRecoParam;
@@ -40,9 +40,9 @@ public:
 
  //  virtual ~AliTOFtrackerMI() {delete fTOFpid;}
  virtual ~AliTOFtrackerMI();
- virtual Int_t Clusters2Tracks(AliESD* /*event*/) {return -1;};
- virtual Int_t PropagateBack(AliESD* event);
- virtual Int_t RefitInward(AliESD* /*event*/) {return -1;};
+ virtual Int_t Clusters2Tracks(AliESDEvent* /*event*/) {return -1;};
+ virtual Int_t PropagateBack(AliESDEvent* event);
+ virtual Int_t RefitInward(AliESDEvent* /*event*/) {return -1;};
  virtual Int_t LoadClusters(TTree *dTree); // Loading Clusters from Digits
  virtual void  UnloadClusters();// UnLoad Clusters
  virtual AliCluster *GetCluster(Int_t /*index*/) const {return NULL;};
index 5e6048d..c59d414 100644 (file)
@@ -180,7 +180,7 @@ AliTracker* AliTPCReconstructor::CreateTracker(AliRunLoader* /* runLoader */) co
 
 //_____________________________________________________________________________
 void AliTPCReconstructor::FillESD(AliRunLoader* /*runLoader*/, 
-                                 AliESD* esd) const
+                                 AliESDEvent* esd) const
 {
 // make PID
 
index 21c1adc..c69c428 100644 (file)
@@ -24,17 +24,17 @@ public:
   virtual void         Reconstruct(AliRawReader* rawReader, TTree* clustersTree) const;
 
   virtual AliTracker*  CreateTracker(AliRunLoader* runLoader) const;
-  virtual void         FillESD(AliRunLoader* runLoader, AliESD* esd) const;
+  virtual void         FillESD(AliRunLoader* runLoader, AliESDEvent* esd) const;
   virtual void         FillESD(TTree* digitsTree, TTree* clustersTree, 
-                              AliESD* esd) const {
+                              AliESDEvent* esd) const {
     AliReconstructor::FillESD(digitsTree,clustersTree,esd);
   }
   virtual void         FillESD(AliRawReader* rawReader, TTree* clustersTree, 
-                              AliESD* esd) const {
+                              AliESDEvent* esd) const {
     AliReconstructor::FillESD(rawReader,clustersTree,esd);
   }
   virtual void         FillESD(AliRunLoader* runLoader, 
-                              AliRawReader* rawReader, AliESD* esd) const {
+                              AliRawReader* rawReader, AliESDEvent* esd) const {
     AliReconstructor::FillESD(runLoader,rawReader,esd);
   }
 
index 460278f..2909499 100644 (file)
@@ -20,7 +20,7 @@
 //-----------------------------------------------------------------
 
 #include "AliTPCpidESD.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
 #include "AliESDtrack.h"
 
 ClassImp(AliTPCpidESD)
@@ -53,7 +53,7 @@ Double_t AliTPCpidESD::Bethe(Double_t bg) {
 }
 
 //_________________________________________________________________________
-Int_t AliTPCpidESD::MakePID(AliESD *event)
+Int_t AliTPCpidESD::MakePID(AliESDEvent *event)
 {
   //
   //  This function calculates the "detector response" PID probabilities 
index 0e74ad2..593e158 100644 (file)
 //-------------------------------------------------------
 #include <Rtypes.h>
 
-class AliESD;
+class AliESDEvent;
 
 class AliTPCpidESD {
 public:
   AliTPCpidESD():fMIP(0.),fRes(0.),fRange(0.){}
   AliTPCpidESD(Double_t *param);
   virtual ~AliTPCpidESD() {}
-  Int_t MakePID(AliESD *event);
+  Int_t MakePID(AliESDEvent *event);
   static Double_t Bethe(Double_t bg);
 private:
   Double_t fMIP;          // dEdx for MIP
index b8d0e23..7011119 100644 (file)
@@ -25,7 +25,7 @@
 #include <TFile.h>
 #include <TTree.h>
 
-#include "AliESD.h"
+#include "AliESDEvent.h"
 
 #include "AliTPCtracker.h"
 #include "AliTPCcluster.h"
@@ -569,7 +569,7 @@ Int_t AliTPCtracker::ReadSeeds(const TFile *inp) {
 }
 
 //_____________________________________________________________________________
-Int_t AliTPCtracker::Clusters2Tracks(AliESD *event) {
+Int_t AliTPCtracker::Clusters2Tracks(AliESDEvent *event) {
   //-----------------------------------------------------------------
   // This is a track finder.
   // The clusters must be already loaded ! 
@@ -635,7 +635,7 @@ Int_t AliTPCtracker::Clusters2Tracks(AliESD *event) {
 }
 
 //_____________________________________________________________________________
-Int_t AliTPCtracker::RefitInward(AliESD* event) {
+Int_t AliTPCtracker::RefitInward(AliESDEvent* event) {
   //
   // The function propagates tracks throught TPC inward
   // using already associated clusters.
@@ -688,7 +688,7 @@ Int_t AliTPCtracker::RefitInward(AliESD* event) {
   return 0;
 }
 
-Int_t AliTPCtracker::PropagateBack(AliESD *event) {
+Int_t AliTPCtracker::PropagateBack(AliESDEvent *event) {
   //-----------------------------------------------------------------
   // This function propagates tracks back through the TPC.
   // The clusters must be already loaded !
index cd1bdaa..803add0 100644 (file)
@@ -21,7 +21,7 @@ class TBranch;
 class AliTPCParam;
 class TObjArray;
 class TClonesArray;
-class AliESD;
+class AliESDEvent;
 
 class AliTPCtracker : public AliTracker {
 public:
@@ -35,9 +35,9 @@ public:
    void UnloadClusters();
 
    AliCluster *GetCluster(Int_t index) const;
-   Int_t Clusters2Tracks(AliESD *event);
-   Int_t PropagateBack(AliESD *event);
-   Int_t RefitInward(AliESD *event);
+   Int_t Clusters2Tracks(AliESDEvent *event);
+   Int_t PropagateBack(AliESDEvent *event);
+   Int_t RefitInward(AliESDEvent *event);
 
    virtual void  CookLabel(AliKalmanTrack *t,Float_t wrong) const; 
 
index 78dd902..3977dce 100644 (file)
@@ -33,7 +33,7 @@
 #include "AliLog.h"
 
 #include "AliComplexCluster.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
 #include "AliKink.h"
 #include "AliV0.h"
 #include "AliHelix.h"
@@ -352,7 +352,7 @@ void AliTPCtrackerMI::SetIO()
 }
 
 
-void AliTPCtrackerMI::SetIO(TTree * input, TTree * output, AliESD * event)
+void AliTPCtrackerMI::SetIO(TTree * input, TTree * output, AliESDEvent * event)
 {
 
   // set input
@@ -2617,7 +2617,7 @@ void  AliTPCtrackerMI::StopNotActive(AliTPCseed * seed, Int_t row0, Float_t th0,
 }
 
 
-Int_t AliTPCtrackerMI::RefitInward(AliESD *event)
+Int_t AliTPCtrackerMI::RefitInward(AliESDEvent *event)
 {
   //
   // back propagation of ESD tracks
@@ -2684,7 +2684,7 @@ Int_t AliTPCtrackerMI::RefitInward(AliESD *event)
 }
 
 
-Int_t AliTPCtrackerMI::PropagateBack(AliESD *event)
+Int_t AliTPCtrackerMI::PropagateBack(AliESDEvent *event)
 {
   //
   // back propagation of ESD tracks
@@ -2747,7 +2747,7 @@ void AliTPCtrackerMI::DeleteSeeds()
   fSeeds =0;
 }
 
-void AliTPCtrackerMI::ReadSeeds(AliESD *event, Int_t direction)
+void AliTPCtrackerMI::ReadSeeds(AliESDEvent *event, Int_t direction)
 {
   //
   //read seeds from the event
@@ -4078,7 +4078,7 @@ AliTPCseed *AliTPCtrackerMI::ReSeed(AliTPCseed *track,Int_t r0, Bool_t forward)
   return seed;
 }
 
-void  AliTPCtrackerMI::FindKinks(TObjArray * array, AliESD *esd)
+void  AliTPCtrackerMI::FindKinks(TObjArray * array, AliESDEvent *esd)
 {
   //
   //  find kinks
@@ -4769,7 +4769,7 @@ void  AliTPCtrackerMI::FindKinks(TObjArray * array, AliESD *esd)
   timer.Print();
 }
 
-void  AliTPCtrackerMI::FindV0s(TObjArray * array, AliESD *esd)
+void  AliTPCtrackerMI::FindV0s(TObjArray * array, AliESDEvent *esd)
 {
   //
   //  find V0s
@@ -5492,7 +5492,7 @@ Int_t AliTPCtrackerMI::ReadSeeds(const TFile *inp) {
   return 0;
 }
 
-Int_t AliTPCtrackerMI::Clusters2Tracks (AliESD *esd)
+Int_t AliTPCtrackerMI::Clusters2Tracks (AliESDEvent *esd)
 {
   //
   if (fSeeds) DeleteSeeds();
index bc7d95e..b7d59ab 100644 (file)
@@ -24,7 +24,7 @@ class TFile;
 class AliTPCParam;
 class AliTPCseed;
 class AliTPCTrackerPoint;
-class AliESD;   
+class AliESDEvent;   
 class TTree;
 class AliESDkink;
 class TTreeSRedirector;
@@ -37,22 +37,22 @@ public:
   virtual ~AliTPCtrackerMI();
   //
   void SetIteration(Int_t iteration){fIteration = iteration;}
-  virtual Int_t Clusters2Tracks (AliESD *esd);
-  virtual Int_t RefitInward (AliESD *esd);
+  virtual Int_t Clusters2Tracks (AliESDEvent *esd);
+  virtual Int_t RefitInward (AliESDEvent *esd);
   virtual Int_t LoadClusters (TTree * tree);
   Int_t  LoadClusters();
   void   UnloadClusters();
   void   Transform(AliTPCclusterMI * cluster);
   //
   void SetIO();  //set default IO from folders
-  void SetIO(TTree * input, TTree * output, AliESD * event);
+  void SetIO(TTree * input, TTree * output, AliESDEvent * event);
   void FillESD(TObjArray* arr);
   void WriteTracks();
   void WriteTracks(TTree * tree);  
   void DeleteSeeds();
   void SetDebug(Int_t debug){ fDebug = debug;}
-  void FindKinks(TObjArray * array, AliESD * esd);
-  void FindV0s(TObjArray * array, AliESD * esd);
+  void FindKinks(TObjArray * array, AliESDEvent * esd);
+  void FindV0s(TObjArray * array, AliESDEvent * esd);
   void UpdateKinkQualityM(AliTPCseed * seed);
   void UpdateKinkQualityD(AliTPCseed * seed);
   Int_t CheckKinkPoint(AliTPCseed*seed, AliTPCseed &mother, AliTPCseed &daughter, AliESDkink &kink);
@@ -80,7 +80,7 @@ public:
    Int_t FollowToNextCluster( AliTPCseed& t, Int_t nr);
 
    Int_t PropagateBack(TObjArray * arr);
-   Int_t PropagateBack(AliESD * event);
+   Int_t PropagateBack(AliESDEvent * event);
    Int_t PropagateBack(AliTPCseed *pt, Int_t row0, Int_t row1);   
    Int_t PropagateForward();
    Int_t PropagateForward2(TObjArray * arr);
@@ -227,7 +227,7 @@ private:
    Float_t  GetSigmaZ(AliTPCseed * seed);
    void GetShape(AliTPCseed * seed, Int_t row);
  
-   void ReadSeeds(AliESD *event, Int_t direction);  //read seeds from the event
+   void ReadSeeds(AliESDEvent *event, Int_t direction);  //read seeds from the event
 
    void MakeSeeds3(TObjArray * arr, Int_t sec, Int_t i1, Int_t i2, Float_t cuts[4], Float_t deltay = -1, Int_t ddsec=0); 
    void MakeSeeds5(TObjArray * arr, Int_t sec, Int_t i1, Int_t i2, Float_t cuts[4], Float_t deltay = -1);
@@ -272,7 +272,7 @@ private:
    TTree * fOutput;      // output tree with tracks
    TTree * fSeedTree;    // output tree with seeds - filled in debug mode 1
    TTree * fTreeDebug;   // output with a debug information about track
-   AliESD * fEvent;      // output with esd tracks
+   AliESDEvent * fEvent;      // output with esd tracks
    Int_t    fDebug;      // debug option        
    Bool_t   fNewIO;      // indicated if we have data using New IO 
    Int_t fNtracks;                     //current number of tracks
@@ -285,7 +285,7 @@ private:
    Double_t fPadLength[200];                // max y for given pad row
    const AliTPCParam *fParam;          //pointer to the parameters
    TTreeSRedirector *fDebugStreamer;     //!debug streamer
-   ClassDef(AliTPCtrackerMI,1) 
+   ClassDef(AliTPCtrackerMI,2) 
 };
 
 
index 85a9c8e..b0bbeed 100644 (file)
@@ -27,7 +27,7 @@
 #include "AliRawReader.h"
 #include "AliLog.h"
 #include "AliESDTrdTrack.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
 
 #include "AliTRDReconstructor.h"
 #include "AliTRDclusterizerV1.h"
@@ -167,7 +167,7 @@ AliTracker *AliTRDReconstructor::CreateTracker(AliRunLoader *runLoader) const
 //_____________________________________________________________________________
 void AliTRDReconstructor::FillESD(AliRunLoader* /*runLoader*/
                                , AliRawReader* /*rawReader*/
-                               , AliESD *esd) const
+                               , AliESDEvent *esd) const
 {
   //
   // Make PID
@@ -181,7 +181,7 @@ void AliTRDReconstructor::FillESD(AliRunLoader* /*runLoader*/
 //_____________________________________________________________________________
 void AliTRDReconstructor::FillESD(AliRawReader* /*rawReader*/
                                , TTree* /*clusterTree*/
-                               , AliESD *esd) const
+                               , AliESDEvent *esd) const
 {
   //
   // Make PID
@@ -195,7 +195,7 @@ void AliTRDReconstructor::FillESD(AliRawReader* /*rawReader*/
 //_____________________________________________________________________________
 void AliTRDReconstructor::FillESD(TTree* /*digitsTree*/
                                , TTree* /*clusterTree*/
-                               , AliESD *esd) const
+                               , AliESDEvent *esd) const
 {
   //
   // Make PID
@@ -208,7 +208,7 @@ void AliTRDReconstructor::FillESD(TTree* /*digitsTree*/
 
 //_____________________________________________________________________________
 void AliTRDReconstructor::FillESD(AliRunLoader* /*runLoader*/
-                               , AliESD *esd) const
+                               , AliESDEvent *esd) const
 {
   //
   // Make PID
index e14865c..fefaa4e 100644 (file)
@@ -33,10 +33,10 @@ class AliTRDReconstructor: public AliReconstructor {
 
   virtual AliTracker *CreateTracker(AliRunLoader *runLoader) const;
 
-  virtual void        FillESD(AliRunLoader *runLoader, AliRawReader *rawReader, AliESD *esd) const;
-  virtual void        FillESD(AliRawReader *rawReader, TTree *clusterTree, AliESD *esd) const;
-  virtual void        FillESD(TTree *digitsTree, TTree *clusterTree, AliESD *esd) const;
-  virtual void        FillESD(AliRunLoader *runLoader, AliESD *esd) const;
+  virtual void        FillESD(AliRunLoader *runLoader, AliRawReader *rawReader, AliESDEvent *esd) const;
+  virtual void        FillESD(AliRawReader *rawReader, TTree *clusterTree, AliESDEvent *esd) const;
+  virtual void        FillESD(TTree *digitsTree, TTree *clusterTree, AliESDEvent *esd) const;
+  virtual void        FillESD(AliRunLoader *runLoader, AliESDEvent *esd) const;
 
   static  void        SetSeedingOn(Bool_t seeding)               { fgkSeedingOn  = seeding; }  
   static  void        SetStreamLevel(Int_t level)                { fgStreamLevel = level;   }
index aea62d5..d1f43ea 100644 (file)
@@ -20,7 +20,7 @@
 // Implementation of the TRD PID class                                    //
 //                                                                        //
 // Assigns the electron and pion likelihoods to each ESD track.           //
-// The function MakePID(AliESD *event) calculates the probability         //
+// The function MakePID(AliESDEvent *event) calculates the probability         //
 // of having dedx and a maximum timbin at a given                         //
 // momentum (mom) and particle type k                                     //
 // from the precalculated distributions.                                  //
@@ -32,7 +32,7 @@
 ////////////////////////////////////////////////////////////////////////////
 
 #include "AliLog.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
 #include "AliESDtrack.h"
 #include "AliTracker.h"
 
@@ -108,7 +108,7 @@ void AliTRDpidESD::Copy(TObject &p) const
 }
 
 //_____________________________________________________________________________
-Int_t AliTRDpidESD::MakePID(AliESD *event)
+Int_t AliTRDpidESD::MakePID(AliESDEvent *event)
 {
   //
   // This function calculates the PID probabilities based on TRD signals
index 0d73b3a..92fc99e 100644 (file)
@@ -15,7 +15,7 @@
 
 #include <TObject.h>
 
-class AliESD;
+class AliESDEvent;
 class AliESDtrack;
 class AliExternalTrackParam;
 class AliTRDpidESD : public TObject {
@@ -29,7 +29,7 @@ class AliTRDpidESD : public TObject {
 
   virtual void    Copy(TObject &p) const;
   static  Bool_t  CheckTrack(AliESDtrack *t);
-          Int_t   MakePID(AliESD *event);
+          Int_t   MakePID(AliESDEvent *event);
 
           void    SetCheckTrackStatus(Bool_t status = kTRUE) { fCheckTrackStatus = status; };
           void    SetCheckKinkStatus(Bool_t status = kTRUE)  { fCheckKinkStatus  = status; };
index a6fa72f..120b345 100644 (file)
@@ -39,7 +39,7 @@
 #include <TTree.h>  
 #include <TTreeStream.h>
 
-#include "AliESD.h"
+#include "AliESDEvent.h"
 #include "AliAlignObj.h"
 #include "AliRieman.h"
 #include "AliTrackPointArray.h"
@@ -570,7 +570,7 @@ Int_t  AliTRDtracker::GetLastPlane(AliTRDtrack *track)
 }
 
 //_____________________________________________________________________________
-Int_t AliTRDtracker::Clusters2Tracks(AliESD *event)
+Int_t AliTRDtracker::Clusters2Tracks(AliESDEvent *event)
 {
   //
   // Finds tracks within the TRD. The ESD event is expected to contain seeds 
@@ -629,7 +629,7 @@ Int_t AliTRDtracker::Clusters2Tracks(AliESD *event)
 }     
      
 //_____________________________________________________________________________
-Int_t AliTRDtracker::PropagateBack(AliESD *event) 
+Int_t AliTRDtracker::PropagateBack(AliESDEvent *event) 
 {
   //
   // Gets seeds from ESD event. The seeds are AliTPCtrack's found and
@@ -914,7 +914,7 @@ Int_t AliTRDtracker::PropagateBack(AliESD *event)
 }
 
 //_____________________________________________________________________________
-Int_t AliTRDtracker::RefitInward(AliESD *event)
+Int_t AliTRDtracker::RefitInward(AliESDEvent *event)
 {
   //
   // Refits tracks within the TRD. The ESD event is expected to contain seeds 
@@ -1505,7 +1505,7 @@ void AliTRDtracker::UnloadClusters()
 }
 
 //_____________________________________________________________________________
-void AliTRDtracker::MakeSeedsMI(Int_t /*inner*/, Int_t /*outer*/, AliESD *esd)
+void AliTRDtracker::MakeSeedsMI(Int_t /*inner*/, Int_t /*outer*/, AliESDEvent *esd)
 {
   //
   // Creates  seeds using clusters between  position inner plane  and outer plane 
index 58d26f4..164e907 100644 (file)
@@ -27,7 +27,7 @@ class AliTRDtrack;
 class AliTRDtracklet;
 class AliTRDcluster;
 class AliTRDseed;
-class AliESD;
+class AliESDEvent;
 class TTreeSRedirector;
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -94,9 +94,9 @@ class AliTRDtracker : public AliTracker {
   return (AliCluster *) fClusters->UncheckedAt(index); }
   
   static  Int_t    Freq(Int_t n, const Int_t *inlist, Int_t *outlist, Bool_t down);    
-  Int_t    Clusters2Tracks(AliESD *event);
-  Int_t    PropagateBack(AliESD *event);
-  Int_t    RefitInward(AliESD *event);
+  Int_t    Clusters2Tracks(AliESDEvent *event);
+  Int_t    PropagateBack(AliESDEvent *event);
+  Int_t    RefitInward(AliESDEvent *event);
   
   virtual void     CookLabel(AliKalmanTrack *t, Float_t wrong) const;
   
@@ -261,7 +261,7 @@ class AliTRDtracker : public AliTracker {
  private:
   
   AliTRDtrack *RegisterSeed(AliTRDseed *seeds, Double_t *params);
-  void     MakeSeedsMI(Int_t inner, Int_t outer, AliESD *esd = 0);
+  void     MakeSeedsMI(Int_t inner, Int_t outer, AliESDEvent *esd = 0);
   
   Int_t    FollowBackProlongation(AliTRDtrack &t);
   Int_t    FollowProlongation(AliTRDtrack &t);
index 696a833..f459272 100644 (file)
@@ -39,7 +39,7 @@
 #include "AliRunLoader.h"
 #include "AliTRDgeometry.h"
 #include "AliRun.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
 #include "AliESDtrack.h"
 #include "AliTrackReference.h"
 
@@ -651,7 +651,7 @@ void  AliTRDtrackingAnalysis::CheckFiles()
   }
   
   fEsdTree = (TTree*)esdFile->Get("esdTree"); 
-  fESD = new AliESD();
+  fESD = new AliESDEvent();
   fESD->ReadFromTree(fEsdTree);
   //fEsdTree->SetBranchAddress("ESD", &fESD);
 }
index 7386a53..0eb636b 100644 (file)
@@ -23,7 +23,7 @@ class TGraphErrors;
 
 class AliRunLoader;
 class AliTRDgeometry;
-class AliESD;
+class AliESDEvent;
 class AliTRDcluster;
 class AliTRDtracker;
 
@@ -61,7 +61,7 @@ class AliTRDtrackingAnalysis : public TObject {
 
   AliRunLoader *fLoader;          // AliRunLoader instance
   TTree  *fEsdTree;               // ESD tree
-  AliESD *fESD;                   // ESD
+  AliESDEvent *fESD;                   // ESD
 
   AliTRDtracker *fTracker;        // TRD tracker instance
 
index 3898206..93cd190 100644 (file)
@@ -26,7 +26,7 @@
 
 #include "AliRunLoader.h"
 #include "AliRawReader.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
 #include "AliZDCDigit.h"
 #include "AliZDCRawStream.h"
 #include "AliZDCReco.h"
@@ -316,7 +316,7 @@ void AliZDCReconstructor::ReconstructEvent(AliLoader* loader, Float_t zn1corr,
 
 //_____________________________________________________________________________
 void AliZDCReconstructor::FillESD(AliRunLoader* runLoader, 
-                                 AliESD* esd) const
+                                 AliESDEvent* esd) const
 {
 // fill energies and number of participants to the ESD
 
index 8f478a9..78175d1 100644 (file)
@@ -31,12 +31,12 @@ public:
                {AliReconstructor::Reconstruct(digitsTree,clustersTree);}
   virtual void Reconstruct(AliRawReader* rawReader, TTree* clustersTree) const 
                {AliReconstructor::Reconstruct(rawReader,clustersTree);}
-  virtual void FillESD(AliRunLoader* runLoader, AliESD* esd) const;
-  virtual void FillESD(TTree* digitsTree, TTree* clustersTree, AliESD* esd) const 
+  virtual void FillESD(AliRunLoader* runLoader, AliESDEvent* esd) const;
+  virtual void FillESD(TTree* digitsTree, TTree* clustersTree, AliESDEvent* esd) const 
                {AliReconstructor::FillESD(digitsTree,clustersTree,esd);}
-  virtual void FillESD(AliRawReader* rawReader, TTree* clustersTree, AliESD* esd) const 
+  virtual void FillESD(AliRawReader* rawReader, TTree* clustersTree, AliESDEvent* esd) const 
                {AliReconstructor::FillESD(rawReader,clustersTree,esd);}
-  virtual void FillESD(AliRunLoader* runLoader, AliRawReader* rawReader, AliESD* esd) const 
+  virtual void FillESD(AliRunLoader* runLoader, AliRawReader* rawReader, AliESDEvent* esd) const 
                  {AliReconstructor::FillESD(runLoader,rawReader,esd);}
   
   AliCDBStorage   *SetStorage(const char* uri);
index 7ac32e7..f65abaa 100644 (file)
@@ -33,10 +33,9 @@ void test() {
   name = "AliESDs.root";
   TFile * fSig = TFile::Open(name.Data());
   TTree * tSig = (TTree*)fSig->Get("esdTree");
-  TBranch * bSig = tSig->GetBranch("ESD");  
 
-  AliESD * esdSig = 0; // The signal ESD object is put here
-  bSig->SetAddress(&esdSig);
+  AliESDEvent * esdSig = new AliESDEvent; // The signal ESD object is put here
+  esdSig->ReadFromTree(tSig);
 
   // Run loader
   name = "galice.root";
@@ -59,7 +58,7 @@ void test() {
     cout << "Signal event " << iev << endl;
 
     // Get ESD
-    bSig->GetEntry(iev);
+    tSig->GetEntry(iev);
 
     // Get MC
     rlSig->GetEvent(iev);