advisor-scattering 0.5.2__py3-none-any.whl → 0.9.1__py3-none-any.whl

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/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/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/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/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/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/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/features/__init__.py

@@ -1,6 +1,9 @@
-"""Feature packages."""
+"""Feature packages.
 
-from advisor.features.scattering_geometry.controllers import ScatteringGeometryController
-from advisor.features.structure_factor.controllers import StructureFactorController
+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__ = ["ScatteringGeometryController", "StructureFactorController"]
+__all__ = []