essreduce 25.5.2__py3-none-any.whl → 25.7.0__py3-none-any.whl

ess/reduce/time_of_flight/types.py

@@ -1,7 +1,6 @@
 # SPDX-License-Identifier: BSD-3-Clause
 # Copyright (c) 2025 Scipp contributors (https://github.com/scipp)
 
-from dataclasses import dataclass
 from typing import NewType
 
 import sciline as sl
@@ -9,81 +8,6 @@ import scipp as sc
 
 from ..nexus.types import MonitorType, RunType
 
-
-@dataclass
-class SimulationResults:
-    """
-    Results of a time-of-flight simulation used to create a lookup table.
-
-    The results (apart from ``distance``) should be flat lists (1d arrays) of length N
-    where N is the number of neutrons, containing the properties of the neutrons in the
-    simulation.
-
-    Parameters
-    ----------
-    time_of_arrival:
-        Time of arrival of the neutrons at the position where the events were recorded
-        (1d array of size N).
-    speed:
-        Speed of the neutrons, typically derived from the wavelength of the neutrons
-        (1d array of size N).
-    wavelength:
-        Wavelength of the neutrons (1d array of size N).
-    weight:
-        Weight/probability of the neutrons (1d array of size N).
-    distance:
-        Distance from the source to the position where the events were recorded
-        (single value; we assume all neutrons were recorded at the same position).
-        For a ``tof`` simulation, this is just the position of the detector where the
-        events are recorded. For a ``McStas`` simulation, this is the distance between
-        the source and the event monitor.
-    """
-
-    time_of_arrival: sc.Variable
-    speed: sc.Variable
-    wavelength: sc.Variable
-    weight: sc.Variable
-    distance: sc.Variable
-
-
-NumberOfSimulatedNeutrons = NewType("NumberOfSimulatedNeutrons", int)
-"""
-Number of neutrons simulated in the simulation that is used to create the lookup table.
-This is typically a large number, e.g., 1e6 or 1e7.
-"""
-
-LtotalRange = NewType("LtotalRange", tuple[sc.Variable, sc.Variable])
-"""
-Range (min, max) of the total length of the flight path from the source to the detector.
-This is used to create the lookup table to compute the neutron time-of-flight.
-Note that the resulting table will extend slightly beyond this range, as the supplied
-range is not necessarily a multiple of the distance resolution.
-
-Note also that the range of total flight paths is supplied manually to the workflow
-instead of being read from the input data, as it allows us to compute the expensive part
-of the workflow in advance (the lookup table) and does not need to be repeated for each
-run, or for new data coming in in the case of live data collection.
-"""
-
-DistanceResolution = NewType("DistanceResolution", sc.Variable)
-"""
-Step size of the distance axis in the lookup table.
-Should be a single scalar value with a unit of length.
-This is typically of the order of 1-10 cm.
-"""
-
-TimeResolution = NewType("TimeResolution", sc.Variable)
-"""
-Step size of the event_time_offset axis in the lookup table.
-This is basically the 'time-of-flight' resolution of the detector.
-Should be a single scalar value with a unit of time.
-This is typically of the order of 0.1-0.5 ms.
-
-Since the event_time_offset range needs to span exactly one pulse period, the final
-resolution in the lookup table will be at least the supplied value here, but may be
-smaller if the pulse period is not an integer multiple of the time resolution.
-"""
-
 TimeOfFlightLookupTableFilename = NewType("TimeOfFlightLookupTableFilename", str)
 """Filename of the time-of-flight lookup table."""
 
@@ -93,21 +17,6 @@ TimeOfFlightLookupTable = NewType("TimeOfFlightLookupTable", sc.DataArray)
 Lookup table giving time-of-flight as a function of distance and time of arrival.
 """
 
-LookupTableRelativeErrorThreshold = NewType("LookupTableRelativeErrorThreshold", float)
-"""
-Threshold for the relative standard deviation (coefficient of variation) of the
-projected time-of-flight above which values are masked.
-"""
-
-PulsePeriod = NewType("PulsePeriod", sc.Variable)
-"""
-Period of the source pulses, i.e., time between consecutive pulse starts.
-"""
-
-PulseStride = NewType("PulseStride", int)
-"""
-Stride of used pulses. Usually 1, but may be a small integer when pulse-skipping.
-"""
 
 PulseStrideOffset = NewType("PulseStrideOffset", int | None)
 """
@@ -130,43 +39,3 @@ class DetectorTofData(sl.Scope[RunType, sc.DataArray], sc.DataArray):
 
 class MonitorTofData(sl.Scope[RunType, MonitorType, sc.DataArray], sc.DataArray):
     """Monitor data with time-of-flight coordinate."""
-
-
-class ResampledDetectorTofData(sl.Scope[RunType, sc.DataArray], sc.DataArray):
-    """
-    Histogrammed detector data with time-of-flight coordinate, that has been resampled.
-
-    Histogrammed data that has been converted to `tof` will typically have
-    unsorted bin edges (due to either wrapping of `time_of_flight` or wavelength
-    overlap between subframes).
-    We thus resample the data to ensure that the bin edges are sorted.
-    It makes use of the ``to_events`` helper which generates a number of events in each
-    bin with a uniform distribution. The new events are then histogrammed using a set of
-    sorted bin edges to yield a new histogram with sorted bin edges.
-
-    WARNING:
-    This function is highly experimental, has limitations and should be used with
-    caution. It is a workaround to the issue that rebinning data with unsorted bin
-    edges is not supported in scipp.
-    """
-
-
-class ResampledMonitorTofData(
-    sl.Scope[RunType, MonitorType, sc.DataArray], sc.DataArray
-):
-    """
-    Histogrammed monitor data with time-of-flight coordinate, that has been resampled.
-
-    Histogrammed data that has been converted to `tof` will typically have
-    unsorted bin edges (due to either wrapping of `time_of_flight` or wavelength
-    overlap between subframes).
-    We thus resample the data to ensure that the bin edges are sorted.
-    It makes use of the ``to_events`` helper which generates a number of events in each
-    bin with a uniform distribution. The new events are then histogrammed using a set of
-    sorted bin edges to yield a new histogram with sorted bin edges.
-
-    WARNING:
-    This function is highly experimental, has limitations and should be used with
-    caution. It is a workaround to the issue that rebinning data with unsorted bin
-    edges is not supported in scipp.
-    """

ess/reduce/time_of_flight/workflow.py

@@ -1,22 +1,17 @@
 # SPDX-License-Identifier: BSD-3-Clause
 # Copyright (c) 2025 Scipp contributors (https://github.com/scipp)
 from collections.abc import Iterable
-from enum import Enum, auto
 
 import sciline
 import scipp as sc
 
 from ..nexus import GenericNeXusWorkflow
