JetGroupProduct Class Reference

#include <JetGroupProduct.h>

Inheritance diagram for JetGroupProduct:

Collaboration diagram for JetGroupProduct:

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

Private Member Functions
void	init (const std::vector< std::size_t > &siblings, const CondInd2JetGroupsInds &satisfiedBy, const std::vector< std::size_t > &condMult)

Private Attributes
JetGroupInd2ElemInds	m_jg2elemjgs
std::vector< bool >	m_jetMask
std::size_t	m_jetEnd {0}
std::vector< std::vector< std::size_t > >	m_seenIndices
std::unique_ptr< JetStreamer >	m_jetstreamer {nullptr}
bool	m_valid {false}

Detailed Description

Definition at line 20 of file JetGroupProduct.h.

Constructor & Destructor Documentation

JetGroupProduct()

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

Definition at line 13 of file JetGroupProduct.cxx.

                                                        :
  m_jg2elemjgs{jg2elemjgs}
{
 
  m_valid = !siblings.empty() or satisfiedBy.size() != condMult.size();
  if (m_valid) {init(siblings, satisfiedBy, condMult);}
}

Member Function Documentation

init()

void JetGroupProduct::init ( const std::vector< std::size_t > &  siblings, const CondInd2JetGroupsInds &  satisfiedBy, const std::vector< std::size_t > &  condMult  )

private

Definition at line 24 of file JetGroupProduct.cxx.

                                                    {
 
  // create a jetstreamer object to cycle through the
  // possoble combinations. The streamer may form 
  // vectors of indices by performing external products, and
  // these may have duplicates, and vectors that differ only in
  // order, which will need to be removed.
 
  
  std::vector<std::vector<std::size_t>> condIndices;
  condIndices.reserve(siblings.size());
  std::vector<std::size_t> repeats;
  condIndices.reserve(siblings.size());
  
  for(const auto& isib : siblings){
    auto mult = condMult[isib];  // jet groups indices of satisying jgs.
    repeats.push_back(mult);
    condIndices.push_back(satisfiedBy.at(isib));
 
    // find the greatest jet index we will deal with
    const auto& sibjets = satisfiedBy.at(isib);
    m_jetEnd = std::max(m_jetEnd,
               *std::max_element(sibjets.begin(),
                         sibjets.end()));
    ++m_jetEnd;; // to be used as an end marker
    m_jetMask.reserve(m_jetEnd);
    
  }
 
 
  auto streamer = make_jetstream(condIndices, repeats, 0);
  m_jetstreamer.reset(new JetStreamer(std::move(streamer)));
}

next()

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

overridevirtual

Implements IJetGroupProduct.

Definition at line 60 of file JetGroupProduct.cxx.

                                                                    {
  // Produce an ordered set sequence of jet indices, one from each Condition
  // with no duplicate indices.
  //
  // Ask ProductGen for the next set of indices into the condIndices arrays
  // use these to create a sequences of jet indices. The process is blocked
  // if there is a duplicate jet index using m_jetMask
  //
  // finally, m_seenIndices keeps track of jet index seqiences that have
  // already been generated. If this is the first time the sequece has
  // been generated, it will be added to m_seenJetIndices, and then requrned
  // to the caller. If it has already been seen, it will be abandoned.
 
  if (!m_valid) {return std::vector<std::size_t>();}
  
  unsigned int ipass{0};
  std::vector<std::size_t> jg_indices;
  while(true){
 
    m_jetMask.assign(m_jetEnd, false);
    
    if(collector){
      collector->collect("JetGroupProduct::next()",
                         "loop start pass " + std::to_string(ipass++));
    }
      
 
    bool blocked{false};
    auto jet_indices = m_jetstreamer->next();
    if (jet_indices.empty()) {
      if(collector){
      collector->collect("JetGroupProduct::next()",
                         "end of iteration ");
      }
      return jet_indices;
    }
    for (const auto& ind : jet_indices) {
      if (m_jetMask[ind]) {
    blocked = true;
    break;
      }
      m_jetMask[ind] = true;
    }
 
    if (blocked){continue;}
 
    jg_indices.clear();
    for(std::size_t i = 0; i != m_jetEnd; ++i) {
      if (m_jetMask[i]) {
    jg_indices.push_back(i);
      }
    }
 
    auto elem_indices = elementalJetGroups(jg_indices,
                       m_jg2elemjgs);
    if (elem_indices.empty()) {continue;}
 
    if (std::find(m_seenIndices.begin(),
          m_seenIndices.end(),
          elem_indices) == m_seenIndices.end()){
      m_seenIndices.push_back(elem_indices);
      return elem_indices;
    }
  }            
}

valid()

bool JetGroupProduct::valid ( ) const

overridevirtual

Implements IJetGroupProduct.

Definition at line 127 of file JetGroupProduct.cxx.

{return m_valid;}

Member Data Documentation

m_jetEnd

std::size_t JetGroupProduct::m_jetEnd {0}

private

Definition at line 48 of file JetGroupProduct.h.

m_jetMask

std::vector<bool> JetGroupProduct::m_jetMask

private

Definition at line 47 of file JetGroupProduct.h.

m_jetstreamer

std::unique_ptr<JetStreamer> JetGroupProduct::m_jetstreamer {nullptr}

private

Definition at line 51 of file JetGroupProduct.h.

m_jg2elemjgs

JetGroupInd2ElemInds JetGroupProduct::m_jg2elemjgs

private

Definition at line 45 of file JetGroupProduct.h.

m_seenIndices

std::vector<std::vector<std::size_t> > JetGroupProduct::m_seenIndices

private

Definition at line 50 of file JetGroupProduct.h.

m_valid

bool JetGroupProduct::m_valid {false}

private

Definition at line 52 of file JetGroupProduct.h.

---

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

• JetGroupProduct.h
• JetGroupProduct.cxx