#include <JetGroupReducer.h>

Inheritance diagram for JetGroupReducer:

Collaboration diagram for JetGroupReducer:

Public Member Functions
	JetGroupReducer (const std::vector< std::size_t > &siblings, const CondInd2JetGroupsInds &satisfiedBy, const JetGroupInd2ElemInds &)
virtual std::vector< std::size_t >	next (const Collector &) override
virtual bool	valid () const override

Private Attributes
std::vector< std::size_t >	m_jetIndices
bool	m_done {false}

Detailed Description

Definition at line 29 of file JetGroupReducer.h.

Constructor & Destructor Documentation

◆ JetGroupReducer()

JetGroupReducer::JetGroupReducer	(	const std::vector< std::size_t > &	siblings,
		const CondInd2JetGroupsInds &	satisfiedBy,
		const JetGroupInd2ElemInds &	jg2elemjgs )

Definition at line 13 of file JetGroupReducer.cxx.

                                                        {
  
  // make a vector of the jet indices that satisfy the sibling Conditions
  // with no duplicates
 
  // edge cases
  if (siblings.empty()){
    m_done = true;
    return;
  }
 
  for (const auto& s : siblings){
    if (satisfiedBy.at(s).empty()) {
      m_done = true;
      return;
    }
  }
 
  std::vector<std::size_t> satisfying; 
 
  for (const auto& s :siblings){
    satisfying.insert(satisfying.end(),
              satisfiedBy.at(s).cbegin(),
              satisfiedBy.at(s).cend()
              );
  }
 
  // If more there are more than one siblings, there could be
  // duplicates in the combined list of (non-elementary) jet groups.
  // Eliminate these.
  
  auto end = satisfying.end();
  if (siblings.size() > 1) {
    std::sort(satisfying.begin(),
          satisfying.end());
 
    end = std::unique(satisfying.begin(),
              satisfying.end());
  }
 
  std::vector<std::size_t> jet_indices;
  for(auto iter = satisfying.begin(); iter != end; ++iter) {
    jet_indices.insert(jet_indices.end(),
               jg2elemjgs.at(*iter).begin(),
               jg2elemjgs.at(*iter).end());
  }
 
  std::sort(jet_indices.begin(),
        jet_indices.end());
  
  auto final_end = std::unique(jet_indices.begin(),
                   jet_indices.end());
  
  
  jet_indices.resize(final_end-jet_indices.begin());
  
  m_jetIndices = elementalJetGroups(jet_indices,
                    jg2elemjgs);
  m_done = false;
  }

Member Function Documentation

◆ next()

std::vector< std::size_t > JetGroupReducer::next ( const Collector & collector )

overridevirtual

Implements IJetGroupProduct.

Definition at line 77 of file JetGroupReducer.cxx.

                                                                    {
  if(collector){
    std::stringstream sstr;
    sstr << "no of indices " << m_jetIndices.size()
     << " done " << std::boolalpha << m_done;
    collector->collect("JetGroupReducer::next()", sstr.str());
  }
  
  if (m_done) {
    return std::vector<std::size_t>();
  }
 
  m_done = true;
  return m_jetIndices;
}

◆ valid()

bool JetGroupReducer::valid ( ) const

overridevirtual

Implements IJetGroupProduct.

Definition at line 93 of file JetGroupReducer.cxx.

93{return true;}

Member Data Documentation

◆ m_done

bool JetGroupReducer::m_done {false}

private

Definition at line 43 of file JetGroupReducer.h.

43{false};

◆ m_jetIndices

std::vector<std::size_t> JetGroupReducer::m_jetIndices