---

more/phys/ens.h

Go to the documentation of this file.

//  Copyright (C) 2001--2002  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: ens.h,v 1.1 2002/05/30 18:01:40 petter_urkedal Exp $

/** \file more/phys/ens.h
 **
 ** All type definitions and declarations of the \c more::phys::ens
 ** namespace. */


#ifndef MORE_PHYS_ENS_H
#define MORE_PHYS_ENS_H

#include <more/math/qtypes.h>
#include <more/phys/confidence_interval.h>
#include <more/phys/nuclear.h>
#include <more/phys/si.h>
#include <more/io/syncstream.h>
#include <more/sys/time.h>
#include <more/sys/date.h>
#include <more/gen/link.h>
#include <more/gen/identifier.h>
#include <more/diag/debug.h>
#include <more/lang/stdint.h>
#include <list>
#include <set>
#include <map>
#include <vector>
#include <string>
#include <stdexcept>
#include <memory>


namespace more {
namespace phys {
namespace ens {

  //
  // Forward Declarations
  //
  class parser;
  class rec_ident;      // 1
  class rec_history;    // 2
  class rec_qvalue;     // 3
  class rec_xref;       // 4
  class rec_comment;    // 5
  class rec_parent;     // 6
  class rec_norm;       // 7
  class rec_pnorm;      // 8
  class rec_level;      // 9
  class rec_radiation;  // 10-14
  class rec_beta_mi;    //   10
  class rec_beta_pl;    //   11
  class rec_alpha;      //   12
  class rec_particle;   //   13
  class rec_gamma;      //   14
  class rec_ref;        // 15

  struct parse_error : std::runtime_error
  {
      parse_error(std::string what) : std::runtime_error(what) {}
  };

  //
  // Typedefs
  //
  typedef confidence_interval<double> confiv_t;

  enum fuzzy_bool_t {
      fuzzy_false = 0,
//       fuzzy_most_improbable = 1,
//       fuzzy_improbable = 2,
//       fuzzy_possible = 3,
      fuzzy_probable = 4,
//       fuzzy_most_probable = 5,
      fuzzy_true = 6,
      fuzzy_invalid = 7
  };

  // nucleus used for V1
  // std::string used for V2

  /** A reference to a publication. */
  struct citation_t                     // V3
  {
      /** Construct an invalid keynum. */
      citation_t() : m_year(0xffff) {}

      /** Construct an initialized keynum. */
      citation_t(int year, char* rest)
          : m_year(year)
      {
          std::copy(rest, rest+4, m_rest);
      }

      /** True if valid. */
      bool is_valid() const;

      /** Return the first part of the keynum, which in conventionally
       ** set to the year of the reference. */
      int year() const { return m_year; }

      /** Return a pointer to the first of the remaining 4 characters. */
      char const* rest_begin() const { return m_rest; }

      /** Return <tt>rest_begin() + 4</tt>. */
      char const* rest_end() const { return m_rest + 4; }

      /** True if \c *this and \c rhs are equal. */
      bool operator==(citation_t const& rhs) const
      {
          return m_year == rhs.m_year
              && m_rest[0] == rhs.m_rest[0]
              && m_rest[1] == rhs.m_rest[1]
              && m_rest[2] == rhs.m_rest[2]
              && m_rest[3] == rhs.m_rest[3];
      }

      void sync(io::syncstream&);

    private:
      unsigned short m_year;
      char m_rest[4];
  };
  std::istream& operator>>(std::istream&, citation_t&);
  std::ostream& operator<<(std::ostream&, citation_t const&);

  struct citation_list : std::list<citation_t> {};      // V3
  std::istream& operator>>(std::istream&, citation_list&);
  std::ostream& operator<<(std::ostream&, citation_list const&);

  struct publication_info_t             // V4
  {
      publication_info_t() {}

      explicit publication_info_t(std::string const& str) : m_str(str) {}

      std::string as_string() const { return m_str; }

      void sync(io::syncstream&);

    private:
      std::string m_str;
  };

  using sys::date;                      // V5

  enum record_kind_t                    // V6
  {
      record_kind_invalid,
      record_kind_none,
      record_kind_history,
      record_kind_norm,
      record_kind_pnorm, // note P in col 7
      record_kind_parent,
      record_kind_qvalue,
      record_kind_level,
      record_kind_gamma,
      record_kind_beta_mi,
      record_kind_beta_pl,
      record_kind_alpha,
      record_kind_reference,
      record_kind_xref,
      record_kind_particle,
      record_kind_dparticle
  };
  std::string record_kind_to_str(record_kind_t);

  inline std::ostream&
  operator<<(std::ostream& os, record_kind_t rk)
  {
      os << record_kind_to_str(rk);
      return os;
  }

  /** A set of comment refereces. */
  struct comment_refs_t                 // V8, FLAG
  {
      typedef std::vector<char>::const_iterator iterator;
      typedef std::vector<char>::const_iterator const_iterator;

      comment_refs_t() {}
      comment_refs_t(char const* beg, char const* end);

      iterator begin() const { return m_arr.begin(); }
      iterator end() const { return m_arr.end(); }

      bool empty() const { return m_arr.empty(); }

      void insert(char ch)
      {
          m_arr.push_back(ch);
          std::inplace_merge(m_arr.begin(), m_arr.end()-1, m_arr.end());
      }

      bool contains(char ch) const
      {
          return std::binary_search(begin(), end(), ch);
      }

      bool operator<(comment_refs_t const& rhs) const
      {
          return m_arr < rhs.m_arr;
      }
      bool operator==(comment_refs_t const& rhs) const
      {
          return m_arr == rhs.m_arr;
      }

      void sync(io::syncstream&);

    private:
      std::vector<char> m_arr;
  };

  // std::string used for V7
  // std::string used for V8

  /** Enumerator for kinds of particles. */
  enum particle_kind_t
  {
      particle_kind_invalid,
      particle_kind_none,
      particle_kind_neutron,    ///< The enumerator of a neutron
      particle_kind_proton,             ///< The enumerator of a proton
      particle_kind_alpha               ///< The enumerator of an α-particle
  };

  std::string particle_kind_to_str(particle_kind_t);

  inline std::ostream&
  operator<<(std::ostream& os, particle_kind_t pk)
  {
      os << particle_kind_to_str(pk);
      return os;
  }

  //   confiv_t used for V14

  struct multipolarity_t                // V19
  {
      // XXX to be refined
      multipolarity_t() {}
      explicit multipolarity_t(std::string const& str) : m_str(str) {}

      std::string as_string() const { return m_str; }
      bool is_known() const { return !m_str.empty(); }

      void sync(io::syncstream& sio);

    private:
      std::string m_str;
  };

  inline std::ostream&
  operator<<(std::ostream& os, multipolarity_t mult)
  {
      os << mult.as_string();
      return os;
  }

  struct ang_mom_xfer_elt
  {
      typedef unsigned int flags_t;
      static flags_t const flag_uncertain = 1;
      static flags_t const flag_assumed = 2;
      static flags_t const flag_upper_limit = 4;
      static flags_t const flag_lower_limit = 8;
      static flags_t const flag_magnetic = 16;
      static flags_t const flag_electric = 32;
      static flags_t const flags_unknown = 15;

      ang_mom_xfer_elt()
          : m_L(-1), m_flags(flags_unknown) {}

      ang_mom_xfer_elt(int L, flags_t fl)
          : m_L(L), m_flags(fl) {}

      int L() const { return m_L; }
      bool is_unknown() const { return m_flags == flags_unknown; }
      bool is_uncertain() const { return m_flags & flag_uncertain; }
      bool is_assumed() const { return m_flags & flag_assumed; }
      bool is_upper_limit() const { return m_flags & flag_upper_limit; }
      bool is_lower_limit() const { return m_flags & flag_lower_limit; }
      bool is_electric() const { return m_flags & flag_electric; }
      bool is_magnetic() const { return m_flags & flag_magnetic; }

      void sync(io::syncstream& sio);

      bool operator<(ang_mom_xfer_elt const& rhs) const
      {
          return m_L < rhs.m_L
              || m_L == rhs.m_L && m_flags < rhs.m_flags;
      }
      bool operator==(ang_mom_xfer_elt const& rhs) const
      {
          return m_L == rhs.m_L && m_flags == rhs.m_flags;
      }

    private:
      int m_L;
      flags_t m_flags;
  };

  struct ang_mom_xfer_set               // V22
      : std::set<ang_mom_xfer_elt>
  {
      void sync(io::syncstream& sio);
  };

  struct ang_mom_to_strength_map        // V21, V22
      : std::map<ang_mom_xfer_elt, confiv_t>
  {
      void sync(io::syncstream& sio);
  };

  /** An expression for possible spins and parities. */
  struct spin_parity_expr_t     // V20
  {
      // The J fields have a rather complex syntax which may require
      // an expression tree to fully represent.  The meaning of the
      // 'and' operator is unclear.  How the 'and', 'or' and 'to'
      // operators can be mixed is also unclear.
      spin_parity_expr_t() {}

      explicit spin_parity_expr_t(std::string const& str) : m_str(str) {}

      bool is_known() const { return !m_str.empty(); }
      std::string as_string() const { return m_str; }
      void sync(io::syncstream&);

    private:
      std::string m_str; // XXX temporary solution
  };

  typedef int energy_index_t;
  const energy_index_t energy_index_none = 0;
  const energy_index_t energy_index_sn = -1;
  const energy_index_t energy_index_sp = -2;
  const energy_index_t energy_index_sa = -3; // undocumented
  const int energy_index_bits = 6;
  void print_energy_ref(std::ostream& os, energy_index_t eref);

