Heed::HeedPhoton Class Reference

#include <HeedPhoton.h>

Inheritance diagram for Heed::HeedPhoton:

Public Member Functions
	HeedPhoton ()
	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.
virtual void	physics_after_new_speed (std::vector< gparticle * > &secondaries)
virtual void	physics (std::vector< gparticle * > &secondaries)
virtual void	print (std::ostream &file, int l) const
virtual HeedPhoton *	copy () const
Public Member Functions inherited from Heed::gparticle
	gparticle ()
	Default constructor.
	gparticle (manip_absvol *primvol, const point &pt, const vec &vel, vfloat time)
	Constructor.
virtual	~gparticle ()
	Destructor.
virtual void	step (std::vector< gparticle * > &secondaries)
virtual void	change_vol (void)
virtual void	curvature (int &fs_cf, vec &frelcen, vfloat &fmrange, vfloat prec)
virtual void	physics_after_new_speed (std::vector< gparticle * > &)
virtual void	physics (std::vector< gparticle * > &)
virtual void	physics_mrange (double &fmrange)
virtual stvpoint	calc_step_to_bord ()
	Produces nextpos.
stvpoint	switch_new_vol ()
virtual void	fly (std::vector< gparticle * > &secondaries)
	Transport the particle.
virtual void	print (std::ostream &file, int l) const
virtual gparticle *	copy () const
Public Member Functions inherited from Heed::RegPassivePtr
	RegPassivePtr (void)
	RegPassivePtr (char fs_ban_del, char fs_ban_sub, char fs_ban_cop=0)
	RegPassivePtr (const RegPassivePtr &f)
RegPassivePtr &	operator= (const RegPassivePtr &f)
CountPP_ns::CountPassivePtr *	book (void) const
void	clear_pointers (void) const
virtual RegPassivePtr *	copy () const
virtual	~RegPassivePtr ()
virtual void	print (std::ostream &file, int l=1) const
void	set_s_ban_del (char fs_ban_del)
char	get_s_ban_del (void) const
void	set_s_ban_sub (char fs_ban_sub)
char	get_s_ban_sub (void) const
void	set_s_ban_cop (char fs_ban_cop)
char	get_s_ban_cop (void) const
void	set_s_allow_del_at_zero_count (char fs_allow_del_at_zero_count)
char	get_s_allow_del_at_zero_count (void) const
long	get_total_number_of_references (void) const

Public Attributes
long	particle_number
long	parent_particle_number
double	energy
	Photon energy [MeV].
bool	s_photon_absorbed
long	na_absorbing
	Index of absorbing atom.
long	ns_absorbing
	Index of absorbing shell.
bool	s_delta_generated
	Flag that delta-electrons are already generated (or cannot be created).
Public Attributes inherited from Heed::gparticle
bool	s_life
long	nstep
	Step number.
double	total_range_from_origin
	Range from origin to currpos.
long	n_zero_step
	Number of previous steps with zero range (including this step).
stvpoint	origin
stvpoint	prevpos
stvpoint	currpos
stvpoint	nextpos
vec	curr_relcen

Additional Inherited Members
Static Public Member Functions inherited from Heed::RegPassivePtr
static void	set_s_ban_del_ignore (char fs_ban_del_ignore)
static char	get_s_ban_del_ignore (void)
static void	set_s_print_adr_cpp (char fs_print_adr_cpp)
static char	get_s_print_adr_cpp (void)
Static Public Attributes inherited from Heed::gparticle
static long	max_q_zero_step = 100

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

inline

Default constructor.

Definition at line 21 of file HeedPhoton.h.

: gparticle(), m_fieldMap(NULL) {}

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, time),
      particle_number(last_particle_number++),
      parent_particle_number(fparent_particle_number),
      energy(fenergy),
      s_photon_absorbed(false),
#ifdef SFER_PHOTOEL
      s_sfer_photoel(0),
#endif
      s_delta_generated(false),
      s_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()

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

inlinevirtual

Reimplemented from Heed::gparticle.

Definition at line 32 of file HeedPhoton.h.

{ return new HeedPhoton(*this); }

physics()

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

virtual

Reimplemented from Heed::gparticle.

