PostProcBase.hpp

Go to the documentation of this file.

//project
#include "PostProcBase.h"
//root
#include "TFile.h"
 
//c++
#include <algorithm>
#include <iostream>
#include <sstream>
#include <string>
#include <deque>
#include <utility>
using std::cout;
using std::endl;
using std::stringstream;
using std::to_string;
using std::deque;
template <class T> 
PostProcBase<T>::PostProcBase()
://allocator list
m_trees(nullptr),
m_treeName(""),
m_branchName(""),
m_currentEvent(nullptr),
m_hasFile(false)
{
//nothing to do
}
template <class T> 
int PostProcBase<T>::addFile(string a_filename)
{
  //check if an attempt to load the file has already happened
  auto testIt = std::find(m_loadedFiles.begin(),m_loadedFiles.end(),a_filename);
  //if it hasnt been loaded we should load it
  if(testIt == m_loadedFiles.end())
  {
    //if a file has already been loaded the work is easy
    if(m_hasFile)
    {
      int success = m_trees->AddFile(a_filename.c_str(),-1);
      if(!success)
      {
        cout << "Adding an additional file to the TChain failed";
        cout << " returning without doing anyting " << endl;
        return 1;
      }
      else
      {
        //return success
        m_loadedFiles.push_back(a_filename);
        return 0;
      }
    }
    //if no file has been loaded memory needs to be allocated and 
    //branches need to be assigned
    else
    {
      setTreeName();
      setBranchName();
      cout << "creating event memory";
      m_currentEvent = new T();
      cout << " and tchain";
      m_trees = new TChain(m_treeName.c_str());
      cout << " with succes";
      cout << endl;
      int success = m_trees->Add(a_filename.c_str(),-1);
      if(!success)
      {
        cout << "Adding the first file to the TChain failed";
        cout << " returning without doing anyting " << endl;
        return 1;
      }
      else
      {
        cout << "associating branch address";
        m_trees->SetBranchAddress(m_branchName.c_str(),&m_currentEvent);
        cout << " with sucess" << endl;
        m_hasFile = true;
        m_loadedFiles.push_back(a_filename);
        return 0;
      }
    }
  }
  //if it has been loaded we should inform of the duplicate call
  else
  {
    cout << "Attempt to load an already loaded file. Was this intentional";
    cout << endl;
    return 1;
  }
//how did we get here
  cout << "oddly reached end of add file without a hitting a return" <<endl;
  return 1;
}
 
template <class T> 
int PostProcBase<T>::addFilesFromDirectory(string a_dir,
                                           string a_ext
                                          )
{
  std::vector<std::string> files;
  files = EZFileSystem::getFileListWithExt(a_dir,a_ext);
  std::cout << "Adding " << files.size() << " files";
  std::cout << std::endl;
  for(auto && file : files)
  {
    addFile(file);
  }
  return 0;
}
 
 
template <class T> 
int PostProcBase<T>::loadEvent(int a_eventNumber)
{
  if(fileNotLoaded())
  {
    return 1;
  }
  m_trees->GetEntry(a_eventNumber);
  return 0;
}  
template <class T> 
int PostProcBase<T>::fileNotLoaded()
{
  if(!m_hasFile)
  {
    cout << "no file to test is loaded" <<endl;
    return 1;
  }
  return 0;
}
template <class T> 
std::ostream& PostProcBase<T>::
  printState(std::ostream& a_stream)
{
  a_stream << "PostProcBase ";
  if(m_hasFile)
  {
    a_stream << " has " << m_loadedFiles.size() << " file present";
    a_stream << std::endl;
    a_stream << "Files: ";
    for(auto & file : m_loadedFiles)
    {
      a_stream << file << ", ";
    }
    a_stream << std::endl;
  }
  else
  {
    a_stream << " doesn't have any files loaded and won't be particularly";
    a_stream << " useful" << std::endl;
  }
  return a_stream;
}
 
template <class T> 
int PostProcBase<T>::clearFileState()
{
  if(m_hasFile)
  {
    delete m_trees;
    delete m_currentEvent;
    m_loadedFiles.clear();
    m_hasFile = false;
    return 1; 
  }
  else
  {
    std::cout << "I haven't loaded a file so clearing state is meaningless";
    std::cout << std::endl;
    return 0;
  }
  return 0;
}
 
template <class T> PostProcBase<T>::~PostProcBase()
{
  delete m_currentEvent;
  delete m_trees;
}
 
template <class T> 
TChain* PostProcBase<T>::getTrees()
{
  return m_trees;
}