//Author: Alice Offline Group http://alisoft.cern.ch
//Responsible: Piotr.Skowronski@cern.ch
//
-#include <AliLoader.h>
+#include "AliLoader.h"
//Root includes
#include <TROOT.h>
-#include <TFolder.h>
#include <TFile.h>
-#include <TTree.h>
-#include <TTask.h>
+#include <TFolder.h>
#include <TString.h>
-#include <TError.h>
+#include <TTask.h>
//AliRoot includes
-#include <AliRun.h>
-#include <AliRunLoader.h>
-#include <AliRunDigitizer.h>
-#include <AliDigitizer.h>
-#include <AliDetector.h>
-
-Int_t AliLoader::fgDebug = 0;
+#include "AliConfig.h"
+#include "AliDetector.h"
+#include "AliDigitizer.h"
+#include "AliLog.h"
+#include "AliRun.h"
+#include "AliRunLoader.h"
const TString AliLoader::fgkDefaultHitsContainerName("TreeH");
const TString AliLoader::fgkDefaultDigitsContainerName = "TreeD";
fModuleFolder(0x0),
fTasksFolder(0x0),
fQAFolder(0x0)
- {
+{
//default constructor
}
fQAFolder(0x0)
{
//ctor
- if (GetDebug()) Info("AliLoader(const Char_t* detname,const Char_t* eventfoldername)",
- "detname = %s eventfoldername = %s",detname,eventfoldername);
+ AliDebug(1, Form("detname = %s eventfoldername = %s",detname,eventfoldername));
//try to find folder eventfoldername in top alice folder
//safe because GetTopFolder will abort in case of failure
SetEventFolder(eventfolder);
//fileoption's don't need to initialized because default TString ctor does it correctly
}
-/*****************************************************************************/
+/*****************************************************************************/
AliLoader::~AliLoader()
{
//detructor
return dynamic_cast<AliDataLoader*>(fDataLoaders->FindObject(name));
}
/*****************************************************************************/
+void AliLoader::AddDataLoader(AliDataLoader* dl)
+{
+ //
+ // Adds a data loader
+ //
+ if (dl == 0x0)
+ {
+ AliError("Pointer is NULL");
+ return;
+ }
+ if (fDataLoaders->FindObject(dl->GetName()))
+ {
+ AliError("Such a loader exists");
+ return;
+ }
+ fDataLoaders->AddLast(dl);
+ dl->SetEventFolder(fEventFolder);
+ dl->SetFolder(GetDetectorDataFolder()); //Must exists - ensure register is called before
+}
+/*****************************************************************************/
Int_t AliLoader::SetEvent()
{
}
/******************************************************************/
+void AliLoader::UnloadAll()
+{
+ //calls UnloadAll for all base laoders
+ //Unloads everything
+ TIter next(fDataLoaders);
+ AliDataLoader* dl;
+ while ((dl = (AliDataLoader*)next()))
+ {
+ dl->UnloadAll();
+ }
+}
+/******************************************************************/
+
Int_t AliLoader::GetEvent()
{
//changes to proper root directory and tries to load data from files to folders
retval = dl->GetEvent();
if (retval)
{
- Error("GetEvent","Error occured while GetEvent for %s",dl->GetName());
+ AliError(Form("Error occured while GetEvent for %s",dl->GetName()));
return retval;
}
}
//returns the folder speciofic to given detector e.g. /Folders/Event/Data/
if (!fDataFolder)
{
- fDataFolder = dynamic_cast<TFolder*>(GetEventFolder()->FindObject(AliConfig::fgkDataFolderName));
+ fDataFolder = dynamic_cast<TFolder*>(GetEventFolder()->FindObject(AliConfig::Instance()->GetDataFolderName()));
if (!fDataFolder)
{
- Fatal("GetDataFolder","Can not find AliRoot data folder. Aborting");
+ AliFatal("Can not find AliRoot data folder. Aborting");
return 0x0;
}
}
//Returns pointer to Folder with Alice Tasks
if (!fTasksFolder)
{
- fTasksFolder = dynamic_cast<TFolder*>(GetTopFolder()->FindObject(AliConfig::fgkTasksFolderName));
+ fTasksFolder = dynamic_cast<TFolder*>(GetTopFolder()->FindObject(AliConfig::GetTasksFolderName()));
if (!fTasksFolder)
{
- Fatal("GetTasksFolder","Can not find tasks folder. Aborting");
+ AliFatal("Can not find tasks folder. Aborting");
return 0x0;
}
}
TFolder* AliLoader::GetModulesFolder()
{
+ //returns pointer to the folder containing modules
if (!fModuleFolder)
{
fModuleFolder = dynamic_cast<TFolder*>(GetEventFolder()->FindObjectAny(AliConfig::GetModulesFolderName()));
if (!fModuleFolder)
{
- Fatal("GetModulesFolder","Can not find modules folder. Aborting");
+ AliFatal("Can not find modules folder. Aborting");
return 0x0;
}
}
if (fQAFolder == 0x0)
{
- Fatal("GetQAFolder","Can not find Quality Assurance folder. Aborting");
+ AliFatal("Can not find Quality Assurance folder. Aborting");
return 0x0;
}
}
}
/*****************************************************************************/
-TTask* AliLoader::SDigitizer()
+TTask* AliLoader::SDigitizer() const
{
//returns SDigitizer task for this detector
return GetSDigitsDataLoader()->GetBaseTaskLoader()->Task();
}
/*****************************************************************************/
-AliDigitizer* AliLoader::Digitizer()
+AliDigitizer* AliLoader::Digitizer() const
{
//returns Digitizer task for this detector
return dynamic_cast<AliDigitizer*>(GetDigitsDataLoader()->GetBaseTaskLoader()->Task());
}
/*****************************************************************************/
-TTask* AliLoader::Reconstructioner()
+TTask* AliLoader::Reconstructioner() const
{
//returns Recontructioner (Cluster Finder, Cluster Maker,
//or whatever you want to call it) task for this detector
}
/*****************************************************************************/
-TTask* AliLoader::Tracker()
+TTask* AliLoader::Tracker() const
{
//returns tracker
return dynamic_cast<TTask*>(GetTracksDataLoader()->GetBaseTaskLoader()->Task());
}
/*****************************************************************************/
-TTask* AliLoader::PIDTask()
+TTask* AliLoader::PIDTask() const
{
//returns tracker
return dynamic_cast<TTask*>(GetRecParticlesDataLoader()->GetBaseTaskLoader()->Task());
/*****************************************************************************/
-TTask* AliLoader::QAtask(const char* name)
+TTask* AliLoader::QAtask(const char* name) const
{
+ // Returns pointer to the quality assurance task
TTask* qat = AliRunLoader::GetRunQATask();
if ( qat == 0x0 )
{
- Error("QAtask","Can not get RunQATask. (Name:%s)",GetName());
+ AliError(Form("Can not get RunQATask. (Name:%s)",GetName()));
return 0x0;
}
if ( dqat == 0x0 )
{
- Error("QAtask","Can not find QATask in RunQATask for %s",GetDetectorName().Data());
+ AliError(Form("Can not find QATask in RunQATask for %s",GetDetectorName().Data()));
return 0x0;
}
if(taskname.BeginsWith(name))
return task ;
}
- Error("QAtask","Can not find sub-task with name starting with %s in task %s",name,dqat->GetName());
+ AliError(Form("Can not find sub-task with name starting with %s in task %s",name,dqat->GetName()));
return 0x0;
}
/*****************************************************************************/
if (file == 0x0)
{
- ::Error("AliLoader::ChangeDir","File is null");
+ AliErrorClass("File is null");
return 0x0;
}
if (file->IsOpen() == kFALSE)
{
- ::Error("AliLoader::ChangeDir","File is not opened");
+ AliErrorClass("File is not opened");
return 0x0;
}
TString dirname("Event");
dirname+=eventno;
- if (AliLoader::fgDebug > 1)
- ::Info("AliLoader::ChangeDir","Changing Dir to %s in file %s.",dirname.Data(),file->GetName());
+ AliDebugClass(1, Form("Changing Dir to %s in file %s.",dirname.Data(),file->GetName()));
Bool_t result;
if (dir == 0x0)
{
- if (AliLoader::fgDebug > 1)
- ::Info("AliLoader::ChangeDir","Can not find directory %s in file %s, creating...",
- dirname.Data(),file->GetName());
+ AliDebugClass(1, Form("Can not find directory %s in file %s, creating...",
+ dirname.Data(),file->GetName()));
if (file->IsWritable() == kFALSE)
{
- ::Error("AliLoader::ChangeDir","Can not create directory. File %s in not writable.",
- file->GetName());
+ AliErrorClass(Form("Can not create directory. File %s in not writable.",
+ file->GetName()));
return 0x0;
}
TDirectory* newdir = file->mkdir(dirname);
if (newdir == 0x0)
{
- ::Error("AliLoader::ChangeDir","Failed to create new directory in file %s.",
- file->GetName());
+ AliErrorClass(Form("Failed to create new directory in file %s.",
+ file->GetName()));
return 0x0;
}
result = file->cd(dirname);
}
/*****************************************************************************/
-TString AliLoader::GetUnixDir()
+TString AliLoader::GetUnixDir() const
{
//This Method will manage jumping through unix directories in case of
//run with more events per run than defined in gAlice
}
/*****************************************************************************/
-Int_t AliLoader::WriteHits(Option_t* opt)
+Int_t AliLoader::WriteHits(Option_t* opt) const
{
+ // Writes hits
AliDataLoader* dl = GetHitsDataLoader();
Int_t ret = dl->WriteData(opt);
return ret;
}
/*****************************************************************************/
-Int_t AliLoader::WriteSDigits(Option_t* opt)
+Int_t AliLoader::WriteSDigits(Option_t* opt) const
{
+ // Writes summable digits
AliDataLoader* dl = GetSDigitsDataLoader();
Int_t ret = dl->WriteData(opt);
return ret;
/*****************************************************************************/
-Int_t AliLoader::PostSDigitizer(TTask* sdzer)
+Int_t AliLoader::PostSDigitizer(TTask* sdzer) const
{
+ // Posts sdigitizer
return GetSDigitsDataLoader()->GetBaseTaskLoader()->Post(sdzer);
}
/*****************************************************************************/
-Int_t AliLoader::PostDigitizer(AliDigitizer* task)
+Int_t AliLoader::PostDigitizer(AliDigitizer* task) const
{
+ // Posts digitizer
return GetDigitsDataLoader()->GetBaseTaskLoader()->Post(task);
}
/*****************************************************************************/
-Int_t AliLoader::PostReconstructioner(TTask* task)
+Int_t AliLoader::PostReconstructioner(TTask* task) const
{
+ // Posts Reconstructioner
return GetRecPointsDataLoader()->GetBaseTaskLoader()->Post(task);
}
/*****************************************************************************/
-Int_t AliLoader::PostTracker(TTask* task)
+Int_t AliLoader::PostTracker(TTask* task) const
{
+ // Posts a tracker
return GetTracksDataLoader()->GetBaseTaskLoader()->Post(task);
}
/*****************************************************************************/
-Int_t AliLoader::PostPIDTask(TTask* task)
+Int_t AliLoader::PostPIDTask(TTask* task) const
{
+ // Posts particle identification task
return GetRecParticlesDataLoader()->GetBaseTaskLoader()->Post(task);
}
/*****************************************************************************/
TObject** AliLoader::GetDetectorDataRef(TObject *obj)
{
+ // Returns pointer to an entry in the list of folders pointing to "obj"
if (obj == 0x0)
{
return 0x0;
TObject** AliLoader::SDigitizerRef()
{
+ // Returns pointer to a Runloader's task-list entry pointing to SDigitizer
TTask* rsd = AliRunLoader::GetRunSDigitizer();
if (rsd == 0x0)
{
TObject** AliLoader::DigitizerRef()
{
+ // Returns pointer to a Runloader's task-list entry pointing to Digitizer
TTask* rd = AliRunLoader::GetRunDigitizer();
if (rd == 0x0)
{
TObject** AliLoader::ReconstructionerRef()
{
+ // Returns pointer to a Runloader's task-list entry pointing to Reconstructioner
TTask* rrec = AliRunLoader::GetRunReconstructioner();
if (rrec == 0x0)
{
TObject** AliLoader::TrackerRef()
{
+ // Returns pointer to a Runloader's task-list entry pointing to Tracker
TTask* rrec = AliRunLoader::GetRunTracker();
if (rrec == 0x0)
{
TObject** AliLoader::PIDTaskRef()
{
+ // Returns pointer to a Runloader's task-list entry pointing to PIDTask
TTask* rrec = AliRunLoader::GetRunPIDTask();
if (rrec == 0x0)
{
AliDataLoader* dl;
while ((dl = (AliDataLoader*)next()))
{
- if (GetDebug()) Info("CleanFolders","name = %s cleaning",dl->GetName());
+ AliDebug(1, Form("name = %s cleaning",dl->GetName()));
dl->Clean();
}
}
void AliLoader::CleanSDigitizer()
{
//removes and deletes detector task from Run Task
- TTask* task = AliRunLoader::GetRunSDigitizer();
- if (task == 0x0)
- {
- Error("CleanSDigitizer","Can not get RunSDigitizer from folder. Can not clean");
- return;
- }
-
- if (GetDebug()) Info("CleanSDigitizer","Attempting to delete S Digitizer");
- delete task->GetListOfTasks()->Remove(SDigitizer()); //TTList::Remove does not delete object
+ if ( GetSDigitsDataLoader()->GetBaseTaskLoader() == 0x0 )
+ {
+ AliWarning("Task Loader for SDigits does not exist");
+ return;
+ }
+ GetSDigitsDataLoader()->GetBaseTaskLoader()->Clean();
}
/*****************************************************************************/
void AliLoader::CleanDigitizer()
{
//removes and deletes detector task from Run Task
- TTask* task = AliRunLoader::GetRunDigitizer();
- if (task == 0x0)
- {
- Error("CleanDigitizer","Can not get RunDigitizer from folder. Can not clean");
- return;
- }
-
- if (GetDebug())
- Info("CleanDigitizer","Attempting to delete Digitizer %X",
- task->GetListOfTasks()->Remove(Digitizer()));
- delete task->GetListOfTasks()->Remove(Digitizer()); //TTList::Remove does not delete object
+ if ( GetDigitsDataLoader()->GetBaseTaskLoader() == 0x0 )
+ {
+ AliWarning("Task Loader for Digits does not exist");
+ return;
+ }
+ GetDigitsDataLoader()->GetBaseTaskLoader()->Clean();
}
/*****************************************************************************/
void AliLoader::CleanReconstructioner()
{
//removes and deletes detector Reconstructioner from Run Reconstructioner
- TTask* task = AliRunLoader::GetRunReconstructioner();
- if (task == 0x0)
- {
- Error("CleanReconstructioner","Can not get RunReconstructioner from folder. Can not clean");
- return;
- }
-
- if (GetDebug())
- Info("CleanReconstructioner","Attempting to delete Reconstructioner");
- delete task->GetListOfTasks()->Remove(Reconstructioner()); //TTList::Remove does not delete object
+ if ( GetRecPointsDataLoader()->GetBaseTaskLoader() == 0x0 )
+ {
+ AliWarning("Task Loader for SDigits does not exist");
+ return;
+ }
+ GetRecPointsDataLoader()->GetBaseTaskLoader()->Clean();
}
/*****************************************************************************/
void AliLoader::CleanTracker()
{
-//removes and deletes detector tracker from Run Tracker
- TTask* task = AliRunLoader::GetRunTracker();
- if (task == 0x0)
- {
- Error("CleanTracker","Can not get RunTracker from folder. Can not clean");
- return;
- }
-
- if (GetDebug())
- Info("CleanTracker","Attempting to delete Tracker %X",
- task->GetListOfTasks()->Remove(Tracker()));
- delete task->GetListOfTasks()->Remove(Tracker()); //TTList::Remove does not delete object
+//removes and deletes detector task from Run Task
+ if ( GetTracksDataLoader()->GetBaseTaskLoader() == 0x0 )
+ {
+ AliWarning("Task Loader for Tracks does not exist");
+ return;
+ }
+ GetTracksDataLoader()->GetBaseTaskLoader()->Clean();
}
/*****************************************************************************/
void AliLoader::CleanPIDTask()
{
//removes and deletes detector Reconstructioner from Run Reconstructioner
- TTask* task = AliRunLoader::GetRunPIDTask();
- if (task == 0x0)
- {
- Error("CleanPIDTask","Can not get Run PID Task from folder. Can not clean");
- return;
- }
- if (GetDebug())
- Info("CleanPIDTask","Attempting to delete PID Task");
- delete task->GetListOfTasks()->Remove(PIDTask()); //TTList::Remove does not delete object
+ if ( GetRecParticlesDataLoader()->GetBaseTaskLoader() == 0x0 )
+ {
+ AliWarning("Task Loader for Reconstructed Particles does not exist");
+ return;
+ }
+ GetRecParticlesDataLoader()->GetBaseTaskLoader()->Clean();
}
/*****************************************************************************/
Int_t AliLoader::ReloadAll()
{
+ // Calling Reload function for all the data loaders
TIter next(fDataLoaders);
AliDataLoader* dl;
Int_t err = dl->Reload();
if (err)
{
- Error("ReloadAll","Reload returned error for %s",dl->GetName());
+ AliError(Form("Reload returned error for %s",dl->GetName()));
return err;
}
}
Int_t AliLoader::SetEventFolder(TFolder* eventfolder)
{
+ //sets the event folder
if (eventfolder == 0x0)
{
- Error("SetEventFolder","Stupid joke. Argument is NULL");
+ AliError("Stupid joke. Argument is NULL");
return 1;
}
//creation of folder structure as well (some detectors needs folders
//alrady in constructors)
- if (GetDebug()) Info("Register","Name is %s.",GetName());
+ AliDebug(1, Form("Name is %s.",GetName()));
if (eventFolder == 0x0)
{
- Error("Register","Event folder is not set.");
+ AliError("Event folder is not set.");
return 1;
}
Int_t retval = AliConfig::Instance()->AddDetector(eventFolder,fDetectorName,fDetectorName);
if(retval)
{
- Error("SetEventFolder","Can not create tasks and/or folders for %s. Event folder name is %s",
- fDetectorName.Data(),eventFolder->GetName());
+ AliError(Form("Can not create tasks and/or folders for %s. Event folder name is %s",
+ fDetectorName.Data(),eventFolder->GetName()));
return retval;
}
SetEventFolder(eventFolder);
{
//gets the run-loader from event folder
AliRunLoader* rg = 0x0;
- TObject * obj = GetEventFolder()->FindObject(AliRunLoader::fgkRunLoaderName);
+ TObject * obj = GetEventFolder()->FindObject(AliRunLoader::GetRunLoaderName());
if (obj) rg = dynamic_cast<AliRunLoader*>(obj);
return rg;
}
/*****************************************************************************/
void AliLoader::SetDirName(TString& dirname)
{
-//adds "dirname/" to each file
+//adds "dirname" to each file. Dirname should end with "#","/", or ":"
TIter next(fDataLoaders);
AliDataLoader* dl;
while((dl = (AliDataLoader*)next()))
/*****************************************************************************/
-void AliLoader::SetDigitsFileNameSuffix(const TString& suffix)
+void AliLoader::SetDigitsFileNameSuffix(const TString& suffix) const
{
//adds the suffix before ".root",
//e.g. TPC.Digits.root -> TPC.DigitsMerged.root
void AliLoader::Clean(const TString& name)
{
+ // Removes object with "name" from the detector's data folder
+ // and from the memory
TObject* obj = GetDetectorDataFolder()->FindObject(name);
if(obj)
{
- if (GetDebug())
- Info("Clean(const TString&)","name=%s, cleaning %s.",GetName(),name.Data());
+ AliDebug(1, Form("name=%s, cleaning %s.",GetName(),name.Data()));
GetDetectorDataFolder()->Remove(obj);
delete obj;
}
Bool_t AliLoader::IsOptionWritable(const TString& opt)
{
+ // Returns "true" if the option means also "writable"
if (opt.CompareTo("recreate",TString::kIgnoreCase)) return kTRUE;
if (opt.CompareTo("new",TString::kIgnoreCase)) return kTRUE;
if (opt.CompareTo("create",TString::kIgnoreCase)) return kTRUE;
if (opt.CompareTo("update",TString::kIgnoreCase)) return kTRUE;
return kFALSE;
}
+
+/*****************************************************************************/
+
+void AliLoader::SetDebug(Int_t deb)
+{
+ // Sets debug level
+ AliLog::SetClassDebugLevel("AliRunLoader", deb);
+ AliLog::SetClassDebugLevel("AliLoader", deb);
+ AliLog::SetClassDebugLevel("AliDataLoader", deb);
+ AliLog::SetClassDebugLevel("AliBaseLoader", deb);
+ AliLog::SetClassDebugLevel("AliObjectLoader", deb);
+ AliLog::SetClassDebugLevel("AliTreeLoader", deb);
+ AliLog::SetClassDebugLevel("AliTaskLoader", deb);
+ AliLog::SetClassDebugLevel("AliConfig", deb);
+}
/*****************************************************************************/
void AliLoader::SetTAddrInDet()
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff