isotope.h

Go to the documentation of this file.

/* Author(s)    : Benoit Guillon  <guillon@lpccaen.in2p3.fr>
 * Creation date: 2010-03-06
 * Last modified: 2014-06-11
 *
 * Description : A simple class to handle only isotopes (ZAI) and their basic properties (mass & decays).
 *
 */

#ifndef MATERIALS_ISOTOPE_H
#define MATERIALS_ISOTOPE_H 1

// Standard Library:
#include <string>
#include <map>

// Third party:
// - Bayeux/datatools:
#include <datatools/properties.h>
#include <datatools/i_tree_dump.h>
#include <datatools/bit_mask.h>

// This project:
#include <materials/chemical_symbol.h>

namespace materials {

  class isotope : public datatools::i_tree_dumpable
  {
  public:

    static int max_number_of_protons();

    static int undefined_number_of_nucleons();

    static int max_number_of_nucleons();

    class id : public datatools::i_tree_dumpable {
    public:

      id();

      id(int z_, int a_);

      void reset();

      void set_z(int z_);

      int get_z() const;

      void set_a(int z_);

      int get_a() const;

      void set(int z_, int a_);

      std::string get_name() const;

      void to_string(std::string &) const;

      std::string to_string() const;

      bool from_string(const std::string &);

      bool is_valid() const;

      bool operator<(const id &) const;

      bool operator==(const id &) const;

      virtual void tree_dump(std::ostream & out_         = std::clog,
                             const std::string & title_  = "",
                             const std::string & indent_ = "",
                             bool inherit_          = false) const;

    private:

      int _z_; 
      int _a_; 

    };

    enum build_flag_type {
      BF_MASS_DATA  = datatools::bit_mask::bit00, 
      BF_DECAY_DATA = datatools::bit_mask::bit01, 
      BF_LOCK       = datatools::bit_mask::bit31  
    };

    struct record_type  : public datatools::i_tree_dumpable {
    public:
      int get_Z() const;
      int get_A() const;
      int get_N() const;
      double get_nucleus_mass() const;
      double get_mass_excess() const;
      double get_binding_energy_per_nucleon() const;
      double get_atomic_mass() const;
      record_type();
      virtual void tree_dump(std::ostream & out_         = std::clog,
                             const std::string & title_  = "",
                             const std::string & indent_ = "",
                             bool inherit_               = false) const;

    public:

      std::string symbol; 
      int    Z;           
      int    A;           
      double mx;          
      double mx_err;      
      double bea;         
      double bea_err;     
      double am;          
      double am_err;      

   };

    typedef std::map<id, record_type> isotope_dict_type;

    static void print_table_of_isotopes(const isotope_dict_type &,
                                        std::ostream & out_ = std::clog,
                                        const std::string & title_ = "",
                                        const std::string & indent_ = "",
                                        bool inherit_ = false);

    static const isotope_dict_type & table_of_isotopes();

    static bool id_is_tabulated(const id &);

    enum ame_release_type {
      AME_RELEASE_2003 = 0,
      AME_RELEASE_2012 = 1
    };

    static void load_ame_table(isotope::isotope_dict_type &, ame_release_type ame_release_ = AME_RELEASE_2012);

    static const record_type & table_record_from_id(const id &);

    enum isomeric_level_type {
      GROUND_STATE           =  0,                                                   
      ISOMERIC_STATE         =  datatools::bit_mask::bit00,                          
      ISOMERIC_M             =  ISOMERIC_STATE,                                      
      ISOMERIC_M1            =  ISOMERIC_STATE | datatools::bit_mask::bit02,         
      ISOMERIC_M2            =  ISOMERIC_STATE | datatools::bit_mask::bit03,         
      ISOMERIC_M3            =  ISOMERIC_STATE | datatools::bit_mask::bit04,         
      ISOMERIC_FISSION_STATE =  datatools::bit_mask::bit01,                          
      ISOMERIC_F             =  ISOMERIC_FISSION_STATE,                              
      ISOMERIC_F1            =  ISOMERIC_FISSION_STATE | datatools::bit_mask::bit02, 
      ISOMERIC_F2            =  ISOMERIC_FISSION_STATE | datatools::bit_mask::bit03, 
      ISOMERIC_F3            =  ISOMERIC_FISSION_STATE | datatools::bit_mask::bit04, 
      ISOMERIC_INVALID       =  datatools::bit_mask::bit31                           
    };

    static std::string isomeric_to_label(isomeric_level_type);

    static isomeric_level_type label_to_isomeric(const std::string &);

    isotope();


    explicit isotope(const std::string & name_);


    explicit isotope(const char * name_);


    explicit isotope(int z_ ,
                     int a_ ,
                     isomeric_level_type i_ = GROUND_STATE,
                     unsigned int build_flags_ = 0);


    explicit isotope(const std::string & ch_symbol_,
                     int a_ ,
                     isomeric_level_type i_ = GROUND_STATE,
                     unsigned int build_flags_ = 0);


    explicit isotope(const char * ch_symbol_,
                     int a_ ,
                     isomeric_level_type i_ = GROUND_STATE,
                     unsigned int build_flags_ = 0);


    explicit isotope(const std::string & name_,
                     int z_ ,
                     int a_ ,
                     isomeric_level_type i_ = GROUND_STATE,
                     unsigned int build_flags_ = 0);


    explicit isotope(const char * name_,
                     int z_ ,
                     int a_ ,
                     isomeric_level_type i_ = GROUND_STATE,
                     unsigned int build_flags_ = 0);



    explicit isotope(const std::string & name_,
                     const std::string & ch_symbol_,
                     int a_,
                     isomeric_level_type i_ = GROUND_STATE,
                     unsigned int build_flags_ = 0);


    explicit isotope(const char * name_,
                     const char * ch_symbol_,
                     int a_,
                     isomeric_level_type i_ = GROUND_STATE,
                     unsigned int build_flags_ = 0);

    virtual ~isotope();

    bool is_valid() const;

    bool find_mass_data();

    bool find_decay_data();

    const std::string & get_name() const;

    const std::string & get_chemical_symbol() const;

    std::string get_zai_name() const;

    int get_z() const;

    int get_a() const;

    int get_n() const;

    id get_id() const;

    double get_mass() const;

    isomeric_level_type get_isomeric() const;

    bool is_ground_state() const;

    bool is_known() const;

    bool has_atomic_mass_data() const;

    bool has_mass_excess_data() const;

    double get_mass_excess() const;

    double get_err_mass_excess() const;

    double get_atomic_mass() const;

    double get_err_atomic_mass() const;


    void set_z(int z_);


    void set_a(int a_);


    void set_isomeric(isomeric_level_type i_);


    void set_zai(int z_, int a_, isomeric_level_type i_ = GROUND_STATE);

    bool has_mass() const;


    void set_name(const std::string & name_);


    void set_mass(double mass_);


    void set_mass_excess(double mass_excess_, double err_mass_excess_ = 0.0);


    void set_binding_energy_per_nucleon(double bea_, double err_bea_ = 0.0);


    void set_atomic_mass(double mass_, double err_mass_ = 0.0);


    void set_half_life(double half_life_, double err_half_life_ = 0.0);

    bool has_decay_data() const;

    bool is_stable() const;

    double get_half_life() const;

    double get_err_half_life() const;

    datatools::properties & grab_properties();

    const datatools::properties & get_properties() const;

    bool is_locked() const;

    void lock();

    void unlock();

    void build(unsigned int flags_ = 0);

    void set_default_data();

    void reset();

    virtual void tree_dump(std::ostream & out_         = std::clog,
                           const std::string & title_  = "",
                           const std::string & indent_ = "",
                           bool inherit_          = false) const;

    static double compute_electron_binding_energy(int z_);

    static double compute_nucleus_mass(int z_, int a_, double binding_energy_per_nucleon_);

    static double compute_nucleus_mass(int z_, double atomic_mass_);

  protected:

    void _set_defaults();

  private :

    bool _locked_;                  
    int _z_;                        
    int _a_;                        
    isomeric_level_type _isomeric_; 
    std::string _name_;             
    double _mass_;            
    double _mass_excess_;     
    double _err_mass_excess_; 
    double _bea_;             
    double _err_bea_;         
    double _atomic_mass_;     
    double _err_atomic_mass_; 
    double _half_life_;       
    double _err_half_life_;   
    bool   _is_known_;        
    datatools::properties _properties_; 

  }; // end of class isotope

} // end of namespace materials

#endif // MATERIALS_ISOTOPE_H

/*
** Local Variables: --
** mode: c++ --
** c-file-style: "gnu" --
** tab-width: 2 --
** End: --
*/