WireCell::Gen::BinnedDiffusion Class Reference

#include <BinnedDiffusion.h>

Public Types
enum	ImpactDataCalculationStrategy { constant =1, linear =2 }
	Useful to client code to mark a calculation strategy. More...

Public Member Functions
	BinnedDiffusion (const Pimpos &pimpos, const Binning &tbins, double nsigma=3.0, IRandom::pointer fluctuate=nullptr, ImpactDataCalculationStrategy calcstrat=linear)
const Pimpos &	pimpos () const
const Binning &	tbins () const
bool	add (IDepo::pointer deposition, double sigma_time, double sigma_pitch)
void	add (std::shared_ptr< GaussianDiffusion > gd, int impact_index)
void	erase (int begin_impact_index, int end_impact_index)
ImpactData::pointer	impact_data (int bin) const
std::pair< double, double >	pitch_range (double nsigma=0.0) const
std::pair< int, int >	impact_bin_range (double nsigma=0.0) const
std::pair< double, double >	time_range (double nsigma=0.0) const
std::pair< int, int >	time_bin_range (double nsigma=0.0) const
double	get_nsigma () const

Private Attributes
const Pimpos &	m_pimpos
const Binning &	m_tbins
double	m_nsigma
IRandom::pointer	m_fluctuate
ImpactDataCalculationStrategy	m_calcstrat
std::pair< int, int >	m_window
std::map< int, ImpactData::mutable_pointer >	m_impacts
std::set< std::shared_ptr< GaussianDiffusion > >	m_diffs
int	m_outside_pitch
int	m_outside_time

Detailed Description

A BinnedDiffusion maintains an association between impact positions along the pitch direction of a wire plane and the diffused depositions that drift to them.

It covers a fixed and discretely sampled time and pitch domain.

Definition at line 23 of file BinnedDiffusion.h.

Member Enumeration Documentation

enum WireCell::Gen::BinnedDiffusion::ImpactDataCalculationStrategy

Useful to client code to mark a calculation strategy.

Create a BinnedDiffusion.

Arguments are:

• pimpos :: a Pimpos instance defining the wire and impact binning.
• tbins :: a Binning instance defining the time sampling binning.
• nsigma :: number of sigma the 2D (transverse X longitudinal) Gaussian extends.
• fluctuate :: set to an IRandom if charge-preserving Poisson fluctuations are to be applied.
• calcstrat :: set a calculation strategy that gives how the microscopic distribution of charge between two impacts will be interpolated toward either edge.

Enumerator
constant
linear

Definition at line 47 of file BinnedDiffusion.h.

{ constant=1, linear=2 };

Constructor & Destructor Documentation

Gen::BinnedDiffusion::BinnedDiffusion	(	const Pimpos &	pimpos,
		const Binning &	tbins,
		double	nsigma = 3.0,
		IRandom::pointer	fluctuate = nullptr,
		ImpactDataCalculationStrategy	calcstrat = linear
	)

Definition at line 11 of file BinnedDiffusion.cxx.

    : m_pimpos(pimpos)
    , m_tbins(tbins)
    , m_nsigma(nsigma)
    , m_fluctuate(fluctuate)
    , m_calcstrat(calcstrat)
    , m_window(0,0)
    , m_outside_pitch(0)
    , m_outside_time(0)
{
}

Member Function Documentation

bool Gen::BinnedDiffusion::add	(	IDepo::pointer	deposition,
		double	sigma_time,
		double	sigma_pitch
	)

Add a deposition and its associated diffusion sigmas. Return false if no activity falls within the domain.

Definition at line 25 of file BinnedDiffusion.cxx.

{

    const double center_time = depo->time();
    const double center_pitch = m_pimpos.distance(depo->pos());

    Gen::GausDesc time_desc(center_time, sigma_time);
    {
        double nmin_sigma = time_desc.distance(m_tbins.min());
        double nmax_sigma = time_desc.distance(m_tbins.max());

        double eff_nsigma = sigma_time>0?m_nsigma:0;
        if (nmin_sigma > eff_nsigma || nmax_sigma < -eff_nsigma) {
            // std::cerr << "BinnedDiffusion: depo too far away in time sigma:"
            //           << " t_depo=" << center_time/units::ms << "ms not in:"
            //           << " t_bounds=[" << m_tbins.min()/units::ms << ","
            //           << m_tbins.max()/units::ms << "]ms"
            //           << " in Nsigma: [" << nmin_sigma << "," << nmax_sigma << "]\n";
            ++m_outside_time;
            return false;
        }
    }

    auto ibins = m_pimpos.impact_binning();

    Gen::GausDesc pitch_desc(center_pitch, sigma_pitch);
    {
        double nmin_sigma = pitch_desc.distance(ibins.min());
        double nmax_sigma = pitch_desc.distance(ibins.max());

        double eff_nsigma = sigma_pitch>0?m_nsigma:0;
        if (nmin_sigma > eff_nsigma || nmax_sigma < -eff_nsigma) {
            // std::cerr << "BinnedDiffusion: depo too far away in pitch sigma: "
            //           << " p_depo=" << center_pitch/units::cm << "cm not in:"
            //           << " p_bounds=[" << ibins.min()/units::cm << ","
            //           << ibins.max()/units::cm << "]cm"
            //           << " in Nsigma:[" << nmin_sigma << "," << nmax_sigma << "]\n";
            ++m_outside_pitch;
            return false;
        }
    }

    // make GD and add to all covered impacts
    int bin_beg = std::max(ibins.bin(center_pitch - sigma_pitch*m_nsigma), 0);
    int bin_end = std::min(ibins.bin(center_pitch + sigma_pitch*m_nsigma)+1, ibins.nbins());
    // debug
    //int bin_center = ibins.bin(center_pitch);
    //cerr << "DEBUG center_pitch: "<<center_pitch/units::cm<<endl; 
    //cerr << "DEBUG bin_center: "<<bin_center<<endl;

    auto gd = std::make_shared<GaussianDiffusion>(depo, time_desc, pitch_desc);
    for (int bin = bin_beg; bin < bin_end; ++bin) {
      //   if (bin == bin_beg)  m_diffs.insert(gd);
      this->add(gd, bin);
    }

    return true;
}

void Gen::BinnedDiffusion::add	(	std::shared_ptr< GaussianDiffusion >	gd,
		int	impact_index
	)

Unconditionally associate an already built GaussianDiffusion to one impact.

Definition at line 84 of file BinnedDiffusion.cxx.

{
    ImpactData::mutable_pointer idptr = nullptr;
    auto it = m_impacts.find(bin);
    if (it == m_impacts.end()) {
        idptr = std::make_shared<ImpactData>(bin);
        m_impacts[bin] = idptr;
    }
    else {
        idptr = it->second;
    }
    idptr->add(gd);
    if (false) {                           // debug
        auto mm = idptr->span();
        cerr << "Gen::BinnedDiffusion: add: "
             << " poffoset="<<gd->poffset_bin()
             << " toffoset="<<gd->toffset_bin()
             << " charge=" << gd->depo()->charge()/units::eplus << " eles"
             <<", for bin " << bin << " t=[" << mm.first/units::us << "," << mm.second/units::us << "]us\n";
    }
    m_diffs.insert(gd);
    //m_diffs.push_back(gd);
}

void Gen::BinnedDiffusion::erase	(	int	begin_impact_index,
		int	end_impact_index
	)

Drop any stored ImpactData within the half open impact index range.

Definition at line 108 of file BinnedDiffusion.cxx.

{
    for (int bin=begin_impact_number; bin<end_impact_number; ++bin) {
        m_impacts.erase(bin);
    }
}

double WireCell::Gen::BinnedDiffusion::get_nsigma ( ) const

inline

Definition at line 96 of file BinnedDiffusion.h.

{return m_nsigma;};

std::pair< int, int > Gen::BinnedDiffusion::impact_bin_range

(

double

nsigma = 0.0

)

const

Return the half open bin range of impact bins, constrained so that either number is in [0,nimpacts].

Definition at line 170 of file BinnedDiffusion.cxx.

{
    const auto ibins = m_pimpos.impact_binning();
    auto mm = pitch_range(nsigma);
    return std::make_pair(std::max(ibins.bin(mm.first), 0),
                          std::min(ibins.bin(mm.second)+1, ibins.nbins()));
}

Gen::ImpactData::pointer Gen::BinnedDiffusion::impact_data

