#include <HeedDeltaElectron.h>

Inheritance diagram for Heed::HeedDeltaElectron:

Public Member Functions
	HeedDeltaElectron ()=default
	Default constructor.

	HeedDeltaElectron (manip_absvol primvol, const point &pt, const vec &vel, vfloat ftime, long fparent_particle_number, HeedFieldMap fieldmap, bool fs_print_listing=false)
	Constructor.

virtual	~HeedDeltaElectron ()
	Destructor.

HeedDeltaElectron *	copy () const override
	Clone the particle.

void	print (std::ostream &file, int l) const override
	Print-out.

Public Member Functions inherited from Heed::eparticle
	eparticle ()=default
	Default constructor.

	eparticle (manip_absvol primvol, const point &pt, const vec &vel, vfloat time, particle_def fpardef, HeedFieldMap *fieldmap)
	Constructor using velocity vector.

virtual	~eparticle ()
	Destructor.

Public Member Functions inherited from Heed::mparticle
	mparticle ()=default
	Default constructor.

	mparticle (manip_absvol *primvol, const point &pt, const vec &vel, vfloat ftime, double fmass)
	Constructor, $\gamma - 1$ calculated from the from velocity vector.

virtual	~mparticle ()
	Destructor.

double	kinetic_energy () const
	Get the current kinetic energy.

void	print (std::ostream &file, int l) const override
	Print-out.

mparticle *	copy () const override
	Clone the particle.

Public Member Functions inherited from Heed::gparticle
	gparticle ()=default
	Default constructor.

	gparticle (manip_absvol *primvol, const point &pt, const vec &vel, vfloat time)
	Constructor.

virtual	~gparticle ()
	Destructor.

virtual void	fly (std::vector< gparticle * > &secondaries)
	Transport the particle.

virtual void	fly (std::vector< gparticle * > &secondaries, const bool one_step)

void	set_step_limits (const vfloat fmax_range, const vfloat frad_for_straight, const vfloat fmax_straight_arange, const vfloat fmax_circ_arange)
	Set limits/parameters for trajectory steps.

const vec &	position () const
	Get the current position of the particle.

vfloat	time () const
	Get the current time of the particle.

const vec &	direction () const
	Get the current direction of the particle.

bool	alive () const
	Alive?

Public Attributes
std::vector< HeedCondElectron >	conduction_electrons

std::vector< HeedCondElectron >	conduction_ions

long	parent_particle_number

Protected Member Functions
void	physics_mrange (double &fmrange) override

void	physics_after_new_speed (std::vector< gparticle * > &secondaries) override
	Apply any other processes (turn the trajectory, kill the particle, ...).

Protected Member Functions inherited from Heed::eparticle
int	force (const point &pt, vec &f, vec &f_perp, vfloat &mrange) override
	Calculate force components.

Protected Member Functions inherited from Heed::mparticle
void	step (std::vector< gparticle * > &secondaries) override

void	curvature (bool &curved, vec &frelcen, vfloat &fmrange, vfloat prec) override

Protected Member Functions inherited from Heed::gparticle
virtual void	change_vol ()
	Move from one volume to another.

virtual void	physics (std::vector< gparticle * > &)
	Apply any other processes (turn the trajectory, kill the particle, ...).

virtual stvpoint	calc_step_to_bord ()
	Determine next position.

void	turn (const double ctheta, const double stheta)
	Change the direction of the particle.

stvpoint	switch_new_vol ()
	Generate next position in new volume.

Additional Inherited Members
Static Public Member Functions inherited from Heed::gparticle
static void	reset_counter ()
	Reset the counter.

Protected Attributes inherited from Heed::eparticle
particle_def *	m_pardef = nullptr

HeedFieldMap *	m_fieldMap = nullptr
	Pointer to field map.

Protected Attributes inherited from Heed::mparticle
double	m_mass = 0.
	Mass (not mass * speed_of_light^2)

double	m_curr_ekin = 0.
	Current kinetic energy.

double	m_orig_ekin = 0.
	Original kinetic energy.

double	m_prev_ekin = 0.
	Previous kinetic energy.

double	m_curr_gamma_1 = 0.
	Current $\gamma - 1$ .

double	m_orig_gamma_1 = 0.
	Original $\gamma - 1$ .

double	m_prev_gamma_1 = 0.
	Previous $\gamma - 1$ .

Protected Attributes inherited from Heed::gparticle
bool	m_alive = false
	Status flag whether the particle is active.

long	m_nstep = 0
	Step number.

long	m_nzero_step = 0
	Number of previous steps with zero range (including this step).

stvpoint	m_origin
	Original point.

double	m_total_range_from_origin = 0.
	Range from origin to current position.

stvpoint	m_prevpos
	Previous point.

stvpoint	m_currpos
	Current point.

stvpoint	m_nextpos
	Next point.

Static Protected Attributes inherited from Heed::gparticle
static std::atomic< long >	s_counter {0L}
	Instance counter.

static constexpr long	m_max_qzero_step = 100
	Max. number of zero-steps allowed.

Detailed Description

Definition of delta-electron which can be traced through the geometry. 2003, I. Smirnov

Definition at line 14 of file HeedDeltaElectron.h.

Constructor & Destructor Documentation

◆ HeedDeltaElectron() [1/2]

Heed::HeedDeltaElectron::HeedDeltaElectron ( )

default

Default constructor.

Referenced by copy().

◆ HeedDeltaElectron() [2/2]

Heed::HeedDeltaElectron::HeedDeltaElectron	(	manip_absvol *	primvol,
		const point &	pt,
		const vec &	vel,
		vfloat	ftime,
		long	fparent_particle_number,
		HeedFieldMap *	fieldmap,
		bool	fs_print_listing = false )

Constructor.

Definition at line 61 of file HeedDeltaElectron.cpp.

    : eparticle(primvol, pt, vel, ftime, &electron_def, fieldmap),
      parent_particle_number(fparent_particle_number),
      m_particle_number(s_counter++),
      m_print_listing(fprint_listing) {
  mfunname("HeedDeltaElectron::HeedDeltaElectron(...)");
}

◆ ~HeedDeltaElectron()

virtual Heed::HeedDeltaElectron::~HeedDeltaElectron ( )

inlinevirtual

Destructor.

Definition at line 23 of file HeedDeltaElectron.h.

23{}

Member Function Documentation

◆ copy()

HeedDeltaElectron * Heed::HeedDeltaElectron::copy ( ) const

inlineoverridevirtual

Clone the particle.

Reimplemented from Heed::eparticle.

Definition at line 25 of file HeedDeltaElectron.h.

                                           {
    return new HeedDeltaElectron(*this);
  }

◆ physics_after_new_speed()

void Heed::HeedDeltaElectron::physics_after_new_speed ( std::vector< gparticle * > & )

overrideprotectedvirtual

Apply any other processes (turn the trajectory, kill the particle, ...).

Reimplemented from Heed::gparticle.

Definition at line 151 of file HeedDeltaElectron.cpp.

                              {
  mfunname("void HeedDeltaElectron::physics_after_new_speed()");
  if (m_print_listing) {
    mcout << "HeedDeltaElectron::physics_after_new_speed\n";
    Iprint2n(mcout, m_currpos.prange, m_curr_ekin);
  }
  check_econd11(vecerror, != 0, mcerr);
  if (m_currpos.prange <= 0.0) {
    if (m_curr_ekin <= 0.0) {
      // Get local volume.
      absvol* av = m_currpos.volume();
      if (av && av->s_sensitive && m_fieldMap->inside(m_currpos.ptloc)) {
        if (m_print_listing) mcout << "Convert to conduction electron.\n";
        conduction_electrons.emplace_back(
            HeedCondElectron(m_currpos.ptloc, m_currpos.time));
      }
      m_alive = false;
    }
    if (m_print_listing) mcout << "exit due to currpos.prange <= 0.0\n";
    return;
  }
  // Get local volume and convert it to a cross-section object.
  const absvol* av = m_currpos.volume();
  auto hdecs = dynamic_cast<const HeedDeltaElectronCS*>(av);
  if (!hdecs) return;
  double ek = m_curr_ekin / MeV;
  if (m_print_listing) {
    Iprintnf(mcout, ek);
    Iprint3n(mcout, m_stop_eloss, m_phys_mrange, m_currpos.prange);
  }
  // Calculate dE/dx and energy loss. Update the kinetic energy.
  double dedx;
  double Eloss = 0.;
  if (m_stop_eloss && m_phys_mrange == m_currpos.prange) {
    Eloss = m_curr_ekin;
    m_curr_ekin = 0.0;
    dedx = Eloss / m_currpos.prange / (MeV / cm);
  } else {
    EnergyMesh* emesh = hdecs->hmd->energy_mesh;
    dedx = interpolate(emesh, ek, hdecs->eLoss);
    Eloss = std::min(m_currpos.prange * dedx * MeV / cm, m_curr_ekin);
    m_total_eloss += Eloss;
    m_curr_ekin -= Eloss;
  }
  if (m_print_listing)
    Iprint3nf(mcout, m_prev_ekin / eV, m_curr_ekin / eV, Eloss / eV);
  if (m_curr_ekin <= 0.0) {
    if (m_print_listing) mcout << "m_curr_ekin <= 0.0\n";
    m_curr_ekin = 0.0;
    m_curr_gamma_1 = 0.0;
    m_currpos.speed = 0.0;
    m_alive = false;
  } else {
    const double resten = m_mass * c_squared;
    m_curr_gamma_1 = m_curr_ekin / resten;
    m_currpos.speed = c_light * lorbeta(m_curr_gamma_1);
  }
  absvol* vav = m_currpos.volume();
  if (vav && vav->s_sensitive) {
    if (m_print_listing) {
      mcout << "volume is sensitive\n";
      Iprint2nf(mcout, Eloss / eV, m_necessary_energy / eV);
    }
    if (Eloss > 0.0) ionisation(Eloss, dedx, hdecs->pairprod);
  }
  if (m_print_listing) {
    mcout << '\n';
    Iprintn(mcout, m_alive);
  }
  if (!m_alive) {
    // Done tracing the delta electron. Create the last conduction electron.
    vav = m_currpos.volume();
    if (vav && vav->s_sensitive && m_fieldMap->inside(m_currpos.ptloc)) {
      if (m_print_listing) mcout << "Last conduction electron\n";
      conduction_electrons.emplace_back(
          HeedCondElectron(m_currpos.ptloc, m_currpos.time));
    }
    return;
  }
 
  if (m_print_listing) mcout << "\nstart to rotate by low angle\n";
  double ek_restr = std::max(ek, 0.0005);
  if (m_print_listing) Iprint2nf(mcout, m_currpos.prange, m_phys_mrange);
  if (m_currpos.prange < m_phys_mrange) {
    // recalculate scatterings
    m_path_length = false;
    if (s_low_mult_scattering) {
      EnergyMesh* emesh = hdecs->hmd->energy_mesh;
      const double low_path_length = interpolate(emesh, ek_restr, hdecs->low_lambda) * cm;
      if (m_print_listing) Iprintnf(mcout, low_path_length / cm);
      m_mult_low_path_length = false;
      m_q_low_path_length = m_currpos.prange / low_path_length;
      if (m_print_listing) Iprintnf(mcout, m_q_low_path_length);
    }
  }
  if (m_print_listing) Iprintnf(mcout, m_q_low_path_length);
#ifdef RANDOM_POIS
  if (m_q_low_path_length > 0.0) {
    m_q_low_path_length = pois(m_q_low_path_length);
    if (m_print_listing) {
      mcout << "After pois:\n";
      Iprintnf(mcout, m_q_low_path_length);
    }
  }
#endif
  if (m_q_low_path_length > 0) {
    if (s_direct_low_if_little && m_q_low_path_length < 5) {
      // direct modeling
      if (m_print_listing) {
        mcout << "direct modeling of low scatterings\n";
        Iprint(mcout, m_currpos.dir);
      }
      EnergyMesh* emesh = hdecs->hmd->energy_mesh;
      const long n1r = findInterval(emesh, ek_restr);
      for (long nscat = 0; nscat < m_q_low_path_length; ++nscat) {
        if (m_print_listing) Iprintn(mcout, nscat);
        const double theta =
            hdecs->low_angular_points_ran[n1r].ran(SRANLUX()) * degree;
        if (m_print_listing) Iprintnf(mcout, theta);
        turn(cos(theta), sin(theta));
      }
    } else {
      const double sigma = hdecs->get_sigma(ek_restr, m_q_low_path_length);
      // actually it is mean(1-cos(theta)) or
      // sqrt(mean(square(1-cos(theta)))) depending on USE_MEAN_COEF
      if (m_print_listing) Iprintnf(mcout, sigma);
      // Gauss:
      // double ctheta = 1.0 - fabs(rnorm_improved() * sigma);
      // Exponential distribution fits better:
#ifdef USE_MEAN_COEF
      const double ctheta = sample_ctheta(sigma);
#else
      const double ctheta = sample_ctheta(sigma / sqrt(2.));
#endif
      if (m_print_listing) Iprintnf(mcout, ctheta);
      const double theta = acos(ctheta);
      if (m_print_listing) Iprint2nf(mcout, theta, theta / degree);
      turn(ctheta, sin(theta));
    }
  }
  if (m_path_length) {
    if (m_print_listing) {
      mcout << "\nstarting to rotate by large angle" << std::endl;
      Iprintnf(mcout, m_path_length);
    }
    EnergyMesh* emesh = hdecs->hmd->energy_mesh;
    const long n1r = findInterval(emesh, ek_restr);
    const double theta = hdecs->angular_points_ran[n1r].ran(SRANLUX()) * degree;
    if (m_print_listing) Iprintnf(mcout, theta);
    turn(cos(theta), sin(theta));
  }
  if (m_print_listing) Iprint2nf(mcout, m_currpos.dir, m_currpos.dirloc);
}

◆ physics_mrange()

void Heed::HeedDeltaElectron::physics_mrange ( double & fmrange )

overrideprotectedvirtual

Reduce the maximal possible range due to continuous processes. Called from calc_step_to_bord after the call of curvature. but before considering the crossing with volumes. Therefore mrange may be reduced after this.

Reimplemented from Heed::gparticle.

Definition at line 73 of file HeedDeltaElectron.cpp.

                                                      {
  mfunname("void HeedDeltaElectron::physics_mrange(double& fmrange)");
  if (m_print_listing) mcout << "HeedDeltaElectron::physics_mrange\n";
 
  m_mult_low_path_length = false;
  m_q_low_path_length = 0.0;
  m_path_length = false;
  if (fmrange <= 0.0) return;
  if (m_curr_ekin <= 0.0) {
    fmrange = 0.0;
    return;
  }
  // Get local volume and convert it to a cross-section object.
  const absvol* av = m_currpos.volume();
  auto hdecs = dynamic_cast<const HeedDeltaElectronCS*>(av);
  if (!hdecs) return;
  if (m_print_listing) Iprintnf(mcout, fmrange);
  const double ek = m_curr_ekin / MeV;
  // Get the dE/dx at this kinetic energy.
  EnergyMesh* emesh = hdecs->hmd->energy_mesh;
  const double dedx = interpolate(emesh, ek, hdecs->eLoss);
  // Min. loss 50 eV.
  double eloss = std::max(0.1 * ek, 0.00005);
  if (eloss > ek) {
    eloss = ek;
    m_stop_eloss = true;
  } else {
    m_stop_eloss = false;
  }
  fmrange = std::min(fmrange, (eloss / dedx) * cm);
  if (m_print_listing) Iprint2nf(mcout, fmrange, ek);
  const double ek_restr = std::max(ek, 0.0005);
  if (m_print_listing) Iprintnf(mcout, ek_restr / keV);
 
  double low_path_length = 0.;  // in internal units
  if (s_low_mult_scattering) {
    low_path_length = interpolate(emesh, ek_restr, hdecs->low_lambda) * cm;
    if (m_print_listing) Iprintnf(mcout, low_path_length / cm);
    long qscat = hdecs->eesls->get_qscat();
    const double sigma_ctheta = hdecs->get_sigma(ek_restr, qscat);
    // Reduce the number of scatterings, if the angle is too large.
    if (sigma_ctheta > 0.3) qscat = long(qscat * 0.3 / sigma_ctheta);
    const double mult_low_path_length = qscat * low_path_length;
    if (m_print_listing) Iprintnf(mcout, mult_low_path_length);
    if (fmrange > mult_low_path_length) {
      fmrange = mult_low_path_length;
      m_mult_low_path_length = true;
      m_q_low_path_length = hdecs->eesls->get_qscat();
      m_stop_eloss = false;
    } else {
      m_mult_low_path_length = false;
      m_q_low_path_length = fmrange / low_path_length;
    }
    if (m_print_listing) Iprint2nf(mcout, fmrange, m_q_low_path_length);
  }
 
  if (s_high_mult_scattering) {
    const double mean_path = interpolate(emesh, ek_restr, hdecs->lambda);
    if (m_print_listing) Iprintnf(mcout, mean_path);
    const double path_length = -mean_path * cm * log(1.0 - SRANLUX());
    if (m_print_listing) Iprintnf(mcout, path_length);
    if (fmrange > path_length) {
      fmrange = path_length;
      m_path_length = true;
      m_mult_low_path_length = true;
      if (s_low_mult_scattering) {
        m_q_low_path_length = fmrange / low_path_length;
        if (m_print_listing) Iprintnf(mcout, m_q_low_path_length);
      }
      m_stop_eloss = false;
    } else {
      m_path_length = false;
    }
    if (m_print_listing) Iprintnf(mcout, fmrange);
  }
  m_phys_mrange = fmrange;
}

