advisor-scattering 0.5.3__py3-none-any.whl → 0.9.5__py3-none-any.whl

advisor/features/scattering_geometry/ui/components/hk_angles_components.py

@@ -1,26 +1,13 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 # pylint: disable=no-name-in-module, import-error
-from PyQt5.QtWidgets import (
-    QWidget,
-    QVBoxLayout,
-    QHBoxLayout,
-    QFormLayout,
-    QGroupBox,
-    QLabel,
-    QPushButton,
-    QDoubleSpinBox,
-    QTableWidget,
-    QTableWidgetItem,
-    QHeaderView,
-    QButtonGroup,
-    QMessageBox,
-    QDialog,
-    QScrollArea,
-    QFrame,
-)
 from PyQt5.QtCore import Qt, pyqtSignal
-from PyQt5.QtGui import QColor, QBrush, QFont
+from PyQt5.QtGui import QBrush, QColor, QFont
+from PyQt5.QtWidgets import (QButtonGroup, QDialog, QDoubleSpinBox,
+                             QFormLayout, QFrame, QGroupBox, QHBoxLayout,
+                             QHeaderView, QLabel, QMessageBox, QPushButton,
+                             QScrollArea, QTableWidget, QTableWidgetItem,
+                             QVBoxLayout, QWidget)
 
 
 class HKAnglesControls(QWidget):
@@ -369,7 +356,7 @@ class HKAnglesHistoryDialog(QDialog):
                 # Create table for solutions
                 table = QTableWidget()
                 table.setColumnCount(5)
-                table.setHorizontalHeaderLabels(["#", "tth (°)", "θ (°)", "φ (°)", "χ (°)"])
+                table.setHorizontalHeaderLabels(["#", "tth (°)", "θ (°)", "χ (°)", "φ (°)"])
                 table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
                 table.verticalHeader().setVisible(False)
                 table.setMaximumHeight(100)
@@ -377,8 +364,8 @@ class HKAnglesHistoryDialog(QDialog):
                 # Add rows for each solution
                 tth_list = entry.get('tth', [])
                 theta_list = entry.get('theta', [])
-                phi_list = entry.get('phi', [])
                 chi_list = entry.get('chi', [])
+                phi_list = entry.get('phi', [])
                 feasible_list = entry.get('feasible', [])
                 
                 for i in range(len(tth_list)):
@@ -386,8 +373,8 @@ class HKAnglesHistoryDialog(QDialog):
                     table.setItem(i, 0, QTableWidgetItem(f"{i + 1}"))
                     table.setItem(i, 1, QTableWidgetItem(f"{tth_list[i]:.2f}"))
                     table.setItem(i, 2, QTableWidgetItem(f"{theta_list[i]:.2f}"))
-                    table.setItem(i, 3, QTableWidgetItem(f"{phi_list[i]:.2f}"))
-                    table.setItem(i, 4, QTableWidgetItem(f"{chi_list[i]:.2f}"))
+                    table.setItem(i, 3, QTableWidgetItem(f"{chi_list[i]:.2f}"))
+                    table.setItem(i, 4, QTableWidgetItem(f"{phi_list[i]:.2f}"))
                     
                     # Color based on feasibility
                     feasible = feasible_list[i] if i < len(feasible_list) else True
@@ -438,7 +425,7 @@ class HKAnglesResultsWidget(QWidget):
         # Current solutions display (table for up to 2 solutions)
         self.results_table = QTableWidget()
         self.results_table.setColumnCount(4)
-        self.results_table.setHorizontalHeaderLabels(["tth (°)", "θ (°)", "φ (°)", "χ (°)"])
+        self.results_table.setHorizontalHeaderLabels(["tth (°)", "θ (°)", "χ (°)", "φ (°)"])
         self.results_table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
         self.results_table.verticalHeader().setVisible(False)
         self.results_table.setMaximumHeight(90)
@@ -472,8 +459,8 @@ class HKAnglesResultsWidget(QWidget):
         
         tth_list = results.get('tth', [])
         theta_list = results.get('theta', [])
-        phi_list = results.get('phi', [])
         chi_list = results.get('chi', [])
+        phi_list = results.get('phi', [])
         feasible_list = results.get('feasible', [])
         
         for i in range(len(tth_list)):
@@ -482,8 +469,8 @@ class HKAnglesResultsWidget(QWidget):
             
             self.results_table.setItem(row, 0, QTableWidgetItem(f"{tth_list[i]:.2f}"))
             self.results_table.setItem(row, 1, QTableWidgetItem(f"{theta_list[i]:.2f}"))
-            self.results_table.setItem(row, 2, QTableWidgetItem(f"{phi_list[i]:.2f}"))
-            self.results_table.setItem(row, 3, QTableWidgetItem(f"{chi_list[i]:.2f}"))
+            self.results_table.setItem(row, 2, QTableWidgetItem(f"{chi_list[i]:.2f}"))
+            self.results_table.setItem(row, 3, QTableWidgetItem(f"{phi_list[i]:.2f}"))
             
             # Color based on feasibility
             feasible = feasible_list[i] if i < len(feasible_list) else True
@@ -499,15 +486,15 @@ class HKAnglesResultsWidget(QWidget):
         if current_row >= 0 and self.current_result:
             tth_list = self.current_result.get('tth', [])
             theta_list = self.current_result.get('theta', [])
-            phi_list = self.current_result.get('phi', [])
             chi_list = self.current_result.get('chi', [])
+            phi_list = self.current_result.get('phi', [])
             
             if current_row < len(tth_list):
                 selected_solution = {
                     'tth': tth_list[current_row],
                     'theta': theta_list[current_row],
-                    'phi': phi_list[current_row],
                     'chi': chi_list[current_row],
+                    'phi': phi_list[current_row],
                     'H': self.current_result.get('H'),
                     'K': self.current_result.get('K'),
                     'L': self.current_result.get('L'),

advisor/features/scattering_geometry/ui/components/hkl_scan_components.py

@@ -1,29 +1,18 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 # pylint: disable=no-name-in-module, import-error
-from PyQt5.QtWidgets import (
-    QWidget,
-    QVBoxLayout,
-    QHBoxLayout,
-    QFormLayout,
-    QGroupBox,
-    QLabel,
-    QPushButton,
-    QDoubleSpinBox,
-    QSpinBox,
-    QTableWidget,
-    QTableWidgetItem,
-    QHeaderView,
-    QRadioButton,
-    QButtonGroup,
-    QFileDialog,
-    QMessageBox,
-)
-from PyQt5.QtCore import Qt, pyqtSignal
-from PyQt5.QtGui import QColor, QBrush
 import csv
 import os
+
 import numpy as np
+from PyQt5.QtCore import Qt, pyqtSignal
+from PyQt5.QtGui import QBrush, QColor
+from PyQt5.QtWidgets import (QButtonGroup, QDoubleSpinBox, QFileDialog,
+                             QFormLayout, QGroupBox, QHBoxLayout, QHeaderView,
+                             QLabel, QMessageBox, QPushButton, QRadioButton,
+                             QSpinBox, QTableWidget, QTableWidgetItem,
+                             QVBoxLayout, QWidget)
+
 
 class RangeInputWidget(QWidget):
     """Widget for input range (start, end, num_points)."""
@@ -434,8 +423,8 @@ class HKLScanResultsTable(QTableWidget):
         l_values = results["L"]
         tth_values = results["tth"]
         theta_values = results["theta"]
-        phi_values = results["phi"]
         chi_values = results["chi"]
+        phi_values = results["phi"]
         feasible_values = results.get("feasible", [True] * len(h_values))
         solution_groups = results.get("solution_group", list(range(len(h_values))))
         solution_indices = results.get("solution_index", [1] * len(h_values))
@@ -456,8 +445,8 @@ class HKLScanResultsTable(QTableWidget):
 
             # Add angle values
             self.setItem(row_position, 4, QTableWidgetItem(f"{theta_values[i]:.1f}"))
-            self.setItem(row_position, 5, QTableWidgetItem(f"{phi_values[i]:.1f}"))
-            self.setItem(row_position, 6, QTableWidgetItem(f"{chi_values[i]:.1f}"))
+            self.setItem(row_position, 5, QTableWidgetItem(f"{chi_values[i]:.1f}"))
+            self.setItem(row_position, 6, QTableWidgetItem(f"{phi_values[i]:.1f}"))
             self.setItem(row_position, 7, QTableWidgetItem(f"{tth_values[0]-theta_values[i]:.1f}"))
 
             # Determine row color based on feasibility and group
@@ -510,8 +499,8 @@ class HKLScanResultsTable(QTableWidget):
                         "Solution#",
                         "tth (deg)",
                         "theta (deg)",
-                        "phi (deg)",
                         "chi (deg)",
+                        "phi (deg)",
                         "feasible",
                     ]
                 )
