#include <Diffuser.h>

Inheritance diagram for WireCell::Diffuser:

Public Types
typedef std::pair< double, double >	bounds_type

Public Types inherited from WireCell::IQueuedoutNode< IDepo, IDiffusion >
typedef std::shared_ptr< IQueuedoutNodeBase >	pointer

typedef IDepo	input_type

typedef IDiffusion	output_type

typedef std::shared_ptr< const IDepo >	input_pointer

typedef std::shared_ptr< const IDiffusion >	output_pointer

typedef std::deque< output_pointer >	output_queue

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

typedef std::deque< boost::any >	queuedany

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
	Diffuser (const Ray &pitch=Ray(Point(0.0, 0.0, 0.0), Point(0.0, 0.0, 5 units::millimeter)), double binsize_l=2.0 units::millimeter, double time_offset=0.0 units::microsecond, double origin_l=0.0 units::microsecond, double DL=5.3 units::centimeter2/units::second, double DT=12.8 units::centimeter2/units::second, double drift_velocity=1.6 units::millimeter/units::microsecond, double max_sigma_l=5 units::microsecond, double nsigma=3.0)

virtual	~Diffuser ()

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 void	reset ()

virtual bool	operator() (const input_pointer &depo, output_queue &outq)
	The calling signature: More...

IDiffusion::pointer	diffuse (double mean_l, double mean_t, double sigma_l, double sigma_t, double weight=1.0, IDepo::pointer depo=nullptr)

bounds_type	bounds (double mean, double sigma, double binsize, double origin=0.0)

std::vector< double >	oned (double mean, double sigma, double binsize, const Diffuser::bounds_type &bounds)

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

virtual std::string	signature ()

Public Member Functions inherited from WireCell::IQueuedoutNode< IDepo, IDiffusion >
virtual	~IQueuedoutNode ()

virtual bool	operator() (const boost::any &anyin, queuedany &outanyq)
	The calling signature: More...

virtual std::vector< std::string >	input_types ()

virtual std::vector< std::string >	output_types ()

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

virtual NodeCategory	category ()
	Return the behavior category type. More...

virtual int	concurrency ()
	By default assume all subclasses maintain state. More...

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

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 Member Functions
void	dump (const std::string &msg)

Private Attributes
Point	m_pitch_origin

Vector	m_pitch_direction

double	m_time_offset

double	m_origin_l

double	m_origin_t

double	m_binsize_l

double	m_binsize_t

double	m_DL

double	m_DT

double	m_drift_velocity

double	m_max_sigma_l

double	m_nsigma

IDiffusionSet	m_input

bool	m_eos

Detailed Description

Model longitudinal and transverse diffusion of drifted charge.

WireCell::IDepo objects are inserted and WireCell::IDiffusion objects are extracted. An internal buffer is kept in order to assure the output is time ordered by the leading edge of the diffusion "patch". Depositions are diffused in place so are assumed to be drifted to whatever location they are wanted. The IDepo::prior() method is used to find the total drift distance.

FIXME: this action is really a compound as it does three things:

1) Projects a deposition position onto wire pitch. 2) Applies arbitrary time offset. 3) Diffuses the deposition.

Definition at line 31 of file Diffuser.h.

Member Typedef Documentation

typedef std::pair<double,double> WireCell::Diffuser::bounds_type

Definition at line 34 of file Diffuser.h.

Constructor & Destructor Documentation

Diffuser::Diffuser	(	const Ray &	pitch = `Ray(Point(0.0,0.0,0.0),Point(0.0,0.0,5*units::millimeter))`,
		double	binsize_l = `2.0*units::millimeter`,
		double	time_offset = `0.0*units::microsecond`,
		double	origin_l = `0.0*units::microsecond`,
		double	DL = `5.3*units::centimeter2/units::second`,
		double	DT = `12.8*units::centimeter2/units::second`,
		double	drift_velocity = `1.6*units::millimeter/units::microsecond`,
		double	max_sigma_l = `5*units::microsecond`,
		double	nsigma = `3.0`
	)

Create a diffuser.

Parameters

pitch	gives the wire coordinate system.
lbinsize	defines the grid spacing in the longitudinal direction.
tbinsize	defines the grid spacing in the transverse direction.
lorigin	defines a grid line in the longitudinal direction.
torigin	defines a grid line in the transverse direction.
DL	is the longitudinal diffusion coefficient.
DT	is the transverse diffusion coefficient.
drift_velocity	is what it sounds like.
max_sigma_l	is the largest possible longitudinal diffusion.
nsigma	defines the number of sigma at which to truncate the Gaussian.

Definition at line 20 of file Diffuser.cxx.

     : m_pitch_origin(pitch.first)
     , m_pitch_direction(ray_unit(pitch))
     , m_time_offset(time_offset)
     , m_origin_l(origin_l)
     , m_origin_t(0.0)           // measure pitch direction from pitch_origin
     , m_binsize_l(binsize_l)
     , m_binsize_t(ray_length(pitch))
     , m_DL(DL)
     , m_DT(DT)
     , m_drift_velocity(drift_velocity)
     , m_max_sigma_l(max_sigma_l)
     , m_nsigma(nsigma)
     , m_eos(false)
 {
     //dump("Diffuser created");
 }

Diffuser::~Diffuser ( )

virtual

Definition at line 46 of file Diffuser.cxx.

47 {

48 }

Member Function Documentation

Diffuser::bounds_type Diffuser::bounds	(	double	mean,
		double	sigma,
		double	binsize,
		double	origin = `0.0`
	)

Definition at line 195 of file Diffuser.cxx.

 {
     double low = floor( (mean - m_nsigma*sigma - origin) / binsize ) * binsize + origin;    
     double high = ceil( (mean + m_nsigma*sigma - origin) / binsize ) * binsize + origin;    
 
     return std::make_pair(low, high);
 }

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

virtual

Accept a configuration.

Implements WireCell::IConfigurable.

Definition at line 70 of file Diffuser.cxx.

 {
     m_pitch_origin = get<Point>(cfg, "pitch_origin", m_pitch_origin);
     m_pitch_direction = get<Point>(cfg, "pitch_direction", m_pitch_direction).norm();
     m_time_offset = get<double>(cfg, "timeoffset", m_time_offset);
 
     m_origin_l = get<double>(cfg, "starttime", m_origin_l);
     m_origin_t = get<double>(cfg, "origin", m_origin_t);
 
     m_binsize_l = get<double>(cfg, "timeslice", m_binsize_l);
     m_binsize_t = get<double>(cfg, "pitch_distance", m_binsize_t);
 
     m_DL = get<double>(cfg, "DL", m_DL);
     m_DT = get<double>(cfg, "DT", m_DT);
 
     m_drift_velocity = get<double>(cfg, "drift_velocity", m_drift_velocity);
 
     m_max_sigma_l = get<double>(cfg, "max_sigma_l", m_max_sigma_l);
     m_nsigma = get<double>(cfg, "nsigma", m_nsigma);
 
     //dump("Diffuser configured");
 }

Configuration Diffuser::default_configuration ( ) const

virtual

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

Reimplemented from WireCell::IConfigurable.

Definition at line 50 of file Diffuser.cxx.

 {
     stringstream ss;
     ss << "{\n"
        << "\"pitch_origin\":{\"x\":0.0,\"y\":0.0,\"z\":0.0},\n"
        << "\"pitch_direction\":{\"x\":0.0,\"y\":0.0,\"z\":1.0},\n"
        << "\"pitch_distance\":" << 5.0*units::mm << ",\n"
        << "\"timeslice\":" << 2.0 * units::us << ",\n"
        << "\"timeoffset\":0.0,\n"
        << "\"starttime\":0.0,\n"
        << "\"origin\":0.0,\n"
        << "\"DL\":" << 5.3*units::centimeter2/units::second << ",\n"
        << "\"DT\":"<<12.8*units::centimeter2/units::second <<",\n"
        << "\"drift_velocity\":" << 1.6 * units::mm/units::us << ",\n"
        << "\"max_sigma_l\":" << 5.0 * units::us << ",\n"
        << "\"nsigma\":3.0\n"
        << "}\n";
     return Persist::loads(ss.str());
 }

