advisor-scattering 0.9.1__tar.gz → 0.9.5__tar.gz

{advisor_scattering-0.9.1 → advisor_scattering-0.9.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: advisor-scattering
-Version: 0.9.1
+Version: 0.9.5
 Summary: Advisor-Scattering: Advanced Visual X-ray Scattering Toolkit for Reciprocal-space visualization and calculation
 Author: Xunyang Hong
 License: MIT
@@ -37,6 +37,7 @@ or use the link below to view the demo video.
 - Visualize scattering geometry and unit cells
 - Compute and visualize structure factors in reciprocal space.
 - CIF file drop-in support
+- Import crystal orientation from diffraction test data
 
 
 ## Install
@@ -75,7 +76,8 @@ python -m advisor
 ### 1. Initialization window
 - Enter lattice constants (a, b, c) and angles (alpha, beta, gamma); beam energy auto-updates wavelength/|k|.
 - Optional: drop a CIF to autofill lattice parameters and preview the unit cell.
-- Adjust Euler angles (roll, pitch, yaw) to orient the sample relative to the scattering plane;
+- Adjust Euler angles (roll, pitch, yaw) to orient the lattice/sample relative to the goniometer.
+- **New:** Use **Import from Diffraction Test** to automatically determine Euler angles from known diffraction measurements.
 - Click **Initialize** to load the main interface and pass parameters to all tabs.
 
 ### 2. Scattering Geometry tab

{advisor_scattering-0.9.1 → advisor_scattering-0.9.5}/README.md

@@ -15,6 +15,7 @@ or use the link below to view the demo video.
 - Visualize scattering geometry and unit cells
 - Compute and visualize structure factors in reciprocal space.
 - CIF file drop-in support
+- Import crystal orientation from diffraction test data
 
 
 ## Install
@@ -53,7 +54,8 @@ python -m advisor
 ### 1. Initialization window
 - Enter lattice constants (a, b, c) and angles (alpha, beta, gamma); beam energy auto-updates wavelength/|k|.
 - Optional: drop a CIF to autofill lattice parameters and preview the unit cell.
-- Adjust Euler angles (roll, pitch, yaw) to orient the sample relative to the scattering plane;
+- Adjust Euler angles (roll, pitch, yaw) to orient the lattice/sample relative to the goniometer.
+- **New:** Use **Import from Diffraction Test** to automatically determine Euler angles from known diffraction measurements.
 - Click **Initialize** to load the main interface and pass parameters to all tabs.
 
 ### 2. Scattering Geometry tab

{advisor_scattering-0.9.1 → advisor_scattering-0.9.5}/advisor/domain/orientation_calculator.py

@@ -14,11 +14,10 @@ from advisor.domain.core import Lab
 
 
 class OrientationCalculator:
-    """Lightweight calculator for orientation fitting.
+    """Lightweight version of Brillouincalculator for orientation fitting (Set UB Matrix calculation).
 
-    This class provides only the methods needed for fitting crystal orientation
-    from diffraction test data. It uses the Lab class directly and avoids
-    dependencies on feature-specific modules.
+    This class provides only the methods needed for fitting crystal orientation (UB matrix)
+    from diffraction data. 
     """
 
     # Physical constants

{advisor_scattering-0.9.1 → advisor_scattering-0.9.5}/advisor/features/scattering_geometry/domain/brillouin_calculator.py

@@ -446,7 +446,8 @@ class BrillouinCalculator:
             "error": None,
             "feasible": all_feasible,
         }
-
+    
+    
     def is_initialized(self):
         """Check if the calculator is initialized.
 
@@ -471,6 +472,35 @@ class BrillouinCalculator:
             "gamma": gamma,
         }
 
+
+    def get_max_hkl_values(self, tth):
+        """Get the maximum HKL values, valid only for orthorhombic crystals.
+
+        Returns:
+            tuple: Maximum HKL values
+        """
+        if not self.is_initialized():
+            raise ValueError("Calculator not initialized")
+        a, b, c, alpha, beta, gamma = self.lab.get_lattice_parameters()
+        k_magnitude = self.get_k_magnitude(tth)
+        h_max = k_magnitude / (2 * np.pi / a)
+        k_max = k_magnitude / (2 * np.pi / b)
+        l_max = k_magnitude / (2 * np.pi / c)
+        if alpha != 90.0 or beta != 90.0 or gamma != 90.0:
+            success = False 
+            message = "The crystal is not orthorhombic,\nthe accesible area is just approximate."
+        else: 
+            success = True
+            message = None
+        return {
+            "h_max": h_max,
+            "k_max": k_max,
+            "l_max": l_max,
+            "success": success,
+            "message": message,
+        }
+        
+
     def get_real_space_vectors(self):
         """Get the real space vectors.
 

{advisor_scattering-0.9.1 → advisor_scattering-0.9.5}/advisor/features/scattering_geometry/ui/components/angles_to_hkl_components.py

@@ -1,17 +1,9 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 # pylint: disable=no-name-in-module, import-error
-from PyQt5.QtWidgets import (
-    QWidget,
-    QVBoxLayout,
-    QFormLayout,
-    QGroupBox,
-    QLabel,
-    QPushButton,
-    QDoubleSpinBox,
-    QLineEdit,
-)
 from PyQt5.QtCore import pyqtSignal
+from PyQt5.QtWidgets import (QDoubleSpinBox, QFormLayout, QGroupBox, QLabel,
+                             QLineEdit, QPushButton, QVBoxLayout, QWidget)
 
 
 class AnglesToHKLControls(QWidget):
@@ -48,14 +40,6 @@ class AnglesToHKLControls(QWidget):
         self.theta_input.valueChanged.connect(self.anglesChanged.emit)
         form_layout.addRow("θ:", self.theta_input)
 
-        # phi input
-        self.phi_input = QDoubleSpinBox()
-        self.phi_input.setRange(-180.0, 180.0)
-        self.phi_input.setValue(0.0)
-        self.phi_input.setSuffix(" °")
-        self.phi_input.valueChanged.connect(self.anglesChanged.emit)
-        form_layout.addRow("φ:", self.phi_input)
-
         # chi input
         self.chi_input = QDoubleSpinBox()
         self.chi_input.setRange(-180.0, 180.0)
@@ -64,6 +48,14 @@ class AnglesToHKLControls(QWidget):
         self.chi_input.valueChanged.connect(self.anglesChanged.emit)
         form_layout.addRow("χ:", self.chi_input)
 
+        # phi input
+        self.phi_input = QDoubleSpinBox()
+        self.phi_input.setRange(-180.0, 180.0)
+        self.phi_input.setValue(0.0)
+        self.phi_input.setSuffix(" °")
+        self.phi_input.valueChanged.connect(self.anglesChanged.emit)
+        form_layout.addRow("φ:", self.phi_input)
+
         main_layout.addWidget(form_group)
 
         # Calculate button

{advisor_scattering-0.9.1 → advisor_scattering-0.9.5}/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_scattering-0.9.1 → advisor_scattering-0.9.5}/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_scattering-0.9.1 → advisor_scattering-0.9.5}/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_scattering-0.9.1 → advisor_scattering-0.9.5}/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_scattering-0.9.1 → advisor_scattering-0.9.5}/advisor/ui/dialogs/diffraction_test_dialog.py

@@ -30,7 +30,7 @@ class DiffractionTestDialog(QDialog):
         self.lattice_params = lattice_params
         self.result = None  # Will store (roll, pitch, yaw) on success
 
-        self.setWindowTitle("Import Orientation from Diffraction Tests")
+        self.setWindowTitle("Import Orientation from UB Matrix Tests")
         self.setMinimumWidth(800)
         self.setMinimumHeight(550)
 
@@ -42,7 +42,7 @@ class DiffractionTestDialog(QDialog):
 
         # Instructions label
         instructions = QLabel(
-            "Enter diffraction test data below. Each row represents a measurement "
+            "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)
@@ -52,7 +52,7 @@ class DiffractionTestDialog(QDialog):
         self.table = QTableWidget()
         self.table.setColumnCount(8)
         self.table.setHorizontalHeaderLabels(
-            ["H", "K", "L", "Energy (eV)", "tth (°)", "θ (°)", "φ (°)", "χ (°)"]
+            ["H", "K", "L", "Energy (eV)", "tth (°)", "θ (°)", "χ (°)", "φ (°)"]
         )
 
         # Set column resize mode
@@ -116,6 +116,7 @@ class DiffractionTestDialog(QDialog):
 
         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")
@@ -129,12 +130,30 @@ class DiffractionTestDialog(QDialog):
 
         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, phi, chi)
+        # 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))
@@ -166,8 +185,8 @@ class DiffractionTestDialog(QDialog):
                     "energy": float(self.table.item(row, 3).text()),
                     "tth": float(self.table.item(row, 4).text()),
                     "theta": float(self.table.item(row, 5).text()),
-                    "phi": float(self.table.item(row, 6).text()),
-                    "chi": float(self.table.item(row, 7).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:
@@ -218,6 +237,10 @@ class DiffractionTestDialog(QDialog):
         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"],

{advisor_scattering-0.9.1 → advisor_scattering-0.9.5}/advisor/ui/init_window.py

@@ -1,25 +1,16 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 # pylint: disable=no-name-in-module, import-error
-from PyQt5.QtWidgets import (
-    QWidget,
-    QGridLayout,
-    QFormLayout,
-    QLabel,
-    QLineEdit,
-    QPushButton,
-    QDoubleSpinBox,
-    QGroupBox,
-    QMessageBox,
-    QFileDialog,
-)
-from PyQt5.QtCore import pyqtSlot, pyqtSignal
+from PyQt5.QtCore import pyqtSignal, pyqtSlot
 from PyQt5.QtGui import QDragEnterEvent, QDropEvent
+from PyQt5.QtWidgets import (QDoubleSpinBox, QFileDialog, QFormLayout,
+                             QGridLayout, QGroupBox, QLabel, QLineEdit,
+                             QMessageBox, QPushButton, QWidget)
 
 from advisor.domain import UnitConverter
+from advisor.ui.dialogs import DiffractionTestDialog
 from advisor.ui.utils import readcif
 from advisor.ui.visualizers import CoordinateVisualizer, UnitcellVisualizer
-from advisor.ui.dialogs import DiffractionTestDialog
 
 
 class DragDropLineEdit(QLineEdit):
@@ -189,8 +180,8 @@ class InitWindow(QWidget):
         # Add energy group to main layout at (0,1)
         layout.addWidget(energy_group, 0, 1)
 
-        # Group box for Euler angles
-        euler_group = QGroupBox("Euler Angles")
+        # Group box for Sample orientation Euler angles
+        euler_group = QGroupBox("Sample Orientation (Euler Angles)")
         euler_layout = QFormLayout(euler_group)
 
         self.roll_input = QDoubleSpinBox()
@@ -220,10 +211,10 @@ class InitWindow(QWidget):
         self.yaw_input.valueChanged.connect(self.update_visualization)
         euler_layout.addRow("Yaw:", self.yaw_input)
 
-        # Add "Import from Diffraction Test" button
-        self.import_orientation_btn = QPushButton("Import from Diffraction Test")
+        # Add "Set UB Matrix (Import from Diffraction Tests)" button
+        self.import_orientation_btn = QPushButton("Set UB Matrix")
         self.import_orientation_btn.setToolTip(
-            "Calculate Euler angles from known diffraction measurements"
+            "Calculate Sample orientation (Euler angles) from known diffraction measurements. E.g. Two Braggs (002) (101) peaks are found at certain angles (tth, theta, phi, chi), at certain energy, the sample orientation can be determined."
         )
         self.import_orientation_btn.clicked.connect(self.open_diffraction_test_dialog)
         euler_layout.addRow(self.import_orientation_btn)
@@ -310,7 +301,7 @@ class InitWindow(QWidget):
         if dialog.exec_() == DiffractionTestDialog.Accepted:
             result = dialog.get_result()
             if result is not None:
-                # Apply the calculated Euler angles
+                # Apply the calculated Sample orientation Euler angles
                 self.roll_input.setValue(result["roll"])
                 self.pitch_input.setValue(result["pitch"])
                 self.yaw_input.setValue(result["yaw"])

{advisor_scattering-0.9.1 → advisor_scattering-0.9.5}/advisor/ui/visualizers/HKLScan2DVisualizer.py

@@ -1,6 +1,8 @@
-from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
-from matplotlib.figure import Figure
 import numpy as np
+from matplotlib.backends.backend_qt5agg import \
+    FigureCanvasQTAgg as FigureCanvas
+from matplotlib.figure import Figure
+from matplotlib.patches import Ellipse
 
 
 class HKLScan2DVisualizer(FigureCanvas):
@@ -222,3 +224,36 @@ class HKLScan2DVisualizer(FigureCanvas):
         except Exception as e:
             print(f"Error in _plot_trajectory_only: {e}")
             return False
+
+    def plot_accessible_area(self, plane_type, h_max, k_max, l_max, message=None):
+        """ plot an ellipse in the plane to represent the accessible area in k-space.
+        
+        Args:
+            plane_type: "HK", "HL", or "KL"
+            h_max: maximum value of the h-axis
+            k_max: maximum value of the k-axis
+            l_max: maximum value of the l-axis
+        """
+        # use matplotlib patches to plot an ellipse in the plane to represent the accessible area in
+        # k-space.
+
+        if plane_type == "HK":
+            x_max = h_max
+            y_max = k_max
+        elif plane_type == "HL":
+            x_max = h_max
+            y_max = l_max
+        elif plane_type == "KL":
+            x_max = k_max
+            y_max = l_max
+
+        ellipse = Ellipse(xy=(0, 0), width=2*x_max, height=2*y_max, angle=0, color='#80e8be', alpha=0.35, edgecolor='none')
+        self.axes.add_patch(ellipse)
+        
+        # put a gray text on the top left corner of the plot
+        if message is not None:
+            self.axes.text(0.02, 0.985, message, color='gray', fontsize=8, transform=self.axes.transAxes, va="top", alpha = 0.65)
+
+        self.axes.text(0,0.1,"accessible area", color='#52a38b', fontsize=8, ha="center")
+        self.draw()
+        return True

{advisor_scattering-0.9.1 → advisor_scattering-0.9.5}/advisor_scattering.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: advisor-scattering
-Version: 0.9.1
+Version: 0.9.5
 Summary: Advisor-Scattering: Advanced Visual X-ray Scattering Toolkit for Reciprocal-space visualization and calculation
 Author: Xunyang Hong
 License: MIT
@@ -37,6 +37,7 @@ or use the link below to view the demo video.
 - Visualize scattering geometry and unit cells
 - Compute and visualize structure factors in reciprocal space.
 - CIF file drop-in support
+- Import crystal orientation from diffraction test data
 
 
 ## Install
@@ -75,7 +76,8 @@ python -m advisor
 ### 1. Initialization window
 - Enter lattice constants (a, b, c) and angles (alpha, beta, gamma); beam energy auto-updates wavelength/|k|.
 - Optional: drop a CIF to autofill lattice parameters and preview the unit cell.
-- Adjust Euler angles (roll, pitch, yaw) to orient the sample relative to the scattering plane;
+- Adjust Euler angles (roll, pitch, yaw) to orient the lattice/sample relative to the goniometer.
+- **New:** Use **Import from Diffraction Test** to automatically determine Euler angles from known diffraction measurements.
 - Click **Initialize** to load the main interface and pass parameters to all tabs.
 
 ### 2. Scattering Geometry tab

{advisor_scattering-0.9.1 → advisor_scattering-0.9.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "advisor-scattering"
-version = "0.9.1"
+version = "0.9.5"
 description = "Advisor-Scattering: Advanced Visual X-ray Scattering Toolkit for Reciprocal-space visualization and calculation"
 readme = "README.md"
 requires-python = ">=3.8"