edmtest::ThinningDSVTestAnalyzer Class Reference

Inheritance diagram for edmtest::ThinningDSVTestAnalyzer:

Classes
struct	DSContent

Public Member Functions
void	analyze (edm::StreamID, edm::Event const &e, edm::EventSetup const &c) const override
	ThinningDSVTestAnalyzer (edm::ParameterSet const &pset)
Public Member Functions inherited from edm::global::EDAnalyzer<>
	EDAnalyzer ()=default
	EDAnalyzer (const EDAnalyzer &)=delete
const EDAnalyzer &	operator= (const EDAnalyzer &)=delete
bool	wantsGlobalLuminosityBlocks () const final
bool	wantsGlobalRuns () const final
bool	wantsInputProcessBlocks () const final
bool	wantsProcessBlocks () const final
bool	wantsStreamLuminosityBlocks () const final
bool	wantsStreamRuns () const final
Public Member Functions inherited from edm::global::EDAnalyzerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
	EDAnalyzerBase ()
ModuleDescription const &	moduleDescription () const
	~EDAnalyzerBase () override
Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const
void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...
	EDConsumerBase ()
	EDConsumerBase (EDConsumerBase const &)=delete
	EDConsumerBase (EDConsumerBase &&)=default
ESResolverIndex const *	esGetTokenIndices (edm::Transition iTrans) const
std::vector< ESResolverIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const
std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (edm::Transition iTrans) const
ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const
void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const
void	labelsForToken (EDGetToken iToken, Labels &oLabels) const
void	modulesWhoseProductsAreConsumed (std::array< std::vector< ModuleDescription const *> *, NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, ProductRegistry const &preg, std::map< std::string, ModuleDescription const *> const &labelsToDesc, std::string const &processName) const
EDConsumerBase const &	operator= (EDConsumerBase const &)=delete
EDConsumerBase &	operator= (EDConsumerBase &&)=default
bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const
void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)
ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const
void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)
void	updateLookup (eventsetup::ESRecordsToProductResolverIndices const &)
virtual	~EDConsumerBase () noexcept(false)

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)
Static Public Member Functions inherited from edm::global::EDAnalyzerBase
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Member Functions
void	incrementExpectedValue (std::vector< int >::const_iterator &iter) const

Private Attributes
bool	associationShouldBeDropped_
edm::EDGetTokenT< edm::ThinnedAssociation >	associationToken_
std::vector< unsigned int >	expectedIndexesIntoParent_
unsigned int	expectedNumberOfTracks_
std::vector< DSContent >	expectedParentContent_
std::vector< DSContent >	expectedThinnedContent_
std::vector< int >	expectedValues_
int	parentSlimmedValueFactor_
edm::EDGetTokenT< edmNew::DetSetVector< Thing > >	parentToken_
bool	parentWasDropped_
int	refSlimmedValueFactor_
bool	refToParentIsAvailable_
bool	thinnedIsAlias_
int	thinnedSlimmedValueFactor_
edm::EDGetTokenT< edmNew::DetSetVector< Thing > >	thinnedToken_
bool	thinnedWasDropped_
edm::EDGetTokenT< TrackOfDSVThingsCollection >	trackToken_

Additional Inherited Members
Public Types inherited from edm::global::EDAnalyzerBase
typedef EDAnalyzerBase	ModuleType
Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels
Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)
template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)
ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)
template<Transition Tr = Transition::Event>
constexpr auto	esConsumes ()
template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag)
template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
void	resetItemsToGetFrom (BranchType iType)

Detailed Description

Definition at line 23 of file ThinningDSVTestAnalyzer.cc.

Constructor & Destructor Documentation

ThinningDSVTestAnalyzer()

edmtest::ThinningDSVTestAnalyzer::ThinningDSVTestAnalyzer ( edm::ParameterSet const &  pset )

explicit

Definition at line 59 of file ThinningDSVTestAnalyzer.cc.

