edmtest::ViewAnalyzer Class Reference

Inheritance diagram for edmtest::ViewAnalyzer:

Public Member Functions
void	analyze (edm::StreamID, edm::Event const &e, edm::EventSetup const &) const override
void	testAVProduct (edm::Event const &e, std::string const &moduleLabel) const
void	testDSVProduct (edm::Event const &e, std::string const &moduleLabel) const
template<typename P , typename V >
void	testProduct (edm::Event const &e, std::string const &moduleLabel) const
void	testProductWithBaseClass (edm::Event const &e, std::string const &moduleLabel) const
void	testPtrVector (edm::Event const &e, std::string const &moduleLabel) const
void	testRefToBaseVector (edm::Event const &e, std::string const &moduleLabel) const
void	testRefVector (edm::Event const &e, std::string const &moduleLabel) const
void	testStdVectorPtr (edm::Event const &e, std::string const &moduleLabel) const
void	testStdVectorUniquePtr (edm::Event const &e, std::string const &moduleLabel) const
	ViewAnalyzer (edm::ParameterSet const &)
Public Member Functions inherited from edm::global::EDAnalyzer<>
	EDAnalyzer ()=default
	EDAnalyzer (const EDAnalyzer &)=delete
const EDAnalyzer &	operator= (const EDAnalyzer &)=delete
bool	wantsGlobalLuminosityBlocks () const noexcept final
bool	wantsGlobalRuns () const noexcept final
bool	wantsInputProcessBlocks () const noexcept final
bool	wantsProcessBlocks () const noexcept final
bool	wantsStreamLuminosityBlocks () const noexcept final
bool	wantsStreamRuns () const noexcept 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)

Additional Inherited Members
Public Types inherited from edm::global::EDAnalyzerBase
typedef EDAnalyzerBase	ModuleType
Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels
Static Public Member Functions inherited from edm::global::EDAnalyzerBase
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &descriptions)
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 29 of file ViewAnalyzer.cc.

Constructor & Destructor Documentation

ViewAnalyzer()

edmtest::ViewAnalyzer::ViewAnalyzer ( edm::ParameterSet const &  )

explicit

Definition at line 54 of file ViewAnalyzer.cc.

                                                {
    consumes<edm::View<int>>(edm::InputTag{"intvec", "", "TEST"});
    consumes<edm::View<int>>(edm::InputTag{"intvec", ""});
    consumes<std::vector<int>>(edm::InputTag{"intvec"});
    consumes<edm::View<int>>(edm::InputTag{"intvec"});
    consumes<std::list<int>>(edm::InputTag{"intlist"});
    consumes<edm::View<int>>(edm::InputTag{"intlist"});
    consumes<std::deque<int>>(edm::InputTag{"intdeque"});
    consumes<edm::View<int>>(edm::InputTag{"intdeque"});
    consumes<std::set<int>>(edm::InputTag{"intset"});
    consumes<edm::View<int>>(edm::InputTag{"intset"});
    consumes<SCSimpleProduct>(edm::InputTag{"simple"});
    consumes<edm::View<SCSimpleProduct::value_type>>(edm::InputTag{"simple"});
    consumes<OVSimpleProduct>(edm::InputTag{"ovsimple"});
    consumes<edm::View<OVSimpleProduct::value_type>>(edm::InputTag{"ovsimple"});
    consumes<AVSimpleProduct>(edm::InputTag{"avsimple"});
    consumes<edm::View<AVSimpleProduct::value_type>>(edm::InputTag{"avsimple"});
    consumes<edmtest::DSVSimpleProduct>(edm::InputTag{"dsvsimple"});
    consumes<edm::View<edmtest::DSVSimpleProduct::value_type>>(edm::InputTag{"dsvsimple"});

    consumes<OVSimpleDerivedProduct>(edm::InputTag{"ovsimple", "derived"});
    consumes<edm::View<Simple>>(edm::InputTag{"ovsimple", "derived"});

    consumes<RefVector<std::vector<int>>>(edm::InputTag{"intvecrefvec"});
    consumes<edm::View<int>>(edm::InputTag{"intvecrefvec"});

    consumes<RefToBaseVector<int>>(edm::InputTag{"intvecreftbvec"});
    consumes<edm::View<int>>(edm::InputTag{"intvecreftbvec"});

    consumes<PtrVector<int>>(edm::InputTag{"intvecptrvec"});
    consumes<edm::View<int>>(edm::InputTag{"intvecptrvec"});

    consumes<std::vector<edm::Ptr<int>>>(edm::InputTag{"intvecstdvecptr"});
    consumes<edm::View<int>>(edm::InputTag{"intvecstdvecptr"});

    consumes<std::vector<std::unique_ptr<int>>>(edm::InputTag{"intvecstdvecuniqptr"});
    consumes<edm::View<int>>(edm::InputTag{"intvecstdvecuniqptr"});
    consumes<std::vector<std::unique_ptr<IntProduct>>>(edm::InputTag{"intvecstdvecuniqptr"});
    consumes<edm::View<IntProduct>>(edm::InputTag{"intvecstdvecuniqptr"});

    mayConsume<edm::View<int>>(edm::InputTag{"intvecptrvecdoesNotExist"});
  }

