WireCell::Gen::MultiDuctor Class Reference

#include <MultiDuctor.h>

Inheritance diagram for WireCell::Gen::MultiDuctor:

Classes
struct	SubDuctor

Public Member Functions
	MultiDuctor (const std::string anode="AnodePlane")
virtual	~MultiDuctor ()
virtual bool	operator() (const input_pointer &depo, output_queue &frames)
	The calling signature: More...
virtual void	configure (const WireCell::Configuration &config)
	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::IDuctor
virtual	~IDuctor ()
virtual std::string	signature ()
Public Member Functions inherited from WireCell::IQueuedoutNode< IDepo, IFrame >
virtual	~IQueuedoutNode ()
virtual bool	operator() (const boost::any &anyin, queuedany &outanyq)
	The calling signature: More...
virtual std::vector< std::string >	input_types ()
virtual std::vector< std::string >	output_types ()
Public Member Functions inherited from WireCell::IQueuedoutNodeBase
virtual	~IQueuedoutNodeBase ()
virtual NodeCategory	category ()
	Return the behavior category type. More...
virtual int	concurrency ()
	By default assume all subclasses maintain state. 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 Types
typedef std::vector< SubDuctor >	ductorchain_t

Private Member Functions
void	merge (const output_queue &newframes)
void	maybe_extract (const input_pointer &depo, output_queue &outframes)
bool	start_processing (const input_pointer &depo)
void	dump_frame (const IFrame::pointer frame, std::string msg="Gen::MultiDuctor:")

Private Attributes
std::string	m_anode_tn
IAnodePlane::pointer	m_anode
double	m_tick
double	m_start_time
double	m_readout_time
int	m_frame_count
bool	m_continuous
bool	m_eos
std::vector< ductorchain_t >	m_chains
output_queue	m_frame_buffer

Additional Inherited Members
Public Types inherited from WireCell::IDuctor
typedef std::shared_ptr< IDuctor >	pointer
Public Types inherited from WireCell::IQueuedoutNode< IDepo, IFrame >
typedef std::shared_ptr< IQueuedoutNodeBase >	pointer
typedef IDepo	input_type
typedef IFrame	output_type
typedef std::shared_ptr< const IDepo >	input_pointer
typedef std::shared_ptr< const IFrame >	output_pointer
typedef std::deque< output_pointer >	output_queue
Public Types inherited from WireCell::IQueuedoutNodeBase
typedef std::shared_ptr< IQueuedoutNodeBase >	pointer
typedef std::deque< boost::any >	queuedany
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 22 of file MultiDuctor.h.

Member Typedef Documentation

typedef std::vector<SubDuctor> WireCell::Gen::MultiDuctor::ductorchain_t

private

Definition at line 57 of file MultiDuctor.h.

Constructor & Destructor Documentation

Gen::MultiDuctor::MultiDuctor

(

const std::string

anode = "AnodePlane"

)

Definition at line 20 of file MultiDuctor.cxx.

    : m_anode_tn(anode)
    , m_tick(0.5*units::us)
    , m_start_time(0.0*units::ns)
    , m_readout_time(5.0*units::ms)
    , m_frame_count(0)
    , m_continuous(false)
    , m_eos(true)
{
}

Gen::MultiDuctor::~MultiDuctor ( )

virtual

Definition at line 30 of file MultiDuctor.cxx.

{
}

Member Function Documentation

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

virtual

Accept a configuration.

fixme: this is totally going to break when going to two-faced anodes.

Implements WireCell::IConfigurable.

Definition at line 126 of file MultiDuctor.cxx.

{
    m_readout_time = get<double>(cfg, "readout_time", m_readout_time);
    m_tick = get<double>(cfg, "tick", m_tick);
    m_start_time = get<double>(cfg, "start_time", m_start_time);
    m_frame_count = get<int>(cfg, "first_frame_number", m_frame_count);
    m_continuous = get(cfg, "continuous", m_continuous);

    m_anode_tn = get(cfg, "anode", m_anode_tn);
    m_anode = Factory::find_tn<IAnodePlane>(m_anode_tn);
    if (!m_anode) {
        std::cerr << "Gen::MultiDuctor::configure: error: unknown anode: " << m_anode_tn << std::endl;
        return;
    }
    auto jchains = cfg["chains"];
    if (jchains.isNull()) {
        std::cerr << "Gen::MultiDuctor::configure: warning: configured with empty collection of chains\n";
        return;
    }

    /// fixme: this is totally going to break when going to two-faced anodes.
    if ( m_anode->faces().size() > 1 ) {
        std::cerr << "Gen::MultDuctor:configure: warning: I currently only support a front-faced AnodePlane.\n";
    }

    std::vector<const Pimpos*> pimpos;
    for (auto face : m_anode->faces()) {
        if (face->planes().empty()) {
            std::cerr << "Gen::MultDuctor: not given multi-plane AnodeFace for face "<<face->ident()<<"\n";
            continue;
        }
        for (auto plane : face->planes()) {
            pimpos.push_back(plane->pimpos());
        }
        break;                 // fixme: 
    }
    if (pimpos.size() != 3) {
        std::cerr << "Gen::MultiDuctor got unexpected number planes (" << pimpos.size() <<") from anode\n";
        THROW(ValueError() << errmsg{"Gen::MultiDuctor got unexpected number planes"});
    }

    for (auto jchain : jchains) {
        std::cerr << "Gen::MultiDuctor::configure chain:\n";
        ductorchain_t dchain;

        for (auto jrule : jchain) {
            auto rule = jrule["rule"].asString();
            auto ductor_tn = jrule["ductor"].asString();
            std::cerr << "\tMultiDuctor: " << ductor_tn << " rule: " << rule << std::endl;
            auto ductor = Factory::find_tn<IDuctor>(ductor_tn);
            if (!ductor) {
                THROW(KeyError() << errmsg{"Failed to find (sub) Ductor: " + ductor_tn});
            }
            auto jargs = jrule["args"];
            if (rule == "wirebounds") {
                dchain.push_back(SubDuctor(ductor_tn, Wirebounds(pimpos, jargs), ductor));
            }
            if (rule == "bool") {
                dchain.push_back(SubDuctor(ductor_tn, ReturnBool(jargs), ductor));
            }
        }
        m_chains.push_back(dchain);
    } // loop to store chains of ductors
}

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

virtual

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

The initial time for this ductor

The time span for each readout.

If false then determine start time of each readout based on the input depos. This option is useful when running WCT sim on a source of depos which have already been "chunked" in time. If true then this Ductor will continuously simulate all time in "readout_time" frames leading to empty frames in the case of some readout time with no depos.

Allow for a custom starting frame number

Reimplemented from WireCell::IConfigurable.

Definition at line 34 of file MultiDuctor.cxx.

{
    // The "chain" is a list of dictionaries.  Each provides:
    // - ductor: TYPE[:NAME] of a ductor component
    // - rule: name of a rule function to apply
    // - args: args for the rule function
    //
    // Rule functions:
    // wirebounds (list of wire ranges)
    // bool (true/false)

    Configuration cfg;
    cfg["anode"] = m_anode_tn;
    cfg["chain"] = Json::arrayValue;

    // must be consistent with subductors
    cfg["tick"] = m_tick;

    /// The initial time for this ductor
    cfg["start_time"] = m_start_time;

    /// The time span for each readout.
    cfg["readout_time"] = m_readout_time;

    /// If false then determine start time of each readout based on the
    /// input depos.  This option is useful when running WCT sim on a
    /// source of depos which have already been "chunked" in time.  If
    /// true then this Ductor will continuously simulate all time in
    /// "readout_time" frames leading to empty frames in the case of
    /// some readout time with no depos.
    cfg["continuous"] = m_continuous;

    /// Allow for a custom starting frame number
    cfg["first_frame_number"] = m_frame_count;
     
    return cfg;
}

void Gen::MultiDuctor::dump_frame ( const IFrame::pointer  frame, std::string  msg = "Gen::MultiDuctor:"  )

private

Definition at line 221 of file MultiDuctor.cxx.

{
    auto traces = frame->traces();
    if (!traces or traces->empty()) {
        std::cerr << msg
                  << " fid:" << frame->ident()
                  << " has no traces\n";
        return;
    }

    auto mm = FrameTools::tbin_range(*traces);
    std::cerr << msg
              << " fid:" << frame->ident()
              << " #ch:" << traces->size()
              << " t:" << std::setprecision(12) << m_start_time/units::us<<"us "
              << " tbins:["<<mm.first<<","<<mm.second<<"]\n";
}

void Gen::MultiDuctor::maybe_extract ( const input_pointer &  depo, output_queue &  outframes  )

private

Big fat lazy programmer FIXME: there is a bug waiting to bite here. If somehow a sub-ductor manages to make a frame that remains bigger than m_readout_time after the split() above, it will cause the final output frame to extend past requested duration. There needs to be a loop over to_extract added.

Big fat lazy programmer FIXME v2: there can be multiple traces on the same channel which may overlap in time.

Definition at line 240 of file MultiDuctor.cxx.

{
    if (!start_processing(depo)) { // may set m_start_time
        return;
    }

    // Must flush all sub-ductors to assure synchronization.
    for (auto& chain : m_chains) {
        for (auto& sd : chain) {
            output_queue newframes;
            (*sd.ductor)(nullptr, newframes); // flush with EOS marker
            merge(newframes);   // updates frame buffer
        }
    }

    // we must read out, and yet we have nothing
    //
    // fixme: the default behavior of this is to make sequential
    // blocks of m_readout_time even if there be no data.  Need to
    // also handle a more isolated running where the readout window is
    // data driven up until EOS is found.
    if (!m_frame_buffer.size()) {

        std::cerr << "MultiDuctor: returning empty frame with "<<m_frame_count
                  << " at " << m_start_time << "\n";

        ITrace::vector traces;
        auto frame = std::make_shared<SimpleFrame>(m_frame_count, m_start_time, traces, m_tick);
        outframes.push_back(frame);

        m_start_time += m_readout_time;
        ++m_frame_count;
        return;
    }


    // At this point the m_frame_buffer has at least some frames from
    // multiple sub-ductors, each of different time and channel extent
    // and potentially out of order.


    const double target_time = m_start_time + m_readout_time;
    output_queue to_keep, to_extract;
    for (auto frame: m_frame_buffer) {
        if (!frame) {
            std::cerr << "Gen::MultiDuctor: skipping null frame in frame buffer\n";
            continue;
        }
        if (!frame->traces()) {
            std::cerr << "Gen::MultiDuctor: skipping empty frame in frame buffer\n";
            continue;
        }   

        {
            const double tick = frame->tick();
            if (std::abs(tick - m_tick) > 0.0001) {
                std::cerr << "MultiDuctor: configuration error: got different tick in frame from sub-ductor = "
                     << tick/units::us << "us, mine = " << m_tick/units::us << "us\n";
                THROW(ValueError() << errmsg{"tick size mismatch"});
            }
        }

        int cmp = FrameTools::frmtcmp(frame, target_time);
        // std::cerr << "Gen::MultiDuctor: checking to keep: "
        //           << std::setprecision(12)
        //           << "t_target=" << target_time/units::us << "us, "
        //           << "cmp returns " << cmp << ", frame is:\n";
        // dump_frame(frame, "\t");

        if (cmp < 0) {
            to_extract.push_back(frame);
            continue;
        }
        if (cmp > 0) {
            to_keep.push_back(frame);
            continue;
        }                

        // If cmp==0 above then both halves of the pair should hold a frame.
        auto ff = FrameTools::split(frame, target_time);
        if (ff.first) {
            to_extract.push_back(ff.first);
            //dump_frame(ff.first, "Gen::MultiDuctor: to extract");
        }
        else {
            std::cerr << "Gen::MultiDuctor: error: early split is null\n";
        }

        if (ff.second) {
            to_keep.push_back(ff.second);
            //dump_frame(ff.second, "Gen::MultiDuctor: to keep");
        }
        else {
            std::cerr << "Gen::MultiDuctor: error: late split is null\n";
        }

    }
    m_frame_buffer = to_keep;
    
    if (!to_extract.size()) {
        // we read out, and yet we have nothing

        std::cerr << "MultiDuctor: returning empty frame after sub frame sorting with "
                  << m_frame_count<<" at " << m_start_time << "\n";

        ITrace::vector traces;
        auto frame = std::make_shared<SimpleFrame>(m_frame_count, m_start_time, traces, m_tick);
        outframes.push_back(frame);
        m_start_time += m_readout_time;
        ++m_frame_count;
        return;
    }
    

    /// Big fat lazy programmer FIXME: there is a bug waiting to bite
    /// here.  If somehow a sub-ductor manages to make a frame that
    /// remains bigger than m_readout_time after the split() above, it
    /// will cause the final output frame to extend past requested
    /// duration.  There needs to be a loop over to_extract added.

    /// Big fat lazy programmer FIXME v2: there can be multiple traces
    /// on the same channel which may overlap in time.

    ITrace::vector traces;
    for (auto frame: to_extract) {
        const double tref = frame->time();
        const int extra_tbins = (tref-m_start_time)/m_tick;
        for (auto trace : (*frame->traces())) {
            const int tbin = trace->tbin() + extra_tbins;
            const int chid = trace->channel();
            // std::cerr <<traces.size()
            //           <<" tstart="<<m_start_time/units::us<<"us"
            //           <<" tref="<<tref/units::us << "us"
            //           <<" tbin="<<tbin
            //           <<" extra bins="<< extra_tbins<<" chid="<<chid<<"\n";
            auto mtrace = std::make_shared<SimpleTrace>(chid, tbin, trace->charge());
            traces.push_back(mtrace);
        }
    }
    auto frame = std::make_shared<SimpleFrame>(m_frame_count, m_start_time, traces, m_tick);
    dump_frame(frame, "Gen::MultiDuctor: output frame");

    outframes.push_back(frame);
    m_start_time += m_readout_time;
    ++m_frame_count;
}

void Gen::MultiDuctor::merge ( const output_queue &  newframes )

private

Definition at line 387 of file MultiDuctor.cxx.

{
    for (auto frame : newframes) {
        if (!frame) { continue; } // skip internal EOS
        auto traces = frame->traces();
        if (!traces) { continue; }
        if (traces->empty()) { continue; }

        //dump_frame(frame, "Gen::MultiDuctor: merging frame");
        m_frame_buffer.push_back(frame);
    }
}

bool Gen::MultiDuctor::operator() ( const input_pointer &  in, output_queue &  outq  )

virtual

The calling signature:

Implements WireCell::IQueuedoutNode< IDepo, IFrame >.

Definition at line 400 of file MultiDuctor.cxx.

{
    // end of stream processing
    if (!depo) {              
        //std::cerr << "Gen::MultiDuctor: end of stream processing\n";
        maybe_extract(depo, outframes);
        outframes.push_back(nullptr); // pass on EOS marker
        if (!m_frame_buffer.empty()) {
            std::cerr << "Gen::MultiDuctor: purging " << m_frame_buffer.size() << " frames at EOS\n";
            for (auto frame : m_frame_buffer) {
                dump_frame(frame, "\t");
            }
            m_frame_buffer.clear();
        }
        return true;
    }


    // check each rule in the chain to find match
    bool all_okay = true;
    int count = 0;
    for (auto& chain : m_chains) {

        for (auto& sd : chain) {

            if (!sd.check(depo)) {
                continue;
            }

            // found a matching sub-ductor
            ++count;

            // Normal buffered processing.
            output_queue newframes;
            bool ok = (*sd.ductor)(depo, newframes);
            merge(newframes);
            all_okay = all_okay && ok;

            // got a match so abandon chain
            break;
        }
    }
    if (count == 0) {
        std::cerr << "Gen::MultiDuctor: warning: no appropriate Ductor for depo at: "
                  << depo->pos() << std::endl;
    }

    maybe_extract(depo, outframes);
    if (outframes.size()) {
        std::cerr << "Gen::MultiDuctor: returning " << outframes.size() << " frames\n";
    }
    return true;
}

bool Gen::MultiDuctor::start_processing ( const input_pointer &  depo )

private

Definition at line 204 of file MultiDuctor.cxx.

{
    if (!depo) {
        m_eos = true;
        return true;
    }
    if (!m_continuous) {
        if (depo && m_eos) {
            m_eos = false;
            m_start_time = depo->time();
            return false;
        }
    }
    return depo->time() > m_start_time + m_readout_time;
}

Member Data Documentation

IAnodePlane::pointer WireCell::Gen::MultiDuctor::m_anode

private

Definition at line 41 of file MultiDuctor.h.

std::string WireCell::Gen::MultiDuctor::m_anode_tn

private

Definition at line 40 of file MultiDuctor.h.

std::vector<ductorchain_t> WireCell::Gen::MultiDuctor::m_chains

private

Definition at line 58 of file MultiDuctor.h.

bool WireCell::Gen::MultiDuctor::m_continuous

private

Definition at line 46 of file MultiDuctor.h.

bool WireCell::Gen::MultiDuctor::m_eos

private

Definition at line 47 of file MultiDuctor.h.

output_queue WireCell::Gen::MultiDuctor::m_frame_buffer

private

As sub ductors are called they will each return frames which are not in general synchronized with the others. Their frames must be buffered here and released as a merged frame in order for MultiDuctor to behave just like a monolithic ductor.

Definition at line 65 of file MultiDuctor.h.

int WireCell::Gen::MultiDuctor::m_frame_count

private

Definition at line 45 of file MultiDuctor.h.

double WireCell::Gen::MultiDuctor::m_readout_time

private

Definition at line 44 of file MultiDuctor.h.

double WireCell::Gen::MultiDuctor::m_start_time

private

Definition at line 43 of file MultiDuctor.h.

double WireCell::Gen::MultiDuctor::m_tick

private

Definition at line 42 of file MultiDuctor.h.

---

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

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