#include <AliRunDigitizer.h>
#include <AliDigitizer.h>
#include <AliDetector.h>
+#include "AliConfig.h"
Int_t AliLoader::fgDebug = 0;
//fileoption's don't need to initialized because default TString ctor does it correctly
}
/*****************************************************************************/
+AliLoader::AliLoader(const AliLoader& source):TNamed(source) {
+ // dummy copy constructor
+ if(&source==this)return;
+
+ Fatal("AliLoader","Copy constructor not implemented. Aborting");
+ return;
+}
+/*****************************************************************************/
+AliLoader& AliLoader::operator=(const AliLoader& source) {
+ // dummy assignment operator
+ if(&source==this) return *this;
+
+ Fatal("AliLoader","Assignment operator not implemented. Aborting");
+ return *this;
+}
+
+/*****************************************************************************/
AliLoader::~AliLoader()
{
//detructor
return dynamic_cast<AliDataLoader*>(fDataLoaders->FindObject(name));
}
/*****************************************************************************/
+void AliLoader::AddDataLoader(AliDataLoader* dl)
+{
+
+ if (dl == 0x0)
+ {
+ Error("AddDataLoader","Pointer is NULL");
+ return;
+ }
+ if (fDataLoaders->FindObject(dl->GetName()))
+ {
+ Error("AddDataLoader","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
TFolder* AliLoader::GetModulesFolder()
{
+ //returns pointer to the folder containing modules
if (!fModuleFolder)
{
fModuleFolder = dynamic_cast<TFolder*>(GetEventFolder()->FindObjectAny(AliConfig::GetModulesFolderName()));
}
/*****************************************************************************/
-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 )
{
}
/*****************************************************************************/
-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)
{
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 )
+ {
+ Warning("CleanSDigitizer","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 )
+ {
+ Warning("CleanDigitizer","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 )
+ {
+ Warning("CleanSDigitizer","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 )
+ {
+ Warning("CleanTracker","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 )
+ {
+ Warning("CleanPIDTask","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 AliLoader::SetEventFolder(TFolder* eventfolder)
{
+ //sets the event folder
if (eventfolder == 0x0)
{
Error("SetEventFolder","Stupid joke. Argument is NULL");
/*****************************************************************************/
-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)
{
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;
det->SetTreeAddress();
}
/*****************************************************************************/
+
+void AliLoader::Synchronize()
+{
+ //synchrinizes all writtable files
+ TIter next(fDataLoaders);
+ AliDataLoader* dl;
+ while ((dl = (AliDataLoader*)next()))
+ {
+ dl->Synchronize();
+ }
+
+}
+/*****************************************************************************/
/*****************************************************************************/
/*****************************************************************************/
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff