def test_identities(self):
rec_elem1 = mo.get_recoil_element()
rec_elem2 = mo.get_recoil_element()
self.assertNotEqual(rec_elem1, rec_elem2)
self.assertEqual(rec_elem1, rec_elem1)
self.assertIs(rec_elem2, rec_elem2)
def test_add_element_simulation(self):
sim = mo.get_simulation()
rec_c = mo.get_recoil_element(symbol="C")
rec_16c = mo.get_recoil_element(symbol="C", isotope=16)
elem_sim_c = sim.add_element_simulation(rec_c, save_on_creation=False)
elem_sim_16c = sim.add_element_simulation(rec_16c,
save_on_creation=False)
self.assertEqual([elem_sim_c, elem_sim_16c], sim.element_simulations)
def test_can_add_recoil(self):
sim = mo.get_simulation()
rec = mo.get_recoil_element()
self.assertTrue(sim.can_add_recoil(rec))
sim.add_element_simulation(rec, save_on_creation=False)
rec2 = mo.get_recoil_element()
self.assertFalse(sim.can_add_recoil(rec2))
rec2.element.isotope = 1
self.assertTrue(sim.can_add_recoil(rec2))
def test_calculate_spectrum(self, mock_run, mock_get_espe):
"""Tests that the file paths generated during energy spectrum
calculation are correct depending on the type of optimization.
"""
self.main_rec.name = "main_rec"
optim_recoil = mo.get_recoil_element()
optim_recoil.prefix = "C"
optim_recoil.name = "optimized"
espe_recoil = mo.get_recoil_element()
espe_recoil.prefix = "H"
espe_recoil.name = "spectrum"
self.elem_sim.optimization_recoils = [optim_recoil]
self.elem_sim.simulation = mo.get_simulation()
with tempfile.TemporaryDirectory() as tmp_dir:
self.elem_sim.directory = tmp_dir
# No optimization
rec_file = Path(tmp_dir, f"{espe_recoil.get_full_name()}.recoil")
erd_file = Path(tmp_dir, f"{self.main_rec.get_full_name()}.*.erd")
espe_file = Path(tmp_dir, f"{espe_recoil.get_full_name()}.simu")
kwargs = {"recoil_element": espe_recoil}
self.assert_files_equal(mock_get_espe, kwargs, rec_file, erd_file,
espe_file)
# Recoil optimization
rec_file = Path(tmp_dir, f"{espe_recoil.get_full_name()}.recoil")
erd_file = Path(tmp_dir, f"{optim_recoil.prefix}-opt.*.erd")
espe_file = Path(tmp_dir, f"{espe_recoil.get_full_name()}.simu")
kwargs = {
"recoil_element": espe_recoil,
"optimization_type": OptimizationType.RECOIL
}
self.assert_files_equal(mock_get_espe, kwargs, rec_file, erd_file,
espe_file)
# Fluence optimization
rec_file = Path(tmp_dir, f"{espe_recoil.prefix}-optfl.recoil")
erd_file = Path(tmp_dir, f"{self.main_rec.prefix}-optfl.*.erd")
espe_file = Path(tmp_dir, f"{espe_recoil.prefix}-optfl.simu")
kwargs = {
"recoil_element": espe_recoil,
"optimization_type": OptimizationType.FLUENCE
}
self.assert_files_equal(mock_get_espe, kwargs, rec_file, erd_file,
espe_file)
self.assertEqual(mock_run.call_count, 3)
def test_raises_exception_if_recoil_added_twice(self):
sim = mo.get_simulation()
rec = mo.get_recoil_element()
sim.add_element_simulation(rec, save_on_creation=False)
self.assertRaises(
ValueError,
lambda: sim.add_element_simulation(rec, save_on_creation=False))
def test_espe_params(self, mock_exec):
esp = EnergySpectrumParamsDialog(Mock(),
"measurement",
measurement=mo.get_measurement())
esp.close()
# ValueError is raised if spectrum type is wrong
self.assertRaises(ValueError,
lambda: EnergySpectrumParamsDialog(Mock(), "simu"))
# AttributeError is raised if simulation has no sample
self.assertRaises(
AttributeError, lambda: EnergySpectrumParamsDialog(
Mock(),
"simulation",
simulation=mo.get_simulation(),
element_simulation=mo.get_element_simulation(),
recoil_widget=Mock()))
sample = mo.get_sample()
sim = mo.get_simulation()
sim.sample = sample
elem_sim = sim.add_element_simulation(mo.get_recoil_element(),
save_on_creation=False)
esp = EnergySpectrumParamsDialog(Mock(),
"simulation",
simulation=sim,
element_simulation=elem_sim,
recoil_widget=Mock())
esp.close()
assert mock_exec.call_count == 2
def setUpClass(cls):
cls.directory = Path(tempfile.gettempdir())
target = Target(layers=[
Layer("layer1", [
Element.from_string("Li 1.0")
], 0.01, 0.01, start_depth=0.0),
Layer("layer2", [
Element.from_string("Li 0.048"),
Element.from_string("O 0.649"),
Element.from_string("Mn 0.303")
], 90.0, 4.0, start_depth=0.01),
Layer("subtrate", [
Element.from_string("Si 1.0")
], 1000.0, 2.32, start_depth=90.01)
])
cls.mcerd = MCERD(101, {
"recoil_element": mo.get_recoil_element(),
"sim_dir": tempfile.gettempdir(),
"simulation_type": SimulationType.ERD,
"target": target,
"detector": mo.get_detector(),
"beam": mo.get_beam(),
# Following simulation parameters have been determined by the
# rigorous application of the Stetson-Harrison method.
"minimum_scattering_angle": 5.5,
"minimum_main_scattering_angle": 6.5,
"minimum_energy_of_ions": 8.15,
"number_of_recoils": 15,
"simulation_mode": SimulationMode.NARROW,
"number_of_scaling_ions": 14,
"number_of_ions_in_presimu": 100,
"number_of_ions": 1000
}, mo.get_element_simulation().get_full_name())
def test_serialization(self):
with tempfile.TemporaryDirectory() as tmp_dir:
tmp_dir = Path(tmp_dir)
elem = mo.get_element()
prefix = elem.symbol
re1 = mo.get_recoil_element(symbol=prefix)
re2 = mo.get_recoil_element(name="secondary", symbol=prefix)
o_re_first = mo.get_recoil_element(name="optfirst")
o_re_med = mo.get_recoil_element(name="optmed")
o_re_last = mo.get_recoil_element(name="optlast")
es1 = ElementSimulation(
tmp_dir,
mo.get_request(), [re1, re2],
name_prefix=prefix,
save_on_creation=True,
optimized_fluence=5e12,
optimization_recoils=[o_re_first, o_re_med, o_re_last])
es1.to_file(save_optim_results=True)
mcsimu = es1.get_default_file_path()
es2 = ElementSimulation.from_file(mo.get_request(),
prefix,
tmp_dir,
mcsimu_file=mcsimu,
profile_file=None,
simulation=mo.get_simulation(),
save_on_creation=False)
utils.assert_all_equal("He-Default", es1.get_full_name(),
es2.get_full_name())
self.assertEqual("He-Default",
es1.get_main_recoil().get_full_name(),
es2.get_main_recoil().get_full_name())
utils.assert_all_equal(["Default", "secondary"],
[r.name for r in es1.recoil_elements],
[r.name for r in es2.recoil_elements])
utils.assert_all_equal(5e12, es1.optimized_fluence,
es2.optimized_fluence)
utils.assert_all_equal(["optfirst", "optmed", "optlast"],
[r.name for r in es1.optimization_recoils],
[r.name for r in es2.optimization_recoils])
def test_get_active_simulation(self, mock_run):
sim = mo.get_simulation()
sim.add_element_simulation(mo.get_recoil_element(),
save_on_creation=False)
self.assertEqual(([], [], [], []), sim.get_active_simulations())
elem_sim = sim.element_simulations[0]
elem_sim.use_default_settings = False
elem_sim.start(1, 1).run()
self.assertEqual(([], [elem_sim], [], []),
sim.get_active_simulations())
mock_run.assert_called_once()
elem_sim.optimization_recoils = [mo.get_recoil_element()]
elem_sim.start(1, 1, optimization_type=OptimizationType.RECOIL).run()
self.assertEqual(([], [elem_sim], [], [elem_sim]),
sim.get_active_simulations())
def test_get_recoils(self):
sim = mo.get_simulation()
n = 10
elems = set(
mo.get_element(randomize=True, amount_p=0) for _ in range(n))
rec_elems = [mo.get_recoil_element(element=elem) for elem in elems]
for rec in rec_elems:
sim.add_element_simulation(rec, save_on_creation=False)
self.assertEqual(rec_elems, sim.get_recoil_elements())
def test_has_element(self):
sim = mo.get_simulation()
elem = mo.get_element()
self.assertFalse(sim.has_element(elem))
rec = mo.get_recoil_element(symbol=elem.symbol)
sim.add_element_simulation(rec, save_on_creation=False)
self.assertTrue(sim.has_element(elem))
def test_has_element(self):
rec_he = mo.get_recoil_element(symbol="He")
rec_1he = mo.get_recoil_element(symbol="He", isotope=1)
rec_1he_2 = mo.get_recoil_element(symbol="He", isotope=1, amount=2)
self.elem_sim.recoil_elements = []
self.assertFalse(self.elem_sim.has_element(rec_he.element))
self.elem_sim.recoil_elements = [rec_he]
self.assertTrue(self.elem_sim.has_element(rec_he.element))
self.assertFalse(self.elem_sim.has_element(rec_1he.element))
self.assertFalse(self.elem_sim.has_element(rec_1he_2.element))
self.elem_sim.recoil_elements = [rec_1he]
self.assertFalse(self.elem_sim.has_element(rec_he.element))
self.assertTrue(self.elem_sim.has_element(rec_1he.element))
self.assertTrue(self.elem_sim.has_element(rec_1he_2.element))
self.elem_sim.recoil_elements = [rec_1he, rec_he]
self.assertTrue(self.elem_sim.has_element(rec_he.element))
self.assertTrue(self.elem_sim.has_element(rec_1he.element))
self.assertTrue(self.elem_sim.has_element(rec_1he_2.element))
def setUp(self):
self.main_rec = mo.get_recoil_element()
self.kwargs = {
"minimum_energy": 42.0,
"minimum_scattering_angle": 17.0,
"minimum_main_scattering_angle": 14.0,
"number_of_preions": 3
}
self.elem_sim = ElementSimulation(Path(tempfile.gettempdir()),
mo.get_request(), [self.main_rec],
save_on_creation=False,
use_default_settings=False,
**self.kwargs)
def test_use_default_settings(self):
"""Tests that use_default_settings overrides kwargs"""
elem_sim2 = ElementSimulation(Path(tempfile.gettempdir()),
self.elem_sim.request,
[mo.get_recoil_element()],
save_on_creation=False,
use_default_settings=True,
**self.kwargs)
self.assertEqual(
self.elem_sim.request.default_element_simulation.get_settings(),
elem_sim2.get_settings())
for key, value in self.kwargs.items():
self.assertNotEqual(value, getattr(elem_sim2, key))