Member Function Documentation

analyze()

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

overridevirtual

Implements edm::global::EDAnalyzerBase.

Definition at line 104 of file ViewAnalyzer.cc.

References cms::cuda::assert(), MillePedeFileConverter_cfg::e, edm::HandleBase::isValid(), and makeGlobalPositionRcd_cfg::tag.

                                                                                {
    tester<std::vector<int>>::call(this, e, "intvec");
    tester<std::list<int>>::call(this, e, "intlist");
    tester<std::deque<int>>::call(this, e, "intdeque");
    tester<std::set<int>>::call(this, e, "intset");

    tester<SCSimpleProduct>::call(this, e, "simple");
    tester<OVSimpleProduct>::call(this, e, "ovsimple");
    tester<AVSimpleProduct>::call(this, e, "avsimple");

    testDSVProduct(e, "dsvsimple");
    testAVProduct(e, "avsimple");
    testProductWithBaseClass(e, "ovsimple");
    testRefVector(e, "intvecrefvec");
    testRefToBaseVector(e, "intvecreftbvec");
    testPtrVector(e, "intvecptrvec");
    testStdVectorPtr(e, "intvecstdvecptr");
    testStdVectorUniquePtr(e, "intvecstdvecuniqptr");

    //See if InputTag works
    {
      edm::InputTag tag("intvec", "");
      edm::Handle<edm::View<int>> hInt;
      e.getByLabel(tag, hInt);
      assert(hInt.isValid());
    }
    {
      edm::InputTag tag("intvec", "", "TEST");
      edm::Handle<edm::View<int>> hInt;
      e.getByLabel(tag, hInt);
      assert(hInt.isValid());
    }
  }

testAVProduct()

void edmtest::ViewAnalyzer::testAVProduct	(	edm::Event const &	e,
		std::string const &	moduleLabel
	)		const

Definition at line 221 of file ViewAnalyzer.cc.

References cms::cuda::assert(), MillePedeFileConverter_cfg::e, edm::ProductID::id(), edm::HandleBase::id(), edm::HandleBase::isValid(), HerwigMaxPtPartonFilter_cfi::moduleLabel, copyEcalPFRecHitThresholds_cfg::prod, and edm::HandleBase::provenance().

                                                                                     {
    typedef edmtest::AVSimpleProduct sequence_t;
    typedef sequence_t::value_type value_t;
    typedef View<value_t> view_t;

    Handle<sequence_t> hprod;
    e.getByLabel(moduleLabel, hprod);
    assert(hprod.isValid());

    Handle<view_t> hview;
    e.getByLabel(moduleLabel, hview);
    assert(hview.isValid());

    assert(hprod.id() == hview.id());
    assert(*hprod.provenance() == *hview.provenance());

    assert(hprod->size() == hview->size());

    sequence_t::const_iterator i_prod = hprod->begin();
    sequence_t::const_iterator e_prod = hprod->end();
    view_t::const_iterator i_view = hview->begin();
    view_t::const_iterator e_view = hview->end();

    while (i_prod != e_prod && i_view != e_view) {
      value_t const& prod = *i_prod;
      value_t const& view = *i_view;
      assert(prod == view);
      assert((*hprod)[prod.first] == prod.second);
      edm::Ptr<sequence_t::key_type> ptr(prod.first.id(), prod.first.key(), &e.productGetter());
      assert((*hprod)[ptr] == prod.second);
      edm::RefToBase<sequence_t::key_type> refToBase(prod.first);
      assert((*hprod)[refToBase] == prod.second);
      ++i_prod;
      ++i_view;
    }
  }

testDSVProduct()

void edmtest::ViewAnalyzer::testDSVProduct	(	edm::Event const &	e,
		std::string const &	moduleLabel
	)		const

Definition at line 187 of file ViewAnalyzer.cc.

References cms::cuda::assert(), MillePedeFileConverter_cfg::e, edm::ProductID::id(), edm::HandleBase::id(), edm::HandleBase::isValid(), HerwigMaxPtPartonFilter_cfi::moduleLabel, copyEcalPFRecHitThresholds_cfg::prod, and edm::HandleBase::provenance().

                                                                                      {
    typedef edmtest::DSVSimpleProduct sequence_t;
    typedef sequence_t::value_type value_t;
    typedef View<value_t> view_t;

    Handle<sequence_t> hprod;
    e.getByLabel(moduleLabel, hprod);
    assert(hprod.isValid());

    Handle<view_t> hview;
    e.getByLabel(moduleLabel, hview);
    assert(hview.isValid());

    assert(hprod.id() == hview.id());
    assert(*hprod.provenance() == *hview.provenance());

    assert(hprod->size() == hview->size());

    sequence_t::const_iterator i_prod = hprod->begin();
    sequence_t::const_iterator e_prod = hprod->end();
    view_t::const_iterator i_view = hview->begin();
    view_t::const_iterator e_view = hview->end();

    while (i_prod != e_prod && i_view != e_view) {
      value_t const& prod = *i_prod;
      value_t const& view = *i_view;
      assert(prod.detId() == view.detId());
      assert(prod.data == view.data);

      ++i_prod;
      ++i_view;
    }
  }

testProduct()

template<typename P , typename V >

void edmtest::ViewAnalyzer::testProduct	(	edm::Event const &	e,
		std::string const &	moduleLabel
	)		const

Definition at line 139 of file ViewAnalyzer.cc.

References cms::cuda::assert(), MillePedeFileConverter_cfg::e, mps_fire::i, edm::ProductID::id(), edm::HandleBase::id(), edm::RefToBase< T >::isNonnull(), edm::HandleBase::isValid(), HerwigMaxPtPartonFilter_cfi::moduleLabel, gpuClustering::numElements, edm::HandleBase::provenance(), FCDTask_cfi::slot, and cms::cuda::V.

                                                                                   {
    typedef P sequence_t;
    typedef V value_t;
    typedef View<value_t> view_t;

    Handle<sequence_t> hproduct;
    e.getByLabel(moduleLabel, hproduct);
    assert(hproduct.isValid());

    Handle<view_t> hview;
    e.getByLabel(moduleLabel, hview);
    assert(hview.isValid());

    assert(hproduct.id() == hview.id());
    assert(*hproduct.provenance() == *hview.provenance());

    assert(hproduct->size() == hview->size());

    typename sequence_t::const_iterator i_product = hproduct->begin();
    typename sequence_t::const_iterator e_product = hproduct->end();
    typename view_t::const_iterator i_view = hview->begin();
    typename view_t::const_iterator e_view = hview->end();
    size_t slot = 0;
    while (i_product != e_product && i_view != e_view) {
      value_t const& product_item = *i_product;
      value_t const& view_item = *i_view;
      assert(product_item == view_item);

      edm::Ref<sequence_t> ref3(hproduct, slot);
      assert(*ref3 == product_item);

      edm::RefProd<sequence_t> refProd4(hproduct);
      edm::Ref<sequence_t> ref4(refProd4, slot);
      assert(*ref4 == product_item);

      ++i_product;
      ++i_view;
      ++slot;
    }

    // Make sure the references are right.
    size_t numElements = hview->size();
    for (size_t i = 0; i < numElements; ++i) {
      RefToBase<value_t> ref = hview->refAt(i);
      assert(ref.isNonnull());
    }
  }

testProductWithBaseClass()

void edmtest::ViewAnalyzer::testProductWithBaseClass	(	edm::Event const &	e,
		std::string const &	moduleLabel
	)		const

Definition at line 262 of file ViewAnalyzer.cc.

