ANALYSIS/AliAnalysisTask.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 /* $Id$ */
  17 // Author: Andrei Gheata, 31/05/2006
  18
  19 //==============================================================================
  20 //   AliAnalysysTask - Class representing a basic analysis task. Any
  21 // user-defined task should derive from it and implement the Exec() virtual
  22 // method.
  23 //==============================================================================
  24 //
  25 // A specific user analysis task have to derive from this class. The list of
  26 // specific input and output slots have to be defined in the derived class ctor:
  27 //
  28 //   UserTask::UserTask(name, title)
  29 //   {
  30 //      DefineInput(0, TTree::Class());
  31 //      DefineInput(1, TH1::Class());
  32 //      ...
  33 //      DefineOutput(0, TTree::Class());
  34 //      DefineOutput(1, MyObject::Class());
  35 //      ...
  36 //   }
  37 //
  38 // An existing data contaner (AliAnalysisDataContainer) can be connected to the
  39 // input/output slots of an analysis task. Containers should not be defined and
  40 // connected by the derived analysis task, but from the level of AliAnalysisManager:
  41 //
  42 //   AliAnalysisManager::ConnectInput(AliAnalysisTask *task, Int_t islot,
  43 //                                   AliAnalysisDataContainer *cont)
  44 //   AliAnalysisManager::ConnectOutput(AliAnalysisTask *task, Int_t islot,
  45 //                                    AliAnalysisDataContainer *cont)
  46 // To connect a slot to a data container, the data types declared by both must
  47 // match.
  48 //
  49 // The method Init will be called once per session at the moment when the data is
  50 // available at all input slots.
  51 // The method Init() has to be overloaded by the derived class in order to:
  52 // 1. Define objects that should be created only once per session (e.g. output
  53 //    histograms)
  54 // 2. Set the branch address or connect to a branch address in case the input
  55 //    slots are connected to trees.
  56 //
  57 // Example:
  58 // MyAnalysisTask::Init(Option_t *)
  59 // {
  60 //    if (!fHist1) fHist1 = new TH1F("h1", ....);
  61 //    if (!fHist2) fHist2 = new TH1F("h2", ....);
  62 //    fESD = GetBranchAddress(islot=0, "ESD");
  63 //    if (!fESD) SetBranchAddress(islot=0, "ESD", &fESD);
  64 // }
  65 //
  66 // The method Terminate() will be called by the framework once at the end of
  67 // data processing. Overload this if needed.
  68 //
  69 //==============================================================================
  70
  71 #include "TClass.h"
  72
  73 #include "AliLog.h"
  74 #include "AliAnalysisTask.h"
  75 #include "AliAnalysisDataSlot.h"
  76 #include "AliAnalysisDataContainer.h"
  77
  78 ClassImp(AliAnalysisTask)
  79
  80 //______________________________________________________________________________
  81 AliAnalysisTask::AliAnalysisTask()
  82                 :fReady(kFALSE),
  83                  fInitialized(kFALSE),
  84                  fNinputs(0),
  85                  fNoutputs(0),
  86                  fOutputReady(NULL),
  87                  fPublishedData(NULL),
  88                  fInputs(NULL),
  89                  fOutputs(NULL)
  90 {
  91 // Default constructor.
  92 }
  93
  94 //______________________________________________________________________________
  95 AliAnalysisTask::AliAnalysisTask(const char *name, const char *title)
  96                 :TTask(name,title),
  97                  fReady(kFALSE),
  98                  fInitialized(kFALSE),
  99                  fNinputs(0),
 100                  fNoutputs(0),
 101                  fOutputReady(NULL),
 102                  fPublishedData(NULL),
 103                  fInputs(NULL),
 104                  fOutputs(NULL)
 105 {
 106 // Constructor.
 107    fInputs      = new TObjArray(2);
 108    fOutputs     = new TObjArray(2);
 109 }
 110
 111 //______________________________________________________________________________
 112 AliAnalysisTask::AliAnalysisTask(const AliAnalysisTask &task)
 113                 :TTask(task),
 114                  fReady(task.fReady),
 115                  fInitialized(task.fInitialized),
 116                  fNinputs(task.fNinputs),
 117                  fNoutputs(task.fNoutputs),
 118                  fOutputReady(NULL),
 119                  fPublishedData(NULL),
 120                  fInputs(NULL),
 121                  fOutputs(NULL)
 122 {
 123 // Copy ctor.
 124    fInputs      = new TObjArray((fNinputs)?fNinputs:2);
 125    fOutputs     = new TObjArray((fNoutputs)?fNoutputs:2);
 126    fPublishedData = 0;
 127    Int_t i;
 128    for (i=0; i<fNinputs; i++) fInputs->AddAt(task.GetInputSlot(i),i);
 129    fOutputReady = new Bool_t[(fNoutputs)?fNoutputs:2];
 130    for (i=0; i<fNoutputs; i++) {
 131       fOutputReady[i] = IsOutputReady(i);
 132       fOutputs->AddAt(task.GetOutputSlot(i),i);
 133    }
 134 }
 135
 136 //______________________________________________________________________________
 137 AliAnalysisTask::~AliAnalysisTask()
 138 {
 139 // Dtor.
 140    if (fInputs)  {fInputs->Delete(); delete fInputs;}
 141    if (fOutputs) {fOutputs->Delete(); delete fOutputs;}
 142 }
 143
 144 //______________________________________________________________________________
 145 AliAnalysisTask& AliAnalysisTask::operator=(const AliAnalysisTask& task)
 146 {
 147 // Assignment
 148    if (&task == this) return *this;
 149    TTask::operator=(task);
 150    fReady       = task.IsReady();
 151    fInitialized = task.IsInitialized();
 152    fNinputs     = task.GetNinputs();
 153    fNoutputs    = task.GetNoutputs();
 154    fInputs      = new TObjArray((fNinputs)?fNinputs:2);
 155    fOutputs     = new TObjArray((fNoutputs)?fNoutputs:2);
 156    fPublishedData = 0;
 157    Int_t i;
 158    for (i=0; i<fNinputs; i++) fInputs->AddAt(new AliAnalysisDataSlot(*task.GetInputSlot(i)),i);
 159    fOutputReady = new Bool_t[(fNoutputs)?fNoutputs:2];
 160    for (i=0; i<fNoutputs; i++) {
 161       fOutputReady[i] = IsOutputReady(i);
 162       fOutputs->AddAt(new AliAnalysisDataSlot(*task.GetOutputSlot(i)),i);
 163    }
 164    return *this;
 165 }
 166
 167 //______________________________________________________________________________
 168 Bool_t AliAnalysisTask::AreSlotsConnected()
 169 {
 170 // Check if all input/output slots are connected. If this is the case fReady=true
 171    fReady = kFALSE;
 172    if (!fNinputs || !fNoutputs) return kFALSE;
 173    Int_t i;
 174    AliAnalysisDataSlot *slot;
 175    for (i=0; i<fNinputs; i++) {
 176       slot = (AliAnalysisDataSlot*)fInputs->At(i);
 177       if (!slot) {
 178          AliError(Form("Input slot %i of task %s not defined !",i,GetName()));
 179          return kFALSE;
 180       }
 181       if (!slot->IsConnected()) return kFALSE;
 182    }
 183    for (i=0; i<fNoutputs; i++) {
 184       slot = (AliAnalysisDataSlot*)fOutputs->At(i);
 185       if (!slot) {
 186          AliError(Form("Output slot %i of task %s not defined !",i,GetName()));
 187          return kFALSE;
 188       }
 189       if (!slot->IsConnected()) return kFALSE;
 190    }
 191    fReady = kTRUE;
 192    return kTRUE;
 193 }
 194
 195 //______________________________________________________________________________
 196 void AliAnalysisTask::CheckNotify(Bool_t init)
 197 {
 198 // Check if data is available from all inputs. Change the status of the task
 199 // accordingly. This method is called automatically for all tasks connected
 200 // to a container where the data was published.
 201    if (init) fInitialized = kFALSE;
 202    for (Int_t islot=0; islot<fNinputs; islot++) {
 203       if (!GetInputData(islot)) {
 204          SetActive(kFALSE);
 205          return;
 206       }
 207    }
 208    SetActive(kTRUE);
 209    if (fInitialized) return;
 210    TDirectory *cursav = gDirectory;
 211    Init();
 212    if (cursav) cursav->cd();
 213    fInitialized = kTRUE;
 214 }
 215
 216 //______________________________________________________________________________
 217 Bool_t AliAnalysisTask::ConnectInput(Int_t islot, AliAnalysisDataContainer *cont)
 218 {
 219 // Connect an input slot to a data container.
 220    AliAnalysisDataSlot *input = GetInputSlot(islot);
 221    if (!input) {
 222       AliError(Form("Input slot %i not defined for analysis task %s", islot, GetName()));
 223       return kFALSE;
 224    }
 225    // Check type matching
 226    if (!input->GetType()->InheritsFrom(cont->GetType())) {
 227       AliError(Form("Data type %s for input %i of task %s not matching container %s of type %s",
 228                input->GetType()->GetName(), islot, GetName(), cont->GetName(), cont->GetType()->GetName()));
 229       return kFALSE;
 230    }
 231    // Connect the slot to the container as input
 232    if (!input->ConnectContainer(cont)) return kFALSE;
 233    // Add this to the list of container consumers
 234    cont->AddConsumer(this, islot);
 235    AreSlotsConnected();
 236    return kTRUE;
 237 }
 238
 239 //______________________________________________________________________________
 240 Bool_t AliAnalysisTask::ConnectOutput(Int_t islot, AliAnalysisDataContainer *cont)
 241 {
 242 // Connect an output slot to a data container.
 243    AliAnalysisDataSlot *output = GetOutputSlot(islot);
 244    if (!output) {
 245       AliError(Form("Output slot %i not defined for analysis task %s", islot, GetName()));
 246       return kFALSE;
 247    }
 248    // Check type matching
 249    if (!output->GetType()->InheritsFrom(cont->GetType())) {
 250       AliError(Form("Data type %s for output %i of task %s not matching container %s of type %s",
 251                output->GetType()->GetName(), islot, GetName(), cont->GetName(), cont->GetType()->GetName()));
 252       return kFALSE;
 253    }
 254    // Connect the slot to the container as output
 255    if (!output->ConnectContainer(cont)) return kFALSE;
 256    // Declare this as the data producer
 257    cont->SetProducer(this, islot);
 258    AreSlotsConnected();
 259    return kTRUE;
 260 }
 261
 262 //______________________________________________________________________________
 263 void AliAnalysisTask::DefineInput(Int_t islot, TClass *type)
 264 {
 265 // Define an input slot and its type.
 266    AliAnalysisDataSlot *input = new AliAnalysisDataSlot(type, this);
 267    if (fNinputs<islot+1) fNinputs = islot+1;
 268    fInputs->AddAtAndExpand(input, islot);
 269 }
 270
 271 //______________________________________________________________________________
 272 void AliAnalysisTask::DefineOutput(Int_t islot, TClass *type)
 273 {
 274 // Define an output slot and its type.
 275    if (islot<0) {
 276       AliError(Form("Cannot define negative output slot number for task %s", GetName()));
 277       return;
 278    }
 279    AliAnalysisDataSlot *output = new AliAnalysisDataSlot(type, this);
 280    if (fNoutputs<islot+1) {
 281       fNoutputs = islot+1;
 282       if (fOutputReady) delete [] fOutputReady;
 283       fOutputReady = new Bool_t[fNoutputs];
 284       memset(fOutputReady, 0, fNoutputs*sizeof(Bool_t));
 285    }
 286    fOutputs->AddAtAndExpand(output, islot);
 287 }
 288
 289 //______________________________________________________________________________
 290 TClass *AliAnalysisTask::GetInputType(Int_t islot) const
 291 {
 292 // Retreive type of a given input slot.
 293    AliAnalysisDataSlot *input = GetInputSlot(islot);
 294    if (!input) {
 295       AliError(Form("Input slot %i not defined for analysis task %s", islot, GetName()));
 296       return NULL;
 297    }
 298    return (input->GetType());
 299 }
 300
 301 //______________________________________________________________________________
 302 TClass *AliAnalysisTask::GetOutputType(Int_t islot) const
 303 {
 304 // Retreive type of a given output slot.
 305    AliAnalysisDataSlot *output = GetOutputSlot(islot);
 306    if (!output) {
 307       AliError(Form("Output slot %i not defined for analysis task %s", islot, GetName()));
 308       return NULL;
 309    }
 310    return (output->GetType());
 311 }
 312
 313 //______________________________________________________________________________
 314 TObject *AliAnalysisTask::GetInputData(Int_t islot) const
 315 {
 316 // Retreive input data for a slot if ready. Normally called by Exec() and
 317 // the object has to be statically cast to the appropriate type.
 318    AliAnalysisDataSlot *input = GetInputSlot(islot);
 319    if (!input) {
 320       AliError(Form("Input slot %i not defined for analysis task %s", islot, GetName()));
 321       return NULL;
 322    }
 323    return (input->GetData());
 324 }
 325
 326 //______________________________________________________________________________
 327 char *AliAnalysisTask::GetBranchAddress(Int_t islot, const char *branch) const
 328 {
 329 // Check if a branch with a given name from the specified input is connected
 330 // to some address. Call this in Init() before trying to call SetBranchAddress()
 331 // since the adress may be set by other task.
 332    return (char *)GetInputSlot(islot)->GetBranchAddress(branch);
 333 }
 334
 335 //______________________________________________________________________________
 336 Bool_t AliAnalysisTask::SetBranchAddress(Int_t islot, const char *branch, void *address) const
 337 {
 338 // Connect an object address to a branch of the specified input.
 339    return GetInputSlot(islot)->SetBranchAddress(branch, address);
 340 }
 341
 342 //______________________________________________________________________________
 343 void AliAnalysisTask::Init(Option_t *)
 344 {
 345 // Branch address initialization.
 346 }
 347
 348 //______________________________________________________________________________
 349 void AliAnalysisTask::Terminate(Option_t *)
 350 {
 351 // Method called by the framework at the end of data processing.
 352 }
 353
 354 //______________________________________________________________________________
 355 void AliAnalysisTask::OpenFile(Int_t iout, const char *name, Option_t *option) const
 356 {
 357 // Set data at output iout to be written in the specified file.
 358    GetOutputSlot(iout)->GetContainer()->OpenFile(name, option);
 359 }
 360
 361 //______________________________________________________________________________
 362 Bool_t AliAnalysisTask::PostData(Int_t iout, TObject *data, Option_t *option)
 363 {
 364 // Post output data for a given ouput slot in the corresponding data container.
 365 // Published data becomes owned by the data container.
 366 // If option is specified, the container connected to the output slot must have
 367 // an associated file name defined. The option represents the method to open the file.
 368    fPublishedData = 0;
 369    AliAnalysisDataSlot *output = GetOutputSlot(iout);
 370    if (!output) {
 371       AliError(Form("Output slot %i not defined for analysis task %s", iout, GetName()));
 372       return kFALSE;
 373    }
 374    if (!output->IsConnected()) {
 375       AliError(Form("Output slot %i of analysis task %s not connected to any data container", iout, GetName()));
 376       return kFALSE;
 377    }
 378    if (!fOutputReady) {
 379       fOutputReady = new Bool_t[fNoutputs];
 380       memset(fOutputReady, 0, fNoutputs*sizeof(Bool_t));
 381    }
 382    fOutputReady[iout] = kTRUE;
 383    fPublishedData = data;
 384    return (output->GetContainer()->SetData(data, option));
 385 }
 386
 387 //______________________________________________________________________________
 388 void AliAnalysisTask::SetUsed(Bool_t flag)
 389 {
 390 // Set 'used' flag recursively to task and all daughter tasks.
 391    if (TestBit(kTaskUsed)==flag) return;
 392    TObject::SetBit(kTaskUsed,flag);
 393    Int_t nd = fTasks->GetSize();
 394    AliAnalysisTask *task;
 395    for (Int_t i=0; i<nd; i++) {
 396       task = (AliAnalysisTask*)fTasks->At(i);
 397       task->SetUsed(flag);
 398    }
 399 }
 400
 401 //______________________________________________________________________________
 402 Bool_t AliAnalysisTask::CheckCircularDeps()
 403 {
 404 // Check for illegal circular dependencies, e.g. a daughter task should not have
 405 // a hierarchical parent as subtask.
 406    if (IsChecked()) return kTRUE;
 407    SetChecked();
 408    TList *tasks = GetListOfTasks();
 409    Int_t ntasks = tasks->GetSize();
 410    AliAnalysisTask *task;
 411    for (Int_t i=0; i<ntasks; i++) {
 412       task = (AliAnalysisTask*)tasks->At(i);
 413       if (task->CheckCircularDeps()) return kTRUE;
 414    }
 415    SetChecked(kFALSE);
 416    return kFALSE;
 417 }
 418
 419 //______________________________________________________________________________
 420 void AliAnalysisTask::PrintTask(Option_t *option, Int_t indent) const
 421 {
 422 // Print task info.
 423    AliAnalysisTask *thistask = (AliAnalysisTask*)this;
 424    TString opt(option);
 425    opt.ToLower();
 426    Bool_t dep = (opt.Contains("dep"))?kTRUE:kFALSE;
 427    TString ind;
 428    Int_t islot;
 429    AliAnalysisDataContainer *cont;
 430    for (Int_t i=0; i<indent; i++) ind += " ";
 431    if (!dep || (dep && IsChecked())) {
 432       printf("%s\n", Form("%stask: %s  ACTIVE=%i", ind.Data(), GetName(),IsActive()));
 433       if (dep) thistask->SetChecked(kFALSE);
 434       else {
 435          for (islot=0; islot<fNinputs; islot++) {
 436             printf("%s", Form("%s   INPUT #%i: %s <- ",ind.Data(),islot, GetInputType(islot)->GetName()));
 437             cont = GetInputSlot(islot)->GetContainer();
 438             if (cont) printf(" [%s]\n", cont->GetName());
 439             else printf(" [NO CONTAINER]\n");
 440          }
 441          for (islot=0; islot<fNoutputs; islot++) {
 442             printf("%s", Form("%s   OUTPUT #%i: %s -> ",ind.Data(),islot, GetOutputType(islot)->GetName()));
 443             cont = GetOutputSlot(islot)->GetContainer();
 444             if (cont) printf(" [%s]\n", cont->GetName());
 445             else printf(" [NO CONTAINER]\n");
 446          }
 447       }
 448    }
 449    PrintContainers(option, indent+3);
 450 }
 451
 452 //______________________________________________________________________________
 453 void AliAnalysisTask::PrintContainers(Option_t *option, Int_t indent) const
 454 {
 455 // Print containers info.
 456    AliAnalysisDataContainer *cont;
 457    TString ind;
 458    for (Int_t i=0; i<indent; i++) ind += " ";
 459    Int_t islot;
 460    for (islot=0; islot<fNoutputs; islot++) {
 461       cont = GetOutputSlot(islot)->GetContainer();
 462       cont->PrintContainer(option, indent);
 463    }
 464 }