#include <OmniChannelNoiseDB.h>

Inheritance diagram for WireCell::SigProc::OmniChannelNoiseDB:

Classes
struct	ChannelInfo

Public Member Functions
	OmniChannelNoiseDB ()

virtual	~OmniChannelNoiseDB ()

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...

virtual double	sample_time () const
	FIXME: how to handle state changes? More...

virtual double	nominal_baseline (int channel) const
	Return a nominal baseline correction (additive offset) More...

virtual double	gain_correction (int channel) const

virtual double	response_offset (int channel) const
	Return a time offset associated with the response(). More...

virtual double	min_rms_cut (int channel) const

virtual double	max_rms_cut (int channel) const

virtual int	pad_window_front (int channel) const

virtual int	pad_window_back (int channel) const

virtual float	coherent_nf_decon_limit (int channel) const

virtual float	coherent_nf_decon_lf_cutoff (int channel) const

virtual float	coherent_nf_decon_limit1 (int channel) const

virtual float	coherent_nf_adc_limit (int channel) const

virtual float	coherent_nf_protection_factor (int channel) const

virtual float	coherent_nf_min_adc_limit (int channel) const

virtual float	coherent_nf_roi_min_max_ratio (int channel) const

virtual const filter_t &	rcrc (int channel) const
	Return the filter for the RC+RC coupling response function. More...

virtual const filter_t &	config (int channel) const
	Return the filter to correct any wrongly configured channels. More...

virtual const filter_t &	noise (int channel) const
	Return the filter to attenuate noise. More...

virtual const filter_t &	response (int channel) const
	A nominal detector response spectrum for a given channel. More...

virtual std::vector< channel_group_t >	coherent_channels () const
	Return channel grouping for coherent noise subtraction. More...

virtual channel_group_t	bad_channels () const
	Return channels which are considered a'priori "bad". More...

virtual channel_group_t	miscfg_channels () const
	Return channels which are considered a'priori "misconfigured". More...

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

Public Member Functions inherited from WireCell::IComponent< IChannelNoiseDatabase >
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 ()

Protected Member Functions
virtual void	set_bad_channels (const channel_group_t &bad)

virtual void	set_misconfigured (const std::vector< int > &channels, double from_gain, double from_shaping, double to_gain, double to_shaping, bool reset=false)

Private Types
typedef std::shared_ptr< filter_t >	shared_filter_t

typedef std::vector< shared_filter_t >	filter_vector_t

Private Member Functions
const ChannelInfo &	dbget (int ch) const

std::vector< int >	parse_channels (const Json::Value &jchannels)

shared_filter_t	make_filter (std::complex< float > defval=std::complex< float >(1, 0))

shared_filter_t	default_filter ()

shared_filter_t	parse_freqmasks (Json::Value jfm)

shared_filter_t	parse_rcrc (Json::Value jrcrc, int nrc)

double	parse_gain (Json::Value jreconfig)

shared_filter_t	parse_reconfig (Json::Value jreconfig)

shared_filter_t	get_reconfig (double from_gain, double from_shaping, double to_gain, double to_shaping)

shared_filter_t	parse_response (Json::Value jreconfig)

void	update_channels (Json::Value cfg)

ChannelInfo &	get_ci (int chid)

Private Attributes
double	m_tick

int	m_nsamples

IAnodePlane::pointer	m_anode

IFieldResponse::pointer	m_fr

int	m_rc_layers

std::unordered_map< int, ChannelInfo >	m_db

std::vector< channel_group_t >	m_channel_groups

channel_group_t	m_bad_channels

channel_group_t	m_miscfg_channels

std::unordered_map< int, shared_filter_t >	m_rcrc_cache

std::unordered_map< int, shared_filter_t >	m_reconfig_cache

std::unordered_map< int, shared_filter_t >	m_waveform_cache

std::unordered_map< int, shared_filter_t >	m_response_cache

Log::logptr_t	log

Additional Inherited Members
Public Types inherited from WireCell::IChannelNoiseDatabase
typedef WireCell::Waveform::compseq_t	filter_t
	The data type for all frequency-space, multiplicative filters. More...

typedef std::vector< int >	channel_group_t

Public Types inherited from WireCell::IComponent< IChannelNoiseDatabase >
typedef std::shared_ptr< IChannelNoiseDatabase >	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 24 of file OmniChannelNoiseDB.h.

Member Typedef Documentation

typedef std::vector<shared_filter_t> WireCell::SigProc::OmniChannelNoiseDB::filter_vector_t

private

Definition at line 108 of file OmniChannelNoiseDB.h.

typedef std::shared_ptr<filter_t> WireCell::SigProc::OmniChannelNoiseDB::shared_filter_t

private

Definition at line 107 of file OmniChannelNoiseDB.h.

Constructor & Destructor Documentation

OmniChannelNoiseDB::OmniChannelNoiseDB ( )

Create a configurable channel noise DB for digitized waveforms with the given size and number of samples. Default is for microphone.

Definition at line 14 of file OmniChannelNoiseDB.cxx.

     : m_tick(0.5*units::us)
     , m_nsamples(9600)
     , m_rc_layers(2)
     , log(Log::logger("sigproc"))
 {
 }

OmniChannelNoiseDB::~OmniChannelNoiseDB ( )

virtual

Definition at line 21 of file OmniChannelNoiseDB.cxx.

 {
     // for (auto it = m_db.begin(); it!= m_db.end(); it++){
     //    delete it->second;
     // }
     // m_db.clear();
 }

Member Function Documentation

virtual channel_group_t WireCell::SigProc::OmniChannelNoiseDB::bad_channels ( ) const

inlinevirtual

Return channels which are considered a'priori "bad".

Reimplemented from WireCell::IChannelNoiseDatabase.

Reimplemented in wcls::ChannelSelectorDB.

Definition at line 68 of file OmniChannelNoiseDB.h.

                                                          {
                 return m_bad_channels;
             }

virtual std::vector<channel_group_t> WireCell::SigProc::OmniChannelNoiseDB::coherent_channels ( ) const

inlinevirtual

Return channel grouping for coherent noise subtraction.

Implements WireCell::IChannelNoiseDatabase.

Definition at line 65 of file OmniChannelNoiseDB.h.

                                                                          {
                 return m_channel_groups;
             }

float OmniChannelNoiseDB::coherent_nf_adc_limit ( int channel ) const

virtual

Implements WireCell::IChannelNoiseDatabase.

Definition at line 701 of file OmniChannelNoiseDB.cxx.

 {
     return dbget(channel).adc_limit;
 }

float OmniChannelNoiseDB::coherent_nf_decon_lf_cutoff ( int channel ) const

virtual

Implements WireCell::IChannelNoiseDatabase.

Definition at line 691 of file OmniChannelNoiseDB.cxx.

 {
     return dbget(channel).decon_lf_cutoff;
 }

float OmniChannelNoiseDB::coherent_nf_decon_limit ( int channel ) const

virtual

Implements WireCell::IChannelNoiseDatabase.

Definition at line 686 of file OmniChannelNoiseDB.cxx.

 {
     return dbget(channel).decon_limit;
 }

float OmniChannelNoiseDB::coherent_nf_decon_limit1 ( int channel ) const

virtual

Implements WireCell::IChannelNoiseDatabase.

Definition at line 696 of file OmniChannelNoiseDB.cxx.

 {
     return dbget(channel).decon_limit1;
 }

float OmniChannelNoiseDB::coherent_nf_min_adc_limit ( int channel ) const

virtual

Implements WireCell::IChannelNoiseDatabase.

Definition at line 711 of file OmniChannelNoiseDB.cxx.

 {
     return dbget(channel).min_adc_limit;
 }

float OmniChannelNoiseDB::coherent_nf_protection_factor ( int channel ) const

virtual

Implements WireCell::IChannelNoiseDatabase.

Definition at line 706 of file OmniChannelNoiseDB.cxx.

 {
     return dbget(channel).protection_factor;
 }

float OmniChannelNoiseDB::coherent_nf_roi_min_max_ratio ( int channel ) const

virtual

Implements WireCell::IChannelNoiseDatabase.

Definition at line 716 of file OmniChannelNoiseDB.cxx.

 {
     return dbget(channel).roi_min_max_ratio;
 }

const IChannelNoiseDatabase::filter_t & OmniChannelNoiseDB::config ( int channel ) const

virtual

Return the filter to correct any wrongly configured channels.

Implements WireCell::IChannelNoiseDatabase.

Definition at line 731 of file OmniChannelNoiseDB.cxx.

 {
     auto filt = dbget(channel).config;
     if (filt) {
         return *filt;
     }    
     static filter_t dummy;
     return dummy;
 }

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

virtual

Accept a configuration.

Implements WireCell::IConfigurable.

Reimplemented in wcls::ChannelNoiseDB, and wcls::ChannelSelectorDB.

Definition at line 590 of file OmniChannelNoiseDB.cxx.

 {
     m_tick = get(cfg, "tick", m_tick);
     m_nsamples = get(cfg, "nsamples", m_nsamples);
     std::string anode_tn = get<std::string>(cfg, "anode", "AnodePlane");
     m_anode = Factory::find_tn<IAnodePlane>(anode_tn);
     std::string fr_tn = get<std::string>(cfg, "field_response", "FieldResponse");
     m_fr = Factory::find_tn<IFieldResponse>(fr_tn);
 
     // WARNING: this assumes channel numbers count from 0 with no gaps!
     //int nchans = m_anode->channels().size();
     //std::cerr << "noise database with " << nchans << " channels\n";
     //m_db.resize(nchans);
 
     // clear any previous config, and recover the memory
     // for (auto it = m_db.begin(); it!= m_db.end(); it++){
     //    delete it->second;
     // }
     // m_db.clear();
     for(auto ch: m_anode->channels()){
         // m_db.insert(std::make_pair(ch, new ChannelInfo));
         m_db[ch] = ChannelInfo();
     }
 
     m_channel_groups.clear();
     auto jgroups = cfg["groups"];
     for (auto jgroup: jgroups) {
         std::vector<int> channel_group;
         for (auto jch: jgroup) {
             channel_group.push_back(jch.asInt());
         }
         m_channel_groups.push_back(channel_group);
     }
     m_bad_channels.clear();
     for (auto jch : cfg["bad"]) {
         m_bad_channels.push_back(jch.asInt());
     }
     std::sort(m_bad_channels.begin(), m_bad_channels.end());
     if (m_bad_channels.size()) {
         log->debug("OmniChannelNoiseDB: setting {}:[{},{}] bad channels",
                    m_bad_channels.size(), m_bad_channels.front(), m_bad_channels.back());
     }
 
     
     m_miscfg_channels.clear();
     for (auto jci : cfg["channel_info"]) {
         update_channels(jci);
     }
 }

const ChannelInfo& WireCell::SigProc::OmniChannelNoiseDB::dbget ( int ch ) const

inlineprivate

Definition at line 138 of file OmniChannelNoiseDB.h.

                                                    {
                  auto it = m_db.find(ch);
                  if (it == m_db.end()) {
                      //it = m_db.find(defch);
                      //return *(it->second);
                      // m_db.insert(std::make_pair(ch, new ChannelInfo));
                      // return *(m_db[ch]);
                         THROW(KeyError() << errmsg{String::format("no db info for channel %d", ch)});
                  }
                  return it->second;
                 //return m_db.at(ch);
             }

WireCell::Configuration OmniChannelNoiseDB::default_configuration ( ) const

virtual

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

These must be provided

Reimplemented from WireCell::IConfigurable.

Definition at line 55 of file OmniChannelNoiseDB.cxx.

 {
     Configuration cfg;
     // The assumed time-domain sample period used to make response spetra.
     cfg["tick"] = m_tick;
     // The number of *frequency domain* sample.  This is NOT anything
     // related to the length of a waveform to which this class may be
     // applied, except by accident or contrivance.
     cfg["nsamples"] = m_nsamples;
     cfg["anode"] = "AnodePlane";
     cfg["field_response"] = "FieldResponse";
 
     /// These must be provided
     cfg["groups"] = Json::arrayValue;
     cfg["channel_info"] = Json::arrayValue;
     
     return cfg;
 }

OmniChannelNoiseDB::shared_filter_t OmniChannelNoiseDB::default_filter ( )

private

Definition at line 148 of file OmniChannelNoiseDB.cxx.

 {
     static shared_filter_t def = make_filter();
     return def;
 }

double OmniChannelNoiseDB::gain_correction ( int channel ) const

virtual

Return simple gain correction (a multiplicative, unitless scaling) to apply to a given channel.

Implements WireCell::IChannelNoiseDatabase.

Definition at line 656 of file OmniChannelNoiseDB.cxx.

 {
     return dbget(channel).gain_correction;
 }

OmniChannelNoiseDB::ChannelInfo & OmniChannelNoiseDB::get_ci ( int chid )

private

Definition at line 369 of file OmniChannelNoiseDB.cxx.

 {
     auto it = m_db.find(chid);
     if (it == m_db.end()) {
         THROW(KeyError() << errmsg{String::format("no db info for channel %d", chid)}); 
     }
     return it->second;
     //return m_db.at(chid);
 }

OmniChannelNoiseDB::shared_filter_t OmniChannelNoiseDB::get_reconfig	(	double	from_gain,
		double	from_shaping,
		double	to_gain,
		double	to_shaping
	)

private

Definition at line 239 of file OmniChannelNoiseDB.cxx.

 {
     // kind of evil.
     int key = int(round(10.0*from_gain/(units::mV/units::fC))) << 24
         | int(round(10.0*from_shaping/units::us)) << 16
         | int(round(10.0*to_gain/(units::mV/units::fC))) << 8
         | int(round(10.0*to_shaping/units::us));
         
     // std::cerr << "KEY:" << key
     //           << " fg="<<from_gain/(units::mV/units::fC) << " mV/fC,"
     //           << " fs=" << from_shaping/units::us << " us,"
     //           << " tg="<<to_gain/(units::mV/units::fC) << " mV/fC,"
     //           << " ts="<<to_shaping/units::us << " us,"
     //           << " m_tick=" << m_tick/units::us << " us."
     //           << std::endl;
 
 
     auto it = m_reconfig_cache.find(key);
     if (it != m_reconfig_cache.end()) {
         return it->second;
     }
 
     Response::ColdElec from_ce(from_gain, from_shaping);
     Response::ColdElec to_ce(to_gain, to_shaping);
     // auto to_sig   =   to_ce.generate(WireCell::Binning(m_nsamples, 0, m_nsamples*m_tick));
     // auto from_sig = from_ce.generate(WireCell::Binning(m_nsamples, 0, m_nsamples*m_tick));
     auto to_sig   =   to_ce.generate(WireCell::Waveform::Domain(0, m_nsamples*m_tick), m_nsamples);
     auto from_sig = from_ce.generate(WireCell::Waveform::Domain(0, m_nsamples*m_tick), m_nsamples);
     
     auto to_filt   = Waveform::dft(to_sig);
     auto from_filt = Waveform::dft(from_sig);
 
     //auto from_filt_sum = Waveform::sum(from_filt);
     //auto to_filt_sum   = Waveform::sum(to_filt);
 
     Waveform::shrink(to_filt, from_filt); // divide
     auto filt = std::make_shared<filter_t>(to_filt);
 
     //    std::cerr << filt->at(0) << " " << filt->at(1) << std::endl;
     
     // std::cerr << "OmniChannelNoiseDB: "
     //           << " from_sig sum=" << Waveform::sum(from_sig)
     //           << " to_sig sum=" << Waveform::sum(to_sig)
     //           << " from_filt sum=" << from_filt_sum
     //           << " to_filt sum=" << to_filt_sum
     //           << " rat_filt sum=" << Waveform::sum(to_filt)
     //           << std::endl;
 
 
     m_reconfig_cache[key] = filt;
     return filt;
 }

OmniChannelNoiseDB::shared_filter_t OmniChannelNoiseDB::make_filter ( std::complex< float > defval = std::complex<float>(1,0) )

private

Definition at line 144 of file OmniChannelNoiseDB.cxx.

 {
     return std::make_shared<filter_t>(m_nsamples, defval);
 }

double OmniChannelNoiseDB::max_rms_cut ( int channel ) const

virtual

Implements WireCell::IChannelNoiseDatabase.

Definition at line 671 of file OmniChannelNoiseDB.cxx.

 {
     return dbget(channel).max_rms_cut;
 }

double OmniChannelNoiseDB::min_rms_cut ( int channel ) const

virtual

Implements WireCell::IChannelNoiseDatabase.

Definition at line 666 of file OmniChannelNoiseDB.cxx.

 {
     return dbget(channel).min_rms_cut;
 }

virtual channel_group_t WireCell::SigProc::OmniChannelNoiseDB::miscfg_channels ( ) const

inlinevirtual

Return channels which are considered a'priori "misconfigured".

Reimplemented from WireCell::IChannelNoiseDatabase.

Reimplemented in wcls::ChannelSelectorDB.

Definition at line 71 of file OmniChannelNoiseDB.h.

                                                             {
                 return m_miscfg_channels;
             }

const IChannelNoiseDatabase::filter_t & OmniChannelNoiseDB::noise ( int channel ) const

virtual

Return the filter to attenuate noise.

Implements WireCell::IChannelNoiseDatabase.

Definition at line 741 of file OmniChannelNoiseDB.cxx.

 {
     auto filt = dbget(channel).noise;
     if (filt) {
         return *filt;
     }
     static filter_t dummy;
     return dummy;
 }

double OmniChannelNoiseDB::nominal_baseline ( int channel ) const

virtual

Return a nominal baseline correction (additive offset)

Implements WireCell::IChannelNoiseDatabase.

Definition at line 651 of file OmniChannelNoiseDB.cxx.

 {
     return dbget(channel).nominal_baseline;
 }

int OmniChannelNoiseDB::pad_window_back ( int channel ) const

virtual

Implements WireCell::IChannelNoiseDatabase.

Definition at line 681 of file OmniChannelNoiseDB.cxx.

 {
     return dbget(channel).pad_window_back;
 }

int OmniChannelNoiseDB::pad_window_front ( int channel ) const

virtual

Implements WireCell::IChannelNoiseDatabase.

Definition at line 676 of file OmniChannelNoiseDB.cxx.

 {
     return dbget(channel).pad_window_front;
 }

std::vector< int > OmniChannelNoiseDB::parse_channels ( const Json::Value & jchannels )

private

Definition at line 96 of file OmniChannelNoiseDB.cxx.

 {
     std::vector<int> ret;
 
     // single channel
     if (jchannels.isInt()) {
         ret.push_back(jchannels.asInt());
         return ret;
     }
 
     // array of explicit channels
     if (jchannels.isArray()) {
         const int nch = jchannels.size();
         ret.resize(nch);
         for (int ind=0; ind<nch; ++ind) {
             ret[ind] = jchannels[ind].asInt();
         }
         return ret;
     }
 
     // else, assume an object
 
     // range
     if (jchannels.isMember("first") && jchannels.isMember("last")) {
         const int chf = jchannels["first"].asInt();
         const int chl = jchannels["last"].asInt();
         const int nch = chl-chf+1;
         ret.resize(nch);
         for (int ind=0; ind < nch; ++ind) {
             ret[ind] = chf + ind;
         }
         return ret;
     }
     
     // wire plane id
     if (jchannels.isMember("wpid")) {
         WirePlaneId wpid(jchannels["wpid"].asInt());
         for (auto ch : m_anode->channels()) {
             if (m_anode->resolve(ch) == wpid) {
                 ret.push_back(ch);
             }
         }
         return ret;
     }
 
     return ret;
 }

OmniChannelNoiseDB::shared_filter_t OmniChannelNoiseDB::parse_freqmasks ( Json::Value jfm )

private

Definition at line 154 of file OmniChannelNoiseDB.cxx.

 {
     if (jfm.isNull()) {
         return default_filter();
     }
 
     auto spectrum = make_filter(std::complex<float>(1,0));
     for (auto jone : jfm) {
         double value = jone["value"].asDouble();
         int lo = std::max(jone["lobin"].asInt(), 0);
         int hi = std::min(jone["hibin"].asInt(), m_nsamples-1);
         // std::cerr << "freqmasks: set [" << lo << "," << hi << "] to " << value << std::endl;
         for (int ind=lo; ind <= hi; ++ind) { // inclusive
             spectrum->at(ind) = value;
         }
     }
     return spectrum;
 }

double OmniChannelNoiseDB::parse_gain ( Json::Value jreconfig )

private

Definition at line 214 of file OmniChannelNoiseDB.cxx.

 {
     if (jreconfig.empty()) {
         return 1.0;
     }
 
     const double from_gain = jreconfig["from"]["gain"].asDouble();
     const double to_gain = jreconfig["to"]["gain"].asDouble();
     return to_gain/from_gain;
 }

OmniChannelNoiseDB::shared_filter_t OmniChannelNoiseDB::parse_rcrc	(	Json::Value	jrcrc,
		int	nrc
	)

private

Definition at line 173 of file OmniChannelNoiseDB.cxx.

 {
     if (jrcrc.isNull()) {
         return default_filter();
     }
     const double rcrc_val = jrcrc.asDouble();
     const int key = int(round(1000*rcrc_val/units::ms));
     auto it = m_rcrc_cache.find(key);
     if (it != m_rcrc_cache.end()) {
         return it->second;
     }
 
     Response::SimpleRC rcres(rcrc_val, m_tick);
     // auto signal = rcres.generate(WireCell::Binning(m_nsamples, 0, m_nsamples*m_tick));
     auto signal = rcres.generate(WireCell::Waveform::Domain(0, m_nsamples*m_tick), m_nsamples);
     
     Waveform::compseq_t spectrum = Waveform::dft(signal);
     // get the square of it because there are two RC filters
     Waveform::compseq_t spectrum2 = spectrum;
     // Waveform::scale(spectrum2,spectrum);
 
     // std::cerr << "[wgu] parse_rcrc nrc= " << nrc << std::endl;
     nrc --;
     while(nrc>0){
         // std::cerr << "[wgu] more nrc= " << nrc << std::endl;
         Waveform::scale(spectrum2,spectrum);
         nrc --;
     }
     
 
     // std::cerr << "OmniChannelNoiseDB:: get rcrc as: " << rcrc_val 
     //           << " sum=" << Waveform::sum(spectrum2)
     //           << std::endl;
 
     auto ret = std::make_shared<filter_t>(spectrum2);
     m_rcrc_cache[key] = ret;
     return ret;
 }

OmniChannelNoiseDB::shared_filter_t OmniChannelNoiseDB::parse_reconfig ( Json::Value jreconfig )

private

Definition at line 225 of file OmniChannelNoiseDB.cxx.

 {
     if (jreconfig.empty()) {
         return default_filter();
     }
 
     const double from_gain = jreconfig["from"]["gain"].asDouble();
     const double from_shaping = jreconfig["from"]["shaping"].asDouble();
     const double to_gain = jreconfig["to"]["gain"].asDouble();
     const double to_shaping = jreconfig["to"]["shaping"].asDouble();
 
 
     return get_reconfig(from_gain, from_shaping, to_gain, to_shaping);
 }

OmniChannelNoiseDB::shared_filter_t OmniChannelNoiseDB::parse_response ( Json::Value jreconfig )

private

Definition at line 313 of file OmniChannelNoiseDB.cxx.

 {
     if (jfilt.isMember("wpid")) {
         WirePlaneId wpid(jfilt["wpid"].asInt());
         auto it = m_response_cache.find(wpid.ident());
         if (it != m_response_cache.end()) {
             return it->second;
         }
         auto const& fr = m_fr->field_response();
         auto fravg = Response::wire_region_average(fr);
         auto const& pr = fravg.planes[wpid.index()];
 
         // full length waveform
         std::vector<float> waveform(m_nsamples, 0.0);
         for (auto const& path : pr.paths) {
             auto const& current = path.current;
             const size_t nsamp = std::min(m_nsamples, (int)current.size());
             for (size_t ind=0; ind<nsamp; ++ind) {
                 waveform[ind] += current[ind];
             }
         }
         auto spectrum = WireCell::Waveform::dft(waveform);
         auto ret = std::make_shared<filter_t>(spectrum);
         m_response_cache[wpid.ident()] = ret;
         return ret;
     }
 
     if (jfilt.isMember("waveform") && jfilt.isMember("waveformid")) {
         int id = jfilt["waveformid"].asInt();
         auto it = m_waveform_cache.find(id);
         if (it != m_waveform_cache.end()) {
             return it->second;
         }
         
         auto jwave = jfilt["waveform"];
         const int nsamp = std::min(m_nsamples, (int)jwave.size());
 
         // Explicitly given waveform
         std::vector<float> waveform(m_nsamples, 0.0);
         for (int ind=0; ind<nsamp; ++ind) {
             waveform[ind] = jwave[ind].asFloat();
         }
         
         auto spectrum = WireCell::Waveform::dft(waveform);
         auto ret = std::make_shared<filter_t>(spectrum);
         m_waveform_cache[id] = ret;
         return ret;
     }
 
     // this default return is special in that it's empty instead of
     // being a flat, unity spectrum.
     static shared_filter_t empty = std::make_shared<filter_t>();
     return empty;
 }

const IChannelNoiseDatabase::filter_t & OmniChannelNoiseDB::rcrc ( int channel ) const

virtual

Return the filter for the RC+RC coupling response function.

Implements WireCell::IChannelNoiseDatabase.

Definition at line 721 of file OmniChannelNoiseDB.cxx.

 {
     auto filt = dbget(channel).rcrc;
     if (filt) {
         return *filt;
     }
     static filter_t dummy;
     return dummy;
 }

const IChannelNoiseDatabase::filter_t & OmniChannelNoiseDB::response ( int channel ) const

virtual

A nominal detector response spectrum for a given channel.

Implements WireCell::IChannelNoiseDatabase.

Definition at line 751 of file OmniChannelNoiseDB.cxx.

 {
     auto filt = dbget(channel).response;
     if (filt) {
         return *filt;
     }
     static filter_t dummy;
     return dummy;
 }

double OmniChannelNoiseDB::response_offset ( int channel ) const

virtual

Return a time offset associated with the response().

Implements WireCell::IChannelNoiseDatabase.

Definition at line 661 of file OmniChannelNoiseDB.cxx.

 {
     return dbget(channel).response_offset;
 }

double OmniChannelNoiseDB::sample_time ( ) const

virtual

FIXME: how to handle state changes?

Return the time-domain sample period (time in system of units) which is was used in producing the filter response spectral functions (filter_t).

Warning: take care that the number of frequency samples (filter_t::size()) is fixed and may not match the number of ticks in your waveform.

Implements WireCell::IChannelNoiseDatabase.

Definition at line 644 of file OmniChannelNoiseDB.cxx.

 {
     return m_tick;
 }

virtual void WireCell::SigProc::OmniChannelNoiseDB::set_bad_channels ( const channel_group_t & bad )

inlineprotectedvirtual

Definition at line 85 of file OmniChannelNoiseDB.h.

                                                                       {
                 m_bad_channels = bad;
             }

void OmniChannelNoiseDB::set_misconfigured	(	const std::vector< int > &	channels,
		double	from_gain,
		double	from_shaping,
		double	to_gain,
		double	to_shaping,
		bool	reset = `false`
	)

protectedvirtual

Definition at line 292 of file OmniChannelNoiseDB.cxx.

 {
     if (reset) {
         auto def = default_filter();
         for (auto& it : m_db) {
             it.second.config = def;
         }
     }
     auto val = get_reconfig(from_gain, from_shaping, to_gain, to_shaping);
     for (int ch : channels) {
         //m_db.at(ch).config = val;
         //dbget(ch).config = val;
         get_ci(ch).config = val;
         m_miscfg_channels.push_back(ch);
     }
 }

void OmniChannelNoiseDB::update_channels ( Json::Value cfg )

private

Definition at line 386 of file OmniChannelNoiseDB.cxx.

 {
     auto chans = parse_channels(cfg["channels"]);
 
     if (cfg.isMember("nominal_baseline")) {
         double val = cfg["nominal_baseline"].asDouble();
         dump_cfg("baseline", chans, val);
         for (int ch : chans) {
             //m_db.at(ch).nominal_baseline = val;
             //dbget(ch).nominal_baseline = val;
             get_ci(ch).nominal_baseline = val;
         }
     }
     if (cfg.isMember("gain_correction")) {
         double val = cfg["gain_correction"].asDouble();
         dump_cfg("gain", chans, val);
         for (int ch : chans) {
             //m_db.at(ch).gain_correction = val;
             //dbget(ch).gain_correction = val;
             get_ci(ch).gain_correction = val;
         }
     }
     // fixme: why have two ways to set the same thing?  
     {                           
         auto jfilt = cfg["reconfig"];
         if (!jfilt.isNull()) {
             auto val = parse_gain(jfilt);
             dump_cfg("gain", chans, val);
             for (int ch : chans) {
                 //m_db.at(ch).gain_correction = val;
                 //dbget(ch).gain_correction = val;
                 get_ci(ch).gain_correction = val;
             }
         }
     }
 
     if (cfg.isMember("response_offset")) {
         double val = cfg["response_offset"].asDouble();
         dump_cfg("offset", chans, val);
         for (int ch : chans) {
             //m_db.at(ch).response_offset = val;
             //dbget(ch).response_offset = val;
             get_ci(ch).response_offset = val;
         }
     }
     if (cfg.isMember("min_rms_cut")) {
         double val = cfg["min_rms_cut"].asDouble();
         dump_cfg("minrms", chans, val);
         for (int ch : chans) {
             //m_db.at(ch).min_rms_cut = val;
             //dbget(ch).min_rms_cut = val;
             get_ci(ch).min_rms_cut = val;
         }
     }
     if (cfg.isMember("max_rms_cut")) {
         double val = cfg["max_rms_cut"].asDouble();
         dump_cfg("maxrms", chans, val);
         for (int ch : chans) {
             //m_db.at(ch).max_rms_cut = val;
             //dbget(ch).max_rms_cut = val;
             get_ci(ch).max_rms_cut = val;
         }
     }
     if (cfg.isMember("pad_window_front")) {
         int val = cfg["pad_window_front"].asDouble();
         dump_cfg("padfront", chans, val);
         for (int ch : chans) {
             //m_db.at(ch).pad_window_front = val;
             //dbget(ch).pad_window_front = val;
             get_ci(ch).pad_window_front = val;
         }
     }
     if (cfg.isMember("pad_window_back")) {
         int val = cfg["pad_window_back"].asDouble();
         dump_cfg("padback", chans, val);
         for (int ch : chans) {
             //m_db.at(ch).pad_window_back = val;
             //dbget(ch).pad_window_back = val;
             get_ci(ch).pad_window_back = val;
         }
     }
 
     if (cfg.isMember("decon_limit")) {
         float val = cfg["decon_limit"].asDouble();
         dump_cfg("deconlimit", chans, val);
         for (int ch : chans) {
             //m_db.at(ch).decon_limit = val;
             //dbget(ch).decon_limit = val;
             get_ci(ch).decon_limit = val;
         }
     }
 
      if (cfg.isMember("decon_lf_cutoff")) {
         float val = cfg["decon_lf_cutoff"].asDouble();
         dump_cfg("deconlfcutoff", chans, val);
         for (int ch : chans) {
             //m_db.at(ch).decon_limit = val;
             //dbget(ch).decon_limit = val;
             get_ci(ch).decon_lf_cutoff = val;
         }
     }
      
     if (cfg.isMember("decon_limit1")) {
         float val = cfg["decon_limit1"].asDouble();
         dump_cfg("deconlimit1", chans, val);
         for (int ch : chans) {
             //m_db.at(ch).decon_limit1 = val;
             //dbget(ch).decon_limit1 = val;
             get_ci(ch).decon_limit1 = val;
         }
     }
     if (cfg.isMember("adc_limit")) {
         float val = cfg["adc_limit"].asDouble();
         dump_cfg("adclimit", chans, val);
         for (int ch : chans) {
             //m_db.at(ch).adc_limit = val;
             //dbget(ch).adc_limit = val;
             get_ci(ch).adc_limit = val;
         }
     }
      if (cfg.isMember("protection_factor")) {
         float val = cfg["protection_factor"].asDouble();
         dump_cfg("protectionfactor", chans, val);
         for (int ch : chans) {
             get_ci(ch).protection_factor = val;
         }
     }
      if (cfg.isMember("min_adc_limit")) {
         float val = cfg["min_adc_limit"].asDouble();
         dump_cfg("minadclimit", chans, val);
         for (int ch : chans) {
             //m_db.at(ch).adc_limit = val;
             //dbget(ch).adc_limit = val;
             get_ci(ch).min_adc_limit = val;
         }
     }
     if (cfg.isMember("roi_min_max_ratio")) {
         float val = cfg["roi_min_max_ratio"].asDouble();
         dump_cfg("roiminmaxratio", chans, val);
         for (int ch : chans) {
             get_ci(ch).roi_min_max_ratio = val;
         }
     }
     
     {
         auto jfilt = cfg["rcrc"];
         if (!jfilt.isNull()) {
             if (cfg.isMember("rc_layers")){
                 m_rc_layers = cfg["rc_layers"].asInt();
             }
             // std::cerr << "rc_layers = " << m_rc_layers << std::endl;
             auto val = parse_rcrc(jfilt, m_rc_layers);
             dump_cfg("rcrc", chans, Waveform::sum(*val));
             for (int ch : chans) {
                 //m_db.at(ch).rcrc = val;
                 //dbget(ch).rcrc = val;
                 get_ci(ch).rcrc = val;
             }
         }
     }
     {
         auto jfilt = cfg["reconfig"];
         if (!jfilt.isNull()) {
             auto val = parse_reconfig(jfilt);
             dump_cfg("reconfig", chans, Waveform::sum(*val));
             for (int ch : chans) {
                 //m_db.at(ch).config = val;
                 //dbget(ch).config = val;
                 get_ci(ch).config = val;
                 // fill in misconfgured channels
                 //std::cout <<" miscfg_channels fill: "<< ch <<"\n"
                 if(!jfilt.empty()) m_miscfg_channels.push_back(ch);
             }
         }
     }
     {
         auto jfilt = cfg["freqmasks"];
         if (!jfilt.isNull()) {
             auto val = parse_freqmasks(jfilt);
             dump_cfg("freqmasks", chans, Waveform::sum(*val));
             // std::cerr << jfilt << std::endl;
             for (int ch : chans) {
                 //m_db.at(ch).noise = val;
                 //dbget(ch).noise = val;
                 get_ci(ch).noise = val;
             }
         }
     }
     {
         auto jfilt = cfg["response"];
         if (!jfilt.isNull()) {
             auto val = parse_response(jfilt);
             dump_cfg("response", chans, Waveform::sum(*val));
             for (int ch : chans) {
                 //m_db.at(ch).response = val;
                 //dbget(ch).response = val;
                 get_ci(ch).response = val;
             }
         }
     }
 
 }

