#include <PlaneImpactResponse.h>

Inheritance diagram for WireCell::Gen::PlaneImpactResponse:

Public Types
typedef std::vector< int >	region_indices_t

typedef std::vector< region_indices_t >	wire_region_indicies_t

Public Types inherited from WireCell::IComponent< IPlaneImpactResponse >
typedef std::shared_ptr< IPlaneImpactResponse >	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
	PlaneImpactResponse (int plane_ident=0, size_t nbins=10000, double tick=0.5 *units::us)

	~PlaneImpactResponse ()

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

virtual IImpactResponse::pointer	closest (double relpitch) const

virtual TwoImpactResponses	bounded (double relpitch) const

double	pitch_range () const

double	pitch () const

double	impact () const

int	nwires () const
	The number of wires that span the pitch range. More...

size_t	nbins () const

int	nimp_per_wire () const
	not in the interface More...

const wire_region_indicies_t &	bywire_map () const

std::pair< int, int >	closest_wire_impact (double relpitch) const

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

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

Private Attributes
std::string	m_frname

std::vector< std::string >	m_short

double	m_overall_short_padding

std::vector< std::string >	m_long

double	m_long_padding

int	m_plane_ident

size_t	m_nbins

double	m_tick

wire_region_indicies_t	m_bywire

std::vector< IImpactResponse::pointer >	m_ir

double	m_half_extent

double	m_pitch

double	m_impact

Log::logptr_t	l

Detailed Description

Collection of all impact responses for a plane

Definition at line 53 of file PlaneImpactResponse.h.

Member Typedef Documentation

typedef std::vector<int> WireCell::Gen::PlaneImpactResponse::region_indices_t

Definition at line 99 of file PlaneImpactResponse.h.

typedef std::vector<region_indices_t> WireCell::Gen::PlaneImpactResponse::wire_region_indicies_t

Definition at line 100 of file PlaneImpactResponse.h.

Constructor & Destructor Documentation

Gen::PlaneImpactResponse::PlaneImpactResponse	(	int	plane_ident = `0`,
		size_t	nbins = `10000`,
		double	tick = `0.5*units::us`
	)

Create a PlaneImpactResponse.

Field response is assumed to be normalized in units of current.

Pre-amplifier gain and peaking time is that of the FE electronics. The preamp gain should be in units consistent with the field response. If 0.0 then no electronics response will be convolved.

A flat post-FEE amplifier gain can also be given to provide a global scaling of the output of the electronics.

Fixme: field response should be provided by a component.

Definition at line 34 of file PlaneImpactResponse.cxx.

     : m_frname("FieldResponse")
     , m_plane_ident(plane_ident)
     , m_nbins(nbins)
     , m_tick(tick)
     , l(Log::logger("geom"))
 {
 }

Gen::PlaneImpactResponse::~PlaneImpactResponse ( )

Definition at line 253 of file PlaneImpactResponse.cxx.

254 {

255 }

Member Function Documentation

TwoImpactResponses Gen::PlaneImpactResponse::bounded ( double relpitch ) const

virtual

Return the two responses which are associated with the impact positions on either side of the given pitch location (measured relative to the wire of interest).

Implements WireCell::IPlaneImpactResponse.

Definition at line 302 of file PlaneImpactResponse.cxx.

 {
     if (relpitch < -m_half_extent || relpitch > m_half_extent) {
         return TwoImpactResponses(nullptr, nullptr);
     }
 
     std::pair<int,int> wi = closest_wire_impact(relpitch);
 
     auto region = m_bywire[wi.first];
     if (wi.second == 0) {
         return std::make_pair(m_ir[region[0]], m_ir[region[1]]);
     }
     if (wi.second == (int)region.size()-1) {
         return std::make_pair(m_ir[region[wi.second-1]], m_ir[region[wi.second]]);
     }
 
     const double absimpact = m_half_extent + relpitch - wi.first*m_pitch;
     const double sign = absimpact - wi.second*m_impact;
 
     if (sign > 0) {
         return TwoImpactResponses(m_ir[region[wi.second]], m_ir[region[wi.second+1]]);
     }
     return TwoImpactResponses(m_ir[region[wi.second-1]], m_ir[region[wi.second]]);
 }

void Gen::PlaneImpactResponse::build_responses ( )

private

FIXME: this assumes impact positions are on uniform grid!

FIXME: this assumes paths are ordered by pitch

FIXME: this assumes detailed ordering of paths w/in one wire

Definition at line 97 of file PlaneImpactResponse.cxx.

 {
     auto ifr = Factory::find_tn<IFieldResponse>(m_frname);
 
     const size_t n_short_length = fft_best_length(m_overall_short_padding/m_tick);
     
     // build "short" response spectra
     WireCell::Waveform::compseq_t short_spec(n_short_length, Waveform::complex_t(1.0, 0.0));
     const size_t nshort = m_short.size();
     for (size_t ind=0; ind<nshort; ++ind) {
         const auto& name = m_short[ind];
         auto iw = Factory::find_tn<IWaveform>(name);
         if (std::abs(iw->waveform_period() - m_tick) > 1*units::ns) {
             l->critical("from {} got {} us sample period expected {} us",
                      name, iw->waveform_period()/units::us, m_tick/units::us);
             THROW(ValueError() << errmsg{"Tick mismatch in " + name});
         }
         auto wave = iw->waveform_samples(); // copy
         if (wave.size() != n_short_length) {
             l->debug("PIR: short response {} has different number of samples ({}) than expected ({})", name, wave.size(), n_short_length);
             wave.resize(n_short_length, 0);
         }
         // note: we are ignoring waveform_start which will introduce
         // an arbitrary phase shift....
         auto spec = Waveform::dft(wave);
         for (size_t ibin=0; ibin < n_short_length; ++ibin) {
             short_spec[ibin] *= spec[ibin];
         }
     }
 
     
     // build "long" response spectrum in time domain ...
     size_t n_long_length = fft_best_length(m_nbins);
     WireCell::Waveform::compseq_t long_spec(n_long_length, Waveform::complex_t(1.0, 0.0));
     const size_t nlong = m_long.size();
     for (size_t ind=0; ind<nlong; ++ind) {
         const auto& name = m_long[ind];
         auto iw = Factory::find_tn<IWaveform>(name);
         if (std::abs(iw->waveform_period() - m_tick) > 1*units::ns) {
             l->critical("from {} got {} us sample period expected {} us",
                      name,  iw->waveform_period()/units::us, m_tick/units::us);
             THROW(ValueError() << errmsg{"Tick mismatch in " + name});
         }
         auto wave = iw->waveform_samples(); // copy
         if (wave.size() != n_long_length) {
             l->debug("PIR: long response {} has different number of samples ({}) than expected ({})", name, wave.size(), n_long_length);
             wave.resize(n_long_length, 0);
         }
         // note: we are ignoring waveform_start which will introduce
         // an arbitrary phase shift....
         auto spec = Waveform::dft(wave);
         for (size_t ibin=0; ibin < n_long_length; ++ibin) {
             long_spec[ibin] *= spec[ibin];
         }
 
     }
     WireCell::Waveform::realseq_t long_wf;
     if (nlong >0)
       long_wf = Waveform::idft(long_spec);
    
 
     const auto& fr = ifr->field_response();
     const auto& pr = *fr.plane(m_plane_ident);
     const int npaths = pr.paths.size();
 
     // FIXME HUGE ASSUMPTIONS ABOUT ORGANIZATION OF UNDERLYING
     // FIELD RESPONSE DATA!!!
     //
     // Paths must be in increasing pitch with one impact position at
     // nearest wire and 5 more impact positions equally spaced and at
     // smaller pitch distances than the associated wire.  The final
     // impact position should be no further from the wire than 1/2
     // pitch.
 
     const int n_per = 6;        // fixme: assumption
     const int n_wires = npaths/n_per;
     const int n_wires_half = n_wires / 2; // integer div
     //const int center_index = n_wires_half * n_per;
 
     /// FIXME: this assumes impact positions are on uniform grid!
     m_impact = std::abs(pr.paths[1].pitchpos - pr.paths[0].pitchpos);
     /// FIXME: this assumes paths are ordered by pitch
     m_half_extent = std::max(std::abs(pr.paths.front().pitchpos),
                              std::abs(pr.paths.back().pitchpos));
     /// FIXME: this assumes detailed ordering of paths w/in one wire
     m_pitch = 2.0*std::abs(pr.paths[n_per-1].pitchpos - pr.paths[0].pitchpos);
 
 
     // native response time binning
     const int rawresp_size = pr.paths[0].current.size();
     const double rawresp_min = fr.tstart;
     const double rawresp_tick = fr.period;
     const double rawresp_max = rawresp_min + rawresp_size*rawresp_tick;
     Binning rawresp_bins(rawresp_size, rawresp_min, rawresp_max);
 
     // collect paths and index by wire and impact position.
     std::map<int, region_indices_t> wire_to_ind;
     for (int ipath = 0; ipath < npaths; ++ipath) {
         const Response::Schema::PathResponse& path = pr.paths[ipath];
         const int wirenum = int(ceil(path.pitchpos/pr.pitch)); // signed
         wire_to_ind[wirenum].push_back(ipath);
 
         // match response sampling to digi and zero-pad
         WireCell::Waveform::realseq_t wave(n_short_length, 0.0);
         for (int rind=0; rind<rawresp_size; ++rind) { // sample at fine bins of response function
             const double time = rawresp_bins.center(rind);
 
             // fixme: assumes field response appropriately centered
             const size_t bin = time/m_tick; 
 
             if (bin>= n_short_length) {
                 l->warn("PIR: out of bounds field response bin={}, ntbins={}, time={} us, tick={} us", bin, n_short_length, time/units::us, m_tick/units::us);
             }
 
 
             // Here we have sampled, instantaneous induced *current*
             // (in WCT system-of-units for current) due to a single
             // drifting electron from the field response function.
             const double induced_current = path.current[rind];
 
             // Integrate across the fine time bin to get the element
             // of induced *charge* over this bin.
             const double induced_charge = induced_current*rawresp_tick;
 
             // sum up over coarse ticks.
             wave[bin] += induced_charge;
         }
         WireCell::Waveform::compseq_t spec = Waveform::dft(wave);
 
         // Convolve with short responses
         if (nshort) {
             for (size_t find=0; find < n_short_length; ++find) {
                 spec[find] *= short_spec[find];
             }
         }
         Waveform::realseq_t wf = Waveform::idft(spec);
         wf.resize(m_nbins,0);
 
         IImpactResponse::pointer ir = std::make_shared<Gen::ImpactResponse>(ipath, wf, m_overall_short_padding/m_tick, long_wf, m_long_padding/m_tick);
         m_ir.push_back(ir);
     }
 
     // apply symmetry.
     for (int irelwire=-n_wires_half; irelwire <= n_wires_half; ++irelwire) {
         auto direct = wire_to_ind[irelwire];
         auto other = wire_to_ind[-irelwire];
 
         std::vector<int> indices(direct.begin(), direct.end());
         for (auto it = other.rbegin()+1; it != other.rend(); ++it) {
             indices.push_back(*it);
         }
         m_bywire.push_back(indices);
     }
 
 }

const wire_region_indicies_t& WireCell::Gen::PlaneImpactResponse::bywire_map ( ) const

inline

Definition at line 101 of file PlaneImpactResponse.h.

101 { return m_bywire; }

WireCell::Gen::PlaneImpactResponse::m_bywire

wire_region_indicies_t m_bywire

Definition: PlaneImpactResponse.h:116

IImpactResponse::pointer Gen::PlaneImpactResponse::closest ( double relpitch ) const

virtual

Return the response at the impact position closest to the given relative pitch location (measured relative to the wire of interest).

Implements WireCell::IPlaneImpactResponse.

Definition at line 275 of file PlaneImpactResponse.cxx.

 {
     if (relpitch < -m_half_extent || relpitch > m_half_extent) {
         return nullptr;
     }
     std::pair<int,int> wi = closest_wire_impact(relpitch);
     if (wi.first < 0 || wi.first >= (int)m_bywire.size()) {
         l->debug("PIR: closest relative pitch:{} outside of wire range: {}",
                  relpitch,  wi.first);
         return nullptr;
     }
     const std::vector<int>& region = m_bywire[wi.first];
     if (wi.second < 0 || wi.second >= (int)region.size()) {
         l->debug("PIR: relative pitch:{} outside of impact range: {}",
                  relpitch,  wi.second);
         return nullptr;
     }
     int irind = region[wi.second];
     if (irind < 0 || irind > (int)m_ir.size()) {
         l->debug("PIR: relative pitch:{} no impact response for region: {}",
                  relpitch, irind);
         return nullptr;
     }
     
     return m_ir[irind];
 }

std::pair< int, int > Gen::PlaneImpactResponse::closest_wire_impact ( double relpitch ) const

Definition at line 262 of file PlaneImpactResponse.cxx.

 {
     const int center_wire = nwires()/2;
     
     const int relwire = int(round(relpitch/m_pitch));
     const int wire_index = center_wire + relwire;
     
     const double remainder_pitch = relpitch - relwire*m_pitch;
     const int impact_index = int(round(remainder_pitch / m_impact)) + nimp_per_wire()/2;
 
     return std::make_pair(wire_index, impact_index);
 }

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

virtual

Accept a configuration.

Implements WireCell::IConfigurable.

Definition at line 64 of file PlaneImpactResponse.cxx.

 {
     m_frname = get(cfg, "field_response", m_frname);
     m_plane_ident = get(cfg, "plane", m_plane_ident);
 
     m_short.clear();
     auto jfilts = cfg["short_responses"];
     if (!jfilts.isNull() and !jfilts.empty()) {
         for (auto jfn: jfilts) {
             auto tn = jfn.asString();
             m_short.push_back(tn);
         }
     }
     
     m_long.clear();
     auto jfilts1 = cfg["long_responses"];
     if (!jfilts1.isNull() and !jfilts1.empty()) {
         for (auto jfn: jfilts1) {
             auto tn = jfn.asString();
             m_long.push_back(tn);
         }
     }
 
     m_overall_short_padding = get(cfg, "overall_short_padding", m_overall_short_padding);
     m_long_padding = get(cfg, "long_padding", m_long_padding);
 
     m_nbins = (size_t) get(cfg, "nticks", (int)m_nbins);
     m_tick = get(cfg, "tick", m_tick);
 
     build_responses();
 }

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

virtual

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

Reimplemented from WireCell::IConfigurable.

Definition at line 44 of file PlaneImpactResponse.cxx.

 {
     Configuration cfg;
     // IFieldResponse component
     cfg["field_response"] = m_frname; 
     // plane id to use to index into field response .plane()
     cfg["plane"] = 0;            
     // names of IWaveforms interpreted as subsequent response
     // functions.
     cfg["short_responses"] = Json::arrayValue;
     cfg["overall_short_padding"] = 100*units::us;
     cfg["long_responses"] = Json::arrayValue;
     cfg["long_padding"] = 1.5*units::ms;
     // number of bins in impact response spectra
     cfg["nticks"] = 10000;
     // sample period of response waveforms
     cfg["tick"] = 0.5*units::us; 
     return cfg;
 }

double WireCell::Gen::PlaneImpactResponse::impact ( ) const

inlinevirtual

Implements WireCell::IPlaneImpactResponse.

Definition at line 91 of file PlaneImpactResponse.h.

91 { return m_impact; }

WireCell::Gen::PlaneImpactResponse::m_impact

double m_impact

Definition: PlaneImpactResponse.h:119

size_t WireCell::Gen::PlaneImpactResponse::nbins ( ) const

inlinevirtual

