#include <TBranch.h>
#include <TFile.h>
#include <TFolder.h>
-#include <TGeometry.h>
#include <TObjArray.h>
#include <TString.h>
class TTask;
#include <TTree.h>
+#include "AliLog.h"
#include "AliRun.h"
#include "AliConfig.h"
#include "AliLoader.h"
#include "AliHeader.h"
#include "AliStack.h"
#include "AliDetector.h"
-#include "AliRunLoader.h"
+#include "AliCDBManager.h"
+#include "AliCDBLocal.h"
+#include "AliCentralTrigger.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();//force to build the folder structure
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(".")
{
//ctor
}
/**************************************************************************/
-AliRunLoader::AliRunLoader(const AliRunLoader &rl):
- TNamed(rl),
- fLoaders(0x0),
- fEventFolder(0x0),
- fCurrentEvent(0),
- fGAFile(0x0),
- fHeader(0x0),
- fStack(0x0),
- fKineDataLoader(0x0),
- fTrackRefsDataLoader(0x0),
- fNEventsPerFile(0),
- fUnixDirName(".")
-{
- //
- // Copy ctor
- //
- rl.Copy(*this);
-}
-/**************************************************************************/
-
AliRunLoader::~AliRunLoader()
{
//dtor
- if (fgRunLoader == this) fgRunLoader = 0x0;
+
UnloadHeader();
UnloadgAlice();
-
+ if (fgRunLoader == this) fgRunLoader = 0x0;
if(fLoaders) {
fLoaders->SetOwner();
delete fLoaders;
RemoveEventFolder();
//fEventFolder is deleted by the way of removing - TopAliceFolder owns it
- delete fHeader;
+ if( fCTrigger ) delete fCTrigger;
delete fStack;
delete fGAFile;
}
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(".")
{
//ctor
if(topfolder == 0x0)
{
TString errmsg("Parameter is NULL");
- Error("AliRunLoader(TFolder*)","%s",errmsg.Data());
+ AliError(errmsg.Data());
throw errmsg;
return;
}
errmsg+=fEventFolder->GetName();
errmsg+=" object named "+fgkRunLoaderName+" already exists. I am confused ...";
- Error("AliRunLoader(const char*)","%s",errmsg.Data());
+ AliError(errmsg.Data());
throw errmsg;
return;//never reached
}
fEventFolder->Add(this);//put myself to the folder to accessible for all
}
-/**************************************************************************/
-void AliRunLoader::Copy(TObject &) const
-{
- Fatal("Copy","Not implemented");
-}
/**************************************************************************/
Int_t AliRunLoader::GetEvent(Int_t evno)
{
//Gets event number evno
//Reloads all data properly
- if (fCurrentEvent == evno) return 0;
+//PH if (fCurrentEvent == evno) return 0;
if (evno < 0)
{
- Error("GetEvent","Can not give the event with negative number");
+ AliError("Can not give the event with negative number");
return 4;
}
if (evno >= GetNumberOfEvents())
{
- Error("GetEvent","There is no event with number %d",evno);
+ AliError(Form("There is no event with number %d",evno));
return 3;
}
- if (GetDebug())
- {
- Info("GetEvent",">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
- Info("GetEvent",">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
- Info("GetEvent",">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
- Info("GetEvent"," GETTING EVENT %d",evno);
- Info("GetEvent",">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
- Info("GetEvent",">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
- Info("GetEvent",">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
- }
+ AliDebug(1, ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
+ AliDebug(1, ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
+ AliDebug(1, ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
+ AliDebug(1, Form(" GETTING EVENT %d",evno));
+ AliDebug(1, ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
+ AliDebug(1, ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
+ AliDebug(1, ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
fCurrentEvent = evno;
retval = TreeE()->GetEvent(fCurrentEvent);
if ( retval == 0)
{
- Error("GetEvent","Cannot find event: %d\n ",fCurrentEvent);
+ AliError(Form("Cannot find event: %d\n ",fCurrentEvent));
return 5;
}
}
//Reload stack (If header was loaded)
if (TreeE()) fStack = GetHeader()->Stack();
//Set event folder in stack (it does not mean that we read kinematics from file)
- if (fStack)
- {
- fStack->SetEventFolderName(fEventFolder->GetName());
- }
- else
- {
- Warning("GetEvent","Stack not found in header");
+ 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)
{
- Error("GetEvent","Error occured while setting event %d",evno);
+ AliError(Form("Error occured while setting event %d",evno));
return 1;
}
retval = fTrackRefsDataLoader->GetEvent();
if (retval)
{
- Error("GetEvent","Error occured while GetEvent for Track References. Event %d",evno);
+ AliError(Form("Error occured while GetEvent for Track References. Event %d",evno));
return 2;
}
//Read Kinematics if loaded
- fKineDataLoader->GetEvent();
+ retval = fKineDataLoader->GetEvent();
if (retval)
{
- Error("GetEvent","Error occured while GetEvent for Kinematics. Event %d",evno);
+ AliError(Form("Error occured while GetEvent for Kinematics. Event %d",evno));
return 2;
}
- if (fStack && fKineDataLoader->GetBaseLoader(0)->IsLoaded()) fStack->GetEvent();
-
+ 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;
+ }
+ }
+
//Trigger data reloading in all loaders
TIter next(fLoaders);
AliLoader *loader;
retval = loader->GetEvent();
if (retval)
{
- Error("GetEvent","Error occured while getting event for %s. Event %d.",
- loader->GetDetectorName().Data(), evno);
+ AliError(Form("Error occured while getting event for %s. Event %d.",
+ loader->GetDetectorName().Data(), evno));
return 3;
}
}
retval = fKineDataLoader->SetEvent();
if (retval)
{
- Error("SetEvent","SetEvent for Kinamtics Data Loader retutned error.");
+ AliError("SetEvent for Kinamtics Data Loader retutned error.");
return retval;
}
retval = fTrackRefsDataLoader->SetEvent();
if (retval)
{
- Error("SetEvent","SetEvent for Track References Data Loader retutned error.");
+ AliError("SetEvent for Track References Data Loader retutned error.");
return retval;
}
retval = loader->SetEvent();
if (retval)
{
- Error("SetEvent","SetEvent for %s Data Loader retutned error.",loader->GetName());
+ AliError(Form("SetEvent for %s Data Loader retutned error.",loader->GetName()));
return retval;
}
}
return SetEvent();
}
+/**************************************************************************/
+AliCDBEntry* AliRunLoader::GetCDBEntry(const char* name) const
+{
+//Get an AliCDBEntry from the run data storage
+
+ 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)
//in case of error returns NULL
static const TString kwebaddress("http://alisoft.cern.ch/people/skowron/codedoc/split/index.html");
- if (AliLoader::GetDebug())
- ::Info("AliRunLoader::Open",
- "\n\n\nNew I/O strcture: See more info:\n %s\n\n\n",kwebaddress.Data());
+ AliDebugClass(1,Form("\n\n\nNew I/O strcture: See more info:\n %s\n\n\n",kwebaddress.Data()));
AliRunLoader* result = 0x0;
TFolder* fold = dynamic_cast<TFolder*>(obj);
if (fold == 0x0)
{
- ::Error("AliRunLoader::Open","Such a obejct already exists in top alice folder and it is not a folder.");
+ 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)
{
- ::Error("AliRunLoader::Open",
- "Folder %s already exists, and can not find session there. Can not mount.",eventfoldername);
+ AliErrorClass(Form("Folder %s already exists, and can not find session there. Can not mount.",eventfoldername));
return 0x0;
}
if (result->GetFileName().CompareTo(filename) != 0)
{
- ::Error("AliRunLoader::Open","Other file is mounted in demanded folder. Can not mount.");
+ AliErrorClass("Other file is mounted in demanded folder. Can not mount.");
return 0x0;
}
//check if now is demanded (re)creation
if ( AliLoader::TestFileOption(option) == kFALSE)
{
- ::Error("AliRunLoader::Open",
- "Session already exists in folder %s and this session option is %s. Unable to proceed.",
- eventfoldername,option);
+ AliErrorClass(Form("Session already exists in folder %s and this session option is %s. Unable to proceed.",
+ eventfoldername,option));
return 0x0;
}
if ( (tmpstr.CompareTo("update",TString::kIgnoreCase) == 0) &&
(result->fGAFile->IsWritable() == kFALSE) )
{
- ::Error("AliRunLoader::Open",
- "Session already exists in folder %s and is not writable while this session option is %s. Unable to proceed.",
- eventfoldername,option);
+ 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;
}
- ::Warning("AliRunLoader::Open","Session is already opened and mounted in demanded folder");
+ AliWarningClass("Session is already opened and mounted in demanded folder");
+ if (!fgRunLoader) fgRunLoader = result; //PH get access from any place
return result;
} //end of checking in case of existance of object named identically that folder session is being opened
TFile * gAliceFile = TFile::Open(filename,option);//open a file
if (!gAliceFile)
{//null pointer returned
- ::Fatal("AliRunLoader::Open","Can not open file %s.",filename);
+ AliFatalClass(Form("Can not open file %s.",filename));
return 0x0;
}
if (gAliceFile->IsOpen() == kFALSE)
{//pointer to valid object returned but file is not opened
- ::Error("AliRunLoader::Open","Can not open file %s.",filename);
+ AliErrorClass(Form("Can not open file %s.",filename));
return 0x0;
}
//else create new AliRunLoader
if ( AliLoader::TestFileOption(option) )
{
- if (AliLoader::GetDebug())
- ::Info("AliRunLoader::Open","Reading RL from file");
+ AliDebugClass(1, "Reading RL from file");
result = dynamic_cast<AliRunLoader*>(gAliceFile->Get(fgkRunLoaderName));//get the run Loader from the file
if (result == 0x0)
{//didn't get
- ::Error("AliRunLoader::Open","Can not find run-Loader in file %s.",filename);
+ AliErrorClass(Form("Can not find run-Loader in file %s.",filename));
delete gAliceFile;//close the file
return 0x0;
}
Int_t tmp = result->SetEventFolderName(eventfoldername);//mount a event folder
if (tmp)//if SetEvent returned error
{
- ::Error("AliRunLoader::Open","Can not mount event in folder %s.",eventfoldername);
+ AliErrorClass(Form("Can not mount event in folder %s.",eventfoldername));
delete result; //delete run-Loader
delete gAliceFile;//close the file
return 0x0;
}
else
{
- if (AliLoader::GetDebug())
- ::Info("AliRunLoader::Open","Creating new AliRunLoader. Folder name is %s",eventfoldername);
+ AliDebugClass(1, Form("Creating new AliRunLoader. Folder name is %s",eventfoldername));
try
{
result = new AliRunLoader(eventfoldername);
}
catch (TString& errmsg)
{
- ::Error("Open","AliRunLoader constrcutor has thrown exception: %s\n",errmsg.Data());
+ AliErrorClass(Form("AliRunLoader constrcutor has thrown exception: %s\n",errmsg.Data()));
delete result;
delete gAliceFile;//close the file
return 0x0;
//procedure for extracting dir name from the file name
TString fname(filename);
- Int_t nsl = fname.Last('/');//look for slash in file name
+ Int_t nsl = fname.Last('#');//look for hash in file name
TString dirname;
- if (nsl < 0)
- {//slash not found
- Int_t nsl = fname.Last(':');//look for colon e.g. rfio:galice.root
- if (nsl < 0) dirname = ".";//not found
- else dirname = fname.Remove(nsl);//found
- }
- else dirname = fname.Remove(nsl);//slash found
+ if (nsl < 0) {//hash not found
+ nsl = fname.Last('/');// look for slash
+ if (nsl < 0)
+ nsl = fname.Last(':');// look for colon e.g. rfio:galice.root
+ }
+
+ if (nsl < 0) dirname = "./"; // no directory path, use "."
+ else dirname = fname.Remove(nsl+1);// directory path
- if (AliLoader::GetDebug())
- ::Info("AliRunLoader::Open","Dir name is : %s",dirname.Data());
+ AliDebugClass(1, Form("Dir name is : %s",dirname.Data()));
result->SetDirName(dirname);
result->SetGAliceFile(gAliceFile);//set the pointer to gAliceFile
retval = LoadHeader();
if (retval)
{
- Error("GetNumberOfEvents","Error occured while loading header");
+ AliError("Error occured while loading header");
return -1;
}
}
void AliRunLoader::MakeHeader()
{
//Makes header and connects it to header tree (if it exists)
- if (GetDebug()) Info("MakeHeader","");
+ AliDebug(1, "");
if(fHeader == 0x0)
{
- if (GetDebug()) Info("MakeHeader","Creating new Header Object");
+ AliDebug(1, "Creating new Header Object");
fHeader= new AliHeader();
}
TTree* tree = TreeE();
if (tree)
{
- if (GetDebug()) Info("MakeHeader","Got Tree from folder.");
+ AliDebug(1, "Got Tree from folder.");
TBranch* branch = tree->GetBranch(fgkHeaderBranchName);
if (branch == 0x0)
{
- if (GetDebug()) Info("MakeHeader","Creating new branch");
+ AliDebug(1, "Creating new branch");
branch = tree->Branch(fgkHeaderBranchName, "AliHeader", &fHeader, 4000, 0);
branch->SetAutoDelete(kFALSE);
}
else
{
- if (GetDebug()) Info("MakeHeader","Got Branch from Tree");
+ AliDebug(1, "Got Branch from Tree");
branch->SetAddress(&fHeader);
tree->GetEvent(fCurrentEvent);
fStack = fHeader->Stack(); //should be safe - if we created Stack, header returns pointer to the same object
if (fStack)
{
- fStack->SetEventFolderName(fEventFolder->GetName());
- if (TreeK()) fStack->GetEvent();
+ if (TreeK()) {
+ fStack->ConnectTree(TreeK());
+ fStack->GetEvent();
+ }
}
else
{
- if (GetDebug()) Info("MakeHeader","Haeder do not have a stack.");
+ AliDebug(1, "Header does not have a stack.");
}
}
}
- if (GetDebug()) Info("MakeHeader","Exiting MakeHeader method");
+ AliDebug(1, "Exiting MakeHeader method");
}
/**************************************************************************/
if(fStack == 0x0)
{
fStack = new AliStack(10000);
- fStack->SetEventFolderName(fEventFolder->GetName());
}
}
+/**************************************************************************/
+void AliRunLoader::MakeTrigger()
+{
+ // Makes trigger object and connects it to trigger tree (if it exists)
+ 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)
{
//Creates trees
- const char *oK = strstr(option,"K"); //Kine
- const char *oE = strstr(option,"E"); //Header
-
- if(oK && !TreeK())
- {
- if (fKineDataLoader->GetBaseLoader(0)->IsLoaded() == kFALSE)
+ const char *oK = strstr(option,"K"); //Kine
+ const char *oE = strstr(option,"E"); //Header
+ const char *oGG = strstr(option,"GG"); //Central TriGGer
+
+ if(oK)
+ {
+ if (fKineDataLoader->GetBaseLoader(0)->IsLoaded() == kFALSE)
{
- Error("MakeTree(\"K\")","Load Kinematics first");
+ AliError("Load Kinematics first");
}
- else
+ else
{
- fKineDataLoader->MakeTree();
- MakeStack();
- fStack->ConnectTree();
- WriteKinematics("OVERWRITE");
- }
- }
+ if (!TreeK()) {
+ fKineDataLoader->MakeTree();
+ MakeStack();
+ }
+ fStack->ConnectTree(TreeK());
+ WriteKinematics("OVERWRITE");
+ }
+ } // TreeK
if(oE && !TreeE())
{
WriteHeader("OVERWRITE");
}
+ if(oGG && !TreeCT())
+ {
+ // create the CTP Trigger output file and tree
+ 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();
+ // WriteHeader("OVERWRITE");
+ }
+
TIter next(fLoaders);
AliLoader *loader;
while((loader = (AliLoader*)next()))
//Loads gAlice from file
if (GetAliRun())
{
- Warning("LoadgAlice","AliRun is already in folder. Unload first.");
+ AliWarning("AliRun is already in folder. Unload first.");
return 0;
}
AliRun* alirun = dynamic_cast<AliRun*>(fGAFile->Get(fgkGAliceName));
if (alirun == 0x0)
{
- Error("LoadgAlice"," Can not find gAlice in file %s",fGAFile->GetName());
+ AliError(Form("Can not find gAlice in file %s",fGAFile->GetName()));
return 2;
}
alirun->SetRunLoader(this);
if (gAlice)
{
- Warning("LoadgAlice","gAlice already exists. Putting retrived object in folder named %s",
- GetEventFolder()->GetName());
+ AliWarning(Form("gAlice already exists. Putting retrived object in folder named %s",
+ GetEventFolder()->GetName()));
}
else
{
//loads treeE and reads header object for current event
if (TreeE())
{
- Warning("LoadHeader","Header is already loaded. Use ReloadHeader to force reload. Nothing done");
+ AliWarning("Header is already loaded. Use ReloadHeader to force reload. Nothing done");
return 0;
}
if (GetEventFolder() == 0x0)
{
- Error("LoadHeader","Event folder not specified yet");
+ AliError("Event folder not specified yet");
return 1;
}
if (fGAFile == 0x0)
{
- Error("LoadHeader","Session not opened. Use AliRunLoader::Open");
+ AliError("Session not opened. Use AliRunLoader::Open");
return 2;
}
if (fGAFile->IsOpen() == kFALSE)
{
- Error("LoadHeader","Session not opened. Use AliRunLoader::Open");
+ AliError("Session not opened. Use AliRunLoader::Open");
return 2;
}
TTree* tree = dynamic_cast<TTree*>(fGAFile->Get(fgkHeaderContainerName));
if (tree == 0x0)
{
- Error("LoadHeader","Can not find header tree named %s in file %s",
- fgkHeaderContainerName.Data(),fGAFile->GetName());
+ AliError(Form("Can not find header tree named %s in file %s",
+ fgkHeaderContainerName.Data(),fGAFile->GetName()));
return 2;
}
}
/**************************************************************************/
+Int_t AliRunLoader::LoadTrigger(Option_t* option)
+{
+ //Load treeCT
+ 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;
+ }
+ // get the CTP Trigger output file and tree
+ 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)
{
//Loads the kinematics
Int_t retval = fKineDataLoader->GetBaseLoader(0)->Load(option);
if (retval)
{
- Error("LoadKinematics","Error occured while loading kinamatics tree.");
+ AliError("Error occured while loading kinamatics tree.");
return retval;
}
if (fStack)
{
- retval = fStack->GetEvent();
+ fStack->ConnectTree(TreeK());
+ retval = fStack->GetEvent();
if ( retval == kFALSE)
{
- Error("LoadKinematics","Error occured while loading kinamatics tree.");
+ AliError("Error occured while loading kinamatics tree.");
return retval;
}
{
if (file->IsOpen() == kFALSE)
{//pointer is not null but file is not opened
- Warning("OpenDataFile","Pointer to file is not null, but file is not opened");//risky any way
+ AliWarning("Pointer to file is not null, but file is not opened");//risky any way
delete file;
file = 0x0; //proceed with opening procedure
}
else
{
- Warning("OpenDataFile","File %s already opened",filename.Data());
+ AliWarning(Form("File %s already opened",filename.Data()));
return 0;
}
}
{
if(file->IsOpen() == kTRUE)
{
- Warning("OpenDataFile","File %s already opened by sombody else.",file->GetName());
+ AliWarning(Form("File %s already opened by sombody else.",file->GetName()));
return 0;
}
}
file = TFile::Open(filename,opt);
if (file == 0x0)
{//file is null
- Error("LoadKinematics","Can not open file %s",filename.Data());
+ AliError(Form("Can not open file %s",filename.Data()));
return 1;
}
if (file->IsOpen() == kFALSE)
{//file is not opened
- Error("LoadKinematics","Can not open file %s",filename.Data());
+ AliError(Form("Can not open file %s",filename.Data()));
return 1;
}
dir = AliLoader::ChangeDir(file,fCurrentEvent);
if (dir == 0x0)
{
- Error("OpenKineFile","Can not change to root directory in file %s",filename.Data());
+ AliError(Form("Can not change to root directory in file %s",filename.Data()));
return 3;
}
return 0;
TTree* AliRunLoader::TreeE() const
{
//returns the tree from folder; shortcut method
- if (GetDebug() > 10) fEventFolder->ls();
+ if (AliDebugLevel() > 10) fEventFolder->ls();
TObject *obj = fEventFolder->FindObject(fgkHeaderContainerName);
return (obj)?dynamic_cast<TTree*>(obj):0x0;
}
/**************************************************************************/
+TTree* AliRunLoader::TreeCT() const
+{
+ //returns the tree from folder; shortcut method
+ if (AliDebugLevel() > 10) fEventFolder->ls();
+ TObject *obj = fEventFolder->FindObject(fgkTriggerContainerName);
+ return (obj)?dynamic_cast<TTree*>(obj):0x0;
+}
+/**************************************************************************/
+
AliHeader* AliRunLoader::GetHeader() const
{
//returns pointer header object
return fHeader;
}
/**************************************************************************/
+
+AliCentralTrigger* AliRunLoader::GetTrigger() const
+{
+//returns pointer trigger object
+ return fCTrigger;
+}
+
+/**************************************************************************/
TTree* AliRunLoader::TreeK() const
{
}
/**************************************************************************/
-Int_t AliRunLoader::WriteGeometry(Option_t* /*opt*/)
-{
-//writes geometry to the file
- fGAFile->cd();
- TGeometry* geo = GetAliRun()->GetGeometry();
- if (geo == 0x0)
- {
- Error("WriteGeometry","Can not get geometry from gAlice");
- return 1;
- }
- geo->Write();
- return 0;
-}
-/**************************************************************************/
-
Int_t AliRunLoader::WriteHeader(Option_t* opt)
{
//writes treeE
- if (GetDebug()) Info("WriteHeader"," WRITING HEADER");
+ AliDebug(1, "WRITING HEADER");
TTree* tree = TreeE();
if ( tree == 0x0)
{
- Warning("WriteHeader","Can not find Header Tree in Folder");
+ AliWarning("Can not find Header Tree in Folder");
return 0;
}
if (fGAFile->IsWritable() == kFALSE)
{
- Error("WriteHeader","File %s is not writable",fGAFile->GetName());
+ AliError(Form("File %s is not writable",fGAFile->GetName()));
return 1;
}
TString tmp(opt);
if(tmp.Contains("OVERWRITE",TString::kIgnoreCase) == 0)
{//if it is not used - give an error message and return an error code
- Error("WriteHeader","Tree already exisists. Use option \"OVERWRITE\" to overwrite previous data");
+ AliError("Tree already exisists. Use option \"OVERWRITE\" to overwrite previous data");
return 3;
}
}
tree->SetDirectory(fGAFile);
tree->Write(0,TObject::kOverwrite);
- if (GetDebug()) Info("WriteHeader","WRITTEN\n\n");
+ AliDebug(1, "WRITTEN\n\n");
return 0;
}
+
+/**************************************************************************/
+
+Int_t AliRunLoader::WriteTrigger(Option_t* opt)
+{
+ //writes TreeCT
+ 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 ) { //if they exist, see if option OVERWRITE is used
+ TString tmp(opt);
+ if( tmp.Contains( "OVERWRITE", TString::kIgnoreCase ) == 0) {
+ //if it is not used - give an error message and return an error code
+ 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* /*opt*/)
res = loader->WriteHits(opt);
if (res)
{
- Error("WriteHits","Failed to write hits for %s (%d)",loader->GetDetectorName().Data(),res);
+ AliError(Form("Failed to write hits for %s (%d)",loader->GetDetectorName().Data(),res));
result = 1;
}
}
res = loader->WriteSDigits(opt);
if (res)
{
- Error("WriteSDigits","Failed to write summable digits for %s.",loader->GetDetectorName().Data());
+ AliError(Form("Failed to write summable digits for %s.",loader->GetDetectorName().Data()));
result = 1;
}
}
res = loader->WriteDigits(opt);
if (res)
{
- Error("WriteDigits","Failed to write digits for %s.",loader->GetDetectorName().Data());
+ AliError(Form("Failed to write digits for %s.",loader->GetDetectorName().Data()));
result = 1;
}
}
res = loader->WriteRecPoints(opt);
if (res)
{
- Error("WriteRecPoints","Failed to write Reconstructed Points for %s.",
- loader->GetDetectorName().Data());
+ AliError(Form("Failed to write Reconstructed Points for %s.",
+ loader->GetDetectorName().Data()));
result = 1;
}
}
res = loader->WriteTracks(opt);
if (res)
{
- Error("WriteTracks","Failed to write Tracks for %s.",
- loader->GetDetectorName().Data());
+ AliError(Form("Failed to write Tracks for %s.",
+ loader->GetDetectorName().Data()));
result = 1;
}
}
//sets top folder name for this run; of alread
if (name.IsNull())
{
- Error("SetTopFolderName","Name is empty");
+ AliError("Name is empty");
return 1;
}
TFolder* fold = dynamic_cast<TFolder*>(obj);
if (fold == 0x0)
{
- Error("SetTopFolderName","Such a obejct already exists in top alice folder and it is not a folder.");
+ AliError("Such a obejct already exists in top alice folder and it is not a folder.");
return 2;
}
//folder which was found is our folder
}
else
{
- Error("SetTopFolderName","Such a folder already exists in top alice folder. Can not mount.");
+ AliError("Such a folder already exists in top alice folder. Can not mount.");
return 2;
}
}
fTrackRefsDataLoader = new AliDataLoader(fgkDefaultTrackRefsFileName,fgkTrackRefsContainerName,"Track References");
//build the event folder structure
- if (GetDebug()) Info("SetEventFolderName","Creating new event folder named %s",name.Data());
+ AliDebug(1, Form("Creating new event folder named %s",name.Data()));
fEventFolder = AliConfig::Instance()->BuildEventFolder(name,"Event Folder");
fEventFolder->Add(this);//put myself to the folder to accessible for all
- if (Stack()) Stack()->SetEventFolderName(fEventFolder->GetName());
TIter next(fLoaders);
AliLoader *loader;
while((loader = (AliLoader*)next()))
//Adds the Loader for given detector
if (loader == 0x0) //if null shout and exit
{
- Error("AddLoader","Parameter is NULL");
+ AliError("Parameter is NULL");
return;
}
loader->SetDirName(fUnixDirName);
if (get)
{
- if (GetDebug()) Info("AddLoader","Detector: %s Loader : %s",det->GetName(),get->GetName());
+ AliDebug(1, Form("Detector: %s Loader : %s",det->GetName(),get->GetName()));
AddLoader(get);
}
}
if(det == 0x0) return 0x0;
TString getname(det->GetName());
getname+="Loader";
- if (GetDebug()) Info("GetLoader(AliDetector* det)"," Loader name is %s",getname.Data());
+ AliDebug(1, Form(" Loader name is %s",getname.Data()));
return GetLoader(getname);
}
CleanDetectors();
CleanHeader();
CleanKinematics();
+ CleanTrigger();
}
/**************************************************************************/
{
//LoadHits in selected detectors i.e. detectors="ITS TPC TRD" or "all"
- if (GetDebug()) Info("LoadHits","Loading Hits");
+ AliDebug(1, "Loading Hits");
TObjArray* loaders;
TObjArray arr;
const char* oAll = strstr(detectors,"all");
if (oAll)
{
- if (GetDebug()) Info("LoadHits","Option is All");
+ AliDebug(1, "Option is All");
loaders = fLoaders;
}
else
loaders = &arr;//get the pointer array
}
- if (GetDebug()) Info("LoadHits","For detectors. Number of detectors chosen for loading %d",loaders->GetEntries());
+ AliDebug(1, Form("For detectors. Number of detectors chosen for loading %d",loaders->GetEntries()));
TIter next(loaders);
AliLoader *loader;
while((loader = (AliLoader*)next()))
{
- if (GetDebug()) Info("LoadHits"," Calling LoadHits(%s) for %s",opt,loader->GetName());
+ AliDebug(1, Form(" Calling LoadHits(%s) for %s",opt,loader->GetName()));
loader->LoadHits(opt);
}
- if (GetDebug()) Info("LoadHits","Done");
+ AliDebug(1, "Done");
return 0;
}
//run loader object
AliRunLoader* runLoader = GetRunLoader(eventfoldername);
if (!runLoader) {
- ::Error("AliRunLoader::GetDetectorLoader","No run loader found");
+ AliErrorClass("No run loader found");
return NULL;
}
return runLoader->GetDetectorLoader(detname);
sprintf(loadername, "%sLoader", detname);
AliLoader* loader = GetLoader(loadername);
if (!loader) {
- Error("GetDetectorLoader", "No loader for %s found", detname);
+ AliError(Form("No loader for %s found", detname));
return NULL;
}
return loader;
}
else
{
- Error("GetListOfDetectors","Can not find Loader for %s",buff);
+ AliError(Form("Can not find Loader for %s",buff));
}
buff[0] = 0;
TObject* obj = GetEventFolder()->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()));
GetEventFolder()->Remove(obj);
delete obj;
+ obj = 0x0;
}
}
TFolder* topf = AliConfig::Instance()->GetTaskFolder();
if (topf == 0x0)
{
- ::Error("AliRunLoader::GetRunQATask","Can not get task folder from AliConfig");
+ AliErrorClass("Can not get task folder from AliConfig");
return 0x0;
}
TObject* obj = topf->FindObjectAny(AliConfig::Instance()->GetQATaskName());
//removes TreeE from folder and deletes it
// as well as fHeader object
CleanHeader();
- delete fHeader;
fHeader = 0x0;
}
/**************************************************************************/
+void AliRunLoader::UnloadTrigger()
+{
+ //removes TreeCT from folder and deletes it
+ // as well as fHeader object
+ CleanTrigger();
+ delete fCTrigger;
+ fCTrigger = 0x0;
+}
+
+/**************************************************************************/
+
void AliRunLoader::UnloadKinematics()
{
//Unloads Kinematics
//Unloads gAlice
if (gAlice == GetAliRun())
{
- if (GetDebug()) Info("UnloadgAlice","Set gAlice = 0x0");
+ AliDebug(1, "Set gAlice = 0x0");
gAlice = 0x0;//if gAlice is the same that in folder (to be deleted by the way of folder)
}
AliRun* alirun = GetAliRun();
const TString& offfsetdotroot = offset + dotroot;
TString out = fname;
out = out.ReplaceAll(dotroot,offfsetdotroot);
- if (GetDebug()) Info("SetFileOffset"," in=%s out=%s",fname.Data(),out.Data());
+ AliDebug(1, Form(" in=%s out=%s",fname.Data(),out.Data()));
return out;
}
/*****************************************************************************/
fKineDataLoader->Synchronize();
fTrackRefsDataLoader->Synchronize();
+
+ TFile* file = gROOT->GetFile( gSystem->ConcatFileName( fUnixDirName.Data(), fgkDefaultTriggerFileName.Data() ) ) ;
+ if( file ) file->Flush();
if (fGAFile) fGAFile->Flush();
}