Member Data Documentation

Log::logptr_t WireCell::SigProc::OmniChannelNoiseDB::log

private

Definition at line 182 of file OmniChannelNoiseDB.h.

IAnodePlane::pointer WireCell::SigProc::OmniChannelNoiseDB::m_anode

private

Definition at line 103 of file OmniChannelNoiseDB.h.

channel_group_t WireCell::SigProc::OmniChannelNoiseDB::m_bad_channels

private

Definition at line 152 of file OmniChannelNoiseDB.h.

std::vector< channel_group_t > WireCell::SigProc::OmniChannelNoiseDB::m_channel_groups

private

Definition at line 151 of file OmniChannelNoiseDB.h.

std::unordered_map<int, ChannelInfo> WireCell::SigProc::OmniChannelNoiseDB::m_db

private

Definition at line 136 of file OmniChannelNoiseDB.h.

IFieldResponse::pointer WireCell::SigProc::OmniChannelNoiseDB::m_fr

private

Definition at line 104 of file OmniChannelNoiseDB.h.

channel_group_t WireCell::SigProc::OmniChannelNoiseDB::m_miscfg_channels

private

Definition at line 153 of file OmniChannelNoiseDB.h.

int WireCell::SigProc::OmniChannelNoiseDB::m_nsamples

private

Definition at line 102 of file OmniChannelNoiseDB.h.

int WireCell::SigProc::OmniChannelNoiseDB::m_rc_layers

private

Definition at line 105 of file OmniChannelNoiseDB.h.

std::unordered_map<int, shared_filter_t> WireCell::SigProc::OmniChannelNoiseDB::m_rcrc_cache

private

Definition at line 174 of file OmniChannelNoiseDB.h.

std::unordered_map<int, shared_filter_t> WireCell::SigProc::OmniChannelNoiseDB::m_reconfig_cache

private

Definition at line 176 of file OmniChannelNoiseDB.h.

std::unordered_map<int, shared_filter_t> WireCell::SigProc::OmniChannelNoiseDB::m_response_cache

private

Definition at line 180 of file OmniChannelNoiseDB.h.

double WireCell::SigProc::OmniChannelNoiseDB::m_tick

private

Definition at line 101 of file OmniChannelNoiseDB.h.

std::unordered_map<int, shared_filter_t> WireCell::SigProc::OmniChannelNoiseDB::m_waveform_cache

private

Definition at line 178 of file OmniChannelNoiseDB.h.

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

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

Classes

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation