EventSkipperByID.cc

Go to the documentation of this file.

#include "FWCore/Sources/interface/EventSkipperByID.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Utilities/interface/Algorithms.h"
#include "FWCore/ParameterSet/interface/ParameterSetDescription.h"

namespace edm {
  EventSkipperByID::EventSkipperByID(ParameterSet const& pset) :
    // The default value provided as the second argument to the getUntrackedParameter function call
    // is not used when the ParameterSet has been validated and the parameters are not optional
    // in the description.  As soon as all primary input sources and all modules with a secondary
    // input sources have defined descriptions, the defaults in the getUntrackedParameterSet function
    // calls can and should be deleted from the code.
        firstRun_(pset.getUntrackedParameter<unsigned int>("firstRun", 1U)),
        firstLumi_(pset.getUntrackedParameter<unsigned int>("firstLuminosityBlock", 0U)),
        firstEvent_(pset.existsAs<unsigned int>("firstEvent", false) ? pset.getUntrackedParameter<unsigned int>("firstEvent") :
                                                                       pset.getUntrackedParameter<unsigned long long>("firstEvent", 1U)),
        whichLumisToSkip_(pset.getUntrackedParameter<std::vector<LuminosityBlockRange> >("lumisToSkip", std::vector<LuminosityBlockRange>())),
        whichLumisToProcess_(pset.getUntrackedParameter<std::vector<LuminosityBlockRange> >("lumisToProcess", std::vector<LuminosityBlockRange>())),
        whichEventsToSkip_(pset.getUntrackedParameter<std::vector<EventRange> >("eventsToSkip",std::vector<EventRange>())),
        whichEventsToProcess_(pset.getUntrackedParameter<std::vector<EventRange> >("eventsToProcess",std::vector<EventRange>())),
        skippingLumis_(!(whichLumisToSkip_.empty() && whichLumisToProcess_.empty())),
        skippingEvents_(!(whichEventsToSkip_.empty() && whichEventsToProcess_.empty())),
        somethingToSkip_(skippingLumis_ || skippingEvents_ || !(firstRun_ <= 1U && firstLumi_ <= 1U && firstEvent_ <= 1U)) {

    sortAndRemoveOverlaps(whichLumisToSkip_);
    sortAndRemoveOverlaps(whichLumisToProcess_);
    sortAndRemoveOverlaps(whichEventsToSkip_);
    sortAndRemoveOverlaps(whichEventsToProcess_);
  }

  EventSkipperByID::~EventSkipperByID() {}

  std::unique_ptr<EventSkipperByID>
  EventSkipperByID::create(ParameterSet const& pset) {
    auto evSkp = std::make_unique<EventSkipperByID>(pset);
    if (!evSkp->somethingToSkip()) {
      evSkp.reset();
    }
    return evSkp;
  }

  // Determines whether a run, lumi, or event will be skipped based on the run, lumi, and event number.
  // This function is called by a predicate, so it must not modify the state of the EventSkipperByID_ object.
  // The mutable lumi_ and event_ data members are just temporary caches, so they may be modified.
  bool
  EventSkipperByID::skipIt(RunNumber_t run, LuminosityBlockNumber_t lumi, EventNumber_t event) const {

    if(run == 0U) run = 1U; // Correct zero run number
    if(run < firstRun_) {
      // Skip all entries before the first run.
      return true;
    }
    if(lumi == 0U) {
      // This is a run entry that is not before the first run.
      // Keep it, since there are no other parameters to skip runs.
      return false;
    }
    // If we get here, this is a lumi or event entry.
    if(run == firstRun_) {
      // This lumi or event entry is in the first run to be processed.
      if(lumi < firstLumi_) {
        // This lumi or event entry is for a lumi prior to the first lumi to be processed.  Skip it.
        return true;
      }
      if(firstLumi_ == 0 || lumi == firstLumi_) {
        // If we get here, this entry is in the first lumi to be processed in the first run.
    // Note that if firstLumi_ == 0, we are processing all lumis in the run.
        if(event != 0U && event < firstEvent_) {
      // This is an event entry prior to the first event to be processed. Skip it.
          return true;
        }
      }
    }
    if (skippingLumis()) {
      // If we get here, the entry was not skipped due to firstRun, firstLuminosityBlock, and/or firstEvent.
      LuminosityBlockID lumiID = LuminosityBlockID(run, lumi);
      LuminosityBlockRange lumiRange = LuminosityBlockRange(lumiID, lumiID);
      bool(*lt)(LuminosityBlockRange const&, LuminosityBlockRange const&) = &lessThan;
      if(binary_search_all(whichLumisToSkip_, lumiRange, lt)) {
        // The entry is in a lumi specified in whichLumisToSkip.  Skip it.
        return true;
      }
      if(!whichLumisToProcess_.empty() && !binary_search_all(whichLumisToProcess_, lumiRange, lt)) {
        // The entry is not in a lumi specified in non-empty whichLumisToProcess.  Skip it.
        return true;
      }
    }
    if(event == 0U) {
      // The entry is a lumi entry that was not skipped above.  Keep it.
      return false;
    }
    if (skippingEvents()) {
      // If we get here, the entry was not skipped due to firstRun, firstLuminosityBlock, and/or firstEvent.
      EventID eventID = EventID(run, lumi, event);
      EventRange eventRange = EventRange(eventID, eventID);
      EventID eventIDNoLumi = EventID(run, 0U, event);
      EventRange eventRangeNoLumi = EventRange(eventIDNoLumi, eventIDNoLumi);
      bool(*lt)(EventRange const&, EventRange const&) = &lessThanSpecial;
      if(binary_search_all(whichEventsToSkip_, eventRange, lt) || binary_search_all(whichEventsToSkip_, eventRangeNoLumi, lt)) {
        // The entry is an event specified in whichEventsToSkip.  Skip it.
        return true;
      }
      if(!whichEventsToProcess_.empty() && !binary_search_all(whichEventsToProcess_, eventRange, lt) && !binary_search_all(whichEventsToProcess_, eventRangeNoLumi, lt)) {
        // The entry is not an event specified in non-empty whichEventsToProcess.  Skip it.
        return true;
      }
    }
    return false;
  }

  void
  EventSkipperByID::fillDescription(ParameterSetDescription & desc) {

    desc.addUntracked<unsigned int>("firstRun", 1U)
        ->setComment("Skip any run with run number < 'firstRun'.");
    desc.addUntracked<unsigned int>("firstLuminosityBlock", 0U)
        ->setComment("Skip any lumi in run 'firstRun' with lumi number < 'firstLuminosityBlock'.");

    desc.addNode( edm::ParameterDescription<unsigned int>("firstEvent", 1U, false) xor
                  edm::ParameterDescription<unsigned long long>("firstEvent", 1ULL, false))
        ->setComment("'firstEvent' is an XOR group because it can have type uint32 or uint64, default:1\n"
                     "If 'firstLuminosityBlock' == 0, skip any event in run 'firstRun' with event number < 'firstEvent'.\n"
                     "If 'firstLuminosityBlock' != 0, skip any event in lumi 'firstRun:firstLuminosityBlock' with event number < 'firstEvent'.");

    std::vector<LuminosityBlockRange> defaultLumis;
    desc.addUntracked<std::vector<LuminosityBlockRange> >("lumisToSkip", defaultLumis)
        ->setComment("Skip any lumi inside the specified run:lumi range. In python do 'help(cms.LuminosityBlockRange)' for documentation.");
    desc.addUntracked<std::vector<LuminosityBlockRange> >("lumisToProcess", defaultLumis)
        ->setComment("If not empty, skip any lumi outside the specified run:lumi range. In python do 'help(cms.LuminosityBlockRange)' for documentation.");

    std::vector<EventRange> defaultEvents;
    desc.addUntracked<std::vector<EventRange> >("eventsToSkip", defaultEvents)
        ->setComment("Skip any event inside the specified run:event or run:lumi:event range. In python do 'help(cms.EventRange)' for documentation.");
    desc.addUntracked<std::vector<EventRange> >("eventsToProcess", defaultEvents)
        ->setComment("If not empty, skip any event outside the specified run:event or run:lumi:event range. In python do 'help(cms.EventRange)' for documentation.");
  }
}