New easycore (#259)

* changes for new easycore.

* work on dependent parameters.

* install libs before installing python deps

* fixes for dependent parameters

* added constraint display

* remove constraint works now

* CR fixes

Author: rozyczko

.github/workflows/installer.yml

@@ -31,6 +31,13 @@ jobs:
       - name: Upgrade package installer for Python
         run: python -m pip install --upgrade pip
 
+      - name: Install needed libraries (Linux)
+        if: runner.os == 'Linux'
+        run: |
+          sudo apt-get update
+          sudo apt-get install libxcb-icccm4 libxcb-image0 libxcb-keysyms1 libxcb-randr0 libxcb-render-util0 libxcb-xfixes0 libxcb-shape0 libxcb-cursor0
+          sudo apt-get install libcairo2-dev pkg-config
+
       - name: Install Python dependences
         run: |
           python -m pip install flit
@@ -74,11 +81,12 @@ jobs:
         run: |
           echo "SETUP_EXE_PATH=$(python ${{ env.SCRIPTS_PATH }}/Config.py ${{ env.BRANCH_NAME }} ${{ matrix.os }} setup_exe_path)" >> $GITHUB_ENV
 
-      - name: Install needed libraries (Linux)
-        if: runner.os == 'Linux'
-        run: |
-          sudo apt-get update
-          sudo apt-get install libxcb-icccm4 libxcb-image0 libxcb-keysyms1 libxcb-randr0 libxcb-render-util0 libxcb-xfixes0 libxcb-shape0 libxcb-cursor0
+      # - name: Install needed libraries (Linux)
+      #   if: runner.os == 'Linux'
+      #   run: |
+      #     sudo apt-get update
+      #     sudo apt-get install libxcb-icccm4 libxcb-image0 libxcb-keysyms1 libxcb-randr0 libxcb-render-util0 libxcb-xfixes0 libxcb-shape0 libxcb-cursor0
+      #     sudo apt-get install libcairo2-dev pkg-config
 
       # - name: Run app in testmode and quit
       #   shell: bash

EasyReflectometryApp/Backends/Mock/Sample.qml

@@ -3,6 +3,8 @@ pragma Singleton
 import QtQuick
 
 QtObject {
+    // Signals to match the Python backend
+    signal constraintsChanged
     // MATERIALS
     readonly property int currentMaterialIndex: -1
 
@@ -271,11 +273,58 @@ QtObject {
         'parameter 2',
         'parameter 3'
     ]
-    readonly property var relationOperators: ['=', '&lt', '&gt']
+    readonly property var relationOperators: ['=', '<', '>']
     readonly property var arithmicOperators: ['', '*', '/', '+', '-']
 
+    // Mock constraints data - matches the new simplified format
+    property var constraintsList: [
+        {
+            dependentName: "Thickness Layer 1",
+            expression: "2.0 * parameter 2 + 1.5"
+        },
+        {
+            dependentName: "Roughness Layer 2",
+            expression: "parameter 1 / 3.14"
+        },
+        {
+            dependentName: "SLD Layer 3",
+            expression: "5.0"
+        }
+    ]
+
     function addConstraint(value1, value2, value3, value4, value5) {
         console.debug(`addConstraint ${value1} ${value2} ${value3} ${value4} ${value5}`)
+
+        // Create constraint object in the new simplified format
+        let expression = ""
+        if (value5 >= 0 && value5 < parameterNames.length) {
+            // Parameter-parameter constraint
+            expression = `${value3} ${value4} ${parameterNames[value5]}`
+        } else {
+            // Numeric constraint
+            expression = `= ${value3}`
+        }
+
+        const constraint = {
+            dependentName: parameterNames[value1] || "Unknown",
+            expression: expression
+        }
+
+        // Add to constraints list - need to reassign the array to trigger property change
+        var newConstraints = constraintsList.slice() // Create a copy
+        newConstraints.push(constraint)
+        constraintsList = newConstraints
+        constraintsChanged()
+    }
+
+    function removeConstraintByIndex(index) {
+        console.debug(`removeConstraintByIndex ${index}`)
+        if (index >= 0 && index < constraintsList.length) {
+            var newConstraints = constraintsList.slice() // Create a copy
+            newConstraints.splice(index, 1)
+            constraintsList = newConstraints
+            constraintsChanged()
+        }
     }
 
     // Q Range

EasyReflectometryApp/Backends/Py/logic/models.py

@@ -81,23 +81,23 @@ def add_new(self) -> None:
         self._models[-1].sample.data[0].layers.data[0].material = self._project_lib._materials[
             self._project_lib.get_index_air()
         ]
-        self._models[-1].sample.data[0].layers.data[0].thickness = 0.0
-        self._models[-1].sample.data[0].layers.data[0].roughness = 0.0
+        self._models[-1].sample.data[0].layers.data[0].thickness.value = 0.0
+        self._models[-1].sample.data[0].layers.data[0].roughness.value = 0.0
         self._models[-1].sample.data[0].name = 'Superphase'
 
         self._models[-1].sample.data[1].layers.data[0].material = self._project_lib._materials[
             self._project_lib.get_index_sio2()
         ]
-        self._models[-1].sample.data[1].layers.data[0].thickness = 20.0
-        self._models[-1].sample.data[1].layers.data[0].roughness = 3.0
+        self._models[-1].sample.data[1].layers.data[0].thickness.value = 20.0
+        self._models[-1].sample.data[1].layers.data[0].roughness.value = 3.0
         self._models[-1].sample.data[1].name = 'SiO2'
 
         self._models[-1].sample.data[2].layers.data[0].material = self._project_lib._materials[
             self._project_lib.get_index_si()
         ]
         self._models[-1].sample.data[2].name = 'Substrate'
-        self._models[-1].sample.data[2].layers.data[0].thickness = 0.0
-        self._models[-1].sample.data[2].layers.data[0].roughness = 1.2
+        self._models[-1].sample.data[2].layers.data[0].thickness.value = 0.0
+        self._models[-1].sample.data[2].layers.data[0].roughness.value = 1.2
 
         self._models[-1].sample._disable_changes_to_outermost_layers()
 

EasyReflectometryApp/Backends/Py/logic/parameters.py

@@ -4,9 +4,7 @@
 from easyreflectometry.utils import count_fixed_parameters
 from easyreflectometry.utils import count_free_parameters
 from easyscience import global_object
-from easyscience.Constraints import NumericConstraint
-from easyscience.Constraints import ObjConstraint
-from easyscience.Objects.variable import Parameter
+from easyscience.variable import Parameter
 
 
 class Parameters:
@@ -90,39 +88,63 @@ def add_constraint(
         dependent = self._project_lib.parameters[dependent_idx]
 
         if arithmetic_operator != '' and independent_idx > -1:
-            constaint = ObjConstraint(
-                dependent_obj=dependent, operator=str(float(value)) + arithmetic_operator, independent_obj=independent
-            )
+            dependent.make_dependent_on(
+                dependency_expression='a' + arithmetic_operator + 'b', dependency_map={'a': independent, 'b': float(value)})
         elif arithmetic_operator == '' and independent_idx == -1:
             relational_operator = relational_operator.replace('=', '==')
             relational_operator = relational_operator.replace('&lt', '>')
             relational_operator = relational_operator.replace('&gt', '<')
-            constaint = NumericConstraint(dependent_obj=dependent, operator=relational_operator, value=float(value))
+
+            dependent.make_dependent_on(dependency_expression='a', dependency_map={'a': float(value)})
         else:
             print('Failed to add constraint: Unsupported type')
             return
-        # print(c)
-        independent.user_constraints[dependent.name] = constaint
-        constaint()
 
         print(f'{dependent_idx}, {relational_operator}, {value}, {arithmetic_operator}, {independent_idx}')
 
-
 def _from_parameters_to_list_of_dicts(parameters: List[Parameter], model_unique_name: str) -> list[dict[str, str]]:
+    """Convert parameters to list of dictionaries with simplified logic."""
+
+    def _get_parameter_display_name(param: Parameter) -> str:
+        """Extract display name from parameter path."""
+        path = global_object.map.find_path(model_unique_name, param.unique_name)
+        if len(path) >= 2:
+            parent_name = global_object.map.get_item_by_key(path[-2]).name
+            param_name = global_object.map.get_item_by_key(path[-1]).name
+            return f'{parent_name} {param_name}'
+        return param.name  # Fallback to parameter name
+
+    def _get_dependency_expression(param: Parameter) -> str:
+        """Get simplified dependency expression."""
+        if param.independent:
+            return ''
+
+        # Check if parameter has dependency map with 'a' key (parameter dependency)
+        if hasattr(param, 'dependency_map') and 'a' in param.dependency_map:
+            dependent_param = param.dependency_map['a']
+            dep_name = _get_parameter_display_name(dependent_param)
+            return param.dependency_expression.replace('a', dep_name)
+
+        # Simple numerical dependency
+        return f'= {param.value}'
+
     parameter_list = []
     for parameter in parameters:
-        path = global_object.map.find_path(model_unique_name, parameter.unique_name)
-        if 0 < len(path):
-            name = f'{global_object.map.get_item_by_key(path[-2]).name} {global_object.map.get_item_by_key(path[-1]).name}'
-            parameter_list.append(
-                {
-                    'name': name,
-                    'value': float(parameter.value),
-                    'error': float(parameter.variance),
-                    'max': float(parameter.max),
-                    'min': float(parameter.min),
-                    'units': parameter.unit,
-                    'fit': parameter.free,
-                }
-            )
+        # Skip parameters not in the current model path
+        if not global_object.map.find_path(model_unique_name, parameter.unique_name):
+            continue
+
+        parameter_list.append({
+            'name': _get_parameter_display_name(parameter),
+            'value': float(parameter.value),
+            'error': float(parameter.variance),
+            'max': float(parameter.max),
+            'min': float(parameter.min),
+            'units': parameter.unit,
+            'fit': parameter.free,
+            'independent': parameter.independent,
+            'dependency': _get_dependency_expression(parameter),
+            'object': parameter,  # Direct reference to the Parameter object
+        })
+
     return parameter_list

EasyReflectometryApp/Backends/Py/sample.py

@@ -26,6 +26,7 @@ class Sample(QObject):
     layersIndexChanged = Signal()
 
     qRangeChanged = Signal()
+    constraintsChanged = Signal()
 
     externalRefreshPlot = Signal()
     externalSampleChanged = Signal()
@@ -412,6 +413,10 @@ def _clearCacheAndEmitLayersChanged(self):
     def parameterNames(self) -> list[dict[str, str]]:
         return [parameter['name'] for parameter in self._parameters_logic.parameters]
 
+    @Property('QVariantList', notify=layersChange)
+    def dependentParameterNames(self) -> list[dict[str, str]]:
+        return [parameter['name'] for parameter in self._parameters_logic.parameters if parameter['independent']]
+
     @Property('QVariantList', notify=layersChange)
     def relationOperators(self) -> list[str]:
         return self._parameters_logic.constraint_relations()
@@ -420,16 +425,93 @@ def relationOperators(self) -> list[str]:
     def arithmicOperators(self) -> list[str]:
         return self._parameters_logic.constraint_arithmetic()
 
+    @Property('QVariantList', notify=constraintsChanged)
+    def constraintsList(self) -> list[dict[str, str]]:
+        """Get the list of active constraints from dependent parameters."""
+        constraints = []
+        parameters = self._parameters_logic.parameters
+        for param in parameters:
+            if not param['independent']:
+                constraints.append({param['name']: param['dependency']})
+
+        return constraints
+
+    @Slot(int)
+    def removeConstraintByIndex(self, index_str: str) -> None:
+        """Remove constraint by index by making the parameter independent."""
+        try:
+            index = int(index_str)
+        except ValueError:
+            return
+
+        constraints_list = self.constraintsList
+        if index >= len(constraints_list):
+            return
+
+        param_name = list(constraints_list[index].keys())[0]
+        param_obj = self._find_parameter_object_by_name(param_name)
+
+        if param_obj is None or param_obj.independent:
+            return
+
+        self._make_parameter_independent(param_obj)
+        self.constraintsChanged.emit()
+        self.externalSampleChanged.emit()
+
+    def _find_parameter_object_by_name(self, param_name: str):
+        """Find parameter object by name."""
+        parameters = self._parameters_logic.parameters
+        for param in parameters:
+            if param['name'] == param_name:
+                return param['object']
+        return None
+
+    def _make_parameter_independent(self, param_obj) -> None:
+        """Make a parameter independent, handling different parameter types."""
+        try:
+            param_obj.make_independent()
+        except AttributeError:
+            param_obj._independent = True  # Fallback for custom ERL constraints
+
     @Slot(str, str, str, str, str)
     def addConstraint(self, value1: str, value2: str, value3: str, value4: str, value5: str) -> None:
-        self._parameters_logic.add_constraint(
-            dependent_idx=int(value1),
-            relational_operator=value2,
-            value=float(value3),
-            arithmetic_operator=value4,
-            independent_idx=int(value5),
-        )
+        dependent = self._project_lib.parameters[int(value1)]
+        if value5 == '-1':
+            independent = None
+        else:
+            independent = self._project_lib.parameters[int(value5)]
+        relational_operator = value2
+        arithmetic_operator = value4
+        value = float(value3)
+        if arithmetic_operator == '':
+            if relational_operator == '=':
+                # simple parameter equality
+                # assign to the parameter and make it frozen
+                dependent.value = value
+                dependent.free = False
+                # here, we need to make the parameter "dependent" so it can't be changed in GUI
+                dependent._independent = False
+
+            elif relational_operator == '>':
+                # set the minimum value of the parameter
+                dependent.min = value
+                dependent.free = True
+
+            elif relational_operator == '<':
+                # set the maximum value of the parameter
+                dependent.max = value
+                dependent.free = True
+        else:
+            # make the parameter dependent on another parameter
+            # e.g. thickness = 2 * a + 5
+            expr = "a " + arithmetic_operator + str(float(value))
+            dependency_map = {'a': independent}
+            dependent.make_dependent_on(
+                dependency_expression=expr, dependency_map=dependency_map
+            )
+        self.constraintsChanged.emit()
         self.externalSampleChanged.emit()
+        self.layersChange.emit()
 
     # # #
     # Q Range

EasyReflectometryApp/Gui/Globals/BackendWrapper.qml

@@ -159,10 +159,13 @@ QtObject {
 
     // Constraints
     readonly property var sampleParameterNames: activeBackend.sample.parameterNames
+    readonly property var sampleDepParameterNames: activeBackend.sample.dependentParameterNames
     readonly property var sampleRelationOperators: activeBackend.sample.relationOperators
     readonly property var sampleArithmicOperators: activeBackend.sample.arithmicOperators
+    readonly property var sampleConstraintsList: activeBackend.sample.constraintsList
 
     function sampleAddConstraint(value1, value2, value3, value4, value5) { activeBackend.sample.addConstraint(value1, value2, value3, value4, value5) }
+    function sampleRemoveConstraintByIndex(value) { activeBackend.sample.removeConstraintByIndex(value) }
 
     // Q range
     readonly property var sampleQMin: activeBackend.sample.q_min