|
CYCLUS
|
Classes | |
| class | IndeterminateNuclideForm |
| class | NotANuclide |
Typedefs | |
| typedef std::set< name_t > | name_group |
| typedef name_group::iterator | name_group_iter |
| typedef std::string | name_t |
| typedef name_zz_t::iterator | name_zz_iter |
| typedef std::map< name_t, zz_t > | name_zz_t |
| typedef std::set< zz_t > | zz_group |
| typedef zz_group::iterator | zz_group_iter |
| typedef int | zz_t |
| typedef zzname_t::iterator | zzname_iter |
| typedef std::map< zz_t, name_t > | zzname_t |
Functions | |||
| name_zz_t | get_fluka_zz () | ||
| name_zz_t | get_name_zz () | ||
| zzname_t | get_zz_fluka () | ||
| zzname_t | get_zz_name () | ||
| zz_group | name_to_zz_group (name_group eg) | ||
isnuclide functions | |||
These functions test if an input nuc is a valid nuclide.
| |||
| bool | isnuclide (std::string nuc) | ||
| bool | isnuclide (const char *nuc) | ||
| bool | isnuclide (int nuc) | ||
iselement functions | |||
These functions test if an input nuc is a valid element.
| |||
| bool | iselement (std::string nuc) | ||
| bool | iselement (const char *nuc) | ||
| bool | 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:
| |||
| int | id (int nuc) | ||
| int | id (const char *nuc) | ||
| int | 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.
| |||
| std::string | name (int nuc) | ||
| std::string | name (const char *nuc) | ||
| std::string | 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.
| |||
| int | znum (int nuc) | ||
| int | znum (const char *nuc) | ||
| int | 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.
| |||
| int | anum (int nuc) | ||
| int | anum (const char *nuc) | ||
| int | 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.
| |||
| int | snum (int nuc) | ||
| int | snum (const char *nuc) | ||
| int | 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’.
| |||
| int | zzaaam (int nuc) | ||
| int | zzaaam (const char *nuc) | ||
| int | 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.
| |||
| int | zzaaam_to_id (int nuc) | ||
| int | zzaaam_to_id (const char *nuc) | ||
| int | 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’.
| |||
| int | zzzaaa (int nuc) | ||
| int | zzzaaa (const char *nuc) | ||
| int | 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.
| |||
| int | zzzaaa_to_id (int nuc) | ||
| int | zzzaaa_to_id (const char *nuc) | ||
| int | 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’.
| |||
| std::string | zzllaaam (int nuc) | ||
| std::string | zzllaaam (const char *nuc) | ||
| std::string | 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.
| |||
| int | zzllaaam_to_id (const char *nuc) | ||
| int | 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.
| |||
| int | mcnp (int nuc) | ||
| int | mcnp (const char *nuc) | ||
| int | 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.
| |||
| int | mcnp_to_id (int nuc) | ||
| int | mcnp_to_id (const char *nuc) | ||
| int | 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.
| |||
| std::string | fluka (int nuc) | ||
FLUKA Form to Identifier Form Functions | |||
This converts from the FLUKA name to the id canonical form for nuclides in PyNE.
| |||
| int | fluka_to_id (std::string name) | ||
| int | 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.
| |||
| std::string | serpent (int nuc) | ||
| std::string | serpent (const char *nuc) | ||
| std::string | 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.
| |||
| int | serpent_to_id (const char *nuc) | ||
| int | 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.
| |||
| std::string | nist (int nuc) | ||
| std::string | nist (const char *nuc) | ||
| std::string | 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.
| |||
| int | nist_to_id (const char *nuc) | ||
| int | 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’.
| |||
| int | cinder (int nuc) | ||
| int | cinder (const char *nuc) | ||
| int | 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.
| |||
| int | cinder_to_id (int nuc) | ||
| int | cinder_to_id (const char *nuc) | ||
| int | 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.
| |||
| std::string | alara (int nuc) | ||
| std::string | alara (const char *nuc) | ||
| std::string | 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.
| |||
| int | alara_to_id (const char *nuc) | ||
| int | 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.
| |||
| int | sza (int nuc) | ||
| int | sza (const char *nuc) | ||
| int | 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.
| |||
| int | sza_to_id (int nuc) | ||
| int | sza_to_id (const char *nuc) | ||
| int | 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.
| |||
| int | groundstate (int nuc) | ||
| int | groundstate (std::string nuc) | ||
| int | groundstate (const char *nuc) | ||
ENSDF Form Functions | |||
This converts id's stored using standard ensdf syntax to nuc_id's
| |||
| int | ensdf_to_id (const char *nuc) | ||
| int | ensdf_to_id (std::string nuc) | ||
State Map functions | |
These convert from/to decay state ids (used in decay data) to metastable ids (the PyNE default) | |
| std::map< int, int > | state_id_map |
| void | _load_state_map () |
| int | state_id_to_id (int state) |
| int | id_to_state_id (int nuc_id) |
Nuclide naming conventions.
| 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 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 |
| pyne::nucname::name_zz_t pyne::nucname::get_fluka_zz | ( | ) |
| pyne::nucname::name_zz_t pyne::nucname::get_name_zz | ( | ) |
| pyne::nucname::zzname_t pyne::nucname::get_zz_fluka | ( | ) |
| pyne::nucname::zzname_t pyne::nucname::get_zz_name | ( | ) |
| pyne::nucname::zz_group pyne::nucname::name_to_zz_group | ( | name_group | eg | ) |
| pyne::nucname::name_group pyne::nucname::ACT |
actinide name group
| pyne::nucname::zz_group pyne::nucname::act = pyne::nucname::name_to_zz_group(pyne::nucname::ACT) |
| pyne::nucname::name_t pyne::nucname::ACT_array |
| pyne::nucname::name_zz_t pyne::nucname::fluka_zz = pyne::nucname::get_fluka_zz() |
| pyne::nucname::name_group pyne::nucname::FP |
fission product name group
| pyne::nucname::zz_group pyne::nucname::fp |
fission product Z number group
| pyne::nucname::name_t pyne::nucname::FP_array |
array of fission product names
| pyne::nucname::name_group pyne::nucname::LAN |
lanthanide name group
| pyne::nucname::zz_group pyne::nucname::lan |
lanthanide Z number group
| pyne::nucname::name_t pyne::nucname::LAN_array |
| pyne::nucname::name_group pyne::nucname::MA |
minor actinide name group
| pyne::nucname::zz_group pyne::nucname::ma |
minor actinide Z number group
| pyne::nucname::name_t pyne::nucname::MA_array |
| int pyne::nucname::map_metastable[TOTAL_STATE_MAPS] |
| int pyne::nucname::map_nuc_ids[TOTAL_STATE_MAPS] |
| pyne::nucname::name_zz_t pyne::nucname::name_zz = pyne::nucname::get_name_zz() |
| pyne::nucname::name_group pyne::nucname::TRU |
transuranic name group
| pyne::nucname::zz_group pyne::nucname::tru |
transuranic Z number group
| pyne::nucname::name_t pyne::nucname::TRU_array |
| pyne::nucname::zzname_t pyne::nucname::zz_fluka = pyne::nucname::get_zz_fluka() |
| pyne::nucname::zzname_t pyne::nucname::zz_name = pyne::nucname::get_zz_name() |
1.8.13