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/Histograms.h"
#include "Framework/Logger.h"
#include "Framework/NtupleManager.h"
#include "Framework/RunHeader.h"
#include "Framework/StorageControl.h"
 
/*~~~~~~~~~~~~~~~~*/
/*   C++ StdLib   */
/*~~~~~~~~~~~~~~~~*/
#include <any>
#include <map>
 
class TDirectory;
 
namespace framework {
 
class Process;
class EventProcessor;
class EventFile;
 
typedef EventProcessor *EventProcessorMaker(const std::string &name,
                                            Process &process);
 
class AbortEventException : public framework::exception::Exception {
 public:
  AbortEventException() throw() : framework::exception::Exception() {}
 
  virtual ~AbortEventException() throw() {}
};
 
class EventProcessor {
 public:
  EventProcessor(const std::string &name, Process &process);
 
  virtual ~EventProcessor() { ; }
 
  virtual void configure(framework::config::Parameters &parameters) {}
 
  virtual void onNewRun(const ldmx::RunHeader &runHeader) {}
 
  virtual void onFileOpen(EventFile &eventFile) {}
 
  virtual void onFileClose(EventFile &eventFile) {}
 
  virtual void onProcessStart() {}
 
  virtual void onProcessEnd() {}
 
  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_; }
 
  static void declare(const std::string &classname, int classtype,
                      EventProcessorMaker *);
 
  void createHistograms(
      const std::vector<framework::config::Parameters> &histos);
 
 protected:
  void abortEvent() { throw AbortEventException(); }
 
  HistogramHelper histograms_;
 
  NtupleManager &ntuple_{NtupleManager::getInstance()};
 
  logging::logger theLog_;
 
 private:
  Conditions &getConditions() const;
 
  const ldmx::EventHeader &getEventHeader() const;
 
  Process &process_;
 
  std::string name_;
 
  TDirectory *histoDir_{0};
};
 
class Producer : public EventProcessor {
 public:
  static const int CLASSTYPE{1};
 
  Producer(const std::string &name, Process &process);
 
  virtual void produce(Event &event) = 0;
 
  virtual void beforeNewRun(ldmx::RunHeader &header) {}
};
 
class Analyzer : public EventProcessor {
 public:
  static const int CLASSTYPE{2};
 
  Analyzer(const std::string &name, Process &process);
 
  virtual void analyze(const Event &event) = 0;
};
 
}  // namespace framework
 
#define DECLARE_PRODUCER(CLASS)                                               \
  framework::EventProcessor *CLASS##_ldmx_make(const std::string &name,       \
                                               framework::Process &process) { \
    return new CLASS(name, process);                                          \
  }                                                                           \
  __attribute__((constructor(1000))) static void CLASS##_ldmx_declare() {     \
    framework::EventProcessor::declare(                                       \
        #CLASS, ::framework::Producer::CLASSTYPE, &CLASS##_ldmx_make);        \
  }
 
#define DECLARE_ANALYZER(CLASS)                                               \
  framework::EventProcessor *CLASS##_ldmx_make(const std::string &name,       \
                                               framework::Process &process) { \
    return new CLASS(name, process);                                          \
  }                                                                           \
  __attribute__((constructor(1000))) static void CLASS##_ldmx_declare() {     \
    framework::EventProcessor::declare(                                       \
        #CLASS, ::framework::Analyzer::CLASSTYPE, &CLASS##_ldmx_make);        \
  }
 
#define DECLARE_PRODUCER_NS(NS, CLASS)                                        \
  framework::EventProcessor *CLASS##_ldmx_make(const std::string &name,       \
                                               framework::Process &process) { \
    return new NS::CLASS(name, process);                                      \
  }                                                                           \
  __attribute__((constructor(1000))) static void CLASS##_ldmx_declare() {     \
    framework::EventProcessor::declare(                                       \
        std::string(#NS) + "::" + std::string(#CLASS),                        \
        ::framework::Producer::CLASSTYPE, &CLASS##_ldmx_make);                \
  }
 
#define DECLARE_ANALYZER_NS(NS, CLASS)                                        \
  framework::EventProcessor *CLASS##_ldmx_make(const std::string &name,       \
                                               framework::Process &process) { \
    return new NS::CLASS(name, process);                                      \
  }                                                                           \
  __attribute__((constructor(1000))) static void CLASS##_ldmx_declare() {     \
    framework::EventProcessor::declare(                                       \
        std::string(#NS) + "::" + std::string(#CLASS),                        \
        ::framework::Analyzer::CLASSTYPE, &CLASS##_ldmx_make);                \
  }
 
#endif