#include <EventSkipperByID.h>

Public Member Functions
	EventSkipperByID (ParameterSet const &pset)

bool	skipIt (RunNumber_t run, LuminosityBlockNumber_t lumi, EventNumber_t event) const

bool	skippingEvents () const

bool	skippingLumis () const

bool	somethingToSkip () const

	~EventSkipperByID ()

Static Public Member Functions
static std::unique_ptr< EventSkipperByID >	create (ParameterSet const &pset)

static void	fillDescription (ParameterSetDescription &desc)

Private Attributes
EventNumber_t	firstEvent_

LuminosityBlockNumber_t	firstLumi_

RunNumber_t	firstRun_

bool	skippingEvents_

bool	skippingLumis_

bool	somethingToSkip_

std::vector< EventRange >	whichEventsToProcess_

std::vector< EventRange >	whichEventsToSkip_

std::vector< LuminosityBlockRange >	whichLumisToProcess_

std::vector< LuminosityBlockRange >	whichLumisToSkip_

Detailed Description

Definition at line 17 of file EventSkipperByID.h.

Constructor & Destructor Documentation

edm::EventSkipperByID::EventSkipperByID ( ParameterSet const & pset )

explicit

Definition at line 7 of file EventSkipperByID.cc.

References edm::sortAndRemoveOverlaps(), whichEventsToProcess_, whichEventsToSkip_, whichLumisToProcess_, and whichLumisToSkip_.

                                                              :
     // 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_);
   }

edm::EventSkipperByID::~EventSkipperByID ( )

Definition at line 31 of file EventSkipperByID.cc.

31 {}

Member Function Documentation

std::unique_ptr< EventSkipperByID > edm::EventSkipperByID::create ( ParameterSet const & pset )

static

Definition at line 34 of file EventSkipperByID.cc.

References muonDTDigis_cfi::pset.

Referenced by somethingToSkip().

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

void edm::EventSkipperByID::fillDescription ( ParameterSetDescription & desc )

static

Definition at line 112 of file EventSkipperByID.cc.

References edm::ParameterSetDescription::addNode(), edm::ParameterSetDescription::addUntracked(), edm::ParameterDescriptionNode::setComment(), and mitigatedMETSequence_cff::U.

Referenced by edm::RootPrimaryFileSequence::fillDescription(), edm::StreamerFileReader::fillDescriptions(), dqmservices::DQMStreamerReader::fillDescriptions(), and somethingToSkip().

                                                                   {
 
     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.");
   }

bool edm::EventSkipperByID::skipIt	(	RunNumber_t	run,
		LuminosityBlockNumber_t	lumi,
		EventNumber_t	event
	)		const

Definition at line 46 of file EventSkipperByID.cc.

References edm::binary_search_all(), firstEvent_, firstLumi_, firstRun_, edm::lessThan(), edm::lessThanSpecial(), skippingEvents(), skippingLumis(), mitigatedMETSequence_cff::U, whichEventsToProcess_, whichEventsToSkip_, whichLumisToProcess_, and whichLumisToSkip_.

                                                                                                    {
 
     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;
   }