class TestLogNormalCSDSDistribution(unittest.TestCase): component = None def setUp(self): self.CSDS = LogNormalCSDSDistribution() def tearDown(self): del self.CSDS def test_not_none(self): self.assertIsNotNone(self.CSDS) def test_data_object(self): self.assertIsNotNone(self.CSDS.data_object) test_average = create_object_attribute_test("CSDS", "average", 15) test_alpha_scale = create_object_attribute_test("CSDS", "alpha_scale", 0.5) test_alpha_offset = create_object_attribute_test("CSDS", "alpha_offset", 0.6) test_beta_scale = create_object_attribute_test("CSDS", "alpha_scale", 0.5) test_beta_offset = create_object_attribute_test("CSDS", "alpha_offset", 0.6) pass # end of class
class TestR1G2Model(AbstractTestProbModel, unittest.TestCase): prob_model_type = R1G2Model test_W1 = create_object_attribute_test("prob_model", "W1", 0.7) test_P11_or_P22 = create_object_attribute_test("prob_model", "P11_or_P22", 0.7) pass # end of class
class TestAtom(unittest.TestCase): atom_type = None def setUp(self): self.atom = Atom() def tearDown(self): del self.atom def test_not_none(self): self.assertIsNotNone(self.atom) def test_data_object(self): self.assertIsNotNone(self.atom.data_object) test_name = create_object_attribute_test("atom", "name", "Test Name") test_pn = create_object_attribute_test("atom", "pn", 3) test_default_z = create_object_attribute_test("atom", "default_z", 5.3) test_stretch_values = create_object_attribute_test("atom", "stretch_values", True) def test_parent(self): parent_atom = Atom(name="Parent") self.atom.parent = parent_atom self.assertEqual(self.atom.parent, parent_atom) def test_z_calculations(self): # Checks wether the atom can calculate stretched values: # 1. When everything is set up the way it should be: default_z = 9.0 lattice_d = 5.4 factor = 0.5 class DummyComponent(object): def get_interlayer_stretch_factors(self): return lattice_d, factor parent = DummyComponent() atom = Atom(parent=parent) atom.stretch_values = True atom.default_z = default_z z = atom.z self.assertEqual(z, lattice_d + (default_z - lattice_d) * factor) # 2. When no component is set, but stretched is True: should not raise an error, but simple ignore the stretching atom.parent = None z = atom.z def test_structure_factors(self): import numpy as np rng = 2.0 * np.sin(np.arange(30)) / 0.154056 res = self.atom.get_structure_factors(rng) self.assertIsNotNone(res) pass # end of class
class TestAtomRatio(unittest.TestCase): phase = None def setUp(self): self.atom1 = DummyAtom() self.atom2 = DummyAtom() self.parent = DummyParent() self.atom_ratio = AtomRatio(name="TestRatio", sum=2, value=0.5, atom1=[self.atom1, "attribute"], atom2=[self.atom2, "attribute"], parent=self.parent) self.atom_ratio.resolve_relations() def tearDown(self): del self.atom1 del self.atom2 del self.atom_ratio def test_not_none(self): self.assertIsNotNone(self.atom_ratio) self.assertIsNotNone(self.atom_ratio.atom1[0]) self.assertIsNotNone(self.atom_ratio.atom2[0]) def test_apply_relation(self): self.atom_ratio.enabled = True self.atom_ratio.apply_relation() self.assertEqual(self.atom1.attribute, 1.0) self.assertEqual(self.atom2.attribute, 1.0) self.atom_ratio.value = 0.1 self.atom_ratio.apply_relation() self.assertEqual(self.atom1.attribute, 0.2) self.assertEqual(self.atom2.attribute, 1.8) test_name = create_object_attribute_test("atom_ratio", "name", "Test Name") test_name = create_object_attribute_test("atom_ratio", "value", 0.5) test_name = create_object_attribute_test("atom_ratio", "sum", 6) test_name = create_object_attribute_test("atom_ratio", "atom1", (None, "Test")) test_name = create_object_attribute_test("atom_ratio", "atom2", (None, "Test")) pass # end of class
class TestPhase(unittest.TestCase): phase = None def setUp(self): self.ucp = UnitCellProperty(name="TestUCP", value=0.0, enabled=False, factor=0.0, constant=0.0, prop=None, parent=None) def tearDown(self): del self.ucp def test_not_none(self): self.assertIsNotNone(self.ucp) def test_value_of_prop(self): class Dummy(): attribute = "Test123" dummy = Dummy() self.ucp.prop = (dummy, "attribute") self.assertEqual(self.ucp.get_value_of_prop(), dummy.attribute) self.ucp.prop = (None, "attribute") self.assertEqual(self.ucp.get_value_of_prop(), 0.0) def test_update_value(self): class Dummy(): attribute = 0.5 dummy = Dummy() self.ucp.prop = (dummy, "attribute") self.ucp.factor = 0.5 self.ucp.constant = 1.0 #Check that if the prop is disabled, it can be set manually: self.ucp.value = 0.075 self.assertEqual(self.ucp.value, 0.075) #Check that if the prop is enabled, it is calculated automatically: self.ucp.enabled = True self.assertEqual(self.ucp.value, 0.5 * 0.5 + 1.0) #Check that if the prop is enabled, it can't be set manually: self.ucp.value = 0.075 self.assertNotEqual(self.ucp.value, 0.075) test_name = create_object_attribute_test("ucp", "name", "Test Name") test_name = create_object_attribute_test("ucp", "value", 0.5) test_name = create_object_attribute_test("ucp", "factor", 0.5) test_name = create_object_attribute_test("ucp", "constant", 0.5) test_name = create_object_attribute_test("ucp", "prop", (None, "")) test_name = create_object_attribute_test("ucp", "enabled", True) test_name = create_object_attribute_test("ucp", "inherited", True) pass # end of class
class TestR2G3Model(AbstractTestProbModel, unittest.TestCase): prob_model_type = R2G3Model test_W1 = create_object_attribute_test("prob_model", "W1", 0.7) test_P111_or_P212 = create_object_attribute_test("prob_model", "P111_or_P212", 0.7) test_G1 = create_object_attribute_test("prob_model", "G1", 0.7) test_G2 = create_object_attribute_test("prob_model", "G2", 0.7) test_G3 = create_object_attribute_test("prob_model", "G3", 0.7) test_G4 = create_object_attribute_test("prob_model", "G4", 0.7) pass # end of class
class TestDritsCSDSDistribution(unittest.TestCase): component = None def setUp(self): self.CSDS = DritsCSDSDistribution() def tearDown(self): del self.CSDS def test_not_none(self): self.assertIsNotNone(self.CSDS) def test_data_object(self): self.assertIsNotNone(self.CSDS.data_object) test_average = create_object_attribute_test("CSDS", "average", 15) pass # end of class
class TestAtomType(unittest.TestCase): atom_type = None def setUp(self): self.atom_type = AtomType() def tearDown(self): del self.atom_type def test_not_none(self): self.assertIsNotNone(self.atom_type) def test_data_object(self): self.assertIsNotNone(self.atom_type.data_object) test_name = create_object_attribute_test("atom_type", "name", "Test Name") test_charge = create_object_attribute_test("atom_type", "charge", -5) test_debye = create_object_attribute_test("atom_type", "debye", 1.0) test_weight = create_object_attribute_test("atom_type", "weight", 60.123) test_atom_nr = create_object_attribute_test("atom_type", "atom_nr", 20) test_par_c = create_object_attribute_test("atom_type", "par_c", 10.2) test_par_a1 = create_object_attribute_test("atom_type", "par_a1", 10.2) test_par_a2 = create_object_attribute_test("atom_type", "par_a2", 10.2) test_par_a3 = create_object_attribute_test("atom_type", "par_a3", 10.2) test_par_a4 = create_object_attribute_test("atom_type", "par_a4", 10.2) test_par_a5 = create_object_attribute_test("atom_type", "par_a5", 10.2) test_par_b1 = create_object_attribute_test("atom_type", "par_b1", 10.2) test_par_b2 = create_object_attribute_test("atom_type", "par_b2", 10.2) test_par_b3 = create_object_attribute_test("atom_type", "par_b3", 10.2) test_par_b4 = create_object_attribute_test("atom_type", "par_b4", 10.2) test_par_b5 = create_object_attribute_test("atom_type", "par_b5", 10.2) def test_parent(self): parent_atom_type = AtomType(name="Parent") self.atom_type.parent = parent_atom_type self.assertEqual(self.atom_type.parent, parent_atom_type) pass # end of class
class TestPhase(unittest.TestCase): phase = None def setUp(self): settings.initialize() self.phase = Phase(R=0, G=1) def tearDown(self): del self.phase def test_not_none(self): self.assertIsNotNone(self.phase) def test_data_object(self): self.assertIsNotNone(self.phase.data_object) def test_R_G(self): self.assertIsNotNone(Phase(R=0, G=1)) self.assertIsNotNone(Phase(R=0, G=2)) self.assertIsNotNone(Phase(R=0, G=3)) self.assertIsNotNone(Phase(R=0, G=4)) self.assertIsNotNone(Phase(R=0, G=5)) self.assertIsNotNone(Phase(R=0, G=6)) self.assertIsNotNone(Phase(R=1, G=2)) self.assertIsNotNone(Phase(R=1, G=3)) self.assertIsNotNone(Phase(R=1, G=4)) self.assertIsNotNone(Phase(R=2, G=2)) self.assertIsNotNone(Phase(R=2, G=3)) self.assertIsNotNone(Phase(R=3, G=2)) test_name = create_object_attribute_test("phase", "name", "Test Name") test_display_color = create_object_attribute_test("phase", "display_color", "#FF00FF") test_default_c = create_object_attribute_test("phase", "default_c", 0.646) test_sigma_star = create_object_attribute_test("phase", "sigma_star", 12.5) test_inherit_display_color = create_object_attribute_test( "phase", "inherit_display_color", True) test_inherit_CSDS_distribution = create_object_attribute_test( "phase", "inherit_CSDS_distribution", True) test_inherit_sigma_star = create_object_attribute_test( "phase", "inherit_sigma_star", True) test_inherit_probabilities = create_object_attribute_test( "phase", "inherit_probabilities", True) def test_import_export(self): from io import BytesIO phases = [Phase(R=0, G=1), Phase(R=1, G=2)] fn = BytesIO() Phase.save_phases(phases, filename=fn) loaded_phases = list(JSONPhaseParser.parse(fn)) def strip_uuid(data): new_data = [] for line in data.split('\n'): if "uuid" not in line: new_data.append(line) return "\n".join(new_data) outp1 = [strip_uuid(phase.dump_object()) for phase in phases] outp2 = [strip_uuid(phase.dump_object()) for phase in loaded_phases] self.assertEqual(outp1, outp2) pass # end of class
class TestProject(unittest.TestCase): project = None def setUp(self): mock_settings() self.project = Project(name="Test Project") def tearDown(self): del self.project def test_not_none(self): self.assertIsNotNone(self.project) test_name = create_object_attribute_test("project", "name", "Test Name") test_date = create_object_attribute_test("project", "date", "19/09/1987") test_description = create_object_attribute_test("project", "description", "Test Description") test_author = create_object_attribute_test("project", "author", "Test Author") test_layout_mode = create_object_attribute_test("project", "layout_mode", "FULL") test_display_marker_align = create_object_attribute_test( "project", "display_marker_align", "right") test_display_marker_color = create_object_attribute_test( "project", "display_marker_color", "#FF00FF") test_display_marker_base = create_object_attribute_test( "project", "display_marker_base", 2) test_display_marker_top = create_object_attribute_test( "project", "display_marker_top", 1) test_display_marker_top_offset = create_object_attribute_test( "project", "display_marker_top_offset", 0.5) test_display_marker_angle = create_object_attribute_test( "project", "display_marker_angle", 45.6) test_display_marker_style = create_object_attribute_test( "project", "display_marker_style", "dashed") test_display_calc_color = create_object_attribute_test( "project", "display_calc_color", "#FF0099") test_display_exp_color = create_object_attribute_test( "project", "display_exp_color", "#9900FF") test_display_calc_lw = create_object_attribute_test( "project", "display_calc_lw", 5) test_display_exp_lw = create_object_attribute_test("project", "display_exp_lw", 1) test_display_plot_offset = create_object_attribute_test( "project", "display_plot_offset", 1.5) test_display_group_by = create_object_attribute_test( "project", "display_group_by", 3) test_display_label_pos = create_object_attribute_test( "project", "display_label_pos", 0.75) test_axes_xscale = create_object_attribute_test("project", "axes_xscale", 1) test_axes_xmin = create_object_attribute_test("project", "axes_xmin", 15) test_axes_xmax = create_object_attribute_test("project", "axes_xmax", 52) test_axes_xstretch = create_object_attribute_test("project", "axes_xstretch", True) test_axes_yscale = create_object_attribute_test("project", "axes_yscale", 1) test_axes_yvisible = create_object_attribute_test("project", "axes_yvisible", True) # TODO # - addition of phases, specimens & atom_types # - loading of phases, specimens & atom_types # - testing inherit properties (markers) # - testing initialization deprecated keywords etc. pass # end of class
class TestLineMixin(): def setUp(self): self.line = self.line_type() self.observer = LineObserver(model=self.line) def tearDown(self): self.observer.relieve_model(self.line) del self.observer del self.line def test_not_none(self): self.assertIsNotNone(self.line) test_lw = create_object_attribute_test('line', 'lw', 5) test_color = create_object_attribute_test('line', 'color', '#FF0000') test_label = create_object_attribute_test('line', 'label', '#FF0000') def _set_some_data(self): x = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 ] y = [ 0, 0, 0, 0, 0, 0, 10, 20, 30, 40, 80, 160, 80, 40, 30, 20, 10, 0, 0, 0 ] y = list(zip(y, y)) self.line.set_data(x, y) def test_updates(self): self.observer.needs_update_recieved = False self._set_some_data() self.assertTrue(self.observer.needs_update_recieved) def test_data(self): self._set_some_data() self.assertEqual(self.line.num_columns, 3) self.assertEqual(self.line.max_intensity, 160) self.assertEqual(self.line.size, 20) self.assertEqual(self.line.get_y_at_x(7), 10) self.assertEqual(self.line.get_y_at_x(10.5), 60) def test_names(self): self.observer.needs_update_recieved = False self._set_some_data() names = ["TestName"] self.line.y_names = names self.assertEqual(self.line.get_y_name(0), names[0]) def test_append_valid(self): self.line.append(0, 0) self.assertEqual(self.line[0], (0.0, [0.0])) def test_append_valid_multi(self): self.line.append(0, [0, 1, 2]) self.assertEqual(self.line[0], (0.0, [0.0, 1.0, 2.0])) def test_signal(self): self.observer.needs_update_recieved = False self.line.lw = 10 self.assertTrue(self.observer.needs_update_recieved) def test_serialisation(self): x = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 ] y = [ 0, 0, 0, 0, 0, 0, 10, 20, 30, 40, 80, 160, 80, 40, 30, 20, 10, 0, 0, 0 ] self.line.set_data(x, y) serialised1 = self.line._serialize_data() self.line._set_from_serial_data(serialised1) serialised2 = self.line._serialize_data() self.assertEqual(serialised1, serialised2) pass # end of class
class TestAtomType(unittest.TestCase): atom_type = None def setUp(self): self.atom_type = AtomType() def tearDown(self): del self.atom_type def test_not_none(self): self.assertIsNotNone(self.atom_type) def test_data_object(self): self.assertIsNotNone(self.atom_type.data_object) test_name = create_object_attribute_test("atom_type", "name", "Test Name") test_charge = create_object_attribute_test("atom_type", "charge", -5) test_debye = create_object_attribute_test("atom_type", "debye", 1.0) test_weight = create_object_attribute_test("atom_type", "weight", 60.123) test_atom_nr = create_object_attribute_test("atom_type", "atom_nr", 20) test_par_c = create_object_attribute_test("atom_type", "par_c", 10.2) test_par_a1 = create_object_attribute_test("atom_type", "par_a1", 10.2) test_par_a2 = create_object_attribute_test("atom_type", "par_a2", 10.2) test_par_a3 = create_object_attribute_test("atom_type", "par_a3", 10.2) test_par_a4 = create_object_attribute_test("atom_type", "par_a4", 10.2) test_par_a5 = create_object_attribute_test("atom_type", "par_a5", 10.2) test_par_b1 = create_object_attribute_test("atom_type", "par_b1", 10.2) test_par_b2 = create_object_attribute_test("atom_type", "par_b2", 10.2) test_par_b3 = create_object_attribute_test("atom_type", "par_b3", 10.2) test_par_b4 = create_object_attribute_test("atom_type", "par_b4", 10.2) test_par_b5 = create_object_attribute_test("atom_type", "par_b5", 10.2) def test_parent(self): parent_atom_type = AtomType(name="Parent") self.atom_type.parent = parent_atom_type self.assertEqual(self.atom_type.parent, parent_atom_type) def test_get_atomic_scattering_factors(self): import numpy as np stl_range = np.array([0.1152, 0.5756, 1.1469]) self.atom_type.par_a1 = 10.2 self.atom_type.par_a2 = 10.2 self.atom_type.par_a3 = 10.2 self.atom_type.par_a4 = 10.2 self.atom_type.par_a5 = 10.2 self.atom_type.par_b1 = 10.2 self.atom_type.par_b2 = 10.2 self.atom_type.par_b3 = 10.2 self.atom_type.par_b4 = 10.2 self.atom_type.par_b5 = 10.2 self.atom_type.par_c = 20.2 self.assertListEqual( self.atom_type.get_atomic_scattering_factors(stl_range).tolist(), [71.1827439324707, 70.77093939463964, 69.51772020477823]) pass # end of class
class TestComponent(unittest.TestCase): component = None def setUp(self): self.component = Component() def tearDown(self): del self.component def test_not_none(self): self.assertIsNotNone(self.component) def test_data_object(self): self.assertIsNotNone(self.component.data_object) test_name = create_object_attribute_test("component", "name", "Test Name") test_d001 = create_object_attribute_test("component", "d001", 0.789) test_default_c = create_object_attribute_test("component", "default_c", 0.646) test_delta_c = create_object_attribute_test("component", "delta_c", 0.002) test_inherit_atom_relations = create_object_attribute_test( "component", "inherit_atom_relations", True) test_inherit_interlayer_atoms = create_object_attribute_test( "component", "inherit_interlayer_atoms", True) test_inherit_layer_atoms = create_object_attribute_test( "component", "inherit_layer_atoms", True) test_inherit_delta_c = create_object_attribute_test( "component", "inherit_delta_c", True) test_inherit_default_c = create_object_attribute_test( "component", "inherit_default_c", True) test_inherit_ucp_a = create_object_attribute_test("component", "inherit_ucp_a", True) test_inherit_ucp_b = create_object_attribute_test("component", "inherit_ucp_b", True) test_inherit_d001 = create_object_attribute_test("component", "inherit_d001", True) def _setup_inheritance(self): self.component2 = Component() self.component2.linked_with = self.component self.component2.inherit_atom_relations = True # TODO self.component2.inherit_interlayer_atoms = True # TODO self.component2.inherit_layer_atoms = True # TODO self.component2.inherit_delta_c = True self.component2.inherit_default_c = True self.component2.inherit_ucp_a = True # TODO self.component2.inherit_ucp_b = True # TODO self.component2.inherit_d001 = True def test_inheritance_for_delta_c(self): self._setup_inheritance() self.component.delta_c = 0.005 self.assertEqual(self.component2.delta_c, 0.005) def test_inheritance_for_default_c(self): self._setup_inheritance() self.component.default_c = 0.750 self.assertEqual(self.component2.default_c, 0.750) def test_inheritance_for_d001(self): self._setup_inheritance() self.component.d001 = 0.750 self.assertEqual(self.component2.d001, 0.750) pass # end of class
class TestMixture(unittest.TestCase): atom_type = None def setUp(self): mock_settings() self.project = Project(name="TestProject") self.mixture = Mixture(name="TestMixture", parent=self.project) def tearDown(self): del self.mixture del self.project def test_not_none(self): self.assertIsNotNone(self.mixture) def test_data_object(self): self.assertIsNotNone(self.mixture.data_object) test_name = create_object_attribute_test("mixture", "name", "Test Name") def test_parent(self): parent_project = Project(name="Parent2") self.mixture.parent = parent_project self.assertEqual(self.mixture.parent, parent_project) def test_add_phase_slot(self): index = self.mixture.add_phase_slot("TestPhase", 0.5) self.assertEqual(index, 0, "Adding a phase slot should return the correct index!") def test_add_specimen_slot(self): index = self.mixture.add_specimen_slot(None, 1.0, 0) self.assertEqual(index, 0, "Adding a specimen slot should return the correct index!") def test_add_order1(self): """Test if addition works when 1st specimen slot is added before 1st phase slot""" self.mixture.add_specimen_slot(None, 1.0, 0) self.assertEqual(len(self.mixture.specimens), 1) self.assertEqual(len(self.mixture.phases), 0) self.assertEqual(len(self.mixture.fractions), 0) self.assertEqual(self.mixture.phase_matrix.shape, (1, 0)) self.mixture.add_phase_slot("TestPhase", 0.5) self.assertEqual(len(self.mixture.specimens), 1) self.assertEqual(len(self.mixture.phases), 1) self.assertEqual(len(self.mixture.fractions), 1) self.assertEqual(self.mixture.phase_matrix.shape, (1, 1)) self.assertEqual(self.mixture.phase_matrix[0, 0], None) def test_add_order2(self): """Test if addition works when 1st phase slot is added before 1st specimen slot""" self.mixture.add_phase_slot("TestPhase", 0.5) self.assertEqual(len(self.mixture.specimens), 0) self.assertEqual(len(self.mixture.phases), 1) self.assertEqual(len(self.mixture.fractions), 1) self.assertEqual(self.mixture.phase_matrix.shape, (0, 1)) self.mixture.add_specimen_slot(None, 1.0, 0) self.assertEqual(len(self.mixture.specimens), 1) self.assertEqual(len(self.mixture.phases), 1) self.assertEqual(len(self.mixture.fractions), 1) self.assertEqual(self.mixture.phase_matrix.shape, (1, 1)) self.assertEqual(self.mixture.phase_matrix[0, 0], None) def test_add_multiple(self): """Test if addition for multiple phases and specimens works as expected""" self.mixture.add_phase_slot("TestPhase", 0.5) self.mixture.add_specimen_slot(None, 1.0, 0) self.mixture.add_specimen_slot(None, 1.0, 0) self.mixture.add_phase_slot("TestPhase2", 0.5) self.mixture.add_phase_slot("TestPhase3", 0.5) self.assertEqual(len(self.mixture.specimens), 2) self.assertEqual(len(self.mixture.phases), 3) self.assertEqual(len(self.mixture.fractions), 3) self.assertEqual(self.mixture.phase_matrix.shape, (2, 3)) def test_del_phase_slot(self): """Test if deleting a phase works as expected""" self.mixture.add_phase_slot("TestPhase1", 0.1) self.mixture.add_phase_slot("TestPhase2", 0.1) self.mixture.del_phase_slot(1) self.assertEqual(len(self.mixture.phases), 1) self.assertEqual(len(self.mixture.fractions), 1) self.assertEqual(self.mixture.phase_matrix.shape, (0, 1)) self.mixture.del_phase_slot(0) self.assertEqual(len(self.mixture.phases), 0) self.assertEqual(len(self.mixture.fractions), 0) self.assertEqual(self.mixture.phase_matrix.shape, (0, 0)) def test_del_specimen_slot(self): """Test if deleting a specimen works as expected""" self.mixture.add_specimen_slot(None, 0.5, 0) self.mixture.add_specimen_slot(None, 0.5, 0) self.mixture.del_specimen_slot(1) self.assertEqual(len(self.mixture.specimens), 1) self.assertEqual(self.mixture.phase_matrix.shape, (1, 0)) self.mixture.del_specimen_slot(0) self.assertEqual(len(self.mixture.specimens), 0) self.assertEqual(self.mixture.phase_matrix.shape, (0, 0)) def test_del_phase_slot_by_name(self): self.mixture.add_phase_slot("TestPhase1", 0.1) self.mixture.del_phase_slot_by_name("TestPhase1") self.assertEqual(len(self.mixture.phases), 0) self.assertEqual(len(self.mixture.fractions), 0) self.assertEqual(self.mixture.phase_matrix.shape, (0, 0)) def test_del_specimen_slot_by_object(self): dummy = Specimen(name="Test Specimen", parent=self.project) self.project.specimens.append(dummy) self.mixture.add_specimen_slot(dummy, 0.5, 0) self.mixture.del_specimen_slot_by_object(dummy) self.assertEqual(len(self.mixture.specimens), 0) self.assertEqual(self.mixture.phase_matrix.shape, (0, 0)) def test_set_specimen(self): dummy = Specimen(name="Test Specimen", parent=self.project) self.project.specimens.append(dummy) self.mixture.add_specimen_slot(None, 0.5, 0) self.mixture.set_specimen(0, dummy) self.assertEqual(self.mixture.specimens[0], dummy) def test_unset_specimen(self): dummy = Specimen(name="Test Specimen", parent=self.project) self.project.specimens.append(dummy) self.mixture.add_specimen_slot(dummy, 0.5, 0) self.mixture.unset_specimen(dummy) self.assertEqual(self.mixture.specimens[0], None) def test_unset_phase(self): specimen = Specimen(name="Test Specimen", parent=self.project) self.project.specimens.append(specimen) self.mixture.add_specimen_slot(specimen, 0.5, 0) self.mixture.add_phase_slot("Test Phase1", 0.5) dummy = Phase(name="Test Phase", parent=self.project) self.project.phases.append(dummy) self.mixture.set_phase(0, 0, dummy) self.mixture.unset_phase(dummy) self.assertEqual(self.mixture.phase_matrix[0, 0], None) def test_randomize_empty_mixture(self): self.mixture.refinement.randomize() def _refinement_setup(self): # TODO maybe add some more variation in the type of Phases? specimen = Specimen(name="Test Specimen", parent=self.project) self.project.specimens.append(specimen) phase1 = Phase(name="Test Phase1", parent=self.project) self.project.phases.append(phase1) phase2 = Phase(name="Test Phase2", parent=self.project) self.project.phases.append(phase2) self.mixture.add_specimen_slot(specimen, 0.5, 0) self.mixture.add_phase_slot("Test Phase1", 0.5) self.mixture.add_phase_slot("Test Phase2", 0.5) self.mixture.set_phase(0, 0, phase1) self.mixture.set_phase(0, 1, phase2) def test_randomize(self): self._refinement_setup() # Mark the attribute(s) for refinement & get their values: refinables = [] for node in self.mixture.refinables.iter_children(): ref_prop = node.object if ref_prop.refinable: ref_prop.refine = True refinables.append((ref_prop, ref_prop.value)) # Randomize: self.mixture.refinement.randomize() # Check all of them have been randomized: # It is possible (but unlikely) that the randomized value # is the same as the pre-randomized value. If so run this test again # to make sure it is really failing. for ref_prop, pre_val in refinables: self.assertNotEqual(pre_val, ref_prop.value) def test_auto_restrict_empy_mixture(self): self.mixture.refinement.auto_restrict() def test_auto_restrict(self): self._refinement_setup() # Mark the attribute(s) for refinement & get their values: refinables = [] for node in self.mixture.refinables.iter_children(): ref_prop = node.object if ref_prop.refinable: ref_prop.refine = True refinables.append((ref_prop, ref_prop.value)) # Randomize: self.mixture.refinement.auto_restrict() # Check all of them have been restricted: for ref_prop, pre_val in refinables: self.assertEqual(pre_val * 0.8, ref_prop.value_min) self.assertEqual(pre_val * 1.2, ref_prop.value_max) # TODO: # - set_data_object # - optimize # - apply_current_data_object # - update # - get_refinement_method # - setup_refine_options pass # end of class
class TestAtom(unittest.TestCase): atom_type = None def setUp(self): self.atom = Atom() def tearDown(self): del self.atom def get_mocked_hierarchy(self): oxygen = Mock() oxygen.name = "O1-" hydrogen = Mock() hydrogen.name = "H+" project = Mock() project.atom_types = [oxygen, hydrogen] phase = Mock() phase.attach_mock(project, 'project') component = Mock() component.attach_mock(phase, 'phase') return oxygen, hydrogen, component, phase, project def test_not_none(self): self.assertIsNotNone(self.atom) def test_data_object(self): self.assertIsNotNone(self.atom.data_object) test_name = create_object_attribute_test("atom", "name", "Test Name") test_pn = create_object_attribute_test("atom", "pn", 3) test_default_z = create_object_attribute_test("atom", "default_z", 5.3) test_stretch_values = create_object_attribute_test("atom", "stretch_values", True) def test_parent(self): parent_atom = Atom(name="Parent") self.atom.parent = parent_atom self.assertEqual(self.atom.parent, parent_atom) def test_set_atom_type(self): oxygen, hydrogen, component, _, _ = self.get_mocked_hierarchy() atom = Atom( parent=component, name="O", atom_type=oxygen, ) atom.atom_type = hydrogen self.assertEqual(atom.atom_type, hydrogen) def test_z_calculations(self): # Checks wether the atom can calculate stretched values: # 1. When everything is set up the way it should be: default_z = 9.0 lattice_d = 5.4 factor = 0.5 parent = Mock() parent.configure_mock(**{ 'get_interlayer_stretch_factors.return_value': (lattice_d, factor) }) atom = Atom(parent=parent) atom.stretch_values = True atom.default_z = default_z z = atom.z self.assertEqual(z, lattice_d + (default_z - lattice_d) * factor) # 2. When no component is set, but stretched is True: should not raise an error, but simple ignore the stretching atom.parent = None z = atom.z def test_structure_factors(self): import numpy as np rng = 2.0 * np.sin(np.arange(30)) / 0.154056 res = self.atom.get_structure_factors(rng) self.assertIsNotNone(res) def test_loads_atom_type_by_name(self): atom_json_dict = { "uuid": "878341b04e9e11e2b238150ae229a525", "name": "O", "default_z": 0.66, "pn": 6.0, "atom_type_name": "O1-" } oxygen, _, component, _, _ = self.get_mocked_hierarchy() atom = Atom.from_json(parent=component, **atom_json_dict) atom.resolve_json_references() self.assertEqual(atom.atom_type, oxygen) pass # end of class
class TestR1G4Model(AbstractTestProbModel, unittest.TestCase): prob_model_type = R1G4Model test_W1 = create_object_attribute_test("prob_model", "W1", 0.7) test_P11_or_P22 = create_object_attribute_test("prob_model", "P11_or_P22", 0.7) test_R1 = create_object_attribute_test("prob_model", "R1", 0.7) test_R2 = create_object_attribute_test("prob_model", "R2", 0.7) test_G1 = create_object_attribute_test("prob_model", "G1", 0.7) test_G2 = create_object_attribute_test("prob_model", "G2", 0.7) test_G11 = create_object_attribute_test("prob_model", "G11", 0.7) test_G12 = create_object_attribute_test("prob_model", "G12", 0.7) test_G21 = create_object_attribute_test("prob_model", "G21", 0.7) test_G22 = create_object_attribute_test("prob_model", "G22", 0.7) test_G31 = create_object_attribute_test("prob_model", "G31", 0.7) test_G22 = create_object_attribute_test("prob_model", "G32", 0.7) pass # end of class
class TestComponent(unittest.TestCase): component = None def setUp(self): self.component = Component() def tearDown(self): del self.component def test_not_none(self): self.assertIsNotNone(self.component) def test_data_object(self): self.assertIsNotNone(self.component.data_object) test_name = create_object_attribute_test("component", "name", "Test Name") test_d001 = create_object_attribute_test("component", "d001", 0.789) test_default_c = create_object_attribute_test("component", "default_c", 0.646) test_delta_c = create_object_attribute_test("component", "delta_c", 0.002) test_inherit_atom_relations = create_object_attribute_test( "component", "inherit_atom_relations", True) test_inherit_interlayer_atoms = create_object_attribute_test( "component", "inherit_interlayer_atoms", True) test_inherit_layer_atoms = create_object_attribute_test( "component", "inherit_layer_atoms", True) test_inherit_delta_c = create_object_attribute_test( "component", "inherit_delta_c", True) test_inherit_default_c = create_object_attribute_test( "component", "inherit_default_c", True) test_inherit_ucp_a = create_object_attribute_test("component", "inherit_ucp_a", True) test_inherit_ucp_b = create_object_attribute_test("component", "inherit_ucp_b", True) test_inherit_d001 = create_object_attribute_test("component", "inherit_d001", True) pass # end of class