Updated Unload functionality (P.Skowronski)
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 19 Aug 2003 15:09:23 +0000 (15:09 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 19 Aug 2003 15:09:23 +0000 (15:09 +0000)
STEER/AliDataLoader.cxx
STEER/AliLoader.cxx
STEER/AliLoader.h
STEER/AliRunLoader.cxx
STEER/AliRunLoader.h
TPC/AliTPCtrackerMI.cxx

index 76b0e91846cb0b19a8ee71796014d5497ce29fd3..2ee8be1394f27cd992d94d7f19bb7906e8cabec7 100644 (file)
@@ -245,6 +245,8 @@ void AliDataLoader::Unload()
 void AliDataLoader::UnloadAll()
 {
 //Unloads all data and tasks
+ if ( fFile == 0x0 ) return; //nothing loaded
  TIter next(fBaseLoaders);
  AliBaseLoader* bl;
  while ((bl = (AliBaseLoader*)next()))
index c38995bb7320a20e82b650c7602efdd582b47834..34ed89c2d7179f345df0b4ef5780a2d28b7bed76 100644 (file)
@@ -186,6 +186,19 @@ Int_t AliLoader::SetEvent()
 }
 /******************************************************************/
 
+void AliLoader::UnloadAll()
+{
+ //calls UnloadAll for all base laoders
+ //Unloads everything
+ TIter next(fDataLoaders);
+ AliDataLoader* dl;
+ while ((dl = (AliDataLoader*)next()))
+  {
+    dl->UnloadAll();
+  }
+}
+/******************************************************************/
+
 Int_t AliLoader::GetEvent()
 {
  //changes to proper root  directory and tries to load data from files to folders
index 374c0479648bfc1298128d19d22c7f2d50a82b16..ea77545a2ead0b762886edac191cfe7ed99708a3 100644 (file)
@@ -133,6 +133,7 @@ class AliLoader: public TNamed
     void           UnloadRecPoints(){GetRecPointsDataLoader()->Unload();}
     void           UnloadTracks(){GetTracksDataLoader()->Unload();}
     void           UnloadRecParticles(){GetRecParticlesDataLoader()->Unload();}
+    void           UnloadAll();
 
     virtual Int_t  ReloadHits(){return GetHitsDataLoader()->Reload();}  //unload and load again Hits
     virtual Int_t  ReloadSDigits(){return GetSDigitsDataLoader()->Reload();} //unload and load again 
index 5c6a81aa57b4bb29b10d2211841a1c031154285a..17f737d130c39c3c2363e6b7756b28881c5232fa 100644 (file)
 //////////////////////////////////////////////////////////////////////////////////////
 /**************************************************************************/
 
+#include <TROOT.h>
 #include <TString.h>
 #include <TFolder.h>
+#include <TTask.h>
 #include <TFile.h>
 #include <TTree.h>
-#include <TROOT.h>
 #include <TBranch.h>
 #include <TGeometry.h>
-#include <TTask.h>
 #include <TError.h>
+#include <TObjArray.h>
 
 #include "AliRun.h"
 #include "AliConfig.h"
 #include "AliLoader.h"
 #include "AliHeader.h"
 #include "AliStack.h"
-#include "TObjArray.h"
 #include "AliDetector.h"
 #include "AliRunDigitizer.h"
 
@@ -97,6 +97,8 @@ AliRunLoader::AliRunLoader(const char* eventfoldername):
 AliRunLoader::~AliRunLoader()
 {
 //dtor
+  if (fgRunLoader == this) fgRunLoader = 0x0;
+  
   UnloadHeader();
   UnloadgAlice();
   
@@ -1108,7 +1110,7 @@ Int_t AliRunLoader::LoadSDigits(Option_t* detectors,Option_t* opt)
   else
    {
      GetListOfDetectors(detectors,arr);//this method looks for all Loaders corresponding to names (many) specified in detectors option
-     loaders = &arr;//get the pointer array
+     loaders = &arr;//get the pointer to array
    }   
 
   TIter next(loaders);
@@ -1148,7 +1150,6 @@ Int_t AliRunLoader::LoadDigits(Option_t* detectors,Option_t* opt)
    }
   return 0;
 } 
-
 /**************************************************************************/
 
 Int_t AliRunLoader::LoadRecPoints(Option_t* detectors,Option_t* opt)
@@ -1177,7 +1178,34 @@ Int_t AliRunLoader::LoadRecPoints(Option_t* detectors,Option_t* opt)
    }
   return 0;
 } 
+/**************************************************************************/
 
+Int_t AliRunLoader::LoadRecParticles(Option_t* detectors,Option_t* opt)
+{
+//LoadHits in selected detectors i.e. detectors="ITS TPC TRD" or "all"
+
+  TObjArray* Loaders;
+  TObjArray arr;
+
+  const char* oAll = strstr(detectors,"all");
+  if (oAll)
+   {
+     Loaders = fLoaders;
+   }
+  else
+   {
+     GetListOfDetectors(detectors,arr);//this method looks for all Loaders corresponding to names (many) specified in detectors option
+     Loaders = &arr;//get the pointer array
+   }   
+
+  TIter next(Loaders);
+  AliLoader *Loader;
+  while((Loader = (AliLoader*)next())) 
+   {
+    Loader->LoadRecParticles(opt);
+   }
+  return 0;
+} 
 /**************************************************************************/
 
 Int_t AliRunLoader::LoadTracks(Option_t* detectors,Option_t* opt)
@@ -1206,7 +1234,189 @@ Int_t AliRunLoader::LoadTracks(Option_t* detectors,Option_t* opt)
    }
   return 0;
 } 
+/**************************************************************************/
+
+void AliRunLoader::UnloadHits(Option_t* detectors)
+{
+  //unloads hits for detectors specified in parameter
+  TObjArray* loaders;
+  TObjArray arr;
+
+  const char* oAll = strstr(detectors,"all");
+  if (oAll)
+   {
+     loaders = fLoaders;
+   }
+  else
+   {
+     GetListOfDetectors(detectors,arr);//this method looks for all Loaders corresponding to names (many) specified in detectors option
+     loaders = &arr;//get the pointer to array
+   }   
+
+  TIter next(loaders);
+  AliLoader *loader;
+  while((loader = (AliLoader*)next())) 
+   {
+    loader->UnloadHits();
+   }
+}
+/**************************************************************************/
+
+void AliRunLoader::UnloadSDigits(Option_t* detectors)
+{
+  //unloads SDigits for detectors specified in parameter
+  TObjArray* loaders;
+  TObjArray arr;
+
+  const char* oAll = strstr(detectors,"all");
+  if (oAll)
+   {
+     loaders = fLoaders;
+   }
+  else
+   {
+     GetListOfDetectors(detectors,arr);//this method looks for all Loaders corresponding to names (many) specified in detectors option
+     loaders = &arr;//get the pointer to array
+   }   
+
+  TIter next(loaders);
+  AliLoader *loader;
+  while((loader = (AliLoader*)next())) 
+   {
+    loader->UnloadSDigits();
+   }
+}
+/**************************************************************************/
+
+void AliRunLoader::UnloadDigits(Option_t* detectors)
+{
+  //unloads Digits for detectors specified in parameter
+  TObjArray* loaders;
+  TObjArray arr;
+
+  const char* oAll = strstr(detectors,"all");
+  if (oAll)
+   {
+     loaders = fLoaders;
+   }
+  else
+   {
+     GetListOfDetectors(detectors,arr);//this method looks for all Loaders corresponding to names (many) specified in detectors option
+     loaders = &arr;//get the pointer to array
+   }   
+
+  TIter next(loaders);
+  AliLoader *loader;
+  while((loader = (AliLoader*)next())) 
+   {
+    loader->UnloadDigits();
+   }
+}
+/**************************************************************************/
+
+void AliRunLoader::UnloadRecPoints(Option_t* detectors)
+{
+  //unloads RecPoints for detectors specified in parameter
+  TObjArray* loaders;
+  TObjArray arr;
+
+  const char* oAll = strstr(detectors,"all");
+  if (oAll)
+   {
+     loaders = fLoaders;
+   }
+  else
+   {
+     GetListOfDetectors(detectors,arr);//this method looks for all Loaders corresponding to names (many) specified in detectors option
+     loaders = &arr;//get the pointer to array
+   }   
+
+  TIter next(loaders);
+  AliLoader *loader;
+  while((loader = (AliLoader*)next())) 
+   {
+    loader->UnloadRecPoints();
+   }
+}
+/**************************************************************************/
+
+void AliRunLoader::UnloadAll(Option_t* detectors)
+{
+  //calls UnloadAll for detectors names specified in parameter
+  // option "all" passed can be passed
+  TObjArray* loaders;
+  TObjArray arr;
+
+  const char* oAll = strstr(detectors,"all");
+  if (oAll)
+   {
+     loaders = fLoaders;
+   }
+  else
+   {
+     GetListOfDetectors(detectors,arr);//this method looks for all Loaders corresponding to names (many) specified in detectors option
+     loaders = &arr;//get the pointer to array
+   }   
 
+  TIter next(loaders);
+  AliLoader *loader;
+  while((loader = (AliLoader*)next())) 
+   {
+    loader->UnloadAll();
+   }
+}
+/**************************************************************************/
+
+void AliRunLoader::UnloadTracks(Option_t* detectors)
+{
+  //unloads Tracks for detectors specified in parameter
+  TObjArray* loaders;
+  TObjArray arr;
+
+  const char* oAll = strstr(detectors,"all");
+  if (oAll)
+   {
+     loaders = fLoaders;
+   }
+  else
+   {
+     GetListOfDetectors(detectors,arr);//this method looks for all Loaders corresponding to names (many) specified in detectors option
+     loaders = &arr;//get the pointer to array
+   }   
+
+  TIter next(loaders);
+  AliLoader *loader;
+  while((loader = (AliLoader*)next())) 
+   {
+    loader->UnloadTracks();
+   }
+}
+/**************************************************************************/
+
+void AliRunLoader::UnloadRecParticles(Option_t* detectors)
+{
+  //unloads Particles for detectors specified in parameter
+  TObjArray* loaders;
+  TObjArray arr;
+
+  const char* oAll = strstr(detectors,"all");
+  if (oAll)
+   {
+     loaders = fLoaders;
+   }
+  else
+   {
+     GetListOfDetectors(detectors,arr);//this method looks for all Loaders corresponding to names (many) specified in detectors option
+     loaders = &arr;//get the pointer to array
+   }   
+
+  TIter next(loaders);
+  AliLoader *loader;
+  while((loader = (AliLoader*)next())) 
+   {
+    loader->UnloadRecParticles();
+   }
+}
 /**************************************************************************/
 
 AliRunLoader* AliRunLoader::GetRunLoader(const char* eventfoldername)
@@ -1223,24 +1433,44 @@ AliRunLoader* AliRunLoader::GetRunLoader(const char* eventfoldername)
 }
 /**************************************************************************/
 
-AliLoader* AliRunLoader::GetDetectorLoader(const char* detname)
+AliLoader* AliRunLoader::GetDetectorLoader(const char* detname, const char* eventfoldername)
 {
 //get the loader of the detector with the given name from the global
 //run loader object
-  AliRunLoader* runLoader = GetRunLoader();
+  AliRunLoader* runLoader = GetRunLoader(eventfoldername);
   if (!runLoader) {
-    cerr << "AliRunLoader::GetDetectorLoader: no run loader found\n";
+    ::Error("AliRunLoader::GetDetectorLoader","No run loader found");
     return NULL;
   }
+  return runLoader->GetDetectorLoader(detname);
+}
+/**************************************************************************/
+
+AliLoader* AliRunLoader::GetDetectorLoader(const char* detname)
+{
+//get the loader of the detector with the given name from the global
+//run loader object
+  
   char loadername[256];
   sprintf(loadername, "%sLoader", detname);
-  AliLoader* loader = runLoader->GetLoader(loadername);
+  AliLoader* loader = GetLoader(loadername);
   if (!loader) {
-    runLoader->Error("GetDetectorLoader", "no loader for %s found", detname);
+    Error("GetDetectorLoader", "No loader for %s found", detname);
     return NULL;
   }
   return loader;
 }
+/**************************************************************************/
+
+TTree* AliRunLoader::GetTreeH(const char* detname, Bool_t maketree, const char* eventfoldername)
+{
+//get the tree with hits of the detector with the given name
+//if maketree is true and the tree does not exist, the tree is created
+  AliLoader* loader = GetDetectorLoader(detname,eventfoldername);
+  if (!loader) return NULL;
+  if (!loader->TreeH() && maketree) loader->MakeTree("H");
+  return loader->TreeH();
+}
 
 /**************************************************************************/
 
