alphanso-gui 0.0.2__py3-none-any.whl

alphanso_gui/__init__.py

@@ -0,0 +1,3 @@
+"""ALPHONSO GUI — Graphical interface for the ALPHANSO (α,n) neutron source calculator."""
+
+__version__ = "0.1.0"

alphanso_gui/__main__.py

@@ -0,0 +1,5 @@
+"""Entry point for ``python -m alphanso_gui``."""
+from alphanso_gui.app import main
+
+if __name__ == "__main__":
+    main()

alphanso_gui/app.py

@@ -0,0 +1,311 @@
+"""Main application window for ALPHONSO GUI."""
+
+from __future__ import annotations
+
+import sys
+
+from PyQt5.QtCore import Qt
+from PyQt5.QtGui import QFont
+from PyQt5.QtWidgets import (
+    QApplication,
+    QHBoxLayout,
+    QLabel,
+    QMainWindow,
+    QMessageBox,
+    QPushButton,
+    QSizePolicy,
+    QSplitter,
+    QStackedWidget,
+    QStatusBar,
+    QVBoxLayout,
+    QWidget,
+)
+
+from alphanso_gui.worker import CalculationWorker
+from alphanso_gui.widgets.beam_panel import BeamPanel
+from alphanso_gui.widgets.homogeneous_panel import HomogeneousPanel
+from alphanso_gui.widgets.interface_panel import InterfacePanel
+from alphanso_gui.widgets.sandwich_panel import SandwichPanel
+from alphanso_gui.widgets.results_panel import ResultsPanel
+
+
+# Ordered list of (calc_type, display_name) for the tab buttons
+_PROBLEM_TYPES: list[tuple[str, str]] = [
+    ("beam",        "Beam"),
+    ("homogeneous", "Homogeneous"),
+    ("interface",   "Interface"),
+    ("sandwich",    "Sandwich"),
+]
+
+_DESCRIPTIONS: dict[str, str] = {
+    "beam": (
+        "<b>Beam</b> — Mono- or poly-energetic alpha beam incident on a thick target. "
+        "Yields the (α,n) neutron production rate per incident alpha particle."
+    ),
+    "homogeneous": (
+        "<b>Homogeneous</b> — Uniform mixture of alpha-emitting isotopes and target nuclides. "
+        "Yields neutron production rates per gram of material from (α,n) and spontaneous fission."
+    ),
+    "interface": (
+        "<b>Interface</b> — Planar interface between an alpha source region and a target region. "
+        "Yields neutron production per cm² of interface area."
+    ),
+    "sandwich": (
+        "<b>Sandwich</b> — Multi-layer geometry: Source | Intermediate layers | Target. "
+        "Yields total and per-layer neutron production per cm² of interface."
+    ),
+}
+
+_STYLE = """
+QMainWindow {
+    background-color: #f0f0f0;
+}
+QGroupBox {
+    font-weight: bold;
+    border: 1px solid #cccccc;
+    border-radius: 4px;
+    margin-top: 8px;
+    padding-top: 6px;
+}
+QGroupBox::title {
+    subcontrol-origin: margin;
+    left: 8px;
+    padding: 0 4px;
+}
+QPushButton#tab_btn {
+    border: none;
+    border-bottom: 3px solid transparent;
+    background: transparent;
+    padding: 6px 18px;
+    font-size: 13px;
+}
+QPushButton#tab_btn:checked {
+    border-bottom: 3px solid #1f77b4;
+    color: #1f77b4;
+    font-weight: bold;
+}
+QPushButton#tab_btn:hover:!checked {
+    border-bottom: 3px solid #aaaaaa;
+}
+QPushButton#run_btn {
+    background-color: #1f77b4;
+    color: white;
+    border-radius: 4px;
+    padding: 8px 28px;
+    font-size: 13px;
+    font-weight: bold;
+}
+QPushButton#run_btn:hover {
+    background-color: #155d91;
+}
+QPushButton#run_btn:disabled {
+    background-color: #aaaaaa;
+}
+"""
+
+
+class MainWindow(QMainWindow):
+    """ALPHONSO GUI main window."""
+
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle("ALPHONSO GUI — (α,n) Neutron Source Calculator")
+        self.resize(1200, 750)
+        self.setMinimumSize(900, 600)
+        self.setStyleSheet(_STYLE)
+
+        self._worker: CalculationWorker | None = None
+
+        # ---- Central widget layout -----------------------------------
+        central = QWidget()
+        self.setCentralWidget(central)
+        root_layout = QVBoxLayout(central)
+        root_layout.setContentsMargins(8, 8, 8, 4)
+        root_layout.setSpacing(6)
+
+        # ---- Header --------------------------------------------------
+        header = QLabel("ALPHONSO  —  <small>(α,n) Neutron Source Calculator</small>")
+        header.setTextFormat(Qt.RichText)
+        header_font = QFont()
+        header_font.setPointSize(15)
+        header_font.setBold(True)
+        header.setFont(header_font)
+        header.setAlignment(Qt.AlignCenter)
+        header.setStyleSheet("color: #1f4e79; padding: 4px 0;")
+        root_layout.addWidget(header)
+
+        # ---- Tab bar (problem type selector) -------------------------
+        tab_row = QHBoxLayout()
+        tab_row.setContentsMargins(0, 0, 0, 0)
+        self._tab_buttons: list[QPushButton] = []
+        for i, (ctype, name) in enumerate(_PROBLEM_TYPES):
+            btn = QPushButton(name)
+            btn.setObjectName("tab_btn")
+            btn.setCheckable(True)
+            btn.setChecked(i == 0)
+            btn.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
+            btn.clicked.connect(lambda checked, idx=i: self._switch_tab(idx))
+            tab_row.addWidget(btn)
+            self._tab_buttons.append(btn)
+        tab_row.addStretch()
+        root_layout.addLayout(tab_row)
+
+        # Description label
+        self._desc_label = QLabel()
+        self._desc_label.setTextFormat(Qt.RichText)
+        self._desc_label.setWordWrap(True)
+        self._desc_label.setStyleSheet("color: #444444; font-size: 11px; padding: 2px 0;")
+        root_layout.addWidget(self._desc_label)
+
+        # ---- Main splitter (parameters | results) --------------------
+        splitter = QSplitter(Qt.Horizontal)
+        splitter.setHandleWidth(6)
+
+        # --- Left: stacked parameter panels ---------------------------
+        self._param_stack = QStackedWidget()
+        self._panels: list[QWidget] = [
+            BeamPanel(),
+            HomogeneousPanel(),
+            InterfacePanel(),
+            SandwichPanel(),
+        ]
+        for panel in self._panels:
+            self._param_stack.addWidget(panel)
+        self._param_stack.setMinimumWidth(380)
+        splitter.addWidget(self._param_stack)
+
+        # --- Right: results panel ------------------------------------
+        self._results = ResultsPanel()
+        self._results.setMinimumWidth(350)
+        splitter.addWidget(self._results)
+
+        splitter.setSizes([480, 680])
+        root_layout.addWidget(splitter, stretch=1)
+
+        # ---- Bottom bar (run button + status) -----------------------
+        bottom = QHBoxLayout()
+        self._run_btn = QPushButton("▶  Calculate")
+        self._run_btn.setObjectName("run_btn")
+        self._run_btn.setFixedWidth(160)
+        self._run_btn.clicked.connect(self._run_calculation)
+        bottom.addWidget(self._run_btn)
+        bottom.addStretch()
+        root_layout.addLayout(bottom)
+
+        # ---- Status bar ---------------------------------------------
+        self._status_bar = QStatusBar()
+        self.setStatusBar(self._status_bar)
+        self._status_bar.showMessage("Ready.")
+
+        # Initialise description for the first tab
+        self._switch_tab(0)
+
+    # ------------------------------------------------------------------
+    # Tab switching
+    # ------------------------------------------------------------------
+    def _switch_tab(self, index: int):
+        for i, btn in enumerate(self._tab_buttons):
+            btn.setChecked(i == index)
+        self._param_stack.setCurrentIndex(index)
+        ctype = _PROBLEM_TYPES[index][0]
+        self._desc_label.setText(_DESCRIPTIONS[ctype])
+        self._results.clear()
+        self._status_bar.showMessage(
+            f"{_PROBLEM_TYPES[index][1]} mode — configure parameters and press Calculate."
+        )
+
+    # ------------------------------------------------------------------
+    # Calculation
+    # ------------------------------------------------------------------
+    def _run_calculation(self):
+        if self._worker is not None and self._worker.isRunning():
+            return  # already in progress
+
+        index = self._param_stack.currentIndex()
+        panel = self._panels[index]
+        config = panel.get_config()
+
+        # Basic sanity check
+        if not self._validate_config(config):
+            return
+
+        self._run_btn.setEnabled(False)
+        self._status_bar.showMessage("Calculating… this may take a moment.")
+        self._results.clear()
+
+        self._worker = CalculationWorker(config)
+        self._worker.finished.connect(self._on_finished)
+        self._worker.error.connect(self._on_error)
+        self._worker.start()
+
+    def _on_finished(self, results: dict):
+        index = self._param_stack.currentIndex()
+        calc_type = _PROBLEM_TYPES[index][0]
+        self._results.update_results(results, calc_type)
+        self._run_btn.setEnabled(True)
+        self._status_bar.showMessage("Calculation complete.")
+
+    def _on_error(self, message: str):
+        self._run_btn.setEnabled(True)
+        self._status_bar.showMessage(f"Error: {message}")
+        QMessageBox.critical(
+            self,
+            "Calculation Error",
+            f"The calculation failed with the following error:\n\n{message}",
+        )
+
+    # ------------------------------------------------------------------
+    # Validation helpers
+    # ------------------------------------------------------------------
+    def _validate_config(self, config: dict) -> bool:
+        calc_type = config.get("calc_type", "")
+
+        def _check_matdef(key: str, label: str) -> bool:
+            matdef = config.get(key, {})
+            if not matdef:
+                QMessageBox.warning(
+                    self,
+                    "Incomplete configuration",
+                    f"The {label} is empty. Please add at least one isotope.",
+                )
+                return False
+            return True
+
+        if calc_type == "beam":
+            if not _check_matdef("matdef", "target material"):
+                return False
+        elif calc_type == "homogeneous":
+            if not _check_matdef("matdef", "material composition"):
+                return False
+        elif calc_type == "interface":
+            if not _check_matdef("source_matdef", "source material"):
+                return False
+            if not _check_matdef("target_matdef", "target material"):
+                return False
+        elif calc_type == "sandwich":
+            if not _check_matdef("source_matdef", "source material"):
+                return False
+            if not _check_matdef("target_matdef", "target material"):
+                return False
+            if not config.get("intermediate_layers"):
+                QMessageBox.warning(
+                    self,
+                    "Incomplete configuration",
+                    "Please add at least one intermediate layer.",
+                )
+                return False
+        return True
+
+
+# ---------------------------------------------------------------------------
+# Application entry point
+# ---------------------------------------------------------------------------
+def main():
+    app = QApplication.instance() or QApplication(sys.argv)
+    window = MainWindow()
+    window.show()
+    sys.exit(app.exec_())
+
+
+if __name__ == "__main__":
+    main()

alphanso_gui/illustrations.py

@@ -0,0 +1,199 @@
+"""Matplotlib figures illustrating each ALPHANSO geometry type."""
+
+import matplotlib.patches as mpatches
+import matplotlib.pyplot as plt
+import numpy as np
+from matplotlib.figure import Figure
+
+# Consistent colour palette
+_COL_SOURCE = "#d62728"   # red – alpha-emitting source
+_COL_TARGET = "#1f77b4"   # blue – neutron target material
+_COL_LAYER  = "#2ca02c"   # green – intermediate layer
+_COL_ARROW  = "#ff7f0e"   # orange – beam / neutron arrows
+_COL_BG     = "#f8f9fa"   # very light grey background
+
+
+def _base_fig(height: float = 2.8) -> tuple[Figure, plt.Axes]:
+    fig = Figure(figsize=(5.0, height), dpi=100, facecolor=_COL_BG)
+    ax = fig.add_axes([0.0, 0.0, 1.0, 1.0])
+    ax.set_xlim(0, 1)
+    ax.set_ylim(0, 1)
+    ax.set_aspect("auto")
+    ax.axis("off")
+    ax.set_facecolor(_COL_BG)
+    return fig, ax
+
+
+def beam_figure() -> Figure:
+    """Monoenergetic alpha beam incident on a thick target."""
+    fig, ax = _base_fig()
+
+    # Target rectangle (right half)
+    target = mpatches.FancyBboxPatch(
+        (0.50, 0.15), 0.40, 0.70,
+        boxstyle="round,pad=0.01",
+        linewidth=1.5, edgecolor=_COL_TARGET, facecolor="#aec7e8",
+    )
+    ax.add_patch(target)
+    ax.text(0.70, 0.50, "Target\nmaterial", ha="center", va="center",
+            fontsize=9, color="#023858", fontweight="bold")
+
+    # Alpha beam arrows
+    for y in [0.35, 0.50, 0.65]:
+        ax.annotate(
+            "", xy=(0.50, y), xytext=(0.10, y),
+            arrowprops=dict(arrowstyle="-|>", color=_COL_SOURCE, lw=2.0),
+        )
+    ax.text(0.05, 0.50, "α", ha="center", va="center",
+            fontsize=16, color=_COL_SOURCE, fontweight="bold")
+    ax.text(0.28, 0.82, "α beam", ha="center", va="bottom",
+            fontsize=8, color=_COL_SOURCE)
+
+    # Neutron arrows emerging from target
+    rng = np.random.default_rng(42)
+    for _ in range(6):
+        angle = rng.uniform(-70, 70)
+        dx = 0.14 * np.cos(np.radians(angle))
+        dy = 0.14 * np.sin(np.radians(angle))
+        x0, y0 = 0.90, rng.uniform(0.25, 0.75)
+        ax.annotate(
+            "", xy=(x0 + dx, y0 + dy), xytext=(x0, y0),
+            arrowprops=dict(arrowstyle="-|>", color=_COL_ARROW, lw=1.2),
+        )
+    ax.text(0.96, 0.88, "n", ha="center", va="center",
+            fontsize=11, color=_COL_ARROW, fontweight="bold")
+
+    ax.set_title("Beam geometry", fontsize=10, pad=4,
+                 color="#333333", fontstyle="italic")
+    return fig
+
+
+def homogeneous_figure() -> Figure:
+    """Uniform mixture of alpha emitters and target nuclei."""
+    fig, ax = _base_fig()
+
+    # Single mixture box
+    box = mpatches.FancyBboxPatch(
+        (0.10, 0.10), 0.80, 0.72,
+        boxstyle="round,pad=0.01",
+        linewidth=1.8, edgecolor="#555555", facecolor="#e8f4f8",
+    )
+    ax.add_patch(box)
+
+    rng = np.random.default_rng(7)
+    # Alpha-emitter dots (red filled circles)
+    for x, y in zip(rng.uniform(0.15, 0.85, 14), rng.uniform(0.15, 0.78, 14)):
+        if rng.random() > 0.5:
+            ax.plot(x, y, "o", ms=7, color=_COL_SOURCE, mec="#7f0000", mew=0.8)
+        else:
+            ax.plot(x, y, "o", ms=7, mfc="none", color=_COL_TARGET, mew=1.5)
+
+    # Legend patches
+    src_patch = mpatches.Patch(color=_COL_SOURCE, label="α emitter")
+    tgt_patch = mpatches.Patch(facecolor="none", edgecolor=_COL_TARGET,
+                               linewidth=1.5, label="Target nucleus")
+    ax.legend(handles=[src_patch, tgt_patch], loc="lower center",
+              fontsize=7, ncol=2, framealpha=0.7, handlelength=1.2)
+
+    ax.set_title("Homogeneous geometry", fontsize=10, pad=4,
+                 color="#333333", fontstyle="italic")
+    return fig
+
+
+def interface_figure() -> Figure:
+    """Planar interface between source (left) and target (right) regions."""
+    fig, ax = _base_fig()
+
+    # Source region
+    src_box = mpatches.FancyBboxPatch(
+        (0.05, 0.10), 0.42, 0.72,
+        boxstyle="square,pad=0.0",
+        linewidth=1.5, edgecolor=_COL_SOURCE, facecolor="#ffd0d0",
+    )
+    ax.add_patch(src_box)
+    ax.text(0.26, 0.74, "Source (A)", ha="center", va="center",
+            fontsize=8, color="#7f0000", fontweight="bold")
+
+    # Target region
+    tgt_box = mpatches.FancyBboxPatch(
+        (0.53, 0.10), 0.42, 0.72,
+        boxstyle="square,pad=0.0",
+        linewidth=1.5, edgecolor=_COL_TARGET, facecolor="#d0e8ff",
+    )
+    ax.add_patch(tgt_box)
+    ax.text(0.74, 0.74, "Target (B)", ha="center", va="center",
+            fontsize=8, color="#023858", fontweight="bold")
+
+    # Interface line
+    ax.plot([0.50, 0.50], [0.08, 0.84], "--", color="#444444", lw=2.0)
+    ax.text(0.50, 0.88, "Interface", ha="center", va="bottom",
+            fontsize=7.5, color="#444444")
+
+    # Alpha particles in source
+    rng = np.random.default_rng(3)
+    for x, y in zip(rng.uniform(0.08, 0.44, 8), rng.uniform(0.14, 0.68, 8)):
+        ax.plot(x, y, "o", ms=6, color=_COL_SOURCE, mec="#7f0000", mew=0.7)
+    ax.text(0.26, 0.58, "α", fontsize=13, color=_COL_SOURCE,
+            ha="center", va="center", fontweight="bold")
+
+    # Neutron arrows leaving interface into target
+    for y in [0.28, 0.46, 0.64]:
+        ax.annotate(
+            "", xy=(0.72, y), xytext=(0.52, y),
+            arrowprops=dict(arrowstyle="-|>", color=_COL_ARROW, lw=1.5),
+        )
+    ax.text(0.82, 0.46, "n", ha="center", va="center",
+            fontsize=12, color=_COL_ARROW, fontweight="bold")
+
+    ax.set_title("Interface geometry", fontsize=10, pad=4,
+                 color="#333333", fontstyle="italic")
+    return fig
+
+
+def sandwich_figure() -> Figure:
+    """Multi-layer sandwich geometry: Source | B1 | B2 | … | Target."""
+    fig, ax = _base_fig()
+
+    regions = [
+        (0.03, 0.20, "Source\n(A)", _COL_SOURCE, "#ffd0d0"),
+        (0.23, 0.18, "Layer\nB1",   _COL_LAYER,  "#d0f0d0"),
+        (0.41, 0.18, "Layer\nB2",   _COL_LAYER,  "#b8e8b8"),
+        (0.59, 0.38, "Target\n(C)", _COL_TARGET,  "#d0e8ff"),
+    ]
+    y0, height = 0.10, 0.72
+    for x, width, label, edge, face in regions:
+        box = mpatches.FancyBboxPatch(
+            (x, y0), width, height,
+            boxstyle="square,pad=0.0",
+            linewidth=1.5, edgecolor=edge, facecolor=face,
+        )
+        ax.add_patch(box)
+        ax.text(x + width / 2, y0 + height / 2, label,
+                ha="center", va="center", fontsize=7.5,
+                color="#222222", fontweight="bold")
+
+    # Alpha arrows (source → layers)
+    for y in [0.30, 0.46, 0.62]:
+        ax.annotate(
+            "", xy=(0.96, y), xytext=(0.03, y),
+            arrowprops=dict(arrowstyle="-|>", color=_COL_ARROW, lw=1.0,
+                            connectionstyle="arc3,rad=0.0"),
+        )
+
+    ax.text(0.50, 0.90, "α →", ha="center", va="bottom",
+            fontsize=9, color=_COL_ARROW)
+    ax.text(0.50, 0.94, "neutron production", ha="center", va="bottom",
+            fontsize=7, color="#555555")
+
+    ax.set_title("Sandwich geometry", fontsize=10, pad=4,
+                 color="#333333", fontstyle="italic")
+    return fig
+
+
+# Map calc_type → factory function
+ILLUSTRATIONS: dict[str, callable] = {
+    "beam":        beam_figure,
+    "homogeneous": homogeneous_figure,
+    "interface":   interface_figure,
+    "sandwich":    sandwich_figure,
+}