WireCell::Img::NaiveStriper Class Reference

#include <NaiveStriper.h>

Inheritance diagram for WireCell::Img::NaiveStriper:

Public Member Functions
virtual	~NaiveStriper ()
virtual void	configure (const WireCell::Configuration &cfg)
	Accept a configuration. More...
virtual WireCell::Configuration	default_configuration () const
	Optional, override to return a hard-coded default configuration. More...
virtual bool	operator() (const input_pointer &in, output_pointer &out)
	The calling signature: More...
Public Member Functions inherited from WireCell::ISliceStriper
virtual	~ISliceStriper ()
virtual std::string	signature ()
	Set the signature for all subclasses. More...
Public Member Functions inherited from WireCell::IFunctionNode< ISlice, IStripeSet >
virtual	~IFunctionNode ()
virtual bool	operator() (const boost::any &anyin, boost::any &anyout)
	The calling signature: More...
virtual std::vector< std::string >	input_types ()
virtual std::vector< std::string >	output_types ()
Public Member Functions inherited from WireCell::IFunctionNodeBase
virtual	~IFunctionNodeBase ()
virtual NodeCategory	category ()
	Return the behavior category type. More...
virtual int	concurrency ()
	By default assume all subclasses are stateless. More...
Public Member Functions inherited from WireCell::INode
virtual	~INode ()
virtual void	reset ()
Public Member Functions inherited from WireCell::IComponent< INode >
virtual	~IComponent ()
Public Member Functions inherited from WireCell::Interface
virtual	~Interface ()
Public Member Functions inherited from WireCell::IConfigurable
virtual	~IConfigurable ()
Public Member Functions inherited from WireCell::IComponent< IConfigurable >
virtual	~IComponent ()

Private Attributes
size_t	m_gap

Additional Inherited Members
Public Types inherited from WireCell::ISliceStriper
typedef std::shared_ptr< ISliceStriper >	pointer
Public Types inherited from WireCell::IFunctionNode< ISlice, IStripeSet >
typedef ISlice	input_type
typedef IStripeSet	output_type
typedef std::shared_ptr< const ISlice >	input_pointer
typedef std::shared_ptr< const IStripeSet >	output_pointer
typedef IFunctionNode< ISlice, IStripeSet >	signature_type
Public Types inherited from WireCell::IFunctionNodeBase
typedef std::shared_ptr< IFunctionNodeBase >	pointer
Public Types inherited from WireCell::INode
enum	NodeCategory {   unknown, sourceNode, sinkNode, functionNode,   queuedoutNode, joinNode, splitNode, faninNode,   fanoutNode, multioutNode, hydraNode }
Public Types inherited from WireCell::IComponent< INode >
typedef std::shared_ptr< INode >	pointer
	Access subclass facet by pointer. More...
typedef std::vector< pointer >	vector
	Vector of shared pointers. More...
Public Types inherited from WireCell::Interface
typedef std::shared_ptr< Interface >	pointer
Public Types inherited from WireCell::IComponent< IConfigurable >
typedef std::shared_ptr< IConfigurable >	pointer
	Access subclass facet by pointer. More...
typedef std::vector< pointer >	vector
	Vector of shared pointers. More...

Detailed Description

Definition at line 16 of file NaiveStriper.h.

Constructor & Destructor Documentation

Img::NaiveStriper::~NaiveStriper ( )

virtual

Definition at line 17 of file NaiveStriper.cxx.

{
}

Member Function Documentation

void Img::NaiveStriper::configure ( const WireCell::Configuration &  config )

virtual

Accept a configuration.

Implements WireCell::IConfigurable.

Definition at line 33 of file NaiveStriper.cxx.

{
    m_gap = get(cfg, "gap", 1);
}

WireCell::Configuration Img::NaiveStriper::default_configuration ( ) const

virtual

Optional, override to return a hard-coded default configuration.

Reimplemented from WireCell::IConfigurable.

Definition at line 21 of file NaiveStriper.cxx.

{
    Configuration cfg;

    // The number of intersticial wires which must exist without
    // activity to consider two wires to be non-adjacent.
    cfg["gap"] = 1;

    return cfg;
}

