#include <DriftLineRKF.hh>

Public Member Functions
	DriftLineRKF ()
	Default constructor.

	DriftLineRKF (Sensor *sensor)
	Constructor.

	~DriftLineRKF ()
	Destructor.

void	SetSensor (Sensor *s)
	Set the sensor.

void	EnablePlotting (ViewDrift *view)
	Switch on drift line plotting.

void	DisablePlotting ()
	Switch off drift line plotting.

void	EnableSignalCalculation (const bool on=true)
	Switch calculation of induced currents on or off (default: enabled).

void	SetSignalAveragingOrder (const unsigned int navg)

void	UseWeightingPotential (const bool on=true)

void	SetIntegrationAccuracy (const double eps)
	Set the accuracy of the Runge Kutta Fehlberg drift line integration.

void	SetMaximumStepSize (const double ms)
	Set (explicitly) the maximum step size that is allowed.

void	SetMaximumStepSize ()

void	UnsetMaximumStepSize ()
	Do not apply an upper limit to the step size that is allowed.

void	RejectKinks (const bool on=true)

void	SetElectronSignalScalingFactor (const double scale)
	Set multiplication factor for the signal induced by electrons.

void	SetHoleSignalScalingFactor (const double scale)
	Set multiplication factor for the signal induced by holes.

void	SetIonSignalScalingFactor (const double scale)
	Set multiplication factor for the signal induced by ions.

void	EnableAvalanche (const bool on=true)
	Enable/disable simulation electron multiplication (default: on).

void	EnableIonTail (const bool on=true)
	Enable/disable simulation of the ion tail (default: off).

void	EnableNegativeIonTail (const bool on=true)
	Enable/disable simulation of the negative ion tail (default: off).

void	SetGainFluctuationsFixed (const double gain=-1.)
	Do not randomize the avalanche size.

void	SetGainFluctuationsPolya (const double theta, const double mean=-1., const bool quiet=false)

void	EnableTownsendMap (const bool on=true)
	Retrieve the Townsend coefficient from the component.

void	EnableVelocityMap (const bool on=true)
	Retrieve the drift velocity from the component.

bool	DriftElectron (const double x0, const double y0, const double z0, const double t0)
	Simulate the drift line of an electron with a given starting point.

bool	DriftHole (const double x0, const double y0, const double z0, const double t0)
	Simulate the drift line of a hole with a given starting point.

bool	DriftIon (const double x0, const double y0, const double z0, const double t0)
	Simulate the drift line of an ion with a given starting point.

bool	DriftPositron (const double x0, const double y0, const double z0, const double t0)

bool	DriftNegativeIon (const double x0, const double y0, const double z0, const double t0)

void	PrintDriftLine () const
	Print the trajectory of the most recent drift line.

void	GetEndPoint (double &x, double &y, double &z, double &t, int &st) const
	Get the end point and status flag of the most recent drift line.

size_t	GetNumberOfDriftLinePoints () const
	Get the number of points of the most recent drift line.

void	GetDriftLinePoint (const size_t i, double &x, double &y, double &z, double &t) const
	Get the coordinates and time of a point along the most recent drift line.

double	GetArrivalTimeSpread (const double eps=1.e-4) const

double	GetGain (const double eps=1.e-4) const
	Compute the multiplication factor for the current drift line.

double	GetLoss (const double eps=1.e-4) const
	Compute the attachment loss factor for the current drift line.

double	GetDriftTime () const
	Get the cumulative drift time.

double	GetPathLength () const
	Get the cumulative path length.

void	GetAvalancheSize (double &ne, double &ni) const

bool	FieldLine (const double xi, const double yi, const double zi, std::vector< std::array< float, 3 > > &xl, const bool electron=true) const

void	EnableDebugging (const bool on=true)
	Switch debugging messages on/off (default: off).

Detailed Description

Calculation of drift lines based on macroscopic transport coefficients using Runge-Kutta-Fehlberg integration.

Definition at line 18 of file DriftLineRKF.hh.

Constructor & Destructor Documentation

◆ DriftLineRKF() [1/2]

Garfield::DriftLineRKF::DriftLineRKF ( )

inline

Default constructor.

Definition at line 21 of file DriftLineRKF.hh.

21: DriftLineRKF(nullptr) {}

Garfield::DriftLineRKF::DriftLineRKF

DriftLineRKF()

Default constructor.

Definition DriftLineRKF.hh:21

Referenced by DriftLineRKF().

◆ DriftLineRKF() [2/2]

Garfield::DriftLineRKF::DriftLineRKF ( Sensor * sensor )

Constructor.

Definition at line 58 of file DriftLineRKF.cc.

                                         : m_sensor(sensor) {
  m_t.reserve(1000);
  m_x.reserve(1000);
}

◆ ~DriftLineRKF()

Garfield::DriftLineRKF::~DriftLineRKF ( )

inline

Destructor.

Definition at line 25 of file DriftLineRKF.hh.

25{}

Member Function Documentation

◆ DisablePlotting()

void Garfield::DriftLineRKF::DisablePlotting ( )

Switch off drift line plotting.

Definition at line 103 of file DriftLineRKF.cc.

103{ m_view = nullptr; }

◆ DriftElectron()

bool Garfield::DriftLineRKF::DriftElectron	(	const double	x0,
		const double	y0,
		const double	z0,
		const double	t0 )

Simulate the drift line of an electron with a given starting point.

Definition at line 143 of file DriftLineRKF.cc.

                                                                   {
  std::vector<std::array<double, 3> > x;
  std::vector<double> t;
  int status = 0;
  const bool ok = DriftLine({x0, y0, z0}, t0, Particle::Electron, 
                            t, x, status);
  if (ok) {
    const size_t nPoints = t.size();
    std::vector<double> ne(nPoints, 1.);
    std::vector<double> ni(nPoints, 0.);
    std::vector<double> nn(nPoints, 0.);
    double scale = 1.;
    if (m_doAvalanche) Avalanche(Particle::Electron, x, ne, ni, nn, scale);
    if (m_doSignal) {
      ComputeSignal(Particle::Electron, scale * m_scaleE, t, x, ne);
    }
    if (m_doAvalanche) {
      if (m_doIonTail) AddIonTail(t, x, ni, scale);
      if (m_doNegativeIonTail) AddNegativeIonTail(t, x, nn, scale);
    }
    m_nE = scale * ne.back();
    m_nI = scale * std::accumulate(ni.begin(), ni.end(), 0.);
  } else {
    m_nE = 0.;
    m_nI = 0.;
  } 
  std::swap(m_x, x);
  std::swap(m_t, t);
  m_particle = Particle::Electron;
  m_status = status;
  return ok;
}

◆ DriftHole()

bool Garfield::DriftLineRKF::DriftHole	(	const double	x0,
		const double	y0,
		const double	z0,
		const double	t0 )

Simulate the drift line of a hole with a given starting point.

Definition at line 250 of file DriftLineRKF.cc.

                                              {
  std::vector<std::array<double, 3> > x;
  std::vector<double> t;
  int status = 0;
  const bool ok = DriftLine({x0, y0, z0}, t0, Particle::Hole, t, x, status);
  if (ok && m_doSignal) {
    ComputeSignal(Particle::Hole, m_scaleH, t, x, {});
  }
  std::swap(m_x, x);
  std::swap(m_t, t);
  m_particle = Particle::Hole;
  m_status = status;
  return ok;
}

◆ DriftIon()

bool Garfield::DriftLineRKF::DriftIon	(	const double	x0,
		const double	y0,
		const double	z0,
		const double	t0 )

Simulate the drift line of an ion with a given starting point.

Definition at line 266 of file DriftLineRKF.cc.

                                             {
  std::vector<std::array<double, 3> > x;
  std::vector<double> t;
  int status = 0;
  const bool ok = DriftLine({x0, y0, z0}, t0, Particle::Ion, t, x, status);
  if (ok && m_doSignal) {
    ComputeSignal(Particle::Ion, m_scaleI, t, x, {});
  }
  std::swap(m_x, x);
  std::swap(m_t, t);
  m_particle = Particle::Ion;
  m_status = status;
  return ok;
}

◆ DriftNegativeIon()

bool Garfield::DriftLineRKF::DriftNegativeIon	(	const double	x0,
		const double	y0,
		const double	z0,
		const double	t0 )

