framework::Process Class Reference

Class which represents the process under execution. More...

#include <Process.h>

Public Member Functions
	Process (const framework::config::Parameters &configuration)
	Class constructor.
	~Process ()
	Class Destructor.
const std::string &	getPassName () const
	Get the processing pass label.
int	getRunNumber () const
	Get the current run number or the run number to be used when initiating new events from the job.
const ldmx::EventHeader *	getEventHeader () const
	Get the pointer to the current event header, if defined.
const ldmx::RunHeader *	getRunHeader () const
	Get the pointer to the current run header, if defined.
Conditions &	getConditions ()
	Get a reference to the conditions system.
int	getLogFrequency () const
	Get the frequency with which the event information is printed.
void	run ()
	Run the process.
void	requestFinish ()
	Request that the processing finish with this event.
TDirectory *	makeHistoDirectory (const std::string &dirName)
	Construct a TDirectory* for the given module.
TDirectory *	openHistoFile ()
	Open a ROOT TFile to write histograms and TTrees.
StorageControl &	getStorageController ()
	Access the storage control unit for this process.
void	setEventHeader (ldmx::EventHeader *h)
	Set the pointer to the current event header, used only for tests.

Static Public Member Functions
static Process	getDummy ()
	Get a dummy process.

Private Member Functions
	Process ()
	Private dummy constructor We hide it here because it shouldn't be used anywhere else.
bool	process (int n, int n_tries, Event &event) const
	Process the input event through the sequence of processors.
void	newRun (ldmx::RunHeader &header)
	Run through the processors and let them know that we are starting a new run.
void	onFileOpen (EventFile &file) const
	File is being opened.
void	onFileClose (EventFile &file) const
	File is begin closed.
	enableLogging ("Process")
	Turn on logging for our process.

Private Attributes
framework::config::Parameters	config_
	The parameters used to configure this class.
std::string	passname_
	Processing pass name.
int	eventLimit_
	Limit on events to process.
int	totalEvents_
	Number of events we'd like to produce independetly of the number of tries it would take.
int	logFrequency_
	The frequency with which event info is printed.
int	maxTries_
	Maximum number of attempts to make before giving up on an event.
bool	skipCorruptedInputFiles_
	allow the Process to skip input files that are corrupted
StorageControl	storageController_
	Storage controller.
std::vector< EventProcessor * >	sequence_
	Ordered list of EventProcessors to execute.
Conditions	conditions_
	Set of ConditionsProviders.
std::vector< std::string >	inputFiles_
	List of input files to process.
std::vector< std::string >	outputFiles_
	List of output file names.
int	compressionSetting_
	Compression setting to pass to output files.
std::vector< std::string >	dropKeepRules_
	Set of drop/keep rules.
int	runForGeneration_ {1}
	Run number to use if generating events.
std::string	histoFilename_
	Filename for histograms and other user products.
const ldmx::EventHeader *	eventHeader_ {0}
	Pointer to the current EventHeader, used for Conditions information.
ldmx::RunHeader *	runHeader_ {0}
	Pointer to the current RunHeader, used for Conditions information.
TFile *	histoTFile_ {0}
	TFile for histograms and other user products.
performance::Tracker *	performance_ {0}
	class with calls backs to track performance measurements of software

Detailed Description

Class which represents the process under execution.

Definition at line 36 of file Process.h.

Constructor & Destructor Documentation

Process() [1/2]

framework::Process::Process

(

const framework::config::Parameters &

configuration

)

Class constructor.

Parameters

configuration

Parameters to configure process with