Implements WireCell::IPlaneImpactResponse.

Definition at line 95 of file PlaneImpactResponse.h.

95 { return m_nbins; }

WireCell::Gen::PlaneImpactResponse::m_nbins

size_t m_nbins

Definition: PlaneImpactResponse.h:113

int WireCell::Gen::PlaneImpactResponse::nimp_per_wire ( ) const

inline

not in the interface

Definition at line 98 of file PlaneImpactResponse.h.

98 { return m_bywire[0].size(); }

WireCell::Gen::PlaneImpactResponse::m_bywire

wire_region_indicies_t m_bywire

Definition: PlaneImpactResponse.h:116

int WireCell::Gen::PlaneImpactResponse::nwires ( ) const

inlinevirtual

The number of wires that span the pitch range.

Implements WireCell::IPlaneImpactResponse.

Definition at line 93 of file PlaneImpactResponse.h.

93 { return m_bywire.size(); }

WireCell::Gen::PlaneImpactResponse::m_bywire

wire_region_indicies_t m_bywire

Definition: PlaneImpactResponse.h:116

double WireCell::Gen::PlaneImpactResponse::pitch ( ) const

inlinevirtual

Implements WireCell::IPlaneImpactResponse.

Definition at line 90 of file PlaneImpactResponse.h.

90 { return m_pitch; }

WireCell::Gen::PlaneImpactResponse::m_pitch

double m_pitch

Definition: PlaneImpactResponse.h:119

double WireCell::Gen::PlaneImpactResponse::pitch_range ( ) const

inlinevirtual

The extent in pitch covered by the impact positions. This extent is relative to and centered on the "wire of interest" for which the PIR is associated.

Implements WireCell::IPlaneImpactResponse.

Definition at line 89 of file PlaneImpactResponse.h.

89 { return 2.0*m_half_extent; }

WireCell::Gen::PlaneImpactResponse::m_half_extent

double m_half_extent

Definition: PlaneImpactResponse.h:119

Member Data Documentation

Log::logptr_t WireCell::Gen::PlaneImpactResponse::l

private

Definition at line 121 of file PlaneImpactResponse.h.

wire_region_indicies_t WireCell::Gen::PlaneImpactResponse::m_bywire

private

Definition at line 116 of file PlaneImpactResponse.h.

std::string WireCell::Gen::PlaneImpactResponse::m_frname

private

Definition at line 106 of file PlaneImpactResponse.h.

double WireCell::Gen::PlaneImpactResponse::m_half_extent

private

Definition at line 119 of file PlaneImpactResponse.h.

double WireCell::Gen::PlaneImpactResponse::m_impact

private

Definition at line 119 of file PlaneImpactResponse.h.

std::vector<IImpactResponse::pointer> WireCell::Gen::PlaneImpactResponse::m_ir

private

Definition at line 118 of file PlaneImpactResponse.h.

std::vector<std::string> WireCell::Gen::PlaneImpactResponse::m_long

private

Definition at line 109 of file PlaneImpactResponse.h.

double WireCell::Gen::PlaneImpactResponse::m_long_padding

private

Definition at line 110 of file PlaneImpactResponse.h.

size_t WireCell::Gen::PlaneImpactResponse::m_nbins

private

Definition at line 113 of file PlaneImpactResponse.h.

double WireCell::Gen::PlaneImpactResponse::m_overall_short_padding

private

Definition at line 108 of file PlaneImpactResponse.h.

double WireCell::Gen::PlaneImpactResponse::m_pitch

private

Definition at line 119 of file PlaneImpactResponse.h.

int WireCell::Gen::PlaneImpactResponse::m_plane_ident

private

Definition at line 112 of file PlaneImpactResponse.h.

std::vector<std::string> WireCell::Gen::PlaneImpactResponse::m_short

private

Definition at line 107 of file PlaneImpactResponse.h.

double WireCell::Gen::PlaneImpactResponse::m_tick

private

Definition at line 114 of file PlaneImpactResponse.h.

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

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

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation