restage 0.3.2__tar.gz → 0.4.1__tar.gz

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

@@ -1,14 +1,22 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: restage
-Version: 0.3.2
+Version: 0.4.1
 Author-email: Gregory Tucker <gregory.tucker@ess.eu>
+License: BSD-3-Clause
 Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 Requires-Dist: zenlog>=1.1
 Requires-Dist: platformdirs>=3.11
 Requires-Dist: psutil>=5.9.6
-Requires-Dist: importlib_metadata; python_version < "3.8"
-Requires-Dist: mccode-antlr[hdf5]>=0.7.1
+Requires-Dist: mccode-antlr[hdf5]>=0.10.2
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: chopcal; extra == "test"

{restage-0.3.2 → restage-0.4.1}/pyproject.toml

@@ -8,15 +8,23 @@ dependencies = [
     'zenlog>=1.1',
     'platformdirs>=3.11',
     'psutil>=5.9.6',
-    "importlib_metadata; python_version<'3.8'",
-    'mccode-antlr[hdf5]>=0.7.1',
+    'mccode-antlr[hdf5]>=0.10.2',
 ]
 readme = "README.md"
+license = {text = "BSD-3-Clause"}
+requires-python = ">=3.9"
 authors = [
     { name = "Gregory Tucker", email = "gregory.tucker@ess.eu" },
 ]
 classifiers = [
     "License :: OSI Approved :: BSD License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
 ]
 dynamic = ["version"]
 
