restage 0.4.0__tar.gz → 0.4.1__tar.gz

{restage-0.4.0/src/restage.egg-info → restage-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: restage
-Version: 0.4.0
+Version: 0.4.1
 Author-email: Gregory Tucker <gregory.tucker@ess.eu>
 License: BSD-3-Clause
 Classifier: License :: OSI Approved :: BSD License

{restage-0.4.0 → restage-0.4.1}/src/restage/bifrost_choppers.py

@@ -82,9 +82,7 @@ def bandwidth_chopper_speeds_phases(energy_minimum: float):
     return SOURCE_FREQUENCY, phase, -SOURCE_FREQUENCY, phase
 
 
-def calculate(order: float, time: float, energy: float, names: list[str] | None = None):
-    if names is None or len(names) != 6:
-        names = ['ps1', 'ps2', 'fo1', 'fo2', 'bw1', 'bw2']
+def calculate(order: float, time: float, energy: float, names: tuple[str, ...]):
     a, b, c, d, e, f = names
     s, p = 'speed', 'phase'
     r = dict()
@@ -94,9 +92,12 @@ def calculate(order: float, time: float, energy: float, names: list[str] | None
     return r
 
 
-def main(order: float, time: float, energy: float, names: list[str] | None = None):
+def main(order: float, time: float, energy: float, names: tuple[str, ...] | None = None):
     if names is None or len(names) != 6:
-        names = ['ps1', 'ps2', 'fo1', 'fo2', 'bw1', 'bw2']
+        # names = ('ps1', 'ps2', 'fo1', 'fo2', 'bw1', 'bw2')
+        names = ('pulse_shaping_chopper_1', 'pulse_shaping_chopper_2',
+                 'frame_overlap_chopper_1', 'frame_overlap_chopper_2',
+                 'bandwidth_chopper_1', 'bandwidth_chopper_2')
     rep = calculate(order, time, energy, names)
     print(' '.join([f'{k}={v}' for k, v in rep.items()]))
 

{restage-0.4.0 → restage-0.4.1}/src/restage/cache.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 from mccode_antlr.instr import Instr
 from .tables import InstrEntry, SimulationTableEntry, SimulationEntry
-from mccode_antlr.compiler.c import CBinaryTarget
 
 
 def setup_database(named: str):
@@ -54,6 +53,8 @@ def _compile_instr(entry: InstrEntry, instr: Instr, config: dict | None = None,
         generator = MCSTAS_GENERATOR
 
     output = directory_under_module_data_path('bin')
+    # TODO consider adding `dump_source=True` _and_ putting the resulting file into
+    #      the cache in order to make debugging future problems a tiny bit easier.
     binary_path = compile_instrument(instr, target, output, generator=generator, config=config)
     entry.mccode_version = __version__
     entry.binary_path = str(binary_path)

{restage-0.4.0 → restage-0.4.1}/src/restage/energy.py

@@ -10,13 +10,15 @@ def get_and_remove(d: dict, k: str, default=None):
     return default
 
 
-def one_generic_energy_to_chopper_parameters(calculate_choppers, time: float, order: int, parameters: dict):
+def one_generic_energy_to_chopper_parameters(
+        calculate_choppers, chopper_names: tuple[str, ...],
+        time: float, order: int, parameters: dict):
     if any(x in parameters for x in ('ei', 'wavelength', 'lambda', 'energy', 'e')):
         ei = get_and_remove(parameters, 'ei', get_and_remove(parameters, 'energy', get_and_remove(parameters, 'e')))
         if ei is None:
             wavelength = get_and_remove(parameters, 'wavelength', get_and_remove(parameters, 'lambda'))
             ei = _wavelength_angstrom_to_energy_mev(wavelength)
-        choppers = calculate_choppers(order, time, ei)
+        choppers = calculate_choppers(order, time, ei, names=chopper_names)
         parameters.update(choppers)
     return parameters
 
@@ -24,25 +26,28 @@ def one_generic_energy_to_chopper_parameters(calculate_choppers, time: float, or
 def bifrost_translate_energy_to_chopper_parameters(parameters: dict):
     from itertools import product
     from .bifrost_choppers import calculate
-    for name in product([a+b for a, b in product(('ps', 'fo', 'bw'), ('1', '2'))], ('speed', 'phase')):
+    choppers = tuple(f'{a}_chopper_{b}' for a, b in product(['pulse_shaping', 'frame_overlap', 'bandwidth'], [1, 2]))
+    # names = [a+b for a, b in product(('ps', 'fo', 'bw'), ('1', '2'))]
+    for name in product(choppers, ('speed', 'phase')):
         name = ''.join(name)
         if name not in parameters:
             parameters[name] = 0
     order = get_and_remove(parameters, 'order', 14)
     time = get_and_remove(parameters, 'time', get_and_remove(parameters, 't', 170/180/(2 * 15 * 14)))
-    return one_generic_energy_to_chopper_parameters(calculate, time, order, parameters)
+    return one_generic_energy_to_chopper_parameters(calculate, choppers, time, order, parameters)
 
 
 def cspec_translate_energy_to_chopper_parameters(parameters: dict):
     from itertools import product
     from .cspec_choppers import calculate
-    for name in product(('bw1', 'bw2', 'bw3', 's', 'p', 'm1', 'm2'), ('speed', 'phase')):
+    choppers = ('bw1', 'bw2', 'bw3', 's', 'p', 'm1', 'm2')
+    for name in product(choppers, ('speed', 'phase')):
         name = ''.join(name)
         if name not in parameters:
             parameters[name] = 0
     time = get_and_remove(parameters, 'time', 0.004)
     order = get_and_remove(parameters, 'order', 16)
-    return one_generic_energy_to_chopper_parameters(calculate, time, order, parameters)
+    return one_generic_energy_to_chopper_parameters(calculate, choppers, time, order, parameters)
 
 
 def no_op_translate_energy_to_chopper_parameters(parameters: dict):

{restage-0.4.0 → restage-0.4.1}/src/restage/instr.py

@@ -6,10 +6,9 @@ from __future__ import annotations
 from pathlib import Path
 from typing import Union
 from mccode_antlr.instr import Instr
-from mccode_antlr.reader import Registry
 
 
-def load_instr(filepath: Union[str, Path], extra_registries: list[Registry] | None = None) -> Instr:
+def load_instr(filepath: Union[str, Path]) -> Instr:
     """Loads an Instr object from a .instr file or a HDF5 file"""
     from mccode_antlr.io import load_hdf5
     from mccode_antlr.loader import load_mcstas_instr
@@ -19,23 +18,10 @@ def load_instr(filepath: Union[str, Path], extra_registries: list[Registry] | No
     if not filepath.exists() or not filepath.is_file():
         raise ValueError('The provided filepath does not exist or is not a file')
 
-    # FIXME this hack should be removed ASAP
-    if extra_registries is None:
-        from mccode_antlr.reader import GitHubRegistry
-        mcpl_input_once_registry = GitHubRegistry(
-            name='mcpl_input_once',
-            url='https://github.com/g5t/mccode-mcpl-input-once',
-            version='main',
-            filename='pooch-registry.txt'
-        )
-        extra_registries = [mcpl_input_once_registry]
-
     if filepath.suffix == '.instr':
-        return load_mcstas_instr(filepath, registries=extra_registries)
+        return load_mcstas_instr(filepath)
 
-    instr = load_hdf5(filepath)
-    instr.registries += tuple(extra_registries)
-    return instr
+    return load_hdf5(filepath)
 
 
 def collect_parameter_dict(instr: Instr, kwargs: dict, strict: bool = True) -> dict:
@@ -60,7 +46,7 @@ def collect_parameter_dict(instr: Instr, kwargs: dict, strict: bool = True) -> d
     for k, v in kwargs.items():
         if k not in parameters:
             if strict:
-                raise ValueError(f"Parameter {k} is not a valid parameter name")
+                raise ValueError(f"Parameter {k} is not a valid parameter name. Valid names are: {', '.join(parameters)}")
             continue
         if not isinstance(v, Value):
             expected_type = parameters[k].data_type

{restage-0.4.0 → restage-0.4.1/src/restage.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: restage
-Version: 0.4.0
+Version: 0.4.1
 Author-email: Gregory Tucker <gregory.tucker@ess.eu>
 License: BSD-3-Clause
 Classifier: License :: OSI Approved :: BSD License

{restage-0.4.0 → restage-0.4.1}/test/test_energy.py

@@ -1,20 +1,31 @@
 import unittest
 
+
+def parameters(names: tuple[str, ...]):
+    from itertools import product
+    return tuple(x + y for x, y in product(names, ('speed', 'phase')))
+
+
+CHOPPER_NAMES = ('pulse_shaping', 'frame_overlap', 'bandwidth')
+CHOPPERS = tuple(f'{name}_chopper_{no}' for name in CHOPPER_NAMES for no in (1, 2))
+OLD_CHOPPERS = tuple(f'{name}{no}' for name in ('ps', 'fo', 'bw') for no in (1, 2))
+
+
 class BIFROSTEnergyTestCase(unittest.TestCase):
     def setUp(self):
         from mccode_antlr.loader import parse_mcstas_instr
         instr = f"""DEFINE INSTRUMENT this_IS_NOT_BIFROST(
-        ps1speed, ps1phase, ps2speed, ps2phase, fo1speed, fo1phase, bw1speed, bw1phase, bw2speed, bw2phase
+        pulse_shaping_chopper_1speed, pulse_shaping_chopper_1phase, pulse_shaping_chopper_2speed, pulse_shaping_chopper_2phase, frame_overlap_chopper_1speed, frame_overlap_chopper_1phase, bandwidth_chopper_1speed, bandwidth_chopper_1phase, bandwidth_chopper_2speed, bandwidth_chopper_2phase
         )
         TRACE
         COMPONENT origin = Arm() AT (0, 0, 0) ABSOLUTE
-        COMPONENT ps1 = DiskChopper(theta_0=170, radius=0.35, nu=ps1speed, phase=ps1phase) AT (0, 0, 1) RELATIVE PREVIOUS
-        COMPONENT ps2 = DiskChopper(theta_0=170, radius=0.35, nu=ps2speed, phase=ps2phase) AT (0, 0, 0.02) RELATIVE ps1
-        COMPONENT fo1 = DiskChopper(theta_0=110, radius=0.35, nu=fo1speed, phase=fo1phase) AT (0, 0, 12) RELATIVE ps2
-        COMPONENT fo2 = DiskChopper(theta_0=115, radius=0.35, nu=fo1speed, phase=fo1phase) AT (0, 0, 4) RELATIVE fo1
-        COMPONENT bw1 = DiskChopper(theta_0=110, radius=0.35, nu=bw1speed, phase=bw1phase) AT (0, 0, 80) RELATIVE fo2
-        COMPONENT bw2 = DiskChopper(theta_0=115, radius=0.35, nu=bw2speed, phase=bw2phase) AT (0, 0, 0.02) RELATIVE bw1
-        COMPONENT sample = Arm() AT (0, 0, 80) RELATIVE bw2
+        COMPONENT pulse_shaping_chopper_1 = DiskChopper(theta_0=170, radius=0.35, nu=pulse_shaping_chopper_1speed, phase=pulse_shaping_chopper_1phase) AT (0, 0, 1) RELATIVE PREVIOUS
+        COMPONENT pulse_shaping_chopper_2 = DiskChopper(theta_0=170, radius=0.35, nu=pulse_shaping_chopper_2speed, phase=pulse_shaping_chopper_2phase) AT (0, 0, 0.02) RELATIVE pulse_shaping_chopper_1
+        COMPONENT frame_overlap_chopper_1 = DiskChopper(theta_0=110, radius=0.35, nu=frame_overlap_chopper_1speed, phase=frame_overlap_chopper_1phase) AT (0, 0, 12) RELATIVE pulse_shaping_chopper_2
+        COMPONENT frame_overlap_chopper_2 = DiskChopper(theta_0=115, radius=0.35, nu=frame_overlap_chopper_1speed, phase=frame_overlap_chopper_1phase) AT (0, 0, 4) RELATIVE frame_overlap_chopper_1
+        COMPONENT bandwidth_chopper_1 = DiskChopper(theta_0=110, radius=0.35, nu=bandwidth_chopper_1speed, phase=bandwidth_chopper_1phase) AT (0, 0, 80) RELATIVE frame_overlap_chopper_2
+        COMPONENT bandwidth_chopper_2 = DiskChopper(theta_0=115, radius=0.35, nu=bandwidth_chopper_2speed, phase=bandwidth_chopper_2phase) AT (0, 0, 0.02) RELATIVE bandwidth_chopper_1
+        COMPONENT sample = Arm() AT (0, 0, 80) RELATIVE bandwidth_chopper_2
         END
         """
         self.instr = parse_mcstas_instr(instr)
@@ -46,8 +57,8 @@ class BIFROSTEnergyTestCase(unittest.TestCase):
             e = y * 0.5 + 1.7
             self.assertAlmostEqual(x, e)
 
-        parameters = dict(order=order, time=time, ei=ei)
-        npts, names, points = parameters_to_scan(parameters, grid=True)
+        scan_parameters = dict(order=order, time=time, ei=ei)
+        npts, names, points = parameters_to_scan(scan_parameters, grid=True)
         self.assertEqual(npts, 47*11)
         self.assertEqual(names, ['order', 'time', 'ei'])
         all_points = list(points)
@@ -68,7 +79,7 @@ class BIFROSTEnergyTestCase(unittest.TestCase):
         from restage.energy import energy_to_chopper_translator
         from restage.energy import bifrost_translate_energy_to_chopper_parameters
         from restage.range import MRange, Singular, parameters_to_scan
-        from itertools import product
+
 
         translator = energy_to_chopper_translator(self.instr.name)
         self.assertEqual(translator, bifrost_translate_energy_to_chopper_parameters)
@@ -76,36 +87,33 @@ class BIFROSTEnergyTestCase(unittest.TestCase):
         order = Singular(14,  1)
         time = MRange(0.0001, 0.002248, 0.0002)
         ei = MRange(1.7, 24.7, 0.5)
-        parameters = dict(order=order, time=time, ei=ei)
+        scan_parameters = dict(order=order, time=time, ei=ei)
 
-        spts, names, points = parameters_to_scan(parameters, grid=True)
+        spts, names, points = parameters_to_scan(scan_parameters, grid=True)
 
         self.assertEqual(47*11, spts)
         self.assertEqual(names, ['order', 'time', 'ei'])
 
-        chopper_pars = [x + y for x, y in product(('ps1', 'ps2', 'fo1', 'fo2', 'bw1', 'bw2'), ('speed', 'phase'))]
-
+        chopper_parameters = parameters(CHOPPERS)
         for point in points:
             kv = {k: v for k, v in zip(names, point)}
             translated = translator(kv)
-            for x in chopper_pars:
-                self.assertTrue(''.join(x) in translated)
+            for x in chopper_parameters:
+                self.assertTrue(x in translated)
 
-            self.assertEqual(len(translated), len(chopper_pars))
-            self.assertAlmostEqual(translated['bw1speed'], 14.0)
-            self.assertAlmostEqual(translated['bw2speed'], -14.0)
-            self.assertAlmostEqual(translated['fo1speed'], 14.0)
-            self.assertAlmostEqual(translated['fo1speed'], 14.0)
-            self.assertAlmostEqual(translated['ps1speed'], 14*14.0)
-            self.assertAlmostEqual(translated['ps2speed'], 14*14.0)
+            self.assertEqual(len(translated), len(chopper_parameters))
+            self.assertAlmostEqual(translated['bandwidth_chopper_1speed'], 14.0)
+            self.assertAlmostEqual(translated['bandwidth_chopper_2speed'], -14.0)
+            self.assertAlmostEqual(translated['frame_overlap_chopper_1speed'], 14.0)
+            self.assertAlmostEqual(translated['frame_overlap_chopper_1speed'], 14.0)
+            self.assertAlmostEqual(translated['pulse_shaping_chopper_1speed'], 14*14.0)
+            self.assertAlmostEqual(translated['pulse_shaping_chopper_2speed'], 14*14.0)
 
     def test_calculations(self):
         from itertools import product
         from chopcal import bifrost as mcstas_bifrost_calculation
         from restage.energy import bifrost_translate_energy_to_chopper_parameters
 
-        pars = [x+y for x, y in product(('ps1', 'ps2', 'fo1', 'fo2', 'bw1', 'bw2'), ('speed', 'phase'))]
-
         shortest_time = 0.0001  # this is approximately twice the opening time of the pulse shaping choppers at 15*14 Hz
         # Normal operation  Shortest full-height pulse  Shorter pulses reduce height
         #      /-----\                  /\
@@ -129,8 +137,8 @@ class BIFROSTEnergyTestCase(unittest.TestCase):
             kv = {'order': order, 'time': time, 'ei': energy}
             translated = bifrost_translate_energy_to_chopper_parameters(kv)
             from_mcstas = mcstas_bifrost_calculation(energy, 0., time)
-            for x in pars:
-                self.assertAlmostEqual(from_mcstas[x], translated[x])
+            for o, x in zip(parameters(OLD_CHOPPERS), parameters(CHOPPERS)):
+                self.assertAlmostEqual(from_mcstas[o], translated[x])
 
 
 if __name__ == '__main__':

{restage-0.4.0 → restage-0.4.1}/test/test_single.py

@@ -218,6 +218,13 @@ class SplitRunTestCase(unittest.TestCase):
             shutil.rmtree(self.dir)
 
     def test_simple_scan(self):
+        """This test requires MCPL shared libraries to work
+
+        For some unexplored reason, MCPL shared libraries are not found in their
+        default installed location, /usr/local/lib64/libmcpl.so; so this test must
+        be invoked with that location specified, e.g.,
+            $ LD_LIBRARY_PATH=/usr/local/lib64 pytest test/test_single.py -k test_simple_scan
+        """
         # Scanning a1 and a2 with a2=2*a1 should produce approximately the same intensity for all points
         # as long as a1 is between the limits of min_a1 and max_a1
         from restage.splitrun import splitrun