WireCell::RayGrid::Solving Class Reference

#include <RaySolving.h>

Classes
struct	node_t

Public Types
typedef size_t	ident_t
typedef boost::adjacency_list< boost::vecS, boost::vecS, boost::undirectedS, node_t >	graph_t
typedef boost::graph_traits< graph_t >::vertex_descriptor	vertex_t
typedef std::unordered_map< ident_t, float >	solution_t

Public Member Functions
	Solving ()=default
	~Solving ()=default
void	add (const Grouping::clusterset_t &cset)
solution_t	solve ()
graph_t &	graph ()

Private Member Functions
vertex_t	measurement_node (float value, float weight)
vertex_t	source_node (ident_t sid, float value, float weight)
void	solve_one (solution_t &answer, const std::vector< vertex_t > &sources, const std::vector< vertex_t > &measures)

Private Attributes
graph_t	m_graph
std::unordered_map< ident_t, vertex_t >	m_sid2vtx

Detailed Description

Definition at line 59 of file RaySolving.h.

Member Typedef Documentation

typedef boost::adjacency_list<boost::vecS, boost::vecS, boost::undirectedS, node_t> WireCell::RayGrid::Solving::graph_t

Definition at line 71 of file RaySolving.h.

typedef size_t WireCell::RayGrid::Solving::ident_t

Definition at line 64 of file RaySolving.h.

typedef std::unordered_map<ident_t, float> WireCell::RayGrid::Solving::solution_t

Definition at line 78 of file RaySolving.h.

typedef boost::graph_traits<graph_t>::vertex_descriptor WireCell::RayGrid::Solving::vertex_t

Definition at line 72 of file RaySolving.h.

Constructor & Destructor Documentation

WireCell::RayGrid::Solving::Solving ( )

default

WireCell::RayGrid::Solving::~Solving ( )

default

Member Function Documentation

void RayGrid::Solving::add

(

const Grouping::clusterset_t &

cset

)

Definition at line 88 of file RaySolving.cxx.

{
    for (const auto& it : cset) {
        double total_value = 0;
        double total_weight = 0;
        int nms = 0;
        std::vector<vertex_t> snodes;
        for (const auto& node : it.second) {
            if (node.ntype == 'm') {
                total_value += node.value;
                total_weight += node.weight;
                ++nms;
                continue;
            }
            if (node.ntype == 's') {
                auto snode = source_node(node.ident, node.value, node.weight);
                snodes.push_back(snode);
                continue;
            }
            // skip w's
        }
        if (!nms or snodes.empty()) {
            // require at least one measurement and one source.
            continue;
        }
        auto mnode = measurement_node(total_value, total_weight/nms);
        for (auto snode : snodes) {
            boost::add_edge(mnode, snode, m_graph);
        }
    }
}

graph_t& WireCell::RayGrid::Solving::graph ( )

inline

Definition at line 81 of file RaySolving.h.

{ return m_graph; }

RayGrid::Solving::vertex_t RayGrid::Solving::measurement_node ( float  value, float  weight  )

private

Definition at line 78 of file RaySolving.cxx.

{
    vertex_t mnode = boost::add_vertex(m_graph);
    m_graph[mnode].ntype = 'm';
    m_graph[mnode].ident = 0xdeadbeef;
    m_graph[mnode].value = value;
    m_graph[mnode].weight = weight;
    return mnode;
}

RayGrid::Solving::solution_t RayGrid::Solving::solve

(

)

Definition at line 161 of file RaySolving.cxx.

{
    std::unordered_map<vertex_t, int> probs;
    int nprobs = boost::connected_components(m_graph, boost::make_assoc_property_map(probs));


    solution_t answer;
    if (!nprobs) {
        return answer;
    }
    
    struct SMVecs {
        std::vector<vertex_t> sources, measures;
    };
    std::unordered_map<int, SMVecs> smvecs;
    for (auto it : probs) {
        auto vtx = it.first;
        if (m_graph[vtx].ntype == 's') {
            smvecs[it.second].sources.push_back(vtx);
        }
        if (m_graph[vtx].ntype == 'm') {
            smvecs[it.second].measures.push_back(vtx);
        }
    }

    for (auto sit : smvecs) {
        solve_one(answer, sit.second.sources, sit.second.measures);
    }
    return answer;

}

void RayGrid::Solving::solve_one ( solution_t &  answer, const std::vector< vertex_t > &  sources, const std::vector< vertex_t > &  measures  )

private

Definition at line 121 of file RaySolving.cxx.

{
    // convert source nodes and their edge end mnodes to m vector and G matrix
    Ress::vector_t meas = Ress::vector_t::Zero(measures.size());
    Ress::vector_t init = Ress::vector_t::Zero(sources.size());
    Ress::vector_t weight = Ress::vector_t::Zero(sources.size());
    Ress::matrix_t geom = Ress::matrix_t::Zero(measures.size(), sources.size());
    std::unordered_map<vertex_t, size_t> sv2ind, mv2ind;
    for (size_t mind=0; mind<measures.size(); ++mind) {
        vertex_t mvtx = measures[mind];
        mv2ind[mvtx] = mind;
        meas(mind) = m_graph[mvtx].value;
    }
    for (size_t sind=0; sind<sources.size(); ++sind) {
        vertex_t svtx = sources[sind];
        sv2ind[svtx] = sind;
        init(sind) = m_graph[svtx].value;
        weight(sind) = m_graph[svtx].weight;
        auto medges = boost::out_edges(svtx, m_graph);
        for (auto mit = medges.first; mit != medges.second; ++mit) {
            auto mvtx = target(*mit, m_graph);
            size_t mind = mv2ind[mvtx];
            geom(mind, sind) = 1.0;
        }
        // fixme: this ignores measurement weights.
    }

    Ress::Params params;
    params.model = Ress::lasso;
    Ress::vector_t solved = Ress::solve(geom, meas, params, init, weight);
    for (int sind = 0; sind < solved.size(); ++sind) {
        auto svtx = sources[sind];
        m_graph[svtx].value = solved[sind];
        answer[m_graph[svtx].ident] = solved[sind];
    }
}

RayGrid::Solving::vertex_t RayGrid::Solving::source_node ( ident_t  sid, float  value, float  weight  )

private

Definition at line 63 of file RaySolving.cxx.

{
    auto it = m_sid2vtx.find(sid);
    if (it != m_sid2vtx.end()) {
        return it->second;
    }
    vertex_t snode = boost::add_vertex(m_graph);
    m_sid2vtx[sid] = snode;
    m_graph[snode].ntype = 's';
    m_graph[snode].ident = sid;
    m_graph[snode].value = value;
    m_graph[snode].weight = weight;
    return snode;
}

Member Data Documentation

graph_t WireCell::RayGrid::Solving::m_graph

private

Definition at line 85 of file RaySolving.h.

std::unordered_map<ident_t, vertex_t> WireCell::RayGrid::Solving::m_sid2vtx

private

Definition at line 86 of file RaySolving.h.

---

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

• wire-cell-build/util/inc/WireCellUtil/RaySolving.h
• wire-cell-build/util/src/RaySolving.cxx