Removed enabled attr

src/easyreflectometry/project.py

@@ -79,12 +79,6 @@ def parameters(self) -> List[Parameter]:
                 parameters.append(vertice_obj)
         return parameters
 
-    @property
-    def enabled_parameters(self) -> List[Parameter]:
-        parameters = self.parameters
-        # Only include enabled parameters
-        return [param for param in parameters if param.enabled]
-
     @property
     def q_min(self):
         if self._q_min is None:

src/easyreflectometry/sample/assemblies/base_assembly.py

@@ -99,8 +99,6 @@ def _enable_thickness_constraints(self):
             # Make sure that the thickness constraint is enabled
             self._setup_thickness_constraints()
             # Make sure that the thickness parameter is enabled
-            for i in range(len(self.layers)):
-                self.layers[i].thickness.enabled = True
         else:
             raise Exception('Thickness constraints not setup')
 

src/easyreflectometry/sample/assemblies/surfactant_layer.py

@@ -103,7 +103,6 @@ def __init__(
 
         self.interface = interface
         self.conformal = False
-        self.head_layer._area_per_molecule.enabled = True
 
         if conformal_roughness:
             self._enable_roughness_constraints()

src/easyreflectometry/sample/collections/sample.py

@@ -50,7 +50,6 @@ def __init__(
             if not issubclass(type(assembly), BaseAssembly):
                 raise ValueError('The elements must be an Assembly.')
         super().__init__(name, interface, unique_name=unique_name, *assemblies, **kwargs)
-        self._disable_changes_to_outermost_layers()
 
     def add_assembly(self, assembly: Optional[BaseAssembly] = None):
         """Add an assembly to the sample.
@@ -62,16 +61,13 @@ def add_assembly(self, assembly: Optional[BaseAssembly] = None):
                 name='EasyMultilayer added',
                 interface=self.interface,
             )
-        self._enable_changes_to_outermost_layers()
         self.append(assembly)
-        self._disable_changes_to_outermost_layers()
 
     def duplicate_assembly(self, index: int):
         """Add an assembly to the sample.
 
         :param assembly: Assembly to add.
         """
-        self._enable_changes_to_outermost_layers()
         to_be_duplicated = self[index]
         if isinstance(to_be_duplicated, Multilayer):
             duplicate = Multilayer.from_dict(to_be_duplicated.as_dict(skip=['unique_name']))
@@ -81,34 +77,27 @@ def duplicate_assembly(self, index: int):
             duplicate = SurfactantLayer.from_dict(to_be_duplicated.as_dict(skip=['unique_name']))
         duplicate.name = duplicate.name + ' duplicate'
         self.append(duplicate)
-        self._disable_changes_to_outermost_layers()
 
     def move_up(self, index: int):
         """Move the assembly at the given index up in the sample.
 
         :param index: Index of the assembly to move up.
         """
-        self._enable_changes_to_outermost_layers()
         super().move_up(index)
-        self._disable_changes_to_outermost_layers()
 
     def move_down(self, index: int):
         """Move the assembly at the given index down in the sample.
 
         :param index: Index of the assembly to move down.
         """
-        self._enable_changes_to_outermost_layers()
         super().move_down(index)
-        self._disable_changes_to_outermost_layers()
 
     def remove_assembly(self, index: int):
         """Remove the assembly at the given index from the sample.
 
         :param index: Index of the assembly to remove.
         """
-        self._enable_changes_to_outermost_layers()
         self.pop(index)
-        self._disable_changes_to_outermost_layers()
 
     @property
     def superphase(self) -> Layer:
@@ -124,26 +113,6 @@ def subphase(self) -> Layer:
         else:
             return self[-1].back_layer
 
-    def _enable_changes_to_outermost_layers(self):
-        """Allowed to change the outermost layers of the sample.
-        Superphase can change thickness and roughness.
-        Subphase can change thickness.
-        """
-        if len(self) != 0:
-            self.superphase.thickness.enabled = True
-            self.superphase.roughness.enabled = True
-            self.subphase.thickness.enabled = True
-
-    def _disable_changes_to_outermost_layers(self):
-        """No allowed to change the outermost layers of the sample.
-        Superphase can change thickness and roughness.
-        Subphase can change thickness.
-        """
-        if len(self) != 0:
-            self.superphase.thickness.enabled = False
-            self.superphase.roughness.enabled = False
-            self.subphase.thickness.enabled = False
-
     # Representation
     def as_dict(self, skip: Optional[List[str]] = None) -> dict:
         """Produces a cleaned dict using a custom as_dict method to skip necessary things.

src/easyreflectometry/sample/elements/materials/material_mixture.py

@@ -113,8 +113,6 @@ def isld(self) -> float:
         return self._isld.value
 
     def _materials_constraints(self):
-        self._sld.enabled = True
-        self._isld.enabled = True
         dependency_expression = 'a * (1 - p) + b * p'
         dependency_map = {'a': self._material_a.sld, 'b': self._material_b.sld, 'p': self._fraction}
         self._sld.make_dependent_on(dependency_expression=dependency_expression, dependency_map=dependency_map)

tests/sample/assemblies/test_base_assembly.py

@@ -56,8 +56,6 @@ def test_enable_thickness_constraints(self, base_assembly: BaseAssembly) -> None
 
         # Expect
         assert self.mock_layer_0.thickness.value == self.mock_layer_0.thickness.value
-        assert self.mock_layer_0.thickness.enabled is True
-        assert self.mock_layer_1.thickness.enabled is True
 
     def test_enable_thickness_constraints_exception(self, base_assembly: BaseAssembly) -> None:
         # When

tests/sample/collections/test_sample.py

@@ -5,7 +5,6 @@
 __author__ = 'github.com/arm61'
 __version__ = '0.0.1'
 
-from unittest.mock import MagicMock
 
 import pytest
 from easyscience import global_object
@@ -40,8 +39,6 @@ def test_dont_populate(self):
     def test_add_assembly(self):
         # When
         p = Sample()
-        p._enable_changes_to_outermost_layers = MagicMock()
-        p._disable_changes_to_outermost_layers = MagicMock()
         surfactant = SurfactantLayer()
 
         # Then
@@ -53,17 +50,13 @@ def test_add_assembly(self):
         assert_equal(p[1].name, 'EasyMultilayer')
         assert_equal(p[2].name, 'EasyMultilayer added')
         assert_equal(p[3].name, 'EasySurfactantLayer')
-        p._enable_changes_to_outermost_layers.assert_called()
-        p._disable_changes_to_outermost_layers.assert_called()
 
     # Problems with parameterized tests START
     def test_duplicate_assembly_multilayer(self):
         # When
         assembly_to_duplicate = Multilayer()
         p = Sample()
         p.add_assembly(assembly_to_duplicate)
-        p._enable_changes_to_outermost_layers = MagicMock()
-        p._disable_changes_to_outermost_layers = MagicMock()
 
         # Then
         p.duplicate_assembly(2)
@@ -73,16 +66,12 @@ def test_duplicate_assembly_multilayer(self):
         assert_equal(p[1].name, 'EasyMultilayer')
         assert_equal(p[2].name, assembly_to_duplicate.name)
         assert_equal(p[3].name, assembly_to_duplicate.name + ' duplicate')
-        p._enable_changes_to_outermost_layers.assert_called_once_with()
-        p._disable_changes_to_outermost_layers.assert_called_once_with()
 
     def test_duplicate_assembly_repeating_multilayer(self):
         # When
         assembly_to_duplicate = RepeatingMultilayer()
         p = Sample()
         p.add_assembly(assembly_to_duplicate)
-        p._enable_changes_to_outermost_layers = MagicMock()
-        p._disable_changes_to_outermost_layers = MagicMock()
 
         # Then
         p.duplicate_assembly(2)
@@ -92,16 +81,12 @@ def test_duplicate_assembly_repeating_multilayer(self):
         assert_equal(p[1].name, 'EasyMultilayer')
         assert_equal(p[2].name, assembly_to_duplicate.name)
         assert_equal(p[3].name, assembly_to_duplicate.name + ' duplicate')
-        p._enable_changes_to_outermost_layers.assert_called_once_with()
-        p._disable_changes_to_outermost_layers.assert_called_once_with()
 
     def test_duplicate_assembly_surfactant(self):
         # When
         assembly_to_duplicate = SurfactantLayer()
         p = Sample()
         p.add_assembly(assembly_to_duplicate)
-        p._enable_changes_to_outermost_layers = MagicMock()
-        p._disable_changes_to_outermost_layers = MagicMock()
 
         # Then
         p.duplicate_assembly(2)
@@ -111,8 +96,6 @@ def test_duplicate_assembly_surfactant(self):
         assert_equal(p[1].name, 'EasyMultilayer')
         assert_equal(p[2].name, assembly_to_duplicate.name)
         assert_equal(p[3].name, assembly_to_duplicate.name + ' duplicate')
-        p._enable_changes_to_outermost_layers.assert_called_once_with()
-        p._disable_changes_to_outermost_layers.assert_called_once_with()
 
     # Problems with parameterized tests END
 
@@ -121,8 +104,6 @@ def test_move_assembly_up(self):
         p = Sample()
         surfactant = SurfactantLayer()
         p.add_assembly(surfactant)
-        p._enable_changes_to_outermost_layers = MagicMock()
-        p._disable_changes_to_outermost_layers = MagicMock()
 
         # Then
         p.move_up(2)
@@ -131,16 +112,12 @@ def test_move_assembly_up(self):
         assert_equal(p[0].name, 'EasyMultilayer')
         assert_equal(p[1].name, surfactant.name)
         assert_equal(p[2].name, 'EasyMultilayer')
-        p._enable_changes_to_outermost_layers.assert_called_once_with()
-        p._disable_changes_to_outermost_layers.assert_called_once_with()
 
     def test_move_assembly_up_index_0(self):
         # When
         p = Sample()
         surfactant = SurfactantLayer()
         p.add_assembly(surfactant)
-        p._enable_changes_to_outermost_layers = MagicMock()
-        p._disable_changes_to_outermost_layers = MagicMock()
 
         # Then
         p.move_up(0)
@@ -149,16 +126,12 @@ def test_move_assembly_up_index_0(self):
         assert_equal(p[0].name, 'EasyMultilayer')
         assert_equal(p[1].name, 'EasyMultilayer')
         assert_equal(p[2].name, surfactant.name)
-        p._enable_changes_to_outermost_layers.assert_called()
-        p._disable_changes_to_outermost_layers.assert_called()
 
     def test_move_assembly_down(self):
         # When
         p = Sample()
         surfactant = SurfactantLayer()
         p.add_assembly(surfactant)
-        p._enable_changes_to_outermost_layers = MagicMock()
-        p._disable_changes_to_outermost_layers = MagicMock()
 
         # Then
         p.move_down(1)
@@ -167,16 +140,12 @@ def test_move_assembly_down(self):
         assert_equal(p[0].name, 'EasyMultilayer')
         assert_equal(p[1].name, surfactant.name)
         assert_equal(p[2].name, 'EasyMultilayer')
-        p._enable_changes_to_outermost_layers.assert_called_once_with()
-        p._disable_changes_to_outermost_layers.assert_called_once_with()
 
     def test_move_assembly_down_index_2(self):
         # When
         p = Sample()
         surfactant = SurfactantLayer()
         p.add_assembly(surfactant)
-        p._enable_changes_to_outermost_layers = MagicMock()
-        p._disable_changes_to_outermost_layers = MagicMock()
 
         # Then
         p.move_down(2)
@@ -185,25 +154,19 @@ def test_move_assembly_down_index_2(self):
         assert_equal(p[0].name, 'EasyMultilayer')
         assert_equal(p[1].name, 'EasyMultilayer')
         assert_equal(p[2].name, surfactant.name)
-        p._enable_changes_to_outermost_layers.assert_called()
-        p._disable_changes_to_outermost_layers.assert_called()
 
     def test_remove_assembly(self):
         # When
         p = Sample()
         surfactant = SurfactantLayer()
         p.add_assembly(surfactant)
-        p._enable_changes_to_outermost_layers = MagicMock()
-        p._disable_changes_to_outermost_layers = MagicMock()
 
         # Then
         p.remove_assembly(1)
 
         # Expect
         assert_equal(p[0].name, 'EasyMultilayer')
         assert_equal(p[1].name, surfactant.name)
-        p._enable_changes_to_outermost_layers.assert_called_once_with()
-        p._disable_changes_to_outermost_layers.assert_called_once_with()
 
     def test_subphase(self):
         # When
@@ -231,36 +194,6 @@ def test_superphase(self):
         # Expect
         assert_equal(layer.name, 'new layer')
 
-    def test_enable_changes_to_outermost_layers(self):
-        # When
-        p = Sample()
-        p.superphase.thickness.enabled = False
-        p.superphase.roughness.enabled = False
-        p.subphase.thickness.enabled = False
-
-        # Then
-        p._enable_changes_to_outermost_layers()
-
-        # Expect
-        assert_equal(p.superphase.thickness.enabled, True)
-        assert_equal(p.superphase.roughness.enabled, True)
-        assert_equal(p.subphase.thickness.enabled, True)
-
-    def test_disable_changes_to_outermost_layers(self):
-        # When
-        p = Sample()
-        p.superphase.thickness.enabled = True
-        p.superphase.roughness.enabled = True
-        p.subphase.thickness.enabled = True
-
-        # Then
-        p._disable_changes_to_outermost_layers()
-
-        # Expect
-        assert_equal(p.superphase.thickness.enabled, False)
-        assert_equal(p.superphase.roughness.enabled, False)
-        assert_equal(p.subphase.thickness.enabled, False)
-
     def test_from_pars(self):
         # When
         m1 = Material(6.908, -0.278, 'Boron')