Removing temorary some changes to be able to merge with the master
authorhristov <Peter.Hristov@cern.ch>
Thu, 6 Nov 2014 11:33:05 +0000 (12:33 +0100)
committerhristov <Peter.Hristov@cern.ch>
Thu, 6 Nov 2014 11:33:05 +0000 (12:33 +0100)
25 files changed:
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 c543f08..28b74cd 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"
@@ -47,8 +40,8 @@ ClassImp(AliTPCAnalysisTaskcalib)
 AliTPCAnalysisTaskcalib::AliTPCAnalysisTaskcalib()
   :AliAnalysisTask(),
    fCalibJobs(0),
-   fEvent(0),
-   fEventFriend(0),
+   fESD(0),
+   fESDfriend(0),
    fDebugOutputPath("")
 {
   //
@@ -61,8 +54,8 @@ AliTPCAnalysisTaskcalib::AliTPCAnalysisTaskcalib()
 AliTPCAnalysisTaskcalib::AliTPCAnalysisTaskcalib(const char *name) 
   :AliAnalysisTask(name,""),
    fCalibJobs(0),
-   fEvent(0),
-   fEventFriend(0),
+   fESD(0),
+   fESDfriend(0),
    fDebugOutputPath("")
 {
   //
@@ -91,26 +84,23 @@ void AliTPCAnalysisTaskcalib::Exec(Option_t *) {
   //
   // Exec function
   // Loop over tracks and call  Process function
-    //Printf("AliTPCAnalysisTaskcalib::Exec()...");
-
-  if (!fEvent) {
-    Printf("ERROR AliTPCAnalysisTaskcalib::Exec(): fEvent not available");
+  if (!fESD) {
+    //Printf("ERROR: fESD not available");
     return;
   }
-  fEventFriend=fEvent->FindFriend();
-  //fESDfriend=fESD->FindFriend();
-  Int_t n=fEvent->GetNumberOfTracks();
-  Process(fEvent);
-  if (!fEventFriend) {
-    //Printf("ERROR AliTPCAnalysisTaskcalib::Exec(): fEventFriend not available");
+  fESDfriend=static_cast<AliESDfriend*>(fESD->FindListObject("AliESDfriend"));
+  Int_t n=fESD->GetNumberOfTracks();
+  Process(fESD);
+  if (!fESDfriend) {
+    //Printf("ERROR: fESDfriend not available");
     return;
   }
-  if (fEventFriend->TestSkipBit()) return;
+  if (fESDfriend->TestSkipBit()) return;
   //
-  Int_t run = fEvent->GetRunNumber();
+  Int_t run = fESD->GetRunNumber();
   for (Int_t i=0;i<n;++i) {
-    const AliVfriendTrack *friendTrack=fEventFriend->GetTrack(i);
-    AliVTrack *track=fEvent->GetVTrack(i);
+    AliESDfriendTrack *friendTrack=fESDfriend->GetTrack(i);
+    AliESDtrack *track=fESD->GetTrack(i);
     TObject *calibObject=0;
     AliTPCseed *seed=0;
     if (!friendTrack) continue;
@@ -132,13 +122,12 @@ void AliTPCAnalysisTaskcalib::ConnectInputData(Option_t *) {
     //Printf("ERROR: Could not read chain from input slot 0");
   } 
   else {
-    //AliESDInputHandler *esdH = dynamic_cast<AliESDInputHandler*> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
-    AliVEventHandler *esdH = AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler();
+    AliESDInputHandler *esdH = dynamic_cast<AliESDInputHandler*> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
     if (!esdH) {
-      Printf("ERROR: Could not get ESDInputHandler");
+      //Printf("ERROR: Could not get ESDInputHandler");
     } 
     else {
-      fEvent = esdH->GetEvent();
+      fESD = esdH->GetEvent();
       //Printf("*** CONNECTED NEW EVENT ****");
     }
   }
@@ -184,11 +173,10 @@ void AliTPCAnalysisTaskcalib::FinishTaskOutput()
 }
 
 
-void AliTPCAnalysisTaskcalib::Process(AliVEvent *event) {
+void AliTPCAnalysisTaskcalib::Process(AliESDEvent *event) {
   //
   // Process ESD event
   //
-    //Printf("AliTPCAnalysisTaskcalib::Process(event)...");
   AliTPCcalibBase *job=0;
   Int_t njobs = fCalibJobs->GetEntriesFast();
   for (Int_t i=0;i<njobs;i++){
@@ -205,7 +193,6 @@ 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++){
@@ -216,11 +203,10 @@ void AliTPCAnalysisTaskcalib::Process(AliTPCseed *track) {
   }
 }
 
-void AliTPCAnalysisTaskcalib::Process(AliVTrack *track, Int_t run) {
+void AliTPCAnalysisTaskcalib::Process(AliESDtrack *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 c14d232..0d0f973 100644 (file)
 #include "AliAnalysisTask.h"
 #include "TObjArray.h"
 #include "AliTPCcalibBase.h"
-//class AliESDEvent;
-//class AliESDtrack;
-//class AliESDfriend;
-class AliVEvent;
-class AliVTrack;
-class AliVfriendEvent;
-
+class AliESDEvent;
+class AliESDtrack;
+class AliESDfriend;
 class AliTPCseed;
 
 class AliTPCAnalysisTaskcalib:public AliAnalysisTask {
@@ -35,16 +31,16 @@ public:
   virtual void FinishTaskOutput();
   void         SetDebugOuputhPath(const char * name){fDebugOutputPath=name;}
 protected:
-  virtual void     Process(AliVEvent *event);
+  virtual void     Process(AliESDEvent *event);
   virtual void     Process(AliTPCseed *track);
-  virtual void     Process(AliVTrack *track, Int_t run);
+  virtual void     Process(AliESDtrack *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?
-  AliVEvent *fEvent;         //! current event
-  AliVfriendEvent *fEventFriend;  //! current event friend
+  AliESDEvent *fESD;         //! current esd
+  AliESDfriend *fESDfriend;  //! current esd friend
   TString      fDebugOutputPath; // debug output path   
   AliTPCAnalysisTaskcalib(const AliTPCAnalysisTaskcalib&);
   AliTPCAnalysisTaskcalib& operator=(const AliTPCAnalysisTaskcalib&);
index 1b89f15..a130e06 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"
@@ -455,7 +449,7 @@ AliTPCcalibAlign::~AliTPCcalibAlign() {
 
 }
 
-void AliTPCcalibAlign::Process(AliVEvent *event) {
+void AliTPCcalibAlign::Process(AliESDEvent *event) {
   //
   // Process pairs of cosmic tracks
   //
@@ -467,10 +461,9 @@ void AliTPCcalibAlign::Process(AliVEvent *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"));
-  AliVfriendEvent *friendEvent=event->FindFriend();
-  if (!friendEvent) return;
-  if (friendEvent->TestSkipBit()) return;
+  AliESDfriend *eESDfriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
+  if (!eESDfriend) return;
+  if (eESDfriend->TestSkipBit()) return;
   Int_t ntracks=event->GetNumberOfTracks(); 
   Float_t dca0[2];
   Float_t dca1[2];
@@ -479,23 +472,21 @@ void AliTPCcalibAlign::Process(AliVEvent *event) {
   // process seeds
   //
   for (Int_t i0=0;i0<ntracks;++i0) {
-    AliVTrack *track0 = event->GetVTrack(i0);
-    if(!track0) continue;
-    //AliESDfriendTrack *friendTrack = 0;
+    AliESDtrack *track0 = event->GetTrack(i0);
+    AliESDfriendTrack *friendTrack = 0;
     TObject *calibObject=0;
     AliTPCseed *seed0 = 0;
     //
-    //friendTrack = (AliESDfriendTrack *)friendEvent->GetTrack(i0);;
-    const AliVfriendTrack *friendTrack = friendEvent->GetTrack(i0);;
+    friendTrack = (AliESDfriendTrack *)eESDfriend->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=const_cast<AliVfriendTrack*>(friendTrack);
+    fCurrentFriendTrack=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);
@@ -507,16 +498,14 @@ void AliTPCcalibAlign::Process(AliVEvent *event) {
   //
   //select pairs - for alignment  
   for (Int_t i0=0;i0<ntracks;++i0) {
-      AliVTrack *track0 = event->GetVTrack(i0);
-      if(!track0) continue;
+    AliESDtrack *track0 = event->GetTrack(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;
-      AliVTrack *track1 = event->GetVTrack(i1);
-      if(!track1) continue;
+      AliESDtrack *track1 = event->GetTrack(i1);
       //      if (track1->GetTPCNcls()<kminCl) continue;
       track1->GetImpactParameters(dca1[0],dca1[1]);
       // fast cuts on dca and theta
@@ -524,18 +513,18 @@ void AliTPCcalibAlign::Process(AliVEvent *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; ///!!! then it was used twice, cannot be const pointer
+      AliESDfriendTrack *friendTrack = 0;
       TObject *calibObject=0;
       AliTPCseed *seed0 = 0,*seed1=0;
       //
-      const AliVfriendTrack *friendTrack0 = friendEvent->GetTrack(i0);;
-      if (!friendTrack0) continue;
-      for (Int_t l=0;(calibObject=friendTrack0->GetCalibObject(l));++l) {
+      friendTrack = (AliESDfriendTrack *)eESDfriend->GetTrack(i0);;
+      if (!friendTrack) continue;
+      for (Int_t l=0;(calibObject=friendTrack->GetCalibObject(l));++l) {
        if ((seed0=dynamic_cast<AliTPCseed*>(calibObject))) break;
       }
-      const AliVfriendTrack *friendTrack1 = friendEvent->GetTrack(i1);;
-      if (!friendTrack1) continue;
-      for (Int_t l=0;(calibObject=friendTrack1->GetCalibObject(l));++l) {
+      friendTrack = (AliESDfriendTrack *)eESDfriend->GetTrack(i1);;
+      if (!friendTrack) continue;
+      for (Int_t l=0;(calibObject=friendTrack->GetCalibObject(l));++l) {
        if ((seed1=dynamic_cast<AliTPCseed*>(calibObject))) break;
       }
       if (!seed0) continue;
@@ -619,15 +608,13 @@ void AliTPCcalibAlign::Process(AliVEvent *event) {
   }
 }
 
-void  AliTPCcalibAlign::ExportTrackPoints(AliVEvent *event){
+void  AliTPCcalibAlign::ExportTrackPoints(AliESDEvent *event){
   //
   // Export track points for alignment - calibration
   // export space points for pairs of tracks if possible
   //
-  //AliESDfriend *eESDfriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
-  AliVfriendEvent *friendEvent=event->FindFriend();
-
-  if (!friendEvent) return;
+  AliESDfriend *eESDfriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
+  if (!eESDfriend) 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
@@ -642,13 +629,10 @@ void  AliTPCcalibAlign::ExportTrackPoints(AliVEvent *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
-  AliESDVertex *tpcVertex;
-  AliESDVertex tpcVtx;
+  const AliESDVertex *tpcVertex = 0;
   // get the primary vertex TPC
   if (ntracks>kMinVertexTracks) {
-    event->GetPrimaryVertexSPD(tpcVtx);
-    tpcVertex=&tpcVtx;
-    //event->GetPrimaryVertexSPD(tpcVertex);
+    tpcVertex = event->GetPrimaryVertexSPD();
     if (tpcVertex->GetNContributors()<kMinVertexTracks) tpcVertex=0;
   }
   //
@@ -657,26 +641,15 @@ void  AliTPCcalibAlign::ExportTrackPoints(AliVEvent *event){
   Int_t index0=0,index1=0;
   //
   for (Int_t i0=0;i0<ntracks;++i0) {
-    AliVTrack *track0 = event->GetVTrack(i0);
+    AliESDtrack *track0 = event->GetTrack(i0);
     if (!track0) continue;
-    if ((track0->GetStatus() & AliVTrack::kTPCrefit)==0) continue;
-
-    AliExternalTrackParam trck0Out;
-    track0->GetTrackParamOp(trck0Out);
-    if ( (track0->GetTrackParamOp(trck0Out)) < 0) continue;
-    AliExternalTrackParam * track0Out = &trck0Out;
-    if (!track0Out) continue;
-
-    AliExternalTrackParam trck0In;
-    track0->GetTrackParamIp(trck0In);
-    if((track0->GetTrackParamIp(trck0In)) < 0) continue;
-    AliExternalTrackParam * track0In = &trck0In;
-    if (!track0In) continue;
-
-    if (TMath::Abs(track0In->GetSigned1Pt()-track0Out->GetSigned1Pt())>kDist1Pt) continue;
-    if (TMath::Abs(track0In->GetSigned1Pt())>kDist1Pt) continue;
-    if (TMath::Abs(track0In->GetTgl()-track0Out->GetTgl())>kDistThS) continue;
-    AliVTrack *track1P = 0;
+    if ((track0->GetStatus() & AliESDtrack::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;
     if (track0->GetTPCNcls()<kminCl) continue;
     track0->GetImpactParameters(dca0[0],dca0[1]);
     index0=i0;
@@ -684,26 +657,15 @@ void  AliTPCcalibAlign::ExportTrackPoints(AliVEvent *event){
     //
     if (ntracks<kMaxTracks) for (Int_t i1=i0+1;i1<ntracks;++i1) {
       if (i0==i1) continue;
-      AliVTrack *track1 = event->GetVTrack(i1);
+      AliESDtrack *track1 = event->GetTrack(i1);
       if (!track1) continue;
-      if ((track1->GetStatus() & AliVTrack::kTPCrefit)==0) continue;
-
-      AliExternalTrackParam trck1Out;
-      track1->GetTrackParamOp(trck1Out);
-      if((track1->GetTrackParamOp(trck1Out)) < 0) continue;
-      AliExternalTrackParam * track1Out = &trck1Out;
-      if (!track1Out) continue;
-
-      AliExternalTrackParam trck1In;
-      track1->GetTrackParamIp(trck1In);
-      if((track1->GetTrackParamIp(trck1In)) < 0) continue;
-      AliExternalTrackParam * track1In = &trck1In;
-      if (!track1In) continue;
-
+      if ((track1->GetStatus() & AliESDtrack::kTPCrefit)==0) continue;
+      if (track1->GetOuterParam()==0) continue;
+      if (track1->GetInnerParam()==0) continue;
       if (track1->GetTPCNcls()<kminCl) continue;
-      if (TMath::Abs(track1In->GetSigned1Pt()-track1Out->GetSigned1Pt())>kDist1Pt) continue;
-      if (TMath::Abs(track1In->GetTgl()-track1Out->GetTgl())>kDistThS) continue;
-      if (TMath::Abs(track1In->GetSigned1Pt())>kDist1Pt) continue;
+      if (TMath::Abs(track1->GetInnerParam()->GetSigned1Pt()-track1->GetOuterParam()->GetSigned1Pt())>kDist1Pt) continue;
+      if (TMath::Abs(track1->GetInnerParam()->GetTgl()-track1->GetOuterParam()->GetTgl())>kDistThS) continue;
+      if (TMath::Abs(track1->GetInnerParam()->GetSigned1Pt())>kDist1Pt) continue;
       //track1->GetImpactParameters(dca1[0],dca1[1]);
       //if (TMath::Abs(dca1[0]-dca0[0])>kDistY) continue;
       //if (TMath::Abs(dca1[1]-dca0[1])>kDistZ) continue;
@@ -712,20 +674,19 @@ void  AliTPCcalibAlign::ExportTrackPoints(AliVEvent *event){
       track1P = track1;
       index1=i1;
     }
-    //AliESDfriendTrack *friendTrack = 0;
+    AliESDfriendTrack *friendTrack = 0;
     TObject *calibObject=0;
     AliTPCseed *seed0 = 0,*seed1=0;
     //
-    //friendTrack = (AliESDfriendTrack *)friendEvent->GetTrack(index0);;
-    const AliVfriendTrack *friendTrack = friendEvent->GetTrack(index0);;
+    friendTrack = (AliESDfriendTrack *)eESDfriend->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){
-      const AliVfriendTrack *friendTrack1 = friendEvent->GetTrack(index1);;
-      if (!friendTrack1) continue;
-      for (Int_t l=0;(calibObject=friendTrack1->GetCalibObject(l));++l) {
+      friendTrack = (AliESDfriendTrack *)eESDfriend->GetTrack(index1);;
+      if (!friendTrack) continue;
+      for (Int_t l=0;(calibObject=friendTrack->GetCalibObject(l));++l) {
        if ((seed1=dynamic_cast<AliTPCseed*>(calibObject))) break;
       }
     }
@@ -784,30 +745,20 @@ void  AliTPCcalibAlign::ExportTrackPoints(AliVEvent *event){
       Bool_t isVertex=(tpcVertex)? kTRUE:kFALSE;
       Double_t tof0=track0->GetTOFsignal();
       Double_t tof1=(track1P) ?  track1P->GetTOFsignal(): 0;
-      static AliExternalTrackParam param;
-      AliExternalTrackParam *p0In  = &param;
-      AliExternalTrackParam *p1In  = &param;
-      AliExternalTrackParam *p0Out = &param;
-      AliExternalTrackParam *p1Out = &param;
+      static AliExternalTrackParam dummy;
+      AliExternalTrackParam *p0In  = &dummy;
+      AliExternalTrackParam *p1In  = &dummy;
+      AliExternalTrackParam *p0Out = &dummy;
+      AliExternalTrackParam *p1Out = &dummy;
       AliESDVertex vdummy;
       AliESDVertex *pvertex= (tpcVertex)? (AliESDVertex *)tpcVertex: &vdummy;
       if (track0) {
-    //p0In= new AliExternalTrackParam(*track0);
-    p0In->CopyFromVTrack(track0);
-
-    AliExternalTrackParam trckOut;
-    track0->GetTrackParamOp(trckOut);
-    AliExternalTrackParam * trackout = &trckOut;
-    p0Out=new AliExternalTrackParam(*trackout);
+       p0In= new AliExternalTrackParam(*track0);
+       p0Out=new AliExternalTrackParam(*(track0->GetOuterParam()));
       }
       if (track1P) {
-    //p1In= new AliExternalTrackParam(*track1P);
-    p1In->CopyFromVTrack(track1P);
-
-    AliExternalTrackParam trck1POut;
-    track1P->GetTrackParamOp(trck1POut);
-    AliExternalTrackParam * track1POut = &trck1POut;
-    p1Out=new AliExternalTrackParam(*track1POut);
+       p1In= new AliExternalTrackParam(*track1P);
+       p1Out=new AliExternalTrackParam(*(track1P->GetOuterParam()));
       }
 
       (*cstream)<<"trackPoints"<<
@@ -2658,12 +2609,7 @@ void AliTPCcalibAlign::UpdateClusterDeltaField(const AliTPCseed * seed){
   // 4. Combine In and Out track - - fil cluster residuals
   //
   if (!fCurrentFriendTrack) return;
-
-  AliExternalTrackParam trckTPCOut;
-  fCurrentFriendTrack->GetTrackParamTPCOut(trckTPCOut);
-  if((fCurrentFriendTrack->GetTrackParamTPCOut(trckTPCOut)) < 0) return;
-  AliExternalTrackParam * trackTPCOut = &trckTPCOut;
-  if (!trackTPCOut) return;
+  if (!fCurrentFriendTrack->GetTPCOut()) return;
   const Double_t kPtCut=1.0;    // pt
   const Double_t kSnpCut=0.2; // snp cut
   const Double_t kNclCut=120; //
@@ -2696,13 +2642,8 @@ void AliTPCcalibAlign::UpdateClusterDeltaField(const AliTPCseed * seed){
   Int_t detector=-1;
   //
   //
-  //AliExternalTrackParam trackIn  = *(fCurrentTrack->GetInnerParam());
-  AliExternalTrackParam trackIn;
-  fCurrentTrack->GetTrackParamIp(trackIn);
-  //AliExternalTrackParam trackOut = *(fCurrentFriendTrack->GetTPCOut());
-  AliExternalTrackParam trackOut;
-  fCurrentFriendTrack->GetTrackParamTPCOut(trackOut);
-
+  AliExternalTrackParam trackIn  = *(fCurrentTrack->GetInnerParam());
+  AliExternalTrackParam trackOut = *(fCurrentFriendTrack->GetTPCOut());
   trackIn.ResetCovariance(10);
   trackOut.ResetCovariance(10);
   Double_t *covarIn = (Double_t*)trackIn.GetCovariance();
@@ -2932,10 +2873,7 @@ 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);
-  AliESDVertex vtx;
-  fCurrentEvent->GetPrimaryVertexTracks(vtx);
-  const AliESDVertex* vertex=&vtx;
-
+  const AliESDVertex* vertex = fCurrentEvent->GetPrimaryVertexTracks();
   vertex->GetXYZ(vPosG.GetMatrixArray());
   fCurrentTrack->GetImpactParameters(vImpact[0],vImpact[1]);  // track impact parameters
   //
index 3134467..c48d1bf 100644 (file)
@@ -23,7 +23,6 @@ class TTree;
 class AliExternalTrackParam;
 class AliTPCPointCorrection;
 class AliTPCseed;
-class AliVEvent;
 
 class AliTPCcalibAlign:public AliTPCcalibBase {
 public:
@@ -36,13 +35,13 @@ public:
   AliTPCcalibAlign(const AliTPCcalibAlign &align);
   //
   virtual ~AliTPCcalibAlign();
-  void     Process(AliVEvent *event);
+  void     Process(AliESDEvent *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(AliVEvent *event);
+  void ExportTrackPoints(AliESDEvent *event);
   //
   //
   void MakeReportDy(TFile *output); 
@@ -91,8 +90,7 @@ 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(AliVTrack *const track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);}
+  void     Process(AliESDtrack *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 ba673f6..e4e004a 100644 (file)
 #include "AliLog.h"
 #include "AliESDEvent.h"
 
-#include "AliVEvent.h"
-#include "AliVTrack.h"
-#include "AliVfriendTrack.h"
-
 
 ClassImp(AliTPCcalibBase)
 
@@ -189,7 +185,7 @@ TTreeSRedirector *AliTPCcalibBase::GetDebugStreamer(){
 }
 
 
-void    AliTPCcalibBase::UpdateEventInfo(AliVEvent * event){
+void    AliTPCcalibBase::UpdateEventInfo(AliESDEvent * event){
   //
   //
   //
@@ -204,7 +200,7 @@ void    AliTPCcalibBase::UpdateEventInfo(AliVEvent * event){
 }
 
 
-Bool_t AliTPCcalibBase::HasLaser(AliVEvent *event){
+Bool_t AliTPCcalibBase::HasLaser(AliESDEvent *event){
   //
   //
   //
index 2e6275f..f40241b 100644 (file)
 #include "TNamed.h"
 #include "TObjString.h"
 class AliTPCseed;
-//class AliESDEvent;
-class AliVEvent;
-//class AliESDtrack;
-class AliVTrack;
-//class AliESDfriendTrack;
-class AliVfriendTrack;
+class AliESDEvent;
+class AliESDtrack;
+class AliESDfriendTrack;
 class TCollection;
 class TTreeSRedirector;
 class TGraph;
@@ -32,19 +29,13 @@ public:
   AliTPCcalibBase(const AliTPCcalibBase&calib);
   AliTPCcalibBase &operator=(const AliTPCcalibBase&calib);
   virtual ~AliTPCcalibBase();
-  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 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 Long64_t Merge(TCollection */*li*/){return 0;}
   virtual void     Analyze(){return;}
   virtual void     Terminate();
-  virtual void     UpdateEventInfo(AliVEvent * event);
+  virtual void     UpdateEventInfo(AliESDEvent * event);
   virtual Bool_t   AcceptTrigger();
   virtual void     SetTriggerMask(Int_t accept, Int_t reject, Bool_t rejectLaser){fTriggerMaskAccept=accept;fTriggerMaskReject=reject; fRejectLaser = rejectLaser;}
  
@@ -56,7 +47,7 @@ public:
   Int_t      GetStreamLevel() const {return fStreamLevel;}
   Int_t      GetDebugLevel() const {return fDebugLevel;}
   virtual void RegisterDebugOutput(const char *path);
-  static     Bool_t HasLaser(AliVEvent *event);
+  static     Bool_t HasLaser(AliESDEvent *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);
@@ -75,9 +66,9 @@ protected:
   Bool_t  fHasLaser;                    //flag the laser is overlayed with given event
   Bool_t  fRejectLaser;                 //flag- reject laser
   TObjString fTriggerClass;             // trigger class
-  AliVEvent  *fCurrentEvent;          //! current event
-  AliVTrack *fCurrentTrack;           //! current esd track
-  AliVfriendTrack *fCurrentFriendTrack;     //! current friend track
+  AliESDEvent  *fCurrentEvent;          //! current event
+  AliESDtrack *fCurrentTrack;           //! current esd track
+  AliESDfriendTrack *fCurrentFriendTrack;     //! current friend track
   AliTPCseed   *fCurrentSeed;           //! current seed
 private:
   Int_t  fDebugLevel;                   //  debug level
index be8b1d8..f97c0cc 100644 (file)
 #include "TTreeStream.h"
 #include "AliLog.h"
 #include "TTimeStamp.h"
-//#include "AliESDEvent.h"
-//#include "AliESDfriend.h"
-//#include "AliESDtrack.h"
-
-#include "AliVEvent.h"
-#include "AliVfriendEvent.h"
-#include "AliVTrack.h"
-#include "AliVfriendTrack.h"
-
+#include "AliESDEvent.h"
+#include "AliESDfriend.h"
+#include "AliESDtrack.h"
 #include "AliTracker.h"
 #include "AliTPCClusterParam.h"
 #include "AliTPCParam.h"
@@ -134,21 +128,20 @@ AliTPCcalibCalib::~AliTPCcalibCalib() {
 }
 
 
-void     AliTPCcalibCalib::Process(AliVEvent *event){
+void     AliTPCcalibCalib::Process(AliESDEvent *event){
   //
   // 
   //
   if (!event) {
     return;
   }  
-  //AliESDfriend *ESDfriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
-  AliVfriendEvent *friendEvent=event->FindFriend();
-  if (!friendEvent) {
+  AliESDfriend *ESDfriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
+  if (!ESDfriend) {
    return;
   }
-  if (friendEvent->TestSkipBit()) return;
+  if (ESDfriend->TestSkipBit()) return;
   if (GetDebugLevel()>20) printf("Hallo world: Im here\n");
-  Int_t ntracks=friendEvent->GetNumberOfTracks();
+  Int_t ntracks=ESDfriend->GetNumberOfTracks();   
   //AliTPCcalibDB::Instance()->SetExBField(fMagF);
 
   //
@@ -156,29 +149,17 @@ void     AliTPCcalibCalib::Process(AliVEvent *event){
   //
 
   for (Int_t i=0;i<ntracks;++i) {
-    AliVTrack *track = event->GetVTrack(i);
-    if(!track) continue;
-    const AliVfriendTrack *friendTrack = friendEvent->GetTrack(i);
+    AliESDtrack *track = event->GetTrack(i);     
+    AliESDfriendTrack *friendTrack = (AliESDfriendTrack*) ESDfriend->GetTrack(i);
     if (!friendTrack) continue;
     //track->SetFriendTrack(friendTrack);
-    fCurrentFriendTrack=const_cast<AliVfriendTrack*>(friendTrack);
-    AliExternalTrackParam trckIn;
-    track->GetTrackParamIp(trckIn);
-    if((track->GetTrackParamIp(trckIn)) < 0) continue;
-    const AliExternalTrackParam * trackIn  = &trckIn;
+    fCurrentFriendTrack=friendTrack;
+    const AliExternalTrackParam * trackIn  = track->GetInnerParam();
+    const AliExternalTrackParam * trackOut = track->GetOuterParam();
+    AliExternalTrackParam * tpcOut   = (AliExternalTrackParam *)friendTrack->GetTPCOut();
     if (!trackIn) continue;
-
-    AliExternalTrackParam trckOut;
-    track->GetTrackParamOp(trckOut);
-    if((track->GetTrackParamOp(trckOut)) < 0) continue;
-    const AliExternalTrackParam * trackOut = &trckOut;
     if (!trackOut) continue;
-
-    AliExternalTrackParam prmtpcOut;
-    friendTrack->GetTrackParamTPCOut(prmtpcOut);
-    if((friendTrack->GetTrackParamTPCOut(prmtpcOut)) < 0) continue;
-    AliExternalTrackParam * tpcOut   = &prmtpcOut;
-    if (!tpcOut) continue;
+    if (!tpcOut) continue;   
     TObject *calibObject;
     AliTPCseed *seed = 0;
     for (Int_t l=0;(calibObject=friendTrack->GetCalibObject(l));++l) {
@@ -186,16 +167,12 @@ void     AliTPCcalibCalib::Process(AliVEvent *event){
     }
     if (!seed) continue;
     RefitTrack(track, seed, event->GetMagneticField());
-
-    AliExternalTrackParam prmOut;
-    track->GetTrackParamOp(prmOut);
-    AliExternalTrackParam * paramOut = &prmOut;
-    (*tpcOut)=*paramOut;
+    (*tpcOut)=*(track->GetOuterParam());  
   }
   return;
 }
 
-Bool_t  AliTPCcalibCalib::RefitTrack(AliVTrack *track, AliTPCseed *seed, Float_t magesd){
+Bool_t  AliTPCcalibCalib::RefitTrack(AliESDtrack * track, AliTPCseed *seed, Float_t magesd){
   //
   // Refit track
   // if magesd==0 forget the curvature
@@ -212,7 +189,7 @@ Bool_t  AliTPCcalibCalib::RefitTrack(AliVTrack *track, AliTPCseed *seed, Float_t
 
   static Int_t streamCounter=0;
   streamCounter++;
-  AliVfriendTrack *friendTrack = fCurrentFriendTrack;
+  AliESDfriendTrack *friendTrack = fCurrentFriendTrack;
 
   AliTPCTransform *transform = AliTPCcalibDB::Instance()->GetTransform() ;
   AliTPCParam     *param     = AliTPCcalibDB::Instance()->GetParameters();
@@ -319,19 +296,13 @@ Bool_t  AliTPCcalibCalib::RefitTrack(AliVTrack *track, AliTPCseed *seed, Float_t
   // 
   // And now do refit
   //
-  AliExternalTrackParam trckOld;
-  track->GetTrackParamIp(trckOld);
-  AliExternalTrackParam * trackInOld  = &trckOld;
-
-  AliExternalTrackParam trckOuter;
-  track->GetTrackParamOp(trckOuter);
-  AliExternalTrackParam * trackOuter = &trckOuter;
-
-  AliExternalTrackParam trckOutOld;
-  friendTrack->GetTrackParamTPCOut(trckOutOld);
-  AliExternalTrackParam * trackOutOld = &trckOutOld;
+  AliExternalTrackParam * trackInOld  = (AliExternalTrackParam*)track->GetInnerParam();
+  AliExternalTrackParam * trackOuter = (AliExternalTrackParam*)track->GetOuterParam();
+  AliExternalTrackParam * trackOutOld   = (AliExternalTrackParam *)friendTrack->GetTPCOut();
   Double_t mass =    TDatabasePDG::Instance()->GetParticle("pi+")->Mass();
 
+    
+
   AliExternalTrackParam trackIn  = *trackOutOld;
   trackIn.ResetCovariance(kResetCov);
   trackIn.AddCovariance(covar);
index 3dd666f..25663cc 100644 (file)
 
 #include "AliTPCcalibBase.h"
 class AliTPCseed;
-//class AliESDEvent;
-class AliVEvent;
-//class AliESDtrack;
-class AliVTrack;
+class AliESDEvent;
+class AliESDtrack;
 class TCollection;
 class TTreeSRedirector;
 class AliExternalTrackParam;
@@ -26,13 +24,12 @@ public:
   AliTPCcalibCalib(const AliTPCcalibCalib&calib);
   AliTPCcalibCalib &operator=(const AliTPCcalibCalib&calib);
   virtual ~AliTPCcalibCalib();
-  virtual void     Process(AliVEvent *event);
+  virtual void     Process(AliESDEvent *event);
   virtual void     Analyze(){return;}
   
-  Bool_t  RefitTrack(AliVTrack * track, AliTPCseed *seed, Float_t magesd);
+  Bool_t  RefitTrack(AliESDtrack * 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(AliVTrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);}
+  void     Process(AliESDtrack *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 419e833..c9e4665 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"
@@ -331,12 +325,12 @@ void AliTPCcalibCosmic::Add(const AliTPCcalibCosmic* cosmic){
 
 
 
-void AliTPCcalibCosmic::Process(AliVEvent *event) {
+void AliTPCcalibCosmic::Process(AliESDEvent *event) {
   //
   // Process of the ESD event  - fill calibration components
   //
   if (!event) {
-    Printf("ERROR: event not available");
+    Printf("ERROR: ESD not available");
     return;
   }  
    
@@ -466,7 +460,7 @@ void AliTPCcalibCosmic::FillHistoPerformance(const AliExternalTrackParam *par0,
   
 }
 
-void AliTPCcalibCosmic::FindPairs(const AliVEvent *event){
+void AliTPCcalibCosmic::FindPairs(const AliESDEvent *event){
   //
   // Find cosmic pairs
   // 
@@ -474,7 +468,7 @@ void AliTPCcalibCosmic::FindPairs(const AliVEvent *event){
   // Track1 is choosen in lower TPC part
   //
   if (GetDebugLevel()>20) printf("Hallo world: Im here\n");
-  AliVfriendEvent *friendEvent=event->FindFriend();
+  AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
   Int_t ntracks=event->GetNumberOfTracks(); 
   TObjArray  tpcSeeds(ntracks);
   if (ntracks==0) return;
@@ -485,8 +479,7 @@ void AliTPCcalibCosmic::FindPairs(const AliVEvent *event){
   //track loop
   //
   for (Int_t i=0;i<ntracks;++i) {
-   AliVTrack *track = event->GetVTrack(i);
-   if(!track) continue;
+   AliESDtrack *track = event->GetTrack(i);
    fClusters->Fill(track->GetTPCNcls()); 
   
    const AliExternalTrackParam * trackIn = track->GetInnerParam();
@@ -496,7 +489,7 @@ void AliTPCcalibCosmic::FindPairs(const AliVEvent *event){
    if (ntracks>4 && TMath::Abs(trackIn->GetTgl())<0.0015) continue;  // filter laser 
 
 
-   const AliVfriendTrack *friendTrack = friendEvent->GetTrack(i);
+   AliESDfriendTrack *friendTrack = esdFriend->GetTrack(i);
    if (!friendTrack) continue;
    TObject *calibObject;
    AliTPCseed *seed = 0;   
@@ -526,7 +519,7 @@ void AliTPCcalibCosmic::FindPairs(const AliVEvent *event){
   // Find pairs
   //
   for (Int_t i=0;i<ntracks;++i) {
-      AliVTrack *track0 = event->GetVTrack(i);
+    AliESDtrack *track0 = event->GetTrack(i);     
     // track0 - choosen upper part
     if (!track0) continue;
     if (!track0->GetOuterParam()) continue;
@@ -535,7 +528,7 @@ void AliTPCcalibCosmic::FindPairs(const AliVEvent *event){
     track0->GetDirection(dir0);    
     for (Int_t j=0;j<ntracks;++j) {
       if (i==j) continue;
-      AliVTrack *track1 = event->GetVTrack(j);
+      AliESDtrack *track1 = event->GetTrack(j);   
       //track 1 lower part
       if (!track1) continue;
       if (!track1->GetOuterParam()) continue;
@@ -576,11 +569,8 @@ void AliTPCcalibCosmic::FindPairs(const AliVEvent *event){
       //
       //
       Float_t dmax = TMath::Max(TMath::Abs(d0),TMath::Abs(d1));
-      AliExternalTrackParam param0;
-      param0.CopyFromVTrack(track0);
-
-      AliExternalTrackParam param1;
-      param1.CopyFromVTrack(track1);
+      AliExternalTrackParam param0(*track0);
+      AliExternalTrackParam param1(*track1);
       //
       // Propagate using Magnetic field and correct fo material budget
       //
@@ -713,7 +703,7 @@ void AliTPCcalibCosmic::FindPairs(const AliVEvent *event){
 
 
 
-void  AliTPCcalibCosmic::FillAcordeHist(AliVTrack *upperTrack) {
+void  AliTPCcalibCosmic::FillAcordeHist(AliESDtrack *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;
@@ -994,20 +984,14 @@ void AliTPCcalibCosmic::UpdateTrack(AliExternalTrackParam &track1, const AliExte
 
 
 
-void AliTPCcalibCosmic::FindCosmicPairs(const AliVEvent *event) {
+void AliTPCcalibCosmic::FindCosmicPairs(const AliESDEvent * event) {
   //
   // find cosmic pairs trigger by random trigger
   //
   //
-  AliESDVertex vtxSPD;
-  event->GetPrimaryVertexSPD(vtxSPD);
-  AliESDVertex *vertexSPD=&vtxSPD;
-
-  AliESDVertex vtxTPC;
-  event->GetPrimaryVertexTPC(vtxTPC);
-  AliESDVertex *vertexTPC=&vtxTPC;
-
-  AliVfriendEvent *friendEvent=event->FindFriend();
+  AliESDVertex *vertexSPD =  (AliESDVertex *)event->GetPrimaryVertexSPD();
+  AliESDVertex *vertexTPC =  (AliESDVertex *)event->GetPrimaryVertexTPC(); 
+  AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
   const Double_t kMinPt=1;
   const Double_t kMinPtMax=0.8;
   const Double_t kMinNcl=50;
@@ -1022,9 +1006,9 @@ void AliTPCcalibCosmic::FindCosmicPairs(const AliVEvent *event) {
 
 
   for (Int_t itrack0=0;itrack0<ntracks;itrack0++) {
-    AliVTrack *track0 = event->GetVTrack(itrack0);
+    AliESDtrack *track0 = event->GetTrack(itrack0);
     if (!track0) continue;
-    if (!track0->IsOn(AliVTrack::kTPCrefit)) continue;
+    if (!track0->IsOn(AliESDtrack::kTPCrefit)) continue;
 
     if (TMath::Abs(AliTracker::GetBz())>1&&track0->Pt()<kMinPt) continue;
     if (track0->GetTPCncls()<kMinNcl) continue;
@@ -1038,9 +1022,9 @@ void AliTPCcalibCosmic::FindCosmicPairs(const AliVEvent *event) {
     //if (TMath::Abs(dcaTPC[1])<kMaxDelta[0]*2) continue;
     //    const AliExternalTrackParam * trackIn0 = track0->GetInnerParam();
     for (Int_t itrack1=itrack0+1;itrack1<ntracks;itrack1++) {
-      AliVTrack *track1 = event->GetVTrack(itrack1);
+      AliESDtrack *track1 = event->GetTrack(itrack1);
       if (!track1) continue;  
-      if (!track1->IsOn(AliVTrack::kTPCrefit)) continue;
+      if (!track1->IsOn(AliESDtrack::kTPCrefit)) continue;
       if (track1->GetKinkIndex(0)>0) continue;
       if (TMath::Abs(AliTracker::GetBz())>1&&track1->Pt()<kMinPt) continue;
       if (track1->GetTPCncls()<kMinNcl) continue;
@@ -1071,7 +1055,7 @@ void AliTPCcalibCosmic::FindCosmicPairs(const AliVEvent *event) {
       if (!isPair) continue;
       TString filename(AliAnalysisManager::GetAnalysisManager()->GetTree()->GetCurrentFile()->GetName());
       Int_t eventNumber = event->GetEventNumberInFile(); 
-      Bool_t hasFriend=(friendEvent) ? (friendEvent->GetTrack(itrack0)!=0):0;
+      Bool_t hasFriend=(esdFriend) ? (esdFriend->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);
 
@@ -1083,9 +1067,9 @@ void AliTPCcalibCosmic::FindCosmicPairs(const AliVEvent *event) {
       Int_t ntracksSPD = vertexSPD->GetNContributors();
       Int_t ntracksTPC = vertexTPC->GetNContributors();
       //
-      const AliVfriendTrack *friendTrack0 = friendEvent->GetTrack(itrack0);
+      AliESDfriendTrack *friendTrack0 = esdFriend->GetTrack(itrack0);
       if (!friendTrack0) continue;
-      const AliVfriendTrack *friendTrack1 = friendEvent->GetTrack(itrack1);
+      AliESDfriendTrack *friendTrack1 = esdFriend->GetTrack(itrack1);
       if (!friendTrack1) continue;
       TObject *calibObject;
       AliTPCseed *seed0 = 0;   
@@ -1097,7 +1081,6 @@ void AliTPCcalibCosmic::FindCosmicPairs(const AliVEvent *event) {
       for (Int_t l=0;(calibObject=friendTrack1->GetCalibObject(l));++l) {
        if ((seed1=dynamic_cast<AliTPCseed*>(calibObject))) break;
       }
-
       //
       if (pcstream){
        (*pcstream)<<"pairs"<<
@@ -1114,30 +1097,12 @@ void AliTPCcalibCosmic::FindCosmicPairs(const AliVEvent *event) {
          "vTPC.="<<vertexTPC<<         //primary vertex -TPC
          "t0.="<<track0<<              //track0
          "t1.="<<track1<<              //track1
-      //"ft0.="<<dummyfriendTrack0<<       //track0
-      //"ft1.="<<dummyfriendTrack1<<       //track1
+         "ft0.="<<friendTrack0<<       //track0
+         "ft1.="<<friendTrack1<<       //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);
@@ -1145,15 +1110,15 @@ void AliTPCcalibCosmic::FindCosmicPairs(const AliVEvent *event) {
       if (fCosmicTree->GetEntries()==0){
        //
        fCosmicTree->SetDirectory(0);
-    fCosmicTree->Branch("t0.",&dummytrack0);
-    fCosmicTree->Branch("t1.",&dummytrack1);
-    fCosmicTree->Branch("ft0.",&dummyfriendTrack0);
-    fCosmicTree->Branch("ft1.",&dummyfriendTrack1);
+       fCosmicTree->Branch("t0.",&track0);
+       fCosmicTree->Branch("t1.",&track1);
+       fCosmicTree->Branch("ft0.",&friendTrack0);
+       fCosmicTree->Branch("ft1.",&friendTrack1);
       }else{
-    fCosmicTree->SetBranchAddress("t0.",&dummytrack0);
-    fCosmicTree->SetBranchAddress("t1.",&dummytrack1);
-    fCosmicTree->SetBranchAddress("ft0.",&dummyfriendTrack0);
-    fCosmicTree->SetBranchAddress("ft1.",&dummyfriendTrack1);
+       fCosmicTree->SetBranchAddress("t0.",&track0);   
+       fCosmicTree->SetBranchAddress("t1.",&track1);
+       fCosmicTree->SetBranchAddress("ft0.",&friendTrack0);    
+       fCosmicTree->SetBranchAddress("ft1.",&friendTrack1);
       }
       fCosmicTree->Fill();
     }
@@ -1179,7 +1144,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 2ecbb46..9b97112 100644 (file)
@@ -8,10 +8,8 @@
 class TH2F;
 class TH1F;
 class TList;
-//class AliESDEvent;
-class AliVEvent;
-//class AliESDtrack;
-class AliVTrack;
+class AliESDEvent;
+class AliESDtrack;
 class THnSparse;
 
 class AliTPCcalibCosmic:public AliTPCcalibBase {
@@ -20,14 +18,14 @@ public:
   AliTPCcalibCosmic(const Text_t *name, const Text_t *title);
   virtual ~AliTPCcalibCosmic();
   
-  virtual void      Process(AliVEvent *event);
+  virtual void      Process(AliESDEvent *event);
   virtual Long64_t  Merge(TCollection *const li);
   void              Add(const AliTPCcalibCosmic* cosmic);
   //
   //
   void              Init();
-  void              FindPairs(const AliVEvent *event);
-  void              FindCosmicPairs(const AliVEvent * event);
+  void              FindPairs(const AliESDEvent *event);
+  void              FindCosmicPairs(const AliESDEvent * event);
 
   Bool_t            IsPair(AliExternalTrackParam *tr0, AliExternalTrackParam *tr1) const;
   static void       CalculateBetheParams(TH2F *hist, Double_t * initialParam);
@@ -53,8 +51,7 @@ 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(AliVTrack *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(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);
@@ -69,7 +66,7 @@ public:
   static void AddTree(TTree* treeOutput, TTree * treeInput);
 private:
   
-  void              FillAcordeHist(AliVTrack *upperTrack);
+  void              FillAcordeHist(AliESDtrack *upperTrack);
 
   
 
index bf53e85..f7f5906 100644 (file)
@@ -44,18 +44,12 @@ 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 "AliESDfriendTrack.h"
+#include "AliESDEvent.h"
+#include "AliESDfriend.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"
 
@@ -297,7 +291,7 @@ AliTPCcalibGainMult::~AliTPCcalibGainMult(){
 
 
 
-void AliTPCcalibGainMult::Process(AliVEvent *event) {
+void AliTPCcalibGainMult::Process(AliESDEvent *event) {
   //
   // Main function of the class
   // 1. Select Identified  particles - for identified particles the flag in the PID matrix is stored
@@ -320,30 +314,25 @@ void AliTPCcalibGainMult::Process(AliVEvent *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 AliTPCcalibGainMult::Process(): event not available");
+    Printf("ERROR: ESD not available");
     return;
   }  
-  fCurrentEvent=event;
+  fCurrentEvent=event  ;
   fMagF = event->GetMagneticField();
   Int_t ntracks=event->GetNumberOfTracks();  
-  //AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindFriend());
-  AliVfriendEvent *friendEvent=event->FindFriend();
-  if (!friendEvent) {
-    Printf("ERROR: esdFriend not available");
+  AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
+  if (!esdFriend) {
+    //Printf("ERROR: esdFriend not available");
     delete fPIDMatrix;
     return;
   }
-  if (!(friendEvent->TestSkipBit())) fPIDMatrix= new TMatrixD(ntracks,5);
+  if (!(esdFriend->TestSkipBit())) fPIDMatrix= new TMatrixD(ntracks,5);
   fHistNTracks->Fill(ntracks);
   //  ProcessCosmic(event);  // usually not enogh statistic
 
-  if (friendEvent->TestSkipBit()) {
+  if (esdFriend->TestSkipBit()) {
     return;
    }
   //
@@ -358,15 +347,10 @@ void AliTPCcalibGainMult::Process(AliVEvent *event) {
   //
   for (Int_t i=0;i<ntracks;++i) {
     //
-    //AliESDtrack *track = (AliESDtrack*)(event->GetTrack(i));
-    AliVTrack *track = event->GetVTrack(i);
+    AliESDtrack *track = event->GetTrack(i);
     if (!track) continue;
     //   
-
-    AliExternalTrackParam trckIn;
-    track->GetTrackParamIp(trckIn);
-    if ( (track->GetTrackParamIp(trckIn)) < 0) continue;
-    AliExternalTrackParam * trackIn = &trckIn;
+    AliExternalTrackParam * trackIn  = (AliExternalTrackParam *)track->GetInnerParam();
     if (!trackIn) continue;
   
     // calculate necessary track parameters
@@ -388,19 +372,13 @@ void AliTPCcalibGainMult::Process(AliVEvent *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
-
+    if ((status&AliESDtrack::kTPCrefit)==0) continue;
+    if ((status&AliESDtrack::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&AliVTrack::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;
     //
     //  
     // fill Alexander QA histogram
@@ -408,8 +386,7 @@ void AliTPCcalibGainMult::Process(AliVEvent *event) {
     if (primVtxDCA < 3 && track->GetNcls(0) > 3 && track->GetKinkIndex(0) == 0 && ncls > 100) fHistQA->Fill(meanP, track->GetTPCsignal(), 5);
 
     // Get seeds
-    //AliESDfriendTrack *friendTrack = friendEvent->GetTrack(i);
-    const AliVfriendTrack *friendTrack = friendEvent->GetTrack(i);
+    AliESDfriendTrack *friendTrack = esdFriend->GetTrack(i);
     if (!friendTrack) continue;
     TObject *calibObject;
     AliTPCseed *seed = 0;
@@ -420,10 +397,8 @@ void AliTPCcalibGainMult::Process(AliVEvent *event) {
     //
     if (seed) { // seed the container with track parameters and the clusters
       // 
-      AliExternalTrackParam trckOut;
-      friendTrack->GetTrackParamTPCOut(trckOut);
-      if ( (friendTrack->GetTrackParamTPCOut(trckOut)) <0) continue;
-      AliExternalTrackParam * trackOut = &trckOut;  // tack at the outer radius of TPC
+      const AliExternalTrackParam * trackOut = friendTrack->GetTPCOut();  // tack at the outer radius of TPC
+      if (!trackIn) continue;
       if (!trackOut) continue;
       Double_t meanDrift = 250 - 0.5*TMath::Abs(trackIn->GetZ() + trackOut->GetZ());
       Double_t dipAngleTgl  = trackIn->GetTgl();
@@ -774,7 +749,7 @@ void AliTPCcalibGainMult::UpdateClusterParam() {
 }
 
 
-void AliTPCcalibGainMult::DumpTrack(AliVTrack * track, AliVfriendTrack *ftrack, AliTPCseed * seed, Int_t index){
+void AliTPCcalibGainMult::DumpTrack(AliESDtrack * track, AliESDfriendTrack *ftrack, AliTPCseed * seed, Int_t index){
   //
   // dump interesting tracks
   // 1. track at MIP region
@@ -828,9 +803,7 @@ void AliTPCcalibGainMult::DumpTrack(AliVTrack * track, AliVfriendTrack *ftrack,
   static Double_t radius1= roc->GetPadRowRadiiUp(30);
   static Double_t radius2= roc->GetPadRowRadiiUp(roc->GetNRows(36)-15);
 
-  AliESDVertex vtx;
-  fCurrentEvent->GetPrimaryVertex(vtx);
-  AliESDVertex *vertex=&vtx;
+  AliESDVertex *vertex= (AliESDVertex *)fCurrentEvent->GetPrimaryVertex();
   //
   // Estimate current MIP position - 
   //
@@ -856,25 +829,13 @@ void AliTPCcalibGainMult::DumpTrack(AliVTrack * track, AliVfriendTrack *ftrack,
   if ( (isMuon==0 && isElectron==0)  && (TMath::Sqrt(dca[0]*dca[0]+dca[1]*dca[1])>kDCAcut) ) return;
   Double_t normdEdx= track->GetTPCsignal()/(medianMIP0); // TPC signal normalized to the MIP
   //
-  AliExternalTrackParam trckIn;
-  track->GetTrackParamIp(trckIn);
-  if ( (track->GetTrackParamIp(trckIn)) <0) return;
-  AliExternalTrackParam * trackIn  = &trckIn;
+  AliExternalTrackParam * trackIn  = (AliExternalTrackParam *)track->GetInnerParam();
+  AliExternalTrackParam * trackOut = (AliExternalTrackParam *)track->GetOuterParam();
+  AliExternalTrackParam * tpcOut   = (AliExternalTrackParam *)ftrack->GetTPCOut();
   if (!trackIn) return;
-
-  AliExternalTrackParam trckOut;
-  track->GetTrackParamOp(trckOut);
-  if ( (track->GetTrackParamOp(trckOut)) <0) return;
-  AliExternalTrackParam * trackOut  = &trckOut;
   if (!trackOut) return;
-
-  AliExternalTrackParam trckTPCOut;
-  ftrack->GetTrackParamTPCOut(trckTPCOut);
-  if ( (ftrack->GetTrackParamTPCOut(trckTPCOut)) <0) return;
-  AliExternalTrackParam * tpcOut  = &trckTPCOut;
   if (!tpcOut) return;
-
-  if (trckIn.GetZ()*trckOut.GetZ()<0) return;  // remove crossing tracks
+  if (trackIn->GetZ()*trackOut->GetZ()<0) return;  // remove crossing tracks
   //
   // calculate local and global angle
   Int_t side = (trackIn->GetZ()>0)? 1:-1;
@@ -906,11 +867,8 @@ void AliTPCcalibGainMult::DumpTrack(AliVTrack * track, AliVfriendTrack *ftrack,
   // Select the kaons and Protons which are "isolated" in TPC dedx curve
   // 
   //
-  AliExternalTrackParam trkIn;
-  track->GetTrackParamIp(trkIn);
-  AliExternalTrackParam * trackIP = &trkIn;
-  Double_t dedxP = AliExternalTrackParam::BetheBlochAleph(trackIP->GetP()/massP,kp1,kp2,kp3,kp4,kp5);
-  Double_t dedxK = AliExternalTrackParam::BetheBlochAleph(trackIP->GetP()/massK,kp1,kp2,kp3,kp4,kp5);
+  Double_t dedxP = AliExternalTrackParam::BetheBlochAleph(track->GetInnerParam()->GetP()/massP,kp1,kp2,kp3,kp4,kp5);
+  Double_t dedxK = AliExternalTrackParam::BetheBlochAleph(track->GetInnerParam()->GetP()/massK,kp1,kp2,kp3,kp4,kp5);
   if (dedxP>2 || dedxK>2){
     if (track->GetP()<1.2 && normdEdx>1.8&&counterMIP0>10){ // not enough from TOF and V0s triggered by high dedx
       // signing the Proton  and kaon - using the "bitmask" bit 1 and 2 is dedicated for V0s and TOF selected       
@@ -926,7 +884,7 @@ void AliTPCcalibGainMult::DumpTrack(AliVTrack * track, AliVfriendTrack *ftrack,
   Double_t mass = 0;  
   Bool_t isHighPt = ((TMath::Power(1/track->Pt(),4)*gRandom->Rndm())<0.005);  // rnadomly selected HPT tracks
   // there are selected for the QA of the obtained calibration
-  Bool_t isMIP    =  TMath::Abs(trackIP->P()-0.4)<0.005&&(counter<kMax); //
+  Bool_t isMIP    =  TMath::Abs(track->GetInnerParam()->P()-0.4)<0.005&&(counter<kMax); //
   // REMINDER - it is not exactly MIP - we select the regtion where the Kaon and Electrons are well separated
 
   if (isElectron>0) mass = massE;
@@ -1294,19 +1252,18 @@ void AliTPCcalibGainMult::DumpTrack(AliVTrack * track, AliVfriendTrack *ftrack,
 
 
 
-void AliTPCcalibGainMult::ProcessV0s(AliVEvent *event){
+void AliTPCcalibGainMult::ProcessV0s(AliESDEvent * event){
   //
   // Select the K0s and gamma  - and sign daughter products 
   //  
   TTreeSRedirector * pcstream =  GetDebugStreamer();
   AliKFParticle::SetField(event->GetMagneticField()); 
-  //AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindFriend());
-  AliVfriendEvent *friendEvent=event->FindFriend();
-  if (!friendEvent) {
-    //Printf("ERROR: friendEvent not available");
+  AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
+  if (!esdFriend) {
+    //Printf("ERROR: esdFriend not available");
    return;
   }
-  if (friendEvent->TestSkipBit()) return;
+  if (esdFriend->TestSkipBit()) return;
   //
   // 
   static const TDatabasePDG *pdg = TDatabasePDG::Instance();  
@@ -1317,24 +1274,11 @@ void AliTPCcalibGainMult::ProcessV0s(AliVEvent *event){
   const Double_t kMaxREl=70;
   //
   Int_t nv0 = event->GetNumberOfV0s(); 
-
-
-  //AliESDVertex *vertex= (AliESDVertex *)event->GetPrimaryVertex();
-  AliESDVertex vtx;
-  event->GetPrimaryVertex(vtx);
-  AliESDVertex *vertex=&vtx;
-
+  AliESDVertex *vertex= (AliESDVertex *)event->GetPrimaryVertex();
   AliKFVertex kfvertex=*vertex;
-
-
   //
   for (Int_t iv0=0;iv0<nv0;iv0++){
-    //AliESDv0 *v0 = event->GetV0(iv0);
-    AliESDv0 v0dummy;
-    event->GetV0(v0dummy, iv0);
-    if( (event->GetV0(v0dummy, iv0)) < 0) continue;
-    AliESDv0 *v0 = &v0dummy;
-
+    AliESDv0 *v0 = event->GetV0(iv0);
     if (!v0) continue;
     if (v0->GetOnFlyStatus()<0.5) continue;
     if (v0->GetPindex()<0) continue;
@@ -1387,10 +1331,8 @@ void AliTPCcalibGainMult::ProcessV0s(AliVEvent *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 = (AliESDtrack*)event->GetTrack(pindex);
-    //AliESDtrack * trackN = (AliESDtrack*)event->GetTrack(nindex);
-    AliVTrack * trackP = event->GetVTrack(pindex);
-    AliVTrack * trackN = event->GetVTrack(nindex);
+    AliESDtrack * trackP = event->GetTrack(pindex);
+    AliESDtrack * trackN = event->GetTrack(nindex);
     if (!trackN) continue;
     if (!trackP) continue;
     Int_t nclP= (Int_t)trackP->GetTPCClusterInfo(2,1);
@@ -1400,10 +1342,8 @@ void AliTPCcalibGainMult::ProcessV0s(AliVEvent *event){
     if (TMath::Abs(eta)>1) continue;
     //
     //
-    //AliESDfriendTrack *friendTrackP = friendEvent->GetTrack(pindex);
-    //AliESDfriendTrack *friendTrackN = friendEvent->GetTrack(nindex);
-    const AliVfriendTrack *friendTrackP = friendEvent->GetTrack(pindex);
-    const AliVfriendTrack *friendTrackN = friendEvent->GetTrack(nindex);
+    AliESDfriendTrack *friendTrackP = esdFriend->GetTrack(pindex);
+    AliESDfriendTrack *friendTrackN = esdFriend->GetTrack(nindex);
     if (!friendTrackP) continue;
     if (!friendTrackN) continue;
     TObject *calibObject;
@@ -1443,7 +1383,7 @@ void AliTPCcalibGainMult::ProcessV0s(AliVEvent *event){
 
 
 
-void AliTPCcalibGainMult::ProcessCosmic(const AliVEvent *event) {
+void AliTPCcalibGainMult::ProcessCosmic(const AliESDEvent * event) {
   //
   // Find cosmic pairs trigger by random trigger
   // 
@@ -1451,16 +1391,9 @@ void AliTPCcalibGainMult::ProcessCosmic(const AliVEvent *event) {
   AliTPCTransform *transform = AliTPCcalibDB::Instance()->GetTransform() ;
   AliTPCParam     *param     = AliTPCcalibDB::Instance()->GetParameters();
 
-  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();
+  AliESDVertex *vertexSPD =  (AliESDVertex *)event->GetPrimaryVertexSPD();
+  AliESDVertex *vertexTPC =  (AliESDVertex *)event->GetPrimaryVertexTPC(); 
+  AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
   const Double_t kMinPt=4;
   const Double_t kMinPtMax=0.8;
   const Double_t kMinNcl=159*0.5;
@@ -1475,9 +1408,9 @@ void AliTPCcalibGainMult::ProcessCosmic(const AliVEvent *event) {
   
 
   for (Int_t itrack0=0;itrack0<ntracks;itrack0++) {
-    AliVTrack *track0 = event->GetVTrack(itrack0);
+    AliESDtrack *track0 = event->GetTrack(itrack0);
     if (!track0) continue;
-    if (!track0->IsOn(AliVTrack::kTPCrefit)) continue;
+    if (!track0->IsOn(AliESDtrack::kTPCrefit)) continue;
 
     if (TMath::Abs(AliTracker::GetBz())>1&&track0->Pt()<kMinPt) continue;
     if (track0->GetTPCncls()<kMinNcl) continue;
@@ -1488,9 +1421,9 @@ void AliTPCcalibGainMult::ProcessCosmic(const AliVEvent *event) {
     //rm primaries
     //
     for (Int_t itrack1=itrack0+1;itrack1<ntracks;itrack1++) {
-      AliVTrack *track1 = event->GetVTrack(itrack1);
+      AliESDtrack *track1 = event->GetTrack(itrack1);
       if (!track1) continue;  
-      if (!track1->IsOn(AliVTrack::kTPCrefit)) continue;
+      if (!track1->IsOn(AliESDtrack::kTPCrefit)) continue;
       if (track1->GetKinkIndex(0)>0) continue;
       if (TMath::Abs(AliTracker::GetBz())>1&&track1->Pt()<kMinPt) continue;
       if (track1->GetTPCncls()<kMinNcl) continue;
@@ -1514,7 +1447,7 @@ void AliTPCcalibGainMult::ProcessCosmic(const AliVEvent *event) {
       if (!isPair) continue;
       TString filename(AliAnalysisManager::GetAnalysisManager()->GetTree()->GetCurrentFile()->GetName());
       Int_t eventNumber = event->GetEventNumberInFile(); 
-      Bool_t hasFriend=(friendEvent) ? (friendEvent->GetTrack(itrack0)!=0):0;
+      Bool_t hasFriend=(esdFriend) ? (esdFriend->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));
       //
@@ -1541,9 +1474,9 @@ void AliTPCcalibGainMult::ProcessCosmic(const AliVEvent *event) {
          "\n";      
       }
       //
-      const AliVfriendTrack *friendTrack0 = friendEvent->GetTrack(itrack0);
+      AliESDfriendTrack *friendTrack0 = esdFriend->GetTrack(itrack0);
       if (!friendTrack0) continue;
-      const AliVfriendTrack *friendTrack1 = friendEvent->GetTrack(itrack1);
+      AliESDfriendTrack *friendTrack1 = esdFriend->GetTrack(itrack1);
       if (!friendTrack1) continue;
       TObject *calibObject;
       AliTPCseed *seed0 = 0;   
@@ -1571,21 +1504,12 @@ void AliTPCcalibGainMult::ProcessCosmic(const AliVEvent *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
@@ -1647,13 +1571,13 @@ void AliTPCcalibGainMult::ProcessCosmic(const AliVEvent *event) {
 
 
 
-void AliTPCcalibGainMult::ProcessKinks(const AliVEvent *event){
+void AliTPCcalibGainMult::ProcessKinks(const AliESDEvent * event){
   //
   //
   //
   AliKFParticle::SetField(event->GetMagneticField()); 
-  AliVfriendEvent *friendEvent=event->FindFriend();
-  if (!friendEvent) {
+  AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
+  if (!esdFriend) {
     //Printf("ERROR: esdFriend not available");
     return;
   }
@@ -1666,11 +1590,7 @@ void AliTPCcalibGainMult::ProcessKinks(const AliVEvent *event){
   const Int_t    kMinNcl=110;
   //
   Int_t nkinks = event->GetNumberOfKinks(); 
-  //AliESDVertex *vertex= (AliESDVertex *)event->GetPrimaryVertex();
-  AliESDVertex vtx;
-  event->GetPrimaryVertex(vtx);
-  AliESDVertex *vertex=&vtx;
-
+  AliESDVertex *vertex= (AliESDVertex *)event->GetPrimaryVertex();
   AliKFVertex kfvertex=*vertex;
   TTreeSRedirector * pcstream =  GetDebugStreamer();
   //
@@ -1690,8 +1610,8 @@ void AliTPCcalibGainMult::ProcessKinks(const AliVEvent *event){
     AliKFParticle *v0KF = new AliKFParticle(kfpm,kfpd); 
     v0KF->SetVtxGuess(kink->GetPosition()[0],kink->GetPosition()[1],kink->GetPosition()[2]);
     Double_t chi2 = v0KF->GetChi2();
-    AliVTrack * trackM = event->GetVTrack(kink->GetIndex(0));
-    AliVTrack * trackD = event->GetVTrack(kink->GetIndex(1));
+    AliESDtrack * trackM = event->GetTrack(kink->GetIndex(0));
+    AliESDtrack * trackD = event->GetTrack(kink->GetIndex(1));
     if (!trackM) continue;
     if (!trackD) continue;
     Int_t nclM= (Int_t)trackM->GetTPCClusterInfo(2,1);
@@ -1742,8 +1662,8 @@ void AliTPCcalibGainMult::ProcessKinks(const AliVEvent *event){
     if (TMath::Abs(eta)>1) continue;
     //
     //
-    const AliVfriendTrack *friendTrackM = friendEvent->GetTrack(kink->GetIndex(0));
-    const AliVfriendTrack *friendTrackD = friendEvent->GetTrack(kink->GetIndex(1));
+    AliESDfriendTrack *friendTrackM = esdFriend->GetTrack(kink->GetIndex(0));
+    AliESDfriendTrack *friendTrackD = esdFriend->GetTrack(kink->GetIndex(1));
     if (!friendTrackM) continue;
     if (!friendTrackD) continue;
     TObject *calibObject;
@@ -1758,7 +1678,7 @@ void AliTPCcalibGainMult::ProcessKinks(const AliVEvent *event){
   }
 }
 
-void AliTPCcalibGainMult::DumpHPT(const AliVEvent *event){
+void AliTPCcalibGainMult::DumpHPT(const AliESDEvent * 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
@@ -1767,41 +1687,31 @@ void AliTPCcalibGainMult::DumpHPT(const AliVEvent *event){
 
   TTreeSRedirector * pcstream =  GetDebugStreamer();
   AliKFParticle::SetField(event->GetMagneticField()); 
-  AliVfriendEvent *friendEvent=event->FindFriend();
-  if (!friendEvent) {
+  AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
+  if (!esdFriend) {
     //Printf("ERROR: esdFriend not available");
    return;
   }
-  if (friendEvent->TestSkipBit()) return;
+  if (esdFriend->TestSkipBit()) return;
 
   Int_t ntracks=event->GetNumberOfTracks(); 
   //
   for (Int_t i=0;i<ntracks;++i) {
     //
-    AliVTrack *track = event->GetVTrack(i);
+    AliESDtrack *track = event->GetTrack(i);
     if (!track) continue;
     if (track->Pt()<4) continue; 
     UInt_t status = track->GetStatus();
     //   
-
-    AliExternalTrackParam trckIn;
-    track->GetTrackParamIp(trckIn);
-    if ((track->GetTrackParamIp(trckIn)) <0) continue;
-    AliExternalTrackParam * trackIn = &trckIn;
+    AliExternalTrackParam * trackIn  = (AliExternalTrackParam *)track->GetInnerParam();
     if (!trackIn) continue;
-    if ((status&AliVTrack::kTPCrefit)==0) continue;
-    if ((status&AliVTrack::kITSrefit)==0) continue;
-    const AliVfriendTrack *friendTrack = friendEvent->GetTrack(i);
+    if ((status&AliESDtrack::kTPCrefit)==0) continue;
+    if ((status&AliESDtrack::kITSrefit)==0) continue;
+    AliESDfriendTrack *friendTrack = esdFriend->GetTrack(i);
     if (!friendTrack) continue;
-    AliExternalTrackParam prmitsOut;
-    friendTrack->GetTrackParamITSOut(prmitsOut);
-    if ((friendTrack->GetTrackParamITSOut(prmitsOut)) < 0) continue;
-    AliExternalTrackParam * itsOut = &prmitsOut;
+    AliExternalTrackParam * itsOut = (AliExternalTrackParam *)(friendTrack->GetITSOut());
     if (!itsOut) continue;
-
-    //AliExternalTrackParam * itsOut2 = (AliExternalTrackParam *)(friendTrack->GetITSOut()->Clone());
-    AliExternalTrackParam * itsOut2 = (AliExternalTrackParam *)(itsOut->Clone());
-
+    AliExternalTrackParam * itsOut2 = (AliExternalTrackParam *)(friendTrack->GetITSOut()->Clone());
     AliExternalTrackParam * tpcIn2 = (AliExternalTrackParam *)(trackIn->Clone());
     if (!itsOut2->Rotate(trackIn->GetAlpha())) continue;
     //Double_t xmiddle=0.5*(itsOut2->GetX()+tpcIn2->GetX());
@@ -1809,29 +1719,19 @@ void AliTPCcalibGainMult::DumpHPT(const AliVEvent *event){
     if (!itsOut2->PropagateTo(xmiddle,event->GetMagneticField())) continue;
     if (!tpcIn2->PropagateTo(xmiddle,event->GetMagneticField())) continue;
     //
-    AliExternalTrackParam prmtpcInner;
-    track->GetTrackParamTPCInner(prmtpcInner);
-    if ((track->GetTrackParamTPCInner(prmtpcInner)) < 0) continue;
-    AliExternalTrackParam * tpcInner = &prmtpcInner;
+    AliExternalTrackParam * tpcInner = (AliExternalTrackParam *)(track->GetTPCInnerParam());
     if (!tpcInner) continue;
     tpcInner->Rotate(track->GetAlpha());
     tpcInner->PropagateTo(track->GetX(),event->GetMagneticField());
     //
     // tpc constrained
     //
-    AliExternalTrackParam prmtpcInnerC;
-    track->GetTrackParamTPCInner(prmtpcInnerC);
-    if ((track->GetTrackParamTPCInner(prmtpcInnerC)) < 0) continue;
-    AliExternalTrackParam * tpcInnerC = &prmtpcInnerC;
-    //AliExternalTrackParam * tpcInnerC = (AliExternalTrackParam *)(track->GetTPCInnerParam()->Clone());
+    AliExternalTrackParam * tpcInnerC = (AliExternalTrackParam *)(track->GetTPCInnerParam()->Clone());
     if (!tpcInnerC) continue;
     tpcInnerC->Rotate(track->GetAlpha());
     tpcInnerC->PropagateTo(track->GetX(),event->GetMagneticField());
     Double_t dz[2],cov[3];
-    AliESDVertex dummyvtx;
-    event->GetPrimaryVertex(dummyvtx);
-    AliESDVertex *vtx=&dummyvtx;
-
+    AliESDVertex *vtx= (AliESDVertex *)event->GetPrimaryVertex();
   
     if (!tpcInnerC->PropagateToDCA(vtx, event->GetMagneticField(), 3, dz, cov)) continue;
     Double_t covar[6]; vtx->GetCovMatrix(covar);
@@ -1863,7 +1763,7 @@ void AliTPCcalibGainMult::DumpHPT(const AliVEvent *event){
 
 
 
-void AliTPCcalibGainMult::ProcessTOF(const AliVEvent *event){
+void AliTPCcalibGainMult::ProcessTOF(const AliESDEvent * event){
   //
   // 1. Loop over tracks
   // 2. Fit T0
@@ -1874,14 +1774,12 @@ void AliTPCcalibGainMult::ProcessTOF(const AliVEvent *event){
   const Double_t kMaxD=20;
   const Double_t kRMS0=200; 
   const Double_t kMaxDCAZ=10;
-  AliESDVertex dummyvtx;
-  event->GetPrimaryVertex(dummyvtx);
-  AliESDVertex *vtx=&dummyvtx;
+  AliESDVertex *vtx= (AliESDVertex *)event->GetPrimaryVertex();
   //
   TTreeSRedirector * pcstream =  GetDebugStreamer();
   AliKFParticle::SetField(event->GetMagneticField()); 
-  AliVfriendEvent *friendEvent=event->FindFriend();
-  if (!friendEvent) {
+  AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
+  if (!esdFriend) {
     //Printf("ERROR: esdFriend not available");
    return;
   }
@@ -1901,9 +1799,9 @@ void AliTPCcalibGainMult::ProcessTOF(const AliVEvent *event){
     counter=0;
     for (Int_t i=0;i<ntracks;++i) {
       //
-      AliVTrack *track = event->GetVTrack(i);
+      AliESDtrack *track = event->GetTrack(i);
       if (!track) continue;
-      if (!track->IsOn(AliVTrack::kTIME)) continue;
+      if (!track->IsOn(AliESDtrack::kTIME)) continue;
       if (TMath::Abs(track->GetZ())>kMaxDCAZ) continue;         // remove overlaped events
       if (TMath::Abs(track->GetTOFsignalDz())>kMaxD) continue;
       Double_t times[1000];
@@ -1934,9 +1832,9 @@ void AliTPCcalibGainMult::ProcessTOF(const AliVEvent *event){
   //
   for (Int_t i=0;i<ntracks;++i) {
     //
-    AliVTrack *track = event->GetVTrack(i);
+    AliESDtrack *track = event->GetTrack(i);
     if (!track) continue;
-    if (!track->IsOn(AliVTrack::kTIME)) continue;
+    if (!track->IsOn(AliESDtrack::kTIME)) continue;
     if (TMath::Abs(track->GetZ())>kMaxDCAZ) continue;          //remove overlapped events
     if (TMath::Abs(track->GetTOFsignalDz())>kMaxD) continue;
     Double_t times[1000];
index 4dfb4e9..7896be8 100644 (file)
 #include "TVectorD.h"
 class TH1F;
 class TList;
-//class AliESDEvent;
-class AliVEvent;
-//class AliESDtrack;
-class AliVTrack;
-class AliVfriendTrack;
+class AliESDEvent;
+class AliESDtrack;
 class AliTPCseed;
 
 #include "TTreeStream.h"
@@ -32,24 +29,15 @@ public:
   void SetBBParam(TVectorD * param) {fBBParam=param;}
   //  virtual void Terminate();  
   //
-  //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 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 Long64_t       Merge(TCollection *li);
   virtual void           Analyze();
-  void                   DumpTrack(AliVTrack * track, AliVfriendTrack *ftrack, AliTPCseed * seed, Int_t index);
+  void                   DumpTrack(AliESDtrack * track, AliESDfriendTrack *ftrack, AliTPCseed * seed, Int_t index);
   //
   TH1F   *          GetHistNTracks() const {return fHistNTracks;};
   TH1F   *          GetHistClusterShape() const {return fHistClusterShape;};
@@ -84,8 +72,7 @@ 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(AliVTrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);}
+  void     Process(AliESDtrack *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 416dbee..cac5c4a 100644 (file)
 #include "TLinearFitter.h"
 #include "AliTPCcalibLaser.h"
 #include "AliExternalTrackParam.h"
-//#include "AliESDEvent.h"
-//#include "AliESDfriend.h"
-//#include "AliESDtrack.h"
-
-#include "AliVEvent.h"
-#include "AliVTrack.h"
-#include "AliVfriendEvent.h"
-#include "AliVfriendTrack.h"
-
+#include "AliESDEvent.h"
+#include "AliESDfriend.h"
+#include "AliESDtrack.h"
 #include "AliTPCTracklet.h"
 #include "TH1D.h"
 #include "TH1F.h"
@@ -142,11 +136,11 @@ ClassImp(AliTPCcalibLaser)
 
 AliTPCcalibLaser::AliTPCcalibLaser():
   AliTPCcalibBase(),
-  fEvent(0),
-  fEventFriend(0),
+  fESD(0),
+  fESDfriend(0),
   fNtracks(0),
   fTracksMirror(336),
-  fTracks(336),
+  fTracksEsd(336),
   fTracksEsdParam(336),
   fTracksTPC(336),
   fFullCalib(kTRUE),
@@ -251,11 +245,11 @@ AliTPCcalibLaser::AliTPCcalibLaser():
 
 AliTPCcalibLaser::AliTPCcalibLaser(const Text_t *name, const Text_t *title, Bool_t full):
   AliTPCcalibBase(),
-  fEvent(0),
-  fEventFriend(0),
+  fESD(0),
+  fESDfriend(0),
   fNtracks(0),
   fTracksMirror(336),
-  fTracks(336),
+  fTracksEsd(336),
   fTracksEsdParam(336),
   fTracksTPC(336),
   fFullCalib(full),
@@ -367,11 +361,11 @@ AliTPCcalibLaser::AliTPCcalibLaser(const Text_t *name, const Text_t *title, Bool
 
 AliTPCcalibLaser::AliTPCcalibLaser(const AliTPCcalibLaser& calibLaser):
   AliTPCcalibBase(calibLaser), 
-  fEvent(0),
-  fEventFriend(0),
+  fESD(0),
+  fESDfriend(0),
   fNtracks(0),
   fTracksMirror(336),
-  fTracks(336),
+  fTracksEsd(336),
   fTracksEsdParam(336),
   fTracksTPC(336),
   fFullCalib(calibLaser.fFullCalib),
@@ -581,7 +575,7 @@ AliTPCcalibLaser::~AliTPCcalibLaser() {
 
 
 
-void AliTPCcalibLaser::Process(AliVEvent *event) {
+void AliTPCcalibLaser::Process(AliESDEvent * event) {
   //
   //
   // Loop over tracks and call  Process function
@@ -589,25 +583,24 @@ void AliTPCcalibLaser::Process(AliVEvent *event) {
   const Int_t  kMinTracks=20;
   const Int_t  kMinClusters=40;
 
-  fEvent = event;
-  if (!fEvent) {
-      //Printf("****ERROR AliTPCcalibLaser::Process(): Event not available!!********");
+  fESD = event;
+  if (!fESD) {
     return;
   }
-  fEventFriend=fEvent->FindFriend();
-  if (!fEventFriend) {
+  fESDfriend=static_cast<AliESDfriend*>(fESD->FindListObject("AliESDfriend"));
+  if (!fESDfriend) {
     return;
   }
-  if (fEventFriend->TestSkipBit()) return;
-  if (fEvent->GetNumberOfTracks()<kMinTracks) return; //not enough tracks
+  if (fESDfriend->TestSkipBit()) return;
+  if (fESD->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<fEvent->GetNumberOfTracks();++i) {
-    AliVTrack *track=fEvent->GetVTrack(i);
+  for (Int_t i=0;i<fESD->GetNumberOfTracks();++i) {
+    AliESDtrack *track=fESD->GetTrack(i);
     if (!track) continue;
     hisCE.Fill(track->GetZ());
     hisCE.Fill(track->GetZ()+2);
@@ -618,7 +611,7 @@ void AliTPCcalibLaser::Process(AliVEvent *event) {
 
 
   fTracksTPC.Clear();
-  fTracks.Clear();
+  fTracksEsd.Clear();
   fTracksEsdParam.Delete();
   for (Int_t id=0; id<336;id++) {
     fCounter[id]=0;
@@ -626,12 +619,12 @@ void AliTPCcalibLaser::Process(AliVEvent *event) {
     fClusterSatur[id]=0;
   }
   //
-  Int_t n=fEvent->GetNumberOfTracks();
+  Int_t n=fESD->GetNumberOfTracks();
   Int_t counter=0;
   for (Int_t i=0;i<n;++i) {
-    const AliVfriendTrack *friendTrack=fEventFriend->GetTrack(i);
+    AliESDfriendTrack *friendTrack=fESDfriend->GetTrack(i);
     if (!friendTrack) continue;
-    AliVTrack *track= fEvent->GetVTrack(i);
+    AliESDtrack *track=fESD->GetTrack(i);
     if (!track) continue;
     Double_t binC = hisCE.GetBinContent(hisCE.FindBin(track->GetZ()));
     if (binC>336) continue; //remove CE background
@@ -696,7 +689,7 @@ void AliTPCcalibLaser::MakeDistHisto(Int_t id){
 
     AliExternalTrackParam *param=(AliExternalTrackParam*)fTracksEsdParam.At(id);
     AliTPCLaserTrack *ltrp = ( AliTPCLaserTrack*)fTracksMirror.At(id);
-    AliVTrack   *track    = (AliVTrack*)fTracks.At(id);
+    AliESDtrack   *track    = (AliESDtrack*)fTracksEsd.At(id);
     if (!param) return;
     if (!ltrp) return;
     if (!track) return;
@@ -803,7 +796,7 @@ void AliTPCcalibLaser::FitDriftV(){
       if (!AcceptLaser(id)) continue;
       if ( fClusterSatur[id]>kSaturCut)  continue;
       if ( fClusterCounter[id]<kMinClusters)  continue;
-      AliVTrack   *track    = (AliVTrack*)fTracks.At(id);
+      AliESDtrack   *track    = (AliESDtrack*)fTracksEsd.At(id);
       if (track->GetTPCsignal()<kMinSignal) continue;
       AliExternalTrackParam *param=(AliExternalTrackParam*)fTracksEsdParam.At(id);
       AliTPCLaserTrack *ltrp = ( AliTPCLaserTrack*)fTracksMirror.At(id);
@@ -1106,7 +1099,7 @@ Bool_t  AliTPCcalibLaser::FitDriftV(Float_t minFraction){
       if (!AcceptLaser(id)) continue;
       if ( fClusterSatur[id]>kSaturCut)  continue;
       if ( fClusterCounter[id]<kMinClusters)  continue;
-      AliVTrack   *track    = (AliVTrack*)fTracks.At(id);
+      AliESDtrack   *track    = (AliESDtrack*)fTracksEsd.At(id);
       if (track->GetTPCsignal()<kMinSignal) continue;
       AliExternalTrackParam *param=(AliExternalTrackParam*)fTracksEsdParam.At(id);
       AliTPCLaserTrack *ltrp = ( AliTPCLaserTrack*)fTracksMirror.At(id);
@@ -1363,16 +1356,12 @@ Bool_t  AliTPCcalibLaser::AcceptLaser(Int_t id){
   return kTRUE;
 }
 
-Int_t  AliTPCcalibLaser::FindMirror(AliVTrack *track, AliTPCseed *seed){
+Int_t  AliTPCcalibLaser::FindMirror(AliESDtrack *track, AliTPCseed *seed){
   //
   // Find corresponding mirror
   // add the corresponding tracks
-
-  AliExternalTrackParam trckOut;
-  track->GetTrackParamOp(trckOut);
-  if ((track->GetTrackParamOp(trckOut)) < 0) return -1;
-  AliExternalTrackParam * trackOut = &trckOut;
-  if (!trackOut) return -1;
+  if (!track->GetOuterParam()) return -1;
 
   Float_t kRadius0  = 252;
   Float_t kRadius   = 254.2;
@@ -1402,7 +1391,7 @@ Int_t  AliTPCcalibLaser::FindMirror(AliVTrack *track, AliTPCseed *seed){
   if (csideC>0.5*seed->GetNumberOfClusters()) side=1;
 
 
-  AliExternalTrackParam param(*trackOut);
+  AliExternalTrackParam param(*(track->GetOuterParam()));
   AliTracker::PropagateTrackTo(&param,kRadius0,TDatabasePDG::Instance()->GetParticle("mu+")->Mass(),3,kTRUE);
   AliTracker::PropagateTrackTo(&param,kRadius,TDatabasePDG::Instance()->GetParticle("mu+")->Mass(),0.1,kTRUE);
   AliTPCLaserTrack ltr;
@@ -1447,7 +1436,7 @@ Int_t  AliTPCcalibLaser::FindMirror(AliVTrack *track, AliTPCseed *seed){
   if (accept){
     fClusterCounter[id]=countercl;
     fTracksEsdParam.AddAt(param.Clone(),id);
-    fTracks.AddAt(track,id);
+    fTracksEsd.AddAt(track,id);
     fTracksTPC.AddAt(seed,id);
   }
   return id;
@@ -1459,7 +1448,7 @@ void AliTPCcalibLaser::DumpLaser(Int_t id) {
   //
   //  Dump Laser info to the tree
   //
-  AliVTrack   *track    = (AliVTrack*)fTracks.At(id);
+  AliESDtrack   *track    = (AliESDtrack*)fTracksEsd.At(id);
   AliExternalTrackParam *param=(AliExternalTrackParam*)fTracksEsdParam.At(id);
   AliTPCLaserTrack *ltrp = ( AliTPCLaserTrack*)fTracksMirror.At(id);
   //
@@ -1480,7 +1469,7 @@ void AliTPCcalibLaser::DumpLaser(Int_t id) {
   
   if (fStreamLevel>0){
     TTreeSRedirector *cstream = GetDebugStreamer();
-    Int_t time = fEvent->GetTimeStamp();
+    Int_t time = fESD->GetTimeStamp();
     Bool_t accept = AcceptLaser(id);
     if (cstream){
       (*cstream)<<"Track"<<
index 900f998..9a764a7 100644 (file)
 
 
 class AliExternalTrackParam;
-//class AliESDtrack;
-//class AliESDEvent;
-//class AliESDfriend;
-class AliVEvent;
-class AliVTrack;
-class AliVfriendEvent;
+class AliESDtrack;
+class AliESDEvent;
+class AliESDfriend;
 class TGraphErrors;
 class TTree;
 class TH2F;
@@ -37,7 +34,7 @@ public:
   AliTPCcalibLaser(const AliTPCcalibLaser& laser);
   AliTPCcalibLaser & operator=(const AliTPCcalibLaser& calibLaser);
   virtual ~AliTPCcalibLaser();
-  virtual void     Process(AliVEvent *event);
+  virtual void     Process(AliESDEvent *event);
   Int_t   GetNtracks(){return fNtracks;}
   virtual void Analyze();
   static void        DumpLaser(const char *finput, Int_t run);
@@ -57,14 +54,13 @@ 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(AliVTrack *track, AliTPCseed *seed);
+  Int_t  FindMirror(AliESDtrack *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(AliVTrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);}
+  void     Process(AliESDtrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);};
   void     Process(AliTPCseed *track){return AliTPCcalibBase::Process(track);}
   //
   void SetBeamParameters(TVectorD& meanOffset, TVectorD& meanSlope,
@@ -74,12 +70,12 @@ public:
     {fUseFixedDriftV = 1; fFixedFitAside0=aside0; fFixedFitAside1=aside1;
     fFixedFitCside0=cside0; fFixedFitCside1=cside1;}
 
-  AliVEvent  * fEvent;             //! ESD event  - not OWNER
-  AliVfriendEvent * fEventFriend;       //! ESD event  - not OWNER
+  AliESDEvent  * fESD;             //! ESD event  - not OWNER
+  AliESDfriend * fESDfriend;       //! ESD event  - not OWNER
   Int_t          fNtracks;         //! counter of associated laser tracks
   //
   TObjArray      fTracksMirror;    //! tracks with mirror information
-  TObjArray      fTracks;       //! tracks with reconstructed information -
+  TObjArray      fTracksEsd;       //! tracks with reconstructed information - 
   //                               not owner ESD
   TObjArray      fTracksEsdParam;  //! tracks with reconstructed information - 
   //                               is owner ESD at mirror
index e0b9481..6df9bf4 100644 (file)
@@ -39,16 +39,10 @@ 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 "AliVEvent.h"
-#include "AliVTrack.h"
-#include "AliVfriendEvent.h"
-#include "AliVfriendTrack.h"
-
+#include "AliESDfriend.h"
 #include "AliLog.h"
 #include "AliRelAlignerKalman.h"
 #include "AliTPCCalROC.h"
@@ -372,31 +366,19 @@ void AliTPCcalibTime::ResetCurrent(){
 
 
 
-void AliTPCcalibTime::Process(AliVEvent *event){
+void AliTPCcalibTime::Process(AliESDEvent *event){
   //
   // main function to make calibration
   //
-
-    //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!");
+  if(!event) return;
+  if (event->GetNumberOfTracks()<2) return; 
+  AliESDfriend *ESDfriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
+  if (!ESDfriend) {
     return;
   }
-  if (friendEvent->TestSkipBit()) return;
+  if (ESDfriend->TestSkipBit()) return;
   
   ResetCurrent();
-
-  //AliESDEvent *ev=(AliESDEvent*)event;
   //if(IsLaser  (event)) 
   ProcessLaser (event);
   //if(IsCosmics(event)) 
@@ -405,7 +387,7 @@ void AliTPCcalibTime::Process(AliVEvent *event){
   ProcessBeam  (event);
 }
 
-void AliTPCcalibTime::ProcessLaser(AliVEvent *event){
+void AliTPCcalibTime::ProcessLaser(AliESDEvent *event){
   //
   // Fit drift velocity using laser 
   // 
@@ -534,16 +516,16 @@ void AliTPCcalibTime::ProcessLaser(AliVEvent *event){
   }
 }
 
-void AliTPCcalibTime::ProcessCosmic(const AliVEvent *const event){
+void AliTPCcalibTime::ProcessCosmic(const AliESDEvent *const event){
   //
   // process Cosmic event - track matching A side C side
   //
   if (!event) {
-    //Printf("ERROR: event not available");
+    Printf("ERROR: ESD not available");
     return;
   }  
   if (event->GetTimeStamp() == 0 ) {
-    //Printf("no time stamp!");
+    Printf("no time stamp!");
     return;
   }
   
@@ -560,8 +542,8 @@ void AliTPCcalibTime::ProcessCosmic(const AliVEvent *const event){
   if (ntracks > fCutTracks) return;
   
   if (GetDebugLevel()>20) printf("Hallo world: Im here\n");
-  //AliESDfriend *esdFriend=(AliESDfriend*)(((AliESDEvent*)event)->FindListObject("AliESDfriend"));
-  AliVfriendEvent *friendEvent=event->FindFriend();
+  AliESDfriend *esdFriend=(AliESDfriend*)(((AliESDEvent*)event)->FindListObject("AliESDfriend"));
+  
   TObjArray  tpcSeeds(ntracks);
   Double_t vtxx[3]={0,0,0};
   Double_t svtxx[3]={0.000001,0.000001,100.};
@@ -574,25 +556,17 @@ void AliTPCcalibTime::ProcessCosmic(const AliVEvent *const event){
   for (Int_t i=0;i<ntracks;++i) {
     clusterSideA[i]=0;
     clusterSideC[i]=0;
-    AliVTrack *track = event->GetVTrack(i);
-    if(!track) continue;
-
-    AliExternalTrackParam trckIn;
-    track->GetTrackParamIp(trckIn);
-    if ( (track->GetTrackParamIp(trckIn)) <0) continue;
-    AliExternalTrackParam * trackIn = &trckIn;
+    AliESDtrack *track = event->GetTrack(i);
+    
+    const AliExternalTrackParam * trackIn = track->GetInnerParam();
+    const AliExternalTrackParam * trackOut = track->GetOuterParam();
     if (!trackIn) continue;
-
-    AliExternalTrackParam trckOut;
-    track->GetTrackParamOp(trckOut);
-    if ( (track->GetTrackParamOp(trckOut)) <0) continue;
-    AliExternalTrackParam * trackOut = &trckOut;
     if (!trackOut) continue;
     
-    const AliVfriendTrack *friendTrack = friendEvent->GetTrack(i);
+    AliESDfriendTrack *friendTrack = esdFriend->GetTrack(i);
     if (!friendTrack) continue;
     if (friendTrack) ProcessSame(track,friendTrack,event);
-    if (friendTrack) ProcessAlignITS(track,friendTrack,event,friendEvent);
+    if (friendTrack) ProcessAlignITS(track,friendTrack,event,esdFriend);
     if (friendTrack) ProcessAlignTRD(track,friendTrack);
     if (friendTrack) ProcessAlignTOF(track,friendTrack);
     TObject *calibObject;
@@ -617,29 +591,19 @@ void AliTPCcalibTime::ProcessCosmic(const AliVEvent *const event){
   //
 
   for (Int_t i=0;i<ntracks;++i) {
-    AliVTrack *track0 = event->GetVTrack(i);
+    AliESDtrack *track0 = event->GetTrack(i);
     // track0 - choosen upper part
     if (!track0) continue;
-
-    AliExternalTrackParam trckOut;
-    track0->GetTrackParamOp(trckOut);
-    if ( (track0->GetTrackParamOp(trckOut)) < 0) continue;
-    AliExternalTrackParam * trackOut = &trckOut;
-    if (!trackOut) continue;
-    if (trackOut->GetAlpha()<0) continue;
+    if (!track0->GetOuterParam()) continue;
+    if (track0->GetOuterParam()->GetAlpha()<0) continue;
     Double_t d1[3];
     track0->GetDirection(d1);    
     for (Int_t j=0;j<ntracks;++j) {
       if (i==j) continue;
-      AliVTrack *track1 = event->GetVTrack(j);
+      AliESDtrack *track1 = event->GetTrack(j);   
       //track 1 lower part
       if (!track1) continue;
-
-      AliExternalTrackParam trck1Out;
-      track1->GetTrackParamOp(trck1Out);
-      if ( (track1->GetTrackParamOp(trck1Out)) < 0) continue;
-      AliExternalTrackParam * track1Out = &trck1Out;
-      if (!track1Out) continue;
+      if (!track1->GetOuterParam()) continue;
       if (track0->GetTPCNcls()+ track1->GetTPCNcls()< kMinClusters) continue;
       Int_t nAC = TMath::Max( TMath::Min(clusterSideA[i], clusterSideC[j]), 
                              TMath::Min(clusterSideC[i], clusterSideA[j]));
@@ -676,10 +640,8 @@ void AliTPCcalibTime::ProcessCosmic(const AliVEvent *const event){
       //
       //
       Float_t dmax = TMath::Max(TMath::Abs(dist0),TMath::Abs(dist1));
-      AliExternalTrackParam param0;
-      param0.CopyFromVTrack(track0);
-      AliExternalTrackParam param1;
-      param1.CopyFromVTrack(track1);
+      AliExternalTrackParam param0(*track0);
+      AliExternalTrackParam param1(*track1);
       //
       // Propagate using Magnetic field and correct fo material budget
       //
@@ -797,7 +759,7 @@ void AliTPCcalibTime::ProcessCosmic(const AliVEvent *const event){
   if (GetDebugLevel()>20) printf("Trigger: %s\n",event->GetFiredTriggerClasses().Data());
 }
 
-void AliTPCcalibTime::ProcessBeam(const AliVEvent *const event){
+void AliTPCcalibTime::ProcessBeam(const AliESDEvent *const event){
   //
   // Process beam data - calculates vartex
   //                     from A side and C side
@@ -830,46 +792,27 @@ void AliTPCcalibTime::ProcessBeam(const AliVEvent *const event){
   if (ntracks==0) return;
   if (ntracks > fCutTracks) return;
   //
-  //AliESDfriend *esdFriend=(AliESDfriend*)(((AliESDEvent*)event)->FindListObject("AliESDfriend"));
-  AliVfriendEvent *friendEvent=event->FindFriend();
+  AliESDfriend *esdFriend=(AliESDfriend*)(((AliESDEvent*)event)->FindListObject("AliESDfriend"));
   //
   // 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 vtxSPD;
-  event->GetPrimaryVertexSPD(vtxSPD);
-  AliESDVertex *vertexSPD=&vtxSPD;
-
-  AliESDVertex vtx;
-  event->GetPrimaryVertex(vtx);
-  AliESDVertex *vertex=&vtx;
-
-  AliESDVertex vtxTracks;
-  event->GetPrimaryVertexTracks(vtxTracks);
-  AliESDVertex *vertexTracks=&vtxTracks;
-
-
+  AliESDVertex *vertexSPD =  (AliESDVertex *)event->GetPrimaryVertexSPD();
+  AliESDVertex *vertex    =  (AliESDVertex *)event->GetPrimaryVertex();
+  AliESDVertex *vertexTracks =  (AliESDVertex *)event->GetPrimaryVertexTracks();
   Double_t vertexZA[10000], vertexZC[10000];
   //
   Int_t ntracksA= 0;
   Int_t ntracksC= 0;
   //
   for (Int_t itrack=0;itrack<ntracks;itrack++) {
-    AliVTrack *track = event->GetVTrack(itrack);
-    if(!track) continue;
-    const AliVfriendTrack *friendTrack = friendEvent->GetTrack(itrack);
+    AliESDtrack *track = event->GetTrack(itrack);
+    AliESDfriendTrack *friendTrack = esdFriend->GetTrack(itrack);
     if (!friendTrack) continue;
     if (TMath::Abs(track->GetTgl())>kMaxTgl) continue;
     if (TMath::Abs(track->Pt())<kMinPt) continue;
-    AliExternalTrackParam trckIn;
-    track->GetTrackParamIp(trckIn);
-    AliExternalTrackParam * trackIn = &trckIn;
-
+    const AliExternalTrackParam * trackIn  = track->GetInnerParam();
     TObject *calibObject=0;
     AliTPCseed *seed = 0;
     Int_t nA=0, nC=0;
@@ -1314,23 +1257,17 @@ Bool_t  AliTPCcalibTime::IsPair(const AliExternalTrackParam *tr0, const AliExter
 
   return kTRUE;  
 }
-Bool_t AliTPCcalibTime::IsCross(const AliVTrack *const tr0, const AliVTrack *const tr1){
+Bool_t AliTPCcalibTime::IsCross(const AliESDtrack *const tr0, const AliESDtrack *const tr1){
   //
   // check if the cosmic pair of tracks crossed A/C side
   // 
-  AliExternalTrackParam trck0Out;
-  tr0->GetTrackParamOp(trck0Out);
-
-  AliExternalTrackParam trck1Out;
-  tr1->GetTrackParamOp(trck1Out);
-
-  Bool_t result= trck0Out.GetZ()*trck1Out.GetZ()<0;
+  Bool_t result= tr0->GetOuterParam()->GetZ()*tr1->GetOuterParam()->GetZ()<0;
   if (result==kFALSE) return result;
   result=kTRUE;
   return result;
 }
 
-Bool_t AliTPCcalibTime::IsSame(const AliVTrack *const tr0, const AliVTrack *const tr1){
+Bool_t AliTPCcalibTime::IsSame(const AliESDtrack *const tr0, const AliESDtrack *const tr1){
   // 
   // track crossing the CE
   // 0. minimal number of clusters 
@@ -1352,35 +1289,21 @@ Bool_t AliTPCcalibTime::IsSame(const AliVTrack *const tr0, const AliVTrack *cons
   //
   // 1. alpha cut - sector+-1
   //
-  AliExternalTrackParam trck0Out;
-  tr0->GetTrackParamOp(trck0Out);
-
-  AliExternalTrackParam trck1Out;
-  tr1->GetTrackParamOp(trck1Out);
-
-  if (TMath::Abs(trck0Out.GetAlpha()-trck1Out.GetAlpha())>kalphaCut) return kFALSE;
+  if (TMath::Abs(tr0->GetOuterParam()->GetAlpha()-tr1->GetOuterParam()->GetAlpha())>kalphaCut) return kFALSE;
   //
   // 2. Z crossing
   //
-  AliExternalTrackParam trck0In;
-  tr0->GetTrackParamIp(trck0In);
-
-  AliExternalTrackParam trck1In;
-  tr1->GetTrackParamIp(trck1In);
-  //if (tr0->GetOuterParam()->GetZ()*tr0->GetInnerParam()->GetZ()>0) result&=kFALSE;
-  //if (tr1->GetOuterParam()->GetZ()*tr1->GetInnerParam()->GetZ()>0) result&=kFALSE;
-  if (trck0Out.GetZ()*trck0In.GetZ()>0) result&=kFALSE;
-  if (trck1Out.GetZ()*trck1In.GetZ()>0) result&=kFALSE;
-
+  if (tr0->GetOuterParam()->GetZ()*tr0->GetInnerParam()->GetZ()>0) result&=kFALSE;
+  if (tr1->GetOuterParam()->GetZ()*tr1->GetInnerParam()->GetZ()>0) result&=kFALSE;
   if (result==kFALSE){
     return result;
   }
   //
   //
-  const Double_t *p0I = trck0In.GetParameter();
-  const Double_t *p1I = trck1In.GetParameter();
-  const Double_t *p0O = trck0Out.GetParameter();
-  const Double_t *p1O = trck1Out.GetParameter();
+  const Double_t *p0I = tr0->GetInnerParam()->GetParameter();
+  const Double_t *p1I = tr1->GetInnerParam()->GetParameter();
+  const Double_t *p0O = tr0->GetOuterParam()->GetParameter();
+  const Double_t *p1O = tr1->GetOuterParam()->GetParameter();
   //
   if (TMath::Abs(p0I[0]-p1I[0])>fCutMaxD)  result&=kFALSE;
   if (TMath::Abs(p0I[1]-p1I[1])>fCutMaxDz) result&=kFALSE;
@@ -1397,7 +1320,7 @@ Bool_t AliTPCcalibTime::IsSame(const AliVTrack *const tr0, const AliVTrack *cons
 }
 
 
-void  AliTPCcalibTime::ProcessSame(const AliVTrack *const track, const AliVfriendTrack *const friendTrack, const AliVEvent *const event){
+void  AliTPCcalibTime::ProcessSame(const AliESDtrack *const track, AliESDfriendTrack *const friendTrack, const AliESDEvent *const event){
   //
   // Process  TPC tracks crossing CE
   //
@@ -1411,19 +1334,12 @@ void  AliTPCcalibTime::ProcessSame(const AliVTrack *const track, const AliVfrien
   const Double_t kMaxDy=1;  // maximal distance in y
   const Double_t kMaxDsnp=0.05;  // maximal distance in snp
   const Double_t kMaxDtheta=0.05;  // maximal distance in theta
-
-  AliExternalTrackParam trckIn;
-  track->GetTrackParam(trckIn);
-
-  AliExternalTrackParam trckTPCOut;
-  friendTrack->GetTrackParamTPCOut(trckTPCOut);
-  if ( (friendTrack->GetTrackParamTPCOut(trckTPCOut)) < 0) return;
-  AliExternalTrackParam * trackTPCOut = &trckTPCOut;
-  if (!trackTPCOut) return;
+  
+  if (!friendTrack->GetTPCOut()) return;
   //
   // 0. Select only track crossing the CE
   //
-  if (trckIn.GetZ()*trckTPCOut.GetZ()>0) return;
+  if (track->GetInnerParam()->GetZ()*friendTrack->GetTPCOut()->GetZ()>0) return;
   //
   // 1. cut on track length
   //
@@ -1438,13 +1354,8 @@ void  AliTPCcalibTime::ProcessSame(const AliVTrack *const track, const AliVfrien
   }
   if (!seed) return;
   //
-  //AliExternalTrackParam trackIn(*track->GetInnerParam());
-  AliExternalTrackParam trackIn(trckIn);
-
-  AliExternalTrackParam trckOut;
-  track->GetTrackParamOp(trckOut);
-  AliExternalTrackParam trackOut(trckOut);
-
+  AliExternalTrackParam trackIn(*track->GetInnerParam());
+  AliExternalTrackParam trackOut(*track->GetOuterParam());
   Double_t cov[3]={0.01,0.,0.01}; //use the same errors
   Double_t xyz[3]={0,0.,0.0};  
   Double_t bz   =0;
@@ -1572,7 +1483,7 @@ void  AliTPCcalibTime::ProcessSame(const AliVTrack *const track, const AliVfrien
 
 }
 
-void  AliTPCcalibTime::ProcessAlignITS(AliVTrack *const track, const AliVfriendTrack *const friendTrack, const AliVEvent *const event, AliVfriendEvent *const friendEvent){
+void  AliTPCcalibTime::ProcessAlignITS(AliESDtrack *const track, const AliESDfriendTrack *const friendTrack, const AliESDEvent *const event, AliESDfriend *const esdFriend){
   //
   // Process track - Update TPC-ITS alignment
   // Updates: 
@@ -1601,63 +1512,42 @@ void  AliTPCcalibTime::ProcessAlignITS(AliVTrack *const track, const AliVfriendT
   // 
   Int_t dummycl[1000];
   if (track->GetTPCNcls()<kMinTPC) return;  // minimal amount of clusters cut
-  if (!track->IsOn(AliVTrack::kTPCrefit)) return;
-
-  AliExternalTrackParam trckIn;
-  track->GetTrackParamIp(trckIn);
-  if ( (track->GetTrackParamIp(trckIn)) < 0) return;
-  AliExternalTrackParam * trackIn = &trckIn;
-  if (!trackIn)   return;
-
-  AliExternalTrackParam trckOut;
-  track->GetTrackParamOp(trckOut);
-  if ( (track->GetTrackParamOp(trckOut)) < 0) return;
-  AliExternalTrackParam * trackOut = &trckOut;
-  if (!trackOut)   return;
-
-  if (trackIn->Pt()<kMinPt)  return;
+  if (!track->IsOn(AliESDtrack::kTPCrefit)) return;
+  if (!track->GetInnerParam())   return;
+  if (!track->GetOuterParam())   return;
+  if (track->GetInnerParam()->Pt()<kMinPt)  return;
   // exclude crossing track
-  if (trckOut.GetZ()*trckIn.GetZ()<0)   return;
-  if (TMath::Abs(trackIn->GetZ())<kMinZ/3.)   return;
-  if (trackIn->GetX()>90)   return;
+  if (track->GetOuterParam()->GetZ()*track->GetInnerParam()->GetZ()<0)   return;
+  if (TMath::Abs(track->GetInnerParam()->GetZ())<kMinZ/3.)   return;
+  if (track->GetInnerParam()->GetX()>90)   return;
   //
-  AliExternalTrackParam &pTPC=(AliExternalTrackParam &)(*trackIn);
+  AliExternalTrackParam &pTPC=(AliExternalTrackParam &)(*(track->GetInnerParam()));
   //  
   AliExternalTrackParam pITS;   // ITS standalone if possible
   AliExternalTrackParam pITS2;  //TPC-ITS track
-
-  AliExternalTrackParam trckITSOut;
-  friendTrack->GetTrackParamITSOut(trckITSOut);
-  AliExternalTrackParam * trackITSOut = &trckITSOut;
-
-  if ( (friendTrack->GetTrackParamITSOut(trckITSOut)) == 0 && (trackITSOut) ){
-    pITS2=(*trackITSOut);  //TPC-ITS track - snapshot ITS out
+  if (friendTrack->GetITSOut()){
+    pITS2=(*(friendTrack->GetITSOut()));  //TPC-ITS track - snapshot ITS out
     pITS2.Rotate(pTPC.GetAlpha());
     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++){
-    AliVTrack * trackITS = event->GetVTrack(i);
+    AliESDtrack * trackITS = event->GetTrack(i); 
     if (!trackITS) continue;
     if (trackITS->GetITSclusters(dummycl)<kMinITS) continue;  // minimal amount of clusters
-    const AliVfriendTrack *itsfriendTrack = friendEvent->GetTrack(i);
+    itsfriendTrack = esdFriend->GetTrack(i);
     if (!itsfriendTrack) continue;
-
-    AliExternalTrackParam itstrckOut;
-    itsfriendTrack->GetTrackParamITSOut(itstrckOut);
-    if ( (itsfriendTrack->GetTrackParamITSOut(itstrckOut)) < 0) continue;
-    AliExternalTrackParam * ITStrackOut = &itstrckOut;
-    if (!ITStrackOut) continue;
+    if (!itsfriendTrack->GetITSOut()) continue;
      
-    if (TMath::Abs(pTPC.GetTgl()-ITStrackOut->GetTgl())> kMaxAngle) continue;
-    if (TMath::Abs(pTPC.GetSigned1Pt()-ITStrackOut->GetSigned1Pt())> kMax1Pt) continue;
-    pITS=(*ITStrackOut);
+    if (TMath::Abs(pTPC.GetTgl()-itsfriendTrack->GetITSOut()->GetTgl())> kMaxAngle) continue;
+    if (TMath::Abs(pTPC.GetSigned1Pt()-itsfriendTrack->GetITSOut()->GetSigned1Pt())> kMax1Pt) continue;
+    pITS=(*(itsfriendTrack->GetITSOut()));
     //
     pITS.Rotate(pTPC.GetAlpha());
     AliTracker::PropagateTrackToBxByBz(&pITS,pTPC.GetX(),0.1,0.1,kFALSE);
@@ -1782,7 +1672,7 @@ void  AliTPCcalibTime::ProcessAlignITS(AliVTrack *const track, const AliVfriendT
 
 
 
-void  AliTPCcalibTime::ProcessAlignTRD(AliVTrack *const track, const AliVfriendTrack *const friendTrack){
+void  AliTPCcalibTime::ProcessAlignTRD(AliESDtrack *const track, const AliESDfriendTrack *const friendTrack){
   //
   // Process track - Update TPC-TRD alignment
   // Updates: 
@@ -1813,27 +1703,17 @@ void  AliTPCcalibTime::ProcessAlignTRD(AliVTrack *const track, const AliVfriendT
   if (track->GetTPCNcls()<kMinTPC) return;  // minimal amount of clusters cut
   //  if (!friendTrack->GetTRDIn()) return;  
   //  if (!track->IsOn(AliESDtrack::kTRDrefit)) return;   
-  if (!track->IsOn(AliVTrack::kTRDout)) return;
-
-  AliExternalTrackParam trckIn;
-  track->GetTrackParamIp(trckIn);
-  if ( (track->GetTrackParamIp(trckIn)) < 0) return;
-  AliExternalTrackParam * trackIn = &trckIn;
-  if (!trackIn)   return;
-
-  AliExternalTrackParam trckTPCOut;
-  friendTrack->GetTrackParamTPCOut(trckTPCOut);
-  if ( (friendTrack->GetTrackParamTPCOut(trckTPCOut)) < 0) return;
-  AliExternalTrackParam * trackTPCOut = &trckTPCOut;
-  if (!trackTPCOut)   return;
+  if (!track->IsOn(AliESDtrack::kTRDout)) return;  
+  if (!track->GetInnerParam())   return;
+  if (!friendTrack->GetTPCOut())   return;
   // exclude crossing track
-  if (trckTPCOut.GetZ()*trckIn.GetZ()<0)   return;
+  if (friendTrack->GetTPCOut()->GetZ()*track->GetInnerParam()->GetZ()<0)   return;
   //
-  AliExternalTrackParam &pTPC=(AliExternalTrackParam &)(*trackTPCOut);
+  AliExternalTrackParam &pTPC=(AliExternalTrackParam &)(*(friendTrack->GetTPCOut()));
   AliTracker::PropagateTrackToBxByBz(&pTPC,kRefX,0.1,0.1,kFALSE);
   AliExternalTrackParam *pTRDtrack = 0; 
   TObject *calibObject=0;
-  for (Int_t l=0;(calibObject=friendTrack->GetCalibObject(l));++l) {
+  for (Int_t l=0;(calibObject=((AliESDfriendTrack*)friendTrack)->GetCalibObject(l));++l) {
     if ((dynamic_cast< AliTPCseed*>(calibObject))) continue;
     if ((pTRDtrack=dynamic_cast< AliExternalTrackParam*>(calibObject))) break;
   }
@@ -1960,7 +1840,7 @@ void  AliTPCcalibTime::ProcessAlignTRD(AliVTrack *const track, const AliVfriendT
 }
 
 
-void  AliTPCcalibTime::ProcessAlignTOF(AliVTrack *const track, const AliVfriendTrack *const friendTrack){
+void  AliTPCcalibTime::ProcessAlignTOF(AliESDtrack *const track, const AliESDfriendTrack *const friendTrack){
   //
   //
   // Process track - Update TPC-TOF alignment
@@ -1989,22 +1869,12 @@ void  AliTPCcalibTime::ProcessAlignTOF(AliVTrack *const track, const AliVfriendT
   //     Clusters are not in friends - use alingment points
   //
   if (track->GetTOFsignal()<=0)  return;
-
-  AliExternalTrackParam trckIn;
-  track->GetTrackParamIp(trckIn);
-  if ( (track->GetTrackParamIp(trckIn)) < 0) return;
-  AliExternalTrackParam * trackIn = &trckIn;
-  if (!trackIn)   return;
-
-  AliExternalTrackParam trckTPCOut;
-  friendTrack->GetTrackParamTPCOut(trckTPCOut);
-  if ( (friendTrack->GetTrackParamTPCOut(trckTPCOut)) < 0) return;
-  AliExternalTrackParam * trackTPCOut = &trckTPCOut;
-  if (!trackTPCOut)   return;
-
+  if (!friendTrack->GetTPCOut()) return;
+  if (!track->GetInnerParam())   return;
+  if (!friendTrack->GetTPCOut())   return;
   const AliTrackPointArray *points=friendTrack->GetTrackPointArray();
   if (!points) return;
-  AliExternalTrackParam pTPC(*trackTPCOut);
+  AliExternalTrackParam pTPC(*(friendTrack->GetTPCOut()));
   AliExternalTrackParam pTOF(pTPC);
   Double_t mass = TDatabasePDG::Instance()->GetParticle("mu+")->Mass();
   Int_t npoints = points->GetNPoints();
@@ -2037,7 +1907,7 @@ void  AliTPCcalibTime::ProcessAlignTOF(AliVTrack *const track, const AliVfriendT
   //
   if (track->GetTPCNcls()<kMinTPC) return;  // minimal amount of clusters cut
   // exclude crossing track
-  if (trckTPCOut.GetZ()*trckIn.GetZ()<0)   return;
+  if (friendTrack->GetTPCOut()->GetZ()*track->GetInnerParam()->GetZ()<0)   return;
   //
   if (TMath::Abs(pTOF.GetY()-pTPC.GetY())    >kMaxDy)    return;
   if (TMath::Abs(pTOF.GetSnp()-pTPC.GetSnp())>kMaxAngle) return;
@@ -2323,26 +2193,18 @@ void        AliTPCcalibTime::FillResHistoTPCITS(const AliExternalTrackParam * pT
 }  
 
      
-void        AliTPCcalibTime::FillResHistoTPC(const AliVTrack *pTrack){
+void        AliTPCcalibTime::FillResHistoTPC(const AliESDtrack * pTrack){
   //
   // fill residual histograms pTPC - vertex
   // Histogram is filled only for primary tracks
   //
   if (fMemoryMode<2) return;
   Double_t histoX[4];
-  AliExternalTrackParam prmTPCIn;
-  pTrack->GetTrackParamIp(prmTPCIn);
-  AliExternalTrackParam * pTPCIn = &prmTPCIn;
-
-  AliExternalTrackParam pTPCvertex(*pTPCIn);
+  const AliExternalTrackParam * pTPCIn = pTrack->GetInnerParam();
+  AliExternalTrackParam pTPCvertex(*(pTrack->GetInnerParam()));
   //
-
-  AliExternalTrackParam cnstrPrm;
-  pTrack->GetTrackParamCp(cnstrPrm);
-  if ( (pTrack->GetTrackParamCp(cnstrPrm)) <0) return;
-  AliExternalTrackParam * constrainedParam = &cnstrPrm;
-  if (!constrainedParam) return;
-  AliExternalTrackParam lits(*constrainedParam);
+  if (!(pTrack->GetConstrainedParam())) return;
+  AliExternalTrackParam lits(*(pTrack->GetConstrainedParam()));
   if (TMath::Abs(pTrack->GetY())>3) return;  // beam pipe
   pTPCvertex.Rotate(lits.GetAlpha());
   //pTPCvertex.PropagateTo(pTPCvertex->GetX(),fMagF);
index 265f5f4..ea629f7 100644 (file)
@@ -20,17 +20,12 @@ class TH3F;
 class TH2F;
 class TH1D;
 class TList;
-//class AliESDEvent;
-class AliVEvent;
-//class AliESDtrack;
-class AliVTrack;
-class AliExternalTrackParam;
+class AliESDEvent;
+class AliESDtrack;
 class AliTPCcalibLaser;
 class TGraphErrors;
 class AliSplineFit;
-//class AliESDfriendTrack;
-class AliVfriendTrack;
-class AliVfriendEvent;
+class AliESDfriendTrack;
 
 class AliTPCcalibTime:public AliTPCcalibBase {
 public:
@@ -38,26 +33,22 @@ 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(AliVEvent *event);
+  virtual void           Process(AliESDEvent *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 (AliVEvent *event);
-  void                   ProcessCosmic(const AliVEvent *const event);
-  void                   ProcessBeam  (const AliVEvent *const event);
-
+  void                   ProcessLaser (AliESDEvent *event);
+  void                   ProcessCosmic(const AliESDEvent *const event);
+  void                   ProcessBeam  (const AliESDEvent *const event);
   Bool_t                 IsPair(const AliExternalTrackParam *tr0, const AliExternalTrackParam *tr1);
-  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);
+  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);
 
   THnSparse*    GetHistVdriftLaserA(Int_t index=1) const {return fHistVdriftLaserA[index];};
   THnSparse*    GetHistVdriftLaserC(Int_t index=1) const {return fHistVdriftLaserC[index];};
@@ -68,8 +59,7 @@ 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(AliVTrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);}
+  void     Process(AliESDtrack *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
@@ -87,7 +77,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 AliVTrack * pTrack);
+  void        FillResHistoTPC(const AliESDtrack * pTrack);
   void        FillResHistoTPCTRD(const AliExternalTrackParam * pTPCOut, const AliExternalTrackParam * pTRDIn );
   void        FillResHistoTPCTOF(const AliExternalTrackParam * pTPCOut, const AliExternalTrackParam * pTOFIn );
 
index b9a59d0..2245496 100644 (file)
@@ -156,16 +156,11 @@ 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"
@@ -313,27 +308,19 @@ AliTPCcalibTimeGain::~AliTPCcalibTimeGain(){
 }
 
 
-void AliTPCcalibTimeGain::Process(AliVEvent *event) {
+void AliTPCcalibTimeGain::Process(AliESDEvent *event) {
   //
   // main track loop
   //
-    //Printf("AliTPCcalibTimeGain::Process(event)...");
-
   if (!event) {
-    //Printf("ERROR AliTPCcalibTimeGain::Process(): event not available");
+    Printf("ERROR: ESD not available");
     return;
   }
-
-  AliVfriendEvent *friendEvent=event->FindFriend();
-
-  if (!friendEvent) {
-      //Printf("ERROR AliTPCcalibTimeGain::Process(): friendEvent not available");
+  AliESDfriend *ESDfriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
+  if (!ESDfriend) {
    return;
   }
-  //Printf("friendEvent->TestSkipBit() = %d",friendEvent->TestSkipBit() );
-  if (friendEvent->TestSkipBit()) {
-      return;
-  }
+  if (ESDfriend->TestSkipBit()) return;
 
   if (fIsCosmic) { // this should be removed at some point based on trigger mask !?
     ProcessCosmicEvent(event);
@@ -341,45 +328,37 @@ void AliTPCcalibTimeGain::Process(AliVEvent *event) {
     ProcessBeamEvent(event);
   }
   
+
+  
+  
 }
 
 
-void AliTPCcalibTimeGain::ProcessCosmicEvent(AliVEvent *event) {
+void AliTPCcalibTimeGain::ProcessCosmicEvent(AliESDEvent *event) {
   //
   // Process in case of cosmic event
   //
-    //Printf("AliTPCcalibTimeGain::ProcessCosmicEvent(event)...");
-
-  AliVfriendEvent *friendEvent=event->FindFriend();
-  if (!friendEvent) {
-   //Printf("ERROR AliTPCcalibTimeGain::ProcessCosmicEvent(): ESDfriend not available");
+  AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
+  if (!esdFriend) {
+   Printf("ERROR: ESDfriend not available");
    return;
   }
   //
   UInt_t time = event->GetTimeStamp();
-  Int_t nFriendTracks = friendEvent->GetNumberOfTracks();
+  Int_t nFriendTracks = esdFriend->GetNumberOfTracks();
   Int_t runNumber = event->GetRunNumber();
   //
   // track loop
   //
   for (Int_t i=0;i<nFriendTracks;++i) {
 
-    AliVTrack *track = event->GetVTrack(i);
+    AliESDtrack *track = event->GetTrack(i);
     if (!track) continue;
-    const AliVfriendTrack *friendTrack = friendEvent->GetTrack(i);
-    if (!friendTrack) continue;
-    //const AliExternalTrackParam * trackIn = track->GetInnerParam();
-    AliExternalTrackParam trckIn;
-    track->GetTrackParamIp(trckIn);
-    if ( (track->GetTrackParamIp(trckIn)) < 0) continue;
-    AliExternalTrackParam * trackIn = &trckIn;
+    AliESDfriendTrack *friendTrack = esdFriend->GetTrack(i);
+    if (!friendTrack) continue;        
+    const AliExternalTrackParam * trackIn = track->GetInnerParam();
+    const AliExternalTrackParam * trackOut = friendTrack->GetTPCOut();
     if (!trackIn) continue;
-
-    //const AliExternalTrackParam * trackOut = friendTrack->GetTPCOut();
-    AliExternalTrackParam trckOut;
-    friendTrack->GetTrackParamTPCOut(trckOut);
-    if ( (friendTrack->GetTrackParamTPCOut(trckOut)) < 0) continue;
-    AliExternalTrackParam * trackOut = &trckOut;
     if (!trackOut) continue;
 
     // calculate necessary track parameters
@@ -418,49 +397,32 @@ void AliTPCcalibTimeGain::ProcessCosmicEvent(AliVEvent *event) {
 
 
 
-void AliTPCcalibTimeGain::ProcessBeamEvent(AliVEvent *event) {
+void AliTPCcalibTimeGain::ProcessBeamEvent(AliESDEvent *event) {
   //
   // Process in case of beam event
   //
-    //Printf("AliTPCcalibTimeGain::ProcessBeamEvent(event)...");
-
-  AliVfriendEvent *friendEvent=event->FindFriend();
-  if (!friendEvent) {
-   //Printf("ERROR AliTPCcalibTimeGain::ProcessBeamEvent(): ESDfriend not available");
+  AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
+  if (!esdFriend) {
+   Printf("ERROR: ESDfriend not available");
    return;
   }
   //
   UInt_t time = event->GetTimeStamp();
-  if (!time) Printf("ERROR: no time stamp available!");
-  Int_t nFriendTracks = friendEvent->GetNumberOfTracks();
+  Int_t nFriendTracks = esdFriend->GetNumberOfTracks();
   Int_t runNumber = event->GetRunNumber();
   //
   // track loop
   //
   for (Int_t i=0;i<nFriendTracks;++i) { // begin track loop
 
-    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;
-    }
+    AliESDtrack *track = event->GetTrack(i);
+    if (!track) continue;
+    AliESDfriendTrack *friendTrack = esdFriend->GetTrack(i);
+    if (!friendTrack) continue;
         
-    //const AliExternalTrackParam * trackIn = track->GetInnerParam();
-    AliExternalTrackParam trckIn;
-    track->GetTrackParamIp(trckIn);
-    if ( (track->GetTrackParamIp(trckIn)) < 0) continue;
-    AliExternalTrackParam * trackIn = &trckIn;
+    const AliExternalTrackParam * trackIn = track->GetInnerParam();
+    const AliExternalTrackParam * trackOut = friendTrack->GetTPCOut();
     if (!trackIn) continue;
-
-    //const AliExternalTrackParam * trackOut = friendTrack->GetTPCOut();
-    AliExternalTrackParam trckOut;
-    friendTrack->GetTrackParamTPCOut(trckOut);
-    if ( (friendTrack->GetTrackParamTPCOut(trckOut)) < 0) continue;
-    AliExternalTrackParam * trackOut = &trckOut;
     if (!trackOut) continue;
 
     // calculate necessary track parameters
@@ -476,13 +438,13 @@ void AliTPCcalibTimeGain::ProcessBeamEvent(AliVEvent *event) {
     if (TMath::Abs(trackIn->Eta()) > fCutEtaWindow) continue;
     //
     UInt_t status = track->GetStatus();
-    if ((status&AliVTrack::kTPCrefit)==0) continue;
-    if ((status&AliVTrack::kITSrefit)==0 && fCutRequireITSrefit) continue; // ITS cluster
+    if ((status&AliESDtrack::kTPCrefit)==0) continue;
+    if ((status&AliESDtrack::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&AliVTrack::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;
     //
     Double_t eta = trackIn->Eta();
     
@@ -514,12 +476,10 @@ void AliTPCcalibTimeGain::ProcessBeamEvent(AliVEvent *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);
     }
     
@@ -528,13 +488,7 @@ void AliTPCcalibTimeGain::ProcessBeamEvent(AliVEvent *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 v0dummy;
-     event->GetV0(v0dummy, iv0);
-     AliESDv0 *v0 = &v0dummy;
-
-     //if (!v0) Printf("ERROR AliTPCcalibTimeGain::ProcessBeamEvent(): ESDv0 not available! ");
-
+    AliESDv0 * v0 = event->GetV0(iv0);
     if (!v0->GetOnFlyStatus()) continue;
     if (v0->GetEffMass(0,0) > 0.02) continue; // select low inv. mass
     Double_t xyz[3];
@@ -545,24 +499,13 @@ void AliTPCcalibTimeGain::ProcessBeamEvent(AliVEvent *event) {
     //
     for(Int_t idaughter = 0; idaughter < 2; idaughter++) { // daughter loop
       Int_t index = idaughter == 0 ? v0->GetPindex() : v0->GetNindex();
-      AliVTrack * trackP = event->GetVTrack(index);
-      if (!trackP) continue; //Printf("***ERROR*** trackP not available!");
-      const AliVfriendTrack *friendTrackP = friendEvent->GetTrack(index);
+      AliESDtrack * trackP = event->GetTrack(index);
+      AliESDfriendTrack *friendTrackP = esdFriend->GetTrack(index);
       if (!friendTrackP) continue;
-      //const AliExternalTrackParam * trackPIn = trackP->GetInnerParam();
-      AliExternalTrackParam trckPIn;
-      trackP->GetTrackParamIp(trckPIn);
-      if ( (trackP->GetTrackParamIp(trckPIn)) < 0) continue;
-      AliExternalTrackParam * trackPIn = &trckPIn;
+      const AliExternalTrackParam * trackPIn = trackP->GetInnerParam();
+      const AliExternalTrackParam * trackPOut = friendTrackP->GetTPCOut();
       if (!trackPIn) continue;
-
-      //const AliExternalTrackParam * trackPOut = friendTrackP->GetTPCOut();
-      AliExternalTrackParam trckPOut;
-      friendTrackP->GetTrackParamTPCOut(trckPOut);
-      if ( (friendTrackP->GetTrackParamTPCOut(trckPOut)) < 0) continue;
-      AliExternalTrackParam * trackPOut = &trckPOut;
       if (!trackPOut) continue;
-
       // calculate necessary track parameters
       Double_t meanP = trackPIn->GetP();
       Double_t meanDrift = 250 - 0.5*TMath::Abs(trackPIn->GetZ() + trackPOut->GetZ());
@@ -584,8 +527,7 @@ void AliTPCcalibTimeGain::ProcessBeamEvent(AliVEvent *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)};
-    //Printf("Fill Gain histo in v0 loop...");
-    fHistGainTime->Fill(vec);
+       fHistGainTime->Fill(vec);
       }
     }
     
index ff6becd..385417b 100644 (file)
@@ -17,10 +17,8 @@ class TH3F;
 class TH2F;
 class TList;
 class TGraphErrors;
-//class AliESDEvent;
-class AliVEvent;
-//class AliESDtrack;
-class AliVTrack;
+class AliESDEvent;
+class AliESDtrack;
 class AliTPCcalibLaser;
 class AliTPCseed;
 
@@ -33,16 +31,12 @@ 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(AliVEvent *event);
+  virtual void           Process(AliESDEvent *event);
   virtual Long64_t       Merge(TCollection *li);
   virtual void           AnalyzeRun(Int_t minEntries);
   //
-  //void                   ProcessCosmicEvent(AliESDEvent *event);
-  //void                   ProcessBeamEvent(AliESDEvent *event);
-
-  void                   ProcessCosmicEvent(AliVEvent *event);
-  void                   ProcessBeamEvent(AliVEvent *event);
+  void                   ProcessCosmicEvent(AliESDEvent *event);
+  void                   ProcessBeamEvent(AliESDEvent *event);
   //
   void                   CalculateBetheAlephParams(TH2F *hist, Double_t * ini);
   static void            BinLogX(THnSparse *h, Int_t axisDim);
@@ -121,7 +115,7 @@ private:
   //
   AliTPCcalibTimeGain(const AliTPCcalibTimeGain&); 
   AliTPCcalibTimeGain& operator=(const AliTPCcalibTimeGain&); 
-  void     Process(AliVTrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);}
+  void     Process(AliESDtrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);};
   void     Process(AliTPCseed *track){return AliTPCcalibBase::Process(track);}
 
   ClassDef(AliTPCcalibTimeGain, 2);
index b143214..17fb28a 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 5e25f2b..e486a1c 100644 (file)
@@ -35,16 +35,14 @@ 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 AliVEvent;
-class AliVTrack;
+class AliESDEvent;
 
 using namespace std;
 
@@ -58,10 +56,8 @@ public :
   virtual ~AliTPCcalibTracks();                // destructor
   
   virtual void            Process(AliTPCseed *track);  // to be called by the Selector
-  //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);}
+  void     Process(AliESDEvent *event) {AliTPCcalibBase::Process(event);};
+  void     Process(AliESDtrack *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 381d201..e39032a 100644 (file)
@@ -143,7 +143,7 @@ Int_t AliTPCcalibTracksCuts::AcceptTrack(const AliTPCseed * track) const {
   return 0;
 }
 
-Int_t AliTPCcalibTracksCuts::AcceptTrack(const AliVTrack * track) const {
+Int_t AliTPCcalibTracksCuts::AcceptTrack(const AliESDtrack * track) const {
   //
   // Function, that decides wheather a given track is accepted for 
   // the analysis or not. 
index 97a3ea8..519b92e 100644 (file)
@@ -18,7 +18,7 @@
 
 class TChain;
 class AliTPCseed;
-class AliVTrack;
+class AliESDtrack;
 
 using namespace std;
 
@@ -33,7 +33,7 @@ public:
    static  AliTPCcalibTracksCuts  *CreateCuts(char* ctype);
 
    Int_t AcceptTrack(const AliTPCseed * track) const;
-   Int_t AcceptTrack(const AliVTrack * track) const;
+   Int_t AcceptTrack(const AliESDtrack * track) const;
 
    void SetMinClusters(Int_t minClusters){fMinClusters = minClusters;}
    void SetMinRatio(Float_t minRatio){fMinRatio = minRatio;}
index 242ad98..545ad0d 100644 (file)
@@ -98,10 +98,8 @@ public:
 
 
   TLinearFitter*  GetFitter(UInt_t segment, UInt_t padType, UInt_t fitType);  
-  //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);}
+  void     Process(AliESDEvent *event) {AliTPCcalibBase::Process(event);};
+  void     Process(AliESDtrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);};
   
 public:
   //
index dabb9a2..2cfad02 100644 (file)
 
 #include "AliMagF.h"
 #include "AliTracker.h"
-//#include "AliESDEvent.h"
+#include "AliESDEvent.h"
 #include "AliESDtrack.h"
 #include "AliESDfriend.h"
-#include "AliESDfriendTrack.h"
-#include "AliESDVertex.h"
-
-#include "AliVEvent.h"
-#include "AliVTrack.h"
-#include "AliVfriendTrack.h"
-#include "AliVfriendEvent.h"
-
+#include "AliESDfriendTrack.h" 
 #include "AliMathBase.h" 
 #include "AliTPCseed.h"
 #include "AliTPCclusterMI.h"
@@ -62,7 +55,7 @@ AliTPCcalibV0::AliTPCcalibV0() :
    fV0Tree(0),
    fHPTTree(0),
    fStack(0),
-   fEvent(0),
+   fESD(0),
    fPdg(0),
    fParticles(0),
    fV0s(0),
@@ -75,7 +68,7 @@ AliTPCcalibV0::AliTPCcalibV0(const Text_t *name, const Text_t *title):
    fV0Tree(0),
    fHPTTree(0),
    fStack(0),
-   fEvent(0),
+   fESD(0),
    fPdg(0),
    fParticles(0),
    fV0s(0),
@@ -99,44 +92,43 @@ AliTPCcalibV0::~AliTPCcalibV0(){
 
 
 
-void  AliTPCcalibV0::ProcessESD(AliVEvent *event){
+void  AliTPCcalibV0::ProcessESD(AliESDEvent *esd){
   //
   //
   //
-  fEvent = event;
-  AliKFParticle::SetField(event->GetMagneticField());
+  fESD = esd;
+  AliKFParticle::SetField(esd->GetMagneticField());
   if (TMath::Abs(AliTracker::GetBz())<1) return;  
-  DumpToTree(event);
-  DumpToTreeHPT(event);
+  DumpToTree(esd);
+  DumpToTreeHPT(esd);
 }
 
-void  AliTPCcalibV0::DumpToTreeHPT(AliVEvent *event){
+void  AliTPCcalibV0::DumpToTreeHPT(AliESDEvent *esd){
   //
   // 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.;
-  AliVfriendEvent *friendEvent=event->FindFriend();
+  AliESDfriend *esdFriend=static_cast<AliESDfriend*>(esd->FindListObject("AliESDfriend"));
 //   if (!esdFriend) {
 //     Printf("ERROR: esdFriend not available");
 //     return;
 //   }
   //
-  Int_t ntracks=event->GetNumberOfTracks();
+  Int_t ntracks=esd->GetNumberOfTracks();
   for (Int_t i=0;i<ntracks;++i) {
     Bool_t isOK=kFALSE;
-    AliVTrack *track = event->GetVTrack(i);
-    if(!track) continue;
+    AliESDtrack *track = esd->GetTrack(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(AliVTrack::kITSrefit)) isAccepted=kFALSE;
-      if (!track->IsOn(AliVTrack::kTPCrefit)) isAccepted=kFALSE;
-      if (!track->IsOn(AliVTrack::kTOFout))   isAccepted=kFALSE;
+      if (!track->IsOn(AliESDtrack::kITSrefit)) isAccepted=kFALSE;
+      if (!track->IsOn(AliESDtrack::kTPCrefit)) isAccepted=kFALSE;
+      if (!track->IsOn(AliESDtrack::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;
@@ -147,25 +139,25 @@ void  AliTPCcalibV0::DumpToTreeHPT(AliVEvent *event){
       if (!isAccepted) isOK=kFALSE;
     } 
     if ( track->GetTPCsignal()>100 && track->GetInnerParam()->Pt()>1 ){
-      if (track->IsOn(AliVTrack::kITSin)||track->IsOn(AliVTrack::kTRDout)||track->IsOn(AliVTrack::kTOFin))
+      if (track->IsOn(AliESDtrack::kITSin)||track->IsOn(AliESDtrack::kTRDout)||track->IsOn(AliESDtrack::kTOFin))
        isOK=kTRUE;
       if (isOK){
        TString filename(AliAnalysisManager::GetAnalysisManager()->GetTree()->GetCurrentFile()->GetName());
-    Int_t eventNumber = event->GetEventNumberInFile();
-    Bool_t hasFriend=(friendEvent) ? (friendEvent->GetTrack(i)!=0):0;
+       Int_t eventNumber = esd->GetEventNumberInFile();
+       Bool_t hasFriend=(esdFriend) ? (esdFriend->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 = event->GetEventNumberInFile();
-    Bool_t hasFriend=(friendEvent) ? (friendEvent->GetTrack(i)!=0):0;
+    Int_t eventNumber = esd->GetEventNumberInFile();   
+    Bool_t hasFriend=(esdFriend) ? (esdFriend->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 (!friendEvent) continue;
-    const AliVfriendTrack *friendTrack = friendEvent->GetTrack(i);
+    if (!esdFriend) continue;
+    AliESDfriendTrack *friendTrack = esdFriend->GetTrack(i);
     if (!friendTrack) continue;
 
     if (!isOK) continue;
@@ -181,24 +173,15 @@ void  AliTPCcalibV0::DumpToTreeHPT(AliVEvent *event){
       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.",&dummytrack);
-      fHPTTree->Branch("ft.",&dummyfriendTrack);
+      fHPTTree->Branch("t.",&track);
+      fHPTTree->Branch("ft.",&friendTrack);
       fHPTTree->Branch("s.",&seed);
     }else{
-      fHPTTree->SetBranchAddress("t.",&dummytrack);
-      fHPTTree->SetBranchAddress("ft.",&dummyfriendTrack);
+      fHPTTree->SetBranchAddress("t.",&track);
+      fHPTTree->SetBranchAddress("ft.",&friendTrack);
       fHPTTree->SetBranchAddress("s.",&seed);
     }
     fHPTTree->Fill();
@@ -208,30 +191,25 @@ void  AliTPCcalibV0::DumpToTreeHPT(AliVEvent *event){
 
 
 
-void  AliTPCcalibV0::DumpToTree(AliVEvent *event){
+void  AliTPCcalibV0::DumpToTree(AliESDEvent *esd){
   //
   // Dump V0s fith full firend information to the 
   // 
-  Int_t nV0s  = fEvent->GetNumberOfV0s();
+  Int_t nV0s  = fESD->GetNumberOfV0s();
   const Int_t kMinCluster=110;
   const Double_t kDownscale=0.01;
   const Float_t kMinPt   =1.0;
   const Float_t kMinMinPt   =0.7;
-  AliVfriendEvent *friendEvent=event->FindFriend();
+  AliESDfriend *esdFriend=static_cast<AliESDfriend*>(esd->FindListObject("AliESDfriend"));
   //
   
   for (Int_t ivertex=0; ivertex<nV0s; ivertex++){
     Bool_t isOK=kFALSE;
-    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) continue;
+    AliESDv0 * v0 = (AliESDv0*) esd->GetV0(ivertex);
+    AliESDtrack * track0 = fESD->GetTrack(v0->GetIndex(0)); // negative track
+    AliESDtrack * track1 = fESD->GetTrack(v0->GetIndex(1)); // positive track 
     if (track0->GetTPCNcls()<kMinCluster) continue;
-    if (track0->GetKinkIndex(0)>0) continue;
-    if(!track1) continue;
+    if (track0->GetKinkIndex(0)>0) continue;    
     if (track1->GetTPCNcls()<kMinCluster) continue;
     if (track1->GetKinkIndex(0)>0) continue;
     if (v0->GetOnFlyStatus()==kFALSE) continue;
@@ -244,17 +222,17 @@ void  AliTPCcalibV0::DumpToTree(AliVEvent *event){
     if (!isOK) continue;
     //
     TString filename(AliAnalysisManager::GetAnalysisManager()->GetTree()->GetCurrentFile()->GetName());
-    Int_t eventNumber = event->GetEventNumberInFile();
+    Int_t eventNumber = esd->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,(friendEvent!=0), hasITS);
+    printf("DUMPHPTV0:%s|%f|%d|%d|%d\n",filename.Data(), (TMath::Min(track0->Pt(),track1->Pt())), eventNumber,(esdFriend!=0), hasITS);
     //
-    if (!friendEvent) continue;
+    if (!esdFriend) continue;
     //
     
     //
-    const AliVfriendTrack *ftrack0 = friendEvent->GetTrack(v0->GetIndex(0));
+    AliESDfriendTrack *ftrack0 = esdFriend->GetTrack(v0->GetIndex(0));
     if (!ftrack0) continue;
-    const AliVfriendTrack *ftrack1 = friendEvent->GetTrack(v0->GetIndex(1));
+    AliESDfriendTrack *ftrack1 = esdFriend->GetTrack(v0->GetIndex(1));
     if (!ftrack1) continue;
     //
     TObject *calibObject;
@@ -278,32 +256,22 @@ void  AliTPCcalibV0::DumpToTree(AliVEvent *event){
       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.",&dummytrack0);
-      fV0Tree->Branch("t1.",&dummytrack1);
-      fV0Tree->Branch("ft0.",&dummyftrack0);
-      fV0Tree->Branch("ft1.",&dummyftrack1);
+      fV0Tree->Branch("t0.",&track0);
+      fV0Tree->Branch("t1.",&track1);
+      fV0Tree->Branch("ft0.",&ftrack0);
+      fV0Tree->Branch("ft1.",&ftrack1);
       fV0Tree->Branch("s0.",&seed0);
       fV0Tree->Branch("s1.",&seed1);
     }else{
       fV0Tree->SetBranchAddress("v0.",&v0);
-      fV0Tree->SetBranchAddress("t0.",&dummytrack0);
-      fV0Tree->SetBranchAddress("t1.",&dummytrack1);
-      fV0Tree->SetBranchAddress("ft0.",&dummyftrack0);
-      fV0Tree->SetBranchAddress("ft1.",&dummyftrack1);
+      fV0Tree->SetBranchAddress("t0.",&track0);
+      fV0Tree->SetBranchAddress("t1.",&track1);
+      fV0Tree->SetBranchAddress("ft0.",&ftrack0);
+      fV0Tree->SetBranchAddress("ft1.",&ftrack1);
       fV0Tree->SetBranchAddress("s0.",&seed0);
       fV0Tree->SetBranchAddress("s1.",&seed1);
     }
@@ -917,7 +885,7 @@ void AliTPCcalibV0::BinLogX(TH2F *h) {
 
 
 
-void AliTPCcalibV0::FilterV0s(AliVEvent *event){
+void AliTPCcalibV0::FilterV0s(AliESDEvent* event){
   //
   // 
   TDatabasePDG pdg;  
@@ -926,26 +894,12 @@ void AliTPCcalibV0::FilterV0s(AliVEvent *event){
   const Double_t ptCut=0.2;
   const Int_t kMinNcl=110;
   //
-  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;
+  Int_t nv0 = event->GetNumberOfV0s(); 
+  AliESDVertex *vertex= (AliESDVertex *)event->GetPrimaryVertex();
   AliKFVertex kfvertex=*vertex;
-
   //
   for (Int_t iv0=0;iv0<nv0;iv0++){
-    AliESDv0 dummyv0;
-    event->GetV0(dummyv0,iv0);
-    AliESDv0 *v0=&dummyv0;
-
+    AliESDv0 *v0 = event->GetV0(iv0);
     if (!v0) continue;
     if (v0->GetPindex()<0) continue;
     if (v0->GetNindex()<0) continue;
@@ -979,8 +933,8 @@ void AliTPCcalibV0::FilterV0s(AliVEvent *event){
 
     Double_t sign= v0->GetParamP()->GetSign()* v0->GetParamN()->GetSign();
     if (sign<0&&v0->GetOnFlyStatus()>0.5&&maxPt>ptCut&&isV0){
-      AliVTrack * trackP = event->GetVTrack(v0->GetPindex());
-      AliVTrack * trackN = event->GetVTrack(v0->GetNindex());
+      AliESDtrack * trackP = event->GetTrack(v0->GetPindex());
+      AliESDtrack * trackN = event->GetTrack(v0->GetNindex());
       if (!trackN) continue;
       if (!trackP) continue;
       Int_t nclP= (Int_t)trackP->GetTPCClusterInfo(2,1);
@@ -995,7 +949,7 @@ void AliTPCcalibV0::FilterV0s(AliVEvent *event){
          "tp.="<<trackP<<
          "tm.="<<trackN<<
          //
-      //"v.="<<vertex<<
+         "v.="<<vertex<<
          "ncls="<<ncls<<
          "maxPt="<<maxPt<<
          "\n";        
index 92cdefd..df7a7c2 100644 (file)
@@ -8,10 +8,8 @@
 class TTreeSRedirector;
 class AliTPCROC;
 class AliTPCseed;
-//class AliESDtrack;
-//class AliESDEvent;
-class AliVEvent;
-class AliVTrack;
+class AliESDtrack;
+class AliESDEvent;
 class TH3F;
 class TH1F;
 class TH2F;
@@ -34,8 +32,8 @@ public :
   AliTPCcalibV0();
   AliTPCcalibV0(const Text_t *name, const Text_t *title);
   virtual ~AliTPCcalibV0();
-  virtual void     Process(AliVEvent *event) {return ProcessESD(event);}
-  void FilterV0s(AliVEvent* event);
+  virtual void     Process(AliESDEvent *event) {return ProcessESD(event);}
+  void FilterV0s(AliESDEvent* event);
   Long64_t Merge(TCollection *const li);
   void AddTree(TTree * treeInput);
   void AddTreeHPT(TTree * treeInput);
@@ -45,9 +43,9 @@ public :
   //
   //
   //
-  void ProcessESD(AliVEvent *event);
-  void DumpToTree(AliVEvent *event);
-  void DumpToTreeHPT(AliVEvent *event);
+  void ProcessESD(AliESDEvent *esd);
+  void DumpToTree(AliESDEvent *esd);
+  void DumpToTreeHPT(AliESDEvent *esd);
   TTree * GetV0Tree(){return fV0Tree;}
   TTree * GetHPTTree(){return fHPTTree;}
   //  
@@ -70,14 +68,13 @@ private:
   TTree          *fHPTTree;      // tree with high mometa tracks - full calib info
   //
   AliStack       *fStack;        // pointer to kinematic tree        
-  AliVEvent      *fEvent;              //! current ED to proccess - NOT OWNER
+  AliESDEvent    *fESD;              //! 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(AliVTrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);}
+  void     Process(AliESDtrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);};
   void     Process(AliTPCseed *track){return AliTPCcalibBase::Process(track);}  
   //       
   ClassDef(AliTPCcalibV0,3);