NuInputEvents.cxx

Go to the documentation of this file.

// Coded by Jeff Hartnell Jan/2007 onwards
//                                                                    
// Contact: j.j.hartnell@rl.ac.uk

#include <cassert>
#include <fstream>

#include "glob.h" // For globbing that works better than ROOT's

#include "TChain.h"
#include "TFile.h"
#include "TMath.h"
#include "TObjString.h"
#include "TRegexp.h"
#include "TSystem.h"

#include "MessageService/MsgService.h"

#include "NtupleUtils/NuInputEvents.h"

using std::endl;
using std::cout;
using std::vector;

string NuInputEvents::fInputFileName="";

CVSID("$Id: NuInputEvents.cxx,v 1.9 2009/11/06 15:39:47 bckhouse Exp $");

//......................................................................

NuInputEvents::NuInputEvents()
{
  MSG("NuInputEvents",Msg::kDebug)
    <<"Running NuInputEvents Constructor..."<<endl;
  
  //initialise data members
  fUseCachedNuEvents=false;//use tree as std
  fUseCachedNuMCEvents=false;//use tree as std
  fpvNuEvents=0;
  fpvNuMCEvents=0;
  //fNuEventsIter;//what to do with this?
  //fNuMCEventsIter;//what to do with this?
  fInputFileDir=0;
  fEntriesNuEvent=0;
  fFirstRunNumberNuEvent=999;
  this->ResetNuEventTreePositionToStart();//sets fEntry=-1;
  fEntriesNuMCEvent=0;
  fFirstRunNumberNuMCEvent=999;
  this->ResetNuMCEventTreePositionToStart();//sets fEntry=-1;
  fNuEvent=0;
  fNuMCEvent=0;
  fChainNuEvent=0;
  fChainNuMCEvent=0;

  MSG("NuInputEvents",Msg::kDebug)
    <<"Finished NuInputEvents Constructor"<<endl;
}

//......................................................................

NuInputEvents::~NuInputEvents()
{
  MSG("NuInputEvents",Msg::kDebug)
    <<"Running NuInputEvents Destructor..."<<endl;
  
  //clean up memory
  if (fChainNuEvent) {
    delete fChainNuEvent;
    fChainNuEvent=0;
  }
  //clean up memory
  if (fChainNuMCEvent) {
    delete fChainNuMCEvent;
    fChainNuMCEvent=0;
  }
  //fNuEvent is only ever used as a pointer and doesn't own any memory

  MSG("NuInputEvents",Msg::kDebug)
    <<"Finished NuInputEvents Destructor"<<endl;
}

//......................................................................

void NuInputEvents::InitialiseChains()
{
  if (fChainNuMCEvent || fChainNuEvent) {
    MSG("NuInputEvents",Msg::kInfo)
      <<"Chains already initialised... nothing to do"<<endl;
  }
  else this->MakeChain();
}

//......................................................................

