Inheritance diagram for edmtest::ThinningTestAnalyzer:

Public Member Functions
void	analyze (edm::StreamID, edm::Event const &e, edm::EventSetup const &c) const override

	ThinningTestAnalyzer (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

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

std::vector< ESProxyIndex > 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

bool	registeredToConsumeMany (TypeID const &, 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::ESRecordsToProxyIndices 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
edm::Handle< edm::ThinnedAssociation >	getAssociation (edm::Event const &event) const

edm::Handle< ThingCollection >	getParent (edm::Event const &event) const

std::tuple< edm::Handle< ThingCollection >, edm::RefProd< ThingCollection > >	getThinned (edm::Event const &event) const

edm::Handle< TrackOfThingsCollection >	getTrackCollection (edm::Event const &event) const

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

template<typename RefT >
void	testRefToParent (RefT const &ref, std::string_view refName, int const expectedValue, int const eventOffset) const

template<typename RefT >
void	testRefToThinned (RefT const &ref, std::string_view refName, int const expectedValue, int const eventOffset, edm::ProductID const thinnedCollectionID) const

void	testVectors (TrackOfThings const &track, edm::RefProd< ThingCollection > const &thinnedRefProd, edm::EDProductGetter const &productGetter, int const eventOffset) const

Private Attributes
bool	associationShouldBeDropped_

edm::EDGetTokenT< edm::ThinnedAssociation >	associationToken_

std::vector< unsigned int >	expectedIndexesIntoParent_

std::vector< int >	expectedParentContent_

std::vector< int >	expectedThinnedContent_

std::vector< int >	expectedValues_

int	parentSlimmedValueFactor_

edm::EDGetTokenT< ThingCollection >	parentToken_

bool	parentWasDropped_

int	refSlimmedValueFactor_

bool	refToParentIsAvailable_

bool	thinnedIsAlias_

int	thinnedSlimmedValueFactor_

edm::EDGetTokenT< ThingCollection >	thinnedToken_

bool	thinnedWasDropped_

edm::EDGetTokenT< TrackOfThingsCollection >	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 ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

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 21 of file ThinningTestAnalyzer.cc.

Constructor & Destructor Documentation

◆ ThinningTestAnalyzer()

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

explicit

Definition at line 74 of file ThinningTestAnalyzer.cc.

References associationShouldBeDropped_, associationToken_, submitPVResolutionJobs::count, expectedIndexesIntoParent_, expectedParentContent_, expectedThinnedContent_, expectedValues_, mps_fire::i, parentSlimmedValueFactor_, parentToken_, parentWasDropped_, muonDTDigis_cfi::pset, refSlimmedValueFactor_, refToParentIsAvailable_, runTheMatrix::ret, thinnedIsAlias_, thinnedSlimmedValueFactor_, thinnedToken_, thinnedWasDropped_, and trackToken_.

                                                                         {
     parentToken_ = consumes<ThingCollection>(pset.getParameter<edm::InputTag>("parentTag"));
     thinnedToken_ = mayConsume<ThingCollection>(pset.getParameter<edm::InputTag>("thinnedTag"));
     associationToken_ = mayConsume<edm::ThinnedAssociation>(pset.getParameter<edm::InputTag>("associationTag"));
     trackToken_ = consumes<TrackOfThingsCollection>(pset.getParameter<edm::InputTag>("trackTag"));
     parentWasDropped_ = pset.getParameter<bool>("parentWasDropped");
     if (!parentWasDropped_) {
       expectedParentContent_ = pset.getParameter<std::vector<int>>("expectedParentContent");
     }
     thinnedWasDropped_ = pset.getParameter<bool>("thinnedWasDropped");
     thinnedIsAlias_ = pset.getParameter<bool>("thinnedIsAlias");
     if (!thinnedWasDropped_) {
       expectedThinnedContent_ = pset.getParameter<std::vector<int>>("expectedThinnedContent");
     }
     refToParentIsAvailable_ = pset.getParameter<bool>("refToParentIsAvailable");
     associationShouldBeDropped_ = pset.getParameter<bool>("associationShouldBeDropped");
     if (!associationShouldBeDropped_) {
       expectedIndexesIntoParent_ = pset.getParameter<std::vector<unsigned int>>("expectedIndexesIntoParent");
     }
     expectedValues_ = pset.getParameter<std::vector<int>>("expectedValues");
 
     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::ThinningTestAnalyzer::analyze	(	edm::StreamID	,
		edm::Event const &	e,
		edm::EventSetup const &	c
	)		const

overridevirtual

Implements edm::global::EDAnalyzerBase.

Definition at line 136 of file ThinningTestAnalyzer.cc.

References associationShouldBeDropped_, Exception, expectedValues_, getAssociation(), getParent(), getThinned(), getTrackCollection(), incrementExpectedValue(), parentWasDropped_, testRefToParent(), testRefToThinned(), testVectors(), edm::thinnedRefFrom(), thinnedWasDropped_, HLT_2023v12_cff::track, and JetHT_cfg::trackCollection.

                                                                                                    {
     auto parentCollection = getParent(event);
     auto [thinnedCollection, thinnedRefProd] = getThinned(event);
     auto associationCollection = getAssociation(event);
     auto trackCollection = getTrackCollection(event);
 
     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";
       }
     }
 
     int const eventOffset = static_cast<int>(event.eventAuxiliary().event() * 100 + 100);
 
     std::vector<int>::const_iterator expectedValue = expectedValues_.begin();
     for (auto const& track : *trackCollection) {
       testRefToParent(track.ref1, "ref1", *expectedValue, eventOffset);
       if (not thinnedWasDropped_) {
         testRefToThinned(edm::thinnedRefFrom(track.ref1, thinnedRefProd, event.productGetter()),
                          "ref1",
                          *expectedValue,
                          eventOffset,
                          thinnedCollection.id());
       }
       testRefToParent(track.refToBase1, "refToBase1", *expectedValue, eventOffset);
       incrementExpectedValue(expectedValue);
 
       testRefToParent(track.ref2, "ref2", *expectedValue, eventOffset);
       if (not thinnedWasDropped_) {
         testRefToThinned(edm::thinnedRefFrom(track.ref2, thinnedRefProd, event.productGetter()),
                          "ref2",
                          *expectedValue,
                          eventOffset,
                          thinnedCollection.id());
       }
       incrementExpectedValue(expectedValue);
 
       testRefToParent(track.ptr1, "ptr1", *expectedValue, eventOffset);
       incrementExpectedValue(expectedValue);
 
       testRefToParent(track.ptr2, "ptr2", *expectedValue, eventOffset);
       incrementExpectedValue(expectedValue);
 
       testVectors(track, thinnedRefProd, event.productGetter(), eventOffset);
     }
   }

◆ fillDescriptions()

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

static

Definition at line 108 of file ThinningTestAnalyzer.cc.

References 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;
     desc.add<std::vector<int>>("expectedParentContent", defaultV);
     desc.add<std::vector<int>>("expectedThinnedContent", defaultV);
     desc.add<std::vector<unsigned int>>("expectedIndexesIntoParent", defaultVU);
     desc.add<bool>("associationShouldBeDropped", false);
     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);
   }

