Heed::AtomMixDef Class Reference

#include <AtomDef.h>

Inheritance diagram for Heed::AtomMixDef:

Public Member Functions
	AtomMixDef ()=default
	Default constructor.
	AtomMixDef (unsigned long fqatom, const std::vector< std::string > &fatom_not, const std::vector< double > &fweight_quan)
	AtomMixDef (unsigned long fqatom, const std::vector< std::string > &fatom_not, const std::vector< long > &fweight_quan)
	AtomMixDef (const std::string &fatom_not)
	AtomMixDef (const std::string &fatom_not1, double fweight_quan1, const std::string &fatom_not2, double fweight_quan2)
	AtomMixDef (const std::string &fatom_not1, double fweight_quan1, const std::string &fatom_not2, double fweight_quan2, const std::string &fatom_not3, double fweight_quan3)
	AtomMixDef (const std::string &fatom_not1, double fweight_quan1, const std::string &fatom_not2, double fweight_quan2, const std::string &fatom_not3, double fweight_quan3, const std::string &fatom_not4, double fweight_quan4)
void	print (std::ostream &file, int l) const
long	qatom () const
const std::vector< AtomDef * > &	atom () const
AtomDef *	atom (long n) const
const std::vector< double > &	weight_quan () const
const std::vector< double > &	weight_mass () const
double	weight_quan (long n) const
double	weight_mass (long n) const
double	Z_mean () const
double	A_mean () const
double	inv_A_mean () const
double	mean_ratio_Z_to_A () const
double	NumberOfElectronsInGram () const

Detailed Description

Definition of atomic mixtures. Pointers to atoms, weights and various mean parameters.

Definition at line 97 of file AtomDef.h.

Constructor & Destructor Documentation

AtomMixDef() [1/7]

Heed::AtomMixDef::AtomMixDef ( )

default

Default constructor.

AtomMixDef() [2/7]

Heed::AtomMixDef::AtomMixDef	(	unsigned long	fqatom,
		const std::vector< std::string > &	fatom_not,
		const std::vector< double > &	fweight_quan
	)

Definition at line 96 of file AtomDef.cpp.

    : qatomh(fqatom),
      atomh(fqatom, nullptr),
      weight_quanh(fqatom, 0.0),
      weight_massh(fqatom, 0.0) {
  mfunnamep("AtomMixDef::AtomMixDef(...)");
  check_econd11(fqatom, <= 0, mcerr);
  check_econd12(fqatom, >, fatom_not.size(), mcerr);
  check_econd12(fqatom, >, fweight_quan.size(), mcerr);
 
  for (long n = 0; n < qatomh; ++n) {
    AtomDef* ad = AtomDef::get_AtomDef(fatom_not[n]);
    if (!ad) {
      funnw.ehdr(mcerr);
      mcerr << "cannot find atom with notation " << fatom_not[n]
            << "\nIn particular, check the sequence of initialization\n";
      spexit(mcerr);
    }
    atomh[n] = ad;
  }
  double s = 0.0;
  for (long n = 0; n < qatomh; n++) {
    weight_quanh[n] = fweight_quan[n];
    check_econd11(weight_quanh[n], <= 0, mcerr);
    s += weight_quanh[n];
  }
  check_econd11(s, <= 0, mcerr);
  if (s != 1.0) {
    for (long n = 0; n < qatomh; n++) {
      weight_quanh[n] /= s;
    }
  }
  for (long n = 0; n < qatomh; n++) {
    weight_massh[n] = weight_quanh[n] * atomh[n]->A();
  }
  s = 0.0;
  for (long n = 0; n < qatomh; n++) {
    s += weight_massh[n];
  }
  check_econd11(s, <= 0, mcerr);
  if (s != 1.0) {
    for (long n = 0; n < qatomh; n++) {
      weight_massh[n] /= s;
    }
  }
  for (long n = 0; n < qatomh; n++) {
    Z_meanh += atomh[n]->Z() * weight_quanh[n];
    A_meanh += atomh[n]->A() * weight_quanh[n];
    inv_A_meanh += (1.0 / atomh[n]->A()) * weight_quanh[n];
  }
  mean_ratio_Z_to_Ah = Z_meanh / A_meanh;
  NumberOfElectronsInGramh = mean_ratio_Z_to_Ah * (gram / mole) * Avogadro;
}

AtomMixDef() [3/7]

Heed::AtomMixDef::AtomMixDef	(	unsigned long	fqatom,
		const std::vector< std::string > &	fatom_not,
		const std::vector< long > &	fweight_quan
	)

Definition at line 152 of file AtomDef.cpp.

    : qatomh(fqatom),
      atomh(fqatom, nullptr),
      weight_quanh(fqatom, 0.0),
      weight_massh(fqatom, 0.0) {
  mfunnamep("AtomMixDef::AtomMixDef(...)");
  check_econd11(fqatom, <= 0, mcerr);
  check_econd12(fqatom, >, fatom_not.size(), mcerr);
  check_econd12(fqatom, >, fweight_quan.size(), mcerr);
 
  for (long n = 0; n < qatomh; ++n) {
    AtomDef* ad = AtomDef::get_AtomDef(fatom_not[n]);
    if (!ad) {
      funnw.ehdr(mcerr);
      mcerr << "cannot find atom with notation " << fatom_not[n]
            << "\nIn particular, check the sequence of initialization\n";
      spexit(mcerr);
    }
    atomh[n] = ad;
  }
  double s = 0.0;
  for (long n = 0; n < qatomh; n++) {
    weight_quanh[n] = fweight_quan[n];
    check_econd11(weight_quanh[n], <= 0, mcerr);
    s += weight_quanh[n];
  }
  check_econd11(s, <= 0, mcerr);
  if (s != 1.0) {
    for (long n = 0; n < qatomh; n++) {
      weight_quanh[n] /= s;
    }
  }
  for (long n = 0; n < qatomh; n++) {
    weight_massh[n] = weight_quanh[n] * atomh[n]->A();
  }
  s = 0.0;
  for (long n = 0; n < qatomh; n++) {
    s += weight_massh[n];
  }
  check_econd11(s, <= 0, mcerr);
  if (s != 1.0) {
    for (long n = 0; n < qatomh; n++) {
      weight_massh[n] /= s;
    }
  }
  for (long n = 0; n < qatomh; n++) {
    Z_meanh += atomh[n]->Z() * weight_quanh[n];
    A_meanh += atomh[n]->A() * weight_quanh[n];
    inv_A_meanh += (1.0 / atomh[n]->A()) * weight_quanh[n];
  }
  mean_ratio_Z_to_Ah = Z_meanh / A_meanh;
  NumberOfElectronsInGramh = mean_ratio_Z_to_Ah * (gram / mole) * Avogadro;
}

AtomMixDef() [4/7]

Heed::AtomMixDef::AtomMixDef

(

const std::string &

fatom_not

)

Definition at line 209 of file AtomDef.cpp.

    : qatomh(1),
      atomh(1, nullptr),
      weight_quanh(1, 1.),
      weight_massh(1, 1.) {
  mfunnamep("AtomMixDef::AtomMixDef(...)");
  AtomDef* ad = AtomDef::get_AtomDef(fatom_not);
  if (!ad) {
    funnw.ehdr(mcerr);
    mcerr << "cannot find atom with notation " << fatom_not
          << "\nIn particular, check the sequence of initialization\n";
    spexit(mcerr);
  }
  atomh[0] = ad;
 
  weight_quanh[0] = 1.0;
  weight_massh[0] = 1.0;
 
  Z_meanh += atomh[0]->Z();
  A_meanh += atomh[0]->A();
  inv_A_meanh += (1.0 / atomh[0]->A());
  mean_ratio_Z_to_Ah = Z_meanh / A_meanh;
  NumberOfElectronsInGramh = mean_ratio_Z_to_Ah * (gram / mole) * Avogadro;
}

AtomMixDef() [5/7]

Heed::AtomMixDef::AtomMixDef	(	const std::string &	fatom_not1,
		double	fweight_quan1,
		const std::string &	fatom_not2,
		double	fweight_quan2
	)

Definition at line 235 of file AtomDef.cpp.

    : qatomh(2),
      atomh(2, nullptr),
      weight_quanh(2),
      weight_massh(2) {
  mfunnamep("AtomMixDef::AtomMixDef(...)");
  std::vector<std::string> fatom_not(2);
  fatom_not[0] = fatom_not1;
  fatom_not[1] = fatom_not2;
 
  for (long n = 0; n < qatomh; ++n) {
    AtomDef* ad = AtomDef::get_AtomDef(fatom_not[n]);
    if (!ad) {
      funnw.ehdr(mcerr);
      mcerr << "cannot find atom with notation " << fatom_not[n]
            << "\nIn particular, check the sequence of initialization\n";
      spexit(mcerr);
    }
    atomh[n] = ad;
  }
  weight_quanh[0] = fweight_quan1;
  weight_quanh[1] = fweight_quan2;
  double s = 0.0;
  for (long n = 0; n < qatomh; n++) {
    check_econd11(weight_quanh[n], <= 0, mcerr);
    s += weight_quanh[n];
  }
  check_econd11(s, <= 0, mcerr);
  if (s != 1.0) {
    for (long n = 0; n < qatomh; n++) {
      weight_quanh[n] /= s;
    }
  }
  for (long n = 0; n < qatomh; n++) {
    weight_massh[n] = weight_quanh[n] * atomh[n]->A();
  }
  s = 0.0;
  for (long n = 0; n < qatomh; n++) {
    s += weight_massh[n];
  }
  check_econd11(s, <= 0, mcerr);
  if (s != 1.0) {
    for (long n = 0; n < qatomh; n++) {
      weight_massh[n] /= s;
    }
  }
  for (long n = 0; n < qatomh; n++) {
    Z_meanh += atomh[n]->Z() * weight_quanh[n];
    A_meanh += atomh[n]->A() * weight_quanh[n];
    inv_A_meanh += (1.0 / atomh[n]->A()) * weight_quanh[n];
  }
  mean_ratio_Z_to_Ah = Z_meanh / A_meanh;
  NumberOfElectronsInGramh = mean_ratio_Z_to_Ah * (gram / mole) * Avogadro;
}

AtomMixDef() [6/7]

Heed::AtomMixDef::AtomMixDef	(	const std::string &	fatom_not1,
		double	fweight_quan1,
		const std::string &	fatom_not2,
		double	fweight_quan2,
		const std::string &	fatom_not3,
		double	fweight_quan3
	)

Definition at line 292 of file AtomDef.cpp.

    : qatomh(3),
      atomh(3, nullptr),
      weight_quanh(3),
      weight_massh(3) {
 
  mfunnamep("AtomMixDef::AtomMixDef(...)");
  std::vector<std::string> fatom_not(3);
  fatom_not[0] = fatom_not1;
  fatom_not[1] = fatom_not2;
  fatom_not[2] = fatom_not3;
 
  for (long n = 0; n < qatomh; ++n) {
    AtomDef* ad = AtomDef::get_AtomDef(fatom_not[n]);
    if (!ad) {
      funnw.ehdr(mcerr);
      mcerr << "cannot find atom with notation " << fatom_not[n]
            << "\nIn particular, check the sequence of initialization\n";
      spexit(mcerr);
    }
    atomh[n] = ad;
  }
  weight_quanh[0] = fweight_quan1;
  weight_quanh[1] = fweight_quan2;
  weight_quanh[2] = fweight_quan3;
  double s = 0.0;
  for (long n = 0; n < qatomh; n++) {
    check_econd11(weight_quanh[n], <= 0, mcerr);
    s += weight_quanh[n];
  }
  check_econd11(s, <= 0, mcerr);
  if (s != 1.0) {
    for (long n = 0; n < qatomh; n++) {
      weight_quanh[n] /= s;
    }
  }
  for (long n = 0; n < qatomh; n++) {
    weight_massh[n] = weight_quanh[n] * atomh[n]->A();
  }
  s = 0.0;
  for (long n = 0; n < qatomh; n++) {
    s += weight_massh[n];
  }
  check_econd11(s, <= 0, mcerr);
  if (s != 1.0) {
    for (long n = 0; n < qatomh; n++) {
      weight_massh[n] /= s;
    }
  }
  for (long n = 0; n < qatomh; n++) {
    Z_meanh += atomh[n]->Z() * weight_quanh[n];
    A_meanh += atomh[n]->A() * weight_quanh[n];
    inv_A_meanh += (1.0 / atomh[n]->A()) * weight_quanh[n];
  }
  mean_ratio_Z_to_Ah = Z_meanh / A_meanh;
  NumberOfElectronsInGramh = mean_ratio_Z_to_Ah * (gram / mole) * Avogadro;
}

AtomMixDef() [7/7]

Heed::AtomMixDef::AtomMixDef	(	const std::string &	fatom_not1,
		double	fweight_quan1,
		const std::string &	fatom_not2,
		double	fweight_quan2,
		const std::string &	fatom_not3,
		double	fweight_quan3,
		const std::string &	fatom_not4,
		double	fweight_quan4
	)

Definition at line 353 of file AtomDef.cpp.

    : qatomh(4),
      atomh(4, nullptr),
      weight_quanh(4, 0.),
      weight_massh(4, 0.) {
  mfunnamep("AtomMixDef::AtomMixDef(...)");
  std::vector<std::string> fatom_not(4);
  fatom_not[0] = fatom_not1;
  fatom_not[1] = fatom_not2;
  fatom_not[2] = fatom_not3;
  fatom_not[3] = fatom_not4;
 
  for (long k = 0; k < qatomh; k++) {
    AtomDef* ad = AtomDef::get_AtomDef(fatom_not[k]);
    if (!ad) {
      funnw.ehdr(mcerr);
      mcerr << "cannot find atom with notation " << fatom_not[k]
            << "\nIn particular, check the sequence of initialization\n";
      spexit(mcerr);
    }
    atomh[k] = ad;
  }
  weight_quanh[0] = fweight_quan1;
  weight_quanh[1] = fweight_quan2;
  weight_quanh[2] = fweight_quan3;
  weight_quanh[3] = fweight_quan4;
  double s = 0.0;
  for (long n = 0; n < qatomh; n++) {
    check_econd11(weight_quanh[n], <= 0, mcerr);
    s += weight_quanh[n];
  }
  check_econd11(s, <= 0, mcerr);
  if (s != 1.0) {
    for (long n = 0; n < qatomh; n++) {
      weight_quanh[n] /= s;
    }
  }
  for (long n = 0; n < qatomh; n++) {
    weight_massh[n] = weight_quanh[n] * atomh[n]->A();
  }
  s = 0.0;
  for (long n = 0; n < qatomh; n++) {
    s += weight_massh[n];
  }
  check_econd11(s, <= 0, mcerr);
  if (s != 1.0) {
    for (long n = 0; n < qatomh; n++) {
      weight_massh[n] /= s;
    }
  }
  for (long n = 0; n < qatomh; n++) {
    Z_meanh += atomh[n]->Z() * weight_quanh[n];
    A_meanh += atomh[n]->A() * weight_quanh[n];
    inv_A_meanh += (1.0 / atomh[n]->A()) * weight_quanh[n];
  }
  mean_ratio_Z_to_Ah = Z_meanh / A_meanh;
  NumberOfElectronsInGramh = mean_ratio_Z_to_Ah * (gram / mole) * Avogadro;
}

Member Function Documentation

A_mean()

double Heed::AtomMixDef::A_mean ( ) const

inline

Definition at line 141 of file AtomDef.h.

{ return A_meanh; }

Referenced by Heed::HeedDeltaElectronCS::HeedDeltaElectronCS(), Heed::operator<<(), and Heed::HeedPhoton::physics().

atom() [1/2]

const std::vector< AtomDef * > & Heed::AtomMixDef::atom ( ) const

inline

Definition at line 134 of file AtomDef.h.

{ return atomh; }

Referenced by Heed::HeedDeltaElectronCS::HeedDeltaElectronCS(), Heed::HeedMatterDef::HeedMatterDef(), Heed::MoleculeDef::MoleculeDef(), and Heed::operator<<().

atom() [2/2]

AtomDef * Heed::AtomMixDef::atom ( long  n ) const

inline

Definition at line 135 of file AtomDef.h.

{ return atomh[n]; }

inv_A_mean()

double Heed::AtomMixDef::inv_A_mean ( ) const

inline

Definition at line 142 of file AtomDef.h.

{ return inv_A_meanh; }

Referenced by Heed::operator<<().

mean_ratio_Z_to_A()

double Heed::AtomMixDef::mean_ratio_Z_to_A ( ) const

inline

Definition at line 143 of file AtomDef.h.

{ return mean_ratio_Z_to_Ah; }

Referenced by Heed::operator<<().

NumberOfElectronsInGram()

double Heed::AtomMixDef::NumberOfElectronsInGram ( ) const

inline

Definition at line 144 of file AtomDef.h.

                                         {
    return NumberOfElectronsInGramh;
  }

Referenced by Heed::operator<<().

print()

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

Definition at line 415 of file AtomDef.cpp.

                                                    {
  if (l > 0) file << (*this);
}

qatom()

long Heed::AtomMixDef::qatom ( ) const

inline

Definition at line 133 of file AtomDef.h.

{ return qatomh; }

Referenced by Heed::EnTransfCS::EnTransfCS(), Heed::HeedDeltaElectronCS::HeedDeltaElectronCS(), Heed::HeedMatterDef::HeedMatterDef(), Heed::MoleculeDef::MoleculeDef(), Heed::operator<<(), Heed::HeedParticle::physics(), Heed::HeedParticle_BGM::physics(), Heed::HeedPhoton::physics(), Heed::EnTransfCS::print(), and Heed::HeedMatterDef::print().

weight_mass() [1/2]

const std::vector< double > & Heed::AtomMixDef::weight_mass ( ) const

inline

Definition at line 137 of file AtomDef.h.

{ return weight_massh; }

Referenced by Heed::operator<<().

weight_mass() [2/2]

double Heed::AtomMixDef::weight_mass ( long  n ) const

inline

Definition at line 139 of file AtomDef.h.

{ return weight_massh[n]; }

weight_quan() [1/2]

const std::vector< double > & Heed::AtomMixDef::weight_quan ( ) const

inline

Definition at line 136 of file AtomDef.h.

{ return weight_quanh; }

Referenced by Heed::EnTransfCS::EnTransfCS(), Heed::HeedDeltaElectronCS::HeedDeltaElectronCS(), Heed::HeedMatterDef::HeedMatterDef(), Heed::operator<<(), and Heed::HeedPhoton::physics().

weight_quan() [2/2]

double Heed::AtomMixDef::weight_quan ( long  n ) const

inline

Definition at line 138 of file AtomDef.h.

{ return weight_quanh[n]; }

Z_mean()

double Heed::AtomMixDef::Z_mean ( ) const

inline

Definition at line 140 of file AtomDef.h.

{ return Z_meanh; }

Referenced by Heed::EnTransfCS::EnTransfCS(), Heed::HeedDeltaElectronCS::HeedDeltaElectronCS(), and Heed::operator<<().

---

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

• AtomDef.h
• AtomDef.cpp