TDirectory* NuInputEvents::OpenNextInputFile() 
{
  //check if input file name exists
  if (fInputFileName=="") {
    MSG("NuInputEvents",Msg::kWarning)
      <<"No input file given so returning NULL, fInputFileName="
      <<fInputFileName<<endl;
    return NULL;
  }

  //create a vector to store the list of files
  static vector<string> fileList;
  if (fileList.size()==0) {
    MSG("NuInputEvents",Msg::kInfo)
      <<"Searching for files..."<<endl;
    fileList=this->GetListOfFilesInDir(fInputFileName);
    
    //check if file found
    if (fileList.size()==0) {
      MSG("NuInputEvents",Msg::kWarning)
        <<"No file found so returning NULL, fInputFileName="
        <<fInputFileName<<endl;
      return NULL;
    }

    //print out files found    
    MSG("NuInputEvents",Msg::kInfo)
      <<"Found "<<fileList.size()<<" files:"<<endl;
    for (vector<string>::iterator it=fileList.begin();
         it!=fileList.end();++it) {
      MSG("NuInputEvents",Msg::kInfo)
        <<"  File name="<<*it<<endl;
    }
  }
  
  //get an iterator
  static vector<string>::iterator it=fileList.begin();
  
  //check if iterator points to anything
  if (it==fileList.end()) return NULL;
  
  //to avoid changing the global configuration
  //get the original directory
  TDirectory* directoryOrig=gDirectory;
  //cout<<"Original directory is:"<<endl;
  //directoryOrig->Print();
  
  //keep a pointer to the file
  static TFile* file=0;
  static TFile* firstFile=0;
  //close the file if it exists
  //don't close the first file... the clones of histos in the first
  //file seem to disappear if the file is closed
  //not closing the first file is a nasty work around 
  if (file) {
    if (file!=firstFile) {
      cout<<"Closing file="<<file->GetName()<<endl;
      file->Close();
      file=0;//reset the pointer
    }
    else cout<<"Not closing the first file to be opened (avoids a segv)"
             <<endl;
  }

  //open the new file
  cout<<"Opening file... name="<<(*it).c_str()<<endl;
  file=TFile::Open((*it).c_str());
  if (!firstFile) firstFile=file;

  //increment the iterator
  ++it;

  //store the directory of the file
  fInputFileDir=gDirectory;
  
  //reset the global directory to the original directory
  gDirectory=directoryOrig;
  
  return fInputFileDir;
}

//......................................................................

TDirectory* NuInputEvents::OpenInputFile() 
{
  if (!fInputFileDir) {
    //to avoid changing the global configuration
    //get the original directory
    TDirectory* directoryOrig=gDirectory;
    //cout<<"Original directory is:"<<endl;
    //directoryOrig->Print();
    
    if (fInputFileName=="") return NULL;
    
    vector<string> fileList;
    fileList=this->GetListOfFilesInDir(fInputFileName);
    
    //print out files found    
    MSG("NuInputEvents",Msg::kInfo)
      <<"Found "<<fileList.size()<<" files:"<<endl;
    for (vector<string>::iterator it=fileList.begin();
         it!=fileList.end();++it) {
      MSG("NuInputEvents",Msg::kInfo)
        <<"  File name="<<*it<<endl;
    }

    if (fileList.size()>0) {
      cout<<"Opening (1st) file="<<fileList[0]<<endl;
      TFile::Open(fileList[0].c_str());
    }
    else {
      MSG("NuInputEvents",Msg::kWarning)
        <<"No file found so returning NULL, fInputFileName="
        <<fInputFileName<<endl;
      return NULL;
    }
    
    //store the directory of the file
    fInputFileDir=gDirectory;
    
    //reset the global directory to the original directory
    gDirectory=directoryOrig;
  }
  else {
    MSG("NuInputEvents",Msg::kWarning)
      <<"A file has already been opened, fInputFileName="
      <<fInputFileName
      <<", fInputFileDir="
      <<endl;
    fInputFileDir->Print();
  }

  return fInputFileDir;
}

//......................................................................

void NuInputEvents::ResetNuEventLoopPositionToStart()
{
  if (fUseCachedNuEvents) {
    this->ResetNuEventCachePositionToStart();
  }
  else {
    this->ResetNuEventTreePositionToStart();
  }
}

//......................................................................

void NuInputEvents::ResetNuMCEventLoopPositionToStart()
{
  if (fUseCachedNuMCEvents) {
    this->ResetNuMCEventCachePositionToStart();
  }
  else {
    this->ResetNuMCEventTreePositionToStart();
  }
}

//......................................................................

void NuInputEvents::ResetNuEventTreePositionToStart()
{
  //this is one before the first so that GetNext works properly
  fEntryNuEvent=-1;
}

//......................................................................

void NuInputEvents::ResetNuMCEventTreePositionToStart()
{
  //this is one before the first so that GetNext works properly
  fEntryNuMCEvent=-1;
}

//......................................................................

void NuInputEvents::ResetNuEventCachePositionToStart()
{
  if (fpvNuEvents) {
    fNuEventsIter=fpvNuEvents->begin();
    //this is one before the first so that GetNext works properly
    --fNuEventsIter;
  }
  else {
    MSG("NuInputEvents",Msg::kError) 
      <<"Can't reset cache position to start before cache is created"
      <<endl
      <<"Will exit here..."<<endl;
    assert(false);
  }
}

//......................................................................

void NuInputEvents::ResetNuMCEventCachePositionToStart()
{
  if (fpvNuMCEvents) {
    fNuMCEventsIter=fpvNuMCEvents->begin();
    //this is one before the first so that GetNext works properly
    --fNuMCEventsIter;
  }
  else {
    MSG("NuInputEvents",Msg::kError) 
      <<"Can't reset cache position to start before cache is created"
      <<endl
      <<"Will exit here..."<<endl;
    assert(false);
  }
}

//......................................................................

Int_t NuInputEvents::GetEntriesNuEvent() const
{
  if (fUseCachedNuEvents) {
    return this->GetCacheEntriesNuEvent();
  }
  else {
    return this->GetTreeEntriesNuEvent();
  }
}

//......................................................................

Int_t NuInputEvents::GetEntriesNuMCEvent() const
{
  if (fUseCachedNuMCEvents) {
    return this->GetCacheEntriesNuMCEvent();
  }
  else {
    return this->GetTreeEntriesNuMCEvent();
  }
}

//......................................................................

Int_t NuInputEvents::GetTreeEntriesNuEvent() const
{
  if (fChainNuEvent) {
    return fEntriesNuEvent;
  }
  else {
    MSG("NuInputEvents",Msg::kError) 
      <<"Can't get NuEvent tree entries before chain is created"<<endl
      <<"Will exit here..."<<endl;
    assert(false);
    return -1;//keep the compiler quiet
  }
}

//......................................................................

Int_t NuInputEvents::GetTreeEntriesNuMCEvent() const
{
  if (fChainNuMCEvent) {
    return fEntriesNuMCEvent;
  }
  else {
    //MSG("NuInputEvents",Msg::kError) 
    //<<"Can't get NuMCEvent tree entries before chain is created"<<endl
    //<<"Will exit here..."<<endl;
    //assert(false);
    //return -1;//keep the compiler quiet
    
    MSG("NuInputEvents",Msg::kWarning) 
      <<"Can't get NuMCEvent tree entries when chain doesn't exist."
      <<" Returning ZERO entries"<<endl;
    return 0;
  }
}

//......................................................................

Int_t NuInputEvents::GetCacheEntriesNuEvent() const
{
  if (fpvNuEvents) {
    return fpvNuEvents->size();
  }
  else {
    MSG("NuInputEvents",Msg::kError) 
      <<"Can't get NuEvent cache entries before cache is created"<<endl
      <<"Will exit here..."<<endl;
    assert(false);
    return -1;//keep the compiler quiet
  }
}

//......................................................................

Int_t NuInputEvents::GetCacheEntriesNuMCEvent() const
{
  if (fpvNuMCEvents) {
    return fpvNuMCEvents->size();
  }
  else {
    MSG("NuInputEvents",Msg::kError) 
      <<"Can't get NuMCEvent cache entries before cache is created"
      <<endl
      <<"Will exit here..."<<endl;
    assert(false);
    return -1;//keep the compiler quiet
  }
}

//......................................................................

void NuInputEvents::PrintNewFileName() const 
{
  static int lastFileno = -1;
  if (fUseCachedNuEvents) return;
  int current = fChainNuEvent->GetTreeNumber();
  
  if (current > lastFileno) {
    lastFileno = current;
    MSG("NuInputEvents",Msg::kInfo) << "*** New File: " << fChainNuEvent->GetFile()->GetName() << endl;
  }
  
}

//......................................................................

void NuInputEvents::PrintNewMCFileName() const 
{
  static int lastFileno = -1;
  if (fUseCachedNuMCEvents) return;
  int current = fChainNuMCEvent->GetTreeNumber();
  
  if (current > lastFileno) {
    lastFileno = current;
    MSG("NuInputEvents",Msg::kInfo) << "*** New File: " << fChainNuMCEvent->GetFile()->GetName() << endl;
  }
  
}

//......................................................................