◆ getAssociation()

edm::Handle< edm::ThinnedAssociation > edmtest::ThinningTestAnalyzer::getAssociation ( edm::Event const & event ) const

private

Definition at line 251 of file ThinningTestAnalyzer.cc.

References associationShouldBeDropped_, associationToken_, Exception, and expectedIndexesIntoParent_.

Referenced by analyze().

                                                                                                    {
     auto associationCollection = event.getHandle(associationToken_);
     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";
       }
       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;
       }
     }
     return associationCollection;
   }

◆ getParent()

edm::Handle< ThingCollection > edmtest::ThinningTestAnalyzer::getParent ( edm::Event const & event ) const

private

Definition at line 189 of file ThinningTestAnalyzer.cc.

References Exception, expectedParentContent_, mps_fire::i, parentSlimmedValueFactor_, parentToken_, and parentWasDropped_.

Referenced by analyze().

                                                                                         {
     auto parentCollection = event.getHandle(parentToken_);
 
     unsigned int i = 0;
     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();
       }
       for (auto const& thing : *parentCollection) {
         // Just some numbers that match the somewhat arbitrary values put in
         // by the ThingProducer.
         int expected = static_cast<int>(expectedParentContent_.at(i) + event.eventAuxiliary().event() * 100 + 100) *
                        parentSlimmedValueFactor_;
         if (thing.a != expected) {
           throw cms::Exception("TestFailure")
               << "parent collection has unexpected content, got " << thing.a << " expected " << expected;
         }
         ++i;
       }
     }
 
     return parentCollection;
   }

