Network of directed nodes of the type EntryType. More...

#include <DirectedNodeNetwork.h>

Public Member Functions
	DirectedNodeNetwork ()
	*********************** CONSTRUCTOR/DESTRUCTOR ***********************

	~DirectedNodeNetwork ()
	destructor taking care of cleaning up the pointer-mess WARNING only needed when using classic pointers for the nodes!

bool	addNode (NodeID nodeID, EntryType &newEntry)
	*********************** PUBLIC MEMBER FUNCTIONS ***********************

bool	addInnerToLastOuterNode (NodeID innerNodeID)
	to the last outerNode added, another innerNode will be attached

bool	addOuterToLastInnerNode (NodeID outerNodeID)
	to the last innerNode added, another outerNode will be attached

bool	linkNodes (NodeID outerNodeID, NodeID innerNodeID)
	takes two entry IDs and weaves them into the network

bool	isNodeInNetwork (const NodeID nodeID) const
	Check if a given entry is already in the network.

void	clear ()
	Clear directed node network Called to clear the directed node network if its size grows to large.

std::vector< Node * >	getOuterEnds ()
	getters:

std::vector< Node * >	getInnerEnds ()
	returns all nodes which have no inner nodes (but outer ones) and therefore are inner ends of the network

Node *	getNode (NodeID toBeFound)
	Returns pointer to the node carrying the entry which is equal to given parameter.

std::vector< Node * > &	getNodes ()
	Returns all nodes of the network.

std::vector< Node * >::iterator	begin ()
	Returns iterator for container: begin.

std::vector< Node * >::iterator	end ()
	Returns iterator for container: end.

unsigned int	size () const
	Returns number of nodes to be found in the network.

Protected Types
using	Node = DirectedNode< EntryType, MetaInfoType >
	Defining abbreviation for the used directed node type pack.

using	NodeID = std::int64_t
	NodeID should be some unique integer.

Protected Member Functions
void	finalize ()
	Finalizing the NodeNetwork.

Static Protected Member Functions
static bool	createLink (Node &outerNode, Node &innerNode)
	*********************** INTERNAL MEMBER FUNCTIONS ***********************

Protected Attributes
std::unordered_map< NodeID, Node * >	m_nodeMap
	*********************** DATA MEMBERS ***********************

NodeID	m_lastOuterNodeID
	temporal storage for last outer node added, used for speed-up

NodeID	m_lastInnerNodeID
	temporal storage for last inner node added, used for speed-up

bool	m_isFinalized
	keeps track of the state of the network to fill the vectors m_nodes, m_outerEnds, m_innerEnds only if required

std::vector< Node * >	m_nodes
	After the network is finalized this vector will also carry all nodes to be able to keep the old interface.

std::vector< Node * >	m_outerEnds
	keeps track of current outerEnds (nodes which have no outerNodes) entries are the NodeIDs of the nodes which currently form an outermost node

std::vector< Node * >	m_innerEnds
	keeps track of current innerEnds (nodes which have no innerNodes) entries are the NodeIds of the nodes which currently form an innermost node

Detailed Description

template<typename EntryType, typename MetaInfoType>
class Belle2::DirectedNodeNetwork< EntryType, MetaInfoType >

Network of directed nodes of the type EntryType.

Template Parameters

EntryType	: type of the directe nodes
MetaInfoType	: meta info type of the nodes

Definition at line 28 of file DirectedNodeNetwork.h.

Member Typedef Documentation

◆ Node

using Node = DirectedNode<EntryType, MetaInfoType>

protected

Defining abbreviation for the used directed node type pack.

Definition at line 31 of file DirectedNodeNetwork.h.

◆ NodeID

using NodeID = std::int64_t

protected

NodeID should be some unique integer.

Definition at line 33 of file DirectedNodeNetwork.h.

Constructor & Destructor Documentation

◆ DirectedNodeNetwork()

DirectedNodeNetwork ( )

inline

************************* CONSTRUCTOR/DESTRUCTOR *************************

Constructor

Definition at line 38 of file DirectedNodeNetwork.h.

                          :
      m_lastOuterNodeID(),
      m_lastInnerNodeID(),
      m_isFinalized(false)
    {
      m_nodeMap.reserve(40000);
      m_nodes.reserve(40000);
    }

◆ ~DirectedNodeNetwork()

~DirectedNodeNetwork ( )

inline

destructor taking care of cleaning up the pointer-mess WARNING only needed when using classic pointers for the nodes!

Definition at line 50 of file DirectedNodeNetwork.h.

    {
      for (auto nodePointer : m_nodeMap) {
        delete nodePointer.second;
      }
      m_nodeMap.clear();
    }

Member Function Documentation

◆ addInnerToLastOuterNode()

bool addInnerToLastOuterNode ( NodeID innerNodeID )

inline

to the last outerNode added, another innerNode will be attached

