AssnAnalyzer Class Reference

Inheritance diagram for AssnAnalyzer:

Public Types
typedef std::vector< int >	intvec_t
typedef std::vector< std::string >	strvec_t
typedef art::Assns< std::string, int >	strintAssns_t
Public Types inherited from art::EDAnalyzer
using	WorkerType = WorkerT< EDAnalyzer >
using	ModuleType = EDAnalyzer

Public Member Functions
	AssnAnalyzer (fhicl::ParameterSet const &p)
	AssnAnalyzer (AssnAnalyzer const &)=delete
	AssnAnalyzer (AssnAnalyzer &&)=delete
AssnAnalyzer &	operator= (AssnAnalyzer const &)=delete
AssnAnalyzer &	operator= (AssnAnalyzer &&)=delete
void	analyze (art::Event const &e) override
Public Member Functions inherited from art::EDAnalyzer
	EDAnalyzer (fhicl::ParameterSet const &pset)
template<typename Config >
	EDAnalyzer (Table< Config > const &config)
std::string	workerType () const
Public Member Functions inherited from art::detail::Analyzer
virtual	~Analyzer () noexcept
	Analyzer (fhicl::ParameterSet const &pset)
template<typename Config >
	Analyzer (Table< Config > const &config)
void	doBeginJob (SharedResources const &resources)
void	doEndJob ()
void	doRespondToOpenInputFile (FileBlock const &fb)
void	doRespondToCloseInputFile (FileBlock const &fb)
void	doRespondToOpenOutputFiles (FileBlock const &fb)
void	doRespondToCloseOutputFiles (FileBlock const &fb)
bool	doBeginRun (RunPrincipal &rp, ModuleContext const &mc)
bool	doEndRun (RunPrincipal &rp, ModuleContext const &mc)
bool	doBeginSubRun (SubRunPrincipal &srp, ModuleContext const &mc)
bool	doEndSubRun (SubRunPrincipal &srp, ModuleContext const &mc)
bool	doEvent (EventPrincipal &ep, ModuleContext const &mc, std::atomic< std::size_t > &counts_run, std::atomic< std::size_t > &counts_passed, std::atomic< std::size_t > &counts_failed)
Public Member Functions inherited from art::Observer
	~Observer () noexcept
	Observer (Observer const &)=delete
	Observer (Observer &&)=delete
Observer &	operator= (Observer const &)=delete
Observer &	operator= (Observer &&)=delete
void	registerProducts (ProductDescriptions &, ModuleDescription const &)
void	fillDescriptions (ModuleDescription const &)
fhicl::ParameterSetID	selectorConfig () const
Public Member Functions inherited from art::ModuleBase
virtual	~ModuleBase () noexcept
	ModuleBase ()
ModuleDescription const &	moduleDescription () const
void	setModuleDescription (ModuleDescription const &)
std::array< std::vector< ProductInfo >, NumBranchTypes > const &	getConsumables () const
void	sortConsumables (std::string const &current_process_name)
template<typename T , BranchType BT>
ViewToken< T >	consumesView (InputTag const &tag)
template<typename T , BranchType BT>
ViewToken< T >	mayConsumeView (InputTag const &tag)

Private Member Functions
void	for_each_associated_group_test (art::Event const &e) const
void	associated_groups_test (art::Event const &e) const
void	associated_groups_with_left_test (art::Event const &e) const

Private Attributes
art::InputTag	fInputLabel
std::set< std::string >	fEnabledTests

Additional Inherited Members
Protected Member Functions inherited from art::Observer
std::string const &	processName () const
bool	wantAllEvents () const noexcept
bool	wantEvent (ScheduleID id, Event const &e) const
Handle< TriggerResults >	getTriggerResults (Event const &e) const
	Observer (fhicl::ParameterSet const &config)
	Observer (std::vector< std::string > const &select_paths, std::vector< std::string > const &reject_paths, fhicl::ParameterSet const &config)
Protected Member Functions inherited from art::ModuleBase
ConsumesCollector &	consumesCollector ()
template<typename T , BranchType = InEvent>
ProductToken< T >	consumes (InputTag const &)
template<typename Element , BranchType = InEvent>
ViewToken< Element >	consumesView (InputTag const &)
template<typename T , BranchType = InEvent>
void	consumesMany ()
template<typename T , BranchType = InEvent>
ProductToken< T >	mayConsume (InputTag const &)
template<typename Element , BranchType = InEvent>
ViewToken< Element >	mayConsumeView (InputTag const &)
template<typename T , BranchType = InEvent>
void	mayConsumeMany ()

Detailed Description

Definition at line 30 of file AssnAnalyzer_module.cc.

Member Typedef Documentation

typedef std::vector<int> AssnAnalyzer::intvec_t

Definition at line 32 of file AssnAnalyzer_module.cc.

typedef art::Assns<std::string, int> AssnAnalyzer::strintAssns_t

Definition at line 34 of file AssnAnalyzer_module.cc.

typedef std::vector<std::string> AssnAnalyzer::strvec_t

Definition at line 33 of file AssnAnalyzer_module.cc.

Constructor & Destructor Documentation

AssnAnalyzer::AssnAnalyzer ( fhicl::ParameterSet const &  p )

explicit

Definition at line 69 of file AssnAnalyzer_module.cc.

  :
  EDAnalyzer(p)
  , fInputLabel(p.get<art::InputTag>("input_label"))
{
  auto enableTests = p.get<std::vector<std::string>>("enableTests");
  if (enableTests.empty()) {
    fEnabledTests = {
      "forEachAssociatedGroup", "associatedGroups", "associatedGroupsWithLeft"
    };
  }
  else {
    std::copy(enableTests.begin(), enableTests.end(),
      std::inserter(fEnabledTests, fEnabledTests.begin()));
  }
}

