22-jun-2005 NvE Specific job folder recursively removed from the generic AliJob folde...
authornick <nick@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 23 Jun 2005 10:35:00 +0000 (10:35 +0000)
committernick <nick@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 23 Jun 2005 10:35:00 +0000 (10:35 +0000)
                in the AliJob destructor before actually deleting the specific job folder itself.
                Also main object pointer updated in case of a match with removal of object(s) from
                the specific job environment.
23-jun-2005 NvE Creation of specific job folder made optionally in AliJob.
23-jun-2005 NvE Specification and consequently writing-out of datastructures made
                optionally in IceF2k. This will allow IceF2k to be used as a facility
                to investigate/analyse F2K data using the Ralice/IcePack analysis tools
                without producing output data files.

RALICE/AliJob.cxx
RALICE/AliJob.h
RALICE/history.txt
RALICE/icepack/iceconvert/IceF2k.cxx
RALICE/icepack/iceconvert/history.txt
RALICE/icepack/iceconvert/macros/icef2k.cc

index 08e928f4fa0f9c2502e2e34d91b457adc5d3d3a6..1509d6a431cff40bbd2e596555a7b8acf7fdc748 100644 (file)
 // This base class provides a working environment for the derived
 // (user defined) processor class and all of its subtasks.
 //
-// The working environment consists of (a.o.) :
+// The default working environment consists of :
+//
+// * An array containing pointers to the objects which are stored
+//   via the AddObject() facility of this AliJob class.
+//   From this storage the objects can be directly accessed via the
+//   GetObject() and GetObjects() memberfunctions.
+// * A pointer to the main object structure during job processing.
+//   This pointer can be initiated/updated only by the derived top level
+//   processor via the SetMainObject() facility but all sub-tasks can access
+//   it via the above array facilities or the GetMainObject() memberfunction.
+//   The latter provides faster access to the main object structure than
+//   the GetObject (search) based procedures.
+//
+// Optionally one may invoke the MakeFolder() memberfunction to provide
+// in addition to the above the following job-specific folder structure :
+//
 // * A folder which may serve as a whiteboard for transferring pointers to
 //   objects which are posted there by the top level processor or any
 //   of its subtasks.
 //   Access to the job folder is obtained via the GetFolder() memberfunction
 //   and from this the various objects can be accessed via the usual TFolder
 //   FindObject and/or iterator facilities.
-// * An array containing pointers to the objects which are stored
-//   via the AddObject() facility of this AliJob class.
-//   From this storage the objects can be (more directly) accessed via the
-//   GetObject() and GetObjects() memberfunctions.
-// * A pointer to the main object structure during job processing.
-//   This pointer can be initiated/updated only by the derived top level
-//   processor via the SetMainObject() facility but all sub-tasks can access
-//   it via the above folder/array facilities or the GetMainObject() memberfunction.
-//   The latter provides faster access to the main object structure than
-//   the GetObject() or TFolder search based procedures.
 //
 // Notes :
 // -------
@@ -56,7 +61,7 @@
 //
 // 2) Only references to the various introduced objects are stored.
 //    It is the user's responsibility to delete all introduced objects,
-//    either in the destructor of the derived top level processor class
+//    either in the Exec() or destructor of the derived top level processor class
 //    or via Clear() facility as provided by the TTask machinery.
 //
 // 3) The top level processor instance is entered into the standard ROOT
 //
 //      AliJob* parent=(AliJob*)gROOT->GetListOfTasks()->FindObject(opt)
 //
-// 4) The job-specific folder will be created in the generic folder called
-//    "AliJob-folders" as a sub-folder under the same name as the one
+// 4) If selected, the job-specific folder will be created in the generic folder
+//    called "AliJob-folders" as a sub-folder under the same name as the one
 //    introduced in the constructor of the derived top level processor class.
-//    The folder will only be created when the first object is posted via
-//    the AddObject() or SetMainObject() facilities.
+//    The folder will only be created if the MakeFolder() member function has been
+//    invoked explicitly and when the first object is posted via the AddObject()
+//    or SetMainObject() facilities.
 //
 // Execution of the (user defined) top level processor has to be invoked via
 // the memberfunction ExecuteJob() of this AliJob base class.