void NuInputEvents::SetLoopVariablesNuEvent(Int_t entry,Int_t printMode)
{
  if (printMode==1){
    Float_t fract=ceil(fEntriesNuEvent/20.);  
    if (ceil(((Float_t)entry)/fract)==((Float_t)entry)/fract){
      MSG("NuInputEvents",Msg::kDebug) 
        <<"Fraction of loop complete: "<<entry 
        <<"/"<<fEntriesNuEvent<<"  ("
        <<(Int_t)(100.*entry/fEntriesNuEvent)<<"%)"<<endl;
    }
  }

  //get the snarl/entry
  fChainNuEvent->GetEntry(entry); 
}

//......................................................................

void NuInputEvents::SetLoopVariablesNuMCEvent(Int_t entry,Int_t printMode)
{
  if (printMode==1){
    Float_t fract=ceil(fEntriesNuMCEvent/20.);  
    if (ceil(((Float_t)entry)/fract)==((Float_t)entry)/fract){
      MSG("NuInputEvents",Msg::kDebug) 
        <<"Fraction of loop complete: "<<entry 
        <<"/"<<fEntriesNuMCEvent<<"  ("
        <<(Int_t)(100.*entry/fEntriesNuMCEvent)<<"%)"<<endl;
    }
  }

  //get the snarl/entry
  fChainNuMCEvent->GetEntry(entry); 
}

//......................................................................

void NuInputEvents::UseNuEventCache(Bool_t useCache)
{
  if (useCache==true) {
    MSG("NuInputEvents",Msg::kInfo) 
      <<"Setting NuInputEvents object to use the cache"<<endl;
    fUseCachedNuEvents=true;
  }
  else {
    MSG("NuInputEvents",Msg::kInfo) 
      <<"Setting NuInputEvents object to use the tree"<<endl;
    fUseCachedNuEvents=false;
  }
}

//......................................................................

void NuInputEvents::UseNuMCEventCache(Bool_t useCache)
{
  if (useCache==true) {
    MSG("NuInputEvents",Msg::kInfo) 
      <<"Setting NuInputEvents object to use the cache"<<endl;
    fUseCachedNuMCEvents=true;
  }
  else {
    MSG("NuInputEvents",Msg::kInfo) 
      <<"Setting NuInputEvents object to use the tree"<<endl;
    fUseCachedNuMCEvents=false;
  }
}

//......................................................................

void NuInputEvents::InitialiseNuEventCache()
{
  MSG("NuInputEvents",Msg::kInfo) 
    <<"Running NuInputEvents::InitialiseNuEventCache"<<endl;

  //create the vector of NuEvents and initialise
  fpvNuEvents=new vector<NuEvent*>;

  //make space in memory for objects
  fpvNuEvents->reserve(50000);

  //initialise the iterator
  fNuEventsIter=fpvNuEvents->begin();
  //this is one before the first so that GetNext works properly
  --fNuEventsIter;

  MSG("NuInputEvents",Msg::kInfo) 
    <<"   Cache size="<<fpvNuEvents->size()<<endl;
}

//......................................................................

void NuInputEvents::InitialiseNuMCEventCache()
{
  MSG("NuInputEvents",Msg::kInfo) 
    <<"Running NuInputEvents::InitialiseNuMCEventCache"<<endl;

  //create the vector of NuMCEvents and initialise
  fpvNuMCEvents=new vector<NuMCEvent*>;

  //make space in memory for objects
  fpvNuMCEvents->reserve(50000);

  //initialise the iterator
  fNuMCEventsIter=fpvNuMCEvents->begin();
  //this is one before the first so that GetNext works properly
  --fNuMCEventsIter;

  MSG("NuInputEvents",Msg::kInfo) 
    <<"   Cache size="<<fpvNuMCEvents->size()<<endl;
}

//......................................................................

void NuInputEvents::AddNuEventToCache(const NuEvent& nu)
{
  //create a new NuEvent on the heap
  NuEvent* nuClone=new NuEvent();

  //clone the NuEvent
  *nuClone=nu;

  //add the nuClone to the cache
  if (fpvNuEvents) {
    fpvNuEvents->push_back(nuClone);
  }
  else cout<<"Ahhhh, fpvNuEvents==0, can't AddNuEventToCache"<<endl;
}

