CYCLUS
Classes | Namespaces | Macros | Typedefs | Enumerations | Functions | Variables
pyne.h File Reference
#include <string>
#include <string.h>
#include <sstream>
#include <cctype>
#include <stdlib.h>
#include <iostream>
#include <cmath>
#include <exception>
#include <sys/stat.h>
#include <sys/types.h>
#include <cstdlib>
#include <vector>
#include <algorithm>
#include <math.h>
#include <fstream>
#include <map>
#include <set>
#include <stdio.h>
#include "hdf5.h"
#include <utility>
#include <limits>
#include <float.h>
#include "hdf5_hl.h"
#include <deque>
#include <stack>

Go to the source code of this file.

Classes

struct  pyne::alpha
 
struct  pyne::atomic
 
struct  pyne::atomic_mass_data
 
struct  pyne::beta
 
class  pyne::enrichment::Cascade
 
class  Json::CustomWriter
 
struct  pyne::decay
 
struct  pyne::dose
 
struct  pyne::ecbp
 
class  pyne::enrichment::EnrichmentInfiniteLoopError
 
class  pyne::enrichment::EnrichmentIterationLimit
 
class  pyne::enrichment::EnrichmentIterationNaN
 
class  Json::FastWriter
 
class  Json::Features
 
class  pyne::FileNotFound
 
class  h5wrap::FileNotHDF5
 
struct  pyne::gamma
 
class  h5wrap::GroupNotFound
 
class  h5wrap::HDF5BoundsError
 
class  h5wrap::HomogenousTypeTable< T >
 
class  pyne::nucname::IndeterminateNuclideForm
 
class  pyne::rxname::IndeterminateReactionForm
 
class  pyne::InvalidSimpleXS
 
struct  pyne::level_data
 
class  pyne::Material
 
struct  pyne::material_data
 
class  pyne::MaterialProtocolError
 
struct  pyne::ndsfpy
 
struct  pyne::ndsfpysub
 
class  pyne::nucname::NotANuclide
 
class  pyne::rxname::NotAReaction
 
class  Json::Path
 
class  Json::PathArgument
 
class  h5wrap::PathNotFound
 
struct  pyne::q_val_data
 
class  Json::Reader
 
struct  pyne::scattering_lengths
 
class  Json::StaticString
 
class  Json::StyledStreamWriter
 
class  Json::StyledWriter
 
class  pyne::swapmapcompare
 
class  Json::Value
 
class  Json::ValueConstIterator
 
class  Json::ValueIterator
 
class  Json::ValueIteratorBase
 
struct  pyne::wimsdfpy
 
class  Json::Writer
 
struct  xd_complex_t
 

Namespaces

 h5wrap
 
 Json
 
 pyne
 
 pyne::decayers
 
 pyne::enrichment
 
 pyne::nucname
 
 pyne::rxname
 

Macros

#define _XDRESS_EXTRA_TYPES_
 
#define CPPTL_JSON_FEATURES_H_INCLUDED
 
#define CPPTL_JSON_H_INCLUDED
 
#define CPPTL_JSON_READER_H_INCLUDED
 
#define isnan(x)   __isnand((double)x)
 
#define JSON_AMALGATED_H_INCLUDED
 
#define JSON_API
 
#define JSON_CONFIG_H_INCLUDED
 
#define JSON_FORWARD_AMALGATED_H_INCLUDED
 
#define JSON_FORWARDS_H_INCLUDED
 
#define JSON_HAS_INT64
 
#define JSON_IS_AMALGAMATION
 
#define JSON_IS_AMALGATED
 
#define JSON_IS_AMALGATED
 
#define JSON_USE_EXCEPTION   1
 
#define JSON_WRITER_H_INCLUDED
 
#define JSONCPP_DEPRECATED(message)
 
#define NUM_RX_NAMES   572
 
#define PYNE_3QGDWZMLZBHDHI424JL52SQHN4
 
#define PYNE_46Z7LQYFI5HZNASIPCWHVX3X5E
 
#define PYNE_7DOEB2PKSBEFFIA3Q2NARI3KFY
 
#define PYNE_B3ANNCKDQ5HEJLI33RPZPDNX6A
 
#define PYNE_D35WIXV5DZAA5LLOWBY2BL2DPA
 
#define PYNE_IS_AMALGAMATED
 
#define PYNE_KMMHYNANYFF5BFMEYIP7TUNLHA
 
#define PYNE_MR34UE5INRGMZK2QYRDWICFHVM
 
#define PYNE_MRNAFG5GNZDNPCRPX3UCBZ5MFE
 
#define PYNE_OU4PO4TJDBDM5PY4VKAVL7JCSM
 
#define PYNE_TEWK4A7VOFFLHDDXD5ZZ7KPXEQ
 

Typedefs

typedef unsigned int Json::ArrayIndex
 
typedef comp_map::iterator pyne::comp_iter
 
typedef std::map< int, double > pyne::comp_map
 
typedef int Json::Int
 
typedef long long int Json::Int64
 
typedef Int64 Json::LargestInt
 
typedef UInt64 Json::LargestUInt
 
typedef struct pyne::material_data pyne::material_data
 
typedef std::set< name_t > pyne::nucname::name_group
 
typedef name_group::iterator pyne::nucname::name_group_iter
 
typedef std::string pyne::nucname::name_t
 
typedef name_zz_t::iterator pyne::nucname::name_zz_iter
 
typedef std::map< name_t, zz_t > pyne::nucname::name_zz_t
 
typedef unsigned int Json::UInt
 
typedef unsigned long long int Json::UInt64
 
typedef std::set< zz_t > pyne::nucname::zz_group
 
typedef zz_group::iterator pyne::nucname::zz_group_iter
 
typedef int pyne::nucname::zz_t
 
typedef zzname_t::iterator pyne::nucname::zzname_iter
 
typedef std::map< zz_t, name_t > pyne::nucname::zzname_t
 

Enumerations

enum  Json::CommentPlacement { Json::commentBefore = 0, Json::commentAfterOnSameLine, Json::commentAfter, Json::numberOfCommentPlacement }
 
enum  Json::ValueType {
  Json::nullValue = 0, Json::intValue, Json::uintValue, Json::realValue,
  Json::stringValue, Json::booleanValue, Json::arrayValue, Json::objectValue
}
 

Functions

Cascade pyne::enrichment::_fill_default_uranium_cascade ()
 
void * pyne::rxname::_fill_maps ()
 
hid_t h5wrap::_get_PYTABLES_COMPLEX128 ()
 
void pyne::_insert_abund_map ()
 
void pyne::_insert_atomic_mass_map ()
 
void pyne::_load_atomic_mass_map_memory ()
 
double pyne::enrichment::alphastar_i (double alpha, double Mstar, double M_i)
 