Definition at line 23 of file Process.cxx.

    : conditions_{*this} {
  config_ = configuration;
 
  passname_ = configuration.getParameter<std::string>("passName", "");
  histoFilename_ = configuration.getParameter<std::string>("histogramFile", "");
 
  maxTries_ = configuration.getParameter<int>("maxTriesPerEvent", 1);
  eventLimit_ = configuration.getParameter<int>("maxEvents", -1);
  totalEvents_ = configuration.getParameter<int>("totalEvents", -1);
  logFrequency_ = configuration.getParameter<int>("logFrequency", -1);
  compressionSetting_ =
      configuration.getParameter<int>("compressionSetting", 9);
  skipCorruptedInputFiles_ =
      configuration.getParameter<bool>("skipCorruptedInputFiles", false);
 
  inputFiles_ =
      configuration.getParameter<std::vector<std::string>>("inputFiles", {});
  outputFiles_ =
      configuration.getParameter<std::vector<std::string>>("outputFiles", {});
  dropKeepRules_ =
      configuration.getParameter<std::vector<std::string>>("keep", {});
 
  eventHeader_ = 0;
 
  // set up the logging for this run
  logging::open(
      configuration.getParameter<framework::config::Parameters>("logger", {}));
 
  auto run{configuration.getParameter<int>("run", -1)};
  if (run > 0) runForGeneration_ = run;
 
  auto libs{
      configuration.getParameter<std::vector<std::string>>("libraries", {})};
  std::for_each(libs.begin(), libs.end(), [](auto &lib) {
    PluginFactory::getInstance().loadLibrary(lib);
  });
 
  storageController_.setDefaultKeep(
      configuration.getParameter<bool>("skimDefaultIsKeep", true));
  auto skimRules{
      configuration.getParameter<std::vector<std::string>>("skimRules", {})};
  for (size_t i = 0; i < skimRules.size(); i += 2) {
    storageController_.addRule(skimRules[i], skimRules[i + 1]);
  }
 
  auto sequence{
      configuration.getParameter<std::vector<framework::config::Parameters>>(
          "sequence", {})};
  if (sequence.empty() &&
      configuration.getParameter<bool>("testingMode", false)) {
    EXCEPTION_RAISE(
        "NoSeq",
        "No sequence has been defined. What should I be doing?\nUse "
        "p.sequence to tell me what processors to run.");
  }
  for (auto proc : sequence) {
    auto className{proc.getParameter<std::string>("className")};
    auto instanceName{proc.getParameter<std::string>("instanceName")};
    EventProcessor *ep = PluginFactory::getInstance().createEventProcessor(
        className, instanceName, *this);
    if (ep == 0) {
      EXCEPTION_RAISE(
          "UnableToCreate",
          "Unable to create instance '" + instanceName + "' of class '" +
              className +
              "'. Did you load the library that this class is apart of?");
    }
    auto histograms{
        proc.getParameter<std::vector<framework::config::Parameters>>(
            "histograms", {})};
    if (!histograms.empty()) {
      ep->getHistoDirectory();
      ep->createHistograms(histograms);
    }
    ep->configure(proc);
    sequence_.push_back(ep);
  }
 
  auto conditionsObjectProviders{
      configuration.getParameter<std::vector<framework::config::Parameters>>(
          "conditionsObjectProviders", {})};
  for (auto cop : conditionsObjectProviders) {
    auto className{cop.getParameter<std::string>("className")};
    auto objectName{cop.getParameter<std::string>("objectName")};
    auto tagName{cop.getParameter<std::string>("tagName")};
 
    conditions_.createConditionsObjectProvider(className, objectName, tagName,
                                               cop);
  }
 
  bool logPerformance =
      configuration.getParameter<bool>("logPerformance", false);
  if (logPerformance) {
    std::vector<std::string> names{sequence_.size()};
    for (std::size_t i{0}; i < sequence_.size(); i++) {
      names[i] = sequence_[i]->getName();
    }
    performance_ =
        new performance::Tracker(makeHistoDirectory("performance"), names);
  }
}

References framework::StorageControl::addRule(), compressionSetting_, conditions_, config_, framework::EventProcessor::configure(), framework::Conditions::createConditionsObjectProvider(), framework::PluginFactory::createEventProcessor(), framework::EventProcessor::createHistograms(), dropKeepRules_, eventHeader_, eventLimit_, framework::EventProcessor::getHistoDirectory(), framework::PluginFactory::getInstance(), framework::config::Parameters::getParameter(), histoFilename_, inputFiles_, logFrequency_, makeHistoDirectory(), maxTries_, outputFiles_, passname_, performance_, run(), runForGeneration_, sequence_, framework::StorageControl::setDefaultKeep(), skipCorruptedInputFiles_, storageController_, and totalEvents_.

~Process()

framework::Process::~Process

(

)

Class Destructor.

Cleans up sequence of EventProcessors. These processors were created by ConfigurePython and should be deleted.

Definition at line 126 of file Process.cxx.

                  {
  // need to delete the performance object so that it is
  // written before we close the histogram file below
  if (performance_) delete performance_;
  for (EventProcessor *ep : sequence_) {
    delete ep;
  }
  if (histoTFile_) {
    histoTFile_->Write();
    delete histoTFile_;
    histoTFile_ = 0;
  }
}

References histoTFile_, performance_, and sequence_.

Process() [2/2]

framework::Process::Process ( )

inlineprivate

Private dummy constructor We hide it here because it shouldn't be used anywhere else.

Definition at line 133 of file Process.h.

: conditions_{*this} {}

Referenced by getDummy().

Member Function Documentation

getConditions()

Conditions & framework::Process::getConditions ( )

inline

Get a reference to the conditions system.

Definition at line 78 of file Process.h.

{ return conditions_; }

References conditions_.

Referenced by framework::EventProcessor::getConditions(), and framework::ConditionsObjectProvider::requestParentCondition().

getDummy()

static Process framework::Process::getDummy ( )

inlinestatic

Get a dummy process.

This function returns an instance of this class without any configuration. This is only helpful in the use case where the user is writing a test for a processor and needs to pass a Process object to the processor's constructor.

Returns

Process without any configuration

Definition at line 126 of file Process.h.

{ return std::move(Process()); }

References Process().

getEventHeader()

const ldmx::EventHeader * framework::Process::getEventHeader ( ) const

inline

Get the pointer to the current event header, if defined.

Definition at line 68 of file Process.h.

{ return eventHeader_; }

References eventHeader_.

Referenced by framework::Conditions::getConditionPtr(), and framework::EventProcessor::getEventHeader().

getLogFrequency()

int framework::Process::getLogFrequency ( ) const

inline

Get the frequency with which the event information is printed.

Returns

integer log frequency (negative if turned off)

Definition at line 84 of file Process.h.

{ return logFrequency_; }

References logFrequency_.

Referenced by framework::EventProcessor::getLogFrequency().

getPassName()

const std::string & framework::Process::getPassName ( ) const

inline

Get the processing pass label.

Returns

The processing pass label.

Definition at line 56 of file Process.h.

{ return passname_; }

References passname_.

Referenced by framework::RandomNumberSeedService::onNewRun().

getRunHeader()

const ldmx::RunHeader * framework::Process::getRunHeader ( ) const

inline

Get the pointer to the current run header, if defined.

Definition at line 73 of file Process.h.

{ return runHeader_; }

References runHeader_.

getRunNumber()

int framework::Process::getRunNumber

(

)

const

Get the current run number or the run number to be used when initiating new events from the job.

Returns

int Run number

Definition at line 420 of file Process.cxx.

                                {
  return (eventHeader_) ? (eventHeader_->getRun()) : (runForGeneration_);
}

References eventHeader_, ldmx::EventHeader::getRun(), and runForGeneration_.

Referenced by framework::EventProcessor::getRunNumber().

getStorageController()

StorageControl & framework::Process::getStorageController ( )

inline

Access the storage control unit for this process.

Definition at line 109 of file Process.h.

{ return storageController_; }

References storageController_.

Referenced by framework::EventProcessor::setStorageHint().

makeHistoDirectory()

TDirectory * framework::Process::makeHistoDirectory

(

const std::string &

dirName

)

Construct a TDirectory* for the given module.

Definition at line 424 of file Process.cxx.

                                                                {
  auto owner{openHistoFile()};
  TDirectory *child = owner->mkdir((char *)dirName.c_str());
  if (child) child->cd();
  return child;
}

References openHistoFile().

Referenced by framework::EventProcessor::getHistoDirectory(), and Process().

newRun()

void framework::Process::newRun ( ldmx::RunHeader &  header )

private

Run through the processors and let them know that we are starting a new run.

Parameters

[in]

header

RunHeader for the new run

Definition at line 452 of file Process.cxx.

                                          {
  // Producers are allowed to put parameters into
  // the run header through 'beforeNewRun' method
  if (performance_) performance_->start(performance::Callback::beforeNewRun, 0);
  std::size_t i_proc{0};
  for (auto module : sequence_) {
    i_proc++;
    if (dynamic_cast<Producer *>(module)) {
      if (performance_)
        performance_->start(performance::Callback::beforeNewRun, i_proc);
      dynamic_cast<Producer *>(module)->beforeNewRun(header);
      if (performance_)
        performance_->stop(performance::Callback::beforeNewRun, i_proc);
    }
  }
  if (performance_) performance_->stop(performance::Callback::beforeNewRun, 0);
  // now run header has been modified by Producers,
  // it is valid to read from for everyone else in 'onNewRun'
  if (performance_) performance_->start(performance::Callback::onNewRun, 0);
  conditions_.onNewRun(header);
  i_proc = 0;
  for (auto module : sequence_) {
    i_proc++;
    if (performance_)
      performance_->start(performance::Callback::onNewRun, i_proc);
    module->onNewRun(header);
    if (performance_)
      performance_->stop(performance::Callback::onNewRun, i_proc);
  }
  if (performance_) performance_->stop(performance::Callback::onNewRun, 0);
}

References conditions_, framework::Conditions::onNewRun(), performance_, sequence_, framework::performance::Tracker::start(), and framework::performance::Tracker::stop().

Referenced by run().

onFileClose()

void framework::Process::onFileClose ( EventFile &  file ) const

private

File is begin closed.

Definition at line 539 of file Process.cxx.

                                               {
  if (performance_) performance_->start(performance::Callback::onFileClose, 0);
  std::size_t i_proc{0};
  for (auto module : sequence_) {
    i_proc++;
    if (performance_)
      performance_->start(performance::Callback::onFileClose, i_proc);
    module->onFileClose(file);
    if (performance_)
      performance_->stop(performance::Callback::onFileClose, i_proc);
  }
  if (performance_) performance_->stop(performance::Callback::onFileClose, 0);
}

References performance_, sequence_, framework::performance::Tracker::start(), and framework::performance::Tracker::stop().

Referenced by run().

onFileOpen()

void framework::Process::onFileOpen ( EventFile &  file ) const

private

File is being opened.

Definition at line 525 of file Process.cxx.

                                              {
  if (performance_) performance_->start(performance::Callback::onFileOpen, 0);
  std::size_t i_proc{0};
  for (auto module : sequence_) {
    i_proc++;
    if (performance_)
      performance_->start(performance::Callback::onFileOpen, i_proc);
    module->onFileOpen(file);
    if (performance_)
      performance_->stop(performance::Callback::onFileOpen, i_proc);
  }
  if (performance_) performance_->stop(performance::Callback::onFileOpen, 0);
}

References performance_, sequence_, framework::performance::Tracker::start(), and framework::performance::Tracker::stop().

Referenced by run().

openHistoFile()

TDirectory * framework::Process::openHistoFile

(

)

Open a ROOT TFile to write histograms and TTrees.

Definition at line 431 of file Process.cxx.

                                   {
  TDirectory *owner{nullptr};
 
  if (histoFilename_.empty()) {
    // trying to write histograms/ntuples but no file defined
    EXCEPTION_RAISE(
        "NoHistFileName",
        "You did not provide the necessary histogram file name to "
        "put your histograms (or performance data) in.\n    Provide this "
        "name in the python configuration with 'p.histogramFile = "
        "\"myHistFile.root\"' where p is the Process object.");
  } else if (histoTFile_ == nullptr) {
    histoTFile_ = new TFile(histoFilename_.c_str(), "RECREATE");
    owner = histoTFile_;
  } else
    owner = histoTFile_;
  owner->cd();
 
  return owner;
}

References histoFilename_, and histoTFile_.

Referenced by makeHistoDirectory().

process()

bool framework::Process::process ( int  n, int  n_tries, Event &  event  ) const

private

Process the input event through the sequence of processors.

The input counters (for events and tries) are only used to print the status.

Parameters

[in]	n	counter for number of events processed
[in]	n_tries	counter for number of tries on current event
[in,out]	event	reference to event we are going to process

Returns

true if event was full processed (false if aborted)

