def test_iselement_U235():
are = [92, "U"]
arent = [922350, "U235"]
for nuc in are:
yield assert_true, nucname.iselement(nuc)
for nuc in arent:
yield assert_false, nucname.iselement(nuc)
def test_iselement_H1():
are = [1, "H"]
arent = [1001, "H1"]
for nuc in are:
yield assert_true, nucname.iselement(nuc)
for nuc in arent:
yield assert_false, nucname.iselement(nuc)
def test_iselement():
are = [92, 'U']
arent = [922350, 'U235']
for nuc in are:
yield assert_true, nucname.iselement(nuc)
for nuc in arent:
yield assert_false, nucname.iselement(nuc)
def test_iselement():
are = [92, 'U']
arent = [922350, 'U235']
for nuc in are:
yield assert_true, nucname.iselement(nuc)
for nuc in arent:
yield assert_false, nucname.iselement(nuc)
def parse_csv_abundances(csvy_data):
"""
A parser for the csv data part of a csvy model file. This function filters out columns that are not abundances.
Parameters
----------
csvy_data : pandas.DataFrame
Returns
-------
index : ~np.ndarray
abundances : ~pandas.DataFrame
isotope_abundance : ~pandas.MultiIndex
"""
abundance_col_names = [
name for name in csvy_data.columns
if nucname.iselement(name) or nucname.isnuclide(name)
]
df = csvy_data.loc[:, abundance_col_names]
df = df.transpose()
abundance = pd.DataFrame(
columns=np.arange(df.shape[1]),
index=pd.Index([], name="atomic_number"),
dtype=np.float64,
)
isotope_index = pd.MultiIndex([[]] * 2, [[]] * 2,
names=["atomic_number", "mass_number"])
isotope_abundance = pd.DataFrame(columns=np.arange(df.shape[1]),
index=isotope_index,
dtype=np.float64)
for element_symbol_string in df.index[0:]:
if element_symbol_string in nucname.name_zz:
z = nucname.name_zz[element_symbol_string]
abundance.loc[z, :] = df.loc[element_symbol_string].tolist()
else:
z = nucname.znum(element_symbol_string)
mass_no = nucname.anum(element_symbol_string)
isotope_abundance.loc[(
z, mass_no), :] = df.loc[element_symbol_string].tolist()
return abundance.index, abundance, isotope_abundance
def from_csvy(cls, config):
"""
Create a new Radial1DModel instance from a Configuration object.
Parameters
----------
config : tardis.io.config_reader.Configuration
Returns
-------
Radial1DModel
"""
CSVY_SUPPORTED_COLUMNS = {
'velocity', 'density', 't_rad', 'dilution_factor'
}
if os.path.isabs(config.csvy_model):
csvy_model_fname = config.csvy_model
else:
csvy_model_fname = os.path.join(config.config_dirname,
config.csvy_model)
csvy_model_config, csvy_model_data = load_csvy(csvy_model_fname)
base_dir = os.path.abspath(os.path.dirname(__file__))
schema_dir = os.path.join(base_dir, '..', 'io', 'schemas')
csvy_schema_file = os.path.join(schema_dir, 'csvy_model.yml')
csvy_model_config = Configuration(
validate_dict(csvy_model_config, schemapath=csvy_schema_file))
if hasattr(csvy_model_data, 'columns'):
abund_names = set([
name for name in csvy_model_data.columns
if nucname.iselement(name) or nucname.isnuclide(name)
])
unsupported_columns = set(
csvy_model_data.columns) - abund_names - CSVY_SUPPORTED_COLUMNS
field_names = set(
[field['name'] for field in csvy_model_config.datatype.fields])
assert set(csvy_model_data.columns) - field_names == set(),\
'CSVY columns exist without field descriptions'
assert field_names - set(csvy_model_data.columns) == set(),\
'CSVY field descriptions exist without corresponding csv data'
if unsupported_columns != set():
logger.warning(
"The following columns are specified in the csvy"
"model file, but are IGNORED by TARDIS: %s" %
(str(unsupported_columns)))
time_explosion = config.supernova.time_explosion.cgs
electron_densities = None
temperature = None
#if hasattr(csvy_model_config, 'v_inner_boundary'):
# v_boundary_inner = csvy_model_config.v_inner_boundary
#else:
# v_boundary_inner = None
#if hasattr(csvy_model_config, 'v_outer_boundary'):
# v_boundary_outer = csvy_model_config.v_outer_boundary
#else:
# v_boundary_outer = None
if hasattr(config, 'model'):
if hasattr(config.model, 'v_inner_boundary'):
v_boundary_inner = config.model.v_inner_boundary
else:
v_boundary_inner = None
if hasattr(config.model, 'v_outer_boundary'):
v_boundary_outer = config.model.v_outer_boundary
else:
v_boundary_outer = None
else:
v_boundary_inner = None
v_boundary_outer = None
if hasattr(csvy_model_config, 'velocity'):
velocity = quantity_linspace(csvy_model_config.velocity.start,
csvy_model_config.velocity.stop,
csvy_model_config.velocity.num +
1).cgs
else:
velocity_field_index = [
field['name'] for field in csvy_model_config.datatype.fields
].index('velocity')
velocity_unit = u.Unit(
csvy_model_config.datatype.fields[velocity_field_index]
['unit'])
velocity = csvy_model_data['velocity'].values * velocity_unit
velocity = velocity.to('cm/s')
if hasattr(csvy_model_config, 'density'):
homologous_density = HomologousDensity.from_csvy(
config, csvy_model_config)
else:
time_0 = csvy_model_config.model_density_time_0
density_field_index = [
field['name'] for field in csvy_model_config.datatype.fields
].index('density')
density_unit = u.Unit(
csvy_model_config.datatype.fields[density_field_index]['unit'])
density_0 = csvy_model_data['density'].values * density_unit
density_0 = density_0.to('g/cm^3')[1:]
density_0 = density_0.insert(0, 0)
homologous_density = HomologousDensity(density_0, time_0)
no_of_shells = len(velocity) - 1
# TODO -- implement t_radiative
#t_radiative = None
if temperature:
t_radiative = temperature
elif hasattr(csvy_model_data, 'columns'):
if 't_rad' in csvy_model_data.columns:
t_rad_field_index = [
field['name']
for field in csvy_model_config.datatype.fields
].index('t_rad')
t_rad_unit = u.Unit(
csvy_model_config.datatype.fields[t_rad_field_index]
['unit'])
t_radiative = csvy_model_data['t_rad'].iloc[
0:].values * t_rad_unit
else:
t_radiative = None
dilution_factor = None
if hasattr(csvy_model_data, 'columns'):
if 'dilution_factor' in csvy_model_data.columns:
dilution_factor = csvy_model_data['dilution_factor'].iloc[
0:].to_numpy()
elif config.plasma.initial_t_rad > 0 * u.K:
t_radiative = np.ones(no_of_shells) * config.plasma.initial_t_rad
else:
t_radiative = None
if config.plasma.initial_t_inner < 0.0 * u.K:
luminosity_requested = config.supernova.luminosity_requested
t_inner = None
else:
luminosity_requested = None
t_inner = config.plasma.initial_t_inner
if hasattr(csvy_model_config, 'abundance'):
abundances_section = csvy_model_config.abundance
abundance, isotope_abundance = read_uniform_abundances(
abundances_section, no_of_shells)
else:
index, abundance, isotope_abundance = parse_csv_abundances(
csvy_model_data)
abundance = abundance.replace(np.nan, 0.0)
abundance = abundance[abundance.sum(axis=1) > 0]
abundance = abundance.loc[:, 1:]
abundance.columns = np.arange(abundance.shape[1])
norm_factor = abundance.sum(axis=0) + isotope_abundance.sum(axis=0)
if np.any(np.abs(norm_factor - 1) > 1e-12):
logger.warning("Abundances have not been normalized to 1."
" - normalizing")
abundance /= norm_factor
isotope_abundance /= norm_factor
#isotope_abundance = IsotopeAbundances(isotope_abundance)
isotope_abundance = IsotopeAbundances(
isotope_abundance, time_0=csvy_model_config.model_isotope_time_0)
#isotope_abundance.time_0 = csvy_model_config.model_isotope_time_0
return cls(velocity=velocity,
homologous_density=homologous_density,
abundance=abundance,
isotope_abundance=isotope_abundance,
time_explosion=time_explosion,
t_radiative=t_radiative,
t_inner=t_inner,
luminosity_requested=luminosity_requested,
dilution_factor=dilution_factor,
v_boundary_inner=v_boundary_inner,
v_boundary_outer=v_boundary_outer,
electron_densities=electron_densities)
def tape9_to_sparse(tape9s,
phi,
format='csr',
decaylib='decay.lib',
include_fission=True,
alpha_as_He4=False):
"""Converts a TAPE9 file to a sparse matrix.
Parameters
----------
tape9s : str or list of str
The filename(s) of the tape file(s).
phi : float
The neutron flux in [n / cm^2 / sec]
format : str, optional
Format of the sparse matrix created.
decaylib : str, optional
A path to TAPE9 containg the decay data libraries if the decay libraries
are not present in tape9. If this is a relative path, it is taken
relative to the given tape9 location.
include_fission : bool
Flag for whether or not the fission data should be included in the
resultant matrix.
Returns
-------
mat : scipy.sparse matrix
A sparse matrix in the specified layout.
nucs : list
The list of nuclide names in canonical order.
"""
all_decays_consts, all_gammas, all_sigma_ij, all_sigma_fission, all_fission_product_yields = [], [], [], [], []
all_alpha_ij, all_gamma_alphas = [], []
nucs = set()
mats = []
# seed initial nucs with known atomic masses
data.atomic_mass('u235')
for tape9 in tape9s:
print("Getting data for", tape9)
t9 = parse_tape9(tape9)
decay = find_decaylib(t9, tape9, decaylib)
for i in data.atomic_mass_map.keys():
if nucname.iselement(i):
continue
try:
nucs.add(nucname.name(i))
except RuntimeError:
pass
# get the tape 9 data
nucs, decays_consts, gammas, gammas_alphas = decay_data(decay,
nucs=nucs)
nucs, sigma_ij, sigma_fission, fission_product_yields, alpha_ij = cross_section_data(
t9, nucs=nucs)
if not include_fission:
sigma_fission = {}
fission_product_yields = {}
if not alpha_as_He4:
gammas_alphas = {}
alpha_ij = {}
all_decays_consts.append(decays_consts)
all_gammas.append(gammas)
all_sigma_ij.append(sigma_ij)
all_sigma_fission.append(sigma_fission)
all_fission_product_yields.append(fission_product_yields)
all_alpha_ij.append(alpha_ij)
all_gamma_alphas.append(gammas_alphas)
nucs = sort_nucs(nucs)
for i in range(len(tape9s)):
dok = create_dok(phi, nucs, all_decays_consts[i], all_gammas[i],
all_sigma_ij[i], all_sigma_fission[i],
all_fission_product_yields[i], all_alpha_ij[i],
all_gamma_alphas[i])
rows, cols, vals, shape = dok_to_sparse_info(nucs, dok)
mats.append(SPMAT_FORMATS[format]((vals, (rows, cols)), shape=shape))
return mats, nucs
