[u/mrichter/AliRoot.git] / ANALYSIS / AliAnalysisTask.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

//==============================================================================
//   AliAnalysysTask - Class representing a basic analysis task. Any
// user-defined task should derive from it and implement the Exec() virtual
// method.
//==============================================================================
//
// A specific user analysis task have to derive from this class. The list of
// specific input and output slots have to be defined in the derived class ctor:
//
//   UserTask::UserTask(name, title)
//   {
//      DefineInput(0, TTree::Class());
//      DefineInput(1, TH1::Class());
//      ...
//      DefineOutput(0, TTree::Class());
//      DefineOutput(1, MyObject::Class());
//      ...
//   }
//
// An existing data contaner (AliAnalysisDataContainer) can be connected to the
// input/output slots of an analysis task. Containers should not be defined and
// connected by the derived analysis task, but from the level of AliAnalysisManager:
//
//   AliAnalysisManager::ConnectInput(AliAnalysisTask *task, Int_t islot,
//                                   AliAnalysisDataContainer *cont)
//   AliAnalysisManager::ConnectOutput(AliAnalysisTask *task, Int_t islot,
//                                    AliAnalysisDataContainer *cont)
// To connect a slot to a data container, the data types declared by both must
// match.
//==============================================================================

#include "TClass.h"

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

ClassImp(AliAnalysisTask)

//______________________________________________________________________________
AliAnalysisTask::AliAnalysisTask()
{
// Default constructor.
   fReady       = kFALSE;
   fNinputs     = 0;
   fNoutputs    = 0;
   fOutputReady = 0;
   fPublishedData = 0;
   fInputs      = 0;
   fOutputs     = 0;
}

//______________________________________________________________________________
AliAnalysisTask::AliAnalysisTask(const char *name, const char *title)
                :TTask(name,title)
{
// Named constructor.
   fReady       = kFALSE;
   fNinputs     = 0;
   fNoutputs    = 0;
   fOutputReady = 0;
   fPublishedData = 0;
   fInputs      = new TObjArray(2);
   fOutputs     = new TObjArray(2);
}

//______________________________________________________________________________
AliAnalysisTask::AliAnalysisTask(const AliAnalysisTask &task)
                :TTask(task)
{
// Copy ctor.
   fReady       = task.IsReady();
   fNinputs     = task.GetNinputs();
   fNoutputs    = task.GetNoutputs();
   fInputs      = new TObjArray((fNinputs)?fNinputs:2);
   fOutputs     = new TObjArray((fNoutputs)?fNoutputs:2);
   fPublishedData = 0;
   Int_t i;
   for (i=0; i<fNinputs; i++) fInputs->AddAt(task.GetInputSlot(i),i);
   fOutputReady = new Bool_t[(fNoutputs)?fNoutputs:2];
   for (i=0; i<fNoutputs; i++) {
      fOutputReady[i] = IsOutputReady(i);
      fOutputs->AddAt(task.GetOutputSlot(i),i);
   }   
}

//______________________________________________________________________________
AliAnalysisTask::~AliAnalysisTask()
{
// Dtor.
   if (fInputs)  {fInputs->Delete(); delete fInputs;}
   if (fOutputs) {fOutputs->Delete(); delete fOutputs;}
}   
  
//______________________________________________________________________________
AliAnalysisTask& AliAnalysisTask::operator=(const AliAnalysisTask& task)
{
// Assignment
   if (&task != this) {
      TTask::operator=(task);
      fReady       = task.IsReady();
      fNinputs     = task.GetNinputs();
      fNoutputs    = task.GetNoutputs();
      fInputs      = new TObjArray((fNinputs)?fNinputs:2);
      fOutputs     = new TObjArray((fNoutputs)?fNoutputs:2);
      fPublishedData = 0;
      Int_t i;
      for (i=0; i<fNinputs; i++) fInputs->AddAt(task.GetInputSlot(i),i);
      fOutputReady = new Bool_t[(fNoutputs)?fNoutputs:2];
      for (i=0; i<fNoutputs; i++) {
         fOutputReady[i] = IsOutputReady(i);
         fOutputs->AddAt(task.GetOutputSlot(i),i);
      }         
   }
   return *this;
}