Definition at line 484 of file Process.cxx.

                                                          {
  if ((logFrequency_ != -1) && ((n + 1) % logFrequency_ == 0) && (n_try < 2)) {
    // only printout event counter if we've enabled log frequency, the event
    // matches the frequency and we are on the first try
    TTimeStamp t;
    ldmx_log(info) << "Processing " << n + 1 << " Run "
                   << event.getEventHeader().getRun() << " Event "
                   << event.getEventHeader().getEventNumber() << "  ("
                   << t.AsString("lc") << ")";
  }
 
  if (performance_) performance_->start(performance::Callback::process, 0);
  std::size_t i_proc{0};
  try {
    for (auto module : sequence_) {
      i_proc++;
      if (performance_)
        performance_->start(performance::Callback::process, i_proc);
      if (dynamic_cast<Producer *>(module)) {
        (dynamic_cast<Producer *>(module))->produce(event);
      } else if (dynamic_cast<Analyzer *>(module)) {
        (dynamic_cast<Analyzer *>(module))->analyze(event);
      }
      if (performance_)
        performance_->stop(performance::Callback::process, i_proc);
    }
  } catch (AbortEventException &) {
    if (performance_) {
      performance_->stop(performance::Callback::process, i_proc);
      performance_->stop(performance::Callback::process, 0);
      performance_->end_event(false);
    }
    return false;
  }
  if (performance_) {
    performance_->stop(performance::Callback::process, 0);
    performance_->end_event(true);
  }
  return true;
}

References framework::performance::Tracker::end_event(), logFrequency_, performance_, sequence_, framework::performance::Tracker::start(), and framework::performance::Tracker::stop().

Referenced by run().

requestFinish()

void framework::Process::requestFinish ( )

inline

Request that the processing finish with this event.

Definition at line 94 of file Process.h.

{ eventLimit_ = 0; }

References eventLimit_.

run()

void framework::Process::run

(

)

Run the process.

Definition at line 140 of file Process.cxx.

                  {
  if (performance_) performance_->absolute_start();
 
  // Counter to keep track of the number of events that have been
  // procesed
  auto n_events_processed{0};
 
  // make sure the ntuple manager is in a blank state
  NtupleManager::getInstance().reset();
 
  // event bus for this process
  Event theEvent(passname_);
  // the EventHeader object is created with the event bus as
  // one of its members, we obtain a pointer for the header
  // here so we can share it with the conditions system
  eventHeader_ = theEvent.getEventHeaderPtr();
  theEvent.getEventHeader().setRun(runForGeneration_);
 
  // Start by notifying everyone that modules processing is beginning
  std::size_t i_proc{0};
  if (performance_)
    performance_->start(performance::Callback::onProcessStart, 0);
  conditions_.onProcessStart();
  for (auto module : sequence_) {
    i_proc++;
    if (performance_)
      performance_->start(performance::Callback::onProcessStart, i_proc);
    module->onProcessStart();
    if (performance_)
      performance_->stop(performance::Callback::onProcessStart, i_proc);
  }
  if (performance_)
    performance_->stop(performance::Callback::onProcessStart, 0);
 
  // If we have no input files, but do have an event number, run for
  // that number of events and generate an output file.
  if (inputFiles_.empty() && eventLimit_ > 0) {
    if (outputFiles_.empty()) {
      EXCEPTION_RAISE("InvalidConfig",
                      "No input files or output files were given.");
    } else if (outputFiles_.size() > 1) {
      ldmx_log(warn) << "Several output files given with no input files. "
                     << "Only the first output file '" << outputFiles_.at(0)
                     << "' will be used.";
    }
    std::string outputFileName = outputFiles_.at(0);
 
    // Configure the event file to create an output file with no parent. This
    // requires setting the parameters isOutputFile and isSingleOutput to true.
    EventFile outFile(config_, outputFileName, nullptr, true, true, false);
    onFileOpen(outFile);
    outFile.setupEvent(&theEvent);
 
    for (auto rule : dropKeepRules_) outFile.addDrop(rule);
 
    ldmx::RunHeader runHeader(runForGeneration_);
    runHeader.setRunStart(std::time(nullptr));  // set run starting
    runHeader_ = &runHeader;            // give handle to run header to process
    outFile.writeRunHeader(runHeader);  // add run header to file
 
    newRun(runHeader);
 
    int totalTries = 0;  // total number of tries for entire run
    int numTries = 0;    // number of tries for the current event number
    int event_limit = eventLimit_;
    if (totalEvents_ > 0) {
      // Have a warning at the first event
      if (numTries == 0)
        ldmx_log(warn) << "The totalEvents was set, so maxEvents and "
                          "maxTriesPerEvent will be ignored!";
      event_limit = totalEvents_;
    }
    while (n_events_processed < event_limit) {
      totalTries++;
      numTries++;
 
      ldmx::EventHeader &eh = theEvent.getEventHeader();
      eh.setRun(runForGeneration_);
      eh.setEventNumber(n_events_processed + 1);
      eh.setTimestamp(TTimeStamp());
 
      // reset the storage controller state
      storageController_.resetEventState();
      logging::Formatter::set(theEvent.getEventNumber());
 
      bool completed = process(n_events_processed, numTries, theEvent);
 
      outFile.nextEvent(storageController_.keepEvent(completed));
 
      // reset try counter only on successfully completed events
      if (completed) numTries = 0;
 
      // we use modulo here insetad of >= because we want to carry
      // the number of tries across the number of events processed boundary
      // totalEvents_ is set let's not exit until that's reached
      if (completed or (totalEvents_ < 0 and numTries % maxTries_ == 0)) {
        n_events_processed++;                 // increment events made
        NtupleManager::getInstance().fill();  // fill ntuples
      }
 
      NtupleManager::getInstance().clear();
    }
 
    onFileClose(outFile);
 
    runHeader.setRunEnd(std::time(nullptr));
    runHeader.setNumTries(totalTries);
    ldmx_log(info) << runHeader;
    outFile.writeRunTree();
 
    // Give a warning that this filter has very low efficiency
    if (n_events_processed < totalTries / 10000) {  // integer division is okay
      ldmx_log(warn)
          << "Less than 1 event out of every 10k events tried was accepted!";
      ldmx_log(warn)
          << "This could be an issue with your filtering and biasing procedure "
             "since this is incredibly inefficient.";
    }
 
  } else {
    // there are input files
 
    EventFile *outFile(0);
 
    bool singleOutput = false;
    if (outputFiles_.size() == 1) {
      singleOutput = true;
    } else if (!outputFiles_.empty() and
               outputFiles_.size() != inputFiles_.size()) {
      EXCEPTION_RAISE("Process",
                      "Unable to handle case of different number of input and "
                      "output files (other than zero/one ouput file).");
    }
 
    // next, loop through the files
    int ifile = 0;
    int wasRun = -1;
    for (auto infilename : inputFiles_) {
      EventFile inFile(config_, infilename);
      if (inFile.isCorrupted()) {
        if (skipCorruptedInputFiles_) {
          ldmx_log(warn) << "Input file '" << infilename
                         << "' was found to be corrupted. Skipping.";
          continue;
        } else {
          EXCEPTION_RAISE(
              "BadCode",
              "We should never get here. "
              "EventFile is corrupted but we aren't skipping corrupted inputs. "
              "EventFile should be throwing its own exceptions in this case.");
        }
      }
 
      ldmx_log(info) << "Opening file " << infilename;
      onFileOpen(inFile);
 
      // configure event file that will be iterated over
      EventFile *masterFile;
      if (!outputFiles_.empty()) {
        // setup new output file if either
        // 1) we are not in single output mode
        // 2) this is the first input file
        if (!singleOutput or ifile == 0) {
          // setup new output file
          outFile = new EventFile(config_, outputFiles_[ifile], &inFile,
                                  singleOutput);
          ifile++;
 
          // setup theEvent we will iterate over
          if (outFile) {
            outFile->setupEvent(&theEvent);
            masterFile = outFile;
          } else {
            EXCEPTION_RAISE("Process", "Unable to construct output file for " +
                                           outputFiles_[ifile]);
          }
 
          for (auto rule : dropKeepRules_) outFile->addDrop(rule);
 
        } else {
          // all other input files
          outFile->updateParent(&inFile);
          masterFile = outFile;
 
        }  // check if in singleOutput mode
 
      } else {
        // empty output file list, use inputFile as master file
        inFile.setupEvent(&theEvent);
        masterFile = &inFile;
      }
 
      bool event_completed = true;
      while (masterFile->nextEvent(
                 storageController_.keepEvent(event_completed)) &&
             (eventLimit_ < 0 || (n_events_processed) < eventLimit_)) {
        // clean up for storage control calculation
        storageController_.resetEventState();
        logging::Formatter::set(theEvent.getEventNumber());
 
        // notify for new run if necessary
        if (theEvent.getEventHeader().getRun() != wasRun) {
          wasRun = theEvent.getEventHeader().getRun();
          ldmx::RunHeader *rh{masterFile->getRunHeaderPtr(wasRun)};
          if (rh != nullptr) {
            runHeader_ = rh;
            ldmx_log(info) << "Got new run header from '"
                           << masterFile->getFileName() << "' ...\n"
                           << *runHeader_;
            newRun(*runHeader_);
          } else {
            ldmx_log(warn) << "Run header for run " << wasRun
                           << " was not found!";
          }
        }
 
        event_completed = process(n_events_processed, 1, theEvent);
 
        if (event_completed) NtupleManager::getInstance().fill();
        NtupleManager::getInstance().clear();
 
        n_events_processed++;
      }  // loop through events
 
      bool leave_early{false};
      if (eventLimit_ > 0 && n_events_processed == eventLimit_) {
        ldmx_log(info) << "Reached event limit of " << eventLimit_ << " events";
        leave_early = true;
      }
 
      if (eventLimit_ == 0 && n_events_processed > eventLimit_) {
        ldmx_log(warn) << "Processing interrupted";
        leave_early = true;
      }
 
      ldmx_log(info) << "Closing file " << infilename;
      onFileClose(inFile);
 
      // Reset the event in case of multiple input files
      theEvent.onEndOfFile();
 
      if (outFile and !singleOutput) {
        outFile->writeRunTree();
        delete outFile;
        outFile = nullptr;
      }
 
      if (leave_early) {
        break;
      }
    }  // loop through input files
 
    if (outFile) {
      // close outFile
      //  outFile would survive to here in single output mode
      outFile->writeRunTree();
      delete outFile;
      outFile = nullptr;
    }
 
  }  // are there input files? if-else tree
 
  // finally, notify everyone that we are stopping
  if (performance_) performance_->start(performance::Callback::onProcessEnd, 0);
  i_proc = 0;
  for (auto module : sequence_) {
    i_proc++;
    if (performance_)
      performance_->start(performance::Callback::onProcessEnd, i_proc);
    module->onProcessEnd();
    if (performance_)
      performance_->stop(performance::Callback::onProcessEnd, i_proc);
  }
  if (performance_) performance_->stop(performance::Callback::onProcessEnd, 0);
 
  // we're done so let's close up the logging
  logging::close();
  if (performance_) performance_->absolute_stop();
}