bool Img::NaiveStriper::operator() ( const input_pointer &  in, output_pointer &  out  )

virtual

The calling signature:

Implements WireCell::IFunctionNode< ISlice, IStripeSet >.

Definition at line 39 of file NaiveStriper.cxx.

{
    out = nullptr;
    if (!slice) {
        return true;            // eos
    }

    // The graph connects channels to attached wires and wires to
    // their adjacent neighbor in the plane and along the positive
    // pitch direction.  

    typedef boost::adjacency_list<boost::vecS, boost::vecS, boost::undirectedS> graph_t;
    typedef boost::graph_traits<graph_t>::vertex_descriptor vertex_t;
    graph_t graph;

    // Boost graph uses simple numbers as the "node object".  We could
    // attach vertex properties to nodes to hold either the IWire or
    // the IChannel+charge values or we can keep or own lookup tables.
    // The former is probably faster but for now, we these lookups out
    // in the open.
    std::unordered_map<IWire::pointer, IChannel::pointer> wire_to_chan;
    std::unordered_map<IChannel::pointer, vertex_t> chan_to_node;
    std::unordered_map<vertex_t, ISlice::pair_t> node_to_chanval;
    std::unordered_map<int, IWireIndexSet> hit_wires;

    // Fill channel nodes in graph and group wires by plane 
    for (const auto& cv : slice->activity()) {
        auto ichan = cv.first;
        auto node = boost::add_vertex(graph);
        chan_to_node[ichan] = node;
        node_to_chanval[node] = cv;
        for (auto iwire : ichan->wires()) {
            const auto pid = iwire->planeid();
            hit_wires[pid.ident()].insert(iwire);
            wire_to_chan[iwire] = ichan;
        }
    }

    // Loop over ordered wires per plane and make edges.
    for (const auto& phw : hit_wires) {
        int last_ind = -1;
        vertex_t last_wire = 0;
        for (auto iwire : phw.second) {
            auto ichan = wire_to_chan[iwire];
            vertex_t chan_node = chan_to_node[ichan];
            vertex_t wire_node = boost::add_vertex(graph);
            const int this_index = iwire->index();

            // no matter what, chan->node.
            boost::add_edge(chan_node, wire_node, graph);

            const size_t dind = this_index - last_ind;
            if (last_ind >= 0 and dind <= m_gap) {
                boost::add_edge(last_wire, wire_node, graph);
            }
            last_ind = this_index;
            last_wire = wire_node;
        }
    }

    // Here's the heavy lifing.  Stripes are understood to be formed as
    // the channels found by looking for the "connected subgraphs".
    // Like the graph itself, this neesds some looksup to translate
    // between Boost Graph's subgraph index and a corresponding stripe.
    std::unordered_map<vertex_t, int> subclusters;
    std::unordered_map<int, Img::Data::Stripe*> cluster_to_stripe;
    boost::connected_components(graph, boost::make_assoc_property_map(subclusters));

    // Collect channels of like cluster number into stripes
    for (auto& p : subclusters) {
        auto ncvit = node_to_chanval.find(p.first);
        if (ncvit == node_to_chanval.end()) {
            continue;
        }
        auto& cv = ncvit->second;
        auto stripe = cluster_to_stripe[p.second];
        if (!stripe) {
            cluster_to_stripe[p.second] = stripe = new Img::Data::Stripe(p.first);
        }
        stripe->append(cv.first, cv.second);
    }
    
    auto sliceset = new Img::Data::StripeSet(slice->ident());
    for (auto ss : cluster_to_stripe) {
        sliceset->push_back(IStripe::pointer(ss.second));
    }

    out = IStripeSet::pointer(sliceset);
    return true;
}

Member Data Documentation

size_t WireCell::Img::NaiveStriper::m_gap

private

Definition at line 26 of file NaiveStriper.h.

---

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

• wire-cell-build/img/inc/WireCellImg/NaiveStriper.h
• wire-cell-build/img/src/NaiveStriper.cxx