nucmass.h
Go to the documentation of this file.
1 /*
2  -------------------------------------------------------------------
3 
4  Copyright (C) 2006-2017, Andrew W. Steiner
5 
6  This file is part of O2scl.
7 
8  O2scl is free software; you can redistribute it and/or modify
9  it under the terms of the GNU General Public License as published by
10  the Free Software Foundation; either version 3 of the License, or
11  (at your option) any later version.
12 
13  O2scl is distributed in the hope that it will be useful,
14  but WITHOUT ANY WARRANTY; without even the implied warranty of
15  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16  GNU General Public License for more details.
17 
18  You should have received a copy of the GNU General Public License
19  along with O2scl. If not, see <http://www.gnu.org/licenses/>.
20 
21  -------------------------------------------------------------------
22 */
23 #ifndef O2SCL_NUCLEAR_MASS_H
24 #define O2SCL_NUCLEAR_MASS_H
25 
26 /** \file nucmass.h
27  \brief File defining \ref o2scl::nucmass and related classes
28 */
29 
30 #include <cmath>
31 #include <string>
32 #include <map>
33 
34 #include <boost/numeric/ublas/vector.hpp>
35 
36 #include <o2scl/nucleus.h>
37 #include <o2scl/constants.h>
38 #include <o2scl/table.h>
39 #include <o2scl/inte_qagiu_gsl.h>
40 #include <o2scl/root_cern.h>
41 #include <o2scl/root_brent_gsl.h>
42 
43 #ifndef DOXYGEN_NO_O2NS
44 namespace o2scl {
45 #endif
46 
47  /** \brief Nuclear mass information
48 
49  This class exists to provide some basic information on
50  nuclei to nuclear mass classes which are children of
51  \ref nucmass.
52 
53  Elements 113, 115, 117 and 118 are named "Uut", "Uup", "Uus",
54  and "Uuo", respectively, until the IUPAC decides on their names.
55  Note that some of the nuclear mass tables use older or
56  alternative names for the heavier elements, so \ref Ztoel() may
57  return something different than is stored in, e.g., \ref
58  nucmass_ame::entry::el.
59 
60  \future Add the full names for each element.
61  */
62  class nucmass_info {
63  public:
64 
65  nucmass_info();
66 
67  /** \brief Parse a string representing an element
68 
69  Accepts strings of one of the following forms:
70  - <tt>Pb208</tt>
71  - <tt>pb208</tt>
72  - <tt>Pb 208</tt>
73  - <tt>Pb-208</tt>
74  - <tt>pb 208</tt>
75  - <tt>pb-208</tt>
76  or one of the special strings <tt>n</tt>, <tt>p</tt>, <tt>d</tt>
77  or <tt>t</tt> for the neutron, proton, deuteron, and triton,
78  respectively. This function also allows the value of A
79  to precede the element symbol.
80 
81  \note At present, this allows nuclei which don't make sense
82  because A<Z, such as Carbon-5.
83 
84  \future Warn about malformed combinations like Carbon-5
85  \future Right now, <tt>n4</tt> is interpreted incorrectly
86  as Nitrogen-4, rather than the tetraneutron.
87  \future Interpret strings with the full name rather
88  than just the abbreviation.
89  */
90  int parse_elstring(std::string ela, int &Z, int &N, int &A);
91 
92  /** \brief Return Z given the element name abbreviation
93 
94  If the string parameter \c el is invalid, the error handler is
95  called and the value -1 is returned.
96  */
97  int eltoZ(std::string el);
98 
99  /** \brief Return the element name abbreviation given Z
100 
101  \note This function returns \c "n" indicating the neutron for
102  Z=0, and if the argument \c Z is greater than 118, then
103  the error handler is called.
104  */
105  std::string Ztoel(size_t Z);
106 
107  /** \brief Return a string of the form "Pb208" for a given Z and N
108 
109  Note that if \c Z is zero, then and \c 'n' is
110  used to indicate the a nucleus composed entirely of neutrons
111  and if the argument \c Z is greater than 118, the
112  error handler is called.
113  */
114  std::string tostring(size_t Z, size_t N);
115 
116 #ifndef DOXYGEN_INTERNAL
117 
118  protected:
119 
120  /// The number of elements (proton number)
121  static const int nelements=119;
122 
123  /** \brief A map containing the proton numbers organized by
124  element abbreviation
125  */
126  std::map<std::string,int,std::greater<std::string> > element_table;
127 
128  /// A convenient typedef for an iterator for element_table
129  typedef std::map<std::string,int,std::greater<std::string> >::iterator table_it;
130 
131  /// The list of elements organized by proton number
132  std::string element_list[nelements];
133 
134 #endif
135 
136  };
137 
138  /** \brief Nuclear mass formula base [abstract base]
139 
140  (See also the discussion in \ref nuclei_section.)
141 
142  This is abstract base class for the nuclear mass formulas. Some
143  mass formulas are undefined for sufficiently exotic nuclei. You
144  can use the function is_included() to find if a particular
145  \nucleus is included or not in a particular mass formula.
146 
147  The quantities below are returned in units of MeV. The functions
148  include a version which takes Z and N as integers and a version
149  with a suffix <tt>"_d"</tt> which takes Z and N as
150  double-precision numbers.
151 
152  The mass excess is given by \ref mass_excess() and \ref
153  mass_excess_d() .
154 
155  Binding energies (\ref binding_energy() and \ref
156  binding_energy_d() ) are determined from mass excesses by
157  \f[
158  \mathrm{binding~energy} = A u - Z \left(m_p + m_e\right) - N m_n +
159  \mathrm{mass~excess}
160  \f]
161  The neutron, proton, and electron masses and atomic mass unit
162  are stored in \ref m_prot, \ref m_neut, \ref m_elec, and \ref
163  m_amu . By default, this are assigned to the values in \ref
164  o2scl_mks times \ref o2scl_const::hc_mev_fm , but these default
165  values are modified in the constructors of some children
166  classes.
167 
168  Total masses, as returned by \ref total_mass() and \ref
169  total_mass_d() , are the mass of the nuclide without the
170  electron mass or binding energy contribution
171  \f[
172  \mathrm{total~mass} = \mathrm{mass~excess} + A u - Z m_e
173  \f]
174 
175  Atomic masses are the total mass with the electron mass and
176  binding energy contributions (see \ref atomic_mass() and \ref
177  atomic_mass_d() ). Electron binding energies are computed
178  in \ref electron_binding() and approximated
179  with
180  \f[
181  14.4381 \times 10^{-6} Z^{2.39} + 1.55468 \times 10^{-12}
182  Z^{5.35}~\mathrm{MeV}
183  \f]
184  as in Eq. A4 of \ref Lunney03 .
185 
186  Generally, descendants of this class only need to provide an
187  implementation of \ref mass_excess() and \ref mass_excess_d()
188  and possibly a new version of \ref is_included() to be fully
189  functional.
190 
191  \comment
192  \future It might be useful to consider a fudge factor
193  to ensure no problems with finite precision arithmetic
194  when converting \c double to \c int.
195  11/22/09 - I waffle back and forth on this. I think
196  maybe its best to let the user deal with this their own
197  way.
198  \endcomment
199 
200  */
201  class nucmass : public nucmass_info {
202 
203  public:
204 
205  nucmass();
206 
207  virtual ~nucmass() {};
208 
209  /// Return the type, \c "nucmass".
210  virtual const char *type() { return "nucmass"; }
211 
212  /** \brief Return false if the mass formula does not include
213  specified nucleus
214  */
215  virtual bool is_included(int Z, int N) {
216  return true;
217  }
218 
219  /** \brief Fill \c n with the information from nucleus with the given
220  neutron and proton number
221 
222  All masses are given in \f$\mathrm{fm}^{-1}\f$. The total mass
223  (withouth the electrons) is put in part::m and part::ms, the
224  binding energy is placed in nucleus::be, the mass excess in
225  nucleus::mex and the degeneracy (part::g) is arbitrarily set
226  to 1 for even A nuclei and 2 for odd A nuclei.
227  */
228  virtual int get_nucleus(int Z, int N, nucleus &n);
229 
230  /// Given \c Z and \c N, return the mass excess in MeV [abstract]
231  virtual double mass_excess(int Z, int N)=0;
232 
233  /// Given \c Z and \c N, return the mass excess in MeV [abstract]
234  virtual double mass_excess_d(double Z, double N)=0;
235 
236  /** \brief Return the approximate electron binding energy in MeV
237  */
238  virtual double electron_binding(double Z) {
239  return (14.4381*pow(Z,2.39)+1.55468e-6*pow(Z,5.35))*1.0e-6;
240  }
241 
242  /** \brief Return the binding energy in MeV
243 
244  The binding energy is defined to be negative for bound
245  nuclei, thus the binding energy per baryon of Pb-208
246  is about -8*208 = -1664 MeV.
247  */
248  virtual double binding_energy(int Z, int N) {
249  return (mass_excess(Z,N)+((Z+N)*m_amu-Z*m_elec-N*m_neut-Z*m_prot));
250  }
251 
252  /** \brief Return the binding energy in MeV
253 
254  The binding energy is defined to be negative for bound
255  nuclei, thus the binding energy per baryon of Pb-208
256  is about -8*208 = -1664 MeV.
257  */
258  virtual double binding_energy_d(double Z, double N) {
259  return (mass_excess_d(Z,N)+((Z+N)*m_amu-Z*m_elec-N*m_neut-Z*m_prot));
260  }
261 
262  /** \brief Return the total mass of the nucleus (without the
263  electrons) in MeV
264  */
265  virtual double total_mass(int Z, int N) {
266  return (mass_excess(Z,N)+((Z+N)*m_amu-Z*m_elec));
267  }
268 
269  /** \brief Return the total mass of the nucleus (without the electrons)
270  in MeV
271  */
272  virtual double total_mass_d(double Z, double N) {
273  return (mass_excess_d(Z,N)+((Z+N)*m_amu-Z*m_elec));
274  }
275 
276  /** \brief Return the atomic mass of the nucleus in MeV
277  (includes electrons and their binding energy)
278  */
279  virtual double atomic_mass(int Z, int N) {
280  return total_mass(Z,N)+Z*m_elec-electron_binding(Z);
281  }
282 
283  /** \brief Return the atomic mass of the nucleus in MeV
284  (includes electrons and their binding energy)
285  */
286  virtual double atomic_mass_d(double Z, double N) {
287  return total_mass_d(Z,N)+Z*m_elec-electron_binding(Z);
288  }
289 
290  /// \name Base masses
291  //@{
292  /** \brief Neutron mass in \f$ \mathrm{MeV} \f$
293  (defaults to o2scl_mks::mass_neutron converted into MeV)
294  */
295  double m_neut;
296 
297  /** \brief Proton mass in \f$ \mathrm{MeV} \f$
298  (defaults to o2scl_mks::mass_proton converted into MeV)
299  */
300  double m_prot;
301 
302  /** \brief Electron mass in \f$ \mathrm{MeV} \f$
303  (defaults to o2scl_mks::mass_electron converted into MeV)
304  */
305  double m_elec;
306 
307  /** \brief Atomic mass unit in \f$ \mathrm{MeV} \f$
308  (defaults to o2scl_mks::unified_atomic_mass converted into MeV)
309  */
310  double m_amu;
311  //@}
312 
313  };
314 
315  /** \brief Tabulated nuclear masses [abstract base]
316 
317  This uses simple linear interpolation to obtain masses of nuclei
318  with non-integer value of Z and N.
319 
320  Generally, descendants of this class only need to provide an
321  implementation of \ref mass_excess() and possibly a version
322  of \ref nucmass::is_included()
323 
324  */
325  class nucmass_table : public nucmass {
326 
327  public:
328 
329  /// Given \c Z and \c N, return the mass excess in MeV
330  virtual double mass_excess_d(double Z, double N);
331 
332  };
333 
334  /** \brief Fittable mass formula [abstract base]
335 
336  Nuclear mass formulas which are descendants of this class
337  can be fit to experiment using \ref nucmass_fit.
338 
339  Within \o2p, this class has only two children,
340  \ref nucmass_frdm and \ref nucmass_semi_empirical. There
341  is also a child <tt>nucmass_ldrop</tt> in \o2e.
342  \comment
343  (Note that nucmass_ldrop is in o2scl_eos so currently
344  can't be referenced)
345  \endcomment
346  */
347  class nucmass_fit_base : public nucmass {
348 
349  public:
350 
352 
353  /// Return the type, \c "nucmass_fit_base".
354  virtual const char *type() { return "nucmass_fit_base"; }
355 
356  /// Number of fitting parameters
357  size_t nfit;
358 
359  /// Fix parameters from an array for fitting [abstract]
360  virtual int fit_fun(size_t nv, const ubvector &x)=0;
361 
362  /// Fill array with guess from present values for fitting [abstract]
363  virtual int guess_fun(size_t nv, ubvector &x)=0;
364 
365  };
366 
367  /** \brief Semi-empirical mass formula
368 
369  A simple semi-empirical mass formula of the form
370  \f[
371  E/A = B + S_s \frac{1}{A^{1/3}}+E_c \frac{Z^2}{A^{4/3}}
372  + S_v \left(1-\frac{2Z}{A}\right)^2+E_{\mathrm{pair}}(Z,N)
373  \f]
374  where the pairing energy is given by
375  \f[
376  E_{\mathrm{pair}}(Z,N) = - \frac{E_{\mathrm{pair}}}{2 A^{3/2}}
377  \left[ \cos \left( \pi Z \right)+\cos \left( \pi N \right) \right]
378  \f]
379  which is equivalent to the traditional prescription
380  \f[
381  E_{\mathrm{pair}}(Z,N) = \frac{E_{\mathrm{pair}}}{A^{3/2}}
382  \times
383  \left\{
384  \begin{array}{rl}
385  -1 & \mathrm{N~and~Z~even} \\
386  +1 & \mathrm{N~and~Z~odd} \\
387  0 & \mathrm{otherwise}
388  \end{array}
389  \right.
390  \f]
391  when \f$ Z \f$ and \f$ N \f$ and integers.
392 
393  \note The default parameters are arbitrary, and are not
394  determined from a fit.
395 
396  There is an example of the usage of this class given in
397  \ref ex_nucmass_fit_sect.
398  */
400 
401  public:
402 
404 
405  /// Binding energy (negative and in MeV, default -16)
406  double B;
407 
408  /// Symmetry energy (in MeV, default 23.7)
409  double Sv;
410 
411  /// Surface energy (in MeV, default 18)
412  double Ss;
413 
414  /// Coulomb energy (in MeV, default 0.7)
415  double Ec;
416 
417  /// Pairing energy (MeV, default 13.0)
418  double Epair;
419 
420  /// Return the type, \c "nucmass_semi_empirical".
421  virtual const char *type() { return "nucmass_semi_empirical"; }
422 
424 
425  /// Given \c Z and \c N, return the mass excess in MeV
426  virtual double mass_excess_d(double Z, double N);
427 
428  /// Given \c Z and \c N, return the mass excess in MeV
429  virtual double mass_excess(int Z, int N) {
430  return mass_excess_d(Z,N);
431  }
432 
433  /// Fix parameters from an array for fitting
434  virtual int fit_fun(size_t nv, const ubvector &x);
435 
436  /// Fill array with guess from present values for fitting
437  virtual int guess_fun(size_t nv, ubvector &x);
438 
439  };
440 
441  /** \brief An approximation of shell effects in nuclei based on
442  the interacting boson model
443 
444  Shell effects from \ref Dieperink09 based on the interacting
445  boson model, with corrections as suggested by \ref Duflo95.
446 
447  The default shell correction coefficients -1.39, 0.02, 0.03, and
448  0.075 (all in MeV), respectively.
449  */
451 
452  public:
453 
455 
456  virtual ~nucmass_ibm_shell() {}
457 
458  /** \name Shell correction coefficients in MeV
459  \comment
460  Remember that name documentation can only be one line
461  \endcomment
462  */
463  //@{
464  double s_a1;
465  double s_a2;
466  double s_a3;
467  double s_anp;
468  //@}
469 
470  /// Number of magic numbers
471  static const size_t nshells=11;
472 
473  /// Magic numbers
474  int shells[nshells];
475 
476  /// Most recently computed shell energy
477  double shell;
478 
479  /// Compute the shell energy for nucleus Z and N
480  virtual double shell_energy(int Z, int N);
481 
482  /** \brief Compute the shell energy for specified values of Z and N
483  using bilinear interpolation
484  */
485  virtual double shell_energy_interp(double Z, double N);
486 
487  };
488 
489  /** \brief Nuclear mass formula from Dieperink and van Isacker (2009)
490  */
492 
493  public:
494 
496 
497  /// Volume energy coefficient
498  double av;
499  /// Surface energy coefficient
500  double as;
501  /// Symmetry energy coefficient
502  double sv;
503  /// Coulomb energy coefficient
504  double ac;
505  /// Pairing energy coefficient
506  double ap;
507  /// Surface symmetry energy coefficient
508  double y;
509 
510  /// Return the type, \c "nucmass_dvi".
511  virtual const char *type() { return "nucmass_dvi"; }
512 
513  nucmass_dvi();
514 
515  /// Given \c Z and \c N, return the mass excess in MeV
516  virtual double mass_excess_d(double Z, double N);
517 
518  /// Given \c Z and \c N, return the mass excess in MeV
519  virtual double mass_excess(int Z, int N) {
520  return mass_excess_d(Z,N);
521  }
522 
523  /// Fix parameters from an array for fitting
524  virtual int fit_fun(size_t nv, const ubvector &x);
525 
526  /// Fill array with guess from present values for fitting
527  virtual int guess_fun(size_t nv, ubvector &x);
528 
529  };
530 
531  /** \brief Compute the RMS radius of a Fermi-Dirac density distribution
532  with fixed diffusiveness
533 
534  This class computes the RMS radius given either the central density
535  or the radius specified in the Fermi function. This class assumes
536  the density distribution function is of the form
537  \f[
538  N = 4 \pi \rho_0 \int r^2~dr~\left\{1+\exp
539  \left[\left(r-R_{\mathrm{fermi}}\right)/d\right]\right\}^{-1}
540  \f]
541  where \f$ N \f$ is the total number of particles, \f$ d \f$ is
542  the diffusiveness, \f$ R_{\mathrm{fermi}} \f$ is the half-height
543  radius, and \f$ \rho_0 \f$ is the central density.
544 
545  The radius assuming constant density,
546  \f[
547  R_{\mathrm{cd}} = \left(\frac{3 N}{4 \pi \rho_0}\right)^3 \, ,
548  \f]
549  is also given.
550  */
552 
553  protected:
554 
555  /// The central denstiy
556  double urho0;
557  /// The diffusiveness
558  double ud;
559  /** \brief Store the user-specified value of the radius in the
560  Fermi distribution
561 
562  This is used in the integrands \ref iand() and \ref iand2().
563  */
564  double uRfermi;
565  /// The total number of particles
566  double uN;
567 
568  /// The integrator
570  /// The solver
572 
573  /// The function \f$ 4 \pi r^4 \rho(r) \f$
574  double iand(double r);
575 
576  /// The function \f$ 4 \pi r^2 \rho(r) \f$
577  double iand2(double r);
578 
579  /// The function to fix the total number of particles
580  double solve(double x);
581 
582  public:
583 
584  nucmass_radius();
585 
586  /** \brief Compute the RMS radius from the central density
587 
588  Computes the RMS radius \c Rrms from the central density \c
589  rho0, the number of particles \c N, and the diffusiveness \c
590  d. This function also computes the radius in the Fermi
591  distribution function, \c Rfermi and the radius assuming
592  constant density, \c Rcd.
593  */
594  void eval_rms_rho(double rho0, double N, double d,
595  double &Rcd, double &Rfermi, double &Rrms);
596 
597  /** \brief Compute the RMS radius from the Fermi distribution radius
598 
599  Computes the RMS radius \c Rrms from the radius \c Rfermi in
600  the Fermi distribution assuming a total number of particles \c
601  N, a diffusiveness paramter \c d. This function also produces
602  the central density \c rho0, and the radius assuming constant
603  density, \c Rcd.
604  */
605  void eval_rms_rsq(double Rfermi, double N, double d,
606  double &rho0, double &Rcd, double &Rrms);
607 
608  /** \brief The radial density distribution
609  */
610  double density(double r, double Rfermi, double d, double rho0);
611 
612  /** \brief The radial density distribution times radius squared
613  */
614  double iand2_new(double r, double Rfermi, double d, double rho0);
615 
616  /** \brief Compute the total number of particles with
617  numerical uncertainty
618  */
619  void eval_N_err(double Rfermi, double d, double rho0,
620  double &N, double &N_err);
621 
622  /** \brief Compute the total number of particles
623  */
624  double eval_N(double Rfermi, double d, double rho0);
625 
626  };
627 
628 #ifndef DOXYGEN_NO_O2NS
629 }
630 #endif
631 
632 #endif
double ap
Pairing energy coefficient.
Definition: nucmass.h:506
inte_qagiu_gsl it
The integrator.
Definition: nucmass.h:569
double as
Surface energy coefficient.
Definition: nucmass.h:500
double m_elec
Electron mass in (defaults to o2scl_mks::mass_electron converted into MeV)
Definition: nucmass.h:305
virtual double total_mass_d(double Z, double N)
Return the total mass of the nucleus (without the electrons) in MeV.
Definition: nucmass.h:272
Nuclear mass formula base [abstract base].
Definition: nucmass.h:201
double av
Volume energy coefficient.
Definition: nucmass.h:498
Semi-empirical mass formula.
Definition: nucmass.h:399
double m_neut
Neutron mass in (defaults to o2scl_mks::mass_neutron converted into MeV)
Definition: nucmass.h:295
std::string Ztoel(size_t Z)
Return the element name abbreviation given Z.
double Ec
Coulomb energy (in MeV, default 0.7)
Definition: nucmass.h:415
double uRfermi
Store the user-specified value of the radius in the Fermi distribution.
Definition: nucmass.h:564
std::string element_list[nelements]
The list of elements organized by proton number.
Definition: nucmass.h:132
std::map< std::string, int, std::greater< std::string > > element_table
A map containing the proton numbers organized by element abbreviation.
Definition: nucmass.h:126
static const int nelements
The number of elements (proton number)
Definition: nucmass.h:121
virtual const char * type()
Return the type, "nucmass".
Definition: nucmass.h:210
virtual double binding_energy(int Z, int N)
Return the binding energy in MeV.
Definition: nucmass.h:248
root_cern cr
The solver.
Definition: nucmass.h:571
Nuclear mass information.
Definition: nucmass.h:62
Compute the RMS radius of a Fermi-Dirac density distribution with fixed diffusiveness.
Definition: nucmass.h:551
double shell
Most recently computed shell energy.
Definition: nucmass.h:477
virtual double total_mass(int Z, int N)
Return the total mass of the nucleus (without the electrons) in MeV.
Definition: nucmass.h:265
double uN
The total number of particles.
Definition: nucmass.h:566
double Sv
Symmetry energy (in MeV, default 23.7)
Definition: nucmass.h:409
size_t nfit
Number of fitting parameters.
Definition: nucmass.h:357
virtual double electron_binding(double Z)
Return the approximate electron binding energy in MeV.
Definition: nucmass.h:238
double sv
Symmetry energy coefficient.
Definition: nucmass.h:502
std::map< std::string, int, std::greater< std::string > >::iterator table_it
A convenient typedef for an iterator for element_table.
Definition: nucmass.h:129
double m_amu
Atomic mass unit in (defaults to o2scl_mks::unified_atomic_mass converted into MeV) ...
Definition: nucmass.h:310
Tabulated nuclear masses [abstract base].
Definition: nucmass.h:325
virtual double binding_energy_d(double Z, double N)
Return the binding energy in MeV.
Definition: nucmass.h:258
virtual double atomic_mass(int Z, int N)
Return the atomic mass of the nucleus in MeV (includes electrons and their binding energy) ...
Definition: nucmass.h:279
virtual const char * type()
Return the type, "nucmass_semi_empirical".
Definition: nucmass.h:421
double Ss
Surface energy (in MeV, default 18)
Definition: nucmass.h:412
double ud
The diffusiveness.
Definition: nucmass.h:558
double B
Binding energy (negative and in MeV, default -16)
Definition: nucmass.h:406
double ac
Coulomb energy coefficient.
Definition: nucmass.h:504
double Epair
Pairing energy (MeV, default 13.0)
Definition: nucmass.h:418
double m_prot
Proton mass in (defaults to o2scl_mks::mass_proton converted into MeV)
Definition: nucmass.h:300
double urho0
The central denstiy.
Definition: nucmass.h:556
virtual const char * type()
Return the type, "nucmass_fit_base".
Definition: nucmass.h:354
int parse_elstring(std::string ela, int &Z, int &N, int &A)
Parse a string representing an element.
virtual bool is_included(int Z, int N)
Return false if the mass formula does not include specified nucleus.
Definition: nucmass.h:215
A simple nucleus class.
Definition: nucleus.h:55
Nuclear mass formula from Dieperink and van Isacker (2009)
Definition: nucmass.h:491
int eltoZ(std::string el)
Return Z given the element name abbreviation.
virtual const char * type()
Return the type, "nucmass_dvi".
Definition: nucmass.h:511
double y
Surface symmetry energy coefficient.
Definition: nucmass.h:508
virtual double mass_excess(int Z, int N)
Given Z and N, return the mass excess in MeV.
Definition: nucmass.h:519
virtual double mass_excess(int Z, int N)
Given Z and N, return the mass excess in MeV.
Definition: nucmass.h:429
Fittable mass formula [abstract base].
Definition: nucmass.h:347
virtual double atomic_mass_d(double Z, double N)
Return the atomic mass of the nucleus in MeV (includes electrons and their binding energy) ...
Definition: nucmass.h:286
An approximation of shell effects in nuclei based on the interacting boson model. ...
Definition: nucmass.h:450
std::string tostring(size_t Z, size_t N)
Return a string of the form "Pb208" for a given Z and N.

Documentation generated with Doxygen. Provided under the GNU Free Documentation License (see License Information).