advisor-scattering 0.5.0__py3-none-any.whl

advisor/ui/main_window.py

@@ -0,0 +1,174 @@
+"""Main window view for Advisor-Scattering."""
+
+import os
+from typing import Optional
+
+from PyQt5.QtWidgets import (
+    QAction,
+    QFileDialog,
+    QGridLayout,
+    QMainWindow,
+    QMessageBox,
+    QStatusBar,
+    QStackedWidget,
+    QTabWidget,
+    QToolBar,
+    QWidget,
+)
+from PyQt5.QtCore import Qt, QSize
+from PyQt5.QtGui import QIcon
+
+
+class MainWindow(QMainWindow):
+    """Application shell: hosts init view and feature tabs."""
+
+    def __init__(self, controller):
+        super().__init__()
+        self.controller = controller
+
+        self.init_view: Optional[QWidget] = None
+        self.tabs_loaded = False
+
+        self._setup_window()
+        self._build_layout()
+        self._create_toolbar()
+        self._create_menu()
+
+    def _setup_window(self):
+        config = getattr(self.controller, "config", {}) or {}
+        self.setWindowTitle(config.get("app_name", "Advisor-Scattering"))
+        window_size = config.get("window_size", {"width": 1200, "height": 800})
+        self.resize(window_size.get("width", 1200), window_size.get("height", 800))
+
+    def _build_layout(self):
+        container = QWidget(self)
+        self.setCentralWidget(container)
+
+        layout = QGridLayout(container)
+        layout.setContentsMargins(5, 5, 5, 5)
+        layout.setSpacing(10)
+
+        self.stacked_widget = QStackedWidget()
+        layout.addWidget(self.stacked_widget, 0, 0)
+
+        self.tab_widget = QTabWidget()
+        self.tab_widget.setTabPosition(QTabWidget.West)
+        self.tab_widget.setIconSize(QSize(105, 80))
+        self.tab_widget.setMovable(True)
+        self.tab_widget.setDocumentMode(True)
+        self.stacked_widget.addWidget(self.tab_widget)
+
+        self.setStatusBar(QStatusBar())
+        self.statusBar().showMessage("Please initialize lattice parameters")
+
+    def _create_toolbar(self):
+        toolbar = QToolBar("Main Toolbar", self)
+        toolbar.setMovable(False)
+        toolbar.setIconSize(QSize(24, 24))
+        self.addToolBar(toolbar)
+
+        reset_action = QAction(self)
+        reset_action.setText("Reset Parameters")
+        reset_action.setToolTip("Return to initialization")
+        reset_icon = self._icon_path("reset.png")
+        if reset_icon and os.path.exists(reset_icon):
+            reset_action.setIcon(QIcon(reset_icon))
+        reset_action.triggered.connect(self.controller.reset_parameters)
+        toolbar.addAction(reset_action)
+
+    def _create_menu(self):
+        file_menu = self.menuBar().addMenu("&File")
+
+        open_action = QAction("&Open", self)
+        open_action.setShortcut("Ctrl+O")
+        open_action.triggered.connect(self._open_file)
+        file_menu.addAction(open_action)
+
+        save_action = QAction("&Save", self)
+        save_action.setShortcut("Ctrl+S")
+        save_action.triggered.connect(self._save_file)
+        file_menu.addAction(save_action)
+
+        file_menu.addSeparator()
+        reset_action = QAction("&Reset Parameters", self)
+        reset_action.setShortcut("Ctrl+R")
+        reset_action.triggered.connect(self.controller.reset_parameters)
+        file_menu.addAction(reset_action)
+
+        file_menu.addSeparator()
+        exit_action = QAction("E&xit", self)
+        exit_action.setShortcut("Ctrl+Q")
+        exit_action.triggered.connect(self.close)
+        file_menu.addAction(exit_action)
+
+        help_menu = self.menuBar().addMenu("&Help")
+        about_action = QAction("&About", self)
+        about_action.triggered.connect(self._show_about)
+        help_menu.addAction(about_action)
+
+    def attach_init_view(self, widget: QWidget):
+        """Attach the initialization view as the first stacked page."""
+        self.init_view = widget
+        self.stacked_widget.insertWidget(0, widget)
+        self.stacked_widget.setCurrentWidget(widget)
+
+    def add_feature_tab(self, widget: QWidget, title: str, icon_name: Optional[str] = None, tooltip: str = ""):
+        """Add a feature tab to the tab widget."""
+        icon_path = self._icon_path(icon_name) if icon_name else None
+        if icon_path and os.path.exists(icon_path):
+            self.tab_widget.addTab(widget, QIcon(icon_path), "")
+        else:
+            self.tab_widget.addTab(widget, title)
+
+        index = self.tab_widget.count() - 1
+        self.tab_widget.setTabToolTip(index, tooltip or title)
+
+    def show_tabs(self):
+        """Switch to the main tab view."""
+        self.stacked_widget.setCurrentWidget(self.tab_widget)
+        self.statusBar().showMessage("Ready")
+
+    def show_init(self):
+        """Switch back to initialization view."""
+        if self.init_view:
+            self.stacked_widget.setCurrentWidget(self.init_view)
+            self.statusBar().showMessage("Please initialize lattice parameters")
+
+    def _open_file(self):
+        file_path, _ = QFileDialog.getOpenFileName(
+            self, "Open File", "", "All Files (*);;JSON Files (*.json);;CIF Files (*.cif)"
+        )
+        if not file_path:
+            return
+
+        current_widget = self.tab_widget.currentWidget()
+        if hasattr(current_widget, "open_file"):
+            current_widget.open_file(file_path)
+        else:
+            self.statusBar().showMessage("Current tab does not support opening files")
+
+    def _save_file(self):
+        file_path, _ = QFileDialog.getSaveFileName(
+            self, "Save File", "", "All Files (*);;JSON Files (*.json)"
+        )
+        if not file_path:
+            return
+
+        current_widget = self.tab_widget.currentWidget()
+        if hasattr(current_widget, "save_file"):
+            current_widget.save_file(file_path)
+        else:
+            self.statusBar().showMessage("Current tab does not support saving files")
+
+    def _show_about(self):
+        QMessageBox.about(
+            self,
+            "About Advisor-Scattering",
+            "<b>Advisor-Scattering</b><p>A PyQt5-based application for X-ray scattering and diffraction preparation.</p>",
+        )
+
+    def _icon_path(self, name: Optional[str]) -> Optional[str]:
+        if not name:
+            return None
+        base_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+        return os.path.join(base_dir, "resources", "icons", name)

