EventReco::HyPERGraph Class Reference

#include <HyPERGraph.h>

Inheritance diagram for EventReco::HyPERGraph:

Collaboration diagram for EventReco::HyPERGraph:

Public Member Functions
	HyPERGraph ()
virtual	~HyPERGraph ()=default
virtual void	addNode (const Features &attributes) override
virtual void	addEdge (int64_t source, int64_t target, const Features &attributes) override
virtual void	addGlobal (const Features &attributes) override
void	buildEdgeIndices ()
void	buildHyperEdges (int64_t order)
const std::vector< EdgeIndex > &	getEdgeIndicesVector () const
HyperEdgeIndex	getHyperEdgeIndices (std::size_t index) const
int64_t	nHyperEdges () const
int64_t	hyperEdgeOrder () const
virtual void	printGraph () const
virtual void	printGraphInputsForValidation () const
virtual void	clearGraph ()
Features	getNodeFeats (std::size_t index) const
Features &	getNodeFeats (std::size_t index)
Features	getEdgeFeats (std::size_t index) const
Features	getGlobalFeats () const
EdgeIndex	getEdgeIndicesVector (std::size_t index) const
int64_t	nNodes () const
int64_t	nEdges () const
int64_t	nGlobal () const

Protected Attributes
std::vector< EdgeIndex >	m_edgeIndices = {}
std::vector< HyperEdgeIndex >	m_hyperEdgeIndices = {}
int64_t	m_nHyperEdges = 0
int64_t	m_hyperEdgeOrder = 0
Global	m_global
std::vector< Node >	m_nodes
std::vector< Edge >	m_edges
int64_t	m_nNodes = 0
int64_t	m_nEdges = 0

Private Types
using	HyperEdgeIndex = std::vector<int64_t>

Detailed Description

Definition at line 21 of file HyPERGraph.h.

Member Typedef Documentation

HyperEdgeIndex

using EventReco::HyPERGraph::HyperEdgeIndex = std::vector<int64_t>

private

Definition at line 22 of file HyPERGraph.h.

Constructor & Destructor Documentation

HyPERGraph()

EventReco::HyPERGraph::HyPERGraph ( )

inline

Definition at line 25 of file HyPERGraph.h.

: GraphBase() {};

~HyPERGraph()

virtual EventReco::HyPERGraph::~HyPERGraph ( )

virtualdefault

Member Function Documentation

addEdge()

void EventReco::HyPERGraph::addEdge ( int64_t source, int64_t target, const Features & attributes )

overridevirtual

Implements EventReco::GraphBase.

Definition at line 20 of file HyPERGraph.cxx.

                                                     {
  EventReco::Edge newEdge(source, target, attributes);
  m_edges.push_back(newEdge);
  m_nEdges += 1;
}

addGlobal()

void EventReco::HyPERGraph::addGlobal ( const Features & attributes )

overridevirtual

Implements EventReco::GraphBase.

Definition at line 27 of file HyPERGraph.cxx.

                                                     {
  m_global = EventReco::Global(attributes);
}

addNode()

void EventReco::HyPERGraph::addNode ( const Features & attributes )

overridevirtual

Implements EventReco::GraphBase.

Definition at line 14 of file HyPERGraph.cxx.

                                                   {
  EventReco::Node newNode(attributes, m_nNodes);
  m_nodes.push_back(newNode);
  m_nNodes += 1;
}

buildEdgeIndices()

void EventReco::HyPERGraph::buildEdgeIndices

(

)

Definition at line 31 of file HyPERGraph.cxx.

                                  {
  if (m_nNodes < 2) {
    return;  // There are no edges when the number of nodes is less than 2.
  }
  std::vector<int64_t> edgeIndices = range(m_nNodes);
  for (const auto& index1 : edgeIndices) {
    for (const auto& index2 : edgeIndices) {
      if (index1 != index2)
        m_edgeIndices.push_back(std::make_pair(index1, index2));
    }
  }
}

buildHyperEdges()

void EventReco::HyPERGraph::buildHyperEdges

(

int64_t

order

)

Definition at line 44 of file HyPERGraph.cxx.

                                              {
  m_hyperEdgeOrder = order;
  if (m_nNodes < order) {
    return;  // There are no hyperedges when the number of nodes is less than
             // the hyperedge order.
  }
  std::vector<int64_t> edgeIndices = range(m_nNodes);
  m_hyperEdgeIndices = buildCombinations(edgeIndices, order);
  m_nHyperEdges = m_hyperEdgeIndices.size();
}

clearGraph()