References cms::cuda::assert(), edm::RefToBase< T >::castTo(), MillePedeFileConverter_cfg::e, edm::ProductID::id(), edm::HandleBase::id(), edm::HandleBase::isValid(), HerwigMaxPtPartonFilter_cfi::moduleLabel, copyEcalPFRecHitThresholds_cfg::prod, edm::HandleBase::provenance(), and FCDTask_cfi::slot.

                                                                                                {
    typedef OVSimpleDerivedProduct sequence_t;
    typedef Simple value_t;
    typedef View<value_t> view_t;

    Handle<sequence_t> hprod;
    e.getByLabel(moduleLabel, "derived", hprod);
    assert(hprod.isValid());

    Handle<view_t> hview;
    e.getByLabel(moduleLabel, "derived", hview);
    assert(hview.isValid());

    assert(hprod.id() == hview.id());
    assert(*hprod.provenance() == *hview.provenance());

    assert(hprod->size() == hview->size());

    unsigned slot = 0;

    sequence_t::const_iterator i_prod = hprod->begin();
    sequence_t::const_iterator e_prod = hprod->end();
    view_t::const_iterator i_view = hview->begin();
    view_t::const_iterator e_view = hview->end();

    while (i_prod != e_prod && i_view != e_view) {
      SimpleDerived const& prod = *i_prod;
      Simple const& view = *i_view;
      assert(prod == view);

      // Tack on a test of RefToBase::castTo here

      edm::RefToBaseProd<Simple> refToBaseProd(hview);
      edm::RefToBase<Simple> refToBase(refToBaseProd, slot);

      edm::Ptr<SimpleDerived> ptr = refToBase.castTo<edm::Ptr<SimpleDerived>>();
      SimpleDerived const& valueFromPtr = *ptr;
      assert(valueFromPtr == view);

      edm::Ref<edm::OwnVector<SimpleDerived>> ref = refToBase.castTo<edm::Ref<edm::OwnVector<SimpleDerived>>>();
      SimpleDerived const& valueFromRef = *ref;
      assert(valueFromRef == view);

      ++i_prod;
      ++i_view;
      ++slot;
    }
  }

testPtrVector()

void edmtest::ViewAnalyzer::testPtrVector	(	edm::Event const &	e,
		std::string const &	moduleLabel
	)		const

Definition at line 391 of file ViewAnalyzer.cc.

References cms::cuda::assert(), MillePedeFileConverter_cfg::e, edm::ProductID::id(), edm::HandleBase::id(), edm::HandleBase::isValid(), HerwigMaxPtPartonFilter_cfi::moduleLabel, edm::HandleBase::provenance(), and makeGlobalPositionRcd_cfg::tag.

                                                                                     {
    typedef PtrVector<int> sequence_t;
    typedef int value_t;
    typedef View<value_t> view_t;

    Handle<sequence_t> hproduct;
    e.getByLabel(moduleLabel, hproduct);
    assert(hproduct.isValid());

    Handle<view_t> hview;

    InputTag tag(moduleLabel + "doesNotExist");
    e.getByLabel(tag, hview);
    assert(!hview.isValid());

    e.getByLabel(moduleLabel + "doesNotExist", hview);
    assert(!hview.isValid());

    InputTag tag2(moduleLabel);
    e.getByLabel(tag2, hview);
    assert(hview.isValid());

    assert(hproduct.id() == hview.id());
    assert(*hproduct.provenance() == *hview.provenance());

    assert(hproduct->size() == hview->size());

    sequence_t::const_iterator i_product = hproduct->begin();
    sequence_t::const_iterator e_product = hproduct->end();
    view_t::const_iterator i_view = hview->begin();
    view_t::const_iterator e_view = hview->end();
    while (i_product != e_product && i_view != e_view) {
      value_t const& product_item = **i_product;
      value_t const& view_item = *i_view;
      assert(product_item == view_item);
      ++i_product;
      ++i_view;
    }
  }

testRefToBaseVector()

void edmtest::ViewAnalyzer::testRefToBaseVector	(	edm::Event const &	e,
		std::string const &	moduleLabel
	)		const

Definition at line 360 of file ViewAnalyzer.cc.