//......................................................................

void NuInputEvents::AddNuMCEventToCache(const NuMCEvent& nu)
{
  //create a new NuMCEvent on the heap
  NuMCEvent* nuClone=new NuMCEvent();

  //clone the NuMCEvent
  *nuClone=nu;

  //add the nuClone to the cache
  if (fpvNuMCEvents) {
    fpvNuMCEvents->push_back(nuClone);
  }
  else cout<<"Ahhhh, fpvNuMCEvents==0, can't AddNuMCEventToCache"<<endl;
}

//......................................................................

const NuEvent& NuInputEvents::GetNextCachedNuEvent(Msg::LogLevel_t
                                                   /*logLevel*/)
{

  //increment the iterator to the next nuEvent
  ++fNuEventsIter;

  //return the NuEvent
  return *(*fNuEventsIter);
}

//......................................................................

const NuMCEvent& NuInputEvents::GetNextCachedNuMCEvent(Msg::LogLevel_t
                                                   /*logLevel*/)
{

  //increment the iterator to the next nuEvent
  ++fNuMCEventsIter;

  //return the NuMCEvent
  return *(*fNuMCEventsIter);
}

//......................................................................

const NuEvent& NuInputEvents::GetNextTreeNuEvent(Msg::LogLevel_t
                                                 logLevel)
{

  if (fEntryNuEvent==-1) {
    MSG("NuInputEvents",Msg::kInfo) 
      <<"Running NuInputEvents::GetNextNuEvent for first entry..."
      <<endl;
  }
  else if (fEntryNuEvent>=fEntriesNuEvent) {
    MSG("NuInputEvents",Msg::kError) 
      <<"Asked for entry="<<fEntryNuEvent
      <<" beyond end of tree. Total tree entries="
      <<fEntriesNuEvent<<endl
      <<"Will exit here..."<<endl;
    assert(false);
  }
  
  //increment the entry to get
  ++fEntryNuEvent;
  
  if (logLevel>=Msg::kInfo){
    Float_t fract=ceil(fEntriesNuEvent/20.);  
    if (ceil(((Float_t)fEntryNuEvent)/fract)==
        ((Float_t)fEntryNuEvent)/fract){
      MSG("NuInputEvents",Msg::kInfo) 
        <<"Fraction of loop complete: "<<fEntryNuEvent 
        <<"/"<<fEntriesNuEvent<<"  ("
        <<(Int_t)(100.*fEntryNuEvent/fEntriesNuEvent)<<"%)"<<endl;
    }
  }

  //get the snarl/entry
  fChainNuEvent->GetEntry(fEntryNuEvent); 

  //return the next NuEvent
  return *fNuEvent;
}

//......................................................................

const NuMCEvent& NuInputEvents::GetNextTreeNuMCEvent(Msg::LogLevel_t
                                                 logLevel)
{

  if (fEntryNuMCEvent==-1) {
    MSG("NuInputEvents",Msg::kInfo) 
      <<"Running NuInputEvents::GetNextNuMCEvent for first entry..."
      <<endl;
  }
  else if (fEntryNuMCEvent>=fEntriesNuMCEvent) {
    MSG("NuInputEvents",Msg::kError) 
      <<"Asked for entry="<<fEntryNuMCEvent
      <<" beyond end of tree. Total tree entries="
      <<fEntriesNuMCEvent<<endl
      <<"Will exit here..."<<endl;
    assert(false);
  }
  
  //increment the entry to get
  ++fEntryNuMCEvent;
  
  if (logLevel>=Msg::kInfo){
    Float_t fract=ceil(fEntriesNuMCEvent/20.);  
    if (ceil(((Float_t)fEntryNuMCEvent)/fract)==
        ((Float_t)fEntryNuMCEvent)/fract){
      MSG("NuInputEvents",Msg::kInfo) 
        <<"Fraction of loop complete: "<<fEntryNuMCEvent 
        <<"/"<<fEntriesNuMCEvent<<"  ("
        <<(Int_t)(100.*fEntryNuMCEvent/fEntriesNuMCEvent)<<"%)"<<endl;
    }
  }

  //get the snarl/entry
  fChainNuMCEvent->GetEntry(fEntryNuMCEvent); 

  //return the next NuMCEvent
  return *fNuMCEvent;
}

