merged develop + minor fixes

Author: rozyczko

EasyReflectometryApp/Backends/Py/experiment.py

@@ -64,9 +64,13 @@ def load(self, paths: str) -> None:
         for path in paths:
             generalized = IO.generalizePath(path)
             if self._project_logic.count_datasets_in_file(generalized) > 1:
-                _count, changed = self._project_logic.load_all_experiments_from_file(generalized)
+                result = self._project_logic.load_all_experiments_from_file(generalized)
+                if isinstance(result, tuple):
+                    _count, changed = result
+                else:
+                    changed = bool(getattr(self._project_logic, '_last_q_range_changed', False))
             else:
-                changed = self._project_logic.load_new_experiment(generalized)
+                changed = bool(self._project_logic.load_new_experiment(generalized))
             if changed:
                 q_range_changed = True
             self.experimentChanged.emit()

EasyReflectometryApp/Backends/Py/logic/calculators.py

@@ -13,10 +13,12 @@ def available(self) -> list[str]:
     def current_index(self) -> int:
         return self._current_index
 
-    def set_current_index(self, new_value: int) -> None:
+    def set_current_index(self, new_value: int) -> bool:
         if new_value != self._current_index:
             self._current_index = new_value
             new_calculator = self._list_available_calculators[new_value]
+            if hasattr(self._project_lib._calculator, 'switch'):
+                self._project_lib._calculator.switch(new_calculator)
             self._project_lib.calculator = new_calculator
             return True
         return False

EasyReflectometryApp/Backends/Py/logic/fitting.py

@@ -2,6 +2,7 @@
 from typing import TYPE_CHECKING
 from typing import List
 from typing import Optional
+from typing import cast
 
 from easyreflectometry import Project as ProjectLib
 from easyscience.fitting import FitResults
@@ -31,7 +32,7 @@ def status(self) -> str:
         if self._result is None:
             return ''
         else:
-            return self._result.success
+            return str(self._result.success)
 
     @property
     def running(self) -> bool:
@@ -105,6 +106,8 @@ def prepare_for_threaded_fit(self) -> None:
         self._finished = False
         self._show_results_dialog = False
         self._fit_error_message = None
+        self._result = None
+        self._results = []
 
     def _ordered_experiments(self) -> list:
         """Return experiments as an ordered list of experiment objects.
@@ -118,7 +121,7 @@ def _ordered_experiments(self) -> list:
         if hasattr(experiments, 'items'):
             items = list(experiments.items())
             try:
-                items.sort(key=lambda item: item[0])
+                items = sorted(items)
             except TypeError:
                 pass
             return [experiment for _, experiment in items]
@@ -201,7 +204,7 @@ def prepare_threaded_fit(self, minimizers_logic: 'Minimizers') -> tuple:
             logger.exception('Error preparing threaded fit')
             return None, None, None, None, None
 
-    def on_fit_finished(self, results: List[FitResults]) -> None:
+    def on_fit_finished(self, results: FitResults | List[FitResults]) -> None:
         """Handle successful completion of fitting.
 
         :param results: List of FitResults from the multi-fitter.
@@ -219,25 +222,28 @@ def on_fit_finished(self, results: List[FitResults]) -> None:
             engine_name = getattr(results[0], 'minimizer_engine', 'unknown')
             logger.info('Fit finished: engine=%s, chi2=%s, success=%s', engine_name, self.fit_chi2, results[0].success)
         else:
-            self._result = results
-            self._results = [results] if results else []
+            single_result = cast(Optional[FitResults], results)
+            self._result = single_result
+            self._results = [single_result] if single_result is not None else []
 
     @property
     def fit_n_pars(self) -> int:
         """Return the global number of refined parameters for the fit."""
         if self._results:
-            return self._results[0].n_pars
+            return sum(result.n_pars for result in self._results)
         if self._result is None:
             return 0
         return self._result.n_pars
 
     @property
     def fit_chi2(self) -> float:
-        """Return reduced chi-squared across all fits (chi2 / degrees of freedom)."""
+        """Return reduced chi-squared across all fits."""
         if self._results:
             try:
-                total_chi2 = float(sum(r.chi2 for r in self._results))
-                total_points = sum(len(r.x) for r in self._results)
+                if len(self._results) == 1:
+                    return float(self._results[0].reduced_chi)
+                total_chi2 = float(sum(result.chi2 for result in self._results))
+                total_points = sum(len(result.x) for result in self._results)
                 n_params = self._results[0].n_pars
                 total_dof = total_points - n_params
                 if total_dof <= 0:

