TPC/Calib/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 // ANALYSIS task to perrorm TPC calibration                                  //
  20
  21 //                                                                           //
  22 ///////////////////////////////////////////////////////////////////////////////
  23 #include "AliTPCAnalysisTaskcalib.h"
  24 #include "TChain.h"
  25 #include "AliTPCcalibBase.h"
  26 #include "AliESDEvent.h"
  27 #include "AliESDfriend.h"
  28 #include "AliESDtrack.h"
  29 #include "AliESDfriendTrack.h"
  30 #include "AliTPCseed.h"
  31 #include "AliESDInputHandler.h"
  32
  33 #include "AliVEvent.h"
  34 #include "AliVfriendEvent.h"
  35 #include "AliVTrack.h"
  36 #include "AliVfriendTrack.h"
  37 #include "AliVEventHandler.h"
  38
  39 #include "AliAnalysisManager.h"
  40 #include "TFile.h"
  41 #include "TSystem.h"
  42 #include "TTimeStamp.h"
  43
  44 ClassImp(AliTPCAnalysisTaskcalib)
  45
  46
  47 AliTPCAnalysisTaskcalib::AliTPCAnalysisTaskcalib()
  48   :AliAnalysisTask(),
  49    fCalibJobs(0),
  50    fEvent(0),
  51    fEventFriend(0),
  52    fDebugOutputPath("")
  53 {
  54   //
  55   // default constructor
  56   //
  57
  58 }
  59
  60
  61 AliTPCAnalysisTaskcalib::AliTPCAnalysisTaskcalib(const char *name)
  62   :AliAnalysisTask(name,""),
  63    fCalibJobs(0),
  64    fEvent(0),
  65    fEventFriend(0),
  66    fDebugOutputPath("")
  67 {
  68   //
  69   // Constructor
  70   //
  71   DefineInput(0, TChain::Class());
  72   DefineOutput(0, AliTPCcalibBase::Class());
  73   DefineOutput(1, AliTPCcalibBase::Class());
  74   DefineOutput(2, AliTPCcalibBase::Class());
  75   DefineOutput(3, AliTPCcalibBase::Class());
  76   DefineOutput(4, AliTPCcalibBase::Class());
  77   DefineOutput(5, AliTPCcalibBase::Class());
  78   fCalibJobs = new TObjArray(0);
  79   fCalibJobs->SetOwner(kTRUE);
  80 }
  81
  82 AliTPCAnalysisTaskcalib::~AliTPCAnalysisTaskcalib() {
  83   //
  84   // destructor
  85   //
  86   printf("AliTPCAnalysisTaskcalib::~AliTPCAnalysisTaskcalib");
  87   fCalibJobs->Delete();
  88 }
  89
  90 void AliTPCAnalysisTaskcalib::Exec(Option_t *) {
  91   //
  92   // Exec function
  93   // Loop over tracks and call  Process function
  94     //Printf("AliTPCAnalysisTaskcalib::Exec()...");
  95
  96   if (!fEvent) {
  97     Printf("ERROR AliTPCAnalysisTaskcalib::Exec(): fEvent not available");
  98     return;
  99   }
 100   fEventFriend=fEvent->FindFriend();
 101   //fESDfriend=fESD->FindFriend();
 102   Int_t n=fEvent->GetNumberOfTracks();
 103   Process(fEvent);
 104   if (!fEventFriend) {
 105     //Printf("ERROR AliTPCAnalysisTaskcalib::Exec(): fEventFriend not available");
 106     return;
 107   }
 108   if (fEventFriend->TestSkipBit()) return;
 109   //
 110   Int_t run = fEvent->GetRunNumber();
 111   for (Int_t i=0;i<n;++i) {
 112     const AliVfriendTrack *friendTrack=fEventFriend->GetTrack(i);
 113     AliVTrack *track=fEvent->GetVTrack(i);
 114     TObject *calibObject=0;
 115     AliTPCseed *seed=0;
 116     if (!friendTrack) continue;
 117     for (Int_t j=0;(calibObject=friendTrack->GetCalibObject(j));++j)
 118       if ((seed=dynamic_cast<AliTPCseed*>(calibObject)))
 119         break;
 120     if (track) Process(track, run);
 121     if (seed)
 122       Process(seed);
 123   }
 124 }
 125
 126 void AliTPCAnalysisTaskcalib::ConnectInputData(Option_t *) {
 127   //
 128   //
 129   //
 130   TTree* tree=dynamic_cast<TTree*>(GetInputData(0));
 131   if (!tree) {
 132     //Printf("ERROR: Could not read chain from input slot 0");
 133   }
 134   else {
 135     //AliESDInputHandler *esdH = dynamic_cast<AliESDInputHandler*> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
 136     AliVEventHandler *esdH = AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler();
 137     if (!esdH) {
 138       Printf("ERROR: Could not get ESDInputHandler");
 139     }
 140     else {
 141       fEvent = esdH->GetEvent();
 142       //Printf("*** CONNECTED NEW EVENT ****");
 143     }
 144   }
 145 }
 146
 147 void AliTPCAnalysisTaskcalib::CreateOutputObjects() {
 148   //
 149   //
 150   //
 151   //OpenFile(0, "RECREATE");
 152
 153   for (Int_t i=0; i<fCalibJobs->GetEntries(); i++)
 154   {
 155     if (fCalibJobs->At(i))
 156       PostData(i,(AliTPCcalibBase*)fCalibJobs->At(i));
 157   }
 158 }
 159
 160 void AliTPCAnalysisTaskcalib::Terminate(Option_t */*option*/) {
 161   //
 162   // Terminate
 163   //
 164   AliTPCcalibBase *job=0;
 165   Int_t njobs = fCalibJobs->GetEntriesFast();
 166   for (Int_t i=0;i<njobs;i++){
 167     job = (AliTPCcalibBase*)fCalibJobs->UncheckedAt(i);
 168     if (job) job->Terminate();
 169   }
 170
 171 }
 172
 173 void AliTPCAnalysisTaskcalib::FinishTaskOutput()
 174 {
 175   //
 176   // According description in AliAnalisysTask this method is call
 177   // on the slaves before sending data
 178   //
 179   Terminate("slave");
 180   if(!fDebugOutputPath.IsNull()) {
 181     RegisterDebugOutput();
 182   }
 183
 184 }
 185
 186
 187 void AliTPCAnalysisTaskcalib::Process(AliVEvent *event) {
 188   //
 189   // Process ESD event
 190   //
 191     //Printf("AliTPCAnalysisTaskcalib::Process(event)...");
 192   AliTPCcalibBase *job=0;
 193   Int_t njobs = fCalibJobs->GetEntriesFast();
 194   for (Int_t i=0;i<njobs;i++){
 195     job = (AliTPCcalibBase*)fCalibJobs->UncheckedAt(i);
 196     if (job) {
 197       job->UpdateEventInfo(event);
 198       if (job->AcceptTrigger())
 199         job->Process(event);
 200     }
 201   }
 202 }
 203
 204 void AliTPCAnalysisTaskcalib::Process(AliTPCseed *track) {
 205   //
 206   // Process TPC track
 207   //
 208     //Printf("AliTPCAnalysisTaskcalib::Process(TPC track)...");
 209   AliTPCcalibBase *job=0;
 210   Int_t njobs = fCalibJobs->GetEntriesFast();
 211   for (Int_t i=0;i<njobs;i++){
 212     job = (AliTPCcalibBase*)fCalibJobs->UncheckedAt(i);
 213     if (job)
 214       if (job->AcceptTrigger())
 215         job->Process(track);
 216   }
 217 }
 218
 219 void AliTPCAnalysisTaskcalib::Process(AliVTrack *track, Int_t run) {
 220   //
 221   // Process ESD track
 222   //
 223     //Printf("AliTPCAnalysisTaskcalib::Process(ESD track)...");
 224   AliTPCcalibBase *job=0;
 225   Int_t njobs = fCalibJobs->GetEntriesFast();
 226   for (Int_t i=0;i<njobs;i++){
 227     job = (AliTPCcalibBase*)fCalibJobs->UncheckedAt(i);
 228     if (job)
 229       if (job->AcceptTrigger())
 230         job->Process(track,run);
 231   }
 232 }
 233
 234 Long64_t AliTPCAnalysisTaskcalib::Merge(TCollection *li) {
 235   TIterator *i=fCalibJobs->MakeIterator();
 236   AliTPCcalibBase *job;
 237   Long64_t n=0;
 238   while ((job=dynamic_cast<AliTPCcalibBase*>(i->Next())))
 239     n+=job->Merge(li);
 240   return n;
 241 }
 242
 243 void AliTPCAnalysisTaskcalib::Analyze() {
 244   //
 245   // Analyze the content of the task
 246   //
 247   AliTPCcalibBase *job=0;
 248   Int_t njobs = fCalibJobs->GetEntriesFast();
 249   for (Int_t i=0;i<njobs;i++){
 250     job = (AliTPCcalibBase*)fCalibJobs->UncheckedAt(i);
 251     if (job) job->Analyze();
 252   }
 253 }
 254
 255
 256 void AliTPCAnalysisTaskcalib::RegisterDebugOutput(){
 257   //
 258   //
 259   //
 260   AliTPCcalibBase *job=0;
 261   Int_t njobs = fCalibJobs->GetEntriesFast();
 262   for (Int_t i=0;i<njobs;i++){
 263     job = (AliTPCcalibBase*)fCalibJobs->UncheckedAt(i);
 264     if (job) job->RegisterDebugOutput(fDebugOutputPath.Data());
 265   }
 266   TString dsName=GetName();
 267   dsName+=".root";
 268   TFile fff(dsName.Data(),"recreate");
 269   fCalibJobs->Write("TPCCalib",TObject::kSingleKey);
 270   fff.Close();
 271   //
 272   // store  - copy debug output to the destination position
 273   // currently ONLY for local copy
 274   TString dsName2=fDebugOutputPath.Data();
 275   gSystem->MakeDirectory(dsName2.Data());
 276   dsName2+=gSystem->HostName();
 277   gSystem->MakeDirectory(dsName2.Data());
 278   dsName2+="/";
 279   TTimeStamp s;
 280   dsName2+=Int_t(s.GetNanoSec());
 281   dsName2+="/";
 282   gSystem->MakeDirectory(dsName2.Data());
 283   dsName2+=dsName;
 284   AliInfo(Form("copy %s\t%s\n",dsName.Data(),dsName2.Data()));
 285   printf("copy %s\t%s\n",dsName.Data(),dsName2.Data());
 286   TFile::Cp(dsName.Data(),dsName2.Data());
 287
 288 }