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

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