lar_content::LArGraph Class Reference

LArGraph class. More...

#include "LArGraph.h"

Classes
class	Edge

Public Types
typedef std::vector< const Edge * >	EdgeVector

Public Member Functions
	LArGraph (const bool fullyConnect=true, const int nSourceEdges=2, const float maxSecondaryCosine=0.996f, const float maxSecondaryDistance=3.f)
	Constructor. More...
	~LArGraph ()
	Destructor. More...
const EdgeVector &	GetEdges () const
	Retrieve the edges for this graph. More...
void	MakeGraph (const pandora::CaloHitList &caloHitList)
	Construct a graph from a list of calo hits. More...
void	Walk (const pandora::CaloHit *const pCaloHit, const HitEdgeMap &hitToEdgesMap, pandora::CaloHitList &graph, HitUseMap &connectedHits) const
	Walk along node edges to define a connected graph. More...

Private Types
typedef std::map< const pandora::CaloHit *, EdgeVector >	HitEdgeMap
typedef std::map< const pandora::CaloHit *, pandora::CaloHitList >	HitConnectionsMap
typedef std::map< const pandora::CaloHit *, bool >	HitUseMap

Private Member Functions
void	IdentifyDisconnectedRegions (const HitEdgeMap &hitToEdgesMap, HitConnectionsMap &graphs) const
	Identify the different disconnected sub graphs in a set of eges. More...
void	ConnectRegions (const HitConnectionsMap &graphs, HitEdgeMap &hitToEdgesMap)
	Identify the different disconnected sub graphs in a set of eges. More...
void	Vectorize (const pandora::CaloHitList &caloHitList, Eigen::MatrixXf &hitMatrix) const
	Convert a list of calo hits into an Eigen matrix. More...

Private Attributes
EdgeVector	m_edges
	The edges defining the graph. More...
bool	m_fullyConnect
	Whether or not to connect any disconnected regions. More...
int	m_nSourceEdges
	The number of edges to consider emerging from a source. More...
float	m_maxSecondaryCosine
	The number of edges to consider emerging from a source. More...
float	m_maxSecondaryDistance
	The number of edges to consider emerging from a source. More...

Detailed Description

LArGraph class.

Definition at line 21 of file LArGraph.h.

Member Typedef Documentation

typedef std::vector<const Edge *> lar_content::LArGraph::EdgeVector

Definition at line 57 of file LArGraph.h.

typedef std::map<const pandora::CaloHit *, pandora::CaloHitList> lar_content::LArGraph::HitConnectionsMap

private

Definition at line 61 of file LArGraph.h.

typedef std::map<const pandora::CaloHit *, EdgeVector> lar_content::LArGraph::HitEdgeMap

private

Definition at line 60 of file LArGraph.h.

typedef std::map<const pandora::CaloHit *, bool> lar_content::LArGraph::HitUseMap

private

Definition at line 62 of file LArGraph.h.

Constructor & Destructor Documentation

lar_content::LArGraph::LArGraph	(	const bool	fullyConnect = true,
		const int	nSourceEdges = 2,
		const float	maxSecondaryCosine = 0.996f,
		const float	maxSecondaryDistance = 3.f
	)

Constructor.

Parameters

fullyConnect	Whether or not to connect disconnected regions
nSourceEdges	The number of edges emerging from a source node
maxSecondaryCosine	The maximum cosine of the opening angle between non-primary edges with the same source hit
maxSecondaryDistance	The maximum distance for a non-primary edge between hits

Definition at line 20 of file LArGraph.cc.

References m_maxSecondaryCosine, m_maxSecondaryDistance, and m_nSourceEdges.

                                                                                                                                    :
    m_fullyConnect{fullyConnect},
    m_nSourceEdges{nSourceEdges},
    m_maxSecondaryCosine{maxSecondaryCosine},
    m_maxSecondaryDistance{maxSecondaryDistance}
{
}

lar_content::LArGraph::~LArGraph