References associationShouldBeDropped_, submitPVResolutionJobs::count, expectedIndexesIntoParent_, expectedParentContent_, expectedThinnedContent_, mps_fire::i, AlCaHLTBitMon_ParallelJobs::p, parentSlimmedValueFactor_, parentWasDropped_, muonDTDigis_cfi::pset, refSlimmedValueFactor_, runTheMatrix::ret, thinnedSlimmedValueFactor_, thinnedWasDropped_, and edm::vector_transform().

      : parentToken_(consumes<edmNew::DetSetVector<Thing>>(pset.getParameter<edm::InputTag>("parentTag"))),
        thinnedToken_(consumes<edmNew::DetSetVector<Thing>>(pset.getParameter<edm::InputTag>("thinnedTag"))),
        associationToken_(consumes<edm::ThinnedAssociation>(pset.getParameter<edm::InputTag>("associationTag"))),
        trackToken_(consumes<TrackOfDSVThingsCollection>(pset.getParameter<edm::InputTag>("trackTag"))),
        parentWasDropped_(pset.getParameter<bool>("parentWasDropped")),
        thinnedWasDropped_(pset.getParameter<bool>("thinnedWasDropped")),
        thinnedIsAlias_(pset.getParameter<bool>("thinnedIsAlias")),
        refToParentIsAvailable_(pset.getParameter<bool>("refToParentIsAvailable")),
        associationShouldBeDropped_(pset.getParameter<bool>("associationShouldBeDropped")),
        expectedNumberOfTracks_(pset.getParameter<unsigned int>("expectedNumberOfTracks")),
        expectedValues_(pset.getParameter<std::vector<int>>("expectedValues")) {
    auto makeDSContent = [](edm::ParameterSet const& p) {
      return DSContent{p.getParameter<unsigned int>("id"), p.getParameter<std::vector<int>>("values")};
    };
    if (!parentWasDropped_) {
      expectedParentContent_ = edm::vector_transform(
          pset.getParameter<std::vector<edm::ParameterSet>>("expectedParentContent"), makeDSContent);
    }
    if (!thinnedWasDropped_) {
      expectedThinnedContent_ = edm::vector_transform(
          pset.getParameter<std::vector<edm::ParameterSet>>("expectedThinnedContent"), makeDSContent);
    }
    if (!associationShouldBeDropped_) {
      expectedIndexesIntoParent_ = pset.getParameter<std::vector<unsigned int>>("expectedIndexesIntoParent");
    }

    auto slimmedFactor = [](int count, int factor) {
      int ret = 1;
      for (int i = 0; i < count; ++i) {
        ret *= factor;
      }
      return ret;
    };
    int const slimmedValueFactor = pset.getParameter<int>("slimmedValueFactor");
    parentSlimmedValueFactor_ = slimmedFactor(pset.getParameter<int>("parentSlimmedCount"), slimmedValueFactor);
    thinnedSlimmedValueFactor_ = slimmedFactor(pset.getParameter<int>("thinnedSlimmedCount"), slimmedValueFactor);
    refSlimmedValueFactor_ = slimmedFactor(pset.getParameter<int>("refSlimmedCount"), slimmedValueFactor);
  }

Member Function Documentation

analyze()

void edmtest::ThinningDSVTestAnalyzer::analyze ( edm::StreamID  , edm::Event const &  e, edm::EventSetup const &  c  ) const

overridevirtual

Implements edm::global::EDAnalyzerBase.

Definition at line 132 of file ThinningDSVTestAnalyzer.cc.

