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