EasyReflectometryApp/Backends/Py/logic/project.py

@@ -8,6 +8,7 @@
 class Project:
     def __init__(self, project_lib: ProjectLib):
         self._project_lib = project_lib
+        self._last_q_range_changed = False
         self._project_lib.default_model()
         self._update_enablement_of_fixed_layers_for_model(0)
 
@@ -119,10 +120,10 @@ def load_new_experiment(self, path: str) -> bool:
     def count_datasets_in_file(self, path: str) -> int:
         return self._project_lib.count_datasets_in_file(path)
 
-    def load_all_experiments_from_file(self, path: str) -> tuple[int, bool]:
+    def load_all_experiments_from_file(self, path: str) -> int:
         loaded_count = self._project_lib.load_all_experiments_from_file(path)
-        q_max_changed = self._sync_q_max_with_loaded_experiments()
-        return loaded_count, q_max_changed
+        self._last_q_range_changed = self._sync_q_max_with_loaded_experiments()
+        return loaded_count
 
     def _sync_q_max_with_loaded_experiments(self) -> bool:
         """Set model q_max to the largest q value found in loaded experiments.

EasyReflectometryApp/Backends/Py/plotting_1d.py

@@ -459,6 +459,22 @@ def individualExperimentDataList(self) -> list:
             )
         return qml_data_list
 
+    @Property(float, notify=sampleChartRangesChanged)
+    def residualMinX(self):
+        return self._get_residual_range()[0]
+
+    @Property(float, notify=sampleChartRangesChanged)
+    def residualMaxX(self):
+        return self._get_residual_range()[1]
+
+    @Property(float, notify=sampleChartRangesChanged)
+    def residualMinY(self):
+        return self._get_residual_range()[2]
+
+    @Property(float, notify=sampleChartRangesChanged)
+    def residualMaxY(self):
+        return self._get_residual_range()[3]
+
     @Slot(str, str, 'QVariant')
     def setQtChartsSerieRef(self, page: str, serie: str, ref: QObject):
         self._chartRefs['QtCharts'][page][serie] = ref
@@ -537,70 +553,143 @@ def getExperimentDataPoints(self, experiment_index: int) -> list:
             console.debug(f'Error getting experiment data points for index {experiment_index}: {e}')
             return []
 
-    @Slot(int, result='QVariantList')
-    def getAnalysisDataPoints(self, experiment_index: int) -> list:
-        """Get measured and calculated data points for a specific experiment for analysis plotting."""
-        try:
-            # Get measured experimental data
-            exp_data = self._project_lib.experimental_data_for_model_at_index(experiment_index)
-
-            # Get the model index for this experiment - it may be different from experiment_index
-            # When multiple experiments share the same model
-            model_index = 0
-            model_found = False
-            if hasattr(exp_data, 'model') and exp_data.model is not None:
-                # Find the model index in the models collection
-                for idx, model in enumerate(self._project_lib.models):
-                    if model is exp_data.model:
-                        model_index = idx
-                        model_found = True
-                        break
-                if not model_found:
-                    console.debug(f'Warning: model for experiment {experiment_index} '
-                                  f'not found in models collection, falling back to model 0')
-            else:
-                # Fallback: use experiment_index if it's within model range, else 0
-                model_index = experiment_index if experiment_index < len(self._project_lib.models) else 0
+    def _get_experiment_model_index(self, experiment_index: int, exp_data=None) -> int:
+        """Resolve the model index used by a given experiment."""
+        if exp_data is not None and hasattr(exp_data, 'model') and exp_data.model is not None:
+            for idx, model in enumerate(self._project_lib.models):
+                if model is exp_data.model:
+                    return idx
+        if experiment_index < len(self._project_lib.models):
+            return experiment_index
+        return 0
+
+    def _get_aligned_analysis_values(self, experiment_index: int) -> list[dict]:
+        """Return measured, calculated and sigma values aligned on experiment q points."""
+        exp_data = self._project_lib.experimental_data_for_model_at_index(experiment_index)
+        q_values = np.asarray(getattr(exp_data, 'x', np.empty(0)), dtype=float)
+        measured_values = np.asarray(getattr(exp_data, 'y', np.empty(0)), dtype=float)
+        sigma_values = np.asarray(getattr(exp_data, 'ye', np.zeros_like(measured_values)), dtype=float)
+
+        if q_values.size == 0 or measured_values.size == 0:
+            return []
 
-            # Get the q values from the experimental data for calculating the model
-            q_values = exp_data.x
-            # Filter to q range
-            mask = (q_values >= self._project_lib.q_min) & (q_values <= self._project_lib.q_max)
-            q_filtered = q_values[mask]
+        q_mask = (q_values >= self._project_lib.q_min) & (q_values <= self._project_lib.q_max)
+        q_filtered = q_values[q_mask]
+        measured_filtered = measured_values[q_mask]
+        sigma_filtered = sigma_values[q_mask] if sigma_values.size else np.zeros_like(measured_filtered)
 
-            # Get calculated model data at the same q points using the correct model index
+        model_index = self._get_experiment_model_index(experiment_index, exp_data)
+        try:
             calc_data = self._project_lib.model_data_for_model_at_index(model_index, q_filtered)
+        except TypeError:
+            calc_data = self._project_lib.model_data_for_model_at_index(model_index)
+
+        calc_values = np.asarray(getattr(calc_data, 'y', np.empty(0)), dtype=float)
+        calc_q_values = np.asarray(getattr(calc_data, 'x', np.empty(0)), dtype=float)
+
+        if calc_values.size == q_filtered.size:
+            calculated_filtered = calc_values
+        elif calc_values.size == 0:
+            calculated_filtered = measured_filtered.copy()
+        elif calc_q_values.size == calc_values.size and calc_values.size > 1:
+            calculated_filtered = np.interp(q_filtered, calc_q_values, calc_values)
+        elif calc_values.size == 1:
+            calculated_filtered = np.full_like(measured_filtered, calc_values[0], dtype=float)
+        else:
+            calculated_filtered = np.resize(calc_values, q_filtered.size)
+
+        measured_filtered = self._apply_rq4(q_filtered, measured_filtered)
+        calculated_filtered = self._apply_rq4(q_filtered, calculated_filtered)
+        sigma_filtered = self._apply_rq4(q_filtered, sigma_filtered)
+
+        points = []
+        for q_value, measured_value, calculated_value, sigma_value in zip(
+            q_filtered,
+            measured_filtered,
+            calculated_filtered,
+            sigma_filtered,
+        ):
+            points.append(
+                {
+                    'q': float(q_value),
+                    'measured': float(measured_value),
+                    'calculated': float(calculated_value),
+                    'sigma': float(sigma_value),
+                }
+            )
+        return points
 
+    @Slot(int, result='QVariantList')
+    def getAnalysisDataPoints(self, experiment_index: int) -> list:
+        """Get measured and calculated data points for a specific experiment for analysis plotting."""
+        try:
             points = []
-            exp_points = list(exp_data.data_points())
-            calc_y = calc_data.y
-
-            if len(calc_y) != len(q_filtered):
-                console.debug(f'Warning: calculated data length ({len(calc_y)}) '
-                              f'differs from filtered experimental data ({len(q_filtered)}) '
-                              f'for experiment {experiment_index}')
-
-            calc_idx = 0
-            for point in exp_points:
-                if point[0] < self._project_lib.q_max and self._project_lib.q_min < point[0]:
-                    q = point[0]
-                    r_meas = point[1]
-                    calc_y_val = calc_y[calc_idx] if calc_idx < len(calc_y) else r_meas
-                    r_meas = self._apply_rq4(q, r_meas)
-                    calc_y_val = self._apply_rq4(q, calc_y_val)
-                    points.append(
-                        {
-                            'x': float(q),
-                            'measured': float(np.log10(r_meas)),
-                            'calculated': float(np.log10(calc_y_val)),
-                        }
-                    )
-                    calc_idx += 1
+            for point in self._get_aligned_analysis_values(experiment_index):
+                measured = point['measured']
+                calculated = point['calculated']
+                points.append(
+                    {
+                        'x': point['q'],
+                        'measured': float(np.log10(measured)) if measured > 0 else -10.0,
+                        'calculated': float(np.log10(calculated)) if calculated > 0 else -10.0,
+                    }
+                )
             return points
         except Exception as e:
             console.debug(f'Error getting analysis data points for index {experiment_index}: {e}')
             return []
 
+    @Slot(int, result='QVariantList')
+    def getResidualDataPoints(self, experiment_index: int) -> list:
+        """Get residual data points for a specific experiment."""
+        try:
+            points = []
+            for point in self._get_aligned_analysis_values(experiment_index):
+                sigma = point['sigma']
+                residual = point['calculated'] - point['measured']
+                if sigma > 0:
+                    residual = residual / sigma
+                points.append({'x': point['q'], 'y': float(residual)})
+            return points
+        except Exception as e:
+            console.debug(f'Error getting residual data points for index {experiment_index}: {e}')
+            return []
+
+    def _get_residual_range(self) -> tuple[float, float, float, float]:
+        """Return residual plot ranges for the current selection."""
+        try:
+            if self.is_multi_experiment_mode:
+                selected_indices = getattr(self._proxy._analysis, '_selected_experiment_indices', [])
+            else:
+                selected_indices = [self._project_lib.current_experiment_index]
+
+            all_points = []
+            for experiment_index in selected_indices:
+                all_points.extend(self.getResidualDataPoints(experiment_index))
+
+            if not all_points:
+                return 0.0, 1.0, -1.0, 1.0
+
+            x_values = np.asarray([point['x'] for point in all_points], dtype=float)
+            y_values = np.asarray([point['y'] for point in all_points], dtype=float)
+            if x_values.size == 0 or y_values.size == 0:
+                return 0.0, 1.0, -1.0, 1.0
+
+            min_x = float(np.min(x_values))
+            max_x = float(np.max(x_values))
+            min_y = float(np.min(y_values))
+            max_y = float(np.max(y_values))
+
+            if min_y == max_y:
+                margin = max(abs(min_y) * 0.05, 1.0)
+            else:
+                margin = (max_y - min_y) * 0.05
+
+            return min_x, max_x, min_y - margin, max_y + margin
+        except Exception as e:
+            console.debug(f'Error getting residual range: {e}')
+            return 0.0, 1.0, -1.0, 1.0
+
     def refreshSamplePage(self):
         # Clear cached data so it gets recalculated
         self._sample_data = {}
@@ -617,6 +706,7 @@ def refreshExperimentPage(self):
     def refreshAnalysisPage(self):
         self._model_data = {}
         self.drawCalculatedAndMeasuredOnAnalysisChart()
+        self.sampleChartRangesChanged.emit()
 
     def refreshExperimentRanges(self):
         """Emit signal to update experiment chart ranges when selection changes."""

EasyReflectometryApp/Backends/Py/py_backend.py

@@ -135,6 +135,11 @@ def plottingGetAnalysisDataPoints(self, experiment_index: int) -> list:
         """Get measured and calculated data points for a specific experiment for analysis plotting."""
         return self._plotting_1d.getAnalysisDataPoints(experiment_index)
 
+    @Slot(int, result='QVariantList')
+    def plottingGetResidualDataPoints(self, experiment_index: int) -> list:
+        """Get residual data points for a specific experiment for residual plotting."""
+        return self._plotting_1d.getResidualDataPoints(experiment_index)
+
     ######### Connections to relay info between the backend parts
     def _connect_backend_parts(self) -> None:
         self._connect_project_page()
@@ -160,7 +165,8 @@ def _connect_sample_page(self) -> None:
     def _connect_experiment_page(self) -> None:
         self._experiment.externalExperimentChanged.connect(self._relay_experiment_page_experiment_changed)
         self._experiment.externalExperimentChanged.connect(self._refresh_plots)
-        self._experiment.qRangeUpdated.connect(self._sample.qRangeChanged)
+        if hasattr(self._experiment, 'qRangeUpdated') and hasattr(self._sample, 'qRangeChanged'):
+            self._experiment.qRangeUpdated.connect(self._sample.qRangeChanged)
 
     def _connect_analysis_page(self) -> None:
         self._analysis.externalMinimizerChanged.connect(self._relay_analysis_page)
@@ -196,12 +202,10 @@ def _relay_project_page_project_changed(self):
         self._sample.assembliesIndexChanged.emit()
         self._experiment.experimentChanged.emit()
         self._analysis.experimentsChanged.emit()
-        self._analysis._clearCacheAndEmitParametersChanged()
         self._status.statusChanged.emit()
         self._summary.summaryChanged.emit()
         self._plotting_1d.reset_data()
         self._refresh_plots()
-        self._plotting_1d.samplePageResetAxes.emit()
 
     def _relay_sample_page_sample_changed(self):
         self._plotting_1d.reset_data()