#include "AliHeader.h"
#include "AliStack.h"
#include "AliDetector.h"
-#include "AliRunDataStorage.h"
-#include "AliRunDataFile.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():
fGAFile(0x0),
fHeader(0x0),
fStack(0x0),
+ fCTrigger(0x0),
fKineDataLoader(0x0),
fTrackRefsDataLoader(0x0),
fNEventsPerFile(1),
fGAFile(0x0),
fHeader(0x0),
fStack(0x0),
+ fCTrigger(0x0),
fKineDataLoader(new AliDataLoader(fgkDefaultKineFileName,fgkKineContainerName,"Kinematics")),
fTrackRefsDataLoader(new AliDataLoader(fgkDefaultTrackRefsFileName,fgkTrackRefsContainerName,"Track References")),
fNEventsPerFile(1),
fGAFile(0x0),
fHeader(0x0),
fStack(0x0),
+ fCTrigger(0x0),
fKineDataLoader(0x0),
fTrackRefsDataLoader(0x0),
fNEventsPerFile(0),
RemoveEventFolder();
//fEventFolder is deleted by the way of removing - TopAliceFolder owns it
+ if( fCTrigger ) delete fCTrigger;
delete fHeader;
delete fStack;
delete fGAFile;
fGAFile(0x0),
fHeader(0x0),
fStack(0x0),
+ fCTrigger(0x0),
fKineDataLoader(new AliDataLoader(fgkDefaultKineFileName,fgkKineContainerName,"Kinematics")),
fTrackRefsDataLoader(new AliDataLoader(fgkDefaultTrackRefsFileName,fgkTrackRefsContainerName,"Track References")),
fNEventsPerFile(1),
{
//Gets event number evno
//Reloads all data properly
- if (fCurrentEvent == evno) return 0;
+//PH if (fCurrentEvent == evno) return 0;
if (evno < 0)
{
//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
- {
- AliWarning("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();
}
//Read Kinematics if loaded
- fKineDataLoader->GetEvent();
+ 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->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;
}
/**************************************************************************/
-const TObject* AliRunLoader::GetRunObject(const char* name) const
+AliCDBEntry* AliRunLoader::GetCDBEntry(const char* name) const
{
-//Get an object from the run data storage
+//Get an AliCDBEntry from the run data storage
- if (!AliRunDataStorage::Instance()) {
- AliWarning("No run data storage defined. Using AliRunDataFile.");
- new AliRunDataFile;
+ if ( !(AliCDBManager::Instance()->IsDefaultStorageSet()) ) {
+ AliError("No run data storage defined!");
+ return 0x0;
}
- return AliRunDataStorage::Instance()->Get(name, GetEventNumber());
+ return AliCDBManager::Instance()->GetDefaultStorage()->Get(name, GetHeader()->GetRun());
+
}
/**************************************************************************/
}
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
//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
AliDebugClass(1, Form("Dir name is : %s",dirname.Data()));
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(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)
{
- AliError("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 ) {
+ file = TFile::Open( gSystem->ConcatFileName( fUnixDirName.Data(), fgkDefaultTriggerFileName.Data() ), "RECREATE" ) ;
+ }
+
+ 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()))
}
/**************************************************************************/
+Int_t AliRunLoader::LoadTrigger(Option_t* option)
+{
+ //Load treeCT
+
+ if( TreeCT() ) {
+ AliWarning("Trigger is already loaded. Nothing done");
+ return 0;
+ }
+
+ if( GetEventFolder() == 0x0 ) {
+ AliError("Event folder not specified yet");
+ return 1;
+ }
+ // get the CTP Trigger output file and tree
+ TString trgfile = gSystem->ConcatFileName( fUnixDirName.Data(),
+ fgkDefaultTriggerFileName.Data() );
+ 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
}
if (fStack)
{
- retval = fStack->GetEvent();
+ fStack->ConnectTree(TreeK());
+ retval = fStack->GetEvent();
if ( retval == kFALSE)
{
AliError("Error occured while loading kinamatics tree.");
}
/**************************************************************************/
+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
{
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*/)
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()))
CleanDetectors();
CleanHeader();
CleanKinematics();
+ CleanTrigger();
}
/**************************************************************************/
AliDebug(1, Form("name=%s, cleaning %s.",GetName(),name.Data()));
GetEventFolder()->Remove(obj);
delete obj;
+ obj = 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
fKineDataLoader->Synchronize();
fTrackRefsDataLoader->Synchronize();
+
+ TFile* file = gROOT->GetFile( gSystem->ConcatFileName( fUnixDirName.Data(), fgkDefaultTriggerFileName.Data() ) ) ;
+ if( file ) file->Flush();
if (fGAFile) fGAFile->Flush();
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff