#include <DuplicateChecker.h>

Public Member Functions
bool	checkDisabled () const

bool	checkingAllFiles () const

void	disable ()

	DuplicateChecker (ParameterSet const &pset)

void	inputFileClosed ()

void	inputFileOpened (bool realData, IndexIntoFile const &indexIntoFile, std::vector< std::shared_ptr< IndexIntoFile > > const &indexesIntoFiles, std::vector< std::shared_ptr< IndexIntoFile > >::size_type currentIndexIntoFile)

bool	isDuplicateAndCheckActive (int index, RunNumber_t run, LuminosityBlockNumber_t lumi, EventNumber_t event, std::string const &fileName)

bool	noDuplicatesInFile () const

Static Public Member Functions
static void	fillDescription (ParameterSetDescription &desc)

Private Types
enum	DataType { isRealData, isSimulation, unknown }

enum	DuplicateCheckMode { noDuplicateCheck, checkEachFile, checkEachRealDataFile, checkAllFilesOpened }

Private Attributes
DataType	dataType_

bool	disabled_

DuplicateCheckMode	duplicateCheckMode_

bool	itIsKnownTheFileHasNoDuplicates_

std::set< IndexIntoFile::IndexRunLumiEventKey >	relevantPreviousEvents_

Detailed Description

Definition at line 30 of file DuplicateChecker.h.

Member Enumeration Documentation

◆ DataType

enum edm::DuplicateChecker::DataType

private

Enumerator
isRealData
isSimulation
unknown

Definition at line 64 of file DuplicateChecker.h.

64 { isRealData, isSimulation, unknown };

◆ DuplicateCheckMode

enum edm::DuplicateChecker::DuplicateCheckMode

private

Enumerator
noDuplicateCheck
checkEachFile
checkEachRealDataFile
checkAllFilesOpened

Definition at line 60 of file DuplicateChecker.h.

60 { noDuplicateCheck, checkEachFile, checkEachRealDataFile, checkAllFilesOpened };

Constructor & Destructor Documentation

◆ DuplicateChecker()

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

Definition at line 13 of file DuplicateChecker.cc.

       : dataType_(unknown), itIsKnownTheFileHasNoDuplicates_(false), disabled_(false) {
     // 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.  This is currently true when PoolSource is the primary input source.
     // The modules that use PoolSource as a SecSource have not defined their fillDescriptions function
     // yet, so the ParameterSet does not get validated yet.  As soon as all the modules with a SecSource
     // have defined descriptions, the defaults in the getUntrackedParameterSet function calls can
     // and should be deleted from the code.
     std::string duplicateCheckMode =
         pset.getUntrackedParameter<std::string>("duplicateCheckMode", std::string("checkAllFilesOpened"));
  
     if (duplicateCheckMode == std::string("noDuplicateCheck"))
       duplicateCheckMode_ = noDuplicateCheck;
     else if (duplicateCheckMode == std::string("checkEachFile"))
       duplicateCheckMode_ = checkEachFile;
     else if (duplicateCheckMode == std::string("checkEachRealDataFile"))
       duplicateCheckMode_ = checkEachRealDataFile;
     else if (duplicateCheckMode == std::string("checkAllFilesOpened"))
       duplicateCheckMode_ = checkAllFilesOpened;
     else {
       throw cms::Exception("Configuration")
           << "Illegal configuration parameter value passed to PoolSource for\n"
           << "the \"duplicateCheckMode\" parameter, legal values are:\n"
           << "\"noDuplicateCheck\", \"checkEachFile\", \"checkEachRealDataFile\", \"checkAllFilesOpened\"\n";
     }
   }

References checkAllFilesOpened, checkEachFile, checkEachRealDataFile, EcnaPython_AdcPeg12_S1_10_R170298_1_0_150_Dee0::duplicateCheckMode, duplicateCheckMode_, Exception, noDuplicateCheck, muonDTDigis_cfi::pset, and AlCaHLTBitMon_QueryRunRegistry::string.

Member Function Documentation

◆ checkDisabled()

bool edm::DuplicateChecker::checkDisabled ( ) const

inline

Definition at line 45 of file DuplicateChecker.h.

                                {
       return duplicateCheckMode_ == noDuplicateCheck ||
              (duplicateCheckMode_ == checkEachRealDataFile && dataType_ == isSimulation) || disabled_;
     }

References checkEachRealDataFile, dataType_, disabled_, duplicateCheckMode_, isSimulation, and noDuplicateCheck.

Referenced by inputFileOpened(), and isDuplicateAndCheckActive().

◆ checkingAllFiles()

bool edm::DuplicateChecker::checkingAllFiles ( ) const

inline

Definition at line 55 of file DuplicateChecker.h.

