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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: advisor-scattering
-Version: 0.5.3
+Version: 0.9.1
 Summary: Advisor-Scattering: Advanced Visual X-ray Scattering Toolkit for Reciprocal-space visualization and calculation
 Author: Xunyang Hong
 License: MIT

{advisor_scattering-0.5.3 → advisor_scattering-0.9.1}/advisor/controllers/app_controller.py

@@ -6,7 +6,8 @@ from typing import Optional
 
 from PyQt5.QtWidgets import QApplication
 
-from advisor.features import ScatteringGeometryController, StructureFactorController
+from advisor.features.scattering_geometry.controllers import ScatteringGeometryController
+from advisor.features.structure_factor.controllers import StructureFactorController
 from advisor.ui.init_window import InitWindow
 from advisor.ui.main_window import MainWindow
 

{advisor_scattering-0.5.3 → advisor_scattering-0.9.1}/advisor/domain/__init__.py

@@ -10,6 +10,8 @@ from .geometry import (
     lab_to_sample_conversion,
 )
 from .unit_converter import UnitConverter
+from .orientation import fit_orientation_from_diffraction_tests
+from .orientation_calculator import OrientationCalculator
 
 __all__ = [
     "get_real_space_vectors",
@@ -20,4 +22,6 @@ __all__ = [
     "sample_to_lab_conversion",
     "lab_to_sample_conversion",
     "UnitConverter",
+    "fit_orientation_from_diffraction_tests",
+    "OrientationCalculator",
 ]

{advisor_scattering-0.5.3 → advisor_scattering-0.9.1}/advisor/domain/core/lab.py

@@ -3,8 +3,8 @@
 import numpy as np
 
 from advisor.domain import angle_to_matrix
-from .sample import Sample
 
+from .sample import Sample
 
 
 class Lab:
@@ -113,9 +113,16 @@ class Lab:
         return ex_lattice_in_lab, ey_lattice_in_lab, ez_lattice_in_lab
 
     def rotate(self, theta, phi, chi):
-        """Rotate the lab."""
+        """Rotate the lab / goniometer"""
         self.theta = theta
         self.phi = phi
         self.chi = chi
         self.calculate_real_space_vectors()
         self.calculate_reciprocal_space_vectors()
+    
+    def reorient(self,roll, pitch, yaw):
+        """reorient the sample with respect to the lab"""
+        self.sample.reorient(roll, pitch, yaw)
+        self.calculate_real_space_vectors()
+        self.calculate_reciprocal_space_vectors()
+

{advisor_scattering-0.5.3 → advisor_scattering-0.9.1}/advisor/domain/core/lattice.py

@@ -2,10 +2,7 @@
 
 import numpy as np
 
-from advisor.domain import (
-    get_real_space_vectors,
-    get_reciprocal_space_vectors,
-)
+from advisor.domain import get_real_space_vectors, get_reciprocal_space_vectors
 
 
 class Lattice:
@@ -31,7 +28,7 @@ class Lattice:
         self.c_star_vec_lattice = None
 
     def initialize(self, a, b, c, alpha, beta, gamma):
-        """Initialize the sample.
+        """Initialize by calculating the real and reciprocal space vectors.
 
         Args:
             a, b, c (float): Lattice constants in Angstroms

{advisor_scattering-0.5.3 → advisor_scattering-0.9.1}/advisor/domain/core/sample.py

@@ -3,8 +3,10 @@
 import numpy as np
 
 from advisor.domain import euler_to_matrix
+
 from .lattice import Lattice
 
+
 class Sample:
     """This is a class for the sample."""
 
@@ -97,5 +99,10 @@ class Sample:
         self.b_star_vec_sample = rotation_matrix @ b_star_vec_lattice
         self.c_star_vec_sample = rotation_matrix @ c_star_vec_lattice
 
-    def rotate(self, theta, phi, chi):
-        """Rotate the sample."""
+    def reorient(self,roll, pitch, yaw):
+        """reorient the sample"""
+        self.roll = roll
+        self.pitch = pitch
+        self.yaw = yaw
+        self.calculate_real_space_vectors()
+        self.calculate_reciprocal_space_vectors()

advisor_scattering-0.9.1/advisor/domain/orientation.py

@@ -0,0 +1,219 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Orientation fitting from diffraction tests.
+
+This module provides functions to determine the optimal Euler angles (roll, pitch, yaw)
+that align a crystal lattice orientation with observed diffraction data.
+"""
+
+import numpy as np
+from scipy.optimize import minimize
+
+from .orientation_calculator import OrientationCalculator
+
+# Default number of random restarts for optimization
+DEFAULT_N_RESTARTS = 20
+# Target residual error - stop early if achieved
+TARGET_RESIDUAL = 1e-10
+
+
+def fit_orientation_from_diffraction_tests(
+    lattice_params: dict,
+    diffraction_tests: list,
+    initial_guess: tuple = (0.0, 0.0, 0.0),
+    n_restarts: int = DEFAULT_N_RESTARTS,
+) -> dict:
+    """Fit crystal orientation from diffraction test data.
+
+    Given lattice parameters and a list of diffraction tests (each containing
+    known HKL values and measured angles), find the Euler angles (roll, pitch, yaw)
+    that best explain the observations.
+
+    Uses multiple random restarts to avoid local minima.
+
+    Args:
+        lattice_params: Dictionary containing lattice parameters:
+            - a, b, c (float): Lattice constants in Angstroms
+            - alpha, beta, gamma (float): Lattice angles in degrees
+        diffraction_tests: List of dictionaries, each containing:
+            - H, K, L (float): Expected Miller indices
+            - energy (float): X-ray energy in eV
+            - tth (float): Scattering angle 2θ in degrees
+            - theta (float): Sample theta rotation in degrees
+            - phi (float): Sample phi rotation in degrees
+            - chi (float): Sample chi rotation in degrees
+        initial_guess: Initial guess for (roll, pitch, yaw) in degrees
+        n_restarts: Number of random restarts to try (default: 20)
+
+    Returns:
+        dict: Dictionary containing:
+            - roll, pitch, yaw (float): Optimized Euler angles in degrees
+            - residual_error (float): Final residual error (sum of squared HKL differences)
+            - individual_errors (list): Per-test HKL errors
+            - success (bool): Whether optimization converged
+            - message (str): Status message
+    """
+
+    if not diffraction_tests:
+        return {
+            "success": False,
+            "message": "No diffraction tests provided",
+            "roll": 0.0,
+            "pitch": 0.0,
+            "yaw": 0.0,
+        }
+
+    # Validate diffraction tests
+    required_keys = ["H", "K", "L", "energy", "tth", "theta", "phi", "chi"]
+    for i, test in enumerate(diffraction_tests):
+        missing = [k for k in required_keys if k not in test]
+        if missing:
+            return {
+                "success": False,
+                "message": f"Test {i+1} is missing required keys: {missing}",
+                "roll": 0.0,
+                "pitch": 0.0,
+                "yaw": 0.0,
+            }
+
+    # Initialize calculator with lattice parameters (using initial roll, pitch, yaw = 0)
+    calculator = OrientationCalculator()
+    init_params = {
+        "a": lattice_params["a"],
+        "b": lattice_params["b"],
+        "c": lattice_params["c"],
+        "alpha": lattice_params["alpha"],
+        "beta": lattice_params["beta"],
+        "gamma": lattice_params["gamma"],
+        "energy": diffraction_tests[0]["energy"],  # Will be updated per test
+        "roll": 0.0,
+        "pitch": 0.0,
+        "yaw": 0.0,
+    }
+
+    if not calculator.initialize(init_params):
+        return {
+            "success": False,
+            "message": "Failed to initialize calculator with given lattice parameters",
+            "roll": 0.0,
+            "pitch": 0.0,
+            "yaw": 0.0,
+        }
+
+    def objective(params):
+        """Objective function: sum of squared HKL errors."""
+        roll, pitch, yaw = params
+        calculator.reorient_sample(roll, pitch, yaw)
+
+        total_error = 0.0
+        for test in diffraction_tests:
+            # Update energy for this test
+            calculator.change_energy(test["energy"])
+
+            # Calculate HKL from angles
+            result = calculator.calculate_hkl(
+                test["tth"], test["theta"], test["phi"], test["chi"]
+            )
+
+            # Compute squared error
+            dH = result["H"] - test["H"]
+            dK = result["K"] - test["K"]
+            dL = result["L"] - test["L"]
+            total_error += dH**2 + dK**2 + dL**2
+
+        return total_error
+
+    def run_optimization(start_point):
+        """Run a single optimization from a starting point."""
+        return minimize(
+            objective,
+            start_point,
+            method="L-BFGS-B",
+            bounds=[(-180, 180), (-180, 180), (-180, 180)],
+            options={"ftol": 1e-12, "gtol": 1e-10, "maxiter": 1000},
+        )
+
+    # Multiple random restarts to find global minimum
+    best_result = None
+    best_error = float("inf")
+
+    # First try the user-provided initial guess
+    initial_points = [initial_guess]
+
+    # Add random starting points
+    rng = np.random.default_rng(seed=42)  # Reproducible results
+    for _ in range(n_restarts - 1):
+        # Random angles in [-180, 180]
+        random_point = tuple(rng.uniform(-180, 180, 3))
+        initial_points.append(random_point)
+
+    # Also add some structured starting points
+    structured_points = [
+        (0, 0, 0),
+        (90, 0, 0), (-90, 0, 0),
+        (0, 90, 0), (0, -90, 0),
+        (0, 0, 90), (0, 0, -90),
+    ]
+    for pt in structured_points:
+        if pt not in initial_points:
+            initial_points.append(pt)
+
+    # Run optimization from each starting point
+    for start_point in initial_points:
+        try:
+            result = run_optimization(start_point)
+            if result.fun < best_error:
+                best_error = result.fun
+                best_result = result
+
+            # Early stopping if we found a very good solution
+            if best_error < TARGET_RESIDUAL:
+                break
+        except Exception:
+            # Skip failed optimizations
+            continue
+
+    if best_result is None:
+        return {
+            "success": False,
+            "message": "All optimization attempts failed",
+            "roll": 0.0,
+            "pitch": 0.0,
+            "yaw": 0.0,
+        }
+
+    # Extract optimized parameters
+    roll_opt, pitch_opt, yaw_opt = best_result.x
+
+    # Calculate individual errors at optimal orientation
+    calculator.reorient_sample(roll_opt, pitch_opt, yaw_opt)
+    individual_errors = []
+    for test in diffraction_tests:
+        calculator.change_energy(test["energy"])
+        calc_result = calculator.calculate_hkl(
+            test["tth"], test["theta"], test["phi"], test["chi"]
+        )
+        error = {
+            "H_expected": test["H"],
+            "K_expected": test["K"],
+            "L_expected": test["L"],
+            "H_calculated": calc_result["H"],
+            "K_calculated": calc_result["K"],
+            "L_calculated": calc_result["L"],
+            "H_error": calc_result["H"] - test["H"],
+            "K_error": calc_result["K"] - test["K"],
+            "L_error": calc_result["L"] - test["L"],
+        }
+        individual_errors.append(error)
+
+    return {
+        "success": best_result.success,
+        "message": best_result.message if hasattr(best_result, "message") else "Optimization completed",
+        "roll": float(roll_opt),
+        "pitch": float(pitch_opt),
+        "yaw": float(yaw_opt),
+        "residual_error": float(best_result.fun),
+        "individual_errors": individual_errors,
+        "n_iterations": best_result.nit if hasattr(best_result, "nit") else None,
+        "n_restarts_used": len(initial_points),
+    }

advisor_scattering-0.9.1/advisor/domain/orientation_calculator.py

@@ -0,0 +1,174 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Lightweight calculator for orientation fitting.
+
+This module provides a minimal calculator class that can compute HKL values
+from scattering angles, used specifically for orientation fitting.
+It avoids importing from feature modules to prevent circular dependencies.
+"""
+
+import numpy as np
+
+from advisor.domain import angle_to_matrix
+from advisor.domain.core import Lab
+
+
+class OrientationCalculator:
+    """Lightweight calculator for orientation fitting.
+
+    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.
+    """
+
+    # Physical constants
+    EV_TO_LAMBDA = 12398.42  # eV to Angstrom conversion
+
+    def __init__(self):
+        """Initialize the calculator."""
+        self._initialized = False
+        self.lab = Lab()
+        self.energy = None
+        self.lambda_A = None
+        self.k_in = None
+
+    def initialize(self, params: dict) -> bool:
+        """Initialize with lattice parameters.
+
+        Args:
+            params: Dictionary containing:
+                - a, b, c (float): Lattice constants in Angstroms
+                - alpha, beta, gamma (float): Lattice angles in degrees
+                - energy (float): X-ray energy in eV
+                - roll, pitch, yaw (float, optional): Euler angles in degrees
+
+        Returns:
+            bool: True if initialization was successful
+        """
+        try:
+            a = params.get("a", 4.0)
+            b = params.get("b", 4.0)
+            c = params.get("c", 12.0)
+            alpha = params.get("alpha", 90.0)
+            beta = params.get("beta", 90.0)
+            gamma = params.get("gamma", 90.0)
+            roll = params.get("roll", 0.0)
+            pitch = params.get("pitch", 0.0)
+            yaw = params.get("yaw", 0.0)
+            self.energy = params["energy"]
+
+            # Initialize lab with default sample rotation (0, 0, 0)
+            self.lab.initialize(a, b, c, alpha, beta, gamma, roll, pitch, yaw, 0, 0, 0)
+
+            # Calculate wavelength and wavevector
+            self.lambda_A = self.EV_TO_LAMBDA / self.energy
+            self.k_in = 2 * np.pi / self.lambda_A
+
+            self._initialized = True
+            return True
+        except Exception as e:
+            print(f"Error initializing OrientationCalculator: {e}")
+            return False
+
+    def change_energy(self, energy: float) -> bool:
+        """Change the X-ray energy.
+
+        Args:
+            energy: X-ray energy in eV
+
+        Returns:
+            bool: True if successful
+        """
+        self.energy = energy
+        self.lambda_A = self.EV_TO_LAMBDA / self.energy
+        self.k_in = 2 * np.pi / self.lambda_A
+        return True
+
+    def reorient_sample(self, roll: float, pitch: float, yaw: float) -> bool:
+        """Reorient the sample (change Euler angles).
+
+        Args:
+            roll, pitch, yaw: Euler angles in degrees
+
+        Returns:
+            bool: True if successful
+        """
+        self.lab.reorient(roll, pitch, yaw)
+        return True
+
+    def calculate_hkl(
+        self, tth: float, theta: float, phi: float, chi: float
+    ) -> dict:
+        """Calculate HKL from scattering angles.
+
+        Args:
+            tth: Scattering angle 2θ in degrees
+            theta: Sample theta rotation in degrees
+            phi: Sample phi rotation in degrees
+            chi: Sample chi rotation in degrees
+
+        Returns:
+            dict: Dictionary containing:
+                - H, K, L (float): Miller indices
+                - tth, theta, phi, chi (float): Input angles
+                - success (bool): Whether calculation succeeded
+                - error (str or None): Error message if any
+        """
+        if not self._initialized:
+            return {
+                "H": None, "K": None, "L": None,
+                "tth": tth, "theta": theta, "phi": phi, "chi": chi,
+                "success": False,
+                "error": "Calculator not initialized",
+            }
+
+        try:
+            # Get real space vectors in lab frame
+            a_vec_lab, b_vec_lab, c_vec_lab = self.lab.get_real_space_vectors()
+
+            # Calculate momentum transfer magnitude
+            k_magnitude = 2.0 * self.k_in * np.sin(np.radians(tth / 2.0))
+
+            # Calculate delta angle
+            delta = 90 - (tth / 2.0)
+            sin_delta = np.sin(np.radians(delta))
+            cos_delta = np.cos(np.radians(delta))
+
+            # Momentum transfer at theta, phi, chi = 0
+            k_vec_initial = np.array(
+                [-k_magnitude * sin_delta, -k_magnitude * cos_delta, 0.0]
+            )
+
+            # Rotation of the beam is the reverse rotation of the sample
+            rotation_matrix = angle_to_matrix(theta, phi, chi).T
+
+            # Momentum transfer at the given angles
+            k_vec_lab = rotation_matrix @ k_vec_initial
+
+            # Calculate HKL by projecting onto real space vectors
+            H = np.dot(k_vec_lab, a_vec_lab) / (2 * np.pi)
+            K = np.dot(k_vec_lab, b_vec_lab) / (2 * np.pi)
+            L = np.dot(k_vec_lab, c_vec_lab) / (2 * np.pi)
+
+            return {
+                "H": H,
+                "K": K,
+                "L": L,
+                "tth": tth,
+                "theta": theta,
+                "phi": phi,
+                "chi": chi,
+                "success": True,
+                "error": None,
+            }
+        except Exception as e:
+            return {
+                "H": None, "K": None, "L": None,
+                "tth": tth, "theta": theta, "phi": phi, "chi": chi,
+                "success": False,
+                "error": str(e),
+            }
+
+    def is_initialized(self) -> bool:
+        """Check if the calculator is initialized."""
+        return self._initialized

advisor_scattering-0.9.1/advisor/features/__init__.py

@@ -0,0 +1,9 @@
+"""Feature packages.
+
+Note: Controllers are not exported here to avoid circular imports.
+Import them directly from their modules:
+    from advisor.features.scattering_geometry.controllers import ScatteringGeometryController
+    from advisor.features.structure_factor.controllers import StructureFactorController
+"""
+
+__all__ = []

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

@@ -105,6 +105,18 @@ class BrillouinCalculator:
             print(f"Error initializing calculator: {str(e)}")
             return False
 
+    def change_energy(self, energy):
+        """Change the energy of the X-ray source, in eV"""
+        self.energy = energy
+        self.lambda_A = self.ev_to_lambda / self.energy
+        self.k_in = 2 * np.pi / self.lambda_A
+        return True
+    
+    def reorient_sample(self, roll, pitch, yaw):
+        """Reorient the sample with respect to the lab"""
+        self.lab.reorient(roll, pitch, yaw)
+        return True
+
     def _sample_to_lab_conversion(self, a_vec, b_vec, c_vec):
         """Convert vectors from sample coordinate system to lab coordinate system."""
         # For now, just return the same vectors

{advisor_scattering-0.5.3 → advisor_scattering-0.9.1}/advisor/features/scattering_geometry/domain/core.py

@@ -253,7 +253,7 @@ def _calculate_angles_chi_fixed(
     yaw,
     chi_fixed,
     target_objective=1e-10,
-    max_restarts=20,
+    max_restarts=40,
 ):
     """Calculate scattering angles with chi angle (in degrees) fixed.
 
@@ -268,7 +268,7 @@ def _calculate_angles_chi_fixed(
         roll, pitch, yaw (float): Lattice rotation Euler angles in degrees. We use ZYX convention.
         chi_fixed (float): Fixed chi angle in degrees
         target_objective (float, optional): Convergence tolerance for fsolve. Defaults to 1e-10.
-        max_restarts (int, optional): Maximum number of random restarts. Defaults to 20.
+        max_restarts (int, optional): Maximum number of random restarts. Defaults to 40.
 
     Returns:
         dict: Dictionary containing:
@@ -384,7 +384,7 @@ def _calculate_angles_phi_fixed(
     yaw,
     phi_fixed,
     target_objective=1e-10,
-    max_restarts=20,
+    max_restarts=40,
 ):
     """Calculate scattering angles with phi angle fixed.
 
@@ -399,7 +399,7 @@ def _calculate_angles_phi_fixed(
         roll, pitch, yaw (float): Lattice rotation Euler angles in degrees. We use ZYX convention.
         phi_fixed (float): Fixed phi angle in degrees
         target_objective (float, optional): Convergence tolerance for fsolve. Defaults to 1e-10.
-        max_restarts (int, optional): Maximum number of random restarts. Defaults to 20.
+        max_restarts (int, optional): Maximum number of random restarts. Defaults to 40.
 
     Returns:
         dict: Dictionary containing:

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

@@ -0,0 +1,264 @@
+#!/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 Diffraction 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 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)
+        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 _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)
+        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()),
+                    "phi": float(self.table.item(row, 6).text()),
+                    "chi": 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)
+
+        # 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

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