void EventReco::HyPERGraph::clearGraph ( )

virtual

Definition at line 170 of file HyPERGraph.cxx.

                            {
  m_nNodes = 0;
  m_nEdges = 0;
  m_nodes.clear();
  m_edges.clear();
  m_global = {};
  m_edgeIndices = {};
  m_hyperEdgeIndices = {};
  m_hyperEdgeOrder = 0;
  m_nHyperEdges = 0;
}

getEdgeFeats()

Features EventReco::GraphBase::getEdgeFeats ( std::size_t index ) const

inlineinherited

Definition at line 80 of file GraphBase.h.

                                               {
    return m_edges[index].getFeatures();
  };

getEdgeIndicesVector() [1/2]

EdgeIndex EventReco::GraphBase::getEdgeIndicesVector ( std::size_t index ) const

inlineinherited

Definition at line 84 of file GraphBase.h.

                                                        {
    return m_edges[index].getIndices();
  };

getEdgeIndicesVector() [2/2]

const std::vector< EdgeIndex > & EventReco::HyPERGraph::getEdgeIndicesVector ( ) const

inline

Definition at line 35 of file HyPERGraph.h.

                                                           {
    return m_edgeIndices;
  }

getGlobalFeats()

Features EventReco::GraphBase::getGlobalFeats ( ) const

inlineinherited

Definition at line 83 of file GraphBase.h.

{ return m_global.getFeatures(); };

getHyperEdgeIndices()

HyperEdgeIndex EventReco::HyPERGraph::getHyperEdgeIndices ( std::size_t index ) const

inline

Definition at line 38 of file HyPERGraph.h.

                                                            {
    return m_hyperEdgeIndices[index];
  }

getNodeFeats() [1/2]

Features & EventReco::GraphBase::getNodeFeats ( std::size_t index )

inlineinherited

Definition at line 77 of file GraphBase.h.

                                          {
    return m_nodes[index].getFeatures();
  };

getNodeFeats() [2/2]

Features EventReco::GraphBase::getNodeFeats ( std::size_t index ) const

inlineinherited

Definition at line 74 of file GraphBase.h.

                                               {
    return m_nodes[index].getFeatures();
  };

hyperEdgeOrder()

int64_t EventReco::HyPERGraph::hyperEdgeOrder ( ) const

inline

Definition at line 42 of file HyPERGraph.h.

{ return m_hyperEdgeOrder; }

nEdges()

int64_t EventReco::GraphBase::nEdges ( ) const

inlineinherited

Definition at line 89 of file GraphBase.h.

{ return m_nEdges; };

nGlobal()

int64_t EventReco::GraphBase::nGlobal ( ) const

inlineinherited

Definition at line 90 of file GraphBase.h.

{ return m_global.getFeatures().size(); };

nHyperEdges()

int64_t EventReco::HyPERGraph::nHyperEdges ( ) const

inline

Definition at line 41 of file HyPERGraph.h.

{ return m_nHyperEdges; }

nNodes()

int64_t EventReco::GraphBase::nNodes ( ) const

inlineinherited

Definition at line 88 of file GraphBase.h.

{ return m_nNodes; };

printGraph()

void EventReco::HyPERGraph::printGraph ( ) const

virtual

Definition at line 55 of file HyPERGraph.cxx.

                                  {
  using namespace asg::msgUserCode;
  setMsgLevel(MSG::INFO);
  ANA_MSG_INFO("Printing graph...");
  // Print the nodes
  for (const auto& node : m_nodes) {
    ANA_MSG_INFO("Node Index: " << node.getNodeIndex());
    for (const auto& feat : node.getFeatures()) {
      ANA_MSG_INFO("Feature:  " << feat);
    }
  }
  // Print the edges
  for (const auto& edge : m_edges) {
    ANA_MSG_INFO("Edge Index: " << edge.getIndices().first << " -> "
                                << edge.getIndices().second);
    for (const auto& feat : edge.getFeatures()) {
      ANA_MSG_INFO("Feature:  " << feat);
    }
  }
  // Print the global
  ANA_MSG_INFO("Global Features: ");
  for (const auto& feat : m_global.getFeatures()) {
    ANA_MSG_INFO("Feature:  " << feat);
  }
  // Print the hyperedges
  for (const auto& hyperEdge : m_hyperEdgeIndices) {
    std::string indices{""};
    for (const auto& index : hyperEdge) {
      indices += std::to_string(index) + " ";
    }
    ANA_MSG_INFO("HyperEdge indices: " << indices);
  }
  ANA_MSG_INFO("Finished graph printing...");
}

