NavigateEventsLooper.cc

Go to the documentation of this file.

#include "FWCore/Framework/interface/EDLooperBase.h"
#include "FWCore/Framework/interface/LooperFactory.h"
#include "FWCore/Framework/interface/ProcessingController.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"

#include <iostream>

namespace edm {

  class NavigateEventsLooper : public EDLooperBase {
  public:
    NavigateEventsLooper(ParameterSet const& pset);
    ~NavigateEventsLooper() override;

    void startingNewLoop(unsigned int iIteration) override;
    Status duringLoop(Event const& ev, EventSetup const& es, ProcessingController& pc) override;
    Status endOfLoop(EventSetup const& es, unsigned int iCounter) override;

  private:
    NavigateEventsLooper(NavigateEventsLooper const&) = delete;                   // stop default
    NavigateEventsLooper const& operator=(NavigateEventsLooper const&) = delete;  // stop default

    int maxLoops_;
    int countLoops_;
    bool shouldStopLoop_;
    bool shouldStopProcess_;
  };

  NavigateEventsLooper::NavigateEventsLooper(ParameterSet const& pset)
      : maxLoops_(pset.getUntrackedParameter<int>("maxLoops", -1)),
        countLoops_(0),
        shouldStopLoop_(false),
        shouldStopProcess_(false) {}

  NavigateEventsLooper::~NavigateEventsLooper() {}

  void NavigateEventsLooper::startingNewLoop(unsigned int /*iIteration*/) {}

  EDLooperBase::Status NavigateEventsLooper::duringLoop(Event const&, EventSetup const&, ProcessingController& pc) {
    if (!pc.lastOperationSucceeded()) {
      std::cout << "Event could not be found. Nothing done. Try again.\n";
    }

    std::cout << "\nWhat should we do next?\n";

    if (pc.forwardState() == ProcessingController::kEventsAheadInFile) {
      std::cout << "(0) process the next event\n";
    } else if (pc.forwardState() == ProcessingController::kNextFileExists) {
      std::cout << "(0) process the next event if it exists (at last event in the open file. there are more files)\n";
    } else if (pc.forwardState() == ProcessingController::kAtLastEvent) {
      std::cout << "(0) will stop the loop because this is the last event\n";
    } else if (pc.forwardState() == ProcessingController::kUnknownForward) {
      std::cout << "(0) process the next event (if it exists)\n";
    }

    if (pc.canRandomAccess()) {
      if (pc.reverseState() == ProcessingController::kEventsBackwardsInFile) {
        std::cout << "(1) process the previous event\n";
      } else if (pc.reverseState() == ProcessingController::kPreviousFileExists) {
        std::cout << "(1) process the previous event if there are any (at first event in the open file. there are "
                     "previous files)\n";
      } else if (pc.reverseState() == ProcessingController::kAtFirstEvent) {
        std::cout << "(1) will stop the loop because this is the first event\n";
      }

      std::cout << "(2) process a specific event\n";
    }

    std::cout << "(3) stop loop\n";
    std::cout << "(4) stop process" << std::endl;
    long long int x;

    bool inputFailed = false;
    do {
      inputFailed = false;
      if (!(std::cin >> x) || x < 0 || x > 4) {
        inputFailed = true;
        std::cin.clear();
        std::cin.ignore(10000, '\n');
        std::cout << "Please enter numeric characters only. The value must be in the range 0 to 4 (inclusive). Please "
                     "try again."
                  << std::endl;
      }
      if (!pc.canRandomAccess() && (x == 1 || x == 2)) {
        inputFailed = true;
        std::cout << "The source cannot do random access. 1 and 2 are illegal values. Please try again." << std::endl;
      }
    } while (inputFailed);

    shouldStopLoop_ = false;
    shouldStopProcess_ = false;
    if (x == 0) {
      pc.setTransitionToNextEvent();
    } else if (x == 1) {
      pc.setTransitionToPreviousEvent();
    } else if (x == 2) {
      std::cout << "Which run?" << std::endl;
      do {
        inputFailed = false;
        if (!(std::cin >> x)) {
          inputFailed = true;
          std::cin.clear();
          std::cin.ignore(10000, '\n');
          std::cout << "Please enter numeric characters only. Please try again." << std::endl;
        }
      } while (inputFailed);
      RunNumber_t run = x;
      std::cout << "Which luminosity block?" << std::endl;
      do {
        inputFailed = false;
        if (!(std::cin >> x)) {
          inputFailed = true;
          std::cin.clear();
          std::cin.ignore(10000, '\n');
          std::cout << "Please enter numeric characters only. Please try again." << std::endl;
        }
      } while (inputFailed);
      LuminosityBlockNumber_t lumi = x;
      std::cout << "Which event?" << std::endl;
      do {
        inputFailed = false;
        if (!(std::cin >> x)) {
          inputFailed = true;
          std::cin.clear();
          std::cin.ignore(10000, '\n');
          std::cout << "Please enter numeric characters only. Please try again." << std::endl;
        }
      } while (inputFailed);
      EventNumber_t ev = x;
      pc.setTransitionToEvent(EventID(run, lumi, ev));
    } else if (x == 3) {
      pc.setTransitionToNextEvent();
      shouldStopLoop_ = true;
    } else if (x == 4) {
      pc.setTransitionToNextEvent();
      shouldStopLoop_ = true;
      shouldStopProcess_ = true;
    }
    return shouldStopLoop_ ? kStop : kContinue;
  }

  EDLooperBase::Status NavigateEventsLooper::endOfLoop(EventSetup const&, unsigned int /*iCounter*/) {
    std::cout << "Ending loop" << std::endl;
    if (shouldStopProcess_)
      return kStop;
    ++countLoops_;
    return (maxLoops_ < 0 || countLoops_ < maxLoops_) ? kContinue : kStop;
  }
}  // namespace edm

using edm::NavigateEventsLooper;
DEFINE_FWK_LOOPER(NavigateEventsLooper);