Heed::HeedPhoton Class Reference

#include <HeedPhoton.h>

Inheritance diagram for Heed::HeedPhoton:

Public Member Functions
	HeedPhoton ()=default
	Default constructor.
	HeedPhoton (manip_absvol *primvol, const point &pt, const vec &vel, vfloat time, long fparent_particle_number, double fenergy, HeedFieldMap *fieldmap, const bool fs_print_listing=false)
	Constructor.
virtual	~HeedPhoton ()
	Destructor.
void	print (std::ostream &file, int l) const override
	Print-out.
HeedPhoton *	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.
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.
virtual void	print (std::ostream &file, int l) const
	Print-out.
virtual gparticle *	copy () const
	Clone the particle.

Public Attributes
long	m_particle_number
long	m_parent_particle_number
double	m_energy
	Photon energy [MeV].
bool	m_photon_absorbed = false
long	m_na_absorbing
	Index of absorbing atom.
long	m_ns_absorbing
	Index of absorbing shell.
bool	m_delta_generated = false
	Flag that delta-electrons are already generated (or cannot be created).

Protected Member Functions
void	physics_after_new_speed (std::vector< gparticle * > &secondaries) override
	Apply any other processes (turn the trajectory, kill the particle, ...).
void	physics (std::vector< gparticle * > &secondaries) override
	Apply any other processes (turn the trajectory, kill the particle, ...).
Protected Member Functions inherited from Heed::gparticle
virtual void	step (std::vector< gparticle * > &secondaries)
virtual void	change_vol ()
	Move from one volume to another.
virtual void	curvature (bool &curved, vec &frelcen, vfloat &fmrange, vfloat prec)
virtual void	physics_after_new_speed (std::vector< gparticle * > &)
	Apply any other processes (turn the trajectory, kill the particle, ...).
virtual void	physics (std::vector< gparticle * > &)
	Apply any other processes (turn the trajectory, kill the particle, ...).
virtual void	physics_mrange (double &fmrange)
virtual stvpoint	calc_step_to_bord ()
	Determine next position.
stvpoint	switch_new_vol ()
	Generate next position in new volume.

Additional Inherited Members
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 constexpr long	m_max_qzero_step = 100
	Max. number of zero-steps allowed.

Detailed Description

Definition of the photon which can be emitted at atomic relaxation cascades and traced through the geometry. 2003, I. Smirnov

Definition at line 18 of file HeedPhoton.h.

Constructor & Destructor Documentation

HeedPhoton() [1/2]

Heed::HeedPhoton::HeedPhoton ( )

default

Default constructor.

Referenced by copy(), and physics_after_new_speed().

HeedPhoton() [2/2]

Heed::HeedPhoton::HeedPhoton	(	manip_absvol *	primvol,
		const point &	pt,
		const vec &	vel,
		vfloat	time,
		long	fparent_particle_number,
		double	fenergy,
		HeedFieldMap *	fieldmap,
		const bool	fs_print_listing = false
	)

Constructor.

Definition at line 23 of file HeedPhoton.cpp.

    : gparticle(primvol, pt, vel, ftime),
      m_particle_number(last_particle_number++),
      m_parent_particle_number(fparent_particle_number),
      m_energy(fenergy),
#ifdef SFER_PHOTOEL
      s_sfer_photoel(0),
#endif
      m_print_listing(fs_print_listing),
      m_fieldMap(fieldmap) {
  mfunname("HeedPhoton::HeedPhoton(...)");
  double length_vel = vel.length();
  check_econd11(fabs(length_vel - c_light) / (length_vel + c_light), > 1.0e-10,
                mcerr);
}

~HeedPhoton()

virtual Heed::HeedPhoton::~HeedPhoton ( )

inlinevirtual

Destructor.

Definition at line 27 of file HeedPhoton.h.

{}

Member Function Documentation

copy()

HeedPhoton * Heed::HeedPhoton::copy ( ) const

inlineoverridevirtual

Clone the particle.

Reimplemented from Heed::gparticle.

Definition at line 30 of file HeedPhoton.h.

{ return new HeedPhoton(*this); }

physics()

void Heed::HeedPhoton::physics ( std::vector< gparticle * > &  )

overrideprotectedvirtual

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

Reimplemented from Heed::gparticle.

Definition at line 42 of file HeedPhoton.cpp.

                                                 {
  mfunname("void HeedPhoton::physics()");
  if (m_print_listing) mcout << "HeedPhoton::physics() starts\n";
  // Stop here if the photon has already been absorbed.
  if (m_photon_absorbed) return;
  if (m_nextpos.prange <= 0.0) return;
  // Get least address of volume
  const absvol* av = m_currpos.tid.G_lavol();
  HeedMatterDef* hmd = nullptr;
  auto etcs = dynamic_cast<const EnTransfCS*>(av);
  if (etcs) {
    hmd = etcs->hmd;
  } else {
    auto hdecs = dynamic_cast<const HeedDeltaElectronCS*>(av);
    if (hdecs) hmd = hdecs->hmd;
  }
  // Stop here if we couldn't retrieve the material definition.
  if (!hmd) return;
  // Sum up the cross-sections.
  std::vector<double> cs;
  std::vector<long> nat;
  std::vector<long> nsh;
  double s = 0.0;
  const long qa = hmd->matter->qatom();
  for (long na = 0; na < qa; na++) {
    const long qs = hmd->apacs[na]->get_qshell();
    const double awq = hmd->matter->weight_quan(na);
    for (long ns = 0; ns < qs; ns++) {
      cs.push_back(hmd->apacs[na]->get_ICS(ns, m_energy) * awq);
      // threshold is taken into account in apacs[na]->get_ACS(ns,..)
      nat.push_back(na);
      nsh.push_back(ns);
      s += cs.back();
    }
  }
  if (m_print_listing) Iprintn(mcout, s);
  // Multiply with the density and calculate the path length.
  // s = s * hmd->eldens / hmd->matter->Z_mean() * C1_MEV_CM;
  s = s * 1.0e-18 * Avogadro / (hmd->matter->A_mean() / (gram / mole)) *
      hmd->matter->density() / (gram / cm3);
  if (m_print_listing) Iprintn(mcout, s);
  const double path_length = 1.0 / s;  // cm
  if (m_print_listing) Iprint2n(mcout, m_energy, path_length);
  // Draw a random step length.
  const double xleng = -path_length * log(1.0 - SRANLUX());
  if (m_print_listing) Iprint2n(mcout, xleng, m_nextpos.prange / cm);
  if (xleng * cm < m_nextpos.prange) {
    m_photon_absorbed = true;
#ifdef SFER_PHOTOEL
    // Assume that virtual photons are already
    // absorbed and s_sfer_photoel is 0 for them
    s_sfer_photoel = 1;  
#endif
    // Sample the shell.
    chispre(cs);
    const double r = chisran(SRANLUX(), cs);
    const long n = std::min(std::max(long(r), 0L), long(cs.size() - 1));
    if (m_print_listing) Iprintn(mcout, n);
    m_na_absorbing = nat[n];
    m_ns_absorbing = nsh[n];
    m_nextpos.prange = xleng * cm;
    m_nextpos.pt = m_currpos.pt + m_nextpos.prange * m_currpos.dir;
    m_nextpos.ptloc = m_nextpos.pt;
    m_nextpos.tid.up_absref(&m_nextpos.ptloc);
  }
}

physics_after_new_speed()

void Heed::HeedPhoton::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 109 of file HeedPhoton.cpp.

                                                                           {
  mfunname("void HeedPhoton::physics_after_new_speed()");
  if (m_print_listing) mcout << "HeedPhoton::physics_after_new_speed starts\n";
  // Stop if the photon has not been absorbed.
  if (!m_photon_absorbed) return;
  // Stop if the delta electrons have already been generated.
  if (m_delta_generated) return;
  // Get least address of volume
  const absvol* av = m_currpos.tid.G_lavol();
  HeedMatterDef* hmd = nullptr;
  auto etcs = dynamic_cast<const EnTransfCS*>(av);
  if (etcs) {
    hmd = etcs->hmd;
  } else {
    auto hdecs = dynamic_cast<const HeedDeltaElectronCS*>(av);
    if (hdecs) hmd = hdecs->hmd;
  }
  // Stop here if we couldn't retrieve the material definition.
  if (!hmd) return;
  // Generate delta-electrons.
  std::vector<double> el_energy;
  std::vector<double> ph_energy;
  hmd->apacs[m_na_absorbing]
      ->get_escape_particles(m_ns_absorbing, m_energy, el_energy, ph_energy);
  if (m_print_listing) {
    mcout << "The condition:\n";
    Iprint2n(mcout, m_na_absorbing, m_ns_absorbing);
    mcout << "The decay products:\n";
    for (unsigned int k = 0; k < el_energy.size(); ++k)
      mcout << el_energy[k] << "\n";
    for (unsigned int k = 0; k < ph_energy.size(); ++k)
      mcout << ph_energy[k] << "\n";
  }
  const long qel = el_energy.size();
  for (long nel = 0; nel < qel; nel++) {
    vec vel = m_currpos.dir;
    if (nel == 0) {  
      // The first in the list should be the photoelectron.
#ifdef SFER_PHOTOEL
      if (s_sfer_photoel == 1) {
        vel.random_sfer_vec();
      } else {
        vel = m_currpos.dir;
      }
#else
      vel = m_currpos.dir;  // direction is OK
#endif
    } else {
      vel.random_sfer_vec();
    }
    const double gam_1 = el_energy[nel] / electron_mass_c2;
    const double inv = 1.0 / (gam_1 + 1.0);
    const double beta = sqrt(1.0 - inv * inv);
    const double mod_v = beta * c_light;
    vel = vel * mod_v;
    if (m_print_listing) {
      mcout << "Initializing delta electron\n";
      Iprint4n(mcout, el_energy[nel], gam_1, beta, mod_v);
    }
    HeedDeltaElectron* hd =
        new HeedDeltaElectron(m_currpos.tid.eid[0], m_currpos.pt, vel,
                              m_currpos.time, m_particle_number, m_fieldMap);
    secondaries.push_back(hd);
  }
  const long qph = ph_energy.size();
  for (long nph = 0; nph < qph; nph++) {
    vec vel;
    vel.random_sfer_vec();
    vel *= c_light;
    if (m_print_listing) {
      mcout << "Initializing photon\n";
      Iprint2n(mcout, el_energy[nph], vel);
    }
    HeedPhoton* hp = new HeedPhoton(m_currpos.tid.eid[0], m_currpos.pt,
                                    vel, m_currpos.time, m_particle_number,
                                    ph_energy[nph], m_fieldMap);
    secondaries.push_back(hp);
  }
  m_delta_generated = true;
  m_alive = false;
  if (m_print_listing) mcout << "HeedPhoton::physics_after_new_speed exited\n";
}

print()

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

overridevirtual

Print-out.

Reimplemented from Heed::gparticle.

Definition at line 192 of file HeedPhoton.cpp.

                                                    {
  if (l < 0) return;
  Ifile << "HeedPhoton (l=" << l << "): particle_number=" << m_particle_number
        << " energy=" << m_energy << "MeV\n";
  if (l == 1) return;
  indn.n += 2;
  Ifile << "s_photon_absorbed=" << m_photon_absorbed
        << " na_absorbing=" << m_na_absorbing 
        << " ns_absorbing=" << m_ns_absorbing
        << " s_delta_generated=" << m_delta_generated
#ifdef SFER_PHOTOEL
        << " s_sfer_photoel=" << s_sfer_photoel
#endif
        << " parent_particle_number=" << m_parent_particle_number
        << " s_print_listing=" << m_print_listing << '\n';
  gparticle::print(file, l - 1);
  indn.n -= 2;
}

Member Data Documentation

m_delta_generated

bool Heed::HeedPhoton::m_delta_generated = false

Flag that delta-electrons are already generated (or cannot be created).

Definition at line 51 of file HeedPhoton.h.

Referenced by Heed::HeedParticle::physics(), Heed::HeedParticle_BGM::physics(), physics_after_new_speed(), and print().

m_energy

double Heed::HeedPhoton::m_energy

Photon energy [MeV].

Definition at line 36 of file HeedPhoton.h.

Referenced by Garfield::TrackHeed::GetCluster(), physics(), physics_after_new_speed(), and print().

m_na_absorbing

long Heed::HeedPhoton::m_na_absorbing

Index of absorbing atom.

Definition at line 42 of file HeedPhoton.h.

Referenced by Heed::HeedParticle::physics(), Heed::HeedParticle_BGM::physics(), physics(), physics_after_new_speed(), and print().

m_ns_absorbing

long Heed::HeedPhoton::m_ns_absorbing

Index of absorbing shell.

Definition at line 44 of file HeedPhoton.h.

Referenced by Heed::HeedParticle::physics(), Heed::HeedParticle_BGM::physics(), physics(), physics_after_new_speed(), and print().

m_parent_particle_number

long Heed::HeedPhoton::m_parent_particle_number

Definition at line 33 of file HeedPhoton.h.

Referenced by print().

m_particle_number

long Heed::HeedPhoton::m_particle_number

Definition at line 32 of file HeedPhoton.h.

Referenced by physics_after_new_speed(), and print().

m_photon_absorbed

bool Heed::HeedPhoton::m_photon_absorbed = false

Flag whether the photon has been absorbed. Used in physics_after_new_speed.

Definition at line 40 of file HeedPhoton.h.

Referenced by Heed::HeedParticle::physics(), Heed::HeedParticle_BGM::physics(), physics(), physics_after_new_speed(), and print().

---

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

• HeedPhoton.h
• HeedPhoton.cpp