histCollection Class Reference

Collaboration diagram for histCollection:

Classes
class	histPerDir_t
struct	histDir_t

Public Member Functions
	histCollection (bool debug=false)
void	addDirectory (TDirectory *dir, const std::string &dirName)
size_t	size ()
void	addFile (TFile *in)
void	print ()
void	write (TFile *out)
void	addExclusion (const std::string &dir)

Private Member Functions
bool	isExcluded (const std::string &dir)

Private Attributes
std::map< std::string, histDir_t, std::less<> >	m_data
bool	m_dbg
std::vector< std::string >	m_exclusion

Detailed Description

Definition at line 51 of file LArQuickHistMerge.cxx.

Constructor & Destructor Documentation

histCollection()

histCollection::histCollection ( bool debug = false )

inlineexplicit

Definition at line 55 of file LArQuickHistMerge.cxx.

: m_dbg(debug) {};

Member Function Documentation

addDirectory()

void histCollection::addDirectory	(	TDirectory *	dir,
		const std::string &	dirName )

Definition at line 297 of file LArQuickHistMerge.cxx.

                                                                           {
  TIter next( dir->GetListOfKeys() );
  TKey* key;
  while((key=(TKey*)next()))  {
    const char* name=key->GetName();
    const char* classname=key->GetClassName();
    if (m_dbg) std::cout << "Found name " << name << ", classname=" << classname << std::endl;
    const std::string newName=dirName+"/"+name;
 
    if (this->isExcluded(newName)) {
      std::cout << "Path " << newName << " excluded" << std::endl;
      return;
    }
 
    if (!strncmp(classname,"TH1",3) || !strncmp(classname,"TH2",3) || !strncmp(classname,"TProfile",8)) {
      auto mIt=m_data.find("dirName");
      
      if (mIt==m_data.end()) { // New top-level directory
    TTree* md=(TTree*)dir->Get("metadata");
    if (!md) std::cout << "ERROR: Did not find metadata tree in directroy " << dirName << std::endl;
    mIt=m_data.insert(std::make_pair(dirName,histDir_t(md))).first;
      }
      histPerDir_t histo(name,key->ReadObj(),mIt->second.md,m_dbg);
 
      // Check if we already have this histogram in the list
      bool found = 0;
      for (auto it1=mIt->second.histos.begin(); it1!=mIt->second.histos.end();++it1) {
    if( it1->name == name){
      found=1;
      break;
    }
      }
      if ( found == 0 ){ // Add the histrogam if we didn't already have it
    mIt->second.histos.push_back(std::move(histo));
      }
 
    }
    else if (!strncmp(classname,"TDirectory",10)) {
      TObject* obj = key->ReadObj();
      TDirectory* subdir = dynamic_cast<TDirectory*>( obj );
      if (subdir) {
    this->addDirectory(subdir,newName);
      }
    }
    else if (!strcmp(classname,"TTree") && (!strcmp(name,"metadata"))) {
      //std::cout << "Found Metadata tree" << std::endl;
    }
    else {
      std::cout << "Ignored objects '" << name << "' of type "<< classname << std::endl;
    } 
  }
  return;
}

addExclusion()

void histCollection::addExclusion

(

const std::string &

dir

)

Definition at line 89 of file LArQuickHistMerge.cxx.

                                                      {
  m_exclusion.push_back(dir);
  return;
}

addFile()

void histCollection::addFile

(

TFile *

in

)

Definition at line 352 of file LArQuickHistMerge.cxx.

                                      {
  auto it=m_data.begin();
  auto it_e=m_data.end();
  for(;it!=it_e;++it) {
    const std::string& dirName=it->first;
    const histDir_t& hd=it->second;
    std::vector<histPerDir_t>::const_iterator it1=hd.histos.begin();
    std::vector<histPerDir_t>::const_iterator it1_e=hd.histos.end();
    for (;it1!=it1_e;++it1) {
      const std::string fullName=dirName+"/"+it1->name;
      if (!it1->obj) {
    std::cout << "Object " << fullName << " not properly set up. Not merged." << std::endl;
    continue;
      }
      TObject* obj=in->Get(fullName.c_str());
      if (!obj) {
    std::cout << "ERROR: Could not access path " << fullName <<" in file " << in->GetName() << std::endl;
      }
      else
    (*it1->mergeMethod)(it1->obj,obj);
    }//End loop over histograms in directory
  }//End loop over directory names
  return;
}

isExcluded()

bool histCollection::isExcluded ( const std::string & dir )

private

