// 5.- Set the relevant trigger
// 1.- Get loaders and pointers
- AliRunLoader* runLoader = AliRunLoader::GetRunLoader();
+ AliRunLoader* runLoader = AliRunLoader::Instance();
AliACORDELoader* loader =
(AliACORDELoader* )runLoader->GetLoader( "ACORDELoader" );
loader->LoadDigits("READ");
// Make all memory allocations which can not be done in default constructor.
// Attach the Clusterizer task to the list of EMCAL tasks
- AliRunLoader *rl = AliRunLoader::GetRunLoader();
+ AliRunLoader *rl = AliRunLoader::Instance();
if (rl->GetAliRun() && rl->GetAliRun()->GetDetector("EMCAL"))
fGeom = dynamic_cast<AliEMCAL*>(rl->GetAliRun()->GetDetector("EMCAL"))->GetGeometry();
else
AliEMCALDigitizer::~AliEMCALDigitizer()
{
//dtor
- if (AliRunLoader::GetRunLoader()) {
+ if (AliRunLoader::Instance()) {
AliLoader *emcalLoader=0;
- if ((emcalLoader = AliRunLoader::GetRunLoader()->GetDetectorLoader("EMCAL")))
+ if ((emcalLoader = AliRunLoader::Instance()->GetDetectorLoader("EMCAL")))
emcalLoader->CleanDigitizer();
}
else
//
static int nEMC=0; //max number of digits possible
- AliRunLoader *rl = AliRunLoader::GetRunLoader();
+ AliRunLoader *rl = AliRunLoader::Instance();
AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(rl->GetDetectorLoader("EMCAL"));
Int_t readEvent = event ;
// fManager is data member from AliDigitizer
if(strstr(option,"tim"))
gBenchmark->Start("EMCALDigitizer");
- AliRunLoader *rl = AliRunLoader::GetRunLoader();
+ AliRunLoader *rl = AliRunLoader::Instance();
AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(rl->GetDetectorLoader("EMCAL"));
// Post Digitizer to the white board
{
// Makes all memory allocations
fInit = kTRUE ;
- AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(AliRunLoader::GetRunLoader()->GetDetectorLoader("EMCAL"));
+ AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(AliRunLoader::Instance()->GetDetectorLoader("EMCAL"));
if ( emcalLoader == 0 ) {
Fatal("Init", "Could not obtain the AliEMCALLoader");
return ;
}
// looking for the file which contains SDigits
- AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(AliRunLoader::GetRunLoader()->GetDetectorLoader("EMCAL"));
+ AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(AliRunLoader::Instance()->GetDetectorLoader("EMCAL"));
TString fileName( emcalLoader->GetSDigitsFileName() ) ;
if ( eventFolderName != AliConfig::GetDefaultEventFolderName()) // only if not the default folder name
fileName = fileName.ReplaceAll(".root", "") + "_" + eventFolderName + ".root" ;
printf ("Adding SDigits from %s %s\n", fInputFileNames[index].Data(), fileName.Data()) ;
}
- AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(AliRunLoader::GetRunLoader()->GetDetectorLoader("EMCAL"));
+ AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(AliRunLoader::Instance()->GetDetectorLoader("EMCAL"));
printf("\nWriting digits to %s", emcalLoader->GetDigitsFileName().Data()) ;
{
//utility method for printing digit information
- AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(AliRunLoader::GetRunLoader()->GetDetectorLoader("EMCAL"));
+ AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(AliRunLoader::Instance()->GetDetectorLoader("EMCAL"));
TClonesArray * digits = emcalLoader->Digits() ;
TClonesArray * sdigits = emcalLoader->SDigits() ;
if ((rl = AliRunLoader::GetRunLoader(tempo)))
rl->GetDetectorLoader("EMCAL")->UnloadSDigits() ;
}
- AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(AliRunLoader::GetRunLoader()->GetDetectorLoader("EMCAL"));
+ AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(AliRunLoader::Instance()->GetDetectorLoader("EMCAL"));
emcalLoader->UnloadDigits() ;
}
// and branch "AliEMCALDigitizer", with the same title to keep all the parameters
// and names of files, from which digits are made.
- AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(AliRunLoader::GetRunLoader()->GetDetectorLoader("EMCAL"));
+ AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(AliRunLoader::Instance()->GetDetectorLoader("EMCAL"));
const TClonesArray * digits = emcalLoader->Digits() ;
TTree * treeD = emcalLoader->TreeD();
//
// MC: If you work with MC data you have to get geometry the next way:
// == =============================
-// AliRunLoader *rl = AliRunLoader::GetRunLoader();
+// AliRunLoader *rl = AliRunLoader::Instance();
// AliEMCALGeometry *geom = dynamic_cast<AliEMCAL*>(rl->GetAliRun()->GetDetector("EMCAL"))->GetGeometry();
// TGeoManager::Import("geometry.root");
//To make sure we match with the geometry in a simulation file,
//let's try to get it first. If not, take the default geometry
- AliRunLoader *rl = AliRunLoader::GetRunLoader();
+ AliRunLoader *rl = AliRunLoader::Instance();
if(!rl) AliError("Cannot find RunLoader!");
if (rl->GetAliRun() && rl->GetAliRun()->GetDetector("EMCAL")) {
fGeom = dynamic_cast<AliEMCAL*>(rl->GetAliRun()->GetDetector("EMCAL"))->GetGeometry();
{
// convert digits of the current event to raw data
- AliRunLoader *rl = AliRunLoader::GetRunLoader();
+ AliRunLoader *rl = AliRunLoader::Instance();
AliEMCALLoader *loader = dynamic_cast<AliEMCALLoader*>(rl->GetDetectorLoader("EMCAL"));
// get the digits
//To make sure we match with the geometry in a simulation file,
//let's try to get it first. If not, take the default geometry
- AliRunLoader *rl = AliRunLoader::GetRunLoader();
+ AliRunLoader *rl = AliRunLoader::Instance();
if (rl->GetAliRun() && rl->GetAliRun()->GetDetector("EMCAL")) {
fGeom = dynamic_cast<AliEMCAL*>(rl->GetAliRun()->GetDetector("EMCAL"))->GetGeometry();
} else {
AliEMCALSDigitizer::~AliEMCALSDigitizer() {
//dtor
AliLoader *emcalLoader=0;
- if ((emcalLoader = AliRunLoader::GetRunLoader()->GetDetectorLoader("EMCAL")))
+ if ((emcalLoader = AliRunLoader::Instance()->GetDetectorLoader("EMCAL")))
emcalLoader->CleanSDigitizer();
}
fInit = kTRUE;
- AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(AliRunLoader::GetRunLoader()->GetDetectorLoader("EMCAL"));
+ AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(AliRunLoader::Instance()->GetDetectorLoader("EMCAL"));
if ( emcalLoader == 0 ) {
Fatal("Init", "Could not obtain the AliEMCALLoader");
if(strstr(option,"tim"))
gBenchmark->Start("EMCALSDigitizer");
- AliRunLoader *rl = AliRunLoader::GetRunLoader();
+ AliRunLoader *rl = AliRunLoader::Instance();
AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(rl->GetDetectorLoader("EMCAL"));
//switch off reloading of this task while getting event
{
//Prints list of digits produced at the current pass of AliEMCALDigitizer
- AliEMCALLoader *rl = dynamic_cast<AliEMCALLoader*>(AliRunLoader::GetRunLoader()->GetDetectorLoader("EMCAL"));
+ AliEMCALLoader *rl = dynamic_cast<AliEMCALLoader*>(AliRunLoader::Instance()->GetDetectorLoader("EMCAL"));
const TClonesArray * sdigits = rl->SDigits() ;
printf("\n") ;
void AliEMCALSDigitizer::Unload() const
{
// Unload Hits and SDigits from the folder
- AliEMCALLoader *rl = dynamic_cast<AliEMCALLoader*>(AliRunLoader::GetRunLoader()->GetDetectorLoader("EMCAL"));
+ AliEMCALLoader *rl = dynamic_cast<AliEMCALLoader*>(AliRunLoader::Instance()->GetDetectorLoader("EMCAL"));
rl->UnloadHits() ;
rl->UnloadSDigits() ;
}
{
TH1::AddDirectory(0);
//Main Method to select triggers.
- AliRunLoader *runLoader = AliRunLoader::GetRunLoader();
+ AliRunLoader *runLoader = AliRunLoader::Instance();
AliEMCALLoader *emcalLoader = 0;
if(runLoader) {
emcalLoader = dynamic_cast<AliEMCALLoader*>(runLoader->GetDetectorLoader("EMCAL"));
AliCDBStorage* specificStorage = man->GetSpecificStorage(calibType);
AliEMCALCalibData* caldata = (AliEMCALCalibData*)
- specificStorage->Get(calibTypeData, gAlice->GetRunNumber())->GetObject();
+ specificStorage->Get(calibTypeData, AliRunLoader::Instance()->GetRunNumber())->GetObject();
if(caldata == 0) return 0;
AliEMCALGeometry *g = AliEMCALGeometry::GetInstance();
if(fRunLoader) return kTRUE;
- fRunLoader = AliRunLoader::GetRunLoader();
+ fRunLoader = AliRunLoader::Instance();
if(!fRunLoader) fRunLoader = AliRunLoader::Open(filename,
AliConfig::GetDefaultEventFolderName(),"read");
if(!fRunLoader) return kFALSE;
ClassImp(AliDimuCombinator)
AliDimuCombinator::AliDimuCombinator():
- fNParticle((Int_t) (AliRunLoader::GetRunLoader()->TreeK())->GetEntries()),
+ fNParticle((Int_t) (AliRunLoader::Instance()->TreeK())->GetEntries()),
fImuon1(0),
fImuon2(0),
fImin1(0),
fEtaMax(10.)
{
// Constructor
- fNParticle = (Int_t) (AliRunLoader::GetRunLoader()->TreeK())->GetEntries();
+ fNParticle = (Int_t) (AliRunLoader::Instance()->TreeK())->GetEntries();
}
AliDimuCombinator::AliDimuCombinator(const AliDimuCombinator & combinator)
else
{ //Here we are in the first call of the method
fCurrentEvent=0;
- Int_t numberOfEvents = AliRunLoader::GetRunLoader()->GetNumberOfEvents();
+ Int_t numberOfEvents = AliRunLoader::Instance()->GetNumberOfEvents();
//Create stacks
fInternalStacks = new TObjArray(numberOfEvents + fNBgEvents); //Create array of internal stacks
fCollisionGeometries = new AliCollisionGeometry*[numberOfEvents + fNBgEvents]; //Create array of collision geometries
AliGenerator* GetCurrentGenerator() const;
virtual void SetActiveEventNumber(Int_t actev);
Int_t GetActiveEventNumber() const {return fActiveEvent;}
- virtual Int_t GetNumberOfEvents() const {return AliRunLoader::GetRunLoader()->GetNumberOfEvents() + fNBgEvents;}
+ virtual Int_t GetNumberOfEvents() const {return AliRunLoader::Instance()->GetNumberOfEvents() + fNBgEvents;}
void SetNBgEvents(Int_t nbg=0){fNBgEvents = nbg;}
static TMCProcess IntToMCProcess(Int_t no);
void AliGenExtFile::CdEventFile()
{
// CD back to the event file
- (AliRunLoader::GetRunLoader())->CdGAFile();
+ AliRunLoader::Instance()->CdGAFile();
}
if (gAlice) printf("AliRun object found on file\n");
if (!gAlice) gAlice = new AliRun("gAlice","Alice test program");
}
- TTree *fAli=AliRunLoader::GetRunLoader()->TreeK();
+ TTree *fAli=AliRunLoader::Instance()->TreeK();
if (fAli) pFile =fAli->GetCurrentFile();
pFile->cd();
printf("Generate - I'm out \n");
if (gAlice) printf("AliRun object found on file\n");
if (!gAlice) gAlice = new AliRun("gAlice","Alice test program");
}
- TTree *fAli=AliRunLoader::GetRunLoader()->TreeK();
+ TTree *fAli=AliRunLoader::Instance()->TreeK();
if (fAli) pFile =fAli->GetCurrentFile();
pFile->cd();
}
Bool_t primordialTrigger = kFALSE;
while(!primordialTrigger) {
//Reseting stack
- AliRunLoader * runloader = AliRunLoader::GetRunLoader();
+ AliRunLoader * runloader = AliRunLoader::Instance();
if (runloader)
if (runloader->Stack())
runloader->Stack()->Clean();
Bool_t primordialTrigger = kFALSE;
while(!primordialTrigger) {
//Reseting stack
- AliRunLoader * runloader = AliRunLoader::GetRunLoader();
+ AliRunLoader * runloader = AliRunLoader::Instance();
if (runloader)
if (runloader->Stack())
runloader->Stack()->Clean();
// Loop over the generated collision times, call the generator
// and correct the partcile times in the stack
- AliStack *stack = AliRunLoader::GetRunLoader()->Stack();
+ AliStack *stack = AliRunLoader::Instance()->Stack();
Int_t lastpart=0;
entry->SetFirst(lastpart);
// Initialization
// Connect base file and file to read from
- TTree *ali = AliRunLoader::GetRunLoader()->TreeE();
+ TTree *ali = AliRunLoader::Instance()->TreeE();
if (ali) {
fBaseFile = ali->GetCurrentFile();
} else {
}
// Make sure we have the correct CTP trigger loaded.
- AliRunLoader* runloader = AliRunLoader::GetRunLoader();
+ AliRunLoader* runloader = AliRunLoader::Instance();
if (runloader != NULL)
{
if (runloader->GetTrigger() == NULL)
AliRawDataHeader* header = reinterpret_cast<AliRawDataHeader*>(outBuffer);
// Fill header with default values.
*header = AliRawDataHeader();
- AliRunLoader* runloader = AliRunLoader::GetRunLoader();
+ AliRunLoader* runloader = AliRunLoader::Instance();
if (runloader != NULL)
{
if (runloader->GetTrigger() != NULL)
AliRawDataHeader* header = reinterpret_cast<AliRawDataHeader*>(outBuffer);
// Fill header with default values.
*header = AliRawDataHeader();
- AliRunLoader* runloader = AliRunLoader::GetRunLoader();
+ AliRunLoader* runloader = AliRunLoader::Instance();
if (runloader != NULL)
{
if (runloader->GetTrigger() != NULL)
// load mc tracks
while( fDoHLTPerformance ){
if( !gAlice ) break;
- AliRunLoader *rl = AliRunLoader::GetRunLoader();//gAlice->GetRunLoader();
+ AliRunLoader *rl = AliRunLoader::Instance();//gAlice->GetRunLoader();
if( !rl ) break;
rl->LoadKinematics();
AliStack *stack = rl->Stack();
cerr<<"Looking for cascade vertices...\n";
if (gAlice) {
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice=0;
}
TClonesArray** modA = new TClonesArray*[size];
for (Int_t mod = 0; mod < size; mod++) modA[mod] = new TClonesArray("AliITSpListItem", 10000);
- AliLoader* loader = (AliRunLoader::GetRunLoader())->GetLoader("ITSLoader");
+ AliLoader* loader = (AliRunLoader::Instance())->GetLoader("ITSLoader");
if (!loader)
{
Error("Open","Can not get ITS loader from Run Loader");
loadlibs();
} else {
if(gAlice){
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice=0;
}
//------------------------------------------------------------
// Tries to find mother's labels
//------------------------------------------------------------
- AliRunLoader *rl = AliRunLoader::GetRunLoader();
+ AliRunLoader *rl = AliRunLoader::Instance();
TTree *trK=(TTree*)rl->TreeK();
if(trK){
//______________________________________________________________________
void AliITSClusterFinder::AddLabel(Int_t lab[10], Int_t label) {
//add label to the cluster
- AliRunLoader *rl = AliRunLoader::GetRunLoader();
+ AliRunLoader *rl = AliRunLoader::Instance();
TTree *trK=(TTree*)rl->TreeK();
if(trK){
if(label<0) return; // In case of no label just exit
loadlibs();
} else {
if(gAlice){
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice=0;
} // end if gAlice
Int_t GoodTracksITS(const Char_t *dir) {
if (gAlice) {
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;//if everything was OK here it is already NULL
gAlice = 0x0;
}
gROOT->ProcessLine(".x $(ALICE_ROOT)/macros/loadlibs.C");
}
if(gAlice){
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice=0;
} // end if gAlice
if (gClassTable->GetID("AliRun") < 0) {
gROOT->ProcessLine(".x $(ALICE_ROOT)/macros/loadlibs.C");
}else if (gAlice){
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice=0;
} // end if
// set opt equal to "SPD" or to "SDD" or to "SSD" do build
// rec points for individual subdetectors
if (gAlice) {
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice = NULL;
}
gROOT->Macro("loadlibs.C");
} else {
if(gAlice){
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice=0;
}
// Remove an already existing Run Loader
if (gAlice) {
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice=0;
}
if (gAlice) {
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice=0;
}
}
else {
if(gAlice){
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice=0;
}
if (gClassTable->GetID("AliRun") < 0) {
gROOT->ProcessLine(".x $(ALICE_ROOT)/macros/loadlibs.C");
}else if (gAlice){
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice=0;
}
}
else {
if(gAlice){
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice=0;
}
if (gClassTable->GetID("AliRun") < 0) {
gROOT->ProcessLine(".x $(ALICE_ROOT)/macros/loadlibs.C");
}else if (gAlice){
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice=0;
}
// Load event files
if (gAlice) {
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice=0;
}
// Load event files
if (gAlice) {
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice=0;
}
// Remove an already existing Run Loader
if (gAlice) {
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice=0;
}
loadlibs();
}else {
if(gAlice){
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice=0;
} // end if gAlice
}
else {
if(gAlice){
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice=0;
}
}
else {
if(gAlice){
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice=0;
}
TStopwatch timer;
if(gAlice)
{
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice = 0x0;
} // end if gAlice
{
// ********** Get run loader for the current event **********
- AliRunLoader* runLoader = AliRunLoader::GetRunLoader();
+ AliRunLoader* runLoader = AliRunLoader::Instance();
AliITSLoader* loader = (AliITSLoader* )runLoader->GetLoader( "ITSLoader" );
AliITSgeom* geom = loader->GetITSgeom();
void AliITSVertexer::Init(TString filename){
// Initialize the vertexer in case of
// analysis of an entire file
- AliRunLoader *rl = AliRunLoader::GetRunLoader();
+ AliRunLoader *rl = AliRunLoader::Instance();
if(!rl){
Fatal("AliITSVertexer","Run Loader not found");
}
//______________________________________________________________________
void AliITSVertexer::WriteCurrentVertex(){
// Write the current AliVertex object to file fOutFile
- AliRunLoader *rl = AliRunLoader::GetRunLoader();
+ AliRunLoader *rl = AliRunLoader::Instance();
AliITSLoader* itsLoader = (AliITSLoader*) rl->GetLoader("ITSLoader");
fCurrentVertex->SetName("Vertex");
// const char * name = fCurrentVertex->GetName();
void AliITSVertexer::FindVertices(){
// computes the vertices of the events in the range FirstEvent - LastEvent
- AliRunLoader *rl = AliRunLoader::GetRunLoader();
+ AliRunLoader *rl = AliRunLoader::Instance();
AliITSLoader* itsloader = (AliITSLoader*) rl->GetLoader("ITSLoader");
itsloader->LoadRecPoints("read");
for(Int_t i=fFirstEvent;i<=fLastEvent;i++){
{
// Default Constructor
fSmear = 0;
- AliRunLoader *rl =AliRunLoader::GetRunLoader();
+ AliRunLoader *rl =AliRunLoader::Instance();
TTree *trK=(TTree*)rl->TreeK();
if(!trK)AliFatal("This class should be used only with simulated events!!");
rl->LoadHeader();
fSmear = new Double_t[3];
for(Int_t i=0;i<3;i++)fSmear[i]=smear[i];
Info("AliITSVertexerFast","Gaussian smaring of the generated vertex. Parameters %f12.5 , %f12.5 , %f12.5 \n",fSmear[0],fSmear[1],fSmear[2]);
- AliRunLoader *rl =AliRunLoader::GetRunLoader();
+ AliRunLoader *rl =AliRunLoader::Instance();
TTree *trK=(TTree*)rl->TreeK();
if(!trK)AliFatal("This class should be used only with simulated events!!");
rl->LoadHeader();
AliWarning(Form("This class should be used only with simulated events!! Input cluster tree (%p) will not be used!!",itsClusterTree));
fCurrentVertex = 0;
- AliRunLoader *rl =AliRunLoader::GetRunLoader();
+ AliRunLoader *rl =AliRunLoader::Instance();
TArrayF primaryVertex(3); // true vertex
AliHeader* header = rl->GetHeader();
AliGenEventHeader* genEventHeader = header->GenEventHeader();
//------------------------------------------------------------
// This function creates ITS clusters from raw data
//------------------------------------------------------------
- AliRunLoader* runLoader = AliRunLoader::GetRunLoader();
+ AliRunLoader* runLoader = AliRunLoader::Instance();
if (!runLoader) {
Error("Digits2Clusters", "no run loader found");
return;
//------------------------------------------------------------
// Tries to find mother's labels
//------------------------------------------------------------
- AliRunLoader *rl = AliRunLoader::GetRunLoader();
+ AliRunLoader *rl = AliRunLoader::Instance();
TTree *trK=(TTree*)rl->TreeK();
if(trK){
//------------------------------------------------------------
// Tries to find mother's labels
//------------------------------------------------------------
- AliRunLoader *rl = AliRunLoader::GetRunLoader();
+ AliRunLoader *rl = AliRunLoader::Instance();
TTree *trK=(TTree*)rl->TreeK();
if(trK){
static void AddLabel(Int_t lab[10], Int_t label) {
// add label of the particle in the kine tree which originates this cluster
// (used for reconstruction of MC data only, for comparison purposes)
- AliRunLoader *rl = AliRunLoader::GetRunLoader();
+ AliRunLoader *rl = AliRunLoader::Instance();
TTree *trK=(TTree*)rl->TreeK();
if(trK){
fDet[0] = fDet[1] = fDet[2] = kTRUE;
fEnt0 = 0;
- fEnt = AliRunLoader::GetRunLoader()->GetNumberOfEvents();
+ fEnt = AliRunLoader::Instance()->GetNumberOfEvents();
AliLoader* loader = fRunLoader->GetLoader("ITSLoader");
loadlibs();
} else {
if(gAlice){
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice=0;
}
AliRunLoader* runLoader;
if (gAlice) {
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice=0;
}
}
else {
if(gAlice){
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice=0;
}
}
else {
if(gAlice){
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice=0;
}
}
else {
if(gAlice){
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice=0;
}
}
else {
if (gAlice){
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice=0;
}
// get runloader
if (gAlice) {
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice=0;
}
// In order to create galice.root follow the steps shown below
//
// gAlice->Init("galice.C");
-// AliRunLoader::GetRunLoader()->Write();
-// delete AliRunLoader::GetRunLoader();
+// AliRunLoader::Instance()->Write();
+// delete AliRunLoader::Instance();
//
// make sure galice.root is there
if (!gSystem->Which(".", "galice.root")) {
gAlice->InitMC("$ALICE_ROOT/MONITOR/galice.C");
- AliRunLoader::GetRunLoader()->Write();
- delete AliRunLoader::GetRunLoader();
+ AliRunLoader::Instance()->Write();
+ delete AliRunLoader::Instance();
}
// start the monitoring
fSplitter->SetDebug(fDebug);
// find out current event number, and reset the cluster number
- AliRunLoader *runLoader = AliRunLoader::GetRunLoader();
+ AliRunLoader *runLoader = AliRunLoader::Instance();
fEventNumber = runLoader ? runLoader->GetEventNumber() : 0;
fClusterNumber = -1;
fClusterList.Delete();
fDetElemId = detElemId;
// find out current event number, and reset the cluster number
- AliRunLoader *runLoader = AliRunLoader::GetRunLoader();
+ AliRunLoader *runLoader = AliRunLoader::Instance();
fEventNumber = runLoader ? runLoader->GetEventNumber() : 0;
fClusterNumber = -1;
fClusterList.Delete();
fDetElemId = detElemId;
// find out current event number, and reset the cluster number
- AliRunLoader *runLoader = AliRunLoader::GetRunLoader();
+ AliRunLoader *runLoader = AliRunLoader::Instance();
fEventNumber = runLoader ? runLoader->GetEventNumber() : 0;
fClusterNumber = -1;
fClusterList.Delete();
AliMUONPedestalEventGenerator::LoadRun(const char* mode)
{
/// Get access to AliRunLoader object
- while (AliRunLoader::GetRunLoader())
+ while (AliRunLoader::Instance())
{
- AliDebug(1,Form("Deleting AliRunLoader %p",AliRunLoader::GetRunLoader()));
- delete AliRunLoader::GetRunLoader();
+ AliDebug(1,Form("Deleting AliRunLoader %p",AliRunLoader::Instance()));
+ delete AliRunLoader::Instance();
}
AliRunLoader* runLoader =
AliDebug(1,"");
- AliRunLoader* runLoader = AliRunLoader::GetRunLoader();
+ AliRunLoader* runLoader = AliRunLoader::Instance();
AliLoader* loader = runLoader->GetDetectorLoader("MUON");
loader->LoadHits("READ");
{
/// sets the trigger inputs
- AliRunLoader* runLoader = AliRunLoader::GetRunLoader();
+ AliRunLoader* runLoader = AliRunLoader::Instance();
AliLoader * muonLoader = runLoader->GetDetectorLoader("MUON");
muonLoader->LoadDigits("READ");
fRunLoader->LoadgAlice();
gAlice = fRunLoader->GetAliRun();
- fEventsPerRun = AliRunLoader::GetRunLoader()->GetNumberOfEvents();
+ fEventsPerRun = AliRunLoader::Instance()->GetNumberOfEvents();
fLoader = fRunLoader->GetLoader("MUONLoader");
fRunLoader->GetEvent(fEvent);
//print Final Table
- maxevent = (Int_t)AliRunLoader::GetRunLoader()->TreeE()->GetEntries() ;
+ maxevent = (Int_t)AliRunLoader::Instance()->TreeE()->GetEntries() ;
TString message ;
message = "Resolutions: Analyzed %d event(s)\n" ;
printf("writing gAlice \n") ;
fHeaderFile->cd() ;
gAlice->Write(0,TObject::kOverwrite);
- AliRunLoader::GetRunLoader()->TreeE()->Write(0,TObject::kOverwrite);
+ AliRunLoader::Instance()->TreeE()->Write(0,TObject::kOverwrite);
}
delete gAlice ;
//Write header
fHeaderFile->cd() ;
- AliRunLoader::GetRunLoader()->TreeE()->Fill();
+ AliRunLoader::Instance()->TreeE()->Fill();
}
//____________________________________________________________________________
void AliPHOSRaw2Digits::Print(const Option_t *)const{
{
// Get the number of primaries at the origine of the RecParticle
Int_t rv = 0 ;
- AliRunLoader* rl = AliRunLoader::GetRunLoader() ;
+ AliRunLoader* rl = AliRunLoader::Instance() ;
AliPHOSLoader * phosLoader = dynamic_cast<AliPHOSLoader*>(rl->GetLoader("PHOSLoader"));
Int_t emcRPindex = dynamic_cast<AliPHOSTrackSegment*>(phosLoader->TrackSegments()->At(GetPHOSTSIndex()))->GetEmcIndex();
dynamic_cast<AliPHOSEmcRecPoint*>(phosLoader->EmcRecPoints()->At(emcRPindex))->GetPrimaries(rv) ;
{
// Get the primary particle at the origine of the RecParticle and
// which has deposited the largest energy in SDigits
- AliRunLoader* rl = AliRunLoader::GetRunLoader() ;
+ AliRunLoader* rl = AliRunLoader::Instance() ;
AliPHOSLoader * phosLoader = dynamic_cast<AliPHOSLoader*>(rl->GetLoader("PHOSLoader"));
rl->GetEvent(rl->GetEventNumber()) ;
rl->LoadKinematics("READ");
// which the RecParticle is created from
- AliRunLoader* rl = AliRunLoader::GetRunLoader() ;
+ AliRunLoader* rl = AliRunLoader::Instance() ;
AliPHOSLoader * phosLoader = dynamic_cast<AliPHOSLoader*>(rl->GetLoader("PHOSLoader"));
rl->GetEvent(rl->GetEventNumber()) ;
rl->LoadHits("READ");
}
else {
Int_t dummy ;
- AliRunLoader* rl = AliRunLoader::GetRunLoader() ;
+ AliRunLoader* rl = AliRunLoader::Instance() ;
AliPHOSLoader * phosLoader = dynamic_cast<AliPHOSLoader*>(rl->GetLoader("PHOSLoader"));
Int_t emcRPindex = dynamic_cast<AliPHOSTrackSegment*>(phosLoader->TrackSegments()->At(GetPHOSTSIndex()))->GetEmcIndex();
{
// does the trigger job
- AliRunLoader* rl = AliRunLoader::GetRunLoader() ;
+ AliRunLoader* rl = AliRunLoader::Instance() ;
AliPHOSLoader * phosLoader = dynamic_cast<AliPHOSLoader*>(rl->GetLoader("PHOSLoader"));
// Get PHOS Geometry object
{
if (gAlice)
{
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;//if everything was OK here it is already NULL
gAlice = 0x0;
}
{
if (gAlice)
{
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;//if everything was OK here it is already NULL
gAlice = 0x0;
}
//
fLoader = AliRunLoader::Open(fnGalice);
if (gAlice){
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice = 0x0;
}
//
fLoader = AliRunLoader::Open(fnGalice);
if (gAlice){
- //delete AliRunLoader::GetRunLoader();
+ //delete AliRunLoader::Instance();
delete gAlice;
gAlice = 0x0;
}
}
fNpartons = fPythia->GetN();
} else {
- printf("Loading Event %d\n",AliRunLoader::GetRunLoader()->GetEventNumber());
- fRL->GetEvent(AliRunLoader::GetRunLoader()->GetEventNumber());
+ printf("Loading Event %d\n",AliRunLoader::Instance()->GetEventNumber());
+ fRL->GetEvent(AliRunLoader::Instance()->GetEventNumber());
fPythia->SetN(0);
LoadEvent(fRL->Stack(), 0 , 1);
fPythia->Pyedit(21);
}
fNpartons = fPythia->GetNumberOfParticles();
} else {
- printf("Loading Event %d\n",AliRunLoader::GetRunLoader()->GetEventNumber());
- fRL->GetEvent(AliRunLoader::GetRunLoader()->GetEventNumber());
+ printf("Loading Event %d\n",AliRunLoader::Instance()->GetEventNumber());
+ fRL->GetEvent(AliRunLoader::Instance()->GetEventNumber());
fPythia->SetNumberOfParticles(0);
fPythia->LoadEvent(fRL->Stack(), 0 , 1);
fPythia->EditEventList(21);
if (fStack) {
particle = fStack->Particle(nt);
} else {
- particle = AliRunLoader::GetRunLoader()->Stack()->Particle(nt);
+ particle = AliRunLoader::Instance()->Stack()->Particle(nt);
}
// particle->SetFirstDaughter(fPythia->GetK(2, i));
// particle->SetLastDaughter(fPythia->GetK(3, i));
ULong64_t l2class = 0;
UChar_t l2cluster = 0;
AliInfo("Storing the CTP DDL raw data...");
- AliRunLoader *runloader = AliRunLoader::GetRunLoader();
+ AliRunLoader *runloader = AliRunLoader::Instance();
if (runloader) {
if (!runloader->LoadTrigger()) {
AliCentralTrigger *aCTP = runloader->GetTrigger();
Int_t GoodCascades(const Char_t *dir) {
if (gAlice) {
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice=0;
}
//
fLoader = AliRunLoader::Open(fnGalice);
if (gAlice){
- //delete AliRunLoader::GetRunLoader();
+ //delete AliRunLoader::Instance();
delete gAlice;
gAlice = 0x0;
}
{
if (gAlice)
{
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;//if everything was OK here it is already NULL
gAlice = 0x0;
}
//
//SET Input loaders
if (gAlice){
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice = 0x0;
}
cout<<"Event "<<iEvent++<<endl;
if( !gAlice ) return;
- AliRunLoader *rl = AliRunLoader::GetRunLoader();
+ AliRunLoader *rl = AliRunLoader::Instance();
AliStack *stack = rl->Stack();
if( !stack ) return;
cout <<" Opening "<<filename<<"\nand ESD "<<esdfile<<endl;
if (gAlice) {
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice=0;
}
if(!AliGeomManager::CheckSymNamesLUT("ALL"))
AliFatal("Current loaded geometry differs in the definition of symbolic names!");
- return AliSimulation::Instance()->MisalignGeometry(AliRunLoader::GetRunLoader());
+ return AliSimulation::Instance()->MisalignGeometry(AliRunLoader::Instance());
}
//_______________________________________________________________________
Float_t ed, ed2;
Int_t kn, i, left, j, id;
const Float_t kzero=0;
- Int_t ievent=AliRunLoader::GetRunLoader()->GetHeader()->GetEvent()+1;
+ Int_t ievent=AliRunLoader::Instance()->GetHeader()->GetEvent()+1;
//
// Energy loss information
if(ievent) {
AliDebug(1, ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
AliDebug(1, ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
- AliRunLoader *runloader=AliRunLoader::GetRunLoader();
+ AliRunLoader *runloader=AliRunLoader::Instance();
/*******************************/
/* Clean after eventual */
//
// Called at the end of each primary track
//
- AliRunLoader *runloader=AliRunLoader::GetRunLoader();
+ AliRunLoader *runloader=AliRunLoader::Instance();
// static Int_t count=0;
// const Int_t times=10;
// This primary is finished, purify stack
{
//
// Remaps the track labels of the hits
- AliRunLoader *runloader=AliRunLoader::GetRunLoader();
+ AliRunLoader *runloader=AliRunLoader::Instance();
AliStack* stack = runloader->Stack();
TList* hitLists = GetHitLists();
TIter next(hitLists);
fSum2Energy[i]+=fEventEnergy[i]*fEventEnergy[i];
}
- AliRunLoader *runloader=AliRunLoader::GetRunLoader();
+ AliRunLoader *runloader=AliRunLoader::Instance();
AliHeader* header = runloader->GetHeader();
AliStack* stack = runloader->Stack();
//
// Returns current track
//
- return AliRunLoader::GetRunLoader()->Stack()->GetCurrentTrackNumber();
+ return AliRunLoader::Instance()->Stack()->GetCurrentTrackNumber();
}
//_______________________________________________________________________
//
// Dumps particle i in the stack
//
- AliRunLoader * runloader = AliRunLoader::GetRunLoader();
+ AliRunLoader * runloader = AliRunLoader::Instance();
if (runloader->Stack())
runloader->Stack()->DumpPart(i);
}
//
// Dumps the particle stack
//
- AliRunLoader * runloader = AliRunLoader::GetRunLoader();
+ AliRunLoader * runloader = AliRunLoader::Instance();
if (runloader->Stack())
runloader->Stack()->DumpPStack();
}
// Returns number of tracks in stack
//
Int_t ntracks = -1;
- AliRunLoader * runloader = AliRunLoader::GetRunLoader();
+ AliRunLoader * runloader = AliRunLoader::Instance();
if (runloader->Stack())
ntracks = runloader->Stack()->GetNtrack();
return ntracks;
// return number of primary that has generated track
//
Int_t nprimary = -999;
- AliRunLoader * runloader = AliRunLoader::GetRunLoader();
+ AliRunLoader * runloader = AliRunLoader::Instance();
if (runloader->Stack())
nprimary = runloader->Stack()->GetPrimary(track);
return nprimary;
{
// Returns the i-th particle from the stack taking into account
// the remaping done by PurifyKine
- AliRunLoader * runloader = AliRunLoader::GetRunLoader();
+ AliRunLoader * runloader = AliRunLoader::Instance();
if (runloader)
if (runloader->Stack())
return runloader->Stack()->Particle(i);
//
// Returns pointer to Particles array
//
- AliRunLoader * runloader = AliRunLoader::GetRunLoader();
+ AliRunLoader * runloader = AliRunLoader::Instance();
if (runloader)
if (runloader->Stack())
return runloader->Stack()->Particles();
{
// Delegate to stack
//
- AliRunLoader * runloader = AliRunLoader::GetRunLoader();
+ AliRunLoader * runloader = AliRunLoader::Instance();
if (runloader)
if (runloader->Stack())
runloader->Stack()->PushTrack(done, parent, pdg, pmom, vpos, polar, tof,
{
// Delegate to stack
//
- AliRunLoader * runloader = AliRunLoader::GetRunLoader();
+ AliRunLoader * runloader = AliRunLoader::Instance();
if (runloader)
if (runloader->Stack())
runloader->Stack()->PushTrack(done, parent, pdg, px, py, pz, e, vx, vy, vz, tof,
{
//
// Set high water mark for last track in event
- AliRunLoader * runloader = AliRunLoader::GetRunLoader();
+ AliRunLoader * runloader = AliRunLoader::Instance();
if (runloader)
if (runloader->Stack())
runloader->Stack()->SetHighWaterMark(nt);
//
// Delegate to stack
//
- AliRunLoader * runloader = AliRunLoader::GetRunLoader();
+ AliRunLoader * runloader = AliRunLoader::Instance();
if (runloader)
if (runloader->Stack())
runloader->Stack()->KeepTrack(track);
{
// Delegate to stack
//
- AliRunLoader * runloader = AliRunLoader::GetRunLoader();
+ AliRunLoader * runloader = AliRunLoader::Instance();
if (runloader)
if (runloader->Stack())
runloader->Stack()->FlagTrack(track);
//
// Set current track number
//
- AliRunLoader * runloader = AliRunLoader::GetRunLoader();
+ AliRunLoader * runloader = AliRunLoader::Instance();
if (runloader)
if (runloader->Stack())
runloader->Stack()->SetCurrentTrack(track);
// Reorder and expand the temporary track reference tree in order to match the kinematics tree
//
- AliRunLoader *rl = AliRunLoader::GetRunLoader();
+ AliRunLoader *rl = AliRunLoader::Instance();
//
// TreeTR
AliDebug(1, "fRunLoader->MakeTrackRefsContainer()");
Char_t fname[100];
if (gAlice) {
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice=0;
}
AliRawDataHeaderSim() : AliRawDataHeader() {
// Takes the trigger mask and
// stores it in the data header
- AliRunLoader *runloader = AliRunLoader::GetRunLoader();
+ AliRunLoader *runloader = AliRunLoader::Instance();
if (runloader) {
if (!runloader->LoadTrigger()) {
AliCentralTrigger *aCTP = runloader->GetTrigger();
}
//_____________________________________________________________________________
-Bool_t AliReconstruction::SetFieldMap(Float_t l3Cur, Float_t diCur, Float_t l3Pol, Float_t diPol,
- Float_t beamenergy, Char_t *beamtype,const char *path) {
+Bool_t AliReconstruction::SetFieldMap(Float_t l3Cur, Float_t diCur, Float_t l3Pol,
+ Float_t diPol, Float_t beamenergy,
+ const Char_t *beamtype, const Char_t *path)
+{
//------------------------------------------------
// The magnetic field map, defined externally...
// L3 current 30000 A -> 0.5 T
//*** Magnetic field setters
void SetUniformFieldTracking(Bool_t flag=kTRUE){fUniformField=flag;}
Bool_t SetFieldMap(Float_t l3Current=30000., Float_t diCurrent=6000.,
- Float_t l3Pol=1., Float_t dipPol=1., Float_t benergy=7000., char* btype="pp",
- const char *path="$(ALICE_ROOT)/data/maps/mfchebKGI_sym.root");
+ Float_t l3Pol=1., Float_t dipPol=1., Float_t benergy=7000.,
+ const Char_t* btype="pp",
+ const Char_t* path="$(ALICE_ROOT)/data/maps/mfchebKGI_sym.root");
//*** Global reconstruction flag setters
void SetRunVertexFinder(Bool_t flag=kTRUE) {fRunVertexFinder=flag;};
//_______________________________________________________________________
AliRun::AliRun():
- fRun(-1),
+// fRun(-1),
fEvent(0),
fEventNrInRun(-1),
fModules(0),
//_____________________________________________________________________________
AliRun::AliRun(const char *name, const char *title):
TNamed(name,title),
- fRun(-1),
fEvent(0),
fEventNrInRun(-1),
fModules(new TObjArray(77)), // Support list for the Detectors
/**** R E L O A D ****/
/*****************************************/
- AliRunLoader::GetRunLoader()->GetEvent(event);
+ AliRunLoader::Instance()->GetEvent(event);
/*****************************************/
/**** P O S T R E L O A D I N G ****/
detector->SetTreeAddress();
}
- return AliRunLoader::GetRunLoader()->GetHeader()->GetNtrack();
+ return AliRunLoader::Instance()->GetHeader()->GetNtrack();
}
//_______________________________________________________________________
// Convert Hits to sumable digits
//
- for (Int_t nevent=0; nevent<AliRunLoader::GetRunLoader()->TreeE()->GetEntries(); nevent++) {
+ for (Int_t nevent=0; nevent<AliRunLoader::Instance()->TreeE()->GetEntries(); nevent++) {
GetEvent(nevent);
Hits2SDigits(selected);
SDigits2Digits(selected);
void AliRun::SetGenEventHeader(AliGenEventHeader* header)
{
- AliRunLoader::GetRunLoader()->GetHeader()->SetGenEventHeader(header);
+ AliRunLoader::Instance()->GetHeader()->SetGenEventHeader(header);
}
TObjArray *Modules() const {return fModules;}
void AddModule(AliModule* mod);
Int_t GetEvNumber() const;
- Int_t GetRunNumber() const {return fRun;}
void SetEventNrInRun(Int_t event) {fEventNrInRun=event;}
Int_t GetEventNrInRun() const {return fEventNrInRun;}
Int_t GetNdets() const {return fNdets;}
virtual void Announce() const;
virtual void InitLoaders(); //prepares run (i.e. creates getters)
- void SetRunNumber(Int_t run) {fRun=run;}
protected:
virtual void Tree2Tree(Option_t *option, const char *detector=0);
- Int_t fRun; //! Current run number
Int_t fEvent; //! Current event number (from 1)
Int_t fEventNrInRun; //! Current unique event number in run
TObjArray *fModules; // List of Detectors
AliRunLoader::AliRunLoader():
fLoaders(0x0),
fEventFolder(0x0),
+ fRun(-1),
fCurrentEvent(0),
fGAFile(0x0),
fHeader(0x0),
TNamed(fgkRunLoaderName,fgkRunLoaderName),
fLoaders(new TObjArray()),
fEventFolder(0x0),
+ fRun(-1),
fCurrentEvent(0),
fGAFile(0x0),
fHeader(0x0),
TTree* TreeTR() const; //returns the tree from folder; shortcut method
AliRun* GetAliRun()const;
+ Int_t GetRunNumber() const {return fRun;}
+ void SetRunNumber(Int_t run) {fRun=run;}
Int_t WriteHeader(Option_t* opt="");
Int_t WriteTrigger(Option_t* opt="");
/***** Public S T A T I C Stuff *******/
/******************************************/
static AliRunLoader* GetRunLoader(const char* eventfoldername);
- static AliRunLoader* GetRunLoader(){return fgRunLoader;}
+ static AliRunLoader* Instance(){return fgRunLoader;}
static AliLoader* GetDetectorLoader(const char* detname, const char* eventfoldername);
static TTree* GetTreeH(const char* detname, Bool_t maketree, const char* eventfoldername);
static TTree* GetTreeS(const char* detname, Bool_t maketree, const char* eventfoldername);
static TTree* GetTreeT(const char* detname, Bool_t maketree, const char* eventfoldername);
static TTree* GetTreeP(const char* detname, Bool_t maketree, const char* eventfoldername);
-// static AliRunDigitizer* GetRunDigitizer();
// Tasks are supposed to be singletons, that is why following methods are static
static TTask* GetRunDigitizer(); //
static TTask* GetRunSDigitizer(); //
static TString GetGAliceName () {return fgkGAliceName;}
protected:
- /**********************************************/
- /************ PROTECTED ***************/
- /********* D A T A ************/
- /**********************************************/
+ void SetGAliceFile(TFile* gafile);//sets the pointer to gAlice file
+ Int_t OpenKineFile(Option_t* opt);
+ Int_t OpenTrackRefsFile(Option_t* opt);
- TObjArray *fLoaders; // List of Detectors
- TFolder *fEventFolder; //!top folder for this run
+ Int_t OpenDataFile(const TString& filename,TFile*& file,TDirectory*& dir,Option_t* opt,Int_t cl);
+ void SetUnixDir(const TString& udirname);
+ const TString SetFileOffset(const TString& fname);//adds the proper number before .root
+ void SetDetectorAddresses();
+
+ TObjArray *fLoaders; // List of Detectors
+ TFolder *fEventFolder; //!top folder for this run
- Int_t fCurrentEvent;//!Number of current event
+ Int_t fRun; //! Current run number
+ Int_t fCurrentEvent;//!Number of current event
TFile *fGAFile;//! pointer to main file with AliRun and Run Loader -> galice.root
AliHeader *fHeader;//! pointer to header
AliStack *fStack; //! pointer to stack
AliCentralTrigger *fCTrigger; //! pointer to CEntral Trigger Processor
- AliDataLoader *fKineDataLoader;// kinematics data loader
- AliDataLoader *fTrackRefsDataLoader;//track reference data loader
+ AliDataLoader *fKineDataLoader;// kinematics data loader
+ AliDataLoader *fTrackRefsDataLoader;//track reference data loader
- Int_t fNEventsPerFile; //defines number of events stored per one file
- TString fUnixDirName; //! name of unix path to directory that contains event
+ Int_t fNEventsPerFile; //defines number of events stored per one file
+ TString fUnixDirName; //! name of unix path to directory that contains event
static const TString fgkDefaultKineFileName;//default file name with kinamatics
static const TString fgkDefaultTrackRefsFileName;//default file name with kinamatics
static const TString fgkDefaultTriggerFileName;//default file name with trigger
-
- /*********************************************/
- /************ PROTECTED **************/
- /********* M E T H O D S ***********/
- /*********************************************/
-
- void SetGAliceFile(TFile* gafile);//sets the pointer to gAlice file
- Int_t OpenKineFile(Option_t* opt);
- Int_t OpenTrackRefsFile(Option_t* opt);
-
- Int_t OpenDataFile(const TString& filename,TFile*& file,TDirectory*& dir,Option_t* opt,Int_t cl);
- void SetUnixDir(const TString& udirname);
- const TString SetFileOffset(const TString& fname);//adds the proper number before .root
- void SetDetectorAddresses();
private:
AliRunLoader(const AliRunLoader &r); //Not implemented
AliRunLoader & operator = (const AliRunLoader &); //Not implemented
-
void GetListOfDetectors(const char * namelist,TObjArray& pointerarray) const;
-
void CleanHeader(){Clean(fgkHeaderContainerName);}
void CleanTrigger(){Clean(fgkTriggerContainerName);}
void Clean(const TString& name);
-
Int_t SetEvent();
- static AliRunLoader* fgRunLoader; //pointer to the AliRunLoader instance
-
-private:
+ static AliRunLoader* fgRunLoader; //pointer to the AliRunLoader instance
static const TString fgkRunLoaderName; //default name of the run loader
static const TString fgkHeaderContainerName; //default name of the kinematics container (TREE) name - TreeE
AliWarning("Run number not initialized!!");
}
- AliRunLoader::GetRunLoader()->CdGAFile();
+ AliRunLoader::Instance()->CdGAFile();
AliPDG::AddParticlesToPdgDataBase();
//Must be here because some MCs (G4) adds detectors here and not in Config.C
gAlice->InitLoaders();
- AliRunLoader::GetRunLoader()->MakeTree("E");
+ AliRunLoader::Instance()->MakeTree("E");
//
// Save stuff at the beginning of the file to avoid file corruption
- AliRunLoader::GetRunLoader()->CdGAFile();
+ AliRunLoader::Instance()->CdGAFile();
gAlice->Write();
//Save current generator
//Run Lego Object
- AliRunLoader::GetRunLoader()->SetNumberOfEventsPerFile(nev);
+ AliRunLoader::Instance()->SetNumberOfEventsPerFile(nev);
gMC->ProcessRun(nev);
// End of this run, close files
gInterpreter->ProcessLine(gAlice->GetConfigFunction());
if(AliCDBManager::Instance()->GetRun() >= 0) {
- gAlice->SetRunNumber(AliCDBManager::Instance()->GetRun());
+ AliRunLoader::Instance()->SetRunNumber(AliCDBManager::Instance()->GetRun());
} else {
AliWarning("Run number not initialized!!");
}
- AliRunLoader::GetRunLoader()->CdGAFile();
+ AliRunLoader::Instance()->CdGAFile();
AliPDG::AddParticlesToPdgDataBase();
//Must be here because some MCs (G4) adds detectors here and not in Config.C
gAlice->InitLoaders();
- AliRunLoader::GetRunLoader()->MakeTree("E");
- AliRunLoader::GetRunLoader()->LoadKinematics("RECREATE");
- AliRunLoader::GetRunLoader()->LoadTrackRefs("RECREATE");
- AliRunLoader::GetRunLoader()->LoadHits("all","RECREATE");
+ AliRunLoader::Instance()->MakeTree("E");
+ AliRunLoader::Instance()->LoadKinematics("RECREATE");
+ AliRunLoader::Instance()->LoadTrackRefs("RECREATE");
+ AliRunLoader::Instance()->LoadHits("all","RECREATE");
//
// Save stuff at the beginning of the file to avoid file corruption
- AliRunLoader::GetRunLoader()->CdGAFile();
+ AliRunLoader::Instance()->CdGAFile();
gAlice->Write();
gAlice->SetEventNrInRun(-1); //important - we start Begin event from increasing current number in run
//___________________________________________________________________________________________
// Set run number in CDBManager
AliInfo(Form("Run number: %d",AliCDBManager::Instance()->GetRun()));
- AliRunLoader* runLoader = AliRunLoader::GetRunLoader();
+ AliRunLoader* runLoader = AliRunLoader::Instance();
if (!runLoader) {
AliError(Form("gAlice has no run loader object. "
"Check your config file: %s", fConfigFileName.Data()));
MisalignGeometry(runLoader);
#endif
-// AliRunLoader* runLoader = AliRunLoader::GetRunLoader();
+// AliRunLoader* runLoader = AliRunLoader::Instance();
// if (!runLoader) {
// AliError(Form("gAlice has no run loader object. "
// "Check your config file: %s", fConfigFileName.Data()));
if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
SetCDBLock();
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice = NULL;
{
// delete existing run loaders, open a new one and load gAlice
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
AliRunLoader* runLoader =
AliRunLoader::Open(fGAliceFileName.Data(),
AliConfig::GetDefaultEventFolderName(), mode);
AliWarning("Run number not initialized!!");
}
- AliRunLoader::GetRunLoader()->CdGAFile();
+ AliRunLoader::Instance()->CdGAFile();
AliPDG::AddParticlesToPdgDataBase();
//Must be here because some MCs (G4) adds detectors here and not in Config.C
gAlice->InitLoaders();
- AliRunLoader::GetRunLoader()->MakeTree("E");
- AliRunLoader::GetRunLoader()->LoadKinematics("RECREATE");
- AliRunLoader::GetRunLoader()->LoadTrackRefs("RECREATE");
- AliRunLoader::GetRunLoader()->LoadHits("all","RECREATE");
+ AliRunLoader::Instance()->MakeTree("E");
+ AliRunLoader::Instance()->LoadKinematics("RECREATE");
+ AliRunLoader::Instance()->LoadTrackRefs("RECREATE");
+ AliRunLoader::Instance()->LoadHits("all","RECREATE");
//
// Save stuff at the beginning of the file to avoid file corruption
- AliRunLoader::GetRunLoader()->CdGAFile();
+ AliRunLoader::Instance()->CdGAFile();
gAlice->Write();
//
// Initialize CDB
Int_t iDet;
//
// Get the runloader
- AliRunLoader* runLoader = AliRunLoader::GetRunLoader();
+ AliRunLoader* runLoader = AliRunLoader::Instance();
//
// Open esd file if available
TFile* esdFile = TFile::Open(esdFileName);
if(IsLegoRun())
{
AliDebug(1, "Finish Lego");
- AliRunLoader::GetRunLoader()->CdGAFile();
+ AliRunLoader::Instance()->CdGAFile();
fLego->FinishRun();
}
detector->FinishRun();
}
- AliDebug(1, "AliRunLoader::GetRunLoader()->WriteHeader(OVERWRITE)");
- AliRunLoader::GetRunLoader()->WriteHeader("OVERWRITE");
+ AliDebug(1, "AliRunLoader::Instance()->WriteHeader(OVERWRITE)");
+ AliRunLoader::Instance()->WriteHeader("OVERWRITE");
// Write AliRun info and all detectors parameters
- AliRunLoader::GetRunLoader()->CdGAFile();
+ AliRunLoader::Instance()->CdGAFile();
gAlice->Write(0,TObject::kOverwrite);//write AliRun
- AliRunLoader::GetRunLoader()->Write(0,TObject::kOverwrite);//write RunLoader itself
+ AliRunLoader::Instance()->Write(0,TObject::kOverwrite);//write RunLoader itself
if(gAlice->GetMCApp()) gAlice->GetMCApp()->FinishRun();
- AliRunLoader::GetRunLoader()->Synchronize();
+ AliRunLoader::Instance()->Synchronize();
}
//_____________________________________________________________________________
// run the QA on summable hits, digits or digits
if(!gAlice) return kFALSE;
- fQASteer->SetRunLoader(AliRunLoader::GetRunLoader()) ;
+ fQASteer->SetRunLoader(AliRunLoader::Instance()) ;
TString detectorsw("") ;
Bool_t rv = kTRUE ;
gInterpreter->ProcessLine(gAlice->GetConfigFunction());
if(AliCDBManager::Instance()->GetRun() >= 0) {
- gAlice->SetRunNumber(AliCDBManager::Instance()->GetRun());
+ AliRunLoader::Instance()->SetRunNumber(AliCDBManager::Instance()->GetRun());
} else {
AliWarning("Run number not initialized!!");
}
- AliRunLoader::GetRunLoader()->CdGAFile();
+ AliRunLoader::Instance()->CdGAFile();
AliPDG::AddParticlesToPdgDataBase();
//Must be here because some MCs (G4) adds detectors here and not in Config.C
gAlice->InitLoaders();
- AliRunLoader::GetRunLoader()->MakeTree("E");
- AliRunLoader::GetRunLoader()->LoadKinematics("RECREATE");
- AliRunLoader::GetRunLoader()->LoadTrackRefs("RECREATE");
- AliRunLoader::GetRunLoader()->LoadHits("all","RECREATE");
+ AliRunLoader::Instance()->MakeTree("E");
+ AliRunLoader::Instance()->LoadKinematics("RECREATE");
+ AliRunLoader::Instance()->LoadTrackRefs("RECREATE");
+ AliRunLoader::Instance()->LoadHits("all","RECREATE");
//
// Save stuff at the beginning of the file to avoid file corruption
- AliRunLoader::GetRunLoader()->CdGAFile();
+ AliRunLoader::Instance()->CdGAFile();
gAlice->Write();
- AliRunLoader* runLoader = AliRunLoader::GetRunLoader();
+ AliRunLoader* runLoader = AliRunLoader::Instance();
if( !runLoader ) {
AliError( Form( "gAlice has no run loader object. "
"Check your config file: %s", configfile.Data() ) );
AliWarning( Form( "Triggering dummy detector %s", GetName() ) );
// ********** Get Digits for the current event **********
- AliRunLoader* runLoader = AliRunLoader::GetRunLoader();
+ AliRunLoader* runLoader = AliRunLoader::Instance();
AliInfo( Form( "Event %d", runLoader->GetEventNumber() ) );
TString loadername = GetName();
Int_t GoodV0s(const Char_t *dir) {
if (gAlice) {
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;//if everything was OK here it is already NULL
gAlice = 0x0;
}
AliGeomManager::LoadGeometry("geometry.root");
if (gAlice) {
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice=0;
}
//------------------------------------------------------------------------
if (gAlice) {
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice=0;
}
void TestRmTracks(Int_t iev=0) {
if (gAlice) {
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice=0;
}
if( gClassTable->GetID( "AliRun" ) < 0 ) {
gROOT->ProcessLine( ".x $(ALICE_ROOT)/macros/loadlibs.C" );
} else if( gAlice ) {
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice=0;
}
memset(fBuffer,0,512*sizeof(UInt_t));
//get event number
- AliRunLoader *runloader = AliRunLoader::GetRunLoader();
+ AliRunLoader *runloader = AliRunLoader::Instance();
if (runloader) {
fEventNumber = runloader->GetEventNumber();
}
{
// trigger input
- AliRunLoader* runLoader = AliRunLoader::GetRunLoader();
+ AliRunLoader* runLoader = AliRunLoader::Instance();
AliLoader * fT0Loader = runLoader->GetLoader("T0Loader");
// AliT0digit *fDigits;
fT0Loader->LoadDigits("READ");
if (fContainer) {
fContainer->AddHeader(header);
} else {
- AliRunLoader::GetRunLoader()->GetHeader()->SetGenEventHeader(header);
+ AliRunLoader::Instance()->GetHeader()->SetGenEventHeader(header);
}
}
fHeader = new AliGenCocktailEventHeader("Beamgas Header");
const TObjArray *partArray = gAlice->GetMCApp()->Particles();
- AliStack *stack = AliRunLoader::GetRunLoader()->Stack();
+ AliStack *stack = AliRunLoader::Instance()->Stack();
for (Int_t l = 0; l < numbg; l++) {
Vertex();
/*
// Save the geometry
TDirectory* saveDir = gDirectory;
- AliRunLoader::GetRunLoader()->CdGAFile();
+ AliRunLoader::Instance()->CdGAFile();
fTOFGeometry->Write("TOFGeometry");
saveDir->cd();
*/
if (gAlice) {
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;//if everything was OK here it is already NULL
gAlice = 0x0;
}
Int_t GoodTracksTOF(const Char_t *dir) {
if (gAlice) {
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;//if everything was OK here it is already NULL
gAlice = 0x0;
}
if (gAlice)
{
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice = 0x0;
}
if (gAlice)
{
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice = 0x0;
}
AliInfo("Memorandum: 0 means PION | 1 means KAON | 2 means PROTON")
}
- if (fNevents == 0) fNevents = (Int_t) AliRunLoader::GetRunLoader()->TreeE()->GetEntries();
+ if (fNevents == 0) fNevents = (Int_t) AliRunLoader::Instance()->TreeE()->GetEntries();
for (Int_t ievent = 0; ievent < fNevents; ievent++) {
gAlice->GetEvent(ievent);
}
}
AliRunLoader *rl;
- rl = AliRunLoader::GetRunLoader();
+ rl = AliRunLoader::Instance();
Int_t ncurrevent = rl->GetEventNumber();
rl->GetEvent(ncurrevent);
if (gAlice)
{
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice = 0x0;
}
if (gAlice)
{
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice = 0x0;
}
if (gAlice)
{
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice = 0x0;
}
if (gAlice)
{
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice = 0x0;
}
if (gAlice)
{
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice = 0x0;
}
if (gAlice)
{
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice = 0x0;
}
if (gAlice)
{
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice = 0x0;
}
if (gAlice)
{
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice = 0x0;
}
if (gAlice)
{
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice = 0x0;
}
if (gAlice)
{
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice = 0x0;
}
if (gAlice)
{
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice = 0x0;
}
if (gAlice)
{
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice = 0x0;
}
if (gAlice)
{
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice = 0x0;
}
if (rc=AliTOFanalyzeDigits()) return rc;
if (gAlice)
{
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice = 0x0;
}
// delete the current gAlice object, the one from input file will be used
if(gAlice)
{
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice=0x0;
}
if(gAlice)
{
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice=0x0;
}
// Save the geometry
TDirectory* saveDir = gDirectory;
- AliRunLoader::GetRunLoader()->CdGAFile();
+ AliRunLoader::Instance()->CdGAFile();
fTOFGeometry->Write("TOFgeometry");
saveDir->cd();
// Save the geometry
TDirectory* saveDir = gDirectory;
- AliRunLoader::GetRunLoader()->CdGAFile();
+ AliRunLoader::Instance()->CdGAFile();
fTOFGeometry->Write("TOFgeometry");
saveDir->cd();
// Save the geometry
TDirectory* saveDir = gDirectory;
- AliRunLoader::GetRunLoader()->CdGAFile();
+ AliRunLoader::Instance()->CdGAFile();
fTOFGeometry->Write("TOFgeometry");
saveDir->cd();
AliGeomManager::LoadGeometry("geometry.root");
if (gAlice) {
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice=0;
}
Int_t AliTPCFindClusters(Int_t nev=5) {
if (gAlice) {
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;//if everything was OK here it is already NULL
gAlice = 0x0;
}
if (gAlice)
{
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice = 0x0;
}
// initialization
//
if (gAlice) {
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;//if everything was OK here it is already NULL
gAlice = 0x0;
}
Int_t AliTPCHits2Digits(Int_t nev=5) {
// Connect the Root Galice file containing Geometry, Kine and Hits
if (gAlice) {
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;//if everything was OK here it is already NULL
gAlice = 0x0;
}
//it assures full cleaning of prevous session
if (gAlice)
{
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;//if everything was OK here it is already NULL
gAlice = 0x0;
}
if (gAlice)
{
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;//if everything was OK here it is already NULL
gAlice = 0x0;
}
/**** Initialization of the NewIO *******/
if (gAlice) {
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice=0;
}
Int_t u = 0;
AliTRDdigitsManager *digman = new AliTRDdigitsManager();
- digman->ReadDigits(AliRunLoader::GetRunLoader()->GetLoader("TRDLoader")->TreeD());
+ digman->ReadDigits(AliRunLoader::Instance()->GetLoader("TRDLoader")->TreeD());
digman->SetUseDictionaries(kTRUE);
AliTRDfeeParam *feeParam = AliTRDfeeParam::Instance();
}
}
- AliDataLoader *dl = AliRunLoader::GetRunLoader()->GetLoader("TRDLoader")->GetDataLoader("tracklets");
+ AliDataLoader *dl = AliRunLoader::Instance()->GetLoader("TRDLoader")->GetDataLoader("tracklets");
if (!dl) {
AliError("Could not get the tracklets data loader!");
}
// Load MC info
fRunLoader->GetEvent(iEvent);
- AliStack* stack = AliRunLoader::GetRunLoader()->Stack();
+ AliStack* stack = AliRunLoader::Instance()->Stack();
TArrayF vertex(3);
fRunLoader->GetHeader()->GenEventHeader()->PrimaryVertex(vertex);
{
// ********** Get run loader for the current event **********
- AliRunLoader* runLoader = AliRunLoader::GetRunLoader();
+ AliRunLoader* runLoader = AliRunLoader::Instance();
AliVZEROLoader* loader =
(AliVZEROLoader* )runLoader->GetLoader( "VZEROLoader" );
{
// Convert ZDC raw data to Sdigits
- AliLoader* loader = (AliRunLoader::GetRunLoader())->GetLoader("ZDCLoader");
+ AliLoader* loader = (AliRunLoader::Instance())->GetLoader("ZDCLoader");
if(!loader) {
AliError("no ZDC loader found");
return kFALSE;
// // Event loop
Int_t iEvent = 0;
while(rawReader->NextEvent()){
- (AliRunLoader::GetRunLoader())->GetEvent(iEvent++);
+ (AliRunLoader::Instance())->GetEvent(iEvent++);
// Create the output digit tree
TTree* treeS = loader->TreeS();
if(!treeS){
// Trigger selection
//
- AliRunLoader *runLoader = AliRunLoader::GetRunLoader();
+ AliRunLoader *runLoader = AliRunLoader::Instance();
AliLoader *aZDCLoader = runLoader->GetLoader("ZDCLoader");
if (gAlice)
{
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;//if everything was OK here it is already NULL
gAlice = 0x0;
}
void TestVertexerTracks(){
if (gAlice) {
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice = 0x0;
}
gROOT->LoadMacro("loadlibs.C");
loadlibs();
} else {
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
gAlice = 0;
}
*/
void Quit()
{
- delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::Instance();
delete gAlice;
exit(0);
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff