#include <HeedParticle.h>

Inheritance diagram for Heed::HeedParticle:

Public Member Functions
	HeedParticle ()
	Default constructor.

	HeedParticle (manip_absvol primvol, const point &pt, const vec &vel, vfloat time, particle_def fpardef, HeedFieldMap *fieldmap, const bool fs_loss_only=false, const bool fs_print_listing=false)

virtual	~HeedParticle ()
	Destructor.

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

virtual HeedParticle *	copy () const

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

Public Member Functions inherited from Heed::eparticle
	eparticle ()
	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.

virtual eparticle *	copy () const

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

virtual int	force (const point &pt, vec &f, vec &f_perp, vfloat &mrange)
	Calculate force components.

Public Member Functions inherited from Heed::mparticle
void	check_consistency () const
	Check consistency of kin_energy, gamma_1, speed, speed_of_light and mass.

virtual void	step (std::vector< gparticle * > &secondaries)

virtual void	curvature (int &fs_cf, vec &frelcen, vfloat &fmrange, vfloat prec)

virtual int	force (const point &pt, vec &f, vec &f_perp, vfloat &mrange)

void	new_speed ()
	Set new speed, direction and time for currpos.

	mparticle ()
	Default constructor.

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

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

virtual mparticle *	copy () const

virtual	~mparticle ()
	Destructor.

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 Member Functions inherited from Heed::particle_type
	particle_type ()

	particle_type (particle_def *f)

	particle_type (const char *name, int s=0)

int	operator== (const particle_type &f)

int	operator!= (const particle_type &f)

void	print_notation (std::ostream &file) const

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)

Public Attributes inherited from Heed::mparticle
double	mass
	Mass (not mass * speed_of_light^2)

double	orig_kin_energy

double	orig_gamma_1

double	prev_kin_energy

double	prev_gamma_1

double	curr_kin_energy

double	curr_gamma_1

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

Public Attributes inherited from Heed::particle_type
PassivePtr< particle_def >	pardef

Static Public Attributes inherited from Heed::gparticle
static long	max_q_zero_step = 100

Protected Attributes inherited from Heed::eparticle
HeedFieldMap *	m_fieldMap

Detailed Description

Definition of the particle which can be traced through the geometry. Also the definition of cluster (energy transfer), and particle bank.

2003, I. Smirnov

Definition at line 16 of file HeedParticle.h.

Constructor & Destructor Documentation

◆ HeedParticle() [1/2]

Heed::HeedParticle::HeedParticle ( )

inline

Default constructor.

Definition at line 19 of file HeedParticle.h.

19: eparticle() {}

Heed::eparticle::eparticle

eparticle()

Default constructor.

Definition: eparticle.h:18

Referenced by copy().

◆ HeedParticle() [2/2]

Heed::HeedParticle::HeedParticle	(	manip_absvol *	primvol,
		const point &	pt,
		const vec &	vel,
		vfloat	time,
		particle_def *	fpardef,
		HeedFieldMap *	fieldmap,
		const bool	fs_loss_only = `false`,
		const bool	fs_print_listing = `false`
	)

Constructor. If fs_loss_only == false only transferred energy is simulated: no deposition of clusters, no generation of virtual photons.

Definition at line 22 of file HeedParticle.cpp.

    : eparticle(primvol, pt, vel, time, fpardef, fieldmap),
      s_print_listing(fs_print_listing),
      particle_number(last_particle_number++),
      s_loss_only(fs_loss_only),
      s_store_clusters(false) {
 
  mfunname("HeedParticle::HeedParticle(...)");
  etransf.reserve(100);
  natom.reserve(100);
  nshell.reserve(100);
}

◆ ~HeedParticle()

virtual Heed::HeedParticle::~HeedParticle ( )

inlinevirtual

Destructor.

Definition at line 29 of file HeedParticle.h.

29{}

Member Function Documentation

◆ copy()

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

inlinevirtual

Reimplemented from Heed::eparticle.

Definition at line 32 of file HeedParticle.h.

32{ return new HeedParticle(*this); }

Heed::HeedParticle::HeedParticle

HeedParticle()

Default constructor.

Definition: HeedParticle.h:19

◆ physics()

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

virtual

Reimplemented from Heed::gparticle.

Definition at line 38 of file HeedParticle.cpp.

                                                             {
  mfunname("void HeedParticle::physics()");
  if (s_print_listing) {
    mcout << "HeedParticle::physics is started\n";
    Iprintn(mcout, currpos.prange);
  }
  etransf.clear();
  natom.clear();
  nshell.clear();
  if (currpos.prange <= 0.0) return;
  // Get local volume.
  const absvol* av = currpos.tid.G_lavol();
  const EnTransfCS* etcs = dynamic_cast<const EnTransfCS*>(av);
  if (!etcs) return;
  HeedMatterDef* hmd = etcs->hmd.getver();
  MatterDef* matter = hmd->matter.getver();
  EnergyMesh* emesh = hmd->energy_mesh.getver();
  const double* aetemp = hmd->energy_mesh->get_ae();
  PointCoorMesh<double, const double*> pcm(emesh->get_q() + 1, &(aetemp));
  const long qa = matter->qatom();
  if (s_print_listing) Iprintn(mcout, qa);
  basis tempbas(currpos.dir, "tempbas");
  for (long na = 0; na < qa; ++na) {
    if (s_print_listing) Iprintn(mcout, na);
    const long qs = hmd->apacs[na]->get_qshell();
    for (long ns = 0; ns < qs; ++ns) {
      if (s_print_listing) Iprintn(mcout, ns);
      if (etcs->quan[na][ns] <= 0.0) continue;
      // Sample the number of collisions for this shell.
      int ierror = 0;
      const long qt = pois(etcs->quan[na][ns] * currpos.prange / cm, ierror);
      check_econd11a(ierror, == 1,
                     " etcs->quan[na][ns]=" << etcs->quan[na][ns]
                                            << " currpos.prange/cm="
                                            << currpos.prange / cm << '\n',
                     mcerr);
      if (s_print_listing) Iprintn(mcout, qt);
      if (qt <= 0) continue;
      point curpt = prevpos.pt;
      vec dir = unit_vec(currpos.pt - prevpos.pt);
      const double range = (currpos.pt - prevpos.pt).length();
      if (s_print_listing) Iprint3n(mcout, curpt, dir, range);
      for (long nt = 0; nt < qt; ++nt) {
        // Sample the energy transfer in this collision.
        const double rn = SRANLUX();
        if (s_print_listing) Iprint3n(mcout, rn, etcs, etcs->fadda[na][ns][1]);
        const double r = t_hisran_step_ar<
            double, std::vector<double>, PointCoorMesh<double, const double*> >(
            pcm, etcs->fadda[na][ns], rn);
 
        // Convert to internal units.
        const double et = r * MeV;
        etransf.push_back(et);
        natom.push_back(na);
        nshell.push_back(ns);
        if (s_print_listing) Iprint2n(mcout, nt, et);
        // Sample the position of the collision.
        const double arange = SRANLUX() * range;
        point pt = curpt + dir * arange;
        point ptloc = pt;
        prevpos.tid.up_absref(&ptloc);
        if (s_loss_only) continue;
        if (s_print_listing) mcout << "generating new cluster\n";
        if (s_store_clusters) {
          m_clusterBank.push_back(
              HeedCluster(et, 0, pt, ptloc, prevpos.tid, na, ns));
        }
        // Generate a virtual photon.
        const double Ep0 = mass * c_squared + curr_kin_energy;
        const double Ep1 = Ep0 - etransf.back();
        const double Mp = mass * c_squared;
        const double Mt = electron_def.mass * c_squared;
        double theta_p, theta_t;
        theta_two_part(Ep0, Ep1, Mp, Mt, theta_p, theta_t);
        vec vel;
        vel.random_conic_vec(fabs(theta_t));
        vel.down(&tempbas);  // direction is OK
        vel *= c_light;
        // HS
        double speed = vel.length();
        double time = arange / speed;
        if (s_print_listing) mcout << "generating new virtual photon\n";
        HeedPhoton* hp = new HeedPhoton(currpos.tid.eid[0].getver(), pt, vel,
                                        time, particle_number, et, m_fieldMap);
        hp->s_photon_absorbed = true;
        hp->s_delta_generated = false;
        hp->na_absorbing = na;
        hp->ns_absorbing = ns;
        secondaries.push_back(hp);
      }
    }
  }
  if (s_print_listing) {
    const double sum = std::accumulate(etransf.begin(), etransf.end(), 0.);
    Iprint2n(mcout, etransf.size(), sum);
    mcout << "Exiting HeedParticle::physics\n";
  }
}

◆ print()

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

virtual

Reimplemented from Heed::eparticle.

Definition at line 137 of file HeedParticle.cpp.

                                                      {
  if (l < 0) return;
  Ifile << "HeedParticle (l=" << l << "): particle_number=" << particle_number
        << " type=";
  print_notation(file);
  file << std::endl;
  if (l == 1) return;
  mparticle::print(file, l - 1);
  const double sum = std::accumulate(etransf.begin(), etransf.end(), 0.);
  Iprintn(mcout, sum);
  Iprintn(mcout, etransf.size());
  if (l >= 5) {
    Ifile << "   nt  natom nshell transferred energy\n";
    const long qt = etransf.size();
    for (long nt = 0; nt < qt; nt++) {
      Ifile << std::setw(3) << nt << ' ' << std::setw(3) << natom[nt] << ' '
            << std::setw(3) << nshell[nt] << ' ' << std::setw(12) << etransf[nt]
            << '\n';
    }
  }
}

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

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ HeedParticle() [1/2]

◆ HeedParticle() [2/2]

◆ ~HeedParticle()

Member Function Documentation

◆ copy()

◆ physics()

◆ print()