CDF KITS Project:/ include/ HepTuple/ HepRootFileManager.h		[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ]
	Architecture: [ i386 ] Version: [ 4.10.4 ] [ 4.10.5 ] [ 4.8.4 ] [ 4.8.4l3s ] [ 4.8.5 ] [ 4.9.0 ] [ 4.9.1 ] [ 4.9.1.hpt3 ] [ 4.9.1hpt3 ] [ 4.9.1top1 ] [ 5.0.0 ] [ 5.1.0 ] [ 5.1.0beamonly ] [ 5.1.1 ] [ 5.2.0 ] [ 5.3.0 ] [ 5.3.1 ] [ 5.3.1dsp ] [ 5.3.3 ] [ 5.3.3_nt ] [ 5.3.4 ] [ 6.1.1 ] [ 6.1.1b ] [ 6.1.2 ] [ 6.1.3 ] [ 6.1.4 ] [ 6.1.4int3 ] [ 6.1.4mc ] [ 6.1.4mc_a ] [ 6.1.6 ] [ development ]

 #ifndef HEPROOTFILEMANAGER_H
 #define HEPROOTFILEMANAGER_H
 
 // ----------------------------------------------------------------------
 //
 // HepRootFileManager.h - header file for the wrapper for the Nirvana
 //   Rootscope package
 //
 // HepRootFileManager is a C++ wrapper class that controls the
 // initialization and creation of histograms and ntuples and allows
 // them to be written to a file in the Root format.
 //
 // This class is derived from the HepFileManager, and is not an abstract
 // class. It should be instantiated before any histograms or ntuples - a
 // pointer to the manager is passed to every histogram and ntuple upon
 // creation.
 //
 // Usage of the class:
 //
 //   HepFileManager* m = new HepRootFileManager("filename", "rootDirName");
 //    :
 //    :
 //   [create histograms]
 //
 // write() writes the managed Root objects to a file, as does the
 // destructor.
 // dumpAllData() and clearAllData()  initiate calls of dumpData() or
 // clearData() to all managed objects.
 //
 //
 // History
 //   30-Nov-1998  Philippe Canal   Initial draft
 //   19-Mar-2001  Mark Fischler    hepFileFormat()
 //
 // ----------------------------------------------------------------------
 
 #ifndef ZMENVIRONMENT_H
   #include "ZMutility/ZMenvironment.h"
 #endif
 
 #include <string>
 
 #include "HepTuple/HepFileManager.h"
 
 #ifndef FIXEDTYPES_H
   #include "ZMutility/FixedTypes.h"
 #endif
   
 ZM_BEGIN_NAMESPACE( zmht )      /*  namespace zmht  {  */
 
 class HepHist;
 class HepRootHist1D;
 class HepRootHist2D;
 class HepRootHistProf;
 class HepRootNtuple;
 class HepFileSwitch;
 
 class TFile;
 class TDirectory;
 class TObject;
 
 class HepRootFileManager : public HepFileManager  {
 
   friend class HepTFile;
 
 public:
 
   // constructor/destructor:   -----------------------------------------
 
   HepRootFileManager(               // constructor
     const std::string& fName        //   desired file name
   , const std::string& rootDir = "" //   desired name of root directory
   , int compression = 0             //   desired compression level
   );
 
   HepRootFileManager(               // constructor
     const std::string& fName        //   desired file name
   , HepFileManager::mode req_mode   //   desired opening mode
   , const std::string& rootDir = "" //   desired name of root directory
   , int compression = 0             //   desired compression level
   );
 
   virtual ~HepRootFileManager();   // destructor
 
   static void initialiseRoot();
 
   // directory manipulation a la HepRoot:  -------------------------------
 
   virtual void cd( const std::string & path = "" );    // change dir
 
   virtual void mkdir( const std::string & path ); // create a dir
 
   virtual std::string ls(                       // list a dir
     const std::string & path = ""
   , const std::string & opts = ""
   )  const;
 
   virtual void rmdir( const std::string & path, bool recursive = false ); 
   // delete a dir
 
   virtual void rm( int hid = 0 );          // delete a histogram or ntuple
   virtual void rm( const std::string & what );  // delete a histogram or ntuple
 
   virtual TFile* file() const;  // Return a pointer the manager file structure.
 
   // File Format: ---------------------------------------------------------
 
   HepTupleFileFormat hepFileFormat() const;
 
   // HepRoot file manipulation:  -----------------------------------------
 
   virtual void writeDirectory();     // write the managed objects to the file
   virtual int write();         // write the managed objects to the file
 #ifdef LATER
   virtual void dumpAllData();  // call dumpData() for all tuples in the list
   virtual void clearAllData(); // call clearData() for all tuples in the list
 #endif // LATER
 
 
   // Create HepRoot-specific histograms & Ntuples:  ----------------------
 
   virtual HepHist1D & hist1D(
     const std::string& title,
     const int nBins, const float low, const float high,
     const int id = 0
   );
   virtual HepHist2D & hist2D(
     const std::string& title,
     const int nBinsX, const float lowX, const float highX,
     const int nBinsY, const float lowY, const float highY,
     const int id = 0
   );
   virtual HepHistProf & histProf(
     const std::string& title,
     const int nBinsX, const float lowX, const float highX,
     const float lowY, const float highY, const std::string& chopt,
     const int id = 0
   );
   virtual HepHistProf & histProf(
     const std::string& title,
     const int nBinsX, const float lowX, const float highX,
     const float lowY, const float highY,
     const int id = 0
   );
   virtual HepNtuple & ntuple(
     const std::string& title,
     const int hid = 0
   );
 
   // attach to existing histograms & Ntuples:
   virtual HepHist1D & retrieveHist1D(        // 1-D
     const std::string& title,
     const int hid = 0
   );
   virtual HepHist2D & retrieveHist2D(        // 2-D
     const std::string& title,
     const int hid = 0
   );
   virtual HepHistProf & retrieveHistProf(    // profile plot
     const std::string& title,
     const int hid = 0
   );
   virtual HepNtuple & retrieveNtuple(
     const std::string& title,
     const int hid = 0
   );
 
   // user is finished with the indicated object
   virtual void release( HepObj & me );
 
   // For Unmanaged Root Items.
 
   static HepRootNtuple& deadRootNtuple() ;
   static HepRootHist1D& deadRootHist1D() ;
   static HepRootHist2D& deadRootHist2D() ;
   static HepRootHistProf& deadRootHistProf() ;
 
   // For transparently switching output files at user request.
   // Implemented for the Root manager only!
   virtual bool switchFile( const std::string& newFileName,
                            const bool resetHists );
 
   // For transparently switching output files at user request with a user
   // supplied handler to deal with stray TObjects.
   // Implemented for the Root manager only!
   virtual bool switchFile( const std::string& newFileName,
                            const bool resetHists,
                            HepFileSwitch& userHandler );
 
 protected:
   void init(              // constructor body (shared by both constructors)
     const std::string& fName        //   desired file name
   , HepFileManager::mode req_mode   //   desired opening mode
   , const std::string& rootDir      //   desired name of root directory
   , int compression                 //   desired compression level
   );
 
   static bool init_done;
   void retrieveExistingItems();        // make C++ objects out of items in
                                        // an existing file
   virtual void writeOne( HepObj * o );
 
   // Root specific helper routines.
 
   std::string inFileRootPath( const std::string& path ) const;
   const std::string& CurrentRootPath() const;
 
   // Dead Object creators
   virtual HepNtuple& deadNtuple() const;
   virtual HepHist1D& deadHist1D() const;
   virtual HepHist2D& deadHist2D() const;
   virtual HepHistProf& deadHistProf() const;
 
   bool cloneDir( TDirectory* oldFile, TDirectory* newFile,
                  std::vector<void*>& strays, bool resetHists );
 
   TFile * filep_;
 
 private:
 
   Int4 compression_;
   Int4 writeOption_;
 
 };  // HepRootFileManager
 
 
 ZM_END_NAMESPACE( zmht )        /*  }  // namespace zmht  */
 
 
 #endif  // HEPROOTFILEMANAGER_H
 

This page was automatically generated by the LXR engine. The LXR team