def init_reso_from_tb(range_tb_df, e_step, database):
v_1 = range_tb_df[energy_name][0]
v_2 = range_tb_df[energy_name][1]
if v_1 < v_2:
o_reso = Resonance(energy_min=v_1,
energy_max=v_2,
energy_step=e_step,
database=database)
else:
o_reso = Resonance(energy_min=v_2,
energy_max=v_1,
energy_step=e_step,
database=database)
return o_reso
def test_get_atoms_per_cm3_of_layer(self):
"""assert get_atoms_per_cm3_of_layer works"""
_stack = {
'CoAg': {
'elements': ['Co', 'Ag'],
'stoichiometric_ratio': [1, 1],
'thickness': {
'value': 0.025,
'units': 'mm'
},
'density': {
'value': 9.8,
'units': 'g/cm3'
},
},
'Ag': {
'elements': ['Ag'],
'stoichiometric_ratio': [1],
'thickness': {
'value': 0.03,
'units': 'mm'
},
},
}
o_reso = Resonance(stack=_stack, database=self.database)
_stack_returned = o_reso.stack
_molar_mass, _atoms_per_cm3 = get_atoms_per_cm3_of_layer(
compound_dict=_stack['CoAg'])
self.assertAlmostEqual(_atoms_per_cm3, 3.5381585765227397e+22, delta=1)
def test_element_metadata_via_stack_initialization(self):
"""assert __element_metadata is correctly populated using stack initialization"""
_stack = {
'CoAg': {
'elements': ['Co', 'Ag'],
'stoichiometric_ratio': [1, 2],
'thickness': {
'value': 0.025,
'units': 'mm'
},
},
'Ag': {
'elements': ['Ag'],
'stoichiometric_ratio': [1],
'thickness': {
'value': 0.03,
'units': 'mm'
},
},
}
o_reso = Resonance(stack=_stack, database=self.database)
# molar mass
stack = o_reso.stack
co_mass_expected = 58.9332
ag_mass_expected = 107.8682
self.assertEqual(co_mass_expected,
stack['CoAg']['Co']['molar_mass']['value'])
self.assertEqual(ag_mass_expected,
stack['Ag']['Ag']['molar_mass']['value'])
def __init__(self, energy_min=1e-5, energy_max=1000, energy_step=0.01, database='ENDF_VIII'):
"""
initialize the a Simulation() using the Resonance() in ImagingReso
:param energy_min:
:type energy_min:
:param energy_max:
:type energy_max:
:param energy_step:
:type energy_step:
:param database:
:type database:
"""
self.energy_min = energy_min
self.energy_max = energy_max
self.energy_step = energy_step
self.database = database
self.o_reso = Resonance(energy_min=energy_min,
energy_max=energy_max,
energy_step=energy_step,
database=database)
self.neutron_pulse = None
self.layer_list = []
self.layer = fit_util.Layer()
self.x_tof_us = None
self.y_att = None
def test_initialization_of_object(self):
"""assert object is correctly initialized with energy min, max and step"""
_stack = {
'CoAg': {
'elements': ['Co', 'Ag'],
'stoichiometric_ratio': [1, 2],
'thickness': {
'value': 0.025,
'units': 'mm'
},
},
'Ag': {
'elements': ['Ag'],
'stoichiometric_ratio': [1],
'thickness': {
'value': 0.03,
'units': 'mm'
},
},
}
energy_min = 10
energy_max = 150
energy_step = 1
o_reso = Resonance(stack=_stack,
energy_max=energy_max,
energy_min=energy_min,
energy_step=energy_step,
database=self.database)
self.assertEqual(o_reso.energy_max, energy_max)
self.assertEqual(o_reso.energy_min, energy_min)
self.assertEqual(o_reso.energy_step, energy_step)
def test_repr(self):
"""assert object works"""
_stack = {
'CoAg': {
'elements': ['Co', 'Ag'],
'stoichiometric_ratio': [1, 2],
'thickness': {
'value': 0.025,
'units': 'mm'
},
},
'Ag': {
'elements': ['Ag'],
'stoichiometric_ratio': [1],
'thickness': {
'value': 0.03,
'units': 'mm'
},
},
}
energy_min = 10
energy_max = 150
energy_step = 1
o_reso = Resonance(stack=_stack,
energy_max=energy_max,
energy_min=energy_min,
energy_step=energy_step,
database=self.database)
self.assertIsInstance(o_reso.__repr__(), str)
def setUp(self):
_stack = {
'CoAg': {
'elements': ['Co', 'Ag'],
'stoichiometric_ratio': [1, 2],
'thickness': {
'value': 0.025,
'units': 'mm'
},
'density': {
'value': np.NaN,
'units': 'g/cm3'
},
},
'U': {
'elements': ['U'],
'stoichiometric_ratio': [1],
'thickness': {
'value': 0.03,
'units': 'mm'
},
'density': {
'value': np.NaN,
'units': 'g/cm3'
},
},
}
self.o_reso = Resonance(stack=_stack, database=self.database)
def form_iso_table(sample_df: pd.DataFrame, database: str):
o_reso = Resonance(energy_min=1,
energy_max=2,
energy_step=1,
database=database)
o_reso = unpack_sample_tb_df_and_add_layer(o_reso=o_reso,
sample_tb_df=sample_df)
layer_list = list(o_reso.stack.keys())
lay_list = []
ele_list = []
iso_list = []
iso_ratio_list = []
for each_layer in layer_list:
current_ele_list = o_reso.stack[each_layer]['elements']
for each_ele in current_ele_list:
current_iso_list = o_reso.stack[each_layer][each_ele]['isotopes'][
'list']
current_iso_ratio_list = o_reso.stack[each_layer][each_ele][
'isotopes']['isotopic_ratio']
for i, each_iso in enumerate(current_iso_list):
lay_list.append(each_layer)
ele_list.append(each_ele)
iso_list.append(each_iso)
iso_ratio_list.append(round(current_iso_ratio_list[i], 4))
_df = pd.DataFrame({
layer_name: lay_list,
ele_name: ele_list,
iso_name: iso_list,
iso_ratio_name: iso_ratio_list,
})
return _df
def test_element_metadata_via_add_layer_initialization(self):
"""assert __element_metadata is correctly populated using add layer initialization"""
o_reso = Resonance(database=self.database)
# layer 1
layer1 = 'CoAg'
thickness1 = 0.025
o_reso.add_layer(formula=layer1, thickness=thickness1)
# layer 2
layer2 = 'Ag'
thickness2 = 0.1
o_reso.add_layer(formula=layer2, thickness=thickness2)
stack = o_reso.stack
# molar mass
co_mass_expected = 58.9332
ag_mass_expected = 107.8682
self.assertEqual(co_mass_expected,
stack['CoAg']['Co']['molar_mass']['value'])
self.assertEqual(ag_mass_expected,
stack['CoAg']['Ag']['molar_mass']['value'])
self.assertEqual(ag_mass_expected,
stack['Ag']['Ag']['molar_mass']['value'])
# density
co_density_expected = 8.9
ag_density_expected = 10.5
self.assertEqual(co_density_expected,
stack['CoAg']['Co']['density']['value'])
self.assertEqual(ag_density_expected,
stack['Ag']['Ag']['density']['value'])
def test_H_sigma(self):
_energy_min = 0.004
_energy_max = 1
_energy_step = 0.01
o_reso = Resonance(energy_min=_energy_min,
energy_max=_energy_max,
energy_step=_energy_step,
database=self.database)
_layer_1 = 'H2'
_thickness_1 = 0.025 # mm
_layer_2 = 'H'
_thickness_2 = 0.01
_layer_3 = 'CH4'
_thickness_3 = 0.01
_layer_4 = 'ZrH'
_thickness_4 = 0.01
o_reso.add_layer(formula=_layer_1, thickness=_thickness_1)
o_reso.add_layer(formula=_layer_2, thickness=_thickness_2)
o_reso.add_layer(formula=_layer_3, thickness=_thickness_3)
o_reso.add_layer(formula=_layer_4, thickness=_thickness_4)
layer1_sigma = o_reso.stack_sigma[_layer_1]['H']['1-H']['sigma_b_raw'][
0]
layer2_sigma = o_reso.stack_sigma[_layer_2]['H']['1-H']['sigma_b_raw'][
0]
layer3_sigma = o_reso.stack_sigma[_layer_3]['H']['1-H']['sigma_b_raw'][
0]
layer4_sigma = o_reso.stack_sigma[_layer_4]['H']['1-H']['sigma_b_raw'][
0]
self.assertNotEqual(layer1_sigma, layer2_sigma)
self.assertNotEqual(layer1_sigma, layer3_sigma)
self.assertNotEqual(layer1_sigma, layer4_sigma)
self.assertNotEqual(layer2_sigma, layer3_sigma)
self.assertNotEqual(layer2_sigma, layer4_sigma)
self.assertNotEqual(layer3_sigma, layer4_sigma)
def test_raises(self):
_energy_min = 0.002
_energy_max = 1
_energy_step = 0.01
o_reso = Resonance(energy_min=_energy_min,
energy_max=_energy_max,
energy_step=_energy_step,
database=self.database)
self.assertRaises(Exception)
def test_abundance(self):
"""assert"""
o_reso = Resonance(database=self.database)
o_reso.add_layer(formula='C', thickness=1)
self.assertAlmostEqual(
o_reso.stack['C']['C']['isotopes']['isotopic_ratio'][0],
0.9893,
delta=0.0001)
self.assertAlmostEqual(
o_reso.stack['C']['C']['isotopes']['isotopic_ratio'][1],
0.0107,
delta=0.0001)
def setUp(self):
_energy_min = 1
_energy_max = 50
_energy_step = 0.1
_layer_1 = 'Co'
_thickness_1 = 0.025 # mm
o_reso = Resonance(energy_min=_energy_min,
energy_max=_energy_max,
energy_step=_energy_step,
database=self.database)
o_reso.add_layer(formula=_layer_1, thickness=_thickness_1)
self.o_reso = o_reso
def _fill_iso_to_items(name, stack=None, database='ENDF_VII'):
if '*' not in name:
raise ValueError(
"'*' is needed to retrieve all isotopes of '{}' ".format(name))
else:
ele_name = name.replace('*', '')
if stack is None:
o_reso = Resonance(database=database)
o_reso.add_layer(formula=ele_name, thickness=1)
stack = o_reso.stack
iso_list = stack[ele_name][ele_name]['isotopes']['list']
_path_to_iso = []
for _each_iso in iso_list:
_path_to_iso.append(_shape_items(_each_iso))
return _path_to_iso
def test_duplicated_layer_name(self):
o_reso = Resonance(database=self.database)
# layer 1
layer1 = 'CoAg'
thickness1 = 0.025
o_reso.add_layer(formula=layer1, thickness=thickness1)
# Duplicated layer name
layer2 = 'CoAg'
thickness2 = 0.01
self.assertRaises(ValueError,
o_reso.add_layer,
formula=layer2,
thickness=thickness2)
def validate_table_input_clicked(self):
# block element table signal
self.ui.element_table.blockSignals(True)
# disable top part (no more changes allowed)
self.ui.layer_groupBox.setEnabled(False)
# collect table input
nbr_row = self.ui.layer_table.rowCount()
_table_dictionary = {}
for _row_index in range(nbr_row):
_dict = {}
_layer_name = self.get_table_item(_row_index, 0)
if _layer_name == '':
break
_dict['elements'] = self.format_string_to_array(
string=self.get_table_item(_row_index, 1), data_type='str')
_dict['stoichiometric_ratio'] = self.format_string_to_array(
string=self.get_table_item(_row_index, 2), data_type='float')
_dict['thickness'] = {
'value': float(self.get_table_item(_row_index, 3)),
'units': 'mm'
}
if self.get_table_item(_row_index, 4):
_dict['density'] = {
'value': float(self.get_table_item(_row_index, 4)),
'units': 'g/cm3'
}
_table_dictionary[_layer_name] = _dict
self.stack = _table_dictionary
E_min = float(str(self.ui.Emin_lineEdit.text()))
E_max = float(str(self.ui.Emax_lineEdit.text()))
delta_E = float(str(self.ui.deltaE_lineEdit.text()))
o_reso = Resonance(stack=self.stack,
energy_min=E_min,
energy_max=E_max,
energy_step=delta_E)
self.o_reso = o_reso
self.fill_check_groupBox()
self.ui.check_groupBox.setVisible(True)
self.ui.element_table.blockSignals(False)
self.ui.ok_button.setEnabled(True)
def test_get_sigma_isotopes(self):
"""assert get_sigma works"""
_stack = {
'CoAg': {
'elements': ['Co', 'Ag'],
'stoichiometric_ratio': [1, 2],
'thickness': {
'value': 0.025,
'units': 'mm'
},
},
'Ag': {
'elements': ['Ag'],
'stoichiometric_ratio': [1],
'thickness': {
'value': 0.03,
'units': 'mm'
},
},
}
energy_min = 10
energy_max = 150
energy_step = 1
o_reso = Resonance(stack=_stack,
energy_max=energy_max,
energy_min=energy_min,
energy_step=energy_step,
database=self.database)
stack_sigma = o_reso.stack_sigma
# for isotopes
self.assertEqual(len(stack_sigma), 2)
self.assertEqual(stack_sigma['Ag']['Ag']['107-Ag']['energy_eV'][0], 10)
self.assertEqual(stack_sigma['Ag']['Ag']['107-Ag']['energy_eV'][-1],
150)
# for elements
self.assertEqual(stack_sigma['Ag']['Ag']['energy_eV'][0], 10)
def test_layer_density_locked_if_defined_during_initialization_add_layer(
self):
"""assert the layer density is locked if defined at the beginning using add_layer"""
o_reso = Resonance(database=self.database)
# layer 1
layer1 = 'CoAg'
thickness1 = 0.025
density = 8.9
o_reso.add_layer(formula=layer1, thickness=thickness1, density=density)
# layer 2
layer2 = 'Ag'
thickness2 = 0.1
o_reso.add_layer(formula=layer2, thickness=thickness2)
density_lock_before = 8.9
density_lock_after = o_reso.stack['CoAg']['density']['value']
self.assertEqual(density_lock_after, density_lock_before)
density_unlock_expected = 10.5
density_unlock_after = o_reso.stack['Ag']['density']['value']
self.assertEqual(density_unlock_after, density_unlock_expected)
def test_correct_initialization_of_stack(self):
"""assert correct defined stack is correctly saved"""
_stack = {
'CoAg': {
'elements': ['Co', 'Ag'],
'stoichiometric_ratio': [1, 2],
'thickness': {
'value': 0.025,
'units': 'mm'
},
},
'Ag': {
'elements': ['Ag'],
'stoichiometric_ratio': [1],
'thickness': {
'value': 0.03,
'units': 'mm'
},
},
}
o_reso = Resonance(stack=_stack, database=self.database)
_stack_returned = o_reso.stack
self.assertEqual(_stack, _stack_returned)
def test_layer_density_locked_if_defined_during_initialization_init(self):
"""assert the layer density is locked if defined at the beginning using init"""
_stack = {
'CoAg': {
'elements': ['Co', 'Ag'],
'stoichiometric_ratio': [1, 2],
'thickness': {
'value': 0.025,
'units': 'mm'
},
'density': {
'value': 8.9,
'units': 'g/cm3'
},
},
'Ag': {
'elements': ['Ag'],
'stoichiometric_ratio': [1],
'thickness': {
'value': 0.03,
'units': 'mm'
},
'density': {
'value': np.NaN,
'units': 'g/cm3'
},
},
}
o_reso = Resonance(stack=_stack, database=self.database)
density_lock_before = 8.9
density_lock_after = o_reso.stack['CoAg']['density']['value']
self.assertEqual(density_lock_after, density_lock_before)
density_unlock_expected = 10.5
density_unlock_after = o_reso.stack['Ag']['density']['value']
self.assertEqual(density_unlock_after, density_unlock_expected)
def test_adding_layer(self):
"""assert adding_layer works"""
o_reso = Resonance(database=self.database)
# layer 1
layer1 = 'CoAg'
thickness1 = 0.025
o_reso.add_layer(formula=layer1, thickness=thickness1)
# layer 2
layer2 = 'Ag'
thickness2 = 0.1
density2 = 0.5
o_reso.add_layer(formula=layer2,
thickness=thickness2,
density=density2)
returned_stack = o_reso.stack
expected_stack = {
'CoAg': {
'elements': ['Co', 'Ag'],
'stoichiometric_ratio': [1, 1],
'thickness': {
'value': 0.025,
'units': 'mm'
},
'density': {
'value': 9.7,
'units': 'g/cm3'
},
'Co': {
'isotopes': {
'file_names': ['Co-58.csv', 'Co-59.csv'],
'list': ['58-Co', '59-Co'],
'mass': {
'value': [57.9357576, 58.9332002],
'units': 'g/mol',
},
'isotopic_ratio': [0.0, 1.0],
},
'density': {
'value': 8.9,
'units': 'g/cm3'
},
'molar_mass': {
'value': 58.9332,
'units': 'g/mol'
},
},
'Ag': {
'isotopes': {
'file_names': ['Ag-107.csv', 'Ag-109.csv'],
'list': ['107-Ag', '109-Ag'],
'mass': {
'value': [106.905093, 108.904756],
'units': 'g/mol',
},
'isotopic_ratio': [0.51839, 0.48161000],
},
'density': {
'value': 10.5,
'units': 'g/cm3'
},
'molar_mass': {
'value': 107.8682,
'units': 'g/cm3'
},
},
},
'Ag': {
'elements': ['Ag'],
'stoichiometric_ratio': [1],
'thickness': {
'value': 0.1,
'units': 'mm'
},
'density': {
'value': 0.5,
'units': 'g/cm3'
},
'Ag': {
'isotopes': {
'file_names': ['Ag-107.csv', 'Ag-109.csv'],
'list': ['107-Ag', '109-Ag'],
'mass': {
'value': [106.905093, 108.904756],
'units': 'g/mol',
},
'isotopic_ratio': [0.51839, 0.48161000],
},
'density': {
'value': 10.5,
'units': 'g/cm3'
},
'molar_mass': {
'value': 107.8682,
'units': 'g/mol'
},
},
},
}
# CoAg
# elements
self.assertEqual(returned_stack['CoAg']['elements'],
expected_stack['CoAg']['elements'])
# atomic_atomic_ratio
self.assertEqual(returned_stack['CoAg']['stoichiometric_ratio'],
expected_stack['CoAg']['stoichiometric_ratio'])
# thickness
self.assertEqual(returned_stack['CoAg']['thickness']['value'],
expected_stack['CoAg']['thickness']['value'])
self.assertEqual(returned_stack['CoAg']['thickness']['units'],
expected_stack['CoAg']['thickness']['units'])
# isotopes Co
# file names
self.assertEqual(
returned_stack['CoAg']['Co']['isotopes']['file_names'],
expected_stack['CoAg']['Co']['isotopes']['file_names'])
# list
self.assertEqual(returned_stack['CoAg']['Co']['isotopes']['list'],
expected_stack['CoAg']['Co']['isotopes']['list'])
# mass
self.assertEqual(
returned_stack['CoAg']['Co']['isotopes']['mass']['value'],
expected_stack['CoAg']['Co']['isotopes']['mass']['value'])
self.assertEqual(
returned_stack['CoAg']['Co']['isotopes']['mass']['units'],
expected_stack['CoAg']['Co']['isotopes']['mass']['units'])
# atomic_ratio Co
self.assertAlmostEqual(
returned_stack['CoAg']['Co']['isotopes']['isotopic_ratio'][0],
expected_stack['CoAg']['Co']['isotopes']['isotopic_ratio'][0],
delta=0.0001)
self.assertAlmostEqual(
returned_stack['CoAg']['Co']['isotopes']['isotopic_ratio'][1],
expected_stack['CoAg']['Co']['isotopes']['isotopic_ratio'][1],
delta=0.0001)
# isotopic_ratio Ag
self.assertAlmostEqual(
returned_stack['CoAg']['Ag']['isotopes']['isotopic_ratio'][0],
expected_stack['CoAg']['Ag']['isotopes']['isotopic_ratio'][0],
delta=0.0001)
self.assertAlmostEqual(
returned_stack['CoAg']['Ag']['isotopes']['isotopic_ratio'][1],
expected_stack['CoAg']['Ag']['isotopes']['isotopic_ratio'][1],
delta=0.0001)
# layer density
self.assertEqual(returned_stack['Ag']['density']['value'],
expected_stack['Ag']['density']['value'])
self.assertAlmostEqual(returned_stack['CoAg']['density']['value'],
expected_stack['CoAg']['density']['value'],
delta=0.1)
# element density
self.assertEqual(returned_stack['CoAg']['Ag']['density']['value'],
expected_stack['CoAg']['Ag']['density']['value'])
self.assertEqual(returned_stack['CoAg']['Co']['density']['value'],
expected_stack['CoAg']['Co']['density']['value'])
# molar mass
self.assertEqual(returned_stack['CoAg']['Ag']['molar_mass']['value'],
expected_stack['CoAg']['Ag']['molar_mass']['value'])
self.assertEqual(returned_stack['CoAg']['Co']['molar_mass']['value'],
expected_stack['CoAg']['Co']['molar_mass']['value'])
def calculate_transmission(sample_tb_df, iso_tb_df, iso_changed, beamline,
band_min, band_max, band_type, database):
_main_path = os.path.abspath(os.path.dirname(__file__))
_path_to_beam_shape = {
'imaging': 'static/instrument_file/beam_flux_cg1d.txt',
'imaging_crop': 'static/instrument_file/beam_flux_cg1d_crop.txt',
'snap': 'static/instrument_file/beam_flux_snap.txt',
# 'venus': 'static/instrument_file/beam_flux_venus.txt',
}
df_flux_raw = _load_beam_shape(_path_to_beam_shape[beamline])
if beamline in ['imaging', 'imaging_crop']:
e_min = df_flux_raw['energy_eV'].min()
e_max = df_flux_raw['energy_eV'].max()
else:
if band_type == 'lambda':
e_min = round(ir_util.angstroms_to_ev(band_max), 6)
e_max = round(ir_util.angstroms_to_ev(band_min), 6)
else: # band_type == 'energy'
e_min = band_min
e_max = band_max
e_step = (e_max - e_min) / (100 - 1)
__o_reso = Resonance(energy_min=e_min,
energy_max=e_max,
energy_step=e_step,
database=database)
_o_reso = unpack_sample_tb_df_and_add_layer(o_reso=__o_reso,
sample_tb_df=sample_tb_df)
o_reso = unpack_iso_tb_df_and_update(o_reso=_o_reso,
iso_tb_df=iso_tb_df,
iso_changed=iso_changed)
o_stack = o_reso.stack
# interpolate with the beam shape energy
energy = o_reso.total_signal['energy_eV'].round(
6) # !!!need to fix ImagingReso energy_eV columns
interp_type = 'cubic'
interp_flux_function = interp1d(x=df_flux_raw['energy_eV'],
y=df_flux_raw['flux'],
kind=interp_type)
flux_interp = interp_flux_function(energy)
df_flux_interp = pd.DataFrame()
df_flux_interp['energy_eV'] = energy
df_flux_interp['flux'] = flux_interp
df_flux = df_flux_interp[:]
trans_tag = 'transmission'
mu_tag = 'mu_per_cm'
o_signal = o_reso.stack_signal
_total_trans = _calculate_transmission(
flux_df=df_flux, trans_array=o_reso.total_signal[trans_tag])
for each_layer in o_stack.keys():
_current_layer_thickness = o_stack[each_layer]['thickness']['value']
if len(o_stack.keys()) == 1:
_current_layer_trans = _total_trans
else:
_current_layer_trans = _calculate_transmission(
flux_df=df_flux, trans_array=o_signal[each_layer][trans_tag])
o_stack[each_layer][trans_tag] = _current_layer_trans
o_stack[each_layer][mu_tag] = _transmission_to_mu_per_cm(
transmission=_current_layer_trans,
thickness=_current_layer_thickness)
for each_ele in o_stack[each_layer]['elements']:
_current_ele_trans = _calculate_transmission(
flux_df=df_flux,
trans_array=o_signal[each_layer][each_ele][trans_tag])
o_stack[each_layer][each_ele][trans_tag] = _current_ele_trans
o_stack[each_layer][each_ele][mu_tag] = _transmission_to_mu_per_cm(
transmission=_current_ele_trans,
thickness=_current_layer_thickness)
return _total_trans, o_stack
def init_reso(e_min, e_max, e_step):
o_reso = Resonance(energy_min=e_min, energy_max=e_max, energy_step=e_step)
return o_reso