◆ getThinned()

std::tuple< edm::Handle< ThingCollection >, edm::RefProd< ThingCollection > > edmtest::ThinningTestAnalyzer::getThinned ( edm::Event const & event ) const

private

Definition at line 218 of file ThinningTestAnalyzer.cc.

References Exception, expectedThinnedContent_, thinnedSlimmedValueFactor_, thinnedToken_, thinnedWasDropped_, and mkLumiAveragedPlots::tuple.

Referenced by analyze().

                                    {
     auto thinnedCollection = event.getHandle(thinnedToken_);
 
     // 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<ThingCollection> thinnedRefProd;
     if (thinnedWasDropped_) {
       if (thinnedCollection.isValid()) {
         throw cms::Exception("TestFailure") << "thinned collection present, should have been dropped";
       }
     } else {
       thinnedRefProd = edm::RefProd<ThingCollection>{thinnedCollection};
       unsigned expectedIndex = 0;
       if (thinnedCollection->size() != expectedThinnedContent_.size()) {
         throw cms::Exception("TestFailure")
             << "thinned collection has unexpected size, got " << thinnedCollection->size() << " expected "
             << expectedThinnedContent_.size();
       }
       for (auto const& thing : *thinnedCollection) {
         const int expected = (expectedThinnedContent_.at(expectedIndex) + event.eventAuxiliary().event() * 100 + 100) *
                              thinnedSlimmedValueFactor_;
         if (thing.a != expected) {
           throw cms::Exception("TestFailure")
               << "thinned collection has unexpected content, got " << thing.a << " expected " << expected;
         }
         ++expectedIndex;
       }
     }
     return std::tuple(thinnedCollection, thinnedRefProd);
   }

◆ getTrackCollection()

edm::Handle< TrackOfThingsCollection > edmtest::ThinningTestAnalyzer::getTrackCollection ( edm::Event const & event ) const

private

Definition at line 273 of file ThinningTestAnalyzer.cc.

References Exception, JetHT_cfg::trackCollection, and trackToken_.

Referenced by analyze().

                                                                                                          {
     auto trackCollection = event.getHandle(trackToken_);
     if (trackCollection->size() != 5u) {
       throw cms::Exception("TestFailure") << "unexpected Track size";
     }
     return trackCollection;
   }

◆ incrementExpectedValue()

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

private

Definition at line 425 of file ThinningTestAnalyzer.cc.

References expectedValues_.

Referenced by analyze().

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

◆ testRefToParent()

template<typename RefT >

void edmtest::ThinningTestAnalyzer::testRefToParent	(	RefT const &	ref,
		std::string_view	refName,
		int const	expectedValue,
		int const	eventOffset
	)		const

private

Definition at line 282 of file ThinningTestAnalyzer.cc.

References Exception, or, refSlimmedValueFactor_, and refToParentIsAvailable_.

Referenced by analyze().

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

◆ testRefToThinned()

template<typename RefT >

void edmtest::ThinningTestAnalyzer::testRefToThinned	(	RefT const &	ref,
		std::string_view	refName,
		int const	expectedValue,
		int const	eventOffset,
		edm::ProductID const	thinnedCollectionID
	)		const

private

Definition at line 309 of file ThinningTestAnalyzer.cc.

References Exception, and thinnedSlimmedValueFactor_.