◆ print()

void Heed::HeedDeltaElectron::print	(	std::ostream &	file,
		int	l ) const

overridevirtual

Print-out.

Reimplemented from Heed::eparticle.

Definition at line 358 of file HeedDeltaElectron.cpp.

                                                           {
  if (l < 0) return;
  file << "HeedDeltaElectron: particle_number=" << m_particle_number << "\n";
  if (l <= 1) return;
  file << " s_low_mult_scattering=" << s_low_mult_scattering
       << " s_high_mult_scattering=" << s_high_mult_scattering << '\n'
       << " phys_mrange=" << m_phys_mrange 
       << " stop_eloss=" << m_stop_eloss
       << " mult_low_path_length=" << m_mult_low_path_length << '\n'
       << " q_low_path_length=" << m_q_low_path_length
       << " path_length=" << m_path_length
       << " necessary_energy/eV=" << m_necessary_energy / eV << '\n'
       << " parent_particle_number=" << parent_particle_number << '\n';
  mparticle::print(file, l - 1);
}

Member Data Documentation

◆ conduction_electrons

std::vector<HeedCondElectron> Heed::HeedDeltaElectron::conduction_electrons

Definition at line 30 of file HeedDeltaElectron.h.

Referenced by physics_after_new_speed(), and Garfield::TrackHeed::TransportDeltaElectron().

◆ conduction_ions

std::vector<HeedCondElectron> Heed::HeedDeltaElectron::conduction_ions

Definition at line 31 of file HeedDeltaElectron.h.

Referenced by Garfield::TrackHeed::TransportDeltaElectron().

◆ parent_particle_number

long Heed::HeedDeltaElectron::parent_particle_number

Definition at line 33 of file HeedDeltaElectron.h.

Referenced by HeedDeltaElectron(), and print().

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

Public Member Functions

Public Attributes

Protected Member Functions

Additional Inherited Members