attempt at making layer names consistent

Author: rozyczko

EasyReflectometryApp/Backends/Py/logic/layers.py

@@ -60,6 +60,8 @@ def add_new(self) -> None:
         index_si = [material.name for material in self._project_lib._materials].index('Si')
         self._layers.add_layer()
         self._layers[-1].material = self._project_lib._materials[index_si]
+        # Set layer name based on material name
+        self._layers[-1].name = self._project_lib._materials[index_si].name + ' Layer'
 
     def duplicate_selected(self) -> None:
         self._layers.duplicate_layer(self.index)
@@ -95,6 +97,8 @@ def set_roughness_at_current_index(self, new_value: float) -> bool:
     def set_material_at_current_index(self, new_value: int) -> bool:
         if self._layers[self.index].material != self._project_lib._materials[new_value]:
             self._layers[self.index].material = self._project_lib._materials[new_value]
+            # Update layer name based on material name
+            self._layers[self.index].name = self._project_lib._materials[new_value].name + ' Layer'
             return True
         return False
 

EasyReflectometryApp/Backends/Py/logic/models.py

@@ -77,33 +77,40 @@ def remove_at_index(self, value: str) -> None:
     def default_model_content(self, model: Model) -> None:
         """Set the default content for a model."""
         model.add_assemblies()
-        model.sample.data[0].layers.data[0].material = self._project_lib._materials[
-            self._project_lib.get_index_air()
-        ]
+        # Superphase (Air layer)
+        air_material = self._project_lib._materials[self._project_lib.get_index_air()]
+        model.sample.data[0].layers.data[0].material = air_material
         model.sample.data[0].layers.data[0].thickness = 0.0
         model.sample.data[0].layers.data[0].roughness = 0.0
+        model.sample.data[0].layers.data[0].name = air_material.name + ' Layer'
         model.sample.data[0].name = 'Superphase'
 
-        model.sample.data[1].layers.data[0].material = self._project_lib._materials[
-            self._project_lib.get_index_sio2()
-        ]
+        # Middle layer (SiO2)
+        sio2_material = self._project_lib._materials[self._project_lib.get_index_sio2()]
+        model.sample.data[1].layers.data[0].material = sio2_material
         model.sample.data[1].layers.data[0].thickness = 100.0
         model.sample.data[1].layers.data[0].roughness = 3.0
+        model.sample.data[1].layers.data[0].name = sio2_material.name + ' Layer'
         model.sample.data[1].name = 'SiO2'
 
-        model.sample.data[2].layers.data[0].material = self._project_lib._materials[
-            self._project_lib.get_index_si()
-        ]
+        # Subphase (Si substrate)
+        si_material = self._project_lib._materials[self._project_lib.get_index_si()]
+        model.sample.data[2].layers.data[0].material = si_material
         model.sample.data[2].name = 'Substrate'
+        model.sample.data[2].layers.data[0].name = si_material.name + ' Layer'
         model.sample.data[2].layers.data[0].thickness = 0.0
         model.sample.data[2].layers.data[0].roughness = 1.2
 
     def add_new(self) -> None:
         self._models.add_model()
         self.default_model_content(self._models[-1])
+        # Update index to point to the new model
+        self.index = len(self._models) - 1
 
     def duplicate_selected_model(self) -> None:
         self._models.duplicate_model(self.index)
+        # Update index to point to the duplicated model
+        self.index = len(self._models) - 1
 
     def move_selected_up(self) -> None:
         if self.index > 0:

EasyReflectometryApp/Backends/Py/logic/parameters.py

@@ -22,9 +22,9 @@ def as_status_string(self) -> str:
         return f'{self.count_free_parameters() + self.count_fixed_parameters()} ({self.count_free_parameters()} free, {self.count_fixed_parameters()} fixed)'  # noqa: E501
 
     @property
-    def parameters(self) -> List[str]:
+    def parameters(self) -> list[dict[str, Any]]:
         return _from_parameters_to_list_of_dicts(
-            self._project_lib.parameters, self._project_lib._models[self._project_lib.current_model_index].unique_name
+            self._project_lib.parameters, self._project_lib._models
         )
 
     def constraint_context(self) -> list[dict[str, Any]]:
@@ -160,10 +160,18 @@ def add_constraint(
 
         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, Any]]:
-    """Convert parameters to list of dictionaries with simplified logic."""
+def _from_parameters_to_list_of_dicts(parameters: List[Parameter], models) -> list[dict[str, Any]]:
+    """Convert parameters to list of dictionaries with simplified logic.
+
+    Layer parameters (thickness, roughness) are prefixed with model identifier (e.g., M1, M2).
+    Material parameters and model parameters (scale, background) are not prefixed to avoid duplication.
+    """
 
     alias_registry: set[str] = set()
+    processed_unique_names: set[str] = set()  # Track processed parameters to avoid duplicates
+
+    # Layer parameter names that need model prefix
+    LAYER_PARAMS = {'thickness', 'roughness'}
 
     def _make_alias(name: str) -> str:
         base = re.sub(r'[^0-9A-Za-z]+', '_', name).strip('_').lower()
@@ -179,7 +187,7 @@ def _make_alias(name: str) -> str:
         alias_registry.add(alias)
         return alias
 
-    def _get_parameter_display_data(param: Parameter) -> Tuple[str, str]:
+    def _get_parameter_display_data(param: Parameter, model_unique_name: str) -> Tuple[str, str]:
         """Extract display name and group from parameter path."""
         path = global_object.map.find_path(model_unique_name, param.unique_name)
         if len(path) >= 2:
@@ -188,7 +196,7 @@ def _get_parameter_display_data(param: Parameter) -> Tuple[str, str]:
             return f'{parent_name} {param_name}', parent_name
         return param.name, ''  # Fallback to parameter name without group
 
-    def _get_dependency_expression(param: Parameter) -> str:
+    def _get_dependency_expression(param: Parameter, model_unique_name: str) -> str:
         """Get simplified dependency expression."""
         if param.independent:
             return ''
@@ -197,38 +205,62 @@ def _get_dependency_expression(param: Parameter) -> str:
         if hasattr(param, 'dependency_map') and 'a' in param.dependency_map:
             dependent_param = param.dependency_map['a']
             if isinstance(dependent_param, Parameter):
-                dep_name, _ = _get_parameter_display_data(dependent_param)
+                dep_name, _ = _get_parameter_display_data(dependent_param, model_unique_name)
             else:
                 dep_name = str(dependent_param)
             return param.dependency_expression.replace('a', dep_name)
 
         # Simple numerical dependency
         return f'= {param.value}'
 
+    def _is_layer_parameter(param: Parameter) -> bool:
+        """Check if parameter is a layer parameter (thickness or roughness)."""
+        return param.name.lower() in LAYER_PARAMS
+
     parameter_list = []
-    for parameter in parameters:
-        # Skip parameters not in the current model path
-        if not global_object.map.find_path(model_unique_name, parameter.unique_name):
-            continue
-
-        display_name, group_name = _get_parameter_display_data(parameter)
-        alias = _make_alias(display_name or parameter.name)
-        parameter_list.append({
-            'name': display_name,
-            'display_name': display_name,
-            'group': group_name,
-            'alias': alias,
-            'unique_name': parameter.unique_name,
-            '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),
-            'enabled': parameter.enabled if hasattr(parameter, 'enabled') else True,
-            'object': parameter,  # Direct reference to the Parameter object
-        })
+
+    # Process parameters for each model
+    for model_idx, model in enumerate(models):
+        model_unique_name = model.unique_name
+        model_prefix = f'M{model_idx + 1}'
+
+        for parameter in parameters:
+            # Skip parameters not in this model's path
+            if not global_object.map.find_path(model_unique_name, parameter.unique_name):
+                continue
+
+            # For non-layer parameters, skip if already processed (they're shared across models)
+            is_layer_param = _is_layer_parameter(parameter)
+            if not is_layer_param:
+                if parameter.unique_name in processed_unique_names:
+                    continue
+                processed_unique_names.add(parameter.unique_name)
+
+            display_name, group_name = _get_parameter_display_data(parameter, model_unique_name)
+
+            # Add model prefix only to layer parameters (thickness, roughness)
+            if is_layer_param:
+                prefixed_display_name = f'{model_prefix} {display_name}'
+            else:
+                prefixed_display_name = display_name
+
+            alias = _make_alias(prefixed_display_name or parameter.name)
+            parameter_list.append({
+                'name': prefixed_display_name,
+                'display_name': prefixed_display_name,
+                'group': group_name,
+                'alias': alias,
+                'unique_name': parameter.unique_name,
+                '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, model_unique_name),
+                'enabled': parameter.enabled if hasattr(parameter, 'enabled') else True,
+                'object': parameter,  # Direct reference to the Parameter object
+            })
 
     return parameter_list

EasyReflectometryApp/Backends/Py/sample.py

@@ -213,6 +213,7 @@ def addNewModel(self) -> None:
     @Slot()
     def duplicateSelectedModel(self) -> None:
         self._models_logic.duplicate_selected_model()
+        self._project_logic._update_enablement_of_fixed_layers_for_model(self._models_logic.index)
         self.modelsTableChanged.emit()
 
     @Slot()
@@ -764,8 +765,11 @@ def constraintsList(self) -> list[dict[str, str]]:
                 expression_display = state.get('pretty_expression', self._format_numeric(float(value)))
                 raw_expression = state.get('raw_expression', expression_display)
 
+            # Use model-prefixed display name if available (from constrainModelsParameters)
+            dependent_display = state.get('dependent_display', entry['display_name'])
+
             constraints.append({
-                'dependentName': entry['display_name'],
+                'dependentName': dependent_display,
                 'expression': expression_display,
                 'rawExpression': raw_expression,
                 'relation': relation,
@@ -805,11 +809,34 @@ def removeConstraintByIndex(self, index: int) -> None:
         self.layersChange.emit()
 
     def _find_parameter_object_by_name(self, param_name: str):
-        """Find parameter object by name."""
+        """Find parameter object by name.
+
+        Handles both regular names ('SiO2 sld') and model-prefixed names ('M2 SiO2 sld').
+        """
         parameters = self._parameters_logic.parameters
+
+        # Direct match by display name
         for param in parameters:
             if param['name'] == param_name:
                 return param['object']
+
+        # Check constraint states for model-prefixed dependent_display
+        for unique_name, state in self._constraint_states.items():
+            if state.get('dependent_display') == param_name:
+                # Find the parameter by unique_name
+                for param in parameters:
+                    if param.get('unique_name') == unique_name:
+                        return param['object']
+
+        # Try stripping model prefix (e.g., 'M2 SiO2 sld' -> 'SiO2 sld')
+        import re
+        prefix_match = re.match(r'^M\d+\s+(.+)$', param_name)
+        if prefix_match:
+            stripped_name = prefix_match.group(1)
+            for param in parameters:
+                if param['name'] == stripped_name:
+                    return param['object']
+
         return None
 
     def _make_parameter_independent(self, param_obj) -> None:
@@ -965,9 +992,10 @@ def constrainModelsParameters(self, model_indices: list) -> None:
                         # Store constraint state for display
                         unique_name = getattr(dependent_param, 'unique_name', None)
                         if unique_name is not None:
-                            # Get display name for the reference parameter
-                            _, _, display_lookup = self._build_constraint_context()
-                            ref_display = self._get_parameter_display_name(reference_param)
+                            # Get display names with model prefix for clarity
+                            # e.g., "M2 SiO2 sld = M1 SiO2 sld"
+                            ref_display = self._get_parameter_display_name(reference_param, reference_model_idx)
+                            dep_display = self._get_parameter_display_name(dependent_param, model_idx)
 
                             self._constraint_states[unique_name] = {
                                 'mode': 'dynamic',
@@ -977,6 +1005,7 @@ def constrainModelsParameters(self, model_indices: list) -> None:
                                 'raw_expression': 'a',
                                 'pretty_expression': ref_display,
                                 'dependency_map': {'a': reference_param},
+                                'dependent_display': dep_display,
                             }
 
                         constraints_added += 1
@@ -1011,8 +1040,14 @@ def _build_model_parameters_map(self, model) -> Dict[str, DescriptorNumber]:
 
         return params_map
 
-    def _get_parameter_display_name(self, param: DescriptorNumber) -> str:
-        """Get a display name for a parameter."""
+    def _get_parameter_display_name(self, param: DescriptorNumber, model_index: int | None = None) -> str:
+        """Get a display name for a parameter.
+
+        :param param: The parameter to get the display name for.
+        :param model_index: Optional model index to prefix the display name with (e.g., 'M1').
+        :return: Display name, optionally prefixed with model identifier.
+        """
+        display_name = param.name  # Fallback
         try:
             from easyscience import global_object
             # Try to find the parameter's path in the global object map
@@ -1021,10 +1056,14 @@ def _get_parameter_display_name(self, param: DescriptorNumber) -> str:
                 if path and 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}'
+                    display_name = f'{parent_name} {param_name}'
+                    break
         except Exception:  # noqa: BLE001
             pass
-        return param.name
+
+        if model_index is not None:
+            return f'M{model_index + 1} {display_name}'
+        return display_name
 
     # # #
     # Q Range

EasyReflectometryApp/Gui/Pages/Sample/Sidebar/Advanced/Groups/ModelConstraints.qml

@@ -10,7 +10,7 @@ EaElements.GroupBox {
     id: modelConstraintsGroup
     title: qsTr("Model constraints")
     enabled: true
-    last: false
+    last: true
 
     property var selectedModelIndices: []
     property int selectedModelsCount: selectedModelIndices.length
@@ -140,12 +140,12 @@ EaElements.GroupBox {
         Item {
             id: modelConstraintsTableContainer
             width: parent.width
-            height: Math.min(200, Math.max(60, modelConstraintsTable.height))
+            height: modelConstraintsTable.height
 
             EaComponents.TableView {
                 id: modelConstraintsTable
                 width: parent.width
-                height: Math.min(200, Math.max(60, Math.max(modelConstraintsTable.contentHeight, modelConstraintsTable.implicitHeight)))
+                maxRowCountShow: 1000
 
                 defaultInfoText: qsTr("No Model Constraints")
 
@@ -196,8 +196,6 @@ EaElements.GroupBox {
                             return constraint.dependentName + ' ' + prefix + constraint.expression
                         }
                         elide: Text.ElideRight
-                        ToolTip.visible: hovered && Globals.BackendWrapper.sampleConstraintsList[index] && Globals.BackendWrapper.sampleConstraintsList[index].rawExpression
-                        ToolTip.text: Globals.BackendWrapper.sampleConstraintsList[index] ? Globals.BackendWrapper.sampleConstraintsList[index].rawExpression : ""
                     }
 
                     // Placeholder for delete button space