hcg.cxx File Reference

#include <iostream>
#include <vector>
#include <string>
#include <map>
#include <set>
#include <cstdlib>
#include <cstdio>
#include <fstream>
#include <sys/stat.h>
#include "simpletimer.h"
#include "node.h"
#include "addnode.h"
#include "spacer.h"
#include "TStyle.h"
#include "TCanvas.h"
#include "TKey.h"
#include "TH1D.h"
#include "TH2D.h"
#include "TProfile.h"
#include "TFile.h"
#include "TClass.h"
#include "TDirectory.h"
#include "TPad.h"
#include <algorithm>
#include "CxxUtils/checker_macros.h"

Go to the source code of this file.

Classes
class	reference
class	header
class	menu
	make the sidebar many part of the config More...
class	ass
	make the histogram assessment part of the config More...

Functions
std::string	date ()
	sadly, includes a return at the end
bool	file_exists (const std::string &file)
template<typename T>
std::ostream &	operator<< (std::ostream &s, const std::vector< T > &v)
bool	contains (const std::string &s, const std::string &regx)
	does a string contain the substring
template<typename T>
std::ostream &	operator<< (std::ostream &s, const std::vector< T * > &v)
template<class T>
T *	get (TKey *tobj)
	get a TObject* from a TKey* (why can't a TObject be a TKey?)
std::string	find (const std::string &s)
	return a remapped string
int	count (std::string s, const std::string &regx)
	count how many occurances of a regx are in a string
std::string	chop (std::string &s1, const std::string &s2)
std::vector< std::string >	split (const std::string &s, const std::string &t=":")
std::string	chopex (std::string &s1, const std::string &s2)
std::string	chomp (std::string &s1, const std::string &s2)
std::string	choptoken (std::string &s1, const std::string &s2)
std::string	chomptoken (std::string &s1, const std::string &s2)
std::string	chopfirst (std::string &s1, const std::string &s2)
std::string	choplast (std::string &s1, const std::string &s2)
std::string	chopends (std::string &s1, const std::string &s2)
void	removespace (std::string &s, const std::string &s2)
std::string	replace (std::string s, const std::string &s2, const std::string &s3)
void	depunctuate (std::string &s, const std::string &regex=":")
std::vector< std::string >	maphist (const std::vector< std::string > &v)
bool	match (std::string s1, std::string s2)
	match the individual directories of two strings
bool	matchdir (const std::string &s)
	see whether this directory matches any of the directories we are explicitly being asked to match
bool	matchcwd (const std::string &s)
std::string	matchcwdstr (const std::string &s)
std::map< std::string, int >::const_iterator	matchcwditr (const std::string &s)
std::ostream &	operator<< (std::ostream &s, const reference &r)
void	search (TDirectory *td, const std::string &s, std::string cwd, node *n)
	recursive directory search for TH1 and TH2 and TProfiles
int	cost (std::vector< std::string > &files, node &n, const std::string &directory="", bool deleteref=false, bool relocate=false)
int	usage (std::ostream &s, int, char **argv, int status=-1)
void	referenceblock (const std::string &file)
int	main (int argc, char **argv)

Variables
	ATLAS_NO_CHECK_FILE_THREAD_SAFETY
std::vector< std::string >	files
	file names and file pointers
std::vector< TFile * >	fptr
std::vector< std::string >	savedhistos
std::vector< std::string >	mapped
bool	verbose = false
std::ostream *	outp = &std::cout
	send output to here ...
bool	allhists = true
std::string	base = "HLT"
std::string	outref = ""
std::string	algorithm = "HLT_Histogram_Not_Empty&GatherData"
std::string	description = "https://twiki.cern.ch/twiki/bin/view/Atlas/HltTrackingDataQualityMonitoring#Tier0"
	glabal timer - how long have I taken so far?
std::map< std::string, std::string >	remap
	list of directories to be explicitly remapped
std::set< std::string >	exclude
	list of directories to be excluded
std::map< std::string, int >	dirs
	list of directories to be explicitly included, together with corresponding depths of subdirectories
std::vector< std::string >	tags
std::vector< reference >	references
bool	found_dir = false
std::string	currentfile = ""
std::vector< std::string >	refblock

Function Documentation

chomp()

std::string chomp	(	std::string &	s1,
		const std::string &	s2 )

Definition at line 214 of file hcg.cxx.

{
  std::string::size_type pos = s1.find(s2);
  std::string s3;
  if ( pos == std::string::npos ) {
    s3 = s1;
    s1.clear();
  }
  else {
    s3 = s1.substr(pos+s2.size(),s1.size());
    s1.erase(pos,s1.size()); 
  } 
  return s3;
} 

chomptoken()

std::string chomptoken	(	std::string &	s1,
		const std::string &	s2 )

Definition at line 247 of file hcg.cxx.

{
  std::string s3 = "";
  std::string::size_type pos = s1.find(s2);
  if ( pos != std::string::npos ) {
    s3 = s1.substr(pos, s1.size());
    s1.erase(pos, s1.size()); 
  }
  return s3;
} 

chop()

std::string chop	(	std::string &	s1,
		const std::string &	s2 )

Definition at line 161 of file hcg.cxx.

{
  std::string::size_type pos = s1.find(s2);
  std::string s3;
  if ( pos == std::string::npos ) {
    s3 = s1;
    s1.erase(0, s1.size());
  }
  else {
    s3 = s1.substr(0, pos); 
    s1.erase(0, pos+s2.size());
  }
  return s3;
} 

chopends()

std::string chopends	(	std::string &	s1,
		const std::string &	s2 )

Definition at line 290 of file hcg.cxx.

{
  chopfirst(s1, s2);
  choplast(s1, s2);
  return s1;
} 

chopex()

std::string chopex	(	std::string &	s1,
		const std::string &	s2 )

Definition at line 197 of file hcg.cxx.

{
  std::string::size_type pos = s1.find(s2);
  std::string s3;
  if ( pos == std::string::npos ) {
    s3 = s1;
    s1.clear();
  }
  else {
    s3 = s1.substr(0, pos); 
    s1.erase(0, pos+s2.size());
  }
  return s3;
} 

chopfirst()

std::string chopfirst	(	std::string &	s1,
		const std::string &	s2 )

Definition at line 260 of file hcg.cxx.

{
  std::string s3;
  std::string::size_type pos = s1.find_first_not_of(s2);
  if ( pos != std::string::npos ) {
    s3 = s1.substr(0, pos); 
    s1.erase(0, pos);
  }
  else {
    s3 = s1;
    s1.clear();
  } 
  return s3;
} 

choplast()

std::string choplast	(	std::string &	s1,
		const std::string &	s2 )

Definition at line 276 of file hcg.cxx.

{
  std::string s3 = "";
  std::string::size_type pos = s1.find_last_not_of(s2);
  if ( pos != std::string::npos ) {
    s3 = s1.substr(pos+1, s1.size());
    s1.erase(pos+1, s1.size());
  }
  return s3;
} 

choptoken()

std::string choptoken	(	std::string &	s1,
		const std::string &	s2 )

Definition at line 233 of file hcg.cxx.

{
  std::string s3 = "";
  std::string::size_type pos = s1.find(s2);
  if ( pos != std::string::npos ) {
    s3 = s1.substr(0, pos+s2.size()); 
    s1.erase(0, pos+s2.size());
  }
  return s3;
} 

contains()

bool contains	(	const std::string &	s,
		const std::string &	regx )

does a string contain the substring

Definition at line 114 of file hcg.cxx.

{ return s.find(regx)!=std::string::npos; } 

cost()

int cost	(	std::vector< std::string > &	files,
		node &	n,
		const std::string &	directory = "",
		bool	deleteref = false,
		bool	relocate = false )

open the output file

navigate the directory structure to extracting all the info

if asked to delete the unused referenece then do so if however asked to relocate the histgrams, simply modify the list of histogram destinations first

std::cerr << "\t" << dirs[jh] << std::endl;

Definition at line 922 of file hcg.cxx.

                                                                                                                            { 
 
  std::cerr << "processing ..." << std::endl;
 
  //  std::cerr << "opening root files" << std::endl;
 
  fptr.resize(files.size());
 
 
  for ( unsigned i=0 ; i<files.size() ; i++ ) { 
 
    currentfile = files[i];
 
    std::cerr << "opening " << currentfile << std::endl;
 
    if ( !contains( files[i], "root://eosatlas") && !file_exists( files[i] ) ){ 
      std::cerr << "file " << files[i] << " does not exist" << std::endl;
      return -1;    
    }
    
    fptr[i] = TFile::Open( files[i].c_str() );
    
    if ( fptr[i]==0 || fptr[i]->IsZombie() ) { 
      std::cerr << "file " << files[i] << " cannot be opened" << std::endl;
      return -1;
    }
  
    fptr[i]->cd();
 
    if ( directory!="" ) fptr[i]->cd(directory.c_str());    
 
    TDirectory* here = gDirectory;
    
    //    global_timer = simpletimer_start();
 
    //    int tcount = 0;

 
    search( gDirectory, "", "", &n );
 
    here->cd();
    

    if ( deleteref || relocate ) { 
 
      std::cerr << "remapping" << std::endl;
 
      if ( relocate ) mapped = maphist( savedhistos );
      
      if ( relocate && !deleteref ) std::cerr << "saving histograms to file .newhist.root ... " << std::endl;
 
      if ( outref=="" ) outref = ".newhist.root";
      TFile* fnew = new TFile( outref.c_str(), "recreate" );
      fnew->cd();
 
      TDirectory*  base = gDirectory;
 
      if ( mapped.size() != savedhistos.size() ) mapped = savedhistos;
 
      for ( unsigned ih=0 ; ih<savedhistos.size() ; ih++ ) { 
    
    std::vector<std::string> dirs = split( mapped[ih], "/" );
 
    for ( unsigned jh=0 ; jh<dirs.size()-1 ; jh++ ) { 
      TDirectory* renedir = gDirectory->GetDirectory( dirs[jh].c_str() );
      if ( renedir==0 ) gDirectory->mkdir( dirs[jh].c_str() );
      gDirectory->cd( dirs[jh].c_str() );
    }
    
    TH1* href  = (TH1*)fptr[i]->Get( savedhistos[ih].c_str() );
    if ( href ) {
      //      std::cerr << ih << " " << savedhistos[ih] << " 0x" << href << std::endl;
      href->Write( dirs.back().c_str() );
    }
 
    base->cd();
      }
 
 
    }
 
    std::cerr << "closing files" << std::endl; 
        
    fptr[i]->Close();
 
    delete fptr[i];
 
    if ( deleteref ) { 
      if ( outref==".newhist.root" ) { 
    std::cerr << "replacing histogram file" << std::endl;
    std::string cmd = std::string("mv ") + files[i] + " " + files[i] + ".bak";
    std::system( cmd.c_str() );
    cmd = std::string("mv .newhist.root ") + files[i];
    std::system( cmd.c_str() );
      }
    }
    
  }
 
  return 0;
}

count()

int count	(	std::string	s,
		const std::string &	regx )

count how many occurances of a regx are in a string

Definition at line 146 of file hcg.cxx.

                                                {
  size_t p = s.find( regx );
  int i=0;
  while ( p!=std::string::npos ) {
    i++;
    s.erase( 0, p+1 );
    p = s.find( regx );
  } 
  return i;
}

date()

std::string date

(

)

sadly, includes a return at the end

Definition at line 58 of file hcg.cxx.

                 { 
  time_t t;
  time(&t);
  std::string a = ctime(&t);
  std::string b = "";
  for ( unsigned i=0 ; i<a.size()-1 ; i++ ) b+=a[i];
  return b;
}

depunctuate()

void depunctuate	(	std::string &	s,
		const std::string &	regex = ":" )

Definition at line 323 of file hcg.cxx.

                                                       :") 
{
  std::string::size_type pos;
  while ( (pos = s.find(regex))!=std::string::npos ) {
    s.erase(pos, regex.size());
  }
} 

file_exists()

bool file_exists

(

const std::string &

file

)

Definition at line 68 of file hcg.cxx.

                                          { 
  struct stat buff;
  return stat(file.c_str(),&buff)==0;   
}

find()

std::string find

(

const std::string &

s

)

return a remapped string

Definition at line 138 of file hcg.cxx.

                                     { 
  std::map<std::string, std::string>::const_iterator itr = remap.find(s);
  if ( itr!=remap.end() ) return itr->second;
  else                    return s;
} 

get()

template<class T>

T * get

(

TKey *

tobj

)

get a TObject* from a TKey* (why can't a TObject be a TKey?)

Definition at line 130 of file hcg.cxx.

                     { 
  TObject* a = tobj->ReadObj()->Clone();
  static_cast<TH1*>(a)->SetDirectory(0);
  return static_cast<T*>(a);
}

main()

int main	(	int	argc,
		char **	argv )

check some input files

create the structure ...

create the side bar menu part

create the histogram assessment part

ensure that buffer is properly flushed

Definition at line 1066 of file hcg.cxx.

                                { 
 
  //  std::string cock = "HLT_j150_bperf_split/InDetTrigTrackingxAODCnv_BjetPrmVtx_FTF_SuperRoi/Chain"; 
 
  //  replace 
 
  //  std::cout << replace 
 
  gStyle->SetPadRightMargin(0.05);
  gStyle->SetPadTopMargin(0.075);
 
  //  TCanvas* tg = new TCanvas("tg", "tg", 650, 900 );
  TCanvas* tg = new TCanvas("tg", "tg", 700, 600 );
  tg->cd();
 
  gStyle->SetStatY(0.4);                
  // Set y-position (fraction of pad size)
  gStyle->SetStatX(0.89);                
  // Set x-position (fraction of pad size)
  gStyle->SetStatW(0.25);                
  // Set width of stat-box (fraction of pad size)
  gStyle->SetStatH(0.16);      
 
 
  //  if ( argc<3 ) usage( std::cerr << "not enough command options", argc, argv );
  if ( argc<2 ) return usage( std::cerr, argc, argv );
 
 
  for ( int i=1 ; i<argc ; i++ ) { 
    if ( std::string(argv[i])=="-h" || std::string(argv[i])=="--help" )  return usage( *outp, argc, argv, 0 ); 
  }
  
  std::string dir = "";
 
  std::vector<std::string> subdirs;
 
 
  bool deleteref = false;
  bool relocate  = false;
 
  std::string outfile = "";
 
  int offset = 1;
 
 
  for ( int i=1 ; i<argc ; i++ ) { 
    if      ( std::string(argv[i])=="-v" || std::string(argv[i])=="--verbose" ) verbose = true;
    else if ( std::string(argv[i])=="-o" ) {
      ++i;
      if ( i<argc-offset ) outfile = argv[i];
      else  return usage( std::cerr, argc, argv );
    } 
    else if ( std::string(argv[i])=="-or" || std::string(argv[i])=="--outrefr" ) {
      ++i;
      if ( i<argc-offset ) outref = argv[i];
      else  return usage( std::cerr, argc, argv );
    } 
    else if ( std::string(argv[i])=="-ref" || std::string(argv[i])=="--reference" ) {
      std::string reftag;
      std::string reffile;
      ++i;
      if ( i<argc-offset ) reftag = argv[i];
      else  return usage( std::cerr, argc, argv );
      ++i;
      if ( i<argc-offset ) reffile = argv[i];
      else  return usage( std::cerr, argc, argv );
      references.push_back( reference( reftag, reffile ) ); 
      //      std::cerr << references.back() << std::endl;
    } 
    else if ( std::string(argv[i])=="-rc" || std::string(argv[i])=="-refconf" ) {
      ++i;
      if ( i<argc-offset ) referenceblock( argv[i] );
      else  return usage( std::cerr, argc, argv );
    } 
    else if ( std::string(argv[i])=="-dr"  || std::string(argv[i])=="--deleteref" ) deleteref = true;
    else if ( std::string(argv[i])=="-rh"  || std::string(argv[i])=="--relocate" )  relocate  = true;
    else if ( std::string(argv[i])=="-wc"  || std::string(argv[i])=="--wildcard"  )  allhists = false;
    else if ( std::string(argv[i])=="-d"   || std::string(argv[i])=="--dir"       ) {
      ++i;
      
      if ( i<argc-offset ) { 
    std::string stringdir(argv[i]);
      dirs.insert( std::map<std::string,int>::value_type( stringdir, std::count( stringdir.begin(), stringdir.end(), '/' ) ) );
      
      std::string tdir = argv[i];
      
      //      std::cerr << "dirs " << argv[i] << std::endl;
      
      do { 
        subdirs.push_back( chop( tdir, "/" ) );
        //   std::cerr << "chop  " << subdirs.back() << std::endl;
      }
      while ( tdir.size() ); 
      }
      else  return usage( std::cerr, argc, argv );
    } 
    else if ( std::string(argv[i])=="-x" ) {
      ++i;
      if ( i<argc-offset ) exclude.insert( argv[i] );
      else  return usage( std::cerr, argc, argv );
    } 
    else if ( std::string(argv[i])=="-ds" || std::string(argv[i]).find("--desc")==0 ) {
      ++i;
      if ( i<argc-offset ) description = argv[i];
      else  return usage( std::cerr, argc, argv );
    } 
    else if ( std::string(argv[i])=="-b" || std::string(argv[i])=="--base" ) {
      ++i;
      if ( i<argc-offset ) base = argv[i] ;
      else  return usage( std::cerr, argc, argv );
    } 
    else if ( std::string(argv[i])=="-a" || std::string(argv[i])=="--algorithm" ) {
      ++i;
      if ( i<argc-offset ) algorithm = argv[i] ;
      else  return usage( std::cerr, argc, argv );
    } 
    //    else if ( std::string(argv[i])=="-o" ) { 
    //    ++i;
    //    if ( i<argc ) output_file = argv[i];
    //   else  return usage( std::cerr, argc, argv );
    //   }
    else if ( std::string(argv[i])=="-t" || std::string(argv[i])=="--tag" ) {
      ++i;
      if ( i<argc-offset ) tags.push_back( argv[i] );
      else  return usage( std::cerr, argc, argv );
    } 
    else if ( std::string(argv[i])=="-r" ) { 
      std::string src;
      std::string dest;
      if ( i<argc+2-offset ) { 
    src  = argv[++i];
    dest = argv[++i];
    remap.insert( std::map<std::string,std::string>::value_type( src, dest ) );
      } else return usage( std::cerr, argc, argv );
    }
    else { 
      offset = 0;
      files.push_back(argv[i]);
    }
  }
 
 
  if ( base == "" ) base = std::move(dir);
 
  
 
  if ( files.size()<1 ) return usage( std::cerr, argc, argv );
  
 
  //  time the actual running of the cost() routine
  
  if ( verbose ) std::cerr << "timing" << std::endl;
 
  struct timeval tv = simpletimer_start();

 
  node n(0, "" );
  n.name( "top_level" );
 
  int status = cost( files, n, "", deleteref, relocate );
 
  //  std::cerr << "\n\nnodes " << n << std::endl;
 
  if ( status ) return status;
 
  if ( outfile!="" ) outp = new std::ofstream(outfile.c_str()); 
 
  header h;
 
  for ( unsigned ir=0 ; ir<references.size() ; ir++ ) (*outp) << references[ir] << std::endl; 
 
  if ( refblock.size() ) (*outp) << refblock << std::endl;

  menu m( n );

  ass( n, allhists );

  (*outp) << std::endl;
 
  double t = simpletimer_stop(tv);
  
  if ( t>1000 ) std::cerr << "total time " << t*0.001 << " s"  << std::endl;
  else          std::cerr << "total time " << t       << " ms" << std::endl;
 
  return 0;
}

maphist()

std::vector< std::string > maphist

(

const std::vector< std::string > &

v

)

Definition at line 333 of file hcg.cxx.

                                                              {   
  mapped.clear();
  for ( unsigned i=0 ; i<v.size() ; i++ ) { 
    if ( contains( v[i], "Expert" ) ){ 
      std::string tmp = v[i];
      std::string path = chop( tmp, "Expert/" );
      path += "Chains/";
      tmp = replace( tmp, "/", "__" );
      path += tmp;
      mapped.push_back( std::move(path) );
    }
    else { 
      mapped.push_back( v[i] );
    }
  }
 
  return mapped;
}

match()

bool match	(	std::string	s1,
		std::string	s2 )

match the individual directories of two strings

Definition at line 357 of file hcg.cxx.

                                         { 
  
  int i1 = std::count( s1.begin(), s1.end(), '/' );
  int i2 = std::count( s2.begin(), s2.end(), '/' );
 
  int i = ( i1<i2 ? i1 : i2 ); 
 
  //  std::cerr << "match s1 " << s1 << " " << s2 << std::endl;
 
  for ( i++ ; i-- ; ) { 
    size_t p1 = s1.find('/');
    size_t p2 = s2.find('/');
 
    std::string ss1 = s1.substr( 0, p1 );
    std::string ss2 = s2.substr( 0, p2 );
    
    s1.erase( 0, p1+1 );
    s2.erase( 0, p2+1 );
 
    //    std::cerr << i << "\tmatch :" << ss1 << ":" << ss2 << "::\t " << s1 << ":" << s2 << "\tresult " << (ss1!=ss2 ) << std::endl;
    
    if ( ss1!=ss2 ) return false;
 
  } 
  
  return true;
 
}

matchcwd()

bool matchcwd

(

const std::string &

s

)

Definition at line 403 of file hcg.cxx.

                                    { 
  if ( dirs.size()==0 ) return true; 
  std::map<std::string,int>::const_iterator itr = dirs.begin();
  while ( itr!=dirs.end() ) { 
    if ( s.find(itr->first)!=std::string::npos ) return true;
    ++itr;
  }
  return false;
}

matchcwditr()

std::map< std::string, int >::const_iterator matchcwditr

(

const std::string &

s

)

Definition at line 426 of file hcg.cxx.

                                                                      { 
  if ( dirs.size()==0 ) return dirs.end(); 
  std::map<std::string,int>::const_iterator itr = dirs.begin();
  while ( itr!=dirs.end() ) { 
    if ( s.find(itr->first)!=std::string::npos ) return itr;
    ++itr;
  }
  return dirs.end();
}

matchcwdstr()

std::string matchcwdstr

(

const std::string &

s

)

Definition at line 415 of file hcg.cxx.

                                            { 
  if ( dirs.size()==0 ) return ""; 
  std::map<std::string,int>::const_iterator itr = dirs.begin();
  while ( itr!=dirs.end() ) { 
    if ( s.find(itr->first)!=std::string::npos ) return itr->first;
    ++itr;
  }
  return "";
}

matchdir()

bool matchdir

(

const std::string &

s

)

see whether this directory matches any of the directories we are explicitly being asked to match

Definition at line 390 of file hcg.cxx.

                                    { 
  bool matched = false;
  // int idepth = count( s, "/" );
  std::map<std::string,int>::const_iterator itr = dirs.begin();
  while ( itr!=dirs.end() ) { 
    if ( match( s, itr->first) ) matched = true;
    //    std::cerr << "\tmatchdir :" << s << "::" << itr->first << ": " << itr->second << std::endl;
    if ( matched ) return true;
    ++itr;
  }
  return false;
}

operator<<() [1/3]

std::ostream & operator<<	(	std::ostream &	s,
		const reference &	r )

Definition at line 505 of file hcg.cxx.

                                                            { 
  static bool first = true;
  if ( first ) { 
    s << "##########################\n";
    s << "# References\n";
    s << "##########################\n\n";
    first = false;
  }
  s << "reference "      << r.name() << " {\n";
  s << "\t\tfile = "     << r.file() << "\n";
  s << "\t\tpath = run_" << r.run()  << "\n";
  s << "\t\tname = same_name"        << "\n";
  s << "}\n\n";
  return s;
}

operator<<() [2/3]

template<typename T>

std::ostream & operator<<	(	std::ostream &	s,
		const std::vector< T * > &	v )

Definition at line 119 of file hcg.cxx.

                                                                {
  if ( v.empty() ) return s;
  for ( int i=0 ; i<v.size() ; i++ ) s << *v[i] << "\n";
  return s;
}

operator<<() [3/3]

template<typename T>

std::ostream & operator<<	(	std::ostream &	s,
		const std::vector< T > &	v )

Definition at line 108 of file hcg.cxx.

                                                               {
  if ( v.empty() ) return s;
  for ( size_t i=0 ; i<v.size() ; i++ ) s << v[i] << "\n";
  return s;
}

referenceblock()

void referenceblock

(

const std::string &

file

)

Definition at line 1060 of file hcg.cxx.

                                             { 
  std::ifstream strm(file.c_str());
  for ( std::string line ; getline( strm, line ); ) refblock.push_back( line );
} 

removespace()

void removespace	(	std::string &	s,
		const std::string &	s2 )

Definition at line 300 of file hcg.cxx.

{
  std::string::size_type pos;
  while ( (pos = s.find(s2))!=std::string::npos ) {
    s.erase(pos, s2.size());
  }
} 

replace()

std::string replace	(	std::string	s,
		const std::string &	s2,
		const std::string &	s3 )

Definition at line 310 of file hcg.cxx.

                                                                          {
  std::string::size_type pos;
  //  while ( (pos = s.find(" "))!=std::string::npos ) {
  //    s.replace(pos, 1, "-");
  while ( (pos = s.find(s2))!=std::string::npos ) {
    s.replace(pos, s2.size(), s3);
    if ( contains(s3,s2) ) break;
  }
  return s;
} 

search()

void search	(	TDirectory *	td,
		const std::string &	s,
		std::string	cwd,
		node *	n )

recursive directory search for TH1 and TH2 and TProfiles

not a directory

don't go more than 10 directories deep

go through sub directories

descend into the subdirectory ...

if this is a directory we want, print (*outp) the histograms

get the full path to this object path relative to the file

save the histograms in case we need to save the, later ...

keep the max number of entries updated

Definition at line 739 of file hcg.cxx.

                                                                          { 

  if ( td==0 ) return;
 
  if ( std::string(td->GetName()).find("_LB")!=std::string::npos ) return;
  if ( std::string(td->GetName()).find("lb_")!=std::string::npos ) return;
 
  //  std::cout << "search() in  " << s << td->GetName() << ":    :" << cwd << ":" << std::endl;
 
  static int ir = 0;
 
  ir++;

 
  if ( ir>10 ) { 
    std::cerr << "search() WARNING too many levels of directories (max 10) !!!\n";
    return;
  }
 
 
  TDirectory* here = gDirectory;
 
  //  gDirectory->pwd();
 
  td->cd();
  
  if ( cwd!="" ) cwd += "/";
  cwd += td->GetName();
 
  node* np = n;
 
  std::string fulldir = td->GetName();
 
 
  bool first_found = false;
  if ( !found_dir && matchcwd( cwd ) ) {
 
    std::string ase = matchcwdstr( cwd );
 
    if ( (cwd+"/").find( ase+"/" )!=std::string::npos ) { 
    
      found_dir   = true;
      first_found = true;
      
      std::cerr << "matched dirs " << cwd << " " << matchdir( cwd ) << std::endl;
      
      
      std::map<std::string,int>::const_iterator fitr = matchcwditr( cwd );
      
      if ( fitr!=dirs.end() ) { 
    
    if ( fitr->second>0 ) { 
      
      std::vector<std::string> subpath;
      
      std::string sp = fitr->first; 
      
      while( sp.size() ) subpath.push_back( chop(sp,"/") ); 
      
      for ( unsigned ip=0 ; ip<subpath.size()-1 ; ip++ ) { 
        //      std::cerr << "subpath " << ip << " " << subpath[ip] << std::endl;
        
        node* np_ = addnode( np, subpath[ip] );
        
        np = np_;
        
      }
    }
      }
      
    }
  }
  
 
  if ( found_dir ) { 
    node* np_ = addnode( np, fulldir, td );
    np = np_;
  }
 
  if ( found_dir && verbose ) std::cerr << s << cwd << std::endl;
 
 
  TList* tl  = gDirectory->GetListOfKeys();
  
  //  struct timeval tv = simpletimer_start();
  
  //  (*outp) << "\ttl " << tl << std::endl;
  
 
  for ( int i=0 ; i<tl->GetSize() ; i++ ) { 
    
    TKey* tobj = (TKey*)tl->At(i);
    
    if ( tobj==0 ) continue;
    
    //    (*outp) << "tobj " << tobj;
    //    if ( tobj ) (*outp) << " : \t" << tobj->GetName();
    //    (*outp) << std::endl; 
    
    if ( std::string(tobj->GetClassName()).find("TDirectory")!=std::string::npos ) { 
      //      (*outp) << ns << "Directory " << tobj->GetName() << std::endl;
      
      TDirectory* tnd = (TDirectory*)tobj->ReadObj();
      

      if ( tnd )  search( tnd, s+spacer, cwd, np );
    
    }
    else { 

 
      if ( found_dir ) { 
    if ( std::string(tobj->GetClassName()).find("TH1")!=std::string::npos ||
         std::string(tobj->GetClassName()).find("TH2")!=std::string::npos ||
         std::string(tobj->GetClassName()).find("TProfile")!=std::string::npos ) {
      
      //      TH1* th = (TH1*)tobj->ReadObj();
 
      //      node* h = addnode( np, "", get<TObject>(tobj), node::HISTOGRAM );
      // node* h = 
      addnode( np, tobj->GetName(), get<TObject>(tobj), node::HISTOGRAM );
      

      std::string subdir = cwd;
      chop( subdir, currentfile+"/" );

      savedhistos.push_back( subdir+"/"+tobj->GetName() );

      if ( std::string(tobj->GetName())=="Chain" ) { 
        double N = static_cast<TH1*>(get<TObject>(tobj))->GetEntries();
 
        //      std::cout << "entries " << np->name() << " " << " " << np->parent()->name() << " " << N << std::endl;
        //    std::cout << "\tentries " << np->parent()->name() << "/" << np->name() << "\t" << N << std::endl;
        std::cout << "\t" << subdir << "\t" << N << std::endl;
 
        node* p  = np->parent();
        if ( p && p->name()!="Shifter" ) { 
 
          p->addrate( p->name(), N );
 
          node* p2 = p->parent();
          if ( p2 ) p2->addrate( p->name(), N ); 
        }
      }
 
    }
    
    //      if ( !status ) std::cerr << "bad status" << std::endl;
      }
    }
    
  }
  
 
  //  double _t = simpletimer_stop(tv);
  
  //  double global_time = simpletimer_stop(global_timer);
    
  ir--;
    
  here->cd();
  
  if ( first_found ) found_dir = false;
 
}

split()

std::vector< std::string > split	(	const std::string &	s,
		const std::string &	t = ":" )

Definition at line 177 of file hcg.cxx.

                                                                    :"  ) {
    
    std::string s2 = s;
    size_t pos = s2.find(t);
    
    std::vector<std::string> tags;
    
    while ( pos!=std::string::npos ) { 
      tags.push_back( chop(s2,t) );
      pos = s2.find(t);
    }
    
    tags.push_back(std::move(s2));
    
    return tags;
}

usage()

int usage	(	std::ostream &	s,
		int	,
		char **	argv,
		int	status = -1 )

Definition at line 1035 of file hcg.cxx.

                                                           { 
  s << "Usage: " << argv[0] << " [OPTIONS] input1.root ... inputN.root\n\n";
  s << "    -o             FILENAME  \tname of output (filename required)\n";
  s << "    -b,   --base   DIR       \tuse directory DIR as the base for the han config\n";
  s << "    -d,   --dir    DIR       \tonly directories below DIR where DIR is a structure such as HLT/TRIDT etc\n";
  s << "    -x,            DIR       \texclude directory DIR\n";
  s << "    -r             SRC DST   \tremap directory SRC to directory DST\n"; 
  s << "    -ds,  --desc   DESCRIP   \tuse DESCRIP as the description\n"; 
  s << "    -t,   --tag    VALUE     \tadd the VALUE to the list of command per histogram\n";
  s << "    -a,   --algorithm VALUE  \tuse VALUE as the execution algorithm for each histogram\n";
  s << "    -wc,  --wildcard         \tprint use hist * rather than a separate entry for each histogram\n";
  s << "    -dr,  --deleteref        \tdelete unselected histograms\n";
  s << "    -or,  --outref FILENAME  \tdelete file to write reduced output to (overwrites input otherwise) \n";
  s << "    -rh,  --relocate         \trelocate selected histograms\n";
  s << "    -ref, --reference TAG FILE \tadd FILE as a reference file with tag TAG\n";
  s << "    -rc,  --refconf       FILE \tadd FILE to the config as a reference block\n";
  s << "    -v,   --verbose          \tprint verbose output\n";
  s << "    -h,   --help             \tdisplay this help\n";
  s << std::endl;
  return status;
}

Variable Documentation

algorithm

std::string algorithm = "HLT_Histogram_Not_Empty&GatherData"

Definition at line 85 of file hcg.cxx.

allhists

bool allhists = true

Definition at line 79 of file hcg.cxx.

ATLAS_NO_CHECK_FILE_THREAD_SAFETY

ATLAS_NO_CHECK_FILE_THREAD_SAFETY

Definition at line 47 of file hcg.cxx.

base

std::string base = "HLT"

Definition at line 81 of file hcg.cxx.

currentfile

std::string currentfile = ""

Definition at line 734 of file hcg.cxx.

description

std::string description = "https://twiki.cern.ch/twiki/bin/view/Atlas/HltTrackingDataQualityMonitoring#Tier0"

glabal timer - how long have I taken so far?

Definition at line 91 of file hcg.cxx.

dirs

std::map<std::string, int> dirs

list of directories to be explicitly included, together with corresponding depths of subdirectories

Definition at line 102 of file hcg.cxx.

exclude

std::set<std::string> exclude

list of directories to be excluded

Definition at line 98 of file hcg.cxx.

files

std::vector<std::string> files

file names and file pointers

Definition at line 50 of file hcg.cxx.

found_dir

bool found_dir = false

Definition at line 732 of file hcg.cxx.

fptr

std::vector<TFile*> fptr

Definition at line 51 of file hcg.cxx.

mapped

std::vector<std::string> mapped

Definition at line 54 of file hcg.cxx.

outp

std::ostream* outp = &std::cout

send output to here ...

Definition at line 76 of file hcg.cxx.

outref

std::string outref = ""

Definition at line 83 of file hcg.cxx.

refblock

std::vector<std::string> refblock

Definition at line 1058 of file hcg.cxx.

references

std::vector<reference> references

Definition at line 523 of file hcg.cxx.

remap

std::map<std::string, std::string> remap

list of directories to be explicitly remapped

Definition at line 95 of file hcg.cxx.

savedhistos

std::vector<std::string> savedhistos

Definition at line 53 of file hcg.cxx.

tags

std::vector<std::string> tags

Definition at line 105 of file hcg.cxx.

verbose

bool verbose = false

Definition at line 73 of file hcg.cxx.