Definition at line 44 of file HeedPhoton.cpp.

                                                 {
  mfunname("void HeedPhoton::physics()");
  if (s_print_listing) mcout << "HeedPhoton::physics() starts\n";
  // Stop here if the photon has already been absorbed.
  if (s_photon_absorbed) return;
  if (nextpos.prange <= 0.0) return;
  // Get least address of volume
  const absvol* av = currpos.tid.G_lavol();
  HeedMatterDef* hmd = NULL;
  const EnTransfCS* etcs = dynamic_cast<const EnTransfCS*>(av);
  if (etcs) {
    hmd = etcs->hmd.getver();
  } else {
    const HeedDeltaElectronCS* hdecs =
        dynamic_cast<const HeedDeltaElectronCS*>(av);
    if (hdecs) hmd = hdecs->hmd.get();
  }
  // 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, 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 (s_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 (s_print_listing) Iprintn(mcout, s);
  const double path_length = 1.0 / s;  // cm
  if (s_print_listing) Iprint2n(mcout, energy, path_length);
  // Draw a random step length.
  const double xleng = -path_length * log(1.0 - SRANLUX());
  if (s_print_listing) Iprint2n(mcout, xleng, nextpos.prange / cm);
  if (xleng * cm < nextpos.prange) {
    s_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 (s_print_listing) Iprintn(mcout, n);
    na_absorbing = nat[n];
    ns_absorbing = nsh[n];
    nextpos.prange = xleng * cm;
    nextpos.pt = currpos.pt + nextpos.prange * currpos.dir;
    nextpos.ptloc = nextpos.pt;
    nextpos.tid.up_absref(&nextpos.ptloc);
  }
}

physics_after_new_speed()

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

virtual

Reimplemented from Heed::gparticle.

Definition at line 112 of file HeedPhoton.cpp.

                                                                           {
  mfunname("void HeedPhoton::physics_after_new_speed()");
  if (s_print_listing) mcout << "HeedPhoton::physics_after_new_speed starts\n";
  // Stop if the photon has not been absorbed.
  if (!s_photon_absorbed) return;
  // Stop if the delta electrons have already been generated.
  if (s_delta_generated) return;
  // Get least address of volume
  const absvol* av = currpos.tid.G_lavol();
  HeedMatterDef* hmd = NULL;
  const EnTransfCS* etcs = dynamic_cast<const EnTransfCS*>(av);
  if (etcs) {
    hmd = etcs->hmd.getver();
  } else {
    const HeedDeltaElectronCS* hdecs =
        dynamic_cast<const HeedDeltaElectronCS*>(av);
    if (hdecs) hmd = hdecs->hmd.get();
  }
  // 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[na_absorbing]
      ->get_escape_particles(ns_absorbing, energy, el_energy, ph_energy);
  if (s_print_listing) {
    mcout << "The condition:\n";
    Iprint2n(mcout, na_absorbing, 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 = 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 = currpos.dir;
      }
#else
      vel = 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 (s_print_listing) {
      mcout << "Initializing delta electron\n";
      Iprint4n(mcout, el_energy[nel], gam_1, beta, mod_v);
    }
    HeedDeltaElectron* hd =
        new HeedDeltaElectron(currpos.tid.eid[0].getver(), currpos.pt, vel,
                              currpos.time, 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 (s_print_listing) {
      mcout << "Initializing photon\n";
      Iprint2n(mcout, el_energy[nph], vel);
    }
    HeedPhoton* hp = new HeedPhoton(currpos.tid.eid[0].getver(), currpos.pt,
                                    vel, currpos.time, particle_number,
                                    ph_energy[nph], m_fieldMap);
    secondaries.push_back(hp);
  }
  s_delta_generated = true;
  s_life = false;
  if (s_print_listing) mcout << "HeedPhoton::physics_after_new_speed exited\n";
}

print()

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

virtual

Reimplemented from Heed::gparticle.

Definition at line 196 of file HeedPhoton.cpp.

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

Member Data Documentation

energy

double Heed::HeedPhoton::energy

Photon energy [MeV].

Definition at line 37 of file HeedPhoton.h.

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

na_absorbing

long Heed::HeedPhoton::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().

ns_absorbing

long Heed::HeedPhoton::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().

parent_particle_number

long Heed::HeedPhoton::parent_particle_number

Definition at line 35 of file HeedPhoton.h.

Referenced by print().

particle_number

long Heed::HeedPhoton::particle_number

Definition at line 34 of file HeedPhoton.h.

Referenced by physics_after_new_speed(), and print().

s_delta_generated

bool Heed::HeedPhoton::s_delta_generated

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

Definition at line 50 of file HeedPhoton.h.

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

s_photon_absorbed

bool Heed::HeedPhoton::s_photon_absorbed

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