]> git.uio.no Git - u/mrichter/AliRoot.git/blame - STEER/AliLoader.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Correct streamer (Haavard)
[u/mrichter/AliRoot.git] / STEER / AliLoader.cxx
CommitLineData
88cb7938 1//
2//Class (base) responsible for management of data:
3// - opening and closing proper files
4// - posting data to folders
5// - writing data from folders to proper files
6//
7//Author: Alice Offline Group http://alisoft.cern.ch
8//Responsible: Piotr.Skowronski@cern.ch
9//
d65adc48 10#include "AliLoader.h"
88cb7938 11
12//Root includes
13#include <TROOT.h>
88cb7938 14#include <TFile.h>
a9bbb414 15#include <TFolder.h>
88cb7938 16#include <TString.h>
a9bbb414 17#include <TTask.h>
88cb7938 18
19//AliRoot includes
d0d4a6b3 20#include "AliConfig.h"
a9bbb414 21#include "AliDetector.h"
22#include "AliDigitizer.h"
23#include "AliLog.h"
24#include "AliRun.h"
25#include "AliRunLoader.h"
88cb7938 26
88cb7938 27const TString AliLoader::fgkDefaultHitsContainerName("TreeH");
28const TString AliLoader::fgkDefaultDigitsContainerName = "TreeD";
29const TString AliLoader::fgkDefaultSDigitsContainerName = "TreeS";
30const TString AliLoader::fgkDefaultRecPointsContainerName = "TreeR";
31const TString AliLoader::fgkDefaultTracksContainerName = "TreeT";
32const TString AliLoader::fgkDefaultRecParticlesContainerName = "TreeP";
33const TString AliLoader::fgkLoaderBaseName("Loader");
34
35ClassImp(AliLoader)
36//___________________________________________________________________
37/////////////////////////////////////////////////////////////////////
38// //
39// class AliLoader //
40// //
41// Base class for Loaders. //
42// Loader provides base I/O fascilities for "standard" data. //
43// Each detector has a laoder data member //
44// loader is accessible via folder structure as well //
45// //
46/////////////////////////////////////////////////////////////////////
47
48/*****************************************************************************/
49
50AliLoader::AliLoader():
51 fDataLoaders(0x0),
52 fDetectorName(""),
53 fEventFolder(0x0),
54 fDataFolder(0x0),
55 fDetectorDataFolder(0x0),
56 fModuleFolder(0x0),
57 fTasksFolder(0x0),
58 fQAFolder(0x0)
90e48c0c 59{
88cb7938 60//default constructor
61
62 }
63/******************************************************************/
64
65AliLoader::AliLoader(const Char_t* detname,const Char_t* eventfoldername):
66 fDataLoaders(new TObjArray(kNDataTypes)),
67 fDetectorName(""),
68 fEventFolder(0x0),
69 fDataFolder(0x0),
70 fDetectorDataFolder(0x0),
71 fModuleFolder(0x0),
72 fTasksFolder(0x0),
73 fQAFolder(0x0)
74{
75 //ctor
21bf7095 76 AliDebug(1, Form("detname = %s eventfoldername = %s",detname,eventfoldername));
88cb7938 77
78 //try to find folder eventfoldername in top alice folder
79 //safe because GetTopFolder will abort in case of failure
80
81 fDetectorName = detname;
82 fName = fDetectorName+"Loader";
83 InitDefaults();
84
85 TObject* fobj = GetTopFolder()->FindObject(eventfoldername);
86 fEventFolder = (fobj)?dynamic_cast<TFolder*>(fobj):0x0;//in case FindObject returns NULL dynamic cast cause seg. fault
87 SetEventFolder(fEventFolder);
88
89 }
90/*****************************************************************************/
91
92AliLoader::AliLoader(const Char_t * detname,TFolder* eventfolder):
93 fDataLoaders(new TObjArray(kNDataTypes)),
94 fDetectorName(detname),
95 fEventFolder(0x0),
96 fDataFolder(0x0),
97 fDetectorDataFolder(0x0),
98 fModuleFolder(0x0),
99 fTasksFolder(0x0),
100 fQAFolder(0x0)
101{
102//constructor
103 fDetectorName = detname;
104 fName = fDetectorName+"Loader";
105 InitDefaults();
106 SetEventFolder(eventfolder);
107 //fileoption's don't need to initialized because default TString ctor does it correctly
108}
109/*****************************************************************************/
90e48c0c 110AliLoader::AliLoader(const AliLoader& source) :
111 TNamed(source),
112 fDataLoaders(source.fDataLoaders),
113 fDetectorName(source.fDetectorName),
114 fEventFolder(source.fEventFolder),
115 fDataFolder(source.fDataFolder),
116 fDetectorDataFolder(source.fDetectorDataFolder),
117 fModuleFolder(source.fModuleFolder),
118 fTasksFolder(source.fTasksFolder),
119 fQAFolder(source.fQAFolder)
120{
d0d4a6b3 121 // dummy copy constructor
122 if(&source==this)return;
123
21bf7095 124 AliFatal("Copy constructor not implemented. Aborting");
d0d4a6b3 125 return;
126}
88cb7938 127
d0d4a6b3 128/*****************************************************************************/
129AliLoader& AliLoader::operator=(const AliLoader& source) {
130 // dummy assignment operator
131 if(&source==this) return *this;
132
21bf7095 133 AliFatal("Assignment operator not implemented. Aborting");
d0d4a6b3 134 return *this;
135}
136
137/*****************************************************************************/
88cb7938 138AliLoader::~AliLoader()
139{
140//detructor
141 if (fDataLoaders) fDataLoaders->SetOwner();
142 delete fDataLoaders;
143}
144/*****************************************************************************/
145
146void AliLoader::InitDefaults()
147{
148 // H I T S
149 AliDataLoader* dl;
150 dl = new AliDataLoader(fDetectorName + ".Hits.root",fgkDefaultHitsContainerName, "Hits" );
151 fDataLoaders->AddAt(dl,kHits);
152
153
154 // S U M M A B L E D I G I T S
155 dl = new AliDataLoader(fDetectorName + ".SDigits.root",fgkDefaultSDigitsContainerName, "Summable Digits");
156 AliTaskLoader* tl = new AliTaskLoader(fDetectorName + AliConfig::Instance()->GetSDigitizerTaskName(),
157 dl,AliRunLoader::GetRunSDigitizer(),kTRUE);
158 dl->SetBaseTaskLoader(tl);
159 fDataLoaders->AddAt(dl,kSDigits);
160
161 // D I G I T S
162 dl = new AliDataLoader(fDetectorName + ".Digits.root",fgkDefaultDigitsContainerName, "Digits");
163 tl = new AliTaskLoader(fDetectorName + AliConfig::Instance()->GetDigitizerTaskName(),
164 dl,AliRunLoader::GetRunDigitizer(),kTRUE);
165 dl->SetBaseTaskLoader(tl);
166 fDataLoaders->AddAt(dl,kDigits);
167
168 // R E C O N S T R U C T E D P O I N T S aka C L U S T E R S
169 dl = new AliDataLoader(fDetectorName + ".RecPoints.root",fgkDefaultRecPointsContainerName, "Reconstructed Points");
170 tl = new AliTaskLoader(fDetectorName + AliConfig::Instance()->GetReconstructionerTaskName(),
171 dl,AliRunLoader::GetRunReconstructioner(),kTRUE);
172 dl->SetBaseTaskLoader(tl);
173 fDataLoaders->AddAt(dl,kRecPoints);
174
175 // T R A C K S
176 dl = new AliDataLoader(fDetectorName + ".Tracks.root",fgkDefaultTracksContainerName, "Tracks");
177 tl = new AliTaskLoader(fDetectorName + AliConfig::Instance()->GetTrackerTaskName(),
178 dl,AliRunLoader::GetRunTracker(),kTRUE);
179 dl->SetBaseTaskLoader(tl);
180 fDataLoaders->AddAt(dl,kTracks);
181
182 // R E C O N S T R U C T E D P O I N T S aka C L U S T E R S
183 dl = new AliDataLoader(fDetectorName + ".RecParticles.root",fgkDefaultRecParticlesContainerName, "Reconstructed Particles");
184 tl = new AliTaskLoader(fDetectorName + AliConfig::Instance()->GetPIDTaskName(),
185 dl,AliRunLoader::GetRunPIDTask(),kTRUE);
186 dl->SetBaseTaskLoader(tl);
187 fDataLoaders->AddAt(dl,kRecParticles);
188
189 }
190/*****************************************************************************/
191
192AliDataLoader* AliLoader::GetDataLoader(const char* name)
193{
194//returns Data Loader with specified name
195 return dynamic_cast<AliDataLoader*>(fDataLoaders->FindObject(name));
196}
197/*****************************************************************************/
deee9e3b 198void AliLoader::AddDataLoader(AliDataLoader* dl)
199{
8364b0ef 200 //
201 // Adds a data loader
202 //
deee9e3b 203 if (dl == 0x0)
204 {
21bf7095 205 AliError("Pointer is NULL");
deee9e3b 206 return;
207 }
208 if (fDataLoaders->FindObject(dl->GetName()))
209 {
21bf7095 210 AliError("Such a loader exists");
deee9e3b 211 return;
212 }
213 fDataLoaders->AddLast(dl);
214 dl->SetEventFolder(fEventFolder);
215 dl->SetFolder(GetDetectorDataFolder()); //Must exists - ensure register is called before
216}
217/*****************************************************************************/
88cb7938 218
219Int_t AliLoader::SetEvent()
220{
221 //basically the same that GetEvent but do not post data to folders
222 TIter next(fDataLoaders);
223 AliDataLoader* dl;
224 while ((dl = (AliDataLoader*)next()))
225 {
226 dl->SetEvent();
227 }
228 return 0;
229}
230/******************************************************************/
231
1bb20a37 232void AliLoader::UnloadAll()
233{
234 //calls UnloadAll for all base laoders
235 //Unloads everything
236 TIter next(fDataLoaders);
237 AliDataLoader* dl;
238 while ((dl = (AliDataLoader*)next()))
239 {
240 dl->UnloadAll();
241 }
242}
243/******************************************************************/
244
88cb7938 245Int_t AliLoader::GetEvent()
246{
247 //changes to proper root directory and tries to load data from files to folders
248 // event number is defined in RunLoader
249 //
250 //returns:
251 // 0 - in case of no error
252 // 1 - event not found
253 //
254
255 Int_t retval;
256 TIter next(fDataLoaders);
257 AliDataLoader* dl;
258 while ((dl = (AliDataLoader*)next()))
259 {
260 retval = dl->GetEvent();
261 if (retval)
262 {
21bf7095 263 AliError(Form("Error occured while GetEvent for %s",dl->GetName()));
88cb7938 264 return retval;
265 }
266 }
267
268 return 0;
269}
270
271/******************************************************************/
272
273TFolder* AliLoader::GetTopFolder()
274{
275//returns TOP aliroot folder, just a simple interface to AliConfig (gives shorter notation)
276 return AliConfig::Instance()->GetTopFolder();
277}
278
279/******************************************************************/
280
281TFolder* AliLoader::GetEventFolder()
282{
283//get EVENT folder (data that are changing from event to event, even in single run)
284 return fEventFolder;
285}
286/******************************************************************/
287TFolder* AliLoader::GetDataFolder()
288{
289//returns the folder speciofic to given detector e.g. /Folders/Event/Data/
290 if (!fDataFolder)
291 {
e191bb57 292 fDataFolder = dynamic_cast<TFolder*>(GetEventFolder()->FindObject(AliConfig::Instance()->GetDataFolderName()));
88cb7938 293
294 if (!fDataFolder)
295 {
21bf7095 296 AliFatal("Can not find AliRoot data folder. Aborting");
88cb7938 297 return 0x0;
298 }
299 }
300 return fDataFolder;
301}
302
303/*****************************************************************************/
304
305TFolder* AliLoader::GetTasksFolder()
306{
307//Returns pointer to Folder with Alice Tasks
308 if (!fTasksFolder)
309 {
e191bb57 310 fTasksFolder = dynamic_cast<TFolder*>(GetTopFolder()->FindObject(AliConfig::GetTasksFolderName()));
88cb7938 311
312 if (!fTasksFolder)
313 {
21bf7095 314 AliFatal("Can not find tasks folder. Aborting");
88cb7938 315 return 0x0;
316 }
317 }
318 return fTasksFolder;
319
320}
321/*****************************************************************************/
322
323TFolder* AliLoader::GetModulesFolder()
324{
d0d4a6b3 325 //returns pointer to the folder containing modules
88cb7938 326 if (!fModuleFolder)
327 {
328 fModuleFolder = dynamic_cast<TFolder*>(GetEventFolder()->FindObjectAny(AliConfig::GetModulesFolderName()));
329
330 if (!fModuleFolder)
331 {
21bf7095 332 AliFatal("Can not find modules folder. Aborting");
88cb7938 333 return 0x0;
334 }
335 }
336 return fModuleFolder;
337
338}
339/*****************************************************************************/
340
341TFolder* AliLoader::GetQAFolder()
342{
343 //returns folder with Quality assurance
344 if (fQAFolder == 0x0)
345 {
346 TObject *obj = GetEventFolder()->FindObjectAny(AliConfig::Instance()->GetQAFolderName());
347 fQAFolder = (obj)?dynamic_cast<TFolder*>(obj):0x0;
348
349 if (fQAFolder == 0x0)
350 {
21bf7095 351 AliFatal("Can not find Quality Assurance folder. Aborting");
88cb7938 352 return 0x0;
353 }
354 }
355 return fQAFolder;
356
357}
358/*****************************************************************************/
d0d4a6b3 359TTask* AliLoader::SDigitizer() const
88cb7938 360{
361//returns SDigitizer task for this detector
362 return GetSDigitsDataLoader()->GetBaseTaskLoader()->Task();
363
364}
365/*****************************************************************************/
366
d0d4a6b3 367AliDigitizer* AliLoader::Digitizer() const
88cb7938 368{
369//returns Digitizer task for this detector
370 return dynamic_cast<AliDigitizer*>(GetDigitsDataLoader()->GetBaseTaskLoader()->Task());
371}
372/*****************************************************************************/
373
d0d4a6b3 374TTask* AliLoader::Reconstructioner() const
88cb7938 375{
376//returns Recontructioner (Cluster Finder, Cluster Maker,
377//or whatever you want to call it) task for this detector
378 return GetRecPointsDataLoader()->GetBaseTaskLoader()->Task();
379}
380/*****************************************************************************/
381
d0d4a6b3 382TTask* AliLoader::Tracker() const
88cb7938 383{
384//returns tracker
385 return dynamic_cast<TTask*>(GetTracksDataLoader()->GetBaseTaskLoader()->Task());
386}
387
388/*****************************************************************************/
d0d4a6b3 389TTask* AliLoader::PIDTask() const
88cb7938 390{
391//returns tracker
392 return dynamic_cast<TTask*>(GetRecParticlesDataLoader()->GetBaseTaskLoader()->Task());
393}
394
395/*****************************************************************************/
396
d0d4a6b3 397TTask* AliLoader::QAtask(const char* name) const
88cb7938 398{
d0d4a6b3 399 // Returns pointer to the quality assurance task
88cb7938 400 TTask* qat = AliRunLoader::GetRunQATask();
401 if ( qat == 0x0 )
402 {
21bf7095 403 AliError(Form("Can not get RunQATask. (Name:%s)",GetName()));
88cb7938 404 return 0x0;
405 }
406
407 TString dqatname(fDetectorName + AliConfig::Instance()->GetQATaskName());
408 TTask* dqat = dynamic_cast<TTask*>(qat->GetListOfTasks()->FindObject(dqatname));
409
410 if ( dqat == 0x0 )
411 {
21bf7095 412 AliError(Form("Can not find QATask in RunQATask for %s",GetDetectorName().Data()));
88cb7938 413 return 0x0;
414 }
415
416 if (strlen(name) == 0) return dqat;
417
418 TList* list = dqat->GetListOfTasks();
419
420 TIter it(list) ;
421 TTask * task = 0 ;
422 while((task = static_cast<TTask *>(it.Next()) ))
423 {
424 TString taskname(task->GetName()) ;
425 if(taskname.BeginsWith(name))
426 return task ;
427 }
21bf7095 428 AliError(Form("Can not find sub-task with name starting with %s in task %s",name,dqat->GetName()));
88cb7938 429 return 0x0;
430}
431/*****************************************************************************/
432
433TDirectory* AliLoader::ChangeDir(TFile* file, Int_t eventno)
434{
435//changes the root directory in "file" to "dirname" which corresponds to event 'eventno'
436//in case of success returns the pointer to directory
437//else NULL
438
439 if (file == 0x0)
440 {
21bf7095 441 AliErrorClass("File is null");
88cb7938 442 return 0x0;
443 }
444 if (file->IsOpen() == kFALSE)
445 {
21bf7095 446 AliErrorClass("File is not opened");
88cb7938 447 return 0x0;
448 }
449
450 TString dirname("Event");
451 dirname+=eventno;
21bf7095 452 AliDebugClass(1, Form("Changing Dir to %s in file %s.",dirname.Data(),file->GetName()));
88cb7938 453
454 Bool_t result;
455
456 TDirectory* dir = dynamic_cast<TDirectory*>(file->Get(dirname));
457
458 if (dir == 0x0)
459 {
21bf7095 460 AliDebugClass(1, Form("Can not find directory %s in file %s, creating...",
461 dirname.Data(),file->GetName()));
88cb7938 462
463 if (file->IsWritable() == kFALSE)
464 {
21bf7095 465 AliErrorClass(Form("Can not create directory. File %s in not writable.",
466 file->GetName()));
88cb7938 467 return 0x0;
468 }
469
470 TDirectory* newdir = file->mkdir(dirname);
471 if (newdir == 0x0)
472 {
21bf7095 473 AliErrorClass(Form("Failed to create new directory in file %s.",
474 file->GetName()));
88cb7938 475 return 0x0;
476 }
477 result = file->cd(dirname);
478 if (result == kFALSE)
479 {
480 return 0x0;
481 }
482 }
483 else
484 {
485 file->cd();//make a file active
486 file->cd(dirname);//cd event dir
487 }
488
489 return gDirectory;
490}
491/*****************************************************************************/
492
d0d4a6b3 493TString AliLoader::GetUnixDir() const
88cb7938 494 {
495 //This Method will manage jumping through unix directories in case of
496 //run with more events per run than defined in gAlice
497
498 TString dir;
499
500 return dir;
501 }
502/*****************************************************************************/
503/************************************************************/
504
505void AliLoader::MakeTree(Option_t *option)
506 {
507//Makes a tree depending on option
508// H: - Hits
509// D: - Digits
510// S: - Summable Digits
511// R: - Reconstructed Points (clusters)
512// T: - Tracks (tracklets)
0f46f5fa 513// GG: - Trigger
88cb7938 514
515 const char *oH = strstr(option,"H");
516 const char *oD = strstr(option,"D");
517 const char *oS = strstr(option,"S");
518 const char *oR = strstr(option,"R");
519 const char *oT = strstr(option,"T");
520 const char *oP = strstr(option,"P");
0f46f5fa 521 const char *oGG = strstr(option,"GG");
88cb7938 522
523 if (oH) MakeHitsContainer();
524 if (oD) MakeDigitsContainer();
525 if (oS) MakeSDigitsContainer();
526 if (oR) MakeRecPointsContainer();
527 if (oT) MakeTracksContainer();
528 if (oP) MakeRecParticlesContainer();
0f46f5fa 529 if (oGG) AliError("Don't know how to create a trigger tree");
88cb7938 530 }
531
532/*****************************************************************************/
9bb30bcb 533Int_t AliLoader::WriteHits(Option_t* opt) const
88cb7938 534 {
d0d4a6b3 535 // Writes hits
88cb7938 536 AliDataLoader* dl = GetHitsDataLoader();
537 Int_t ret = dl->WriteData(opt);
538 return ret;
539 }
540/*****************************************************************************/
541
9bb30bcb 542Int_t AliLoader::WriteSDigits(Option_t* opt) const
88cb7938 543 {
d0d4a6b3 544 // Writes summable digits
88cb7938 545 AliDataLoader* dl = GetSDigitsDataLoader();
546 Int_t ret = dl->WriteData(opt);
547 return ret;
548 }
549
550/*****************************************************************************/
551
9bb30bcb 552Int_t AliLoader::PostSDigitizer(TTask* sdzer) const
88cb7938 553{
d0d4a6b3 554 // Posts sdigitizer
88cb7938 555 return GetSDigitsDataLoader()->GetBaseTaskLoader()->Post(sdzer);
556}
557/*****************************************************************************/
558
9bb30bcb 559Int_t AliLoader::PostDigitizer(AliDigitizer* task) const
88cb7938 560 {
d0d4a6b3 561 // Posts digitizer
88cb7938 562 return GetDigitsDataLoader()->GetBaseTaskLoader()->Post(task);
563 }
564/*****************************************************************************/
565
9bb30bcb 566Int_t AliLoader::PostReconstructioner(TTask* task) const
88cb7938 567 {
d0d4a6b3 568 // Posts Reconstructioner
88cb7938 569 return GetRecPointsDataLoader()->GetBaseTaskLoader()->Post(task);
570 }
571/*****************************************************************************/
572
9bb30bcb 573Int_t AliLoader::PostTracker(TTask* task) const
88cb7938 574 {
d0d4a6b3 575 // Posts a tracker
88cb7938 576 return GetTracksDataLoader()->GetBaseTaskLoader()->Post(task);
577 }
578/*****************************************************************************/
579
9bb30bcb 580Int_t AliLoader::PostPIDTask(TTask* task) const
88cb7938 581 {
d0d4a6b3 582 // Posts particle identification task
88cb7938 583 return GetRecParticlesDataLoader()->GetBaseTaskLoader()->Post(task);
584 }
585/*****************************************************************************/
586
587TObject** AliLoader::GetDetectorDataRef(TObject *obj)
588{
d0d4a6b3 589 // Returns pointer to an entry in the list of folders pointing to "obj"
88cb7938 590 if (obj == 0x0)
591 {
592 return 0x0;
593 }
594 return GetDetectorDataFolder()->GetListOfFolders()->GetObjectRef(obj) ;
595}
596/*****************************************************************************/
597
598TObject** AliLoader::SDigitizerRef()
599{
d0d4a6b3 600 // Returns pointer to a Runloader's task-list entry pointing to SDigitizer
88cb7938 601 TTask* rsd = AliRunLoader::GetRunSDigitizer();
602 if (rsd == 0x0)
603 {
604 return 0x0;
605 }
606 return rsd->GetListOfTasks()->GetObjectRef(SDigitizer());
607}
608/*****************************************************************************/
609
610TObject** AliLoader::DigitizerRef()
611{
d0d4a6b3 612 // Returns pointer to a Runloader's task-list entry pointing to Digitizer
88cb7938 613 TTask* rd = AliRunLoader::GetRunDigitizer();
614 if (rd == 0x0)
615 {
616 return 0x0;
617 }
618 return rd->GetListOfTasks()->GetObjectRef(Digitizer()) ;
619}
620/*****************************************************************************/
621
622TObject** AliLoader::ReconstructionerRef()
623{
d0d4a6b3 624 // Returns pointer to a Runloader's task-list entry pointing to Reconstructioner
88cb7938 625 TTask* rrec = AliRunLoader::GetRunReconstructioner();
626 if (rrec == 0x0)
627 {
628 return 0x0;
629 }
630 return rrec->GetListOfTasks()->GetObjectRef(Reconstructioner());
631}
632/*****************************************************************************/
633
634TObject** AliLoader::TrackerRef()
635{
d0d4a6b3 636 // Returns pointer to a Runloader's task-list entry pointing to Tracker
88cb7938 637 TTask* rrec = AliRunLoader::GetRunTracker();
638 if (rrec == 0x0)
639 {
640 return 0x0;
641 }
642 return rrec->GetListOfTasks()->GetObjectRef(Tracker());
643}
644/*****************************************************************************/
645
646TObject** AliLoader::PIDTaskRef()
647{
d0d4a6b3 648 // Returns pointer to a Runloader's task-list entry pointing to PIDTask
88cb7938 649 TTask* rrec = AliRunLoader::GetRunPIDTask();
650 if (rrec == 0x0)
651 {
652 return 0x0;
653 }
654 return rrec->GetListOfTasks()->GetObjectRef(PIDTask());
655}
656
657/*****************************************************************************/
658void AliLoader::CleanFolders()
659 {
660 //Cleans all posted objects == removes from folders and deletes them
661 TIter next(fDataLoaders);
662 AliDataLoader* dl;
663 while ((dl = (AliDataLoader*)next()))
664 {
21bf7095 665 AliDebug(1, Form("name = %s cleaning",dl->GetName()));
88cb7938 666 dl->Clean();
667 }
668 }
669/*****************************************************************************/
670
671/*****************************************************************************/
672
673void AliLoader::CleanSDigitizer()
674{
675//removes and deletes detector task from Run Task
3637d19d 676 if ( GetSDigitsDataLoader()->GetBaseTaskLoader() == 0x0 )
677 {
21bf7095 678 AliWarning("Task Loader for SDigits does not exist");
3637d19d 679 return;
680 }
681 GetSDigitsDataLoader()->GetBaseTaskLoader()->Clean();
88cb7938 682}
683/*****************************************************************************/
684
685void AliLoader::CleanDigitizer()
686{
687//removes and deletes detector task from Run Task
3637d19d 688 if ( GetDigitsDataLoader()->GetBaseTaskLoader() == 0x0 )
689 {
21bf7095 690 AliWarning("Task Loader for Digits does not exist");
3637d19d 691 return;
692 }
693 GetDigitsDataLoader()->GetBaseTaskLoader()->Clean();
88cb7938 694}
695/*****************************************************************************/
696
697void AliLoader::CleanReconstructioner()
698{
699//removes and deletes detector Reconstructioner from Run Reconstructioner
3637d19d 700 if ( GetRecPointsDataLoader()->GetBaseTaskLoader() == 0x0 )
701 {
21bf7095 702 AliWarning("Task Loader for SDigits does not exist");
3637d19d 703 return;
704 }
705 GetRecPointsDataLoader()->GetBaseTaskLoader()->Clean();
88cb7938 706}
707/*****************************************************************************/
708
709void AliLoader::CleanTracker()
710{
3637d19d 711//removes and deletes detector task from Run Task
712 if ( GetTracksDataLoader()->GetBaseTaskLoader() == 0x0 )
713 {
21bf7095 714 AliWarning("Task Loader for Tracks does not exist");
3637d19d 715 return;
716 }
717 GetTracksDataLoader()->GetBaseTaskLoader()->Clean();
88cb7938 718}
719/*****************************************************************************/
720
721void AliLoader::CleanPIDTask()
722{
723//removes and deletes detector Reconstructioner from Run Reconstructioner
88cb7938 724
3637d19d 725 if ( GetRecParticlesDataLoader()->GetBaseTaskLoader() == 0x0 )
726 {
21bf7095 727 AliWarning("Task Loader for Reconstructed Particles does not exist");
3637d19d 728 return;
729 }
730 GetRecParticlesDataLoader()->GetBaseTaskLoader()->Clean();
88cb7938 731}
732/*****************************************************************************/
733
734Int_t AliLoader::ReloadAll()
735{
d0d4a6b3 736 // Calling Reload function for all the data loaders
88cb7938 737 TIter next(fDataLoaders);
738 AliDataLoader* dl;
739
740 while((dl = (AliDataLoader*)next()))
741 {
742 Int_t err = dl->Reload();
743 if (err)
744 {
21bf7095 745 AliError(Form("Reload returned error for %s",dl->GetName()));
88cb7938 746 return err;
747 }
748 }
749 return 0;
750}
751/*****************************************************************************/
752
753void AliLoader::CloseFiles()
754{
755//close files for data loaders
756 TIter next(fDataLoaders);
757 AliDataLoader* dl;
758 while((dl = (AliDataLoader*)next()))
759 {
760 dl->CloseFile();
761 }
762}
763/*****************************************************************************/
764
765Int_t AliLoader::SetEventFolder(TFolder* eventfolder)
766{
d0d4a6b3 767 //sets the event folder
88cb7938 768 if (eventfolder == 0x0)
769 {
21bf7095 770 AliError("Stupid joke. Argument is NULL");
88cb7938 771 return 1;
772 }
773
774 fEventFolder = eventfolder;
775 TIter next(fDataLoaders);
776 AliDataLoader* dl;
777
778 while((dl = (AliDataLoader*)next()))
779 {
780 dl->SetEventFolder(fEventFolder);
781 dl->SetFolder(GetDetectorDataFolder()); //Must exists - ensure register is called before
782 }
783
784 return 0;
785}//sets the event folder
786/*****************************************************************************/
787
788Int_t AliLoader::Register(TFolder* eventFolder)
789{
790//triggers creation of subfolders for a given detector
791//this method is called when session is read from disk
792//
793//warning: AliDetector in constructor (not default) calls
794//creation of folder structure as well (some detectors needs folders
795//alrady in constructors)
796
21bf7095 797 AliDebug(1, Form("Name is %s.",GetName()));
88cb7938 798 if (eventFolder == 0x0)
799 {
21bf7095 800 AliError("Event folder is not set.");
88cb7938 801 return 1;
802 }
803 Int_t retval = AliConfig::Instance()->AddDetector(eventFolder,fDetectorName,fDetectorName);
804 if(retval)
805 {
21bf7095 806 AliError(Form("Can not create tasks and/or folders for %s. Event folder name is %s",
807 fDetectorName.Data(),eventFolder->GetName()));
88cb7938 808 return retval;
809 }
810 SetEventFolder(eventFolder);
811 return 0;
812}
813/*****************************************************************************/
814AliRunLoader* AliLoader::GetRunLoader()
815{
816//gets the run-loader from event folder
817 AliRunLoader* rg = 0x0;
024a7e64 818 TObject * obj = GetEventFolder()->FindObject(AliRunLoader::GetRunLoaderName());
88cb7938 819 if (obj) rg = dynamic_cast<AliRunLoader*>(obj);
820 return rg;
821}
822/*****************************************************************************/
823Bool_t AliLoader::TestFileOption(Option_t* opt)
824{
825//tests the TFile::Option
826//if file is truncated at opening moment ("recreate", "new" or "create") returns kFALSE;
827//else kTRUE (means opened with "read" or "update" mode)
828 TString option(opt);
829 if (option.CompareTo("recreate",TString::kIgnoreCase) == 0) return kFALSE;
830 if (option.CompareTo("new",TString::kIgnoreCase) == 0) return kFALSE;
831 if (option.CompareTo("create",TString::kIgnoreCase) == 0) return kFALSE;
832 return kTRUE;
833}
834/*****************************************************************************/
835void AliLoader::SetDirName(TString& dirname)
836{
fca6cd9f 837//adds "dirname" to each file. Dirname should end with "#","/", or ":"
88cb7938 838 TIter next(fDataLoaders);
839 AliDataLoader* dl;
840 while((dl = (AliDataLoader*)next()))
841 {
842 dl->SetDirName(dirname);
843 }
844}
845
846/*****************************************************************************/
847
9bb30bcb 848void AliLoader::SetDigitsFileNameSuffix(const TString& suffix) const
88cb7938 849{
850 //adds the suffix before ".root",
851 //e.g. TPC.Digits.root -> TPC.DigitsMerged.root
852 //made on Jiri Chudoba demand
853 GetDigitsDataLoader()->SetFileNameSuffix(suffix);
854}
855/*****************************************************************************/
856
857void AliLoader::SetCompressionLevel(Int_t cl)
858{
859//sets comression level for data defined by di
860 TIter next(fDataLoaders);
861 AliDataLoader* dl;
862 while((dl = (AliDataLoader*)next()))
863 {
864 dl->SetCompressionLevel(cl);
865 }
866}
867/*****************************************************************************/
868
869void AliLoader::Clean()
870{
871//Cleans all data loaders
872 TIter next(fDataLoaders);
873 AliDataLoader* dl;
874 while((dl = (AliDataLoader*)next()))
875 {
876 dl->Clean();
877 }
878}
879/*****************************************************************************/
880
881void AliLoader::Clean(const TString& name)
882{
d0d4a6b3 883 // Removes object with "name" from the detector's data folder
884 // and from the memory
88cb7938 885 TObject* obj = GetDetectorDataFolder()->FindObject(name);
886 if(obj)
887 {
21bf7095 888 AliDebug(1, Form("name=%s, cleaning %s.",GetName(),name.Data()));
88cb7938 889 GetDetectorDataFolder()->Remove(obj);
890 delete obj;
891 }
892}
893
894/*****************************************************************************/
895
896Bool_t AliLoader::IsOptionWritable(const TString& opt)
897{
d0d4a6b3 898 // Returns "true" if the option means also "writable"
88cb7938 899 if (opt.CompareTo("recreate",TString::kIgnoreCase)) return kTRUE;
900 if (opt.CompareTo("new",TString::kIgnoreCase)) return kTRUE;
901 if (opt.CompareTo("create",TString::kIgnoreCase)) return kTRUE;
902 if (opt.CompareTo("update",TString::kIgnoreCase)) return kTRUE;
903 return kFALSE;
904}
88cb7938 905
21bf7095 906/*****************************************************************************/
907
908void AliLoader::SetDebug(Int_t deb)
909{
910 // Sets debug level
911 AliLog::SetClassDebugLevel("AliRunLoader", deb);
912 AliLog::SetClassDebugLevel("AliLoader", deb);
913 AliLog::SetClassDebugLevel("AliDataLoader", deb);
914 AliLog::SetClassDebugLevel("AliBaseLoader", deb);
915 AliLog::SetClassDebugLevel("AliObjectLoader", deb);
916 AliLog::SetClassDebugLevel("AliTreeLoader", deb);
917 AliLog::SetClassDebugLevel("AliTaskLoader", deb);
918 AliLog::SetClassDebugLevel("AliConfig", deb);
919}
920/*****************************************************************************/
921
88cb7938 922void AliLoader::SetTAddrInDet()
923{
924 //calls SetTreeAddress for corresponding detector
925 AliRunLoader* rl = GetRunLoader();
926 if (rl == 0x0) return;
927 AliRun* ar = rl->GetAliRun();
928 if (ar == 0x0) return;
929 AliDetector* det = ar->GetDetector(fDetectorName);
930 if (det == 0x0) return;
931 det->SetTreeAddress();
932}
933/*****************************************************************************/
f0f6f856 934
935void AliLoader::Synchronize()
936{
937 //synchrinizes all writtable files
938 TIter next(fDataLoaders);
939 AliDataLoader* dl;
940 while ((dl = (AliDataLoader*)next()))
941 {
942 dl->Synchronize();
943 }
944
945}
946/*****************************************************************************/
88cb7938 947/*****************************************************************************/
948/*****************************************************************************/
949