Definition at line 75 of file DirectedNodeNetwork.h.

    {
      // check if entry does not exist, constructed with ID=-1
      if (m_lastOuterNodeID < 0) {
        B2WARNING("Last OuterNode is not yet in this network! CurrentNetworkSize is: " << size());
        return false;
      }
      // check if entries are identical (catch loops):
      if (m_lastOuterNodeID == innerNodeID) {
        B2WARNING("LastOuterNode and innerEntry are identical! Skipping linking-process");
        return false;
      }
 
      if (linkNodes(m_lastOuterNodeID, innerNodeID)) {
        return true;
      }
      B2WARNING("Last OuterNode and innerEntry were already in the network and were already connected."
                "This is a sign for unintended behavior!");
      return false;
    }

◆ addNode()

bool addNode	(	NodeID	nodeID,
		EntryType &	newEntry
	)

inline

************************* PUBLIC MEMBER FUNCTIONS *************************

Adding new node to nodeMap, if the nodeID is not already present in the nodeMap. Returns true if new node was added.

Definition at line 62 of file DirectedNodeNetwork.h.

    {
      if (m_nodeMap.count(nodeID) == 0) {
        // cppcheck-suppress stlFindInsert
        m_nodeMap.emplace(nodeID, new Node(newEntry));
        m_isFinalized = false;
        return true;
      }
      return false;
    }

◆ addOuterToLastInnerNode()

bool addOuterToLastInnerNode ( NodeID outerNodeID )

inline

to the last innerNode added, another outerNode will be attached

Definition at line 98 of file DirectedNodeNetwork.h.

    {
      // check if entry does not exist, constructed with ID=-1
      if (m_lastInnerNodeID < 0) {
        B2WARNING("Last InnerNode is not yet in this network! CurrentNetworkSize is: " << size());
        return false;
      }
      // check if entries are identical (catch loops):
      if (outerNodeID == m_lastInnerNodeID) {
        B2WARNING("OuterEntry and lastInnerNode are identical! Skipping linking-process");
        return false;
      }
 
      if (linkNodes(outerNodeID, m_lastInnerNodeID)) {
        return true;
      }
 
      B2WARNING("Last InnerNode and outerEntry were already in the network and were already connected."
                "This is a sign for unintended behavior!");
      return false;
    }

◆ begin()

std::vector< Node * >::iterator begin ( )

inline

Returns iterator for container: begin.

Definition at line 199 of file DirectedNodeNetwork.h.

    {
      if (!m_isFinalized) finalize();
      return m_nodes.begin();
    }

◆ clear()

void clear ( )

inline

Clear directed node network Called to clear the directed node network if its size grows to large.

This is necessary to prevent to following modules from processing events with only partly filled networks.

Definition at line 153 of file DirectedNodeNetwork.h.

    {
      m_nodes.clear();
      // Clearing the unordered_map is important as the following modules will process the event
      // if it still contains entries.
      for (auto nodePointer : m_nodeMap) {
        delete nodePointer.second;
      }
      m_nodeMap.clear();
    }

◆ createLink()

static bool createLink	(	Node &	outerNode,
		Node &	innerNode
	)

inlinestaticprotected

************************* INTERNAL MEMBER FUNCTIONS *************************

links nodes with each other. returns true if everything went well, returns false, if not

Definition at line 221 of file DirectedNodeNetwork.h.

    {
      // not successful if one of them was already added to the other one:
      if (std::find(outerNode.getInnerNodes().begin(), outerNode.getInnerNodes().end(), &innerNode) != outerNode.getInnerNodes().end()) {
        return false;
      }
      if (std::find(innerNode.getOuterNodes().begin(), innerNode.getOuterNodes().end(), &outerNode) != innerNode.getOuterNodes().end()) {
        return false;
      }
 
      outerNode.addInnerNode(innerNode);
      innerNode.addOuterNode(outerNode);
      return true;
    }

◆ end()

std::vector< Node * >::iterator end ( )

inline

Returns iterator for container: end.

Definition at line 207 of file DirectedNodeNetwork.h.

    {
      if (!m_isFinalized) finalize();
      return m_nodes.end();
    }

◆ finalize()

void finalize ( )

inlineprotected

Finalizing the NodeNetwork.

Definition at line 237 of file DirectedNodeNetwork.h.

    {
      if (m_isFinalized) return;
      m_nodes.clear();
      m_nodes.reserve(m_nodeMap.size());
      m_innerEnds.clear();
      m_outerEnds.clear();
      for (const auto& item : m_nodeMap) {
        m_nodes.push_back(item.second);
        if (item.second->getInnerNodes().empty()) m_innerEnds.push_back(item.second);
        if (item.second->getOuterNodes().empty()) m_outerEnds.push_back(item.second);
      }
      m_isFinalized = true;
    }

◆ getInnerEnds()

std::vector< Node * > getInnerEnds ( )

inline

returns all nodes which have no inner nodes (but outer ones) and therefore are inner ends of the network

Definition at line 175 of file DirectedNodeNetwork.h.

    {
      if (!m_isFinalized) finalize();
      return m_innerEnds;
    }

