EventProcessor.h

Go to the documentation of this file.

 
#ifndef FRAMEWORK_EVENTPROCESSOR_H_
#define FRAMEWORK_EVENTPROCESSOR_H_
 
/*~~~~~~~~~~~~~~~*/
/*   Framework   */
/*~~~~~~~~~~~~~~~*/
#include "Framework/Conditions.h"
#include "Framework/Configure/Parameters.h"
#include "Framework/Event.h"
#include "Framework/Exception/Exception.h"
#include "Framework/Factory.h"
#include "Framework/HistogramPool.h"
#include "Framework/Logger.h"
#include "Framework/NtupleManager.h"
#include "Framework/RunHeader.h"
#include "Framework/StorageControl.h"
 
/*~~~~~~~~~~~~~~~~*/
/*   C++ StdLib   */
/*~~~~~~~~~~~~~~~~*/
#include <any>
#include <map>
 
class t_directory;
 
namespace framework {
 
class Process;
class EventProcessor;
class EventFile;
 
class AbortEventException : public framework::exception::Exception {
 public:
  AbortEventException() throw() : framework::exception::Exception() {}
 
  virtual ~AbortEventException() throw() {}
};
 
class EventProcessor {
 public:
  DECLARE_FACTORY(EventProcessor, EventProcessor *, const std::string &,
                  Process &);
 
  EventProcessor(const std::string &name, Process &process);
 
  virtual ~EventProcessor() = default;
 
  virtual void configure(framework::config::Parameters &parameters) {}
 
  virtual void beforeNewRun(ldmx::RunHeader &run_header) {}
 
  virtual void onNewRun(const ldmx::RunHeader &run_header) {}
 
  virtual void onFileOpen(EventFile &event_file) {}
 
  virtual void onFileClose(EventFile &event_file) {}
 
  virtual void onProcessStart() {}
 
  virtual void onProcessEnd() {}
 
  virtual void process(Event &event) = 0;
 
  template <class T>
  const T &getCondition(const std::string &condition_name) {
    return getConditions().getCondition<T>(condition_name);
  }
 
  TDirectory *getHistoDirectory();
 
  void setStorageHint(framework::StorageControl::Hint hint) {
    setStorageHint(hint, "");
  }
 
  void setStorageHint(framework::StorageControl::Hint hint,
                      const std::string &purposeString);
 
  int getLogFrequency() const;
 
  int getRunNumber() const;
 
  std::string getName() const { return name_; }
 
  void createHistograms(
      const std::vector<framework::config::Parameters> &histos);
 
 protected:
  void abortEvent() { throw AbortEventException(); }
 
  HistogramPool histograms_;
 
  NtupleManager &ntuple_{NtupleManager::getInstance()};
 
  logging::logger the_log_;
 
 private:
  Conditions &getConditions() const;
 
  const ldmx::EventHeader &getEventHeader() const;
 
  Process &process_;
 
  std::string name_;
 
  TDirectory *histo_dir_{0};
};
 
class Producer : public EventProcessor {
 public:
  Producer(const std::string &name, Process &process);
 
  virtual void process(Event &event) final { produce(event); }
 
  virtual void produce(Event &event) = 0;
};
 
class Analyzer : public EventProcessor {
 public:
  Analyzer(const std::string &name, Process &process);
 
  virtual void process(Event &event) final { analyze(event); }
 
  virtual void beforeNewRun(ldmx::RunHeader &run_header) final {}
 
  virtual void analyze(const Event &event) = 0;
};
 
}  // namespace framework
 
#define DECLARE_PRODUCER(CLASS) \
  FACTORY_REGISTRATION(framework::EventProcessor, CLASS)
 
#define DECLARE_ANALYZER(CLASS) \
  FACTORY_REGISTRATION(framework::EventProcessor, CLASS)
 
#endif