Referenced by analyze().

                                                                                             {
     if (expectedValue == -1) {
       if (refToThinned.isNonnull()) {
         throw cms::Exception("TestFailure") << "thinnedRefFrom(" << refName << ") is non-null when it should be null";
       }
       if (refToThinned.isAvailable()) {
         throw cms::Exception("TestFailure") << "thinnedRefFrom(" << refName << ") is available when it should not be";
       }
     } else {
       if (refToThinned.isNull()) {
         throw cms::Exception("TestFailure") << "thinnedRefFrom(" << refName << ") is null when it should not be";
       }
       if (refToThinned.id() != thinnedCollectionID) {
         throw cms::Exception("TestFailure") << "thinnedRefFrom(" << refName << ").id() " << refToThinned.id()
                                             << " differs from expectation " << thinnedCollectionID;
       }
       if (not refToThinned.isAvailable()) {
         throw cms::Exception("TestFailure") << "thinnedRefFrom(" << refName << ") 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(" << refName << "), got "
                                             << refToThinned->a << " expected " << expected;
       }
       if (refToThinned->a != expected) {
         throw cms::Exception("TestFailure") << "Unexpected values from thinnedRefFrom(" << refName << ") (2nd try) "
                                             << refToThinned->a << " expected " << expected;
       }
     }
   }

◆ testVectors()

void edmtest::ThinningTestAnalyzer::testVectors	(	TrackOfThings const &	track,
		edm::RefProd< ThingCollection > const &	thinnedRefProd,
		edm::EDProductGetter const &	productGetter,
		int const	eventOffset
	)		const

private

Definition at line 346 of file ThinningTestAnalyzer.cc.

References Exception, expectedValues_, dqmdumpme::k, edm::refcoreimpl::productGetter(), refSlimmedValueFactor_, refToParentIsAvailable_, edm::thinnedRefFrom(), thinnedSlimmedValueFactor_, thinnedWasDropped_, and HLT_2023v12_cff::track.

Referenced by analyze().

                                                                       {
     // Test RefVector, PtrVector, and RefToBaseVector
     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, 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;
           }
           if (track.ptrVector1[k]->a != expected) {
             throw cms::Exception("TestFailure") << "unexpected values from ptrVector1";
           }
           if (track.refToBaseVector1[k]->a != expected) {
             throw cms::Exception("TestFailure") << "unexpected values from refToBaseVector1";
           }
         }
       } else {
         allPresent = false;
       }
       ++k;
     }
 
     if (refToParentIsAvailable_ and allPresent) {
       if (!track.refVector1.isAvailable()) {
         throw cms::Exception("TestFailure") << "unexpected value (false) from refVector::isAvailable";
       }
       if (!track.ptrVector1.isAvailable()) {
         throw cms::Exception("TestFailure") << "unexpected value (false) from ptrVector::isAvailable";
       }
       if (!track.refToBaseVector1.isAvailable()) {
         throw cms::Exception("TestFailure") << "unexpected value (false) from refToBaseVector::isAvailable";
       }
     } else {
       if (track.refVector1.isAvailable()) {
         throw cms::Exception("TestFailure") << "unexpected value (true) from refVector::isAvailable";
       }
       if (track.ptrVector1.isAvailable()) {
         throw cms::Exception("TestFailure") << "unexpected value (true) from ptrVector::isAvailable";
       }
       if (track.refToBaseVector1.isAvailable()) {
         throw cms::Exception("TestFailure") << "unexpected value (true) from refToBaseVector::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;
         }
         if (track.ptrVector1[k]->a != expected) {
           throw cms::Exception("TestFailure") << "unexpected values from ptrVector1";
         }
         if (track.refToBaseVector1[k]->a != expected) {
           throw cms::Exception("TestFailure") << "unexpected values from refToBaseVector1";
         }
       } else {
         allPresent = false;
       }
       ++k;
     }
   }

Member Data Documentation

◆ associationShouldBeDropped_

bool edmtest::ThinningTestAnalyzer::associationShouldBeDropped_

private

Definition at line 67 of file ThinningTestAnalyzer.cc.

Referenced by analyze(), getAssociation(), and ThinningTestAnalyzer().

◆ associationToken_

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

private

Definition at line 57 of file ThinningTestAnalyzer.cc.

Referenced by getAssociation(), and ThinningTestAnalyzer().

◆ expectedIndexesIntoParent_

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

private

Definition at line 66 of file ThinningTestAnalyzer.cc.

Referenced by getAssociation(), and ThinningTestAnalyzer().

◆ expectedParentContent_

std::vector<int> edmtest::ThinningTestAnalyzer::expectedParentContent_

private

