#include "RootSizeOnDisk.h"

Classes
class	Record

Public Types
using	Records_t = std::vector< Record >

Public Member Functions
	RootSizeOnDisk (std::string const &aFileName, TFile *aFile)

std::string const &	filename () const

Long64_t	size () const

Long64_t	sum () const

double	fraction () const

Records_t const &	contents () const

void	print (std::ostream &os, double minimumFraction) const

Private Member Functions
void	fillLevel2 (Record &, TTree *)

Private Attributes
std::string	fileName_

Long64_t	size_

Long64_t	sum_

double	fraction_

Records_t	contents_

Detailed Description

Definition at line 30 of file RootSizeOnDisk.h.

Member Typedef Documentation

using art::RootSizeOnDisk::Records_t = std::vector<Record>

Definition at line 111 of file RootSizeOnDisk.h.

Constructor & Destructor Documentation

art::RootSizeOnDisk::RootSizeOnDisk	(	std::string const &	aFileName,
		TFile *	aFile
	)

Definition at line 113 of file RootSizeOnDisk.cc.

References contents_, f, fileName_, fillLevel2(), fraction_, art::greaterBySize(), size(), size_, art::detail::sizeOnDisk(), and sum_.

   : fileName_(aFileName), size_(0), sum_(0), fraction_(0)
 {
 
   // File size on disk, in bytes.
   size_ = boost::filesystem::file_size(fileName_.c_str());
 
   // Extract info about top level objects.
   // There are usually Multiple cycles of these objects; we only want each name
   // once.
   set<RootSizeOnDisk::Record> topKeys;
   TList* keys = file->GetListOfKeys();
   TIter iter(keys);
   for_each(iter.Begin(), TIter::End(), MyObjects(topKeys));
 
   // Copy to a vector since we will want to sort them by size.
   contents_.assign(topKeys.begin(), topKeys.end());
 
   // Compute sizes of each top level TTree and TKey.
   for (auto& key : contents_) {
     if (key.isTree()) {
       TTree* tree;
       file->GetObject(key.name().c_str(), tree);
       Long64_t const size = detail::sizeOnDisk(tree);
       sum_ += size;
       double const f = double(size) / double(size_);
       key.size(size);
       key.fraction(f);
       fillLevel2(key, tree);
     } else if (key.isTKey()) {
       TKey* tkey = file->FindKey(key.name().c_str());
       Long64_t const size = tkey->GetNbytes();
       sum_ += size;
       double const f = double(size) / double(size_);
       key.size(size);
       key.fraction(f);
     }
   }
 
   // Sort by decreasing size.
   cet::sort_all(contents_, greaterBySize);
 
   fraction_ = double(sum_) / double(size_);
 }

Member Function Documentation

Records_t const& art::RootSizeOnDisk::contents ( ) const

inline

Definition at line 134 of file RootSizeOnDisk.h.

References art::RootSizeOnDisk::Record::contents_, and print().

     {
       return contents_;
     }

std::string const& art::RootSizeOnDisk::filename ( ) const

inline

Definition at line 114 of file RootSizeOnDisk.h.

References fileName_.

Referenced by print().

     {
       return fileName_;
     }

void art::RootSizeOnDisk::fillLevel2	(	Record &	key,
		TTree *	tree
	)

private

Definition at line 160 of file RootSizeOnDisk.cc.

References art::RootSizeOnDisk::Record::contents(), f, art::greaterBySize(), n, art::RootSizeOnDisk::Record::size(), size(), and art::detail::sizeOnDisk().

Referenced by RootSizeOnDisk().

 {
   TObjArray* branches = tree->GetListOfBranches();
   size_t n = branches->GetEntries();
 
   Records_t branchInfo;
 
   for (size_t i = 0; i < n; ++i) {
     auto subbr = static_cast<TBranch*>(branches->At(i));
     Long64_t const size = detail::sizeOnDisk(subbr, true);
     double const f = double(size) / double(key.size());
     branchInfo.emplace_back(subbr->GetName(), "TBranch", size, f);
   }
 
   cet::sort_all(branchInfo, greaterBySize);
   key.contents(branchInfo);
 }

double art::RootSizeOnDisk::fraction ( ) const

inline

Definition at line 129 of file RootSizeOnDisk.h.

References art::RootSizeOnDisk::Record::fraction_.

     {
       return fraction_;
     }

void art::RootSizeOnDisk::print	(	std::ostream &	os,
		double	minimumFraction
	)		const

Definition at line 62 of file RootSizeOnDisk.cc.

References art::RootSizeOnDisk::Record::contents(), filename(), art::RootSizeOnDisk::Record::fraction(), art::RootSizeOnDisk::Record::size(), and sum().

Referenced by contents().

 {
 
   os << "\nSize on disk for the file: " << filename() << "\n"
      << "Total size on disk: " << size() << "\n"
      << endl;
   os << setw(18) << "Size in bytes" << setw(10) << "   Fraction"
      << " TTree/TKey Name" << endl;
   for (RootSizeOnDisk::Record const& key : contents()) {
     if (key.isTree() || key.isTKey()) {
       os << setw(18) << key.size() << " "
          << boost::format("%10.3f") % key.fraction() << " " << key.name()
          << endl;
     } else {
       os << setw(18) << key.size() << " "
          << boost::format("%10.3f") % key.fraction() << " " << key.name()
          << "  (skipped because not a TTree or a TKey; it is a"
          << key.className() << ")" << endl;
     }
   }
   os << "------------------------------\n"
      << setw(18) << sum() << " " << boost::format("%10.3f") % fraction() << " "
      << "Total\n"
      << endl;
 
   os << "Details for each TTree that occupies more than the fraction "
      << minimumFraction << " of the size on disk.\n"
      << endl;
 
   for (RootSizeOnDisk::Record const& key : contents()) {
     if (key.isTree() && (key.fraction() > minimumFraction)) {
       os << "\nDetails for branch: " << key.name() << "\n" << endl;
       os << setw(18) << "Size in bytes" << setw(10) << "   Fraction"
          << " Data Product Name" << endl;
 
       Long64_t sum(0);
       for (auto const& branch : key.contents()) {
         sum += branch.size();
         os << setw(18) << branch.size() << " "
            << boost::format("%10.3f") % branch.fraction() << " "
            << branch.name() << endl;
       }
       double ratio = double(sum) / double(key.size());
       os << "------------------------------\n"
          << setw(18) << sum << " " << boost::format("%10.3f") % ratio << " "
          << "Total\n"
          << endl;
     }
   }
 }