*** V interface for TPCCalibTasks ***
authorivorobye <ivan.vorobyev@cern.ch>
Mon, 15 Sep 2014 18:36:41 +0000 (20:36 +0200)
committerivorobye <ivan.vorobyev@cern.ch>
Mon, 15 Sep 2014 18:36:41 +0000 (20:36 +0200)
- TPCCalib tasks now use V Classes on Event/Track/friends level as input
- added ClassDef in FlatESD
- getters for ESDV0, Kink, Vertex etc

- TPCCalibCosmic and TPCCalibV0 will work only with ESD input at the moment!!!

34 files changed:
HLT/global/AliFlatESDEvent.h
HLT/global/AliFlatESDFriend.h
HLT/global/AliFlatESDFriendTrack.h
HLT/global/AliFlatESDTrack.h
STEER/ESD/AliESDEvent.h
STEER/ESD/AliESDfriendTrack.h
STEER/STEERBase/AliVEvent.h
STEER/STEERBase/AliVTrack.h
STEER/STEERBase/AliVfriendTrack.h
TPC/Calib/AliTPCAnalysisTaskcalib.cxx
TPC/Calib/AliTPCAnalysisTaskcalib.h
TPC/Calib/AliTPCcalibAlign.cxx
TPC/Calib/AliTPCcalibAlign.h
TPC/Calib/AliTPCcalibBase.cxx
TPC/Calib/AliTPCcalibBase.h
TPC/Calib/AliTPCcalibCalib.cxx
TPC/Calib/AliTPCcalibCalib.h
TPC/Calib/AliTPCcalibCosmic.cxx
TPC/Calib/AliTPCcalibCosmic.h
TPC/Calib/AliTPCcalibGainMult.cxx
TPC/Calib/AliTPCcalibGainMult.h
TPC/Calib/AliTPCcalibLaser.cxx
TPC/Calib/AliTPCcalibLaser.h
TPC/Calib/AliTPCcalibTime.cxx
TPC/Calib/AliTPCcalibTime.h
TPC/Calib/AliTPCcalibTimeGain.cxx
TPC/Calib/AliTPCcalibTimeGain.h
TPC/Calib/AliTPCcalibTracks.cxx
TPC/Calib/AliTPCcalibTracks.h
TPC/Calib/AliTPCcalibTracksCuts.cxx
TPC/Calib/AliTPCcalibTracksCuts.h
TPC/Calib/AliTPCcalibTracksGain.h
TPC/Calib/AliTPCcalibV0.cxx
TPC/Calib/AliTPCcalibV0.h

index 0a3c834..f897ab8 100644 (file)
@@ -194,6 +194,8 @@ class AliFlatESDEvent :public AliVEvent {
   // -- Variable Size Object
 
   Byte_t fContent[1];                  // Variale size object, which contains all data
+
+  ClassDef(AliFlatESDEvent,0)
 };
 
 // Inline implementations 
index 1071f14..6eb0da4 100644 (file)
@@ -101,6 +101,8 @@ private:
   // -- Variable Size Object
 
   Byte_t fContent[1];                  // Variale size object, which contains all data
+
+  ClassDef(AliFlatESDFriend,0)
 };
 
 
index 450dd2b..690e970 100644 (file)
@@ -47,6 +47,10 @@ class AliFlatESDFriendTrack :public AliVfriendTrack
 
   //virtual const AliVtrackPointArray *GetTrackPointArray() const {return NULL;}
 
+  TObject* GetCalibObject(Int_t) const {return NULL;}
+  const AliExternalTrackParam* GetTPCOut() const {return NULL;}
+  const AliExternalTrackParam* GetITSOut() const {return NULL;}
+
   
   // bit manipulation for filtering
 
@@ -101,6 +105,8 @@ class AliFlatESDFriendTrack :public AliVfriendTrack
   
   Byte_t fContent[1];                  // Variale size object, which contains all data
 
+  ClassDef(AliFlatESDFriendTrack, 0)
+
 };
 
 inline Int_t AliFlatESDFriendTrack::GetTrackParam( Long64_t ptr, AliExternalTrackParam &param ) const
index a4398c6..847c668 100644 (file)
@@ -162,6 +162,8 @@ class AliFlatESDTrack :public AliVTrack {
   // -- Variable Size Object
   Byte_t fContent[1];                  // Variale size object, which contains all data
 
+  ClassDef(AliFlatESDTrack,0)
+
 };
 
 // _______________________________________________________________________________________________________
index f2694e1..0dea219 100644 (file)
@@ -292,6 +292,30 @@ public:
 
   const AliESDVertex *GetPrimaryVertex() const;
 
+  //getters for calibration
+  Int_t GetPrimaryVertex (AliESDVertex &v) const {
+      if(!GetPrimaryVertex()) return -1;
+      v=*GetPrimaryVertex();
+      return 0;
+  }
+
+  Int_t GetPrimaryVertexTPC (AliESDVertex &v) const {
+      if(!GetPrimaryVertexTPC()) return -1;
+      v=*GetPrimaryVertexTPC();
+      return 0;
+  }
+
+  Int_t GetPrimaryVertexSPD (AliESDVertex &v) const {
+      if(!GetPrimaryVertexSPD()) return -1;
+      v=*GetPrimaryVertexSPD();
+      return 0;
+  }
+
+  Int_t GetPrimaryVertexTracks (AliESDVertex &v) const {
+      if(!GetPrimaryVertexTracks()) return -1;
+      v=*GetPrimaryVertexTracks();
+      return 0;
+  }
 
 
   void SetTOFHeader(const AliTOFHeader * tofEventTime);
@@ -413,6 +437,12 @@ public:
   AliESDv0 *GetV0(Int_t i) const {
     return (AliESDv0*)(fV0s?fV0s->At(i):0x0);
   }
+
+  Int_t GetV0(AliESDv0 &v0dum, Int_t i) const {
+        if(!GetV0(i)) return -1;
+        v0dum=*GetV0(i);
+        return 0;}
+
   Int_t AddV0(const AliESDv0 *v);
 
   AliESDcascade *GetCascade(Int_t i) const {
index 12bebd2..f4d5cf4 100644 (file)
@@ -96,7 +96,7 @@ protected:
 private:
   AliESDfriendTrack &operator=(const AliESDfriendTrack & /* t */) {return *this;}
 
-  ClassDef(AliESDfriendTrack,6) //ESD friend track
+  ClassDef(AliESDfriendTrack,7) //ESD friend track
 };
 
 #endif
index dbd5714..99fd31b 100644 (file)
@@ -33,19 +33,15 @@ class AliVVZERO;
 class AliVZDC;
 class AliVMFT;   // AU
 class AliESDkink;