AssnAnalyzer::AssnAnalyzer ( AssnAnalyzer const &  )

delete

AssnAnalyzer::AssnAnalyzer ( AssnAnalyzer &&  )

delete

Member Function Documentation

void AssnAnalyzer::analyze ( art::Event const &  e )

overridevirtual

Implements art::EDAnalyzer.

Definition at line 87 of file AssnAnalyzer_module.cc.

{
   if (fEnabledTests.count("forEachAssociatedGroup"))
     AssnAnalyzer::for_each_associated_group_test(e);
   if (fEnabledTests.count("associatedGroups"))
     AssnAnalyzer::associated_groups_test(e);
   if (fEnabledTests.count("associatedGroupsWithLeft"))
     AssnAnalyzer::associated_groups_with_left_test(e);
}

void AssnAnalyzer::associated_groups_test ( art::Event const &  e ) const

private

Definition at line 125 of file AssnAnalyzer_module.cc.

{
   // this is the exact same test as for_each_associated_group_test(),
   // but written with an explicit loop

   typedef typename art::Assns<int, std::string> istr_assns;
   auto const & int_to_str_assns = *e.getValidHandle<istr_assns> (fInputLabel);
   auto vs = strvec_t {"one", "one-a", "two", "two-a", "three", "three-a"};

   strvec_t strvec;
   for (auto strs: util::associated_groups(int_to_str_assns)) {
      for(art::Ptr<std::string> const& s: strs) {
         std::cout << s << std::flush << " \"" << *s << "\"" << std::endl;
         strvec.push_back(*s);
      }
   } // for associated groups

   //strings should be same as vs
   for(auto k=0; k<6;++k) {
      if (strvec[k] != vs[k]) {
        throw art::Exception(art::errors::LogicError)
          << "String #" << k << " expected to be '" << vs[k]
          << "', got '" << strvec[k] << "' instead!\n";
      }
   }

} // associated_groups_test()

void AssnAnalyzer::associated_groups_with_left_test ( art::Event const &  e ) const

private

Definition at line 154 of file AssnAnalyzer_module.cc.

{
   // this is the exact same test as associated_groups_test(),
   // but passing around also the key

   typedef typename art::Assns<int, std::string> istr_assns;
   auto const & int_to_str_assns = *e.getValidHandle<istr_assns> (fInputLabel);
   std::vector<std::pair<int, std::string>> vs = {
     { 1, "one"     },
     { 1, "one-a"   },
     { 2, "two"     },
     { 2, "two-a"   },
     { 3, "three"   },
     { 3, "three-a" }
   };

   std::vector<std::pair<int, std::string>> strvec;
   for (auto const& group: util::associated_groups_with_left(int_to_str_assns))
   {
      // user code here:
      auto const& key = std::get<0>(group);  // group.first also ok
      auto const& strs = std::get<1>(group); // group.second also ok

      std::cout << "#" << (*key) << " (" << key << ")" << std::endl;
      for(art::Ptr<std::string> const& s: strs) {
         std::cout << " - " << s << " \"" << *s << "\"" << std::endl;
         strvec.emplace_back(*key, *s);
      }
   } // for associated groups

   //strings should be same as vs
   for(auto k=0; k<6;++k) {
      std::string const& s = strvec[k].second;
      int key = 0; // (unknown)
      if      (starts_with(s, "one"  )) key = 1;
      else if (starts_with(s, "two"  )) key = 2;
      else if (starts_with(s, "three")) key = 3;

      if (key != vs[k].first) {
        throw art::Exception(art::errors::LogicError)
          << "String #" << k << " expected to have key '" << vs[k].first
          << "', got '" << key << "' instead!\n";
      }

      if (s != vs[k].second) {
        throw art::Exception(art::errors::LogicError)
          << "String #" << k << " expected to be '" << vs[k].second
          << "', got '" << s << "' instead!\n";
      }

   }

} // associated_groups_test()

void AssnAnalyzer::for_each_associated_group_test ( art::Event const &  e ) const

private

Definition at line 97 of file AssnAnalyzer_module.cc.

{
   typedef typename art::Assns<int, std::string> istr_assns;
   auto const & int_to_str_assns = *e.getValidHandle<istr_assns> (fInputLabel);
   auto vs = strvec_t {"one", "one-a", "two", "two-a", "three", "three-a"};

   strvec_t strvec;
   auto strings = [&strvec](auto strs) {
      for(auto s=begin(strs); s!=end(strs); ++s) {
         std::cout << *s << std::flush << " \"" << **s << "\"" << std::endl;
         strvec.push_back(**s);
      }
   };

   art::for_each_group(int_to_str_assns, strings);

   //strings should be same as vs
   for(auto k=0; k<6;++k) {
      if (strvec[k] != vs[k]) {
        throw art::Exception(art::errors::LogicError)
          << "String #" << k << " expected to be '" << vs[k]
          << "', got '" << strvec[k] << "' instead!\n";
      }
   }

} // for_each_associated_group_test()

AssnAnalyzer& AssnAnalyzer::operator= ( AssnAnalyzer const &  )

delete

AssnAnalyzer& AssnAnalyzer::operator= ( AssnAnalyzer &&  )

delete

Member Data Documentation

std::set<std::string> AssnAnalyzer::fEnabledTests

private

Definition at line 52 of file AssnAnalyzer_module.cc.

art::InputTag AssnAnalyzer::fInputLabel

private

Definition at line 50 of file AssnAnalyzer_module.cc.

---

The documentation for this class was generated from the following file:

• lardata/test/Utilities/testForEachAssociatedGroup/AssnAnalyzer_module.cc