std::string pyne::capitalize (std::string s)
 
bool pyne::contains_substring (std::string s, std::string substr)
 
double pyne::coth (double x)
 
comp_map pyne::decayers::decay (comp_map, double)
 
double pyne::endftod_cpp (char *s)
 
double pyne::endftod_f (char *s)
 
double pyne::enrichment::feed_per_prod (double x_feed, double x_prod, double x_tail)
 
double pyne::enrichment::feed_per_tail (double x_feed, double x_prod, double x_tail)
 
bool pyne::file_exists (std::string strfilename)
 
template<typename T >
h5wrap::get_array_index (hid_t dset, int n, hid_t dtype=H5T_NATIVE_DOUBLE)
 
std::string pyne::get_flag (char line[], int max_l)
 
name_zz_t pyne::nucname::get_fluka_zz ()
 
name_zz_t pyne::nucname::get_name_zz ()
 
zzname_t pyne::nucname::get_zz_fluka ()
 
zzname_t pyne::nucname::get_zz_name ()
 
template<typename T >
std::set< T > h5wrap::h5_array_to_cpp_set (hid_t h5file, std::string data_path, hid_t dtype=H5T_NATIVE_DOUBLE)
 
template<typename T >
std::vector< T > h5wrap::h5_array_to_cpp_vector_1d (hid_t h5file, std::string data_path, hid_t dtype=H5T_NATIVE_DOUBLE)
 
template<typename T >
std::vector< std::vector< T > > h5wrap::h5_array_to_cpp_vector_2d (hid_t h5file, std::string data_path, hid_t dtype=H5T_NATIVE_DOUBLE)
 
template<typename T >
std::vector< std::vector< std::vector< T > > > h5wrap::h5_array_to_cpp_vector_3d (hid_t h5file, std::string data_path, hid_t dtype=H5T_NATIVE_DOUBLE)
 
std::string pyne::last_char (std::string s)
 
zz_group pyne::nucname::name_to_zz_group (name_group eg)
 
std::string pyne::natural_naming (std::string name)
 
int pyne::rxname::offset (int dz, int da, int ds=0)
 
std::ostream & pyne::operator<< (std::ostream &os, Material mat)
 
std::ostream & Json::operator<< (std::ostream &, const Value &root)
 
std::istream & Json::operator>> (std::istream &, Value &)
 
bool h5wrap::path_exists (hid_t h5file, std::string path)
 
double pyne::enrichment::prod_per_feed (double x_feed, double x_prod, double x_tail)
 
double pyne::enrichment::prod_per_tail (double x_feed, double x_prod, double x_tail)
 
void pyne::pyne_start ()
 
std::string pyne::remove_characters (std::string s, std::string chars)
 
std::string pyne::remove_substring (std::string s, std::string substr)
 
std::string pyne::replace_all_substrings (std::string s, std::string substr, std::string repstr)
 
double pyne::simple_xs (int nuc, int rx, std::string energy)
 
double pyne::simple_xs (int nuc, std::string rx, std::string energy)
 
double pyne::simple_xs (std::string nuc, int rx, std::string energy)
 
double pyne::simple_xs (std::string nuc, std::string rx, std::string energy)
 
std::string pyne::slice_from_end (std::string s, int n=-1, int l=1)
 
double pyne::slope (double x2, double y2, double x1, double y1)
 
double pyne::solve_line (double x, double x2, double y2, double x1, double y1)
 
Cascade pyne::enrichment::solve_symbolic (Cascade &orig_casc)
 
double pyne::enrichment::swu_per_feed (double x_feed, double x_prod, double x_tail)
 
double pyne::enrichment::swu_per_prod (double x_feed, double x_prod, double x_tail)
 
double pyne::enrichment::swu_per_tail (double x_feed, double x_prod, double x_tail)
 
double pyne::enrichment::tail_per_feed (double x_feed, double x_prod, double x_tail)
 
double pyne::enrichment::tail_per_prod (double x_feed, double x_prod, double x_tail)
 
double pyne::tanh (double x)
 
bool pyne::ternary_ge (int a, int b, int c)
 
double pyne::to_dbl (std::string s)
 
int pyne::to_int (std::string s)
 
std::string pyne::to_lower (std::string s)
 
std::string pyne::to_upper (std::string s)
 
bool pyne::toggle_warnings ()
 
void pyne::use_fast_endftod ()
 
double pyne::enrichment::value_func (double x)
 
std::string Json::valueToQuotedString (const char *value)
 
std::string Json::valueToString (LargestInt value)
 
std::string Json::valueToString (LargestUInt value)
 
std::string Json::valueToString (Int value)
 
std::string Json::valueToString (UInt value)
 
std::string Json::valueToString (double value)
 
std::string Json::valueToString (bool value)
 
void pyne::warning (std::string s)
 
String Conversion Functions

Converts the variables of various types to their C++ string representation.

std::string pyne::to_str (int t)
 
std::string pyne::to_str (unsigned int t)
 
std::string pyne::to_str (double t)
 
std::string pyne::to_str (bool t)
 
isnuclide functions

These functions test if an input nuc is a valid nuclide.

Parameters
nuca possible nuclide
Returns
a bool
bool pyne::nucname::isnuclide (std::string nuc)
 
bool pyne::nucname::isnuclide (const char *nuc)
 
bool pyne::nucname::isnuclide (int nuc)
 
iselement functions

These functions test if an input nuc is a valid element.

Parameters
nuca possible element
Returns
a bool
bool pyne::nucname::iselement (std::string nuc)
 
bool pyne::nucname::iselement (const char *nuc)
 
bool pyne::nucname::iselement (int nuc)
 
Identifier Form Functions

The 'id' nuclide naming convention is the canonical form for representing nuclides in PyNE.

This is termed a ZAS, or ZZZAAASSSS, representation because It stores 3 Z-number digits, 3 A-number digits, followed by 4 S-number digits which the nucleus excitation state.

The id() function will always return an nuclide in id form, if successful. If the input nuclide is in id form already, then this is function does no work. For all other formats, the id() function provides a best-guess based on a heirarchy of other formats that is used to resolve ambiguities between naming conventions. For integer input the form resolution order is:

  • id
  • zz (elemental z-num only given)
  • zzaaam
  • cinder (aaazzzm)
  • mcnp
  • zzaaa For string (or char *) input the form resolution order is as follows:
  • ZZ-LL-AAAM
  • Integer form in a string representation, uses interger resolution
  • NIST
  • name form
  • Serpent
  • LL (element symbol) For well-defined situations where you know ahead of time what format the nuclide is in, you should use the various form_to_id() functions, rather than the id() function which is meant to resolve possibly ambiquous cases.
    Parameters
    nuca nuclide
    Returns
    nucid 32-bit integer identifier
int pyne::nucname::id (int nuc)
 
