ReadStats.h

Go to the documentation of this file.

// Dear emacs, this is -*- c++ -*-
 
/*
  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
 
// $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