1509d6a431cff40bbd2e596555a7b8acf7fdc748
[u/mrichter/AliRoot.git] / RALICE / AliJob.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
18 ///////////////////////////////////////////////////////////////////////////
19 // Class AliJob
20 // Base class for the top level processor class in a task based procedure.
21 // It allows stepwise invokation of various sub-tasks by the derived
22 // (user defined) top level processor, based on looping over a certain
23 // main object structure (e.g. AliEvent for event-by-event processing).
24 // The main object structure (if needed) may be specified by the derived
25 // top level processor class and will be stored automatically in the
26 // working environment (see below).  
27 // This base class provides a working environment for the derived
28 // (user defined) processor class and all of its subtasks.
29 //
30 // The default working environment consists of :
31 //
32 // * An array containing pointers to the objects which are stored
33 //   via the AddObject() facility of this AliJob class.
34 //   From this storage the objects can be directly accessed via the
35 //   GetObject() and GetObjects() memberfunctions.
36 // * A pointer to the main object structure during job processing.
37 //   This pointer can be initiated/updated only by the derived top level
38 //   processor via the SetMainObject() facility but all sub-tasks can access
39 //   it via the above array facilities or the GetMainObject() memberfunction.
40 //   The latter provides faster access to the main object structure than
41 //   the GetObject (search) based procedures.
42 //
43 // Optionally one may invoke the MakeFolder() memberfunction to provide
44 // in addition to the above the following job-specific folder structure :
45 //
46 // * A folder which may serve as a whiteboard for transferring pointers to
47 //   objects which are posted there by the top level processor or any
48 //   of its subtasks.
49 //   Objects can be posted in the job folder via the AddObject() facility
50 //   of this AliJob class.
51 //   Access to the job folder is obtained via the GetFolder() memberfunction
52 //   and from this the various objects can be accessed via the usual TFolder
53 //   FindObject and/or iterator facilities.
54 //
55 // Notes :
56 // -------
57 // 1) This AliJob class is derived from TTask, which implies that every
58 //    (user defined) top level processor class is itself also a TTask.
59 //    This allows sub-tasks to be introduced to the top level processor
60 //    using the standard TTask facilities.
61 //
62 // 2) Only references to the various introduced objects are stored.
63 //    It is the user's responsibility to delete all introduced objects,
64 //    either in the Exec() or destructor of the derived top level processor class
65 //    or via Clear() facility as provided by the TTask machinery.
66 //
67 // 3) The top level processor instance is entered into the standard ROOT
68 //    ListOfTasks under the name which was provided by the user in the
69 //    constructor of the top level processor.
70 //    The name of the top level processor is passed automatically as the
71 //    opt argument to the Exec(Option_t* opt) memberfunctions of the 
72 //    various sub-tasks by the ExecuteJob() memberfunction (see below).
73 //    This allows all sub-tasks to obtain the pointer to the top level
74 //    processor instance from its name via the statement :
75 //
76 //      AliJob* parent=(AliJob*)gROOT->GetListOfTasks()->FindObject(opt)
77 //
78 // 4) If selected, the job-specific folder will be created in the generic folder
79 //    called "AliJob-folders" as a sub-folder under the same name as the one
80 //    introduced in the constructor of the derived top level processor class.
81 //    The folder will only be created if the MakeFolder() member function has been
82 //    invoked explicitly and when the first object is posted via the AddObject()
83 //    or SetMainObject() facilities.
84 //
85 // Execution of the (user defined) top level processor has to be invoked via
86 // the memberfunction ExecuteJob() of this AliJob base class.
87 // This will set the default gROOT as the global working directory and then
88 // invoke the (user written) Exec() memberfunction of the top level
89 // processor class with as argument the name of the top level processor instance
90 // as specified by the user in the top level processor constructor.
91 // This will allow stepwise (e.g. event-by-event) execution of the various sub-tasks.
92 //
93 // It is the user's responsibility to invoke the sub-tasks via the
94 // ExecuteTasks() statement at the appropriate location in the top level
95 // processor class. 
96 //
97 //--- Author: Nick van Eijndhoven 07-may-2005 Utrecht University
98 //- Modified: NvE $Date$ Utrecht University
99 ///////////////////////////////////////////////////////////////////////////
100  
101 #include "AliJob.h"
102 #include "Riostream.h"
103
104 ClassImp(AliJob) // Class implementation to enable ROOT I/O
105
106 AliJob::AliJob(const char* name,const char* title) : TTask(name,title)
107 {
108 // Default constructor.
109 // Initialise the working environment for general data access
110 // by the derived task and its subtasks.
111
112  fMakefolder=0;
113  fMainObject=0;
114  fFolder=0;
115  fObjects=0;
116  fSelect=0;
117
118  // Introduce this AliJob based instance into the ROOT task list
119  TSeqCollection* tasks=gROOT->GetListOfTasks();
120  if (tasks) tasks->Add(this);
121 }
122 ///////////////////////////////////////////////////////////////////////////
123 AliJob::~AliJob()
124 {
125 // Default destructor.
126 // The internal array and job specific folder (if any) holding the various
127 // references are deleted.
128 // Note : The objects belonging to the various pointers in the array/folder
129 //        and the main processing object are NOT deleted by this base class.
130
131  if (fObjects)
132  {
133   delete fObjects;
134   fObjects=0;
135  }
136  if (fFolder)
137  {
138   TList* list=gROOT->GetListOfBrowsables();
139   if (list)
140   {
141    TFolder* top=(TFolder*)list->FindObject("AliJob-folders");
142    if (top) RecursiveRemove(fFolder);
143   }
144   delete fFolder;
145   fFolder=0;
146  }
147  if (fSelect)
148  {
149   delete fSelect;
150   fSelect=0;
151  }
152 }
153 ///////////////////////////////////////////////////////////////////////////
154 void AliJob::ListEnvironment()
155 {
156 // Provide listing of the job environment. 
157
158  cout << " ***" << endl;
159  cout << " *** Environment of job " << GetName() << " ***" << endl;
160  cout << " ***" << endl;
161  cout << " === Available (sub)tasks : " << endl;
162  ls();
163  if (fFolder)
164  {
165   cout << " === Current job-folder contents : " << endl;
166   fFolder->ls();
167  }
168  cout << endl;
169 }
170 ///////////////////////////////////////////////////////////////////////////
171 void AliJob::ExecuteJob()
172 {
173 // Invokation of the top level processor via its Exec() memberfunction.
174 // Note : Before execution gROOT is set as the global working directory.
175  gROOT->cd(); 
176  Exec(GetName());
177 }
178 ///////////////////////////////////////////////////////////////////////////
179 void AliJob::MakeFolder()
180 {
181 // Select creation of the folder structure in addition to the internal
182 // array storage of objects.
183  fMakefolder=1;
184 }
185 ///////////////////////////////////////////////////////////////////////////
186 TFolder* AliJob::GetFolder() const
187 {
188 // Provide pointer to the whiteboard folder.
189  return fFolder;
190 }
191 ///////////////////////////////////////////////////////////////////////////
192 TObject* AliJob::GetMainObject() const
193 {
194 // Provide pointer to the main object structure.
195  return fMainObject;
196 }
197 ///////////////////////////////////////////////////////////////////////////
198 void AliJob::SetMainObject(TObject* obj)
199 {
200 // Store pointer to the main object structure.
201  if (obj)
202  {
203   fMainObject=obj;
204   AddObject(obj);
205  }
206 }
207 ///////////////////////////////////////////////////////////////////////////
208 void AliJob::AddObject(TObject* obj)
209 {
210 // Store pointer of specified object in the working environment.
211
212  if (!obj) return;
213
214  if (!fObjects) fObjects=new TObjArray();
215
216  if (fMakefolder && !fFolder)
217  {
218   // Create the top level environment folder for all AliJobs if needed 
219   TList* list=gROOT->GetListOfBrowsables();
220   if (list)
221   {
222    TFolder* top=(TFolder*)list->FindObject("AliJob-folders");
223    if (!top)
224    {
225     top=new TFolder("AliJob-folders","Environment for all AliJob derived tasks");
226     list->Add(top,"AliJob-folders");
227    }
228    // Create the task-specific folder as a sub-folder in the top folder 
229    fFolder=top->AddFolder(GetName(),GetTitle());
230   }
231  }
232
233  // Add object pointer to array and folder if it doesn't already exist 
234  Int_t exist=0;
235  for (Int_t i=0; i<fObjects->GetEntries(); i++)
236  {
237   if (obj==fObjects->At(i))
238   {
239    exist=1;
240    break;
241   }
242  }
243  if (!exist)
244  {
245   fObjects->Add(obj);
246   if (fFolder) fFolder->Add(obj);
247  }
248 }
249 ///////////////////////////////////////////////////////////////////////////
250 void AliJob::AddObjects(TObjArray* arr)
251 {
252 // Store pointers of all the array objects individually in the working environment.
253
254  if (!arr) return;
255
256  TObject* obj=0;
257  for (Int_t i=0; i<arr->GetSize(); i++)
258  {
259   obj=arr->At(i);
260   if (obj) AddObject(obj);
261  }
262 }
263 ///////////////////////////////////////////////////////////////////////////
264 void AliJob::RemoveObject(TObject* obj)
265 {
266 // Remove pointer of specified object from the working environment.
267 // In case the specified object is also the main object, the main object
268 // pointer will be set to 0 as well.
269
270  if (!obj) return;
271
272  if (fObjects)
273  {
274   TObject* test=fObjects->Remove(obj);
275   if (test)
276   {
277    fObjects->Compress();
278    if (test==fMainObject) fMainObject=0;
279   }
280  }
281
282  if (fFolder) fFolder->Remove(obj);
283 }
284 ///////////////////////////////////////////////////////////////////////////
285 void AliJob::RemoveObjects(const char* classname)
286 {
287 // Remove all stored objects inheriting from classname.
288 // In case one of the removed objects is also the main object, the main object
289 // pointer will be set to 0 as well.
290
291  if (!fObjects) return;
292
293  Int_t remove=0;
294  for (Int_t i=0; i<fObjects->GetEntries(); i++)
295  {
296   TObject* obj=fObjects->At(i);
297   if (obj->InheritsFrom(classname))
298   {
299    TObject* test=fObjects->Remove(obj);
300    if (test)
301    {
302     remove=1;
303     if (test==fMainObject) fMainObject=0;
304    }
305    if (fFolder) fFolder->Remove(obj);
306   }
307  }
308  if (remove) fObjects->Compress();
309 }
310 ///////////////////////////////////////////////////////////////////////////
311 TObject* AliJob::GetObject(Int_t j) const
312 {
313 // Provide pointer to j-th stored object.
314 // Note : j=1 indicates the first object.
315
316  if (!fObjects || j<1) return 0;
317
318  TObject* obj=0;
319
320  if (j<=fObjects->GetEntries()) obj=fObjects->At(j-1);
321  return obj;
322 }
323 ///////////////////////////////////////////////////////////////////////////
324 TObject* AliJob::GetObject(const char* classname) const
325 {
326 // Provide pointer to the first stored object which inherits from classname.
327
328  if (!fObjects) return 0;
329
330  TObject* obj=0;
331  for (Int_t i=0; i<fObjects->GetEntries(); i++)
332  {
333   TObject* obx=fObjects->At(i);
334   if (obx->InheritsFrom(classname))
335   {
336    obj=obx;
337    break;
338   }
339  }
340  return obj;
341 }
342 ///////////////////////////////////////////////////////////////////////////
343 TObjArray* AliJob::GetObjects() const
344 {
345 // Provide pointers of all the stored objects.
346  return fObjects;
347 }
348 ///////////////////////////////////////////////////////////////////////////
349 TObjArray* AliJob::GetObjects(const char* classname)
350 {
351 // Provide pointers to all stored objects inheriting from classname.
352
353  if (!fObjects) return 0;
354
355  if (fSelect)
356  {
357   fSelect->Clear();
358  }
359  else
360  {
361   fSelect=new TObjArray();
362  }
363
364  for (Int_t i=0; i<fObjects->GetEntries(); i++)
365  {
366   TObject* obj=fObjects->At(i);
367   if (obj->InheritsFrom(classname)) fSelect->Add(obj);
368  }
369  return fSelect;
370 }
371 ///////////////////////////////////////////////////////////////////////////