nucname.h

#ifndef PYNE_D35WIXV5DZAA5LLOWBY2BL2DPA
#define PYNE_D35WIXV5DZAA5LLOWBY2BL2DPA
#include <iostream>
#include <string>
#include <map>
#include <set>
#include <exception>
#include <stdlib.h>
#include <stdio.h>

#ifndef PYNE_IS_AMALGAMATED
#include "utils.h"
#endif

namespace pyne
{
namespace nucname
{
  typedef std::string name_t; 
  typedef int zz_t;           

  typedef std::map<name_t, zz_t> name_zz_t; 
  typedef name_zz_t::iterator name_zz_iter; 
  name_zz_t get_name_zz();  
  extern name_zz_t name_zz; 

  typedef std::map<zz_t, name_t> zzname_t;  
  typedef zzname_t::iterator zzname_iter;   
  zzname_t get_zz_name();   
  extern zzname_t zz_name;  

  name_zz_t get_fluka_zz();  
  extern name_zz_t fluka_zz; 
  zzname_t get_zz_fluka();   
  extern zzname_t zz_fluka;  
  /******************************************/
  /*** Define useful elemental group sets ***/
  /******************************************/

  typedef std::set<name_t> name_group;
  typedef name_group::iterator name_group_iter; 

  typedef std::set<zz_t> zz_group;
  typedef zz_group::iterator zz_group_iter; 

  zz_group name_to_zz_group (name_group eg);

  extern name_t LAN_array[15];  
  extern name_group LAN;        
  extern zz_group lan;          

  extern name_t ACT_array[15];  
  extern name_group ACT;        
  extern zz_group act;          

  extern name_t TRU_array[22];  
  extern name_group TRU;        
  extern zz_group tru;          

  extern name_t MA_array[10];   
  extern name_group MA;         
  extern zz_group ma;           

  extern name_t FP_array[88];   
  extern name_group FP;         
  extern zz_group fp;           


  /******************/
  /*** Exceptions ***/
  /******************/

  class NotANuclide : public std::exception
  {
  public:
    NotANuclide () {};

    ~NotANuclide () throw () {};

    NotANuclide(std::string wasptr, std::string nowptr)
    {
       nucwas = wasptr;
       nucnow = nowptr;
    };

    NotANuclide(std::string wasptr, int nowptr)
    {
      nucwas = wasptr;
      nucnow = pyne::to_str(nowptr);
    };

    NotANuclide(int wasptr, std::string nowptr)
    {
      nucwas = pyne::to_str(wasptr);
      nucnow = nowptr;
    };

    NotANuclide(int wasptr, int nowptr)
    {
      nucwas = pyne::to_str(wasptr);
      nucnow = pyne::to_str(nowptr);
    };

    virtual const char* what() const throw()
    {
      std::string NaNEstr ("Not a Nuclide! ");
      if (!nucwas.empty())
        NaNEstr += nucwas;

      if (!nucnow.empty())
      {
        NaNEstr += " --> ";
        NaNEstr += nucnow;
      }
      const char* NaNEstr_rtn = NaNEstr.c_str();
      return NaNEstr_rtn;
    };

  private:
    std::string nucwas; 
    std::string nucnow; 
  };

  class IndeterminateNuclideForm : public std::exception
  {
  public:
    IndeterminateNuclideForm () {};

    ~IndeterminateNuclideForm () throw () {};

    IndeterminateNuclideForm(std::string wasptr, std::string nowptr)
    {
       nucwas = wasptr;
       nucnow = nowptr;
    };

    IndeterminateNuclideForm(std::string wasptr, int nowptr)
    {
      nucwas = wasptr;
      nucnow = pyne::to_str(nowptr);
    };

    IndeterminateNuclideForm(int wasptr, std::string nowptr)
    {
      nucwas = pyne::to_str(wasptr);
      nucnow = nowptr;
    };

    IndeterminateNuclideForm(int wasptr, int nowptr)
    {
      nucwas = pyne::to_str(wasptr);
      nucnow = pyne::to_str(nowptr);
    };

    virtual const char* what() const throw()
    {
      std::string INFEstr ("Indeterminate nuclide form: ");
      if (!nucwas.empty())
        INFEstr += nucwas;

      if (!nucnow.empty())
      {
        INFEstr += " --> ";
        INFEstr += nucnow;
      }
      const char* INFEstr_rtn = INFEstr.c_str();
      return INFEstr_rtn;
    }

  private:
    std::string nucwas; 
    std::string nucnow; 
  };

  bool isnuclide(std::string nuc);
  bool isnuclide(const char * nuc);
  bool isnuclide(int nuc);

  bool iselement(std::string nuc);
  bool iselement(const char * nuc);
  bool iselement(int nuc);

  int id(int nuc);
  int id(const char * nuc);
  int id(std::string nuc);

  std::string name(int nuc);
  std::string name(const char * nuc);
  std::string name(std::string nuc);

  int znum(int nuc);
  int znum(const char * nuc);
  int znum(std::string nuc);

  int anum(int nuc);
  int anum(const char * nuc);
  int anum(std::string nuc);

  int snum(int nuc);
  int snum(const char * nuc);
  int snum(std::string nuc);

  int zzaaam(int nuc);
  int zzaaam(const char * nuc);
  int zzaaam(std::string nuc);

  int zzaaam_to_id(int nuc);
  int zzaaam_to_id(const char * nuc);
  int zzaaam_to_id(std::string nuc);


  int zzzaaa(int nuc);
  int zzzaaa(const char * nuc);
  int zzzaaa(std::string nuc);


  int zzzaaa_to_id(int nuc);
  int zzzaaa_to_id(const char * nuc);
  int zzzaaa_to_id(std::string nuc);


  std::string zzllaaam(int nuc);
  std::string zzllaaam(const char * nuc);
  std::string zzllaaam(std::string nuc);


  //int zzllaaam_to_id(int nuc);
  int zzllaaam_to_id(const char * nuc);
  int zzllaaam_to_id(std::string nuc);


  int mcnp(int nuc);
  int mcnp(const char * nuc);
  int mcnp(std::string nuc);

  int mcnp_to_id(int nuc);
  int mcnp_to_id(const char * nuc);
  int mcnp_to_id(std::string nuc);

  std::string openmc(int nuc);
  std::string openmc(const char * nuc);
  std::string openmc(std::string nuc);

  int openmc_to_id(const char * nuc);
  int openmc_to_id(std::string nuc);

  std::string fluka(int nuc);

  int fluka_to_id(std::string name);
  int fluka_to_id(char * name);

  std::string serpent(int nuc);
  std::string serpent(const char * nuc);
  std::string serpent(std::string nuc);

  //int serpent_to_id(int nuc);  Should be ZAID
  int serpent_to_id(const char * nuc);
  int serpent_to_id(std::string nuc);

  std::string nist(int nuc);
  std::string nist(const char * nuc);
  std::string nist(std::string nuc);

  //int serpent_to_id(int nuc);  NON-EXISTANT
  int nist_to_id(const char * nuc);
  int nist_to_id(std::string nuc);

  int cinder(int nuc);
  int cinder(const char * nuc);
  int cinder(std::string nuc);

  int cinder_to_id(int nuc);
  int cinder_to_id(const char * nuc);
  int cinder_to_id(std::string nuc);

  std::string alara(int nuc);
  std::string alara(const char * nuc);
  std::string alara(std::string nuc);

  //int alara_to_id(int nuc); NOT POSSIBLE
  int alara_to_id(const char * nuc);
  int alara_to_id(std::string nuc);

  int sza(int nuc);
  int sza(const char * nuc);
  int sza(std::string nuc);

  int sza_to_id(int nuc);
  int sza_to_id(const char * nuc);
  int sza_to_id(std::string nuc);

  inline int groundstate(int nuc) {return (id(nuc) / 10000 ) * 10000;}
  inline int groundstate(std::string nuc) {return groundstate(id(nuc));}
  inline int groundstate(const char * nuc) {return groundstate(std::string(nuc));}

  void _load_state_map();
  int state_id_to_id(int state);
  int id_to_state_id(int nuc_id);
  extern std::map<int, int> state_id_map;

  int ensdf_to_id(const char * nuc);
  int ensdf_to_id(std::string nuc);

}
}

#endif  // PYNE_D35WIXV5DZAA5LLOWBY2BL2DPA