@@ -529,8 +518,8 @@ class HKLScanResultsTable(QTableWidget):
                             f"{solution_indices[i]}",
                             f"{self.last_results['tth'][i]:.6f}",
                             f"{self.last_results['theta'][i]:.6f}",
-                            f"{self.last_results['phi'][i]:.6f}",
                             f"{self.last_results['chi'][i]:.6f}",
+                            f"{self.last_results['phi'][i]:.6f}",
                             f"{feasible_values[i]}",
                         ]
                     )

advisor/features/scattering_geometry/ui/components/hkl_to_angles_components.py

@@ -1,26 +1,15 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 # pylint: disable=no-name-in-module, import-error
-from PyQt5.QtWidgets import (
-    QWidget,
-    QVBoxLayout,
-    QHBoxLayout,
-    QFormLayout,
-    QGroupBox,
-    QLabel,
-    QPushButton,
-    QDoubleSpinBox,
-    QTableWidget,
-    QTableWidgetItem,
-    QHeaderView,
-    QRadioButton,
-    QButtonGroup,
-    QDialog,
-    QScrollArea,
-    QFrame,
-)
 from PyQt5.QtCore import Qt, pyqtSignal
-from PyQt5.QtGui import QColor, QBrush, QFont
+from PyQt5.QtGui import QBrush, QColor, QFont
+from PyQt5.QtWidgets import (QButtonGroup, QDialog, QDoubleSpinBox,
+                             QFormLayout, QFrame, QGroupBox, QHBoxLayout,
+                             QHeaderView, QLabel, QPushButton, QRadioButton,
+                             QScrollArea, QTableWidget, QTableWidgetItem,
+                             QVBoxLayout, QWidget)
+
+
 class HKLToAnglesControls(QWidget):
     """Widget for HKL to Angles calculation controls."""
 
@@ -254,7 +243,7 @@ class HistoryDialog(QDialog):
                 # Create table for solutions
                 table = QTableWidget()
                 table.setColumnCount(5)
-                table.setHorizontalHeaderLabels(["#", "tth (°)", "θ (°)", "φ (°)", "χ (°)"])
+                table.setHorizontalHeaderLabels(["#", "tth (°)", "θ (°)", "χ (°)", "φ (°)"])
                 table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
                 table.verticalHeader().setVisible(False)
                 table.setMaximumHeight(100)
@@ -262,8 +251,8 @@ class HistoryDialog(QDialog):
                 # Add rows for each solution
                 tth_list = entry.get('tth', [])
                 theta_list = entry.get('theta', [])
-                phi_list = entry.get('phi', [])
                 chi_list = entry.get('chi', [])
+                phi_list = entry.get('phi', [])
                 feasible_list = entry.get('feasible', [])
                 
                 for i in range(len(tth_list)):
