WireCell::Gen::Fourdee Class Reference

#include <Fourdee.h>

Inheritance diagram for WireCell::Gen::Fourdee:

Public Member Functions
	Fourdee ()
virtual	~Fourdee ()
virtual void	execute ()
	Implement to run something. More...
virtual void	execute_old ()
virtual void	execute_new ()
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::IApplication
virtual	~IApplication ()
Public Member Functions inherited from WireCell::IComponent< IApplication >
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
WireCell::IDepoSource::pointer	m_depos
WireCell::IDepoFilter::pointer	m_depofilter
WireCell::IDrifter::pointer	m_drifter
WireCell::IDuctor::pointer	m_ductor
WireCell::IFrameSource::pointer	m_dissonance
WireCell::IFrameFilter::pointer	m_digitizer
WireCell::IFrameFilter::pointer	m_filter
WireCell::IFrameSink::pointer	m_output

Additional Inherited Members
Public Types inherited from WireCell::IComponent< IApplication >
typedef std::shared_ptr< IApplication >	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

Fourdee is a Wire Cell Toolkit application class which handles a chain of "the 4 D's": deposition, drifting, "ducting" (induction response) and digitization. There is an optional "5th D": "dissonance" which provides a source of noise to be summed.

Each step provided by a model implemented as an instance of the associated component class. A final sink is also provided if the digitization output is provided.

Definition at line 34 of file Fourdee.h.

Constructor & Destructor Documentation

Gen::Fourdee::Fourdee

(

)

Definition at line 16 of file Fourdee.cxx.

    : m_depos(nullptr)
    , m_drifter(nullptr)
    , m_ductor(nullptr)
    , m_dissonance(nullptr)
    , m_digitizer(nullptr)
    , m_output(nullptr)
{
}

Gen::Fourdee::~Fourdee ( )

virtual

Definition at line 26 of file Fourdee.cxx.

{
}

Member Function Documentation

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

virtual

Accept a configuration.

Implements WireCell::IConfigurable.

Definition at line 48 of file Fourdee.cxx.

{
    std::string tn="";
    Configuration cfg = thecfg;

    cerr << "Gen::Fourdee:configure:\n";

    tn = get<string>(cfg, "DepoSource");
    cerr << "\tDepoSource: " << tn << endl;
    m_depos = Factory::find_maybe_tn<IDepoSource>(tn);

    tn = get<string>(cfg, "DepoFilter");
    if (tn.empty()) {
        m_depofilter = nullptr;
        cerr << "\tDepoFilter: none\n";
    }
    else {
        cerr << "\tDepoFilter: " << tn << endl;
        m_depofilter = Factory::find_maybe_tn<IDepoFilter>(tn);
    }

    tn = get<string>(cfg, "Drifter");
    cerr << "\tDrifter: " << tn << endl;
    m_drifter = Factory::find_maybe_tn<IDrifter>(tn);

    tn = get<string>(cfg, "Ductor");
    cerr << "\tDuctor: " << tn << endl;
    m_ductor = Factory::find_maybe_tn<IDuctor>(tn);

        
    tn = get<string>(cfg, "Dissonance","");
    if (tn.empty()) {           // noise is optional
        m_dissonance = nullptr;
        cerr << "\tDissonance: none\n";
    }
    else {
        m_dissonance = Factory::find_maybe_tn<IFrameSource>(tn);
        cerr << "\tDissonance: " << tn << endl;
    }

    tn = get<string>(cfg, "Digitizer","");
    if (tn.empty()) {           // digitizer is optional, voltage saved w.o. it.
        m_digitizer = nullptr;
        cerr << "\tDigitizer: none\n";
    }
    else {
        m_digitizer = Factory::find_maybe_tn<IFrameFilter>(tn);
        cerr << "\tDigitizer: " << tn << endl;
    }

    tn = get<string>(cfg, "Filter","");
    if (tn.empty()) {           // filter is optional
        m_filter = nullptr;
        cerr << "\tFilter: none\n";
    }
    else {
        m_filter = Factory::find_maybe_tn<IFrameFilter>(tn);
        cerr << "\tFilter: " << tn << endl;
    }

    tn = get<string>(cfg, "FrameSink","");
    if (tn.empty()) {           // sink is optional
        m_output = nullptr;
        cerr << "\tSink: none\n";
    }
    else {
        m_output = Factory::find_maybe_tn<IFrameSink>(tn);
        cerr << "\tSink: " << tn << endl;
    }
}

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

virtual

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

Reimplemented from WireCell::IConfigurable.

Definition at line 30 of file Fourdee.cxx.

{
    Configuration cfg;

    // the 4 d's and proof the developer can not count:
    put(cfg, "DepoSource", "TrackDepos");
    put(cfg, "DepoFilter", "");
    put(cfg, "Drifter", "Drifter");      
    put(cfg, "Ductor", "Ductor");        
    put(cfg, "Dissonance", "SilentNoise");
    put(cfg, "Digitizer", "Digitizer");  
    put(cfg, "Filter", "");  
    put(cfg, "FrameSink", "DumpFrames"); 

    return cfg;
}

void Gen::Fourdee::execute ( )

virtual

Implement to run something.

Implements WireCell::IApplication.

Definition at line 254 of file Fourdee.cxx.

{
    execute_new();
    //execute_old();
}

void Gen::Fourdee::execute_new ( )

virtual

Definition at line 260 of file Fourdee.cxx.

{
    if (!m_depos) {
        cerr << "Fourdee: no depos, can't do much" << endl;
        return;
    }

    if (!m_ductor and (m_digitizer or m_dissonance or m_digitizer or m_filter or m_output) ) {
        std::cerr <<"Fourdee: a Ductor is required for subsequent pipeline stages\n";
        return;
    }

    Pipeline pipeline;
    auto source = new SourceNodeProc(m_depos);
    Proc* last_proc = source;

    if (m_drifter) {            // depo in, depo out
        cerr << "Pipeline adding #"<<pipeline.size()<<": " << type(*m_drifter) << endl;
        auto proc = new QueuedNodeProc(m_drifter);
        last_proc = join(pipeline, last_proc, proc);
    }
    if (m_depofilter) {         // depo in, depo out
        cerr << "Pipeline adding #"<<pipeline.size()<<": " << type(*m_depofilter) << endl;
        auto proc = new FunctionNodeProc(m_depofilter);
        last_proc = join(pipeline, last_proc, proc);
    }

    if (m_ductor) {             // depo in, zero or more frames out
        cerr << "Pipeline adding #"<<pipeline.size()<<": " << type(*m_ductor) << endl;
        auto proc = new QueuedNodeProc(m_ductor);
        last_proc = join(pipeline, last_proc, proc);
    }

    if (m_dissonance) {         // frame in, frame out
        cerr << "Pipeline adding #"<<pipeline.size()<<": " << type(*m_dissonance) << endl;
        auto proc = new NoiseAdderProc(m_dissonance);
        last_proc = join(pipeline, last_proc, proc);
    }

    if (m_digitizer) {          // frame in, frame out
        cerr << "Pipeline adding #"<<pipeline.size()<<": " << type(*m_digitizer) << endl;
        auto proc = new FunctionNodeProc(m_digitizer);
        last_proc = join(pipeline, last_proc, proc);
    }

    if (m_filter) {          // frame in, frame out
        cerr << "Pipeline adding #"<<pipeline.size()<<": " << type(*m_filter) << endl;
        auto proc = new FunctionNodeProc(m_filter);
        last_proc = join(pipeline, last_proc, proc);
    }

    if (m_output) {             // frame in, full stop.
        cerr << "Pipeline adding #"<<pipeline.size()<<": " << type(*m_output) << endl;
        auto proc = new SinkNodeProc(m_output);
        last_proc = join(pipeline, last_proc, proc);
    }
    else {
        cerr << "Pipeline adding #"<<pipeline.size()<<": sink\n";
        auto sink = new DropSinkProc;
        last_proc = join(pipeline, last_proc, sink);
    }

    // truly last proc needs to be added by hand.
    pipeline.push_back(last_proc);



    // A "drain end first" strategy gives attention to draining
    // queues the more toward the the end of the pipeline they are.
    // This keeps the overall pipeline empty and leads to "pulse" type
    // data movement.  It's stupid for multiprocessing but in a single
    // thread will keep memory usage low.
    size_t pipelen = pipeline.size();
    while (true) {
        bool did_something = false;
        for (size_t ind = pipelen-1; ind > 0; --ind) { // source has no input
            SinkProc* proc = dynamic_cast<SinkProc*>(pipeline[ind]);
            if (proc->input_pipe().empty()) {
                continue;
            }
            bool ok = (*proc)();
            if (!ok) {
                std::cerr << "Pipeline failed\n";
                return;
            }
            //std::cerr << "Executed process " << ind << std::endl;
            did_something = true;
            break;
        }
        if (!did_something) {
            bool ok = (*pipeline[0])();
            if (!ok) {
                std::cerr << "Source empty\n";
                return;
            }
            //std::cerr << "Executed source\n";
        }
        // otherwise, go through pipeline again
    }

}

void Gen::Fourdee::execute_old ( )

virtual

Definition at line 361 of file Fourdee.cxx.

{
    if (!m_depos) cerr << "Fourdee: no depos" << endl;
    if (!m_drifter) cerr << "Fourdee: no drifter" << endl;
    if (!m_ductor) cerr << "Fourdee: no ductor" << endl;
    if (!m_dissonance) cerr << "Fourdee: no dissonance" << endl;
    if (!m_digitizer) cerr << "Fourdee: no digitizer" << endl;
    if (!m_filter) cerr << "Fourdee: no filter" << endl;
    if (!m_output) cerr << "Fourdee: no sink" << endl;

    // here we make a manual pipeline.  In a "real" app this might be
    // a DFP executed by TBB.
    int count=0;
    int ndepos = 0;
    int ndrifted = 0;
    ExecMon em;
    cerr << "Gen::Fourdee: starting\n";
    while (true) {
        ++count;

        IDepo::pointer depo;
        if (!(*m_depos)(depo)) {
            cerr << "DepoSource is empty\n";
        }
        if (!depo) {
            cerr << "Got null depo from source at loop iteration " << count << endl;
        }
        else {
            ++ndepos;
        }
        //cerr << "Gen::FourDee: seen " << ndepos << " depos\n";

        IDrifter::output_queue drifted;
        if (!(*m_drifter)(depo, drifted)) {
            cerr << "Stopping on " << type(*m_drifter) << endl;
            goto bail;
        }
        if (drifted.empty()) {
            continue;
        }
        if (m_depofilter) {
            IDrifter::output_queue fdrifted;
            for (auto drifted_depo : drifted) {
                IDepo::pointer fdepo;
                if ((*m_depofilter)(drifted_depo, fdepo)) {
                    fdrifted.push_back(fdepo);
                }
            }
            drifted = fdrifted;
        }

        ndrifted += drifted.size();
        cerr << "Gen::FourDee: seen " << ndrifted << " drifted\n";
        dump(drifted);
        
        for (auto drifted_depo : drifted) {
            IDuctor::output_queue frames;
            if (!(*m_ductor)(drifted_depo, frames)) {
                cerr << "Stopping on " << type(*m_ductor) << endl;
                goto bail;
            }
            if (frames.empty()) {
                continue;
            }
            cerr << "Gen::FourDee: got " << frames.size() << " frames\n";

            for (IFrameFilter::input_pointer voltframe : frames) {
                em("got frame");
                cerr << "voltframe: ";
                dump(voltframe);

                if (m_dissonance) {
                    cerr << "Gen::FourDee: including noise\n";
                    IFrame::pointer noise;
                    if (!(*m_dissonance)(noise)) {
                        cerr << "Stopping on " << type(*m_dissonance) << endl;
                        goto bail;
                    }
                    if (noise) {
                        cerr << "noiseframe: ";
                        dump(noise);
                        voltframe = Gen::sum(IFrame::vector{voltframe,noise}, voltframe->ident());
                        em("got noise");
                    }
                    else {
                        cerr << "Noise source is empty\n";
                    }
                }

                IFrameFilter::output_pointer adcframe;
                if (m_digitizer) {
                    if (!(*m_digitizer)(voltframe, adcframe)) {
                        cerr << "Stopping on " << type(*m_digitizer) << endl;
                        goto bail;
                    }
                    em("digitized");
                    cerr << "digiframe: ";
                    dump(adcframe);
                }
                else {
                    adcframe = voltframe;
                }

                if (m_filter) {
                    IFrameFilter::output_pointer filtframe;
                    if (!(*m_filter)(adcframe, filtframe)) {
                        cerr << "Stopping on " << type(*m_filter) << endl;
                        goto bail;
                    }
                    adcframe = filtframe;
                    em("filtered");
                }

                if (m_output) {
                    if (!(*m_output)(adcframe)) {
                        cerr << "Stopping on " << type(*m_output) << endl;
                        goto bail;
                    }
                    em("output");
                }
                cerr << "Gen::Fourdee: frame with " << adcframe->traces()->size() << " traces\n";
            }
        }
    }
  bail:             // what's this weird syntax?  What is this, BASIC?
    cerr << em.summary() << endl;
}

Member Data Documentation

WireCell::IDepoFilter::pointer WireCell::Gen::Fourdee::m_depofilter

private

Definition at line 50 of file Fourdee.h.

WireCell::IDepoSource::pointer WireCell::Gen::Fourdee::m_depos

private

Definition at line 49 of file Fourdee.h.

WireCell::IFrameFilter::pointer WireCell::Gen::Fourdee::m_digitizer

private

Definition at line 54 of file Fourdee.h.

WireCell::IFrameSource::pointer WireCell::Gen::Fourdee::m_dissonance

private

Definition at line 53 of file Fourdee.h.

WireCell::IDrifter::pointer WireCell::Gen::Fourdee::m_drifter

private

Definition at line 51 of file Fourdee.h.

WireCell::IDuctor::pointer WireCell::Gen::Fourdee::m_ductor

private

Definition at line 52 of file Fourdee.h.

WireCell::IFrameFilter::pointer WireCell::Gen::Fourdee::m_filter

private

Definition at line 55 of file Fourdee.h.

WireCell::IFrameSink::pointer WireCell::Gen::Fourdee::m_output

private

Definition at line 56 of file Fourdee.h.

---

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

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