(

int

bin

)

const

Return the data in the given impact bin. Note, this bin represents drifted charge between two impact positions. Take care when using BinnedDiffusion and field responses because epsilon above or below the impact position exactly in the middle of two wires drastically different response.

Definition at line 116 of file BinnedDiffusion.cxx.

{
    const auto ib = m_pimpos.impact_binning();
    if (! ib.inbounds(bin)) {
        return nullptr;
    }

    auto it = m_impacts.find(bin);
    if (it == m_impacts.end()) {
        return nullptr;
    }
    auto idptr = it->second;

    // make sure all diffusions have been sampled 
    for (auto diff : idptr->diffusions()) {
      diff->set_sampling(m_tbins, ib, m_nsigma, m_fluctuate, m_calcstrat);
      //diff->set_sampling(m_tbins, ib, m_nsigma, 0, m_calcstrat);
    }

    idptr->calculate(m_tbins.nbins());
    return idptr;
}

const Pimpos& WireCell::Gen::BinnedDiffusion::pimpos ( ) const

inline

Definition at line 53 of file BinnedDiffusion.h.

{ return m_pimpos; }

std::pair< double, double > Gen::BinnedDiffusion::pitch_range

(

double

nsigma = 0.0

)

const

Return the range of pitch containing depos out to given nsigma and without bounds checking.

Definition at line 161 of file BinnedDiffusion.cxx.

{
    std::vector<Gen::GausDesc> gds;
    for (auto diff : m_diffs) {
        gds.push_back(diff->pitch_desc());
    }
    return gausdesc_range(gds, nsigma);
}

const Binning& WireCell::Gen::BinnedDiffusion::tbins ( ) const

inline

Definition at line 54 of file BinnedDiffusion.h.

{ return m_tbins; }

std::pair< int, int > Gen::BinnedDiffusion::time_bin_range

(

double

nsigma = 0.0

)

const

Return the half open bin range for time bins constrained so that either number is in [0,nticks].

Definition at line 187 of file BinnedDiffusion.cxx.

{
    auto mm = time_range(nsigma);
    return std::make_pair(std::max(m_tbins.bin(mm.first),0),
                          std::min(m_tbins.bin(mm.second)+1, m_tbins.nbins()));
}

std::pair< double, double > Gen::BinnedDiffusion::time_range

(

double

nsigma = 0.0

)

const

Return the range of time containing depos out to given nsigma and without bounds checking.

Definition at line 178 of file BinnedDiffusion.cxx.

{
    std::vector<Gen::GausDesc> gds;
    for (auto diff : m_diffs) {
        gds.push_back(diff->time_desc());
    }
    return gausdesc_range(gds, nsigma);
}

Member Data Documentation

ImpactDataCalculationStrategy WireCell::Gen::BinnedDiffusion::m_calcstrat

private

Definition at line 105 of file BinnedDiffusion.h.

std::set<std::shared_ptr<GaussianDiffusion> > WireCell::Gen::BinnedDiffusion::m_diffs

private

Definition at line 113 of file BinnedDiffusion.h.

IRandom::pointer WireCell::Gen::BinnedDiffusion::m_fluctuate

private

Definition at line 104 of file BinnedDiffusion.h.

std::map<int, ImpactData::mutable_pointer> WireCell::Gen::BinnedDiffusion::m_impacts

private

Definition at line 110 of file BinnedDiffusion.h.

double WireCell::Gen::BinnedDiffusion::m_nsigma

private

Definition at line 103 of file BinnedDiffusion.h.

int WireCell::Gen::BinnedDiffusion::m_outside_pitch

private

Definition at line 115 of file BinnedDiffusion.h.

int WireCell::Gen::BinnedDiffusion::m_outside_time

private

Definition at line 116 of file BinnedDiffusion.h.

const Pimpos& WireCell::Gen::BinnedDiffusion::m_pimpos

private

Definition at line 96 of file BinnedDiffusion.h.

const Binning& WireCell::Gen::BinnedDiffusion::m_tbins

private

Definition at line 101 of file BinnedDiffusion.h.

std::pair<int,int> WireCell::Gen::BinnedDiffusion::m_window

private

Definition at line 108 of file BinnedDiffusion.h.

---

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

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