@@ -271,8 +260,8 @@ class HistoryDialog(QDialog):
                     table.setItem(i, 0, QTableWidgetItem(f"{i + 1}"))
                     table.setItem(i, 1, QTableWidgetItem(f"{tth_list[i]:.2f}"))
                     table.setItem(i, 2, QTableWidgetItem(f"{theta_list[i]:.2f}"))
-                    table.setItem(i, 3, QTableWidgetItem(f"{phi_list[i]:.2f}"))
-                    table.setItem(i, 4, QTableWidgetItem(f"{chi_list[i]:.2f}"))
+                    table.setItem(i, 3, QTableWidgetItem(f"{chi_list[i]:.2f}"))
+                    table.setItem(i, 4, QTableWidgetItem(f"{phi_list[i]:.2f}"))
                     
                     # Color based on feasibility
                     feasible = feasible_list[i] if i < len(feasible_list) else True
@@ -323,7 +312,7 @@ class HKLToAnglesResultsWidget(QWidget):
         # Current solutions display (table for up to 2 solutions)
         self.results_table = QTableWidget()
         self.results_table.setColumnCount(4)
-        self.results_table.setHorizontalHeaderLabels(["tth (°)", "θ (°)", "φ (°)", "χ (°)"])
+        self.results_table.setHorizontalHeaderLabels(["tth (°)", "θ (°)", "χ (°)", "φ (°)"])
         self.results_table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
         self.results_table.verticalHeader().setVisible(False)
         self.results_table.setMaximumHeight(90)
@@ -357,8 +346,8 @@ class HKLToAnglesResultsWidget(QWidget):
         
         tth_list = results.get('tth', [])
         theta_list = results.get('theta', [])
-        phi_list = results.get('phi', [])
         chi_list = results.get('chi', [])
+        phi_list = results.get('phi', [])
         feasible_list = results.get('feasible', [])
         
         for i in range(len(tth_list)):
@@ -367,8 +356,8 @@ class HKLToAnglesResultsWidget(QWidget):
             
             self.results_table.setItem(row, 0, QTableWidgetItem(f"{tth_list[i]:.2f}"))
             self.results_table.setItem(row, 1, QTableWidgetItem(f"{theta_list[i]:.2f}"))
-            self.results_table.setItem(row, 2, QTableWidgetItem(f"{phi_list[i]:.2f}"))
-            self.results_table.setItem(row, 3, QTableWidgetItem(f"{chi_list[i]:.2f}"))
+            self.results_table.setItem(row, 2, QTableWidgetItem(f"{chi_list[i]:.2f}"))
+            self.results_table.setItem(row, 3, QTableWidgetItem(f"{phi_list[i]:.2f}"))
             
             # Color based on feasibility
             feasible = feasible_list[i] if i < len(feasible_list) else True
@@ -384,15 +373,15 @@ class HKLToAnglesResultsWidget(QWidget):
         if current_row >= 0 and self.current_result:
             tth_list = self.current_result.get('tth', [])
             theta_list = self.current_result.get('theta', [])
-            phi_list = self.current_result.get('phi', [])
             chi_list = self.current_result.get('chi', [])
