FWLiteAnalyzerWrapper.h

Go to the documentation of this file.

#ifndef PhysicsTools_FWLite_interface_FWLiteAnalyzerWrapper_h
#define PhysicsTools_FWLite_interface_FWLiteAnalyzerWrapper_h

#include <string>
#include <vector>
#include <iostream>

#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_;
    std::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_ = std::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_ = std::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);
    }
  }
}  // namespace fwlite

#endif