def setUp(self):
self.p2_args = 1, 1
self.p1 = Point(0, 0)
self.p2 = Point(self.p2_args)
self.p3 = Point(2, 0)
points = [
self.p1, self.p2, self.p3
]
self.rec_elem = RecoilElement(mo.get_element(), points)
def get_recoil_element(recoil_widget=None,
name="Default",
element=None,
**kwargs) -> RecoilElement:
"""Returns a RecoilElement object.
Args:
recoil_widget: object that gets added to RecoilElement's collection
of widgets if not 'None'.
name: name of the recoil
element: element object.
**kwargs: if element is not given, these are the keyword arguments
that get passed down to get_element
"""
if element is None:
element = get_element(**kwargs)
re = RecoilElement(element, [
Point((1, 1)),
Point((2, 2)),
],
"red",
name=name)
if recoil_widget is not None:
re.widgets.append(recoil_widget)
return re
def add_new_recoil(self, spectra_changed=None, recoil_name_changed=None):
"""
Add new recoil to element simulation.
"""
points = copy.deepcopy(
self.element_simulation.get_main_recoil().get_points())
element = copy.copy(self.element_simulation.get_main_recoil().element)
name = "Default-" + str(self.running_int_recoil)
color = self.element_simulation.get_main_recoil().color
if self.element_simulation.simulation_type == "ERD":
rec_type = "rec"
else:
rec_type = "sct"
recoil_element = RecoilElement(element,
points,
color,
name,
rec_type=rec_type)
self.running_int_recoil += 1
recoil_widget = RecoilElementWidget(
self.parent,
self.tab,
self,
self.element_simulation,
color,
recoil_element,
statusbar=self.statusbar,
spectra_changed=spectra_changed,
recoil_name_changed=recoil_name_changed)
recoil_element.widgets.append(recoil_widget)
self.element_simulation.recoil_elements.append(recoil_element)
self.parent.radios.addButton(recoil_widget.radio_button)
# Add recoil widget under ite element simulation's element widget
for i in range(self.parent.recoil_vertical_layout.count()):
if self.parent.recoil_vertical_layout.itemAt(i).widget() == self:
self.parent.recoil_vertical_layout.insertWidget(
i + 1, recoil_widget)
break
recoil_widget.radio_button.setChecked(True)
# Save recoil element
recoil_element.to_file(self.element_simulation.directory)
def setUp(self):
self.timestamp = time.time()
self.rec_type = "rec"
self.ch_width = 4
self.rec_elem = RecoilElement(
mo.get_element(),
[Point((0, 4)),
Point((1, 5)),
Point((2, 10))],
color="black",
description="foo",
name="bar",
rec_type="rec",
reference_density=3,
channel_width=self.ch_width,
modification_time=self.timestamp
)
def test_sorting_points(self):
"""Points should always remain sorted.
"""
n = 10
iters = 10
maximum = 20
minimum = 0
rand = lambda: random.uniform(minimum, maximum)
for _ in range(iters):
points = [
Point(rand(), rand())
for _ in range(n)
]
points_sorted = sorted(points)
rec_elem = RecoilElement(
mo.get_element(), points)
self.assertEqual(points_sorted, rec_elem.get_points())
p_0 = Point(minimum - 1, rand())
p_n = Point(maximum + 1, rand())
rec_elem.add_point(p_0)
rec_elem.add_point(p_n)
self.assertIs(p_0, rec_elem.get_first_point())
self.assertIs(p_n, rec_elem.get_last_point())
def test_get_full_name(self):
self.assertEqual("He-bar", self.rec_elem.get_full_name())
rec_elem = RecoilElement(Element.from_string("16O"), [], name=None)
self.assertEqual("16O-Default", rec_elem.get_full_name())
rec_elem = RecoilElement(Element.from_string("16O"), [], name="")
self.assertEqual("16O-Default", rec_elem.get_full_name())
def test_sorting(self):
# Checks that recoil elements are sorted in the same way as elements
n = 10
iterations = 10
for _ in range(iterations):
elems = [mo.get_element(randomize=True) for _ in range(n)]
rec_elems = [RecoilElement(elem, []) for elem in elems]
random.shuffle(elems)
random.shuffle(rec_elems)
elems.sort()
rec_elems.sort()
for e, r in zip(elems, rec_elems):
self.assertEqual(e, r.element)
def setUpClass(cls):
# default recoil element
cls.elem_4he = RecoilElement(Element.from_string("4He"), [], "red")
# Valid file names for the recoil element
cls.valid_erd_files = ["4He-Default.101.erd", "4He-Default.102.erd"]
# Invalid file names for the recoil element
cls.invalid_erd_files = [
"4He-Default.101", ".4He-Default.102.erd", ".4He-Default..erd",
"4He-Default.101.erf", "4He-Default./.103.erd",
"4He-Default.\\.104.erd", "3He-Default.102.erd"
]
cls.expected_values = [(Path(f), s + 101)
for s, f in enumerate(cls.valid_erd_files)]
def test_get_erd_file_path(self):
rec_elem = RecoilElement(Element.from_string("He"), [], "red")
self.assertEqual("He-Default.101.erd",
fp.get_erd_file_name(rec_elem, 101))
self.assertEqual("He-Default.102.erd",
fp.get_erd_file_name(rec_elem, 102))
self.assertEqual(
"He-opt.101.erd",
fp.get_erd_file_name(
rec_elem, 101, optim_mode=OptimizationType.RECOIL))
self.assertEqual(
"He-optfl.101.erd",
fp.get_erd_file_name(
rec_elem, 101, optim_mode=OptimizationType.FLUENCE))
self.assertRaises(ValueError,
lambda: fp.get_erd_file_name(rec_elem, 101,
optim_mode="foo"))
def test_serialization(self):
with tempfile.TemporaryDirectory() as tmp_dir:
file_path = fp.get_recoil_file_path(self.rec_elem, tmp_dir)
self.rec_elem.to_file(tmp_dir)
rec_elem2 = RecoilElement.from_file(file_path,
channel_width=self.ch_width,
rec_type=self.rec_type)
self.compare_rec_elems(self.rec_elem, rec_elem2)
# Test with an empty list of points and no rec_type or ch_width
rec_elem3 = RecoilElement(Element.from_string("O"), [])
file_path = fp.get_recoil_file_path(rec_elem3, tmp_dir)
rec_elem3.to_file(tmp_dir)
rec_elem4 = RecoilElement.from_file(file_path)
self.compare_rec_elems(rec_elem3, rec_elem4)
self.assertFalse(os.path.exists(tmp_dir))
def test_element_simulation_settings(self):
"""This tests that ElementSimulation is run with the correct settings
depending on how 'use_default_settings' and 'use_request_settings'
have been set.
"""
with tempfile.TemporaryDirectory() as tmp_dir:
# File paths
tmp_dir = Path(tmp_dir).resolve()
req_dir = tmp_dir / "req"
sim_dir = req_dir / "Sample_01-foo" / \
f"{Simulation.DIRECTORY_PREFIX}01-bar"
simu_file = sim_dir / "bar.simulation"
# Request
request = Request(
req_dir, "test_req", GlobalSettings(config_dir=tmp_dir), {},
enable_logging=False)
self.assertEqual(req_dir, request.directory)
self.assertEqual("test_req", request.request_name)
# Sample
sample = request.samples.add_sample(name="foo")
self.assertIs(sample, request.samples.samples[0])
self.assertIsInstance(sample, Sample)
self.assertEqual("foo", sample.name)
self.assertEqual(request, sample.request)
self.assertEqual("Sample_01-foo", sample.directory)
# Simulation
sim = sample.simulations.add_simulation_file(
sample, simu_file, 0)
# Disable logging so the logging file handlers do not cause
# an exception when the tmp dir is removed
sim.close_log_files()
self.assertIs(sim, sample.simulations.get_key_value(0))
self.assertIsInstance(sim.detector, Detector)
self.assertIsInstance(sim.run, Run)
self.assertEqual("bar", sim.name)
self.assertEqual(request, sim.request)
self.assertEqual(sample, sim.sample)
# ElementSimulation
rec_elem = RecoilElement(
Element.from_string("Fe"), [Point((1, 1))], name="recoil_name")
elem_sim = sim.add_element_simulation(rec_elem)
self.assertIs(elem_sim, sim.element_simulations[0])
elem_sim.number_of_preions = 2
elem_sim.number_of_ions = 3
self.assertEqual(request, elem_sim.request)
self.assertEqual("Fe-Default", elem_sim.get_full_name())
# Some pre-simulation checks
self.assertIsNot(sim.target, request.default_target)
self.assertIsNot(elem_sim, request.default_element_simulation)
self.assertIsNot(sim.detector, request.default_detector)
self.assertIsNot(sim.run, request.default_run)
self.assertIsNot(sim.run.beam, request.default_run.beam)
self.assertNotEqual(
elem_sim.number_of_ions,
request.default_element_simulation.number_of_ions)
self.assert_expected_settings(elem_sim, request, sim)
class TestRecoilElement(unittest.TestCase):
def setUp(self):
self.timestamp = time.time()
self.rec_type = "rec"
self.ch_width = 4
self.rec_elem = RecoilElement(
mo.get_element(),
[Point((0, 4)),
Point((1, 5)),
Point((2, 10))],
color="black",
description="foo",
name="bar",
rec_type="rec",
reference_density=3,
channel_width=self.ch_width,
modification_time=self.timestamp
)
def test_get_full_name(self):
self.assertEqual("He-bar", self.rec_elem.get_full_name())
rec_elem = RecoilElement(Element.from_string("16O"), [], name=None)
self.assertEqual("16O-Default", rec_elem.get_full_name())
rec_elem = RecoilElement(Element.from_string("16O"), [], name="")
self.assertEqual("16O-Default", rec_elem.get_full_name())
def test_serialization(self):
with tempfile.TemporaryDirectory() as tmp_dir:
file_path = fp.get_recoil_file_path(self.rec_elem, tmp_dir)
self.rec_elem.to_file(tmp_dir)
rec_elem2 = RecoilElement.from_file(file_path,
channel_width=self.ch_width,
rec_type=self.rec_type)
self.compare_rec_elems(self.rec_elem, rec_elem2)
# Test with an empty list of points and no rec_type or ch_width
rec_elem3 = RecoilElement(Element.from_string("O"), [])
file_path = fp.get_recoil_file_path(rec_elem3, tmp_dir)
rec_elem3.to_file(tmp_dir)
rec_elem4 = RecoilElement.from_file(file_path)
self.compare_rec_elems(rec_elem3, rec_elem4)
self.assertFalse(os.path.exists(tmp_dir))
def compare_rec_elems(self, rec_elem1, rec_elem2):
fst = dict(vars(rec_elem1))
snd = dict(vars(rec_elem2))
self.assertEqual(fst.pop("_points"), snd.pop("_points"))
self.assertEqual(fst.pop("element"), snd.pop("element"))
times = fst.pop("modification_time"), snd.pop("modification_time")
if None not in times:
self.assertAlmostEqual(times[0], times[1], places=2)
self.assertEqual(fst, snd)
def test_calculate_area(self):
self.assertEqual(12, self.rec_elem.calculate_area())
self.assertEqual(4.5, self.rec_elem.calculate_area(
start=0, end=1))
self.assertEqual(0, self.rec_elem.calculate_area(
start=0.5, end=0.5))
self.assertEqual(2.25, self.rec_elem.calculate_area(
start=0.25, end=0.75))
self.assertEqual(5.5, self.rec_elem.calculate_area(
start=0.5, end=1.5))
# If the interval is outside the point range, 0 is returned
self.assertEqual(0, self.rec_elem.calculate_area(
start=2, end=3))
self.assertEqual(0, self.rec_elem.calculate_area(
start=-2, end=0))
# If the length of the interval is non-positive, 0 is returned
self.assertEqual(0, self.rec_elem.calculate_area(
start=1, end=1))
self.assertEqual(0, self.rec_elem.calculate_area(
start=1, end=0))
def test_sorting(self):
# Checks that recoil elements are sorted in the same way as elements
n = 10
iterations = 10
for _ in range(iterations):
elems = [mo.get_element(randomize=True) for _ in range(n)]
rec_elems = [RecoilElement(elem, []) for elem in elems]
random.shuffle(elems)
random.shuffle(rec_elems)
elems.sort()
rec_elems.sort()
for e, r in zip(elems, rec_elems):
self.assertEqual(e, r.element)
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)
class TestPoints(unittest.TestCase):
def setUp(self):
self.p2_args = 1, 1
self.p1 = Point(0, 0)
self.p2 = Point(self.p2_args)
self.p3 = Point(2, 0)
points = [
self.p1, self.p2, self.p3
]
self.rec_elem = RecoilElement(mo.get_element(), points)
def test_sorting_points(self):
"""Points should always remain sorted.
"""
n = 10
iters = 10
maximum = 20
minimum = 0
rand = lambda: random.uniform(minimum, maximum)
for _ in range(iters):
points = [
Point(rand(), rand())
for _ in range(n)
]
points_sorted = sorted(points)
rec_elem = RecoilElement(
mo.get_element(), points)
self.assertEqual(points_sorted, rec_elem.get_points())
p_0 = Point(minimum - 1, rand())
p_n = Point(maximum + 1, rand())
rec_elem.add_point(p_0)
rec_elem.add_point(p_n)
self.assertIs(p_0, rec_elem.get_first_point())
self.assertIs(p_n, rec_elem.get_last_point())
def test_remove_point(self):
self.rec_elem.remove_point(self.p1)
self.assertEqual([self.p2, self.p3], self.rec_elem.get_points())
self.rec_elem.remove_point(self.p3)
self.assertEqual([self.p2], self.rec_elem.get_points())
self.rec_elem.remove_point(Point(self.p2_args))
self.assertEqual([], self.rec_elem.get_points())
self.assertRaises(
ValueError, lambda: self.rec_elem.remove_point(self.p1))
def test_get_neighbours(self):
ln, rn = self.rec_elem.get_neighbors(self.p1)
self.assertIsNone(ln)
self.assertIs(rn, self.p2)
ln, rn = self.rec_elem.get_neighbors(self.p2)
self.assertIs(ln, self.p1)
self.assertIs(rn, self.p3)
ln, rn = self.rec_elem.get_neighbors(self.p3)
self.assertIs(ln, self.p2)
self.assertIsNone(rn)
ln, rn = self.rec_elem.get_neighbors(Point(1, 1))
self.assertIs(ln, self.p1)
self.assertIs(rn, self.p3)
def test_between_zeros(self):
self.assertFalse(self.rec_elem.between_zeros(self.p1))
self.assertTrue(self.rec_elem.between_zeros(self.p2))
self.assertFalse(self.rec_elem.between_zeros(self.p3))
self.assertTrue(self.rec_elem.between_zeros(Point(1, 1)))
self.assertRaises(
ValueError, lambda: self.rec_elem.between_zeros(Point(0.5, 1)))
def test_dist_length(self):
self.assertEqual(2, self.rec_elem.distribution_length())
self.rec_elem.add_point(Point(10.5, 0))
self.assertEqual(10.5, self.rec_elem.distribution_length())
for p in list(self.rec_elem.get_points()):
self.rec_elem.remove_point(p)
self.assertRaises(IndexError, self.rec_elem.distribution_length)