advisor-scattering 0.5.0__py3-none-any.whl

advisor/domain/geometry.py

@@ -0,0 +1,212 @@
+"""
+here includes the translation functions
+"""
+
+import numpy as np
+
+
+def get_real_space_vectors(a, b, c, alpha, beta, gamma):
+    """Get the real space vectors a_vec, b_vec, c_vec from the lattice parameters.
+    - a_vec is by-default along x-axis (a, 0, 0)
+    - b_vec is by-default (b cos gamma, b sin gamma, 0) on the x-y plane,
+    - c_vec is then calculated
+    The above convention defines the lattice coordinate system.
+
+    Args:
+        a, b, c (float): Lattice constants in Angstroms
+        alpha, beta, gamma (float): Lattice angles in degrees
+
+    Returns:
+        a_vec, b_vec, c_vec (np.ndarray): Real space vectors
+    """
+    alpha_rad, beta_rad, gamma_rad = (
+        np.radians(alpha),
+        np.radians(beta),
+        np.radians(gamma),
+    )
+    a_vec = np.array([a, 0, 0])
+    b_vec = np.array([b * np.cos(gamma_rad), b * np.sin(gamma_rad), 0])
+    c_vec_x = c * np.cos(beta_rad)
+    c_vec_y = (
+        c
+        * (np.cos(alpha_rad) - np.cos(beta_rad) * np.cos(gamma_rad))
+        / np.sin(gamma_rad)
+    )
+    c_vec_z = np.sqrt(c**2 - c_vec_x**2 - c_vec_y**2)
+    c_vec = np.array([c_vec_x, c_vec_y, c_vec_z])
+    return a_vec, b_vec, c_vec
+
+
+def get_reciprocal_space_vectors(a, b, c, alpha, beta, gamma):
+    """Get the reciprocal space vectors a_star_vec, b_star_vec, c_star_vec from the lattice
+    parameters, angles in degrees. These vectors are in the crystal coordinate system.
+    """
+    a_vec, b_vec, c_vec = get_real_space_vectors(a, b, c, alpha, beta, gamma)
+    volumn = abs(np.dot(a_vec, np.cross(b_vec, c_vec)))
+    a_star_vec = 2 * np.pi * np.cross(b_vec, c_vec) / volumn
+    b_star_vec = 2 * np.pi * np.cross(c_vec, a_vec) / volumn
+    c_star_vec = 2 * np.pi * np.cross(a_vec, b_vec) / volumn
+    return a_star_vec, b_star_vec, c_star_vec
+
+
+def euler_to_matrix(roll, pitch, yaw):
+    """Convert Euler angles to rotation matrix. We follows the ZYX convention.
+    Remember we are using a right-hand rule.
+
+    Args:
+        roll (float): rotation about the new X axis in degrees
+        pitch (float): rotation about the new Y axis in degrees
+        yaw (float): rotation about the original z axis in degrees
+
+    Returns:
+        rotation_matrix (np.ndarray): Rotation matrix
+    """
+    roll_rad, pitch_rad, yaw_rad = (
+        np.radians(roll),
+        np.radians(pitch),
+        np.radians(yaw),
+    )
+    Rx = np.array(
+        [
+            [1, 0, 0],
+            [0, np.cos(roll_rad), -np.sin(roll_rad)],
+            [0, np.sin(roll_rad), np.cos(roll_rad)],
+        ]
+    )
+    # remember this is a right-hand rule
+    Ry = np.array(
+        [
+            [np.cos(pitch_rad), 0, np.sin(pitch_rad)],
+            [0, 1, 0],
+            [-np.sin(pitch_rad), 0, np.cos(pitch_rad)],
+        ]
+    )
+
+    Rz = np.array(
+        [
+            [np.cos(yaw_rad), -np.sin(yaw_rad), 0],
+            [np.sin(yaw_rad), np.cos(yaw_rad), 0],
+            [0, 0, 1],
+        ]
+    )
+
+    return Rz @ Ry @ Rx  # ZYX order
+
+
+def angle_to_matrix(theta, phi, chi, is_inverse = False):
+    """Convert angles theta, phi, chi to rotation matrix.
+    Pay attention to the direction of the rotation.
+    
+    Updated for x-y scattering plane (z-axis is normal to scattering plane).
+
+    Args:
+        theta (float): rotation about the z-axis in degrees, right-hand rule
+        phi (float): rotation about the x-axis in degrees, right-hand rule
+        chi (float): rotation about the y-axis in degrees, right-hand rule
+
+    Returns:
+        rotation_matrix (np.ndarray): Rotation matrix
+    """
+    theta_rad, phi_rad, chi_rad = (np.radians(theta), np.radians(phi), np.radians(chi))
+
+    # theta rotation around the z-axis (perpendicular to scattering plane)
+    theta_mat = np.array(
+        [
+            [np.cos(theta_rad), -np.sin(theta_rad), 0],
+            [np.sin(theta_rad), np.cos(theta_rad), 0],
+            [0, 0, 1],
+        ]
+    )
+    # chi rotation around the y-axis (in scattering plane)
+    chi_mat = np.array(
+        [
+            [np.cos(chi_rad), 0, np.sin(chi_rad)],
+            [0, 1, 0],
+            [-np.sin(chi_rad), 0, np.cos(chi_rad)],
+        ]
+    )
+
+    # phi rotation around the x-axis (in scattering plane)
+    phi_mat = np.array(
+        [
+            [1, 0, 0],
+            [0, np.cos(phi_rad), -np.sin(phi_rad)],
+            [0, np.sin(phi_rad), np.cos(phi_rad)],
+        ]
+    )
+
+    matrix = theta_mat @ chi_mat @ phi_mat
+    if is_inverse:
+        matrix = matrix.T
+    return matrix
+
+
+def get_rotation(phi, chi, is_inverse = False):
+    """get the rotational matrix that rotates the sample with respect to the scattering plane.
+    
+    Updated for x-y scattering plane (z-axis is normal to scattering plane).
+    phi: rotation about x-axis (in scattering plane)
+    chi: rotation about y-axis (in scattering plane)
+    """
+    # Convert angles to radians
+    phi_rad = np.radians(phi)
+    chi_rad = np.radians(chi)
+
+    # chi rotation about y-axis (in scattering plane)
+    chi_mat_sample = np.array(
+        [
+            [np.cos(chi_rad), 0, np.sin(chi_rad)],
+            [0, 1, 0],
+            [-np.sin(chi_rad), 0, np.cos(chi_rad)],
+        ]
+    )
+    # phi rotation about x-axis (in scattering plane)
+    phi_mat_sample = np.array(
+        [
+            [1, 0, 0],
+            [0, np.cos(phi_rad), -np.sin(phi_rad)],
+            [0, np.sin(phi_rad), np.cos(phi_rad)],
+        ]
+    )
+    matrix = chi_mat_sample @ phi_mat_sample 
+    if is_inverse:
+        matrix = matrix.T
+    return matrix
+
+
+
+
+def sample_to_lab_conversion(
+    a_vec_sample, b_vec_sample, c_vec_sample, roll, pitch, yaw
+):
+    """Convert vectors from sample coordinate system to lab coordinate system.
+
+    Args:
+        a_vec_sample, b_vec_sample, c_vec_sample (np.ndarray): Vectors in sample coordinate system
+        roll, pitch, yaw (float): Euler angles in degrees
+
+    Returns:
+        a_vec_lab, b_vec_lab, c_vec_lab (np.ndarray): Vectors in lab coordinate system
+    """
+    rotation_matrix = euler_to_matrix(roll, pitch, yaw)
+    a_vec_lab = rotation_matrix @ a_vec_sample
+    b_vec_lab = rotation_matrix @ b_vec_sample
+    c_vec_lab = rotation_matrix @ c_vec_sample
+    return a_vec_lab, b_vec_lab, c_vec_lab
+
+
+def lab_to_sample_conversion(a_vec_lab, b_vec_lab, c_vec_lab, roll, pitch, yaw):
+    """Convert vectors from lab coordinate system to sample coordinate system.
+
+    Args:
+        a_vec_lab, b_vec_lab, c_vec_lab (np.ndarray): Vectors in lab coordinate system
+        roll, pitch, yaw (float): Euler angles in degrees
+
+    Returns:
+        a_vec_sample, b_vec_sample, c_vec_sample (np.ndarray): Vectors in sample coordinate system
+    """
+    rotation_matrix = euler_to_matrix(roll, pitch, yaw)
+    a_vec_sample = rotation_matrix.T @ a_vec_lab
+    b_vec_sample = rotation_matrix.T @ b_vec_lab
+    c_vec_sample = rotation_matrix.T @ c_vec_lab
+    return a_vec_sample, b_vec_sample, c_vec_sample