IDiffusion::pointer Diffuser::diffuse	(	double	mean_l,
		double	mean_t,
		double	sigma_l,
		double	sigma_t,
		double	weight = `1.0`,
		IDepo::pointer	depo = `nullptr`
	)

Diffuse a point charge.

Parameters

mean_l	is the position in the longitudinal direction.
mean_t	is the position in the transverse direction.
sigma_l	is the Gaussian sigma in the longitudinal direction.
sigma_t	is the Gaussian sigma in the transverse direction.
weight	is the normalization (eg, amount of charge)

This is a mostly internal method. It does not directly fill or drain any internal buffers so can be used to test diffusion directly.

Definition at line 204 of file Diffuser.cxx.

 {
     bounds_type bounds_l = bounds(mean_l, sigma_l, m_binsize_l, m_origin_l);
     bounds_type bounds_t = bounds(mean_t, sigma_t, m_binsize_t, m_origin_t);
 
     std::vector<double> l_bins = oned(mean_l, sigma_l, m_binsize_l, bounds_l);
     std::vector<double> t_bins = oned(mean_t, sigma_t, m_binsize_t, bounds_t);
 
     if (l_bins.empty() || t_bins.empty()) {
         return nullptr;
     }
 
     // get normalization
     double power = 0;
     for (auto l : l_bins) {
         for (auto t : t_bins) {
             power += l*t;
         }
     }
     if (power == 0.0) {
         return nullptr;
     }
 
     Diffusion* smear = new Diffusion(depo,
                                      l_bins.size(), t_bins.size(),
                                      bounds_l.first, bounds_t.first,
                                      bounds_l.second, bounds_t.second);
 
     for (size_t ind_l = 0; ind_l < l_bins.size(); ++ind_l) {
         for (size_t ind_t = 0; ind_t < t_bins.size(); ++ind_t) {
             double value = l_bins[ind_l]*t_bins[ind_t]/power*weight;
             smear->set(ind_l, ind_t, value);
         }
     }
     
     IDiffusion::pointer ret(smear);
     return ret;
 }

void Diffuser::dump ( const std::string & msg )

private

Definition at line 98 of file Diffuser.cxx.

 {
     stringstream ss;
     ss << msg << endl
        << "\tpitch origin " << m_pitch_origin << endl
        << "\tpitch direction " << m_pitch_direction << endl
        << "\ttime offset " << m_time_offset << endl
        << "\torigin l " << m_origin_l << endl
        << "\torigin t " << m_origin_t << endl
        << "\tbinsize l " << m_binsize_l << endl
        << "\tbinsize t " << m_binsize_t << endl
        << "\tDL = " << m_DL << " DT = " << m_DT << endl
        << "\tdrift velocity = " << m_drift_velocity << endl
        << "\tmax sigma l = " << m_max_sigma_l << endl
        << "\tnsigma = " << m_nsigma;
     cerr << ss.str() << endl;;
 }

std::vector< double > Diffuser::oned	(	double	mean,
		double	sigma,
		double	binsize,
		const Diffuser::bounds_type &	bounds
	)

fragment between bin_edge_{low,high}

Definition at line 173 of file Diffuser.cxx.

 {
     int nbins = round((bounds.second - bounds.first)/binsize);
 
     /// fragment between bin_edge_{low,high}
     std::vector<double> integral(nbins+1, 0.0);
     for (int ibin=0; ibin <= nbins; ++ibin) {
         double absx = bounds.first + ibin*binsize;
         double t = 0.5*(absx-mean)/sigma;
         double e = 0.5*std::erf(t);
         integral[ibin] = e;
     }
 
     std::vector<double> bins;
     for (int ibin=0; ibin<nbins; ++ibin) {
         bins.push_back(integral[ibin+1] - integral[ibin]);
     }
     return bins;
 }

