FWLiteAnalyzerWrapper.h

Go to the documentation of this file.

#ifndef PhysicsTools_UtilAlgos_interface_FWLiteAnalyzerWrapper_h
#define PhysicsTools_UtilAlgos_interface_FWLiteAnalyzerWrapper_h

#include <string>
#include <vector>
#include <iostream>
#include <boost/shared_ptr.hpp>

#include <TFile.h>
#include <TSystem.h>

#include "DataFormats/FWLite/interface/ChainEvent.h"
#include "DataFormats/FWLite/interface/InputSource.h"
#include "DataFormats/FWLite/interface/OutputFiles.h"
#include "FWCore/FWLite/interface/FWLiteEnabler.h"
#include "FWCore/ParameterSet/interface/ProcessDesc.h"
#include "PhysicsTools/FWLite/interface/TFileService.h"

namespace fwlite {

  template<class T> 
  class AnalyzerWrapper {

  public:
    AnalyzerWrapper(const edm::ParameterSet& cfg, std::string analyzerName, std::string directory="");
    virtual ~AnalyzerWrapper(){};
    virtual void beginJob() {  analyzer_->beginJob(); }
    virtual void analyze();
    virtual void endJob() {  analyzer_->endJob(); }
    
  protected:
    fwlite::InputSource inputHandler_;
    fwlite::OutputFiles outputHandler_;
    int maxEvents_;
    unsigned int reportAfter_;
    fwlite::TFileService fileService_;
    boost::shared_ptr<T> analyzer_;
  };

  template<class T>
  AnalyzerWrapper<T>::AnalyzerWrapper(const edm::ParameterSet& cfg, std::string analyzerName, std::string directory): 
  inputHandler_( cfg ), outputHandler_( cfg ), maxEvents_(inputHandler_.maxEvents()), 
  reportAfter_(inputHandler_.reportAfter()), fileService_( outputHandler_.file() ) 
  {
    // analysis specific parameters
    const edm::ParameterSet& ana = cfg.getParameter<edm::ParameterSet>(analyzerName.c_str());
    if(directory.empty()){
      // create analysis class of type BasicAnalyzer
      analyzer_ = boost::shared_ptr<T>( new T( ana, fileService_) );  
    }
    else{
      // create a directory in the file if directory string is non empty
      TFileDirectory dir = fileService_.mkdir(directory);
      analyzer_ = boost::shared_ptr<T>( new T( ana, dir ) );  
    }
  }
    
  template<class T> 
  void AnalyzerWrapper<T>::analyze(){
    int ievt=0;  
    std::vector<std::string> const & inputFiles = inputHandler_.files();
    // loop the vector of input files
    fwlite::ChainEvent event( inputFiles );
    for(event.toBegin(); !event.atEnd(); ++event, ++ievt){
      // break loop if maximal number of events is reached 
      if(maxEvents_>0 ? ievt+1>maxEvents_ : false) break;
      // simple event counter
      if(reportAfter_!=0 ? (ievt>0 && ievt%reportAfter_==0) : false) 
    std::cout << "  processing event: " << ievt << std::endl;
      // analyze event
      analyzer_->analyze(event);
    }
  }
}

#endif