  /** The status of a level or radiation record. */
  enum rstatus_t  // The Q fields (= " ", "?", "S")
  {
      /** The entry is observed. */
      rstatus_observed,  // blank
      /** The entry is observed but uncertain. */
      rstatus_uncertain, // "?"
      /** The entry is not observed, but predicted or expected. */
      rstatus_predicted  // "S"
  };

  /** \internal */
  enum symbol_t {
      symbol_none,
      symbol_E,
      symbol_J,
      symbol_T,
      symbol_L,
      symbol_S,
      symbol_IB,
      symbol_IE,
      symbol_IA,
      symbol_TI,
      symbol_HF,
      symbol_LOGFT,
      symbol_UN
  };

  /** An unsigned int which is wide enough to store
   ** 2<sup><tt>sym</tt></sup> for any <tt>sym</tt> ∈
   ** <tt>symbol_t</tt>. */
  typedef lang::uint_least16_t symbol_intset_t;

  symbol_t str_to_symbol(std::string const&);


  //--------------------------------------------------------------------
  //                           Records
  //--------------------------------------------------------------------

  struct rec_commentable_base
  {
    private:
      typedef gen::link<rec_comment> comment_container;
    public:
      typedef comment_container::const_iterator comment_iterator;

      ~rec_commentable_base();

      comment_iterator comment_begin() const { return m_comments.begin(); }
      comment_iterator comment_end()   const { return m_comments.end(); }

      void dump_base(std::ostream&) const;
      void sync_base(io::syncstream&);

    private:
      comment_container m_comments; // comments for this rec

      friend class parser;
  };

  // 1. The Identification Record
  /** An ENSDF identification record. */
  struct rec_ident
  {
      void dump(std::ostream&) const;
      void sync(io::syncstream&);

      nucleus nucl() const { return m_nucid; }
      std::string const& dataset_id_string() const { return m_dsid; }
      citation_list const& citations() const { return m_dsref; }
      publication_info_t const& publication_info() const { return m_pub; }
      sys::date date_of_entry() const { return m_date; }

    private:
      nucleus                   m_nucid;
      std::string               m_dsid;
      citation_list             m_dsref;
      publication_info_t        m_pub;
      sys::date                 m_date;

      friend class parser;
  };

  // 2. The History Record
  /** An ENSDF history record. */
  struct rec_history : gen::linked
  {
      typedef std::list<std::string>::const_iterator keyless_iterator;

      void dump(std::ostream&) const;
      void sync(io::syncstream&);

      std::string const& type_of_change() const { return m_typ; }
      std::string const& author() const { return m_aut; }
      sys::date date_of_change() const { return m_dat; }
      sys::date literature_cutoff() const { return m_cut; }
      std::string const& citation() const { return m_cit; }
      std::string const& comments() const { return m_com; }

      std::pair<keyless_iterator, keyless_iterator>
      keyless_entries() const { return std::make_pair(m_keyless.begin(),
                                                      m_keyless.end()); }

    private:
      nucleus m_nucid;

      std::string       m_typ;
      std::string       m_aut;
      sys::date         m_dat;
      sys::date         m_cut;
      std::string       m_cit;
      std::string       m_com;

      std::list<std::string> m_keyless;
//       std::map<std::string, std::string> m_entries;

      friend class parser;
  };

  // 3. The Q-value Record
  /** An ENSDF Q-value record. */
  struct rec_qvalue : rec_commentable_base
  {
      void dump(std::ostream&) const;
      void sync(io::syncstream&);

      confiv_t const& Q_mi() const { return m_qmi; }
      confiv_t const& S_n() const { return m_sn; }
      confiv_t const& S_p() const { return m_sp; }
      confiv_t const& S(math::pm_half mt) const {return mt==half?m_sp:m_sn;}
      confiv_t const& Q_alpha() const { return m_qa; }
      citation_list const& citations() const { return m_qref; }

    private:
      confiv_t          m_qmi;
      confiv_t          m_sn;
      confiv_t          m_sp;
      confiv_t          m_qa;
      citation_list     m_qref;

      friend class parser;
  };

  // 4. The Cross-Reference Record
  /** An ENSDF cross reference record. */
  struct rec_xref : gen::linked
  {
      void dump(std::ostream&) const;
      void sync(io::syncstream&);

      char dataset_symbol() const { return m_dssym; }
      std::string const& dataset_id() const { return m_dsid; }

    private:
      char              m_dssym;
      std::string       m_dsid;

      friend class parser;
  };

  // 5. The Comment Record
  /** An ENSDF comment record. */
  struct rec_comment : gen::linked
  {
      typedef std::map<gen::identifier, comment_refs_t>::const_iterator
              symflags_iterator;

      void dump(std::ostream&) const;
      void sync(io::syncstream&);