55 { return checkAllFilesOpened == duplicateCheckMode_; }

References checkAllFilesOpened, and duplicateCheckMode_.

◆ disable()

void edm::DuplicateChecker::disable ( )

Definition at line 41 of file DuplicateChecker.cc.

                                  {
     disabled_ = true;
     dataType_ = unknown;
     relevantPreviousEvents_.clear();
     itIsKnownTheFileHasNoDuplicates_ = false;
   }

References dataType_, disabled_, itIsKnownTheFileHasNoDuplicates_, relevantPreviousEvents_, and unknown.

◆ fillDescription()

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

static

Definition at line 109 of file DuplicateChecker.cc.

                                                                       {
     std::string defaultString("checkAllFilesOpened");
     desc.addUntracked<std::string>("duplicateCheckMode", defaultString)
         ->setComment(
             "'checkAllFilesOpened':   check across all input files\n"
             "'checkEachFile':         check each input file independently\n"
             "'checkEachRealDataFile': check each real data input file independently\n"
             "'noDuplicateCheck':      no duplicate checking\n");
   }

References edm::ParameterSetDescription::addUntracked(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by edm::RootPrimaryFileSequence::fillDescription().

◆ inputFileClosed()

void edm::DuplicateChecker::inputFileClosed ( )

Definition at line 75 of file DuplicateChecker.cc.

                                          {
     dataType_ = unknown;
     relevantPreviousEvents_.clear();
     itIsKnownTheFileHasNoDuplicates_ = false;
   }

References dataType_, itIsKnownTheFileHasNoDuplicates_, relevantPreviousEvents_, and unknown.

◆ inputFileOpened()

void edm::DuplicateChecker::inputFileOpened	(	bool	realData,
		IndexIntoFile const &	indexIntoFile,
		std::vector< std::shared_ptr< IndexIntoFile > > const &	indexesIntoFiles,
		std::vector< std::shared_ptr< IndexIntoFile > >::size_type	currentIndexIntoFile
	)

Definition at line 48 of file DuplicateChecker.cc.

                                                                                                                  {
     dataType_ = realData ? isRealData : isSimulation;
     if (checkDisabled())
       return;
  
     relevantPreviousEvents_.clear();
     itIsKnownTheFileHasNoDuplicates_ = false;
  
     if (duplicateCheckMode_ == checkAllFilesOpened) {
       // Compares the current IndexIntoFile to all the previous ones and saves any duplicates.
       // One unintended thing, it also saves the duplicate runs and lumis.
       for (std::vector<std::shared_ptr<IndexIntoFile> >::size_type i = 0; i < currentIndexIntoFile; ++i) {
         if (indexesIntoFiles[i].get() != nullptr) {
           indexIntoFile.set_intersection(*indexesIntoFiles[i], relevantPreviousEvents_);
         }
       }
     }
     if (relevantPreviousEvents_.empty()) {
       if (!indexIntoFile.containsDuplicateEvents()) {
         itIsKnownTheFileHasNoDuplicates_ = true;
       }
     }
   }

References checkAllFilesOpened, checkDisabled(), edm::IndexIntoFile::containsDuplicateEvents(), dataType_, duplicateCheckMode_, edm::get(), mps_fire::i, isRealData, isSimulation, itIsKnownTheFileHasNoDuplicates_, relevantPreviousEvents_, and edm::IndexIntoFile::set_intersection().

◆ isDuplicateAndCheckActive()

bool edm::DuplicateChecker::isDuplicateAndCheckActive	(	int	index,
		RunNumber_t	run,
		LuminosityBlockNumber_t	lumi,
		EventNumber_t	event,
		std::string const &	fileName
	)

Definition at line 81 of file DuplicateChecker.cc.

                                                                                                                 {
     if (itIsKnownTheFileHasNoDuplicates_)
       return false;
     if (checkDisabled())
       return false;
  
     IndexIntoFile::IndexRunLumiEventKey newEvent(index, run, lumi, event);
     bool duplicate = !relevantPreviousEvents_.insert(newEvent).second;
  
     if (duplicate) {
       if (duplicateCheckMode_ == checkAllFilesOpened) {
         LogWarning("DuplicateEvent") << "Duplicate Events found in entire set of input files.\n"
                                      << "Both events were from run " << run << " and luminosity block " << lumi
                                      << " with event number " << event << ".\n"
                                      << "The duplicate was from file " << fileName << ".\n"
                                      << "The duplicate will be skipped.\n";
       } else {
         LogWarning("DuplicateEvent") << "Duplicate Events found in file " << fileName << ".\n"
                                      << "Both events were from run " << run << " and luminosity block " << lumi
                                      << " with event number " << event << ".\n"
                                      << "The duplicate will be skipped.\n";
       }
       return true;
     }
     return false;
   }