Process.h

Go to the documentation of this file.

 
#ifndef LDMXSW_FRAMEWORK_PROCESS_H_
#define LDMXSW_FRAMEWORK_PROCESS_H_
 
// LDMX
#include "Framework/Conditions.h"
#include "Framework/Configure/Parameters.h"
#include "Framework/Exception/Exception.h"
#include "Framework/Performance/Tracker.h"
#include "Framework/RunHeader.h"
#include "Framework/StorageControl.h"
 
// STL
#include <map>
#include <memory>
#include <vector>
 
class TFile;
class TDirectory;
 
namespace framework {
 
class EventProcessor;
class EventFile;
class Event;
 
class Process {
 public:
  Process(const framework::config::Parameters &configuration);
 
  ~Process();
 
  const std::string &getPassName() const { return passname_; }
 
  int getRunNumber() const;
 
  const ldmx::EventHeader *getEventHeader() const { return eventHeader_; }
 
  const ldmx::RunHeader *getRunHeader() const { return runHeader_; }
 
  Conditions &getConditions() { return conditions_; }
 
  int getLogFrequency() const { return logFrequency_; }
 
  void run();
 
  void requestFinish() { eventLimit_ = 0; }
 
  TDirectory *makeHistoDirectory(const std::string &dirName);
 
  TDirectory *openHistoFile();
 
  StorageControl &getStorageController() { return storageController_; }
 
  void setEventHeader(ldmx::EventHeader *h) { eventHeader_ = h; }
 
  static Process getDummy() { return std::move(Process()); }
 
 private:
  Process() : conditions_{*this} {}
 
  bool process(int n, int n_tries, Event &event) const;
 
  void newRun(ldmx::RunHeader &header);
 
  void onFileOpen(EventFile &file) const;
 
  void onFileClose(EventFile &file) const;
 
 private:
  framework::config::Parameters config_;
 
  std::string passname_;
 
  int eventLimit_;
 
  int totalEvents_;
 
  int logFrequency_;
 
  int maxTries_;
 
  bool skipCorruptedInputFiles_;
 
  StorageControl storageController_;
 
  std::vector<EventProcessor *> sequence_;
 
  Conditions conditions_;
 
  std::vector<std::string> inputFiles_;
 
  std::vector<std::string> outputFiles_;
 
  int compressionSetting_;
 
  std::vector<std::string> dropKeepRules_;
 
  int runForGeneration_{1};
 
  std::string histoFilename_;
 
  const ldmx::EventHeader *eventHeader_{0};
 
  ldmx::RunHeader *runHeader_{0};
 
  TFile *histoTFile_{0};
 
  performance::Tracker *performance_{0};
 
  enableLogging("Process");
};
 
typedef std::unique_ptr<Process> ProcessHandle;
}  // namespace framework
 
#endif