References associationShouldBeDropped_, associationToken_, HLT_2024v11_cff::distance, Exception, expectedIndexesIntoParent_, expectedNumberOfTracks_, expectedParentContent_, expectedThinnedContent_, expectedValues_, incrementExpectedValue(), dqmdumpme::k, or, parentSlimmedValueFactor_, parentToken_, parentWasDropped_, refSlimmedValueFactor_, refToParentIsAvailable_, edm::thinnedRefFrom(), thinnedSlimmedValueFactor_, thinnedToken_, thinnedWasDropped_, HLT_2024v11_cff::track, JetHT_cfg::trackCollection, and trackToken_.

                                                                                                      {
    auto parentCollection = event.getHandle(parentToken_);
    auto thinnedCollection = event.getHandle(thinnedToken_);
    auto associationCollection = event.getHandle(associationToken_);
    auto trackCollection = event.getHandle(trackToken_);

    if (parentWasDropped_) {
      if (parentCollection.isValid()) {
        throw cms::Exception("TestFailure") << "parent collection present, should have been dropped";
      }
    } else if (!expectedParentContent_.empty()) {
      if (parentCollection->size() != expectedParentContent_.size()) {
        throw cms::Exception("TestFailure") << "parent collection has unexpected size, got " << parentCollection->size()
                                            << " expected " << expectedParentContent_.size();
      }

      auto iExpected = expectedParentContent_.begin();
      for (auto const& detset : *parentCollection) {
        auto const& expectedContent = *iExpected;
        ++iExpected;

        if (detset.id() != expectedContent.id) {
          throw cms::Exception("TestFailure")
              << "parent collection detset has unexpected id " << detset.id() << " expected " << expectedContent.id;
        }
        if (detset.size() != expectedContent.values.size()) {
          throw cms::Exception("TestFailure")
              << "parent collection detset with id " << detset.id() << " has unexpected size, got " << detset.size()
              << " expected " << expectedContent.values.size();
        }
        auto iValue = expectedContent.values.begin();
        for (auto const& thing : detset) {
          // Just some numbers that match the somewhat arbitrary values put in
          // by the ThingProducer.
          int expected =
              static_cast<int>(*iValue + (event.eventAuxiliary().event() - 1) * 100) * parentSlimmedValueFactor_;
          if (thing.a != expected) {
            throw cms::Exception("TestFailure")
                << "parent collection has unexpected content for detset with id " << detset.id() << ", got " << thing.a
                << " expected " << expected << " (element " << std::distance(expectedContent.values.begin(), iValue)
                << ")";
          }
          ++iValue;
        }
      }
    }

    // Check to see the content is what we expect based on what was written
    // by ThingProducer and TrackOfThingsProducer. The values are somewhat
    // arbitrary and meaningless.
    edm::RefProd<edmNew::DetSetVector<Thing>> thinnedRefProd;
    if (thinnedWasDropped_) {
      if (thinnedCollection.isValid()) {
        throw cms::Exception("TestFailure") << "thinned collection present, should have been dropped";
      }
    } else {
      thinnedRefProd = edm::RefProd<edmNew::DetSetVector<Thing>>{thinnedCollection};
      if (thinnedCollection->size() != expectedThinnedContent_.size()) {
        throw cms::Exception("TestFailure")
            << "thinned collection has unexpected size, got " << thinnedCollection->size() << " expected "
            << expectedThinnedContent_.size();
      }

      auto iExpected = expectedThinnedContent_.begin();
      for (auto const& detset : *thinnedCollection) {
        auto const& expectedContent = *iExpected;
        ++iExpected;

        if (detset.id() != expectedContent.id) {
          throw cms::Exception("TestFailure")
              << "thinned collection detset has unexpected id " << detset.id() << " expected " << expectedContent.id;
        }
        if (detset.size() != expectedContent.values.size()) {
          throw cms::Exception("TestFailure")
              << "thinned collection detset with id " << detset.id() << " has unexpected size, got " << detset.size()
              << " expected " << expectedContent.values.size();
        }
        auto iValue = expectedContent.values.begin();
        for (auto const& thing : detset) {
          int expected =
              static_cast<int>(*iValue + (event.eventAuxiliary().event() - 1) * 100) * thinnedSlimmedValueFactor_;
          if (thing.a != expected) {
            throw cms::Exception("TestFailure")
                << "thinned collection has unexpected content for detset with id " << detset.id() << ", got " << thing.a
                << " expected " << expected << " (element " << std::distance(expectedContent.values.begin(), iValue)
                << ")";
          }
          ++iValue;
        }
      }
    }

    if (associationShouldBeDropped_ && associationCollection.isValid()) {
      throw cms::Exception("TestFailure") << "association collection should have been dropped but was not";
    }
    if (!associationShouldBeDropped_) {
      unsigned int expectedIndex = 0;
      if (associationCollection->indexesIntoParent().size() != expectedIndexesIntoParent_.size()) {
        throw cms::Exception("TestFailure")
            << "association collection has unexpected size " << associationCollection->indexesIntoParent().size()
            << " expected " << expectedIndexesIntoParent_.size();
      }
      for (auto const& association : associationCollection->indexesIntoParent()) {
        if (association != expectedIndexesIntoParent_.at(expectedIndex)) {
          throw cms::Exception("TestFailure")
              << "association collection has unexpected content, for index " << expectedIndex << " got " << association
              << " expected " << expectedIndexesIntoParent_.at(expectedIndex);
        }
        ++expectedIndex;
      }
    }

    if (!parentWasDropped_ && !associationShouldBeDropped_) {
      if (associationCollection->parentCollectionID() != parentCollection.id()) {
        throw cms::Exception("TestFailure") << "analyze parent ProductID is not correct";
      }
    }

    if (!thinnedWasDropped_ && !associationShouldBeDropped_) {
      if (associationCollection->thinnedCollectionID() != thinnedCollection.id()) {
        throw cms::Exception("TestFailure") << "analyze thinned ProductID is not correct";
      }
    }

    if (trackCollection->size() != expectedNumberOfTracks_) {
      throw cms::Exception("TestFailure")
          << "unexpected Track size " << trackCollection->size() << " expected " << expectedNumberOfTracks_;
    }

    if (expectedValues_.empty()) {
      return;
    }

    int eventOffset = (static_cast<int>(event.eventAuxiliary().event()) - 1) * 100;

    std::vector<int>::const_iterator expectedValue = expectedValues_.begin();
    for (auto const& track : *trackCollection) {
      if (not refToParentIsAvailable_ or *expectedValue == -1) {
        if (track.ref1.isAvailable()) {
          throw cms::Exception("TestFailure") << "ref1 is available when it should not be, refers to "
                                              << track.ref1.id() << " key " << track.ref1.key();
        }
      } else {
        if (!track.ref1.isAvailable()) {
          throw cms::Exception("TestFailure") << "ref1 is not available when it should be";
        }
        // Check twice to test some possible caching problems.
        const int expected = (*expectedValue + eventOffset) * refSlimmedValueFactor_;
        if (track.ref1->a != expected) {
          throw cms::Exception("TestFailure")
              << "Unexpected values from ref1, got " << track.ref1->a << " expected " << expected;
        }
        if (track.ref1->a != expected) {
          throw cms::Exception("TestFailure")
              << "Unexpected values from ref1 (2nd try), got " << track.ref1->a << " expected " << expected;
          ;
        }
      }

      if (not thinnedWasDropped_) {
        auto refToThinned = edm::thinnedRefFrom(track.ref1, thinnedRefProd, event.productGetter());
        if (*expectedValue == -1) {
          if (refToThinned.isNonnull()) {
            throw cms::Exception("TestFailure") << "thinnedRefFrom(ref1) is non-null when it should be null";
          }
          if (refToThinned.isAvailable()) {
            throw cms::Exception("TestFailure") << "thinnedRefFrom(ref1) is available when it should not be";
          }
        } else {
          if (refToThinned.isNull()) {
            throw cms::Exception("TestFailure") << "thinnedRefFrom(ref1) is null when it should not be";
          }
          if (refToThinned.id() != thinnedCollection.id()) {
            throw cms::Exception("TestFailure") << "thinnedRefFrom(ref).id() " << refToThinned.id()
                                                << " differs from expectation " << thinnedCollection.id();
          }
          if (not refToThinned.isAvailable()) {
            throw cms::Exception("TestFailure") << "thinnedRefFrom(ref1) is not available when it should be";
          }
          // Check twice to test some possible caching problems.
          // need to account for slimming because going through an explicit ref-to-slimmed
          const int expected = (*expectedValue + eventOffset) * thinnedSlimmedValueFactor_;
          if (refToThinned->a != expected) {
            throw cms::Exception("TestFailure")
                << "Unexpected values from thinnedRefFrom(ref1), got " << refToThinned->a << " expected " << expected;
          }
          if (refToThinned->a != expected) {
            throw cms::Exception("TestFailure") << "Unexpected values from thinnedRefFrom(ref1) (2nd try) "
                                                << refToThinned->a << " expected " << expected;
          }
        }
      }
      incrementExpectedValue(expectedValue);

      if (not refToParentIsAvailable_ or *expectedValue == -1) {
        if (track.ref2.isAvailable()) {
          throw cms::Exception("TestFailure") << "ref2 is available when it should not be";
        }
      } else {
        if (!track.ref2.isAvailable()) {
          throw cms::Exception("TestFailure") << "ref2 is not available when it should be";
        }

        const int expected = (*expectedValue + eventOffset) * refSlimmedValueFactor_;
        if (track.ref2->a != expected) {
          throw cms::Exception("TestFailure")
              << "unexpected values from ref2, got " << track.ref2->a << " expected " << expected;
        }
        if (track.ref2->a != expected) {
          throw cms::Exception("TestFailure")
              << "unexpected values from ref2 (2nd try), got " << track.ref2->a << " expected " << expected;
        }
      }

      if (not thinnedWasDropped_) {
        auto refToThinned = edm::thinnedRefFrom(track.ref2, thinnedRefProd, event.productGetter());
        if (*expectedValue == -1) {
          if (refToThinned.isNonnull()) {
            throw cms::Exception("TestFailure") << "thinnedRefFrom(ref2) is non-null when it should be null";
          }
          if (refToThinned.isAvailable()) {
            throw cms::Exception("TestFailure") << "thinnedRefFrom(ref2) is available when it should not be";
          }
        } else {
          if (refToThinned.isNull()) {
            throw cms::Exception("TestFailure") << "thinnedRefFrom(ref2) is null when it should not be";
          }
          if (refToThinned.id() != thinnedCollection.id()) {
            throw cms::Exception("TestFailure") << "thinnedRefFrom(ref2).id() " << refToThinned.id()
                                                << " differs from expectation " << thinnedCollection.id();
          }
          if (not refToThinned.isAvailable()) {
            throw cms::Exception("TestFailure") << "thinnedRefFrom(ref2) is not available when it should be";
          }
          // Check twice to test some possible caching problems.
          // need to account for slimming because going through an explicit ref-to-slimmed
          const int expected = (*expectedValue + eventOffset) * thinnedSlimmedValueFactor_;
          if (refToThinned->a != expected) {
            throw cms::Exception("TestFailure")
                << "Unexpected values from thinnedRefFrom(ref2), got " << refToThinned->a << " expected " << expected;
          }
          if (refToThinned->a != expected) {
            throw cms::Exception("TestFailure") << "Unexpected values from thinnedRefFrom(ref2) (2nd try), got "
                                                << refToThinned->a << " expected " << expected;
          }
        }
      }

      incrementExpectedValue(expectedValue);

      // Test RefVector
      unsigned int k = 0;
      bool allPresent = true;
      for (auto iExpectedValue : expectedValues_) {
        if (iExpectedValue != -1) {
          if (not thinnedWasDropped_) {
            auto refToThinned = edm::thinnedRefFrom(track.refVector1[k], thinnedRefProd, event.productGetter());
            // need to account for slimming because going through an explicit ref-to-slimmed
            const int expected = (iExpectedValue + eventOffset) * thinnedSlimmedValueFactor_;
            if (refToThinned->a != expected) {
              throw cms::Exception("TestFailure") << "unexpected values from thinnedRefFrom(refVector1), got "
                                                  << refToThinned->a << " expected " << expected;
            }
          }
          if (refToParentIsAvailable_) {
            const int expected = (iExpectedValue + eventOffset) * refSlimmedValueFactor_;
            if (track.refVector1[k]->a != expected) {
              throw cms::Exception("TestFailure")
                  << "unexpected values from refVector1, got " << track.refVector1[k]->a << " expected " << expected;
            }
          }
        } else {
          allPresent = false;
        }
        ++k;
      }

      if (refToParentIsAvailable_ and allPresent) {
        if (!track.refVector1.isAvailable()) {
          throw cms::Exception("TestFailure") << "unexpected value (false) from refVector::isAvailable";
        }
      } else {
        if (track.refVector1.isAvailable()) {
          throw cms::Exception("TestFailure") << "unexpected value (true) from refVector::isAvailable";
        }
      }
      k = 0;
      for (auto iExpectedValue : expectedValues_) {
        if (refToParentIsAvailable_ and iExpectedValue != -1) {
          const int expected = (iExpectedValue + eventOffset) * refSlimmedValueFactor_;
          if (track.refVector1[k]->a != expected) {
            throw cms::Exception("TestFailure")
                << "unexpected values from refVector1, got " << track.refVector1[k]->a << " expected " << expected;
          }
        } else {
          allPresent = false;
        }
        ++k;
      }
    }
  }

