---

more/phys/nuclear.h

Go to the documentation of this file.

//  Copyright (C) 2001  Petter Urkedal (petter.urkedal@matfys.lth.se)
//
//  This file is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//
//  This file is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//  As a special exception, you may use this file as part of a free
//  software library without restriction.  Specifically, if other files
//  instantiate templates or use macros or inline functions from this
//  file, or you compile this file and link it with other files to
//  produce an executable, this file does not by itself cause the
//  resulting executable to be covered by the GNU General Public
//  License.  This exception does not however invalidate any other
//  reasons why the executable file might be covered by the GNU General
//  Public License.
//
//  $Id: nuclear.h,v 1.1 2002/05/30 18:01:40 petter_urkedal Exp $


#ifndef PHYSICS_NUCLEAR_H
#define PHYSICS_NUCLEAR_H

#include <iosfwd>
#include <string>
#include <more/math/qtypes.h>
#include <more/io/syncstream.h>
#include <cstdlib>


namespace more {
namespace phys {

  namespace nuclear_unit_constants {
    const double mp = 938.280;
    const double mn = 939.573;
    const double mN = 938.927;
    const double hbar = 197.329;
    const double f_2mN_hbar2 = 0.0482259;
    const double f_hbar2_2mN = 20.7358;
  }


  // ---   n u c l e u s   ---

  extern more::minus_half_tag  mt_neut;  // neutron iso-spin z-projection
  extern more::half_tag        mt_prot;  // proton iso-spin z-projection

  extern int nuclear_magic_number_array[];
  extern std::size_t nuclear_magic_number_count;

  bool is_nuclear_magic_number(int);

  std::string chemical_symbol(int Z);
  std::string chemical_name(int Z);
  int Z_of_chemical(std::string name_or_symbol);
  int Z_first_unnamed();

  struct nucleus
  {
      nucleus() : n_p(0), n_n(0) {}

      nucleus(int N, int Z);

      nucleus(const nucleus& x)
          : n_p(x.n_p), n_n(x.n_n) {}

      nucleus&
      operator=(nucleus const& x)
      {
          n_n = x.n_n; n_p = x.n_p;
          return *this;
      }

#if defined(MORE_BACKWARD) && MORE_BACKWARD < 20000612
      int N() const { return n_n; }
      int Z() const { return n_p; }
      int A() const { return n_n+n_p; }
      int n_particles(more::pm_half const& mt) const
        { return mt == more::half? n_p : n_n; }
      static int Z(std::string s) { return n_prot(s); }
#endif
      int n_neut() const { return n_n; }
      int n_prot() const { return n_p; }
      int n_part() const { return n_n + n_p; }
      int n_part(more::pm_half const& mt) const
        { return mt == more::half? n_p : n_n; }
      int n_part(more::half_tag) const { return n_p; }
      int n_part(more::minus_half_tag) const { return n_n; }

      /// \depreciated
      std::string chemical_name() const { return phys::chemical_symbol(n_p); }

      std::string chemical_symbol() const
      { return phys::chemical_symbol(n_p); }

      std::string chemical_full_name() const
      { return phys::chemical_name(n_p); }

      std::string name() const;

      void sync(more::io::syncstream&);

      /// \depreciated
      static int n_prot(std::string s) { return Z_of_chemical(s); }
      /// \depreciated
      static std::string chemical_name(int Z_)
      { return phys::chemical_symbol(Z_); }
      /// \depreciated
      static int n_prot_unnamed() { return Z_first_unnamed(); }
      // XXX is is allowed to overload the non-static member function
      // chemical_name() with a static chemical_name(int)?

    private:
//       static const char *chemical_name_table[Z_first_unnamed+1];
      unsigned char n_p, n_n;
  };

  inline bool operator==(nucleus const& X, nucleus const& Y)
  {
      return X.n_neut() == Y.n_neut()
          && Y.n_prot() == Y.n_prot();
  }
  inline bool operator!=(nucleus const& X, nucleus const& Y)
  {
      return !(X == Y);
  }
  inline bool operator<(nucleus const& X, nucleus const& Y)
  {
      int A0 = X.n_part();
      int A1 = Y.n_part();
      if (A0 < A1)
          return true;
      if (A0 > A1)
          return false;
      return X.n_prot() < Y.n_prot();
  }
  inline bool operator>(nucleus const& X, nucleus const& Y)
  {
      return Y < X;
  }
  inline bool operator<=(nucleus const& X, nucleus const& Y)
  {
      return !(Y < X);
  }
  inline bool operator>=(nucleus const& X, nucleus const& Y)
  {
      return !(X < Y);
  }

  std::istream& operator>>(std::istream&, nucleus&);
  std::ostream& operator<<(std::ostream&, const nucleus&);

  inline nucleus neighbor(nucleus const& nucl, int delta_N, int delta_Z) {
      return nucleus(nucl.n_neut() + delta_N, nucl.n_prot() + delta_Z);
  }

  /** The binding energy according to the semiempirical mass formula. */
  double semiempirical_binding(nucleus const&);

  /** Returns semiempirical (neutron, proton) separation energies. */
  std::pair<double, double>
  semiempirical_separation_energies(nucleus const& nucl);

  /** This gives a rough philter of nuclei which are very unbound. It uses
      the semiempirical mass formula. */
  bool is_reasonably_bound(nucleus const&);

#if 0
  // ---   n u c l e a r   s t a t e   ---

  class nuclear_state : public nucleus {

      more::halfint spin_;
      more::pm_one parity_;
      more::halfint isospin_;
      double energy;

    public:
      more::pm_one parity() { return parity_; }
      more::halfint spin() { return spin_; }
      more::halfint isospin() { return isospin_; }
      more::halfint isospin_z() { return (n_prot() - n_neut())*more::half; }
      double excitation_energy() { return energy; }

      nuclear_state(const nucleus& nuc, more::halfint J, more::pm_one pi,
                    more::halfint T, double E=0.0)
          : nucleus(nuc), spin_(J), parity_(pi), isospin_(T), energy(E) {}

      nuclear_state(const nucleus& nuc, more::halfint J,
                    more::pm_one pi, double E = 0.0)
          : nucleus(nuc), spin_(J), parity_(pi),
            isospin_(isospin_z()), energy(E) {}
  };
#endif


} // namespace phys
} // namespace more

#endif

---