[u/mrichter/AliRoot.git] / ANALYSIS / AliAnalysisDataContainer.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/* $Id$ */
// Author: Andrei Gheata, 31/05/2006

//==============================================================================
//   AliAnalysysDataContainer - Container of data of arbitrary type deriving
//      from TObject used for analysis. A container must be connected to the 
//      output data slot of a single analysis task (producer) , but also as 
//      input slot for possibly several other tasks (consumers). The connected 
//      slots must enforce the same data type as the container (or a derived type).
//      A container becomes the owner of the contained data once this was produced.
//
// Containers should be defined by the analysis module using:
//
//   AliAnalysisModule::AddContainer(const char *name, TClass *type);
//
// A container should be connected to a producer:

//   AliAnalysisModule::ConnectOutput(AliAnalysisTask *task,
//                                    AliAnalysisDataContainer *cont)
// and to its consumers:
//
//   AliAnalysisModule::ConnectInput(AliAnalysisTask *task, Int_t islot,
//                                   AliAnalysisDataContainer *cont)
//
// The container will create an implicit connection between the producer task 
// and all consumers, which will become sub-tasks of the producer.
//
//==============================================================================

#include "TClass.h"
#include "TTree.h"
#include "TFile.h"
#include "AliLog.h"

#include "AliAnalysisDataContainer.h"
#include "AliAnalysisDataSlot.h"
#include "AliAnalysisTask.h"

ClassImp(AliAnalysisDataContainer)

//______________________________________________________________________________
AliAnalysisDataContainer::AliAnalysisDataContainer()
{
// Default ctor.
   fDataReady = kFALSE;
   fOwnedData  = kFALSE;
   fFileName = "";
   fData  = 0;
   fType  = 0;
   fProducer  = 0; 
   fConsumers = 0;
}
//______________________________________________________________________________
AliAnalysisDataContainer::AliAnalysisDataContainer(const char *name, TClass *type)
                         :TNamed(name,"")
{
// Normal constructor.
   fDataReady = kFALSE;
   fOwnedData = kTRUE;
   fFileName = "";
   fData  = 0;
   fType  = type;
   fProducer  = 0; 
   fConsumers = 0;
}

//______________________________________________________________________________
AliAnalysisDataContainer::~AliAnalysisDataContainer()
{
// Destructor. Deletes data ! (What happens if data is a container ???)
   if (fData && fOwnedData) delete fData;
   if (fConsumers) delete fConsumers;
}

//______________________________________________________________________________
Bool_t AliAnalysisDataContainer::SetData(TObject *data, Option_t *option)
{
// Set the data as READY only if it was published by the producer.
// If option is not empty the data will be saved in the file fFileName and option
// describes the method to opent the file: NEW/CREATE, RECREATE, UPDATE
   // If there is no producer declared, this is a top level container.
   AliAnalysisTask *task;
   Int_t i, nc;
   if (!fProducer) {
      fData = data;
      fDataReady = kTRUE;
      if (fConsumers) {
         nc = fConsumers->GetEntriesFast();
         for (i=0; i<nc; i++) {
            task = (AliAnalysisTask*)fConsumers->At(i);
            task->CheckNotify();
         }
      }      
      return kTRUE;
   } 
   // Check if it is the producer who published the data     
   if (fProducer->GetPublishedData()==data) {
      fData = data;
      fDataReady = kTRUE;
      if (strlen(option)) {
         if (!fFileName.Length()) {
            AliWarning(Form("Cannot write data since file name for container %s was not set", GetName()));
            return kFALSE;
         }
         TFile *f = new TFile(fFileName.Data(), option);
         if (!f->IsZombie()) {
            fData->Write();
            f->Write();
         }   
      }
      if (fConsumers) {
         nc = fConsumers->GetEntriesFast();
         for (i=0; i<nc; i++) {
            task = (AliAnalysisTask*)fConsumers->At(i);
            task->CheckNotify();
         }
      }      
      return kTRUE;   
   } else {
      AliWarning(Form("Data for container %s can be published only by producer task %s", 
                 GetName(), fProducer->GetName()));   
      return kFALSE;           
   }              
}

//______________________________________________________________________________
void AliAnalysisDataContainer::SetFileName(const char *name)
{
// Data will be written to this file if it is set using SetData(data, option)
// Option represent the way the file is accessed: NEW, APPEND, ...
   fFileName = name;
}   

