#include <OmnibusNoiseFilter.h>

Inheritance diagram for WireCell::SigProc::OmnibusNoiseFilter:

Public Types
typedef std::vector< std::vector< int > >	grouped_channels_t

Public Types inherited from WireCell::IFrameFilter
typedef std::shared_ptr< IFrameFilter >	pointer

Public Types inherited from WireCell::IFunctionNode< IFrame, IFrame >
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 IFunctionNode< IFrame, IFrame >	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...

Public Member Functions
	OmnibusNoiseFilter (std::string intag="orig", std::string outtag="raw")
	Create an OmnibusNoiseFilter. More...

virtual	~OmnibusNoiseFilter ()

virtual bool	operator() (const input_pointer &in, output_pointer &out)
	IFrameFilter interface. More...

virtual void	configure (const WireCell::Configuration &config)
	IConfigurable interface. More...

virtual WireCell::Configuration	default_configuration () const
	Optional, override to return a hard-coded default configuration. More...

void	set_channel_filters (std::vector< WireCell::IChannelFilter::pointer > filters)

void	set_channel_status_filters (std::vector< WireCell::IChannelFilter::pointer > filters)

void	set_grouped_filters (std::vector< WireCell::IChannelFilter::pointer > filters)

void	set_channel_noisedb (WireCell::IChannelNoiseDatabase::pointer ndb)

Public Member Functions inherited from WireCell::IFrameFilter
virtual	~IFrameFilter ()

virtual std::string	signature ()
	Set the signature for all subclasses. More...

Public Member Functions inherited from WireCell::IFunctionNode< IFrame, IFrame >
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_nticks

std::string	m_intag

std::string	m_outtag

std::vector< WireCell::IChannelFilter::pointer >	m_perchan

std::vector< WireCell::IChannelFilter::pointer >	m_grouped

std::vector< WireCell::IChannelFilter::pointer >	m_perchan_status

WireCell::IChannelNoiseDatabase::pointer	m_noisedb

std::map< std::string, std::string >	m_maskmap

Log::logptr_t	log

Detailed Description

The Omnibus Noise Filter applies two series of IChannelFilter objects. The first series is applied on a per-channel basis and the second is applied on groups of channels as determined by its channel grouping.

Definition at line 32 of file OmnibusNoiseFilter.h.

Member Typedef Documentation

typedef std::vector< std::vector<int> > WireCell::SigProc::OmnibusNoiseFilter::grouped_channels_t

Definition at line 34 of file OmnibusNoiseFilter.h.

Constructor & Destructor Documentation

OmnibusNoiseFilter::OmnibusNoiseFilter	(	std::string	intag = `"orig"`,
		std::string	outtag = `"raw"`
	)

Create an OmnibusNoiseFilter.

Definition at line 24 of file OmnibusNoiseFilter.cxx.

     : m_nticks(0)
     , m_intag(intag)            // orig
     , m_outtag(outtag)          // raw
     , log(Log::logger("sigproc"))
 {
 }

OmnibusNoiseFilter::~OmnibusNoiseFilter ( )

virtual

Definition at line 31 of file OmnibusNoiseFilter.cxx.

32 {

33 }

Member Function Documentation

void OmnibusNoiseFilter::configure ( const WireCell::Configuration & config )

virtual

IConfigurable interface.

Implements WireCell::IConfigurable.

Definition at line 35 of file OmnibusNoiseFilter.cxx.

 {
     //std::cerr << "OmnibusNoiseFilter: configuring with:\n" << cfg << std::endl;
     m_nticks = (size_t)get(cfg, "nticks", (int)m_nticks);
     if (! cfg["nsamples"].isNull()) {
         log->warn("OmnibusNoiseFilter: \"nsamples\" is an obsolete parameter, use \"nticks\"");
     }
 
     auto jmm = cfg["maskmap"];
     for (auto name : jmm.getMemberNames()) {
         m_maskmap[name] = jmm[name].asString();
         //      std::cerr << name << " " << m_maskmap[name] << std::endl;
     }
 
     for (auto jf : cfg["channel_filters"]) {
         auto filt = Factory::find_tn<IChannelFilter>(jf.asString());
         log->debug("OmnibusNoiseFilter: adding channel filter: {} \"{}\"",
                    m_perchan.size(), jf.asString());
         m_perchan.push_back(filt);
     }
     for (auto jf : cfg["channel_status_filters"]) {
         auto filt = Factory::find_tn<IChannelFilter>(jf.asString());
         log->debug("OmnibusNoiseFilter: adding channel status filter: {} \"{}\"",
                    m_perchan_status.size(), jf.asString());
         m_perchan_status.push_back(filt);
     }
     for (auto jf : cfg["grouped_filters"]) {
         auto filt = Factory::find_tn<IChannelFilter>(jf.asString());
         log->debug("OmnibusNoiseFilter: adding grouped filter: {} \"{}\"",
                    m_grouped.size(), jf.asString());
         m_grouped.push_back(filt);
     }
 
 
     auto jcndb = cfg["noisedb"];
     m_noisedb = Factory::find_tn<IChannelNoiseDatabase>(jcndb.asString());
     log->debug("OmnibusNoiseFilter: using channel noise DB object: \"{}\"",
                jcndb.asString());
 
     m_intag = get(cfg, "intraces", m_intag);
     m_outtag = get(cfg, "outtraces", m_outtag);
 }

WireCell::Configuration OmnibusNoiseFilter::default_configuration ( ) const

virtual

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

Reimplemented from WireCell::IConfigurable.

Definition at line 78 of file OmnibusNoiseFilter.cxx.

 {
     Configuration cfg;
     cfg["nticks"] = (int)m_nticks;
     cfg["maskmap"]["chirp"] = "bad";
     cfg["maskmap"]["noisy"] = "bad";
     
     cfg["channel_filters"][0] = "mbOneChannelNoise";
     cfg["channel_status_filters"][0] = "mbOneChannelStatus";
     cfg["grouped_filters"][0] = "mbCoherentNoiseSub";
 
     // user must supply.  "OmniChannelNoiseDB" is a likely choice.
     // Avoid SimpleChannelNoiseDB.
     cfg["noisedb"] = ""; 
 
     // The tags for input and output traces
     cfg["intraces"] = m_intag;
     cfg["outtraces"] = m_outtag;
     return cfg;
 }

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

virtual

IFrameFilter interface.

Implements WireCell::IFunctionNode< IFrame, IFrame >.

Definition at line 100 of file OmnibusNoiseFilter.cxx.

 {
     if (!inframe) {             // eos
         outframe = nullptr;
         return true;
     }
 
     auto traces = wct::sigproc::tagged_traces(inframe, m_intag);
     if (traces.empty()) {
         log->warn("OmnibusNoiseFilter: no traces for tag \"{}\", sending empty frame", m_intag);
         outframe = std::make_shared<SimpleFrame>(inframe->ident(), inframe->time(),
                                                  std::make_shared<ITrace::vector>(),
                                                  inframe->tick());
 
         return true;
     }
 
     if (m_nticks) {
         log->debug("OmnibusNoiseFilter: will resize working waveforms from {} to {}",
                    traces.at(0)->charge().size(), m_nticks);
     }
     else {
         // Warning: this implicitly assumes a dense frame (ie, all tbin=0 and all waveforms same size).
         // It also won't stop triggering a warning inside OneChannelNoise if there is a mismatch.
         m_nticks = traces.at(0)->charge().size();
         log->debug("OmnibusNoiseFilter: nticks based on first waveform: {}", m_nticks);
     }
 
     // For now, just collect any and all masks and interpret them as "bad".
     Waveform::ChannelMaskMap input_cmm = inframe->masks();
     Waveform::ChannelMaskMap cmm;
     Waveform::merge(cmm,input_cmm,m_maskmap);
     
     // Get the ones from database and then merge
     std::vector<int> bad_channels = m_noisedb->bad_channels();
     {
         Waveform::BinRange bad_bins;
         bad_bins.first = 0;
         bad_bins.second = (int) m_nticks;
         Waveform::ChannelMasks temp;
         for (size_t i = 0; i< bad_channels.size();i++){
             temp[bad_channels.at(i)].push_back(bad_bins);
             //std::cout << temp.size() << " " << temp[bad_channels.at(i)].size() << std::endl;
         }
         Waveform::ChannelMaskMap temp_map;
         temp_map["bad"] = temp;
         Waveform::merge(cmm,temp_map,m_maskmap);
     }
 
 
     int nchanged_samples = 0;
 
     // Collect our working area indexed by channel.
     std::unordered_map<int, SimpleTrace*> bychan;
     for (auto trace : traces) {
         int ch = trace->channel();
 
         // make working area directly in simple trace to avoid memory fragmentation
         SimpleTrace* signal = new SimpleTrace(ch, 0, m_nticks);
         bychan[ch] = signal;
 
         // if good
         if (find(bad_channels.begin(), bad_channels.end(),ch) == bad_channels.end()) {
 
             auto const& charge = trace->charge();
             const size_t ncharges = charge.size();          
 
             signal->charge().assign(charge.begin(), charge.begin() + std::min(m_nticks, ncharges));
             signal->charge().resize(m_nticks, 0.0);
             
             if (ncharges != m_nticks) {
                 nchanged_samples += std::abs((int)m_nticks - (int)ncharges);
             }
 
         }
 
         int filt_count=0;
         for (auto filter : m_perchan) {
             auto masks = filter->apply(ch, signal->charge());
 
             // fixme: probably should assure these masks do not lead to out-of-bounds...
 
             Waveform::merge(cmm,masks,m_maskmap);
             ++filt_count;
         }
     }
     traces.clear();             // done with our copy of vector of shared pointers
 
     if (nchanged_samples) {
         log->warn("OmnibusNoiseFilter: warning, truncated or extended {} samples", nchanged_samples);
     }
 
     int group_counter = 0;
     int nunknownchans=0;
     for (auto group : m_noisedb->coherent_channels()) {
         ++group_counter;
 
         int flag = 1;
 
         IChannelFilter::channel_signals_t chgrp;
         for (auto ch : group) {     // fix me: check if we don't actually have this channel
             // std::cout << group_counter << " " << ch << " " << std::endl;
             if (bychan.find(ch)==bychan.end()) {
                 ++nunknownchans;
                 flag = 0;
             }
             else{
                 chgrp[ch] = bychan[ch]->charge(); // copy...
             }
         }
       
         if (flag == 0) continue;
       
         for (auto filter : m_grouped) {
             auto masks = filter->apply(chgrp);
 
             Waveform::merge(cmm,masks,m_maskmap);
         }
 
         for (auto cs : chgrp) {
             // cs.second; // copy
             bychan[cs.first]->charge().assign(cs.second.begin(), cs.second.end());
         }
     }
 
     if (nunknownchans) {
         log->debug("OmnibusNoiseFilter: {} unknown channels (probably the channel selector is in use)", nunknownchans);
     }
 
     // run status
     for (auto& it : bychan) {
         const int ch = it.first;
         IChannelFilter::signal_t& signal = it.second->charge();
         for (auto filter : m_perchan_status) {
             auto masks = filter->apply(ch, signal);
 
             Waveform::merge(cmm,masks,m_maskmap);
         }
     }
     
     ITrace::vector itraces;
     for (auto& cs : bychan) {    // fixme: that tbin though
         itraces.push_back(ITrace::pointer(cs.second));
     }
 
     bychan.clear();
 
     auto sframe = new SimpleFrame(inframe->ident(), inframe->time(), itraces, inframe->tick(), cmm);
     IFrame::trace_list_t indices(itraces.size());
     for (size_t ind=0; ind<itraces.size(); ++ind) {
         indices[ind] = ind;
     }
     sframe->tag_traces(m_outtag, indices);
     sframe->tag_frame("noisefilter");
     outframe = IFrame::pointer(sframe);
 
     return true;
 }

void WireCell::SigProc::OmnibusNoiseFilter::set_channel_filters ( std::vector< WireCell::IChannelFilter::pointer > filters )

inline

Definition at line 52 of file OmnibusNoiseFilter.h.

                                                                                        {
                 m_perchan = filters;
             }

void WireCell::SigProc::OmnibusNoiseFilter::set_channel_noisedb ( WireCell::IChannelNoiseDatabase::pointer ndb )

inline

Definition at line 61 of file OmnibusNoiseFilter.h.

                                                                                {
                 m_noisedb = ndb;
             }

void WireCell::SigProc::OmnibusNoiseFilter::set_channel_status_filters ( std::vector< WireCell::IChannelFilter::pointer > filters )

inline

Definition at line 55 of file OmnibusNoiseFilter.h.

                                                                                               {
                 m_perchan_status = filters;
             }

void WireCell::SigProc::OmnibusNoiseFilter::set_grouped_filters ( std::vector< WireCell::IChannelFilter::pointer > filters )

inline

Definition at line 58 of file OmnibusNoiseFilter.h.

                                                                                        {
                 m_grouped = filters;
             }

Member Data Documentation

Log::logptr_t WireCell::SigProc::OmnibusNoiseFilter::log

private

Definition at line 74 of file OmnibusNoiseFilter.h.

std::vector<WireCell::IChannelFilter::pointer> WireCell::SigProc::OmnibusNoiseFilter::m_grouped

private

Definition at line 69 of file OmnibusNoiseFilter.h.

std::string WireCell::SigProc::OmnibusNoiseFilter::m_intag

private

Definition at line 68 of file OmnibusNoiseFilter.h.

std::map<std::string, std::string> WireCell::SigProc::OmnibusNoiseFilter::m_maskmap

private

Definition at line 72 of file OmnibusNoiseFilter.h.

WireCell::IChannelNoiseDatabase::pointer WireCell::SigProc::OmnibusNoiseFilter::m_noisedb

private

Definition at line 70 of file OmnibusNoiseFilter.h.

size_t WireCell::SigProc::OmnibusNoiseFilter::m_nticks

private

Definition at line 67 of file OmnibusNoiseFilter.h.

std::string WireCell::SigProc::OmnibusNoiseFilter::m_outtag

private

Definition at line 68 of file OmnibusNoiseFilter.h.

std::vector<WireCell::IChannelFilter::pointer> WireCell::SigProc::OmnibusNoiseFilter::m_perchan

private

Definition at line 69 of file OmnibusNoiseFilter.h.

std::vector<WireCell::IChannelFilter::pointer> WireCell::SigProc::OmnibusNoiseFilter::m_perchan_status

private

Definition at line 69 of file OmnibusNoiseFilter.h.

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

wire-cell-build/sigproc/inc/WireCellSigProc/OmnibusNoiseFilter.h
wire-cell-build/sigproc/src/OmnibusNoiseFilter.cxx

Public Types

Public Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation