/cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.4.31/xAODCore/xAODCore/tools/ReadStats.h

// Dear emacs, this is -*- c++ -*-
// $Id: ReadStats.h 642099 2015-01-27 16:43:18Z krasznaa $
#ifndef XAODCORE_TOOLS_READSTATS_H
#define XAODCORE_TOOLS_READSTATS_H

// System include(s):
#include <map>
#include <vector>
#include <string>

// ROOT include(s):
#include <TNamed.h>

// EDM include(s):
#ifndef __MAKECINT__
#ifndef __ROOTCLING__
#   include "AthContainersInterfaces/AuxTypes.h"
#endif // not __ROOTCLING__
#endif // not __MAKECINT__

// Forward declaration(s):
class TCollection;
class TTree;
class TH1;

namespace xAOD {

   class BranchStats : public ::TNamed {

   public:
      BranchStats( const char* name = "xAODBranch",
                   const char* type = "Int_t",
                   ::Int_t nTreesAccessed = 0, ::Long64_t nReadEntries = 0,
                   ::Long64_t nUnzippedBytes = 0, ::Long64_t nZippedBytes = 0 );
      BranchStats( const BranchStats& parent );

      BranchStats& operator= ( const BranchStats& parent );


      ::Int_t treesAccessed() const;
      void setTreesAccessed( ::Int_t nTreesAccessed );

      ::Long64_t readEntries() const;
      void setReadEntries( ::Long64_t nReadEntries );

      ::Long64_t unzippedBytesRead() const;
      void setUnzippedBytesRead( ::Long64_t nUnzippedBytes );

      ::Long64_t zippedBytesRead() const;
      void setZippedBytesRead( ::Long64_t nZippedBytes );


      BranchStats& add( const BranchStats& rh );
      BranchStats& operator+= ( const BranchStats& rh );


      ::Int_t Merge( ::TCollection* coll );

      void Print( ::Option_t* option = "" ) const;


   private:
      ::Int_t m_treesAccessed;
      ::Long64_t m_readEntries;
      ::Long64_t m_unzippedBytes;
      ::Long64_t m_zippedBytes;

      ClassDef( xAOD::BranchStats, 1 )

   }; // class BranchStats

   class ReadStats : public ::TNamed {

   public:
      typedef std::vector< BranchStats* > Vector_t;
      typedef std::map< std::string, Vector_t > Map_t;

      typedef std::map< std::string, BranchStats > MapC_t;

      ReadStats( const char* name = "xAODReadStats",
                 const char* title = "xAOD reading statistics" );
      ReadStats( const ReadStats& parent );
      ~ReadStats();

      ReadStats& operator= ( const ReadStats& parent );

      void Clear( ::Option_t* opt = "" );


      void setBytesRead( ::Long64_t num );
      ::Long64_t bytesRead() const;

      void setBranchNum( ::Int_t num );
      ::Int_t branchNum() const;

      void setFileReads( ::Int_t num );
      ::Int_t fileReads() const;

      void setCacheSize( ::Int_t size );
      ::Int_t cacheSize() const;

      void setReadTime( ::Double_t time );
      ::Double_t readTime() const;

      void setUnzipTime( ::Double_t time );
      ::Double_t unzipTime() const;

      void setProcessTime( ::Double_t time );
      ::Double_t processTime() const;



#ifndef __MAKECINT__
#ifndef __ROOTCLING__
      BranchStats* branch( const std::string& prefix,
                           SG::auxid_t auxid );
      const BranchStats* branch( const std::string& prefix,
                                 SG::auxid_t auxid ) const;
#endif // not __ROOTCLING__
#endif // not __MAKECINT__

      BranchStats* container( const std::string& name );
      const BranchStats* container( const std::string& name ) const;

      const Map_t& branches() const;
      const MapC_t& containers() const;



      bool isCompatible( const ReadStats& rh ) const;
      ReadStats& add( const ReadStats& rh );
      ReadStats& operator+= ( const ReadStats& rh );

      ::Int_t Merge( ::TCollection* coll );



      void addToTreeCache( ::TTree* tree ) const;
      void addToTreeCacheByEntries( ::TTree* tree,
                                    ::Long64_t minEntries ) const;
      void addToTreeCacheByEntryFrac( ::TTree* tree,
                                      ::Double_t minEvFraction ) const;
      void addToTreeCacheByBytes( ::TTree* tree, ::Long64_t minBytes ) const;
      void addToTreeCacheByByteFrac( ::TTree* tree,
                                     ::Double_t minByteFraction ) const;



      std::vector< std::string >
      branchesByEntries( ::Long64_t minEntries ) const;
      std::vector< std::string >
      branchesByEntryFrac( ::Double_t minEvFraction ) const;
      std::vector< std::string >
      branchesByBytes( ::Long64_t minBytes ) const;
      std::vector< std::string >
      branchesByByteFrac( ::Double_t minByteFraction ) const;



      ::TH1* treeAccessStat() const;
      ::TH1* entryReadStat() const;
      ::TH1* zippedByteReadStat() const;
      ::TH1* unzippedByteReadStat() const;


      void Print( ::Option_t* option = "" ) const;

      void printSmartSlimmingBranchList( bool autoIncludeLinks = false ) const;

      void nextEvent();

      ::Long64_t nEvents() const;
      void setNEvents( ::Long64_t nevents );

#ifndef __MAKECINT__
#ifndef __ROOTCLING__
      void readBranch( const std::string& prefix,
                       SG::auxid_t auxid );
#endif // not __ROOTCLING__
#endif // not __MAKECINT__

      void readContainer( const std::string& name );

   private:
      Map_t m_branches;
      MapC_t m_containers;

      ::Long64_t m_bytesRead;
      ::Int_t m_branchNum;
      ::Int_t m_fileReads;
      ::Int_t m_cacheSize;
      ::Double_t m_readTime;
      ::Double_t m_unzipTime;
      ::Double_t m_processTime;

      ::Long64_t m_nEvents;
      ::Long64_t m_nEventsProcessed;

      ClassDef( xAOD::ReadStats, 1 )

   }; // class ReadStats

} // namespace xAOD

#endif // XAODCORE_TOOLS_READSTATS_H

---