def test_hash_properties(self): n = 1000 for _ in range(n): e1 = mo.get_element(randomize=True, amount_p=0.0) e2 = mo.get_element(randomize=True, amount_p=0.0) if e1.symbol == e2.symbol and e1.isotope == e2.isotope: self.assertEqual(hash(e1), hash(e2)) else: self.assertNotEqual(hash(e1), hash(e2))
def test_get_rbs_selections(self): with tempfile.TemporaryDirectory() as tmp_dir: path = Path(tmp_dir, self.rel_dir) self._generate_cut_files(path) files = [Path(entry.path) for entry in os.scandir(path)] rbs = cut_file.get_rbs_selections(files) self.assertEqual( { "1He.RBS_He.0.cut": mo.get_element(symbol="He"), "He.RBS_Cl.0.cut": mo.get_element(symbol="Cl"), "He.RBS_Cl.1.cut": mo.get_element(symbol="Cl"), }, rbs)
def assert_settings_equal(self, gs1: GlobalSettings, gs2: GlobalSettings, only_check_same_size=False): """Asserts that the two GlobalSettings objects return same values. If only_check_same_size is True, the return values of get_element_colors are only checked if they are the same size. """ getters = [ method for method in dir(gs1) if method.startswith("get") or method.startswith("is") ] for getter in getters: if getter == "get_element_color": args = mo.get_element(randomize=True).symbol, elif getter == "get_import_timing": args = random.randint(0, 2), else: args = () val1 = getattr(gs1, getter)(*args) val2 = getattr(gs2, getter)(*args) if only_check_same_size: if getter == "get_element_colors": if len(val1) != len(val2): continue self.assertEqual(val1, val2)
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_equals_prop_based(self): n = 1000 for _ in range(n): elem1 = mo.get_element(randomize=True) elem1_str = str(elem1) elem2 = Element.from_string(elem1_str) self.assertIsNot(elem1, elem2) self.assertEqual(elem1, elem2) self.assertEqual(hash(elem1), hash(elem2))
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 _generate_cut_files(self, directory): cut = CutFile(directory=directory) cut.set_info(mo.get_selection(), self.data) cut.save() cut.save() cut2 = CutFile(directory=directory) cut2.set_info(mo.get_selection(), self.data) cut2.element = mo.get_element(symbol="He", isotope=1) cut2.element_scatter = mo.get_element() cut2.save() cut3 = CutFile(directory=directory) cut3.set_info(mo.get_selection(), self.data) cut3.type = "ERD" cut3.element_scatter = "" cut3.save() cut3.save() cut3.save(element_count=10)
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_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_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_adjustable_settings(self): beam = mo.get_beam() kwargs = { "energy": 1, "charge": 2, "ion": mo.get_element(randomize=True), "energy_distribution": 3, "spot_size": (1, 2), "profile": "foo", "divergence": 7 } self.assertNotEqual(kwargs, beam.get_settings()) beam.set_settings(**kwargs) self.assertEqual(kwargs, beam.get_settings())
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_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_most_common_isotope(self): self.assertEqual(4, Element("He").get_most_common_isotope()) self.assertIsNone(Element("U").get_most_common_isotope()) # get_most_common_isotope just simply returns the number value of # masses.get_most_common_isotope for _ in range(100): e = mo.get_element(randomize=True) mi = masses.get_most_common_isotope(e.symbol) if mi is None: self.assertEqual(mi, e.get_most_common_isotope()) else: self.assertEqual( masses.get_most_common_isotope( e.symbol)[masses.NUMBER_KEY], e.get_most_common_isotope())
def test_loading(self): with tempfile.TemporaryDirectory() as tmp_dir: path = Path(tmp_dir, self.rel_dir) cut1 = CutFile(directory=path, split_count=4) cut1.set_info(mo.get_selection(), self.data) cut1.element = mo.get_element(symbol="F") cut1.save() fp = path / "mesu1.F.RBS_Cl.0.cut" cut2 = CutFile() cut2.load_file(fp) cut1_d = dict(vars(cut1)) cut2_d = dict(vars(cut2)) self.assertIsNone(cut1_d.pop("element_number")) self.assertEqual(0, cut2_d.pop("element_number")) self.assertTrue(len(cut1_d) > 0) self.assertEqual(cut1_d, cut2_d)
def test_serialization(self): t = Target(name="foo", modification_time=random.randint(0, 100), description="bar", target_type="AFM", image_size=(random.randint(0, 99), random.randint(0, 99)), image_file="test", target_theta=random.random(), scattering_element=mo.get_element(randomize=True), layers=[mo.get_layer()]) with tempfile.TemporaryDirectory() as tmp_dir: tgt_file = Path(tmp_dir, ".target") t.to_file(tgt_file) t2 = Target.from_file(tgt_file, mo.get_request()) self.assertIsNot(t, t2) self.assertEqual(t.name, t2.name) self.assertEqual(t.description, t2.description) self.assertEqual(t.layers[0].elements, t2.layers[0].elements) self.assertEqual(t.image_size, t2.image_size) self.assertEqual(t.target_theta, t2.target_theta) self.assertEqual(t.target_type, t2.target_type) self.assertEqual(t.scattering_element, t2.scattering_element)