nucmass.h
Go to the documentation of this file.
1 /*
2  -------------------------------------------------------------------
3 
4  Copyright (C) 2006-2018, 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,
130  std::greater<std::string> >::iterator table_it;
131 
132  /// The list of elements organized by proton number
133  std::string element_list[nelements];
134 
135 #endif
136 
137  };
138 
139  /** \brief Nuclear mass formula base [abstract base]
140 
141  (See also the discussion in \ref nuclei_section.)
142 
143  This is abstract base class for the nuclear mass formulas. Some
144  mass formulas are undefined for sufficiently exotic nuclei. You
145  can use the function is_included() to find if a particular
146  \nucleus is included or not in a particular mass formula.
147 
148  The quantities below are returned in units of MeV. The functions
149  include a version which takes Z and N as integers and a version
150  with a suffix <tt>"_d"</tt> which takes Z and N as
151  double-precision numbers.
152 
153  The mass excess is given by \ref mass_excess() and \ref
154  mass_excess_d() .
155 
156  Binding energies (\ref binding_energy() and \ref
157  binding_energy_d() ) are determined from mass excesses by
158  \f[
159  \mathrm{binding~energy} = A u - Z \left(m_p + m_e\right) - N m_n +
160  \mathrm{mass~excess}
161  \f]
162  The neutron, proton, and electron masses and atomic mass unit
163  are stored in \ref m_prot, \ref m_neut, \ref m_elec, and \ref
164  m_amu . By default, this are assigned to the values in \ref
165  o2scl_mks times \ref o2scl_const::hc_mev_fm , but these default
166  values are modified in the constructors of some children
167  classes.
168 
169  Total masses, as returned by \ref total_mass() and \ref
170  total_mass_d() , are the mass of the nuclide without the
171  electron mass or binding energy contribution
172  \f[
173  \mathrm{total~mass} = \mathrm{mass~excess} + A u - Z m_e
174  \f]
175 
176  Atomic masses are the total mass with the electron mass and
177  binding energy contributions (see \ref atomic_mass() and \ref
178  atomic_mass_d() ). Electron binding energies are computed
179  in \ref electron_binding() and approximated
180  with
181  \f[
182  14.4381 \times 10^{-6} Z^{2.39} + 1.55468 \times 10^{-12}
183  Z^{5.35}~\mathrm{MeV}
184  \f]
185  as in Eq. A4 of \ref Lunney03 .
186 
187  Generally, descendants of this class only need to provide an
188  implementation of \ref mass_excess() and \ref mass_excess_d()
189  and possibly a new version of \ref is_included() to be fully
190  functional.
191 
192  \comment
193  \future It might be useful to consider a fudge factor
194  to ensure no problems with finite precision arithmetic
195  when converting \c double to \c int.
196  11/22/09 - I waffle back and forth on this. I think
197  maybe its best to let the user deal with this their own
198  way.
199  \endcomment
200 
201  */
202  class nucmass : public nucmass_info {
203 
204  public:
205 
206  nucmass();
207 
208  virtual ~nucmass() {};
209 
210  /// Return the type, \c "nucmass".
211  virtual const char *type() { return "nucmass"; }
212 
213  /** \brief Return false if the mass formula does not include
214  specified nucleus
215  */
216  virtual bool is_included(int Z, int N) {
217  return true;
218  }
219 
220  /** \brief Fill \c n with the information from nucleus with the given
221  neutron and proton number
222 
223  All masses are given in \f$\mathrm{fm}^{-1}\f$. The total mass
224  (withouth the electrons) is put in part::m and part::ms, the
225  binding energy is placed in nucleus::be, the mass excess in
226  nucleus::mex and the degeneracy (part::g) is arbitrarily set
227  to 1 for even A nuclei and 2 for odd A nuclei.
228  */
229  virtual int get_nucleus(int Z, int N, nucleus &n);
230 
231  /// Given \c Z and \c N, return the mass excess in MeV [abstract]
232  virtual double mass_excess(int Z, int N)=0;
233 
234  /// Given \c Z and \c N, return the mass excess in MeV [abstract]
235  virtual double mass_excess_d(double Z, double N)=0;
236 
237  /** \brief Return the approximate electron binding energy in MeV
238  */
239  virtual double electron_binding(double Z) {
240  return (14.4381*pow(Z,2.39)+1.55468e-6*pow(Z,5.35))*1.0e-6;
241  }
242 
243  /** \brief Return the binding energy in MeV
244 
245  The binding energy is defined to be negative for bound
246  nuclei, thus the binding energy per baryon of Pb-208
247  is about -8*208 = -1664 MeV.
248  */
249  virtual double binding_energy(int Z, int N) {
250  return (mass_excess(Z,N)+((Z+N)*m_amu-Z*m_elec-N*m_neut-Z*m_prot));
251  }
252 
253  /** \brief Return the binding energy in MeV
254 
255  The binding energy is defined to be negative for bound
256  nuclei, thus the binding energy per baryon of Pb-208
257  is about -8*208 = -1664 MeV.
258  */
259  virtual double binding_energy_d(double Z, double N) {
260  return (mass_excess_d(Z,N)+((Z+N)*m_amu-Z*m_elec-N*m_neut-Z*m_prot));
261  }
262 
263  /** \brief Return the total mass of the nucleus (without the
264  electrons) in MeV
265  */
266  virtual double total_mass(int Z, int N) {
267  return (mass_excess(Z,N)+((Z+N)*m_amu-Z*m_elec));
268  }
269 
270  /** \brief Return the total mass of the nucleus (without the electrons)
271  in MeV
272  */
273  virtual double total_mass_d(double Z, double N) {
274  return (mass_excess_d(Z,N)+((Z+N)*m_amu-Z*m_elec));
275  }
276 
277  /** \brief Return the atomic mass of the nucleus in MeV
278  (includes electrons and their binding energy)
279  */
280  virtual double atomic_mass(int Z, int N) {
281  return total_mass(Z,N)+Z*m_elec-electron_binding(Z);
282  }
283 
284  /** \brief Return the atomic mass of the nucleus in MeV
285  (includes electrons and their binding energy)
286  */
287  virtual double atomic_mass_d(double Z, double N) {
288  return total_mass_d(Z,N)+Z*m_elec-electron_binding(Z);
289  }
290 
291  /// \name Base masses
292  //@{
293  /** \brief Neutron mass in \f$ \mathrm{MeV} \f$
294  (defaults to o2scl_mks::mass_neutron converted into MeV)
295  */
296  double m_neut;
297 
298  /** \brief Proton mass in \f$ \mathrm{MeV} \f$
299  (defaults to o2scl_mks::mass_proton converted into MeV)
300  */
301  double m_prot;
302 
303  /** \brief Electron mass in \f$ \mathrm{MeV} \f$
304  (defaults to o2scl_mks::mass_electron converted into MeV)
305  */
306  double m_elec;
307 
308  /** \brief Atomic mass unit in \f$ \mathrm{MeV} \f$
309  (defaults to o2scl_mks::unified_atomic_mass converted into MeV)
310  */
311  double m_amu;
312  //@}
313 
314  };
315 
316  /** \brief Tabulated nuclear masses [abstract base]
317 
318  This uses simple linear interpolation to obtain masses of nuclei
319  with non-integer value of Z and N.
320 
321  Generally, descendants of this class only need to provide an
322  implementation of \ref mass_excess() and possibly a version
323  of \ref nucmass::is_included()
324 
325  */
326  class nucmass_table : public nucmass {
327 
328  public:
329 
330  /// Given \c Z and \c N, return the mass excess in MeV
331  virtual double mass_excess_d(double Z, double N);
332 
333  };
334 
335  /** \brief Fittable mass formula [abstract base]
336 
337  Nuclear mass formulas which are descendants of this class
338  can be fit to experiment using \ref nucmass_fit.
339 
340  Within \o2p, this class has only two children,
341  \ref nucmass_frdm and \ref nucmass_semi_empirical. There
342  is also a child <tt>nucmass_ldrop</tt> in \o2e.
343  \comment
344  (Note that nucmass_ldrop is in o2scl_eos so currently
345  can't be referenced)
346  \endcomment
347  */
348  class nucmass_fit_base : public nucmass {
349 
350  public:
351 
353 
354  /// Return the type, \c "nucmass_fit_base".
355  virtual const char *type() { return "nucmass_fit_base"; }
356 
357  /// Number of fitting parameters
358  size_t nfit;
359 
360  /// Fix parameters from an array for fitting [abstract]
361  virtual int fit_fun(size_t nv, const ubvector &x)=0;
362 
363  /// Fill array with guess from present values for fitting [abstract]
364  virtual int guess_fun(size_t nv, ubvector &x)=0;
365 
366  };
367 
368  /** \brief Semi-empirical mass formula
369 
370  A simple semi-empirical mass formula of the form
371  \f[
372  E/A = B + S_s \frac{1}{A^{1/3}}+E_c \frac{Z^2}{A^{4/3}}
373  + S_v \left(1-\frac{2Z}{A}\right)^2+E_{\mathrm{pair}}(Z,N)
374  \f]
375  where the pairing energy is given by
376  \f[
377  E_{\mathrm{pair}}(Z,N) = - \frac{E_{\mathrm{pair}}}{2 A^{3/2}}
378  \left[ \cos \left( \pi Z \right)+\cos \left( \pi N \right) \right]
379  \f]
380  which is equivalent to the traditional prescription
381  \f[
382  E_{\mathrm{pair}}(Z,N) = \frac{E_{\mathrm{pair}}}{A^{3/2}}
383  \times
384  \left\{
385  \begin{array}{rl}
386  -1 & \mathrm{N~and~Z~even} \\
387  +1 & \mathrm{N~and~Z~odd} \\
388  0 & \mathrm{otherwise}
389  \end{array}
390  \right.
391  \f]
392  when \f$ Z \f$ and \f$ N \f$ and integers.
393 
394  \note The default parameters are arbitrary, and are not
395  determined from a fit.
396 
397  There is an example of the usage of this class given in
398  \ref ex_nucmass_fit_sect.
399  */
401 
402  public:
403 
405 
406  /// Binding energy (negative and in MeV, default -16)
407  double B;
408 
409  /// Symmetry energy (in MeV, default 23.7)
410  double Sv;
411 
412  /// Surface energy (in MeV, default 18)
413  double Ss;
414 
415  /// Coulomb energy (in MeV, default 0.7)
416  double Ec;
417 
418  /// Pairing energy (MeV, default 13.0)
419  double Epair;
420 
421  /// Return the type, \c "nucmass_semi_empirical".
422  virtual const char *type() { return "nucmass_semi_empirical"; }
423 
425 
426  /// Given \c Z and \c N, return the mass excess in MeV
427  virtual double mass_excess_d(double Z, double N);
428 
429  /// Given \c Z and \c N, return the mass excess in MeV
430  virtual double mass_excess(int Z, int N) {
431  return mass_excess_d(Z,N);
432  }
433 
434  /// Fix parameters from an array for fitting
435  virtual int fit_fun(size_t nv, const ubvector &x);
436 
437  /// Fill array with guess from present values for fitting
438  virtual int guess_fun(size_t nv, ubvector &x);
439 
440  };
441 
442  /** \brief An approximation of shell effects in nuclei based on
443  the interacting boson model
444 
445  Shell effects from \ref Dieperink09 based on the interacting
446  boson model, with corrections as suggested by \ref Duflo95.
447 
448  The default shell correction coefficients -1.39, 0.02, 0.03, and
449  0.075 (all in MeV), respectively.
450  */
452 
453  public:
454 
456 
457  virtual ~nucmass_ibm_shell() {}
458 
459  /** \name Shell correction coefficients in MeV
460  \comment
461  Remember that name documentation can only be one line
462  \endcomment
463  */
464  //@{
465  double s_a1;
466  double s_a2;
467  double s_a3;
468  double s_anp;
469  //@}
470 
471  /// Number of magic numbers
472  static const size_t nshells=11;
473 
474  /// Magic numbers
475  int shells[nshells];
476 
477  /// Most recently computed shell energy
478  double shell;
479 
480  /// Compute the shell energy for nucleus Z and N
481  virtual double shell_energy(int Z, int N);
482 
483  /** \brief Compute the shell energy for specified values of Z and N
484  using bilinear interpolation
485  */
486  virtual double shell_energy_interp(double Z, double N);
487 
488  };
489 
490  /** \brief Nuclear mass formula from Dieperink and van Isacker (2009)
491  */
493 
494  public:
495 
497 
498  /// Volume energy coefficient
499  double av;
500  /// Surface energy coefficient
501  double as;
502  /// Symmetry energy coefficient
503  double sv;
504  /// Coulomb energy coefficient
505  double ac;
506  /// Pairing energy coefficient
507  double ap;
508  /// Surface symmetry energy coefficient
509  double y;
510 
511  /// Return the type, \c "nucmass_dvi".
512  virtual const char *type() { return "nucmass_dvi"; }
513 
514  nucmass_dvi();
515 
516  /// Given \c Z and \c N, return the mass excess in MeV
517  virtual double mass_excess_d(double Z, double N);
518 
519  /// Given \c Z and \c N, return the mass excess in MeV
520  virtual double mass_excess(int Z, int N) {
521  return mass_excess_d(Z,N);
522  }
523 
524  /// Fix parameters from an array for fitting
525  virtual int fit_fun(size_t nv, const ubvector &x);
526 
527  /// Fill array with guess from present values for fitting
528  virtual int guess_fun(size_t nv, ubvector &x);
529 
530  };
531 
532  /** \brief Compute the RMS radius of a Fermi-Dirac density distribution
533  with fixed diffusiveness
534 
535  This class computes the RMS radius given either the central density
536  or the radius specified in the Fermi function. This class assumes
537  the density distribution function is of the form
538  \f[
539  N = 4 \pi \rho_0 \int r^2~dr~\left\{1+\exp
540  \left[\left(r-R_{\mathrm{fermi}}\right)/d\right]\right\}^{-1}
541  \f]
542  where \f$ N \f$ is the total number of particles, \f$ d \f$ is
543  the diffusiveness, \f$ R_{\mathrm{fermi}} \f$ is the half-height
544  radius, and \f$ \rho_0 \f$ is the central density.
545 
546  The radius assuming constant density,
547  \f[
548  R_{\mathrm{cd}} = \left(\frac{3 N}{4 \pi \rho_0}\right)^3 \, ,
549  \f]
550  is also given.
551  */
553 
554  protected:
555 
556  /// The central denstiy
557  double urho0;
558  /// The diffusiveness
559  double ud;
560  /** \brief Store the user-specified value of the radius in the
561  Fermi distribution
562 
563  This is used in the integrands \ref iand() and \ref iand2().
564  */
565  double uRfermi;
566  /// The total number of particles
567  double uN;
568 
569  /// The integrator
571  /// The solver
573 
574  /// The function \f$ 4 \pi r^4 \rho(r) \f$
575  double iand(double r);
576 
577  /// The function \f$ 4 \pi r^2 \rho(r) \f$
578  double iand2(double r);
579 
580  /// The function to fix the total number of particles
581  double solve(double x);
582 
583  public:
584 
585  nucmass_radius();
586 
587  /** \brief Compute the RMS radius from the central density
588 
589  Computes the RMS radius \c Rrms from the central density \c
590  rho0, the number of particles \c N, and the diffusiveness \c
591  d. This function also computes the radius in the Fermi
592  distribution function, \c Rfermi and the radius assuming
593  constant density, \c Rcd.
594  */
595  void eval_rms_rho(double rho0, double N, double d,
596  double &Rcd, double &Rfermi, double &Rrms);
597 
598  /** \brief Compute the RMS radius from the Fermi distribution radius
599 
600  Computes the RMS radius \c Rrms from the radius \c Rfermi in
601  the Fermi distribution assuming a total number of particles \c
602  N, a diffusiveness paramter \c d. This function also produces
603  the central density \c rho0, and the radius assuming constant
604  density, \c Rcd.
605  */
606  void eval_rms_rsq(double Rfermi, double N, double d,
607  double &rho0, double &Rcd, double &Rrms);
608 
609  /** \brief The radial density distribution
610  */
611  double density(double r, double Rfermi, double d, double rho0);
612 
613  /** \brief The radial density distribution times radius squared
614  */
615  double iand2_new(double r, double Rfermi, double d, double rho0);
616 
617  /** \brief Compute the total number of particles with
618  numerical uncertainty
619  */
620  void eval_N_err(double Rfermi, double d, double rho0,
621  double &N, double &N_err);
622 
623  /** \brief Compute the total number of particles
624  */
625  double eval_N(double Rfermi, double d, double rho0);
626 
627  };
628 
629 #ifndef DOXYGEN_NO_O2NS
630 }
631 #endif
632 
633 #endif
double ap
Pairing energy coefficient.
Definition: nucmass.h:507
inte_qagiu_gsl it
The integrator.
Definition: nucmass.h:570
double as
Surface energy coefficient.
Definition: nucmass.h:501
double m_elec
Electron mass in (defaults to o2scl_mks::mass_electron converted into MeV)
Definition: nucmass.h:306
virtual double total_mass_d(double Z, double N)
Return the total mass of the nucleus (without the electrons) in MeV.
Definition: nucmass.h:273
Nuclear mass formula base [abstract base].
Definition: nucmass.h:202
double av
Volume energy coefficient.
Definition: nucmass.h:499
Semi-empirical mass formula.
Definition: nucmass.h:400
double m_neut
Neutron mass in (defaults to o2scl_mks::mass_neutron converted into MeV)
Definition: nucmass.h:296
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:416
double uRfermi
Store the user-specified value of the radius in the Fermi distribution.
Definition: nucmass.h:565
std::string element_list[nelements]
The list of elements organized by proton number.
Definition: nucmass.h:133
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:211
virtual double binding_energy(int Z, int N)
Return the binding energy in MeV.
Definition: nucmass.h:249
root_cern cr
The solver.
Definition: nucmass.h:572
Nuclear mass information.
Definition: nucmass.h:62
Compute the RMS radius of a Fermi-Dirac density distribution with fixed diffusiveness.
Definition: nucmass.h:552
double shell
Most recently computed shell energy.
Definition: nucmass.h:478
virtual double total_mass(int Z, int N)
Return the total mass of the nucleus (without the electrons) in MeV.
Definition: nucmass.h:266
double uN
The total number of particles.
Definition: nucmass.h:567
double Sv
Symmetry energy (in MeV, default 23.7)
Definition: nucmass.h:410
size_t nfit
Number of fitting parameters.
Definition: nucmass.h:358
virtual double electron_binding(double Z)
Return the approximate electron binding energy in MeV.
Definition: nucmass.h:239
double sv
Symmetry energy coefficient.
Definition: nucmass.h:503
double m_amu
Atomic mass unit in (defaults to o2scl_mks::unified_atomic_mass converted into MeV) ...
Definition: nucmass.h:311
Tabulated nuclear masses [abstract base].
Definition: nucmass.h:326
virtual double binding_energy_d(double Z, double N)
Return the binding energy in MeV.
Definition: nucmass.h:259
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:280
virtual const char * type()
Return the type, "nucmass_semi_empirical".
Definition: nucmass.h:422
double Ss
Surface energy (in MeV, default 18)
Definition: nucmass.h:413
double ud
The diffusiveness.
Definition: nucmass.h:559
double B
Binding energy (negative and in MeV, default -16)
Definition: nucmass.h:407
std::map< std::string, int, std::greater< std::string > >::iterator table_it
A convenient typedef for an iterator for element_table.
Definition: nucmass.h:130
double ac
Coulomb energy coefficient.
Definition: nucmass.h:505
double Epair
Pairing energy (MeV, default 13.0)
Definition: nucmass.h:419
double m_prot
Proton mass in (defaults to o2scl_mks::mass_proton converted into MeV)
Definition: nucmass.h:301
double urho0
The central denstiy.
Definition: nucmass.h:557
virtual const char * type()
Return the type, "nucmass_fit_base".
Definition: nucmass.h:355
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:216
A simple nucleus class.
Definition: nucleus.h:55
Nuclear mass formula from Dieperink and van Isacker (2009)
Definition: nucmass.h:492
int eltoZ(std::string el)
Return Z given the element name abbreviation.
virtual const char * type()
Return the type, "nucmass_dvi".
Definition: nucmass.h:512
double y
Surface symmetry energy coefficient.
Definition: nucmass.h:509
virtual double mass_excess(int Z, int N)
Given Z and N, return the mass excess in MeV.
Definition: nucmass.h:520
virtual double mass_excess(int Z, int N)
Given Z and N, return the mass excess in MeV.
Definition: nucmass.h:430
Fittable mass formula [abstract base].
Definition: nucmass.h:348
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:287
An approximation of shell effects in nuclei based on the interacting boson model. ...
Definition: nucmass.h:451
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).