ANALYSIS/AliAnalysisDataContainer.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 //   AliAnalysysDataContainer - Container of data of arbitrary type deriving
  21 //      from TObject used for analysis. A container must be connected to the
  22 //      output data slot of a single analysis task (producer) , but also as
  23 //      input slot for possibly several other tasks (consumers). The connected
  24 //      slots must enforce the same data type as the container (or a derived type).
  25 //      A container becomes the owner of the contained data once this was produced.
  26 //
  27 // Containers should be defined by the analysis module using:
  28 //
  29 //   AliAnalysisModule::AddContainer(const char *name, TClass *type);
  30 //
  31 // A container should be connected to a producer:
  32
  33 //   AliAnalysisModule::ConnectOutput(AliAnalysisTask *task,
  34 //                                    AliAnalysisDataContainer *cont)
  35 // and to its consumers:
  36 //
  37 //   AliAnalysisModule::ConnectInput(AliAnalysisTask *task, Int_t islot,
  38 //                                   AliAnalysisDataContainer *cont)
  39 //
  40 // The container will create an implicit connection between the producer task
  41 // and all consumers, which will become sub-tasks of the producer.
  42 //
  43 //==============================================================================
  44
  45 #include "TClass.h"
  46 #include "TTree.h"
  47 #include "TFile.h"
  48 #include "AliLog.h"
  49
  50 #include "AliAnalysisDataContainer.h"
  51 #include "AliAnalysisDataSlot.h"
  52 #include "AliAnalysisTask.h"
  53
  54 ClassImp(AliAnalysisDataContainer)
  55
  56 //______________________________________________________________________________
  57 AliAnalysisDataContainer::AliAnalysisDataContainer() : TNamed(),
  58                           fDataReady(kFALSE),
  59                           fOwnedData(kFALSE),
  60                           fFileName(),
  61                           fData(NULL),
  62                           fType(NULL),
  63                           fProducer(NULL),
  64                           fConsumers(NULL)
  65 {
  66 // Default ctor.
  67 }
  68
  69 //______________________________________________________________________________
  70 AliAnalysisDataContainer::AliAnalysisDataContainer(const char *name, TClass *type)
  71                          :TNamed(name,""),
  72                           fDataReady(kFALSE),
  73                           fOwnedData(kTRUE),
  74                           fFileName(),
  75                           fData(NULL),
  76                           fType(type),
  77                           fProducer(NULL),
  78                           fConsumers(NULL)
  79 {
  80 // Normal constructor.
  81 }
  82
  83 //______________________________________________________________________________
  84 AliAnalysisDataContainer::AliAnalysisDataContainer(const AliAnalysisDataContainer &cont)
  85                          :TNamed(cont),
  86                           fDataReady(cont.fDataReady),
  87                           fOwnedData(kFALSE),
  88                           fFileName(cont.fFileName),
  89                           fData(cont.fData),
  90                           fType(cont.fType),
  91                           fProducer(cont.fProducer),
  92                           fConsumers(NULL)
  93 {
  94 // Copy ctor.
  95    if (cont.fConsumers) {
  96       fConsumers = new TObjArray(2);
  97       Int_t ncons = cont.fConsumers->GetEntriesFast();
  98       for (Int_t i=0; i<ncons; i++) fConsumers->Add(cont.fConsumers->At(i));
  99    }
 100 }
 101
 102 //______________________________________________________________________________
 103 AliAnalysisDataContainer::~AliAnalysisDataContainer()
 104 {
 105 // Destructor. Deletes data ! (What happens if data is a container ???)
 106    if (fData && fOwnedData) delete fData;
 107    if (fConsumers) delete fConsumers;
 108 }
 109
 110 //______________________________________________________________________________
 111 AliAnalysisDataContainer &AliAnalysisDataContainer::operator=(const AliAnalysisDataContainer &cont)
 112 {
 113 // Assignment.
 114    if (&cont != this) {
 115       TNamed::operator=(cont);
 116       fDataReady = cont.fDataReady;
 117       fOwnedData = kFALSE;  // !!! Data owned by cont.
 118       fFileName = cont.fFileName;
 119       fData = cont.fData;
 120       fType = cont.fType;
 121       fProducer = cont.fProducer;
 122       if (cont.fConsumers) {
 123          fConsumers = new TObjArray(2);
 124          Int_t ncons = cont.fConsumers->GetEntriesFast();
 125          for (Int_t i=0; i<ncons; i++) fConsumers->Add(cont.fConsumers->At(i));
 126       }
 127    }
 128    return *this;
 129 }
 130
 131 //______________________________________________________________________________
 132 Bool_t AliAnalysisDataContainer::SetData(TObject *data, Option_t *option)
 133 {
 134 // Set the data as READY only if it was published by the producer.
 135 // If option is not empty the data will be saved in the file fFileName and option
 136 // describes the method to opent the file: NEW/CREATE, RECREATE, UPDATE
 137    // If there is no producer declared, this is a top level container.
 138    AliAnalysisTask *task;
 139    Int_t i, nc;
 140    if (!fProducer) {
 141       fData = data;
 142       fDataReady = kTRUE;
 143       if (fConsumers) {
 144          nc = fConsumers->GetEntriesFast();
 145          for (i=0; i<nc; i++) {
 146             task = (AliAnalysisTask*)fConsumers->At(i);
 147             task->CheckNotify();
 148          }
 149       }
 150       return kTRUE;
 151    }
 152    // Check if it is the producer who published the data
 153    if (fProducer->GetPublishedData()==data) {
 154       fData = data;
 155       fDataReady = kTRUE;
 156       if (strlen(option)) {
 157          if (!fFileName.Length()) {
 158             AliWarning(Form("Cannot write data since file name for container %s was not set", GetName()));
 159             return kFALSE;
 160          }
 161          TFile *f = new TFile(fFileName.Data(), option);
 162          if (!f->IsZombie()) {
 163             fData->Write();
 164             f->Write();
 165          }
 166       }
 167       if (fConsumers) {
 168          nc = fConsumers->GetEntriesFast();
 169          for (i=0; i<nc; i++) {
 170             task = (AliAnalysisTask*)fConsumers->At(i);
 171             task->CheckNotify();
 172          }
 173       }
 174       return kTRUE;
 175    } else {
 176       AliWarning(Form("Data for container %s can be published only by producer task %s",
 177                  GetName(), fProducer->GetName()));
 178       return kFALSE;
 179    }
 180 }
 181
 182 //______________________________________________________________________________
 183 void AliAnalysisDataContainer::SetFileName(const char *name)
 184 {
 185 // Data will be written to this file if it is set using SetData(data, option)
 186 // Option represent the way the file is accessed: NEW, APPEND, ...
 187    fFileName = name;
 188 }
 189
 190 //______________________________________________________________________________
 191 void AliAnalysisDataContainer::GetEntry(Long64_t ientry)
 192 {
 193 // If data is ready and derives from TTree or from TBranch, this will get the
 194 // requested entry in memory if not already loaded.
 195    if (!fDataReady) return;
 196    Bool_t is_tree = fType->InheritsFrom(TTree::Class());
 197    if (is_tree) {
 198       TTree *tree = (TTree*)fData;
 199       if (tree->GetReadEntry() != ientry) tree->GetEntry(ientry);
 200       return;
 201    }
 202    Bool_t is_branch = fType->InheritsFrom(TBranch::Class());
 203    if (is_branch) {
 204       TBranch *branch = (TBranch*)fData;
 205       if (branch->GetReadEntry() != ientry) branch->GetEntry(ientry);
 206       return;
 207    }
 208 }
 209
 210 //______________________________________________________________________________
 211 void AliAnalysisDataContainer::SetProducer(AliAnalysisTask *prod, Int_t islot)
 212 {
 213 // Set the producer of data. The slot number is required for data type checking.
 214    if (fProducer) {
 215       AliWarning(Form("Data container %s already has a producer: %s",
 216                  GetName(),fProducer->GetName()));
 217    }
 218    if (fDataReady) {
 219       AliError(Form("%s container contains data - cannot change producer!", GetName()));
 220       return;
 221    }
 222    AliAnalysisDataSlot *slot = prod->GetOutputSlot(islot);
 223    if (!slot) {
 224       AliError(Form("Producer task %s does not have an output #%i", prod->GetName(),islot));
 225       return;
 226    }
 227    if (!slot->GetType()->InheritsFrom(fType)) {
 228       AliError(Form("Data type %s for output slot %i of task %s does not match container type %s",
 229                      slot->GetType()->GetName(),islot,prod->GetName(),fType->GetName()));
 230       return;
 231    }
 232
 233    fProducer = prod;
 234    // Add all consumers as daughter tasks
 235    TIter next(fConsumers);
 236    AliAnalysisTask *cons;
 237    while ((cons=(AliAnalysisTask*)next())) {
 238       if (!prod->GetListOfTasks()->FindObject(cons)) prod->Add(cons);
 239    }
 240 }
 241
 242 //______________________________________________________________________________
 243 void AliAnalysisDataContainer::AddConsumer(AliAnalysisTask *consumer, Int_t islot)
 244 {
 245 // Add a consumer for contained data;
 246    AliAnalysisDataSlot *slot = consumer->GetInputSlot(islot);
 247    if (!slot) {
 248       AliError(Form("Consumer task %s does not have an input #%i", consumer->GetName(),islot));
 249       return;
 250    }
 251    if (!slot->GetType()->InheritsFrom(fType)) {
 252       AliError(Form("Data type %s for input slot %i of task %s does not match container type %s",
 253                      slot->GetType()->GetName(),islot,consumer->GetName(),fType->GetName()));
 254       return;
 255    }
 256
 257    if (!fConsumers) fConsumers = new TObjArray(2);
 258    fConsumers->Add(consumer);
 259    // Add the consumer task to the list of task of the producer
 260    if (fProducer && !fProducer->GetListOfTasks()->FindObject(consumer))
 261       fProducer->Add(consumer);
 262 }
 263
 264 //______________________________________________________________________________
 265 Bool_t AliAnalysisDataContainer::ClientsExecuted() const
 266 {
 267 // Check if all client tasks have executed.
 268    TIter next(fConsumers);
 269    AliAnalysisTask *task;
 270    while ((task=(AliAnalysisTask*)next())) {
 271       if (!task->HasExecuted()) return kFALSE;
 272    }
 273    return kTRUE;
 274 }
 275
 276 //______________________________________________________________________________
 277 void AliAnalysisDataContainer::DeleteData()
 278 {
 279 // Delete data if not needed anymore.
 280    if (!fDataReady || !ClientsExecuted()) {
 281       AliWarning(Form("Data not ready or not all clients of container %s executed. Data not deleted.", GetName()));
 282       return;
 283    }
 284    if (!fOwnedData) {
 285       AliWarning(Form("Data not owned by container %s. Not deleted.", GetName()));
 286       return;
 287    }
 288    delete fData;
 289    fData = 0;
 290    fDataReady = kFALSE;
 291 }
 292
 293 //______________________________________________________________________________
 294 void AliAnalysisDataContainer::PrintContainer(Option_t *option, Int_t indent) const
 295 {
 296 // Print info about this container.
 297    TString ind;
 298    for (Int_t i=0; i<indent; i++) ind += " ";
 299    TString opt(option);
 300    opt.ToLower();
 301    Bool_t dep = (opt.Contains("dep"))?kTRUE:kFALSE;
 302    if (!dep) {
 303       printf("%s\n", Form("%sContainer: %s  type: %s", ind.Data(), GetName(), fType->GetName()));
 304       if (fProducer)
 305          printf("%s\n", Form("%s = Data producer: task %s",ind.Data(),fProducer->GetName()));
 306       else
 307          printf("%s\n", Form("%s= No data producer"));
 308       printf("%s", Form("%s = Consumer tasks: "));
 309       if (!fConsumers || !fConsumers->GetEntriesFast()) printf("-none-\n");
 310       else printf("\n");
 311    }
 312    TIter next(fConsumers);
 313    AliAnalysisTask *task;
 314    while ((task=(AliAnalysisTask*)next())) task->PrintTask(option, indent+3);
 315 }