//......................................................................

const NuEvent& NuInputEvents::GetNextNuEvent(Msg::LogLevel_t logLevel)
{
  const NuEvent* pnu=0;
  
  if (fUseCachedNuEvents) {
    pnu=&this->GetNextCachedNuEvent(logLevel);
  }
  else {
    pnu=&this->GetNextTreeNuEvent(logLevel);
  }

  return *pnu;
}

//......................................................................

const NuMCEvent& NuInputEvents::GetNextNuMCEvent(Msg::LogLevel_t logLevel)
{
  const NuMCEvent* pnu=0;
  
  if (fUseCachedNuMCEvents) {
    pnu=&this->GetNextCachedNuMCEvent(logLevel);
  }
  else {
    pnu=&this->GetNextTreeNuMCEvent(logLevel);
  }

  return *pnu;
}

//......................................................................

void NuInputEvents::InputFileName(string f)
{
  if (f!=""){
    MSG("NuInputEvents",Msg::kInfo)
      <<"Running with input file name="<<f<<endl;
    fInputFileName=f;
  }
}

//......................................................................

std::vector<std::string> NuInputEvents::MakeFileList()
{

  vector<string> fileList;
  
  if (fInputFileName!=""){
    MSG("NuInputEvents",Msg::kInfo)
      <<"Running NuInputEvents::MakeFileList with fInputFileName="
      <<fInputFileName<<endl;
    
    Int_t findGives=fInputFileName.find(".root");
    //cout<<"find gives="<<fInputFileName.find(".root")<<endl;

    //check if there is a wildcard
    if (findGives>0 && 
        TString(fInputFileName.c_str()).MaybeWildcard()) {
      MSG("NuInputEvents",Msg::kInfo)
        <<"Found wildcard so getting list of files in directory"<<endl;
      fileList=this->GetListOfFilesInDir(fInputFileName);
      if(fileList.empty())
        MSG("NuInputEvents", Msg::kError)
          << "No files matched wildcard, will fall back to NUEVENT" << endl;
    }
    else if (findGives>0){
      MSG("NuInputEvents",Msg::kInfo)
        <<"Adding file direct to list"<<endl;
      //add the file direct to the list
      fileList.push_back(fInputFileName);
    }
    else{//treat the file as a list of root files 
      ifstream inputFile(fInputFileName.c_str());
      
      //check if file exists
      if (inputFile){
        //variables to hold input from file
        string file="";
        
        //read in from the text file and fill objects
        while(inputFile>>file) {
          MSG("NuInputEvents",Msg::kInfo)
            <<"Found input file name="<<file<<endl;
          fileList.push_back(file);
        }
        MSG("NuInputEvents",Msg::kInfo)
          <<"Files names found in txt file="<<fileList.size()<<endl;
      }
      else{
        MSG("NuInputEvents",Msg::kError)
          <<endl<<endl
          <<"**********************************************************"
          <<endl<<"Input txt file of file names does not exist!"<<endl
          <<"InputFileName="<<fInputFileName<<endl
          <<"**********************************************************"
          <<endl<<endl<<"Program will exit here"<<endl;
        exit(0);
      }
    }
  }
  //return the fileList if files were found
  if (fileList.size()>0) return fileList;
  
  //Check the env variable to find files
  char* envVariable=getenv("NUEVENT");
  if (envVariable==NULL){
    MSG("NuInputEvents",Msg::kError)
      <<endl<<endl
      <<"*************************************************************"
      <<endl<<"Environmental variable NUEVENT not set!"<<endl
      <<"Please set NUEVENT to the directory containing the"
      <<" NuEvent*.root files"<<endl
      <<"Note: If more than one file is found they will be"
      <<" concatenated and treated as one"<<endl
      <<"*************************************************************"
      <<endl<<endl<<"Program will exit here"<<endl;
    exit(0);
  }
  string sEnv=envVariable;
  MSG("NuInputEvents",Msg::kInfo)
    <<"Looking for NuEvent*.root files using the env variable"<<endl
    <<"NUEVENT="<<sEnv<<endl;
  sEnv+="/NuEvent*.root";
  fileList.push_back(sEnv);

  return fileList;
}