Definition at line 94 of file LArQuickHistMerge.cxx.

                                                    {
 
  const size_t firstSlash=dir.find('/',1);
  if (firstSlash==std::string::npos) return false;
 
  std::vector<std::string>::const_iterator it=m_exclusion.begin();
  std::vector<std::string>::const_iterator it_e=m_exclusion.end();
  for(;it!=it_e;++it) {
    const std::string& excl=*it;
    const size_t s=excl.size();
    //std::cout << "Comparing " << dir << " (index "<< firstSlash <<") with " << excl << std::endl; 
    if (dir.compare(firstSlash,s,excl)==0) {
      return true;
    }
  }
  return false;
}

print()

void histCollection::print

(

)

Definition at line 113 of file LArQuickHistMerge.cxx.

                           {
  auto it=m_data.begin();
  auto it_e=m_data.end();
  for(;it!=it_e;++it) {
    const histDir_t& hd=it->second;
    std::cout << "Dir: " << it->first <<" has "<<hd.histos.size()<<" histos"<<std::endl;
    std::vector<histPerDir_t>::const_iterator it1=hd.histos.begin();
    std::vector<histPerDir_t>::const_iterator it1_e=hd.histos.end();
    for (;it1!=it1_e;++it1) 
      std::cout << "\t" << it1->name << std::endl;
  }
 
  std::cout << "\nExclusion List: " << std::endl;
  std::vector<std::string>::const_iterator sit=m_exclusion.begin();
  std::vector<std::string>::const_iterator sit_e=m_exclusion.end();
  for(;sit!=sit_e;++sit) 
    std::cout << "\t" << *sit << std::endl;
 
  return;
}

size()

size_t histCollection::size ( )

inline

Definition at line 57 of file LArQuickHistMerge.cxx.

{return m_data.size();};

write()

void histCollection::write

(

TFile *

out

)

Definition at line 377 of file LArQuickHistMerge.cxx.

                                     {
  unsigned nWritten=0;
  unsigned nIgnored=0;
  TDirectory* histDir=nullptr;
  std::string lastDir;
  auto it=m_data.begin();
  auto it_e=m_data.end();
  for(;it!=it_e;++it) {
    const std::string fulldir=it->first + "/";
    //Create dirs if necessary
    std::string::size_type j=0,j1=0;
    while (j1!=std::string::npos) {
      do {
    j=j1+1;
    j1=fulldir.find('/',j);
    //std::cout << "Inner loop " << fulldir.substr(0,j1) << " << ==? " <<  lastDir.substr(0,j1) << std::endl;
      }
      while(j1!=std::string::npos && !fulldir.compare(0,j1,lastDir,0,j1));
      const std::string currDirAtLevel(fulldir.substr(j,j1-j));
      const std::string currFullDir(fulldir.substr(0,j1));
      const std::string currBaseDir(fulldir.substr(0,j));
      //std::cout << "Working on dir " << fulldir << " [" << currFullDir << " " << currBaseDir << " " << currDirAtLevel << std::endl;
      lastDir=std::move(currFullDir);
      out->cd(currBaseDir.c_str());
      gDirectory->mkdir(currDirAtLevel.c_str());
    }//End outer while loop - full directory created 
    //std::cout << "Done creating " << fulldir << std::endl;
    out->cd(fulldir.c_str());
    it->second.md->SetDirectory(histDir);
    it->second.md->Write(nullptr,TObject::kOverwrite);
    std::vector<histPerDir_t>::const_iterator ith=it->second.histos.begin();
    std::vector<histPerDir_t>::const_iterator ith_e=it->second.histos.end();
    for (;ith!=ith_e;++ith) {
      if (ith->obj) {
    ith->obj->Write();
    std::cout << "Writing " <<  ith->name << " to dir " << fulldir << std::endl;
    ++nWritten;
      }
      else {
    std::cout << "NOT writing " <<  ith->name << ". Invalid." << std::endl;
    ++nIgnored;
      }
    }//End loop over histograms in one directory
  }//End loop over directories;
  std::cout << "Wrote " << nWritten << " histograms to output file.";
  if (nIgnored) 
    std::cout << " Omitting " << nIgnored << " histograms." << std::endl;
  else
    std::cout << std::endl;
  return;
}

Member Data Documentation

m_data

std::map<std::string,histDir_t, std::less<> > histCollection::m_data

private

Definition at line 82 of file LArQuickHistMerge.cxx.

m_dbg

bool histCollection::m_dbg

private

Definition at line 83 of file LArQuickHistMerge.cxx.

m_exclusion

std::vector<std::string> histCollection::m_exclusion

private

Definition at line 84 of file LArQuickHistMerge.cxx.

---

The documentation for this class was generated from the following file:

• LArQuickHistMerge.cxx