Definition at line 61 of file ThinningTestAnalyzer.cc.

Referenced by getParent(), and ThinningTestAnalyzer().

◆ expectedThinnedContent_

std::vector<int> edmtest::ThinningTestAnalyzer::expectedThinnedContent_

private

Definition at line 65 of file ThinningTestAnalyzer.cc.

Referenced by getThinned(), and ThinningTestAnalyzer().

◆ expectedValues_

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

private

Definition at line 68 of file ThinningTestAnalyzer.cc.

Referenced by analyze(), incrementExpectedValue(), testVectors(), and ThinningTestAnalyzer().

◆ parentSlimmedValueFactor_

int edmtest::ThinningTestAnalyzer::parentSlimmedValueFactor_

private

Definition at line 69 of file ThinningTestAnalyzer.cc.

Referenced by getParent(), and ThinningTestAnalyzer().

◆ parentToken_

edm::EDGetTokenT<ThingCollection> edmtest::ThinningTestAnalyzer::parentToken_

private

Definition at line 55 of file ThinningTestAnalyzer.cc.

Referenced by getParent(), and ThinningTestAnalyzer().

◆ parentWasDropped_

bool edmtest::ThinningTestAnalyzer::parentWasDropped_

private

Definition at line 60 of file ThinningTestAnalyzer.cc.

Referenced by analyze(), getParent(), and ThinningTestAnalyzer().

◆ refSlimmedValueFactor_

int edmtest::ThinningTestAnalyzer::refSlimmedValueFactor_

private

Definition at line 71 of file ThinningTestAnalyzer.cc.

Referenced by testRefToParent(), testVectors(), and ThinningTestAnalyzer().

◆ refToParentIsAvailable_

bool edmtest::ThinningTestAnalyzer::refToParentIsAvailable_

private

Definition at line 64 of file ThinningTestAnalyzer.cc.

Referenced by testRefToParent(), testVectors(), and ThinningTestAnalyzer().

◆ thinnedIsAlias_

bool edmtest::ThinningTestAnalyzer::thinnedIsAlias_

private

Definition at line 63 of file ThinningTestAnalyzer.cc.

Referenced by ThinningTestAnalyzer().

◆ thinnedSlimmedValueFactor_

int edmtest::ThinningTestAnalyzer::thinnedSlimmedValueFactor_

private

Definition at line 70 of file ThinningTestAnalyzer.cc.

Referenced by getThinned(), testRefToThinned(), testVectors(), and ThinningTestAnalyzer().

◆ thinnedToken_

edm::EDGetTokenT<ThingCollection> edmtest::ThinningTestAnalyzer::thinnedToken_

private

Definition at line 56 of file ThinningTestAnalyzer.cc.

Referenced by getThinned(), and ThinningTestAnalyzer().

◆ thinnedWasDropped_

bool edmtest::ThinningTestAnalyzer::thinnedWasDropped_

private

Definition at line 62 of file ThinningTestAnalyzer.cc.

Referenced by analyze(), getThinned(), testVectors(), and ThinningTestAnalyzer().

◆ trackToken_

edm::EDGetTokenT<TrackOfThingsCollection> edmtest::ThinningTestAnalyzer::trackToken_

private

Definition at line 58 of file ThinningTestAnalyzer.cc.

Referenced by getTrackCollection(), and ThinningTestAnalyzer().

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ThinningTestAnalyzer()

Member Function Documentation

◆ analyze()

◆ fillDescriptions()

◆ getAssociation()

◆ getParent()

◆ getThinned()

◆ getTrackCollection()

◆ incrementExpectedValue()

◆ testRefToParent()

◆ testRefToThinned()

◆ testVectors()

Member Data Documentation

◆ associationShouldBeDropped_

◆ associationToken_

◆ expectedIndexesIntoParent_

◆ expectedParentContent_

◆ expectedThinnedContent_

◆ expectedValues_

◆ parentSlimmedValueFactor_

◆ parentToken_

◆ parentWasDropped_

◆ refSlimmedValueFactor_

◆ refToParentIsAvailable_

◆ thinnedIsAlias_

◆ thinnedSlimmedValueFactor_

◆ thinnedToken_

◆ thinnedWasDropped_

◆ trackToken_