//______________________________________________________________________________
void AliAnalysisDataContainer::GetEntry(Long64_t ientry)
{
// If data is ready and derives from TTree or from TBranch, this will get the
// requested entry in memory if not already loaded.
   if (!fDataReady) return;
   Bool_t is_tree = fType->InheritsFrom(TTree::Class());
   if (is_tree) {
      TTree *tree = (TTree*)fData;
      if (tree->GetReadEntry() != ientry) tree->GetEntry(ientry);
      return;
   }   
   Bool_t is_branch = fType->InheritsFrom(TBranch::Class());
   if (is_branch) {
      TBranch *branch = (TBranch*)fData;
      if (branch->GetReadEntry() != ientry) branch->GetEntry(ientry);
      return;
   }   
}   

//______________________________________________________________________________
void AliAnalysisDataContainer::SetProducer(AliAnalysisTask *prod, Int_t islot)
{
// Set the producer of data. The slot number is required for data type checking.
   if (fProducer) {
      AliWarning(Form("Data container %s already has a producer: %s",
                 GetName(),fProducer->GetName()));
   } 
   if (fDataReady) {
      AliError(Form("%s container contains data - cannot change producer!", GetName()));
      return;
   }   
   AliAnalysisDataSlot *slot = prod->GetOutputSlot(islot);
   if (!slot) {
      AliError(Form("Producer task %s does not have an output #%i", prod->GetName(),islot));
      return;
   }   
   if (!slot->GetType()->InheritsFrom(fType)) {
      AliError(Form("Data type %s for output slot %i of task %s does not match container type %s", 
                     slot->GetType()->GetName(),islot,prod->GetName(),fType->GetName()));
      return;
   }   
   
   fProducer = prod;
   // Add all consumers as daughter tasks
   TIter next(fConsumers);
   AliAnalysisTask *cons;
   while ((cons=(AliAnalysisTask*)next())) {
      if (!prod->GetListOfTasks()->FindObject(cons)) prod->Add(cons);
   }   
}   

//______________________________________________________________________________
void AliAnalysisDataContainer::AddConsumer(AliAnalysisTask *consumer, Int_t islot)
{
// Add a consumer for contained data;
   AliAnalysisDataSlot *slot = consumer->GetInputSlot(islot);
   if (!slot) {
      AliError(Form("Consumer task %s does not have an input #%i", consumer->GetName(),islot));
      return;
   }   
   if (!slot->GetType()->InheritsFrom(fType)) {
      AliError(Form("Data type %s for input slot %i of task %s does not match container type %s", 
                     slot->GetType()->GetName(),islot,consumer->GetName(),fType->GetName()));
      return;
   }   

   if (!fConsumers) fConsumers = new TObjArray(2);   
   fConsumers->Add(consumer);
   // Add the consumer task to the list of task of the producer
   if (fProducer && !fProducer->GetListOfTasks()->FindObject(consumer)) 
      fProducer->Add(consumer);
}      

//______________________________________________________________________________
Bool_t AliAnalysisDataContainer::ClientsExecuted() const
{
// Check if all client tasks have executed.
   TIter next(fConsumers);
   AliAnalysisTask *task;
   while ((task=(AliAnalysisTask*)next())) {
      if (!task->HasExecuted()) return kFALSE;
   }
   return kTRUE;
}   

//______________________________________________________________________________
void AliAnalysisDataContainer::DeleteData()
{
// Delete data if not needed anymore.
   if (!fDataReady || !ClientsExecuted()) {
      AliWarning(Form("Data not ready or not all clients of container %s executed. Data not deleted.", GetName()));
      return;
   }
   if (!fOwnedData) {
      AliWarning(Form("Data not owned by container %s. Not deleted.", GetName()));
      return;
   }
   delete fData;
   fData = 0;
   fDataReady = kFALSE;
}   
      