fillDescriptions()

void edmtest::ThinningDSVTestAnalyzer::fillDescriptions ( edm::ConfigurationDescriptions &  descriptions )

static

Definition at line 99 of file ThinningDSVTestAnalyzer.cc.

References edm::ParameterSetDescription::add(), edm::ConfigurationDescriptions::addDefault(), and submitPVResolutionJobs::desc.

                                                                                           {
    edm::ParameterSetDescription desc;
    desc.add<edm::InputTag>("parentTag");
    desc.add<edm::InputTag>("thinnedTag");
    desc.add<edm::InputTag>("associationTag");
    desc.add<edm::InputTag>("trackTag");
    desc.add<bool>("parentWasDropped", false);
    desc.add<bool>("thinnedWasDropped", false);
    desc.add<bool>("thinnedIsAlias", false);
    desc.add<bool>("refToParentIsAvailable", true)
        ->setComment(
            "If Ref-to-parent is generally available. With thinnedRefFrom it may happen that the Ref-to-parent is not "
            "available, but the Ref-to-thinned is. In such case this parameter should be set to 'False', and the "
            "'expectedValues' should be set to correspond the values via Ref-to-thinned.");
    std::vector<int> defaultV;
    std::vector<unsigned int> defaultVU;
    std::vector<edm::ParameterSet> defaultVPSet;
    edm::ParameterSetDescription dsValidator;
    dsValidator.add<unsigned int>("id");
    dsValidator.add<std::vector<int>>("values", defaultV);
    desc.addVPSet("expectedParentContent", dsValidator, defaultVPSet);
    desc.addVPSet("expectedThinnedContent", dsValidator, defaultVPSet);
    desc.add<std::vector<unsigned int>>("expectedIndexesIntoParent", defaultVU);
    desc.add<bool>("associationShouldBeDropped", false);
    desc.add<unsigned int>("expectedNumberOfTracks", 5);
    desc.add<std::vector<int>>("expectedValues");
    desc.add<int>("parentSlimmedCount", 0);
    desc.add<int>("thinnedSlimmedCount", 0);
    desc.add<int>("refSlimmedCount", 0);
    desc.add<int>("slimmedValueFactor", 10);
    descriptions.addDefault(desc);
  }

incrementExpectedValue()

void edmtest::ThinningDSVTestAnalyzer::incrementExpectedValue ( std::vector< int >::const_iterator &  iter ) const

private

Definition at line 434 of file ThinningDSVTestAnalyzer.cc.

References expectedValues_.

Referenced by analyze().

                                                                                               {
    ++iter;
    if (iter == expectedValues_.end())
      iter = expectedValues_.begin();
  }

Member Data Documentation

associationShouldBeDropped_

bool edmtest::ThinningDSVTestAnalyzer::associationShouldBeDropped_

private

Definition at line 51 of file ThinningDSVTestAnalyzer.cc.

Referenced by analyze(), and ThinningDSVTestAnalyzer().

associationToken_

edm::EDGetTokenT<edm::ThinnedAssociation> edmtest::ThinningDSVTestAnalyzer::associationToken_

private

Definition at line 36 of file ThinningDSVTestAnalyzer.cc.

Referenced by analyze().

expectedIndexesIntoParent_

std::vector<unsigned int> edmtest::ThinningDSVTestAnalyzer::expectedIndexesIntoParent_

private

Definition at line 50 of file ThinningDSVTestAnalyzer.cc.

Referenced by analyze(), and ThinningDSVTestAnalyzer().

expectedNumberOfTracks_