Simulate the drift line of an ion with a given starting point, assuming that it has negative charge.

Definition at line 282 of file DriftLineRKF.cc.

                                                                      {
  std::vector<std::array<double, 3> > x;
  std::vector<double> t;
  int status = 0;
  const bool ok = DriftLine({x0, y0, z0}, t0, Particle::NegativeIon, 
                            t, x, status);
  if (ok && m_doSignal) {
    ComputeSignal(Particle::NegativeIon, m_scaleI, t, x, {});
  }
  std::swap(m_x, x);
  std::swap(m_t, t);
  m_particle = Particle::NegativeIon;
  m_status = status;
  return ok;
}

◆ DriftPositron()

bool Garfield::DriftLineRKF::DriftPositron	(	const double	x0,
		const double	y0,
		const double	z0,
		const double	t0 )

Simulate the drift line of an electron with a given starting point, assuming that it has positive charge.

Definition at line 233 of file DriftLineRKF.cc.

                                                                   {
  std::vector<std::array<double, 3> > x;
  std::vector<double> t;
  int status = 0;
  const bool ok = DriftLine({x0, y0, z0}, t0, Particle::Positron, 
                            t, x, status);
  if (ok && m_doSignal) {
    ComputeSignal(Particle::Positron, m_scaleE, t, x, {});
  }
  std::swap(m_x, x);
  std::swap(m_t, t);
  m_particle = Particle::Positron;
  m_status = status;
  return ok;
}

◆ EnableAvalanche()

void Garfield::DriftLineRKF::EnableAvalanche ( const bool on = true )

inline

Enable/disable simulation electron multiplication (default: on).

Definition at line 69 of file DriftLineRKF.hh.

69{ m_doAvalanche = on; }

◆ EnableDebugging()

void Garfield::DriftLineRKF::EnableDebugging ( const bool on = true )

inline

Switch debugging messages on/off (default: off).

Definition at line 140 of file DriftLineRKF.hh.

140{ m_debug = on; }

◆ EnableIonTail()

void Garfield::DriftLineRKF::EnableIonTail ( const bool on = true )

inline

Enable/disable simulation of the ion tail (default: off).

Definition at line 71 of file DriftLineRKF.hh.

71{ m_doIonTail = on; }

◆ EnableNegativeIonTail()

void Garfield::DriftLineRKF::EnableNegativeIonTail ( const bool on = true )

inline

Enable/disable simulation of the negative ion tail (default: off).

Definition at line 73 of file DriftLineRKF.hh.

73{ m_doNegativeIonTail = on; }

◆ EnablePlotting()

void Garfield::DriftLineRKF::EnablePlotting ( ViewDrift * view )

Switch on drift line plotting.

Definition at line 95 of file DriftLineRKF.cc.

                                                 {
  if (!view) {
    std::cerr << m_className << "::EnablePlotting: Null pointer.\n";
    return;
  }
  m_view = view;
}

◆ EnableSignalCalculation()

void Garfield::DriftLineRKF::EnableSignalCalculation ( const bool on = true )

inline

Switch calculation of induced currents on or off (default: enabled).

Definition at line 36 of file DriftLineRKF.hh.

36{ m_doSignal = on; }

◆ EnableTownsendMap()

void Garfield::DriftLineRKF::EnableTownsendMap ( const bool on = true )

inline

Retrieve the Townsend coefficient from the component.

Definition at line 82 of file DriftLineRKF.hh.

82{ m_useTownsendMap = on; }

◆ EnableVelocityMap()

void Garfield::DriftLineRKF::EnableVelocityMap ( const bool on = true )

inline

Retrieve the drift velocity from the component.

Definition at line 84 of file DriftLineRKF.hh.

84{ m_useVelocityMap = on; }

◆ FieldLine()

bool Garfield::DriftLineRKF::FieldLine	(	const double	xi,
		const double	yi,
		const double	zi,
		std::vector< std::array< float, 3 > > &	xl,
		const bool	electron = true ) const

Compute an electric field line.

Parameters

xi,yi,zi	starting point
xl	points along the field line
electron	flag to set the direction in which to follow the field