//......................................................................

std::vector<std::string> NuInputEvents::
GetListOfFilesInDir(std::string wildcardString) const
{
  std::vector<std::string> fileList;
  
  glob_t g;
  glob(wildcardString.c_str(),
       // GLOB_NOCHECK | // If no match return pattern
       GLOB_TILDE, // Expand ~'s
       0, &g);
  for(unsigned int i = 0; i < g.gl_pathc; ++i)
    fileList.push_back(g.gl_pathv[i]);
  globfree(&g);

  // glob output is sorted by default

  return fileList;
}

//......................................................................

void NuInputEvents::MakeChain()
{
  //get the files to open
  vector<string> fileList=this->MakeFileList();
  
  //sanity check
  if (fileList.size()<=0) cout<<"Ahhh no files in fileList"<<endl;
  
  //open the file
  TFile* file=TFile::Open((*fileList.begin()).c_str(),"READ");
  
  //check if the NuEvent exists
  if (this->ObjectExistsInFile(file,"s")) {
    //create a chain with NuEvent tree
    fChainNuEvent=new TChain("s");
  }
  else {
    MSG("NuInputEvents",Msg::kInfo)
      <<"Cannot run MakeChain when tree does not exist in file."
      <<" Skipping this step..."<<endl;
    return;
  }
  
  //check if NuMCEvent exists
  if (this->ObjectExistsInFile(file,"mc")) {
    //create a chain with NuEvent tree
    fChainNuMCEvent=new TChain("mc");
    //fChainNuMCEvent->Print();
  }
      
  //add the files to the chain  
  Int_t nfNuEvent=0;
  Int_t nfNuMCEvent=0;
  for (vector<string>::iterator file=fileList.begin();
       file!=fileList.end();++file){
    
    //test if file already exists
    ifstream openOk((*file).c_str()); 

    //check if a wildcard was used because ifstream can't open wildcards
    Int_t stars=(*file).find("*");
    Int_t quest=(*file).find("?");

    //check if file existed
    if (!openOk && !(quest>=0 || stars>=0)){
      MSG("NuInputEvents",Msg::kInfo)
        <<endl<<endl
        <<"***********************************************************"
        <<endl<<"Can't find file="<<*file<<endl
        <<"Note: you can't use '~/'. It has to be the full path"<<endl
        <<"***********************************************************"
        <<endl<<endl
        <<"Exiting here!"<<endl;
      exit(0);
    }
    
    if (fChainNuEvent) {
      MSG("NuInputEvents",Msg::kInfo)<<"Adding file="<<*file<<endl;
      nfNuEvent+=fChainNuEvent->Add((*file).c_str());
      if (fChainNuMCEvent) {
        nfNuMCEvent+=fChainNuMCEvent->Add((*file).c_str());
      }
    }
    else {
      MSG("NuInputEvents",Msg::kWarning)
        <<"fChainNuEvent is a null pointer"<<endl;
    }
  }

  if(nfNuEvent==0){
    MSG("NuInputEvents",Msg::kError)
      <<endl<<endl
      <<"*************************************************************"
      <<endl<<"No NuEvent*.root files found"<<endl
      <<"Please set NUEVENT to the directory containing the"
      <<" NuEvent*.root files"<<endl
      <<"Or give the txt file containing the files to be input"<<endl
      <<"Note: If more than one file is found they will be"
      <<" concatenated in a TChain and treated as one"<<endl
      <<"*************************************************************"
      <<endl<<endl<<"Program will exit here"<<endl;
    exit(0);
  }

  if (nfNuMCEvent) {
    MSG("NuInputEvents",Msg::kInfo) 
      <<"NuMCEvent information:"<<endl;
    //fChainNuMCEvent->Show(0);
    MSG("NuInputEvents",Msg::kInfo)
      <<endl<<"Added "<<nfNuMCEvent<<" file(s) to NuMCEvent TChain"
      <<endl;
  }
  else {
    MSG("NuInputEvents",Msg::kInfo)
      <<endl<<"Zero files added to NuMCEvent TChain"<<endl;
  }
    
  MSG("NuInputEvents",Msg::kInfo) 
    <<"NuEvent information:"<<endl;
  //fChainNuEvent->Show(0);
  
  MSG("NuInputEvents",Msg::kInfo)
    <<endl<<"Analysing "<<nfNuEvent<<" file(s). Reading from disk..."
    <<endl;
}