@@ -19,6 +19,7 @@ from PyQt5.QtGui import QDragEnterEvent, QDropEvent
 from advisor.domain import UnitConverter
 from advisor.ui.utils import readcif
 from advisor.ui.visualizers import CoordinateVisualizer, UnitcellVisualizer
+from advisor.ui.dialogs import DiffractionTestDialog
 
 
 class DragDropLineEdit(QLineEdit):
@@ -219,6 +220,14 @@ 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")
+        self.import_orientation_btn.setToolTip(
+            "Calculate Euler angles from known diffraction measurements"
+        )
+        self.import_orientation_btn.clicked.connect(self.open_diffraction_test_dialog)
+        euler_layout.addRow(self.import_orientation_btn)
+
         # Add euler group to main layout at (0,2)
         layout.addWidget(euler_group, 0, 2)
 
@@ -283,6 +292,30 @@ class InitWindow(QWidget):
             self.file_path_input.setText(file_path)
             # on_cif_file_changed will be triggered by textChanged
 
+    @pyqtSlot()
+    def open_diffraction_test_dialog(self):
+        """Open the diffraction test dialog to import orientation from measurements."""
+        # Gather current lattice parameters
+        lattice_params = {
+            "a": self.a_input.value(),
+            "b": self.b_input.value(),
+            "c": self.c_input.value(),
+            "alpha": self.alpha_input.value(),
+            "beta": self.beta_input.value(),
+            "gamma": self.gamma_input.value(),
+        }
+
+        # Open the dialog
+        dialog = DiffractionTestDialog(lattice_params, self)
+        if dialog.exec_() == DiffractionTestDialog.Accepted:
+            result = dialog.get_result()
+            if result is not None:
+                # Apply the calculated Euler angles
+                self.roll_input.setValue(result["roll"])
+                self.pitch_input.setValue(result["pitch"])
+                self.yaw_input.setValue(result["yaw"])
+                # update_visualization will be triggered by valueChanged signals
+
     def set_lattice_inputs_enabled(self, enabled: bool):
         """Enable/disable lattice parameter inputs (a,b,c,alpha,beta,gamma)."""
         self.a_input.setEnabled(enabled)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: advisor-scattering
-Version: 0.5.3
+Version: 0.9.1
 Summary: Advisor-Scattering: Advanced Visual X-ray Scattering Toolkit for Reciprocal-space visualization and calculation
 Author: Xunyang Hong
 License: MIT

{advisor_scattering-0.5.3 → advisor_scattering-0.9.1}/advisor_scattering.egg-info/SOURCES.txt

@@ -9,6 +9,8 @@ advisor/controllers/app_controller.py
 advisor/controllers/feature_controller.py
 advisor/domain/__init__.py
 advisor/domain/geometry.py
+advisor/domain/orientation.py
+advisor/domain/orientation_calculator.py
 advisor/domain/unit_converter.py
 advisor/domain/core/__init__.py
 advisor/domain/core/lab.py
@@ -56,6 +58,8 @@ advisor/ui/init_window.py
 advisor/ui/main_window.py
 advisor/ui/tab_interface.py
 advisor/ui/tips.py
+advisor/ui/dialogs/__init__.py
+advisor/ui/dialogs/diffraction_test_dialog.py
 advisor/ui/utils/__init__.py
 advisor/ui/utils/readcif.py
 advisor/ui/visualizers/HKLScan2DVisualizer.py

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

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

advisor_scattering-0.5.3/advisor/features/__init__.py

@@ -1,6 +0,0 @@
-"""Feature packages."""
-
-from advisor.features.scattering_geometry.controllers import ScatteringGeometryController
-from advisor.features.structure_factor.controllers import StructureFactorController
-
-__all__ = ["ScatteringGeometryController", "StructureFactorController"]