//______________________________________________________________________________
void AliAnalysisDataContainer::PrintContainer(Option_t *option, Int_t indent) const
{
// Print info about this container.
   TString ind;
   for (Int_t i=0; i<indent; i++) ind += " ";
   TString opt(option);
   opt.ToLower();
   Bool_t dep = (opt.Contains("dep"))?kTRUE:kFALSE;
   if (!dep) {
      printf("%s\n", Form("%sContainer: %s  type: %s", ind.Data(), GetName(), fType->GetName()));
      if (fProducer) 
         printf("%s\n", Form("%s = Data producer: task %s",ind.Data(),fProducer->GetName()));
      else
         printf("%s\n", Form("%s= No data producer"));
      printf("%s", Form("%s = Consumer tasks: "));
      if (!fConsumers || !fConsumers->GetEntriesFast()) printf("-none-\n");
      else printf("\n");
   }   
   TIter next(fConsumers);
   AliAnalysisTask *task;
   while ((task=(AliAnalysisTask*)next())) task->PrintTask(option, indent+3);
}
Commit	Line	Data
d3106602	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()
	58	{
	59	// Default ctor.
	60	fDataReady = kFALSE;
	61	fOwnedData = kFALSE;
	62	fFileName = "";
	63	fData = 0;
	64	fType = 0;
65	fProducer = 0;
66	fConsumers = 0;
67	}
68	//______________________________________________________________________________
69	AliAnalysisDataContainer::AliAnalysisDataContainer(const char name, TClass type)
70	:TNamed(name,"")
71	{
72	// Normal constructor.
73	fDataReady = kFALSE;
74	fOwnedData = kTRUE;
75	fFileName = "";
76	fData = 0;
77	fType = type;
78	fProducer = 0;
79	fConsumers = 0;
80	}
81
82	//______________________________________________________________________________
83	AliAnalysisDataContainer::~AliAnalysisDataContainer()
84	{
85	// Destructor. Deletes data ! (What happens if data is a container ???)
86	if (fData && fOwnedData) delete fData;
87	if (fConsumers) delete fConsumers;
88	}
89
90	//______________________________________________________________________________
91	Bool_t AliAnalysisDataContainer::SetData(TObject data, Option_t option)
92	{
93	// Set the data as READY only if it was published by the producer.
94	// If option is not empty the data will be saved in the file fFileName and option
95	// describes the method to opent the file: NEW/CREATE, RECREATE, UPDATE
96	// If there is no producer declared, this is a top level container.
97	AliAnalysisTask *task;
98	Int_t i, nc;
99	if (!fProducer) {
100	fData = data;
101	fDataReady = kTRUE;
102	if (fConsumers) {
103	nc = fConsumers->GetEntriesFast();
104	for (i=0; i<nc; i++) {
105	task = (AliAnalysisTask*)fConsumers->At(i);
106	task->CheckNotify();
107	}
108	}
109	return kTRUE;
110	}
111	// Check if it is the producer who published the data
112	if (fProducer->GetPublishedData()==data) {
113	fData = data;
114	fDataReady = kTRUE;
115	if (strlen(option)) {
116	if (!fFileName.Length()) {
117	AliWarning(Form("Cannot write data since file name for container %s was not set", GetName()));
118	return kFALSE;
119	}
120	TFile *f = new TFile(fFileName.Data(), option);
121	if (!f->IsZombie()) {
122	fData->Write();
123	f->Write();
124	}
125	}
126	if (fConsumers) {
127	nc = fConsumers->GetEntriesFast();
128	for (i=0; i<nc; i++) {
129	task = (AliAnalysisTask*)fConsumers->At(i);
130	task->CheckNotify();
131	}
132	}
133	return kTRUE;
134	} else {
135	AliWarning(Form("Data for container %s can be published only by producer task %s",
136	GetName(), fProducer->GetName()));
137	return kFALSE;
138	}
139	}
140
141	//______________________________________________________________________________
142	void AliAnalysisDataContainer::SetFileName(const char *name)
143	{
144	// Data will be written to this file if it is set using SetData(data, option)
145	// Option represent the way the file is accessed: NEW, APPEND, ...
146	fFileName = name;
147	}
148
149	//______________________________________________________________________________
150	void AliAnalysisDataContainer::GetEntry(Long64_t ientry)
151	{
152	// If data is ready and derives from TTree or from TBranch, this will get the
153	// requested entry in memory if not already loaded.
154	if (!fDataReady) return;
155	Bool_t is_tree = fType->InheritsFrom(TTree::Class());
156	if (is_tree) {
157	TTree tree = (TTree)fData;
158	if (tree->GetReadEntry() != ientry) tree->GetEntry(ientry);
159	return;
160	}
161	Bool_t is_branch = fType->InheritsFrom(TBranch::Class());
162	if (is_branch) {
163	TBranch branch = (TBranch)fData;
164	if (branch->GetReadEntry() != ientry) branch->GetEntry(ientry);
165	return;
166	}
167	}
168
169	//______________________________________________________________________________
170	void AliAnalysisDataContainer::SetProducer(AliAnalysisTask *prod, Int_t islot)
171	{
172	// Set the producer of data. The slot number is required for data type checking.
173	if (fProducer) {
174	AliWarning(Form("Data container %s already has a producer: %s",
175	GetName(),fProducer->GetName()));
176	}
177	if (fDataReady) {
178	AliError(Form("%s container contains data - cannot change producer!", GetName()));
179	return;
180	}
181	AliAnalysisDataSlot *slot = prod->GetOutputSlot(islot);
182	if (!slot) {
183	AliError(Form("Producer task %s does not have an output #%i", prod->GetName(),islot));
184	return;
185	}
186	if (!slot->GetType()->InheritsFrom(fType)) {
187	AliError(Form("Data type %s for output slot %i of task %s does not match container type %s",
188	slot->GetType()->GetName(),islot,prod->GetName(),fType->GetName()));
189	return;
190	}
191
192	fProducer = prod;
193	// Add all consumers as daughter tasks
194	TIter next(fConsumers);
195	AliAnalysisTask *cons;
196	while ((cons=(AliAnalysisTask*)next())) {
197	if (!prod->GetListOfTasks()->FindObject(cons)) prod->Add(cons);
198	}
199	}
200
201	//______________________________________________________________________________
202	void AliAnalysisDataContainer::AddConsumer(AliAnalysisTask *consumer, Int_t islot)
203	{
204	// Add a consumer for contained data;
205	AliAnalysisDataSlot *slot = consumer->GetInputSlot(islot);
206	if (!slot) {
207	AliError(Form("Consumer task %s does not have an input #%i", consumer->GetName(),islot));
208	return;
209	}
210	if (!slot->GetType()->InheritsFrom(fType)) {
211	AliError(Form("Data type %s for input slot %i of task %s does not match container type %s",
212	slot->GetType()->GetName(),islot,consumer->GetName(),fType->GetName()));
213	return;
214	}
215
216	if (!fConsumers) fConsumers = new TObjArray(2);
217	fConsumers->Add(consumer);
218	// Add the consumer task to the list of task of the producer
219	if (fProducer && !fProducer->GetListOfTasks()->FindObject(consumer))
220	fProducer->Add(consumer);
221	}
222
223	//______________________________________________________________________________
224	Bool_t AliAnalysisDataContainer::ClientsExecuted() const
225	{
226	// Check if all client tasks have executed.
227	TIter next(fConsumers);
228	AliAnalysisTask *task;
229	while ((task=(AliAnalysisTask*)next())) {
230	if (!task->HasExecuted()) return kFALSE;
231	}
232	return kTRUE;
233	}
234
235	//______________________________________________________________________________
236	void AliAnalysisDataContainer::DeleteData()
237	{
238	// Delete data if not needed anymore.
239	if (!fDataReady \|\| !ClientsExecuted()) {
240	AliWarning(Form("Data not ready or not all clients of container %s executed. Data not deleted.", GetName()));
241	return;
242	}
243	if (!fOwnedData) {
244	AliWarning(Form("Data not owned by container %s. Not deleted.", GetName()));
245	return;
246	}
247	delete fData;
248	fData = 0;
249	fDataReady = kFALSE;
250	}
251
252	//______________________________________________________________________________
253	void AliAnalysisDataContainer::PrintContainer(Option_t *option, Int_t indent) const
254	{
255	// Print info about this container.
256	TString ind;
257	for (Int_t i=0; i<indent; i++) ind += " ";
258	TString opt(option);
259	opt.ToLower();
260	Bool_t dep = (opt.Contains("dep"))?kTRUE:kFALSE;
261	if (!dep) {
262	printf("%s\n", Form("%sContainer: %s type: %s", ind.Data(), GetName(), fType->GetName()));
263	if (fProducer)
264	printf("%s\n", Form("%s = Data producer: task %s",ind.Data(),fProducer->GetName()));
265	else
266	printf("%s\n", Form("%s= No data producer"));
267	printf("%s", Form("%s = Consumer tasks: "));
268	if (!fConsumers \|\| !fConsumers->GetEntriesFast()) printf("-none-\n");
269	else printf("\n");
270	}
271	TIter next(fConsumers);
272	AliAnalysisTask *task;
273	while ((task=(AliAnalysisTask*)next())) task->PrintTask(option, indent+3);
274	}