//......................................................................

void NuInputEvents::InitialiseNuEventBranch()
{
  MSG("NuInputEvents",Msg::kDebug)
    <<"Running the SetupNuEventTree method..."<<endl;

  //set up tree
  if (fChainNuEvent) {
    fChainNuEvent->SetBranchAddress("s",&fNuEvent);
    
    //set the number of entries in the tree
    fEntriesNuEvent=static_cast<Int_t>(fChainNuEvent->GetEntries());
    MSG("NuInputEvents",Msg::kInfo)
      <<"NuEvent tree has "<<fEntriesNuEvent<<" entries"<<endl;
    if (fEntriesNuEvent>0){
      //get the snarl/entry
      fChainNuEvent->GetEntry(0); 
      MSG("NuInputEvents",Msg::kInfo)
        <<"NuInputEvents::First run number="<<fNuEvent->run<<endl;
      fFirstRunNumberNuEvent=fNuEvent->run;
    }
  }
  else cout<<"No fChainNuEvent to setup, initialise first"<<endl;
  
  MSG("NuInputEvents",Msg::kDebug)
    <<"Finished the SetupNuEventTree method"<<endl;
}

//......................................................................

void NuInputEvents::InitialiseNuMCEventBranch()
{
  MSG("NuInputEvents",Msg::kDebug)
    <<"Running the SetupNuMCEventTree method..."<<endl;

  //set up tree
  if (fChainNuMCEvent) {
    fChainNuMCEvent->SetBranchAddress("mc",&fNuMCEvent);
  
    //set the number of entries in the tree
    fEntriesNuMCEvent=static_cast<Int_t>(fChainNuMCEvent->GetEntries());
    MSG("NuInputEvents",Msg::kInfo)
      <<"NuMCEvent tree has "<<fEntriesNuMCEvent<<" entries"<<endl;
    if (fEntriesNuMCEvent>0){
      //get the snarl/entry
      fChainNuMCEvent->GetEntry(0); 
      MSG("NuInputEvents",Msg::kInfo)
        <<"NuInputEvents::First run number="<<fNuMCEvent->run<<endl;
      fFirstRunNumberNuMCEvent=fNuMCEvent->run;
    }
  }
  else cout<<"No fChainNuMCEvent to setup, initialise first"<<endl;

  MSG("NuInputEvents",Msg::kDebug)
    <<"Finished the SetupNuMCEventTree method"<<endl;
}

//......................................................................

Bool_t NuInputEvents::ObjectExistsInFile(TFile* file,
                                         std::string objectName) const
{
  if (!file) {
    MSG("NuInputEvents",Msg::kWarning)
      <<"File does not exist so can't test if object exists!"<<endl;
    return false;
  }

  TList* listOfKeys=file->GetListOfKeys();

  static TFile* lastFile=0;
  if (lastFile!=file){
    //MSG("NuInputEvents",Msg::kInfo)
    //<<"File contains these keys:"<<endl;
    //listOfKeys->Print();//too verbose when lots of histos
  }
  lastFile=file;

  TObject* ob=listOfKeys->FindObject(objectName.c_str());
  if (ob) {
    MSG("NuInputEvents",Msg::kInfo)
      <<"Requested object with name="<<objectName
      <<" exists in file:"<<endl;
    ob->Print();
    return true;
  }
  else {
    MSG("NuInputEvents",Msg::kInfo)
      <<"Requested object with name="<<objectName
      <<" does NOT exist in file"<<endl;
    return false;
  }
}

//......................................................................

---