Task now uses VV classes (ready for the case of flat)
authorzampolli <chiara.zampolli@cern.ch>
Fri, 1 Aug 2014 16:36:28 +0000 (18:36 +0200)
committerzampolli <chiara.zampolli@cern.ch>
Fri, 1 Aug 2014 16:36:28 +0000 (18:36 +0200)
15 files changed:
ANALYSIS/AliAnalysisManager.cxx
ANALYSIS/AliAnalysisManager.h
HLT/global/AliFlatESDEvent.h
HLT/global/physics/AliHLTAnaManagerComponent.cxx
STEER/ESD/AliESDfriendTrack.cxx
STEER/ESD/AliESDfriendTrack.h
STEER/STEER/AliHLTTestInputHandler.cxx
STEER/STEER/AliHLTTestInputHandler.h
STEER/STEERBase/AliInputEventHandler.h
STEER/STEERBase/AliVEventHandler.h
STEER/STEERBase/AliVVevent.h
STEER/STEERBase/AliVVfriendTrack.h
STEER/STEERBase/AliVVtrack.h
TPC/Calib/AliAnalysisTaskPt.cxx
TPC/Calib/AliAnalysisTaskPt.h

index 281adc0..33b9ef4 100644 (file)
@@ -2950,7 +2950,7 @@ void AliAnalysisManager::Changed()
 }
 
 //______________________________________________________________________________
-void AliAnalysisManager::InitInputData(AliVEvent* esdEvent, AliESDfriend* esdFriend)
+void AliAnalysisManager::InitInputData(AliVVevent* esdEvent, AliVVfriendEvent* esdFriend)
 {
 
 // Method to propagte to all the connected tasks the HLT event.
index 38179c0..f2d56f3 100644 (file)
@@ -36,8 +36,8 @@ class AliVEventHandler;
 class AliVEventPool;
 class AliAnalysisGrid;
 class AliAnalysisStatistics;
-class AliVEvent;
-class AliESDfriend;
+class AliVVevent;
+class AliVVfriendEvent;
 
 class AliAnalysisManager : public TNamed {
 
@@ -230,7 +230,7 @@ enum EAliAnalysisFlags {
    void                 Lock();
    void                 UnLock();
    void                 Changed();
-   void                 InitInputData(AliVEvent* esdEvent, AliESDfriend* esdFriend);
+   void                 InitInputData(AliVVevent* esdEvent, AliVVfriendEvent* esdFriend);
 protected:
    void                 CreateReadCache();
    void                 ImportWrappers(TList *source);
index 4f276bf..e2900a4 100644 (file)
@@ -107,7 +107,7 @@ class AliFlatESDEvent: public AliVVevent {
   Double_t GetMagneticField() const {return 0;}
   UInt_t GetTimeStamp() const { return 0;}
   UInt_t GetEventSpecie() const { return 0;}
-
+  void ReadFromTree(TTree* /*tree*/, Option_t* /*opt*/) {};
   
   // --------------------------------------------------------------------------------
   // -- Size methods
index 98d5c0d..ffe7596 100644 (file)
@@ -148,6 +148,7 @@ Int_t AliHLTAnaManagerComponent::DoInit( Int_t /*argc*/, const Char_t** /*argv*/
   fAnalysisManager->SetExternalLoop(kTRUE); 
 
   AliAnalysisTaskPt *task = new AliAnalysisTaskPt("TaskPt");
+  task->SetUseFriends(kFALSE);
   fAnalysisManager->AddTask(task);
   AliAnalysisDataContainer *cinput  = fAnalysisManager->GetCommonInputContainer();
   Printf("Defining output file");
index 4d8d376..bf5cf69 100644 (file)
@@ -140,7 +140,7 @@ void AliESDfriendTrack::AddCalibObject(TObject * calibObject){
   fCalibContainer->AddLast(calibObject);
 }
 
-TObject * AliESDfriendTrack::GetCalibObject(Int_t index){
+TObject * AliESDfriendTrack::GetCalibObject(Int_t index) const {
   //
   //
   //
index 4ba64e3..96fa048 100644 (file)
@@ -46,7 +46,7 @@ public:
   AliKalmanTrack *GetTRDtrack() {return fTRDtrack;}
   AliKalmanTrack *GetITStrack() {return fITStrack;}
   void AddCalibObject(TObject * calibObject); 
-  TObject * GetCalibObject(Int_t index);
+  TObject * GetCalibObject(Int_t index) const;
   AliTPCseed* GetTPCseed() const {return NULL;}
   //
   // parameters backup
index eecc8e8..c12db6f 100644 (file)
@@ -34,7 +34,7 @@ AliHLTTestInputHandler::AliHLTTestInputHandler(const char* name, const char* tit
 }
 
 //______________________________________________________________________________
-Bool_t AliHLTTestInputHandler::Init(TTree* tree,  Option_t* opt)
+Bool_t AliHLTTestInputHandler::Init(TTree* /*tree*/,  Option_t* /*opt*/)
 {
 // Initialisation necessary for each new tree. In reco case this is once.
   Printf("----> AliHLTTestInputHandler::Init"); 
@@ -54,14 +54,14 @@ Bool_t AliHLTTestInputHandler::BeginEvent(Long64_t)
 }     
 
 //______________________________________________________________________________
-Bool_t AliHLTTestInputHandler::InitTaskInputData(AliVEvent* esdEvent, AliESDfriend* friendEvent, TObjArray* arrTasks) {
+Bool_t AliHLTTestInputHandler::InitTaskInputData(AliVVevent* esdEvent, AliVVfriendEvent* friendEvent, TObjArray* arrTasks) {
 
 // Method to propagte to all the connected tasks the HLT event.
 // The method gets the list of tasks from the manager
 
   Printf("----> AliHLTTestInputHandler::InitTaskInpuData: Setting the event...");
-  SetEvent(esdEvent);
-  SetFriendEvent(friendEvent);
+  SetVVEvent(esdEvent);
+  SetVVFriendEvent(friendEvent);
   // set transient pointer to event inside tracks
   fEvent->ConnectTracks();
   Printf("----> AliHLTTestInputHandler::InitTaskInpuData: ...Event set");
index 2eea8f7..35258d7 100644 (file)
@@ -13,8 +13,8 @@
 #endif
 
 class TObjArray;
-class AliVEvent;
-class AliESDfriend;
+class AliVVevent;
+class AliVVfriendevent;
 
 class AliHLTTestInputHandler : public AliVEventHandler {
 
@@ -38,20 +38,21 @@ class AliHLTTestInputHandler : public AliVEventHandler {
     virtual Bool_t TerminateIO() {return kTRUE;}
 
     // Especially needed for HLT
-    Bool_t InitTaskInputData(AliVEvent* /*esdEvent*/, AliESDfriend* /*friendEvent*/, TObjArray* /*arrTasks*/);
+    Bool_t InitTaskInputData(AliVVevent* /*esdEvent*/, AliVVfriendEvent* /*friendEvent*/, TObjArray* /*arrTasks*/);
 
-    AliVEvent* GetEvent() const {return fEvent;}
-    void  SetEvent(AliVEvent *event) {fEvent = event;}
+    AliVEvent* GetEvent() const {return NULL;}
+    AliVVevent* GetVVEvent() const {return fEvent;}
+    void  SetVVEvent(AliVVevent *event) {fEvent = event;}
 
-    AliESDfriend* GetFriendEvent() const {return fFriendEvent;}
-    void  SetFriendEvent(AliESDfriend *friendEvent) {fFriendEvent = friendEvent;}
+    AliVVfriendEvent* GetVVFriendEvent() const {return fFriendEvent;}
+    void  SetVVFriendEvent(AliVVfriendEvent *friendEvent) {fFriendEvent = friendEvent;}
       
  private:
     AliHLTTestInputHandler(const AliVEventHandler& handler);             
     AliHLTTestInputHandler& operator=(const AliVEventHandler& handler);  
     
-    AliVEvent    *fEvent;          //! Pointer to the event
-    AliESDfriend *fFriendEvent;    //! Pointer to the friend event
+    AliVVevent       *fEvent;          //! Pointer to the event
+    AliVVfriendEvent *fFriendEvent;    //! Pointer to the friend event
 
     ClassDef(AliHLTTestInputHandler, 1);
 };
index c141030..c9e3a62 100644 (file)
@@ -14,7 +14,7 @@
 #include <TTree.h>
 
 
-class AliVEvent;
+class AliVVevent;
 class AliVCuts;
 class AliRunTag;
 class AliEventTag;
@@ -58,6 +58,7 @@ class AliInputEventHandler : public AliVEventHandler {
     void SetActiveBranches  (const char* branches) {Changed(); fBranchesOn = branches;}
      // Getters
     virtual AliVEvent   *GetEvent()        const                      {return 0;}
+    virtual AliVVevent  *GetVVEvent()      const                      {return 0;}
     virtual const AliEventTag   *GetEventTag() const                  {return 0;}
     virtual AliRunTag   *GetRunTag()       const                      {return 0;}
     // Get the statistics object (currently TH2). Option can be BIN0.
index 1cce6cd..b0e80a0 100644 (file)
@@ -14,8 +14,9 @@
 
 class TTree;
 class TObjArray;
+class AliVVevent;
 class AliVEvent;
-class AliESDfriend;
+class AliVVfriendEvent;
 
 class AliVEventHandler : public TNamed {
 
@@ -63,9 +64,10 @@ enum EEventHandlerFlags {
     virtual TList        *GetUserInfo() const {return 0x0;};
 
     // HLT
-    virtual Bool_t          InitTaskInputData(AliVEvent* /*event*/, AliESDfriend* /*esdFriend*/, TObjArray* /*arrTasks*/) {printf("OOOOPS!!!\n"); return kTRUE;};
-    virtual AliVEvent*      GetEvent() const {return 0x0;};
-    virtual AliESDfriend*   GetFriendEvent() const {return 0x0;};
+    virtual Bool_t              InitTaskInputData(AliVVevent* /*event*/, AliVVfriendEvent* /*esdFriend*/, TObjArray* /*arrTasks*/) {return kTRUE;};
+    virtual AliVEvent*          GetEvent() const {return 0x0;};
+    virtual AliVVevent*         GetVVEvent() const {return 0x0;};
+    virtual AliVVfriendEvent*   GetVVFriendEvent() const {return 0x0;};
 
  private :
   ClassDef(AliVEventHandler, 1);
index 1075581..049c151 100644 (file)
  */
 #include "Rtypes.h"
 #include "TString.h"
-class AliVVevent;
+
+class TList;
 class AliVVvertex;
 class AliVVtrack;
 class AliMultiplicity;
 class AliVVkink;
 class AliVVfriendEvent;
+class TTree;
 
 class AliVVevent {
  public:
@@ -36,7 +38,7 @@ class AliVVevent {
   virtual const AliVVvertex* GetPrimaryVertexTPC() const {return NULL;}
   virtual AliVVtrack* GetTrack(Int_t /*i*/) const {return NULL;}
   virtual AliVVkink* GetKink(Int_t /*i*/) const {return NULL;}
-  virtual AliVVtrack* GetV0(Int_t /*i*/) const {return 0;}
+  virtual AliVVtrack* GetV0(Int_t /*i*/) const {return NULL;}
   virtual Int_t GetNumberOfTracks() const {return 0;}
   virtual Int_t GetNumberOfV0s() const {return 0;}
   virtual Int_t GetNumberOfKinks() const {return 0;}
@@ -49,10 +51,13 @@ class AliVVevent {
   virtual Double_t GetMagneticField() const {return 0;}
   virtual UInt_t GetTimeStamp() const { return 0;}
   virtual UInt_t GetEventSpecie() const { return 0;}
-  virtual ULong64_t GetSize() {return 0;};
+  virtual ULong64_t GetSize() {return 0;}
   virtual AliVVfriendEvent* FindFriend() const { return NULL; }
+  virtual void ConnectTracks() {}
+  virtual void ReadFromTree(TTree* /*tree*/, Option_t* /*opt*/) = 0;
+  virtual TList* GetList() const {return 0;}
 
-  ClassDef(AliVVevent,1)  // base class for event data
+  ClassDef(AliVVevent,0)  // base class for event data
 
 };
 #endif
index bab3182..683f5b4 100644 (file)
@@ -25,6 +25,7 @@ public:
   virtual const AliVVtrack * GetITSOut() const {return NULL;} 
   virtual const AliVVtrack * GetTPCOut() const {return  NULL;} 
   virtual const AliVVtrack * GetTRDIn()  const {return NULL;} 
+  virtual TObject* GetCalibObject(Int_t /*index*/) const {return NULL;}
 
 private: 
   AliVVfriendTrack(const AliVVfriendTrack &);
index ebafbf1..d147d5c 100644 (file)
@@ -11,8 +11,8 @@
 
 #include "AliPID.h"
 
-struct AliFlatTPCCluster;
-struct AliFlatExternalTrackParam;
+class AliFlatTPCCluster;
+class AliFlatExternalTrackParam;
 
 class AliVVtrack {
  public:
index 70cb777..c06ae4e 100644 (file)
@@ -26,7 +26,7 @@ ClassImp(AliAnalysisTaskPt)
 
 //________________________________________________________________________
 AliAnalysisTaskPt::AliAnalysisTaskPt(const char *name) 
-: AliAnalysisTask(name, ""), fESD(0), fESDfriend(0), fHistPt(0), fCuts(0), fEv(0), fHistQ(0), fListOut(0)
+: AliAnalysisTask(name, ""), fESD(0), fESDfriend(0), fHistPt(0), fCuts(0), fEv(0), fHistQ(0), fListOut(0), fUseFriends(kFALSE)
 {
   // Constructor
 
@@ -62,13 +62,15 @@ void AliAnalysisTaskPt::ConnectInputData(Option_t *)
     } else {
       Printf("----> AliAnalysisTaskPt::ConnectInputData Getting the event from handler %p", esdH);
       //fESD = dynamic_cast<AliESDEvent*>(esdH->GetEvent());
-      fESD = esdH->GetEvent();
-      fESDfriend = esdH->GetFriendEvent();
+      fESD = esdH->GetVVEvent();
+      if (fUseFriends){        
+       fESDfriend = esdH->GetVVFriendEvent();
+      }
     }
     if (!fESD) {
       Printf("ERROR, no ESD event");
     }
-    if (!fESDfriend) {
+    if (fUseFriends && !fESDfriend) {
       Printf("ERROR, no ESD friend");
     }
   }
@@ -130,34 +132,46 @@ void AliAnalysisTaskPt::Exec(Option_t *)
       Printf("ERROR: Could not receive track %d", iTracks);
       continue;
     }
-
+    Printf("track %d has pt = %f", iTracks, track->Pt());
     fHistPt->Fill(track->Pt());
   } //track loop 
 
 
-  // Friend Track loop
-  for (Int_t iFriend = 0; iFriend < fESDfriend->GetNumberOfTracks(); iFriend++) {
-    const AliVVfriendTrack* friendTrack = fESDfriend->GetTrack(iFriend);
-    if (!friendTrack) {
-      Printf("ERROR: Could not receive track %d", iFriend);
-      continue;
-    }     
-    AliTPCseed* seed = friendTrack->GetTPCseed();
-    if( seed ){
-      Printf("Found TPC seed");
-      for (Int_t irow = 0; irow < 160; irow++){
-       AliTPCclusterMI* cluMI = seed->GetClusterPointer(irow);
-       if (cluMI){
-         Printf("Found cluster at row %d", irow);
-         Float_t q = cluMI->GetQ();
-         Printf("Q = %f", q);
-         fHistQ->Fill(q);
-       }
+  if (fUseFriends){
+    // Friend Track loop
+    for (Int_t iFriend = 0; iFriend < fESDfriend->GetNumberOfTracks(); iFriend++) {
+      //Printf("Getting friend %d", iFriend);
+      const AliVVfriendTrack* friendTrack = fESDfriend->GetTrack(iFriend);
+      if (!friendTrack) {
+       Printf("ERROR: Could not receive track %d", iFriend);
+       continue;
+      }     
+      TObject* calibObject;
+      AliTPCseed* seed = NULL;
+      //AliTPCseed* seed = friendTrack->GetTPCseed();
+      //if (seed){
+      for (Int_t idx = 0; (calibObject = friendTrack->GetCalibObject(idx)); ++idx) {
+       Printf(" |Cal %d = %p", idx, calibObject); 
+       if ((seed = dynamic_cast<AliTPCseed*>(calibObject))) {    
+         //Printf("Found TPC seed %p", seed);
+         for (Int_t irow = 0; irow < 160; irow++){
+           AliTPCclusterMI* cluMI = seed->GetClusterPointer(irow);
+           if (cluMI){
+             Printf("Found cluster at row %d", irow);
+             Float_t q = cluMI->GetQ();
+             Printf("Q = %f", q);
+             fHistQ->Fill(q);
+           }
+           else {
+             Printf("Row %d does not contain clusters", irow);
+           }            
+         }
+       }    
        else {
-         Printf("Row %d does not contain clusters", irow);
-       }        
+         //Printf("Schade... seed is %p", seed);
+       }
       }
-    }    
+    }
   }
 
   // Post output data.
index b83e83c..b2a51ed 100644 (file)
@@ -23,6 +23,9 @@ class AliAnalysisTaskPt : public AliAnalysisTask {
   virtual void   CreateOutputObjects();
   virtual void   Exec(Option_t *option);
   virtual void   Terminate(Option_t *);
+  
+  Bool_t GetUseFriends() {return fUseFriends;}
+  void   SetUseFriends(Bool_t flag) {fUseFriends = flag;}
 
  private:
   AliVVevent*       fESD;          // ESD object
@@ -32,6 +35,7 @@ class AliAnalysisTaskPt : public AliAnalysisTask {
   Int_t fEv;
   TH1F*             fHistQ;        // TPC clusters Q spectrum
   TList*            fListOut;      // output list
+  Bool_t            fUseFriends;   // flag to decide whether friends should be used
 
   AliAnalysisTaskPt(const AliAnalysisTaskPt&); // not implemented
   AliAnalysisTaskPt& operator=(const AliAnalysisTaskPt&); // not implemented