int pyne::nucname::id (const char *nuc)
 
int pyne::nucname::id (std::string nuc)
 
Name Form Functions

The 'name' nuclide naming convention is the more common, human readable notation.

The chemical symbol (one or two characters long) is first, followed by the nucleon number. Lastly if the nuclide is metastable, the letter M is concatenated to the end. For example, ‘H-1’ and ‘Am242M’ are both valid. Note that nucname will always return name form with dashes removed, the chemical symbol used for letter casing (ie 'Pu'), and a trailing upercase 'M' for a metastable flag. The name() function first converts functions to id form using the id() function. Thus the form order resolution for id() also applies here.

Parameters
nuca nuclide
Returns
a string nuclide identifier.
std::string pyne::nucname::name (int nuc)
 
std::string pyne::nucname::name (const char *nuc)
 
std::string pyne::nucname::name (std::string nuc)
 
Z-Number Functions

The Z-number, or charge number, represents the number of protons in a nuclide.

This function returns that number.

Parameters
nuca nuclide
Returns
an integer Z-number.
int pyne::nucname::znum (int nuc)
 
int pyne::nucname::znum (const char *nuc)
 
int pyne::nucname::znum (std::string nuc)
 
A-Number Functions

The A-number, or nucleon number, represents the number of protons and neutrons in a nuclide.

This function returns that number.

Parameters
nuca nuclide
Returns
an integer A-number.
int pyne::nucname::anum (int nuc)
 
int pyne::nucname::anum (const char *nuc)
 
int pyne::nucname::anum (std::string nuc)
 
S-Number Functions

The S-number, or excitation state number, represents the excitation level of a nuclide.

Normally, this is zero. This function returns that number.

Parameters
nuca nuclide
Returns
an integer A-number.
int pyne::nucname::snum (int nuc)
 
int pyne::nucname::snum (const char *nuc)
 
int pyne::nucname::snum (std::string nuc)
 
ZZAAAM Form Functions

The ZZAAAM nuclide naming convention is the former canonical form for nuclides in PyNE.

This places the charge of the nucleus out front, then has three digits for the atomic mass number, and ends with a metastable flag (0 = ground, 1 = first excited state, 2 = second excited state, etc). Uranium-235 here would be expressed as ‘922350’.

Parameters
nuca nuclide
Returns
an integer nuclide identifier.
int pyne::nucname::zzaaam (int nuc)
 
int pyne::nucname::zzaaam (const char *nuc)
 
int pyne::nucname::zzaaam (std::string nuc)
 
ZZAAAM Form to Identifier Form Functions

This converts from the ZZAAAM nuclide naming convention to the id canonical form for nuclides in PyNE.

Parameters
nuca nuclide in ZZAAAM form.
Returns
an integer id nuclide identifier.
int pyne::nucname::zzaaam_to_id (int nuc)
 
int pyne::nucname::zzaaam_to_id (const char *nuc)
 
int pyne::nucname::zzaaam_to_id (std::string nuc)
 
ZZZAAA Form Functions

The ZZZAAA nuclide naming convention is a form in which the nuclides three digit ZZZ number is followed by the 3 digit AAA number.

If the ZZZ number is 2 digits, the preceding zeros are not included. Uranium-235 here would be expressed as ‘92235’.

Parameters
nuca nuclide
Returns
an integer nuclide identifier.
int pyne::nucname::zzzaaa (int nuc)
 
int pyne::nucname::zzzaaa (const char *nuc)
 
int pyne::nucname::zzzaaa (std::string nuc)
 
ZZZAAA Form to Identifier Form Functions

This converts from the ZZZAAA nuclide naming convention to the id canonical form for nuclides in PyNE.

Parameters
nuca nuclide in ZZZAAA form.
Returns
an integer id nuclide identifier.
int pyne::nucname::zzzaaa_to_id (int nuc)
 
int pyne::nucname::zzzaaa_to_id (const char *nuc)
 
int pyne::nucname::zzzaaa_to_id (std::string nuc)
 
ZZLLAAAM Form Functions

The ZZLLAAAM nuclide naming convention is a form in which the nuclides AA number is followed by the redundant two LL characters, followed by the nuclides ZZZ number.

Can also be followed with a metastable flag. Uranium-235 here would be expressed as ‘92-U-235’.

Parameters
nuca nuclide
Returns
an integer nuclide identifier.
std::string pyne::nucname::zzllaaam (int nuc)
 
std::string pyne::nucname::zzllaaam (const char *nuc)
 
std::string pyne::nucname::zzllaaam (std::string nuc)
 
ZZLLAAAM Form to Identifier Form Functions

This converts from the ZZLLAAAM nuclide naming convention to the id canonical form for nuclides in PyNE.

Parameters
nuca nuclide in ZZLLAAAM form.
Returns
an integer id nuclide identifier.
int pyne::nucname::zzllaaam_to_id (const char *nuc)
 
int pyne::nucname::zzllaaam_to_id (std::string nuc)
 
MCNP Form Functions

This is the naming convention used by the MCNP suite of codes.

The MCNP format for entering nuclides is unfortunately non-standard. In most ways it is similar to zzaaam form, except that it lacks the metastable flag. For information on how metastable isotopes are named, please consult the MCNP documentation for more information.

Parameters
nuca nuclide
Returns
a string nuclide identifier.
int pyne::nucname::mcnp (int nuc)
 
int pyne::nucname::mcnp (const char *nuc)
 
int pyne::nucname::mcnp (std::string nuc)
 
MCNP Form to Identifier Form Functions

This converts from the MCNP nuclide naming convention to the id canonical form for nuclides in PyNE.

Parameters
nuca nuclide in MCNP form.
Returns
an integer id nuclide identifier.
int pyne::nucname::mcnp_to_id (int nuc)
 
int pyne::nucname::mcnp_to_id (const char *nuc)
 
int pyne::nucname::mcnp_to_id (std::string nuc)
 
FLUKA Form Functions

This is the naming convention used by the FLUKA suite of codes.

The FLUKA format for entering nuclides requires some knowledge of FLUKA The nuclide in must cases should be the atomic # times 10000000. The exceptions are for FLUKA's named isotopes See the FLUKA Manual for more information.

Parameters
nuca nuclide
Returns
the received FLUKA name
std::string pyne::nucname::fluka (int nuc)
 
FLUKA Form to Identifier Form Functions

This converts from the FLUKA name to the id canonical form for nuclides in PyNE.

Parameters
namea fluka name
Returns
an integer id nuclide identifier.
int pyne::nucname::fluka_to_id (std::string name)
 
int pyne::nucname::fluka_to_id (char *name)
 
Serpent Form Functions

This is the string-based naming convention used by the Serpent suite of codes.

