WireCell::Gen::FrameFanin Class Reference

#include <FrameFanin.h>

Inheritance diagram for WireCell::Gen::FrameFanin:

Public Member Functions
	FrameFanin (size_t multiplicity=2)
virtual	~FrameFanin ()
virtual std::vector< std::string >	input_types ()
virtual bool	operator() (const input_vector &invec, output_pointer &out)
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...
Public Member Functions inherited from WireCell::IFrameFanin
virtual	~IFrameFanin ()
virtual std::string	signature ()
Public Member Functions inherited from WireCell::IFaninNode< IFrame, IFrame, 0 >
virtual	~IFaninNode ()
virtual bool	operator() (const any_vector &anyv, boost::any &anyout)
	The calling signature: More...
virtual std::vector< std::string >	output_types ()
Public Member Functions inherited from WireCell::IFaninNodeBase
virtual	~IFaninNodeBase ()
virtual NodeCategory	category ()
	Return the behavior category type. More...
virtual int	concurrency ()
	Fanin nodes can usually do their thing 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_multiplicity
std::vector< std::string >	m_tags
tagrules::Context	m_ft

Additional Inherited Members
Public Types inherited from WireCell::IFaninNode< IFrame, IFrame, 0 >
typedef IFrame	input_type
typedef IFrame	output_type
typedef std::shared_ptr< const IFrame >	input_pointer
typedef std::shared_ptr< const IFrame >	output_pointer
typedef std::vector< input_pointer >	input_vector
Public Types inherited from WireCell::IFaninNodeBase
typedef std::shared_ptr< IFaninNodeBase >	pointer
typedef std::vector< boost::any >	any_vector
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 15 of file FrameFanin.h.

Constructor & Destructor Documentation

Gen::FrameFanin::FrameFanin

(

size_t

multiplicity = 2

)

Definition at line 15 of file FrameFanin.cxx.

    : m_multiplicity(multiplicity)
{
}

Gen::FrameFanin::~FrameFanin ( )

virtual

Definition at line 19 of file FrameFanin.cxx.

{
}

Member Function Documentation

void Gen::FrameFanin::configure ( const WireCell::Configuration &  config )

virtual

Accept a configuration.

Implements WireCell::IConfigurable.

Definition at line 44 of file FrameFanin.cxx.

{
    int m = get<int>(cfg, "multiplicity", (int)m_multiplicity);
    if (m<=0) {
        THROW(ValueError() << errmsg{"FrameFanin multiplicity must be positive"});
    }
    m_multiplicity = m;
    m_tags.resize(m);

    // Tag entire input frame worth of traces in the output frame.
    auto jtags = cfg["tags"];   
    for (int ind=0; ind<m; ++ind) {
        m_tags[ind] = convert<std::string>(jtags[ind], "");
    }

    // frame/trace tagging at the port level
    m_ft.configure(cfg["tag_rules"]);
}

WireCell::Configuration Gen::FrameFanin::default_configuration ( ) const

virtual

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

Reimplemented from WireCell::IConfigurable.

Definition at line 23 of file FrameFanin.cxx.

{
    Configuration cfg;
    cfg["multiplicity"] = (int)m_multiplicity;

    // A non-null entry in this array is taken as a string and used to
    // tag traces which arrive on the corresponding input port when
    // they are placed to the output frame.  This creates a tagged
    // subset of output traces corresponding to the entire set of 
    // traces in the input frame from the associated port.
    cfg["tags"] = Json::arrayValue; 

    // Tag rules are an array, one element per input port.  Each
    // element is an object keyed with "frame" or "trace".  Each of
    // their values are an object keyed by a regular expression
    // (regex) and with values that are a single tag or an array of
    // tags. See util/test_tagrules for examples.
    cfg["tag_rules"] = Json::arrayValue;

    return cfg;
}

std::vector< std::string > Gen::FrameFanin::input_types ( )

virtual

Implements WireCell::IFrameFanin.

Definition at line 64 of file FrameFanin.cxx.

{
    const std::string tname = std::string(typeid(input_type).name());
    std::vector<std::string> ret(m_multiplicity, tname);
    return ret;

}

bool Gen::FrameFanin::operator() ( const input_vector &  invec, output_pointer &  out  )

virtual

Implements WireCell::IFaninNode< IFrame, IFrame, 0 >.