(

)

Destructor.

Definition at line 30 of file LArGraph.cc.

References m_edges.

{
    for (const Edge *pEdge : m_edges)
        delete pEdge;
}

Member Function Documentation

void lar_content::LArGraph::ConnectRegions ( const HitConnectionsMap &  graphs, HitEdgeMap &  hitToEdgesMap  )

private

Identify the different disconnected sub graphs in a set of eges.

Parameters

graphs	the map between a root calo hit and all connected hits
hitToEdgesMap	the (updatable) map from calo hits to edges

Definition at line 174 of file LArGraph.cc.

References lar::dump::array(), util::begin(), util::end(), m_edges, and Vectorize().

Referenced by MakeGraph().

{
    std::map<int, std::vector<int>> connectedGraphMap;
    int i{0}, idx1{0}, idx2{0};
    for (const auto &[pCaloHit1, caloHitList1] : graphs)
    {
        ++i;
        Eigen::MatrixXf subGraphMatrix(caloHitList1.size(), 2);
        this->Vectorize(caloHitList1, subGraphMatrix);
        float closestApproach{std::numeric_limits<float>::max()};
        const CaloHit *pClosestHit1{nullptr};
        const CaloHit *pClosestHit2{nullptr};
        int j{0};
        for (const auto &[pCaloHit2, caloHitList2] : graphs)
        {
            ++j;
            auto begin{connectedGraphMap[i].begin()}, end{connectedGraphMap[i].end()};
            if (pCaloHit1 == pCaloHit2 || std::find(begin, end, j) != end)
                continue;
            for (const CaloHit *const pCaloHit : caloHitList2)
            {
                const CartesianVector &pos{pCaloHit->GetPositionVector()};
                Eigen::RowVectorXf row(2);
                row << pos.GetX(), pos.GetZ();
                Eigen::MatrixXf norms((subGraphMatrix.rowwise() - row).array().pow(2).rowwise().sum());
                Eigen::Index index;
                float val{norms.col(0).minCoeff(&index)};
                if (val < closestApproach)
                {
                    auto iter{caloHitList1.begin()};
                    std::advance(iter, index);
                    pClosestHit1 = *iter;
                    pClosestHit2 = pCaloHit;
                    closestApproach = val;
                    idx1 = i;
                    idx2 = j;
                }
            }
        }
        if (pClosestHit1 && pClosestHit2)
        {
            const Edge *pEdge{new Edge(pClosestHit1, pClosestHit2)};
            this->m_edges.emplace_back(pEdge);
            hitToEdgesMap[pEdge->m_v0].emplace_back(pEdge);
            hitToEdgesMap[pEdge->m_v1].emplace_back(pEdge);
            connectedGraphMap[idx1].emplace_back(idx2);
            connectedGraphMap[idx2].emplace_back(idx1);
        }
    }
}

const LArGraph::EdgeVector & lar_content::LArGraph::GetEdges

(

)

const

Retrieve the edges for this graph.

Returns

The edges for this graph

Definition at line 38 of file LArGraph.cc.

References m_edges.

{
    return this->m_edges;
}

void lar_content::LArGraph::IdentifyDisconnectedRegions ( const HitEdgeMap &  hitToEdgesMap, HitConnectionsMap &  graphs  ) const

private

Identify the different disconnected sub graphs in a set of eges.

Parameters

hitToEdgesMap	the input maps from calo hits to edges
graphs	the output map between a root calo hit and all connected hits

Definition at line 153 of file LArGraph.cc.

References Walk().

Referenced by MakeGraph().

{
    HitUseMap connectedHits;
    for (const auto &[pCaloHit, assocEdges] : hitToEdgesMap)
    {
        if (connectedHits.find(pCaloHit) != connectedHits.end())
            continue;
        graphs[pCaloHit] = CaloHitList{pCaloHit};
        connectedHits[pCaloHit] = true;
        for (const Edge *const edge : assocEdges)
        {
            if (pCaloHit == edge->m_v0)
                this->Walk(edge->m_v1, hitToEdgesMap, graphs[pCaloHit], connectedHits);
            else
                this->Walk(edge->m_v0, hitToEdgesMap, graphs[pCaloHit], connectedHits);
        }
    }
}