@@ -35,10 +43,9 @@ legacy_tox_ini = """
     [tox]
     min_version = 4.0
     env_list =
+        py313
         py312
         py311
-        py310
-        py39
         type
 
     [testenv]

{restage-0.3.2 → 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.3.2 → 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.3.2 → 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.3.2 → restage-0.4.1}/src/restage/instr.py

@@ -1,6 +1,8 @@
 """
 Utilities for interfacing with mccode_antlr.instr.Instr objects
 """
+from __future__ import annotations
+
 from pathlib import Path
 from typing import Union
 from mccode_antlr.instr import Instr
@@ -8,8 +10,8 @@ from mccode_antlr.instr import Instr
 
 def load_instr(filepath: Union[str, Path]) -> Instr:
     """Loads an Instr object from a .instr file or a HDF5 file"""
-    from mccode_antlr.loader import load_mcstas_instr
     from mccode_antlr.io import load_hdf5
+    from mccode_antlr.loader import load_mcstas_instr
 
     if not isinstance(filepath, Path):
         filepath = Path(filepath)
@@ -44,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.3.2 → restage-0.4.1}/src/restage/splitrun.py

@@ -1,11 +1,11 @@
 from __future__ import annotations
 
-from typing import Union
 from pathlib import Path
-from .range import Singular, MRange
 from .tables import SimulationEntry, InstrEntry
-from mccode_antlr.compiler.c import CBinaryTarget
 
+def mcpl_parameter_split(s: str) -> tuple[str, str]:
+    k, v = s.split(':', 1)
+    return k, v
 
 def make_splitrun_parser():
     from argparse import ArgumentParser
@@ -40,6 +40,12 @@ def make_splitrun_parser():
     # splitrun controlling parameters
     aa('--split-at', nargs=1, type=str, default=['mcpl_split'],
        help='Component at which to split -- DEFAULT: mcpl_split')
+    aa('--mcpl-output-component', nargs=1, type=str, default=None,
+       help='Inserted MCPL file producing component, MCPL_output(.comp) if not provided')
+    aa('--mcpl-input-component', nargs=1, type=str, default=None,
+       help='Inserted MCPL file consuming component, MCPL_input(.comp) if not provided')
+    aa('--mcpl-input-parameters', nargs='+', type=mcpl_parameter_split, metavar='key:value')
+    aa('--mcpl-output-parameters', nargs='+', type=mcpl_parameter_split, metavar='key:value')
     aa('-P', action='append', default=[], help='Cache parameter matching precision')
 
     # Other McCode runtime arguments exist, but are likely not used during a scan:
@@ -78,31 +84,6 @@ def regular_mccode_runtime_dict(args: dict) -> dict:
     return t
 
 
-def mccode_runtime_dict_to_args_list(args: dict) -> list[str]:
-    """Convert a dictionary of McCode runtime arguments to a string.
-
-    :parameter args: A dictionary of McCode runtime arguments.
-    :return: A list of arguments suitable for use in a command line call to a McCode compiled instrument.
-    """
-    # convert to a standardized string:
-    out = []
-    if 'seed' in args and args['seed'] is not None:
-        out.append(f'--seed={args["seed"]}')
-    if 'ncount' in args and args['ncount'] is not None:
-        out.append(f'--ncount={args["ncount"]}')
-    if 'dir' in args and args['dir'] is not None:
-        out.append(f'--dir={args["dir"]}')
-    if 'trace' in args and args['trace']:
-        out.append('--trace')
-    if 'gravitation' in args and args['gravitation']:
-        out.append('--gravitation')
-    if 'bufsiz' in args and args['bufsiz'] is not None:
-        out.append(f'--bufsiz={args["bufsiz"]}')
-    if 'format' in args and args['format'] is not None:
-        out.append(f'--format={args["format"]}')
-    return out
-
-
 def parse_splitrun_precision(unparsed: list[str]) -> dict[str, float]:
     precision = {}
     for p in unparsed:
@@ -113,43 +94,34 @@ def parse_splitrun_precision(unparsed: list[str]) -> dict[str, float]:
     return precision
 
 
-def sort_args(args: list[str]) -> list[str]:
-    """Take the list of arguments and sort them into the correct order for splitrun"""
-    # TODO this is a bit of a hack, but it works for now
-    first, last = [], []
-    k = 0
-    while k < len(args):
-        if args[k].startswith('-'):
-            first.append(args[k])
-            k += 1
-            if '=' not in first[-1] and k < len(args) and not args[k].startswith('-') and '=' not in args[k]:
-                first.append(args[k])
-                k += 1
-        else:
-            last.append(args[k])
-            k += 1
-    return first + last
-
-
-def parse_splitrun():
+def parse_splitrun(parser):
     from .range import parse_scan_parameters
+    from mccode_antlr.run.runner import sort_args
     import sys
     sys.argv[1:] = sort_args(sys.argv[1:])
 
-    args = make_splitrun_parser().parse_args()
+    args = parser.parse_args()
+    if args.mcpl_input_parameters is not None:
+        args.mcpl_input_parameters = dict(args.mcpl_input_parameters)
+    if args.mcpl_output_parameters is not None:
+        args.mcpl_output_parameters = dict(args.mcpl_output_parameters)
     parameters = parse_scan_parameters(args.parameters)
     precision = parse_splitrun_precision(args.P)
     return args, parameters, precision
 
 
 def entrypoint():
-    args, parameters, precision = parse_splitrun()
+    args, parameters, precision = parse_splitrun(make_splitrun_parser())
     splitrun_from_file(args, parameters, precision)
 
 
 def splitrun_from_file(args, parameters, precision):
     from .instr import load_instr
     instr = load_instr(args.instrument[0])
+    splitrun_args(instr, parameters, precision, args)
+
+
+def splitrun_args(instr, parameters, precision, args, **kwargs):
     splitrun(instr, parameters, precision, split_at=args.split_at[0], grid=args.mesh,
              seed=args.seed[0] if args.seed is not None else None,
              ncount=args.ncount[0] if args.ncount is not None else None,
@@ -164,6 +136,11 @@ def splitrun_from_file(args, parameters, precision):
              parallel=args.parallel,
              gpu=args.gpu,
              process_count=args.process_count,
+             mcpl_output_component=args.mcpl_output_component[0] if args.mcpl_output_component is not None else None,
+             mcpl_output_parameters=args.mcpl_output_parameters,
+             mcpl_input_component=args.mcpl_input_component[0] if args.mcpl_input_component is not None else None,
+             mcpl_input_parameters=args.mcpl_input_parameters,
+             **kwargs
              )
 
 
@@ -174,8 +151,11 @@ def splitrun(instr, parameters, precision: dict[str, float], split_at=None, grid
              parallel=False, gpu=False, process_count=0,
              callback=None, callback_arguments: dict[str, str] | None = None,
              output_split_instrs=True,
+             mcpl_output_component=None, mcpl_output_parameters: dict[str, str] | None = None,
+             mcpl_input_component=None, mcpl_input_parameters: dict[str, str] | None = None,
              **runtime_arguments):
     from zenlog import log
+    from mccode_antlr.common import ComponentParameter, Expr
     from .energy import get_energy_parameter_names
     if split_at is None:
         split_at = 'mcpl_split'
@@ -183,7 +163,17 @@ def splitrun(instr, parameters, precision: dict[str, float], split_at=None, grid
     if not instr.has_component_named(split_at):
         log.error(f'The specified split-at component, {split_at}, does not exist in the instrument file')
     # splitting defines an instrument parameter in both returned instrument, 'mcpl_filename'.
-    pre, post = instr.mcpl_split(split_at, remove_unused_parameters=True)
+    if mcpl_output_parameters is not None:
+        mcpl_output_parameters = tuple(ComponentParameter(k, Expr.parse(v)) for k, v in mcpl_output_parameters.items())
+    if mcpl_input_parameters is not None:
+        mcpl_input_parameters = tuple(ComponentParameter(k, Expr.parse(v)) for k, v in mcpl_input_parameters.items())
+    pre, post = instr.mcpl_split(split_at,
+                                 output_component=mcpl_output_component,
+                                 output_parameters=mcpl_output_parameters,
+                                 input_component=mcpl_input_component,
+                                 input_parameters=mcpl_input_parameters,
+                                 remove_unused_parameters=True
+                                 )
     if output_split_instrs:
         for p in (pre, post):
             with open(f'{p.name}.instr', 'w') as f:
@@ -204,7 +194,8 @@ def splitrun(instr, parameters, precision: dict[str, float], split_at=None, grid
                              dry_run=dry_run, parallel=parallel, gpu=gpu, process_count=process_count)
 
     splitrun_combined(pre_entry, pre, post, pre_parameters, post_parameters, grid, precision,
-                      dry_run=dry_run, callback=callback, callback_arguments=callback_arguments, **runtime_arguments)
+                      dry_run=dry_run, parallel=parallel, gpu=gpu, process_count=process_count,
+                      callback=callback, callback_arguments=callback_arguments, **runtime_arguments)
 
 
 def splitrun_pre(instr, parameters, grid, precision: dict[str, float],
@@ -259,6 +250,7 @@ def _pre_step(instr, entry, names, precision, translate, kw, min_pc, max_pc, dry
 
 def splitrun_combined(pre_entry, pre, post, pre_parameters, post_parameters, grid, precision: dict[str, float],
                       summary=True, dry_run=False, callback=None, callback_arguments: dict[str, str] | None = None,
+                      parallel=False, gpu=False, process_count=0,
                       **runtime_arguments):
     from pathlib import Path
     from .cache import cache_instr, cache_get_simulation
@@ -267,7 +259,7 @@ def splitrun_combined(pre_entry, pre, post, pre_parameters, post_parameters, gri
     from .instr import collect_parameter_dict
     from .tables import best_simulation_entry_match
     from .emulate import mccode_sim_io, mccode_dat_io, mccode_dat_line
-    instr_entry = cache_instr(post, mpi=False, acc=False)
+    instr_entry = cache_instr(post, mpi=parallel, acc=gpu)
     args = regular_mccode_runtime_dict(runtime_arguments)
     sit_kw = {'seed': args.get('seed'), 'ncount': args.get('ncount'), 'gravitation': args.get('gravitation', False)}
     # recombine the parameters to ensure the 'correct' scan is performed
@@ -308,7 +300,7 @@ def splitrun_combined(pre_entry, pre, post, pre_parameters, post_parameters, gri
         # TODO Use the following line instead of the one after it when McCode is fixed to use zero-padded folder names
         # # runtime_arguments['dir'] = args["dir"].joinpath(str(number).zfill(n_zeros))
         runtime_arguments['dir'] = args['dir'].joinpath(str(number))
-        do_secondary_simulation(sim_entry, instr_entry, secondary_pars, runtime_arguments, dry_run=dry_run)
+        do_secondary_simulation(sim_entry, instr_entry, secondary_pars, runtime_arguments, dry_run=dry_run, process_count=process_count)
         if summary and not dry_run:
             # the data file has *all* **scanned** parameters recorded for each step:
             detectors, line = mccode_dat_line(runtime_arguments['dir'], {k: v for k,v in zip(names, values)})
@@ -332,7 +324,8 @@ def splitrun_combined(pre_entry, pre, post, pre_parameters, post_parameters, gri
 
 
 def _args_pars_mcpl(args: dict, params: dict, mcpl_filename) -> str:
-    # Combine the arguments, parameters, and mcpl filename into a single command-arguments string:
+    """Combine the arguments, parameters, and mcpl filename into a single command-arguments string:"""
+    from mccode_antlr.run.runner import mccode_runtime_dict_to_args_list
     first = ' '.join(mccode_runtime_dict_to_args_list(args))
     second = ' '.join([f'{k}={v}' for k, v in params.items()])
     third = f'mcpl_filename={mcpl_filename}'
@@ -457,7 +450,8 @@ def repeat_simulation_until(count, runner, args: dict, parameters, work_dir: Pat
     combine_mccode_sims_in_directories(outputs, work_dir)
 
 
-def do_secondary_simulation(p_sit: SimulationEntry, entry: InstrEntry, pars: dict, args: dict, dry_run: bool = False):
+def do_secondary_simulation(p_sit: SimulationEntry, entry: InstrEntry, pars: dict, args: dict, dry_run: bool = False,
+                            process_count: int = 0):
     from zenlog import log
     from pathlib import Path
     from shutil import copy
@@ -475,7 +469,7 @@ def do_secondary_simulation(p_sit: SimulationEntry, entry: InstrEntry, pars: dic
 
     mcpl_path = mcpl_real_filename(Path(p_sit.output_path).joinpath(mcpl_filename))
     executable = Path(entry.binary_path)
-    target = CBinaryTarget(mpi=entry.mpi, acc=entry.acc, count=1 if not entry.mpi else 0, nexus=False)
+    target = CBinaryTarget(mpi=entry.mpi, acc=entry.acc, count=process_count, nexus=False)
     run_compiled_instrument(executable, target, _args_pars_mcpl(args, pars, mcpl_path), capture=False, dry_run=dry_run)
 
     if not dry_run:

{restage-0.3.2 → restage-0.4.1}/src/restage/tables.py

@@ -10,8 +10,8 @@ def uuid():
 
 
 def utc_timestamp() -> float:
-    from datetime import datetime
-    return datetime.utcnow().timestamp()
+    from datetime import datetime, timezone
+    return datetime.now(timezone.utc).timestamp()
 
 
 COMMON_COLUMNS = ['seed', 'ncount', 'output_path', 'gravitation', 'creation', 'last_access']

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

@@ -1,14 +1,22 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: restage
-Version: 0.3.2
+Version: 0.4.1
 Author-email: Gregory Tucker <gregory.tucker@ess.eu>
+License: BSD-3-Clause
 Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 Requires-Dist: zenlog>=1.1
 Requires-Dist: platformdirs>=3.11
 Requires-Dist: psutil>=5.9.6
-Requires-Dist: importlib_metadata; python_version < "3.8"
-Requires-Dist: mccode-antlr[hdf5]>=0.7.1
+Requires-Dist: mccode-antlr[hdf5]>=0.10.2
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: chopcal; extra == "test"

{restage-0.3.2 → restage-0.4.1}/src/restage.egg-info/SOURCES.txt

@@ -23,8 +23,6 @@ src/restage.egg-info/dependency_links.txt
 src/restage.egg-info/entry_points.txt
 src/restage.egg-info/requires.txt
 src/restage.egg-info/top_level.txt
-test/splitRunTest_first.c
-test/splitRunTest_second.c
 test/test_cache.py
 test/test_database.py
 test/test_energy.py

restage-0.4.1/src/restage.egg-info/requires.txt

@@ -0,0 +1,8 @@
+zenlog>=1.1
+platformdirs>=3.11
+psutil>=5.9.6
+mccode-antlr[hdf5]>=0.10.2
+
+[test]
+pytest
+chopcal

{restage-0.3.2 → 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__':