The serpent naming convention is similar to name form. However, only the first letter in the chemical symbol is uppercase, the dash is always present, and the the meta-stable flag is lowercase. For instance, ‘Am-242m’ is the valid serpent notation for this nuclide.

Parameters
nuca nuclide
Returns
a string nuclide identifier.
std::string pyne::nucname::serpent (int nuc)
 
std::string pyne::nucname::serpent (const char *nuc)
 
std::string pyne::nucname::serpent (std::string nuc)
 
Serpent Form to Identifier Form Functions

This converts from the Serpent nuclide naming convention to the id canonical form for nuclides in PyNE.

Parameters
nuca nuclide in Serpent form.
Returns
an integer id nuclide identifier.
int pyne::nucname::serpent_to_id (const char *nuc)
 
int pyne::nucname::serpent_to_id (std::string nuc)
 
NIST Form Functions

This is the string-based naming convention used by NIST.

The NIST naming convention is also similar to the Serpent form. However, this convention contains no metastable information. Moreover, the A-number comes before the element symbol. For example, ‘242Am’ is the valid NIST notation.

Parameters
nuca nuclide
Returns
a string nuclide identifier.
std::string pyne::nucname::nist (int nuc)
 
std::string pyne::nucname::nist (const char *nuc)
 
std::string pyne::nucname::nist (std::string nuc)
 
NIST Form to Identifier Form Functions

This converts from the NIST nuclide naming convention to the id canonical form for nuclides in PyNE.

Parameters
nuca nuclide in NIST form.
Returns
an integer id nuclide identifier.
int pyne::nucname::nist_to_id (const char *nuc)
 
int pyne::nucname::nist_to_id (std::string nuc)
 
CINDER Form Functions

This is the naming convention used by the CINDER burnup library.

The CINDER format is similar to zzaaam form except that the placement of the Z- and A-numbers are swapped. Therefore, this format is effectively aaazzzm. For example, ‘2420951’ is the valid cinder notation for ‘AM242M’.

Parameters
nuca nuclide
Returns
a string nuclide identifier.
int pyne::nucname::cinder (int nuc)
 
int pyne::nucname::cinder (const char *nuc)
 
int pyne::nucname::cinder (std::string nuc)
 
Cinder Form to Identifier Form Functions

This converts from the Cinder nuclide naming convention to the id canonical form for nuclides in PyNE.

Parameters
nuca nuclide in Cinder form.
Returns
an integer id nuclide identifier.
int pyne::nucname::cinder_to_id (int nuc)
 
int pyne::nucname::cinder_to_id (const char *nuc)
 
int pyne::nucname::cinder_to_id (std::string nuc)
 
ALARA Form Functions

This is the format used in the ALARA activation code elements library.

For elements, the form is "ll" where ll is the atomic symbol. For isotopes the form is "ll:AAA". No metastable isotope flag is used.

Parameters
nuca nuclide
Returns
a string nuclide identifier.
std::string pyne::nucname::alara (int nuc)
 
std::string pyne::nucname::alara (const char *nuc)
 
std::string pyne::nucname::alara (std::string nuc)
 
ALARA Form to Identifier Form Functions

This converts from the ALARA nuclide naming convention to the id canonical form for nuclides in PyNE.

Parameters
nuca nuclide in ALARA form.
Returns
an integer id nuclide identifier.
int pyne::nucname::alara_to_id (const char *nuc)
 
int pyne::nucname::alara_to_id (std::string nuc)
 
SZA Form Functions

This is the new format for ACE data tables in the form SSSZZZAAA.

The first three digits represent the excited state (000 = ground, 001 = first excited state, 002 = second excited state, etc). The second three digits are the atomic number and the last three digits are the atomic mass. Prepending zeros can be omitted, making the SZA form equal to the MCNP form for non-excited nuclides.

Parameters
nuca nuclide
Returns
a string nuclide identifier.
int pyne::nucname::sza (int nuc)
 
int pyne::nucname::sza (const char *nuc)
 
int pyne::nucname::sza (std::string nuc)
 
SZA Form to Identifier Form Functions

This converts from the SZA nuclide naming convention to the id canonical form for nuclides in PyNE.

Parameters
nuca nuclide in SZA form.
Returns
an integer id nuclide identifier.
int pyne::nucname::sza_to_id (int nuc)
 
int pyne::nucname::sza_to_id (const char *nuc)
 
int pyne::nucname::sza_to_id (std::string nuc)
 
Ground State Form Functions

This form stores the nuclide in id form, but removes the state information about the nuclide.

I is in the same form as ID, but the four last digits are all zeros.

Parameters
nuca nuclide
Returns
a integer groundstate id
int pyne::nucname::groundstate (int nuc)
 
int pyne::nucname::groundstate (std::string nuc)
 
int pyne::nucname::groundstate (const char *nuc)
 
State Map functions

These convert from/to decay state ids (used in decay data) to metastable ids (the PyNE default)

void pyne::nucname::_load_state_map ()
 
int pyne::nucname::state_id_to_id (int state)
 
int pyne::nucname::id_to_state_id (int nuc_id)
 
ENSDF Form Functions

This converts id's stored using standard ensdf syntax to nuc_id's

Parameters
ensdfnuc string
Returns
PyNE nuc_id
int pyne::nucname::ensdf_to_id (const char *nuc)
 
int pyne::nucname::ensdf_to_id (std::string nuc)
 
Hash Functions

Custom hash function for reaction name to reaction ids.

This functions will not return a value less than 1000, effectively reserving space for the MT numbers.

unsigned int pyne::rxname::hash (std::string s)
 
unsigned int pyne::rxname::hash (const char *s)
 
Name Functions

Returns the canonical name of a reaction channel.

Parameters
nInteger input of possible reaction, nominally an id or MT number.
sString input of possible reaction, often a reaction or alternate name.
from_nucInitial target nuclide prior to reaction. When from_nuc is an integer it must be in id form.
to_nucTarget nuclide after reaction occurs. When to_nuc is an integer it must be in id form.
zFlag for incident particle type. Particle flags are 'n', 'p', 'd', 't', 'He3', 'a', 'gamma', and 'decay'.
std::string pyne::rxname::name (int n)
 
std::string pyne::rxname::name (unsigned int n)
 
std::string pyne::rxname::name (char *s)
 
std::string pyne::rxname::name (std::string s)
 
std::string pyne::rxname::name (int from_nuc, int to_nuc, std::string z="n")
 
std::string pyne::rxname::name (int from_nuc, std::string to_nuc, std::string z="n")
 
std::string pyne::rxname::name (std::string from_nuc, int to_nuc, std::string z="n")
 
std::string pyne::rxname::name (std::string from_nuc, std::string to_nuc, std::string z="n")
 
ID Functions

Returns the recation id of a reaction channel.

This id has been precomputed from the hash of the name.