unsigned int edmtest::ThinningDSVTestAnalyzer::expectedNumberOfTracks_

private

Definition at line 52 of file ThinningDSVTestAnalyzer.cc.

Referenced by analyze().

expectedParentContent_

std::vector<DSContent> edmtest::ThinningDSVTestAnalyzer::expectedParentContent_

private

Definition at line 45 of file ThinningDSVTestAnalyzer.cc.

Referenced by analyze(), and ThinningDSVTestAnalyzer().

expectedThinnedContent_

std::vector<DSContent> edmtest::ThinningDSVTestAnalyzer::expectedThinnedContent_

private

Definition at line 49 of file ThinningDSVTestAnalyzer.cc.

Referenced by analyze(), and ThinningDSVTestAnalyzer().

expectedValues_

std::vector<int> edmtest::ThinningDSVTestAnalyzer::expectedValues_

private

Definition at line 53 of file ThinningDSVTestAnalyzer.cc.

Referenced by analyze(), and incrementExpectedValue().

parentSlimmedValueFactor_

int edmtest::ThinningDSVTestAnalyzer::parentSlimmedValueFactor_

private

Definition at line 54 of file ThinningDSVTestAnalyzer.cc.

Referenced by analyze(), and ThinningDSVTestAnalyzer().

parentToken_