@@ -1253,7 +1483,17 @@ TTree* AliRunLoader::GetTreeH(const char* detname, Bool_t maketree)
   if (!loader->TreeH() && maketree) loader->MakeTree("H");
   return loader->TreeH();
 }
+/**************************************************************************/
 
+TTree* AliRunLoader::GetTreeS(const char* detname, Bool_t maketree,const char* eventfoldername)
+{
+//get the tree with summable digits of the detector with the given name
+//if maketree is true and the tree does not exist, the tree is created
+  AliLoader* loader = GetDetectorLoader(detname,eventfoldername);
+  if (!loader) return NULL;
+  if (!loader->TreeS() && maketree) loader->MakeTree("S");
+  return loader->TreeS();
+}
 /**************************************************************************/
 
 TTree* AliRunLoader::GetTreeS(const char* detname, Bool_t maketree)
@@ -1265,7 +1505,17 @@ TTree* AliRunLoader::GetTreeS(const char* detname, Bool_t maketree)
   if (!loader->TreeS() && maketree) loader->MakeTree("S");
   return loader->TreeS();
 }
+/**************************************************************************/
 
+TTree* AliRunLoader::GetTreeD(const char* detname, Bool_t maketree,const char* eventfoldername)
+{
+//get the tree with digits of the detector with the given name
+//if maketree is true and the tree does not exist, the tree is created
+  AliLoader* loader = GetDetectorLoader(detname,eventfoldername);
+  if (!loader) return NULL;
+  if (!loader->TreeD() && maketree) loader->MakeTree("D");
+  return loader->TreeD();
+}
 /**************************************************************************/
 
 TTree* AliRunLoader::GetTreeD(const char* detname, Bool_t maketree)
@@ -1277,7 +1527,16 @@ TTree* AliRunLoader::GetTreeD(const char* detname, Bool_t maketree)
   if (!loader->TreeD() && maketree) loader->MakeTree("D");
   return loader->TreeD();
 }
-
+/**************************************************************************/
+TTree* AliRunLoader::GetTreeR(const char* detname, Bool_t maketree,const char* eventfoldername)
+{
+//get the tree with clusters of the detector with the given name
+//if maketree is true and the tree does not exist, the tree is created
+  AliLoader* loader = GetDetectorLoader(detname,eventfoldername);
+  if (!loader) return NULL;
+  if (!loader->TreeR() && maketree) loader->MakeTree("R");
+  return loader->TreeR();
+}
 /**************************************************************************/
 
 TTree* AliRunLoader::GetTreeR(const char* detname, Bool_t maketree)
@@ -1289,7 +1548,17 @@ TTree* AliRunLoader::GetTreeR(const char* detname, Bool_t maketree)
   if (!loader->TreeR() && maketree) loader->MakeTree("R");
   return loader->TreeR();
 }
+/**************************************************************************/
 
+TTree* AliRunLoader::GetTreeT(const char* detname, Bool_t maketree,const char* eventfoldername)
+{
+//get the tree with tracks of the detector with the given name
+//if maketree is true and the tree does not exist, the tree is created
+  AliLoader* loader = GetDetectorLoader(detname,eventfoldername);
+  if (!loader) return NULL;
+  if (!loader->TreeT() && maketree) loader->MakeTree("T");
+  return loader->TreeT();
+}
 /**************************************************************************/
 
 TTree* AliRunLoader::GetTreeT(const char* detname, Bool_t maketree)
@@ -1301,7 +1570,17 @@ TTree* AliRunLoader::GetTreeT(const char* detname, Bool_t maketree)
   if (!loader->TreeT() && maketree) loader->MakeTree("T");
   return loader->TreeT();
 }
+/**************************************************************************/
 
+TTree* AliRunLoader::GetTreeP(const char* detname, Bool_t maketree,const char* eventfoldername)
+{
+//get the tree with particles of the detector with the given name
+//if maketree is true and the tree does not exist, the tree is created
+  AliLoader* loader = GetDetectorLoader(detname,eventfoldername);
+  if (!loader) return NULL;
+  if (!loader->TreeP() && maketree) loader->MakeTree("P");
+  return loader->TreeP();
+}
 /**************************************************************************/
 
 TTree* AliRunLoader::GetTreeP(const char* detname, Bool_t maketree)