Definition at line 1506 of file DriftLineRKF.cc.

                                                        {
 
  xl.clear();
  // Is the sensor set?
  if (!m_sensor) {
    std::cerr << m_className << "::FieldLine: Sensor is not defined.\n";
    return false;
  }
 
  // Get the sensor's bounding box.
  double xmin = 0., xmax = 0.;
  double ymin = 0., ymax = 0.;
  double zmin = 0., zmax = 0.;
  bool bbox = m_sensor->GetArea(xmin, ymin, zmin, xmax, ymax, zmax);
 
  // Set the step size limit if requested.
  double maxStep = -1.;
  if (m_useStepSizeLimit) {
    if (m_maxStepSize > 0.) {
       maxStep = m_maxStepSize;
    } else {
       maxStep = 0.5 * m_sensor->StepSizeHint();
    }
  }
 
  // Make sure the initial position is at a valid location.
  double ex = 0., ey = 0., ez = 0.;
  Medium* medium = nullptr;
  int stat = 0;
  m_sensor->ElectricField(xi, yi, zi, ex, ey, ez, medium, stat);
  if (!medium || stat != 0) {
    std::cerr << m_className << "::FieldLine: "
              << "No valid field at initial position.\n";
    return false;
  }
  Vec x0 = {xi, yi, zi};
  Vec f0 = {ex, ey, ez};
  if (electron) for (auto& f : f0) f *= -1; 
 
  // Set the numerical constants for the RKF integration.
  constexpr double c10 = 214. / 891.;
  constexpr double c11 = 1. / 33.;
  constexpr double c12 = 650. / 891.;
  constexpr double c20 = 533. / 2106.;
  constexpr double c22 = 800. / 1053.;
  constexpr double c23 = -1. / 78.;
 
  constexpr double b10 = 1. / 4.;
  constexpr double b20 = -189. / 800.;
  constexpr double b21 = 729. / 800.;
  constexpr double b30 = 214. / 891.;
  constexpr double b31 = 1. / 33.;
  constexpr double b32 = 650. / 891.;
 
  const double fmag0 = Mag(f0);
  if (fmag0 < Small) {
    std::cerr << m_className << "::FieldLine:\n"
              << "    Zero field at initial position.\n";
    return false;
  }
 
  // Initialise time step and previous time step.
  double h = m_accuracy / fmag0;
  double hprev = h;
  if (m_debug) {
    std::cout << m_className << "::FieldLine:\n"
              << "    Initial step size: " << h << ".\n";
  }
  // Set the initial point.
  xl.push_back({float(x0[0]), float(x0[1]), float(x0[2])});
 
  int initCycle = 3;
  bool ok = true;
  while (ok) {
    // Get the field at the first probe point.
    Vec x1 = x0;
    for (unsigned int i = 0; i < 3; ++i) {
      x1[i] += h * b10 * f0[i];
    }
    m_sensor->ElectricField(x1[0], x1[1], x1[2], ex, ey, ez, medium, stat);
    if (stat != 0) {
      if (m_debug) std::cout << "    Point 1 outside.\n";
      Terminate(x0, x1, xl);
      return true;
    }
    Vec f1 = {ex, ey, ez};
    if (electron) for (auto& f : f1) f *= -1;
    // Get the field at the second probe point.
    Vec x2 = x0;
    for (unsigned int i = 0; i < 3; ++i) {
      x2[i] += h * (b20 * f0[i] + b21 * f1[i]);
    }
    m_sensor->ElectricField(x2[0], x2[1], x2[2], ex, ey, ez, medium, stat);
    if (stat != 0) {
      if (m_debug) std::cout << "    Point 2 outside.\n";
      Terminate(x0, x2, xl);
      return true;
    }
    Vec f2 = {ex, ey, ez};
    if (electron) for (auto& f : f2) f *= -1;
    // Get the field at the third probe point.
    Vec x3 = x0;
    for (unsigned int i = 0; i < 3; ++i) {
      x3[i] += h * (b30 * f0[i] + b31 * f1[i] + b32 * f2[i]);
    }
    m_sensor->ElectricField(x3[0], x3[1], x3[2], ex, ey, ez, medium, stat);
    if (stat != 0) {
      if (m_debug) std::cout << "    Point 3 outside.\n";
      Terminate(x0, x3, xl);
      return true;
    }
    Vec f3 = {ex, ey, ez};
    if (electron) for (auto& f : f3) f *= -1;
    // Check if we crossed a wire.
    double xw = 0., yw = 0., zw = 0., rw = 0.;
    if (m_sensor->CrossedWire(x0[0], x0[1], x0[2], 
                              x1[0], x1[1], x1[2], xw, yw, zw, false, rw) ||
        m_sensor->CrossedWire(x0[0], x0[1], x0[2], 
                              x2[0], x2[1], x2[2], xw, yw, zw, false, rw) ||
        m_sensor->CrossedWire(x0[0], x0[1], x0[2], 
                              x3[0], x3[1], x3[2], xw, yw, zw, false, rw)) {
      // TODO!
      xl.push_back({float(xw), float(yw), float(zw)});
      return true;
      // Drift to wire.
      if (h > Small) {
        h *= 0.5;
        continue;
      } else {
        std::cerr << m_className << "::FieldLine: Step size too small. Stop.\n";
        return false;
      }
    }
    // Calculate the correction terms.
    Vec phi1 = {0., 0., 0.};
    Vec phi2 = {0., 0., 0.};
    for (unsigned int i = 0; i < 3; ++i) {
      phi1[i] = c10 * f0[i] + c11 * f1[i] + c12 * f2[i];
      phi2[i] = c20 * f0[i] + c22 * f2[i] + c23 * f3[i];
    }
    // Check if the step length is valid.
    const double phi1mag = Mag(phi1);
    if (phi1mag < Small) {
      std::cerr << m_className << "::FieldLine: Step has zero length. Stop.\n";
      break;
    } else if (maxStep > 0. && h * phi1mag > maxStep) {
      if (m_debug) {
        std::cout << "    Step is considered too long. H is reduced.\n";
      }
      h = 0.5 * maxStep / phi1mag;
      continue;
    } else if (bbox) {
      // Don't allow h to become too large.
      if (h * fabs(phi1[0]) > 0.1 * fabs(xmax - xmin) ||
          h * fabs(phi1[1]) > 0.1 * fabs(ymax - ymin)) {
        h *= 0.5;
        if (m_debug) {
          std::cout << "    Step is considered too long. H is halved.\n";
        }
        continue;
      }
    }
    if (m_debug) std::cout << "    Step size ok.\n";
    // Update the position.
    for (size_t i = 0; i < 3; ++i) x0[i] += h * phi1[i];
    // Check the new position.
    m_sensor->ElectricField(x0[0], x0[1], x0[2], ex, ey, ez, medium, stat);
    if (stat != 0) {
      // The new position is not inside a valid drift medium.
      // Terminate the drift line.
      if (m_debug) std::cout << "    Point outside. Terminate.\n";
      std::array<double, 3> xp = {xl.back()[0], xl.back()[1], xl.back()[2]};
      Terminate(xp, x0, xl);
      return true;
    }
    // Add the new point to the drift line.
    xl.push_back({float(x0[0]), float(x0[1]), float(x0[2])});
    // Adjust the step size according to the accuracy of the two estimates.
    hprev = h;
    const double dphi = fabs(phi1[0] - phi2[0]) + fabs(phi1[1] - phi2[1]) +
                        fabs(phi1[2] - phi2[2]);
    if (dphi > 0) {
      h = sqrt(h * m_accuracy / dphi);
      if (m_debug) std::cout << "    Adapting H to " << h << ".\n";
    } else {
      h *= 2;
      if (m_debug) std::cout << "    H increased by factor two.\n";
    }
    // Make sure that H is different from zero; this should always be ok.
    if (h < Small) {
      std::cerr << m_className << "::FieldLine: Step size is zero. Stop.\n";
      return false;
    }
    // Check the initial step size.
    if (initCycle > 0 && h < 0.2 * hprev) {
      if (m_debug) std::cout << "    Reinitialise step size.\n";
      --initCycle;
      x0 = {xi, yi, zi};
      xl.clear();
      xl.push_back({float(xi), float(yi), float(zi)});
      continue;
    }
    initCycle = 0;
    // Don't allow H to grow too quickly
    if (h > 10 * hprev) {
      h = 10 * hprev;
      if (m_debug) {
        std::cout << "    H restricted to 10 times the previous value.\n";
      }
    }
    // Stop in case H tends to become too small.
    if (h * (fabs(phi1[0]) + fabs(phi1[1]) + fabs(phi1[2])) < m_accuracy) {
      std::cerr << m_className << "::FieldLine: Step size has become smaller "
                << "than int. accuracy. Stop.\n";
      return false;
    }
    // Update the field.
    f0 = f3;
  }
  return true;
}

Referenced by Garfield::ViewField::PlotFieldLines().

◆ GetArrivalTimeSpread()

double Garfield::DriftLineRKF::GetArrivalTimeSpread ( const double eps = 1.e-4 ) const

Compute the sigma of the arrival time distribution for the current drift line by integrating the longitudinal diffusion coefficient.

Definition at line 735 of file DriftLineRKF.cc.

                                                                {
  return ComputeSigma(m_x, m_particle, eps);
} 

◆ GetAvalancheSize()

void Garfield::DriftLineRKF::GetAvalancheSize	(	double &	ne,
		double &	ni ) const

inline

Definition at line 128 of file DriftLineRKF.hh.

128{ ne = m_nE; ni = m_nI; }

◆ GetDriftLinePoint()

void Garfield::DriftLineRKF::GetDriftLinePoint	(	const size_t	i,
		double &	x,
		double &	y,
		double &	z,
		double &	t ) const

Get the coordinates and time of a point along the most recent drift line.

Definition at line 1287 of file DriftLineRKF.cc.

                                                                 {
  if (i >= m_x.size()) {
    std::cerr << m_className << "::GetDriftLinePoint: Index out of range.\n";
    return;
  }
 
  const auto& p = m_x[i];
  x = p[0];
  y = p[1];
  z = p[2];
  t = m_t[i];
}

◆ GetDriftTime()

double Garfield::DriftLineRKF::GetDriftTime ( ) const

inline

Get the cumulative drift time.

Definition at line 122 of file DriftLineRKF.hh.

                              { 
    return m_t.empty() ? 0. : m_t.back() - m_t.front(); 
  }

◆ GetEndPoint()

void Garfield::DriftLineRKF::GetEndPoint	(	double &	x,
		double &	y,
		double &	z,
		double &	t,
		int &	st ) const

Get the end point and status flag of the most recent drift line.

Definition at line 1272 of file DriftLineRKF.cc.

                                                {
  if (m_x.empty()) {
    x = y = z = t = 0.;
    stat = m_status;
    return;
  }
  const auto& p = m_x.back();
  x = p[0];
  y = p[1];
  z = p[2];
  t = m_t.back();
  stat = m_status;
}

◆ GetGain()

double Garfield::DriftLineRKF::GetGain ( const double eps = 1.e-4 ) const

Compute the multiplication factor for the current drift line.

Definition at line 777 of file DriftLineRKF.cc.

                                                   {
  if (m_status == StatusCalculationAbandoned) return 1.;
  return ComputeGain(m_x, m_particle, eps);
}

◆ GetLoss()

double Garfield::DriftLineRKF::GetLoss ( const double eps = 1.e-4 ) const

Compute the attachment loss factor for the current drift line.

Definition at line 825 of file DriftLineRKF.cc.

                                                   {
  if (m_status == StatusCalculationAbandoned) return 1.;
  return ComputeLoss(m_x, m_particle, eps);
}

◆ GetNumberOfDriftLinePoints()

size_t Garfield::DriftLineRKF::GetNumberOfDriftLinePoints ( ) const

inline

Get the number of points of the most recent drift line.

Definition at line 109 of file DriftLineRKF.hh.

109{ return m_x.size(); }

◆ GetPathLength()

double Garfield::DriftLineRKF::GetPathLength ( ) const

Get the cumulative path length.

Definition at line 871 of file DriftLineRKF.cc.

                                         {
 
  const size_t nPoints = m_x.size();
  if (nPoints < 2) return 0.;
  double path = 0.;
  for (size_t i = 1; i < nPoints; ++i) {
    path += Dist(m_x[i - 1], m_x[i]);
  }
  return path;
}

◆ PrintDriftLine()

void Garfield::DriftLineRKF::PrintDriftLine ( ) const

Print the trajectory of the most recent drift line.

Definition at line 1241 of file DriftLineRKF.cc.

                                        {
 
  std::cout << m_className << "::PrintDriftLine:\n";
  if (m_x.empty()) {
    std::cout << "    No drift line present.\n";
    return;
  }
  if (m_particle == Particle::Electron) {
    std::cout << "    Particle: electron\n";
  } else if (m_particle == Particle::Ion) {
    std::cout << "    Particle: ion\n";
  } else if (m_particle == Particle::Hole) {
    std::cout << "    Particle: hole\n";
  } else if (m_particle == Particle::Positron) {
    std::cout << "    Particle: positive electron\n";
  } else if (m_particle == Particle::NegativeIon) {
    std::cout << "    Particle: negative ion\n";
  } else {
    std::cout << "    Particle: unknown\n";
  }
  std::cout << "    Status: " << m_status << "\n"
            << "  Step       time [ns]        "
            << "x [cm]          y [cm]          z [cm]\n";
  const unsigned int nPoints = m_x.size();
  for (unsigned int i = 0; i < nPoints; ++i) {
    std::printf("%6u %15.7f %15.7f %15.7f %15.7f\n", 
                i, m_t[i], m_x[i][0], m_x[i][1], m_x[i][2]);
  }
 
}

◆ RejectKinks()

void Garfield::DriftLineRKF::RejectKinks ( const bool on = true )

inline

Request (or not) the drift line calculation to be aborted if the drift line makes a bend sharper than 90 degrees.

Definition at line 59 of file DriftLineRKF.hh.

59{ m_rejectKinks = on; }

◆ SetElectronSignalScalingFactor()

void Garfield::DriftLineRKF::SetElectronSignalScalingFactor ( const double scale )

inline

Set multiplication factor for the signal induced by electrons.

Definition at line 62 of file DriftLineRKF.hh.

62{ m_scaleE = scale; }

◆ SetGainFluctuationsFixed()

void Garfield::DriftLineRKF::SetGainFluctuationsFixed ( const double gain = -1. )

Do not randomize the avalanche size.

Definition at line 105 of file DriftLineRKF.cc.

                                                             {
 
  if (gain > 1.) {
    std::cout << m_className << "::SetGainFluctuationsFixed: "
              << "Avalanche size set to " << gain << ".\n";
  } else {
    std::cout << m_className << "::SetGainFluctuationsFixed:\n    "
              << "Avalanche size will be given by "
              << "the integrated Townsend coefficient.\n";
  }
  m_gain = gain; 
  m_gainFluctuations = GainFluctuations::None;
}

◆ SetGainFluctuationsPolya()

void Garfield::DriftLineRKF::SetGainFluctuationsPolya	(	const double	theta,
		const double	mean = -1.,
		const bool	quiet = false )

Sample the avalanche size from a Polya distribution with shape parameter theta.

Definition at line 119 of file DriftLineRKF.cc.

                                                              {
 
  if (theta < 0.) {
    std::cerr << m_className << "::SetGainFluctuationsPolya: "
              << "Shape parameter must be >= 0.\n";
    return;
  }  
  if (!quiet) {
    if (mean > 1.) {
      std::cout << m_className << "::SetGainFluctuationsPolya: "
                << "Mean avalanche size set to " << mean << ".\n";
    } else {
      std::cout << m_className << "::SetGainFluctuationsPolya:\n    "
                << "Mean avalanche size will be given by "
                << "the integrated Townsend coefficient.\n";
    }
  }
  m_gain = mean;
  m_theta = theta;
  m_gainFluctuations = GainFluctuations::Polya;
} 

◆ SetHoleSignalScalingFactor()

void Garfield::DriftLineRKF::SetHoleSignalScalingFactor ( const double scale )

inline

Set multiplication factor for the signal induced by holes.

Definition at line 64 of file DriftLineRKF.hh.

64{ m_scaleH = scale; }

◆ SetIntegrationAccuracy()

void Garfield::DriftLineRKF::SetIntegrationAccuracy ( const double eps )

Set the accuracy of the Runge Kutta Fehlberg drift line integration.

Definition at line 71 of file DriftLineRKF.cc.

                                                          {
  if (eps > 0.) {
    m_accuracy = eps;
  } else {
    std::cerr << m_className << "::SetIntegrationAccuracy:\n"
              << "    Accuracy must be greater than zero.\n";
  }
}

