#include "AliRunLoader.h"
#include "AliLog.h"
#include "AliRun.h"
#include "AliLoader.h"
#include "AliHeader.h"
#include "AliStack.h"
#include "AliDetector.h"
#include "AliCDBManager.h"
#include "AliCDBLocal.h"
#include "AliCentralTrigger.h"
#include <TTree.h>
#include <TBranch.h>
#include <TROOT.h>
#include <TFile.h>
#include <TFolder.h>
#include <TObjArray.h>
#include <TString.h>
ClassImp(AliRunLoader)
AliRunLoader* AliRunLoader::fgRunLoader = 0x0;
const TString AliRunLoader::fgkRunLoaderName("RunLoader");
const TString AliRunLoader::fgkHeaderBranchName("Header");
const TString AliRunLoader::fgkTriggerBranchName("ClassMask");
const TString AliRunLoader::fgkHeaderContainerName("TE");
const TString AliRunLoader::fgkTriggerContainerName("TreeCT");
const TString AliRunLoader::fgkKineContainerName("TreeK");
const TString AliRunLoader::fgkTrackRefsContainerName("TreeTR");
const TString AliRunLoader::fgkKineBranchName("Particles");
const TString AliRunLoader::fgkDefaultKineFileName("Kinematics.root");
const TString AliRunLoader::fgkDefaultTrackRefsFileName("TrackRefs.root");
const TString AliRunLoader::fgkGAliceName("gAlice");
const TString AliRunLoader::fgkDefaultTriggerFileName("Trigger.root");
AliRunLoader::AliRunLoader():
fLoaders(0x0),
fEventFolder(0x0),
fRun(-1),
fCurrentEvent(0),
fGAFile(0x0),
fHeader(0x0),
fStack(0x0),
fCTrigger(0x0),
fKineDataLoader(0x0),
fTrackRefsDataLoader(0x0),
fNEventsPerFile(1),
fNEventsPerRun(0),
fUnixDirName(".")
{
AliConfig::Instance();
if (!fgRunLoader) fgRunLoader = this;
}
AliRunLoader::AliRunLoader(const char* eventfoldername):
TNamed(fgkRunLoaderName,fgkRunLoaderName),
fLoaders(new TObjArray()),
fEventFolder(0x0),
fRun(-1),
fCurrentEvent(0),
fGAFile(0x0),
fHeader(0x0),
fStack(0x0),
fCTrigger(0x0),
fKineDataLoader(new AliDataLoader(fgkDefaultKineFileName,fgkKineContainerName,"Kinematics")),
fTrackRefsDataLoader(new AliDataLoader(fgkDefaultTrackRefsFileName,fgkTrackRefsContainerName,"Track References")),
fNEventsPerFile(1),
fNEventsPerRun(0),
fUnixDirName(".")
{
SetEventFolderName(eventfoldername);
if (!fgRunLoader) fgRunLoader = this;
}
AliRunLoader::~AliRunLoader()
{
UnloadHeader();
UnloadgAlice();
if (fgRunLoader == this) fgRunLoader = 0x0;
if(fLoaders) {
fLoaders->SetOwner();
delete fLoaders;
}
delete fKineDataLoader;
delete fTrackRefsDataLoader;
RemoveEventFolder();
if( fCTrigger ) delete fCTrigger;
delete fStack;
delete fGAFile;
}
AliRunLoader::AliRunLoader(TFolder* topfolder):
TNamed(fgkRunLoaderName,fgkRunLoaderName),
fLoaders(new TObjArray()),
fEventFolder(topfolder),
fRun(-1),
fCurrentEvent(0),
fGAFile(0x0),
fHeader(0x0),
fStack(0x0),
fCTrigger(0x0),
fKineDataLoader(new AliDataLoader(fgkDefaultKineFileName,fgkKineContainerName,"Kinematics")),
fTrackRefsDataLoader(new AliDataLoader(fgkDefaultTrackRefsFileName,fgkTrackRefsContainerName,"Track References")),
fNEventsPerFile(1),
fNEventsPerRun(0),
fUnixDirName(".")
{
if(topfolder == 0x0)
{
TString errmsg("Parameter is NULL");
AliError(errmsg.Data());
throw errmsg;
return;
}
TObject* obj = fEventFolder->FindObject(fgkRunLoaderName);
if (obj)
{
TString errmsg("In Event Folder Named ");
errmsg+=fEventFolder->GetName();
errmsg+=" object named "+fgkRunLoaderName+" already exists. I am confused ...";
AliError(errmsg.Data());
throw errmsg;
return;
}
if (!fgRunLoader) fgRunLoader = this;
fEventFolder->Add(this);
}
Int_t AliRunLoader::GetEvent(Int_t evno)
{
if (evno < 0)
{
AliError("Can not give the event with negative number");
return 4;
}
if (evno >= GetNumberOfEvents())
{
AliError(Form("There is no event with number %d",evno));
return 3;
}
AliDebug(1, ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
AliDebug(1, ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
AliDebug(1, ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
AliDebug(1, Form(" GETTING EVENT %d",evno));
AliDebug(1, ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
AliDebug(1, ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
AliDebug(1, ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
fCurrentEvent = evno;
Int_t retval;
if (GetHeader())
{
retval = TreeE()->GetEvent(fCurrentEvent);
if ( retval == 0)
{
AliError(Form("Cannot find event: %d\n ",fCurrentEvent));
return 5;
}
}
if (TreeE()) fStack = GetHeader()->Stack();
if( GetTrigger() && TreeCT() ) {
retval = TreeCT()->GetEvent(fCurrentEvent);
if ( retval < 0 ) {
AliError(Form("Error occured while GetEvent for Trigger. Event %d",evno));
return 2;
}
}
retval = SetEvent();
if (retval)
{
AliError(Form("Error occured while setting event %d",evno));
return 1;
}
retval = fTrackRefsDataLoader->GetEvent();
if (retval)
{
AliError(Form("Error occured while GetEvent for Track References. Event %d",evno));
return 2;
}
retval = fKineDataLoader->GetEvent();
if (retval)
{
AliError(Form("Error occured while GetEvent for Kinematics. Event %d",evno));
return 2;
}
if (fStack && fKineDataLoader->GetBaseLoader(0)->IsLoaded())
{
fStack->ConnectTree(TreeK());
if (fStack->GetEvent() == kFALSE)
{
AliError(Form("Error occured while GetEvent for Stack. Event %d",evno));
return 2;
}
}
TIter next(fLoaders);
AliLoader *loader;
while((loader = (AliLoader*)next()))
{
retval = loader->GetEvent();
if (retval)
{
AliError(Form("Error occured while getting event for %s. Event %d.",
loader->GetDetectorName().Data(), evno));
return 3;
}
}
SetDetectorAddresses();
return 0;
}
Int_t AliRunLoader::SetEvent()
{
Int_t retval;
retval = fKineDataLoader->SetEvent();
if (retval)
{
AliError("SetEvent for Kinamtics Data Loader retutned error.");
return retval;
}
retval = fTrackRefsDataLoader->SetEvent();
if (retval)
{
AliError("SetEvent for Track References Data Loader retutned error.");
return retval;
}
TIter next(fLoaders);
AliLoader *loader;
while((loader = (AliLoader*)next()))
{
retval = loader->SetEvent();
if (retval)
{
AliError(Form("SetEvent for %s Data Loader retutned error.",loader->GetName()));
return retval;
}
}
return 0;
}
Int_t AliRunLoader::SetEventNumber(Int_t evno)
{
if (fCurrentEvent == evno) return 0;
fCurrentEvent = evno;
return SetEvent();
}
AliCDBEntry* AliRunLoader::GetCDBEntry(const char* name) const
{
AliDebug(1, Form("Getting CDBEntry with name %s",name));
if ( !(AliCDBManager::Instance()->IsDefaultStorageSet()) ) {
AliError("No run data storage defined!");
return 0x0;
}
return AliCDBManager::Instance()->GetDefaultStorage()->Get(name, GetHeader()->GetRun());
}
AliRunLoader* AliRunLoader::Open
(const char* filename, const char* eventfoldername, Option_t* option)
{
static const TString kwebaddress("http://alisoft.cern.ch/people/skowron/codedoc/split/index.html");
AliDebugClass(1,Form("\n\n\nNew I/O strcture: See more info:\n %s\n\n\n",kwebaddress.Data()));
AliRunLoader* result = 0x0;
TObject* obj = AliConfig::Instance()->GetTopFolder()->FindObject(eventfoldername);
if(obj)
{
TFolder* fold = dynamic_cast<TFolder*>(obj);
if (fold == 0x0)
{
AliErrorClass("Such a obejct already exists in top alice folder and it is not a folder.");
return 0x0;
}
result = AliRunLoader::GetRunLoader(eventfoldername);
if (result == 0x0)
{
AliErrorClass(Form("Folder %s already exists, and can not find session there. Can not mount.",eventfoldername));
return 0x0;
}
if (result->GetFileName().CompareTo(filename) != 0)
{
AliErrorClass("Other file is mounted in demanded folder. Can not mount.");
return 0x0;
}
if ( AliLoader::TestFileOption(option) == kFALSE)
{
AliErrorClass(Form("Session already exists in folder %s and this session option is %s. Unable to proceed.",
eventfoldername,option));
return 0x0;
}
TString tmpstr(option);
if ( (tmpstr.CompareTo("update",TString::kIgnoreCase) == 0) &&
(result->fGAFile->IsWritable() == kFALSE) )
{
AliErrorClass(Form("Session already exists in folder %s and is not writable while this session option is %s. Unable to proceed.",
eventfoldername,option));
return 0x0;
}
AliWarningClass("Session is already opened and mounted in demanded folder");
if (!fgRunLoader) fgRunLoader = result;
return result;
}
TFile * gAliceFile = TFile::Open(filename,option);
if (!gAliceFile)
{
AliFatalClass(Form("Can not open file %s.",filename));
return 0x0;
}
if (gAliceFile->IsOpen() == kFALSE)
{
AliErrorClass(Form("Can not open file %s.",filename));
return 0x0;
}
if ( AliLoader::TestFileOption(option) )
{
AliDebugClass(1, "Reading RL from file");
result = dynamic_cast<AliRunLoader*>(gAliceFile->Get(fgkRunLoaderName));
if (result == 0x0)
{
AliErrorClass(Form("Can not find run-Loader in file %s.",filename));
delete gAliceFile;
return 0x0;
}
Int_t tmp = result->SetEventFolderName(eventfoldername);
if (tmp)
{
AliErrorClass(Form("Can not mount event in folder %s.",eventfoldername));
delete result;
delete gAliceFile;
return 0x0;
}
}
else
{
AliDebugClass(1, Form("Creating new AliRunLoader. Folder name is %s",eventfoldername));
try
{
result = new AliRunLoader(eventfoldername);
}
catch (TString& errmsg)
{
AliErrorClass(Form("AliRunLoader constrcutor has thrown exception: %s\n",errmsg.Data()));
delete result;
delete gAliceFile;
return 0x0;
}
}
TString fname(filename);
Int_t nsl = fname.Last('#');
TString dirname;
if (nsl < 0) {
nsl = fname.Last('/');
if (nsl < 0)
nsl = fname.Last(':');
}
if (nsl < 0) dirname = "./";
else dirname = fname.Remove(nsl+1);
AliDebugClass(1, Form("Dir name is : %s",dirname.Data()));
result->SetDirName(dirname);
result->SetGAliceFile(gAliceFile);
if (!fgRunLoader) fgRunLoader = result;
return result;
}
Int_t AliRunLoader::GetNumberOfEvents()
{
Int_t retval;
if( TreeE() == 0x0 )
{
retval = LoadHeader();
if (retval)
{
AliError("Error occured while loading header");
return -1;
}
}
return (Int_t)TreeE()->GetEntries();
}
void AliRunLoader::MakeHeader()
{
AliDebug(1, "");
if(fHeader == 0x0)
{
AliDebug(1, "Creating new Header Object");
fHeader= new AliHeader();
}
TTree* tree = TreeE();
if (tree)
{
AliDebug(1, "Got Tree from folder.");
TBranch* branch = tree->GetBranch(fgkHeaderBranchName);
if (branch == 0x0)
{
AliDebug(1, "Creating new branch");
branch = tree->Branch(fgkHeaderBranchName, "AliHeader", &fHeader, 4000, 0);
branch->SetAutoDelete(kFALSE);
}
else
{
AliDebug(1, "Got Branch from Tree");
branch->SetAddress(&fHeader);
tree->GetEvent(fCurrentEvent);
fStack = fHeader->Stack();
if (fStack)
{
if (TreeK()) {
fStack->ConnectTree(TreeK());
fStack->GetEvent();
}
}
else
{
AliDebug(1, "Header does not have a stack.");
}
}
}
AliDebug(1, "Exiting MakeHeader method");
}
void AliRunLoader::MakeStack()
{
if(fStack == 0x0)
{
fStack = new AliStack(10000);
}
}
void AliRunLoader::MakeTrigger()
{
AliDebug( 1, "" );
if( fCTrigger == 0x0 ) {
AliDebug( 1, "Creating new Trigger Object" );
fCTrigger = new AliCentralTrigger();
}
TTree* tree = TreeCT();
if( tree ) {
fCTrigger->MakeBranch( fgkTriggerBranchName, tree );
tree->GetEvent( fCurrentEvent );
}
AliDebug( 1, "Exiting MakeTrigger method" );
}
void AliRunLoader::MakeTree(Option_t *option)
{
const char *oK = strstr(option,"K");
const char *oE = strstr(option,"E");
const char *oGG = strstr(option,"GG");
if(oK)
{
if (fKineDataLoader->GetBaseLoader(0)->IsLoaded() == kFALSE)
{
AliError("Load Kinematics first");
}
else
{
if (!TreeK()) {
fKineDataLoader->MakeTree();
MakeStack();
}
fStack->ConnectTree(TreeK());
WriteKinematics("OVERWRITE");
}
}
if(oE && !TreeE())
{
fGAFile->cd();
TTree* tree = new TTree(fgkHeaderContainerName,"Tree with Headers");
GetEventFolder()->Add(tree);
MakeHeader();
WriteHeader("OVERWRITE");
}
if(oGG && !TreeCT())
{
TFile* file = gROOT->GetFile( fgkDefaultTriggerFileName );
if( !file ) {
char* tmp = gSystem->ConcatFileName( fUnixDirName.Data(), fgkDefaultTriggerFileName.Data() );
file = TFile::Open(tmp , "RECREATE" ) ;
delete[] tmp;
}
file->cd();
TTree* tree = new TTree( fgkTriggerContainerName, "Tree with Central Trigger Mask" );
GetEventFolder()->Add(tree);
MakeTrigger();
}
TIter next(fLoaders);
AliLoader *loader;
while((loader = (AliLoader*)next()))
{
loader->MakeTree(option);
}
}
Int_t AliRunLoader::LoadgAlice()
{
if (GetAliRun())
{
AliWarning("AliRun is already in folder. Unload first.");
return 0;
}
AliRun* alirun = dynamic_cast<AliRun*>(fGAFile->Get(fgkGAliceName));
if (alirun == 0x0)
{
AliError(Form("Can not find gAlice in file %s",fGAFile->GetName()));
return 2;
}
alirun->SetRunLoader(this);
if (gAlice)
{
AliWarning(Form("gAlice already exists. Putting retrived object in folder named %s",
GetEventFolder()->GetName()));
}
else
{
gAlice = alirun;
}
SetDetectorAddresses();
return 0;
}
Int_t AliRunLoader::LoadHeader()
{
if (TreeE())
{
AliWarning("Header is already loaded. Use ReloadHeader to force reload. Nothing done");
return 0;
}
if (GetEventFolder() == 0x0)
{
AliError("Event folder not specified yet");
return 1;
}
if (fGAFile == 0x0)
{
AliError("Session not opened. Use AliRunLoader::Open");
return 2;
}
if (fGAFile->IsOpen() == kFALSE)
{
AliError("Session not opened. Use AliRunLoader::Open");
return 2;
}
TTree* tree = dynamic_cast<TTree*>(fGAFile->Get(fgkHeaderContainerName));
if (tree == 0x0)
{
AliError(Form("Can not find header tree named %s in file %s",
fgkHeaderContainerName.Data(),fGAFile->GetName()));
return 2;
}
if (tree == TreeE()) return 0;
CleanHeader();
GetEventFolder()->Add(tree);
MakeHeader();
return 0;
}
Int_t AliRunLoader::LoadTrigger(Option_t* option)
{
static Bool_t warned = kFALSE;
if( TreeCT() ) {
if (!warned) AliWarning("Trigger is already loaded. Nothing done. Message will not be repeated.");
warned = kTRUE;
return 0;
}
if( GetEventFolder() == 0x0 ) {
AliError("Event folder not specified yet");
return 1;
}
char* tmp = gSystem->ConcatFileName( fUnixDirName.Data(),
fgkDefaultTriggerFileName.Data() );
TString trgfile(tmp);
delete[] tmp;
TFile* file = gROOT->GetFile( trgfile );
if( !file ) {
file = TFile::Open( trgfile, option ) ;
if (!file || file->IsOpen() == kFALSE ) {
AliError( Form( "Can not open trigger file %s", trgfile.Data() ) );
return 2;
}
}
file->cd();
TTree* tree = dynamic_cast<TTree*>(file->Get( fgkTriggerContainerName ));
if( !tree ) {
AliError( Form( "Can not find trigger tree named %s in file %s",
fgkTriggerContainerName.Data(), file->GetName() ) );
return 2;
}
CleanTrigger();
fCTrigger = dynamic_cast<AliCentralTrigger*>(file->Get( "AliCentralTrigger" ));
GetEventFolder()->Add( tree );
MakeTrigger();
return 0;
}
Int_t AliRunLoader::LoadKinematics(Option_t* option)
{
Int_t retval = fKineDataLoader->GetBaseLoader(0)->Load(option);
if (retval)
{
AliError("Error occured while loading kinamatics tree.");
return retval;
}
if (fStack)
{
fStack->ConnectTree(TreeK());
retval = fStack->GetEvent();
if ( retval == kFALSE)
{
AliError("Error occured while loading kinamatics tree.");
return retval;
}
}
return 0;
}
Int_t AliRunLoader::OpenDataFile(const TString& filename,TFile*& file,TDirectory*& dir,Option_t* opt,Int_t cl)
{
if (file)
{
if (file->IsOpen() == kFALSE)
{
AliWarning("Pointer to file is not null, but file is not opened");
delete file;
file = 0x0;
}
else
{
AliWarning(Form("File %s already opened",filename.Data()));
return 0;
}
}
file = (TFile *)( gROOT->GetListOfFiles()->FindObject(filename) );
if (file)
{
if(file->IsOpen() == kTRUE)
{
AliWarning(Form("File %s already opened by sombody else.",file->GetName()));
return 0;
}
}
file = TFile::Open(filename,opt);
if (file == 0x0)
{
AliError(Form("Can not open file %s",filename.Data()));
return 1;
}
if (file->IsOpen() == kFALSE)
{
AliError(Form("Can not open file %s",filename.Data()));
return 1;
}
file->SetCompressionLevel(cl);
dir = AliLoader::ChangeDir(file,fCurrentEvent);
if (dir == 0x0)
{
AliError(Form("Can not change to root directory in file %s",filename.Data()));
return 3;
}
return 0;
}
TTree* AliRunLoader::TreeE() const
{
if (AliDebugLevel() > 10) fEventFolder->ls();
TObject *obj = fEventFolder->FindObject(fgkHeaderContainerName);
return (obj)?dynamic_cast<TTree*>(obj):0x0;
}
TTree* AliRunLoader::TreeCT() const
{
if (AliDebugLevel() > 10) fEventFolder->ls();
TObject *obj = fEventFolder->FindObject(fgkTriggerContainerName);
return (obj)?dynamic_cast<TTree*>(obj):0x0;
}
AliHeader* AliRunLoader::GetHeader() const
{
return fHeader;
}
AliCentralTrigger* AliRunLoader::GetTrigger() const
{
return fCTrigger;
}
TTree* AliRunLoader::TreeK() const
{
TObject *obj = GetEventFolder()->FindObject(fgkKineContainerName);
return (obj)?dynamic_cast<TTree*>(obj):0x0;
}
TTree* AliRunLoader::TreeTR() const
{
TObject* obj = GetEventFolder()->FindObject(fgkTrackRefsContainerName);
return (obj)?dynamic_cast<TTree*>(obj):0x0;
}
AliRun* AliRunLoader::GetAliRun() const
{
if (fEventFolder == 0x0) return 0x0;
TObject *obj = fEventFolder->FindObject(fgkGAliceName);
return (obj)?dynamic_cast<AliRun*>(obj):0x0;
}
Int_t AliRunLoader::WriteHeader(Option_t* opt)
{
AliDebug(1, "WRITING HEADER");
TTree* tree = TreeE();
if ( tree == 0x0)
{
AliWarning("Can not find Header Tree in Folder");
return 0;
}
if (fGAFile->IsWritable() == kFALSE)
{
AliError(Form("File %s is not writable",fGAFile->GetName()));
return 1;
}
TObject* obj = fGAFile->Get(fgkHeaderContainerName);
if (obj)
{
TString tmp(opt);
if(tmp.Contains("OVERWRITE",TString::kIgnoreCase) == 0)
{
AliError("Tree already exisists. Use option \"OVERWRITE\" to overwrite previous data");
return 3;
}
}
fGAFile->cd();
tree->SetDirectory(fGAFile);
tree->Write(0,TObject::kOverwrite);
AliDebug(1, "WRITTEN\n\n");
return 0;
}
Int_t AliRunLoader::WriteTrigger(Option_t* opt)
{
AliDebug( 1, "WRITING TRIGGER" );
TTree* tree = TreeCT();
if ( tree == 0x0) {
AliWarning("Can not find Trigger Tree in Folder");
return 0;
}
TFile* file = gROOT->GetFile( gSystem->ConcatFileName( fUnixDirName.Data(), fgkDefaultTriggerFileName.Data() ) ) ;
if( !file || !file->IsOpen() ) {
AliError( "can't write Trigger, file is not open" );
return kFALSE;
}
TObject* obj = file->Get( fgkTriggerContainerName );
if( obj ) {
TString tmp(opt);
if( tmp.Contains( "OVERWRITE", TString::kIgnoreCase ) == 0) {
AliError( "Tree already exisists. Use option \"OVERWRITE\" to overwrite previous data" );
return 3;
}
}
file->cd();
fCTrigger->Write( 0, TObject::kOverwrite );
tree->Write( 0, TObject::kOverwrite );
file->Flush();
AliDebug(1, "WRITTEN\n\n");
return 0;
}
Int_t AliRunLoader::WriteAliRun(Option_t* )
{
fGAFile->cd();
if (GetAliRun()) GetAliRun()->Write();
return 0;
}
Int_t AliRunLoader::WriteKinematics(Option_t* opt)
{
return fKineDataLoader->GetBaseLoader(0)->WriteData(opt);
}
Int_t AliRunLoader::WriteTrackRefs(Option_t* opt)
{
return fTrackRefsDataLoader->GetBaseLoader(0)->WriteData(opt);
}
Int_t AliRunLoader::WriteHits(Option_t* opt)
{
Int_t res;
Int_t result = 0;
TIter next(fLoaders);
AliLoader *loader;
while((loader = (AliLoader*)next()))
{
res = loader->WriteHits(opt);
if (res)
{
AliError(Form("Failed to write hits for %s (%d)",loader->GetDetectorName().Data(),res));
result = 1;
}
}
return result;
}
Int_t AliRunLoader::WriteSDigits(Option_t* opt)
{
Int_t res;
Int_t result = 0;
TIter next(fLoaders);
AliLoader *loader;
while((loader = (AliLoader*)next()))
{
res = loader->WriteSDigits(opt);
if (res)
{
AliError(Form("Failed to write summable digits for %s.",loader->GetDetectorName().Data()));
result = 1;
}
}
return result;
}
Int_t AliRunLoader::WriteDigits(Option_t* opt)
{
Int_t res;
Int_t result = 0;
TIter next(fLoaders);
AliLoader *loader;
while((loader = (AliLoader*)next()))
{
res = loader->WriteDigits(opt);
if (res)
{
AliError(Form("Failed to write digits for %s.",loader->GetDetectorName().Data()));
result = 1;
}
}
return result;
}
Int_t AliRunLoader::WriteRecPoints(Option_t* opt)
{
Int_t res;
Int_t result = 0;
TIter next(fLoaders);
AliLoader *loader;
while((loader = (AliLoader*)next()))
{
res = loader->WriteRecPoints(opt);
if (res)
{
AliError(Form("Failed to write Reconstructed Points for %s.",
loader->GetDetectorName().Data()));
result = 1;
}
}
return result;
}
Int_t AliRunLoader::WriteTracks(Option_t* opt)
{
Int_t res;
Int_t result = 0;
TIter next(fLoaders);
AliLoader *loader;
while((loader = (AliLoader*)next()))
{
res = loader->WriteTracks(opt);
if (res)
{
AliError(Form("Failed to write Tracks for %s.",
loader->GetDetectorName().Data()));
result = 1;
}
}
return result;
}
Int_t AliRunLoader::WriteRunLoader(Option_t* )
{
CdGAFile();
this->Write(0,TObject::kOverwrite);
return 0;
}
Int_t AliRunLoader::SetEventFolderName(const TString& name)
{
if (name.IsNull())
{
AliError("Name is empty");
return 1;
}
TObject* obj = AliConfig::Instance()->GetTopFolder()->FindObject(name);
if(obj)
{
TFolder* fold = dynamic_cast<TFolder*>(obj);
if (fold == 0x0)
{
AliError("Such a obejct already exists in top alice folder and it is not a folder.");
return 2;
}
if (fEventFolder == fold)
{
return 0;
}
else
{
AliError("Such a folder already exists in top alice folder. Can not mount.");
return 2;
}
}
if (fEventFolder)
{
fEventFolder->SetName(name);
return 0;
}
if (fKineDataLoader == 0x0)
fKineDataLoader = new AliDataLoader(fgkDefaultKineFileName,fgkKineContainerName,"Kinematics");
if ( fTrackRefsDataLoader == 0x0)
fTrackRefsDataLoader = new AliDataLoader(fgkDefaultTrackRefsFileName,fgkTrackRefsContainerName,"Track References");
AliDebug(1, Form("Creating new event folder named %s",name.Data()));
fEventFolder = AliConfig::Instance()->BuildEventFolder(name,"Event Folder");
fEventFolder->Add(this);
TIter next(fLoaders);
AliLoader *loader;
while((loader = (AliLoader*)next()))
{
loader->Register(fEventFolder);
}
fKineDataLoader->SetEventFolder(GetEventFolder());
fTrackRefsDataLoader->SetEventFolder(GetEventFolder());
fKineDataLoader->SetFolder(GetEventFolder());
fTrackRefsDataLoader->SetFolder(GetEventFolder());
fEventFolder->SetOwner();
return 0;
}
void AliRunLoader::AddLoader(AliLoader* loader)
{
if (loader == 0x0)
{
AliError("Parameter is NULL");
return;
}
loader->SetDirName(fUnixDirName);
if (fEventFolder) loader->SetEventFolder(fEventFolder);
fLoaders->Add(loader);
}
void AliRunLoader::AddLoader(AliDetector* det)
{
if (det == 0x0) return;
AliLoader* get = det->GetLoader();
if (get == 0x0) get = det->MakeLoader(fEventFolder->GetName());
if (get)
{
AliDebug(1, Form("Detector: %s Loader : %s",det->GetName(),get->GetName()));
AddLoader(get);
}
}
AliLoader* AliRunLoader::GetLoader(const char* detname) const
{
return (AliLoader*)fLoaders->FindObject(detname);
}
AliLoader* AliRunLoader::GetLoader(AliDetector* det) const
{
if(det == 0x0) return 0x0;
TString getname(det->GetName());
getname+="Loader";
AliDebug(1, Form(" Loader name is %s",getname.Data()));
return GetLoader(getname);
}
void AliRunLoader::CleanFolders()
{
CleanDetectors();
CleanHeader();
CleanKinematics();
CleanTrigger();
}
void AliRunLoader::CleanDetectors()
{
TIter next(fLoaders);
AliLoader *loader;
while((loader = (AliLoader*)next()))
{
loader->CleanFolders();
}
}
void AliRunLoader::RemoveEventFolder()
{
if (fEventFolder == 0x0) return;
fEventFolder->SetOwner(kFALSE);
fEventFolder->Remove(this);
AliConfig::Instance()->GetTopFolder()->SetOwner();
AliConfig::Instance()->GetTopFolder()->Remove(fEventFolder);
delete fEventFolder;
}
void AliRunLoader::SetGAliceFile(TFile* gafile)
{
fGAFile = gafile;
}
Int_t AliRunLoader::LoadHits(Option_t* detectors,Option_t* opt)
{
AliDebug(1, "Loading Hits");
TObjArray* loaders;
TObjArray arr;
const char* oAll = strstr(detectors,"all");
if (oAll)
{
AliDebug(1, "Option is All");
loaders = fLoaders;
}
else
{
GetListOfDetectors(detectors,arr);
loaders = &arr;
}
AliDebug(1, Form("For detectors. Number of detectors chosen for loading %d",loaders->GetEntries()));
TIter next(loaders);
AliLoader *loader;
while((loader = (AliLoader*)next()))
{
AliDebug(1, Form(" Calling LoadHits(%s) for %s",opt,loader->GetName()));
loader->LoadHits(opt);
}
AliDebug(1, "Done");
return 0;
}
Int_t AliRunLoader::LoadSDigits(Option_t* detectors,Option_t* opt)
{
TObjArray* loaders;
TObjArray arr;
const char* oAll = strstr(detectors,"all");
if (oAll)
{
loaders = fLoaders;
}
else
{
GetListOfDetectors(detectors,arr);
loaders = &arr;
}
TIter next(loaders);
AliLoader *loader;
while((loader = (AliLoader*)next()))
{
loader->LoadSDigits(opt);
}
return 0;
}
Int_t AliRunLoader::LoadDigits(Option_t* detectors,Option_t* opt)
{
TObjArray* loaders;
TObjArray arr;
const char* oAll = strstr(detectors,"all");
if (oAll)
{
loaders = fLoaders;
}
else
{
GetListOfDetectors(detectors,arr);
loaders = &arr;
}
TIter next(loaders);
AliLoader *loader;
while((loader = (AliLoader*)next()))
{
loader->LoadDigits(opt);
}
return 0;
}
Int_t AliRunLoader::LoadRecPoints(Option_t* detectors,Option_t* opt)
{
TObjArray* loaders;
TObjArray arr;
const char* oAll = strstr(detectors,"all");
if (oAll)
{
loaders = fLoaders;
}
else
{
GetListOfDetectors(detectors,arr);
loaders = &arr;
}
TIter next(loaders);
AliLoader *loader;
while((loader = (AliLoader*)next()))
{
loader->LoadRecPoints(opt);
}
return 0;
}
Int_t AliRunLoader::LoadRecParticles(Option_t* detectors,Option_t* opt)
{
TObjArray* loaders;
TObjArray arr;
const char* oAll = strstr(detectors,"all");
if (oAll)
{
loaders = fLoaders;
}
else
{
GetListOfDetectors(detectors,arr);
loaders = &arr;
}
TIter next(loaders);
AliLoader *loader;
while((loader = (AliLoader*)next()))
{
loader->LoadRecParticles(opt);
}
return 0;
}
Int_t AliRunLoader::LoadTracks(Option_t* detectors,Option_t* opt)
{
TObjArray* loaders;
TObjArray arr;
const char* oAll = strstr(detectors,"all");
if (oAll)
{
loaders = fLoaders;
}
else
{
GetListOfDetectors(detectors,arr);
loaders = &arr;
}
TIter next(loaders);
AliLoader *loader;
while((loader = (AliLoader*)next()))
{
loader->LoadTracks(opt);
}
return 0;
}
void AliRunLoader::UnloadHits(Option_t* detectors)
{
TObjArray* loaders;
TObjArray arr;
const char* oAll = strstr(detectors,"all");
if (oAll)
{
loaders = fLoaders;
}
else
{
GetListOfDetectors(detectors,arr);
loaders = &arr;
}
TIter next(loaders);
AliLoader *loader;
while((loader = (AliLoader*)next()))
{
loader->UnloadHits();
}
}
void AliRunLoader::UnloadSDigits(Option_t* detectors)
{
TObjArray* loaders;
TObjArray arr;
const char* oAll = strstr(detectors,"all");
if (oAll)
{
loaders = fLoaders;
}
else
{
GetListOfDetectors(detectors,arr);
loaders = &arr;
}
TIter next(loaders);
AliLoader *loader;
while((loader = (AliLoader*)next()))
{
loader->UnloadSDigits();
}
}
void AliRunLoader::UnloadDigits(Option_t* detectors)
{
TObjArray* loaders;
TObjArray arr;
const char* oAll = strstr(detectors,"all");
if (oAll)
{
loaders = fLoaders;
}
else
{
GetListOfDetectors(detectors,arr);
loaders = &arr;
}
TIter next(loaders);
AliLoader *loader;
while((loader = (AliLoader*)next()))
{
loader->UnloadDigits();
}
}
void AliRunLoader::UnloadRecPoints(Option_t* detectors)
{
TObjArray* loaders;
TObjArray arr;
const char* oAll = strstr(detectors,"all");
if (oAll)
{
loaders = fLoaders;
}
else
{
GetListOfDetectors(detectors,arr);
loaders = &arr;
}
TIter next(loaders);
AliLoader *loader;
while((loader = (AliLoader*)next()))
{
loader->UnloadRecPoints();
}
}
void AliRunLoader::UnloadAll(Option_t* detectors)
{
TObjArray* loaders;
TObjArray arr;
const char* oAll = strstr(detectors,"all");
if (oAll)
{
loaders = fLoaders;
}
else
{
GetListOfDetectors(detectors,arr);
loaders = &arr;
}
TIter next(loaders);
AliLoader *loader;
while((loader = (AliLoader*)next()))
{
loader->UnloadAll();
}
}
void AliRunLoader::UnloadTracks(Option_t* detectors)
{
TObjArray* loaders;
TObjArray arr;
const char* oAll = strstr(detectors,"all");
if (oAll)
{
loaders = fLoaders;
}
else
{
GetListOfDetectors(detectors,arr);
loaders = &arr;
}
TIter next(loaders);
AliLoader *loader;
while((loader = (AliLoader*)next()))
{
loader->UnloadTracks();
}
}
void AliRunLoader::UnloadRecParticles(Option_t* detectors)
{
TObjArray* loaders;
TObjArray arr;
const char* oAll = strstr(detectors,"all");
if (oAll)
{
loaders = fLoaders;
}
else
{
GetListOfDetectors(detectors,arr);
loaders = &arr;
}
TIter next(loaders);
AliLoader *loader;
while((loader = (AliLoader*)next()))
{
loader->UnloadRecParticles();
}
}
AliRunLoader* AliRunLoader::GetRunLoader(const char* eventfoldername)
{
TFolder* evfold= dynamic_cast<TFolder*>(AliConfig::Instance()->GetTopFolder()->FindObject(eventfoldername));
if (evfold == 0x0)
{
return 0x0;
}
AliRunLoader* runget = dynamic_cast<AliRunLoader*>(evfold->FindObject(AliRunLoader::fgkRunLoaderName));
return runget;
}
AliLoader* AliRunLoader::GetDetectorLoader(const char* detname, const char* eventfoldername)
{
AliRunLoader* runLoader = GetRunLoader(eventfoldername);
if (!runLoader) {
AliErrorClass("No run loader found");
return NULL;
}
return runLoader->GetDetectorLoader(detname);
}
AliLoader* AliRunLoader::GetDetectorLoader(const char* detname)
{
char loadername[256];
snprintf(loadername, 255, "%sLoader", detname);
AliLoader* loader = GetLoader(loadername);
if (!loader) {
AliError(Form("No loader for %s found", detname));
return NULL;
}
return loader;
}
TTree* AliRunLoader::GetTreeH(const char* detname, Bool_t maketree, const char* eventfoldername)
{
AliLoader* loader = GetDetectorLoader(detname,eventfoldername);
if (!loader) return NULL;
if (!loader->TreeH() && maketree) loader->MakeTree("H");
return loader->TreeH();
}
TTree* AliRunLoader::GetTreeH(const char* detname, Bool_t maketree)
{
AliLoader* loader = GetDetectorLoader(detname);
if (!loader) return NULL;
if (!loader->TreeH() && maketree) loader->MakeTree("H");
return loader->TreeH();
}
TTree* AliRunLoader::GetTreeS(const char* detname, Bool_t maketree,const char* eventfoldername)
{
AliLoader* loader = GetDetectorLoader(detname,eventfoldername);
if (!loader) return NULL;
if (!loader->TreeS() && maketree) loader->MakeTree("S");
return loader->TreeS();
}
TTree* AliRunLoader::GetTreeS(const char* detname, Bool_t maketree)
{
AliLoader* loader = GetDetectorLoader(detname);
if (!loader) return NULL;
if (!loader->TreeS() && maketree) loader->MakeTree("S");
return loader->TreeS();
}
TTree* AliRunLoader::GetTreeD(const char* detname, Bool_t maketree,const char* eventfoldername)
{
AliLoader* loader = GetDetectorLoader(detname,eventfoldername);
if (!loader) return NULL;
if (!loader->TreeD() && maketree) loader->MakeTree("D");
return loader->TreeD();
}
TTree* AliRunLoader::GetTreeD(const char* detname, Bool_t maketree)
{
AliLoader* loader = GetDetectorLoader(detname);
if (!loader) return NULL;
if (!loader->TreeD() && maketree) loader->MakeTree("D");
return loader->TreeD();
}
TTree* AliRunLoader::GetTreeR(const char* detname, Bool_t maketree,const char* eventfoldername)
{
AliLoader* loader = GetDetectorLoader(detname,eventfoldername);
if (!loader) return NULL;
if (!loader->TreeR() && maketree) loader->MakeTree("R");
return loader->TreeR();
}
TTree* AliRunLoader::GetTreeR(const char* detname, Bool_t maketree)
{
AliLoader* loader = GetDetectorLoader(detname);
if (!loader) return NULL;
if (!loader->TreeR() && maketree) loader->MakeTree("R");
return loader->TreeR();
}
TTree* AliRunLoader::GetTreeT(const char* detname, Bool_t maketree,const char* eventfoldername)
{
AliLoader* loader = GetDetectorLoader(detname,eventfoldername);
if (!loader) return NULL;
if (!loader->TreeT() && maketree) loader->MakeTree("T");
return loader->TreeT();
}
TTree* AliRunLoader::GetTreeT(const char* detname, Bool_t maketree)
{
AliLoader* loader = GetDetectorLoader(detname);
if (!loader) return NULL;
if (!loader->TreeT() && maketree) loader->MakeTree("T");
return loader->TreeT();
}
TTree* AliRunLoader::GetTreeP(const char* detname, Bool_t maketree,const char* eventfoldername)
{
AliLoader* loader = GetDetectorLoader(detname,eventfoldername);
if (!loader) return NULL;
if (!loader->TreeP() && maketree) loader->MakeTree("P");
return loader->TreeP();
}
TTree* AliRunLoader::GetTreeP(const char* detname, Bool_t maketree)
{
AliLoader* loader = GetDetectorLoader(detname);
if (!loader) return NULL;
if (!loader->TreeP() && maketree) loader->MakeTree("P");
return loader->TreeP();
}
void AliRunLoader::CdGAFile()
{
if(fGAFile) fGAFile->cd();
}
void AliRunLoader::GetListOfDetectors(const char * namelist,TObjArray& pointerarray) const
{
char buff[10];
char dets [200];
strncpy(dets,namelist,199);
char* pdet = dets;
Int_t tmp;
for(;;)
{
tmp = sscanf(pdet,"%9s",buff);
if ( (buff[0] == 0) || (tmp == 0) ) break;
pdet = strstr(pdet,buff) + strlen(buff);
TString getname(buff);
getname+="Loader";
AliLoader* loader = GetLoader(getname);
if (loader)
{
pointerarray.Add(loader);
}
else
{
AliError(Form("Can not find Loader for %s",buff));
}
buff[0] = 0;
}
}
void AliRunLoader::Clean(const TString& name)
{
if (GetEventFolder() == 0x0) return;
TObject* obj = GetEventFolder()->FindObject(name);
if(obj)
{
AliDebug(1, Form("name=%s, cleaning %s.",GetName(),name.Data()));
GetEventFolder()->Remove(obj);
delete obj;
obj = 0x0;
}
}
void AliRunLoader::SetCompressionLevel(Int_t cl)
{
if (fGAFile) fGAFile->SetCompressionLevel(cl);
SetKineComprLevel(cl);
SetTrackRefsComprLevel(cl);
TIter next(fLoaders);
AliLoader *loader;
while((loader = (AliLoader*)next()))
{
loader->SetCompressionLevel(cl);
}
}
void AliRunLoader::SetKineComprLevel(Int_t cl)
{
fKineDataLoader->SetCompressionLevel(cl);
}
void AliRunLoader::SetTrackRefsComprLevel(Int_t cl)
{
fTrackRefsDataLoader->SetCompressionLevel(cl);
}
void AliRunLoader::UnloadHeader()
{
CleanHeader();
fHeader = 0x0;
}
void AliRunLoader::UnloadTrigger()
{
CleanTrigger();
delete fCTrigger;
fCTrigger = 0x0;
}
void AliRunLoader::UnloadKinematics()
{
fKineDataLoader->GetBaseLoader(0)->Unload();
}
void AliRunLoader::UnloadTrackRefs()
{
fTrackRefsDataLoader->GetBaseLoader(0)->Unload();
}
void AliRunLoader::UnloadgAlice()
{
if (gAlice == GetAliRun())
{
AliDebug(1, "Set gAlice = 0x0");
gAlice = 0x0;
}
AliRun* alirun = GetAliRun();
if (GetEventFolder()) GetEventFolder()->Remove(alirun);
delete alirun;
}
void AliRunLoader::MakeTrackRefsContainer()
{
fTrackRefsDataLoader->MakeTree();
}
Int_t AliRunLoader::LoadTrackRefs(Option_t* option)
{
return fTrackRefsDataLoader->GetBaseLoader(0)->Load(option);
}
void AliRunLoader::SetDirName(TString& dirname)
{
if (dirname.IsNull()) return;
fUnixDirName = dirname;
fKineDataLoader->SetDirName(dirname);
fTrackRefsDataLoader->SetDirName(dirname);
TIter next(fLoaders);
AliLoader *loader;
while((loader = (AliLoader*)next()))
{
loader->SetDirName(dirname);
}
}
Int_t AliRunLoader::GetFileOffset() const
{
return Int_t(fCurrentEvent/fNEventsPerFile);
}
const TString AliRunLoader::SetFileOffset(const TString& fname)
{
Long_t offset = (Long_t)GetFileOffset();
if (offset < 1) return fname;
TString soffset;
soffset += offset;
TString dotroot(".root");
const TString& offfsetdotroot = offset + dotroot;
TString out = fname;
out = out.ReplaceAll(dotroot,offfsetdotroot);
AliDebug(1, Form(" in=%s out=%s",fname.Data(),out.Data()));
return out;
}
void AliRunLoader::SetDigitsFileNameSuffix(const TString& suffix)
{
TIter next(fLoaders);
AliLoader *loader;
while((loader = (AliLoader*)next()))
{
loader->SetDigitsFileNameSuffix(suffix);
}
}
TString AliRunLoader::GetFileName() const
{
TString result;
if (fGAFile == 0x0) return result;
result = fGAFile->GetName();
return result;
}
void AliRunLoader::SetDetectorAddresses()
{
if (GetAliRun()==0x0) return;
TIter next(GetAliRun()->Modules());
AliModule* mod;
while((mod = (AliModule*)next()))
{
AliDetector* det = dynamic_cast<AliDetector*>(mod);
if (det) det->SetTreeAddress();
}
}
void AliRunLoader::Synchronize()
{
TIter next(fLoaders);
AliLoader *loader;
while((loader = (AliLoader*)next()))
{
loader->Synchronize();
}
fKineDataLoader->Synchronize();
fTrackRefsDataLoader->Synchronize();
TFile* file = gROOT->GetFile( gSystem->ConcatFileName( fUnixDirName.Data(), fgkDefaultTriggerFileName.Data() ) ) ;
if( file ) file->Flush();
if (fGAFile) fGAFile->Flush();
}