index 8ce457296429b2fae4cb6b80537dea1b7ed1b500..cea79aac9006af2e7ba435733a71d22cfb25e85d 100644 (file)
@@ -111,7 +111,15 @@ class AliRunLoader: public TNamed
     Int_t       LoadDigits(Option_t* detectors = "all",Option_t* opt = "RAED");
     Int_t       LoadRecPoints(Option_t* detectors = "all",Option_t* opt = "RAED");
     Int_t       LoadTracks(Option_t* detectors = "all",Option_t* opt = "RAED");
+    Int_t       LoadRecParticles(Option_t* detectors = "all",Option_t* opt = "RAED");
     
+    void        UnloadHits(Option_t* detectors = "all");
+    void        UnloadSDigits(Option_t* detectors = "all");
+    void        UnloadDigits(Option_t* detectors = "all");
+    void        UnloadRecPoints(Option_t* detectors = "all");
+    void        UnloadTracks(Option_t* detectors = "all");
+    void        UnloadRecParticles(Option_t* detectors = "all");
+    void        UnloadAll(Option_t* detectors = "all");    
     
     void        AddLoader(AliLoader* loader);
     void        AddLoader(AliDetector* det);
@@ -145,6 +153,14 @@ class AliRunLoader: public TNamed
     void cd(){fgRunLoader = this;}
     void Synchronize();
     
+    AliLoader*    GetDetectorLoader(const char* detname);
+    TTree*        GetTreeH(const char* detname, Bool_t maketree);
+    TTree*        GetTreeS(const char* detname, Bool_t maketree);
+    TTree*        GetTreeD(const char* detname, Bool_t maketree);
+    TTree*        GetTreeR(const char* detname, Bool_t maketree);
+    TTree*        GetTreeT(const char* detname, Bool_t maketree);
+    TTree*        GetTreeP(const char* detname, Bool_t maketree);
+    
   protected:
     /**********************************************/
     /************    PROTECTED      ***************/
@@ -199,13 +215,13 @@ class AliRunLoader: public TNamed
   /******************************************/
     static AliRunLoader* GetRunLoader(const char* eventfoldername);
     static AliRunLoader* GetRunLoader(){return fgRunLoader;}
-    static AliLoader*    GetDetectorLoader(const char* detname);
-    static TTree*        GetTreeH(const char* detname, Bool_t maketree);
-    static TTree*        GetTreeS(const char* detname, Bool_t maketree);
-    static TTree*        GetTreeD(const char* detname, Bool_t maketree);
-    static TTree*        GetTreeR(const char* detname, Bool_t maketree);
-    static TTree*        GetTreeT(const char* detname, Bool_t maketree);
-    static TTree*        GetTreeP(const char* detname, Bool_t maketree);
+    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*        GetTreeD(const char* detname, Bool_t maketree, const char* eventfoldername);
+    static TTree*        GetTreeR(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
index 86e022cfa7b59c1700c31b8a3f4848172f5bab59..3700c6558a8681d0940f1426d8541b45de32ca34 100644 (file)
@@ -1739,14 +1739,14 @@ Int_t AliTPCtrackerMI::Clusters2Tracks() {
   //-----------------------------------------------------------------
   // This is a track finder.
   //-----------------------------------------------------------------
-  TTree* clustersTree = AliRunLoader::GetTreeR("TPC", kFALSE);
+  TTree* clustersTree = AliRunLoader::GetTreeR("TPC", kFALSE,AliConfig::fgkDefaultEventFolderName);
   if (!clustersTree) {
     Error("Clusters2Tracks", "no clusters found");
     return 1;
   }
   fClustersArray.ConnectTree(clustersTree);
 
-  TTree* tracksTree = AliRunLoader::GetTreeT("TPC", kTRUE);
+  TTree* tracksTree = AliRunLoader::GetTreeT("TPC", kTRUE,AliConfig::fgkDefaultEventFolderName);
   TTree& tracktree = *tracksTree;
 //  TTree seedtree("Seeds","Seeds");
   AliTPCtrack *iotrack=0;
@@ -1852,7 +1852,7 @@ Int_t AliTPCtrackerMI::Clusters2Tracks() {
 //  seedtree.Write();
   cerr<<"Number of found tracks : "<<"\t"<<found<<endl;
   
-  AliRunLoader::GetDetectorLoader("TPC")->WriteTracks("OVERWRITE");
+  AliRunLoader::GetDetectorLoader("TPC",AliConfig::fgkDefaultEventFolderName)->WriteTracks("OVERWRITE");
 
   return 0;
 }