//______________________________________________________________________________
Bool_t AliAnalysisTask::AreSlotsConnected()
{
// Check if all input/output slots are connected. If this is the case fReady=true
   fReady = kFALSE;
   if (!fNinputs || !fNoutputs) return kFALSE;
   Int_t i;
   AliAnalysisDataSlot *slot;
   for (i=0; i<fNinputs; i++) {
      slot = (AliAnalysisDataSlot*)fInputs->At(i);
      if (!slot) {
         AliError(Form("Input slot %i of task %s not defined !",i,GetName()));
         return kFALSE;
      }   
      if (!slot->IsConnected()) return kFALSE;
   }   
   for (i=0; i<fNoutputs; i++) {
      slot = (AliAnalysisDataSlot*)fOutputs->At(i);
      if (!slot) {
         AliError(Form("Output slot %i of task %s not defined !",i,GetName()));
         return kFALSE;
      }   
      if (!slot->IsConnected()) return kFALSE;
   } 
   fReady = kTRUE;  
   return kTRUE;
}

//______________________________________________________________________________
void AliAnalysisTask::CheckNotify()
{
// Check if data is available from all inputs. Change the status of the task
// accordingly. This method is called automatically for all tasks connected
// to a container where the data was published.
   for (Int_t islot=0; islot<fNinputs; islot++) {
      if (!GetInputData(islot)) {
         SetActive(kFALSE);
         return;
      }   
   }   
   SetActive(kTRUE);
}

//______________________________________________________________________________
Bool_t AliAnalysisTask::ConnectInput(Int_t islot, AliAnalysisDataContainer *cont)
{
// Connect an input slot to a data container.
   AliAnalysisDataSlot *input = GetInputSlot(islot);
   if (!input) {
      AliError(Form("Input slot %i not defined for analysis task %s", islot, GetName()));
      return kFALSE;
   }
   // Check type matching          
   if (!input->GetType()->InheritsFrom(cont->GetType())) {
      AliError(Form("Data type %s for input %i of task %s not matching container %s of type %s",
               input->GetType()->GetName(), islot, GetName(), cont->GetName(), cont->GetType()->GetName()));
      return kFALSE;
   }  
   // Connect the slot to the container as input          
   if (!input->ConnectContainer(cont)) return kFALSE;
   // Add this to the list of container consumers
   cont->AddConsumer(this, islot);
   AreSlotsConnected();
   return kTRUE;
}   

//______________________________________________________________________________
Bool_t AliAnalysisTask::ConnectOutput(Int_t islot, AliAnalysisDataContainer *cont)
{
// Connect an output slot to a data container.
   AliAnalysisDataSlot *output = GetOutputSlot(islot);
   if (!output) {
      AliError(Form("Output slot %i not defined for analysis task %s", islot, GetName()));
      return kFALSE;
   }
   // Check type matching          
   if (!output->GetType()->InheritsFrom(cont->GetType())) {
      AliError(Form("Data type %s for output %i of task %s not matching container %s of type %s",
               output->GetType()->GetName(), islot, GetName(), cont->GetName(), cont->GetType()->GetName()));
      return kFALSE;
   }            
   // Connect the slot to the container as output         
   if (!output->ConnectContainer(cont)) return kFALSE;
   // Declare this as the data producer
   cont->SetProducer(this, islot);
   AreSlotsConnected();
   return kTRUE;
}   

//______________________________________________________________________________
void AliAnalysisTask::DefineInput(Int_t islot, TClass *type)
{
// Define an input slot and its type.
   AliAnalysisDataSlot *input = new AliAnalysisDataSlot(type, this);
   if (fNinputs<islot+1) fNinputs = islot+1;
   fInputs->AddAt(input, islot);
}

//______________________________________________________________________________
void AliAnalysisTask::DefineOutput(Int_t islot, TClass *type)
{
// Define an output slot and its type.
   if (islot<0) {
      AliError(Form("Cannot define negative output slot number for task %s", GetName()));
      return;
   }   
   AliAnalysisDataSlot *output = new AliAnalysisDataSlot(type, this);
   if (fNoutputs<islot+1) {
      fNoutputs = islot+1;
      if (fOutputReady) delete [] fOutputReady;
      fOutputReady = new Bool_t[fNoutputs];
      memset(fOutputReady, 0, fNoutputs*sizeof(Bool_t));
   } 
   fOutputs->AddAt(output, islot);
}

//______________________________________________________________________________
TClass *AliAnalysisTask::GetInputType(Int_t islot) const
{
// Retreive type of a given input slot.
   AliAnalysisDataSlot *input = GetInputSlot(islot);
   if (!input) {
      AliError(Form("Input slot %i not defined for analysis task %s", islot, GetName()));
      return NULL;
   }
   return (input->GetType());
}

//______________________________________________________________________________
TClass *AliAnalysisTask::GetOutputType(Int_t islot) const
{
// Retreive type of a given output slot.
   AliAnalysisDataSlot *output = GetOutputSlot(islot);
   if (!output) {
      AliError(Form("Output slot %i not defined for analysis task %s", islot, GetName()));
      return NULL;
   }
   return (output->GetType());
}

//______________________________________________________________________________
TObject *AliAnalysisTask::GetInputData(Int_t islot) const
{
// Retreive input data for a slot if ready. Normally called by Exec() and
// the object has to be statically cast to the appropriate type.
   AliAnalysisDataSlot *input = GetInputSlot(islot);
   if (!input) {
      AliError(Form("Input slot %i not defined for analysis task %s", islot, GetName()));
      return NULL;
   }
   return (input->GetData()); 
}

//______________________________________________________________________________
Bool_t AliAnalysisTask::PostData(Int_t iout, TObject *data, Option_t *option)
{
// Post output data for a given ouput slot in the corresponding data container.
// Published data becomes owned by the data container.
// If option is specified, the container connected to the output slot must have
// an associated file name defined. The option represents the method to open the file.
   fPublishedData = 0;
   AliAnalysisDataSlot *output = GetOutputSlot(iout);
   if (!output) {
      AliError(Form("Output slot %i not defined for analysis task %s", iout, GetName()));
      return kFALSE;
   }
   if (!output->IsConnected()) {
      AliError(Form("Output slot %i of analysis task %s not connected to any data container", iout, GetName()));
      return kFALSE;
   }
   if (!fOutputReady) {
      fOutputReady = new Bool_t[fNoutputs];
      memset(fOutputReady, 0, fNoutputs*sizeof(Bool_t));
   }   
   fOutputReady[iout] = kTRUE;
   fPublishedData = data;
   return (output->GetContainer()->SetData(data, option));
}

//______________________________________________________________________________
void AliAnalysisTask::SetUsed(Bool_t flag)
{
// Set 'used' flag recursively to task and all daughter tasks.
   if (TestBit(kTaskUsed)==flag) return;
   TObject::SetBit(kTaskUsed,flag);
   Int_t nd = fTasks->GetSize();
   AliAnalysisTask *task;
   for (Int_t i=0; i<nd; i++) {
      task = (AliAnalysisTask*)fTasks->At(i);
      task->SetUsed(flag);
   }
}   

//______________________________________________________________________________
Bool_t AliAnalysisTask::CheckCircularDeps()
{
// Check for illegal circular dependencies, e.g. a daughter task should not have
// a hierarchical parent as subtask.
   if (IsChecked()) return kTRUE;
   SetChecked();
   TList *tasks = GetListOfTasks();
   Int_t ntasks = tasks->GetSize();
   AliAnalysisTask *task;
   for (Int_t i=0; i<ntasks; i++) {
      task = (AliAnalysisTask*)tasks->At(i);
      if (task->CheckCircularDeps()) return kTRUE;
   }
   SetChecked(kFALSE);
   return kFALSE;
}   
   
//______________________________________________________________________________
void AliAnalysisTask::PrintTask(Option_t *option, Int_t indent) const
{
// Print task info.
   AliAnalysisTask *thistask = (AliAnalysisTask*)this;
   TString opt(option);
   opt.ToLower();
   Bool_t dep = (opt.Contains("dep"))?kTRUE:kFALSE;
   TString ind;
   Int_t islot;
   AliAnalysisDataContainer *cont;
   for (Int_t i=0; i<indent; i++) ind += " ";
   if (!dep || (dep && IsChecked())) {
      printf("%s\n", Form("%stask: %s  ACTIVE=%i", ind.Data(), GetName(),IsActive()));
      if (dep) thistask->SetChecked(kFALSE);
      else {
         for (islot=0; islot<fNinputs; islot++) {
            printf("%s", Form("%s   INPUT #%i: %s <- ",ind.Data(),islot, GetInputType(islot)->GetName()));
            cont = GetInputSlot(islot)->GetContainer();
            if (cont) printf(" [%s]\n", cont->GetName());
            else printf(" [NO CONTAINER]\n");
         }
         for (islot=0; islot<fNoutputs; islot++) {
            printf("%s", Form("%s   OUTPUT #%i: %s -> ",ind.Data(),islot, GetOutputType(islot)->GetName()));
            cont = GetOutputSlot(islot)->GetContainer();
            if (cont) printf(" [%s]\n", cont->GetName());
            else printf(" [NO CONTAINER]\n");
         }            
      }
   }
   PrintContainers(option, indent+3);
}      

//______________________________________________________________________________
void AliAnalysisTask::PrintContainers(Option_t *option, Int_t indent) const
{
// Print containers info.
   AliAnalysisDataContainer *cont;
   TString ind;
   for (Int_t i=0; i<indent; i++) ind += " ";
   Int_t islot;
   for (islot=0; islot<fNoutputs; islot++) {
      cont = GetOutputSlot(islot)->GetContainer();
      cont->PrintContainer(option, indent);
   }   
}
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	// 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
	50	#include "TClass.h"
	51
	52	#include "AliLog.h"
	53	#include "AliAnalysisTask.h"
	54	#include "AliAnalysisDataSlot.h"
	55	#include "AliAnalysisDataContainer.h"
	56
	57	ClassImp(AliAnalysisTask)
	58
	59	//______________________________________________________________________________
	60	AliAnalysisTask::AliAnalysisTask()
	61	{
	62	// Default constructor.
	63	fReady = kFALSE;
	64	fNinputs = 0;
65	fNoutputs = 0;
66	fOutputReady = 0;
67	fPublishedData = 0;
68	fInputs = 0;
69	fOutputs = 0;
70	}
71
72	//______________________________________________________________________________
73	AliAnalysisTask::AliAnalysisTask(const char name, const char title)
74	:TTask(name,title)
75	{
76	// Named constructor.
77	fReady = kFALSE;
78	fNinputs = 0;
79	fNoutputs = 0;
80	fOutputReady = 0;
81	fPublishedData = 0;
82	fInputs = new TObjArray(2);
83	fOutputs = new TObjArray(2);
84	}
85
86	//______________________________________________________________________________
87	AliAnalysisTask::AliAnalysisTask(const AliAnalysisTask &task)
88	:TTask(task)
89	{
90	// Copy ctor.
91	fReady = task.IsReady();
92	fNinputs = task.GetNinputs();
93	fNoutputs = task.GetNoutputs();
94	fInputs = new TObjArray((fNinputs)?fNinputs:2);
95	fOutputs = new TObjArray((fNoutputs)?fNoutputs:2);
96	fPublishedData = 0;
97	Int_t i;
98	for (i=0; i<fNinputs; i++) fInputs->AddAt(task.GetInputSlot(i),i);
99	fOutputReady = new Bool_t[(fNoutputs)?fNoutputs:2];
100	for (i=0; i<fNoutputs; i++) {
101	fOutputReady[i] = IsOutputReady(i);
102	fOutputs->AddAt(task.GetOutputSlot(i),i);
103	}
104	}
105
106	//______________________________________________________________________________
107	AliAnalysisTask::~AliAnalysisTask()
108	{
109	// Dtor.
110	if (fInputs) {fInputs->Delete(); delete fInputs;}
111	if (fOutputs) {fOutputs->Delete(); delete fOutputs;}
112	}
113
114	//______________________________________________________________________________
115	AliAnalysisTask& AliAnalysisTask::operator=(const AliAnalysisTask& task)
116	{
117	// Assignment
118	if (&task != this) {
119	TTask::operator=(task);
120	fReady = task.IsReady();
121	fNinputs = task.GetNinputs();
122	fNoutputs = task.GetNoutputs();
123	fInputs = new TObjArray((fNinputs)?fNinputs:2);
124	fOutputs = new TObjArray((fNoutputs)?fNoutputs:2);
125	fPublishedData = 0;
126	Int_t i;
127	for (i=0; i<fNinputs; i++) fInputs->AddAt(task.GetInputSlot(i),i);
128	fOutputReady = new Bool_t[(fNoutputs)?fNoutputs:2];
129	for (i=0; i<fNoutputs; i++) {
130	fOutputReady[i] = IsOutputReady(i);
131	fOutputs->AddAt(task.GetOutputSlot(i),i);
132	}
133	}
134	return *this;
135	}
136
137	//______________________________________________________________________________
138	Bool_t AliAnalysisTask::AreSlotsConnected()
139	{
140	// Check if all input/output slots are connected. If this is the case fReady=true
141	fReady = kFALSE;
142	if (!fNinputs \|\| !fNoutputs) return kFALSE;
143	Int_t i;
144	AliAnalysisDataSlot *slot;
145	for (i=0; i<fNinputs; i++) {
146	slot = (AliAnalysisDataSlot*)fInputs->At(i);
147	if (!slot) {
148	AliError(Form("Input slot %i of task %s not defined !",i,GetName()));
149	return kFALSE;
150	}
151	if (!slot->IsConnected()) return kFALSE;
152	}
153	for (i=0; i<fNoutputs; i++) {
154	slot = (AliAnalysisDataSlot*)fOutputs->At(i);
155	if (!slot) {
156	AliError(Form("Output slot %i of task %s not defined !",i,GetName()));
157	return kFALSE;
158	}
159	if (!slot->IsConnected()) return kFALSE;
160	}
161	fReady = kTRUE;
162	return kTRUE;
163	}
164
165	//______________________________________________________________________________
166	void AliAnalysisTask::CheckNotify()
167	{
168	// Check if data is available from all inputs. Change the status of the task
169	// accordingly. This method is called automatically for all tasks connected
170	// to a container where the data was published.
171	for (Int_t islot=0; islot<fNinputs; islot++) {
172	if (!GetInputData(islot)) {
173	SetActive(kFALSE);
174	return;
175	}
176	}
177	SetActive(kTRUE);
178	}
179
180	//______________________________________________________________________________
181	Bool_t AliAnalysisTask::ConnectInput(Int_t islot, AliAnalysisDataContainer *cont)
182	{
183	// Connect an input slot to a data container.
184	AliAnalysisDataSlot *input = GetInputSlot(islot);
185	if (!input) {
186	AliError(Form("Input slot %i not defined for analysis task %s", islot, GetName()));
187	return kFALSE;
188	}
189	// Check type matching
190	if (!input->GetType()->InheritsFrom(cont->GetType())) {
191	AliError(Form("Data type %s for input %i of task %s not matching container %s of type %s",
192	input->GetType()->GetName(), islot, GetName(), cont->GetName(), cont->GetType()->GetName()));
193	return kFALSE;
194	}
195	// Connect the slot to the container as input
196	if (!input->ConnectContainer(cont)) return kFALSE;
197	// Add this to the list of container consumers
198	cont->AddConsumer(this, islot);
199	AreSlotsConnected();
200	return kTRUE;
201	}
202
203	//______________________________________________________________________________
204	Bool_t AliAnalysisTask::ConnectOutput(Int_t islot, AliAnalysisDataContainer *cont)
205	{
206	// Connect an output slot to a data container.
207	AliAnalysisDataSlot *output = GetOutputSlot(islot);
208	if (!output) {
209	AliError(Form("Output slot %i not defined for analysis task %s", islot, GetName()));
210	return kFALSE;
211	}
212	// Check type matching
213	if (!output->GetType()->InheritsFrom(cont->GetType())) {
214	AliError(Form("Data type %s for output %i of task %s not matching container %s of type %s",
215	output->GetType()->GetName(), islot, GetName(), cont->GetName(), cont->GetType()->GetName()));
216	return kFALSE;
217	}
218	// Connect the slot to the container as output
219	if (!output->ConnectContainer(cont)) return kFALSE;
220	// Declare this as the data producer
221	cont->SetProducer(this, islot);
222	AreSlotsConnected();
223	return kTRUE;
224	}
225
226	//______________________________________________________________________________
227	void AliAnalysisTask::DefineInput(Int_t islot, TClass *type)
228	{
229	// Define an input slot and its type.
230	AliAnalysisDataSlot *input = new AliAnalysisDataSlot(type, this);
231	if (fNinputs<islot+1) fNinputs = islot+1;
232	fInputs->AddAt(input, islot);
233	}
234
235	//______________________________________________________________________________
236	void AliAnalysisTask::DefineOutput(Int_t islot, TClass *type)
237	{
238	// Define an output slot and its type.
239	if (islot<0) {
240	AliError(Form("Cannot define negative output slot number for task %s", GetName()));
241	return;
242	}
243	AliAnalysisDataSlot *output = new AliAnalysisDataSlot(type, this);
244	if (fNoutputs<islot+1) {
245	fNoutputs = islot+1;
246	if (fOutputReady) delete [] fOutputReady;
247	fOutputReady = new Bool_t[fNoutputs];
248	memset(fOutputReady, 0, fNoutputs*sizeof(Bool_t));
249	}
250	fOutputs->AddAt(output, islot);
251	}
252
253	//______________________________________________________________________________
254	TClass *AliAnalysisTask::GetInputType(Int_t islot) const
255	{
256	// Retreive type of a given input slot.
257	AliAnalysisDataSlot *input = GetInputSlot(islot);
258	if (!input) {
259	AliError(Form("Input slot %i not defined for analysis task %s", islot, GetName()));
260	return NULL;
261	}
262	return (input->GetType());
263	}
264
265	//______________________________________________________________________________
266	TClass *AliAnalysisTask::GetOutputType(Int_t islot) const
267	{
268	// Retreive type of a given output slot.
269	AliAnalysisDataSlot *output = GetOutputSlot(islot);
270	if (!output) {
271	AliError(Form("Output slot %i not defined for analysis task %s", islot, GetName()));
272	return NULL;
273	}
274	return (output->GetType());
275	}
276
277	//______________________________________________________________________________
278	TObject *AliAnalysisTask::GetInputData(Int_t islot) const
279	{
280	// Retreive input data for a slot if ready. Normally called by Exec() and
281	// the object has to be statically cast to the appropriate type.
282	AliAnalysisDataSlot *input = GetInputSlot(islot);
283	if (!input) {
284	AliError(Form("Input slot %i not defined for analysis task %s", islot, GetName()));
285	return NULL;
286	}
287	return (input->GetData());
288	}
289
290	//______________________________________________________________________________
291	Bool_t AliAnalysisTask::PostData(Int_t iout, TObject data, Option_t option)
292	{
293	// Post output data for a given ouput slot in the corresponding data container.
294	// Published data becomes owned by the data container.
295	// If option is specified, the container connected to the output slot must have
296	// an associated file name defined. The option represents the method to open the file.
297	fPublishedData = 0;
298	AliAnalysisDataSlot *output = GetOutputSlot(iout);
299	if (!output) {
300	AliError(Form("Output slot %i not defined for analysis task %s", iout, GetName()));
301	return kFALSE;
302	}
303	if (!output->IsConnected()) {
304	AliError(Form("Output slot %i of analysis task %s not connected to any data container", iout, GetName()));
305	return kFALSE;
306	}
307	if (!fOutputReady) {
308	fOutputReady = new Bool_t[fNoutputs];
309	memset(fOutputReady, 0, fNoutputs*sizeof(Bool_t));
310	}
311	fOutputReady[iout] = kTRUE;
312	fPublishedData = data;
313	return (output->GetContainer()->SetData(data, option));
314	}
315
316	//______________________________________________________________________________
317	void AliAnalysisTask::SetUsed(Bool_t flag)
318	{
319	// Set 'used' flag recursively to task and all daughter tasks.
320	if (TestBit(kTaskUsed)==flag) return;
321	TObject::SetBit(kTaskUsed,flag);
322	Int_t nd = fTasks->GetSize();
323	AliAnalysisTask *task;
324	for (Int_t i=0; i<nd; i++) {
325	task = (AliAnalysisTask*)fTasks->At(i);
326	task->SetUsed(flag);
327	}
328	}
329
330	//______________________________________________________________________________
331	Bool_t AliAnalysisTask::CheckCircularDeps()
332	{
333	// Check for illegal circular dependencies, e.g. a daughter task should not have
334	// a hierarchical parent as subtask.
335	if (IsChecked()) return kTRUE;
336	SetChecked();
337	TList *tasks = GetListOfTasks();
338	Int_t ntasks = tasks->GetSize();
339	AliAnalysisTask *task;
340	for (Int_t i=0; i<ntasks; i++) {
341	task = (AliAnalysisTask*)tasks->At(i);
342	if (task->CheckCircularDeps()) return kTRUE;
343	}
344	SetChecked(kFALSE);
345	return kFALSE;
346	}
347
348	//______________________________________________________________________________
349	void AliAnalysisTask::PrintTask(Option_t *option, Int_t indent) const
350	{
351	// Print task info.
352	AliAnalysisTask thistask = (AliAnalysisTask)this;
353	TString opt(option);
354	opt.ToLower();
355	Bool_t dep = (opt.Contains("dep"))?kTRUE:kFALSE;
356	TString ind;
357	Int_t islot;
358	AliAnalysisDataContainer *cont;
359	for (Int_t i=0; i<indent; i++) ind += " ";
360	if (!dep \|\| (dep && IsChecked())) {
361	printf("%s\n", Form("%stask: %s ACTIVE=%i", ind.Data(), GetName(),IsActive()));
362	if (dep) thistask->SetChecked(kFALSE);
363	else {
364	for (islot=0; islot<fNinputs; islot++) {
365	printf("%s", Form("%s INPUT #%i: %s <- ",ind.Data(),islot, GetInputType(islot)->GetName()));
366	cont = GetInputSlot(islot)->GetContainer();
367	if (cont) printf(" [%s]\n", cont->GetName());
368	else printf(" [NO CONTAINER]\n");
369	}
370	for (islot=0; islot<fNoutputs; islot++) {
371	printf("%s", Form("%s OUTPUT #%i: %s -> ",ind.Data(),islot, GetOutputType(islot)->GetName()));
372	cont = GetOutputSlot(islot)->GetContainer();
373	if (cont) printf(" [%s]\n", cont->GetName());
374	else printf(" [NO CONTAINER]\n");
375	}
376	}
377	}
378	PrintContainers(option, indent+3);
379	}
380
381	//______________________________________________________________________________
382	void AliAnalysisTask::PrintContainers(Option_t *option, Int_t indent) const
383	{
384	// Print containers info.
385	AliAnalysisDataContainer *cont;
386	TString ind;
387	for (Int_t i=0; i<indent; i++) ind += " ";
388	Int_t islot;
389	for (islot=0; islot<fNoutputs; islot++) {
390	cont = GetOutputSlot(islot)->GetContainer();
391	cont->PrintContainer(option, indent);
392	}
393	}