References cms::cuda::assert(), MillePedeFileConverter_cfg::e, edm::ProductID::id(), edm::HandleBase::id(), edm::HandleBase::isValid(), HerwigMaxPtPartonFilter_cfi::moduleLabel, and edm::HandleBase::provenance().

                                                                                           {
    typedef RefToBaseVector<int> sequence_t;
    typedef int value_t;
    typedef View<value_t> view_t;

    Handle<sequence_t> hproduct;
    e.getByLabel(moduleLabel, hproduct);
    assert(hproduct.isValid());

    Handle<view_t> hview;
    e.getByLabel(moduleLabel, hview);
    assert(hview.isValid());

    assert(hproduct.id() == hview.id());
    assert(*hproduct.provenance() == *hview.provenance());

    assert(hproduct->size() == hview->size());

    sequence_t::const_iterator i_product = hproduct->begin();
    sequence_t::const_iterator e_product = hproduct->end();
    view_t::const_iterator i_view = hview->begin();
    view_t::const_iterator e_view = hview->end();
    while (i_product != e_product && i_view != e_view) {
      value_t const& product_item = **i_product;
      value_t const& view_item = *i_view;
      assert(product_item == view_item);
      ++i_product;
      ++i_view;
    }
  }

testRefVector()

void edmtest::ViewAnalyzer::testRefVector	(	edm::Event const &	e,
		std::string const &	moduleLabel
	)		const

Definition at line 311 of file ViewAnalyzer.cc.

References cms::cuda::assert(), edm::RefToBase< T >::castTo(), MillePedeFileConverter_cfg::e, edm::ProductID::id(), edm::HandleBase::id(), edm::HandleBase::isValid(), HerwigMaxPtPartonFilter_cfi::moduleLabel, edm::HandleBase::provenance(), and FCDTask_cfi::slot.

                                                                                     {
    typedef RefVector<std::vector<int>> sequence_t;
    typedef int value_t;
    typedef View<value_t> view_t;

    Handle<sequence_t> hproduct;
    e.getByLabel(moduleLabel, hproduct);
    assert(hproduct.isValid());

    Handle<view_t> hview;
    e.getByLabel(moduleLabel, hview);
    assert(hview.isValid());

    assert(hproduct.id() == hview.id());
    assert(*hproduct.provenance() == *hview.provenance());

    assert(hproduct->size() == hview->size());

    sequence_t::const_iterator i_product = hproduct->begin();
    sequence_t::const_iterator e_product = hproduct->end();
    view_t::const_iterator i_view = hview->begin();
    view_t::const_iterator e_view = hview->end();
    size_t slot = 0;
    while (i_product != e_product && i_view != e_view) {
      value_t const& product_item = **i_product;
      value_t const& view_item = *i_view;
      assert(product_item == view_item);

      // Tack on a test of RefToBase::castTo here
      edm::RefToBaseProd<int> refToBaseProd(hview);
      edm::RefToBase<int> refToBase(refToBaseProd, slot);

      edm::Ptr<int> ref = refToBase.castTo<edm::Ptr<int>>();
      int item_other = *ref;
      assert(item_other == product_item);

      edm::Ref<std::vector<int>> ref2 = refToBase.castTo<edm::Ref<std::vector<int>>>();
      int item_other2 = *ref2;
      assert(item_other2 == product_item);

      edm::Ref<sequence_t> ref3(hproduct, slot);
      assert(*ref3 == product_item);

      ++i_product;
      ++i_view;
      ++slot;
    }
  }

testStdVectorPtr()

void edmtest::ViewAnalyzer::testStdVectorPtr	(	edm::Event const &	e,
		std::string const &	moduleLabel
	)		const

Definition at line 485 of file ViewAnalyzer.cc.

References MillePedeFileConverter_cfg::e, and HerwigMaxPtPartonFilter_cfi::moduleLabel.

                                                                                        {
    testStdVectorPtrT<edm::Ptr<int>>(e, moduleLabel);
  }

testStdVectorUniquePtr()

void edmtest::ViewAnalyzer::testStdVectorUniquePtr	(	edm::Event const &	e,
		std::string const &	moduleLabel
	)		const

Definition at line 489 of file ViewAnalyzer.cc.

References MillePedeFileConverter_cfg::e, and HerwigMaxPtPartonFilter_cfi::moduleLabel.

                                                                                              {
    testStdVectorPtrT<std::unique_ptr<int>>(e, moduleLabel);
    testStdVectorPtrT<std::unique_ptr<IntProduct>>(e, moduleLabel);
  }