Base class to ease access to MUON data structures (Laurent)

diff --git a/MUON/AliMUONDataManager.cxx b/MUON/AliMUONDataManager.cxx
new file mode 100644 (file)
index 0000000..e2f94db
--- /dev/null
+++ b/MUON/AliMUONDataManager.cxx
@@ -0,0 +1,234 @@
+/**************************************************************************
+* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+*                                                                        *
+* Author: The ALICE Off-line Project.                                    *
+* Contributors are mentioned in the code where appropriate.              *
+*                                                                        *
+* Permission to use, copy, modify and distribute this software and its   *
+* documentation strictly for non-commercial purposes is hereby granted   *
+* without fee, provided that the above copyright notice appears in all   *
+* copies and that both the copyright notice and this permission notice   *
+* appear in the supporting documentation. The authors make no claims     *
+* about the suitability of this software for any purpose. It is          *
+* provided "as is" without express or implied warranty.                  *
+**************************************************************************/
+
+// $Id$
+
+/// \class AliMUONDataManager
+///
+/// Utility class to ease access to data stores.
+/// This one is not really meant to be used directly, but more as 
+/// an implementation helper for other classes (see AliMUONMCDataInterface
+/// and AliMUONDataInterface)
+/// 
+/// Note that in the methods, trees are labelled by a single letter (except
+/// for trackrefs) :
+/// - K for Kine
+/// - H for Hits
+/// - S for SDigits
+/// - D for Digits / Trigger
+/// - R for RecPoints / Trigger
+/// - T for Tracks / TriggerTracks
+/// - TR for TrackRefs
+///
+/// \author Laurent Aphecetche
+
+#include "AliMUONDataManager.h"
+
+#include "AliLoader.h"
+#include "AliLog.h"
+#include "AliMUONVStore.h"
+#include "AliRunLoader.h"
+
+#include <TTree.h>
+
+/// \cond CLASSIMP
+ClassImp(AliMUONDataManager)
+/// \endcond
+
+Int_t AliMUONDataManager::fgCount(0);
+
+//_____________________________________________________________________________
+AliMUONDataManager::AliMUONDataManager(const char* file)
+: TObject(),
+  fLoader(0x0),
+  fCurrentEvent(-1),
+  fIsValid(kTRUE)
+{
+    /// ctor
+    ///
+
+  TString foldername(Form("AliMUONDataManager-%d",fgCount));
+  
+    ++fgCount;
+    
+  while (AliRunLoader::GetRunLoader(foldername)) 
+  {
+    delete AliRunLoader::GetRunLoader(foldername);
+  }
+    
+  AliRunLoader* runLoader = AliRunLoader::Open(file,foldername);
+  if (!runLoader) 
+  {
+    AliError(Form("Cannot open file %s",file));    
+    fIsValid = kFALSE;
+  }
+  fLoader = runLoader->GetDetectorLoader("MUON");
+  if (!fLoader) 
+  {
+    AliError("Cannot get AliMUONLoader");
+    fIsValid = kFALSE;
+  }
+}
+
+//_____________________________________________________________________________
+AliMUONDataManager::~AliMUONDataManager()
+{
+  /// dtor. We kill our runLoader to allow other ones to be created.
+  if ( fLoader ) 
+  {
+    delete fLoader->GetRunLoader();
+  }
+}
+
+//_____________________________________________________________________________
+Int_t
+AliMUONDataManager::Load(Int_t event)
+{
+  /// Load event if different from the current one.
+  if ( event != fCurrentEvent ) 
+  {
+    fCurrentEvent = event;
+    AliDebug(1,Form("Loading event %d using runLoader %p",event,fLoader->GetRunLoader()));
+    if ( event < NumberOfEvents() )
+    {
+      return fLoader->GetRunLoader()->GetEvent(event);
+    }
+    else
+    {
+      return 1;
+    }
+  }
+  return 0;
+}
+
+//_____________________________________________________________________________
+void 
+AliMUONDataManager::Load(const char* tree)
+{
+  /// Load a tree, labelled using an abbreviation
+  
+  TString s(tree);
+  s.ToUpper();
+
+  const char* opt = "READ";
+  
+  if ( s == "K" ) fLoader->GetRunLoader()->LoadKinematics(opt);
+  if ( s == "H" ) fLoader->LoadHits(opt);
+  if ( s == "S" ) fLoader->LoadSDigits(opt);
+  if ( s == "T" ) fLoader->LoadTracks(opt);
+  if ( s == "D" ) fLoader->LoadDigits(opt);
+  if ( s == "R" ) fLoader->LoadRecPoints(opt);
+  if ( s == "TR") fLoader->GetRunLoader()->LoadTrackRefs(opt);
+}
+
+//_____________________________________________________________________________
+Int_t
+AliMUONDataManager::NumberOfEvents() const
+{
+  /// Get the number of events in the file we're connected to.
+  if (!IsValid()) return 0;
+  return fLoader->GetRunLoader()->GetNumberOfEvents();
+}
+
+//_____________________________________________________________________________
+AliMUONVStore*
+AliMUONDataManager::ReadConnectable(Int_t event, const char* tree, const char* what)
+{
+  /// Read an object from tree, for a given event.
+  
+  if ( !IsValid() ) 
+  {
+    AliError("Object is not valid");
+    return 0x0;
+  }
+  
+  Int_t rv = Load(event);
+  
+  if (rv)
+  {
+    AliError(Form("Cannot read event %d",event));
+    return 0x0;
+  }
+  
+  Load(tree);
+  
+  TTree* theTree = Tree(tree);
+  
+  if ( theTree ) 
+  {
+    AliMUONVStore* object = AliMUONVStore::Create(*theTree,what);
+    if ( object ) 
+    {
+      Bool_t ok = object->Connect(*theTree);
+      if (ok)
+      {
+        theTree->GetEvent(0);
+
+      }
+      else
+      {
+        AliError(Form("Could not connect %s to tree%s",what,tree));
+        delete object;
+        object = 0x0;
+      }
+    }
+    else
+    {
+      AliError(Form("Could not get %s from tree%s",what,tree));
+    }
+    Unload(tree);
+    return object;
+  }
+  else
+  {
+    AliError(Form("Could not get tree%s",tree));
+  }
+  return 0x0;  
+}
+
+//_____________________________________________________________________________
+TTree*
+AliMUONDataManager::Tree(const char* tree)
+{
+  /// Return a tree, labelled by a letter.
+  TString s(tree);
+  s.ToUpper();
+
+  if ( s == "H" ) return fLoader->TreeH();
+  if ( s == "T" ) return fLoader->TreeT();
+  if ( s == "S" ) return fLoader->TreeS();
+  if ( s == "D" ) return fLoader->TreeD();
+  if ( s == "R" ) return fLoader->TreeR();
+  if ( s == "TR") return fLoader->GetRunLoader()->TreeTR();
+  
+  return 0x0;
+}
+
+//_____________________________________________________________________________
+void 
+AliMUONDataManager::Unload(const char* tree)
+{
+  /// Unload a given tree.
+  TString s(tree);
+  s.ToUpper();
+
+  if ( s == "K" ) fLoader->GetRunLoader()->UnloadKinematics();
+  if ( s == "H" ) fLoader->UnloadHits();
+  if ( s == "S" ) fLoader->UnloadSDigits();
+  if ( s == "T" ) fLoader->UnloadTracks();
+  if ( s == "D" ) fLoader->UnloadDigits();
+  if ( s == "R" ) fLoader->UnloadRecPoints();
+  if ( s == "TR" ) fLoader->GetRunLoader()->UnloadTrackRefs();
+}

