WireCell::Img::GridTiling Class Reference

#include <GridTiling.h>

Inheritance diagram for WireCell::Img::GridTiling:

Public Member Functions
	GridTiling ()
virtual	~GridTiling ()
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 &slice, output_pointer &blobset)
	The calling signature: More...
Public Member Functions inherited from WireCell::ITiling
virtual	~ITiling ()
virtual std::string	signature ()
	Set the signature for all subclasses. More...
Public Member Functions inherited from WireCell::IFunctionNode< ISlice, IBlobSet >
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_blobs_seen
IAnodePlane::pointer	m_anode
IAnodeFace::pointer	m_face
double	m_threshold
Log::logptr_t	l

Additional Inherited Members
Public Types inherited from WireCell::ITiling
typedef std::shared_ptr< ITiling >	pointer
Public Types inherited from WireCell::IFunctionNode< ISlice, IBlobSet >
typedef ISlice	input_type
typedef IBlobSet	output_type
typedef std::shared_ptr< const ISlice >	input_pointer
typedef std::shared_ptr< const IBlobSet >	output_pointer
typedef IFunctionNode< ISlice, IBlobSet >	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 26 of file GridTiling.h.

Constructor & Destructor Documentation

Img::GridTiling::GridTiling

(

)

Definition at line 14 of file GridTiling.cxx.

    : m_blobs_seen(0)
    , m_threshold(0.0)
    , l(Log::logger("img"))
{
}

Img::GridTiling::~GridTiling ( )

virtual

Definition at line 21 of file GridTiling.cxx.

{

}

Member Function Documentation

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

virtual

Accept a configuration.

Implements WireCell::IConfigurable.

Definition at line 26 of file GridTiling.cxx.

{
    m_anode = Factory::find_tn<IAnodePlane>(cfg["anode"].asString());
    m_face = m_anode->face(cfg["face"].asInt());
    m_threshold = get(cfg, "threshold", m_threshold);
}

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

virtual

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

Reimplemented from WireCell::IConfigurable.

Definition at line 33 of file GridTiling.cxx.

{
    Configuration cfg;
    cfg["anode"] = "";          // user must set
    cfg["face"] = 0;            // the face number to focus on
    // activity must be bigger than this much to consider.
    cfg["threshold"] = m_threshold;
    return cfg;
}

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

virtual

The calling signature:

Implements WireCell::IFunctionNode< ISlice, IBlobSet >.

Definition at line 45 of file GridTiling.cxx.

{
    out = nullptr;
    if (!slice) {
        m_blobs_seen = 0;
        SPDLOG_LOGGER_TRACE(l, "GridTiling: EOS");
        return true;            // eos
    }

    const int sbs_ident = slice->ident();
    SimpleBlobSet* sbs = new SimpleBlobSet(sbs_ident, slice);
    out = IBlobSet::pointer(sbs);

    const int nbounds_layers = 2;
    const int nlayers = m_face->nplanes() + nbounds_layers;
    std::vector< std::vector<Activity::value_t> > measures(nlayers);
    measures[0].push_back(1);   // assume first two layers in RayGrid::Coordinates
    measures[1].push_back(1);   // are for horiz/vert bounds

    const auto anodeid = m_anode->ident();
    const auto faceid = m_face->ident();
    auto chvs = slice->activity();
    if (chvs.empty()) {
        SPDLOG_LOGGER_TRACE(l,"GridTiling: anode:{} face:{} slice:{} no activity",
                            anodeid, faceid,  slice->ident());
        return true;
    }

    const int nactivities = slice->activity().size();
    int total_activity=0;
    if (nactivities < m_face->nplanes()) {
        SPDLOG_LOGGER_TRACE(l,"GridTiling: anode:{} face:{} slice:{} too few activities given",
                            anodeid, faceid, slice->ident());
        return true;
    }

    for (const auto& chv : slice->activity()) {
        for (const auto& wire : chv.first->wires()) {
            auto wpid = wire->planeid();
            if (wpid.face() != faceid) {
                //l->trace("anode:{} face:{} slice:{} chan:{} wip:{} q:{} skip {}", anodeid, faceid, slice->ident(), chv.first->ident(), wire->index(), chv.second, wpid);
                continue;
            }
            //l->trace("anode:{} face:{} slice:{} chan:{} wip:{} q:{} keep {}", anodeid, faceid, slice->ident(), chv.first->ident(), wire->index(), chv.second, wpid);
            const int pit_ind = wire->index();
            const int layer = nbounds_layers + wire->planeid().index();
            auto& m = measures[layer];
            if (pit_ind < 0) {
                continue;
            }
            if ((int)m.size() <= pit_ind) {
                m.resize(pit_ind+1, 0.0);
            }
            m[pit_ind] += 1.0;
            ++total_activity;
        }
    }

    if (!total_activity) {
        SPDLOG_LOGGER_TRACE(l,"GridTiling: anode:{} face:{} slice:{} no activity",
                            anodeid, faceid, slice->ident());
        return true;
    }
    size_t nactive_layers = 0;
    for (size_t ind = 0; ind<measures.size(); ++ind) {
        const auto& blah = measures[ind];
        if (blah.empty()) {
            SPDLOG_LOGGER_TRACE(l,"GridTiling: anode:{} face:{} slice:{} empty active layer ind={} out of {}",
                                anodeid, faceid, slice->ident(), ind, measures.size());
            continue;
        }
        ++nactive_layers;
    }
    if (nactive_layers != measures.size()) {
        SPDLOG_LOGGER_TRACE(l,"GridTiling: anode:{} face:{} slice:{} missing active layers {}  != {}, {} activities",
                            anodeid, faceid, slice->ident(), nactive_layers, measures.size(), nactivities);
        return true;
    }

    activities_t activities;
    for (int layer = 0; layer<nlayers; ++layer) {
        auto& m = measures[layer];
        Activity activity(layer, {m.begin(), m.end()}, 0, m_threshold);
        SPDLOG_LOGGER_TRACE(l, "L{} A:{}", layer, activity.as_string());
        activities.push_back(activity);
    }

    SPDLOG_LOGGER_TRACE(l,"GridTiling: anode:{} face:{} slice:{} making blobs",
                        anodeid, faceid, slice->ident());
    auto blobs = make_blobs(m_face->raygrid(), activities);

    const float blob_value = 0.0; // tiling doesn't consider particular charge
    for (const auto& blob : blobs) {
        SimpleBlob* sb = new SimpleBlob(m_blobs_seen++, blob_value, 0.0, blob, slice, m_face);
        sbs->m_blobs.push_back(IBlob::pointer(sb));
    }
    SPDLOG_LOGGER_TRACE(l,"GridTiling: anode:{} face:{} slice:{} found {} blobs",
                        anodeid, faceid, slice->ident(), sbs->m_blobs.size());

    return true;
}

Member Data Documentation

Log::logptr_t WireCell::Img::GridTiling::l

private

Definition at line 42 of file GridTiling.h.

IAnodePlane::pointer WireCell::Img::GridTiling::m_anode

private

Definition at line 39 of file GridTiling.h.

size_t WireCell::Img::GridTiling::m_blobs_seen

private

Definition at line 38 of file GridTiling.h.

IAnodeFace::pointer WireCell::Img::GridTiling::m_face

private

Definition at line 40 of file GridTiling.h.

double WireCell::Img::GridTiling::m_threshold

private

Definition at line 41 of file GridTiling.h.

---

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

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