Parameters
xInput reaction specification, may be a reaction name, alternate name, an id, or an MT number.
from_nucInitial target nuclide prior to reaction. When from_nuc is an integer it must be in id form.
to_nucTarget nuclide after reaction occurs. When to_nuc is an integer it must be in id form.
zFlag for incident particle type. Particle flags are 'n', 'p', 'd', 't', 'He3', 'a', 'gamma', and 'decay'.
unsigned int pyne::rxname::id (int x)
 
unsigned int pyne::rxname::id (unsigned int x)
 
unsigned int pyne::rxname::id (const char *x)
 
unsigned int pyne::rxname::id (std::string x)
 
unsigned int pyne::rxname::id (int from_nuc, int to_nuc, std::string z="n")
 
unsigned int pyne::rxname::id (int from_nuc, std::string to_nuc, std::string z="n")
 
unsigned int pyne::rxname::id (std::string from_nuc, int to_nuc, std::string z="n")
 
unsigned int pyne::rxname::id (std::string from_nuc, std::string to_nuc, std::string z="n")
 
MT Number Functions

Returns the MT number of a reaction channel, if available.

Parameters
xInput reaction specification, may be a reaction name, alternate name, an id, or an MT number.
from_nucInitial target nuclide prior to reaction. When from_nuc is an integer it must be in id form.
to_nucTarget nuclide after reaction occurs. When to_nuc is an integer it must be in id form.
zFlag for incident particle type. Particle flags are 'n', 'p', 'd', 't', 'He3', 'a', 'gamma', and 'decay'.
unsigned int pyne::rxname::mt (int x)
 
unsigned int pyne::rxname::mt (unsigned int x)
 
unsigned int pyne::rxname::mt (char *x)
 
unsigned int pyne::rxname::mt (std::string x)
 
unsigned int pyne::rxname::mt (int from_nuc, int to_nuc, std::string z="n")
 
unsigned int pyne::rxname::mt (int from_nuc, std::string to_nuc, std::string z="n")
 
unsigned int pyne::rxname::mt (std::string from_nuc, int to_nuc, std::string z="n")
 
unsigned int pyne::rxname::mt (std::string from_nuc, std::string to_nuc, std::string z="n")
 
Label Functions

Returns a short description of a reaction channel.

Parameters
xInput reaction specification, may be a reaction name, alternate name, an id, or an MT number.
from_nucInitial target nuclide prior to reaction. When from_nuc is an integer it must be in id form.
to_nucTarget nuclide after reaction occurs. When to_nuc is an integer it must be in id form.
zFlag for incident particle type. Particle flags are 'n', 'p', 'd', 't', 'He3', 'a', 'gamma', and 'decay'.
std::string pyne::rxname::label (int x)
 
std::string pyne::rxname::label (unsigned int x)
 
std::string pyne::rxname::label (char *x)
 
std::string pyne::rxname::label (std::string x)
 
std::string pyne::rxname::label (int from_nuc, int to_nuc, std::string z="n")
 
std::string pyne::rxname::label (int from_nuc, std::string to_nuc, std::string z="n")
 
std::string pyne::rxname::label (std::string from_nuc, int to_nuc, std::string z="n")
 
std::string pyne::rxname::label (std::string from_nuc, std::string to_nuc, std::string z="n")
 
Documentation Functions

Returns a short description of a reaction channel.

Parameters
xInput reaction specification, may be a reaction name, alternate name, an id, or an MT number.
from_nucInitial target nuclide prior to reaction. When from_nuc is an integer it must be in id form.
to_nucTarget nuclide after reaction occurs. When to_nuc is an integer it must be in id form.
zFlag for incident particle type. Particle flags are 'n', 'p', 'd', 't', 'He3', 'a', 'gamma', and 'decay'.
std::string pyne::rxname::doc (int x)
 
std::string pyne::rxname::doc (unsigned int x)
 
std::string pyne::rxname::doc (char *x)
 
std::string pyne::rxname::doc (std::string x)
 
std::string pyne::rxname::doc (int from_nuc, int to_nuc, std::string z="n")
 
std::string pyne::rxname::doc (int from_nuc, std::string to_nuc, std::string z="n")
 
std::string pyne::rxname::doc (std::string from_nuc, int to_nuc, std::string z="n")
 
std::string pyne::rxname::doc (std::string from_nuc, std::string to_nuc, std::string z="n")
 
Child Functions

Returns the child nuclide comming from a parent for a reaction channel.

Parameters
nucNuclide after reaction occurs. When nuc is an integer it must be in id form.
rxInput reaction specification, may be a reaction name, alternate name, an id, or an MT number.
zFlag for incident particle type. Particle flags are 'n', 'p', 'd', 't', 'He3', 'a', 'gamma', and 'decay'.
int pyne::rxname::parent (int nuc, unsigned int rx, std::string z="n")
 
int pyne::rxname::parent (int nuc, std::string rx, std::string z="n")
 
int pyne::rxname::parent (std::string nuc, unsigned int rx, std::string z="n")
 
int pyne::rxname::parent (std::string nuc, std::string rx, std::string z="n")
 
Parent Functions

Returns the parent nuclide comming for a child and a given reaction channel.

Parameters
nucInitial target nuclide prior to reaction. When nuc is an integer it must be in id form.
rxInput reaction specification, may be a reaction name, alternate name, an id, or an MT number.
zFlag for incident particle type. Particle flags are 'n', 'p', 'd', 't', 'He3', 'a', 'gamma', and 'decay'.
int pyne::rxname::child (int nuc, unsigned int rx, std::string z="n")
 
int pyne::rxname::child (int nuc, std::string rx, std::string z="n")
 
int pyne::rxname::child (std::string nuc, unsigned int rx, std::string z="n")
 
int pyne::rxname::child (std::string nuc, std::string rx, std::string z="n")
 
Cascade pyne::enrichment::solve_numeric (Cascade &orig_casc, double tolerance=1.0E-7, int max_iter=100)
 
void pyne::enrichment::_recompute_nm (Cascade &casc, double tolerance=1.0E-7)
 
void pyne::enrichment::_recompute_prod_tail_mats (Cascade &casc)
 
Cascade pyne::enrichment::_norm_comp_secant (Cascade &casc, double tolerance=1.0E-7, int max_iter=100)
 
double pyne::enrichment::_deltaU_i_OverG (Cascade &casc, int i)
 
Multicomponent Functions

Finds a value of Mstar by minimzing the seperative power.

Note that Mstar on orig_casc represents an intial guess at what Mstar might be. This is the final function that actually solves for an optimized M* that makes the cascade!

Parameters
orig_cascOriginal input cascade.
solverflag for solver to use, may be 'symbolic' or 'numeric'.
toleranceMaximum numerical error allowed in L/F, N, and M.
max_iterMaximum number of iterations for to perform.
Returns
A cascade whose N & M coorespond to the L/F value.
Cascade pyne::enrichment::multicomponent (Cascade &orig_casc, char *solver, double tolerance=1.0E-7, int max_iter=100)
 
Cascade pyne::enrichment::multicomponent (Cascade &orig_casc, std::string solver="symbolic", double tolerance=1.0E-7, int max_iter=100)
 

Variables

void * pyne::rxname::_ = pyne::rxname::_fill_maps()
 
std::string pyne::rxname::_names [NUM_RX_NAMES]
 
name_group pyne::nucname::ACT
 
zz_group pyne::nucname::act = pyne::nucname::name_to_zz_group(pyne::nucname::ACT)
 
name_t pyne::nucname::ACT_array [15]
 
static std::string pyne::alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 
std::map< std::string, unsigned int > pyne::rxname::altnames
 
std::map< int, double > pyne::atomic_mass_error_map
 
std::map< std::string, std::string > pyne::data_checksums
 
Cascade pyne::enrichment::default_uranium_cascade
 
static std::string pyne::digits = "0123456789"
 
std::map< unsigned int, std::string > pyne::rxname::docs
 
double(* pyne::endftod )(char *s) = &pyne::endftod_f
 
static int pyne::FLUKA_MAT_NUM = 37
 
static std::string pyne::fluka_mat_strings []
 
name_zz_t pyne::nucname::fluka_zz = pyne::nucname::get_fluka_zz()
 
name_group pyne::nucname::FP
 
zz_group pyne::nucname::fp
 
name_t pyne::nucname::FP_array [88]
 
std::map< unsigned int, unsigned int > pyne::rxname::id_mt
 
std::map< unsigned int, std::string > pyne::rxname::id_name
 
std::map< std::pair< std::string, unsigned int >, int > pyne::rxname::id_offset
 
std::map< unsigned int, std::string > pyne::rxname::labels
 
name_group pyne::nucname::LAN
 
zz_group pyne::nucname::lan
 
name_t pyne::nucname::LAN_array [15]
 
name_group pyne::nucname::MA
 
zz_group pyne::nucname::ma
 
name_t pyne::nucname::MA_array [10]
 
std::map< unsigned int, unsigned int > pyne::rxname::mt_id
 
std::map< std::string, unsigned int > pyne::rxname::name_id
 
name_zz_t pyne::nucname::name_zz = pyne::nucname::get_name_zz()
 
std::set< std::string > pyne::rxname::names
 
std::string pyne::NUC_DATA_PATH = ""
 
std::map< std::pair< std::string, int >, unsigned int > pyne::rxname::offset_id
 
std::string pyne::PYNE_DATA = ""
 
static hid_t h5wrap::PYTABLES_COMPLEX128 = _get_PYTABLES_COMPLEX128()
 
std::map< std::string, std::map< int, std::map< int, double > > > pyne::simple_xs_map
 
name_group pyne::nucname::TRU
 
zz_group pyne::nucname::tru
 
name_t pyne::nucname::TRU_array [22]
 
bool pyne::USE_WARNINGS = true
 
static std::string pyne::words = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_"
 
zzname_t pyne::nucname::zz_fluka = pyne::nucname::get_zz_fluka()
 
zzname_t pyne::nucname::zz_name = pyne::nucname::get_zz_name()
 
Mathematical and Physical Constants
const double pyne::pi = 3.14159265359
 
const double pyne::N_A = 6.0221415e+23
 
const double pyne::barns_per_cm2 = 1e24
 
const double pyne::cm2_per_barn = 1e-24
 
const double pyne::sec_per_day = 24.0 * 3600.0
 
const double pyne::MeV_per_K = 8.617343e-11
 
const double pyne::MeV_per_MJ = 6.2415096471204E+18
 
const double pyne::Bq_per_Ci = 3.7e10
 
const double pyne::Ci_per_Bq = 2.7027027e-11
 

Atomic Mass Data

typedef struct pyne::atomic_mass_data pyne::atomic_mass_data
 
std::map< int, double > pyne::atomic_mass_map = std::map<int, double>()
 
std::map< std::string, std::string > pyne::get_data_checksums ()
 
void pyne::_load_atomic_mass_map ()
 
double pyne::atomic_mass (int nuc)
 
double pyne::atomic_mass (char *nuc)
 
double pyne::atomic_mass (std::string nuc)
 

Natural Abundance Data

std::map< int, double > pyne::natural_abund_map = std::map<int, double>()
 
double pyne::natural_abund (int nuc)
 
double pyne::natural_abund (char *nuc)
 
double pyne::natural_abund (std::string nuc)
 

Q_value Data

typedef struct pyne::q_val_data pyne::q_val_data
 
std::map< int, double > pyne::q_val_map = std::map<int, double>()
 
std::map< int, double > pyne::gamma_frac_map = std::map<int, double>()
 
void pyne::_load_q_val_map ()
 
double pyne::q_val (int nuc)
 
double pyne::q_val (const char *nuc)
 
double pyne::q_val (std::string nuc)
 
double pyne::gamma_frac (int nuc)
 
double pyne::gamma_frac (const char *nuc)
 
double pyne::gamma_frac (std::string nuc)
 

Dose Factor Data

typedef struct pyne::dose pyne::dose
 
std::map< int, dose > pyne::epa_dose_map
 
std::map< int, dose > pyne::doe_dose_map
 
std::map< int, dose > pyne::genii_dose_map
 
void pyne::_load_dose_map (std::map< int, dose > &dm, std::string source_path)
 
double pyne::ext_air_dose (int nuc, int source)
 
double pyne::ext_air_dose (const char *nuc, int source)
 
double pyne::ext_air_dose (std::string nuc, int source)
 
double pyne::ext_soil_dose (int nuc, int source)
 
double pyne::ext_soil_dose (const char *nuc, int source)
 
double pyne::ext_soil_dose (std::string nuc, int source)
 
double pyne::ingest_dose (int nuc, int source)
 
double pyne::ingest_dose (const char *nuc, int source)
 
double pyne::ingest_dose (std::string nuc, int source)
 
double pyne::inhale_dose (int nuc, int source)
 
double pyne::inhale_dose (const char *nuc, int source)
 
double pyne::inhale_dose (std::string nuc, int source)
 
double pyne::dose_ratio (int nuc, int source)
 
double pyne::dose_ratio (const char *nuc, int source)
 
double pyne::dose_ratio (std::string nuc, int source)
 
double pyne::dose_fluid_frac (int nuc, int source)
 
double pyne::dose_fluid_frac (const char *nuc, int source)
 
double pyne::dose_fluid_frac (std::string nuc, int source)
 
std::string pyne::dose_lung_model (int nuc, int source)
 
std::string pyne::dose_lung_model (const char *nuc, int source)
 
std::string pyne::dose_lung_model (std::string nuc, int source)
 

Scattering Length Data

typedef struct pyne::scattering_lengths pyne::scattering_lengths
 
std::map< int, xd_complex_tpyne::b_coherent_map = std::map<int, xd_complex_t>()
 
std::map< int, xd_complex_tpyne::b_incoherent_map = std::map<int, xd_complex_t>()
 
std::map< int, double > pyne::b_map = std::map<int, double>()
 
void pyne::_load_scattering_lengths ()
 
xd_complex_t pyne::b_coherent (int nuc)
 
xd_complex_t pyne::b_coherent (char *nuc)
 
xd_complex_t pyne::b_coherent (std::string nuc)
 
xd_complex_t pyne::b_incoherent (int nuc)
 
xd_complex_t pyne::b_incoherent (char *nuc)
 
xd_complex_t pyne::b_incoherent (std::string nuc)
 
double pyne::b (int nuc)
 
double pyne::b (char *nuc)
 
double pyne::b (std::string nuc)
 

Fission Product Yield Data

typedef struct pyne::wimsdfpy pyne::wimsdfpy
 
typedef struct pyne::ndsfpy pyne::ndsfpy
 
typedef struct pyne::ndsfpysub pyne::ndsfpysub
 
std::map< std::pair< int, int >, double > pyne::wimsdfpy_data
 
std::map< std::pair< int, int >, ndsfpysub > pyne::ndsfpy_data
 
void pyne::_load_wimsdfpy ()
 
void pyne::_load_ndsfpy ()
 
double pyne::fpyield (std::pair< int, int > from_to, int source, bool get_error)
 
double pyne::fpyield (int from_nuc, int to_nuc, int source, bool get_error)
 
double pyne::fpyield (char *from_nuc, char *to_nuc, int source, bool get_error)
 
double pyne::fpyield (std::string from_nuc, std::string to_nuc, int source, bool get_error)
 

Decay Data

typedef struct pyne::atomic pyne::atomic
 
typedef struct pyne::level_data pyne::level_data
 
typedef struct pyne::decay pyne::decay
 
typedef struct pyne::gamma pyne::gamma
 
typedef struct pyne::alpha pyne::alpha
 
typedef struct pyne::beta pyne::beta
 
typedef struct pyne::ecbp pyne::ecbp
 
std::map< int, atomic > pyne::atomic_data_map
 
std::map< std::pair< int, double >, level_data > pyne::level_data_lvl_map
 
std::map< std::pair< int, unsigned int >, level_data > pyne::level_data_rx_map
 
std::map< std::pair< int, int >, decay > pyne::decay_data
 
std::map< std::pair< int, double >, gamma > pyne::gamma_data
 
std::map< std::pair< int, double >, alpha > pyne::alpha_data
 
std::map< std::pair< int, double >, beta > pyne::beta_data
 
std::map< std::pair< int, double >, ecbp > pyne::ecbp_data
 
template<typename T , typename U >
std::vector< T > pyne::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 > pyne::data_access (int parent, double min, double max, size_t valoffset, std::map< std::pair< int, double >, U > &data)
 
template<typename T , typename U >
pyne::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 > pyne::data_access (int parent, size_t valoffset, std::map< std::pair< int, int >, U > &data)
 
template<typename T , typename U >
std::vector< T > pyne::data_access (int parent, size_t valoffset, std::map< std::pair< int, unsigned int >, U > &data)
 
template<typename U >
double pyne::data_access (int parent, size_t valoffset, std::map< int, U > &data)
 
template<typename T >
void pyne::_load_data ()
 
template<>
void pyne::_load_data< atomic > ()
 
std::vector< std::pair< double, double > > pyne::calculate_xray_data (int z, double k_conv, double l_conv)
 
template<>
void pyne::_load_data< level_data > ()
 
int pyne::id_from_level (int nuc, double level)
 
int pyne::id_from_level (int nuc, double level, std::string special)
 
int pyne::metastable_id (int nuc, int m)
 
int pyne::metastable_id (int nuc)
 
double pyne::half_life (int nuc)
 
double pyne::half_life (char *nuc)
 
double pyne::half_life (std::string nuc)
 
double pyne::decay_const (int nuc)
 
double pyne::decay_const (char *nuc)
 
double pyne::decay_const (std::string nuc)
 
double pyne::branch_ratio (std::pair< int, int > from_to)
 
double pyne::branch_ratio (int from_nuc, int to_nuc)
 
double pyne::branch_ratio (char *from_nuc, char *to_nuc)
 
double pyne::branch_ratio (std::string from_nuc, std::string to_nuc)
 
double pyne::state_energy (int nuc)
 
double pyne::state_energy (char *nuc)
 
double pyne::state_energy (std::string nuc)
 
std::set< int > pyne::decay_children (int nuc)
 
std::set< int > pyne::decay_children (char *nuc)
 
std::set< int > pyne::decay_children (std::string nuc)
 
template<>
void pyne::_load_data< decay > ()
 
std::vector< int > pyne::decay_data_children (int parent)
 
std::pair< double, double > pyne::decay_half_life (std::pair< int, int >)
 
std::vector< std::pair< double, double > > pyne::decay_half_lifes (int)
 
std::pair< double, double > pyne::decay_branch_ratio (std::pair< int, int >)
 
std::vector< double > pyne::decay_branch_ratios (int parent)
 
std::pair< double, double > pyne::decay_photon_branch_ratio (std::pair< int, int >)
 
std::vector< std::pair< double, double > > pyne::decay_photon_branch_ratios (int parent)
 
std::pair< double, double > pyne::decay_beta_branch_ratio (std::pair< int, int >)
 
std::vector< std::pair< double, double > > pyne::decay_beta_branch_ratios (int parent)
 
template<>
void pyne::_load_data< gamma > ()
 
std::vector< std::pair< double, double > > pyne::gamma_energy (int parent)
 
std::vector< std::pair< double, double > > pyne::gamma_energy (double energy, double error)
 
std::vector< std::pair< double, double > > pyne::gamma_photon_intensity (int parent)
 
std::vector< std::pair< double, double > > pyne::gamma_photon_intensity (double energy, double error)
 
std::vector< std::pair< double, double > > pyne::gamma_conversion_intensity (int parent)
 
std::vector< std::pair< double, double > > pyne::gamma_total_intensity (int parent)
 
std::vector< std::pair< int, int > > pyne::gamma_from_to (int parent)
 
std::vector< std::pair< int, int > > pyne::gamma_from_to (double energy, double error)
 
std::vector< std::pair< int, int > > pyne::gamma_parent_child (double energy, double error)
 
std::vector< int > pyne::gamma_parent (double energy, double error)
 
std::vector< int > pyne::gamma_child (double energy, double error)
 
std::vector< int > pyne::gamma_child (int parent)
 
std::vector< std::pair< double, double > > pyne::gamma_xrays (int parent)
 
std::vector< std::pair< double, double > > pyne::gammas (int parent_state_id)
 
std::vector< std::pair< double, double > > pyne::alphas (int parent_state_id)
 
std::vector< std::pair< double, double > > pyne::betas (int parent_state_id)
 
std::vector< std::pair< double, double > > pyne::xrays (int parent)
 
template<>
void pyne::_load_data< alpha > ()
 
std::vector< double > pyne::alpha_energy (int parent)
 
std::vector< double > pyne::alpha_intensity (int parent)
 
std::vector< int > pyne::alpha_parent (double energy, double error)
 
std::vector< int > pyne::alpha_child (double energy, double error)
 
std::vector< int > pyne::alpha_child (int parent)
 
template<>
void pyne::_load_data< beta > ()
 
std::vector< double > pyne::beta_endpoint_energy (int parent)
 
std::vector< double > pyne::beta_average_energy (int parent)
 
std::vector< double > pyne::beta_intensity (int parent)
 
std::vector< int > pyne::beta_parent (double energy, double error)
 
std::vector< int > pyne::beta_child (double energy, double error)
 
std::vector< int > pyne::beta_child (int parent)
 
template<>
void pyne::_load_data< ecbp > ()
 
std::vector< double > pyne::ecbp_endpoint_energy (int parent)
 
std::vector< double > pyne::ecbp_average_energy (int parent)
 
std::vector< double > pyne::ec_intensity (int parent)
 
std::vector< double > pyne::bp_intensity (int parent)
 
std::vector< int > pyne::ecbp_parent (double energy, double error)
 
std::vector< int > pyne::ecbp_child (double energy, double error)
 
std::vector< int > pyne::ecbp_child (int parent)
 
std::vector< std::pair< double, double > > pyne::ecbp_xrays (int parent)
 

Macro Definition Documentation

#define _XDRESS_EXTRA_TYPES_

Definition at line 267 of file pyne.h.

#define CPPTL_JSON_FEATURES_H_INCLUDED

Definition at line 3050 of file pyne.h.

#define CPPTL_JSON_H_INCLUDED

Definition at line 3113 of file pyne.h.

#define CPPTL_JSON_READER_H_INCLUDED

Definition at line 4230 of file pyne.h.

#define isnan (   x)    __isnand((double)x)

Definition at line 102 of file pyne.h.

#define JSON_AMALGATED_H_INCLUDED

Json-cpp amalgated header (http://jsoncpp.sourceforge.net/).

It is intented to be used with #include <json.h>

Definition at line 2867 of file pyne.h.

#define JSON_API

If defined, indicates that the source file is amalgated to prevent private header inclusion.

Remarks: it is automatically defined in the generated amalgated header.

Definition at line 2666 of file pyne.h.

#define JSON_CONFIG_H_INCLUDED

Definition at line 2622 of file pyne.h.

#define JSON_FORWARD_AMALGATED_H_INCLUDED

Json-cpp amalgated forward header (http://jsoncpp.sourceforge.net/).

It is intented to be used with #include <json/json-forwards.h> This header provides forward declaration for all JsonCpp types.

Definition at line 2607 of file pyne.h.

#define JSON_FORWARDS_H_INCLUDED

Definition at line 2732 of file pyne.h.

#define JSON_HAS_INT64

Definition at line 2706 of file pyne.h.

#define JSON_IS_AMALGAMATION

Definition at line 110 of file pyne.h.

#define JSON_IS_AMALGATED

If defined, indicates that the source file is amalgated to prevent private header inclusion.

Definition at line 2870 of file pyne.h.

#define JSON_IS_AMALGATED

If defined, indicates that the source file is amalgated to prevent private header inclusion.

Definition at line 2870 of file pyne.h.

#define JSON_USE_EXCEPTION   1

If defined, indicates that json library is embedded in CppTL library.

If defined, indicates that json may leverage CppTL library If defined, indicates that cpptl vector based map should be used instead of std::map as Value container. If defined, indicates that Json specific container should be used (hash table & simple deque container with customizable allocator). THIS FEATURE IS STILL EXPERIMENTAL! There is know bugs: See #3177332 Force usage of standard new/malloc based allocator instead of memory pool based allocator. The memory pools allocator used optimization (initializing Value and ValueInternalLink as if it was a POD) that may cause some validation tool to report errors. Only has effects if JSON_VALUE_USE_INTERNAL_MAP is defined. If defined, indicates that Json use exception to report invalid type manipulation instead of C assert macro.

Definition at line 2644 of file pyne.h.

#define JSON_WRITER_H_INCLUDED

Definition at line 4458 of file pyne.h.

#define JSONCPP_DEPRECATED (   message)

Definition at line 2685 of file pyne.h.

#define NUM_RX_NAMES   572

Number of reactions supported by default.

Definition at line 1419 of file pyne.h.

#define PYNE_3QGDWZMLZBHDHI424JL52SQHN4

A container representing enrichment cascades.

Definition at line 5133 of file pyne.h.

#define PYNE_46Z7LQYFI5HZNASIPCWHVX3X5E

Definition at line 4681 of file pyne.h.

#define PYNE_7DOEB2PKSBEFFIA3Q2NARI3KFY

Converts between naming conventions for reaction channels.

Definition at line 1403 of file pyne.h.

#define PYNE_B3ANNCKDQ5HEJLI33RPZPDNX6A

Definition at line 5209 of file pyne.h.

#define PYNE_D35WIXV5DZAA5LLOWBY2BL2DPA

Converts between naming conventions for nuclides.

Definition at line 790 of file pyne.h.

#define PYNE_IS_AMALGAMATED

Definition at line 24 of file pyne.h.

#define PYNE_KMMHYNANYFF5BFMEYIP7TUNLHA

This is the base PyNE library.

It contains a lot of utility functions and constants that are globaly useful through out the rest of the PyNE infrastructure.

Definition at line 80 of file pyne.h.

#define PYNE_MR34UE5INRGMZK2QYRDWICFHVM

The ever-important material class and related helpers.

The material class is effectively a normalized nuclide linked list with associated mass, density, atoms per mol, and metadata. However, this implementation also contains other functions for mixing materials and generating related materials.

Definition at line 4748 of file pyne.h.

#define PYNE_MRNAFG5GNZDNPCRPX3UCBZ5MFE

Definition at line 337 of file pyne.h.

#define PYNE_OU4PO4TJDBDM5PY4VKAVL7JCSM

Definition at line 5384 of file pyne.h.

#define PYNE_TEWK4A7VOFFLHDDXD5ZZ7KPXEQ

Definition at line 1809 of file pyne.h.