advisor/ui/tab_interface.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Base class for all tab implementations."""
+
+from PyQt5.QtWidgets import QWidget, QGridLayout
+
+
+class TabInterface(QWidget):
+    """Base class for feature tabs."""
+
+    def __init__(self, controller=None, main_window=None):
+        super().__init__()
+        self.controller = controller
+        self.main_window = main_window
+
+        self.layout = QGridLayout(self)
+        self.layout.setContentsMargins(10, 10, 10, 10)
+        self.layout.setSpacing(10)
+
+        self.init_ui()
+
+    def init_ui(self):
+        """Initialize UI components."""
+        raise NotImplementedError("Subclasses must implement init_ui()")
+
+    def open_file(self, file_path: str):
+        """Handle opening a file."""
+        return False
+
+    def save_file(self, file_path: str):
+        """Handle saving to a file."""
+        return False
+
+    def clear(self):
+        """Clear all inputs and results."""
+        pass
+
+    def get_state(self) -> dict:
+        """Get the current state of the tab for session saving."""
+        return {}
+
+    def set_state(self, state: dict):
+        """Restore tab state from saved session."""
+        return False

advisor/ui/tips.py

@@ -0,0 +1,30 @@
+"""Tooltip helper utilities."""
+
+import json
+import os
+
+
+def _tips_path() -> str:
+    base_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    return os.path.join(base_dir, "resources", "config", "tips.json")
+
+
+class Tips:
+    """Load tooltip text from resources/config/tips.json."""
+
+    def __init__(self):
+        self.tips = {}
+        try:
+            with open(_tips_path(), "r", encoding="utf-8") as handle:
+                self.tips = json.load(handle)
+        except FileNotFoundError:
+            self.tips = {}
+
+    def tip(self, key):
+        return self.tips.get(key, "")
+
+
+def set_tip(widget, tip):
+    """Set the tooltip and status tip for a widget."""
+    widget.setToolTip(tip)
+    widget.setStatusTip(tip)

advisor/ui/utils/__init__.py

@@ -0,0 +1,6 @@
+"""Utility helpers for UI."""
+
+from .readcif import readcif
+
+__all__ = ["readcif"]
+

advisor/ui/utils/readcif.py

@@ -0,0 +1,129 @@
+import os, re
+def readcif(filename=None, debug=False):
+
+    """
+    Open a Crystallographic Information File (*.cif) file and store all entries in a key:value dictionary
+     Looped values are stored as lists under a single key entry
+     All values are stored as strings
+    E.G.
+      crys=readcif('somefile.cif')
+      crys['_cell_length_a'] = '2.835(2)'
+
+    crys[key] = value
+    available keys are give by crys.keys()
+
+    To debug the file with outputted messages, use:
+      cif = readcif(file, debug=True)
+
+    Some useful standard CIF keywords:
+        _cell_length_a
+        _cell_length_b
+        _cell_length_c
+        _cell_angle_alpha
+        _cell_angle_beta
+        _cell_angle_gamma
+        _space_group_symop_operation_xyz
+        _atom_site_label
+        _atom_site_type_symbol
+        _atom_site_occupancy
+        _atom_site_U_iso_or_equiv
+        _atom_site_fract_x
+        _atom_site_fract_y
+        _atom_site_fract_z
+    """
+
+    # Get file name
+    filename = os.path.abspath(os.path.expanduser(filename))
+    (dirName, filetitle) = os.path.split(filename)
+    (fname, Ext) = os.path.splitext(filetitle)
+
+    # Open file
+    file = open(filename)
+    text = file.read()
+    file.close()
+
+    # Remove blank lines
+    while "\n\n" in text:
+        text = text.replace("\n\n", "\n")
+    lines = text.splitlines()
+
+    cifvals = {'Filename': filename, 'Directory': dirName, 'FileTitle': fname}
+
+    # Read file line by line, converting the cif file values to a python dict
+    n = 0
+    while n < len(lines):
+        # Convert line to columns
+        vals = lines[n].strip().split()
+
+        # skip empty lines
+        if len(vals) == 0:
+            n += 1
+            continue
+
+        # Search for stored value lines
+        if vals[0][0] == '_':
+            if len(vals) == 1:
+                # Record next lines that are not keys as string
+                if lines[n + 1][0] == ';': n += 1
+                strarg = []
+                while n + 1 < len(lines) and (len(lines[n + 1]) == 0 or lines[n + 1][0].strip() not in ['_', ';']):
+                    strarg += [lines[n + 1].strip('\'"')]
+                    n += 1
+                cifvals[vals[0]] = '\n'.join(strarg)
+                chk = 'a'
+            else:
+                cifvals[vals[0]] = ' '.join(vals[1:]).strip(' \'"\n')
+                chk = 'b'
+            n += 1
+            if debug:
+                print('%5d %s %s = %s' % (n, chk, vals[0], cifvals[vals[0]]))
+            continue
+
+        # Search for loops
+        elif vals[0] == 'loop_':
+            n += 1
+            loopvals = []
+            # Step 1: Assign loop columns
+            # looped columns are given by "_column_name"
+            while n < len(lines) and len(lines[n].strip()) > 0 and lines[n].strip()[0] == '_':
+                loopvals += [lines[n].split()[0]]
+                cifvals[loopvals[-1]] = []
+                n += 1
+
+            # Step 2: Assign data to columns
+            # loops until line has less segments than columns
+            while n < len(lines):
+                # cols = lines[n].split()
+                # this fixes error on symmetry arguments having spaces
+                # this will only work if the last argument in the loop is split by spaces (in quotes)
+                # cols = cols[:len(loopvals) - 1] + [''.join(cols[len(loopvals) - 1:])]
+                cols = [col for col in re.split("( |\\\".*?\\\"|'.*?')", lines[n]) if col.strip()]
+                if len(cols) != len(loopvals): break
+                if cols[0][0] == '_' or cols[0] == 'loop_': break  # catches error if loop is only 1 iteration
+                if cols[0][0] == '#': n += 1; continue  # catches comented out lines
+                if len(loopvals) == 1:
+                    cifvals[loopvals[0]] += [lines[n].strip(' \"\'\n')]
+                else:
+                    for c, ll in enumerate(loopvals):
+                        cifvals[ll] += [cols[c]]
+                n += 1
+
+            if debug:
+                for ll in loopvals:
+                    print('%5d L %s = %s' % (n, ll, str(cifvals[ll])))
+            continue
+
+        else:
+            # Skip anything else
+            if debug:
+                print('%5d SKIPPED: %s' % (n, lines[n]))
+            n += 1
+
+    # Replace '.' in keys - fix bug from isodistort cif files
+    # e.g. '_space_group_symop_magn_operation.xyz'
+    current_keys = list(cifvals.keys())
+    for key in current_keys:
+        if '.' in key:
+            newkey = key.replace('.', '_')
+            cifvals[newkey] = cifvals[key]
+    return cifvals

advisor/ui/visualizers/HKLScan2DVisualizer.py

@@ -0,0 +1,224 @@
+from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
+from matplotlib.figure import Figure
+import numpy as np
+
+
+class HKLScan2DVisualizer(FigureCanvas):
+    """2D visualizer for HKL scan results with structure factor display and trajectory line."""
+
+    def __init__(self, width: float = 5.0, height: float = 4.0, dpi: int = 100, parent=None):
+        self.fig = Figure(figsize=(float(width), float(height)), dpi=int(dpi), tight_layout=True)
+        super().__init__(self.fig)
+        self.axes = self.fig.add_subplot(111)
+        self._colorbar = None
+        self._initialized = True
+
+        # Default range settings: H,K in (-1,1), L in (-2,2)
+        self.default_h_range = (-1.0, 1.0)
+        self.default_k_range = (-1.0, 1.0)
+        self.default_l_range = (-2.0, 2.0)
+        
+        # Current range settings
+        self.h_range = self.default_h_range
+        self.k_range = self.default_k_range
+        self.l_range = self.default_l_range
+        
+        # Store last scan results for trajectory
+        self.last_scan_results = None
+
+    def _auto_detect_ranges(self, scan_results):
+        """Auto-detect HKL ranges based on scan results.
+        
+        Args:
+            scan_results: Dictionary containing H, K, L arrays from scan
+            
+        Returns:
+            tuple: (h_range, k_range, l_range) where each range is (min, max)
+        """
+        import math
+        epsilon = 1e-6
+        try:
+            # Extract HKL values from scan results
+            h_vals = np.array(scan_results.get("H", []), dtype=np.float64)
+            k_vals = np.array(scan_results.get("K", []), dtype=np.float64)
+            l_vals = np.array(scan_results.get("L", []), dtype=np.float64)
+            
+            # Find max absolute values and round up to ceiling
+            if len(h_vals) > 0:
+                h_max = math.ceil(np.max(np.abs(h_vals)) + epsilon)
+                h_range = (-h_max, h_max)
+            else:
+                h_range = self.default_h_range
+                
+            if len(k_vals) > 0:
+                k_max = math.ceil(np.max(np.abs(k_vals)) + epsilon)
+                k_range = (-k_max, k_max)
+            else:
+                k_range = self.default_k_range
+                
+            if len(l_vals) > 0:
+                l_max = math.ceil(np.max(np.abs(l_vals)) + epsilon)
+                l_range = (-l_max, l_max)
+            else:
+                l_range = self.default_l_range
+                
+            return h_range, k_range, l_range
+            
+        except Exception as e:
+            print(f"Error auto-detecting ranges: {e}")
+            return self.default_h_range, self.default_k_range, self.default_l_range
+
+    def set_ranges(self, h_range=None, k_range=None, l_range=None):
+        """Set the plotting ranges for H, K, L indices.
+        
+        Args:
+            h_range: tuple (min, max) for H range, or None to keep current
+            k_range: tuple (min, max) for K range, or None to keep current  
+            l_range: tuple (min, max) for L range, or None to keep current
+        """
+        if h_range is not None:
+            self.h_range = h_range
+        if k_range is not None:
+            self.k_range = k_range
+        if l_range is not None:
+            self.l_range = l_range
+
+
+    def visualize_results(self, scan_results, plane_type="HK"):
+        """Visualize HKL scan results with structure factors and trajectory line.
+        
+        Args:
+            scan_results: Dictionary containing scan results from BrillouinCalculator
+            plane_type: "HK", "HL", or "KL" - which plane to visualize
+        """
+        try:
+            if not scan_results or not scan_results.get("success", False):
+                self.clear_plot()
+                return False
+                
+            # Store scan results for trajectory
+            self.last_scan_results = scan_results
+            
+            # Auto-detect ranges based on scan results
+            h_range, k_range, l_range = self._auto_detect_ranges(scan_results)
+            self.set_ranges(h_range, k_range, l_range)
+            
+            # Extract deactivated index from scan results
+            deactivated_index = scan_results.get("deactivated_index", None)
+            
+            # Map plane type to match deactivated index
+            if deactivated_index == "L":
+                plane_type = "HK"  # L deactivated means HK plane
+                x_label = "H"
+                y_label = "K"
+                fixed_label = "L"
+            elif deactivated_index == "K":
+                plane_type = "HL"  # K deactivated means HL plane
+                x_label = "H"
+                y_label = "L"
+                fixed_label = "K"
+            elif deactivated_index == "H":
+                plane_type = "KL"  # H deactivated means KL plane
+                x_label = "K"
+                y_label = "L"
+                fixed_label = "H"
+            
+            
+            # Plot only the trajectory points as scatter
+            success = self._plot_trajectory_only(scan_results, plane_type, x_label, y_label)
+            
+            return success
+            
+        except Exception as e:
+            print(f"Error in visualize_results: {e}")
+            return False
+
+    def _plot_trajectory_only(self, scan_results, plane_type, x_label, y_label):
+        """Plot only the trajectory points as scatter without structure factor background.
+        
+        Args:
+            scan_results: Dictionary containing H, K, L arrays from scan
+            plane_type: "HK", "HL", or "KL"
+            x_label: X axis label ("H", "K", or "L")
+            y_label: Y axis label ("H", "K", or "L")
+        """
+        try:
+            # Extract HKL coordinates from scan results
+            h_vals = np.array(scan_results.get("H", []), dtype=np.float64)
+            k_vals = np.array(scan_results.get("K", []), dtype=np.float64)  
+            l_vals = np.array(scan_results.get("L", []), dtype=np.float64)
+            
+            if len(h_vals) == 0:
+                self.clear_plot()
+                return False
+            
+            # Get the appropriate coordinates for the plane
+            if plane_type == "HK":
+                x_traj = h_vals
+                y_traj = k_vals
+            elif plane_type == "HL":
+                x_traj = h_vals
+                y_traj = l_vals
+            elif plane_type == "KL":
+                x_traj = k_vals
+                y_traj = l_vals
+            else:
+                self.clear_plot()
+                return False
+
+            # Reset axes
+            if self._colorbar is not None:
+                self._colorbar.remove()
+                self._colorbar = None
+            self.fig.clear()
+            ax = self.fig.add_subplot(111)
+            self.axes = ax
+
+            # Plot trajectory as scatter points
+            # Use different colors for start, middle, and end points
+            if len(x_traj) > 0:
+                # Plot all points in blue
+                scatter = ax.scatter(x_traj, y_traj, c='dodgerblue', s=15, alpha=0.7, 
+                                   label='Scan points', zorder=3)
+                
+
+
+
+            ax.set_xlabel(f"{x_label} (r.l.u.)")
+            ax.set_ylabel(f"{y_label} (r.l.u.)")
+            ax.set_title(f"{x_label}{y_label} plane")
+
+            # Set limits based on auto-detected ranges for the current plane
+            if plane_type == "HK":
+                x_min, x_max = self.h_range[0], self.h_range[1]
+                y_min, y_max = self.k_range[0], self.k_range[1]
+            elif plane_type == "HL":
+                x_min, x_max = self.h_range[0], self.h_range[1]
+                y_min, y_max = self.l_range[0], self.l_range[1]
+            elif plane_type == "KL":
+                x_min, x_max = self.k_range[0], self.k_range[1]
+                y_min, y_max = self.l_range[0], self.l_range[1]
+            else:
+                # Fallback to trajectory data range
+                x_min, x_max = x_traj.min(), x_traj.max()
+                y_min, y_max = y_traj.min(), y_traj.max()
+                
+            ax.set_xlim(x_min, x_max)
+            ax.set_ylim(y_min, y_max)
+            
+            # Add grid and legend
+            ax.grid(True, alpha=0.3)
+            
+            try:
+                from matplotlib.ticker import MaxNLocator
+                ax.xaxis.set_major_locator(MaxNLocator(integer=True))
+                ax.yaxis.set_major_locator(MaxNLocator(integer=True))
+            except Exception:
+                pass
+
+            self.draw()
+            return True
+            
+        except Exception as e:
+            print(f"Error in _plot_trajectory_only: {e}")
+            return False

advisor/ui/visualizers/__init__.py

@@ -0,0 +1,8 @@
+from .coordinate_visualizer import CoordinateVisualizer
+from .unitcell_visualizer import UnitcellVisualizer
+from .scattering_visualizer import ScatteringVisualizer
+from .structure_factor_visualizer import StructureFactorVisualizer3D
+from .structure_factor_visualizer_2d import StructureFactorVisualizer2D
+from .HKLScan2DVisualizer import HKLScan2DVisualizer
+
+__all__ = ["CoordinateVisualizer", "UnitcellVisualizer", "ScatteringVisualizer", "StructureFactorVisualizer3D", "StructureFactorVisualizer2D", "HKLScan2DVisualizer"]