edm::EDGetTokenT<edmNew::DetSetVector<Thing> > edmtest::ThinningDSVTestAnalyzer::parentToken_

private

Definition at line 34 of file ThinningDSVTestAnalyzer.cc.

Referenced by analyze().

parentWasDropped_

bool edmtest::ThinningDSVTestAnalyzer::parentWasDropped_

private

Definition at line 44 of file ThinningDSVTestAnalyzer.cc.

Referenced by analyze(), and ThinningDSVTestAnalyzer().

refSlimmedValueFactor_

int edmtest::ThinningDSVTestAnalyzer::refSlimmedValueFactor_

private

Definition at line 56 of file ThinningDSVTestAnalyzer.cc.

Referenced by analyze(), and ThinningDSVTestAnalyzer().

refToParentIsAvailable_

bool edmtest::ThinningDSVTestAnalyzer::refToParentIsAvailable_

private

Definition at line 48 of file ThinningDSVTestAnalyzer.cc.

Referenced by analyze().

thinnedIsAlias_

bool edmtest::ThinningDSVTestAnalyzer::thinnedIsAlias_

private

Definition at line 47 of file ThinningDSVTestAnalyzer.cc.

thinnedSlimmedValueFactor_

int edmtest::ThinningDSVTestAnalyzer::thinnedSlimmedValueFactor_

private

Definition at line 55 of file ThinningDSVTestAnalyzer.cc.

Referenced by analyze(), and ThinningDSVTestAnalyzer().

thinnedToken_

edm::EDGetTokenT<edmNew::DetSetVector<Thing> > edmtest::ThinningDSVTestAnalyzer::thinnedToken_

private

Definition at line 35 of file ThinningDSVTestAnalyzer.cc.

Referenced by analyze().

thinnedWasDropped_

bool edmtest::ThinningDSVTestAnalyzer::thinnedWasDropped_

private

Definition at line 46 of file ThinningDSVTestAnalyzer.cc.

Referenced by analyze(), and ThinningDSVTestAnalyzer().

trackToken_

edm::EDGetTokenT<TrackOfDSVThingsCollection> edmtest::ThinningDSVTestAnalyzer::trackToken_

private

Definition at line 37 of file ThinningDSVTestAnalyzer.cc.

Referenced by analyze().