void lar_content::LArGraph::MakeGraph

(

const pandora::CaloHitList &

caloHitList

)

Construct a graph from a list of calo hits.

Parameters

caloHitList

the calo hit list containing the hits from which to construct a graph

Definition at line 45 of file LArGraph.cc.

References lar::dump::array(), ConnectRegions(), IdentifyDisconnectedRegions(), m_edges, m_fullyConnect, m_maxSecondaryCosine, m_maxSecondaryDistance, m_nSourceEdges, fhicl::other, r, and Vectorize().

{
    Eigen::MatrixXf hitMatrix(caloHitList.size(), 2);
    this->Vectorize(caloHitList, hitMatrix);
    // Edges can be double-counted, so use map of maps to avoid this
    std::map<const CaloHit *, std::map<const CaloHit *, bool>> edgeMap;
    for (int r = 0; r < hitMatrix.rows(); ++r)
    {
        Eigen::RowVectorXf row(2);
        row << hitMatrix(r, 0), hitMatrix(r, 1);
        Eigen::MatrixXf norms((hitMatrix.rowwise() - row).array().pow(2).rowwise().sum());
        norms(r, 0) = std::numeric_limits<float>::max();
        Eigen::Index index;
        norms.col(0).minCoeff(&index);
        auto iter0{caloHitList.begin()};
        std::advance(iter0, r);
        auto iter1{caloHitList.begin()};
        std::advance(iter1, index);
        edgeMap[*iter0][*iter1] = true;
        edgeMap[*iter1][*iter0] = true;
        norms(index, 0) = std::numeric_limits<float>::max();
        // Create a limited number of additional edges within a maximum distance and avoiding colinearity with existing edges
        int nEdges{1};
        CartesianPointVector sourceEdges({((*iter1)->GetPositionVector() - (*iter0)->GetPositionVector()).GetUnitVector()});
        for (int i = 1; i <= std::min(2 * this->m_nSourceEdges, 5 + this->m_nSourceEdges); ++i)
        {
            if (nEdges >= this->m_nSourceEdges)
                break;
            auto val{norms.col(0).minCoeff(&index)};
            if (val > this->m_maxSecondaryDistance)
                continue;
            auto iter2{caloHitList.begin()};
            std::advance(iter2, index);
            norms(index, 0) = std::numeric_limits<float>::max();
            const CartesianVector &vec{((*iter2)->GetPositionVector() - (*iter0)->GetPositionVector()).GetUnitVector()};
            bool notColinear{true};
            for (const CartesianVector &other : sourceEdges)
            {
                if (vec.GetDotProduct(other) > m_maxSecondaryCosine)
                {
                    notColinear = false;
                    break;
                }
            }
            if (notColinear)
            {
                sourceEdges.emplace_back(vec);
                edgeMap[*iter0][*iter2] = true;
                edgeMap[*iter2][*iter0] = true;
                ++nEdges;
            }
        }
    }
    std::map<const CaloHit *, std::map<const CaloHit *, bool>> usedEdges;
    for (const auto &[pCaloHit1, map] : edgeMap)
    {
        for (const auto &[pCaloHit2, dummy] : map)
        {
            if (usedEdges.find(pCaloHit1) != usedEdges.end())
            {
                std::map<const CaloHit *, bool> &innerMap{usedEdges[pCaloHit1]};
                if (innerMap.find(pCaloHit2) != innerMap.end())
                    continue;
            }
            usedEdges[pCaloHit1][pCaloHit2] = true;
            usedEdges[pCaloHit2][pCaloHit1] = true;
            this->m_edges.emplace_back(new Edge(pCaloHit1, pCaloHit2));
        }
    }
    if (m_fullyConnect)
    {
        HitEdgeMap hitToEdgesMap;
        for (const Edge *const pEdge : this->m_edges)
        {
            hitToEdgesMap[pEdge->m_v0].emplace_back(pEdge);
            hitToEdgesMap[pEdge->m_v1].emplace_back(pEdge);
        }
        HitConnectionsMap graphs;
        this->IdentifyDisconnectedRegions(hitToEdgesMap, graphs);
        while (graphs.size() > 1)
        {
            this->ConnectRegions(graphs, hitToEdgesMap);
            graphs.clear();
            this->IdentifyDisconnectedRegions(hitToEdgesMap, graphs);
        }
    }
}

void lar_content::LArGraph::Vectorize ( const pandora::CaloHitList &  caloHitList, Eigen::MatrixXf &  hitMatrix  ) const

private

Convert a list of calo hits into an Eigen matrix.

Parameters

caloHitList	the calo hit list containing the hits from which to construct a graph
hitMatrix	the output Eigen matrix

Definition at line 227 of file LArGraph.cc.

Referenced by ConnectRegions(), and MakeGraph().

{
    int i{0};
    for (const CaloHit *const pCaloHit : caloHitList)
    {
        const CartesianVector &pos{pCaloHit->GetPositionVector()};
        hitMatrix(i, 0) = pos.GetX();
        hitMatrix(i, 1) = pos.GetZ();
        ++i;
    }
}

void lar_content::LArGraph::Walk	(	const pandora::CaloHit *const	pCaloHit,
		const HitEdgeMap &	hitToEdgesMap,
		pandora::CaloHitList &	graph,
		HitUseMap &	connectedHits
	)		const

Walk along node edges to define a connected graph.

Parameters

pCaloHit	the root calo hit of the current subgraph
hitToEdgesMap	the map of hits to the edges for which they are a vertex
graph	the current graph to be augmented
connectedHits	the map of hits in use

Definition at line 135 of file LArGraph.cc.

Referenced by IdentifyDisconnectedRegions().

{
    if (connectedHits.find(pRootCaloHit) != connectedHits.end())
        return;
    graph.emplace_back(pRootCaloHit);
    connectedHits[pRootCaloHit] = true;
    const EdgeVector &assocEdges{hitToEdgesMap.at(pRootCaloHit)};
    for (const Edge *const edge : assocEdges)
    {
        if (pRootCaloHit == edge->m_v0)
            this->Walk(edge->m_v1, hitToEdgesMap, graph, connectedHits);
        else
            this->Walk(edge->m_v0, hitToEdgesMap, graph, connectedHits);
    }
}

Member Data Documentation

EdgeVector lar_content::LArGraph::m_edges

private

The edges defining the graph.

Definition at line 129 of file LArGraph.h.

Referenced by ConnectRegions(), GetEdges(), MakeGraph(), and ~LArGraph().

bool lar_content::LArGraph::m_fullyConnect

private

Whether or not to connect any disconnected regions.

Definition at line 130 of file LArGraph.h.

Referenced by MakeGraph().

float lar_content::LArGraph::m_maxSecondaryCosine

private

The number of edges to consider emerging from a source.

Definition at line 132 of file LArGraph.h.

Referenced by LArGraph(), and MakeGraph().

float lar_content::LArGraph::m_maxSecondaryDistance

private

The number of edges to consider emerging from a source.

Definition at line 133 of file LArGraph.h.

Referenced by LArGraph(), and MakeGraph().

int lar_content::LArGraph::m_nSourceEdges

private

The number of edges to consider emerging from a source.

Definition at line 131 of file LArGraph.h.

Referenced by LArGraph(), and MakeGraph().

---

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

• larpandoracontent/v04_08_01/source/larpandoracontent/LArObjects/LArGraph.h
• larpandoracontent/v04_08_01/source/larpandoracontent/LArObjects/LArGraph.cc