-// This will invoke the (user written) Exec() memberfunction of the top level
+// This will set the default gROOT as the global working directory and then
+// invoke the (user written) Exec() memberfunction of the top level
 // processor class with as argument the name of the top level processor instance
 // as specified by the user in the top level processor constructor.
 // This will allow stepwise (e.g. event-by-event) execution of the various sub-tasks.
@@ -102,6 +109,7 @@ AliJob::AliJob(const char* name,const char* title) : TTask(name,title)
 // Initialise the working environment for general data access
 // by the derived task and its subtasks.
 
+ fMakefolder=0;
  fMainObject=0;
  fFolder=0;
  fObjects=0;
@@ -115,7 +123,9 @@ AliJob::AliJob(const char* name,const char* title) : TTask(name,title)
 AliJob::~AliJob()
 {
 // Default destructor.
-// Note : The objects belonging to the various pointers in the folder
+// The internal array and job specific folder (if any) holding the various
+// references are deleted.
+// Note : The objects belonging to the various pointers in the array/folder
 //        and the main processing object are NOT deleted by this base class.
 
  if (fObjects)
@@ -125,6 +135,12 @@ AliJob::~AliJob()
  }
  if (fFolder)
  {
+  TList* list=gROOT->GetListOfBrowsables();
+  if (list)
+  {
+   TFolder* top=(TFolder*)list->FindObject("AliJob-folders");
+   if (top) RecursiveRemove(fFolder);
+  }
   delete fFolder;
   fFolder=0;
  }
@@ -144,17 +160,29 @@ void AliJob::ListEnvironment()
  cout << " ***" << endl;
  cout << " === Available (sub)tasks : " << endl;
  ls();
- cout << " === Current job-folder contents : " << endl;
- fFolder->ls();
+ if (fFolder)
+ {
+  cout << " === Current job-folder contents : " << endl;
+  fFolder->ls();
+ }
  cout << endl;
 }
 ///////////////////////////////////////////////////////////////////////////
 void AliJob::ExecuteJob()
 {
 // Invokation of the top level processor via its Exec() memberfunction.
+// Note : Before execution gROOT is set as the global working directory.
+ gROOT->cd(); 
  Exec(GetName());
 }
 ///////////////////////////////////////////////////////////////////////////
+void AliJob::MakeFolder()
+{
+// Select creation of the folder structure in addition to the internal
+// array storage of objects.
+ fMakefolder=1;
+}
+///////////////////////////////////////////////////////////////////////////
 TFolder* AliJob::GetFolder() const
 {
 // Provide pointer to the whiteboard folder.
@@ -185,7 +213,7 @@ void AliJob::AddObject(TObject* obj)
 
  if (!fObjects) fObjects=new TObjArray();
 
- if (!fFolder)
+ if (fMakefolder && !fFolder)
  {
   // Create the top level environment folder for all AliJobs if needed 
   TList* list=gROOT->GetListOfBrowsables();
@@ -215,7 +243,7 @@ void AliJob::AddObject(TObject* obj)
  if (!exist)
  {
   fObjects->Add(obj);
-  fFolder->Add(obj);
+  if (fFolder) fFolder->Add(obj);
  }
 }
 ///////////////////////////////////////////////////////////////////////////
@@ -236,13 +264,19 @@ void AliJob::AddObjects(TObjArray* arr)
 void AliJob::RemoveObject(TObject* obj)
 {
 // Remove pointer of specified object from the working environment.
+// In case the specified object is also the main object, the main object
+// pointer will be set to 0 as well.
 
  if (!obj) return;
 
  if (fObjects)
  {
   TObject* test=fObjects->Remove(obj);
-  if (test) fObjects->Compress();
+  if (test)
+  {
+   fObjects->Compress();
+   if (test==fMainObject) fMainObject=0;
+  }
  }
 
  if (fFolder) fFolder->Remove(obj);
@@ -251,6 +285,8 @@ void AliJob::RemoveObject(TObject* obj)
 void AliJob::RemoveObjects(const char* classname)
 {
 // Remove all stored objects inheriting from classname.
+// In case one of the removed objects is also the main object, the main object
+// pointer will be set to 0 as well.
 
  if (!fObjects) return;
 
@@ -261,7 +297,11 @@ void AliJob::RemoveObjects(const char* classname)
   if (obj->InheritsFrom(classname))
   {
    TObject* test=fObjects->Remove(obj);
-   if (test) remove=1;
+   if (test)
+   {
+    remove=1;
+    if (test==fMainObject) fMainObject=0;
+   }
    if (fFolder) fFolder->Remove(obj);
   }
  }
index e66e870bce8e94d5a94951705412a4fa24b8197e..a9b402bb103a47a1b0c57010b87f55e5be071ade 100644 (file)
@@ -17,6 +17,7 @@ class AliJob : public TTask
   virtual ~AliJob();                                      // Destructor
   void ListEnvironment();                                 // Provide listing of the job environment
   void ExecuteJob();                                      // Invokation of the top level processing
+  void MakeFolder();                                      // Select creation of the folder structure 
   TFolder* GetFolder() const;                             // Provide pointer to the whiteboard folder 
   TObject* GetMainObject() const;                         // Provide pointer to the main object structure
   void AddObject(TObject* obj);                           // Add an object into the environment
@@ -29,6 +30,7 @@ class AliJob : public TTask
   TObjArray* GetObjects(const char* classname);           // Provide all objects inheriting from "classname" 
 
  protected :
+  Int_t fMakefolder;    // Flag to indicate creation of the folder structure
   TFolder* fFolder;     // Pointer to the folder which serves as the job's whiteboard
   TObject* fMainObject; // Pointer to the main processing object structure within the job
   TObjArray* fObjects;  // Pointers to the various user-added objects 
@@ -36,6 +38,6 @@ class AliJob : public TTask
 
   void SetMainObject(TObject* obj); // Store pointer to the main object structure
 
- ClassDef(AliJob,1) // Base class for top level job in a task based procedure 
+ ClassDef(AliJob,2) // Base class for top level job in a task based procedure 
 };
 #endif
index e7f27614835d0dbd47578f7d716e688b44773cb5..03fb3f7c0a3a79c371e1a6f04863584d53d2b642 100644 (file)
                 of Fortran carriage-control characters on some systems.
 17-jun-2005 NvE New class AliJob introduced to provide a flexible (physics) analysis environment.
                 Bug (forgotten ps transfer in AliTimestamp::SetTJD) fixed (thanks Federico Carminati).
+22-jun-2005 NvE Specific job folder recursively removed from the generic AliJob folder environment
+                in the AliJob destructor before actually deleting the specific job folder itself. 
+                Also main object pointer updated in case of a match with removal of object(s) from
+                the specific job environment.
+23-jun-2005 NvE Creation of specific job folder made optionally in AliJob.
+               
                 
  
\ No newline at end of file
index dc3bab18d085908f9accc64f1d66a5f85443b601..12875cf41adb0278b0e92a401714fc886b2dd21e 100644 (file)
 // In case the user has provided sub-tasks, these will be executed
 // on an event-by-event basis after the IceEvent structure has been filled
 // with the F2K data and before the final structures are written out.
+// Note that the data structures are only written out if an outputfile has
+// been specified via the SetOutputFile memberfunction.
+// In case no outputfile has been specified, this class provides a facility
+// to investigate/analyse F2K data using the Ralice/IcePack analysis tools. 
 //
 // Usage example :
 // ---------------
@@ -74,6 +78,8 @@
 //
 // // Select various objects to be added to the output file
 //
+// ofile->cd(); // Switch to the output file directory
+//
 // AliObjMatrix* omdb=q.GetOMdbase();
 // if (omdb) omdb->Write();
 //
@@ -83,7 +89,7 @@
 // TDatabasePDG* pdg=q.GetPDG();
 // if (pdg) pdg->Write();
 //
-// // Close output file
+// // Flush and close output file
 // ofile->Write();
 // ofile->Close();
 //
@@ -116,8 +122,6 @@ IceF2k::IceF2k(const char* name,const char* title) : AliJob(name,title)
 IceF2k::~IceF2k()
 {
 // Default destructor.
- IceEvent* evt=(IceEvent*)GetMainObject();
- if (evt) delete evt;
 
  if (fPdg)
  {
@@ -237,20 +241,19 @@ void IceF2k::Exec(Option_t* opt)
  // Read the file header information
  rdmc_rarr(fInput,&fHeader);
 
- if (!fOutfile)
+ TTree* otree=0;
+ if (fOutfile)
  {
-  cout << " *IceF2k Exec* No ROOT output file specified." << endl;
-  return;
+  otree=new TTree("T","F2K Data converted to IceEvent structures");
+  otree->SetDirectory(fOutfile);
  }
 
- TTree* otree=new TTree("T","F2K Data converted to IceEvent structures");
-
  IceEvent* evt=new IceEvent();
  evt->SetTrackCopy(1);
  evt->SetDevCopy(1);
 
  // Branch in the tree for the event structure
- otree->Branch("IceEvent","IceEvent",&evt,fBsize,fSplit); 
if (otree) otree->Branch("IceEvent","IceEvent",&evt,fBsize,fSplit); 
 
  // Create the particle database and extend it with some F2000 specific definitions
  if (!fPdg) fPdg=new TDatabasePDG();
@@ -276,8 +279,11 @@ void IceF2k::Exec(Option_t* opt)
 
  // Initialise the job working environment
  SetMainObject(evt);
- AddObject(fOutfile);
- AddObject(otree);
+ if (fOutfile)
+ {
+  AddObject(fOutfile);
+  AddObject(otree);
+ }
 
  cout << " ***" << endl;
  cout << " *** Start processing of job " << GetName() << " ***" << endl;
@@ -285,8 +291,11 @@ void IceF2k::Exec(Option_t* opt)
  cout << " F2K input file : " << fInfile.Data() << endl;
  cout << " Maximum number of events to be processed : " << fMaxevt << endl;
  cout << " Print frequency : " << fPrintfreq << endl;
- cout << " ROOT output file : " << fOutfile->GetName() << endl;
- cout << " Output characteristics : splitlevel = " << fSplit << " buffersize = " << fBsize << endl;
+ if (fOutfile)
+ {
+  cout << " ROOT output file : " << fOutfile->GetName() << endl;
+  cout << " Output characteristics : splitlevel = " << fSplit << " buffersize = " << fBsize << endl;
+ }
 
  ListEnvironment();
  
@@ -314,11 +323,19 @@ void IceF2k::Exec(Option_t* opt)
   if (!(nevt%fPrintfreq)) evt->HeaderData();
 
   // Write the complete structure to the output Tree
-  otree->Fill();
+  if (otree) otree->Fill();
 
   // Update event counter
   nevt++;
  }
+
+ // Remove the IceEvent object from the environment
+ // and delete it as well
+ if (evt)
+ {
+  RemoveObject(evt);
+  delete evt;
+ }
 }
 ///////////////////////////////////////////////////////////////////////////
 void IceF2k::FillOMdbase()
index 0761b6a411815ac58f55afae48bcc23e7fdb62c6..bc25c1a8ce705f9e9b79bceb844d100a2f58171c 100644 (file)
@@ -11,4 +11,8 @@
                 The example macro icef2k.cc has been updated accordingly.
 21-jun-2005 NvE Install scripts for gcc corrected to also include the rdmc stuff
                 in the produced shared libs.
+23-jun-2005 NvE Specification and consequently writing-out of datastructures made
+                optionally in IceF2k. This will allow IceF2k to be used as a facility
+                to investigate/analyse F2K data using the Ralice/IcePack analysis tools
+                without producing output data files.
  
index 2c842e6e91c6e3b92f2c74a51467629d98f39993..4ef8d4884fa772dab6c5bc18660dae1586313717 100644 (file)
@@ -49,6 +49,8 @@
 
  // Select various objects to be added to the output file
 
+ ofile->cd(); // Switch to the output file directory
+
  AliObjMatrix* omdb=q.GetOMdbase();
  if (omdb) omdb->Write();
 
@@ -58,7 +60,7 @@
  TDatabasePDG* pdg=q.GetPDG();
  if (pdg) pdg->Write();
 
- // Close output file
+ // Flush and close the output file
  ofile->Write();
  ofile->Close();
 }