bool Diffuser::operator()	(	const input_pointer &	in,
		output_queue &	outq
	)

virtual

The calling signature:

Implements WireCell::IQueuedoutNode< IDepo, IDiffusion >.

Definition at line 117 of file Diffuser.cxx.

 {
     if (m_eos) {
         return false;
     }
     if (!depo) {                // EOS flush
         for (auto diff : m_input) {
             outq.push_back(diff);
         }
         outq.push_back(nullptr);
         m_eos = true;
         return true;
     }
 
     auto first = *depo_chain(depo).rbegin();
     const double drift_distance = first->pos().x() - depo->pos().x();
     const double drift_time = drift_distance / m_drift_velocity;
     
     const double tmpcm2 = 2*m_DL*drift_time/units::centimeter2;
     const double sigmaL = sqrt(tmpcm2)*units::centimeter / m_drift_velocity;
     const double sigmaT = sqrt(2*m_DT*drift_time/units::centimeter2)*units::centimeter2;
         
     const Vector to_depo = depo->pos() - m_pitch_origin;
     const double pitch_distance = m_pitch_direction.dot(to_depo);
 
     cerr << "Diffuser: "
          << " drift distance=" << drift_distance
          << " drift time=" << drift_time
          << " pitch distance = " << pitch_distance
          << endl;
 
     IDiffusion::pointer diff = this->diffuse(m_time_offset + depo->time(), pitch_distance,
                                              sigmaL, sigmaT, depo->charge(), depo);
     m_input.insert(diff);
 
     while (m_input.size() > 2) {
         auto first = *m_input.begin();
         auto last = *m_input.rbegin();
         const double last_center = 0.5*(last->lend() + last->lbegin());
         if (last_center - first->lbegin() < m_max_sigma_l*m_nsigma) {
             break; // new input with long diffusion may still take lead
         }
 
         // now we are guaranteed no newly added diffusion can have a
         // leading edge long enough to surpass that of the current
         // leader.
         outq.push_back(first);
         m_input.erase(first);
     }
 
     return true;
 }

void Diffuser::reset ( void )

virtual

Optional hook to be implemented in order to reset after an end of stream is encountered. Fixme: this should be removed.

Reimplemented from WireCell::INode.

Definition at line 93 of file Diffuser.cxx.

 {
     m_input.clear();
 }

Member Data Documentation

double WireCell::Diffuser::m_binsize_l

private

Definition at line 109 of file Diffuser.h.

double WireCell::Diffuser::m_binsize_t

private

Definition at line 110 of file Diffuser.h.

double WireCell::Diffuser::m_DL

private

Definition at line 111 of file Diffuser.h.

double WireCell::Diffuser::m_drift_velocity

private

Definition at line 112 of file Diffuser.h.

double WireCell::Diffuser::m_DT

private

Definition at line 111 of file Diffuser.h.

bool WireCell::Diffuser::m_eos

private

Definition at line 118 of file Diffuser.h.

IDiffusionSet WireCell::Diffuser::m_input

private

Definition at line 116 of file Diffuser.h.

double WireCell::Diffuser::m_max_sigma_l

private

Definition at line 113 of file Diffuser.h.

double WireCell::Diffuser::m_nsigma

private

Definition at line 114 of file Diffuser.h.

double WireCell::Diffuser::m_origin_l

private

Definition at line 107 of file Diffuser.h.

double WireCell::Diffuser::m_origin_t

private

Definition at line 108 of file Diffuser.h.

Vector WireCell::Diffuser::m_pitch_direction

private

Definition at line 105 of file Diffuser.h.

Point WireCell::Diffuser::m_pitch_origin

private

Definition at line 104 of file Diffuser.h.

double WireCell::Diffuser::m_time_offset

private

Definition at line 106 of file Diffuser.h.

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

wire-cell-build/gen/inc/WireCellGen/Diffuser.h
wire-cell-build/gen/src/Diffuser.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