Heed::ElElasticScat Class Reference

#include <ElElasticScat.h>

Inheritance diagram for Heed::ElElasticScat:

Public Member Functions
double	get_CS (long Z, double energy, double angle, int s_interp=0)
double	get_CS_Rutherford (long Z, double energy, double angle)
long	get_qe (void) const
double	get_energy_mesh (long ne) const
	ElElasticScat (void)
	Default constructor.
	ElElasticScat (const std::string &file_name)
	Constructor with file name.
void	print (std::ostream &file, int l) 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

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)

Detailed Description

Definition of elastic scattering for low-energy delta-electron. The class contains the data for all atoms presents them by request. 2003, I. Smirnov

Definition at line 36 of file ElElasticScat.h.

Constructor & Destructor Documentation

ElElasticScat() [1/2]

Heed::ElElasticScat::ElElasticScat ( void  )

inline

Default constructor.

Definition at line 59 of file ElElasticScat.h.

: atom(0) {}

ElElasticScat() [2/2]

Heed::ElElasticScat::ElElasticScat

(

const std::string &

file_name

)

Constructor with file name.

Definition at line 37 of file ElElasticScat.cpp.

                                                       : atom(0) {
  mfunnamep("ElElasticScat::ElElasticScat(const string& filename)");
  std::ifstream file(file_name.c_str());
  if (!file) {
    funnw.ehdr(mcerr);
    mcerr << "cannot open file " << file_name << std::endl;
    spexit(mcerr);
  }
  int i = findmark(file, "#");
  check_econd11a(i, != 1, "cannot find sign #, wrong file format", mcerr);
  file >> qe;
  energy_mesh.resize(qe);
  gamma_beta2.resize(qe);
  for (long ne = 0; ne < qe; ++ne) {
    file >> energy_mesh[ne];
    if (!file.good()) {
      funnw.ehdr(mcerr);
      mcerr << "error at reading energy_mesh, ne=" << ne << '\n';
      spexit(mcerr);
    }
    // energy mesh in keV
    const double rm = 0.001 * energy_mesh[ne] / electron_mass_c2;
    const double gamma = 1. + rm;
    const double beta2 = (2 * rm + rm * rm) / (gamma * gamma);
    gamma_beta2[ne] = gamma * beta2;
  }
  while (findmark(file, "$") == 1) {
    long Z;
    file >> Z;
    check_econd21(Z, < 1 ||, > 110, mcerr);
    atom.push_back(ElElasticScatData(Z, qe));
    for (int nc = 0; nc < 4; ++nc) {
      for (long ne = 0; ne < qe; ++ne) {
        file >> atom.back().data[ne].A[nc];
        if (!file.good()) {
          funnw.ehdr(mcerr);
          mcerr << "error at reading A, Z=" << Z << " nc=" << nc << " ne=" << ne
                << '\n';
          spexit(mcerr);
        }
      }
    }
    for (int nc = 0; nc < 7; ++nc) {
      for (long ne = 0; ne < qe; ++ne) {
        file >> atom.back().data[ne].C[nc];
        if (!file.good()) {
          funnw.ehdr(mcerr);
          mcerr << "error at reading C, Z=" << Z << " nc=" << nc << " ne=" << ne
                << '\n';
          spexit(mcerr);
        }
      }
    }
    for (long ne = 0; ne < qe; ++ne) {
      file >> atom.back().data[ne].B;
      if (!file.good()) {
        funnw.ehdr(mcerr);
        mcerr << "error at reading B, Z=" << Z << " ne=" << ne << '\n';
        spexit(mcerr);
      }
    }
  }
}

Member Function Documentation

get_CS()

double Heed::ElElasticScat::get_CS	(	long	Z,
		double	energy,
		double	angle,
		int	s_interp = 0
	)

Get the cross-section (in angstrom^2/srad).

Parameters

Z	atomic number
energy	kinetic energy in MeV
angle	angle
s_interp	flag for debugging and various checks

fill_hist call this function with s_interp=1 for histograms "int...".

Definition at line 168 of file ElElasticScat.cpp.

                                           {
  mfunname(
      "double ElElasticScat::get_CS(long Z, double energy, double angle, "
      "int s_interp)");
  const long qa = atom.size();
  long na_left = 0;
  long Z_left = -100;
  long na_right = qa - 1;
  long Z_right = 10000;
  for (long na = 0; na < qa; na++) {
    if (atom[na].Z == Z && s_interp == 0) {
      return get_CS_for_presented_atom(na, energy, angle);
    }
    if (atom[na].Z > Z_left && atom[na].Z < Z) {
      Z_left = atom[na].Z;
      na_left = na;
    } else if (atom[na].Z < Z_right && atom[na].Z > Z) {
      Z_right = atom[na].Z;
      na_right = na;
    }
  }
  check_econd11a(Z_left, == -100, " have not found previous atom", mcerr);
  check_econd11a(Z_right, == 10000, " have not found next atom", mcerr);
  const double f1 = get_CS_for_presented_atom(na_left, energy, angle);
  const double f2 = get_CS_for_presented_atom(na_right, energy, angle);
  const double z1 = atom[na_left].Z;
  const double z2 = atom[na_right].Z;
  const double c = (f1 * 4 - f2 * z1 * z1) / (f2 * z1 - f1 * z2);
  const double k = f1 / (z1 * (z1 + c));
  double r = k * Z * (Z + c);
  if (r < 0.0) r = 0.0;
  return r;
}

get_CS_Rutherford()

double Heed::ElElasticScat::get_CS_Rutherford	(	long	Z,
		double	energy,
		double	angle
	)

Get the cross-section (in angstrom^2).

Parameters

Z	atomic number
energy	kinetic energy in MeV
angle	angle in internal units (radian)

Definition at line 203 of file ElElasticScat.cpp.

                                                                           {
  mfunname(
      "double ElElasticScat::get_CS_Rutherford(long Z, double energy, "
      "double angle)");
  const double gamma_1 = energy / electron_mass_c2;
  const double beta2 = lorbeta2(gamma_1);
  const double momentum2 = energy * energy + 2.0 * electron_mass_c2 * energy;
  // TODO
  double r = 0.25 * Z * Z * fine_structure_const * fine_structure_const /
             (momentum2 * beta2 * pow(sin(0.5 * angle), 4)) /
             (pow(5.07E10, 2)) * 1.0e16;
  return r;
}

get_energy_mesh()

double Heed::ElElasticScat::get_energy_mesh ( long  ne ) const

inline

Definition at line 56 of file ElElasticScat.h.

{ return energy_mesh[ne]; }

get_qe()

long Heed::ElElasticScat::get_qe ( void  ) const

inline

Definition at line 55 of file ElElasticScat.h.

{ return qe; }

print()

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

virtual

Reimplemented from Heed::RegPassivePtr.

Definition at line 217 of file ElElasticScat.cpp.

                                                       {
  if (l <= 0) return;
  Ifile << "ElElasticScat(l=" << l << "): qe=" << qe
        << " atom.size()=" << atom.size() << std::endl;
  if (l <= 1) return;
  indn.n += 2;
  Ifile << "energy_mesh=";
  for (long ne = 0; ne < qe; ++ne) {
    file << std::setw(12) << energy_mesh[ne];
  }
  file << std::endl;
  Ifile << "gamma_beta2=";
  for (long ne = 0; ne < qe; ++ne) {
    file << std::setw(12) << gamma_beta2[ne];
  }
  file << std::endl;
  indn.n -= 2;
  const long qa = atom.size();
  for (long na = 0; na < qa; ++na) {
    Ifile << "atom[na].Z=" << atom[na].Z << '\n';
    Ifile << "     ";
    for (long ne = 0; ne < qe; ++ne) {
      file << std::setw(12) << energy_mesh[ne];
    }
    file << std::endl;
    for (long n = 0; n < 4; ++n) {
      Ifile << "A[" << n << "]";
      for (long ne = 0; ne < qe; ++ne) {
        file << std::setw(12) << atom[na].data[ne].A[n];
      }
      file << std::endl;
    }
    for (int n = 0; n < 7; ++n) {
      Ifile << "C[" << n << "]";
      for (long ne = 0; ne < qe; ++ne) {
        file << std::setw(12) << atom[na].data[ne].C[n];
      }
      file << std::endl;
    }
    Ifile << "B     ";
    for (long ne = 0; ne < qe; ++ne) {
      file << std::setw(12) << atom[na].data[ne].B;
    }
    file << std::endl;
  }
}

---

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

• ElElasticScat.h
• ElElasticScat.cpp