TPC/AliTPCAnalysisTaskcalib.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16
  17 ///////////////////////////////////////////////////////////////////////////////
  18 //                                                                           //
  19 // blaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa //
  20 //                                                                           //
  21 ///////////////////////////////////////////////////////////////////////////////
  22 #include "AliTPCAnalysisTaskcalib.h"
  23 #include "TChain.h"
  24 #include "AliTPCcalibBase.h"
  25 #include "AliESDEvent.h"
  26 #include "AliESDfriend.h"
  27 #include "AliESDtrack.h"
  28 #include "AliESDfriendTrack.h"
  29 #include "AliTPCseed.h"
  30 #include "AliESDInputHandler.h"
  31 #include "AliAnalysisManager.h"
  32
  33 ClassImp(AliTPCAnalysisTaskcalib)
  34
  35
  36 AliTPCAnalysisTaskcalib::AliTPCAnalysisTaskcalib()
  37   :AliAnalysisTask(),
  38    fCalibJobs(0),
  39    fESD(0),
  40    fESDfriend(0),
  41    fDebugOutputPath()
  42 {
  43   //
  44   // default constructor
  45   //
  46
  47 }
  48
  49
  50 AliTPCAnalysisTaskcalib::AliTPCAnalysisTaskcalib(const char *name)
  51   :AliAnalysisTask(name,""),
  52    fCalibJobs(0),
  53    fESD(0),
  54    fESDfriend(0),
  55    fDebugOutputPath()
  56 {
  57   //
  58   // Constructor
  59   //
  60   DefineInput(0, TChain::Class());
  61   DefineOutput(0, TObjArray::Class());
  62   fCalibJobs = new TObjArray(0);
  63   fCalibJobs->SetOwner(kFALSE);
  64 }
  65
  66 AliTPCAnalysisTaskcalib::~AliTPCAnalysisTaskcalib() {
  67   //
  68   // destructor
  69   //
  70   printf("AliTPCAnalysisTaskcalib::~AliTPCAnalysisTaskcalib");
  71   //fCalibJobs->Delete();
  72 }
  73
  74 void AliTPCAnalysisTaskcalib::Exec(Option_t *) {
  75   //
  76   // Exec function
  77   // Loop over tracks and call  Process function
  78   if (!fESD) {
  79     //Printf("ERROR: fESD not available");
  80     return;
  81   }
  82   fESDfriend=static_cast<AliESDfriend*>(fESD->FindListObject("AliESDfriend"));
  83   if (!fESDfriend) {
  84     //Printf("ERROR: fESDfriend not available");
  85     return;
  86   }
  87   Int_t n=fESD->GetNumberOfTracks();
  88   Process(fESD);
  89   Int_t run = fESD->GetRunNumber();
  90   for (Int_t i=0;i<n;++i) {
  91     AliESDfriendTrack *friendTrack=fESDfriend->GetTrack(i);
  92     AliESDtrack *track=fESD->GetTrack(i);
  93     TObject *calibObject=0;
  94     AliTPCseed *seed=0;
  95     for (Int_t j=0;(calibObject=friendTrack->GetCalibObject(j));++j)
  96       if ((seed=dynamic_cast<AliTPCseed*>(calibObject)))
  97         break;
  98     if (track) Process(track, run);
  99     if (seed)
 100       Process(seed);
 101   }
 102   PostData(0,fCalibJobs);
 103 }
 104
 105 void AliTPCAnalysisTaskcalib::ConnectInputData(Option_t *) {
 106   //
 107   //
 108   //
 109   TTree* tree=dynamic_cast<TTree*>(GetInputData(0));
 110   if (!tree) {
 111     //Printf("ERROR: Could not read chain from input slot 0");
 112   }
 113   else {
 114     AliESDInputHandler *esdH = dynamic_cast<AliESDInputHandler*> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
 115     if (!esdH) {
 116       //Printf("ERROR: Could not get ESDInputHandler");
 117     }
 118     else {
 119       fESD = esdH->GetEvent();
 120       //Printf("*** CONNECTED NEW EVENT ****");
 121     }
 122   }
 123 }
 124
 125 void AliTPCAnalysisTaskcalib::CreateOutputObjects() {
 126   //
 127   //
 128   //
 129 }
 130 void AliTPCAnalysisTaskcalib::Terminate(Option_t */*option*/) {
 131   //
 132   // Terminate
 133   //
 134   AliTPCcalibBase *job=0;
 135   Int_t njobs = fCalibJobs->GetEntriesFast();
 136   for (Int_t i=0;i<njobs;i++){
 137     job = (AliTPCcalibBase*)fCalibJobs->UncheckedAt(i);
 138     if (job) job->Terminate();
 139   }
 140 }
 141
 142 void AliTPCAnalysisTaskcalib::FinishTaskOutput()
 143 {
 144   //
 145   // According description in AliAnalisysTask this method is call
 146   // on the slaves before sending data
 147   //
 148   Terminate("slave");
 149   RegisterDebugOutput();
 150 }
 151
 152
 153 void AliTPCAnalysisTaskcalib::Process(AliESDEvent *event) {
 154   //
 155   // Process ESD event
 156   //
 157   AliTPCcalibBase *job=0;
 158   Int_t njobs = fCalibJobs->GetEntriesFast();
 159   for (Int_t i=0;i<njobs;i++){
 160     job = (AliTPCcalibBase*)fCalibJobs->UncheckedAt(i);
 161     if (job) job->Process(event);
 162   }
 163 }
 164
 165 void AliTPCAnalysisTaskcalib::Process(AliTPCseed *track) {
 166   //
 167   // Process TPC track
 168   //
 169   AliTPCcalibBase *job=0;
 170   Int_t njobs = fCalibJobs->GetEntriesFast();
 171   for (Int_t i=0;i<njobs;i++){
 172     job = (AliTPCcalibBase*)fCalibJobs->UncheckedAt(i);
 173     if (job) job->Process(track);
 174   }
 175 }
 176
 177 void AliTPCAnalysisTaskcalib::Process(AliESDtrack *track, Int_t run) {
 178   //
 179   // Process ESD track
 180   //
 181   AliTPCcalibBase *job=0;
 182   Int_t njobs = fCalibJobs->GetEntriesFast();
 183   for (Int_t i=0;i<njobs;i++){
 184     job = (AliTPCcalibBase*)fCalibJobs->UncheckedAt(i);
 185     if (job) job->Process(track,run);
 186   }
 187 }
 188
 189 Long64_t AliTPCAnalysisTaskcalib::Merge(TCollection *li) {
 190   TIterator *i=fCalibJobs->MakeIterator();
 191   AliTPCcalibBase *job;
 192   Long64_t n=0;
 193   while ((job=dynamic_cast<AliTPCcalibBase*>(i->Next())))
 194     n+=job->Merge(li);
 195   return n;
 196 }
 197
 198 void AliTPCAnalysisTaskcalib::Analyze() {
 199   //
 200   // Analyze the content of the task
 201   //
 202   AliTPCcalibBase *job=0;
 203   Int_t njobs = fCalibJobs->GetEntriesFast();
 204   for (Int_t i=0;i<njobs;i++){
 205     job = (AliTPCcalibBase*)fCalibJobs->UncheckedAt(i);
 206     if (job) job->Analyze();
 207   }
 208 }
 209
 210
 211 void AliTPCAnalysisTaskcalib::RegisterDebugOutput(){
 212   //
 213   //
 214   //
 215   AliTPCcalibBase *job=0;
 216   Int_t njobs = fCalibJobs->GetEntriesFast();
 217   for (Int_t i=0;i<njobs;i++){
 218     job = (AliTPCcalibBase*)fCalibJobs->UncheckedAt(i);
 219     if (job) job->RegisterDebugOutput(fDebugOutputPath.Data());
 220   }
 221 }