      record_kind_t rtype() const { return m_rtype; }
      particle_kind_t particle_kind() const { return m_psym; }
      bool is_preformatted() const { return !m_fill_p; }
      bool is_documentation() const { return m_doc_p; }
      std::string const& text() const { return m_ctext; }

    private:
      // Comment type C/D/T, General/Record/Footnote
      // Blank or record type of records to which the comment pertains
      record_kind_t     m_rtype;
      // Blank or symbol for a (delayed-)particle
      particle_kind_t   m_psym;
//       symflag_list_type      m_symflags;
      std::map<gen::identifier, comment_refs_t> m_symflags;
      std::string       m_ctext;
      unsigned int      m_fill_p : 1;
      unsigned int      m_doc_p : 1;

      friend class parser;
  };

  // 6. The Parent Record
  /** An ENSDF parent record. */
  struct rec_parent : rec_commentable_base
  {
      void dump(std::ostream&) const;
      void sync(io::syncstream&);

    private:
      nucleus           m_nucid;
      confiv_t          m_E;
      energy_index_t    m_E_ref : energy_index_bits;
      spin_parity_expr_t        m_J;
      confiv_t          m_T;
      confiv_t          m_QP;
      //XXXchar         m_ion[4];
      unsigned int      m_T_as_width : 1;

      friend class parser;
  };

  // 7. The Normalization Record
  /** An ENSDF normalization record. */
  struct rec_norm : rec_commentable_base
  {
      void dump(std::ostream&) const;
      void sync(io::syncstream&);

      /** Normalization for photon intensity.  Multiplier for
       ** converting relation photon intensity \c
       ** rec_gamma::I_gamma_rel() to photons per decay of the parent
       ** through this decay branch or to photons per neutron captures
       ** in an (n, γ) reaction. */
      confiv_t const& mult_gamma_rel_branch() const { return m_nr; }

      /** Normalization of transition intensity.  Multiplier for
       ** converting relative transition intensity (including
       ** conversion electrons) \c rec::gamma::I_trans_rel() to
       ** transitions per decay of the parent through this decay
       ** branch or per neutron capture in an (n, γ) reaction. */
      confiv_t const& mult_trans_rel_branch() const { return m_nt; }

      /** Normalization of decay branches.  Multiplier for converting
       ** intensities from per decay of this branch to per decay of
       ** the parent nuclide.  */
      confiv_t const& mult_branch() const { return m_br; }

      /** Normalization of β± decay and EC.  Multiplier for converting
       ** \c rec_beta_mi::I_beta_mi_rel(), \c
       ** rec_beta_pl::I_beta_pl_rel() and \c rec_beta_pl::I_EC_rel()
       ** to intensities per decay through this decay branch. */
      confiv_t const& mult_beta_rel_branch() const { return m_nb; }

      /** Normalization of particle decay.  Multiplier for converting
       ** particle decay intensitis from per decay to per decay of
       ** precursor. */
      confiv_t const& mult_part() const { return m_np; }

    private:
      confiv_t m_nr;
      confiv_t m_nt;
      confiv_t m_br;
      confiv_t m_nb;
      confiv_t m_np;

      friend class parser;
  };

  // 8. The Production Normalization Record
  /** An ENSDF production normalization record. */
  struct rec_pnorm : rec_commentable_base
  {
      void dump(std::ostream&) const;
      void sync(io::syncstream&);

      /** Normalization of photon intensity.  Multiplier for
       ** converting relation photon intensity \c
       ** rec_gamma::I_gamma_rel() to photons per decay of the
       ** parent. */
      confiv_t const& mult_gamma() const { return m_nr_br; }

      /** Normalization of transition intensity.  Multiplier for
       ** converting relative transition intensity \c
       ** rec::gamma::I_trans_rel() to transitions per decay of the
       ** parent. */
      confiv_t const& mult_trans() const { return m_nt_br; }

      /** Normalization of β± decay and EC.  Multiplier for converting
       ** \c rec_beta_mi::I_beta_mi_rel(), \c
       ** rec_beta_pl::I_beta_pl_rel() and \c rec_beta_pl::I_EC_rel()
       ** to intensities per decay. */
      confiv_t const& mult_beta() const { return m_nb_br; }

      /** Normalization of particle decay.  Multiplier for converting
       ** particle decay intensitis from per decay to per decay of
       ** precursor. */
      confiv_t const& mult_part() const { return m_np; }

    private:
      confiv_t m_nr_br;
      confiv_t m_nt_br;
      confiv_t m_nb_br;
      confiv_t m_np;

      unsigned int m_com_opt : 3;
      // 0: Comment given in continuation record.
      // 1-7: Intensity and comment options.

      friend class parser;
  };

  // 9. The Level Record
  /** An ENSDF level record. */
  struct rec_level : gen::linked, rec_commentable_base
  {
      typedef gen::link<rec_radiation>::const_iterator  radiation_iterator;

