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 More...
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 More...
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?) More...
std::string	find (const std::string &s)
	return a remapped string More...
int	count (std::string s, const std::string &regx)
	count how many occurances of a regx are in a string More...
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 More...
bool	matchdir (const std::string &s)
	see whether this directory matches any of the directories we are explicitly being asked to match More...
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 More...
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 More...
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 ... More...
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? More...
std::map< std::string, std::string >	remap
	list of directories to be explicitly remapped More...
std::set< std::string >	exclude
	list of directories to be excluded More...
std::map< std::string, int >	dirs
	list of directories to be explicitly included, together with corresponding depths of subdirectories More...
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 211 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 244 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 158 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 287 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 194 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 257 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 273 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 230 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 111 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 921 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 143 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 55 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 320 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 65 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 135 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 127 of file hcg.cxx.

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

main()

int main	(	int	argc,
		char **	argv
	)

if output file is not defined

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 1065 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]);
    }
  }
 
  //  std::cout << "tags " << tags.size() << " " << tags << std::endl;
 
  if ( base == "" ) base = dir;
 
  //  if ( output_file == "" ) return usage( std::cerr, argc, argv );
  
  //  dataset data("test_EF");
  //  files = data.datafiles();
  
 
  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 330 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/";
      //      std::cerr << " " << v[i] << "\np:" << path << "\t-> " << tmp << std::endl;
      tmp = replace( tmp, "/", "__" );
      path += tmp;
      mapped.push_back( path );
      //     std::cerr << i << "\t" << mapped.back() << std::endl;
    }
    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 356 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 402 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 425 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 414 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 389 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 504 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 116 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 105 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 1059 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 297 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 307 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 738 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 = ((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 174 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(s2);
    
    return tags;
}

usage()

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

Definition at line 1034 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 82 of file hcg.cxx.

allhists

bool allhists = true

Definition at line 76 of file hcg.cxx.

ATLAS_NO_CHECK_FILE_THREAD_SAFETY

ATLAS_NO_CHECK_FILE_THREAD_SAFETY

Definition at line 44 of file hcg.cxx.

base

std::string base = "HLT"

Definition at line 78 of file hcg.cxx.

currentfile

std::string currentfile = ""

Definition at line 733 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 88 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 99 of file hcg.cxx.

exclude

std::set<std::string> exclude

list of directories to be excluded

Definition at line 95 of file hcg.cxx.

files

std::vector<std::string> files

file names and file pointers

Definition at line 47 of file hcg.cxx.

found_dir

bool found_dir = false

Definition at line 731 of file hcg.cxx.

fptr

std::vector<TFile*> fptr

Definition at line 48 of file hcg.cxx.

mapped

std::vector<std::string> mapped

Definition at line 51 of file hcg.cxx.

outp

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

send output to here ...

Definition at line 73 of file hcg.cxx.

outref

std::string outref = ""

Definition at line 80 of file hcg.cxx.

refblock

std::vector<std::string> refblock

Definition at line 1057 of file hcg.cxx.

references

std::vector<reference> references

Definition at line 522 of file hcg.cxx.

remap

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

list of directories to be explicitly remapped

Definition at line 92 of file hcg.cxx.

savedhistos

std::vector<std::string> savedhistos

Definition at line 50 of file hcg.cxx.

tags

std::vector<std::string> tags

Definition at line 102 of file hcg.cxx.

verbose

bool verbose = false

Definition at line 70 of file hcg.cxx.