data.h

Go to the documentation of this file.

#ifndef PYNE_TEWK4A7VOFFLHDDXD5ZZ7KPXEQ
#define PYNE_TEWK4A7VOFFLHDDXD5ZZ7KPXEQ
#include <iostream>
#include <string>
#include <utility>
#include <map>
#include <set>
#include <limits>
#include <exception>
#include <stdlib.h>
#include <stdio.h>
#include <float.h>
#include <math.h>

#include "hdf5.h"
#include "hdf5_hl.h"

#ifndef PYNE_IS_AMALGAMATED
#include "h5wrap.h"
#include "extra_types.h"
#include "utils.h"
#include "nucname.h"
#include "rxname.h"
#endif

namespace pyne
{
  extern const double pi;   
  extern const double N_A;  
  extern const double barns_per_cm2;  
  extern const double cm2_per_barn;   
  extern const double sec_per_day;    
  extern const double MeV_per_K;    
  extern const double MeV_per_MJ;  
  extern const double Bq_per_Ci;   
  extern const double Ci_per_Bq;   

  extern std::string NUC_DATA_PATH; 

  extern std::map<std::string, std::string> data_checksums;


  extern std::map<int, double> atomic_mass_map;

  typedef struct atomic_mass_data {
    int nuc;      
    double mass;  
    double error; 
    double abund; 
  } atomic_mass_data;

  // Loads preset dataset hashes into memory.
  std::map<std::string, std::string> get_data_checksums();

  void _load_atomic_mass_map();

  double atomic_mass(int nuc);
  double atomic_mass(char * nuc);
  double atomic_mass(std::string nuc);



  extern std::map<int, double> natural_abund_map;

  double natural_abund(int nuc);
  double natural_abund(char * nuc);
  double natural_abund(std::string nuc);




  extern std::map<int, double> q_val_map;
  extern std::map<int, double> gamma_frac_map;

  typedef struct q_val_data {
    int nuc;          
    double q_val;      
    double gamma_frac; 
  } q_val_data;

  void _load_q_val_map();

  double q_val(int nuc);
  double q_val(const char * nuc);
  double q_val(std::string nuc);
  double gamma_frac(int nuc);
  double gamma_frac(const char * nuc);
  double gamma_frac(std::string nuc);



  typedef struct dose {
    int nuc;              
    double ext_air_dose;  
    double ratio;         
    double ext_soil_dose; 
    double ingest_dose;   
    double fluid_frac;    
    double inhale_dose;   
    char lung_mod;        
  } dose;

  extern std::map<int, dose> epa_dose_map;
  extern std::map<int, dose> doe_dose_map;
  extern std::map<int, dose> genii_dose_map;

  void _load_dose_map(std::map<int, dose>& dm, std::string source_path);

  double ext_air_dose(int nuc, int source);
  double ext_air_dose(const char * nuc, int source);
  double ext_air_dose(std::string nuc, int source);
  double ext_soil_dose(int nuc, int source);
  double ext_soil_dose(const char * nuc, int source);
  double ext_soil_dose(std::string nuc, int source);
  double ingest_dose(int nuc, int source);
  double ingest_dose(const char * nuc, int source);
  double ingest_dose(std::string nuc, int source);
  double inhale_dose(int nuc, int source);
  double inhale_dose(const char * nuc, int source);
  double inhale_dose(std::string nuc, int source);
  double dose_ratio(int nuc, int source);
  double dose_ratio(const char * nuc, int source);
  double dose_ratio(std::string nuc, int source);
  double dose_fluid_frac(int nuc, int source);
  double dose_fluid_frac(const char * nuc, int source);
  double dose_fluid_frac(std::string nuc, int source);
  std::string dose_lung_model(int nuc, int source);
  std::string dose_lung_model(const char * nuc, int source);
  std::string dose_lung_model(std::string nuc, int source);




  extern std::map<int, xd_complex_t> b_coherent_map;
  extern std::map<int, xd_complex_t> b_incoherent_map;
  extern std::map<int, double> b_map;

  typedef struct scattering_lengths {
    int nuc;  
    xd_complex_t b_coherent;  
    xd_complex_t b_incoherent;  
    double xs_coherent;   
    double xs_incoherent; 
    double xs;            
  } scattering_lengths;

  void _load_scattering_lengths();

  xd_complex_t b_coherent(int nuc);
  xd_complex_t b_coherent(char * nuc);
  xd_complex_t b_coherent(std::string nuc);

  xd_complex_t b_incoherent(int nuc);
  xd_complex_t b_incoherent(char * nuc);
  xd_complex_t b_incoherent(std::string nuc);

  double b(int nuc);
  double b(char * nuc);
  double b(std::string nuc);



  extern std::map<std::pair<int, int>, double> wimsdfpy_data;

  typedef struct wimsdfpy {
    int from_nuc;  
    int to_nuc;  
    double yields; 
  } wimsdfpy;

  void _load_wimsdfpy();

  typedef struct ndsfpy {
    int from_nuc; 
    int to_nuc; 
    double yield_thermal; 
    double yield_thermal_err; 
    double yield_fast; 
    double yield_fast_err; 
    double yield_14MeV; 
    double yield_14MeV_err; 
  } ndsfpy;

  typedef struct ndsfpysub {
    double yield_thermal; 
    double yield_thermal_err; 
    double yield_fast; 
    double yield_fast_err; 
    double yield_14MeV; 
    double yield_14MeV_err; 
  } ndsfpysub;


  extern std::map<std::pair<int, int>, ndsfpysub> ndsfpy_data;

  void _load_ndsfpy();

  double fpyield(std::pair<int, int> from_to, int source, bool get_error);
  double fpyield(int from_nuc, int to_nuc, int source, bool get_error);
  double fpyield(char * from_nuc, char * to_nuc, int source, bool get_error);
  double fpyield(std::string from_nuc, std::string to_nuc, int source, bool get_error);





  class swapmapcompare{
    public:
        bool operator()(const std::pair<int, double>& lhs,
                        const std::pair<int, double>& rhs) const;
  };

  template<typename T, typename U> std::vector<T> data_access(double emin,
    double emax, size_t valoffset, std::map<std::pair<int, double>, U>  &data);
  template<typename T, typename U> std::vector<T> data_access(int parent,
    double min, double max, size_t valoffset,
    std::map<std::pair<int, double>, U>  &data);
  template<typename T, typename U> T data_access(std::pair<int, int> from_to,
    size_t valoffset, std::map<std::pair<int, int>, U> &data);
  template<typename T, typename U> std::vector<T> data_access(int parent,
    size_t valoffset, std::map<std::pair<int, int>, U> &data);
  template<typename T, typename U> std::vector<T> data_access(int parent,
    size_t valoffset, std::map<std::pair<int, unsigned int>, U> &data);

  template<typename U> double data_access(int parent,
  size_t valoffset, std::map<int, U> &data);

  typedef struct atomic{
    int z; 
    double k_shell_fluor; 
    double k_shell_fluor_error; 
    double l_shell_fluor; 
    double l_shell_fluor_error; 
    double prob; 
    double k_shell_be; 
    double k_shell_be_err; 
    double li_shell_be; 
    double li_shell_be_err; 
    double mi_shell_be; 
    double mi_shell_be_err; 
    double ni_shell_be; 
    double ni_shell_be_err; 
    double kb_to_ka; 
    double kb_to_ka_err; 
    double ka2_to_ka1; 
    double ka2_to_ka1_err; 
    double k_auger; 
    double l_auger; 
    double ka1_x_ray_en; 
    double ka1_x_ray_en_err; 
    double ka2_x_ray_en; 
    double ka2_x_ray_en_err; 
    double kb_x_ray_en; 
    double l_x_ray_en; 
  } atomic;

  // map of Z to atomic data
  extern std::map<int, atomic> atomic_data_map;

  template<typename T> void _load_data();
  template<> void _load_data<atomic>();

  // compute X-ray data
  std::vector<std::pair<double, double> >
  calculate_xray_data(int z, double k_conv, double l_conv);


  typedef struct level_data{
    int nuc_id; 
    unsigned int rx_id; 
    double half_life; 
    double level; 
    double branch_ratio; 
    int metastable; 
    char special; 
  } level_data;

  extern std::map<std::pair<int,double>, level_data> level_data_lvl_map;
  extern std::map<std::pair<int,unsigned int>, level_data> level_data_rx_map;

  template<> void _load_data<level_data>();

  int id_from_level(int nuc, double level);
  int id_from_level(int nuc, double level, std::string special);
  int metastable_id(int nuc, int m);
  int metastable_id(int nuc);

  double half_life(int nuc);
  double half_life(char * nuc);
  double half_life(std::string nuc);

  double decay_const(int nuc);
  double decay_const(char * nuc);
  double decay_const(std::string nuc);

  double branch_ratio(std::pair<int, int> from_to);
  double branch_ratio(int from_nuc, int to_nuc);
  double branch_ratio(char * from_nuc, char * to_nuc);
  double branch_ratio(std::string from_nuc, std::string to_nuc);

  double state_energy(int nuc);
  double state_energy(char * nuc);
  double state_energy(std::string nuc);

  std::set<int> decay_children(int nuc);
  std::set<int> decay_children(char * nuc);
  std::set<int> decay_children(std::string nuc);

  typedef struct decay{
    int parent; 
    int child; 
    unsigned int decay; 
    double half_life; 
    double half_life_error; 
    double branch_ratio; 
    double branch_ratio_error; 
    double photon_branch_ratio;
    double photon_branch_ratio_error;
    double beta_branch_ratio;
    double beta_branch_ratio_error;
  } decay;

  template<> void _load_data<decay>();
  extern std::map<std::pair<int, int>, decay> decay_data;

  //
  //
  std::vector<int> decay_data_children(int parent);
  std::pair<double, double> decay_half_life(std::pair<int,int>);
  std::vector<std::pair<double, double> > decay_half_lifes(int);
  std::pair<double, double> decay_branch_ratio(std::pair<int,int>);
  std::vector<double> decay_branch_ratios(int parent);
  std::pair<double, double> decay_photon_branch_ratio(std::pair<int,int>);
  std::vector<std::pair<double, double> >decay_photon_branch_ratios(int parent);
  std::pair<double, double> decay_beta_branch_ratio(std::pair<int,int>);
  std::vector<std::pair<double, double> >decay_beta_branch_ratios(int parent);


  typedef struct gamma{
    int from_nuc; 
    int to_nuc; 
    int parent_nuc; 
    int child_nuc; 
    double energy; 
    double energy_err; 
    double photon_intensity; 
    double photon_intensity_err; 
    double conv_intensity; 
    double conv_intensity_err; 
    double total_intensity; 
    double total_intensity_err; 
    double k_conv_e; 
    double l_conv_e; 
    double m_conv_e; 
  } gamma;

  template<> void _load_data<gamma>();

  extern std::map<std::pair<int, double>, gamma> gamma_data;

  //returns a list of gamma decay energies from input parent nuclide
  std::vector<std::pair<double, double> > gamma_energy(int parent);
  std::vector<std::pair<double, double> > gamma_energy(double energy,
   double error);
  //returns a list of gamma photon intensities from input parent nuclide
  std::vector<std::pair<double, double> > gamma_photon_intensity(int parent);
  std::vector<std::pair<double, double> > gamma_photon_intensity(double energy,
   double error);
  //returns a list of gamma conversion intensities from input parent nuclide
  std::vector<std::pair<double, double> > gamma_conversion_intensity(int parent);
  //returns a list of gamma total intensities from input parent nuclide
  std::vector<std::pair<double, double> > gamma_total_intensity(int parent);
  //returns a list of pairs of excited state transitions from an input parent nuclide
  std::vector<std::pair<int, int> > gamma_from_to(int parent);
  //returns a list of pairs of excited state transitions from an decay energy
  std::vector<std::pair<int, int> > gamma_from_to(double energy, double error);
  //returns a list of parent/child pairs associated with an input decay energy
  std::vector<std::pair<int, int> > gamma_parent_child(double energy, double error);
  //returns a list of parent nuclides associated with an input decay energy
  std::vector<int> gamma_parent(double energy, double error);
  // returns a list of child state_id's based on a gamma-ray energy
  std::vector<int> gamma_child(double energy, double error);
  // returns a list of child state_id's based on a parent state_id
  std::vector<int> gamma_child(int parent);
  //returns an array of arrays of X-ray energies and intesities for a
  //given parent
  std::vector<std::pair<double, double> > gamma_xrays(int parent);

  std::vector<std::pair<double, double> > gammas(int parent_state_id);
  std::vector<std::pair<double, double> > alphas(int parent_state_id);
  std::vector<std::pair<double, double> > betas(int parent_state_id);
  std::vector<std::pair<double, double> > xrays(int parent);

  typedef struct alpha{
    int from_nuc; 
    int to_nuc; 
    double energy; 
    double intensity; 
  } alpha;

  template<> void _load_data<alpha>();

  extern std::map<std::pair<int, double>, alpha> alpha_data;

  //returns a list of alpha decay energies from input parent nuclide
  std::vector<double > alpha_energy(int parent);
  //returns a list of alpha decay intensities from input parent nuclide
  std::vector<double> alpha_intensity(int parent);
  //returns a list of alpha decay parents from input decay energy range
  std::vector<int> alpha_parent(double energy, double error);
  //returns a list of alpha decay children from input decay energy range
  std::vector<int> alpha_child(double energy, double error);
  //returns a list of alpha decay children from input parent nuclide
  std::vector<int> alpha_child(int parent);

  typedef struct beta{
    int from_nuc; 
    int to_nuc; 
    double endpoint_energy; 
    double avg_energy; 
    double intensity; 
  } beta;

  template<> void _load_data<beta>();

  extern std::map<std::pair<int, double>, beta> beta_data;
  //returns a list of beta decay endpoint energies from input parent nuclide
  std::vector<double > beta_endpoint_energy(int parent);
  //returns a list of beta decay average energies from input parent nuclide
  std::vector<double > beta_average_energy(int parent);
  //returns a list of beta decay intensities from input parent nuclide
  std::vector<double> beta_intensity(int parent);
  //returns a list of beta decay parents from input decay energy range
  std::vector<int> beta_parent(double energy, double error);
  //returns a list of beta decay children from input decay energy range
  std::vector<int> beta_child(double energy, double error);
  //returns a list of beta decay children from input parent nuclide
  std::vector<int> beta_child(int parent);

  typedef struct ecbp{
    int from_nuc;  
    int to_nuc; 
    double endpoint_energy; 
    double avg_energy; 
    double beta_plus_intensity; 
    double ec_intensity; 
    double k_conv_e; 
    double l_conv_e; 
    double m_conv_e; 
  } ecbp;

  extern std::map<std::pair<int, double>, ecbp> ecbp_data;

  template<> void _load_data<ecbp>();
  std::vector<double > ecbp_endpoint_energy(int parent);
  //returns a list of electron capture/ beta plus decay average energies from
  //input parent nuclide
  std::vector<double > ecbp_average_energy(int parent);
  //returns a list of electron capture decay intensities from input parent
  //nuclide
  std::vector<double> ec_intensity(int parent);
  //returns a list of beta plus decay intensities from input parent nuclide
  std::vector<double> bp_intensity(int parent);
  //returns a list of electron capture /beta plus decay parents from input
  //decay energy range
  std::vector<int> ecbp_parent(double energy, double error);
  //returns a list of electron capture /beta plus decay children from input
  //decay energy range
  std::vector<int> ecbp_child(double energy, double error);
  //returns a list of electron capture /beta plus decay children from input
  //parent nuclide
  std::vector<int> ecbp_child(int parent);
  //returns an array of arrays of X-ray energies and intesities for a
  //given parent
  std::vector<std::pair<double, double> > ecbp_xrays(int parent);

  extern std::map<std::string, std::map<int, std::map<int, double> > >
      simple_xs_map;

  double simple_xs(int nuc, int rx, std::string energy);
  double simple_xs(int nuc, std::string rx, std::string energy);
  double simple_xs(std::string nuc, int rx, std::string energy);
  double simple_xs(std::string nuc, std::string rx, std::string energy);

  class InvalidSimpleXS : public std::exception {
   public:
    InvalidSimpleXS () {};
    ~InvalidSimpleXS () throw () {};
    InvalidSimpleXS(std::string msg) : msg_(msg) {};
    virtual const char* what() const throw() {
      return msg_.c_str();
    };

   private:
    std::string msg_;
  };

} // namespace pyne

#endif