printGraphInputsForValidation()

void EventReco::HyPERGraph::printGraphInputsForValidation ( ) const

virtual

Definition at line 90 of file HyPERGraph.cxx.

                                                     {
  using namespace asg::msgUserCode;
  setMsgLevel(MSG::INFO);
  ANA_MSG_INFO("Printing graph inputs in validation mode...");
 
  // Print the nodes
  ANA_MSG_INFO("NODES:");
  for (const auto& node : m_nodes) {
    std::string row = "[";
    for (const auto& feat : node.getFeatures()) {
      row += std::to_string(feat) + ", ";
    }
    row += "],";
    ANA_MSG_INFO(row);
  }
  // Print the edges
  ANA_MSG_INFO("EDGES:");
  for (const auto& edge : m_edges) {
    std::string row = "[";
    for (const auto& feat : edge.getFeatures()) {
      row += std::to_string(feat) + ", ";
    }
    row += "],";
    ANA_MSG_INFO(row);
  }
  // Print the edge indices
  ANA_MSG_INFO("EDGE INDICES:");
  std::string row1 = "[";
  std::string row2 = "[";
  for (const auto& edge : m_edges) {
    row1 += std::to_string(edge.getIndices().first) + ", ";
    row2 += std::to_string(edge.getIndices().second) + ", ";
  }
  row1 += "],";
  row2 += "],";
  ANA_MSG_INFO(row1);
  ANA_MSG_INFO(row2);
  // Print the globals
  ANA_MSG_INFO("GLOBAL:");
  std::string row = "[[";
  for (const auto& feat : m_global.getFeatures()) {
    row += std::to_string(feat) + ", ";
  }
  row += "]],";
  ANA_MSG_INFO(row);
  // Print batch
  ANA_MSG_INFO("BATCH:");
  row = "[[";
  for (auto i{0}; i < this->nNodes(); i++) {
    row += "0, ";
  }
  row += "]],";
  ANA_MSG_INFO(row);
  // Print the hyperedges
  ANA_MSG_INFO("HYPEREDGE INDICES:");
  std::vector<std::string> rows(this->hyperEdgeOrder());
  for (auto i{0}; i < this->hyperEdgeOrder(); i++) {
    rows[i] = "[";
  }
  for (const auto& hyperEdge : m_hyperEdgeIndices) {
    for (auto i{0}; i < this->hyperEdgeOrder(); i++) {
      rows[i] += std::to_string(hyperEdge[i]) + ", ";
    }
  }
  for (auto i{0}; i < this->hyperEdgeOrder(); i++) {
    rows[i] += "],";
    ANA_MSG_INFO(rows[i]);
  }
  // Print batch hyperedges
  ANA_MSG_INFO("BATCH HYPEREDGES:");
  row = "[[";
  for (auto i{0}; i < this->nHyperEdges(); i++) {
    row += "0, ";
  }
  row += "]],";
  ANA_MSG_INFO(row);
 
  ANA_MSG_INFO("Finished printing graph inputs for validation...");
}

Member Data Documentation

m_edgeIndices

std::vector<EdgeIndex> EventReco::HyPERGraph::m_edgeIndices = {}

protected

Definition at line 49 of file HyPERGraph.h.

{};

m_edges

std::vector<Edge> EventReco::GraphBase::m_edges

protectedinherited

Definition at line 95 of file GraphBase.h.

m_global

Global EventReco::GraphBase::m_global

protectedinherited

Definition at line 93 of file GraphBase.h.

m_hyperEdgeIndices

std::vector<HyperEdgeIndex> EventReco::HyPERGraph::m_hyperEdgeIndices = {}

protected

Definition at line 50 of file HyPERGraph.h.

{};

m_hyperEdgeOrder

int64_t EventReco::HyPERGraph::m_hyperEdgeOrder = 0

protected

Definition at line 52 of file HyPERGraph.h.

m_nEdges

int64_t EventReco::GraphBase::m_nEdges = 0

protectedinherited

Definition at line 97 of file GraphBase.h.

m_nHyperEdges

int64_t EventReco::HyPERGraph::m_nHyperEdges = 0

protected

Definition at line 51 of file HyPERGraph.h.

m_nNodes

int64_t EventReco::GraphBase::m_nNodes = 0

protectedinherited

Definition at line 96 of file GraphBase.h.

m_nodes

std::vector<Node> EventReco::GraphBase::m_nodes

protectedinherited

Definition at line 94 of file GraphBase.h.

---

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

• HyPERGraph.h
• HyPERGraph.cxx