-from . import eto_to_tof, simulation
-from .types import TimeOfFlightLookupTable, TimeOfFlightLookupTableFilename
-
-
-class TofLutProvider(Enum):
-    """Provider for the time-of-flight lookup table."""
-
-    FILE = auto()  # From file
-    TOF = auto()  # Computed with 'tof' package from chopper settings
-    MCSTAS = auto()  # McStas simulation (not implemented yet)
+from . import eto_to_tof
+from .types import (
+    PulseStrideOffset,
+    TimeOfFlightLookupTable,
+    TimeOfFlightLookupTableFilename,
+)
 
 
 def load_tof_lookup_table(
@@ -29,11 +24,11 @@ def GenericTofWorkflow(
     *,
     run_types: Iterable[sciline.typing.Key],
     monitor_types: Iterable[sciline.typing.Key],
-    tof_lut_provider: TofLutProvider = TofLutProvider.FILE,
 ) -> sciline.Pipeline:
     """
     Generic workflow for computing the neutron time-of-flight for detector and monitor
     data.
+
     This workflow builds on the ``GenericNeXusWorkflow`` and computes time-of-flight
     from a lookup table that is created from the chopper settings, detector Ltotal and
     the neutron time-of-arrival.
@@ -58,11 +53,6 @@ def GenericTofWorkflow(
         List of monitor types to include in the workflow.
         Constrains the possible values of :class:`ess.reduce.nexus.types.MonitorType`
         and :class:`ess.reduce.nexus.types.Component`.
-    tof_lut_provider:
-        Specifies how the time-of-flight lookup table is provided:
-        - FILE: Read from a file
-        - TOF: Computed from chopper settings using the 'tof' package
-        - MCSTAS: From McStas simulation (not implemented yet)
 
     Returns
     -------
@@ -74,16 +64,9 @@ def GenericTofWorkflow(
     for provider in eto_to_tof.providers():
         wf.insert(provider)
 
-    if tof_lut_provider == TofLutProvider.FILE:
-        wf.insert(load_tof_lookup_table)
-    else:
-        wf.insert(eto_to_tof.compute_tof_lookup_table)
-        if tof_lut_provider == TofLutProvider.TOF:
-            wf.insert(simulation.simulate_chopper_cascade_using_tof)
-        if tof_lut_provider == TofLutProvider.MCSTAS:
-            raise NotImplementedError("McStas simulation not implemented yet")
+    wf.insert(load_tof_lookup_table)
 
-    for key, value in eto_to_tof.default_parameters().items():
-        wf[key] = value
+    # Default parameters
+    wf[PulseStrideOffset] = None
 
     return wf

{essreduce-25.5.2.dist-info → essreduce-25.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: essreduce
-Version: 25.5.2
+Version: 25.7.0
 Summary: Common data reduction tools for the ESS facility
 Author: Scipp contributors
 License: BSD 3-Clause License

{essreduce-25.5.2.dist-info → essreduce-25.7.0.dist-info}/RECORD

@@ -18,15 +18,15 @@ ess/reduce/nexus/json_nexus.py,sha256=QrVc0p424nZ5dHX9gebAJppTw6lGZq9404P_OFl1gi
 ess/reduce/nexus/types.py,sha256=DE82JnbgpTlQnt7UN2a2Gur2N9QupV3CDL9j4Iy4lsE,9178
 ess/reduce/nexus/workflow.py,sha256=Ytt80-muk5EiXmip890ahb_m5DQqlTGRQUyaTVXRNzo,24568
 ess/reduce/scripts/grow_nexus.py,sha256=hET3h06M0xlJd62E3palNLFvJMyNax2kK4XyJcOhl-I,3387
-ess/reduce/time_of_flight/__init__.py,sha256=UxMvY4aFkhZQmIbGSo4FBpBGRD2wDJbczLMVqcEhCSg,1583
-ess/reduce/time_of_flight/eto_to_tof.py,sha256=JCu7C3AmJnB7GDJrL76oPjgxGesp67nct9xXRp3O8E4,28204
+ess/reduce/time_of_flight/__init__.py,sha256=bhteT_xvkRYBh_oeJZTzCtiPg0WSW_TRrtm_xzGbzw4,1441
+ess/reduce/time_of_flight/eto_to_tof.py,sha256=pkxtj1Gg0b2aF9Ryr2vL8PeL8RdujuzWbcp1L4TMghU,14712
 ess/reduce/time_of_flight/fakes.py,sha256=0gtbSX3ZQilaM4ZP5dMr3fqbnhpyoVsZX2YEb8GgREE,4489
 ess/reduce/time_of_flight/interpolator_numba.py,sha256=wh2YS3j2rOu30v1Ok3xNHcwS7t8eEtZyZvbfXOCtgrQ,3835
 ess/reduce/time_of_flight/interpolator_scipy.py,sha256=_InoAPuMm2qhJKZQBAHOGRFqtvvuQ8TStoN7j_YgS4M,1853
-ess/reduce/time_of_flight/simulation.py,sha256=vo-zjG6t-PLetv2_nj4dhMSTEyTQ1MsrhlM2XkhOtf8,3632
-ess/reduce/time_of_flight/to_events.py,sha256=w9mHpnWd3vwN2ouob-GK_1NPrTjCaOzPuC2QuEey-m0,4342
-ess/reduce/time_of_flight/types.py,sha256=OQeMYNN7QinXs_HDcoE6kkh_xNcyD0dEJWtnHQy5-uA,6675
-ess/reduce/time_of_flight/workflow.py,sha256=mwNEXwvOnm-M8n4G9Cau1Vuyqzo4qMrhCbZ-S5vszW4,3181
+ess/reduce/time_of_flight/lut.py,sha256=ylZbnf6LeOUzkBkUbLCudeqVfh-Gtf9M-z8PS-l9Db4,18719
+ess/reduce/time_of_flight/resample.py,sha256=Opmi-JA4zNH725l9VB99U4O9UlM37f5ACTCGtwBcows,3718
+ess/reduce/time_of_flight/types.py,sha256=EroKBxi4WUErNx8d200jh8kqkhwtjAGKIV7PvBUwAJs,1310
+ess/reduce/time_of_flight/workflow.py,sha256=mkgESvQ5Yt3CyAsa1iewkjBOHUqrHm5rRc1EhOQRewQ,2213
 ess/reduce/widgets/__init__.py,sha256=SoSHBv8Dc3QXV9HUvPhjSYWMwKTGYZLpsWwsShIO97Q,5325
 ess/reduce/widgets/_base.py,sha256=_wN3FOlXgx_u0c-A_3yyoIH-SdUvDENGgquh9S-h5GI,4852
 ess/reduce/widgets/_binedges_widget.py,sha256=ZCQsGjYHnJr9GFUn7NjoZc1CdsnAzm_fMzyF-fTKKVY,2785
@@ -39,9 +39,9 @@ ess/reduce/widgets/_spinner.py,sha256=2VY4Fhfa7HMXox2O7UbofcdKsYG-AJGrsgGJB85nDX
 ess/reduce/widgets/_string_widget.py,sha256=iPAdfANyXHf-nkfhgkyH6gQDklia0LebLTmwi3m-iYQ,1482
 ess/reduce/widgets/_switchable_widget.py,sha256=fjKz99SKLhIF1BLgGVBSKKn3Lu_jYBwDYGeAjbJY3Q8,2390
 ess/reduce/widgets/_vector_widget.py,sha256=aTaBqCFHZQhrIoX6-sSqFWCPePEW8HQt5kUio8jP1t8,1203
-essreduce-25.5.2.dist-info/licenses/LICENSE,sha256=nVEiume4Qj6jMYfSRjHTM2jtJ4FGu0g-5Sdh7osfEYw,1553
-essreduce-25.5.2.dist-info/METADATA,sha256=LNEHFWDdswQNdu6s_5_eVHlmkVz35siN2fvirZ0KhFI,3768
-essreduce-25.5.2.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
-essreduce-25.5.2.dist-info/entry_points.txt,sha256=PMZOIYzCifHMTe4pK3HbhxUwxjFaZizYlLD0td4Isb0,66
-essreduce-25.5.2.dist-info/top_level.txt,sha256=0JxTCgMKPLKtp14wb1-RKisQPQWX7i96innZNvHBr-s,4
-essreduce-25.5.2.dist-info/RECORD,,
+essreduce-25.7.0.dist-info/licenses/LICENSE,sha256=nVEiume4Qj6jMYfSRjHTM2jtJ4FGu0g-5Sdh7osfEYw,1553
+essreduce-25.7.0.dist-info/METADATA,sha256=3qNSqqDpvL6iuZoOlcFiI1P6Vyhse0kfAn7K3oeEhxw,3768
+essreduce-25.7.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+essreduce-25.7.0.dist-info/entry_points.txt,sha256=PMZOIYzCifHMTe4pK3HbhxUwxjFaZizYlLD0td4Isb0,66
+essreduce-25.7.0.dist-info/top_level.txt,sha256=0JxTCgMKPLKtp14wb1-RKisQPQWX7i96innZNvHBr-s,4
+essreduce-25.7.0.dist-info/RECORD,,

{essreduce-25.5.2.dist-info → essreduce-25.7.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.8.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

ess/reduce/time_of_flight/simulation.py

@@ -1,108 +0,0 @@
-# SPDX-License-Identifier: BSD-3-Clause
-# Copyright (c) 2025 Scipp contributors (https://github.com/scipp)
-from collections.abc import Mapping
-
-import scipp as sc
-import scippnexus as snx
-from scippneutron.chopper import DiskChopper
-
-from ..nexus.types import DiskChoppers, Position, SampleRun
-from .types import NumberOfSimulatedNeutrons, SimulationResults
-
-
-def simulate_beamline(
-    *,
-    choppers: Mapping[str, DiskChopper],
-    source_position: sc.Variable,
-    neutrons: int = 1_000_000,
-    pulses: int = 1,
-    seed: int | None = None,
-    facility: str = 'ess',
-) -> SimulationResults:
-    """
-    Simulate a pulse of neutrons propagating through a chopper cascade using the
-    ``tof`` package (https://tof.readthedocs.io).
-
-    Parameters
-    ----------
-    choppers:
-        A dict of DiskChopper objects representing the choppers in the beamline. See
-        https://scipp.github.io/scippneutron/user-guide/chopper/processing-nexus-choppers.html#Build-DiskChopper
-        for more information.
-    source_position:
-        A scalar variable with ``dtype=vector3`` that defines the source position.
-        Must be in the same coordinate system as the choppers' axle positions.
-    neutrons:
-        Number of neutrons to simulate.
-    pulses:
-        Number of pulses to simulate.
-    seed:
-        Seed for the random number generator used in the simulation.
-    facility:
-        Facility where the experiment is performed.
-    """
-    import tof
-
-    tof_choppers = [
-        tof.Chopper(
-            frequency=abs(ch.frequency),
-            direction=tof.AntiClockwise
-            if (ch.frequency.value > 0.0)
-            else tof.Clockwise,
-            open=ch.slit_begin,
-            close=ch.slit_end,
-            phase=abs(ch.phase),
-            distance=sc.norm(
-                ch.axle_position - source_position.to(unit=ch.axle_position.unit)
-            ),
-            name=name,
-        )
-        for name, ch in choppers.items()
-    ]
-    source = tof.Source(facility=facility, neutrons=neutrons, pulses=pulses, seed=seed)
-    if not tof_choppers:
-        events = source.data.squeeze().flatten(to='event')
-        return SimulationResults(
-            time_of_arrival=events.coords["birth_time"],
-            speed=events.coords["speed"],
-            wavelength=events.coords["wavelength"],
-            weight=events.data,
-            distance=0.0 * sc.units.m,
-        )
-    model = tof.Model(source=source, choppers=tof_choppers)
-    results = model.run()
-    # Find name of the furthest chopper in tof_choppers
-    furthest_chopper = max(tof_choppers, key=lambda c: c.distance)
-    events = results[furthest_chopper.name].data.squeeze().flatten(to='event')
-    events = events[
-        ~(events.masks["blocked_by_others"] | events.masks["blocked_by_me"])
-    ]
-    return SimulationResults(
-        time_of_arrival=events.coords["toa"],
-        speed=events.coords["speed"],
-        wavelength=events.coords["wavelength"],
-        weight=events.data,
-        distance=furthest_chopper.distance,
-    )
-
-
-def simulate_chopper_cascade_using_tof(
-    choppers: DiskChoppers[SampleRun],
-    neutrons: NumberOfSimulatedNeutrons,
-    source_position: Position[snx.NXsource, SampleRun],
-) -> SimulationResults:
-    """
-    Simulate neutrons traveling through the chopper cascade using the ``tof`` package.
-
-    Parameters
-    ----------
-    choppers:
-        Chopper settings.
-    neutrons:
-        Number of neutrons to simulate.
-    source_position:
-        Position of the source.
-    """
-    return simulate_beamline(
-        choppers=choppers, neutrons=neutrons, source_position=source_position
-    )

ess/reduce/time_of_flight/to_events.py

@@ -1,111 +0,0 @@
-# SPDX-License-Identifier: BSD-3-Clause
-# Copyright (c) 2025 Scipp contributors (https://github.com/scipp)
-
-from functools import reduce
-
-import numpy as np
-import scipp as sc
-
-
-def to_events(
-    da: sc.DataArray, event_dim: str, events_per_bin: int = 500
-) -> sc.DataArray:
-    """
-    Convert a histogrammed data array to an event list.
-    The generated events have a uniform distribution within each bin.
-    Each dimension with a bin-edge coordinate is converted to an event coordinate.
-    The contract is that if we re-histogram the event list with the same bin edges,
-    we should get the original counts back.
-    Masks on non-bin-edge dimensions are preserved.
-    If there are masks on bin-edge dimensions, the masked values are zeroed out in the
-    original data before the conversion to events.
-
-    Parameters
-    ----------
-    da:
-        DataArray to convert to events.
-    event_dim:
-        Name of the new event dimension.
-    events_per_bin:
-        Number of events to generate per bin.
-    """
-    if da.bins is not None:
-        raise ValueError("Cannot convert a binned DataArray to events.")
-    rng = np.random.default_rng()
-    event_coords = {}
-    edge_dims = []
-    midp_dims = set(da.dims)
-    midp_coord_names = []
-    # Separate bin-edge and midpoints coords
-    for name in da.coords:
-        dims = da.coords[name].dims
-        is_edges = False if not dims else da.coords.is_edges(name)
-        if is_edges:
-            if name in dims:
-                edge_dims.append(name)
-                midp_dims -= {name}
-        else:
-            midp_coord_names.append(name)
-
-    edge_sizes = {dim: da.sizes[da.coords[dim].dim] for dim in edge_dims}
-    for dim in edge_dims:
-        coord = da.coords[dim]
-        left = sc.broadcast(coord[dim, :-1], sizes=edge_sizes).values
-        right = sc.broadcast(coord[dim, 1:], sizes=edge_sizes).values
-
-        # The numpy.random.uniform function below does not support NaNs, so we need to
-        # replace them with zeros, and then replace them back after the random numbers
-        # have been generated.
-        nans = np.isnan(left) | np.isnan(right)
-        left = np.where(nans, 0.0, left)
-        right = np.where(nans, 0.0, right)
-        # Ensure left <= right
-        left, right = np.minimum(left, right), np.maximum(left, right)
-
-        # In each bin, we generate a number of events with a uniform distribution.
-        events = rng.uniform(
-            left, right, size=(events_per_bin, *list(edge_sizes.values()))
-        )
-        events[..., nans] = np.nan
-        event_coords[dim] = sc.array(
-            dims=[event_dim, *edge_dims], values=events, unit=coord.unit
-        )
-
-    # Find and apply masks that are on a bin-edge dimension
-    event_masks = {}
-    other_masks = {}
-    edge_dims_set = set(edge_dims)
-    for key, mask in da.masks.items():
-        if set(mask.dims) & edge_dims_set:
-            event_masks[key] = mask
-        else:
-            other_masks[key] = mask
-
-    data = da.data
-    if event_masks:
-        inv_mask = (~reduce(lambda a, b: a | b, event_masks.values())).to(dtype=int)
-        inv_mask.unit = ""
-        data = data * inv_mask
-
-    # Create the data counts, which are the original counts divided by the number of
-    # events per bin
-    sizes = {event_dim: events_per_bin} | da.sizes
-    val = sc.broadcast(sc.values(data) / float(events_per_bin), sizes=sizes)
-    kwargs = {"dims": sizes.keys(), "values": val.values, "unit": data.unit}
-    if data.variances is not None:
-        # Note here that all the events are correlated.
-        # If we later histogram the events with different edges than the original
-        # histogram, then neighboring bins will be correlated, and the error obtained
-        # will be too small. It is however not clear what can be done to improve this.
-        kwargs["variances"] = sc.broadcast(
-            sc.variances(data) / float(events_per_bin), sizes=sizes
-        ).values
-    new_data = sc.array(**kwargs)
-
-    new = sc.DataArray(data=new_data, coords=event_coords)
-    new = new.transpose((*midp_dims, *edge_dims, event_dim)).flatten(
-        dims=[*edge_dims, event_dim], to=event_dim
-    )
-    return new.assign_coords(
-        {dim: da.coords[dim].copy() for dim in midp_coord_names}
-    ).assign_masks({key: mask.copy() for key, mask in other_masks.items()})