      ~rec_level();
      void dump(std::ostream&) const;
      void sync(io::syncstream&);

      /** The status of observation. */
      rstatus_t status() const { return (rstatus_t)m_rstatus; }

      /** The energy relative to a given reference point. */
      confiv_t E_minus_E_ref() const { return m_E; }

      /** The index of the reference point energy. */
      energy_index_t i_E_ref() const { return m_E_ref; }

      /** Return the spin and parity specification. */
      spin_parity_expr_t const& Jpi() const { return m_J; }

      /** The half-life of the transition.  Not given if width() is
       ** given. */
      confiv_t T_half() const { return m_T_as_width?confiv_t():m_T; }

      /** The width of the transition.  Not given if T_half() is given. */
      confiv_t Gamma() const { return m_T_as_width?m_T:confiv_t(); }

      /* XXX m_LS */

      /** References to comments. */
      comment_refs_t const& comment_refs() const { return m_C; }

      /** First iterator in the range of radiation. */
      radiation_iterator radiation_begin() const
      {
          return m_radiations.begin();
      }
      /** Past end iterator in the range of radiations. */
      radiation_iterator radiation_end() const
      {
          return m_radiations.end();
      }

    private:
      confiv_t                  m_E;
      energy_index_t            m_E_ref : energy_index_bits;
      spin_parity_expr_t        m_J;
      confiv_t                  m_T;
      ang_mom_to_strength_map   m_LS;
      comment_refs_t            m_C;

      unsigned int m_MS : 4;   // V17
      // 0: blank, 1: M, 2: M1, 3: M2, ...

      unsigned int m_rstatus : 2;
      unsigned int m_T_as_width : 1;

      gen::link<rec_radiation> m_radiations;

      friend class parser;
  };

  // Base for 10–14.
  /** A base class for ENSDF radiation records. */
  struct rec_radiation : gen::linked, rec_commentable_base
  {
      void dump(std::ostream&) const;
      void dump_base(std::ostream&) const;
      void sync_base(io::syncstream&);

      /** The status of observation. */
      rstatus_t status() const { return (rstatus_t)m_rstatus; }

      /** The energy relative to a given reference point. */
      confiv_t E_minus_E_ref() const { return m_E; }
      /** The index of the reference point energy. */
      energy_index_t i_E_ref() const { return m_E_ref; }

      bool is_beta_mi() const { return m_sel == sel_beta_mi; }
      bool is_beta_pl() const { return m_sel == sel_beta_pl; }
      bool is_alpha() const { return m_sel == sel_alpha; }
      bool is_particle() const { return m_sel == sel_particle; }
      bool is_gamma() const { return m_sel == sel_gamma; }

      rec_beta_mi*      to_beta_mi();
      rec_beta_pl*      to_beta_pl();
      rec_alpha*        to_alpha();
      rec_particle*     to_particle();
      rec_gamma*        to_gamma();

      rec_beta_mi const*        to_beta_mi() const;
      rec_beta_pl const*        to_beta_pl() const;
      rec_alpha const*          to_alpha() const;
      rec_particle const*       to_particle() const;
      rec_gamma const*          to_gamma() const;

      static void do_delete(rec_radiation*);

    protected:
      enum selector
      {
          sel_beta_mi,
          sel_beta_pl,
          sel_alpha,
          sel_particle,
          sel_gamma
      };

      rec_radiation(selector sel) : m_sel(sel) {}

    private:
      selector          m_sel;
      confiv_t          m_E;
      energy_index_t    m_E_ref : energy_index_bits;
    protected:
      confiv_t          m_IX; // V13 21..29: multi-purpose
    private:
      comment_refs_t    m_C;  // V8

      unsigned int m_rstatus : 2;

      friend class dataset;
      friend class parser;
  };

  // 10. The Beta (β-) Record
  /** An ENSDF β- decay record. */
  struct rec_beta_mi : rec_radiation
  {
      void dump(std::ostream&) const;
      void sync(io::syncstream&);

      int  forbiddenness()           const { return m_un_forbiddenness; }
      bool forbiddenness_is_unique() const { return m_un_unique; }

      /** The β- intensity.  The unit in given in the normalization
       ** record. */
      confiv_t const& I_beta_mi_rel() const { return m_IX; }

      /** The log(<i>ft</i>) value. */
      confiv_t const& log_ft() const { return m_log_ft; }

    private:
      rec_beta_mi() : rec_radiation(sel_beta_mi) {}

      unsigned int      m_un_forbiddenness : 4; // V16 (0=allowed, 1, ..., 9)
      unsigned int      m_un_unique : 1;
      confiv_t          m_log_ft;

      friend class parser;
  };

  // 11. The EC (or EC + β+) Record
  /** An ENSDF β+ decay and electron capture record. */
  struct rec_beta_pl : rec_radiation
  {
      void dump(std::ostream&) const;
      void sync(io::syncstream&);

      int  forbiddenness()           const { return m_un_forbiddenness; }
      bool forbiddenness_is_unique() const { return m_un_unique; }

      /** The β+ and EC intensity.  The unit is given in the
       ** normalization record. */
      confiv_t const& I_tot_rel() const { return m_TI; }

      /** The β+ intensity.  The unit is given in the normalization
       ** record. */
      confiv_t const& I_beta_pl_rel() const { return m_IX; }

      /** The EC intensity.  The unit is given in the normalization
       ** record */
      confiv_t const& I_EC_rel() const { return m_IE; }

      /** The log(<i>ft</i>) value. */
      confiv_t const& log_ft() const { return m_log_ft; }

    private:
      rec_beta_pl() : rec_radiation(sel_beta_pl) {}

      unsigned int      m_un_forbiddenness : 4; // V16
      unsigned int      m_un_unique : 1;
      confiv_t          m_log_ft;
      confiv_t          m_IE;
      confiv_t          m_TI;

      friend class parser;
  };

  // 12. The Alpha Record
  /** An ENSDF α particle decay record. */
  struct rec_alpha : rec_radiation
  {
      void dump(std::ostream&) const;
      void sync(io::syncstream&);

      /** The hindrance factor. */
      confiv_t const& hindrance_factor() const { return m_HF; }

      /** The α-decay intensity divided by the total α-decay
       ** intensity. */
      confiv_t const& I_alpha() const { return m_IX; }

    private:
      rec_alpha() : rec_radiation(sel_alpha) {}

      confiv_t m_HF;

      friend class parser;
  };

  // 13. The (Delayed-) Particle Record
  /** An ENSDF particle or delayed particle record. */
  struct rec_particle : rec_radiation
  {
      void dump(std::ostream&) const;
      void sync(io::syncstream&);

      /** True if this is a delayed particle record. */
      bool is_delayed() const { return m_delayed_p; }

      /** The kind of particle emitted in the decay (n, p, α). */
      particle_kind_t particle_kind() const { return m_particle; }

      /** Intensity of the (delayed) particle decay divided by the
       ** total (delayed) particle intensity. */
      confiv_t const& I_part() const { return m_IX; }

      /** Energy of the level in the intermediate nucleus if delayed
       ** particle decay.  This nucleus is (N+2, Z+2) for α, (N+1, Z)
       ** for n and (N, Z+1) for p decay. */
      confiv_t E_imedi() const
      {
          if (m_EI_given) {
              confiv_t r = confiv_t(m_EI, confiv_t::unknown);
              r.set_origin(origin_experiment);
              if (m_EI_given != 2)
                  r.be_uncertain();
              return r;
          }
          else
              return confiv_t();
      }

      /** The width (of the initial energy level) of the
       ** transition. */
      confiv_t const& Gamma_trans() const { return m_T; }

      /** The transfer of angular momentum in the reaction. */
      ang_mom_xfer_set const& ang_mom_xfer() const { return m_L; }

      /** Is placement is confirmed by coincidence?  Returned values
       ** are \c fuzzy_false, \c fuzzy_probable and \c fuzzy_true. */
      fuzzy_bool_t has_coincidence() const { return fuzzy_bool_t(m_coin); }

    private:
      rec_particle() : rec_radiation(sel_particle) {}

      particle_kind_t m_particle;
      double m_EI;
      confiv_t m_T;  // width of the transition (energy)
      ang_mom_xfer_set m_L;
      unsigned int m_coin : 3;
      unsigned int m_delayed_p : 1;  // 0 for prompt, 1 for delayed
      unsigned int m_EI_given : 2;   // 0 = no, 1 = uncertain, 2 = yes

      friend class parser;
  };

  // 14. The Gamma Record
  /** An ENSDF γ emission record. */
  struct rec_gamma : rec_radiation
  {
      void dump(std::ostream&) const;
      void sync(io::syncstream&);

      /** The multipolarity of the transition. */
      multipolarity_t const& multipolarity() const { return m_M; }

      /** The mixing ratio.  The returned value may have indefinite
       ** sign, check it with confiv_t::is_signless(). */
      confiv_t const& r_mix() const { return m_MR; }

      /** Relative γ-intensity in units defined by the normalization
       ** record. */
      confiv_t const& I_gamma_rel() const { return m_IX; }

      /** The total conversion coefficient. */
      confiv_t const& alpha_tot() const { return m_CC; }

      /** Relation transition intensity in units defined by the
       ** normalization record. */
      confiv_t const& I_trans_rel() const { return m_TI; }

      /** Is placement is confirmed by coincidence?  Returned values
       ** are \c fuzzy_false, \c fuzzy_probable and \c fuzzy_true. */
      fuzzy_bool_t has_coincidence() const { return fuzzy_bool_t(m_coin); }

    private:
      rec_gamma() : rec_radiation(sel_gamma) {}
      multipolarity_t m_M;
      confiv_t m_MR;
      confiv_t m_CC;
      confiv_t m_TI;
      unsigned int m_coin : 3;

      friend class parser;
  };

  // 10-14. Cont.
  inline rec_beta_mi*
  rec_radiation::to_beta_mi()
  {
      return is_beta_mi()? static_cast<rec_beta_mi*>(this) : 0;
  }
  inline rec_beta_pl*
  rec_radiation::to_beta_pl()
  {
      return is_beta_pl()? static_cast<rec_beta_pl*>(this) : 0;
  }
  inline rec_alpha*
  rec_radiation::to_alpha()
  {
      return is_alpha()? static_cast<rec_alpha*>(this) : 0;
  }
  inline rec_particle*
  rec_radiation::to_particle()
  {
      return is_particle()? static_cast<rec_particle*>(this) : 0;
  }
  inline rec_gamma*
  rec_radiation::to_gamma()
  {
      return is_gamma()? static_cast<rec_gamma*>(this) : 0;
  }
  inline rec_beta_mi const*
  rec_radiation::to_beta_mi() const
  {
      return is_beta_mi()? static_cast<rec_beta_mi const*>(this) : 0;
  }
  inline rec_beta_pl const*
  rec_radiation::to_beta_pl() const
  {
      return is_beta_pl()? static_cast<rec_beta_pl const*>(this) : 0;
  }
  inline rec_alpha const*
  rec_radiation::to_alpha() const
  {
      return is_alpha()? static_cast<rec_alpha const*>(this) : 0;
  }
  inline rec_particle const*
  rec_radiation::to_particle() const
  {
      return is_particle()? static_cast<rec_particle const*>(this) : 0;
  }
  inline rec_gamma const*
  rec_radiation::to_gamma() const
  {
      return is_gamma()? static_cast<rec_gamma const*>(this) : 0;
  }


  // 15. The Reference Record
  /** An ENSDF reference record. */
  struct rec_ref
  {
      void dump(std::ostream&) const;
      void sync(io::syncstream&);

    private:
      // 1-3 MASS
      citation_t m_keynum;
      std::string m_reference;
  };


  /** \class decay_info ens.h more/phys/ens.h
   **
   ** Common information to all decays in a dataset.  This includes
   ** the parent, normalization and production normalization
   ** records. */
  struct decay_info : gen::linked
  {
      decay_info()
          : m_parent(0),
            m_norm(0),
            m_pnorm(0) {}

      ~decay_info();

      /** Return the parent record or 0 if none. */
      rec_parent const* parent() const { return m_parent; }
      /** Retrun the normalization record, or 0 if none. */
      rec_norm const* norm() const { return m_norm; }
      /** Return the production normalization record, or 0 if none. */
      rec_pnorm const* pnorm() const { return m_pnorm; }

    private:
      unsigned int      m_index;
      rec_parent*       m_parent;
      rec_norm*         m_norm;
      rec_pnorm*        m_pnorm;

      friend class dataset;
      friend class parser;
  };

  /** An ENSDF data set.  Use \c ens::nucleus to obtain the datasets
   ** for a given nucleus. */
  struct dataset : gen::linked
  {
      typedef gen::link<rec_history>::const_iterator    history_iterator;
      typedef gen::link<rec_xref>::const_iterator       xref_iterator;
      typedef gen::link<rec_comment>::const_iterator    comment_iterator;
      typedef gen::link<rec_radiation>::const_iterator  radiation_iterator;
      typedef gen::link<rec_level>::const_iterator      level_iterator;
      typedef gen::link<decay_info>::const_iterator     decay_info_iterator;

      dataset() : m_qvalue(0), m_relabel_intset(0) {}
      ~dataset();

      void dump(std::ostream&) const;
      void sync(io::syncstream&);

      rec_ident const*  ident() const { return &m_ident; }
      rec_qvalue const* qvalue() const { return m_qvalue; }

      bool history_range_empty() const { return m_history.empty(); }
      history_iterator  history_begin() const { return m_history.begin(); }
      history_iterator  history_end() const { return m_history.end(); }
      bool xref_range_empty() const { return m_xref.empty(); }
      xref_iterator     xref_begin() const { return m_xref.begin(); }
      xref_iterator     xref_end() const { return m_xref.end(); }
      bool comment_range_empty() const { return m_comments.empty(); }
      comment_iterator  comment_begin() const { return m_comments.begin(); }
      comment_iterator  comment_end() const { return m_comments.end(); }
      bool decay_info_range_empty() const { return m_pnp.empty(); }
      decay_info_iterator decay_info_begin() const { return m_pnp.begin(); }
      decay_info_iterator decay_info_end() const { return m_pnp.end(); }

      bool unplaced_radiation_range_empty() const
      { return m_unpl_rads.empty(); }
      radiation_iterator unplaced_radiation_begin() const
      { return m_unpl_rads.begin(); }
      radiation_iterator unplaced_radiation_end() const
      { return m_unpl_rads.end(); }

      bool level_range_empty() const { return m_levels.empty(); }
      level_iterator    level_begin() const { return m_levels.begin(); }
      level_iterator    level_end() const { return m_levels.end(); }

    private:
      decay_info* find_pnp(unsigned index);
      decay_info* find_or_insert_pnp(unsigned index);

      rec_ident                         m_ident;
      gen::link<rec_history>            m_history;
      gen::link<rec_xref>               m_xref;
      gen::link<rec_comment>            m_comments;
      rec_qvalue*                       m_qvalue;
      gen::link<decay_info>             m_pnp;
      gen::link<rec_radiation>          m_unpl_rads;
      gen::link<rec_level>              m_levels;

      symbol_intset_t                   m_relabel_intset;
      std::map<symbol_t, std::string>   m_relabel_map;

      friend class parser;
  };

  /** \class nucleus ens.h more/phys/ens.h
   **
   ** A nucleus discriptor with access to all the datasets on the
   ** nucleus. */
  struct nucleus : phys::nucleus
  {
    private:
      struct dataset_container : gen::link<dataset>
      {
          dataset_container() : m_ic(0) {}
          unsigned int m_ic;
      };

    public:
      typedef dataset_container::const_iterator dataset_const_iterator;
      typedef dataset_container::const_iterator dataset_iterator;
      typedef dataset_container::const_reverse_iterator
              dataset_const_reverse_iterator;
      typedef dataset_container::const_reverse_iterator
              dataset_reverse_iterator;

      nucleus() : m_datasets(0) {}

      nucleus(int N, int Z)
          : phys::nucleus(N, Z), m_datasets(0)
      {
          init();
      }

      nucleus(nucleus const& nucl)
          : phys::nucleus(nucl), m_datasets(nucl.m_datasets)
      {
          if (m_datasets)
              ++m_datasets->m_ic;
      }

      nucleus(phys::nucleus const& nucl)
          : phys::nucleus(nucl), m_datasets(0)
      {
          init();
      }

      ~nucleus();

      nucleus&
      operator=(nucleus const& nucl)
      {
          this->~nucleus();
          new(this) nucleus(nucl);
          return *this;
      }

      nucleus&
      operator=(phys::nucleus const& nucl)
      {
          this->~nucleus();
          new(this) nucleus(nucl);
          return *this;
      }

      bool has_dataset() const { chk(); return !m_datasets->empty(); }

      dataset_iterator dataset_begin() { chk(); return m_datasets->begin(); }
      dataset_iterator dataset_end()   { chk(); return m_datasets->end(); }
      dataset_reverse_iterator dataset_rbegin()
      { chk(); return m_datasets->rbegin(); }
      dataset_reverse_iterator dataset_rend()
      { chk(); return m_datasets->rend(); }

      dataset_const_iterator
      dataset_begin() const
      {
          chk();
          return m_datasets->begin();
      }

      dataset_const_iterator
      dataset_end() const
      {
          chk();
          return m_datasets->end();
      }

      /** Returns a pointer to the Q-Value Record, or 0 if none. */
      rec_qvalue const* qvalue() const;

      void dump(std::ostream&) const;

      static void set_clog(std::ostream& os) { s_clog = &os; }
      static std::ostream& clog() { return *s_clog; }

    private:
      void chk() const
      {
          if (!m_datasets)
              throw std::logic_error("phys::ens::nucleus: "
                                     "Tried to access null-nucleus");
      }

      void init();
      dataset_container* m_datasets;

      static void clear_cache();
      static int const s_N_max = 170;
      static int const s_Z_max = 120;  // 170*120*12 = 244800
      static diag::auto_ptr<dataset_container> s_cache[s_N_max*s_Z_max];
      static int s_n_in_use;  // cached and in use
      static int s_n_unused;  // cached and not in use
      static std::ostream* s_clog;

      friend class parser;
  };


  //
  // Algorithms (from ens_algo.cc)
  //

  /** Return the pairing energy of \a nucl for isospin \a mt, using
   ** three experimental separation energies.  The returned value may
   ** be flagged as unknown if data is not available. */
  confiv_t four_point_pairing(nucleus const& nucl, math::pm_half mt);

  dataset const* adopted_levels_dataset(nucleus const& nucl);

  rec_level const* ground_state_level(nucleus const& nucl);

  /** Return the half-life of \a nucl if known. */
  confiv_t half_life(nucleus const& nucl);

}}} // more::phys::ens

#endif


// Local Variables:
// coding: utf-8
// End:

---