advisor/domain/unit_converter.py

@@ -0,0 +1,82 @@
+import numpy as np
+from typing import Union, Optional
+
+
+class UnitConverter:
+    """
+    A class for converting between different units commonly used in X-ray spectroscopy.
+    """
+
+    def __init__(self):
+        # Fundamental constants
+        self.angstrom_to_ev_constant = 12398.425
+        self.ev_to_phz_constant = 0.2418
+        self.ev_to_momentum_constant = 0.080656  # in A^-1
+
+    def ev_to_angstrom(
+        self, energy: Union[float, np.ndarray]
+    ) -> Union[float, np.ndarray]:
+        """
+        Convert X-ray energy from eV to wavelength in Angstrom.
+
+        Args:
+            energy: Energy in eV
+
+        Returns:
+            Wavelength in Angstrom
+        """
+        return self.angstrom_to_ev_constant / energy
+
+    def angstrom_to_ev(
+        self, wavelength: Union[float, np.ndarray]
+    ) -> Union[float, np.ndarray]:
+        """
+        Convert X-ray wavelength from Angstrom to energy in eV.
+
+        Args:
+            wavelength: Wavelength in Angstrom
+
+        Returns:
+            Energy in eV
+        """
+        return self.angstrom_to_ev_constant / wavelength
+
+    def ev_to_phz(self, energy: Union[float, np.ndarray]) -> Union[float, np.ndarray]:
+        """
+        Convert X-ray energy from eV to frequency in PHz.
+
+        Args:
+            energy: Energy in eV
+
+        Returns:
+            Frequency in PHz
+        """
+        return energy * self.ev_to_phz_constant
+
+    def phz_to_ev(
+        self, frequency: Union[float, np.ndarray]
+    ) -> Union[float, np.ndarray]:
+        """
+        Convert X-ray frequency from PHz to energy in eV.
+
+        Args:
+            frequency: Frequency in PHz
+
+        Returns:
+            Energy in eV
+        """
+        return frequency / self.ev_to_phz_constant
+
+    def ev_to_momentum(
+        self, energy: Union[float, np.ndarray]
+    ) -> Union[float, np.ndarray]:
+        """
+        Convert X-ray energy from eV to momentum in Å^-1.
+
+        Args:
+            energy: Energy in eV
+
+        Returns:
+            Momentum in Å^-1
+        """
+        return energy * self.ev_to_momentum_constant

advisor/features/__init__.py

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

advisor/features/scattering_geometry/controllers/__init__.py

@@ -0,0 +1,5 @@
+"""Controllers for scattering geometry feature."""
+
+from .scattering_geometry_controller import ScatteringGeometryController
+
+__all__ = ["ScatteringGeometryController"]

advisor/features/scattering_geometry/controllers/scattering_geometry_controller.py

@@ -0,0 +1,26 @@
+"""Controller for the scattering geometry (Brillouin) feature."""
+
+from advisor.controllers.feature_controller import FeatureController
+from advisor.features.scattering_geometry.domain import BrillouinCalculator
+from advisor.features.scattering_geometry.ui.scattering_geometry_tab import ScatteringGeometryTab
+
+
+class ScatteringGeometryController(FeatureController):
+    """Manages the Brillouin/scattering geometry feature."""
+
+    title = "Scattering Geometry"
+    description = "Convert angles ↔ HKL, scan HKL trajectories, and visualize scattering geometry."
+    icon = "bz_calculator.png"
+
+    def __init__(self, app_controller):
+        super().__init__(app_controller)
+        self.calculator = BrillouinCalculator()
+        self.view = self.build_view()
+
+    def build_view(self):
+        return ScatteringGeometryTab(controller=self, calculator=self.calculator)
+
+    def set_parameters(self, params: dict):
+        self.calculator.initialize(params=params)
+        if self.view and hasattr(self.view, "set_parameters"):
+            self.view.set_parameters(params)

advisor/features/scattering_geometry/domain/__init__.py

@@ -0,0 +1,5 @@
+"""Domain logic for scattering geometry feature."""
+
+from .brillouin_calculator import BrillouinCalculator
+
+__all__ = ["BrillouinCalculator"]