def test_isnuclide():
are = [922350, "U235"]
arent = ["U3", -30060000]
for nuc in are:
yield assert_true, nucname.isnuclide(nuc)
for nuc in arent:
yield assert_false, nucname.isnuclide(nuc)
def test_isnuclide():
are = [922350, "U235"]
arent = ["U3", -30060000]
for nuc in are:
yield assert_true, nucname.isnuclide(nuc)
for nuc in arent:
yield assert_false, nucname.isnuclide(nuc)
def test_isnuclide():
are = [922350, 'U235']
arent = ['U3', -30060000]
for nuc in are:
yield assert_true, nucname.isnuclide(nuc)
for nuc in arent:
yield assert_false, nucname.isnuclide(nuc)
def test_isnuclide():
are = [922350, 'U235']
arent = ['U3', -30060000]
for nuc in are:
yield assert_true, nucname.isnuclide(nuc)
for nuc in arent:
yield assert_false, nucname.isnuclide(nuc)
def _is_data(line):
"""
This function is used to check whether a line of alara output file contains
wanted data. The line contains data is conposed of:
- nuc : nuc name (total or total)
- data for each decay time (including 'shutdown': floats
Parameters
----------
line : string
A line from ALARA output.txt
Returns
-------
True : if this line contains results data
False : if this line doesn't contain results data
"""
# check the list from the second value, if they are float, then return True
tokens = line.strip().split()
if len(tokens) < 2:
return False
# first block should be a valid nucname or 'total'
if not (nucname.isnuclide(tokens[0]) or tokens[0] == "TOTAL".lower()):
return False
try:
np.array(tokens[1:]).astype(float)
return True
except:
return False
def __add_recipe(self,constraints,root):
for constraint in constraints:
if nucname.isnuclide(constraint[0]):
eliso = etree.SubElement(root,"isotope")
elid = etree.SubElement(eliso,"id")
elid.text = self.__get_nuclide(constraint[0])
elval = etree.SubElement(eliso,"comp")
elval.text = str(constraint[1])
def __init__(
self,
alias=None,
awr=None,
location=None,
metastable=None,
name=None,
path=None,
temperature=None,
zaid=None,
cross_sections_path=None,
):
"""Parameters
----------
alias : str, optional
ace_table attribute.
awr : str, optional
ace_table attribute.
location : str, optional
ace_table attribute.
metastable : str, optional
ace_table attribute.
name : str, optional
ace_table attribute.
path : str, optional
ace_table attribute.
temperature : str, optional
ace_table attribute.
zaid : str, optional
ace_table attribute. If set or non-zero then the nucid attribute
will be set.
cross_sections_path : str, optional
If this and path are both present then the abspath attribute will be
set.
"""
super(AceTable, self).__init__()
nuc = None
if zaid is not None or zaid != "0":
meta = "0" if metastable is None else metastable
nuc = nucname.zzaaam_to_id(zaid + meta)
if nuc == 0:
pass
elif not nucname.isnuclide(
nuc): # then it's in MCNP metastable form
nuc = nucname.mcnp_to_id(zaid)
self.nucid = nuc
abspath = None
if path is not None and cross_sections_path is not None:
if os.path.isdir(cross_sections_path):
d = cross_sections_path
else:
d = os.path.dirname(cross_sections_path)
abspath = os.path.abspath(os.path.join(d, path))
self.abspath = abspath
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 __init__(self, alias=None, awr=None, location=None, metastable=None,
name=None, path=None, temperature=None, zaid=None,
cross_sections_path=None):
"""Parameters
----------
alias : str, optional
ace_table attribute.
awr : str, optional
ace_table attribute.
location : str, optional
ace_table attribute.
metastable : str, optional
ace_table attribute.
name : str, optional
ace_table attribute.
path : str, optional
ace_table attribute.
temperature : str, optional
ace_table attribute.
zaid : str, optional
ace_table attribute. If set or non-zero then the nucid attribute
will be set.
cross_sections_path : str, optional
If this and path are both present then the abspath attribute will be
set.
"""
super(AceTable, self).__init__()
nuc = None
if zaid is not None or zaid != '0':
meta = "0" if metastable is None else metastable
nuc = nucname.zzaaam_to_id(zaid + meta)
if nuc == 0:
pass
elif not nucname.isnuclide(nuc): # then it's in MCNP metastable form
nuc = nucname.mcnp_to_id(zaid)
self.nucid = nuc
abspath = None
if path is not None and cross_sections_path is not None:
if os.path.isdir(cross_sections_path):
d = cross_sections_path
else:
d = os.path.dirname(cross_sections_path)
abspath = os.path.abspath(os.path.join(d, path))
self.abspath = abspath
def make_energy_injection_model(cutoff_em_energy=20*u.keV, **kwargs):
"""
Make a bolometric lightcurve model
:param kwargs:
:return:
"""
class_dict = {}
class_dict['__init__'] = BaseEnergyInjection.__init__
#class_dict['evaluate'] = BaseBolometricLightCurve.evaluate_specific
init_kwargs = {}
for isotope_name in kwargs:
if not nucname.isnuclide(isotope_name):
raise ValueError('{0} is not a nuclide name')
class_dict[isotope_name.lower()] = Parameter()
init_kwargs[isotope_name.lower()] = kwargs[isotope_name]
EnergyInjection = type('EnergyInjection',
(BaseEnergyInjection,), class_dict)
return EnergyInjection(cutoff_em_energy, **init_kwargs)
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)