◆ getNode()

Node * getNode ( NodeID toBeFound )

inline

Returns pointer to the node carrying the entry which is equal to given parameter.

If no fitting entry was found, nullptr is returned.

Definition at line 184 of file DirectedNodeNetwork.h.

    {
      if (m_nodeMap.count(toBeFound)) return m_nodeMap.at(toBeFound);
      else return nullptr;
    }

◆ getNodes()

std::vector< Node * > & getNodes ( )

inline

Returns all nodes of the network.

Definition at line 191 of file DirectedNodeNetwork.h.

    {
      if (!m_isFinalized) finalize();
      return m_nodes;
    }

◆ getOuterEnds()

std::vector< Node * > getOuterEnds ( )

inline

getters:

returns all nodes which have no outer nodes (but inner ones) and therefore are outer ends of the network

Definition at line 167 of file DirectedNodeNetwork.h.

    {
      if (!m_isFinalized) finalize();
      return m_outerEnds;
    }

◆ isNodeInNetwork()

bool isNodeInNetwork ( const NodeID nodeID ) const

inline

Check if a given entry is already in the network.

Definition at line 143 of file DirectedNodeNetwork.h.

    {
      return m_nodeMap.count(nodeID);
    }

◆ linkNodes()

bool linkNodes	(	NodeID	outerNodeID,
		NodeID	innerNodeID
	)

inline

takes two entry IDs and weaves them into the network

Definition at line 122 of file DirectedNodeNetwork.h.

    {
      m_isFinalized = false;
      // check if entries are identical (catch loops):
      if (outerNodeID == innerNodeID) {
        B2WARNING("OuterNodeID and innerNodeID are identical! Skipping linking-process");
        return false;
      }
      if (m_nodeMap.count(innerNodeID) == 0 or m_nodeMap.count(outerNodeID) == 0) {
        B2WARNING("Trying to link Nodes that are not present yet");
        return false;
      }
 
      m_lastOuterNodeID = outerNodeID;
      m_lastInnerNodeID = innerNodeID;
 
      return createLink(*(m_nodeMap[outerNodeID]), *(m_nodeMap[innerNodeID]));
    }

◆ size()

unsigned int size ( ) const

inline

Returns number of nodes to be found in the network.

Definition at line 215 of file DirectedNodeNetwork.h.

215{ return m_nodeMap.size(); }

Member Data Documentation

◆ m_innerEnds

std::vector<Node*> m_innerEnds

protected

keeps track of current innerEnds (nodes which have no innerNodes) entries are the NodeIds of the nodes which currently form an innermost node

Definition at line 276 of file DirectedNodeNetwork.h.

◆ m_isFinalized

bool m_isFinalized

protected

keeps track of the state of the network to fill the vectors m_nodes, m_outerEnds, m_innerEnds only if required

Definition at line 263 of file DirectedNodeNetwork.h.

◆ m_lastInnerNodeID

NodeID m_lastInnerNodeID

protected

temporal storage for last inner node added, used for speed-up

Definition at line 260 of file DirectedNodeNetwork.h.

◆ m_lastOuterNodeID

NodeID m_lastOuterNodeID

protected

temporal storage for last outer node added, used for speed-up

Definition at line 257 of file DirectedNodeNetwork.h.

◆ m_nodeMap

std::unordered_map<NodeID, Node*> m_nodeMap

protected

************************* DATA MEMBERS *************************

carries all nodes

Definition at line 254 of file DirectedNodeNetwork.h.

◆ m_nodes

std::vector<Node*> m_nodes

protected

After the network is finalized this vector will also carry all nodes to be able to keep the old interface.

This shouldn't affect the performance drastically in comparison to directly accessing the nodeMap.

Definition at line 268 of file DirectedNodeNetwork.h.

◆ m_outerEnds

std::vector<Node*> m_outerEnds

protected

keeps track of current outerEnds (nodes which have no outerNodes) entries are the NodeIDs of the nodes which currently form an outermost node

Definition at line 272 of file DirectedNodeNetwork.h.

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

tracking/trackFindingVXD/segmentNetwork/include/DirectedNodeNetwork.h

Public Member Functions

Protected Types

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Detailed Description

Member Typedef Documentation

◆ Node

◆ NodeID

Constructor & Destructor Documentation

◆ DirectedNodeNetwork()

◆ ~DirectedNodeNetwork()

Member Function Documentation

◆ addInnerToLastOuterNode()

◆ addNode()

◆ addOuterToLastInnerNode()

◆ begin()

◆ clear()

◆ createLink()

◆ end()

◆ finalize()

◆ getInnerEnds()

◆ getNode()

◆ getNodes()

◆ getOuterEnds()

◆ isNodeInNetwork()

◆ linkNodes()

◆ size()

Member Data Documentation

◆ m_innerEnds

◆ m_isFinalized

◆ m_lastInnerNodeID

◆ m_lastOuterNodeID

◆ m_nodeMap

◆ m_nodes

◆ m_outerEnds