diff --git a/MUON/AliMUONDataManager.h b/MUON/AliMUONDataManager.h
new file mode 100644 (file)
index 0000000..5092f1a
--- /dev/null
+++ b/MUON/AliMUONDataManager.h
@@ -0,0 +1,56 @@
+#ifndef ALIMUONDATAMANAGER_H
+#define ALIMUONDATAMANAGER_H
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+* See cxx source for full Copyright notice                               */
+
+// $Id$
+
+/// \ingroup base
+/// \class AliMUONDataManager
+/// \brief Utility class to ease access to data stores.
+/// 
+// Author Laurent Aphecetche
+
+#ifndef ROOT_TObject
+#  include "TObject.h"
+#endif
+
+class AliLoader;
+class AliMUONVStore;
+class TTree;
+
+class AliMUONDataManager : public TObject
+{
+public:
+
+  AliMUONDataManager(const char* file="galice.root");
+  virtual ~AliMUONDataManager();
+
+  AliMUONVStore* ReadConnectable(Int_t event, const char* tree, const char* what);
+
+  /// Whether we were properly initialized or not
+  Bool_t IsValid() const { return fIsValid; }
+  
+  Int_t NumberOfEvents() const;
+  
+  Int_t Load(Int_t event);
+  void Load(const char* tree);
+  TTree* Tree(const char* tree);
+  void Unload(const char* tree);
+  
+private:
+  /// Not implemented
+  AliMUONDataManager(const AliMUONDataManager&);
+  /// Not implemented
+  AliMUONDataManager& operator=(const AliMUONDataManager&);
+  
+  AliLoader* fLoader; //!< Our loader to access trees
+  Int_t fCurrentEvent; //!< Current loaded event
+  Bool_t fIsValid; //!< Whether we were properly initialized or not
+  static Int_t fgCount; //!< instance counter to be able to build a unique folder name
+  
+  ClassDef(AliMUONDataManager,0) // Utility class to ease data store access
+};
+
+#endif