EventProcessor.h

Go to the documentation of this file.

 
#ifndef FIRE_FRAMEWORK_EVENTPROCESSOR_H
#define FIRE_FRAMEWORK_EVENTPROCESSOR_H
 
#include "fire/Processor.h"
#include "Framework/Configure/Parameters.h"
#include "Framework/Logger.h"
 
namespace framework {
 
class Event {
  fire::Event& event_;
 public:
  Event(fire::Event& e) : event_{e} {}
 
  fire::EventHeader& getEventHeader() {
    return event_.header();
  }
 
  int getEventNumber() const {
    return event_.header().number();
  }
 
  double getEventWeight() const {
    return event_.header().weight();
  }
 
  template<typename T>
  void add(const std::string& n, const T& o) {
    event_.add(n,o);
  }
 
  template<typename T>
  const T& getObject(const std::string& n, const std::string& p = "") const {
    return event_.get<T>(n,p);
  }
 
  template<typename T>
  const std::vector<T>& getCollection(const std::string& n, const std::string& p = "") const {
    return getObject<std::vector<T>>(n,p);
  }
 
  template<typename K, typename V>
  const std::map<K,V>& getCollection(const std::string& n, const std::string& p = "") const {
    return getObject<std::map<K,V>>(n,p);
  }
};
 
using Process = fire::Process;
 
class EventProcessor : public fire::Processor {
  static fire::config::Parameters minimal_parameter_set(const std::string& name) {
    fire::config::Parameters ps;
    ps.add("name",name);
    return ps;
  }
 public:
  EventProcessor(const std::string& name, framework::Process& p) 
    : fire::Processor(minimal_parameter_set(name)) {
      this->attach(&p);
    }
 
  virtual void process(fire::Event &event) = 0;
 
  virtual void configure(config::Parameters& ps) {}
};
 
class Producer : public EventProcessor {
 public:
  Producer(const std::string& name, framework::Process& p)
    : EventProcessor(name,p) {}
 
  virtual void produce(framework::Event &event) = 0;
 
  virtual void process(fire::Event &event) final override {
    framework::Event e(event);
    this->produce(e);
  }
};
 
class Analyzer : public EventProcessor {
 public:
  Analyzer(const std::string& name, framework::Process& p)
    : EventProcessor(name,p) {}
  virtual void beforeNewRun(fire::RunHeader&) final override {}
 
  virtual void analyze(const framework::Event &event) = 0;
 
  virtual void process(fire::Event &event) final override {
    framework::Event e(event);
    this->analyze(e);
  }
};
 
}
 
#define DECLARE_PRODUCER_NS(NS,CLASS) DECLARE_PROCESSOR(NS::CLASS)
 
#define DECLARE_PRODUCER(CLASS) DECLARE_PROCESSOR(CLASS)
 
#define DECLARE_ANALYZER_NS(NS,CLASS) DECLARE_PROCESSOR(NS::CLASS)
 
#define DECLARE_ANALYZER(CLASS) DECLARE_PROCESSOR(CLASS)
 
#endif  // FIRE_FRAMEWORK_EVENTPROCESSOR_H