New calibration classes (A.Colla)
[u/mrichter/AliRoot.git] / STEER / AliRunLoader.cxx
CommitLineData
8364b0ef 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
504b172d 18//____________________________________________________________________
19//////////////////////////////////////////////////////////////////////
20// //
21// class AliRunLoader //
22// //
23// This class aims to be the unque interface for managing data I/O. //
24// It stores Loaders for all modules which, knows names //
25// of the files were data are to be stored. //
26// //
27// It aims to substitud AliRun in automatic data managing //
28// thus there is no necessity of loading gAlice from file in order //
29// to get access to the data. //
30// //
31// Logical place to put the specific Loader to the given //
32// detector is detector itself (i.e ITSLoader in ITS). //
33// But, to load detector object one need to load gAlice, and //
34// by the way all other detectors with their geometrieces and //
35// so on. So, if one need to open TPC clusters there is no //
36// principal need to read everything. //
37// //
38// //
39// When RunLoader is read from the file it does not connect to //
40// the folder structure automatically. It must be connected //
41// (mounted) manualy. Default event folder is defined by //
e191bb57 42// AliConfig::GetDefaultEventFolderName() //
504b172d 43// but can be mounted elsewhere. Usefull specially in merging case, //
44// when more than pone session needs to be loaded //
45// //
46//////////////////////////////////////////////////////////////////////
88cb7938 47
134d2ab3 48#include <TROOT.h>
4095d1ca 49#include <TBranch.h>
4095d1ca 50#include <TFile.h>
51#include <TFolder.h>
52#include <TGeometry.h>
53#include <TObjArray.h>
88cb7938 54#include <TString.h>
024a7e64 55class TTask;
88cb7938 56#include <TTree.h>
88cb7938 57
21bf7095 58#include "AliLog.h"
88cb7938 59#include "AliRun.h"
60#include "AliConfig.h"
61#include "AliLoader.h"
62#include "AliHeader.h"
63#include "AliStack.h"
88cb7938 64#include "AliDetector.h"
2c8628dd 65#include "AliRunDataStorage.h"
f05209ee 66#include "AliRunDataOrganizedFile.h"
88cb7938 67
68ClassImp(AliRunLoader)
69
70AliRunLoader* AliRunLoader::fgRunLoader = 0x0;
71
72const TString AliRunLoader::fgkRunLoaderName("RunLoader");
73
74const TString AliRunLoader::fgkHeaderBranchName("Header");
75const TString AliRunLoader::fgkHeaderContainerName("TE");
76const TString AliRunLoader::fgkKineContainerName("TreeK");
77const TString AliRunLoader::fgkTrackRefsContainerName("TreeTR");
78const TString AliRunLoader::fgkKineBranchName("Particles");
79const TString AliRunLoader::fgkDefaultKineFileName("Kinematics.root");
80const TString AliRunLoader::fgkDefaultTrackRefsFileName("TrackRefs.root");
81const TString AliRunLoader::fgkGAliceName("gAlice");
82/**************************************************************************/
83
84AliRunLoader::AliRunLoader():
85 fLoaders(0x0),
86 fEventFolder(0x0),
87 fCurrentEvent(0),
88 fGAFile(0x0),
89 fHeader(0x0),
90 fStack(0x0),
91 fKineDataLoader(0x0),
92 fTrackRefsDataLoader(0x0),
93 fNEventsPerFile(1),
94 fUnixDirName(".")
95{
96 AliConfig::Instance();//force to build the folder structure
85a5290f 97 if (!fgRunLoader) fgRunLoader = this;
88cb7938 98}
99/**************************************************************************/
100
101AliRunLoader::AliRunLoader(const char* eventfoldername):
102 TNamed(fgkRunLoaderName,fgkRunLoaderName),
103 fLoaders(new TObjArray()),
104 fEventFolder(0x0),
105 fCurrentEvent(0),
106 fGAFile(0x0),
107 fHeader(0x0),
108 fStack(0x0),
109 fKineDataLoader(new AliDataLoader(fgkDefaultKineFileName,fgkKineContainerName,"Kinematics")),
110 fTrackRefsDataLoader(new AliDataLoader(fgkDefaultTrackRefsFileName,fgkTrackRefsContainerName,"Track References")),
111 fNEventsPerFile(1),
112 fUnixDirName(".")
113{
114//ctor
115 SetEventFolderName(eventfoldername);
85a5290f 116 if (!fgRunLoader) fgRunLoader = this;
88cb7938 117}
118/**************************************************************************/
119
024a7e64 120AliRunLoader::AliRunLoader(const AliRunLoader &rl):
121 TNamed(rl),
122 fLoaders(0x0),
123 fEventFolder(0x0),
124 fCurrentEvent(0),
125 fGAFile(0x0),
126 fHeader(0x0),
127 fStack(0x0),
128 fKineDataLoader(0x0),
129 fTrackRefsDataLoader(0x0),
130 fNEventsPerFile(0),
131 fUnixDirName(".")
132{
133 //
134 // Copy ctor
135 //
136 rl.Copy(*this);
137}
138/**************************************************************************/
139
88cb7938 140AliRunLoader::~AliRunLoader()
141{
f2a509af 142//dtor
1bb20a37 143 if (fgRunLoader == this) fgRunLoader = 0x0;
144
88cb7938 145 UnloadHeader();
146 UnloadgAlice();
147
148 if(fLoaders) {
149 fLoaders->SetOwner();
150 delete fLoaders;
151 }
152
153 delete fKineDataLoader;
154 delete fTrackRefsDataLoader;
155
156
157 RemoveEventFolder();
158
159 //fEventFolder is deleted by the way of removing - TopAliceFolder owns it
160 delete fHeader;
161 delete fStack;
162 delete fGAFile;
163}
164/**************************************************************************/
165
85a5290f 166AliRunLoader::AliRunLoader(TFolder* topfolder):
167 TNamed(fgkRunLoaderName,fgkRunLoaderName),
168 fLoaders(new TObjArray()),
169 fEventFolder(topfolder),
170 fCurrentEvent(0),
171 fGAFile(0x0),
172 fHeader(0x0),
173 fStack(0x0),
174 fKineDataLoader(new AliDataLoader(fgkDefaultKineFileName,fgkKineContainerName,"Kinematics")),
175 fTrackRefsDataLoader(new AliDataLoader(fgkDefaultTrackRefsFileName,fgkTrackRefsContainerName,"Track References")),
176 fNEventsPerFile(1),
177 fUnixDirName(".")
88cb7938 178{
f2a509af 179//ctor
88cb7938 180 if(topfolder == 0x0)
181 {
131d919a 182 TString errmsg("Parameter is NULL");
21bf7095 183 AliError(errmsg.Data());
131d919a 184 throw errmsg;
88cb7938 185 return;
186 }
88cb7938 187
188 TObject* obj = fEventFolder->FindObject(fgkRunLoaderName);
189 if (obj)
190 { //if it is, then sth. is going wrong... exits aliroot session
131d919a 191 TString errmsg("In Event Folder Named ");
192 errmsg+=fEventFolder->GetName();
193 errmsg+=" object named "+fgkRunLoaderName+" already exists. I am confused ...";
194
21bf7095 195 AliError(errmsg.Data());
131d919a 196 throw errmsg;
88cb7938 197 return;//never reached
198 }
131d919a 199
200 if (!fgRunLoader) fgRunLoader = this;
88cb7938 201
88cb7938 202 fEventFolder->Add(this);//put myself to the folder to accessible for all
203
204}
205/**************************************************************************/
206
024a7e64 207void AliRunLoader::Copy(TObject &) const
208{
21bf7095 209 AliFatal("Not implemented");
024a7e64 210}
211/**************************************************************************/
212
88cb7938 213Int_t AliRunLoader::GetEvent(Int_t evno)
214{
215//Gets event number evno
216//Reloads all data properly
217 if (fCurrentEvent == evno) return 0;
218
219 if (evno < 0)
220 {
21bf7095 221 AliError("Can not give the event with negative number");
88cb7938 222 return 4;
223 }
224
225 if (evno >= GetNumberOfEvents())
226 {
21bf7095 227 AliError(Form("There is no event with number %d",evno));
88cb7938 228 return 3;
229 }
230
21bf7095 231 AliDebug(1, ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
232 AliDebug(1, ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
233 AliDebug(1, ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
234 AliDebug(1, Form(" GETTING EVENT %d",evno));
235 AliDebug(1, ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
236 AliDebug(1, ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
237 AliDebug(1, ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
88cb7938 238
239 fCurrentEvent = evno;
240
241 Int_t retval;
242
243 //Reload header (If header was loaded)
244 if (GetHeader())
245 {
246 retval = TreeE()->GetEvent(fCurrentEvent);
247 if ( retval == 0)
248 {
21bf7095 249 AliError(Form("Cannot find event: %d\n ",fCurrentEvent));
88cb7938 250 return 5;
251 }
252 }
253 //Reload stack (If header was loaded)
254 if (TreeE()) fStack = GetHeader()->Stack();
255 //Set event folder in stack (it does not mean that we read kinematics from file)
256 if (fStack)
257 {
258 fStack->SetEventFolderName(fEventFolder->GetName());
259 }
260 else
261 {
21bf7095 262 AliWarning("Stack not found in header");
88cb7938 263 }
264
265 retval = SetEvent();
266 if (retval)
267 {
21bf7095 268 AliError(Form("Error occured while setting event %d",evno));
88cb7938 269 return 1;
270 }
271
272 //Post Track References
273 retval = fTrackRefsDataLoader->GetEvent();
274 if (retval)
275 {
21bf7095 276 AliError(Form("Error occured while GetEvent for Track References. Event %d",evno));
88cb7938 277 return 2;
278 }
279
280 //Read Kinematics if loaded
281 fKineDataLoader->GetEvent();
282 if (retval)
283 {
21bf7095 284 AliError(Form("Error occured while GetEvent for Kinematics. Event %d",evno));
88cb7938 285 return 2;
286 }
287
288 if (fStack && fKineDataLoader->GetBaseLoader(0)->IsLoaded()) fStack->GetEvent();
289
290 //Trigger data reloading in all loaders
291 TIter next(fLoaders);
292 AliLoader *loader;
293 while((loader = (AliLoader*)next()))
294 {
295 retval = loader->GetEvent();
296 if (retval)
297 {
21bf7095 298 AliError(Form("Error occured while getting event for %s. Event %d.",
299 loader->GetDetectorName().Data(), evno));
88cb7938 300 return 3;
301 }
302 }
303
304 SetDetectorAddresses();
305
306 return 0;
307}
308/**************************************************************************/
309Int_t AliRunLoader::SetEvent()
310{
f2a509af 311//if kinematics was loaded Cleans folder data
312
88cb7938 313 Int_t retval;
314
315 retval = fKineDataLoader->SetEvent();
316 if (retval)
317 {
21bf7095 318 AliError("SetEvent for Kinamtics Data Loader retutned error.");
88cb7938 319 return retval;
320 }
321 retval = fTrackRefsDataLoader->SetEvent();
322 if (retval)
323 {
21bf7095 324 AliError("SetEvent for Track References Data Loader retutned error.");
88cb7938 325 return retval;
326 }
327
328 TIter next(fLoaders);
329 AliLoader *loader;
330 while((loader = (AliLoader*)next()))
331 {
332 retval = loader->SetEvent();
333 if (retval)
334 {
21bf7095 335 AliError(Form("SetEvent for %s Data Loader retutned error.",loader->GetName()));
88cb7938 336 return retval;
337 }
338 }
339
340 return 0;
341}
342/**************************************************************************/
343
344Int_t AliRunLoader::SetEventNumber(Int_t evno)
345{
346 //cleans folders and sets the root dirs in files
347 if (fCurrentEvent == evno) return 0;
348 fCurrentEvent = evno;
349 return SetEvent();
350}
351
352/**************************************************************************/
2c8628dd 353const TObject* AliRunLoader::GetRunObject(const char* name) const
354{
355//Get an object from the run data storage
356
357 if (!AliRunDataStorage::Instance()) {
f05209ee 358 AliWarning("No run data storage defined. Using AliRunDataOrganizedFile.");
359 new AliRunDataOrganizedFile;
2c8628dd 360 }
f05209ee 361 return AliRunDataStorage::Instance()->Get(name, GetHeader()->GetRun());
2c8628dd 362}
363
364/**************************************************************************/
88cb7938 365AliRunLoader* AliRunLoader::Open
366 (const char* filename, const char* eventfoldername, Option_t* option)
367{
368//Opens a desired file 'filename'
369//gets the the run-Loader and mounts it desired folder
370//returns the pointer to run Loader which can be further used for accessing data
371//in case of error returns NULL
372
024a7e64 373 static const TString kwebaddress("http://alisoft.cern.ch/people/skowron/codedoc/split/index.html");
21bf7095 374 AliDebugClass(1,Form("\n\n\nNew I/O strcture: See more info:\n %s\n\n\n",kwebaddress.Data()));
88cb7938 375
376 AliRunLoader* result = 0x0;
377
378 /* ************************************************ */
379 /* Chceck if folder with given name already exists */
380 /* ************************************************ */
381
382 TObject* obj = AliConfig::Instance()->GetTopFolder()->FindObject(eventfoldername);
383 if(obj)
384 {
385 TFolder* fold = dynamic_cast<TFolder*>(obj);
386 if (fold == 0x0)
387 {
21bf7095 388 AliErrorClass("Such a obejct already exists in top alice folder and it is not a folder.");
88cb7938 389 return 0x0;
390 }
391
392 //check if we can get RL from that folder
393 result = AliRunLoader::GetRunLoader(eventfoldername);
394 if (result == 0x0)
395 {
21bf7095 396 AliErrorClass(Form("Folder %s already exists, and can not find session there. Can not mount.",eventfoldername));
88cb7938 397 return 0x0;
398 }
399
400 if (result->GetFileName().CompareTo(filename) != 0)
401 {
21bf7095 402 AliErrorClass("Other file is mounted in demanded folder. Can not mount.");
88cb7938 403 return 0x0;
404 }
405
406 //check if now is demanded (re)creation
407 if ( AliLoader::TestFileOption(option) == kFALSE)
408 {
21bf7095 409 AliErrorClass(Form("Session already exists in folder %s and this session option is %s. Unable to proceed.",
410 eventfoldername,option));
88cb7938 411 return 0x0;
412 }
413
414 //check if demanded option is update and existing one
415 TString tmpstr(option);
416 if ( (tmpstr.CompareTo("update",TString::kIgnoreCase) == 0) &&
417 (result->fGAFile->IsWritable() == kFALSE) )
418 {
21bf7095 419 AliErrorClass(Form("Session already exists in folder %s and is not writable while this session option is %s. Unable to proceed.",
420 eventfoldername,option));
88cb7938 421 return 0x0;
422 }
423
21bf7095 424 AliWarningClass("Session is already opened and mounted in demanded folder");
88cb7938 425 return result;
426 } //end of checking in case of existance of object named identically that folder session is being opened
427
428
429 TFile * gAliceFile = TFile::Open(filename,option);//open a file
430 if (!gAliceFile)
431 {//null pointer returned
21bf7095 432 AliFatalClass(Form("Can not open file %s.",filename));
88cb7938 433 return 0x0;
434 }
435
436 if (gAliceFile->IsOpen() == kFALSE)
437 {//pointer to valid object returned but file is not opened
21bf7095 438 AliErrorClass(Form("Can not open file %s.",filename));
88cb7938 439 return 0x0;
440 }
441
442 //if file is "read" or "update" than we try to find AliRunLoader there - if not found cry and exit
443 //else create new AliRunLoader
444 if ( AliLoader::TestFileOption(option) )
445 {
21bf7095 446 AliDebugClass(1, "Reading RL from file");
88cb7938 447
448 result = dynamic_cast<AliRunLoader*>(gAliceFile->Get(fgkRunLoaderName));//get the run Loader from the file
449 if (result == 0x0)
450 {//didn't get
21bf7095 451 AliErrorClass(Form("Can not find run-Loader in file %s.",filename));
88cb7938 452 delete gAliceFile;//close the file
453 return 0x0;
454 }
455 Int_t tmp = result->SetEventFolderName(eventfoldername);//mount a event folder
456 if (tmp)//if SetEvent returned error
457 {
21bf7095 458 AliErrorClass(Form("Can not mount event in folder %s.",eventfoldername));
88cb7938 459 delete result; //delete run-Loader
460 delete gAliceFile;//close the file
461 return 0x0;
462 }
463 }
464 else
465 {
21bf7095 466 AliDebugClass(1, Form("Creating new AliRunLoader. Folder name is %s",eventfoldername));
131d919a 467 try
468 {
469 result = new AliRunLoader(eventfoldername);
470 }
471 catch (TString& errmsg)
472 {
21bf7095 473 AliErrorClass(Form("AliRunLoader constrcutor has thrown exception: %s\n",errmsg.Data()));
131d919a 474 delete result;
475 delete gAliceFile;//close the file
476 return 0x0;
477 }
88cb7938 478 }
479
480//procedure for extracting dir name from the file name
481 TString fname(filename);
482 Int_t nsl = fname.Last('/');//look for slash in file name
483 TString dirname;
484 if (nsl < 0)
485 {//slash not found
486 Int_t nsl = fname.Last(':');//look for colon e.g. rfio:galice.root
487 if (nsl < 0) dirname = ".";//not found
488 else dirname = fname.Remove(nsl);//found
489 }
490 else dirname = fname.Remove(nsl);//slash found
491
21bf7095 492 AliDebugClass(1, Form("Dir name is : %s",dirname.Data()));
88cb7938 493
494 result->SetDirName(dirname);
495 result->SetGAliceFile(gAliceFile);//set the pointer to gAliceFile
85a5290f 496 if (!fgRunLoader) fgRunLoader = result; //PH get access from any place
88cb7938 497 return result;
498}
499/**************************************************************************/
500Int_t AliRunLoader::GetNumberOfEvents()
501{
502 //returns number of events in Run
503 Int_t retval;
504 if( TreeE() == 0x0 )
505 {
506 retval = LoadHeader();
507 if (retval)
508 {
21bf7095 509 AliError("Error occured while loading header");
88cb7938 510 return -1;
511 }
512 }
513 return (Int_t)TreeE()->GetEntries();
514}
88cb7938 515/**************************************************************************/
f2a509af 516
88cb7938 517void AliRunLoader::MakeHeader()
518{
519 //Makes header and connects it to header tree (if it exists)
21bf7095 520 AliDebug(1, "");
88cb7938 521 if(fHeader == 0x0)
522 {
21bf7095 523 AliDebug(1, "Creating new Header Object");
88cb7938 524 fHeader= new AliHeader();
525 }
526 TTree* tree = TreeE();
527 if (tree)
528 {
21bf7095 529 AliDebug(1, "Got Tree from folder.");
88cb7938 530 TBranch* branch = tree->GetBranch(fgkHeaderBranchName);
531 if (branch == 0x0)
532 {
21bf7095 533 AliDebug(1, "Creating new branch");
88cb7938 534 branch = tree->Branch(fgkHeaderBranchName, "AliHeader", &fHeader, 4000, 0);
535 branch->SetAutoDelete(kFALSE);
536 }
537 else
538 {
21bf7095 539 AliDebug(1, "Got Branch from Tree");
88cb7938 540 branch->SetAddress(&fHeader);
541 tree->GetEvent(fCurrentEvent);
542 fStack = fHeader->Stack(); //should be safe - if we created Stack, header returns pointer to the same object
543 if (fStack)
544 {
545 fStack->SetEventFolderName(fEventFolder->GetName());
546 if (TreeK()) fStack->GetEvent();
547 }
548 else
549 {
21bf7095 550 AliDebug(1, "Header does not have a stack.");
88cb7938 551 }
552 }
553 }
21bf7095 554 AliDebug(1, "Exiting MakeHeader method");
88cb7938 555}
556/**************************************************************************/
557
558void AliRunLoader::MakeStack()
559{
560//Creates the stack object - do not connect the tree
561 if(fStack == 0x0)
562 {
563 fStack = new AliStack(10000);
564 fStack->SetEventFolderName(fEventFolder->GetName());
565 }
566}
567
568/**************************************************************************/
569
570void AliRunLoader::MakeTree(Option_t *option)
571{
572//Creates trees
573 const char *oK = strstr(option,"K"); //Kine
574 const char *oE = strstr(option,"E"); //Header
575
576 if(oK && !TreeK())
577 {
578 if (fKineDataLoader->GetBaseLoader(0)->IsLoaded() == kFALSE)
579 {
21bf7095 580 AliError("Load Kinematics first");
88cb7938 581 }
582 else
583 {
584 fKineDataLoader->MakeTree();
585 MakeStack();
586 fStack->ConnectTree();
587 WriteKinematics("OVERWRITE");
588 }
589 }
590
591 if(oE && !TreeE())
592 {
593 fGAFile->cd();
594 TTree* tree = new TTree(fgkHeaderContainerName,"Tree with Headers");
595 GetEventFolder()->Add(tree);
596 MakeHeader();
597 WriteHeader("OVERWRITE");
598 }
599
600 TIter next(fLoaders);
601 AliLoader *loader;
602 while((loader = (AliLoader*)next()))
603 {
604 loader->MakeTree(option);
605 }
606
607}
608/**************************************************************************/
609
610Int_t AliRunLoader::LoadgAlice()
611{
612//Loads gAlice from file
613 if (GetAliRun())
614 {
21bf7095 615 AliWarning("AliRun is already in folder. Unload first.");
88cb7938 616 return 0;
617 }
618 AliRun* alirun = dynamic_cast<AliRun*>(fGAFile->Get(fgkGAliceName));
619 if (alirun == 0x0)
620 {
21bf7095 621 AliError(Form("Can not find gAlice in file %s",fGAFile->GetName()));
88cb7938 622 return 2;
623 }
624 alirun->SetRunLoader(this);
625 if (gAlice)
626 {
21bf7095 627 AliWarning(Form("gAlice already exists. Putting retrived object in folder named %s",
628 GetEventFolder()->GetName()));
88cb7938 629 }
630 else
631 {
632 gAlice = alirun;
633 }
634 SetDetectorAddresses();//calls SetTreeAddress for all detectors
635 return 0;
636}
637/**************************************************************************/
638
639Int_t AliRunLoader::LoadHeader()
640{
f2a509af 641//loads treeE and reads header object for current event
88cb7938 642 if (TreeE())
643 {
21bf7095 644 AliWarning("Header is already loaded. Use ReloadHeader to force reload. Nothing done");
88cb7938 645 return 0;
646 }
647
648 if (GetEventFolder() == 0x0)
649 {
21bf7095 650 AliError("Event folder not specified yet");
88cb7938 651 return 1;
652 }
653
654 if (fGAFile == 0x0)
655 {
21bf7095 656 AliError("Session not opened. Use AliRunLoader::Open");
88cb7938 657 return 2;
658 }
659
660 if (fGAFile->IsOpen() == kFALSE)
661 {
21bf7095 662 AliError("Session not opened. Use AliRunLoader::Open");
88cb7938 663 return 2;
664 }
665
666 TTree* tree = dynamic_cast<TTree*>(fGAFile->Get(fgkHeaderContainerName));
667 if (tree == 0x0)
668 {
21bf7095 669 AliError(Form("Can not find header tree named %s in file %s",
670 fgkHeaderContainerName.Data(),fGAFile->GetName()));
88cb7938 671 return 2;
672 }
673
674 if (tree == TreeE()) return 0;
675
676 CleanHeader();
677 GetEventFolder()->Add(tree);
678 MakeHeader();//creates header object and connects to tree
679 return 0;
680
681}
682/**************************************************************************/
683
684Int_t AliRunLoader::LoadKinematics(Option_t* option)
685{
686//Loads the kinematics
687 Int_t retval = fKineDataLoader->GetBaseLoader(0)->Load(option);
688 if (retval)
689 {
21bf7095 690 AliError("Error occured while loading kinamatics tree.");
88cb7938 691 return retval;
692 }
443b7449 693 if (fStack)
694 {
695 retval = fStack->GetEvent();
696 if ( retval == kFALSE)
697 {
21bf7095 698 AliError("Error occured while loading kinamatics tree.");
443b7449 699 return retval;
700 }
701
702 }
88cb7938 703 return 0;
704}
705/**************************************************************************/
706
707Int_t AliRunLoader::OpenDataFile(const TString& filename,TFile*& file,TDirectory*& dir,Option_t* opt,Int_t cl)
708{
709//Opens File with kinematics
710 if (file)
711 {
712 if (file->IsOpen() == kFALSE)
713 {//pointer is not null but file is not opened
21bf7095 714 AliWarning("Pointer to file is not null, but file is not opened");//risky any way
88cb7938 715 delete file;
716 file = 0x0; //proceed with opening procedure
717 }
718 else
719 {
21bf7095 720 AliWarning(Form("File %s already opened",filename.Data()));
88cb7938 721 return 0;
722 }
723 }
724//try to find if that file is opened somewere else
725 file = (TFile *)( gROOT->GetListOfFiles()->FindObject(filename) );
726 if (file)
727 {
728 if(file->IsOpen() == kTRUE)
729 {
21bf7095 730 AliWarning(Form("File %s already opened by sombody else.",file->GetName()));
88cb7938 731 return 0;
732 }
733 }
734
735 file = TFile::Open(filename,opt);
736 if (file == 0x0)
737 {//file is null
21bf7095 738 AliError(Form("Can not open file %s",filename.Data()));
88cb7938 739 return 1;
740 }
741 if (file->IsOpen() == kFALSE)
742 {//file is not opened
21bf7095 743 AliError(Form("Can not open file %s",filename.Data()));
88cb7938 744 return 1;
745 }
746
747 file->SetCompressionLevel(cl);
748
749 dir = AliLoader::ChangeDir(file,fCurrentEvent);
750 if (dir == 0x0)
751 {
21bf7095 752 AliError(Form("Can not change to root directory in file %s",filename.Data()));
88cb7938 753 return 3;
754 }
755 return 0;
756}
757/**************************************************************************/
758
759TTree* AliRunLoader::TreeE() const
760{
761 //returns the tree from folder; shortcut method
21bf7095 762 if (AliDebugLevel() > 10) fEventFolder->ls();
88cb7938 763 TObject *obj = fEventFolder->FindObject(fgkHeaderContainerName);
764 return (obj)?dynamic_cast<TTree*>(obj):0x0;
765}
766/**************************************************************************/
767
768AliHeader* AliRunLoader::GetHeader() const
769{
f2a509af 770//returns pointer header object
88cb7938 771 return fHeader;
772}
773/**************************************************************************/
774
775TTree* AliRunLoader::TreeK() const
776{
777 //returns the tree from folder; shortcut method
778 TObject *obj = GetEventFolder()->FindObject(fgkKineContainerName);
779 return (obj)?dynamic_cast<TTree*>(obj):0x0;
780}
781/**************************************************************************/
782
783TTree* AliRunLoader::TreeTR() const
784{
785 //returns the tree from folder; shortcut method
786 TObject* obj = GetEventFolder()->FindObject(fgkTrackRefsContainerName);
787 return (obj)?dynamic_cast<TTree*>(obj):0x0;
788}
789/**************************************************************************/
790
791AliRun* AliRunLoader::GetAliRun() const
792{
793//returns AliRun which sits in the folder
794 if (fEventFolder == 0x0) return 0x0;
795 TObject *obj = fEventFolder->FindObject(fgkGAliceName);
796 return (obj)?dynamic_cast<AliRun*>(obj):0x0;
797}
798/**************************************************************************/
799
d1898505 800Int_t AliRunLoader::WriteGeometry(Option_t* /*opt*/)
88cb7938 801{
f2a509af 802//writes geometry to the file
88cb7938 803 fGAFile->cd();
804 TGeometry* geo = GetAliRun()->GetGeometry();
805 if (geo == 0x0)
806 {
21bf7095 807 AliError("Can not get geometry from gAlice");
88cb7938 808 return 1;
809 }
810 geo->Write();
811 return 0;
812}
813/**************************************************************************/
814
815Int_t AliRunLoader::WriteHeader(Option_t* opt)
816{
f2a509af 817//writes treeE
21bf7095 818 AliDebug(1, "WRITING HEADER");
88cb7938 819
820 TTree* tree = TreeE();
821 if ( tree == 0x0)
822 {
21bf7095 823 AliWarning("Can not find Header Tree in Folder");
88cb7938 824 return 0;
825 }
826 if (fGAFile->IsWritable() == kFALSE)
827 {
21bf7095 828 AliError(Form("File %s is not writable",fGAFile->GetName()));
88cb7938 829 return 1;
830 }
831
832 TObject* obj = fGAFile->Get(fgkHeaderContainerName);
833 if (obj)
834 { //if they exist, see if option OVERWRITE is used
835 TString tmp(opt);
836 if(tmp.Contains("OVERWRITE",TString::kIgnoreCase) == 0)
837 {//if it is not used - give an error message and return an error code
21bf7095 838 AliError("Tree already exisists. Use option \"OVERWRITE\" to overwrite previous data");
88cb7938 839 return 3;
840 }
841 }
842 fGAFile->cd();
843 tree->SetDirectory(fGAFile);
844 tree->Write(0,TObject::kOverwrite);
845
21bf7095 846 AliDebug(1, "WRITTEN\n\n");
88cb7938 847
848 return 0;
849}
850/**************************************************************************/
851
d1898505 852Int_t AliRunLoader::WriteAliRun(Option_t* /*opt*/)
88cb7938 853{
f2a509af 854//writes AliRun object to the file
88cb7938 855 fGAFile->cd();
f2a509af 856 if (GetAliRun()) GetAliRun()->Write();
88cb7938 857 return 0;
858}
859/**************************************************************************/
860
861Int_t AliRunLoader::WriteKinematics(Option_t* opt)
862{
f2a509af 863//writes Kinematics
88cb7938 864 return fKineDataLoader->GetBaseLoader(0)->WriteData(opt);
865}
866/**************************************************************************/
867Int_t AliRunLoader::WriteTrackRefs(Option_t* opt)
868{
f2a509af 869//writes Track References tree
88cb7938 870 return fTrackRefsDataLoader->GetBaseLoader(0)->WriteData(opt);
871}
872/**************************************************************************/
873
874Int_t AliRunLoader::WriteHits(Option_t* opt)
875{
876//Calls WriteHits for all loaders
877 Int_t res;
878 Int_t result = 0;
879 TIter next(fLoaders);
880 AliLoader *loader;
881 while((loader = (AliLoader*)next()))
882 {
883 res = loader->WriteHits(opt);
884 if (res)
885 {
21bf7095 886 AliError(Form("Failed to write hits for %s (%d)",loader->GetDetectorName().Data(),res));
88cb7938 887 result = 1;
888 }
889 }
890 return result;
891}
892/**************************************************************************/
893
894Int_t AliRunLoader::WriteSDigits(Option_t* opt)
895{
f2a509af 896//Calls WriteSDigits for all loaders
88cb7938 897 Int_t res;
898 Int_t result = 0;
899 TIter next(fLoaders);
900 AliLoader *loader;
901 while((loader = (AliLoader*)next()))
902 {
903 res = loader->WriteSDigits(opt);
904 if (res)
905 {
21bf7095 906 AliError(Form("Failed to write summable digits for %s.",loader->GetDetectorName().Data()));
88cb7938 907 result = 1;
908 }
909 }
910 return result;
911}
912/**************************************************************************/
913
914Int_t AliRunLoader::WriteDigits(Option_t* opt)
915{
f2a509af 916//Calls WriteDigits for all loaders
88cb7938 917 Int_t res;
918 Int_t result = 0;
919 TIter next(fLoaders);
920 AliLoader *loader;
921 while((loader = (AliLoader*)next()))
922 {
923 res = loader->WriteDigits(opt);
924 if (res)
925 {
21bf7095 926 AliError(Form("Failed to write digits for %s.",loader->GetDetectorName().Data()));
88cb7938 927 result = 1;
928 }
929 }
930 return result;
931}
932/**************************************************************************/
933
934Int_t AliRunLoader::WriteRecPoints(Option_t* opt)
935{
f2a509af 936//Calls WriteRecPoints for all loaders
88cb7938 937 Int_t res;
938 Int_t result = 0;
939 TIter next(fLoaders);
940 AliLoader *loader;
941 while((loader = (AliLoader*)next()))
942 {
943 res = loader->WriteRecPoints(opt);
944 if (res)
945 {
21bf7095 946 AliError(Form("Failed to write Reconstructed Points for %s.",
947 loader->GetDetectorName().Data()));
88cb7938 948 result = 1;
949 }
950 }
951 return result;
952}
953/**************************************************************************/
954
955Int_t AliRunLoader::WriteTracks(Option_t* opt)
956{
f2a509af 957//Calls WriteTracks for all loaders
88cb7938 958 Int_t res;
959 Int_t result = 0;
960 TIter next(fLoaders);
961 AliLoader *loader;
962 while((loader = (AliLoader*)next()))
963 {
964 res = loader->WriteTracks(opt);
965 if (res)
966 {
21bf7095 967 AliError(Form("Failed to write Tracks for %s.",
968 loader->GetDetectorName().Data()));
88cb7938 969 result = 1;
970 }
971 }
972 return result;
973}
974/**************************************************************************/
975
d1898505 976Int_t AliRunLoader::WriteRunLoader(Option_t* /*opt*/)
88cb7938 977{
f2a509af 978//Writes itself to the file
88cb7938 979 CdGAFile();
980 this->Write(0,TObject::kOverwrite);
981 return 0;
982}
983/**************************************************************************/
984
985Int_t AliRunLoader::SetEventFolderName(const TString& name)
f2a509af 986{
987//sets top folder name for this run; of alread
88cb7938 988 if (name.IsNull())
989 {
21bf7095 990 AliError("Name is empty");
88cb7938 991 return 1;
992 }
993
994 //check if such a folder already exists - try to find it in alice top folder
995 TObject* obj = AliConfig::Instance()->GetTopFolder()->FindObject(name);
996 if(obj)
997 {
998 TFolder* fold = dynamic_cast<TFolder*>(obj);
999 if (fold == 0x0)
1000 {
21bf7095 1001 AliError("Such a obejct already exists in top alice folder and it is not a folder.");
88cb7938 1002 return 2;
1003 }
1004 //folder which was found is our folder
1005 if (fEventFolder == fold)
1006 {
1007 return 0;
1008 }
1009 else
1010 {
21bf7095 1011 AliError("Such a folder already exists in top alice folder. Can not mount.");
88cb7938 1012 return 2;
1013 }
1014 }
1015
1016 //event is alredy connected, just change name of the folder
1017 if (fEventFolder)
1018 {
1019 fEventFolder->SetName(name);
1020 return 0;
1021 }
1022
1023 if (fKineDataLoader == 0x0)
1024 fKineDataLoader = new AliDataLoader(fgkDefaultKineFileName,fgkKineContainerName,"Kinematics");
1025
1026 if ( fTrackRefsDataLoader == 0x0)
1027 fTrackRefsDataLoader = new AliDataLoader(fgkDefaultTrackRefsFileName,fgkTrackRefsContainerName,"Track References");
1028
1029 //build the event folder structure
21bf7095 1030 AliDebug(1, Form("Creating new event folder named %s",name.Data()));
88cb7938 1031 fEventFolder = AliConfig::Instance()->BuildEventFolder(name,"Event Folder");
1032 fEventFolder->Add(this);//put myself to the folder to accessible for all
1033
1034 if (Stack()) Stack()->SetEventFolderName(fEventFolder->GetName());
1035 TIter next(fLoaders);
1036 AliLoader *loader;
1037 while((loader = (AliLoader*)next()))
1038 {
1039 loader->Register(fEventFolder);//build folder structure for this detector
1040 }
1041
1042 fKineDataLoader->SetEventFolder(GetEventFolder());
1043 fTrackRefsDataLoader->SetEventFolder(GetEventFolder());
1044 fKineDataLoader->SetFolder(GetEventFolder());
1045 fTrackRefsDataLoader->SetFolder(GetEventFolder());
1046
1047 fEventFolder->SetOwner();
1048 return 0;
1049}
1050/**************************************************************************/
1051
1052void AliRunLoader::AddLoader(AliLoader* loader)
1053 {
1054 //Adds the Loader for given detector
1055 if (loader == 0x0) //if null shout and exit
1056 {
21bf7095 1057 AliError("Parameter is NULL");
88cb7938 1058 return;
1059 }
1060 loader->SetDirName(fUnixDirName);
1061 if (fEventFolder) loader->SetEventFolder(fEventFolder); //if event folder is already defined,
1062 //pass information to the Loader
1063 fLoaders->Add(loader);//add the Loader to the array
1064 }
1065/**************************************************************************/
1066
1067void AliRunLoader::AddLoader(AliDetector* det)
1068 {
1069//Asks module (detector) ro make a Loader and stores in the array
1070 if (det == 0x0) return;
1071 AliLoader* get = det->GetLoader();//try to get loader
1072 if (get == 0x0) get = det->MakeLoader(fEventFolder->GetName());//if did not obtain, ask to make it
1073
1074 if (get)
1075 {
21bf7095 1076 AliDebug(1, Form("Detector: %s Loader : %s",det->GetName(),get->GetName()));
88cb7938 1077 AddLoader(get);
1078 }
1079 }
1080
1081/**************************************************************************/
1082
1083AliLoader* AliRunLoader::GetLoader(const char* detname) const
1084{
f2a509af 1085//returns loader for given detector
1086//note that naming convention is TPCLoader not just TPC
88cb7938 1087 return (AliLoader*)fLoaders->FindObject(detname);
1088}
1089
1090/**************************************************************************/
1091
1092AliLoader* AliRunLoader::GetLoader(AliDetector* det) const
1093{
f2a509af 1094//get loader for detector det
88cb7938 1095 if(det == 0x0) return 0x0;
1096 TString getname(det->GetName());
1097 getname+="Loader";
21bf7095 1098 AliDebug(1, Form(" Loader name is %s",getname.Data()));
88cb7938 1099 return GetLoader(getname);
1100}
1101
1102/**************************************************************************/
1103
1104void AliRunLoader::CleanFolders()
1105{
1106// fEventFolder->Add(this);//put myself to the folder to accessible for all
1107
1108 CleanDetectors();
1109 CleanHeader();
1110 CleanKinematics();
1111}
1112/**************************************************************************/
1113
1114void AliRunLoader::CleanDetectors()
1115{
1116//Calls CleanFolders for all detectors
1117 TIter next(fLoaders);
d0d4a6b3 1118 AliLoader *loader;
1119 while((loader = (AliLoader*)next()))
88cb7938 1120 {
d0d4a6b3 1121 loader->CleanFolders();
88cb7938 1122 }
1123}
1124/**************************************************************************/
1125
1126void AliRunLoader::RemoveEventFolder()
1127{
1128//remove all the tree of event
1129//all the stuff changing EbE stays untached (PDGDB, tasks, etc.)
1130
1131 if (fEventFolder == 0x0) return;
1132 fEventFolder->SetOwner(kFALSE);//don't we want to deleted while removing the folder that we are sitting in
1133 fEventFolder->Remove(this);//remove us drom folder
1134
1135 AliConfig::Instance()->GetTopFolder()->SetOwner(); //brings ownership back for fEventFolder since it sits in top folder
1136 AliConfig::Instance()->GetTopFolder()->Remove(fEventFolder); //remove the event tree
1137 delete fEventFolder;
1138}
1139/**************************************************************************/
1140
1141void AliRunLoader::SetGAliceFile(TFile* gafile)
1142{
f2a509af 1143//sets pointer to galice.root file
88cb7938 1144 fGAFile = gafile;
1145}
1146
1147/**************************************************************************/
1148
1149Int_t AliRunLoader::LoadHits(Option_t* detectors,Option_t* opt)
1150{
1151//LoadHits in selected detectors i.e. detectors="ITS TPC TRD" or "all"
1152
21bf7095 1153 AliDebug(1, "Loading Hits");
88cb7938 1154 TObjArray* loaders;
1155 TObjArray arr;
1156
1157 const char* oAll = strstr(detectors,"all");
1158 if (oAll)
1159 {
21bf7095 1160 AliDebug(1, "Option is All");
88cb7938 1161 loaders = fLoaders;
1162 }
1163 else
1164 {
1165 GetListOfDetectors(detectors,arr);//this method looks for all Loaders corresponding to names (many) specified in detectors option
1166 loaders = &arr;//get the pointer array
1167 }
1168
21bf7095 1169 AliDebug(1, Form("For detectors. Number of detectors chosen for loading %d",loaders->GetEntries()));
88cb7938 1170
1171 TIter next(loaders);
1172 AliLoader *loader;
1173 while((loader = (AliLoader*)next()))
1174 {
21bf7095 1175 AliDebug(1, Form(" Calling LoadHits(%s) for %s",opt,loader->GetName()));
88cb7938 1176 loader->LoadHits(opt);
1177 }
21bf7095 1178 AliDebug(1, "Done");
88cb7938 1179 return 0;
1180}
1181
1182/**************************************************************************/
1183
1184Int_t AliRunLoader::LoadSDigits(Option_t* detectors,Option_t* opt)
1185{
1186//LoadHits in selected detectors i.e. detectors="ITS TPC TRD" or "all"
1187
1188 TObjArray* loaders;
1189 TObjArray arr;
1190
1191 const char* oAll = strstr(detectors,"all");
1192 if (oAll)
1193 {
1194 loaders = fLoaders;
1195 }
1196 else
1197 {
1198 GetListOfDetectors(detectors,arr);//this method looks for all Loaders corresponding to names (many) specified in detectors option
1bb20a37 1199 loaders = &arr;//get the pointer to array
88cb7938 1200 }
1201
1202 TIter next(loaders);
1203 AliLoader *loader;
1204 while((loader = (AliLoader*)next()))
1205 {
1206 loader->LoadSDigits(opt);
1207 }
1208 return 0;
1209}
1210
1211/**************************************************************************/
1212
1213Int_t AliRunLoader::LoadDigits(Option_t* detectors,Option_t* opt)
1214{
1215//LoadHits in selected detectors i.e. detectors="ITS TPC TRD" or "all"
1216
d0d4a6b3 1217 TObjArray* loaders;
88cb7938 1218 TObjArray arr;
1219
1220 const char* oAll = strstr(detectors,"all");
1221 if (oAll)
1222 {
d0d4a6b3 1223 loaders = fLoaders;
88cb7938 1224 }
1225 else
1226 {
1227 GetListOfDetectors(detectors,arr);//this method looks for all Loaders corresponding to names (many) specified in detectors option
d0d4a6b3 1228 loaders = &arr;//get the pointer array
88cb7938 1229 }
1230
d0d4a6b3 1231 TIter next(loaders);
1232 AliLoader *loader;
1233 while((loader = (AliLoader*)next()))
88cb7938 1234 {
d0d4a6b3 1235 loader->LoadDigits(opt);
88cb7938 1236 }
1237 return 0;
1238}
88cb7938 1239/**************************************************************************/
1240
1241Int_t AliRunLoader::LoadRecPoints(Option_t* detectors,Option_t* opt)
1242{
1243//LoadHits in selected detectors i.e. detectors="ITS TPC TRD" or "all"
1244
d0d4a6b3 1245 TObjArray* loaders;
88cb7938 1246 TObjArray arr;
1247
1248 const char* oAll = strstr(detectors,"all");
1249 if (oAll)
1250 {
d0d4a6b3 1251 loaders = fLoaders;
88cb7938 1252 }
1253 else
1254 {
1255 GetListOfDetectors(detectors,arr);//this method looks for all Loaders corresponding to names (many) specified in detectors option
d0d4a6b3 1256 loaders = &arr;//get the pointer array
88cb7938 1257 }
1258
d0d4a6b3 1259 TIter next(loaders);
1260 AliLoader *loader;
1261 while((loader = (AliLoader*)next()))
88cb7938 1262 {
d0d4a6b3 1263 loader->LoadRecPoints(opt);
88cb7938 1264 }
1265 return 0;
1266}
1bb20a37 1267/**************************************************************************/
88cb7938 1268
1bb20a37 1269Int_t AliRunLoader::LoadRecParticles(Option_t* detectors,Option_t* opt)
1270{
1271//LoadHits in selected detectors i.e. detectors="ITS TPC TRD" or "all"
1272
d0d4a6b3 1273 TObjArray* loaders;
1bb20a37 1274 TObjArray arr;
1275
1276 const char* oAll = strstr(detectors,"all");
1277 if (oAll)
1278 {
d0d4a6b3 1279 loaders = fLoaders;
1bb20a37 1280 }
1281 else
1282 {
1283 GetListOfDetectors(detectors,arr);//this method looks for all Loaders corresponding to names (many) specified in detectors option
d0d4a6b3 1284 loaders = &arr;//get the pointer array
1bb20a37 1285 }
1286
d0d4a6b3 1287 TIter next(loaders);
1288 AliLoader *loader;
1289 while((loader = (AliLoader*)next()))
1bb20a37 1290 {
d0d4a6b3 1291 loader->LoadRecParticles(opt);
1bb20a37 1292 }
1293 return 0;
1294}
88cb7938 1295/**************************************************************************/
1296
1297Int_t AliRunLoader::LoadTracks(Option_t* detectors,Option_t* opt)
1298{
1299//LoadHits in selected detectors i.e. detectors="ITS TPC TRD" or "all"
1300
d0d4a6b3 1301 TObjArray* loaders;
88cb7938 1302 TObjArray arr;
1303
1304 const char* oAll = strstr(detectors,"all");
1305 if (oAll)
1306 {
d0d4a6b3 1307 loaders = fLoaders;
88cb7938 1308 }
1309 else
1310 {
1311 GetListOfDetectors(detectors,arr);//this method looks for all Loaders corresponding to names (many) specified in detectors option
d0d4a6b3 1312 loaders = &arr;//get the pointer array
88cb7938 1313 }
1314
d0d4a6b3 1315 TIter next(loaders);
1316 AliLoader *loader;
1317 while((loader = (AliLoader*)next()))
88cb7938 1318 {
d0d4a6b3 1319 loader->LoadTracks(opt);
88cb7938 1320 }
1321 return 0;
1322}
1bb20a37 1323/**************************************************************************/
1324
1325void AliRunLoader::UnloadHits(Option_t* detectors)
1326{
1327 //unloads hits for detectors specified in parameter
1328 TObjArray* loaders;
1329 TObjArray arr;
1330
1331 const char* oAll = strstr(detectors,"all");
1332 if (oAll)
1333 {
1334 loaders = fLoaders;
1335 }
1336 else
1337 {
1338 GetListOfDetectors(detectors,arr);//this method looks for all Loaders corresponding to names (many) specified in detectors option
1339 loaders = &arr;//get the pointer to array
1340 }
1341
1342 TIter next(loaders);
1343 AliLoader *loader;
1344 while((loader = (AliLoader*)next()))
1345 {
1346 loader->UnloadHits();
1347 }
1348}
1349/**************************************************************************/
1350
1351void AliRunLoader::UnloadSDigits(Option_t* detectors)
1352{
1353 //unloads SDigits for detectors specified in parameter
1354 TObjArray* loaders;
1355 TObjArray arr;
1356
1357 const char* oAll = strstr(detectors,"all");
1358 if (oAll)
1359 {
1360 loaders = fLoaders;
1361 }
1362 else
1363 {
1364 GetListOfDetectors(detectors,arr);//this method looks for all Loaders corresponding to names (many) specified in detectors option
1365 loaders = &arr;//get the pointer to array
1366 }
1367
1368 TIter next(loaders);
1369 AliLoader *loader;
1370 while((loader = (AliLoader*)next()))
1371 {
1372 loader->UnloadSDigits();
1373 }
1374}
1375/**************************************************************************/
1376
1377void AliRunLoader::UnloadDigits(Option_t* detectors)
1378{
1379 //unloads Digits for detectors specified in parameter
1380 TObjArray* loaders;
1381 TObjArray arr;
1382
1383 const char* oAll = strstr(detectors,"all");
1384 if (oAll)
1385 {
1386 loaders = fLoaders;
1387 }
1388 else
1389 {
1390 GetListOfDetectors(detectors,arr);//this method looks for all Loaders corresponding to names (many) specified in detectors option
1391 loaders = &arr;//get the pointer to array
1392 }
1393
1394 TIter next(loaders);
1395 AliLoader *loader;
1396 while((loader = (AliLoader*)next()))
1397 {
1398 loader->UnloadDigits();
1399 }
1400}
1401/**************************************************************************/
1402
1403void AliRunLoader::UnloadRecPoints(Option_t* detectors)
1404{
1405 //unloads RecPoints for detectors specified in parameter
1406 TObjArray* loaders;
1407 TObjArray arr;
1408
1409 const char* oAll = strstr(detectors,"all");
1410 if (oAll)
1411 {
1412 loaders = fLoaders;
1413 }
1414 else
1415 {
1416 GetListOfDetectors(detectors,arr);//this method looks for all Loaders corresponding to names (many) specified in detectors option
1417 loaders = &arr;//get the pointer to array
1418 }
1419
1420 TIter next(loaders);
1421 AliLoader *loader;
1422 while((loader = (AliLoader*)next()))
1423 {
1424 loader->UnloadRecPoints();
1425 }
1426}
1427/**************************************************************************/
1428
1429void AliRunLoader::UnloadAll(Option_t* detectors)
1430{
1431 //calls UnloadAll for detectors names specified in parameter
1432 // option "all" passed can be passed
1433 TObjArray* loaders;
1434 TObjArray arr;
1435
1436 const char* oAll = strstr(detectors,"all");
1437 if (oAll)
1438 {
1439 loaders = fLoaders;
1440 }
1441 else
1442 {
1443 GetListOfDetectors(detectors,arr);//this method looks for all Loaders corresponding to names (many) specified in detectors option
1444 loaders = &arr;//get the pointer to array
1445 }
88cb7938 1446
1bb20a37 1447 TIter next(loaders);
1448 AliLoader *loader;
1449 while((loader = (AliLoader*)next()))
1450 {
1451 loader->UnloadAll();
1452 }
1453}
1454/**************************************************************************/
1455
1456void AliRunLoader::UnloadTracks(Option_t* detectors)
1457{
1458 //unloads Tracks for detectors specified in parameter
1459 TObjArray* loaders;
1460 TObjArray arr;
1461
1462 const char* oAll = strstr(detectors,"all");
1463 if (oAll)
1464 {
1465 loaders = fLoaders;
1466 }
1467 else
1468 {
1469 GetListOfDetectors(detectors,arr);//this method looks for all Loaders corresponding to names (many) specified in detectors option
1470 loaders = &arr;//get the pointer to array
1471 }
1472
1473 TIter next(loaders);
1474 AliLoader *loader;
1475 while((loader = (AliLoader*)next()))
1476 {
1477 loader->UnloadTracks();
1478 }
1479}
1480/**************************************************************************/
1481
1482void AliRunLoader::UnloadRecParticles(Option_t* detectors)
1483{
1484 //unloads Particles for detectors specified in parameter
1485 TObjArray* loaders;
1486 TObjArray arr;
1487
1488 const char* oAll = strstr(detectors,"all");
1489 if (oAll)
1490 {
1491 loaders = fLoaders;
1492 }
1493 else
1494 {
1495 GetListOfDetectors(detectors,arr);//this method looks for all Loaders corresponding to names (many) specified in detectors option
1496 loaders = &arr;//get the pointer to array
1497 }
1498
1499 TIter next(loaders);
1500 AliLoader *loader;
1501 while((loader = (AliLoader*)next()))
1502 {
1503 loader->UnloadRecParticles();
1504 }
1505}
88cb7938 1506/**************************************************************************/
1507
1508AliRunLoader* AliRunLoader::GetRunLoader(const char* eventfoldername)
f2a509af 1509{
1510//returns RunLoader from folder named eventfoldername
88cb7938 1511 TFolder* evfold= dynamic_cast<TFolder*>(AliConfig::Instance()->GetTopFolder()->FindObject(eventfoldername));
1512 if (evfold == 0x0)
1513 {
1514 return 0x0;
1515 }
1516 AliRunLoader* runget = dynamic_cast<AliRunLoader*>(evfold->FindObject(AliRunLoader::fgkRunLoaderName));
1517 return runget;
1518
f2a509af 1519}
88cb7938 1520/**************************************************************************/
1521
1bb20a37 1522AliLoader* AliRunLoader::GetDetectorLoader(const char* detname, const char* eventfoldername)
8de97894 1523{
1524//get the loader of the detector with the given name from the global
1525//run loader object
1bb20a37 1526 AliRunLoader* runLoader = GetRunLoader(eventfoldername);
8de97894 1527 if (!runLoader) {
21bf7095 1528 AliErrorClass("No run loader found");
8de97894 1529 return NULL;
1530 }
1bb20a37 1531 return runLoader->GetDetectorLoader(detname);
1532}
1533/**************************************************************************/
1534
1535AliLoader* AliRunLoader::GetDetectorLoader(const char* detname)
1536{
1537//get the loader of the detector with the given name from the global
1538//run loader object
1539
8de97894 1540 char loadername[256];
1541 sprintf(loadername, "%sLoader", detname);
1bb20a37 1542 AliLoader* loader = GetLoader(loadername);
8de97894 1543 if (!loader) {
21bf7095 1544 AliError(Form("No loader for %s found", detname));
8de97894 1545 return NULL;
1546 }
1547 return loader;
1548}
1bb20a37 1549/**************************************************************************/
1550
1551TTree* AliRunLoader::GetTreeH(const char* detname, Bool_t maketree, const char* eventfoldername)
1552{
1553//get the tree with hits of the detector with the given name
1554//if maketree is true and the tree does not exist, the tree is created
1555 AliLoader* loader = GetDetectorLoader(detname,eventfoldername);
1556 if (!loader) return NULL;
1557 if (!loader->TreeH() && maketree) loader->MakeTree("H");
1558 return loader->TreeH();
1559}
8de97894 1560
1561/**************************************************************************/
1562
1563TTree* AliRunLoader::GetTreeH(const char* detname, Bool_t maketree)
1564{
1565//get the tree with hits of the detector with the given name
1566//if maketree is true and the tree does not exist, the tree is created
1567 AliLoader* loader = GetDetectorLoader(detname);
1568 if (!loader) return NULL;
1569 if (!loader->TreeH() && maketree) loader->MakeTree("H");
1570 return loader->TreeH();
1571}
1bb20a37 1572/**************************************************************************/
8de97894 1573
1bb20a37 1574TTree* AliRunLoader::GetTreeS(const char* detname, Bool_t maketree,const char* eventfoldername)
1575{
1576//get the tree with summable digits of the detector with the given name
1577//if maketree is true and the tree does not exist, the tree is created
1578 AliLoader* loader = GetDetectorLoader(detname,eventfoldername);
1579 if (!loader) return NULL;
1580 if (!loader->TreeS() && maketree) loader->MakeTree("S");
1581 return loader->TreeS();
1582}
8de97894 1583/**************************************************************************/
1584
1585TTree* AliRunLoader::GetTreeS(const char* detname, Bool_t maketree)
1586{
1587//get the tree with summable digits of the detector with the given name
1588//if maketree is true and the tree does not exist, the tree is created
1589 AliLoader* loader = GetDetectorLoader(detname);
1590 if (!loader) return NULL;
1591 if (!loader->TreeS() && maketree) loader->MakeTree("S");
1592 return loader->TreeS();
1593}
1bb20a37 1594/**************************************************************************/
8de97894 1595
1bb20a37 1596TTree* AliRunLoader::GetTreeD(const char* detname, Bool_t maketree,const char* eventfoldername)
1597{
1598//get the tree with digits of the detector with the given name
1599//if maketree is true and the tree does not exist, the tree is created
1600 AliLoader* loader = GetDetectorLoader(detname,eventfoldername);
1601 if (!loader) return NULL;
1602 if (!loader->TreeD() && maketree) loader->MakeTree("D");
1603 return loader->TreeD();
1604}
8de97894 1605/**************************************************************************/
1606
1607TTree* AliRunLoader::GetTreeD(const char* detname, Bool_t maketree)
1608{
1609//get the tree with digits of the detector with the given name
1610//if maketree is true and the tree does not exist, the tree is created
1611 AliLoader* loader = GetDetectorLoader(detname);
1612 if (!loader) return NULL;
1613 if (!loader->TreeD() && maketree) loader->MakeTree("D");
1614 return loader->TreeD();
1615}
1bb20a37 1616/**************************************************************************/
1617TTree* AliRunLoader::GetTreeR(const char* detname, Bool_t maketree,const char* eventfoldername)
1618{
1619//get the tree with clusters of the detector with the given name
1620//if maketree is true and the tree does not exist, the tree is created
1621 AliLoader* loader = GetDetectorLoader(detname,eventfoldername);
1622 if (!loader) return NULL;
1623 if (!loader->TreeR() && maketree) loader->MakeTree("R");
1624 return loader->TreeR();
1625}
8de97894 1626/**************************************************************************/
1627
1628TTree* AliRunLoader::GetTreeR(const char* detname, Bool_t maketree)
1629{
1630//get the tree with clusters of the detector with the given name
1631//if maketree is true and the tree does not exist, the tree is created
1632 AliLoader* loader = GetDetectorLoader(detname);
1633 if (!loader) return NULL;
1634 if (!loader->TreeR() && maketree) loader->MakeTree("R");
1635 return loader->TreeR();
1636}
1bb20a37 1637/**************************************************************************/
8de97894 1638
1bb20a37 1639TTree* AliRunLoader::GetTreeT(const char* detname, Bool_t maketree,const char* eventfoldername)
1640{
1641//get the tree with tracks of the detector with the given name
1642//if maketree is true and the tree does not exist, the tree is created
1643 AliLoader* loader = GetDetectorLoader(detname,eventfoldername);
1644 if (!loader) return NULL;
1645 if (!loader->TreeT() && maketree) loader->MakeTree("T");
1646 return loader->TreeT();
1647}
8de97894 1648/**************************************************************************/
1649
1650TTree* AliRunLoader::GetTreeT(const char* detname, Bool_t maketree)
1651{
1652//get the tree with tracks of the detector with the given name
1653//if maketree is true and the tree does not exist, the tree is created
1654 AliLoader* loader = GetDetectorLoader(detname);
1655 if (!loader) return NULL;
1656 if (!loader->TreeT() && maketree) loader->MakeTree("T");
1657 return loader->TreeT();
1658}
1bb20a37 1659/**************************************************************************/
8de97894 1660
1bb20a37 1661TTree* AliRunLoader::GetTreeP(const char* detname, Bool_t maketree,const char* eventfoldername)
1662{
1663//get the tree with particles of the detector with the given name
1664//if maketree is true and the tree does not exist, the tree is created
1665 AliLoader* loader = GetDetectorLoader(detname,eventfoldername);
1666 if (!loader) return NULL;
1667 if (!loader->TreeP() && maketree) loader->MakeTree("P");
1668 return loader->TreeP();
1669}
8de97894 1670/**************************************************************************/
1671
1672TTree* AliRunLoader::GetTreeP(const char* detname, Bool_t maketree)
1673{
1674//get the tree with particles of the detector with the given name
1675//if maketree is true and the tree does not exist, the tree is created
1676 AliLoader* loader = GetDetectorLoader(detname);
1677 if (!loader) return NULL;
1678 if (!loader->TreeP() && maketree) loader->MakeTree("P");
1679 return loader->TreeP();
1680}
1681
1682/**************************************************************************/
1683
88cb7938 1684void AliRunLoader::CdGAFile()
1685{
1686//sets gDirectory to galice file
1687//work around
1688 if(fGAFile) fGAFile->cd();
1689}
1690
1691/**************************************************************************/
1692
1693void AliRunLoader::GetListOfDetectors(const char * namelist,TObjArray& pointerarray) const
1694 {
1695//this method looks for all Loaders corresponding
1696//to names (many) specified in namelist i.e. namelist ("ITS TPC TRD")
1697
1698 char buff[10];
1699 char dets [200];
1700 strcpy(dets,namelist);//compiler cries when char* = const Option_t*;
1701 dets[strlen(dets)+1] = '\n';//set endl at the end of string
1702 char* pdet = dets;
1703 Int_t tmp;
1704 for(;;)
1705 {
1706 tmp = sscanf(pdet,"%s",buff);//read the string from the input string pdet into buff
1707 if ( (buff[0] == 0) || (tmp == 0) ) break; //if not read
1708
f2a509af 1709 pdet = strstr(pdet,buff) + strlen(buff);//move the input pointer about number of bytes (letters) read
88cb7938 1710 //I am aware that is a little complicated. I don't know the number of spaces between detector names
1711 //so I read the string, than I find where it starts (strstr) and move the pointer about length of a string
1712 //If there is a better way, please write me (Piotr.Skowronski@cern.ch)
1713 //construct the Loader name
1714 TString getname(buff);
1715 getname+="Loader";
1716 AliLoader* loader = GetLoader(getname);//get the Loader
1717 if (loader)
1718 {
1719 pointerarray.Add(loader);
1720 }
1721 else
1722 {
21bf7095 1723 AliError(Form("Can not find Loader for %s",buff));
88cb7938 1724 }
1725
1726 buff[0] = 0;
1727 }
1728 }
1729/*****************************************************************************/
1730
1731void AliRunLoader::Clean(const TString& name)
1732{
1733//removes object with given name from event folder and deletes it
1734 if (GetEventFolder() == 0x0) return;
1735 TObject* obj = GetEventFolder()->FindObject(name);
1736 if(obj)
1737 {
21bf7095 1738 AliDebug(1, Form("name=%s, cleaning %s.",GetName(),name.Data()));
88cb7938 1739 GetEventFolder()->Remove(obj);
1740 delete obj;
1741 }
1742}
1743
1744/*****************************************************************************/
1745
1746TTask* AliRunLoader::GetRunDigitizer()
1747{
1748//returns Run Digitizer from folder
1749
1750 TFolder* topf = AliConfig::Instance()->GetTaskFolder();
1751 TObject* obj = topf->FindObjectAny(AliConfig::Instance()->GetDigitizerTaskName());
1752 return (obj)?dynamic_cast<TTask*>(obj):0x0;
1753}
1754/*****************************************************************************/
1755
1756TTask* AliRunLoader::GetRunSDigitizer()
1757{
1758//returns SDigitizer Task from folder
1759
1760 TFolder* topf = AliConfig::Instance()->GetTaskFolder();
1761 TObject* obj = topf->FindObjectAny(AliConfig::Instance()->GetSDigitizerTaskName());
1762 return (obj)?dynamic_cast<TTask*>(obj):0x0;
1763}
1764/*****************************************************************************/
1765
1766TTask* AliRunLoader::GetRunReconstructioner()
1767{
1768//returns Reconstructioner Task from folder
1769 TFolder* topf = AliConfig::Instance()->GetTaskFolder();
1770 TObject* obj = topf->FindObjectAny(AliConfig::Instance()->GetReconstructionerTaskName());
1771 return (obj)?dynamic_cast<TTask*>(obj):0x0;
1772}
1773/*****************************************************************************/
1774
1775TTask* AliRunLoader::GetRunTracker()
1776{
1777//returns Tracker Task from folder
1778 TFolder* topf = AliConfig::Instance()->GetTaskFolder();
1779 TObject* obj = topf->FindObjectAny(AliConfig::Instance()->GetTrackerTaskName());
1780 return (obj)?dynamic_cast<TTask*>(obj):0x0;
1781}
1782/*****************************************************************************/
1783
1784TTask* AliRunLoader::GetRunPIDTask()
1785{
1786//returns Tracker Task from folder
1787 TFolder* topf = AliConfig::Instance()->GetTaskFolder();
1788 TObject* obj = topf->FindObjectAny(AliConfig::Instance()->GetPIDTaskName());
1789 return (obj)?dynamic_cast<TTask*>(obj):0x0;
1790}
1791/*****************************************************************************/
1792
1793TTask* AliRunLoader::GetRunQATask()
1794{
1795//returns Quality Assurance Task from folder
1796 TFolder* topf = AliConfig::Instance()->GetTaskFolder();
1797 if (topf == 0x0)
1798 {
21bf7095 1799 AliErrorClass("Can not get task folder from AliConfig");
88cb7938 1800 return 0x0;
1801 }
1802 TObject* obj = topf->FindObjectAny(AliConfig::Instance()->GetQATaskName());
1803 return (obj)?dynamic_cast<TTask*>(obj):0x0;
1804}
1805
1806/*****************************************************************************/
1807
1808void AliRunLoader::SetCompressionLevel(Int_t cl)
1809{
1810//Sets Compression Level in all files
1811 if (fGAFile) fGAFile->SetCompressionLevel(cl);
1812 SetKineComprLevel(cl);
1813 SetTrackRefsComprLevel(cl);
1814 TIter next(fLoaders);
1815 AliLoader *loader;
1816 while((loader = (AliLoader*)next()))
1817 {
1818 loader->SetCompressionLevel(cl);
1819 }
1820}
1821/**************************************************************************/
1822
1823void AliRunLoader::SetKineComprLevel(Int_t cl)
1824{
1825//Sets comression level in Kine File
1826 fKineDataLoader->SetCompressionLevel(cl);
1827}
1828/**************************************************************************/
1829
1830void AliRunLoader::SetTrackRefsComprLevel(Int_t cl)
1831{
1832//Sets comression level in Track Refences File
1833 fTrackRefsDataLoader->SetCompressionLevel(cl);
1834}
1835/**************************************************************************/
1836
1837void AliRunLoader::UnloadHeader()
1838{
1839 //removes TreeE from folder and deletes it
1840 // as well as fHeader object
1841 CleanHeader();
1842 delete fHeader;
1843 fHeader = 0x0;
1844}
1845/**************************************************************************/
1846
1847void AliRunLoader::UnloadKinematics()
1848{
f2a509af 1849//Unloads Kinematics
88cb7938 1850 fKineDataLoader->GetBaseLoader(0)->Unload();
1851}
1852/**************************************************************************/
1853
1854void AliRunLoader::UnloadTrackRefs()
1855{
f2a509af 1856//Unloads Track Refernces
88cb7938 1857 fTrackRefsDataLoader->GetBaseLoader(0)->Unload();
1858}
1859/**************************************************************************/
1860
1861void AliRunLoader::UnloadgAlice()
1862{
f2a509af 1863//Unloads gAlice
88cb7938 1864 if (gAlice == GetAliRun())
1865 {
21bf7095 1866 AliDebug(1, "Set gAlice = 0x0");
88cb7938 1867 gAlice = 0x0;//if gAlice is the same that in folder (to be deleted by the way of folder)
1868 }
1869 AliRun* alirun = GetAliRun();
1870 if (GetEventFolder()) GetEventFolder()->Remove(alirun);
1871 delete alirun;
1872}
1873/**************************************************************************/
1874
1875void AliRunLoader::MakeTrackRefsContainer()
1876{
1877// Makes a tree for Track References
1878 fTrackRefsDataLoader->MakeTree();
1879}
1880/**************************************************************************/
1881
1882Int_t AliRunLoader::LoadTrackRefs(Option_t* option)
1883{
1884//Load track references from file (opens file and posts tree to folder)
1885
f2a509af 1886 return fTrackRefsDataLoader->GetBaseLoader(0)->Load(option);
88cb7938 1887}
1888/**************************************************************************/
1889
1890void AliRunLoader::SetDirName(TString& dirname)
1891{
1892//sets directory name
1893 if (dirname.IsNull()) return;
1894 fUnixDirName = dirname;
1895 fKineDataLoader->SetDirName(dirname);
1896 fTrackRefsDataLoader->SetDirName(dirname);
1897
1898 TIter next(fLoaders);
1899 AliLoader *loader;
1900 while((loader = (AliLoader*)next()))
1901 {
1902 loader->SetDirName(dirname);
1903 }
1904
1905}
1906/*****************************************************************************/
1907
1908Int_t AliRunLoader::GetFileOffset() const
1909{
f2a509af 1910//returns the file number that is added to the file name for current event
88cb7938 1911 return Int_t(fCurrentEvent/fNEventsPerFile);
1912}
1913
1914/*****************************************************************************/
1915const TString AliRunLoader::SetFileOffset(const TString& fname)
1916{
f2a509af 1917//adds the the number to the file name at proper place for current event
88cb7938 1918 Long_t offset = (Long_t)GetFileOffset();
1919 if (offset < 1) return fname;
1920 TString soffset;
1921 soffset += offset;//automatic conversion to string
1922 TString dotroot(".root");
1923 const TString& offfsetdotroot = offset + dotroot;
1924 TString out = fname;
1925 out = out.ReplaceAll(dotroot,offfsetdotroot);
21bf7095 1926 AliDebug(1, Form(" in=%s out=%s",fname.Data(),out.Data()));
88cb7938 1927 return out;
1928}
1929/*****************************************************************************/
1930
1931void AliRunLoader::SetDigitsFileNameSuffix(const TString& suffix)
1932{
1933//adds the suffix before ".root",
1934//e.g. TPC.Digits.root -> TPC.DigitsMerged.root
1935//made on Jiri Chudoba demand
1936
1937 TIter next(fLoaders);
d0d4a6b3 1938 AliLoader *loader;
1939 while((loader = (AliLoader*)next()))
88cb7938 1940 {
d0d4a6b3 1941 loader->SetDigitsFileNameSuffix(suffix);
88cb7938 1942 }
1943}
1944/*****************************************************************************/
1945
1946TString AliRunLoader::GetFileName() const
1947{
1948//returns name of galice file
1949 TString result;
1950 if (fGAFile == 0x0) return result;
1951 result = fGAFile->GetName();
1952 return result;
1953}
1954/*****************************************************************************/
1955
1956void AliRunLoader::SetDetectorAddresses()
1957{
1958 //calls SetTreeAddress for all detectors
1959 if (GetAliRun()==0x0) return;
1960 TIter next(GetAliRun()->Modules());
1961 AliModule* mod;
1962 while((mod = (AliModule*)next()))
1963 {
1964 AliDetector* det = dynamic_cast<AliDetector*>(mod);
1965 if (det) det->SetTreeAddress();
1966 }
1967}
1968/*****************************************************************************/
f0f6f856 1969
1970void AliRunLoader::Synchronize()
1971{
1972 //synchrinizes all writtable files
1973 TIter next(fLoaders);
1974 AliLoader *loader;
1975 while((loader = (AliLoader*)next()))
1976 {
1977 loader->Synchronize();
1978 }
1979
1980 fKineDataLoader->Synchronize();
1981 fTrackRefsDataLoader->Synchronize();
1982
504b172d 1983 if (fGAFile) fGAFile->Flush();
f0f6f856 1984}
88cb7938 1985/*****************************************************************************/
1986/*****************************************************************************/