References framework::performance::Tracker::absolute_start(), framework::performance::Tracker::absolute_stop(), framework::EventFile::addDrop(), framework::NtupleManager::clear(), conditions_, config_, dropKeepRules_, eventHeader_, eventLimit_, framework::Event::getEventHeader(), framework::Event::getEventHeaderPtr(), framework::Event::getEventNumber(), framework::EventFile::getFileName(), framework::NtupleManager::getInstance(), ldmx::EventHeader::getRun(), framework::EventFile::getRunHeaderPtr(), inputFiles_, framework::EventFile::isCorrupted(), framework::StorageControl::keepEvent(), maxTries_, newRun(), framework::EventFile::nextEvent(), framework::Event::onEndOfFile(), onFileClose(), onFileOpen(), framework::Conditions::onProcessStart(), outputFiles_, passname_, performance_, process(), framework::NtupleManager::reset(), framework::StorageControl::resetEventState(), runForGeneration_, runHeader_, sequence_, framework::logging::Formatter::set(), ldmx::EventHeader::setEventNumber(), ldmx::RunHeader::setNumTries(), ldmx::EventHeader::setRun(), ldmx::RunHeader::setRunEnd(), ldmx::RunHeader::setRunStart(), ldmx::EventHeader::setTimestamp(), framework::EventFile::setupEvent(), skipCorruptedInputFiles_, framework::performance::Tracker::start(), framework::performance::Tracker::stop(), storageController_, totalEvents_, framework::EventFile::updateParent(), framework::EventFile::writeRunHeader(), and framework::EventFile::writeRunTree().

Referenced by Process().

setEventHeader()

void framework::Process::setEventHeader ( ldmx::EventHeader *  h )

inline

Set the pointer to the current event header, used only for tests.

Definition at line 114 of file Process.h.

{ eventHeader_ = h; }

References eventHeader_.

Member Data Documentation

compressionSetting_

int framework::Process::compressionSetting_