◆ SetIonSignalScalingFactor()

void Garfield::DriftLineRKF::SetIonSignalScalingFactor ( const double scale )

inline

Set multiplication factor for the signal induced by ions.

Definition at line 66 of file DriftLineRKF.hh.

66{ m_scaleI = scale; }

◆ SetMaximumStepSize() [1/2]

void Garfield::DriftLineRKF::SetMaximumStepSize ( )

Try to set an upper limit to the allowable step size based on the feature size of the sensor.

Definition at line 80 of file DriftLineRKF.cc.

                                      {
  m_maxStepSize = -1.;
  m_useStepSizeLimit = true;
}

◆ SetMaximumStepSize() [2/2]

void Garfield::DriftLineRKF::SetMaximumStepSize ( const double ms )

Set (explicitly) the maximum step size that is allowed.

Definition at line 85 of file DriftLineRKF.cc.

                                                     {
  if (ms > 0.) {
    m_maxStepSize = ms;
    m_useStepSizeLimit = true;
  } else {
    std::cerr << m_className << "::SetMaximumStepSize:\n"
              << "    Step size must be greater than zero.\n";
  }
}

Referenced by Garfield::ViewField::PlotFieldLines().

◆ SetSensor()

void Garfield::DriftLineRKF::SetSensor ( Sensor * s )

Set the sensor.

Definition at line 63 of file DriftLineRKF.cc.

                                      {
  if (!s) {
    std::cerr << m_className << "::SetSensor: Null pointer.\n";
    return;
  }
  m_sensor = s;
}

Referenced by Garfield::ViewField::PlotFieldLines().

◆ SetSignalAveragingOrder()

void Garfield::DriftLineRKF::SetSignalAveragingOrder ( const unsigned int navg )

inline

Set the number of points to be used when averaging the delayed signal vector over a time bin in the Sensor class. The averaging is done with a $2\times navg + 1$ point Newton-Raphson integration. Default: 2.

Definition at line 41 of file DriftLineRKF.hh.

41{ m_navg = navg; }

◆ UnsetMaximumStepSize()

void Garfield::DriftLineRKF::UnsetMaximumStepSize ( )

inline

Do not apply an upper limit to the step size that is allowed.

Definition at line 56 of file DriftLineRKF.hh.

56{ m_useStepSizeLimit = false; }

◆ UseWeightingPotential()

void Garfield::DriftLineRKF::UseWeightingPotential ( const bool on = true )

inline

Use the weighting potential (as opposed to the weighting field) for calculating the induced signal.

Definition at line 44 of file DriftLineRKF.hh.

                                                   {
    m_useWeightingPotential = on;
  }

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

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ DriftLineRKF() [1/2]

◆ DriftLineRKF() [2/2]

◆ ~DriftLineRKF()

Member Function Documentation

◆ DisablePlotting()

◆ DriftElectron()

◆ DriftHole()

◆ DriftIon()

◆ DriftNegativeIon()

◆ DriftPositron()

◆ EnableAvalanche()

◆ EnableDebugging()

◆ EnableIonTail()

◆ EnableNegativeIonTail()

◆ EnablePlotting()

◆ EnableSignalCalculation()

◆ EnableTownsendMap()

◆ EnableVelocityMap()

◆ FieldLine()

◆ GetArrivalTimeSpread()

◆ GetAvalancheSize()

◆ GetDriftLinePoint()

◆ GetDriftTime()

◆ GetEndPoint()

◆ GetGain()

◆ GetLoss()

◆ GetNumberOfDriftLinePoints()

◆ GetPathLength()

◆ PrintDriftLine()

◆ RejectKinks()

◆ SetElectronSignalScalingFactor()

◆ SetGainFluctuationsFixed()

◆ SetGainFluctuationsPolya()

◆ SetHoleSignalScalingFactor()

◆ SetIntegrationAccuracy()

◆ SetIonSignalScalingFactor()

◆ SetMaximumStepSize() [1/2]

◆ SetMaximumStepSize() [2/2]

◆ SetSensor()

◆ SetSignalAveragingOrder()

◆ UnsetMaximumStepSize()

◆ UseWeightingPotential()