+            phi_list = self.current_result.get('phi', [])
             
             if current_row < len(tth_list):
                 selected_solution = {
                     'tth': tth_list[current_row],
                     'theta': theta_list[current_row],
-                    'phi': phi_list[current_row],
                     'chi': chi_list[current_row],
+                    'phi': phi_list[current_row],
                     'H': self.current_result.get('H'),
                     'K': self.current_result.get('K'),
                     'L': self.current_result.get('L'),

advisor/features/scattering_geometry/ui/scattering_geometry_tab.py

@@ -437,7 +437,7 @@ class ScatteringGeometryTab(TabInterface):
         """Update the HKL scan visualization with auto-detected ranges and results."""
         try:
             # Structure factor calculator not needed for trajectory-only visualization
-            
+
             # Use the provided scan results or the last stored results
             if scan_results is None:
                 scan_results = getattr(self.hkl_scan_visualizer, 'last_scan_results', None)
@@ -456,6 +456,14 @@ class ScatteringGeometryTab(TabInterface):
                 
                 # Visualize results (ranges will be auto-detected)
                 self.hkl_scan_visualizer.visualize_results(scan_results, plane_type)
+
+                # plot the accessible area in k-space
+                params = self.hkl_scan_controls.get_scan_parameters() 
+                tth = params["tth"]
+                accessible_area = self.calculator.get_max_hkl_values(tth)
+                h_max, k_max, l_max = accessible_area["h_max"], accessible_area["k_max"], accessible_area["l_max"]
+                success, message = accessible_area["success"], accessible_area["message"]
+                self.hkl_scan_visualizer.plot_accessible_area(plane_type, h_max, k_max, l_max, message)
             else:
                 # No scan results yet, just clear the plot
                 self.hkl_scan_visualizer.clear_plot()

advisor/ui/dialogs/__init__.py

@@ -0,0 +1,7 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Dialog components for the Advisor application."""
+
+from .diffraction_test_dialog import DiffractionTestDialog
+
+__all__ = ["DiffractionTestDialog"]

advisor/ui/dialogs/diffraction_test_dialog.py

@@ -0,0 +1,287 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Dialog for importing orientation from diffraction test data."""
+
+from PyQt5.QtCore import Qt
+from PyQt5.QtWidgets import (QDialog, QDoubleSpinBox, QFormLayout, QGroupBox,
+                             QHBoxLayout, QHeaderView, QLabel, QMessageBox,
+                             QPushButton, QTableWidget, QTableWidgetItem,
+                             QVBoxLayout)
+
+from advisor.domain.orientation import fit_orientation_from_diffraction_tests
+
+
+class DiffractionTestDialog(QDialog):
+    """Dialog for entering diffraction test data and calculating orientation.
+
+    This dialog allows users to input multiple diffraction tests (H, K, L, energy,
+    tth, theta, phi, chi) and calculates the optimal Euler angles (roll, pitch, yaw)
+    that best fit the data.
+    """
+
+    def __init__(self, lattice_params: dict, parent=None):
+        """Initialize the dialog.
+
+        Args:
+            lattice_params: Dictionary containing lattice parameters (a, b, c, alpha, beta, gamma)
+            parent: Parent widget
+        """
+        super().__init__(parent)
+        self.lattice_params = lattice_params
+        self.result = None  # Will store (roll, pitch, yaw) on success
+
+        self.setWindowTitle("Import Orientation from UB Matrix Tests")
+        self.setMinimumWidth(800)
+        self.setMinimumHeight(550)
+
+        self._init_ui()
+
+    def _init_ui(self):
+        """Initialize the UI components."""
+        layout = QVBoxLayout(self)
+
+        # Instructions label
+        instructions = QLabel(
+            "Enter UB matrix test (diffraction test) data below. Each row represents a measurement "
+            "with known HKL indices and measured angles. At least one test is required."
+        )
+        instructions.setWordWrap(True)
+        layout.addWidget(instructions)
+
+        # Table for diffraction tests
+        self.table = QTableWidget()
+        self.table.setColumnCount(8)
+        self.table.setHorizontalHeaderLabels(
+            ["H", "K", "L", "Energy (eV)", "tth (°)", "θ (°)", "χ (°)", "φ (°)"]
+        )
+
+        # Set column resize mode
+        header = self.table.horizontalHeader()
+        for i in range(8):
+            header.setSectionResizeMode(i, QHeaderView.Stretch)
+
+        # Add initial empty rows
+        self._add_row()
+        self._add_row()
+
+        layout.addWidget(self.table)
+
+        # Row management buttons
+        row_buttons_layout = QHBoxLayout()
+
+        add_row_btn = QPushButton("Add Row")
+        add_row_btn.clicked.connect(self._add_row)
+        row_buttons_layout.addWidget(add_row_btn)
+
+        remove_row_btn = QPushButton("Remove Selected Row")
+        remove_row_btn.clicked.connect(self._remove_selected_row)
+        row_buttons_layout.addWidget(remove_row_btn)
+
+        row_buttons_layout.addStretch()
+        layout.addLayout(row_buttons_layout)
+
+        # Results display area
+        self.results_group = QGroupBox("Calculated Orientation")
+        results_layout = QFormLayout(self.results_group)
+
+        self.roll_result = QDoubleSpinBox()
+        self.roll_result.setRange(-180, 180)
+        self.roll_result.setDecimals(4)
+        self.roll_result.setReadOnly(True)
+        self.roll_result.setSuffix(" °")
+        results_layout.addRow("Roll:", self.roll_result)
+
+        self.pitch_result = QDoubleSpinBox()
+        self.pitch_result.setRange(-180, 180)
+        self.pitch_result.setDecimals(4)
+        self.pitch_result.setReadOnly(True)
+        self.pitch_result.setSuffix(" °")
+        results_layout.addRow("Pitch:", self.pitch_result)
+
+        self.yaw_result = QDoubleSpinBox()
+        self.yaw_result.setRange(-180, 180)
+        self.yaw_result.setDecimals(4)
+        self.yaw_result.setReadOnly(True)
+        self.yaw_result.setSuffix(" °")
+        results_layout.addRow("Yaw:", self.yaw_result)
+
+        self.error_label = QLabel("Residual Error: --")
+        results_layout.addRow(self.error_label)
+
+        self.results_group.setVisible(False)
+        layout.addWidget(self.results_group)
+
+        # Action buttons
+        button_layout = QHBoxLayout()
+
+        self.calculate_btn = QPushButton("Calculate Orientation")
+        self.calculate_btn.clicked.connect(self._calculate_orientation)
+        self._set_button_highlighted(self.calculate_btn, True)  # Highlight initially
+        button_layout.addWidget(self.calculate_btn)
+
+        self.apply_btn = QPushButton("Apply and Close")
+        self.apply_btn.clicked.connect(self._apply_and_close)
+        self.apply_btn.setEnabled(False)
+        button_layout.addWidget(self.apply_btn)
+
+        cancel_btn = QPushButton("Cancel")
+        cancel_btn.clicked.connect(self.reject)
+        button_layout.addWidget(cancel_btn)
+
+        layout.addLayout(button_layout)
+
+    def _set_button_highlighted(self, button: QPushButton, highlighted: bool):
+        """Set button to highlighted (pastel blue) or normal style."""
+        if highlighted:
+            button.setStyleSheet(
+                "background-color: #a8d0f0; color: #2c5282; font-weight: bold;"
+            )
+        else:
+            button.setStyleSheet("")  # Reset to default
+
+    def _set_button_success(self, button: QPushButton, success: bool):
+        """Set button to success (pastel green) or normal style."""
+        if success:
+            button.setStyleSheet(
+                "background-color: #a8e6c1; color: #2d5a3d; font-weight: bold;"
+            )
+        else:
+            button.setStyleSheet("")  # Reset to default
+
+    def _add_row(self):
+        """Add a new empty row to the table."""
+        row = self.table.rowCount()
+        self.table.insertRow(row)
+
+        # Set default values (H, K, L, energy, tth, theta, chi, phi)
+        defaults = [0.0, 0.0, 0.0, 2200.0, 90.0, 45.0, 0.0, 0.0]
+        for col, default in enumerate(defaults):
+            item = QTableWidgetItem(str(default))
+            item.setTextAlignment(Qt.AlignCenter)
+            self.table.setItem(row, col, item)
+
+    def _remove_selected_row(self):
+        """Remove the currently selected row."""
+        current_row = self.table.currentRow()
+        if current_row >= 0:
+            self.table.removeRow(current_row)
+        elif self.table.rowCount() > 0:
+            # If no row selected, remove the last row
+            self.table.removeRow(self.table.rowCount() - 1)
+
+    def _get_diffraction_tests(self) -> list:
+        """Extract diffraction test data from the table.
+
+        Returns:
+            List of dictionaries containing test data, or None if validation fails.
+        """
+        tests = []
+        for row in range(self.table.rowCount()):
+            try:
+                test = {
+                    "H": float(self.table.item(row, 0).text()),
+                    "K": float(self.table.item(row, 1).text()),
+                    "L": float(self.table.item(row, 2).text()),
+                    "energy": float(self.table.item(row, 3).text()),
+                    "tth": float(self.table.item(row, 4).text()),
+                    "theta": float(self.table.item(row, 5).text()),
+                    "chi": float(self.table.item(row, 6).text()),
+                    "phi": float(self.table.item(row, 7).text()),
+                }
+                tests.append(test)
+            except (ValueError, AttributeError) as e:
+                QMessageBox.warning(
+                    self,
+                    "Invalid Input",
+                    f"Row {row + 1} contains invalid data. Please enter numeric values.\n\nError: {e}",
+                )
+                return None
+
+        if not tests:
+            QMessageBox.warning(
+                self,
+                "No Data",
+                "Please enter at least one diffraction test.",
+            )
+            return None
+
+        return tests
+
+    def _calculate_orientation(self):
+        """Calculate the optimal orientation from the entered data."""
+        tests = self._get_diffraction_tests()
+        if tests is None:
+            return
+
+        # Run the fitting algorithm
+        result = fit_orientation_from_diffraction_tests(
+            self.lattice_params, tests
+        )
+
+        if not result["success"]:
+            QMessageBox.warning(
+                self,
+                "Calculation Failed",
+                f"Failed to calculate orientation:\n\n{result.get('message', 'Unknown error')}",
+            )
+            return
+
+        # Display results (overwrites any previous results)
+        self.roll_result.setValue(result["roll"])
+        self.pitch_result.setValue(result["pitch"])
+        self.yaw_result.setValue(result["yaw"])
+        self.error_label.setText(f"Residual Error: {result['residual_error']:.6f}")
+
+        # Update group title to indicate results are current
+        self.results_group.setTitle("Calculated Orientation (Updated)")
+        self.results_group.setVisible(True)
+        self.apply_btn.setEnabled(True)
+
+        # Update button styles: remove highlight from Calculate, add to Apply
+        self._set_button_highlighted(self.calculate_btn, False)
+        self._set_button_success(self.apply_btn, True)
+
+        # Store result for later retrieval
+        self.result = {
+            "roll": result["roll"],
+            "pitch": result["pitch"],
+            "yaw": result["yaw"],
+        }
+
+        # Show detailed errors if available
+        if result.get("individual_errors"):
+            error_text = "Individual test errors:\n"
+            for i, err in enumerate(result["individual_errors"]):
+                error_text += (
+                    f"  Test {i+1}: ΔH={err['H_error']:.4f}, "
+                    f"ΔK={err['K_error']:.4f}, ΔL={err['L_error']:.4f}\n"
+                )
+            QMessageBox.information(
+                self,
+                "Calculation Complete",
+                f"Orientation calculated successfully!\n\n"
+                f"Roll: {result['roll']:.4f}°\n"
+                f"Pitch: {result['pitch']:.4f}°\n"
+                f"Yaw: {result['yaw']:.4f}°\n\n"
+                f"Residual Error: {result['residual_error']:.6f}\n\n"
+                f"{error_text}",
+            )
+
+    def _apply_and_close(self):
+        """Apply the calculated orientation and close the dialog."""
+        if self.result is not None:
+            self.accept()
+        else:
+            QMessageBox.warning(
+                self,
+                "No Result",
+                "Please calculate the orientation first.",
+            )
+
+    def get_result(self) -> dict:
+        """Get the calculated orientation.
+
+        Returns:
+            Dictionary with roll, pitch, yaw values, or None if not calculated.
+        """
+        return self.result