00001 /* 00002 ------------------------------------------------------------------- 00003 00004 Copyright (C) 2006, 2007, 2008, Andrew W. Steiner 00005 00006 This file is part of O2scl. 00007 00008 O2scl is free software; you can redistribute it and/or modify 00009 it under the terms of the GNU General Public License as published by 00010 the Free Software Foundation; either version 3 of the License, or 00011 (at your option) any later version. 00012 00013 O2scl is distributed in the hope that it will be useful, 00014 but WITHOUT ANY WARRANTY; without even the implied warranty of 00015 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00016 GNU General Public License for more details. 00017 00018 You should have received a copy of the GNU General Public License 00019 along with O2scl. If not, see <http://www.gnu.org/licenses/>. 00020 00021 ------------------------------------------------------------------- 00022 */ 00023 #ifndef O2SCL_NUCLEAR_MASS_H 00024 #define O2SCL_NUCLEAR_MASS_H 00025 00026 #include <cmath> 00027 #include <string> 00028 #include <map> 00029 #include <o2scl/nucleus.h> 00030 #include <o2scl/constants.h> 00031 #include <o2scl/base_ioc.h> 00032 00033 #ifndef DOXYGENP 00034 namespace o2scl { 00035 #endif 00036 00037 /** 00038 \brief Nuclear mass formula base 00039 00040 This base class provides some default functionality for 00041 the nuclear mass formulas. For typical usage, use 00042 \ref ame_mass, \ref mnmsk_mass, \ref mnmsk_mass_exp, 00043 or \ref semi_empirical_mass. 00044 00045 Elements 112-118 are named "Uub", "Uut", "Uuq", "Uup", 00046 "Uuh", "Uus", and "Uuo", respectively. 00047 00048 The binding energy is defined by 00049 \f[ 00050 \mathrm{BE}=Z m_{H} + N m_{n} - m_{\mathrm{nuclide}} 00051 \f] 00052 where \f$m_{\mathrm{nuclide}}\f$ is the mass of the 00053 nucleus including the mass of the electrons. 00054 The mass excess is defined by 00055 \f[ 00056 m_{\mathrm{excess}} = m_{\mathrm{nuclide}} - A m_{u} 00057 \f] 00058 00059 For example, for \f$ \mathrm{U}^{238} \f$, the binding energy is 00060 1801.695 MeV, the mass excess is 47.30366 MeV, and 00061 \f$m_{\mathrm{nuclide}}\f$ is 221742.9 MeV. This is consistent 00062 with the above, as \f$m_H\f$ is 938.7830 MeV, \f$m_n\f$ is 00063 939.5650 MeV, and \f$m_u\f$ is 931.494 MeV. 00064 00065 Some mass formulas are undefined for sufficiently exotic nuclei. 00066 You can use the function is_included() to find if a particular 00067 nucleus is included or not. 00068 00069 This class is designed so that a child only needs to reimplement 00070 either mass_excess() (if <tt>form_type==disc_type</tt>) or 00071 mass_excess_d() (if <tt>form_type==cont_type</tt>), and the 00072 remaining functions should work then automatically. 00073 00074 \warning The spin degeneracy is not handled particularly 00075 intelligently. The get_nucleus() function simply assumes 00076 0 spin for even A and spin 1/2 for odd A. 00077 00078 \warning The treatment of the electron binding energy 00079 contribution is not necessarily consistent at present. 00080 00081 Some common reaction Q-values and separation energies: \n 00082 \f$\mathrm{Q}(\beta^{-})=\mathrm{M(A,Z)}-\mathrm{M(A,Z+1)}\f$: 00083 Beta-decay energy \n 00084 \f$\mathrm{Q}(2\beta^{-})=\mathrm{M(A,Z)}-\mathrm{M(A,Z+2)}\f$: 00085 Double beta-decay energy \n 00086 \f$\mathrm{Q}(4\beta^{-})=\mathrm{M(A,Z)}-\mathrm{M(A,Z+4)}\f$: 00087 Four beta-decay energy \n 00088 \f$\mathrm{Q}(\alpha)=\mathrm{M(A,Z)}-\mathrm{M(A-4,Z-2)}- 00089 \mathrm{M(He^{4})}\f$: 00090 Alpha-decay energy \n 00091 \f$\mathrm{Q}(\beta-n)=\mathrm{M(A,Z)}-\mathrm{M(A-1,Z+1)} 00092 -\mathrm{M(n)}\f$: 00093 Beta-delayed neutron emission decay energy \n 00094 \f$\mathrm{Q}(d,\alpha)=\mathrm{M(A,Z)}-\mathrm{M(A-2,Z-1)} 00095 -\mathrm{M(He^{4})}-\mathrm{M(H^{2})}\f$: 00096 \f$(d,\alpha)\f$ reaction energy \n 00097 \f$\mathrm{Q}(\mathrm{EC})=\mathrm{M(A,Z)}-\mathrm{M(A,Z-1)}\f$: 00098 Electron capture decay energy \n 00099 \f$\mathrm{Q}(\mathrm{ECp})=\mathrm{M(A,Z)}-\mathrm{M(A-1,Z-2)}\f$: 00100 Electron capture with delayed proton emission decay energy \n 00101 \f$\mathrm{Q}(n,\alpha)=\mathrm{M(A,Z)}-\mathrm{M(A-3,Z-2)} 00102 -\mathrm{M(He^{4})}+\mathrm{M(n)}\f$: 00103 \f$(n,\alpha)\f$ reaction energy \n 00104 \f$\mathrm{Q}(p,\alpha)=\mathrm{M(A,Z)}-\mathrm{M(A-3,Z-1)} 00105 -\mathrm{M(He^{4})}+\mathrm{M(p)}\f$: 00106 \f$(p,\alpha)\f$ reaction energy \n 00107 \f$\mathrm{S}(n) = \mathrm{-M(A,Z)}+\mathrm{M(A-1,Z)}+ 00108 \mathrm{M(n)}\f$: Neutron separation energy \n 00109 \f$\mathrm{S}(p) = \mathrm{-M(A,Z)}+\mathrm{M(A-1,Z-1)}+ 00110 \mathrm{H^{1}}\f$: Proton separation energy \n 00111 \f$\mathrm{S}(2n) = \mathrm{-M(A,Z)}+\mathrm{M(A-2,Z)}+ 00112 \mathrm{2M(n)}\f$: Two neutron separation energy \n 00113 \f$\mathrm{S}(2p) = \mathrm{-M(A,Z)}+\mathrm{M(A-2,Z-2)}+ 00114 \mathrm{2 M(H^{1)}}\f$: Two proton separation energy \n 00115 00116 \note All descendants ought to set \c form_type to indicate 00117 whether the mass formula is discrete or continuous 00118 00119 \todo Make the treatment of the electron binding energy 00120 contribution more consistent. 00121 00122 \future It might be useful to consider a fudge factor 00123 to ensure no problems with finite precision arithmetic 00124 when converting \c double to \c int. 00125 00126 */ 00127 class nuclear_mass { 00128 public: 00129 00130 nuclear_mass(); 00131 00132 virtual ~nuclear_mass() {}; 00133 00134 /** 00135 \brief Return false if the mass formula does not include 00136 specified nucleus 00137 */ 00138 virtual bool is_included(int Z, int N) { 00139 return true; 00140 } 00141 00142 /** \brief Fill \c n with the information from nucleus with the given 00143 neutron and proton number 00144 00145 All masses are given in \f$\mathrm{fm}^{-1}\f$. The total mass 00146 (withouth the electrons) is put in part::m and part::ms, the 00147 binding energy is placed in nucleus::be, the mass excess in 00148 nucleus::mex and the degeneracy (part::g) is arbitrarily set 00149 to 1 for even A nuclei and 2 for odd A nuclei. 00150 */ 00151 int get_nucleus(int Z, int N, nucleus &n) { 00152 n.Z=Z; 00153 n.N=N; 00154 n.A=Z+N; 00155 n.mex=mass_excess(Z,N)/o2scl_const::hc_mev_fm; 00156 n.m=n.mex+((Z+N)*o2scl_fm::mass_amu-Z*o2scl_fm::mass_electron); 00157 n.ms=n.m; 00158 n.be=(n.m-N*o2scl_fm::mass_neutron-Z*o2scl_fm::mass_proton); 00159 if (n.A%2==0) n.g=1.0; 00160 else n.g=2.0; 00161 return 0; 00162 } 00163 00164 /// Given \c Z and \c N, return the mass excess in MeV 00165 virtual double mass_excess(int Z, int N) { 00166 if (form_type==cont_type) { 00167 return mass_excess_d(Z,N); 00168 } 00169 set_err("Using base class version of mass_excess().",gsl_nobase); 00170 return 0.0; 00171 } 00172 00173 00174 /// Given \c Z and \c N, return the mass excess in MeV 00175 virtual double mass_excess_d(double Z, double N) { 00176 if (form_type==disc_type) { 00177 int Z1=(int)Z; 00178 int N1=(int)N; 00179 double mz1n1=mass_excess(Z1,N1); 00180 double mz1n2=mass_excess(Z1,N1+1); 00181 double mz2n1=mass_excess(Z1+1,N1); 00182 double mz2n2=mass_excess(Z1+1,N1+1); 00183 double mz1=mz1n1+(N-N1)*(mz1n2-mz1n1); 00184 double mz2=mz2n1+(N-N1)*(mz2n2-mz2n1); 00185 return mz1+(Z-Z1)*(mz2-mz1); 00186 } 00187 set_err("Using base class version of mass_excess_d().",gsl_nobase); 00188 return 0.0; 00189 } 00190 00191 /** 00192 \brief Return the binding energy in MeV 00193 00194 The binding energy is defined to be negative for bound 00195 nuclei, thus the binding energy per baryon of Pb-208 00196 is about -8*208 = -1664 MeV. 00197 */ 00198 virtual double binding_energy(int Z, int N) { 00199 return (mass_excess(Z,N)+ 00200 ((Z+N)*o2scl_fm::mass_amu-Z*o2scl_fm::mass_electron- 00201 N*o2scl_fm::mass_neutron-Z*o2scl_fm::mass_proton)* 00202 o2scl_const::hc_mev_fm); 00203 } 00204 00205 /** 00206 \brief Return the binding energy in MeV 00207 00208 The binding energy is defined to be negative for bound 00209 nuclei, thus the binding energy per baryon of Pb-208 00210 is about -8*208 = -1664 MeV. 00211 */ 00212 virtual double binding_energy_d(double Z, double N) { 00213 return (mass_excess_d(Z,N)+ 00214 ((Z+N)*o2scl_fm::mass_amu-Z*o2scl_fm::mass_electron- 00215 N*o2scl_fm::mass_neutron-Z*o2scl_fm::mass_proton)* 00216 o2scl_const::hc_mev_fm); 00217 } 00218 00219 /** \brief Return the total mass of the nucleus (without the electrons) 00220 in MeV 00221 */ 00222 virtual double total_mass(int Z, int N) { 00223 return (mass_excess(Z,N)+((Z+N)*o2scl_fm::mass_amu- 00224 Z*o2scl_fm::mass_electron)* 00225 o2scl_const::hc_mev_fm); 00226 } 00227 00228 /** \brief Return the total mass of the nucleus (without the electrons) 00229 in MeV 00230 */ 00231 virtual double total_mass_d(double Z, double N) { 00232 return (mass_excess_d(Z,N)+((Z+N)*o2scl_fm::mass_amu- 00233 Z*o2scl_fm::mass_electron)* 00234 o2scl_const::hc_mev_fm); 00235 } 00236 00237 /** 00238 \brief Return Z given the element name 00239 00240 Properly handle errors 00241 */ 00242 int eltoZ(std::string el) { 00243 return element_table.find(el)->second; 00244 } 00245 00246 /** 00247 \brief Return the element name given Z 00248 00249 Note that <tt>Ztoel(0)</tt> returns \c "n" indicating the 00250 neutron and if the argument \c Z is greater than 118, an 00251 empty string is returned. 00252 */ 00253 std::string Ztoel(size_t Z) { 00254 if (((int)Z)>=nelements) { 00255 set_err("Invalid element in Ztoel().",gsl_einval); 00256 return ""; 00257 } 00258 return element_list[Z]; 00259 } 00260 00261 /** 00262 \brief Parse a string of the form "Pb208" 00263 00264 Note that this does not correctly interpret dashes, 00265 e.g. "Pb-208". will not work. 00266 00267 \future Properly ignore dashes and other non-alphanumeric 00268 characters. 00269 */ 00270 int parse_elstring(std::string ela, int &Z, int &N, int &A) { 00271 if (ela.length()<2) { 00272 set_err_ret 00273 ("Element name too short in nuclear_mass::parse_elstring().", 00274 gsl_efailed); 00275 } 00276 if (ela.length()>3 && isalpha(ela[2])) { 00277 std::string el=ela.substr(0,3); 00278 Z=eltoZ(el); 00279 A=stoi(ela.substr(3,ela.length()-2)); 00280 N=A-Z; 00281 return 0; 00282 } 00283 if (ela.length()>2 && isalpha(ela[1])) { 00284 std::string el=ela.substr(0,2); 00285 Z=eltoZ(el); 00286 A=stoi(ela.substr(2,ela.length()-2)); 00287 N=A-Z; 00288 return 0; 00289 } 00290 std::string el=ela.substr(0,1); 00291 Z=eltoZ(el); 00292 A=stoi(ela.substr(1,ela.length()-1)); 00293 N=A-Z; 00294 return 0; 00295 } 00296 00297 #ifndef DOXYGEN_INTERNAL 00298 00299 protected: 00300 00301 /// String comparison operator for element_table 00302 struct string_less_than { 00303 bool operator()(const std::string s1, const std::string s2) const { 00304 return s1<s2; 00305 } 00306 }; 00307 00308 /// The number of elements (proton number) 00309 static const int nelements=119; 00310 00311 /// A map containing the proton numbers organized by element name 00312 std::map<std::string,int,string_less_than> element_table; 00313 00314 /// A convenient typedef for an iterator for element_table 00315 typedef std::map<std::string,int,string_less_than>::iterator table_it; 00316 00317 /// The list of elements organized by proton number 00318 std::string element_list[nelements]; 00319 00320 /** 00321 \name Indicate whether or not the mass formula is 00322 discrete or continuous 00323 */ 00324 //@{ 00325 int form_type; 00326 static const int cont_type=1; 00327 static const int disc_type=2; 00328 //@} 00329 00330 #endif 00331 00332 }; 00333 00334 /** 00335 \brief Fittable mass formula 00336 00337 Nuclear mass formulas which are descendants of this class 00338 can be fit to experiment using \ref mass_fit. 00339 */ 00340 class nuclear_mass_fit : public nuclear_mass { 00341 00342 public: 00343 00344 /// Number of fitting parameters 00345 size_t nfit; 00346 00347 /// Fix parameters from an array for fitting 00348 virtual int fit_fun(size_t nv, const ovector_view &x) { 00349 return 0; 00350 } 00351 00352 /// Fill array with guess from present values for fitting 00353 virtual int guess_fun(size_t nv, ovector_view &x) { 00354 return 0; 00355 } 00356 00357 }; 00358 00359 /** 00360 \brief Semi-empirical mass formula 00361 00362 A simple semi-empirical mass formula of the form 00363 \f[ 00364 E/A = B + S_s \frac{1}{A^{1/3}}+E_c \frac{Z^2}{A^{4/3}} 00365 + S_v \left(1-\frac{2Z}{A}\right)^2+E_{\mathrm{pair}}(Z,N) 00366 \f] 00367 where 00368 \f[ 00369 E_{\mathrm{pair}}(Z,N) = \frac{E_{\mathrm{pair}}}{A^{3/2}} 00370 \times 00371 \left\{ 00372 \begin{array}{rl} 00373 -1 & \mathrm{N~and~Z~even} \\ 00374 +1 & \mathrm{N~and~Z~odd} \\ 00375 0 & \mathrm{otherwise} 00376 \end{array} 00377 \right. 00378 \f] 00379 00380 \note The default parameters are arbitrary, and are not 00381 determined from a fit. 00382 */ 00383 class semi_empirical_mass : public nuclear_mass_fit { 00384 00385 public: 00386 00387 /// Binding energy (negative and in MeV, default -16) 00388 double B; 00389 00390 /// Symmetry energy (in MeV, default 23.7) 00391 double Sv; 00392 00393 /// Surface energy (in MeV, default 18) 00394 double Ss; 00395 00396 /// Coulomb energy (in MeV, default 0.7) 00397 double Ec; 00398 00399 /// Pairing energy (MeV, default 13.0) 00400 double Epair; 00401 00402 semi_empirical_mass() { 00403 B=-16.0; 00404 Ss=18.0; 00405 Ec=0.7; 00406 Sv=23.7; 00407 Epair=13.0; 00408 nfit=5; 00409 form_type=cont_type; 00410 } 00411 00412 /// Given \c Z and \c N, return the mass excess in MeV 00413 virtual double mass_excess_d(double Z, double N) { 00414 double A=Z+N, cA=cbrt(A); 00415 double EoA=B+Ss/cA+Ec*Z*Z/cA/A+Sv*pow(1.0-2.0*Z/A,2.0); 00416 if (((int)(A-Z+0.01))%2==0 && ((int)(Z+0.01))%2==0) { 00417 EoA-=Epair/pow(A,1.5); 00418 } else if (((int)(A-Z+0.01))%2==1 && ((int)(Z+0.01))%2==1) { 00419 EoA+=Epair/pow(A,1.5); 00420 } 00421 double ret=EoA*A+Z*(o2scl_fm::mass_proton+o2scl_fm::mass_electron)* 00422 o2scl_const::hc_mev_fm+N*o2scl_fm::mass_neutron* 00423 o2scl_const::hc_mev_fm-A*o2scl_fm::mass_amu*o2scl_const::hc_mev_fm; 00424 return ret; 00425 } 00426 00427 /// Fix parameters from an array for fitting 00428 virtual int fit_fun(size_t nv, const ovector_view &x) { 00429 B=-x[0]; Sv=x[1]; Ss=x[2]; Ec=x[3]; Epair=x[4]; 00430 return 0; 00431 } 00432 00433 /// Fill array with guess from present values for fitting 00434 virtual int guess_fun(size_t nv, ovector_view &x) { 00435 x[0]=-B; x[1]=Sv; x[2]=Ss; x[3]=Ec; x[4]=Epair; 00436 return 0; 00437 } 00438 00439 }; 00440 00441 /** 00442 \brief Atomic mass entry structure 00443 */ 00444 typedef struct { 00445 00446 /// N-Z 00447 int NMZ; 00448 00449 /// Neutron number 00450 int N; 00451 00452 /// Proton number 00453 int Z; 00454 00455 /// Atomic number 00456 int A; 00457 00458 /// Element name 00459 std::string el; 00460 00461 /// Data origin 00462 std::string orig; 00463 00464 /// Mass excess 00465 double mass; 00466 00467 /// Mass excess uncertainty 00468 double dmass; 00469 00470 /// Binding energy (given in the '95 data) 00471 double be; 00472 00473 /// Binding energy uncertainty (given in the '95 data) 00474 double dbe; 00475 00476 /// Binding energy / A (given in the '03 data) 00477 double beoa; 00478 00479 /// Binding energy / A uncertainty (given in the '03 data) 00480 double dbeoa; 00481 00482 /// Beta decay mode 00483 std::string bdmode; 00484 00485 /// Beta-decay energy 00486 double bde; 00487 00488 /// Beta-decay energy uncertainty 00489 double dbde; 00490 00491 /// ? 00492 int A2; 00493 00494 /// Atomic mass 00495 double amass; 00496 00497 /// Atomic mass uncertainty 00498 double damass; 00499 00500 } ame_entry; 00501 00502 /** \brief A support class for I/O of the 1995 AME data 00503 */ 00504 class ame_entry95_io_type : public io_tlate<ame_entry> { 00505 public: 00506 int input(cinput *co, in_file_format *ins, ame_entry *t); 00507 int output(coutput *co, out_file_format *outs, ame_entry *t); 00508 virtual const char *type(); 00509 }; 00510 00511 /** \brief A support class for I/O of the 2003 AME data 00512 */ 00513 class ame_entry03_io_type : public io_tlate<ame_entry> { 00514 public: 00515 int input(cinput *co, in_file_format *ins, ame_entry *t); 00516 int output(coutput *co, out_file_format *outs, ame_entry *t); 00517 virtual const char *type(); 00518 }; 00519 00520 /** 00521 \brief Mass formula from the Atomic Mass Evaluation (2005 and 1993) 00522 00523 This class provides an interface to the atomic mass table using 00524 data from \ref Audi95 and \ref Audi03. 00525 00526 There are four data sets, selected by the specification of the 00527 \c version string in the constructor. 00528 - "95rmd" - "Recommended" data from \ref Audi95 (ame95rmd.dat) 00529 - "95exp" - "Experimental" data from \ref Audi95 (ame95exp.dat) 00530 - "03round" - "Rounded" data from \ref Audi03 (ame03round.dat) 00531 - "03" - Data from \ref Audi03 (default) (ame03.dat) 00532 00533 If any string other than these four is used, the default 00534 data is loaded. If the constructor cannot find the data file 00535 (e.g. because of a broken installation), then ame::is_loaded() 00536 returns false. 00537 00538 The 1995 data provided the binding energy stored in 00539 ame_entry::be and ame_entry::dbe, while the 2003 data provided 00540 the binding energy divided by the atomic number stored in 00541 ame_entry::beoa and ame_entry::dbeoa. When the 1995 data is used 00542 ame_entry::beoa and ame_entry::dbeoa are calculated automatically, 00543 and when the 2003 data is used ame_entry::be and ame_entry::dbe 00544 are calculated automatically. 00545 00546 Note that blank entries in the original table that correspond to 00547 columns represented by the type \c double are set to zero 00548 arbitrarily. 00549 00550 Note that all uncertainties are 1 sigma uncertainties. 00551 00552 \warning There are strict definitions of the atomic mass unit 00553 and other constants that are defined by the 1995 and 2003 00554 atomic mass evaluations which are not used at present. 00555 00556 \future Create a caching and more intelligent search system for 00557 the table. The table is sorted by A and then N, so we could 00558 probably just copy the search routine from mnmsk_mass, which is 00559 sorted by Z and then N. 00560 \future Use the atomic mass unit 00561 and other constants defined in the evaulation 00562 */ 00563 class ame_mass : public nuclear_mass { 00564 public: 00565 00566 /// Create a collection specified by \c version 00567 ame_mass(std::string version=""); 00568 00569 /** 00570 \brief Return false if the mass formula does not include 00571 specified nucleus 00572 */ 00573 virtual bool is_included(int Z, int N); 00574 00575 /// Given \c Z and \c N, return the mass excess in MeV 00576 virtual double mass_excess(int Z, int N) { 00577 ame_entry ret; 00578 ret=get_ZN(Z,N); 00579 if (ret.Z==0 && ret.N==0) return 0.0; 00580 return ret.mass/1.0e3; 00581 } 00582 00583 /// Get element with Z=l_Z and N=l_N (e.g. 82,126). 00584 ame_entry get_ZN(int l_Z, int l_N); 00585 00586 /// Get element with Z=l_Z and A=l_A (e.g. 82,208). 00587 ame_entry get_ZA(int l_Z, int l_A); 00588 00589 /// Get element with name l_el and A=l_A (e.g. "Pb",208). 00590 ame_entry get_elA(std::string l_el, int l_A); 00591 00592 /// Get element with string (e.g. "Pb208") 00593 ame_entry get(std::string nucleus); 00594 00595 /// The number of entries (about 3000). 00596 int n; 00597 00598 /// The short names of the columns (length 16) 00599 std::string *short_names; 00600 00601 /// The long names of the columns (length 16) 00602 std::string *col_names; 00603 00604 /// The reference for the original data 00605 std::string reference; 00606 00607 /// The array containing the mass data of length ame::n 00608 ame_entry *mass; 00609 00610 /// Returns true if the constructor succesfully loaded the data 00611 bool is_loaded() { return loaded; } 00612 00613 #ifndef DOXYGEN_INTERNAL 00614 00615 protected: 00616 00617 /// True if loading the data was successful 00618 bool loaded; 00619 00620 #endif 00621 00622 }; 00623 00624 /** 00625 \brief Mass formula entry structure for Moller, et al. 00626 */ 00627 typedef struct { 00628 00629 /// Neutron number 00630 int N; 00631 00632 /// Proton number 00633 int Z; 00634 00635 /// Atomic number 00636 int A; 00637 00638 /** \name Ground state deformations (perturbed-spheroid parameterization) 00639 */ 00640 //@{ 00641 /// Quadrupole 00642 double eps2; 00643 /// Octupole 00644 double eps3; 00645 /// Hexadecapole 00646 double eps4; 00647 /// Hexacontatetrapole 00648 double eps6; 00649 /// Hexacontatetrapole without mass asymmetry 00650 double eps6sym; 00651 //@} 00652 00653 /** \name Ground state deformations in the spherical-harmonics expansion 00654 */ 00655 //@{ 00656 /// Quadrupole 00657 double beta2; 00658 /// Octupole 00659 double beta3; 00660 /// Hexadecapole 00661 double beta4; 00662 /// Hexacontatetrapole 00663 double beta6; 00664 //@} 00665 00666 /// The ground-state microscopic energy 00667 double Emic; 00668 00669 /// The theoretical mass excess (in MeV) 00670 double Mth; 00671 00672 /// The experimental mass excess (in MeV) 00673 double Mexp; 00674 00675 /// Experimental mass excess error 00676 double sigmaexp; 00677 00678 /// The ground-state microscopic energy in the FRLDM 00679 double EmicFL; 00680 00681 /// The theoretical mass excess in the FRLDM 00682 double MthFL; 00683 00684 /// Spin and pairity of odd proton 00685 std::string spinp; 00686 00687 /// Spin and pairity of odd neutron 00688 std::string spinn; 00689 00690 /// Lipkin-Nogami proton gap 00691 double gapp; 00692 00693 /// Lipkin-Nogami neutron gap 00694 double gapn; 00695 00696 /// Total binding energy 00697 double be; 00698 00699 /// One neutron separation energy 00700 double S1n; 00701 00702 /// Two neutron separation energy 00703 double S2n; 00704 00705 /** 00706 \brief Percentage of daughters generated in beta decay after 00707 beta-delayed neutron emission 00708 */ 00709 double PA; 00710 00711 /// Desc 00712 double PAm1; 00713 00714 /// Desc 00715 double PAm2; 00716 00717 /// Energy released in beta-decay 00718 double Qbeta; 00719 00720 /// Half-life w.r.t. GT beta-decay 00721 double Tbeta; 00722 00723 /// One proton separation energy 00724 double S1p; 00725 00726 /// Two proton separation energy 00727 double S2p; 00728 00729 /// Energy released in alpha-decay 00730 double Qalpha; 00731 00732 /// Half-life w.r.t. alpha-decay 00733 double Talpha; 00734 00735 00736 } mnmsk_mass_entry; 00737 00738 template<> int io_tlate<mnmsk_mass_entry>::input 00739 (cinput *co, in_file_format *ins, mnmsk_mass_entry *t); 00740 template<> int io_tlate<mnmsk_mass_entry>::output 00741 (coutput *co, out_file_format *outs, mnmsk_mass_entry *t); 00742 template<> const char *io_tlate<mnmsk_mass_entry>::type(); 00743 00744 typedef io_tlate<mnmsk_mass_entry> mnmsk_mass_entry_io_type; 00745 00746 /** 00747 \brief Mass formula from Moller, Nix, Myers and Swiatecki 00748 00749 The data containing an object of type moller_mass_entry for 8979 00750 nuclei is automatically loaded by the constructor. If the file 00751 (nndc/moller.dat) is not found, then is_loaded() will return 00752 false and all calls to get_ZN() will return an object with \c 00753 N=Z=0. 00754 00755 There are several entries in the original table which are 00756 blank because they are in some way not known, measured, or 00757 computable. To distinguish these values from zero, blank entries 00758 have been replaced by the number \c 1.0e99. For convenience, 00759 this value is returned by \ref blank(). 00760 */ 00761 class mnmsk_mass : public nuclear_mass { 00762 public: 00763 00764 mnmsk_mass(); 00765 00766 /** 00767 \brief Return false if the mass formula does not include 00768 specified nucleus 00769 */ 00770 virtual bool is_included(int Z, int N); 00771 00772 /// Given \c Z and \c N, return the mass excess in MeV 00773 virtual double mass_excess(int Z, int N) { 00774 mnmsk_mass_entry ret; 00775 ret=get_ZN(Z,N); 00776 if (ret.Z==0 && ret.N==0) return 0.0; 00777 return ret.Mth; 00778 } 00779 00780 /** 00781 \brief Get the entry for the specified proton and neutron number 00782 00783 This method searches the table using a cached binary search 00784 algorithm. It is assumed that the table is sorted first by 00785 proton number and then by neutron number. 00786 */ 00787 mnmsk_mass_entry get_ZN(int l_Z, int l_N); 00788 00789 /// Verify that the constructor properly loaded the table 00790 bool is_loaded() { return loaded; }; 00791 00792 /// The number of table entries 00793 int n; 00794 00795 /// The array containing the table 00796 mnmsk_mass_entry *mass; 00797 00798 /// The value which corresponds to a blank entry 00799 double blank() { return 1.0e99; }; 00800 00801 /// Neither beta+ or beta- is possible 00802 double neither() { return 1.0e98; }; 00803 00804 /// The value which corresponds to a blank entry 00805 double beta_stable() { return 1.0e97; }; 00806 00807 /// Both beta+ and beta- are possible 00808 double beta_plus_and_minus() { return 1.0e96; }; 00809 00810 /// The value is greater than 100 00811 double greater_100() { return 1.0e95; }; 00812 00813 /// The value is greater than \f$ 10^{20} \f$ 00814 double very_large() { return 1.0e94; }; 00815 00816 #ifndef DOXYGEN_INTERNAL 00817 00818 protected: 00819 00820 /// True if the table was successfully loaded 00821 bool loaded; 00822 00823 /// The last table index for caching 00824 int last; 00825 00826 #endif 00827 00828 }; 00829 00830 /// The experimental values from Moller, Nix, Myers and Swiatecki 00831 class mnmsk_mass_exp : public mnmsk_mass { 00832 00833 public: 00834 00835 /** 00836 \brief Return false if the mass formula does not include 00837 specified nucleus 00838 */ 00839 virtual bool is_included(int Z, int N); 00840 00841 /// Given \c Z and \c N, return the mass excess in MeV 00842 virtual double mass_excess(int Z, int N) { 00843 mnmsk_mass_entry ret; 00844 ret=get_ZN(Z,N); 00845 if (ret.Z==0 && ret.N==0) return 0.0; 00846 return ret.Mexp; 00847 } 00848 00849 }; 00850 00851 #ifndef DOXYGENP 00852 } 00853 #endif 00854 00855 #endif
Documentation generated with Doxygen and provided under the GNU Free Documentation License. See License Information for details.
Project hosting provided by
,
O2scl Sourceforge Project Page