Definition at line 72 of file FrameFanin.cxx.

{
    out = nullptr;
    size_t neos = 0;
    for (const auto& fr : invec) {
        if (!fr) {
            ++neos;
        }
    }
    if (neos == invec.size()) {
        return true;
    }
    if (neos) {
        std::cerr << "Gen::FrameFanin: " << neos << " input frames missing\n";
    }

    if (invec.size() != m_multiplicity) {
        std::cerr << "Gen::FrameFanin: got unexpected multiplicity, got:"
                  << invec.size() << " want:" << m_multiplicity << std::endl;
        THROW(ValueError() << errmsg{"unexpected multiplicity"});
    }


    std::vector<IFrame::trace_list_t> by_port(m_multiplicity);

    // ...
    std::vector< std::tuple<tagrules::tag_t, IFrame::trace_list_t, IFrame::trace_summary_t> > stash;

    tagrules::tagset_t fouttags;
    ITrace::vector out_traces;
    IFrame::pointer one = nullptr;
    for (size_t iport=0; iport < m_multiplicity; ++iport) {
        const size_t trace_offset = out_traces.size();

        const auto& fr = invec[iport];
        if (!one) { one = fr; }
        auto traces = fr->traces();

        { // collect output frame tags by tranforming each input frame
          // tag based on user rules.
            auto fintags = fr->frame_tags();
            fintags.push_back("");
            auto fo = m_ft.transform(iport, "frame", fintags);
            fouttags.insert(fo.begin(), fo.end());
        }

        // collect transformed trace tags, any trace summary and their
        // offset trace indeices. annoying_factor *= 10;
        for (auto inttag : fr->trace_tags()) {
            tagrules::tagset_t touttags = m_ft.transform(iport, "trace", inttag);
            if (touttags.empty()) {
                // std::cerr << "FrameFanin: no port trace tag for " << inttag << "\n";
                continue;
            }
            // std::cerr << "FrameFanin: port trace tags for " << inttag << ":\n";
            // for (const auto& t : touttags) {
            //     std::cerr << "\t" << t << "\n";
            // }

            const auto& summary = fr->trace_summary(inttag);
            IFrame::trace_list_t outtrinds;
            for (size_t trind : fr->tagged_traces(inttag)) {
                outtrinds.push_back(trind + trace_offset);
            }
            for (auto ot : touttags) {
                // need to stash them until after creating the output frame.
              stash.push_back(std::make_tuple(ot, outtrinds, summary));
            }
        };


        if (! m_tags[iport].empty() ) {
            IFrame::trace_list_t tl(traces->size());
            std::iota(tl.begin(), tl.end(), trace_offset);
            by_port[iport] = tl;
        }

        // Insert one intput frames traces.
        out_traces.insert(out_traces.end(), traces->begin(), traces->end());
    }
    
    auto sf = new SimpleFrame(one->ident(), one->time(), out_traces, one->tick());
    for (size_t iport=0; iport < m_multiplicity; ++iport) {
        if (m_tags[iport].size()) {
            // std::cerr << "FrameFanin: tagging trace set: " << by_port[iport].size() << " traces from port "
            //          << iport << " with " << m_tags[iport] << std::endl;
            sf->tag_traces(m_tags[iport], by_port[iport]);
        }
    }
    for (auto ftag : fouttags) {
        // std::cerr << "FrameFanin: tagging frame: " << ftag << std::endl;
        sf->tag_frame(ftag);
    }
    for (auto ttt : stash) {
        // std::cerr << "FrameFanin: tagging traces: "
        //           << get<0>(ttt) << std::endl;
        sf->tag_traces(get<0>(ttt), get<1>(ttt), get<2>(ttt));
    }

    out = IFrame::pointer(sf);
    return true;
}

Member Data Documentation

tagrules::Context WireCell::Gen::FrameFanin::m_ft

private

Definition at line 31 of file FrameFanin.h.

size_t WireCell::Gen::FrameFanin::m_multiplicity

private

Definition at line 29 of file FrameFanin.h.

std::vector<std::string> WireCell::Gen::FrameFanin::m_tags

private

Definition at line 30 of file FrameFanin.h.

---

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

• wire-cell-build/gen/inc/WireCellGen/FrameFanin.h
• wire-cell-build/gen/src/FrameFanin.cxx