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

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

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 )

override

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:

• AssnAnalyzer_module.cc