element.h

Go to the documentation of this file.

/* Author (s) : Benoit Guillon  <guillon@lpccaen.in2p3.fr>
 * Creation date: 2010-03-14
 * Last modified: 2010-03-14
 *
 * Description:  A simple class to handle "abstract" chemical elements and their basic properties.
 */

#ifndef MATERIALS_ELEMENT_H
#define MATERIALS_ELEMENT_H 1

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

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

namespace materials {

  // Forward declaration:
  class isotope;

  class iso_entry
  {
  public:

    iso_entry();

    ~iso_entry();

    bool is_valid() const;

    bool is_owned() const;

    bool has_isotope() const;

    bool has_weight() const;

    double get_weight() const;

    void set_weight(double);

    void set_isotope(const isotope & iso_, bool owned_ = false);

    void set_isotope(const isotope * iso_, bool owned_ = true);

    const isotope & get_isotope() const;

    void reset();

    void reset_iso();

  private:

    bool            _owned_;   
    const isotope * _iso_ptr_; 
    double          _weight_;  

  };

  typedef std::map<std::string, iso_entry> isotope_weight_map_type;

  class element : public datatools::i_tree_dumpable
  {
  public:

    static const int Z_UNDEFINED = -1;

    enum build_flag_type {
      BF_NIST_COMPOSITION = datatools::bit_mask::bit00, 
      BF_LOCK             = datatools::bit_mask::bit31  
    };

    element();


    explicit element(const std::string & name_, int z_, unsigned int build_flags_ = 0);


    explicit element(const char * name_, int z_, unsigned int build_flags_ = 0);


    explicit element(const std::string & name_, int z_, double molar_mass_, unsigned int build_flags_ = 0);


    explicit element(const char * name_, int z_, double molar_mass_, unsigned int build_flags_ = 0);


    explicit element(const std::string & name_, const std::string & symbol_ = "", unsigned int build_flags_ = 0);


    explicit element(const char * name_, const  char * symbol_ = "", unsigned int build_flags_ = 0);

    virtual ~element();

    bool is_built_by_isotopic_composition () const;

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

    void set_z(int z_);

    void set_z(const std::string & symbol_);


    void set_molar_mass(double molar_mass_);

    void add_isotope(const isotope & iso_ref_ , double weight_ = 1.0, bool owned_ = false);

    void add_isotope(const isotope * iso_ptr_ , double weight_ = 1.0);

    void build(unsigned int build_flags_ = 0);

    void build_from_nist();

    const std::string & get_name() const;

    const std::string & get_symbol() const;

    int get_z() const;


    double get_molar_mass() const;

    bool is_locked() const;

    void lock();

    void unlock();

    const isotope_weight_map_type & get_composition() const;

    const datatools::properties & get_properties() const;

    datatools::properties & grab_properties();

    void reset();

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

  protected:

    void _set_defaults();

  private :

    void   _norm_weights_();

    void   _compute_molar_mass_();

    void   _set_molar_mass_(double molar_mass_);

  private :

    bool                    _locked_;      
    std::string             _name_;        
    std::string             _symbol_;      
    int                     _z_;           
    isotope_weight_map_type _composition_; 
    double                  _molar_mass_;  
    datatools::properties   _properties_;  

  }; // end of class element

} // end of namespace materials

#endif // MATERIALS_ELEMENT_H

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