pyneutrace 0.1.1__tar.gz

pyneutrace-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Guochu Deng
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyneutrace-0.1.1/PKG-INFO

@@ -0,0 +1,147 @@
+Metadata-Version: 2.4
+Name: pyneutrace
+Version: 0.1.1
+Summary: pyneutrace is a neutron ray tracing monte carlo simulation package for neutron instrumentation and component design optimization and resolution calculation.
+Author-email: Guochu Deng <gc.deng.ansto@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/gcdengansto/pyneutrace
+Project-URL: Documentation, https://project.readthedocs.io/gcdengansto/pyneutrace
+Keywords: neutron,ray tracing,Monte Carlo,spectrometer,triple-axis,time-of-flight
+Classifier: Programming Language :: Python :: 3
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: scipy>=1.7
+Requires-Dist: pandas>=1.3
+Provides-Extra: gui
+Requires-Dist: matplotlib>=3.1.0; extra == "gui"
+Requires-Dist: pyvista; extra == "gui"
+Requires-Dist: QtPy; extra == "gui"
+Requires-Dist: PySide6; extra == "gui"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: black>=23.0; extra == "dev"
+Dynamic: license-file
+
+# pyneutrace: Neutron Ray Tracing Python Package
+
+A pure Python-based Monte Carlo neutron ray-tracing package for neutron instrument design, structural optimization, resolution calculation, and virtual experiments. 
+
+---
+
+## Features
+
+- **High-Performance Tracing** — Monte Carlo neutron ray tracing simulation utilizing fully vectorized operations via `numpy` to trace millions of rays simultaneously without the need for C/C++ compilation.
+- **Modular Pipeline** — Easy-to-use component assembly system to seamlessly chain neutron optics, sample environments, and detectors.
+- **Built-in Crystallography** — Custom CIF parser natively built into the package to handle real-world crystal structures for powder and single-crystal scattering.
+- **Advanced Ray Checkpointing** — Transparently export and merge live neutron states (with metadata validation) to overcome extreme attenuation and accelerate complex downstream simulations.
+- **Optimization Engine** — SciPy-backed `InstrumentOptimizer` to tune beamline parameters (e.g., guide focus, chopper phase) for maximum flux/resolution.
+
+---
+
+## Directory Structure
+
+```text
+pyneutrace/
+├── src/
+│   └── pyneutrace/ 
+│       ├── __init__.py 
+│       ├── constants.py       # Physical constants and standard D-spacings
+│       ├── utils.py           # Core utilities, including the custom CIF parser
+│       ├── instrument/        # InstrumentAssemble pipeline manager
+│       ├── components/        # Optics, samples, choppers, and detectors
+│       ├── simulation/        # InstrumentOptimizer
+│       └── visualization/     # InstrumentSimPlot for statistical visualization
+├── test/                      # Comprehensive test suite covering all components
+├── pyproject.toml             # Package build configuration
+└── README.md
+```
+
+---
+
+## Quick Start
+
+1. **Installation:** Run `pip install .` in the project root path for the core engine, or `pip install ".[gui]"` to include 3D visualization dependencies.
+2. **Build your instrument:** Instantiate components and chain them using the `InstrumentAssemble` class.
+3. **Run the simulation:** Execute `pipeline.run(num_rays=1_000_000)` to trace the beam.
+4. **Visualize 3D Geometry:** Call `pipeline.visualize_3d()` to render the physical instrument layout via PyVista.
+5. **Analyze Results:** Use the `InstrumentSimPlot` class to visualize transmission drop-off and spatial/energy beam profiles at any stage.
+
+---
+
+## User Interface
+
+### Available Components (`pyneutrace.components`)
+
+| Component Class | Description |
+|---|---|
+| **NeutronSource** | Continuous neutron source (reactor) with a dual-temperature Maxwellian flux spectrum. |
+| **Moderator** | Pulsed neutron source (spallation) with wavelength-dependent Ikeda-Carpenter pulse shaping. |
+| **NeutronGuide** | Straight or tapered supermirror guide (supports m-value reflectivity decay). |
+| **CurvedGuide** | Horizontally curved supermirror bender for filtering fast neutrons and gammas. |
+| **Elliptic / Parabolic Guides**| Focusing optic guides (Single Elliptic, Double Elliptic, Double Parabolic). |
+| **DiskChopper** | Standard rotating disk chopper for pulse shaping and order sorting. |
+| **Straight/Curved FermiChopper**| High-speed rotating slit packages for precise energy selection. |
+| **VelSelector** | Mechanical velocity selector (helical turbine) for monochromatic beam selection. |
+| **Monochromator / Analyzer** | Single crystal (e.g., PG, Si, Ge) arrays to select specific neutron energies via Bragg's law. |
+| **PowderSample** | Realistic sample environment supporting CIF loading and Debye-Scherrer cone diffraction. |
+| **VRodSample** | Cylindrical sample demonstrating isotropic elastic scattering. |
+| **Monitor / CylindMonitor** | Flat and curved Position Sensitive Detectors (PSD) for capturing 2D spatial and 1D energy histograms. |
+| **Soller / RadCollimator** | Linear and radial collimation packages to define beam divergence. |
+| **ExportRays / ImportRays** | I/O components to checkpoint live beams to disk and merge multiple runs. |
+| **Spacer** | A virtual component used to advance the beam a specific distance in empty space. |
+
+### Core Pipeline (`pyneutrace.instrument`)
+
+| Class | Description |
+|---|---|
+| **InstrumentAssemble** | The central pipeline manager. Handles the addition of components, calculates global 4x4 coordinate transformations, and executes the sequential Monte Carlo propagation (`propagate_TOF`). |
+
+### Visualization (`pyneutrace.visualization`)
+
+| Class | Description |
+|---|---|
+| **InstrumentSimPlot** | Generates Matplotlib dashboards summarizing transmission efficiency and "Virtual Monitor" beam profiles without requiring heavy memory storage during runs. |
+
+---
+
+## Physics & Architecture
+
+### Coordinate System
+
+```text
+  X  →  Horizontal (perpendicular to the beam propagating direction)
+  Y  →  Vertical (up)
+  Z  →  Beam propagating direction 
+```
+
+**Local vs. Global Frames**  
+Each component in the instrument possesses its own local coordinate system. A component clearly defines its **entry window** (usually at $Z = 0$) and its **exit window** (usually at $Z = L$). 
+
+`InstrumentAssemble` builds the instrument as a **seamless continuous pipeline**. This means all components, from the source to the detector, are connected back-to-back. The exit window of an upstream component becomes the exact mathematical entry window of the subsequent component. 
+
+To achieve this:
+1. All surviving neutrons exiting a component are mathematically translated (and rotated, if the component bends the beam like a `CurvedGuide` or `Monochromator`) so that their positions and velocities are expressed perfectly relative to the **center of the exit window**.
+2. This allows the next component to simply assume the incoming beam is crossing its own $Z=0$ plane. 
+3. If physical empty space is required between two optical elements, a `Spacer` component must be explicitly inserted into the pipeline.
+
+**The Sample Exception**  
+The only exception to the strict Entry/Exit window rule is the Sample environment. Because neutrons scattered from a sample diverge outward into the entire 3D sphere ($4\pi$ steradians), it is impossible to define a single planar "exit window". 
+
+Instead, neutron coordinates scattered away from a sample use the **sample center** as their origin ($0,0,0$), with the incident primary beam defining the $+Z$ direction. Downstream components (such as a `RadCollimator` or `CylindMonitor`) are explicitly designed to account for this geometry, often utilizing cylindrical or spherical coordinates to capture the flying neutrons.
+
+### Bragg Scattering
+
+For the `Monochromator`, `Analyzer`, and `PowderSample`, the Bragg condition is applied to filter and scatter neutrons at specific wavelengths. The momentum transfer vector $\vec{Q}$ is calculated for reciprocal lattice vectors $\vec{G}$ and the incident wavevector $\vec{k}_{in}$, ensuring that only neutrons satisfying $|\vec{k}_{out}| = |\vec{k}_{in}|$ and $\vec{Q} = \vec{G}$ are scattered with high probability according to their structure factors ($|F|^2$).
+
+---
+
+## Known Limitations
+
+- **Gravity:** The impact of gravity ($\vec{g}$) has not yet been taken into account. Neutrons currently travel in perfectly straight lines between component boundaries.
+- **Detector Efficiency:** Monitors currently act as perfect 100% absorbing planes. Wavelength-dependent gas detection efficiency ($1 - \exp(-c\lambda)$) and finite depth tracking are not yet implemented.
+- **Inelastic Scattering:** Sample kernels for inelastic energy transfer ($S(Q, \omega)$) to simulate phonons and magnons are not yet supported.

pyneutrace-0.1.1/README.md

@@ -0,0 +1,118 @@
+# pyneutrace: Neutron Ray Tracing Python Package
+
+A pure Python-based Monte Carlo neutron ray-tracing package for neutron instrument design, structural optimization, resolution calculation, and virtual experiments. 
+
+---
+
+## Features
+
+- **High-Performance Tracing** — Monte Carlo neutron ray tracing simulation utilizing fully vectorized operations via `numpy` to trace millions of rays simultaneously without the need for C/C++ compilation.
+- **Modular Pipeline** — Easy-to-use component assembly system to seamlessly chain neutron optics, sample environments, and detectors.
+- **Built-in Crystallography** — Custom CIF parser natively built into the package to handle real-world crystal structures for powder and single-crystal scattering.
+- **Advanced Ray Checkpointing** — Transparently export and merge live neutron states (with metadata validation) to overcome extreme attenuation and accelerate complex downstream simulations.
+- **Optimization Engine** — SciPy-backed `InstrumentOptimizer` to tune beamline parameters (e.g., guide focus, chopper phase) for maximum flux/resolution.
+
+---
+
+## Directory Structure
+
+```text
+pyneutrace/
+├── src/
+│   └── pyneutrace/ 
+│       ├── __init__.py 
+│       ├── constants.py       # Physical constants and standard D-spacings
+│       ├── utils.py           # Core utilities, including the custom CIF parser
+│       ├── instrument/        # InstrumentAssemble pipeline manager
+│       ├── components/        # Optics, samples, choppers, and detectors
+│       ├── simulation/        # InstrumentOptimizer
+│       └── visualization/     # InstrumentSimPlot for statistical visualization
+├── test/                      # Comprehensive test suite covering all components
+├── pyproject.toml             # Package build configuration
+└── README.md
+```
+
+---
+
+## Quick Start
+
+1. **Installation:** Run `pip install .` in the project root path for the core engine, or `pip install ".[gui]"` to include 3D visualization dependencies.
+2. **Build your instrument:** Instantiate components and chain them using the `InstrumentAssemble` class.
+3. **Run the simulation:** Execute `pipeline.run(num_rays=1_000_000)` to trace the beam.
+4. **Visualize 3D Geometry:** Call `pipeline.visualize_3d()` to render the physical instrument layout via PyVista.
+5. **Analyze Results:** Use the `InstrumentSimPlot` class to visualize transmission drop-off and spatial/energy beam profiles at any stage.
+
+---
+
+## User Interface
+
+### Available Components (`pyneutrace.components`)
+
+| Component Class | Description |
+|---|---|
+| **NeutronSource** | Continuous neutron source (reactor) with a dual-temperature Maxwellian flux spectrum. |
+| **Moderator** | Pulsed neutron source (spallation) with wavelength-dependent Ikeda-Carpenter pulse shaping. |
+| **NeutronGuide** | Straight or tapered supermirror guide (supports m-value reflectivity decay). |
+| **CurvedGuide** | Horizontally curved supermirror bender for filtering fast neutrons and gammas. |
+| **Elliptic / Parabolic Guides**| Focusing optic guides (Single Elliptic, Double Elliptic, Double Parabolic). |
+| **DiskChopper** | Standard rotating disk chopper for pulse shaping and order sorting. |
+| **Straight/Curved FermiChopper**| High-speed rotating slit packages for precise energy selection. |
+| **VelSelector** | Mechanical velocity selector (helical turbine) for monochromatic beam selection. |
+| **Monochromator / Analyzer** | Single crystal (e.g., PG, Si, Ge) arrays to select specific neutron energies via Bragg's law. |
+| **PowderSample** | Realistic sample environment supporting CIF loading and Debye-Scherrer cone diffraction. |
+| **VRodSample** | Cylindrical sample demonstrating isotropic elastic scattering. |
+| **Monitor / CylindMonitor** | Flat and curved Position Sensitive Detectors (PSD) for capturing 2D spatial and 1D energy histograms. |
+| **Soller / RadCollimator** | Linear and radial collimation packages to define beam divergence. |
+| **ExportRays / ImportRays** | I/O components to checkpoint live beams to disk and merge multiple runs. |
+| **Spacer** | A virtual component used to advance the beam a specific distance in empty space. |
+
+### Core Pipeline (`pyneutrace.instrument`)
+
+| Class | Description |
+|---|---|
+| **InstrumentAssemble** | The central pipeline manager. Handles the addition of components, calculates global 4x4 coordinate transformations, and executes the sequential Monte Carlo propagation (`propagate_TOF`). |
+
+### Visualization (`pyneutrace.visualization`)
+
+| Class | Description |
+|---|---|
+| **InstrumentSimPlot** | Generates Matplotlib dashboards summarizing transmission efficiency and "Virtual Monitor" beam profiles without requiring heavy memory storage during runs. |
+
+---
+
+## Physics & Architecture
+
+### Coordinate System
+
+```text
+  X  →  Horizontal (perpendicular to the beam propagating direction)
+  Y  →  Vertical (up)
+  Z  →  Beam propagating direction 
+```
+
+**Local vs. Global Frames**  
+Each component in the instrument possesses its own local coordinate system. A component clearly defines its **entry window** (usually at $Z = 0$) and its **exit window** (usually at $Z = L$). 
+
+`InstrumentAssemble` builds the instrument as a **seamless continuous pipeline**. This means all components, from the source to the detector, are connected back-to-back. The exit window of an upstream component becomes the exact mathematical entry window of the subsequent component. 
+
+To achieve this:
+1. All surviving neutrons exiting a component are mathematically translated (and rotated, if the component bends the beam like a `CurvedGuide` or `Monochromator`) so that their positions and velocities are expressed perfectly relative to the **center of the exit window**.
+2. This allows the next component to simply assume the incoming beam is crossing its own $Z=0$ plane. 
+3. If physical empty space is required between two optical elements, a `Spacer` component must be explicitly inserted into the pipeline.
+
+**The Sample Exception**  
+The only exception to the strict Entry/Exit window rule is the Sample environment. Because neutrons scattered from a sample diverge outward into the entire 3D sphere ($4\pi$ steradians), it is impossible to define a single planar "exit window". 
+
+Instead, neutron coordinates scattered away from a sample use the **sample center** as their origin ($0,0,0$), with the incident primary beam defining the $+Z$ direction. Downstream components (such as a `RadCollimator` or `CylindMonitor`) are explicitly designed to account for this geometry, often utilizing cylindrical or spherical coordinates to capture the flying neutrons.
+
+### Bragg Scattering
+
+For the `Monochromator`, `Analyzer`, and `PowderSample`, the Bragg condition is applied to filter and scatter neutrons at specific wavelengths. The momentum transfer vector $\vec{Q}$ is calculated for reciprocal lattice vectors $\vec{G}$ and the incident wavevector $\vec{k}_{in}$, ensuring that only neutrons satisfying $|\vec{k}_{out}| = |\vec{k}_{in}|$ and $\vec{Q} = \vec{G}$ are scattered with high probability according to their structure factors ($|F|^2$).
+
+---
+
+## Known Limitations
+
+- **Gravity:** The impact of gravity ($\vec{g}$) has not yet been taken into account. Neutrons currently travel in perfectly straight lines between component boundaries.
+- **Detector Efficiency:** Monitors currently act as perfect 100% absorbing planes. Wavelength-dependent gas detection efficiency ($1 - \exp(-c\lambda)$) and finite depth tracking are not yet implemented.
+- **Inelastic Scattering:** Sample kernels for inelastic energy transfer ($S(Q, \omega)$) to simulate phonons and magnons are not yet supported.

pyneutrace-0.1.1/pyproject.toml

@@ -0,0 +1,57 @@
+[build-system]
+# Minimum requirements for the build system
+requires = ["setuptools>=77.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pyneutrace"
+version = "0.1.1"
+description = "pyneutrace is a neutron ray tracing monte carlo simulation package for neutron instrumentation and component design optimization and resolution calculation."
+readme = "README.md"
+requires-python = ">=3.8"
+
+license = "MIT"
+license-files = ["LICENSE"]
+
+authors = [
+  {name = "Guochu Deng", email = "gc.deng.ansto@gmail.com"}
+]
+
+# Dependencies required to run the core project
+dependencies = [
+    "numpy>=1.20.0",
+    "scipy>=1.7",
+    "pandas>=1.3"
+]
+
+keywords = ["neutron", "ray tracing", "Monte Carlo", "spectrometer", "triple-axis", "time-of-flight"]
+
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Intended Audience :: Science/Research",
+    "Topic :: Scientific/Engineering :: Physics",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+# External links for PyPI
+Homepage = "https://github.com/gcdengansto/pyneutrace"
+Documentation = "https://project.readthedocs.io/gcdengansto/pyneutrace"
+
+[tool.setuptools.packages.find]
+# Automatically find packages in a 'src' directory
+where = ["src"]
+
+[project.optional-dependencies]
+# Optional groups for visualization and UI
+gui = [
+    "matplotlib>=3.1.0",
+    "pyvista",
+    "QtPy",
+    "PySide6"
+]
+# Optional groups for development
+dev = [
+    "pytest>=7.0",
+    "black>=23.0"
+]

pyneutrace-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pyneutrace-0.1.1/src/pyneutrace/components/__init__.py

@@ -0,0 +1,56 @@
+from .source import NeutronSource
+from .nsource import NSource
+from .moderator import Moderator
+from .spacer  import Spacer
+from .soller  import Soller
+from .radcollimator import RadCollimator
+from .neutronguide import NeutronGuide
+from .singleellipticguide import SingleEllipticGuide
+from .doubleparabolicguide import DoubleParabolicGuide
+from .doubleellipticguide import DoubleEllipticGuide
+from .diskchopper import DiskChopper
+from .straightfermichopper import StraightFermiChopper
+from .curvedfermichopper import CurvedFermiChopper
+from .vsample import VRodSample
+from .monitor import Monitor, CylindMonitor
+from .monochromator import Monochromator
+from .analyzer import Analyzer
+from .cascadeanalyzer import CascadeAnalyzer
+from .multicascadeanalyzer import MultiCascadeAnalyzer
+from .velselector import VelSelector
+from .powdersample import PowderSample
+from .virtualfilter import VirtualFilterAndMultiplier
+
+from .curvedguide import CurvedGuide
+from .io_rays import ExportRays, ImportRays
+
+from .singlecrystalsample import SingleCrystalSample
+
+__all__ = [
+    "PowderSample",
+    "SingleCrystalSample",
+    "VirtualFilterAndMultiplier",
+    "CurvedGuide",
+    "ExportRays",
+    "ImportRays",
+    "VelSelector",
+    "NeutronSource",
+    "Moderator",
+    "Spacer",
+    "Soller",
+    "RadCollimator",
+    "NeutronGuide",
+    "SingleEllipticGuide",
+    "DoubleParabolicGuide",
+    "DoubleEllipticGuide",
+    "DiskChopper",
+    "StraightFermiChopper",
+    "CurvedFermiChopper",
+    "VRodSample",
+    "Monitor",
+    "CylindMonitor",
+    "Monochromator",
+    "Analyzer",
+    "CascadeAnalyzer",
+    "MultiCascadeAnalyzer",
+]

pyneutrace-0.1.1/src/pyneutrace/components/analyzer.py

@@ -0,0 +1,161 @@
+import numpy as np
+
+from .monochromator import Monochromator
+
+
+class Analyzer(Monochromator):
+    """
+    Neutron monochromator simulation.
+
+    Parameters
+    ----------
+    entry_w, entry_h  : entry window width / height  [mm]
+    ana_w,  ana_h   : crystal width / height        [mm]
+    exit_w,  exit_h   : exit  window width / height  [mm]
+    length            : entry-window → crystal centre distance  [mm]
+    rotation          : Bragg angle (half of 2θ)  [degrees]
+    crystal           : crystal type string, e.g. "PG"
+    mosaicity         : crystal mosaicity FWHM  [degrees]
+    focus             : "NONE" | "DOUBLE" | "HF_ONLY" | "VF_ONLY"
+    ana_vr            : vertical   focusing radius  [mm]
+    ana_hr            : horizontal focusing radius  [mm]
+    L1                : sample-to-analyzer distance  [mm]  (for optimal-R calc only)
+    L2                : analyzer-to-detector distance  [mm]  (for optimal-R calc only)
+    second_order      : if True, allow λ/2 contamination (only for PG)
+    rng_seed          : optional int seed for reproducibility
+    """
+
+    def __init__(
+        self,
+        entry_w   = 60,
+        entry_h   = 100,
+        ana_w    = 120,
+        ana_h    = 100,
+        exit_w    = 60,
+        exit_h    = 100,
+        length    = 400,
+        rotation  = 45,
+        crystal   = "PG",
+        mosaicity = 0.3,
+        focus     = "NONE",
+        ana_vr   = None,
+        ana_hr   = None,
+        L1        = 1500,
+        L2        = 500,
+        second_order = None,   
+        rng_seed  = None,
+        reflectivity = 1.0,   
+        exit_capture_mode = "position",
+    ):
+        super().__init__(
+            entry_w=entry_w,
+            entry_h=entry_h,
+            mono_w=ana_w,
+            mono_h=ana_h,
+            exit_w=exit_w,
+            exit_h=exit_h,
+            length=length,
+            rotation=rotation,
+            crystal=crystal,
+            mosaicity=mosaicity,
+            focus=focus,
+            mono_vr=ana_vr,
+            mono_hr=ana_hr,
+            L1=L1,
+            L2=L2,
+            second_order=second_order,
+            rng_seed=rng_seed,
+            reflectivity=reflectivity,
+        )
+        self.exit_capture_mode = self._validate_exit_capture_mode(exit_capture_mode)
+        self.exit_capture = self._empty_exit_capture()
+
+    @staticmethod
+    def _validate_exit_capture_mode(mode):
+        if mode not in ("position", "full"):
+            raise ValueError(
+                f"exit_capture_mode must be 'position' or 'full'. Got '{mode}'."
+            )
+        return mode
+
+    def _empty_exit_capture(self):
+        capture = {
+            "x": np.empty((0,), dtype=float),
+            "y": np.empty((0,), dtype=float),
+            "z": np.empty((0,), dtype=float),
+            "weight": np.empty((0,), dtype=float),
+        }
+        if self.exit_capture_mode == "full":
+            capture.update({
+                "vx": np.empty((0,), dtype=float),
+                "vy": np.empty((0,), dtype=float),
+                "vz": np.empty((0,), dtype=float),
+                "time": None,
+            })
+        return capture
+
+    def _record_exit_capture(self, final_pos, final_vel, final_time, final_weight):
+        self.exit_capture = {
+            "x": final_pos[:, 0].copy(),
+            "y": final_pos[:, 1].copy(),
+            "z": final_pos[:, 2].copy(),
+            "weight": final_weight.copy(),
+        }
+        if self.exit_capture_mode == "full":
+            self.exit_capture.update({
+                "vx": final_vel[:, 0].copy(),
+                "vy": final_vel[:, 1].copy(),
+                "vz": final_vel[:, 2].copy(),
+                "time": None if final_time is None else final_time.copy(),
+            })
+
+    def propagate_TOF(
+        self,
+        initPos,
+        initVel,
+        initTime=None,
+        initWeight=None,
+    ):
+        final_pos, final_vel, final_time, final_weight, survived = super().propagate_TOF(
+            initPos,
+            initVel,
+            initTime=initTime,
+            initWeight=initWeight,
+        )
+        self._record_exit_capture(final_pos, final_vel, final_time, final_weight)
+        return final_pos, final_vel, final_time, final_weight, survived
+
+    @property
+    def ana_w(self):
+        return self.mono_w
+
+    @ana_w.setter
+    def ana_w(self, value):
+        self.mono_w = value
+
+
+    @property
+    def ana_h(self):
+        return self.mono_h
+
+    @ana_h.setter
+    def ana_h(self, value):
+        self.mono_h = value
+
+
+    @property
+    def ana_vr(self):
+        return self.mono_vr
+
+    @ana_vr.setter
+    def ana_vr(self, value):
+        self.mono_vr = value
+
+
+    @property
+    def ana_hr(self):
+        return self.mono_hr
+
+    @ana_hr.setter
+    def ana_hr(self, value):
+        self.mono_hr = value