+class AliESDv0;
+class AliESDVertex;
+class AliVTrack;
 
 class AliVEvent : public TObject {
  private:
   // disable some methods from AliVEvent interface
 
-  UInt_t    GetTimeStamp()     const { return 0; }
-  UInt_t    GetEventSpecie() const { return 0; }
   ULong64_t GetTriggerMaskNext50() const { return 0; }
-  AliVfriendEvent* FindFriend() const { return 0; }
-
-  Int_t GetNumberOfKinks() const { return 0; }
-
-  AliESDkink* GetKink(Int_t /*i*/) const { return NULL; }
 
 public:
   enum EOfflineTriggerTypes { 
@@ -156,6 +152,7 @@ public:
  
   // Tracks
   virtual AliVParticle *GetTrack(Int_t i) const = 0;
+  virtual AliVTrack    *GetVTrack(Int_t /*i*/) const {return NULL;}
   //virtual Int_t        AddTrack(const AliVParticle *t) = 0;
   virtual Int_t        GetNumberOfTracks() const = 0;
   virtual Int_t        GetNumberOfV0s() const = 0;
@@ -180,9 +177,6 @@ public:
   const TGeoHMatrix* GetEMCALMatrix(Int_t /*i*/)   const {return NULL;}
   virtual AliVCaloTrigger *GetCaloTrigger(TString /*calo*/) const {return NULL;} 
 
-       
-  // Primary vertex
-  virtual const AliVVertex   *GetPrimaryVertex() const {return 0x0;}
   virtual Bool_t IsPileupFromSPD(Int_t /*minContributors*/, 
                                 Double_t /*minZdist*/, 
                                 Double_t /*nSigmaZdist*/, 
@@ -212,6 +206,26 @@ public:
   virtual AliVTrdTrack* GetTrdTrack(Int_t /* iTrack */) const { return 0x0; }
 
   virtual Int_t     GetNumberOfESDTracks()  const { return 0; }
+  virtual Int_t     GetEventNumberInFile() const {return 0;}
+
+  //used in calibration:
+  virtual Int_t            GetV0(AliESDv0&, Int_t /*iv0*/) const {return 0;}
+  virtual UInt_t           GetTimeStamp() const { return 0; }
+  virtual AliVfriendEvent* FindFriend() const { return 0; }
+  virtual UInt_t           GetEventSpecie() const { return 0; }
+  virtual AliESDkink*      GetKink(Int_t /*i*/) const { return NULL; }
+  virtual Int_t            GetNumberOfKinks() const { return 0; }
+
+  // Primary vertex
+  virtual const AliVVertex   *GetPrimaryVertex() const {return 0x0;}
+  //virtual const AliVVertex   *GetPrimaryVertexSPD() const {return 0x0;}
+  //virtual const AliVVertex   *GetPrimaryVertexTPC() const {return 0x0;}
+  //virtual const AliVVertex   *GetPrimaryVertexTracks() const {return 0x0;}
+
+  virtual Int_t GetPrimaryVertex( AliESDVertex & ) const {return 0;}
+  virtual Int_t GetPrimaryVertexTPC( AliESDVertex & ) const {return 0;}
+  virtual Int_t GetPrimaryVertexSPD( AliESDVertex & ) const {return 0;}
+  virtual Int_t GetPrimaryVertexTracks( AliESDVertex & ) const {return 0;}
 
   virtual void ConnectTracks() {}
 
index 7c41b44..c0fc5c3 100644 (file)
@@ -93,6 +93,12 @@ public:
   virtual const    AliDetectorPID* GetDetectorPID() const { return 0x0; }
   virtual Double_t GetTRDchi2()          const { return -1;}
   virtual Int_t    GetNumberOfClusters() const {return 0;}
+
+  virtual Float_t GetTPCCrossedRows() const {return 0;}
+  virtual void GetImpactParameters(Float_t [], Float_t []) const {;}
+  virtual void GetImpactParameters(Float_t &/*&xy*/,Float_t &/*&z*/) const {;}
+  virtual void GetImpactParametersTPC(Float_t &/*&xy*/,Float_t &/*&z*/) const {;}
+  virtual void GetImpactParametersTPC(Float_t [] /*p[2]*/, Float_t [] /*cov[3]*/) const {;}
   
   virtual Int_t GetEMCALcluster()     const {return kEMCALNoMatch;}
   virtual void SetEMCALcluster(Int_t)       {;}
@@ -140,6 +146,7 @@ public:
   virtual const AliExternalTrackParam * GetInnerParam() const { return NULL;}
   virtual const AliExternalTrackParam * GetOuterParam() const { return NULL;}
   virtual const AliExternalTrackParam * GetTPCInnerParam() const { return NULL;}
+  virtual const AliExternalTrackParam * GetConstrainedParam() const {return NULL;}
 
   virtual void      GetIntegratedTimes(Double_t */*times*/, Int_t nspec=AliPID::kSPECIESC) const;
   virtual Double_t  GetTRDmomentum(Int_t /*plane*/, Double_t */*sp*/=0x0) const {return 0.;}
@@ -172,6 +179,25 @@ public:
   virtual Int_t GetTrackParamCp       ( AliExternalTrackParam& ) const {return 0;}
   virtual Int_t GetTrackParamITSOut   ( AliExternalTrackParam& ) const {return 0;}
 
+  virtual Int_t             GetKinkIndex(Int_t /*i*/) const { return 0;}
+  virtual Double_t          GetSigned1Pt()         const { return 0;}
+  virtual Bool_t            IsOn(Int_t /*mask*/) const {return 0;}
+  virtual Double_t          GetX()    const {return 0;}
+  virtual Double_t          GetY()    const {return 0;}
+  virtual Double_t          GetZ()    const {return 0;}
+  virtual const Double_t   *GetParameter() const {return 0;}
+  virtual Double_t          GetAlpha() const {return 0;}
+  virtual UShort_t          GetTPCncls(Int_t /*row0*/=0, Int_t /*row1*/=159) const {return 0;}
+  virtual Double_t          GetTOFsignalDz() const {return 0;}
+  virtual Double_t          GetP() const {return 0;}
+  virtual void              GetDirection(Double_t []) const {;}
+  virtual Double_t          GetLinearD(Double_t /*xv*/, Double_t /*yv*/) const {return 0;}
+  virtual void              GetDZ(Double_t /*x*/,Double_t /*y*/,Double_t /*z*/,Double_t /*b*/,Float_t [] /*dz[2]*/) const {;}
+  virtual Double_t          GetTgl()  const {return 0;}
+  virtual Char_t            GetITSclusters(Int_t */**idx*/) const {return 0;}
+  virtual UChar_t           GetTRDclusters(Int_t */**idx*/) const {return 0;}
+
+
   ClassDef(AliVTrack,1)  // base class for tracks
 };
 
index 956d5bd..08e6ec3 100644 (file)
@@ -7,6 +7,8 @@
 #include "Rtypes.h"
 class AliTPCseed;
 class AliVVtrackPointArray;
+class AliExternalTrackParam;
+class AliTrackPointArray;
 
 //_____________________________________________________________________________
 class AliVfriendTrack {
@@ -20,6 +22,10 @@ public:
   //used in calibration
   
   virtual Int_t GetTPCseed( AliTPCseed &) const = 0;
+  virtual TObject* GetCalibObject(Int_t /*index*/) const = 0;
+
+  virtual const AliExternalTrackParam* GetTPCOut() const = 0;
+  virtual const AliExternalTrackParam * GetITSOut() const = 0;
   
   /*
   Int_t GetTrackParamTPCOut( AliExternalTrackParam &p ) const { return GetExternalTrackParam( p, 0x0  ); }
@@ -27,7 +33,7 @@ public:
   Int_t GetTrackParamTRDIn( AliExternalTrackParam &p ) const { return GetExternalTrackParam( p, 0x0  ); }
   */
 
-  //virtual const AliVtrackPointArray *GetTrackPointArray() const {return NULL;}
+  virtual const AliTrackPointArray *GetTrackPointArray() const {return NULL ;}
 
   // bit manipulation for filtering
   virtual void SetSkipBit(Bool_t skip) = 0;
index c961165..c543f08 100644 (file)
 #include "AliESDfriendTrack.h"
 #include "AliTPCseed.h"
 #include "AliESDInputHandler.h"
+
+#include "AliVEvent.h"
+#include "AliVfriendEvent.h"
+#include "AliVTrack.h"
+#include "AliVfriendTrack.h"
+#include "AliVEventHandler.h"
+
 #include "AliAnalysisManager.h"
 #include "TFile.h"
 #include "TSystem.h"
@@ -40,8 +47,8 @@ ClassImp(AliTPCAnalysisTaskcalib)
 AliTPCAnalysisTaskcalib::AliTPCAnalysisTaskcalib()
   :AliAnalysisTask(),
    fCalibJobs(0),
-   fESD(0),
-   fESDfriend(0),
+   fEvent(0),
+   fEventFriend(0),
    fDebugOutputPath("")
 {
   //
@@ -54,8 +61,8 @@ AliTPCAnalysisTaskcalib::AliTPCAnalysisTaskcalib()
 AliTPCAnalysisTaskcalib::AliTPCAnalysisTaskcalib(const char *name) 
   :AliAnalysisTask(name,""),
    fCalibJobs(0),
-   fESD(0),
-   fESDfriend(0),
+   fEvent(0),
+   fEventFriend(0),
    fDebugOutputPath("")
 {
   //
@@ -84,24 +91,26 @@ void AliTPCAnalysisTaskcalib::Exec(Option_t *) {
   //
   // Exec function
   // Loop over tracks and call  Process function
-  if (!fESD) {
-    //Printf("ERROR: fESD not available");
+    //Printf("AliTPCAnalysisTaskcalib::Exec()...");
+
+  if (!fEvent) {
+    Printf("ERROR AliTPCAnalysisTaskcalib::Exec(): fEvent not available");
     return;
   }
-  fESDfriend=static_cast<AliESDfriend*>(fESD->FindListObject("AliESDfriend"));
+  fEventFriend=fEvent->FindFriend();
   //fESDfriend=fESD->FindFriend();
-  Int_t n=fESD->GetNumberOfTracks();
-  Process(fESD);
-  if (!fESDfriend) {
-    //Printf("ERROR: fESDfriend not available");
+  Int_t n=fEvent->GetNumberOfTracks();
+  Process(fEvent);
+  if (!fEventFriend) {
+    //Printf("ERROR AliTPCAnalysisTaskcalib::Exec(): fEventFriend not available");
     return;
   }
-  if (fESDfriend->TestSkipBit()) return;
+  if (fEventFriend->TestSkipBit()) return;
   //
-  Int_t run = fESD->GetRunNumber();
+  Int_t run = fEvent->GetRunNumber();
   for (Int_t i=0;i<n;++i) {
-    AliESDfriendTrack *friendTrack=fESDfriend->GetTrack(i);
-    AliESDtrack *track=fESD->GetTrack(i);
+    const AliVfriendTrack *friendTrack=fEventFriend->GetTrack(i);
+    AliVTrack *track=fEvent->GetVTrack(i);
     TObject *calibObject=0;
     AliTPCseed *seed=0;
     if (!friendTrack) continue;
@@ -123,12 +132,13 @@ void AliTPCAnalysisTaskcalib::ConnectInputData(Option_t *) {
     //Printf("ERROR: Could not read chain from input slot 0");
   } 
   else {
-    AliESDInputHandler *esdH = dynamic_cast<AliESDInputHandler*> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
+    //AliESDInputHandler *esdH = dynamic_cast<AliESDInputHandler*> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
+    AliVEventHandler *esdH = AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler();
     if (!esdH) {
-      //Printf("ERROR: Could not get ESDInputHandler");
+      Printf("ERROR: Could not get ESDInputHandler");
     } 
     else {
-      fESD = esdH->GetEvent();
+      fEvent = esdH->GetEvent();
       //Printf("*** CONNECTED NEW EVENT ****");
     }
   }
@@ -174,10 +184,11 @@ void AliTPCAnalysisTaskcalib::FinishTaskOutput()
 }
 
 
-void AliTPCAnalysisTaskcalib::Process(AliESDEvent *event) {
+void AliTPCAnalysisTaskcalib::Process(AliVEvent *event) {
   //
   // Process ESD event
   //
+    //Printf("AliTPCAnalysisTaskcalib::Process(event)...");
   AliTPCcalibBase *job=0;
   Int_t njobs = fCalibJobs->GetEntriesFast();
   for (Int_t i=0;i<njobs;i++){
@@ -194,6 +205,7 @@ void AliTPCAnalysisTaskcalib::Process(AliTPCseed *track) {
   //
   // Process TPC track
   //
+    //Printf("AliTPCAnalysisTaskcalib::Process(TPC track)...");
   AliTPCcalibBase *job=0;
   Int_t njobs = fCalibJobs->GetEntriesFast();
   for (Int_t i=0;i<njobs;i++){
@@ -204,10 +216,11 @@ void AliTPCAnalysisTaskcalib::Process(AliTPCseed *track) {
   }
 }
 
-void AliTPCAnalysisTaskcalib::Process(AliESDtrack *track, Int_t run) {
+void AliTPCAnalysisTaskcalib::Process(AliVTrack *track, Int_t run) {
   //
   // Process ESD track
   //
+    //Printf("AliTPCAnalysisTaskcalib::Process(ESD track)...");
   AliTPCcalibBase *job=0;
   Int_t njobs = fCalibJobs->GetEntriesFast();
   for (Int_t i=0;i<njobs;i++){
index 0d0f973..c14d232 100644 (file)
 #include "AliAnalysisTask.h"
 #include "TObjArray.h"
 #include "AliTPCcalibBase.h"
-class AliESDEvent;
-class AliESDtrack;
-class AliESDfriend;
+//class AliESDEvent;
+//class AliESDtrack;
+//class AliESDfriend;
+class AliVEvent;
+class AliVTrack;
+class AliVfriendEvent;
+
 class AliTPCseed;
 
 class AliTPCAnalysisTaskcalib:public AliAnalysisTask {
@@ -31,16 +35,16 @@ public:
   virtual void FinishTaskOutput();
   void         SetDebugOuputhPath(const char * name){fDebugOutputPath=name;}
 protected:
-  virtual void     Process(AliESDEvent *event);
+  virtual void     Process(AliVEvent *event);
   virtual void     Process(AliTPCseed *track);
-  virtual void     Process(AliESDtrack *track, Int_t run);
+  virtual void     Process(AliVTrack *track, Int_t run);
   virtual Long64_t Merge(TCollection *li);
   virtual void     Analyze();
   void             RegisterDebugOutput();
 private:
   TObjArray *fCalibJobs;      // array of calibration objects - WE ARE NOT OWNER?
-  AliESDEvent *fESD;         //! current esd
-  AliESDfriend *fESDfriend;  //! current esd friend
+  AliVEvent *fEvent;         //! current event
+  AliVfriendEvent *fEventFriend;  //! current event friend
   TString      fDebugOutputPath; // debug output path   
   AliTPCAnalysisTaskcalib(const AliTPCAnalysisTaskcalib&);
   AliTPCAnalysisTaskcalib& operator=(const AliTPCAnalysisTaskcalib&);
index b1ac4d6..1b85074 100644 (file)
 #include "AliTrackPointArray.h"
 
 #include "AliExternalTrackParam.h"
-#include "AliESDEvent.h"
-#include "AliESDfriend.h"
+//#include "AliESDEvent.h"
+//#include "AliESDfriend.h"
 #include "AliESDtrack.h"
 
+#include "AliVEvent.h"
+#include "AliVfriendEvent.h"
+#include "AliVTrack.h"
+#include "AliVfriendTrack.h"
+#include "AliESDVertex.h"
+
 #include "AliTPCTracklet.h"
 #include "TH1D.h"
 #include "TH2F.h"
@@ -447,7 +453,7 @@ AliTPCcalibAlign::~AliTPCcalibAlign() {
 
 }
 
-void AliTPCcalibAlign::Process(AliESDEvent *event) {
+void AliTPCcalibAlign::Process(AliVEvent *event) {
   //
   // Process pairs of cosmic tracks
   //
@@ -459,9 +465,10 @@ void AliTPCcalibAlign::Process(AliESDEvent *event) {
   ExportTrackPoints(event);  // export track points for external calibration 
   const Int_t kMaxTracks =6;
   const Int_t kminCl = 40;
-  AliESDfriend *eESDfriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
-  if (!eESDfriend) return;
-  if (eESDfriend->TestSkipBit()) return;
+  //AliESDfriend *eESDfriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
+  AliVfriendEvent *friendEvent=event->FindFriend();
+  if (!friendEvent) return;
+  if (friendEvent->TestSkipBit()) return;
   Int_t ntracks=event->GetNumberOfTracks(); 
   Float_t dca0[2];
   Float_t dca1[2];
@@ -470,21 +477,22 @@ void AliTPCcalibAlign::Process(AliESDEvent *event) {
   // process seeds
   //
   for (Int_t i0=0;i0<ntracks;++i0) {
-    AliESDtrack *track0 = event->GetTrack(i0);
-    AliESDfriendTrack *friendTrack = 0;
+    AliVTrack *track0 = event->GetVTrack(i0);
+    //AliESDfriendTrack *friendTrack = 0;
     TObject *calibObject=0;
     AliTPCseed *seed0 = 0;
     //
-    friendTrack = (AliESDfriendTrack *)eESDfriend->GetTrack(i0);;
+    //friendTrack = (AliESDfriendTrack *)friendEvent->GetTrack(i0);;
+    const AliVfriendTrack *friendTrack = friendEvent->GetTrack(i0);;
     if (!friendTrack) continue;
     for (Int_t l=0;(calibObject=friendTrack->GetCalibObject(l));++l) {
       if ((seed0=dynamic_cast<AliTPCseed*>(calibObject))) break;
     }
     if (!seed0) continue;
     fCurrentTrack=track0;
-    fCurrentFriendTrack=friendTrack;
+    fCurrentFriendTrack=const_cast<AliVfriendTrack*>(friendTrack);
     fCurrentSeed=seed0;
-    fCurrentEvent=event;
+    fCurrentEvent= event;
     Double_t scalept= TMath::Min(1./TMath::Abs(track0->GetParameter()[4]),2.);
     Bool_t   isSelected = (TMath::Exp(2*scalept)>kptDownscale*gRandom->Rndm());
     if (isSelected) ProcessSeed(seed0);
@@ -496,14 +504,14 @@ void AliTPCcalibAlign::Process(AliESDEvent *event) {
   //
   //select pairs - for alignment  
   for (Int_t i0=0;i0<ntracks;++i0) {
-    AliESDtrack *track0 = event->GetTrack(i0);
+      AliVTrack *track0 = event->GetVTrack(i0);
     //    if (track0->GetTPCNcls()<kminCl) continue;
     track0->GetImpactParameters(dca0[0],dca0[1]);
     //    if (TMath::Abs(dca0[0])>30) continue;
     //
     for (Int_t i1=0;i1<ntracks;++i1) {
       if (i0==i1) continue;
-      AliESDtrack *track1 = event->GetTrack(i1);
+      AliVTrack *track1 = event->GetVTrack(i1);
       //      if (track1->GetTPCNcls()<kminCl) continue;
       track1->GetImpactParameters(dca1[0],dca1[1]);
       // fast cuts on dca and theta
@@ -511,18 +519,18 @@ void AliTPCcalibAlign::Process(AliESDEvent *event) {
       //      if (TMath::Abs(dca1[1]-dca0[1])>15) continue;
       if (TMath::Abs(track0->GetParameter()[3]+track1->GetParameter()[3])>0.1) continue;
       //
-      AliESDfriendTrack *friendTrack = 0;
+      //AliESDfriendTrack *friendTrack = 0; ///!!! then it was used twice, cannot be const pointer
       TObject *calibObject=0;
       AliTPCseed *seed0 = 0,*seed1=0;
       //
-      friendTrack = (AliESDfriendTrack *)eESDfriend->GetTrack(i0);;
-      if (!friendTrack) continue;
-      for (Int_t l=0;(calibObject=friendTrack->GetCalibObject(l));++l) {
+      const AliVfriendTrack *friendTrack0 = friendEvent->GetTrack(i0);;
+      if (!friendTrack0) continue;
+      for (Int_t l=0;(calibObject=friendTrack0->GetCalibObject(l));++l) {
        if ((seed0=dynamic_cast<AliTPCseed*>(calibObject))) break;
       }
-      friendTrack = (AliESDfriendTrack *)eESDfriend->GetTrack(i1);;
-      if (!friendTrack) continue;
-      for (Int_t l=0;(calibObject=friendTrack->GetCalibObject(l));++l) {
+      const AliVfriendTrack *friendTrack1 = friendEvent->GetTrack(i1);;
+      if (!friendTrack1) continue;
+      for (Int_t l=0;(calibObject=friendTrack1->GetCalibObject(l));++l) {
        if ((seed1=dynamic_cast<AliTPCseed*>(calibObject))) break;
       }
       if (!seed0) continue;
@@ -606,13 +614,15 @@ void AliTPCcalibAlign::Process(AliESDEvent *event) {
   }
 }
 
-void  AliTPCcalibAlign::ExportTrackPoints(AliESDEvent *event){
+void  AliTPCcalibAlign::ExportTrackPoints(AliVEvent *event){
   //
   // Export track points for alignment - calibration
   // export space points for pairs of tracks if possible
   //
-  AliESDfriend *eESDfriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
-  if (!eESDfriend) return;
+  //AliESDfriend *eESDfriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
+  AliVfriendEvent *friendEvent=event->FindFriend();
+
+  if (!friendEvent) return;
   Int_t ntracks=event->GetNumberOfTracks();
   Int_t kMaxTracks=4;   // maximal number of tracks for cosmic pairs
   Int_t kMinVertexTracks=5;   // maximal number of tracks for vertex mesurement
@@ -627,10 +637,13 @@ void  AliTPCcalibAlign::ExportTrackPoints(AliESDEvent *event){
   const Double_t kDist1Pt = 0.1;
   const Double_t kMaxD0 =3;  // max distance to the primary vertex
   const Double_t kMaxD1 =5;  // max distance to the primary vertex
-  const AliESDVertex *tpcVertex = 0;
+  AliESDVertex *tpcVertex;
+  AliESDVertex tpcVtx;
   // get the primary vertex TPC
   if (ntracks>kMinVertexTracks) {
-    tpcVertex = event->GetPrimaryVertexSPD();
+    event->GetPrimaryVertexSPD(tpcVtx);
+    tpcVertex=&tpcVtx;
+    //event->GetPrimaryVertexSPD(tpcVertex);
     if (tpcVertex->GetNContributors()<kMinVertexTracks) tpcVertex=0;
   }
   //
@@ -639,15 +652,15 @@ void  AliTPCcalibAlign::ExportTrackPoints(AliESDEvent *event){
   Int_t index0=0,index1=0;
   //
   for (Int_t i0=0;i0<ntracks;++i0) {
-    AliESDtrack *track0 = event->GetTrack(i0);
+    AliVTrack *track0 = event->GetVTrack(i0);
     if (!track0) continue;
-    if ((track0->GetStatus() & AliESDtrack::kTPCrefit)==0) continue;
+    if ((track0->GetStatus() & AliVTrack::kTPCrefit)==0) continue;
     if (track0->GetOuterParam()==0) continue;
     if (track0->GetInnerParam()==0) continue;
     if (TMath::Abs(track0->GetInnerParam()->GetSigned1Pt()-track0->GetOuterParam()->GetSigned1Pt())>kDist1Pt) continue;
     if (TMath::Abs(track0->GetInnerParam()->GetSigned1Pt())>kDist1Pt) continue;
     if (TMath::Abs(track0->GetInnerParam()->GetTgl()-track0->GetOuterParam()->GetTgl())>kDistThS) continue;
-    AliESDtrack *track1P = 0;
+    AliVTrack *track1P = 0;
     if (track0->GetTPCNcls()<kminCl) continue;
     track0->GetImpactParameters(dca0[0],dca0[1]);
     index0=i0;
@@ -655,9 +668,9 @@ void  AliTPCcalibAlign::ExportTrackPoints(AliESDEvent *event){
     //
     if (ntracks<kMaxTracks) for (Int_t i1=i0+1;i1<ntracks;++i1) {
       if (i0==i1) continue;
-      AliESDtrack *track1 = event->GetTrack(i1);
+      AliVTrack *track1 = event->GetVTrack(i1);
       if (!track1) continue;
-      if ((track1->GetStatus() & AliESDtrack::kTPCrefit)==0) continue;
+      if ((track1->GetStatus() & AliVTrack::kTPCrefit)==0) continue;
       if (track1->GetOuterParam()==0) continue;
       if (track1->GetInnerParam()==0) continue;
       if (track1->GetTPCNcls()<kminCl) continue;
@@ -672,19 +685,20 @@ void  AliTPCcalibAlign::ExportTrackPoints(AliESDEvent *event){
       track1P = track1;
       index1=i1;
     }
-    AliESDfriendTrack *friendTrack = 0;
+    //AliESDfriendTrack *friendTrack = 0;
     TObject *calibObject=0;
     AliTPCseed *seed0 = 0,*seed1=0;
     //
-    friendTrack = (AliESDfriendTrack *)eESDfriend->GetTrack(index0);;
+    //friendTrack = (AliESDfriendTrack *)friendEvent->GetTrack(index0);;
+    const AliVfriendTrack *friendTrack = friendEvent->GetTrack(index0);;
     if (!friendTrack) continue;
     for (Int_t l=0;(calibObject=friendTrack->GetCalibObject(l));++l) {
       if ((seed0=dynamic_cast<AliTPCseed*>(calibObject))) break;
     }
     if (index1>0){
-      friendTrack = (AliESDfriendTrack *)eESDfriend->GetTrack(index1);;
-      if (!friendTrack) continue;
-      for (Int_t l=0;(calibObject=friendTrack->GetCalibObject(l));++l) {
+      const AliVfriendTrack *friendTrack1 = friendEvent->GetTrack(index1);;
+      if (!friendTrack1) continue;
+      for (Int_t l=0;(calibObject=friendTrack1->GetCalibObject(l));++l) {
        if ((seed1=dynamic_cast<AliTPCseed*>(calibObject))) break;
       }
     }
@@ -743,19 +757,22 @@ void  AliTPCcalibAlign::ExportTrackPoints(AliESDEvent *event){
       Bool_t isVertex=(tpcVertex)? kTRUE:kFALSE;
       Double_t tof0=track0->GetTOFsignal();
       Double_t tof1=(track1P) ?  track1P->GetTOFsignal(): 0;
-      static AliExternalTrackParam dummy;
-      AliExternalTrackParam *p0In  = &dummy;
-      AliExternalTrackParam *p1In  = &dummy;
-      AliExternalTrackParam *p0Out = &dummy;
-      AliExternalTrackParam *p1Out = &dummy;
+      static AliExternalTrackParam param;
+      AliExternalTrackParam *p0In  = &param;
+      AliExternalTrackParam *p1In  = &param;
+      AliExternalTrackParam *p0Out = &param;
+      AliExternalTrackParam *p1Out = &param;
       AliESDVertex vdummy;
       AliESDVertex *pvertex= (tpcVertex)? (AliESDVertex *)tpcVertex: &vdummy;
       if (track0) {
-       p0In= new AliExternalTrackParam(*track0);
+    //p0In= new AliExternalTrackParam(*track0);
+    p0In->CopyFromVTrack(track0);
        p0Out=new AliExternalTrackParam(*(track0->GetOuterParam()));
       }
       if (track1P) {
-       p1In= new AliExternalTrackParam(*track1P);
+    //p1In= new AliExternalTrackParam(*track1P);
+    p1In->CopyFromVTrack(track1P);
+
        p1Out=new AliExternalTrackParam(*(track1P->GetOuterParam()));
       }
 
@@ -2854,7 +2871,10 @@ void  AliTPCcalibAlign::UpdateAlignSector(const AliTPCseed * track,Int_t isec){
   Double_t alpha =2.*TMath::Pi()*(isec%18+0.5)/18.;
   Double_t scos=TMath::Cos(alpha);
   Double_t ssin=TMath::Sin(alpha);
-  const AliESDVertex* vertex = fCurrentEvent->GetPrimaryVertexTracks();
+  AliESDVertex vtx;
+  fCurrentEvent->GetPrimaryVertexTracks(vtx);
+  const AliESDVertex* vertex=&vtx;
+
   vertex->GetXYZ(vPosG.GetMatrixArray());
   fCurrentTrack->GetImpactParameters(vImpact[0],vImpact[1]);  // track impact parameters
   //
index 9cf738c..a6ad35d 100644 (file)
@@ -23,6 +23,7 @@ class TTree;
 class AliExternalTrackParam;
 class AliTPCPointCorrection;
 class AliTPCseed;
+class AliVEvent;
 
 class AliTPCcalibAlign:public AliTPCcalibBase {
 public:
@@ -35,13 +36,13 @@ public:
   AliTPCcalibAlign(const AliTPCcalibAlign &align);
   //
   virtual ~AliTPCcalibAlign();
-  void     Process(AliESDEvent *event);
+  void     Process(AliVEvent *event);
   virtual void ProcessSeed(AliTPCseed *track);
   virtual void Process(AliTPCseed */*track*/){ return ;}
   virtual void Analyze();
   virtual void Terminate();  
   virtual Long64_t Merge(TCollection* const list);
-  void ExportTrackPoints(AliESDEvent *event);
+  void ExportTrackPoints(AliVEvent *event);
   //
   //
   void MakeReportDy(TFile *output); 
@@ -90,7 +91,8 @@ public:
 //   Bool_t GetTransformationCovar6(Int_t s1,Int_t s2,TMatrixD &a, Bool_t norm=kFALSE);
   void Add(AliTPCcalibAlign * align);
   const Int_t *GetPoints() const {return fPoints;}
-  void     Process(AliESDtrack *const track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);};
+  //void     Process(AliESDtrack *const track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);}
+  void     Process(AliVTrack *const track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);}
   TLinearFitter* GetOrMakeFitter12(Int_t s1,Int_t s2);
   TLinearFitter* GetOrMakeFitter9(Int_t s1,Int_t s2);
   TLinearFitter* GetOrMakeFitter6(Int_t s1,Int_t s2);
index e4e004a..ba673f6 100644 (file)
 #include "AliLog.h"
 #include "AliESDEvent.h"
 
+#include "AliVEvent.h"
+#include "AliVTrack.h"
+#include "AliVfriendTrack.h"
+
 
 ClassImp(AliTPCcalibBase)
 
@@ -185,7 +189,7 @@ TTreeSRedirector *AliTPCcalibBase::GetDebugStreamer(){
 }
 
 
-void    AliTPCcalibBase::UpdateEventInfo(AliESDEvent * event){
+void    AliTPCcalibBase::UpdateEventInfo(AliVEvent * event){
   //
   //
   //
@@ -200,7 +204,7 @@ void    AliTPCcalibBase::UpdateEventInfo(AliESDEvent * event){
 }
 
 
-Bool_t AliTPCcalibBase::HasLaser(AliESDEvent *event){
+Bool_t AliTPCcalibBase::HasLaser(AliVEvent *event){
   //
   //
   //
index f40241b..2e6275f 100644 (file)
 #include "TNamed.h"
 #include "TObjString.h"
 class AliTPCseed;
-class AliESDEvent;
-class AliESDtrack;
-class AliESDfriendTrack;
+//class AliESDEvent;
+class AliVEvent;
+//class AliESDtrack;
+class AliVTrack;
+//class AliESDfriendTrack;
+class AliVfriendTrack;
 class TCollection;
 class TTreeSRedirector;
 class TGraph;
@@ -29,13 +32,19 @@ public:
   AliTPCcalibBase(const AliTPCcalibBase&calib);
   AliTPCcalibBase &operator=(const AliTPCcalibBase&calib);
   virtual ~AliTPCcalibBase();
-  virtual void     Process(AliESDEvent *event){ fCurrentEvent = event; return;}
-  virtual void     Process(AliTPCseed *track){fCurrentSeed = track; return;}
-  virtual void     Process(AliESDtrack *track, Int_t /*runNo=-1*/){fCurrentTrack=track; return;}
+  virtual void     Process(AliVEvent *event){
+      //Printf("AliTPCCalibBase::Process(ESD event)...");
+      fCurrentEvent = event; return;}
+  virtual void     Process(AliTPCseed *track){
+      //Printf("AliTPCCalibBase::Process(TPC track)...");
+      fCurrentSeed = track; return;}
+  virtual void     Process(AliVTrack *track, Int_t /*runNo=-1*/){
+      //Printf("AliTPCCalibBase::Process(ESD track)...");
+      fCurrentTrack=track; return;}
   virtual Long64_t Merge(TCollection */*li*/){return 0;}
   virtual void     Analyze(){return;}
   virtual void     Terminate();
-  virtual void     UpdateEventInfo(AliESDEvent * event);
+  virtual void     UpdateEventInfo(AliVEvent * event);
   virtual Bool_t   AcceptTrigger();
   virtual void     SetTriggerMask(Int_t accept, Int_t reject, Bool_t rejectLaser){fTriggerMaskAccept=accept;fTriggerMaskReject=reject; fRejectLaser = rejectLaser;}
  
@@ -47,7 +56,7 @@ public:
   Int_t      GetStreamLevel() const {return fStreamLevel;}
   Int_t      GetDebugLevel() const {return fDebugLevel;}
   virtual void RegisterDebugOutput(const char *path);
-  static     Bool_t HasLaser(AliESDEvent *event);
+  static     Bool_t HasLaser(AliVEvent *event);
   static TGraphErrors *        FitSlices(THnSparse *h, Int_t axisDim1, Int_t axisDim2, Int_t minEntries, Int_t nmaxBin, Float_t fracLow=0.1, Float_t fracUp=0.9, Bool_t useMedian=kFALSE, TTreeSRedirector *cstream=0, Int_t ival=1);
   static void            BinLogX(THnSparse *h, Int_t axisDim);
   static void            BinLogX(TH1 *h);
@@ -66,9 +75,9 @@ protected:
   Bool_t  fHasLaser;                    //flag the laser is overlayed with given event
   Bool_t  fRejectLaser;                 //flag- reject laser
   TObjString fTriggerClass;             // trigger class
-  AliESDEvent  *fCurrentEvent;          //! current event
-  AliESDtrack *fCurrentTrack;           //! current esd track
-  AliESDfriendTrack *fCurrentFriendTrack;     //! current friend track
+  AliVEvent  *fCurrentEvent;          //! current event
+  AliVTrack *fCurrentTrack;           //! current esd track
+  AliVfriendTrack *fCurrentFriendTrack;     //! current friend track
   AliTPCseed   *fCurrentSeed;           //! current seed
 private:
   Int_t  fDebugLevel;                   //  debug level
index f97c0cc..8a0350b 100644 (file)
 #include "TTreeStream.h"
 #include "AliLog.h"
 #include "TTimeStamp.h"
-#include "AliESDEvent.h"
-#include "AliESDfriend.h"
-#include "AliESDtrack.h"
+//#include "AliESDEvent.h"
+//#include "AliESDfriend.h"
+//#include "AliESDtrack.h"
+
+#include "AliVEvent.h"
+#include "AliVfriendEvent.h"
+#include "AliVTrack.h"
+#include "AliVfriendTrack.h"
+
 #include "AliTracker.h"
 #include "AliTPCClusterParam.h"
 #include "AliTPCParam.h"
@@ -128,20 +134,21 @@ AliTPCcalibCalib::~AliTPCcalibCalib() {
 }
 
 
-void     AliTPCcalibCalib::Process(AliESDEvent *event){
+void     AliTPCcalibCalib::Process(AliVEvent *event){
   //
   // 
   //
   if (!event) {
     return;
   }  
-  AliESDfriend *ESDfriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
-  if (!ESDfriend) {
+  //AliESDfriend *ESDfriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
+  AliVfriendEvent *friendEvent=event->FindFriend();
+  if (!friendEvent) {
    return;
   }
-  if (ESDfriend->TestSkipBit()) return;
+  if (friendEvent->TestSkipBit()) return;
   if (GetDebugLevel()>20) printf("Hallo world: Im here\n");
-  Int_t ntracks=ESDfriend->GetNumberOfTracks();   
+  Int_t ntracks=friendEvent->GetNumberOfTracks();
   //AliTPCcalibDB::Instance()->SetExBField(fMagF);
 
   //
@@ -149,14 +156,14 @@ void     AliTPCcalibCalib::Process(AliESDEvent *event){
   //
 
   for (Int_t i=0;i<ntracks;++i) {
-    AliESDtrack *track = event->GetTrack(i);     
-    AliESDfriendTrack *friendTrack = (AliESDfriendTrack*) ESDfriend->GetTrack(i);
+    AliVTrack *track = event->GetVTrack(i);
+    const AliVfriendTrack *friendTrack = friendEvent->GetTrack(i);
     if (!friendTrack) continue;
     //track->SetFriendTrack(friendTrack);
-    fCurrentFriendTrack=friendTrack;
+    fCurrentFriendTrack=(AliVfriendTrack*)(friendTrack);
     const AliExternalTrackParam * trackIn  = track->GetInnerParam();
     const AliExternalTrackParam * trackOut = track->GetOuterParam();
-    AliExternalTrackParam * tpcOut   = (AliExternalTrackParam *)friendTrack->GetTPCOut();
+    AliExternalTrackParam * tpcOut   = (AliExternalTrackParam *)(friendTrack->GetTPCOut());
     if (!trackIn) continue;
     if (!trackOut) continue;
     if (!tpcOut) continue;   
@@ -172,7 +179,7 @@ void     AliTPCcalibCalib::Process(AliESDEvent *event){
   return;
 }
 
-Bool_t  AliTPCcalibCalib::RefitTrack(AliESDtrack * track, AliTPCseed *seed, Float_t magesd){
+Bool_t  AliTPCcalibCalib::RefitTrack(AliVTrack *track, AliTPCseed *seed, Float_t magesd){
   //
   // Refit track
   // if magesd==0 forget the curvature
@@ -189,7 +196,7 @@ Bool_t  AliTPCcalibCalib::RefitTrack(AliESDtrack * track, AliTPCseed *seed, Floa
 
   static Int_t streamCounter=0;
   streamCounter++;
-  AliESDfriendTrack *friendTrack = fCurrentFriendTrack;
+  AliVfriendTrack *friendTrack = fCurrentFriendTrack;
 
   AliTPCTransform *transform = AliTPCcalibDB::Instance()->GetTransform() ;
   AliTPCParam     *param     = AliTPCcalibDB::Instance()->GetParameters();
index 25663cc..3dd666f 100644 (file)
 
 #include "AliTPCcalibBase.h"
 class AliTPCseed;
-class AliESDEvent;
-class AliESDtrack;
+//class AliESDEvent;
+class AliVEvent;
+//class AliESDtrack;
+class AliVTrack;
 class TCollection;
 class TTreeSRedirector;
 class AliExternalTrackParam;
@@ -24,12 +26,13 @@ public:
   AliTPCcalibCalib(const AliTPCcalibCalib&calib);
   AliTPCcalibCalib &operator=(const AliTPCcalibCalib&calib);
   virtual ~AliTPCcalibCalib();
-  virtual void     Process(AliESDEvent *event);
+  virtual void     Process(AliVEvent *event);
   virtual void     Analyze(){return;}
   
-  Bool_t  RefitTrack(AliESDtrack * track, AliTPCseed *seed, Float_t magesd);
+  Bool_t  RefitTrack(AliVTrack * track, AliTPCseed *seed, Float_t magesd);
   Bool_t  RejectCluster(AliTPCclusterMI* cl, AliExternalTrackParam * param);
-  void     Process(AliESDtrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);};
+  //void     Process(AliESDtrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);}
+  void     Process(AliVTrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);}
   void     Process(AliTPCseed *track){return AliTPCcalibBase::Process(track);}
 
   void  SetApplyExBCorrection(Int_t flag){fApplyExBCorrection=flag;}
index c9e4665..aa220af 100644 (file)
 #include "AliTPCseed.h"
 #include "AliESDVertex.h"
 #include "AliESDEvent.h"
+#include "AliESDtrack.h"
 #include "AliESDfriend.h"
 #include "AliESDInputHandler.h"
 #include "AliAnalysisManager.h"
 
+#include "AliVEvent.h"
+#include "AliVTrack.h"
+#include "AliVfriendEvent.h"
+#include "AliVfriendTrack.h"
+
 #include "AliTracker.h"
 #include "AliMagF.h"
 #include "AliTPCCalROC.h"
@@ -325,12 +331,12 @@ void AliTPCcalibCosmic::Add(const AliTPCcalibCosmic* cosmic){
 
 
 
-void AliTPCcalibCosmic::Process(AliESDEvent *event) {
+void AliTPCcalibCosmic::Process(AliVEvent *event) {
   //
   // Process of the ESD event  - fill calibration components
   //
   if (!event) {
-    Printf("ERROR: ESD not available");
+    Printf("ERROR: event not available");
     return;
   }  
    
@@ -460,7 +466,7 @@ void AliTPCcalibCosmic::FillHistoPerformance(const AliExternalTrackParam *par0,
   
 }
 
-void AliTPCcalibCosmic::FindPairs(const AliESDEvent *event){
+void AliTPCcalibCosmic::FindPairs(const AliVEvent *event){
   //
   // Find cosmic pairs
   // 
@@ -468,7 +474,7 @@ void AliTPCcalibCosmic::FindPairs(const AliESDEvent *event){
   // Track1 is choosen in lower TPC part
   //
   if (GetDebugLevel()>20) printf("Hallo world: Im here\n");
-  AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
+  AliVfriendEvent *friendEvent=event->FindFriend();
   Int_t ntracks=event->GetNumberOfTracks(); 
   TObjArray  tpcSeeds(ntracks);
   if (ntracks==0) return;
@@ -479,7 +485,7 @@ void AliTPCcalibCosmic::FindPairs(const AliESDEvent *event){
   //track loop
   //
   for (Int_t i=0;i<ntracks;++i) {
-   AliESDtrack *track = event->GetTrack(i);
+   AliVTrack *track = event->GetVTrack(i);
    fClusters->Fill(track->GetTPCNcls()); 
   
    const AliExternalTrackParam * trackIn = track->GetInnerParam();
@@ -489,7 +495,7 @@ void AliTPCcalibCosmic::FindPairs(const AliESDEvent *event){
    if (ntracks>4 && TMath::Abs(trackIn->GetTgl())<0.0015) continue;  // filter laser 
 
 
-   AliESDfriendTrack *friendTrack = esdFriend->GetTrack(i);
+   const AliVfriendTrack *friendTrack = friendEvent->GetTrack(i);
    if (!friendTrack) continue;
    TObject *calibObject;
    AliTPCseed *seed = 0;   
@@ -519,7 +525,7 @@ void AliTPCcalibCosmic::FindPairs(const AliESDEvent *event){
   // Find pairs
   //
   for (Int_t i=0;i<ntracks;++i) {
-    AliESDtrack *track0 = event->GetTrack(i);     
+      AliVTrack *track0 = event->GetVTrack(i);
     // track0 - choosen upper part
     if (!track0) continue;
     if (!track0->GetOuterParam()) continue;
@@ -528,7 +534,7 @@ void AliTPCcalibCosmic::FindPairs(const AliESDEvent *event){
     track0->GetDirection(dir0);    
     for (Int_t j=0;j<ntracks;++j) {
       if (i==j) continue;
-      AliESDtrack *track1 = event->GetTrack(j);   
+      AliVTrack *track1 = event->GetVTrack(j);
       //track 1 lower part
       if (!track1) continue;
       if (!track1->GetOuterParam()) continue;
@@ -569,8 +575,11 @@ void AliTPCcalibCosmic::FindPairs(const AliESDEvent *event){
       //
       //
       Float_t dmax = TMath::Max(TMath::Abs(d0),TMath::Abs(d1));
-      AliExternalTrackParam param0(*track0);
-      AliExternalTrackParam param1(*track1);
+      AliExternalTrackParam param0;
+      param0.CopyFromVTrack(track0);
+
+      AliExternalTrackParam param1;
+      param1.CopyFromVTrack(track1);
       //
       // Propagate using Magnetic field and correct fo material budget
       //
@@ -703,7 +712,7 @@ void AliTPCcalibCosmic::FindPairs(const AliESDEvent *event){
 
 
 
-void  AliTPCcalibCosmic::FillAcordeHist(AliESDtrack *upperTrack) {
+void  AliTPCcalibCosmic::FillAcordeHist(AliVTrack *upperTrack) {
 
   // Pt cut to select straight tracks which can be easily propagated to ACORDE which is outside the magnetic field
   if (upperTrack->Pt() < 10 || upperTrack->GetTPCNcls() < 80) return;
@@ -984,14 +993,20 @@ void AliTPCcalibCosmic::UpdateTrack(AliExternalTrackParam &track1, const AliExte
 
 
 
-void AliTPCcalibCosmic::FindCosmicPairs(const AliESDEvent * event) {
+void AliTPCcalibCosmic::FindCosmicPairs(const AliVEvent *event) {
   //
   // find cosmic pairs trigger by random trigger
   //
   //
-  AliESDVertex *vertexSPD =  (AliESDVertex *)event->GetPrimaryVertexSPD();
-  AliESDVertex *vertexTPC =  (AliESDVertex *)event->GetPrimaryVertexTPC(); 
-  AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
+  AliESDVertex vtxSPD;
+  event->GetPrimaryVertexSPD(vtxSPD);
+  AliESDVertex *vertexSPD=&vtxSPD;
+
+  AliESDVertex vtxTPC;
+  event->GetPrimaryVertexTPC(vtxTPC);
+  AliESDVertex *vertexTPC=&vtxTPC;
+
+  AliVfriendEvent *friendEvent=event->FindFriend();
   const Double_t kMinPt=1;
   const Double_t kMinPtMax=0.8;
   const Double_t kMinNcl=50;
@@ -1006,9 +1021,9 @@ void AliTPCcalibCosmic::FindCosmicPairs(const AliESDEvent * event) {
 
 
   for (Int_t itrack0=0;itrack0<ntracks;itrack0++) {
-    AliESDtrack *track0 = event->GetTrack(itrack0);
+    AliVTrack *track0 = event->GetVTrack(itrack0);
     if (!track0) continue;
-    if (!track0->IsOn(AliESDtrack::kTPCrefit)) continue;
+    if (!track0->IsOn(AliVTrack::kTPCrefit)) continue;
 
     if (TMath::Abs(AliTracker::GetBz())>1&&track0->Pt()<kMinPt) continue;
     if (track0->GetTPCncls()<kMinNcl) continue;
@@ -1022,9 +1037,9 @@ void AliTPCcalibCosmic::FindCosmicPairs(const AliESDEvent * event) {
     //if (TMath::Abs(dcaTPC[1])<kMaxDelta[0]*2) continue;
     //    const AliExternalTrackParam * trackIn0 = track0->GetInnerParam();
     for (Int_t itrack1=itrack0+1;itrack1<ntracks;itrack1++) {
-      AliESDtrack *track1 = event->GetTrack(itrack1);
+      AliVTrack *track1 = event->GetVTrack(itrack1);
       if (!track1) continue;  
-      if (!track1->IsOn(AliESDtrack::kTPCrefit)) continue;
+      if (!track1->IsOn(AliVTrack::kTPCrefit)) continue;
       if (track1->GetKinkIndex(0)>0) continue;
       if (TMath::Abs(AliTracker::GetBz())>1&&track1->Pt()<kMinPt) continue;
       if (track1->GetTPCncls()<kMinNcl) continue;
@@ -1055,7 +1070,7 @@ void AliTPCcalibCosmic::FindCosmicPairs(const AliESDEvent * event) {
       if (!isPair) continue;
       TString filename(AliAnalysisManager::GetAnalysisManager()->GetTree()->GetCurrentFile()->GetName());
       Int_t eventNumber = event->GetEventNumberInFile(); 
-      Bool_t hasFriend=(esdFriend) ? (esdFriend->GetTrack(itrack0)!=0):0; 
+      Bool_t hasFriend=(friendEvent) ? (friendEvent->GetTrack(itrack0)!=0):0;
       Bool_t hasITS=(track0->GetNcls(0)+track1->GetNcls(0)>4);
       printf("DUMPHPTCosmic:%s|%f|%d|%d|%d\n",filename.Data(),(TMath::Min(track0->Pt(),track1->Pt())), eventNumber,hasFriend,hasITS);
 
@@ -1067,9 +1082,9 @@ void AliTPCcalibCosmic::FindCosmicPairs(const AliESDEvent * event) {
       Int_t ntracksSPD = vertexSPD->GetNContributors();
       Int_t ntracksTPC = vertexTPC->GetNContributors();
       //
-      AliESDfriendTrack *friendTrack0 = esdFriend->GetTrack(itrack0);
+      const AliVfriendTrack *friendTrack0 = friendEvent->GetTrack(itrack0);
       if (!friendTrack0) continue;
-      AliESDfriendTrack *friendTrack1 = esdFriend->GetTrack(itrack1);
+      const AliVfriendTrack *friendTrack1 = friendEvent->GetTrack(itrack1);
       if (!friendTrack1) continue;
       TObject *calibObject;
       AliTPCseed *seed0 = 0;   
@@ -1081,6 +1096,7 @@ void AliTPCcalibCosmic::FindCosmicPairs(const AliESDEvent * event) {
       for (Int_t l=0;(calibObject=friendTrack1->GetCalibObject(l));++l) {
        if ((seed1=dynamic_cast<AliTPCseed*>(calibObject))) break;
       }
+
       //
       if (pcstream){
        (*pcstream)<<"pairs"<<
@@ -1097,12 +1113,30 @@ void AliTPCcalibCosmic::FindCosmicPairs(const AliESDEvent * event) {
          "vTPC.="<<vertexTPC<<         //primary vertex -TPC
          "t0.="<<track0<<              //track0
          "t1.="<<track1<<              //track1
-         "ft0.="<<friendTrack0<<       //track0
-         "ft1.="<<friendTrack1<<       //track1
+      //"ft0.="<<dummyfriendTrack0<<       //track0
+      //"ft1.="<<dummyfriendTrack1<<       //track1
          "s0.="<<seed0<<               //track0
          "s1.="<<seed1<<               //track1
          "\n";      
       }
+
+      //**********************TEMPORARY!!*******************************************
+      // more investigation is needed with Tree ///!!!
+      //all dummy stuff here is just for code to compile and work with ESD
+
+      AliESDfriendTrack *dummyfriendTrack0 = (AliESDfriendTrack*)friendTrack0;
+      AliESDfriendTrack *dummyfriendTrack1 = (AliESDfriendTrack*)friendTrack1;
+
+      AliESDtrack *dummytrack0 = (AliESDtrack*)track0;
+      AliESDtrack *dummytrack1 = (AliESDtrack*)track1;
+
+      if ((pcstream)&&(dummyfriendTrack0)){
+          (*pcstream)<<"ft0.="<<dummyfriendTrack0<<"\n";
+      }
+      if ((pcstream)&&(dummyfriendTrack1)){
+          (*pcstream)<<"ft1.="<<dummyfriendTrack1<<"\n";
+      }
+
       if (!fCosmicTree) {
        fCosmicTree = new TTree("pairs","pairs");
        fCosmicTree->SetDirectory(0);
@@ -1110,15 +1144,15 @@ void AliTPCcalibCosmic::FindCosmicPairs(const AliESDEvent * event) {
       if (fCosmicTree->GetEntries()==0){
        //
        fCosmicTree->SetDirectory(0);
-       fCosmicTree->Branch("t0.",&track0);
-       fCosmicTree->Branch("t1.",&track1);
-       fCosmicTree->Branch("ft0.",&friendTrack0);
-       fCosmicTree->Branch("ft1.",&friendTrack1);
+    fCosmicTree->Branch("t0.",&dummytrack0);
+    fCosmicTree->Branch("t1.",&dummytrack1);
+    fCosmicTree->Branch("ft0.",&dummyfriendTrack0);
+    fCosmicTree->Branch("ft1.",&dummyfriendTrack1);
       }else{
-       fCosmicTree->SetBranchAddress("t0.",&track0);   
-       fCosmicTree->SetBranchAddress("t1.",&track1);
-       fCosmicTree->SetBranchAddress("ft0.",&friendTrack0);    
-       fCosmicTree->SetBranchAddress("ft1.",&friendTrack1);
+    fCosmicTree->SetBranchAddress("t0.",&dummytrack0);
+    fCosmicTree->SetBranchAddress("t1.",&dummytrack1);
+    fCosmicTree->SetBranchAddress("ft0.",&dummyfriendTrack0);
+    fCosmicTree->SetBranchAddress("ft1.",&dummyfriendTrack1);
       }
       fCosmicTree->Fill();
     }
@@ -1144,7 +1178,7 @@ void AliTPCcalibCosmic::AddTree(TTree* treeOutput, TTree * treeInput){
   //  
   return;
   //if (TMath::Abs(fMagF)<0.1) return; // work around - otherwise crashes 
-  AliESDtrack *track0=new AliESDtrack;
+  AliESDtrack *track0=new AliESDtrack;     ///!!!
   AliESDtrack *track1=new AliESDtrack;
   AliESDfriendTrack *ftrack0=new AliESDfriendTrack;
   AliESDfriendTrack *ftrack1=new AliESDfriendTrack;
index 9b97112..2ecbb46 100644 (file)
@@ -8,8 +8,10 @@
 class TH2F;
 class TH1F;
 class TList;
-class AliESDEvent;
-class AliESDtrack;
+//class AliESDEvent;
+class AliVEvent;
+//class AliESDtrack;
+class AliVTrack;
 class THnSparse;
 
 class AliTPCcalibCosmic:public AliTPCcalibBase {
@@ -18,14 +20,14 @@ public:
   AliTPCcalibCosmic(const Text_t *name, const Text_t *title);
   virtual ~AliTPCcalibCosmic();
   
-  virtual void      Process(AliESDEvent *event);
+  virtual void      Process(AliVEvent *event);
   virtual Long64_t  Merge(TCollection *const li);
   void              Add(const AliTPCcalibCosmic* cosmic);
   //
   //
   void              Init();
-  void              FindPairs(const AliESDEvent *event);
-  void              FindCosmicPairs(const AliESDEvent * event);
+  void              FindPairs(const AliVEvent *event);
+  void              FindCosmicPairs(const AliVEvent * event);
 
   Bool_t            IsPair(AliExternalTrackParam *tr0, AliExternalTrackParam *tr1) const;
   static void       CalculateBetheParams(TH2F *hist, Double_t * initialParam);
@@ -51,7 +53,8 @@ public:
   static void       BinLogX(TH1 *const h);   // method for correct histogram binning
   static void       BinLogX(THnSparse *const h, Int_t axisDim);   // method for correct histogram binning
 
-  void     Process(AliESDtrack *const track, Int_t runNo=-1) {AliTPCcalibBase::Process(track,runNo);};
+  //void     Process(AliESDtrack *const track, Int_t runNo=-1) {AliTPCcalibBase::Process(track,runNo);}
+  void     Process(AliVTrack *const track, Int_t runNo=-1) {AliTPCcalibBase::Process(track,runNo);}
   void     Process(AliTPCseed *const track)  {return AliTPCcalibBase::Process(track);}
   virtual void  Terminate();
   static Double_t GetDeltaTime(Double_t rmin0, Double_t rmax0, Double_t rmin1, Double_t rmax1, Double_t tmin0, Double_t tmax0, Double_t tmin1, Double_t tmax1, Double_t dcaR, TVectorD& vectorDT);
@@ -66,7 +69,7 @@ public:
   static void AddTree(TTree* treeOutput, TTree * treeInput);
 private:
   
-  void              FillAcordeHist(AliESDtrack *upperTrack);
+  void              FillAcordeHist(AliVTrack *upperTrack);
 
   
 
index 4f54f1c..19fadfc 100644 (file)
@@ -44,12 +44,18 @@ Send comments etc. to: A.Kalweit@gsi.de, marian.ivanov@cern.ch
 #include "AliTPCClusterParam.h"
 #include "AliTPCseed.h"
 #include "AliESDVertex.h"
-#include "AliESDEvent.h"
-#include "AliESDfriend.h"
+//#include "AliESDEvent.h"
+//#include "AliESDfriend.h"
+#include "AliESDfriendTrack.h"
 #include "AliESDInputHandler.h"
 #include "AliAnalysisManager.h"
 #include "AliTPCParam.h"
 
+#include "AliVEvent.h"
+#include "AliVTrack.h"
+#include "AliVfriendEvent.h"
+#include "AliVfriendTrack.h"
+
 #include "AliComplexCluster.h"
 #include "AliTPCclusterMI.h"
 
@@ -291,7 +297,7 @@ AliTPCcalibGainMult::~AliTPCcalibGainMult(){
 
 
 
-void AliTPCcalibGainMult::Process(AliESDEvent *event) {
+void AliTPCcalibGainMult::Process(AliVEvent *event) {
   //
   // Main function of the class
   // 1. Select Identified  particles - for identified particles the flag in the PID matrix is stored
@@ -314,25 +320,30 @@ void AliTPCcalibGainMult::Process(AliESDEvent *event) {
   //const Double_t kMaxDCAR=10; // maximal DCA R of the track
   //const Double_t kMaxDCAZ=5;  // maximal DCA Z of the track
   //  const Double_t kMIPPt=0.525; // MIP pt
+
+    //Printf("AliTPCcalibGainMult::Process()...");
+
+    //AliESDEvent *event=(AliESDEvent*)event;
   
   if (!event) {
-    Printf("ERROR: ESD not available");
+    Printf("ERROR AliTPCcalibGainMult::Process(): event not available");
     return;
   }  
-  fCurrentEvent=event  ;
+  fCurrentEvent=event;
   fMagF = event->GetMagneticField();
   Int_t ntracks=event->GetNumberOfTracks();  
-  AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
-  if (!esdFriend) {
-    //Printf("ERROR: esdFriend not available");
+  //AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindFriend());
+  AliVfriendEvent *friendEvent=event->FindFriend();
+  if (!friendEvent) {
+    Printf("ERROR: esdFriend not available");
     delete fPIDMatrix;
     return;
   }
-  if (!(esdFriend->TestSkipBit())) fPIDMatrix= new TMatrixD(ntracks,5);
+  if (!(friendEvent->TestSkipBit())) fPIDMatrix= new TMatrixD(ntracks,5);
   fHistNTracks->Fill(ntracks);
   //  ProcessCosmic(event);  // usually not enogh statistic
 
-  if (esdFriend->TestSkipBit()) {
+  if (friendEvent->TestSkipBit()) {
     return;
    }
   //
@@ -347,7 +358,8 @@ void AliTPCcalibGainMult::Process(AliESDEvent *event) {
   //
   for (Int_t i=0;i<ntracks;++i) {
     //
-    AliESDtrack *track = event->GetTrack(i);
+    //AliESDtrack *track = (AliESDtrack*)(event->GetTrack(i));
+    AliVTrack *track = event->GetVTrack(i);
     if (!track) continue;
     //   
     AliExternalTrackParam * trackIn  = (AliExternalTrackParam *)track->GetInnerParam();
@@ -372,13 +384,19 @@ void AliTPCcalibGainMult::Process(AliESDEvent *event) {
     if (TMath::Abs(trackIn->Eta()) > fCutEtaWindow) continue;
 
     UInt_t status = track->GetStatus();
-    if ((status&AliESDtrack::kTPCrefit)==0) continue;
-    if ((status&AliESDtrack::kITSrefit)==0 && fCutRequireITSrefit) continue; // ITS cluster
+    //if ((status&AliESDtrack::kTPCrefit)==0) continue;
+    //if ((status&AliESDtrack::kITSrefit)==0 && fCutRequireITSrefit) continue; // ITS cluster
+
+    if ((status&AliVTrack::kTPCrefit)==0) continue;
+    if ((status&AliVTrack::kITSrefit)==0 && fCutRequireITSrefit) continue; // ITS cluster
+
     Float_t dca[2], cov[3];
     track->GetImpactParameters(dca,cov);
     Float_t primVtxDCA = TMath::Sqrt(dca[0]*dca[0]);
     if (TMath::Abs(dca[0]) > fCutMaxDcaXY || TMath::Abs(dca[0]) < 0.0000001) continue;  // cut in xy
-    if (((status&AliESDtrack::kITSrefit) == 1 && TMath::Abs(dca[1]) > 3.) || TMath::Abs(dca[1]) > fCutMaxDcaZ ) continue;
+    //if (((status&AliESDtrack::kITSrefit) == 1 && TMath::Abs(dca[1]) > 3.) || TMath::Abs(dca[1]) > fCutMaxDcaZ ) continue;
+    if (((status&AliVTrack::kITSrefit) == 1 && TMath::Abs(dca[1]) > 3.) || TMath::Abs(dca[1]) > fCutMaxDcaZ ) continue;
+
     //
     //  
     // fill Alexander QA histogram
@@ -386,7 +404,8 @@ void AliTPCcalibGainMult::Process(AliESDEvent *event) {
     if (primVtxDCA < 3 && track->GetNcls(0) > 3 && track->GetKinkIndex(0) == 0 && ncls > 100) fHistQA->Fill(meanP, track->GetTPCsignal(), 5);
 
     // Get seeds
-    AliESDfriendTrack *friendTrack = esdFriend->GetTrack(i);
+    //AliESDfriendTrack *friendTrack = friendEvent->GetTrack(i);
+    const AliVfriendTrack *friendTrack = friendEvent->GetTrack(i);
     if (!friendTrack) continue;
     TObject *calibObject;
     AliTPCseed *seed = 0;
@@ -749,7 +768,7 @@ void AliTPCcalibGainMult::UpdateClusterParam() {
 }
 
 
-void AliTPCcalibGainMult::DumpTrack(AliESDtrack * track, AliESDfriendTrack *ftrack, AliTPCseed * seed, Int_t index){
+void AliTPCcalibGainMult::DumpTrack(AliVTrack * track, AliVfriendTrack *ftrack, AliTPCseed * seed, Int_t index){
   //
   // dump interesting tracks
   // 1. track at MIP region
@@ -803,7 +822,9 @@ void AliTPCcalibGainMult::DumpTrack(AliESDtrack * track, AliESDfriendTrack *ftra
   static Double_t radius1= roc->GetPadRowRadiiUp(30);
   static Double_t radius2= roc->GetPadRowRadiiUp(roc->GetNRows(36)-15);
 
-  AliESDVertex *vertex= (AliESDVertex *)fCurrentEvent->GetPrimaryVertex();
+  AliESDVertex vtx;
+  fCurrentEvent->GetPrimaryVertex(vtx);
+  AliESDVertex *vertex=&vtx;
   //
   // Estimate current MIP position - 
   //
@@ -1252,18 +1273,19 @@ void AliTPCcalibGainMult::DumpTrack(AliESDtrack * track, AliESDfriendTrack *ftra
 
 
 
-void AliTPCcalibGainMult::ProcessV0s(AliESDEvent * event){
+void AliTPCcalibGainMult::ProcessV0s(AliVEvent *event){
   //
   // Select the K0s and gamma  - and sign daughter products 
   //  
   TTreeSRedirector * pcstream =  GetDebugStreamer();
   AliKFParticle::SetField(event->GetMagneticField()); 
-  AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
-  if (!esdFriend) {
-    //Printf("ERROR: esdFriend not available");
+  //AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindFriend());
+  AliVfriendEvent *friendEvent=event->FindFriend();
+  if (!friendEvent) {
+    //Printf("ERROR: friendEvent not available");
    return;
   }
-  if (esdFriend->TestSkipBit()) return;
+  if (friendEvent->TestSkipBit()) return;
   //
   // 
   static const TDatabasePDG *pdg = TDatabasePDG::Instance();  
@@ -1274,11 +1296,23 @@ void AliTPCcalibGainMult::ProcessV0s(AliESDEvent * event){
   const Double_t kMaxREl=70;
   //
   Int_t nv0 = event->GetNumberOfV0s(); 
-  AliESDVertex *vertex= (AliESDVertex *)event->GetPrimaryVertex();
+
+
+  //AliESDVertex *vertex= (AliESDVertex *)event->GetPrimaryVertex();
+  AliESDVertex vtx;
+  event->GetPrimaryVertex(vtx);
+  AliESDVertex *vertex=&vtx;
+
   AliKFVertex kfvertex=*vertex;
+
+
   //
   for (Int_t iv0=0;iv0<nv0;iv0++){
-    AliESDv0 *v0 = event->GetV0(iv0);
+    //AliESDv0 *v0 = event->GetV0(iv0);
+    AliESDv0 v0dummy;
+    event->GetV0(v0dummy, iv0);
+    AliESDv0 *v0 = &v0dummy;
+
     if (!v0) continue;
     if (v0->GetOnFlyStatus()<0.5) continue;
     if (v0->GetPindex()<0) continue;
@@ -1331,8 +1365,10 @@ void AliTPCcalibGainMult::ProcessV0s(AliESDEvent * event){
     //
     Int_t pindex = (v0->GetParamP()->GetSign()>0) ? v0->GetPindex() : v0->GetNindex();
     Int_t nindex = (v0->GetParamP()->GetSign()>0) ? v0->GetNindex() : v0->GetPindex();
-    AliESDtrack * trackP = event->GetTrack(pindex);
-    AliESDtrack * trackN = event->GetTrack(nindex);
+    //AliESDtrack * trackP = (AliESDtrack*)event->GetTrack(pindex);
+    //AliESDtrack * trackN = (AliESDtrack*)event->GetTrack(nindex);
+    AliVTrack * trackP = event->GetVTrack(pindex);
+    AliVTrack * trackN = event->GetVTrack(nindex);
     if (!trackN) continue;
     if (!trackP) continue;
     Int_t nclP= (Int_t)trackP->GetTPCClusterInfo(2,1);
@@ -1342,8 +1378,10 @@ void AliTPCcalibGainMult::ProcessV0s(AliESDEvent * event){
     if (TMath::Abs(eta)>1) continue;
     //
     //
-    AliESDfriendTrack *friendTrackP = esdFriend->GetTrack(pindex);
-    AliESDfriendTrack *friendTrackN = esdFriend->GetTrack(nindex);
+    //AliESDfriendTrack *friendTrackP = friendEvent->GetTrack(pindex);
+    //AliESDfriendTrack *friendTrackN = friendEvent->GetTrack(nindex);
+    const AliVfriendTrack *friendTrackP = friendEvent->GetTrack(pindex);
+    const AliVfriendTrack *friendTrackN = friendEvent->GetTrack(nindex);
     if (!friendTrackP) continue;
     if (!friendTrackN) continue;
     TObject *calibObject;
@@ -1383,7 +1421,7 @@ void AliTPCcalibGainMult::ProcessV0s(AliESDEvent * event){
 
 
 
-void AliTPCcalibGainMult::ProcessCosmic(const AliESDEvent * event) {
+void AliTPCcalibGainMult::ProcessCosmic(const AliVEvent *event) {
   //
   // Find cosmic pairs trigger by random trigger
   // 
@@ -1391,9 +1429,16 @@ void AliTPCcalibGainMult::ProcessCosmic(const AliESDEvent * event) {
   AliTPCTransform *transform = AliTPCcalibDB::Instance()->GetTransform() ;
   AliTPCParam     *param     = AliTPCcalibDB::Instance()->GetParameters();
 
-  AliESDVertex *vertexSPD =  (AliESDVertex *)event->GetPrimaryVertexSPD();
-  AliESDVertex *vertexTPC =  (AliESDVertex *)event->GetPrimaryVertexTPC(); 
-  AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
+  AliESDVertex vtxSPD;
+  event->GetPrimaryVertexSPD(vtxSPD);
+  AliESDVertex *vertexSPD=&vtxSPD;
+
+  AliESDVertex vtxTPC;
+  event->GetPrimaryVertexTPC(vtxTPC);
+  AliESDVertex *vertexTPC=&vtxTPC;
+
+  //AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
+  AliVfriendEvent *friendEvent=event->FindFriend();
   const Double_t kMinPt=4;
   const Double_t kMinPtMax=0.8;
   const Double_t kMinNcl=159*0.5;
@@ -1408,9 +1453,9 @@ void AliTPCcalibGainMult::ProcessCosmic(const AliESDEvent * event) {
   
 
   for (Int_t itrack0=0;itrack0<ntracks;itrack0++) {
-    AliESDtrack *track0 = event->GetTrack(itrack0);
+    AliVTrack *track0 = event->GetVTrack(itrack0);
     if (!track0) continue;
-    if (!track0->IsOn(AliESDtrack::kTPCrefit)) continue;
+    if (!track0->IsOn(AliVTrack::kTPCrefit)) continue;
 
     if (TMath::Abs(AliTracker::GetBz())>1&&track0->Pt()<kMinPt) continue;
     if (track0->GetTPCncls()<kMinNcl) continue;
@@ -1421,9 +1466,9 @@ void AliTPCcalibGainMult::ProcessCosmic(const AliESDEvent * event) {
     //rm primaries
     //
     for (Int_t itrack1=itrack0+1;itrack1<ntracks;itrack1++) {
-      AliESDtrack *track1 = event->GetTrack(itrack1);
+      AliVTrack *track1 = event->GetVTrack(itrack1);
       if (!track1) continue;  
-      if (!track1->IsOn(AliESDtrack::kTPCrefit)) continue;
+      if (!track1->IsOn(AliVTrack::kTPCrefit)) continue;
       if (track1->GetKinkIndex(0)>0) continue;
       if (TMath::Abs(AliTracker::GetBz())>1&&track1->Pt()<kMinPt) continue;
       if (track1->GetTPCncls()<kMinNcl) continue;
@@ -1447,7 +1492,7 @@ void AliTPCcalibGainMult::ProcessCosmic(const AliESDEvent * event) {
       if (!isPair) continue;
       TString filename(AliAnalysisManager::GetAnalysisManager()->GetTree()->GetCurrentFile()->GetName());
       Int_t eventNumber = event->GetEventNumberInFile(); 
-      Bool_t hasFriend=(esdFriend) ? (esdFriend->GetTrack(itrack0)!=0):0; 
+      Bool_t hasFriend=(friendEvent) ? (friendEvent->GetTrack(itrack0)!=0):0;
       Bool_t hasITS=(track0->GetNcls(0)+track1->GetNcls(0)>4);
       AliInfo(Form("DUMPHPTCosmic:%s|%f|%d|%d|%d\n",filename.Data(),(TMath::Min(track0->Pt(),track1->Pt())), eventNumber,hasFriend,hasITS));
       //
@@ -1474,9 +1519,9 @@ void AliTPCcalibGainMult::ProcessCosmic(const AliESDEvent * event) {
          "\n";      
       }
       //
-      AliESDfriendTrack *friendTrack0 = esdFriend->GetTrack(itrack0);
+      const AliVfriendTrack *friendTrack0 = friendEvent->GetTrack(itrack0);
       if (!friendTrack0) continue;
-      AliESDfriendTrack *friendTrack1 = esdFriend->GetTrack(itrack1);
+      const AliVfriendTrack *friendTrack1 = friendEvent->GetTrack(itrack1);
       if (!friendTrack1) continue;
       TObject *calibObject;
       AliTPCseed *seed0 = 0;   
@@ -1504,12 +1549,21 @@ void AliTPCcalibGainMult::ProcessCosmic(const AliESDEvent * event) {
          "vTPC.="<<vertexTPC<<         //primary vertex -TPC
          "t0.="<<track0<<              //track0
          "t1.="<<track1<<              //track1
-         "ft0.="<<friendTrack0<<       //track0
-         "ft1.="<<friendTrack1<<       //track1
+      //"ft0.="<<friendTrack0<<       //track0
+      //"ft1.="<<friendTrack1<<       //track1
          "s0.="<<seed0<<               //track0
          "s1.="<<seed1<<               //track1
          "\n";      
       }
+
+      if ((pcstream)&&((AliESDfriendTrack*)friendTrack0)){
+          (*pcstream)<<"ft0.="<<((AliESDfriendTrack*)friendTrack0)<<"\n";
+      }
+      if ((pcstream)&&((AliESDfriendTrack*)friendTrack1)){
+          (*pcstream)<<"ft1.="<<((AliESDfriendTrack*)friendTrack1)<<"\n";
+      }
+
+
       if (!seed0) continue;
       if (!seed1) continue;
       Int_t nclA0=0, nclC0=0;     // number of clusters
@@ -1571,13 +1625,13 @@ void AliTPCcalibGainMult::ProcessCosmic(const AliESDEvent * event) {
 
 
 
-void AliTPCcalibGainMult::ProcessKinks(const AliESDEvent * event){
+void AliTPCcalibGainMult::ProcessKinks(const AliVEvent *event){
   //
   //
   //
   AliKFParticle::SetField(event->GetMagneticField()); 
-  AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
-  if (!esdFriend) {
+  AliVfriendEvent *friendEvent=event->FindFriend();
+  if (!friendEvent) {
     //Printf("ERROR: esdFriend not available");
     return;
   }
@@ -1590,7 +1644,11 @@ void AliTPCcalibGainMult::ProcessKinks(const AliESDEvent * event){
   const Int_t    kMinNcl=110;
   //
   Int_t nkinks = event->GetNumberOfKinks(); 
-  AliESDVertex *vertex= (AliESDVertex *)event->GetPrimaryVertex();
+  //AliESDVertex *vertex= (AliESDVertex *)event->GetPrimaryVertex();
+  AliESDVertex vtx;
+  event->GetPrimaryVertex(vtx);
+  AliESDVertex *vertex=&vtx;
+
   AliKFVertex kfvertex=*vertex;
   TTreeSRedirector * pcstream =  GetDebugStreamer();
   //
@@ -1610,8 +1668,8 @@ void AliTPCcalibGainMult::ProcessKinks(const AliESDEvent * event){
     AliKFParticle *v0KF = new AliKFParticle(kfpm,kfpd); 
     v0KF->SetVtxGuess(kink->GetPosition()[0],kink->GetPosition()[1],kink->GetPosition()[2]);
     Double_t chi2 = v0KF->GetChi2();
-    AliESDtrack * trackM = event->GetTrack(kink->GetIndex(0));
-    AliESDtrack * trackD = event->GetTrack(kink->GetIndex(1));
+    AliVTrack * trackM = event->GetVTrack(kink->GetIndex(0));
+    AliVTrack * trackD = event->GetVTrack(kink->GetIndex(1));
     if (!trackM) continue;
     if (!trackD) continue;
     Int_t nclM= (Int_t)trackM->GetTPCClusterInfo(2,1);
@@ -1662,8 +1720,8 @@ void AliTPCcalibGainMult::ProcessKinks(const AliESDEvent * event){
     if (TMath::Abs(eta)>1) continue;
     //
     //
-    AliESDfriendTrack *friendTrackM = esdFriend->GetTrack(kink->GetIndex(0));
-    AliESDfriendTrack *friendTrackD = esdFriend->GetTrack(kink->GetIndex(1));
+    const AliVfriendTrack *friendTrackM = friendEvent->GetTrack(kink->GetIndex(0));
+    const AliVfriendTrack *friendTrackD = friendEvent->GetTrack(kink->GetIndex(1));
     if (!friendTrackM) continue;
     if (!friendTrackD) continue;
     TObject *calibObject;
@@ -1678,7 +1736,7 @@ void AliTPCcalibGainMult::ProcessKinks(const AliESDEvent * event){
   }
 }
 
-void AliTPCcalibGainMult::DumpHPT(const AliESDEvent * event){
+void AliTPCcalibGainMult::DumpHPT(const AliVEvent *event){
   //
   // Function to select the HPT tracks and events
   // It is used to select event with HPT - list used later for the raw data downloading
@@ -1687,27 +1745,27 @@ void AliTPCcalibGainMult::DumpHPT(const AliESDEvent * event){
 
   TTreeSRedirector * pcstream =  GetDebugStreamer();
   AliKFParticle::SetField(event->GetMagneticField()); 
-  AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
-  if (!esdFriend) {
+  AliVfriendEvent *friendEvent=event->FindFriend();
+  if (!friendEvent) {
     //Printf("ERROR: esdFriend not available");
    return;
   }
-  if (esdFriend->TestSkipBit()) return;
+  if (friendEvent->TestSkipBit()) return;
 
   Int_t ntracks=event->GetNumberOfTracks(); 
   //
   for (Int_t i=0;i<ntracks;++i) {
     //
-    AliESDtrack *track = event->GetTrack(i);
+    AliVTrack *track = event->GetVTrack(i);
     if (!track) continue;
     if (track->Pt()<4) continue; 
     UInt_t status = track->GetStatus();
     //   
     AliExternalTrackParam * trackIn  = (AliExternalTrackParam *)track->GetInnerParam();
     if (!trackIn) continue;
-    if ((status&AliESDtrack::kTPCrefit)==0) continue;
-    if ((status&AliESDtrack::kITSrefit)==0) continue;
-    AliESDfriendTrack *friendTrack = esdFriend->GetTrack(i);
+    if ((status&AliVTrack::kTPCrefit)==0) continue;
+    if ((status&AliVTrack::kITSrefit)==0) continue;
+    const AliVfriendTrack *friendTrack = friendEvent->GetTrack(i);
     if (!friendTrack) continue;
     AliExternalTrackParam * itsOut = (AliExternalTrackParam *)(friendTrack->GetITSOut());
     if (!itsOut) continue;
@@ -1731,7 +1789,10 @@ void AliTPCcalibGainMult::DumpHPT(const AliESDEvent * event){
     tpcInnerC->Rotate(track->GetAlpha());
     tpcInnerC->PropagateTo(track->GetX(),event->GetMagneticField());
     Double_t dz[2],cov[3];
-    AliESDVertex *vtx= (AliESDVertex *)event->GetPrimaryVertex();
+    AliESDVertex dummyvtx;
+    event->GetPrimaryVertex(dummyvtx);
+    AliESDVertex *vtx=&dummyvtx;
+
   
     if (!tpcInnerC->PropagateToDCA(vtx, event->GetMagneticField(), 3, dz, cov)) continue;
     Double_t covar[6]; vtx->GetCovMatrix(covar);
@@ -1763,7 +1824,7 @@ void AliTPCcalibGainMult::DumpHPT(const AliESDEvent * event){
 
 
 
-void AliTPCcalibGainMult::ProcessTOF(const AliESDEvent * event){
+void AliTPCcalibGainMult::ProcessTOF(const AliVEvent *event){
   //
   // 1. Loop over tracks
   // 2. Fit T0
@@ -1774,12 +1835,14 @@ void AliTPCcalibGainMult::ProcessTOF(const AliESDEvent * event){
   const Double_t kMaxD=20;
   const Double_t kRMS0=200; 
   const Double_t kMaxDCAZ=10;
-  AliESDVertex *vtx= (AliESDVertex *)event->GetPrimaryVertex();
+  AliESDVertex dummyvtx;
+  event->GetPrimaryVertex(dummyvtx);
+  AliESDVertex *vtx=&dummyvtx;
   //
   TTreeSRedirector * pcstream =  GetDebugStreamer();
   AliKFParticle::SetField(event->GetMagneticField()); 
-  AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
-  if (!esdFriend) {
+  AliVfriendEvent *friendEvent=event->FindFriend();
+  if (!friendEvent) {
     //Printf("ERROR: esdFriend not available");
    return;
   }
@@ -1799,9 +1862,9 @@ void AliTPCcalibGainMult::ProcessTOF(const AliESDEvent * event){
     counter=0;
     for (Int_t i=0;i<ntracks;++i) {
       //
-      AliESDtrack *track = event->GetTrack(i);
+      AliVTrack *track = event->GetVTrack(i);
       if (!track) continue;
-      if (!track->IsOn(AliESDtrack::kTIME)) continue;
+      if (!track->IsOn(AliVTrack::kTIME)) continue;
       if (TMath::Abs(track->GetZ())>kMaxDCAZ) continue;         // remove overlaped events
       if (TMath::Abs(track->GetTOFsignalDz())>kMaxD) continue;
       Double_t times[1000];
@@ -1832,9 +1895,9 @@ void AliTPCcalibGainMult::ProcessTOF(const AliESDEvent * event){
   //
   for (Int_t i=0;i<ntracks;++i) {
     //
-    AliESDtrack *track = event->GetTrack(i);
+    AliVTrack *track = event->GetVTrack(i);
     if (!track) continue;
-    if (!track->IsOn(AliESDtrack::kTIME)) continue;
+    if (!track->IsOn(AliVTrack::kTIME)) continue;
     if (TMath::Abs(track->GetZ())>kMaxDCAZ) continue;          //remove overlapped events
     if (TMath::Abs(track->GetTOFsignalDz())>kMaxD) continue;
     Double_t times[1000];
index 7896be8..4dfb4e9 100644 (file)
 #include "TVectorD.h"
 class TH1F;
 class TList;
-class AliESDEvent;
-class AliESDtrack;
+//class AliESDEvent;
+class AliVEvent;
+//class AliESDtrack;
+class AliVTrack;
+class AliVfriendTrack;
 class AliTPCseed;
 
 #include "TTreeStream.h"
@@ -29,15 +32,24 @@ public:
   void SetBBParam(TVectorD * param) {fBBParam=param;}
   //  virtual void Terminate();  
   //
-  virtual void           Process(AliESDEvent *event);
-  virtual void           ProcessV0s(AliESDEvent *event);
-  virtual void           ProcessCosmic(const AliESDEvent *event);
-  virtual void           ProcessKinks(const AliESDEvent *event);
-  virtual void           ProcessTOF(const AliESDEvent *event);  
-  virtual void           DumpHPT(const AliESDEvent *event);
+  //virtual void           Process(AliESDEvent *event);
+  virtual void           Process(AliVEvent *event);
+
+  //virtual void           ProcessV0s(AliESDEvent *event);
+  //virtual void           ProcessCosmic(const AliESDEvent *event);
+  //virtual void           ProcessKinks(const AliESDEvent *event);
+  //virtual void           ProcessTOF(const AliESDEvent *event);
+  //virtual void           DumpHPT(const AliESDEvent *event);
+
+  virtual void           ProcessV0s(AliVEvent *event);
+  virtual void           ProcessCosmic(const AliVEvent *event);
+  virtual void           ProcessKinks(const AliVEvent *event);
+  virtual void           ProcessTOF(const AliVEvent *event);
+  virtual void           DumpHPT(const AliVEvent *event);
+
   virtual Long64_t       Merge(TCollection *li);
   virtual void           Analyze();
-  void                   DumpTrack(AliESDtrack * track, AliESDfriendTrack *ftrack, AliTPCseed * seed, Int_t index);
+  void                   DumpTrack(AliVTrack * track, AliVfriendTrack *ftrack, AliTPCseed * seed, Int_t index);
   //
   TH1F   *          GetHistNTracks() const {return fHistNTracks;};
   TH1F   *          GetHistClusterShape() const {return fHistClusterShape;};
@@ -72,7 +84,8 @@ public:
   void SetAlephParameters(Float_t * parameters){for(Int_t j=0;j<5;j++) fAlephParameters[j] = parameters[j];};
   //
   //
-  void     Process(AliESDtrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);};
+  //void     Process(AliESDtrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);}
+  void     Process(AliVTrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);}
   void     Process(AliTPCseed *track){return AliTPCcalibBase::Process(track);}
   //
   void     MakeLookup(THnSparse * hist, Char_t * outputFile);
index cac5c4a..77b0e89 100644 (file)
 #include "TLinearFitter.h"
 #include "AliTPCcalibLaser.h"
 #include "AliExternalTrackParam.h"
-#include "AliESDEvent.h"
-#include "AliESDfriend.h"
-#include "AliESDtrack.h"
+//#include "AliESDEvent.h"
+//#include "AliESDfriend.h"
+//#include "AliESDtrack.h"
+
+#include "AliVEvent.h"
+#include "AliVTrack.h"
+#include "AliVfriendEvent.h"
+#include "AliVfriendTrack.h"
+
 #include "AliTPCTracklet.h"
 #include "TH1D.h"
 #include "TH1F.h"
@@ -136,11 +142,11 @@ ClassImp(AliTPCcalibLaser)
 
 AliTPCcalibLaser::AliTPCcalibLaser():
   AliTPCcalibBase(),
-  fESD(0),
-  fESDfriend(0),
+  fEvent(0),
+  fEventFriend(0),
   fNtracks(0),
   fTracksMirror(336),
-  fTracksEsd(336),
+  fTracks(336),
   fTracksEsdParam(336),
   fTracksTPC(336),
   fFullCalib(kTRUE),
@@ -245,11 +251,11 @@ AliTPCcalibLaser::AliTPCcalibLaser():
 
 AliTPCcalibLaser::AliTPCcalibLaser(const Text_t *name, const Text_t *title, Bool_t full):
   AliTPCcalibBase(),
-  fESD(0),
-  fESDfriend(0),
+  fEvent(0),
+  fEventFriend(0),
   fNtracks(0),
   fTracksMirror(336),
-  fTracksEsd(336),
+  fTracks(336),
   fTracksEsdParam(336),
   fTracksTPC(336),
   fFullCalib(full),
@@ -361,11 +367,11 @@ AliTPCcalibLaser::AliTPCcalibLaser(const Text_t *name, const Text_t *title, Bool
 
 AliTPCcalibLaser::AliTPCcalibLaser(const AliTPCcalibLaser& calibLaser):
   AliTPCcalibBase(calibLaser), 
-  fESD(0),
-  fESDfriend(0),
+  fEvent(0),
+  fEventFriend(0),
   fNtracks(0),
   fTracksMirror(336),
-  fTracksEsd(336),
+  fTracks(336),
   fTracksEsdParam(336),
   fTracksTPC(336),
   fFullCalib(calibLaser.fFullCalib),
@@ -575,7 +581,7 @@ AliTPCcalibLaser::~AliTPCcalibLaser() {
 
 
 
-void AliTPCcalibLaser::Process(AliESDEvent * event) {
+void AliTPCcalibLaser::Process(AliVEvent *event) {
   //
   //
   // Loop over tracks and call  Process function
@@ -583,24 +589,25 @@ void AliTPCcalibLaser::Process(AliESDEvent * event) {
   const Int_t  kMinTracks=20;
   const Int_t  kMinClusters=40;
 
-  fESD = event;
-  if (!fESD) {
+  fEvent = event;
+  if (!fEvent) {
+      Printf("****ERROR AliTPCcalibLaser::Process(): Event not available!!********");
     return;
   }
-  fESDfriend=static_cast<AliESDfriend*>(fESD->FindListObject("AliESDfriend"));
-  if (!fESDfriend) {
+  fEventFriend=fEvent->FindFriend();
+  if (!fEventFriend) {
     return;
   }
-  if (fESDfriend->TestSkipBit()) return;
-  if (fESD->GetNumberOfTracks()<kMinTracks) return; //not enough tracks
+  if (fEventFriend->TestSkipBit()) return;
+  if (fEvent->GetNumberOfTracks()<kMinTracks) return; //not enough tracks
   AliDebug(4,Form("Event number in current file: %d",event->GetEventNumberInFile()));
   //
   // find CE background if present
   //
   if (AliTPCLaserTrack::GetTracks()==0) AliTPCLaserTrack::LoadTracks();
   TH1D hisCE("hhisCE","hhisCE",100,-100,100);  
-  for (Int_t i=0;i<fESD->GetNumberOfTracks();++i) {
-    AliESDtrack *track=fESD->GetTrack(i);
+  for (Int_t i=0;i<fEvent->GetNumberOfTracks();++i) {
+    AliVTrack *track=fEvent->GetVTrack(i);
     if (!track) continue;
     hisCE.Fill(track->GetZ());
     hisCE.Fill(track->GetZ()+2);
@@ -611,7 +618,7 @@ void AliTPCcalibLaser::Process(AliESDEvent * event) {
 
 
   fTracksTPC.Clear();
-  fTracksEsd.Clear();
+  fTracks.Clear();
   fTracksEsdParam.Delete();
   for (Int_t id=0; id<336;id++) {
     fCounter[id]=0;
@@ -619,12 +626,12 @@ void AliTPCcalibLaser::Process(AliESDEvent * event) {
     fClusterSatur[id]=0;
   }
   //
-  Int_t n=fESD->GetNumberOfTracks();
+  Int_t n=fEvent->GetNumberOfTracks();
   Int_t counter=0;
   for (Int_t i=0;i<n;++i) {
-    AliESDfriendTrack *friendTrack=fESDfriend->GetTrack(i);
+    const AliVfriendTrack *friendTrack=fEventFriend->GetTrack(i);
     if (!friendTrack) continue;
-    AliESDtrack *track=fESD->GetTrack(i);
+    AliVTrack *track= fEvent->GetVTrack(i);
     if (!track) continue;
     Double_t binC = hisCE.GetBinContent(hisCE.FindBin(track->GetZ()));
     if (binC>336) continue; //remove CE background
@@ -689,7 +696,7 @@ void AliTPCcalibLaser::MakeDistHisto(Int_t id){
 
     AliExternalTrackParam *param=(AliExternalTrackParam*)fTracksEsdParam.At(id);
     AliTPCLaserTrack *ltrp = ( AliTPCLaserTrack*)fTracksMirror.At(id);
-    AliESDtrack   *track    = (AliESDtrack*)fTracksEsd.At(id);
+    AliVTrack   *track    = (AliVTrack*)fTracks.At(id);
     if (!param) return;
     if (!ltrp) return;
     if (!track) return;
@@ -796,7 +803,7 @@ void AliTPCcalibLaser::FitDriftV(){
       if (!AcceptLaser(id)) continue;
       if ( fClusterSatur[id]>kSaturCut)  continue;
       if ( fClusterCounter[id]<kMinClusters)  continue;
-      AliESDtrack   *track    = (AliESDtrack*)fTracksEsd.At(id);
+      AliVTrack   *track    = (AliVTrack*)fTracks.At(id);
       if (track->GetTPCsignal()<kMinSignal) continue;
       AliExternalTrackParam *param=(AliExternalTrackParam*)fTracksEsdParam.At(id);
       AliTPCLaserTrack *ltrp = ( AliTPCLaserTrack*)fTracksMirror.At(id);
@@ -1099,7 +1106,7 @@ Bool_t  AliTPCcalibLaser::FitDriftV(Float_t minFraction){
       if (!AcceptLaser(id)) continue;
       if ( fClusterSatur[id]>kSaturCut)  continue;
       if ( fClusterCounter[id]<kMinClusters)  continue;
-      AliESDtrack   *track    = (AliESDtrack*)fTracksEsd.At(id);
+      AliVTrack   *track    = (AliVTrack*)fTracks.At(id);
       if (track->GetTPCsignal()<kMinSignal) continue;
       AliExternalTrackParam *param=(AliExternalTrackParam*)fTracksEsdParam.At(id);
       AliTPCLaserTrack *ltrp = ( AliTPCLaserTrack*)fTracksMirror.At(id);
@@ -1356,7 +1363,7 @@ Bool_t  AliTPCcalibLaser::AcceptLaser(Int_t id){
   return kTRUE;
 }
 
-Int_t  AliTPCcalibLaser::FindMirror(AliESDtrack *track, AliTPCseed *seed){
+Int_t  AliTPCcalibLaser::FindMirror(AliVTrack *track, AliTPCseed *seed){
   //
   // Find corresponding mirror
   // add the corresponding tracks
@@ -1436,7 +1443,7 @@ Int_t  AliTPCcalibLaser::FindMirror(AliESDtrack *track, AliTPCseed *seed){
   if (accept){
     fClusterCounter[id]=countercl;
     fTracksEsdParam.AddAt(param.Clone(),id);
-    fTracksEsd.AddAt(track,id);
+    fTracks.AddAt(track,id);
     fTracksTPC.AddAt(seed,id);
   }
   return id;
@@ -1448,7 +1455,7 @@ void AliTPCcalibLaser::DumpLaser(Int_t id) {
   //
   //  Dump Laser info to the tree
   //
-  AliESDtrack   *track    = (AliESDtrack*)fTracksEsd.At(id);
+  AliVTrack   *track    = (AliVTrack*)fTracks.At(id);
   AliExternalTrackParam *param=(AliExternalTrackParam*)fTracksEsdParam.At(id);
   AliTPCLaserTrack *ltrp = ( AliTPCLaserTrack*)fTracksMirror.At(id);
   //
@@ -1469,7 +1476,7 @@ void AliTPCcalibLaser::DumpLaser(Int_t id) {
   
   if (fStreamLevel>0){
     TTreeSRedirector *cstream = GetDebugStreamer();
-    Int_t time = fESD->GetTimeStamp();
+    Int_t time = fEvent->GetTimeStamp();
     Bool_t accept = AcceptLaser(id);
     if (cstream){
       (*cstream)<<"Track"<<
index 9a764a7..900f998 100644 (file)
 
 
 class AliExternalTrackParam;
-class AliESDtrack;
-class AliESDEvent;
-class AliESDfriend;
+//class AliESDtrack;
+//class AliESDEvent;
+//class AliESDfriend;
+class AliVEvent;
+class AliVTrack;
+class AliVfriendEvent;
 class TGraphErrors;
 class TTree;
 class TH2F;
@@ -34,7 +37,7 @@ public:
   AliTPCcalibLaser(const AliTPCcalibLaser& laser);
   AliTPCcalibLaser & operator=(const AliTPCcalibLaser& calibLaser);
   virtual ~AliTPCcalibLaser();
-  virtual void     Process(AliESDEvent *event);
+  virtual void     Process(AliVEvent *event);
   Int_t   GetNtracks(){return fNtracks;}
   virtual void Analyze();
   static void        DumpLaser(const char *finput, Int_t run);
@@ -54,13 +57,14 @@ public:
   void         MakeDistHisto(Int_t id);
   void         AddCut(Double_t xcut, Double_t ycut, Double_t ncl){fEdgeXcuts[fNcuts]=xcut; fEdgeYcuts[fNcuts]=ycut; fNClCuts[fNcuts]=ncl; fNcuts++;}
 
-  Int_t  FindMirror(AliESDtrack *track, AliTPCseed *seed);
+  Int_t  FindMirror(AliVTrack *track, AliTPCseed *seed);
   Bool_t AcceptLaser(Int_t id);
   Float_t GetDistance(AliExternalTrackParam *track, AliTPCLaserTrack *ltrp);
   void   MakeFitHistos();
   void   UpdateFitHistos();
   void   MergeFitHistos(AliTPCcalibLaser * add);
-  void     Process(AliESDtrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);};
+  //void     Process(AliESDtrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);}
+  void     Process(AliVTrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);}
   void     Process(AliTPCseed *track){return AliTPCcalibBase::Process(track);}
   //
   void SetBeamParameters(TVectorD& meanOffset, TVectorD& meanSlope,
@@ -70,12 +74,12 @@ public:
     {fUseFixedDriftV = 1; fFixedFitAside0=aside0; fFixedFitAside1=aside1;
     fFixedFitCside0=cside0; fFixedFitCside1=cside1;}
 
-  AliESDEvent  * fESD;             //! ESD event  - not OWNER
-  AliESDfriend * fESDfriend;       //! ESD event  - not OWNER
+  AliVEvent  * fEvent;             //! ESD event  - not OWNER
+  AliVfriendEvent * fEventFriend;       //! ESD event  - not OWNER
   Int_t          fNtracks;         //! counter of associated laser tracks
   //
   TObjArray      fTracksMirror;    //! tracks with mirror information
-  TObjArray      fTracksEsd;       //! tracks with reconstructed information - 
+  TObjArray      fTracks;       //! tracks with reconstructed information -
   //                               not owner ESD
   TObjArray      fTracksEsdParam;  //! tracks with reconstructed information - 
   //                               is owner ESD at mirror
index 6df9bf4..e844d0b 100644 (file)
@@ -39,10 +39,16 @@ Comments to be written here:
 
 #include "AliDCSSensor.h"
 #include "AliDCSSensorArray.h"
-#include "AliESDEvent.h"
+//#include "AliESDEvent.h"
 #include "AliESDInputHandler.h"
 #include "AliESDVertex.h"
-#include "AliESDfriend.h"
+//#include "AliESDfriend.h"
+
+#include "AliVEvent.h"
+#include "AliVTrack.h"
+#include "AliVfriendEvent.h"
+#include "AliVfriendTrack.h"
+
 #include "AliLog.h"
 #include "AliRelAlignerKalman.h"
 #include "AliTPCCalROC.h"
@@ -366,19 +372,31 @@ void AliTPCcalibTime::ResetCurrent(){
 
 
 
-void AliTPCcalibTime::Process(AliESDEvent *event){
+void AliTPCcalibTime::Process(AliVEvent *event){
   //
   // main function to make calibration
   //
-  if(!event) return;
-  if (event->GetNumberOfTracks()<2) return; 
-  AliESDfriend *ESDfriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
-  if (!ESDfriend) {
+
+    //Printf("*******************AliTPCcalibTime::Process()*******************");
+  if(!event) {
+      Printf("ERROR AliTPCcalibTime::Process(): NO EVENT AVAILABLE!");
+      return;
+  }
+  if (event->GetNumberOfTracks()<2) {
+      //Printf("ACHTUNG AliTPCcalibTime::Process(): not enough tracks!");
+      return;
+  }
+  //AliESDfriend *ESDfriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
+  AliVfriendEvent *friendEvent=event->FindFriend();
+  if (!friendEvent) {
+    Printf("ERROR AliTPCcalibTime::Process(): NO FRIEND AVAILABLE!");
     return;
   }
-  if (ESDfriend->TestSkipBit()) return;
+  if (friendEvent->TestSkipBit()) return;
   
   ResetCurrent();
+
+  //AliESDEvent *ev=(AliESDEvent*)event;
   //if(IsLaser  (event)) 
   ProcessLaser (event);
   //if(IsCosmics(event)) 
@@ -387,7 +405,7 @@ void AliTPCcalibTime::Process(AliESDEvent *event){
   ProcessBeam  (event);
 }
 
-void AliTPCcalibTime::ProcessLaser(AliESDEvent *event){
+void AliTPCcalibTime::ProcessLaser(AliVEvent *event){
   //
   // Fit drift velocity using laser 
   // 
@@ -516,12 +534,12 @@ void AliTPCcalibTime::ProcessLaser(AliESDEvent *event){
   }
 }
 
-void AliTPCcalibTime::ProcessCosmic(const AliESDEvent *const event){
+void AliTPCcalibTime::ProcessCosmic(const AliVEvent *const event){
   //
   // process Cosmic event - track matching A side C side
   //
   if (!event) {
-    Printf("ERROR: ESD not available");
+    Printf("ERROR: event not available");
     return;
   }  
   if (event->GetTimeStamp() == 0 ) {
@@ -542,8 +560,8 @@ void AliTPCcalibTime::ProcessCosmic(const AliESDEvent *const event){
   if (ntracks > fCutTracks) return;
   
   if (GetDebugLevel()>20) printf("Hallo world: Im here\n");
-  AliESDfriend *esdFriend=(AliESDfriend*)(((AliESDEvent*)event)->FindListObject("AliESDfriend"));
-  
+  //AliESDfriend *esdFriend=(AliESDfriend*)(((AliESDEvent*)event)->FindListObject("AliESDfriend"));
+  AliVfriendEvent *friendEvent=event->FindFriend();
   TObjArray  tpcSeeds(ntracks);
   Double_t vtxx[3]={0,0,0};
   Double_t svtxx[3]={0.000001,0.000001,100.};
@@ -556,17 +574,17 @@ void AliTPCcalibTime::ProcessCosmic(const AliESDEvent *const event){
   for (Int_t i=0;i<ntracks;++i) {
     clusterSideA[i]=0;
     clusterSideC[i]=0;
-    AliESDtrack *track = event->GetTrack(i);
+    AliVTrack *track = event->GetVTrack(i);
     
     const AliExternalTrackParam * trackIn = track->GetInnerParam();
     const AliExternalTrackParam * trackOut = track->GetOuterParam();
     if (!trackIn) continue;
     if (!trackOut) continue;
     
-    AliESDfriendTrack *friendTrack = esdFriend->GetTrack(i);
+    const AliVfriendTrack *friendTrack = friendEvent->GetTrack(i);
     if (!friendTrack) continue;
     if (friendTrack) ProcessSame(track,friendTrack,event);
-    if (friendTrack) ProcessAlignITS(track,friendTrack,event,esdFriend);
+    if (friendTrack) ProcessAlignITS(track,friendTrack,event,friendEvent);
     if (friendTrack) ProcessAlignTRD(track,friendTrack);
     if (friendTrack) ProcessAlignTOF(track,friendTrack);
     TObject *calibObject;
@@ -591,7 +609,7 @@ void AliTPCcalibTime::ProcessCosmic(const AliESDEvent *const event){
   //
 
   for (Int_t i=0;i<ntracks;++i) {
-    AliESDtrack *track0 = event->GetTrack(i);
+    AliVTrack *track0 = event->GetVTrack(i);
     // track0 - choosen upper part
     if (!track0) continue;
     if (!track0->GetOuterParam()) continue;
@@ -600,7 +618,7 @@ void AliTPCcalibTime::ProcessCosmic(const AliESDEvent *const event){
     track0->GetDirection(d1);    
     for (Int_t j=0;j<ntracks;++j) {
       if (i==j) continue;
-      AliESDtrack *track1 = event->GetTrack(j);   
+      AliVTrack *track1 = event->GetVTrack(j);
       //track 1 lower part
       if (!track1) continue;
       if (!track1->GetOuterParam()) continue;
@@ -640,8 +658,10 @@ void AliTPCcalibTime::ProcessCosmic(const AliESDEvent *const event){
       //
       //
       Float_t dmax = TMath::Max(TMath::Abs(dist0),TMath::Abs(dist1));
-      AliExternalTrackParam param0(*track0);
-      AliExternalTrackParam param1(*track1);
+      AliExternalTrackParam param0;
+      param0.CopyFromVTrack(track0);
+      AliExternalTrackParam param1;
+      param1.CopyFromVTrack(track1);
       //
       // Propagate using Magnetic field and correct fo material budget
       //
@@ -759,7 +779,7 @@ void AliTPCcalibTime::ProcessCosmic(const AliESDEvent *const event){
   if (GetDebugLevel()>20) printf("Trigger: %s\n",event->GetFiredTriggerClasses().Data());
 }
 
-void AliTPCcalibTime::ProcessBeam(const AliESDEvent *const event){
+void AliTPCcalibTime::ProcessBeam(const AliVEvent *const event){
   //
   // Process beam data - calculates vartex
   //                     from A side and C side
@@ -792,23 +812,38 @@ void AliTPCcalibTime::ProcessBeam(const AliESDEvent *const event){
   if (ntracks==0) return;
   if (ntracks > fCutTracks) return;
   //
-  AliESDfriend *esdFriend=(AliESDfriend*)(((AliESDEvent*)event)->FindListObject("AliESDfriend"));
+  //AliESDfriend *esdFriend=(AliESDfriend*)(((AliESDEvent*)event)->FindListObject("AliESDfriend"));
+  AliVfriendEvent *friendEvent=event->FindFriend();
   //
   // Divide tracks to A and C side tracks - using the cluster indexes
   TObjArray tracksA(ntracks);  
   TObjArray tracksC(ntracks);  
   //
-  AliESDVertex *vertexSPD =  (AliESDVertex *)event->GetPrimaryVertexSPD();
-  AliESDVertex *vertex    =  (AliESDVertex *)event->GetPrimaryVertex();
-  AliESDVertex *vertexTracks =  (AliESDVertex *)event->GetPrimaryVertexTracks();
+  //AliESDVertex *vertexSPD =  (AliESDVertex *)event->GetPrimaryVertexSPD();
+  //AliESDVertex *vertex    =  (AliESDVertex *)event->GetPrimaryVertex();
+  //AliESDVertex *vertexTracks =  (AliESDVertex *)event->GetPrimaryVertexTracks();
+
+  AliESDVertex vtxSPD;
+  event->GetPrimaryVertexSPD(vtxSPD);
+  AliESDVertex *vertexSPD=&vtxSPD;
+
+  AliESDVertex vtx;
+  event->GetPrimaryVertex(vtx);
+  AliESDVertex *vertex=&vtx;
+
+  AliESDVertex vtxTracks;
+  event->GetPrimaryVertexTracks(vtxTracks);
+  AliESDVertex *vertexTracks=&vtxTracks;
+
+
   Double_t vertexZA[10000], vertexZC[10000];
   //
   Int_t ntracksA= 0;
   Int_t ntracksC= 0;
   //
   for (Int_t itrack=0;itrack<ntracks;itrack++) {
-    AliESDtrack *track = event->GetTrack(itrack);
-    AliESDfriendTrack *friendTrack = esdFriend->GetTrack(itrack);
+    AliVTrack *track = event->GetVTrack(itrack);
+    const AliVfriendTrack *friendTrack = friendEvent->GetTrack(itrack);
     if (!friendTrack) continue;
     if (TMath::Abs(track->GetTgl())>kMaxTgl) continue;
     if (TMath::Abs(track->Pt())<kMinPt) continue;
@@ -1257,7 +1292,7 @@ Bool_t  AliTPCcalibTime::IsPair(const AliExternalTrackParam *tr0, const AliExter
 
   return kTRUE;  
 }
-Bool_t AliTPCcalibTime::IsCross(const AliESDtrack *const tr0, const AliESDtrack *const tr1){
+Bool_t AliTPCcalibTime::IsCross(const AliVTrack *const tr0, const AliVTrack *const tr1){
   //
   // check if the cosmic pair of tracks crossed A/C side
   // 
@@ -1267,7 +1302,7 @@ Bool_t AliTPCcalibTime::IsCross(const AliESDtrack *const tr0, const AliESDtrack
   return result;
 }
 
-Bool_t AliTPCcalibTime::IsSame(const AliESDtrack *const tr0, const AliESDtrack *const tr1){
+Bool_t AliTPCcalibTime::IsSame(const AliVTrack *const tr0, const AliVTrack *const tr1){
   // 
   // track crossing the CE
   // 0. minimal number of clusters 
@@ -1320,7 +1355,7 @@ Bool_t AliTPCcalibTime::IsSame(const AliESDtrack *const tr0, const AliESDtrack *
 }
 
 
-void  AliTPCcalibTime::ProcessSame(const AliESDtrack *const track, AliESDfriendTrack *const friendTrack, const AliESDEvent *const event){
+void  AliTPCcalibTime::ProcessSame(const AliVTrack *const track, const AliVfriendTrack *const friendTrack, const AliVEvent *const event){
   //
   // Process  TPC tracks crossing CE
   //
@@ -1483,7 +1518,7 @@ void  AliTPCcalibTime::ProcessSame(const AliESDtrack *const track, AliESDfriendT
 
 }
 
-void  AliTPCcalibTime::ProcessAlignITS(AliESDtrack *const track, const AliESDfriendTrack *const friendTrack, const AliESDEvent *const event, AliESDfriend *const esdFriend){
+void  AliTPCcalibTime::ProcessAlignITS(AliVTrack *const track, const AliVfriendTrack *const friendTrack, const AliVEvent *const event, AliVfriendEvent *const friendEvent){
   //
   // Process track - Update TPC-ITS alignment
   // Updates: 
@@ -1512,7 +1547,7 @@ void  AliTPCcalibTime::ProcessAlignITS(AliESDtrack *const track, const AliESDfri
   // 
   Int_t dummycl[1000];
   if (track->GetTPCNcls()<kMinTPC) return;  // minimal amount of clusters cut
-  if (!track->IsOn(AliESDtrack::kTPCrefit)) return;
+  if (!track->IsOn(AliVTrack::kTPCrefit)) return;
   if (!track->GetInnerParam())   return;
   if (!track->GetOuterParam())   return;
   if (track->GetInnerParam()->Pt()<kMinPt)  return;
@@ -1531,17 +1566,17 @@ void  AliTPCcalibTime::ProcessAlignITS(AliESDtrack *const track, const AliESDfri
     AliTracker::PropagateTrackToBxByBz(&pITS2,pTPC.GetX(),0.1,0.1,kFALSE);
   }
 
-  AliESDfriendTrack *itsfriendTrack=0;
+  //AliESDfriendTrack *itsfriendTrack=0;
   //
   // try to find standalone ITS track corresponing to the TPC if possible
   //
   Bool_t hasAlone=kFALSE;
   Int_t ntracks=event->GetNumberOfTracks();
   for (Int_t i=0; i<ntracks; i++){
-    AliESDtrack * trackITS = event->GetTrack(i); 
+    AliVTrack * trackITS = event->GetVTrack(i);
     if (!trackITS) continue;
     if (trackITS->GetITSclusters(dummycl)<kMinITS) continue;  // minimal amount of clusters
-    itsfriendTrack = esdFriend->GetTrack(i);
+    const AliVfriendTrack *itsfriendTrack = friendEvent->GetTrack(i);
     if (!itsfriendTrack) continue;
     if (!itsfriendTrack->GetITSOut()) continue;
      
@@ -1672,7 +1707,7 @@ void  AliTPCcalibTime::ProcessAlignITS(AliESDtrack *const track, const AliESDfri
 
 
 
-void  AliTPCcalibTime::ProcessAlignTRD(AliESDtrack *const track, const AliESDfriendTrack *const friendTrack){
+void  AliTPCcalibTime::ProcessAlignTRD(AliVTrack *const track, const AliVfriendTrack *const friendTrack){
   //
   // Process track - Update TPC-TRD alignment
   // Updates: 
@@ -1703,7 +1738,7 @@ void  AliTPCcalibTime::ProcessAlignTRD(AliESDtrack *const track, const AliESDfri
   if (track->GetTPCNcls()<kMinTPC) return;  // minimal amount of clusters cut
   //  if (!friendTrack->GetTRDIn()) return;  
   //  if (!track->IsOn(AliESDtrack::kTRDrefit)) return;   
-  if (!track->IsOn(AliESDtrack::kTRDout)) return;  
+  if (!track->IsOn(AliVTrack::kTRDout)) return;
   if (!track->GetInnerParam())   return;
   if (!friendTrack->GetTPCOut())   return;
   // exclude crossing track
@@ -1713,7 +1748,7 @@ void  AliTPCcalibTime::ProcessAlignTRD(AliESDtrack *const track, const AliESDfri
   AliTracker::PropagateTrackToBxByBz(&pTPC,kRefX,0.1,0.1,kFALSE);
   AliExternalTrackParam *pTRDtrack = 0; 
   TObject *calibObject=0;
-  for (Int_t l=0;(calibObject=((AliESDfriendTrack*)friendTrack)->GetCalibObject(l));++l) {
+  for (Int_t l=0;(calibObject=friendTrack->GetCalibObject(l));++l) {
     if ((dynamic_cast< AliTPCseed*>(calibObject))) continue;
     if ((pTRDtrack=dynamic_cast< AliExternalTrackParam*>(calibObject))) break;
   }
@@ -1840,7 +1875,7 @@ void  AliTPCcalibTime::ProcessAlignTRD(AliESDtrack *const track, const AliESDfri
 }
 
 
-void  AliTPCcalibTime::ProcessAlignTOF(AliESDtrack *const track, const AliESDfriendTrack *const friendTrack){
+void  AliTPCcalibTime::ProcessAlignTOF(AliVTrack *const track, const AliVfriendTrack *const friendTrack){
   //
   //
   // Process track - Update TPC-TOF alignment
@@ -2193,7 +2228,7 @@ void        AliTPCcalibTime::FillResHistoTPCITS(const AliExternalTrackParam * pT
 }  
 
      
-void        AliTPCcalibTime::FillResHistoTPC(const AliESDtrack * pTrack){
+void        AliTPCcalibTime::FillResHistoTPC(const AliVTrack *pTrack){
   //
   // fill residual histograms pTPC - vertex
   // Histogram is filled only for primary tracks
index ea629f7..265f5f4 100644 (file)
@@ -20,12 +20,17 @@ class TH3F;
 class TH2F;
 class TH1D;
 class TList;
-class AliESDEvent;
-class AliESDtrack;
+//class AliESDEvent;
+class AliVEvent;
+//class AliESDtrack;
+class AliVTrack;
+class AliExternalTrackParam;
 class AliTPCcalibLaser;
 class TGraphErrors;
 class AliSplineFit;
-class AliESDfriendTrack;
+//class AliESDfriendTrack;
+class AliVfriendTrack;
+class AliVfriendEvent;
 
 class AliTPCcalibTime:public AliTPCcalibBase {
 public:
@@ -33,22 +38,26 @@ public:
   AliTPCcalibTime(const Text_t *name, const Text_t *title, UInt_t StartTime, UInt_t EndTime, Int_t deltaIntegrationTimeVdrift, Int_t memoryMode=2);
   virtual ~AliTPCcalibTime();
   
-  virtual void           Process(AliESDEvent *event);
+  virtual void           Process(AliVEvent *event);
   virtual Long64_t       Merge(TCollection *const li);
   virtual void           Analyze();
   //static Bool_t          IsLaser      (const AliESDEvent *const event) const;
   //static Bool_t          IsCosmics    (const AliESDEvent *const event) const;
   //static Bool_t          IsBeam       (const AliESDEvent *const event) const;
-  void                   ProcessLaser (AliESDEvent *event);
-  void                   ProcessCosmic(const AliESDEvent *const event);
-  void                   ProcessBeam  (const AliESDEvent *const event);
+  //void                   ProcessLaser (AliESDEvent *event);
+  //void                   ProcessCosmic(const AliESDEvent *const event);
+  //void                   ProcessBeam  (const AliESDEvent *const event);
+  void                   ProcessLaser (AliVEvent *event);
+  void                   ProcessCosmic(const AliVEvent *const event);
+  void                   ProcessBeam  (const AliVEvent *const event);
+
   Bool_t                 IsPair(const AliExternalTrackParam *tr0, const AliExternalTrackParam *tr1);
-  Bool_t                 IsCross(const AliESDtrack *const tr0, const AliESDtrack *const tr1);
-  Bool_t                 IsSame (const AliESDtrack *const tr0, const AliESDtrack *const tr1);
-  void                   ProcessSame(const AliESDtrack *const track, AliESDfriendTrack *const friendTrack, const AliESDEvent *const event);
-  void                   ProcessAlignITS(AliESDtrack *const track, const AliESDfriendTrack *const friendTrack, const AliESDEvent *const event, AliESDfriend *const ESDfriend);
-  void                   ProcessAlignTRD(AliESDtrack* const track, const AliESDfriendTrack *const friendTrack);
-  void                   ProcessAlignTOF(AliESDtrack* const track, const AliESDfriendTrack *const friendTrack);
+  Bool_t                 IsCross(const AliVTrack *const tr0, const AliVTrack *const tr1);
+  Bool_t                 IsSame (const AliVTrack *const tr0, const AliVTrack *const tr1);
+  void                   ProcessSame(const AliVTrack *const track, const AliVfriendTrack *const friendTrack, const AliVEvent *const event);
+  void                   ProcessAlignITS(AliVTrack *const track, const AliVfriendTrack *const friendTrack, const AliVEvent *const event, AliVfriendEvent *const friendEvent);
+  void                   ProcessAlignTRD(AliVTrack* const track, const AliVfriendTrack *const friendTrack);
+  void                   ProcessAlignTOF(AliVTrack* const track, const AliVfriendTrack *const friendTrack);
 
   THnSparse*    GetHistVdriftLaserA(Int_t index=1) const {return fHistVdriftLaserA[index];};
   THnSparse*    GetHistVdriftLaserC(Int_t index=1) const {return fHistVdriftLaserC[index];};
@@ -59,7 +68,8 @@ public:
   AliSplineFit* GetFitDrift(const char* name);
 //  TObjArray*    GetFitDrift();
   TH1F*         GetCosmiMatchingHisto(Int_t index=0) const {return fCosmiMatchingHisto[index];};
-  void     Process(AliESDtrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);};
+  //void     Process(AliESDtrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);}
+  void     Process(AliVTrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);}
   void     Process(AliTPCseed *track){return AliTPCcalibBase::Process(track);}
   TObjArray* GetAlignITSTPC() const {return fAlignITSTPC;}              // alignemnt array ITS TPC match
   TObjArray* GetAlignTRDTPC() const {return fAlignTRDTPC;}              // alignemnt array TRD TPC match
@@ -77,7 +87,7 @@ public:
   void        BookDistortionMaps();      // book histograms
   void        FillResHistoTPCCE(const AliExternalTrackParam * pTPCIn, const AliExternalTrackParam * pTPCOut );       // fill residual histo
   void        FillResHistoTPCITS(const AliExternalTrackParam * pTPCIn, const AliExternalTrackParam * pITSOut );       // fill residual histo
-  void        FillResHistoTPC(const AliESDtrack * pTrack);
+  void        FillResHistoTPC(const AliVTrack * pTrack);
   void        FillResHistoTPCTRD(const AliExternalTrackParam * pTPCOut, const AliExternalTrackParam * pTRDIn );
   void        FillResHistoTPCTOF(const AliExternalTrackParam * pTPCOut, const AliExternalTrackParam * pTOFIn );
 
index 2245496..8f40175 100644 (file)
@@ -156,11 +156,16 @@ TGaxis *axis = new TGaxis(xmax,ymin,xmax,ymax,ymin,ymax,50510,"+L");
 #include "AliTPCclusterMI.h"
 #include "AliTPCseed.h"
 #include "AliESDVertex.h"
-#include "AliESDEvent.h"
+//#include "AliESDEvent.h"
 #include "AliESDfriend.h"
-#include "AliESDInputHandler.h"
+//#include "AliESDInputHandler.h"
 #include "AliAnalysisManager.h"
 
+#include "AliVEvent.h"
+#include "AliVTrack.h"
+#include "AliVfriendEvent.h"
+#include "AliVfriendTrack.h"
+
 #include "AliTracker.h"
 #include "AliMagF.h"
 #include "AliTPCCalROC.h"
@@ -308,19 +313,27 @@ AliTPCcalibTimeGain::~AliTPCcalibTimeGain(){
 }
 
 
-void AliTPCcalibTimeGain::Process(AliESDEvent *event) {
+void AliTPCcalibTimeGain::Process(AliVEvent *event) {
   //
   // main track loop
   //
+    //Printf("AliTPCcalibTimeGain::Process(event)...");
+
   if (!event) {
-    Printf("ERROR: ESD not available");
+    Printf("ERROR AliTPCcalibTimeGain::Process(): event not available");
     return;
   }
-  AliESDfriend *ESDfriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
-  if (!ESDfriend) {
+
+  AliVfriendEvent *friendEvent=event->FindFriend();
+
+  if (!friendEvent) {
+      Printf("ERROR AliTPCcalibTimeGain::Process(): friendEvent not available");
    return;
   }
-  if (ESDfriend->TestSkipBit()) return;
+  //Printf("friendEvent->TestSkipBit() = %d",friendEvent->TestSkipBit() );
+  if (friendEvent->TestSkipBit()) {
+      return;
+  }
 
   if (fIsCosmic) { // this should be removed at some point based on trigger mask !?
     ProcessCosmicEvent(event);
@@ -328,34 +341,33 @@ void AliTPCcalibTimeGain::Process(AliESDEvent *event) {
     ProcessBeamEvent(event);
   }
   
-
-  
-  
 }
 
 
-void AliTPCcalibTimeGain::ProcessCosmicEvent(AliESDEvent *event) {
+void AliTPCcalibTimeGain::ProcessCosmicEvent(AliVEvent *event) {
   //
   // Process in case of cosmic event
   //
-  AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
-  if (!esdFriend) {
-   Printf("ERROR: ESDfriend not available");
+    //Printf("AliTPCcalibTimeGain::ProcessCosmicEvent(event)...");
+
+  AliVfriendEvent *friendEvent=event->FindFriend();
+  if (!friendEvent) {
+   Printf("ERROR AliTPCcalibTimeGain::ProcessCosmicEvent(): ESDfriend not available");
    return;
   }
   //
   UInt_t time = event->GetTimeStamp();
-  Int_t nFriendTracks = esdFriend->GetNumberOfTracks();
+  Int_t nFriendTracks = friendEvent->GetNumberOfTracks();
   Int_t runNumber = event->GetRunNumber();
   //
   // track loop
   //
   for (Int_t i=0;i<nFriendTracks;++i) {
 
-    AliESDtrack *track = event->GetTrack(i);
+    AliVTrack *track = event->GetVTrack(i);
     if (!track) continue;
-    AliESDfriendTrack *friendTrack = esdFriend->GetTrack(i);
-    if (!friendTrack) continue;        
+    const AliVfriendTrack *friendTrack = friendEvent->GetTrack(i);
+    if (!friendTrack) continue;
     const AliExternalTrackParam * trackIn = track->GetInnerParam();
     const AliExternalTrackParam * trackOut = friendTrack->GetTPCOut();
     if (!trackIn) continue;
@@ -397,28 +409,34 @@ void AliTPCcalibTimeGain::ProcessCosmicEvent(AliESDEvent *event) {
 
 
 
-void AliTPCcalibTimeGain::ProcessBeamEvent(AliESDEvent *event) {
+void AliTPCcalibTimeGain::ProcessBeamEvent(AliVEvent *event) {
   //
   // Process in case of beam event
   //
-  AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
-  if (!esdFriend) {
-   Printf("ERROR: ESDfriend not available");
+    //Printf("AliTPCcalibTimeGain::ProcessBeamEvent(event)...");
+
+  AliVfriendEvent *friendEvent=event->FindFriend();
+  if (!friendEvent) {
+   Printf("ERROR AliTPCcalibTimeGain::ProcessBeamEvent(): ESDfriend not available");
    return;
   }
   //
   UInt_t time = event->GetTimeStamp();
-  Int_t nFriendTracks = esdFriend->GetNumberOfTracks();
+  if (!time) Printf("ERROR: no time stamp available!");
+  Int_t nFriendTracks = friendEvent->GetNumberOfTracks();
   Int_t runNumber = event->GetRunNumber();
   //
   // track loop
   //
   for (Int_t i=0;i<nFriendTracks;++i) { // begin track loop
 
-    AliESDtrack *track = event->GetTrack(i);
-    if (!track) continue;
-    AliESDfriendTrack *friendTrack = esdFriend->GetTrack(i);
-    if (!friendTrack) continue;
+    AliVTrack *track = event->GetVTrack(i);
+    if (!track) {Printf("***ERROR*** : track not available");  continue;}
+    const AliVfriendTrack *friendTrack = friendEvent->GetTrack(i);
+    if (!friendTrack) {
+        Printf("ERROR ProcessBeamEvent(): friendTrack is not available!");
+        continue;
+    }
         
     const AliExternalTrackParam * trackIn = track->GetInnerParam();
     const AliExternalTrackParam * trackOut = friendTrack->GetTPCOut();
@@ -438,13 +456,13 @@ void AliTPCcalibTimeGain::ProcessBeamEvent(AliESDEvent *event) {
     if (TMath::Abs(trackIn->Eta()) > fCutEtaWindow) continue;
     //
     UInt_t status = track->GetStatus();
-    if ((status&AliESDtrack::kTPCrefit)==0) continue;
-    if ((status&AliESDtrack::kITSrefit)==0 && fCutRequireITSrefit) continue; // ITS cluster
+    if ((status&AliVTrack::kTPCrefit)==0) continue;
+    if ((status&AliVTrack::kITSrefit)==0 && fCutRequireITSrefit) continue; // ITS cluster
     //
     Float_t dca[2], cov[3];
     track->GetImpactParameters(dca,cov);
     if (TMath::Abs(dca[0]) > fCutMaxDcaXY || TMath::Abs(dca[0]) < 0.0000001) continue;  // cut in xy
-    if (((status&AliESDtrack::kITSrefit) == 1 && TMath::Abs(dca[1]) > 3.) || TMath::Abs(dca[1]) > fCutMaxDcaZ ) continue;
+    if (((status&AliVTrack::kITSrefit) == 1 && TMath::Abs(dca[1]) > 3.) || TMath::Abs(dca[1]) > fCutMaxDcaZ ) continue;
     //
     Double_t eta = trackIn->Eta();
     
@@ -476,10 +494,12 @@ void AliTPCcalibTimeGain::ProcessBeamEvent(AliESDEvent *event) {
                                                                    fAlephParameters[4]);
        tpcSignal /= corrFactor; 
       }        
+      //Printf("Fill DeDx histo..");
       fHistDeDxTotal->Fill(meanP, tpcSignal);
       //
       //dE/dx, time, type (1-muon cosmic,2-pion beam data, 3&4 protons), momenta, runNumner, eta
       Double_t vec[7] = {tpcSignal,static_cast<Double_t>(time),static_cast<Double_t>(particleCase),meanDrift,meanP,static_cast<Double_t>(runNumber), eta};
+      //Printf("Fill Gain histo in track loop...");
       fHistGainTime->Fill(vec);
     }
     
@@ -488,7 +508,13 @@ void AliTPCcalibTimeGain::ProcessBeamEvent(AliESDEvent *event) {
   // V0 loop -- in beam events the cosmic part of the histogram is filled with GammaConversions
   //
   for(Int_t iv0 = 0; iv0 < event->GetNumberOfV0s(); iv0++) {
-    AliESDv0 * v0 = event->GetV0(iv0);
+    //AliESDv0 * v0 = event->GetV0(iv0);
+     AliESDv0 v0dummy;
+     event->GetV0(v0dummy, iv0);
+     AliESDv0 *v0 = &v0dummy;
+
+     if (!v0) Printf("ERROR AliTPCcalibTimeGain::ProcessBeamEvent(): ESDv0 not available! ");
+
     if (!v0->GetOnFlyStatus()) continue;
     if (v0->GetEffMass(0,0) > 0.02) continue; // select low inv. mass
     Double_t xyz[3];
@@ -499,8 +525,9 @@ void AliTPCcalibTimeGain::ProcessBeamEvent(AliESDEvent *event) {
     //
     for(Int_t idaughter = 0; idaughter < 2; idaughter++) { // daughter loop
       Int_t index = idaughter == 0 ? v0->GetPindex() : v0->GetNindex();
-      AliESDtrack * trackP = event->GetTrack(index);
-      AliESDfriendTrack *friendTrackP = esdFriend->GetTrack(index);
+      AliVTrack * trackP = event->GetVTrack(index);
+      if (!trackP) Printf("***ERROR*** trackP not available!");
+      const AliVfriendTrack *friendTrackP = friendEvent->GetTrack(index);
       if (!friendTrackP) continue;
       const AliExternalTrackParam * trackPIn = trackP->GetInnerParam();
       const AliExternalTrackParam * trackPOut = friendTrackP->GetTPCOut();
@@ -527,7 +554,8 @@ void AliTPCcalibTimeGain::ProcessBeamEvent(AliESDEvent *event) {
        Double_t tpcSignal = GetTPCdEdx(seed);
        //dE/dx, time, type (1-muon cosmic,2-pion beam data), momenta
        Double_t vec[6] = {tpcSignal,static_cast<Double_t>(time),1,meanDrift,meanP,static_cast<Double_t>(runNumber)};
-       fHistGainTime->Fill(vec);
+    //Printf("Fill Gain histo in v0 loop...");
+    fHistGainTime->Fill(vec);
       }
     }
     
index 385417b..ff6becd 100644 (file)
@@ -17,8 +17,10 @@ class TH3F;
 class TH2F;
 class TList;
 class TGraphErrors;
-class AliESDEvent;
-class AliESDtrack;
+//class AliESDEvent;
+class AliVEvent;
+//class AliESDtrack;
+class AliVTrack;
 class AliTPCcalibLaser;
 class AliTPCseed;
 
@@ -31,12 +33,16 @@ public:
   AliTPCcalibTimeGain(const Text_t *name, const Text_t *title, UInt_t StartTime, UInt_t EndTime, Int_t deltaIntegrationTimeGain);
   virtual ~AliTPCcalibTimeGain();
   //
-  virtual void           Process(AliESDEvent *event);
+  //virtual void           Process(AliESDEvent *event);
+  virtual void           Process(AliVEvent *event);
   virtual Long64_t       Merge(TCollection *li);
   virtual void           AnalyzeRun(Int_t minEntries);
   //
-  void                   ProcessCosmicEvent(AliESDEvent *event);
-  void                   ProcessBeamEvent(AliESDEvent *event);
+  //void                   ProcessCosmicEvent(AliESDEvent *event);
+  //void                   ProcessBeamEvent(AliESDEvent *event);
+
+  void                   ProcessCosmicEvent(AliVEvent *event);
+  void                   ProcessBeamEvent(AliVEvent *event);
   //
   void                   CalculateBetheAlephParams(TH2F *hist, Double_t * ini);
   static void            BinLogX(THnSparse *h, Int_t axisDim);
@@ -115,7 +121,7 @@ private:
   //
   AliTPCcalibTimeGain(const AliTPCcalibTimeGain&); 
   AliTPCcalibTimeGain& operator=(const AliTPCcalibTimeGain&); 
-  void     Process(AliESDtrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);};
+  void     Process(AliVTrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);}
   void     Process(AliTPCseed *track){return AliTPCcalibBase::Process(track);}
 
   ClassDef(AliTPCcalibTimeGain, 2);
index 17fb28a..b143214 100644 (file)
@@ -133,9 +133,9 @@ using namespace std;
 #include "AliMagF.h"
 #include "AliTracker.h"
 #include "AliESD.h"
-#include "AliESDtrack.h"
-#include "AliESDfriend.h"
-#include "AliESDfriendTrack.h" 
+//#include "AliESDtrack.h"
+//#include "AliESDfriend.h"
+//#include "AliESDfriendTrack.h"
 #include "AliTPCseed.h"
 #include "AliTPCclusterMI.h"
 #include "AliTPCROC.h"
index e486a1c..5e25f2b 100644 (file)
@@ -35,14 +35,16 @@ class AliTPCClusterParam;
 class TTreeSRedirector;
 class AliTPCROC;
 class AliTPCseed;
-class AliESDtrack;
+//class AliESDtrack;
 class AliTPCclusterMI;
 class AliTPCcalibTracksCuts;
 class AliTPCCalPad;
 class TChain;
 class TTree;
 class TMutex;
-class AliESDEvent;
+//class AliESDEvent;
+class AliVEvent;
+class AliVTrack;
 
 using namespace std;
 
@@ -56,8 +58,10 @@ public :
   virtual ~AliTPCcalibTracks();                // destructor
   
   virtual void            Process(AliTPCseed *track);  // to be called by the Selector
-  void     Process(AliESDEvent *event) {AliTPCcalibBase::Process(event);};
-  void     Process(AliESDtrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);};
+  //void     Process(AliESDEvent *event) {AliTPCcalibBase::Process(event);}
+  void     Process(AliVEvent *event) {AliTPCcalibBase::Process(event);}
+  //void     Process(AliESDtrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);}
+  void     Process(AliVTrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);}
   virtual Long64_t Merge(TCollection *li);
   void    AddHistos(AliTPCcalibTracks* calib);
   void     MakeResPlotsQTree(Int_t minEntries = 100, const char* pathName = "plots");
index e39032a..381d201 100644 (file)
@@ -143,7 +143,7 @@ Int_t AliTPCcalibTracksCuts::AcceptTrack(const AliTPCseed * track) const {
   return 0;
 }
 
-Int_t AliTPCcalibTracksCuts::AcceptTrack(const AliESDtrack * track) const {
+Int_t AliTPCcalibTracksCuts::AcceptTrack(const AliVTrack * track) const {
   //
   // Function, that decides wheather a given track is accepted for 
   // the analysis or not. 
index 519b92e..97a3ea8 100644 (file)
@@ -18,7 +18,7 @@
 
 class TChain;
 class AliTPCseed;
-class AliESDtrack;
+class AliVTrack;
 
 using namespace std;
 
@@ -33,7 +33,7 @@ public:
    static  AliTPCcalibTracksCuts  *CreateCuts(char* ctype);
 
    Int_t AcceptTrack(const AliTPCseed * track) const;
-   Int_t AcceptTrack(const AliESDtrack * track) const;
+   Int_t AcceptTrack(const AliVTrack * track) const;
 
    void SetMinClusters(Int_t minClusters){fMinClusters = minClusters;}
    void SetMinRatio(Float_t minRatio){fMinRatio = minRatio;}
index 545ad0d..242ad98 100644 (file)
@@ -98,8 +98,10 @@ public:
 
 
   TLinearFitter*  GetFitter(UInt_t segment, UInt_t padType, UInt_t fitType);  
-  void     Process(AliESDEvent *event) {AliTPCcalibBase::Process(event);};
-  void     Process(AliESDtrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);};
+  //void     Process(AliESDEvent *event) {AliTPCcalibBase::Process(event);}
+  void     Process(AliVEvent *event) {AliTPCcalibBase::Process(event);}
+  //void     Process(AliESDtrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);}
+  void     Process(AliVTrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);}
   
 public:
   //
index 2cfad02..c67275c 100644 (file)
 
 #include "AliMagF.h"
 #include "AliTracker.h"
-#include "AliESDEvent.h"
+//#include "AliESDEvent.h"
 #include "AliESDtrack.h"
 #include "AliESDfriend.h"
-#include "AliESDfriendTrack.h" 
+#include "AliESDfriendTrack.h"
+#include "AliESDVertex.h"
+
+#include "AliVEvent.h"
+#include "AliVTrack.h"
+#include "AliVfriendTrack.h"
+#include "AliVfriendEvent.h"
+
 #include "AliMathBase.h" 
 #include "AliTPCseed.h"
 #include "AliTPCclusterMI.h"
@@ -55,7 +62,7 @@ AliTPCcalibV0::AliTPCcalibV0() :
    fV0Tree(0),
    fHPTTree(0),
    fStack(0),
-   fESD(0),
+   fEvent(0),
    fPdg(0),
    fParticles(0),
    fV0s(0),
@@ -68,7 +75,7 @@ AliTPCcalibV0::AliTPCcalibV0(const Text_t *name, const Text_t *title):
    fV0Tree(0),
    fHPTTree(0),
    fStack(0),
-   fESD(0),
+   fEvent(0),
    fPdg(0),
    fParticles(0),
    fV0s(0),
@@ -92,43 +99,43 @@ AliTPCcalibV0::~AliTPCcalibV0(){
 
 
 
-void  AliTPCcalibV0::ProcessESD(AliESDEvent *esd){
+void  AliTPCcalibV0::ProcessESD(AliVEvent *event){
   //
   //
   //
-  fESD = esd;
-  AliKFParticle::SetField(esd->GetMagneticField());
+  fEvent = event;
+  AliKFParticle::SetField(event->GetMagneticField());
   if (TMath::Abs(AliTracker::GetBz())<1) return;  
-  DumpToTree(esd);
-  DumpToTreeHPT(esd);
+  DumpToTree(event);
+  DumpToTreeHPT(event);
 }
 
-void  AliTPCcalibV0::DumpToTreeHPT(AliESDEvent *esd){
+void  AliTPCcalibV0::DumpToTreeHPT(AliVEvent *event){
   //
   // Dump V0s fith full firend information to the 
   // 
   if (TMath::Abs(AliTracker::GetBz())<1) return;
   const Int_t kMinCluster=110;
   const Float_t kMinPt   =4.;
-  AliESDfriend *esdFriend=static_cast<AliESDfriend*>(esd->FindListObject("AliESDfriend"));
+  AliVfriendEvent *friendEvent=event->FindFriend();
 //   if (!esdFriend) {
 //     Printf("ERROR: esdFriend not available");
 //     return;
 //   }
   //
-  Int_t ntracks=esd->GetNumberOfTracks();
+  Int_t ntracks=event->GetNumberOfTracks();
   for (Int_t i=0;i<ntracks;++i) {
     Bool_t isOK=kFALSE;
-    AliESDtrack *track = esd->GetTrack(i);
+    AliVTrack *track = event->GetVTrack(i);
     if (track->GetTPCncls()<kMinCluster) continue;
     if (TMath::Abs(AliTracker::GetBz())>1){ // cut on momenta if measured
       if (track->Pt()>kMinPt) isOK=kTRUE;
     }
     if (TMath::Abs(AliTracker::GetBz())<1){  // require primary track for the B field OFF data
       Bool_t isAccepted=kTRUE;
-      if (!track->IsOn(AliESDtrack::kITSrefit)) isAccepted=kFALSE;
-      if (!track->IsOn(AliESDtrack::kTPCrefit)) isAccepted=kFALSE;
-      if (!track->IsOn(AliESDtrack::kTOFout))   isAccepted=kFALSE;
+      if (!track->IsOn(AliVTrack::kITSrefit)) isAccepted=kFALSE;
+      if (!track->IsOn(AliVTrack::kTPCrefit)) isAccepted=kFALSE;
+      if (!track->IsOn(AliVTrack::kTOFout))   isAccepted=kFALSE;
       Float_t dvertex[2],cvertex[3]; 
       track->GetImpactParametersTPC(dvertex,cvertex);
       if (TMath::Abs(dvertex[0]/TMath::Sqrt(cvertex[0]+0.01))>20) isAccepted=kFALSE;
@@ -139,25 +146,25 @@ void  AliTPCcalibV0::DumpToTreeHPT(AliESDEvent *esd){
       if (!isAccepted) isOK=kFALSE;
     } 
     if ( track->GetTPCsignal()>100 && track->GetInnerParam()->Pt()>1 ){
-      if (track->IsOn(AliESDtrack::kITSin)||track->IsOn(AliESDtrack::kTRDout)||track->IsOn(AliESDtrack::kTOFin))
+      if (track->IsOn(AliVTrack::kITSin)||track->IsOn(AliVTrack::kTRDout)||track->IsOn(AliVTrack::kTOFin))
        isOK=kTRUE;
       if (isOK){
        TString filename(AliAnalysisManager::GetAnalysisManager()->GetTree()->GetCurrentFile()->GetName());
-       Int_t eventNumber = esd->GetEventNumberInFile();
-       Bool_t hasFriend=(esdFriend) ? (esdFriend->GetTrack(i)!=0):0; 
+    Int_t eventNumber = event->GetEventNumberInFile();
+    Bool_t hasFriend=(friendEvent) ? (friendEvent->GetTrack(i)!=0):0;
        Bool_t hasITS=(track->GetNcls(0)>2);
        printf("DUMPIONTrack:%s|%f|%d|%d|%d\n",filename.Data(),track->GetInnerParam()->Pt()*track->GetTPCsignal()/50., eventNumber,hasFriend,hasITS);
       }
     }
     if (!isOK) continue;
     TString filename(AliAnalysisManager::GetAnalysisManager()->GetTree()->GetCurrentFile()->GetName());
-    Int_t eventNumber = esd->GetEventNumberInFile();   
-    Bool_t hasFriend=(esdFriend) ? (esdFriend->GetTrack(i)!=0):0;
+    Int_t eventNumber = event->GetEventNumberInFile();
+    Bool_t hasFriend=(friendEvent) ? (friendEvent->GetTrack(i)!=0):0;
     Bool_t hasITS=(track->GetNcls(0)>2);    
     printf("DUMPHPTTrack:%s|%f|%d|%d|%d\n",filename.Data(),track->Pt(), eventNumber,hasFriend,hasITS);
     //
-    if (!esdFriend) continue;
-    AliESDfriendTrack *friendTrack = esdFriend->GetTrack(i);
+    if (!friendEvent) continue;
+    const AliVfriendTrack *friendTrack = friendEvent->GetTrack(i);
     if (!friendTrack) continue;
 
     if (!isOK) continue;
@@ -173,15 +180,24 @@ void  AliTPCcalibV0::DumpToTreeHPT(AliESDEvent *esd){
       fHPTTree = new TTree("HPT","HPT");
       fHPTTree->SetDirectory(0);
     }
+
+      //**********************TEMPORARY!!*******************************************
+      // more investigation is needed with Tree ///!!!
+      //all dummy stuff here is just for code to compile and work with ESD
+
+      AliESDfriendTrack *dummyfriendTrack=(AliESDfriendTrack*)friendTrack;
+      AliESDtrack *dummytrack=(AliESDtrack*)track;
+
+
     if (fHPTTree->GetEntries()==0){
       //
       fHPTTree->SetDirectory(0);
-      fHPTTree->Branch("t.",&track);
-      fHPTTree->Branch("ft.",&friendTrack);
+      fHPTTree->Branch("t.",&dummytrack);
+      fHPTTree->Branch("ft.",&dummyfriendTrack);
       fHPTTree->Branch("s.",&seed);
     }else{
-      fHPTTree->SetBranchAddress("t.",&track);
-      fHPTTree->SetBranchAddress("ft.",&friendTrack);
+      fHPTTree->SetBranchAddress("t.",&dummytrack);
+      fHPTTree->SetBranchAddress("ft.",&dummyfriendTrack);
       fHPTTree->SetBranchAddress("s.",&seed);
     }
     fHPTTree->Fill();
@@ -191,23 +207,26 @@ void  AliTPCcalibV0::DumpToTreeHPT(AliESDEvent *esd){
 
 
 
-void  AliTPCcalibV0::DumpToTree(AliESDEvent *esd){
+void  AliTPCcalibV0::DumpToTree(AliVEvent *event){
   //
   // Dump V0s fith full firend information to the 
   // 
-  Int_t nV0s  = fESD->GetNumberOfV0s();
+  Int_t nV0s  = fEvent->GetNumberOfV0s();
   const Int_t kMinCluster=110;
   const Double_t kDownscale=0.01;
   const Float_t kMinPt   =1.0;
   const Float_t kMinMinPt   =0.7;
-  AliESDfriend *esdFriend=static_cast<AliESDfriend*>(esd->FindListObject("AliESDfriend"));
+  AliVfriendEvent *friendEvent=event->FindFriend();
   //
   
   for (Int_t ivertex=0; ivertex<nV0s; ivertex++){
     Bool_t isOK=kFALSE;
-    AliESDv0 * v0 = (AliESDv0*) esd->GetV0(ivertex);
-    AliESDtrack * track0 = fESD->GetTrack(v0->GetIndex(0)); // negative track
-    AliESDtrack * track1 = fESD->GetTrack(v0->GetIndex(1)); // positive track 
+    AliESDv0 dummyv0;
+    event->GetV0(dummyv0,ivertex);
+    AliESDv0 *v0=&dummyv0;
+
+    AliVTrack * track0 = fEvent->GetVTrack(v0->GetIndex(0)); // negative track
+    AliVTrack * track1 = fEvent->GetVTrack(v0->GetIndex(1)); // positive track
     if (track0->GetTPCNcls()<kMinCluster) continue;
     if (track0->GetKinkIndex(0)>0) continue;    
     if (track1->GetTPCNcls()<kMinCluster) continue;
@@ -222,17 +241,17 @@ void  AliTPCcalibV0::DumpToTree(AliESDEvent *esd){
     if (!isOK) continue;
     //
     TString filename(AliAnalysisManager::GetAnalysisManager()->GetTree()->GetCurrentFile()->GetName());
-    Int_t eventNumber = esd->GetEventNumberInFile();
+    Int_t eventNumber = event->GetEventNumberInFile();
     Bool_t hasITS=(track0->GetNcls(0)+ track1->GetNcls(0)>4);
-    printf("DUMPHPTV0:%s|%f|%d|%d|%d\n",filename.Data(), (TMath::Min(track0->Pt(),track1->Pt())), eventNumber,(esdFriend!=0), hasITS);
+    printf("DUMPHPTV0:%s|%f|%d|%d|%d\n",filename.Data(), (TMath::Min(track0->Pt(),track1->Pt())), eventNumber,(friendEvent!=0), hasITS);
     //
-    if (!esdFriend) continue;
+    if (!friendEvent) continue;
     //
     
     //
-    AliESDfriendTrack *ftrack0 = esdFriend->GetTrack(v0->GetIndex(0));
+    const AliVfriendTrack *ftrack0 = friendEvent->GetTrack(v0->GetIndex(0));
     if (!ftrack0) continue;
-    AliESDfriendTrack *ftrack1 = esdFriend->GetTrack(v0->GetIndex(1));
+    const AliVfriendTrack *ftrack1 = friendEvent->GetTrack(v0->GetIndex(1));
     if (!ftrack1) continue;
     //
     TObject *calibObject;
@@ -256,22 +275,32 @@ void  AliTPCcalibV0::DumpToTree(AliESDEvent *esd){
       fV0Tree = new TTree("V0s","V0s");
       fV0Tree->SetDirectory(0);
     }
+
+    //**********************TEMPORARY!!*******************************************
+    // more investigation is needed with Tree ///!!!
+    //all dummy stuff here is just for code to compile and work with ESD
+
+    AliESDfriendTrack *dummyftrack0=(AliESDfriendTrack*)ftrack0;
+    AliESDfriendTrack *dummyftrack1=(AliESDfriendTrack*)ftrack1;
+    AliESDtrack *dummytrack0=(AliESDtrack*)track0;
+    AliESDtrack *dummytrack1=(AliESDtrack*)track1;
+
     if (fV0Tree->GetEntries()==0){
       //
       fV0Tree->SetDirectory(0);
       fV0Tree->Branch("v0.",&v0);
-      fV0Tree->Branch("t0.",&track0);
-      fV0Tree->Branch("t1.",&track1);
-      fV0Tree->Branch("ft0.",&ftrack0);
-      fV0Tree->Branch("ft1.",&ftrack1);
+      fV0Tree->Branch("t0.",&dummytrack0);
+      fV0Tree->Branch("t1.",&dummytrack1);
+      fV0Tree->Branch("ft0.",&dummyftrack0);
+      fV0Tree->Branch("ft1.",&dummyftrack1);
       fV0Tree->Branch("s0.",&seed0);
       fV0Tree->Branch("s1.",&seed1);
     }else{
       fV0Tree->SetBranchAddress("v0.",&v0);
-      fV0Tree->SetBranchAddress("t0.",&track0);
-      fV0Tree->SetBranchAddress("t1.",&track1);
-      fV0Tree->SetBranchAddress("ft0.",&ftrack0);
-      fV0Tree->SetBranchAddress("ft1.",&ftrack1);
+      fV0Tree->SetBranchAddress("t0.",&dummytrack0);
+      fV0Tree->SetBranchAddress("t1.",&dummytrack1);
+      fV0Tree->SetBranchAddress("ft0.",&dummyftrack0);
+      fV0Tree->SetBranchAddress("ft1.",&dummyftrack1);
       fV0Tree->SetBranchAddress("s0.",&seed0);
       fV0Tree->SetBranchAddress("s1.",&seed1);
     }
@@ -885,7 +914,7 @@ void AliTPCcalibV0::BinLogX(TH2F *h) {
 
 
 
-void AliTPCcalibV0::FilterV0s(AliESDEvent* event){
+void AliTPCcalibV0::FilterV0s(AliVEvent *event){
   //
   // 
   TDatabasePDG pdg;  
@@ -894,12 +923,26 @@ void AliTPCcalibV0::FilterV0s(AliESDEvent* event){
   const Double_t ptCut=0.2;
   const Int_t kMinNcl=110;
   //
-  Int_t nv0 = event->GetNumberOfV0s(); 
-  AliESDVertex *vertex= (AliESDVertex *)event->GetPrimaryVertex();
+  Int_t nv0 = event->GetNumberOfV0s();
+  //AliESDVertex *vertex= (AliESDVertex *)event->GetPrimaryVertex();
+  //AliKFVertex kfvertex=*vertex;
+
+  //AliESDVertex vtx;
+  //event->GetPrimaryVertex(vtx);
+  //AliESDVertex *vertex=&vtx;
+  //AliKFVertex *kfvertex=(AliKFVertex*)vertex;
+
+  AliESDVertex vtx;
+  event->GetPrimaryVertex(vtx);
+  AliESDVertex *vertex=&vtx;
   AliKFVertex kfvertex=*vertex;
+
   //
   for (Int_t iv0=0;iv0<nv0;iv0++){
-    AliESDv0 *v0 = event->GetV0(iv0);
+    AliESDv0 dummyv0;
+    event->GetV0(dummyv0,iv0);
+    AliESDv0 *v0=&dummyv0;
+
     if (!v0) continue;
     if (v0->GetPindex()<0) continue;
     if (v0->GetNindex()<0) continue;
@@ -933,8 +976,8 @@ void AliTPCcalibV0::FilterV0s(AliESDEvent* event){
 
     Double_t sign= v0->GetParamP()->GetSign()* v0->GetParamN()->GetSign();
     if (sign<0&&v0->GetOnFlyStatus()>0.5&&maxPt>ptCut&&isV0){
-      AliESDtrack * trackP = event->GetTrack(v0->GetPindex());
-      AliESDtrack * trackN = event->GetTrack(v0->GetNindex());
+      AliVTrack * trackP = event->GetVTrack(v0->GetPindex());
+      AliVTrack * trackN = event->GetVTrack(v0->GetNindex());
       if (!trackN) continue;
       if (!trackP) continue;
       Int_t nclP= (Int_t)trackP->GetTPCClusterInfo(2,1);
@@ -949,7 +992,7 @@ void AliTPCcalibV0::FilterV0s(AliESDEvent* event){
          "tp.="<<trackP<<
          "tm.="<<trackN<<
          //
-         "v.="<<vertex<<
+      //"v.="<<vertex<<
          "ncls="<<ncls<<
          "maxPt="<<maxPt<<
          "\n";        
index df7a7c2..92cdefd 100644 (file)
@@ -8,8 +8,10 @@
 class TTreeSRedirector;
 class AliTPCROC;
 class AliTPCseed;
-class AliESDtrack;
-class AliESDEvent;
+//class AliESDtrack;
+//class AliESDEvent;
+class AliVEvent;
+class AliVTrack;
 class TH3F;
 class TH1F;
 class TH2F;
@@ -32,8 +34,8 @@ public :
   AliTPCcalibV0();
   AliTPCcalibV0(const Text_t *name, const Text_t *title);
   virtual ~AliTPCcalibV0();
-  virtual void     Process(AliESDEvent *event) {return ProcessESD(event);}
-  void FilterV0s(AliESDEvent* event);
+  virtual void     Process(AliVEvent *event) {return ProcessESD(event);}
+  void FilterV0s(AliVEvent* event);
   Long64_t Merge(TCollection *const li);
   void AddTree(TTree * treeInput);
   void AddTreeHPT(TTree * treeInput);
@@ -43,9 +45,9 @@ public :
   //
   //
   //
-  void ProcessESD(AliESDEvent *esd);
-  void DumpToTree(AliESDEvent *esd);
-  void DumpToTreeHPT(AliESDEvent *esd);
+  void ProcessESD(AliVEvent *event);
+  void DumpToTree(AliVEvent *event);
+  void DumpToTreeHPT(AliVEvent *event);
   TTree * GetV0Tree(){return fV0Tree;}
   TTree * GetHPTTree(){return fHPTTree;}
   //  
@@ -68,13 +70,14 @@ private:
   TTree          *fHPTTree;      // tree with high mometa tracks - full calib info
   //
   AliStack       *fStack;        // pointer to kinematic tree        
-  AliESDEvent    *fESD;              //! current ED to proccess - NOT OWNER
+  AliVEvent      *fEvent;              //! current ED to proccess - NOT OWNER
   TDatabasePDG   *fPdg;              //! particle database
   TObjArray      *fParticles;         // array of selected MC particles
   TObjArray      *fV0s;               // array of V0s
   TObjArray      *fGammas;           // gamma conversion candidates
   //
-  void     Process(AliESDtrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);};
+  //void     Process(AliESDtrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);}
+  void     Process(AliVTrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);}
   void     Process(AliTPCseed *track){return AliTPCcalibBase::Process(track);}  
   //       
   ClassDef(AliTPCcalibV0,3);