private

Compression setting to pass to output files.

Look at the documentation for the TFile constructor if you want to learn more details. Essentially, setting = 100*algo + level with algo = 0 being the global default.

Definition at line 216 of file Process.h.

Referenced by Process().

conditions_

Conditions framework::Process::conditions_

private

Set of ConditionsProviders.

Definition at line 200 of file Process.h.

Referenced by getConditions(), newRun(), Process(), and run().

config_

framework::config::Parameters framework::Process::config_

private

The parameters used to configure this class.

Definition at line 169 of file Process.h.

Referenced by Process(), and run().

dropKeepRules_

std::vector<std::string> framework::Process::dropKeepRules_

private

Set of drop/keep rules.

Definition at line 219 of file Process.h.

Referenced by Process(), and run().

eventHeader_

const ldmx::EventHeader* framework::Process::eventHeader_ {0}

private

Pointer to the current EventHeader, used for Conditions information.

Definition at line 228 of file Process.h.

{0};

Referenced by getEventHeader(), getRunNumber(), Process(), run(), and setEventHeader().

eventLimit_

int framework::Process::eventLimit_

private

Limit on events to process.

Definition at line 175 of file Process.h.

Referenced by Process(), requestFinish(), and run().

histoFilename_

std::string framework::Process::histoFilename_

private

Filename for histograms and other user products.

Definition at line 225 of file Process.h.

Referenced by openHistoFile(), and Process().

histoTFile_

TFile* framework::Process::histoTFile_ {0}

private

TFile for histograms and other user products.

Definition at line 234 of file Process.h.

{0};

Referenced by openHistoFile(), and ~Process().

inputFiles_

std::vector<std::string> framework::Process::inputFiles_

private

List of input files to process.

May be empty if this Process will generate new events.

Definition at line 204 of file Process.h.

Referenced by Process(), and run().

logFrequency_

int framework::Process::logFrequency_

private

The frequency with which event info is printed.

Definition at line 183 of file Process.h.

Referenced by getLogFrequency(), Process(), and process().

maxTries_

int framework::Process::maxTries_

private

Maximum number of attempts to make before giving up on an event.

Definition at line 186 of file Process.h.

Referenced by Process(), and run().

outputFiles_

std::vector<std::string> framework::Process::outputFiles_

private

List of output file names.

If empty, no output file will be created.

Definition at line 207 of file Process.h.

Referenced by Process(), and run().

passname_

std::string framework::Process::passname_

private

Processing pass name.

Definition at line 172 of file Process.h.

Referenced by getPassName(), Process(), and run().

performance_

performance::Tracker* framework::Process::performance_ {0}

private

class with calls backs to track performance measurements of software

Definition at line 237 of file Process.h.

{0};

Referenced by newRun(), onFileClose(), onFileOpen(), Process(), process(), run(), and ~Process().

runForGeneration_

int framework::Process::runForGeneration_ {1}

private

Run number to use if generating events.

Definition at line 222 of file Process.h.

{1};

Referenced by getRunNumber(), Process(), and run().

runHeader_

ldmx::RunHeader* framework::Process::runHeader_ {0}

private

Pointer to the current RunHeader, used for Conditions information.

Definition at line 231 of file Process.h.

{0};

Referenced by getRunHeader(), and run().

sequence_

std::vector<EventProcessor *> framework::Process::sequence_

private

Ordered list of EventProcessors to execute.

Definition at line 197 of file Process.h.

Referenced by newRun(), onFileClose(), onFileOpen(), Process(), process(), run(), and ~Process().

skipCorruptedInputFiles_

bool framework::Process::skipCorruptedInputFiles_

private

allow the Process to skip input files that are corrupted

Definition at line 191 of file Process.h.

Referenced by Process(), and run().

storageController_

StorageControl framework::Process::storageController_

private

Storage controller.

Definition at line 194 of file Process.h.

Referenced by getStorageController(), Process(), and run().

totalEvents_

int framework::Process::totalEvents_

private

Number of events we'd like to produce independetly of the number of tries it would take.

Be warned about infinite loops!

Definition at line 180 of file Process.h.

Referenced by Process(), and run().

---

The documentation for this class was generated from the following files:

• Framework/include/Framework/Process.h
• Framework/src/Framework/Process.cxx