moreniius 0.1.10__py3-none-any.whl → 0.2.1__py3-none-any.whl

moreniius/additions.py

@@ -8,15 +8,71 @@ log.debug('Extending moreniius.mccode.NXInstance translators')
 COMPONENT_TYPE_NAME_TO_NEXUS['ESS_butterfly'] = 'NXmoderator'
 
 
+# BIFROST has 45 triplet detector modules. Each has its own position and orientation, and defines the positions
+# and orientations of its cylindrical pixels in its own coordinate system.
+# This module-level dictionary is used to dynamically populate their information, to be used when constructing the
+# full detector during the readout-construction.
+BIFROST_DETECTOR_MODULES = {}
+
+BIFROST_DETECTOR_TOPIC = 'bifrost_detector'
+
+
 def readout_translator(instance):
     """BIFROST specific Readout Master, should be deprecated in favour of ReadoutCAEN"""
-    from nexusformat.nexus import NXgroup
+    from numpy import einsum, ndarray, array
+    from nexusformat.nexus import NXdetector, NXcylindrical_geometry
     from .utils import ev44_event_data_group
-    stream = ev44_event_data_group(source='caen', topic='SimulatedEvents')
-
-    # Somehow define the NXdetector_module ... :/
-
-    return NXgroup(data=stream)
+    stream = ev44_event_data_group(source='caen', topic=BIFROST_DETECTOR_TOPIC)
+
+    readout_pos, readout_rot = instance.obj.orientation.position_parts(), instance.obj.orientation.rotation_parts()
+
+    counts = [geometry.detector_number.size for _, _, geometry in BIFROST_DETECTOR_MODULES.values()]
+    total = sum(counts)
+    points = [geometry.vertices.shape[0] for _, _, geometry in BIFROST_DETECTOR_MODULES.values()]
+    total_points = sum(points)
+    all_cylinders = ndarray((total, 3), dtype='int32')
+    all_vertices = ndarray((total_points, 3), dtype='float32')
+    detector_number = ndarray((total,), dtype='int32')
+
+    offset = 0
+
+    for module_pos, module_rot, geometry in BIFROST_DETECTOR_MODULES.values():
+        # Find the vector and rotation matrix linking the two coordinate systems
+        #
+        # - The geometry is defined in the module coordinate system, where any point is p' = (x', y', z').
+        # - There is a rotation matrix rot1 that relates a vector in _a_ global coordinate system to the module
+        #   Such that
+        #       x' = rot1 x_global
+        #   Or
+        #       x_global = rot1.inv() x'
+        # - Similarly, there is a rotation matrix rot2 that relates a vector in the same global coordinate system to
+        #   the readout's coordinate system.
+        #       x = rot2 x_global
+        # - In this global coordinate system, the module position and readout positions have a vector connecting them
+        #       v = p_module - p_readout
+        #
+        # - So, to express the geometry in the readout's coordinate system, we convert p' to the global coordinate
+        #   system, add the difference vector between the two coordinate systems, then convert the result to the
+        #   readout coordinate system:
+        #       p = rot2 (v + rot1.inv() p')
+        #
+        v = instance.instr.expr2nx(tuple((module_pos - readout_pos).position()))  # this is a mccode-antlr Vector
+        rot1 = array(instance.instr.expr2nx(tuple(module_rot.inverse().rotation()))).reshape((3, 3))
+        rot2 = array(instance.instr.expr2nx(tuple(readout_rot.rotation()))).reshape((3, 3))
+        #
+        vertices = einsum('ij,kj->ki', rot1, geometry.vertices)
+        vertices = vertices + v
+        vertices = einsum('ij,kj->ki', rot2, vertices)
+        #
+        cylinders = offset + geometry.cylinders
+        all_vertices[offset:(offset + vertices.shape[0])] = vertices
+        all_cylinders[geometry.detector_number - 1, :] = cylinders
+        detector_number[geometry.detector_number - 1] = geometry.detector_number
+        offset += vertices.shape[0]
+
+    geometry = NXcylindrical_geometry(vertices=all_vertices, cylinders=all_cylinders, detector_number=detector_number)
+
+    return NXdetector(data=stream, geometry=geometry)
 
 
 def monochromator_rowland_translator(nxinstance):
@@ -122,22 +178,25 @@ def detector_tubes_offsets_and_one_cylinder(self):
 
     halfi = (width - 2 * radius) / 2
     di = np.linspace(-halfi, halfi, ni)
-    dj = np.linspace(-height / 2, height / 2, nj)
+
+    half_pixel = height / (nj + 1) / 2  # half the size of one pixel along the tube
+    dj = -np.linspace(-height / 2 + half_pixel, height / 2 - half_pixel, nj)
     Dj, Di = np.meshgrid(dj, di)
 
     arc, triplet = analyzer - 1, cassette - 1  # naming from ICD 01 v6 indexing of triplets
 
     diameter = f'2 * {radius}' if isinstance(radius, str) else 2 * radius
 
-    pars['detector_number'] = [[pixel_fun(nj, arc, triplet, tube, position) for position in range(nj)] for tube in
-                               range(ni)]
-    pars['data'] = ev44_event_data_group(bifrost_source_20230704(arc, triplet), 'SimulatedEvents')
+    detector_number = [[pixel_fun(nj, arc, triplet, tube, position) for position in range(nj)] for tube in range(ni)]
+
+    pars['detector_number'] = np.array(detector_number).astype('int32')
+    pars['data'] = ev44_event_data_group(bifrost_source_20230704(arc, triplet), BIFROST_DETECTOR_TOPIC)
     pars['x_pixel_offset'] = NXfield(Di, units='m')
     pars['y_pixel_offset'] = NXfield(Dj, units='m')
     pars['x_pixel_size'] = NXfield(diameter, units='m')
     pars['y_pixel_size'] = NXfield(height / nj, units='m')
     pars['diameter'] = NXfield(diameter, units='m')
-    pars['type'] = f'{ni} He3 tubes in series' if self.nx_parameter('wires_in_series') else f'{ni} He3 tubes'
+    pars['type'] = f'{ni} He3 tubes in series' if self.nx_parameter('wires_in_series', True) else f'{ni} He3 tubes'
 
     # use NXcylindrical_geometry to define the detectors, which requires:
     #   vertices - (i, 3) -- points relative to the detector position defining each cylinder in the detector
@@ -151,13 +210,65 @@ def detector_tubes_offsets_and_one_cylinder(self):
     #   detector_number: (k,) -- maps the cylinders in cylinder by index with a detector id
     #
     # We're allowed to specify a single cylinder then le the x/y/z_offset position that pixel repeatedly:
-    dy = (dj[1] - dj[0]) / 2
-    vertices = NXfield([[0, -dy, 0], [radius, -dy, 0], [0, dy, 0]], units='m')
+    vertices = NXfield([[0, -half_pixel, 0], [radius, -half_pixel, 0], [0, half_pixel, 0]], units='m')
     cylinders = [[0, 1, 2]]
     geometry = NXcylindrical_geometry(vertices=vertices, cylinders=cylinders)
 
     return NXdetector(**pars, geometry=geometry)
 
+#
+# def detector_tubes_only_cylinder(self):
+#     """This results in only the first cylinder being plotted by Nexus constructor"""
+#     import numpy as np
+#     from nexusformat.nexus import NXdetector, NXfield, NXcylindrical_geometry
+#     from .utils import ev44_event_data_group
+#     # parameters for NXdetector, to be filled-in
+#     pars = {}
+#     pixel_fun, wre = bifrost_pixel_regex_20230911()
+#
+#     if wre.match(str(self.obj.when)):
+#         m = wre.match(str(self.obj.when))
+#         cassette = int(m.group('cassette'))
+#         analyzer = int(m.group('analyzer'))
+#     else:
+#         cassette = 1
+#         analyzer = 1
+#     # cassette in (1, 9), analyzer in (1, 5):
+#
+#     # i is the 'slow' direction, j is the 'fast' direction
+#     # --> i between tubes, j along tubes
+#     ni = self.nx_parameter('N') # corresponds to 'width' and McStas 'x' axis
+#     nj = self.nx_parameter('no')  # corresponds to 'height' and McStas 'y' axis
+#     width, height, radius = [self.nx_parameter(n) for n in ('width', 'height', 'radius')]
+#     halfi = (width - 2 * radius) / 2
+#     di = np.linspace(-halfi, halfi, ni)
+#     dj = np.linspace(-height / 2, height / 2, nj+1)
+#
+#     # use NXcylindrical_geometry to define the detectors, which requires:
+#     #   vertices - (i, 3) -- points relative to the detector position defining each cylinder in the detector
+#     #   cylinders - (j, 3) -- indexes of the vertices, to define a cylinder by its face-center, face-edge, and
+#     #                         opposite face center:
+#     #             |---------------|---------------|
+#     #             |               |               |
+#     #           0 +               + 2             + 4
+#     #             |               |               |
+#     #             |---------------|---------------|
+#     #             1               3               5
+#     #   detector_number: (k,) -- maps the cylinders in cylinder by index with a detector id
+#
+#     arc, triplet = analyzer - 1, cassette - 1  # naming from ICD 01 v6 indexing of triplets
+#
+#     vertices = NXfield([v for x in di for y in dj for v in [[x, y, 0], [x, y, radius]]], units='m')
+#     cylinders = [[k, k+1, k+2] for k in [tube * 2 * (nj + 1) + 2 * j for tube in range(ni) for j in range(nj)]]
+#     detector_number = [pixel_fun(nj, arc, triplet, tube, j) for tube in range(ni) for j in range(nj)]
+#
+#     pars['data'] = ev44_event_data_group(bifrost_source_20230704(arc, triplet), BIFROST_DETECTOR_TOPIC)
+#     pars['type'] = f'{ni} He3 tubes in series' if self.nx_parameter('wires_in_series') else f'{ni} He3 tubes'
+#
+#     geometry = NXcylindrical_geometry(vertices=vertices, cylinders=cylinders, detector_number=detector_number)
+#
+#     return NXdetector(**pars, geometry=geometry)
+
 
 def detector_tubes_only_cylinder(self):
     """This results in only the first cylinder being plotted by Nexus constructor"""
@@ -183,8 +294,9 @@ def detector_tubes_only_cylinder(self):
     nj = self.nx_parameter('no')  # corresponds to 'height' and McStas 'y' axis
     width, height, radius = [self.nx_parameter(n) for n in ('width', 'height', 'radius')]
     halfi = (width - 2 * radius) / 2
+    # signs of di and dj verified by examining plots of detector positions
     di = np.linspace(-halfi, halfi, ni)
-    dj = np.linspace(-height / 2, height / 2, nj+1)
+    dj = -np.linspace(-height / 2, height / 2, nj+1)
 
     # use NXcylindrical_geometry to define the detectors, which requires:
     #   vertices - (i, 3) -- points relative to the detector position defining each cylinder in the detector
@@ -201,17 +313,36 @@ def detector_tubes_only_cylinder(self):
     arc, triplet = analyzer - 1, cassette - 1  # naming from ICD 01 v6 indexing of triplets
 
     vertices = NXfield([v for x in di for y in dj for v in [[x, y, 0], [x, y, radius]]], units='m')
-    cylinders = [[k, k+1, k+2] for k in [tube * 2 * (nj + 1) + 2 * j for tube in range(ni) for j in range(nj)]]
-    detector_number = [pixel_fun(nj, arc, triplet, tube, j) for tube in range(ni) for j in range(nj)]
+    cylinders = np.array([[k, k+1, k+2] for k in [tube * 2 * (nj + 1) + 2 * j for tube in range(ni) for j in range(nj)]]).astype('int32')
+    detector_number = np.array([pixel_fun(nj, arc, triplet, tube, j) for tube in range(ni) for j in range(nj)]).astype('int32')
 
-    pars['data'] = ev44_event_data_group(bifrost_source_20230704(arc, triplet), 'SimulatedEvents')
-    pars['type'] = f'{ni} He3 tubes in series' if self.nx_parameter('wires_in_series') else f'{ni} He3 tubes'
+    pars['data'] = ev44_event_data_group(bifrost_source_20230704(arc, triplet), BIFROST_DETECTOR_TOPIC)
+    pars['type'] = f'{ni} He3 tubes in series' if self.nx_parameter('wires_in_series', True) else f'{ni} He3 tubes'
 
     geometry = NXcylindrical_geometry(vertices=vertices, cylinders=cylinders, detector_number=detector_number)
 
+    for md in self.obj.metadata:
+        if md.mimetype == 'application/json' and md.name == 'nexus_structure_stream_data':
+            from nexusformat.nexus import NXdata
+            from moreniius.utils import NotNXdict
+            from json import loads
+            stream = loads(md.value)
+            name = stream.get('module', 'metadata')
+            pars[name] = NXdata(data=NotNXdict(stream))
+
     return NXdetector(**pars, geometry=geometry)
 
 
+def bifrost_detector_collector(self):
+    # nx_obj = detector_tubes_only_cylinder(self)  # each pixel is a cylinder
+    nx_obj = detector_tubes_offsets_and_one_cylinder(self)  # all pixels share one cylinder
+    # stash the object parts
+    pos, rot = self.obj.orientation.position_parts(), self.obj.orientation.rotation_parts()
+    BIFROST_DETECTOR_MODULES[str(self.obj.when)] = pos, rot, nx_obj.geometry
+    # and return it
+    return nx_obj
+
+
 # def histogram_monitor(obj):
 #     from nexusformat.nexus import NXmonitor
 #     from .nxoff import NXoff
@@ -222,16 +353,17 @@ def detector_tubes_only_cylinder(self):
 #
 #     # parameters to be filled-in
 #     pars = {}
-#     # pars['data'] = ev44_event_data_group(bifrost_source_20230704(arc, triplet), 'SimulatedEvents')
+#     # pars['data'] = ev44_event_data_group(bifrost_source_20230704(arc, triplet), BIFROST_DETECTOR_TOPIC)
 #     # pars['type'] = f'{ni} He3 tubes in series' if self.nx_parameter('wires_in_series') else f'{ni} He3 tubes'
 #     pars['geometry'] = geometry.to_nexus()
 #     return NXmonitor(**pars)
 
 
 # Patch-in the new methods
-register_translator('Readout', readout_translator)
+# register_translator('Readout', readout_translator)
 register_translator('Monochromator_Rowland', monochromator_rowland_translator)
-register_translator('Detector_tubes', detector_tubes_only_cylinder)
+register_translator('Detector_tubes', bifrost_detector_collector)
+register_translator('Detector_time_tubes', bifrost_detector_collector)
 register_translator('Frame_monitor', monitor_translator)
 
 log.debug('moreniius.mccode.NXInstance translators extended')

moreniius/mccode/comp.py

@@ -33,6 +33,7 @@ of the NXInstance class; then it can be used 'transparently' without needing to
 """
 from zenlog import log
 from mccode_antlr.common import Expr
+from moreniius.utils import resolve_parameter_links
 
 
 def slit_translator(nxinstance):
@@ -55,7 +56,8 @@ def slit_translator(nxinstance):
         log.warn(f'{nxinstance.obj.name} has a non-constant x or y zero, which requires special handling for NeXus')
     elif abs(x_zero) or abs(y_zero):
         log.warn(f'{nxinstance.obj.name} should be translated by [{x_zero}, {y_zero}, 0] via eniius_data METADATA')
-    return nxinstance.make_nx(NXslit, x_gap=x_gap, y_gap=y_gap)
+    params = resolve_parameter_links(dict(x_gap=x_gap, y_gap=y_gap))
+    return nxinstance.make_nx(NXslit, **params)
 
 
 def guide_translator(nxinstance):
@@ -64,18 +66,18 @@ def guide_translator(nxinstance):
     off_pars = {k: nxinstance.nx_parameter(k) for k in ('l', 'w1', 'h1', 'w2', 'h2')}
     for k in ('w', 'h'):
         off_pars[f'{k}2'] = off_pars[f'{k}1'] if off_pars[f'{k}2'] == 0 else off_pars[f'{k}2']
-    m_value = nxinstance.parameter('m')
+    guide_pars = {'m_value': nxinstance.parameter('m')}
     geometry = NXoff.from_wedge(**off_pars).to_nexus()
-    return nxinstance.make_nx(NXguide, m_value=m_value, geometry=geometry)
+    return nxinstance.make_nx(NXguide, OFF_GEOMETRY=geometry, **resolve_parameter_links(guide_pars))
 
 
 def collimator_linear_translator(nxinstance):
     from nexusformat.nexus import NXcollimator
     from moreniius.nxoff import NXoff
     pars = {k: nxinstance.nx_parameter(v) for k, v in (('l', 'length'), ('w1', 'xwidth'), ('h1', 'yheight'))}
-    return nxinstance.make_nx(NXcollimator, divergence_x=nxinstance.parameter('divergence'),
-                        divergence_y=nxinstance.parameter('divergenceV'),
-                        geometry=NXoff.from_wedge(**pars).to_nexus())
+    col_pars = dict(divergence_x=nxinstance.parameter('divergence'), divergence_y=nxinstance.parameter('divergenceV'))
+    return nxinstance.make_nx(NXcollimator, OFF_GEOMETRY=NXoff.from_wedge(**pars).to_nexus(),
+                              **resolve_parameter_links(col_pars))
 
 
 def diskchopper_translator(nxinstance):
@@ -90,7 +92,7 @@ def diskchopper_translator(nxinstance):
     nslit, delta = mpars['nslit'], mpars['theta_0'] / 2.0
     slit_edges = [y * 360.0 / nslit + x for y in range(int(nslit)) for x in (-delta, delta)]
     nx_slit_edges = [nxinstance.expr2nx(se) for se in slit_edges]
-    return nxinstance.make_nx(NXdisk_chopper, slit_edges=NXfield(nx_slit_edges, units='degrees'), **pars)
+    return nxinstance.make_nx(NXdisk_chopper, slit_edges=NXfield(nx_slit_edges, units='degrees'), **resolve_parameter_links(pars))
 
 
 def elliptic_guide_gravity_translator(nxinstance):
@@ -116,6 +118,8 @@ def elliptic_guide_gravity_translator(nxinstance):
         z = x * p['l']
         vertices.extend([[-w, -h, z], [-w, h, z], [w, h, z], [w, -h, z]])
 
+    # These are only the guide faces (that is, the inner faces of the sides of the guide housing)
+    # The entry and exit are not guide faces and therefore are NOT represented here!
     for i in range(n):
         j0, j1, j2, j3, j4, j5, j6, j7 = [4 * i + k for k in range(8)]
         faces.extend([[j0, j1, j5, j4], [j1, j2, j6, j5], [j2, j3, j7, j6], [j3, j0, j4, j7]])
@@ -123,22 +127,22 @@ def elliptic_guide_gravity_translator(nxinstance):
     nx_vertices = [[nxinstance.expr2nx(expr) for expr in vector] for vector in vertices]
     nx_faces = [[nxinstance.expr2nx(expr) for expr in face] for face in faces]
 
-    return NXguide(geometry=NXoff(nx_vertices, nx_faces).to_nexus())
+    return NXguide(OFF_GEOMETRY=NXoff(nx_vertices, nx_faces).to_nexus())
 
 
 def monitor_translator(nxinstance):
-    from nexusformat.nexus import NXmonitor
+    from nexusformat.nexus import NXmonitor, NXdata
     from moreniius.nxoff import NXoff
     from moreniius.utils import NotNXdict
     from json import loads
     width = nxinstance.nx_parameter('xwidth')
     height = nxinstance.nx_parameter('yheight')
     geometry = NXoff.from_wedge(l=0.005, w1=width, h1=height)
-    nx_monitor = NXmonitor(geometry=geometry.to_nexus())
+    nx_monitor = NXmonitor(OFF_GEOMETRY=geometry.to_nexus())
     if len(nxinstance.obj.metadata):
         # look for mimetype 'application/json' and check if it is NeXus Structure data stream:
         for md in nxinstance.obj.metadata:
             if md.mimetype == 'application/json' and md.name == 'nexus_structure_stream_data':
-                nx_monitor['data'] = NotNXdict(loads(md.value))
+                nx_monitor['data'] = NXdata(data=NotNXdict(loads(md.value)))
 
     return nx_monitor

moreniius/mccode/instance.py

@@ -69,8 +69,9 @@ class NXInstance:
     transforms: dict[str, NXfield]
     only_nx: bool
     nx: Union[None, dict, NXfield] = None
+    dump_mcstas: bool = False
 
-    def parameter(self, name):
+    def parameter(self, name, default=None):
         """
         Pull out a named instance parameter -- if it's value is not a constant, attempt to evaluate it
         using the Instr declare and initialize sections
@@ -78,7 +79,7 @@ class NXInstance:
         par = self.obj.get_parameter(name)
         if par is None:
             log.warn(f'It appears that {self.obj.type.name} does not define the parameter {name}')
-            return None
+            return default
 
         expr = par.value
         # log.info(f'get parameter {name} which is {par}  and expr {repr(expr)}')
@@ -99,9 +100,9 @@ class NXInstance:
     def expr2nx(self, expr: Expr):
         return self.instr.expr2nx(expr)
 
-    def nx_parameter(self, name):
+    def nx_parameter(self, name, default=None):
         """Retrieve the named instance parameter and convert to a NeXus compatible value"""
-        return self.expr2nx(self.parameter(name))
+        return self.expr2nx(self.parameter(name, default))
 
     def make_nx(self, nx_class, *args, **kwargs):
         return self.instr.make_nx(nx_class, *args, **kwargs)
@@ -111,7 +112,8 @@ class NXInstance:
         from nexusformat.nexus import NXtransformations
         from moreniius.utils import outer_transform_dependency, mccode_component_eniius_data
         self.nx = getattr(self, self.obj.type.name, self.default_translation)()
-        self.nx['mcstas'] = dumps({'instance': str(self.obj), 'order': self.index})
+        if self.dump_mcstas:
+            self.nx['mcstas'] = dumps({'instance': str(self.obj), 'order': self.index})
         if self.transforms:
             self.nx['transformations'] = NXtransformations(**self.transforms)
             most_dependent = outer_transform_dependency(self.nx['transformations'])

moreniius/mccode/instr.py

@@ -78,4 +78,12 @@ class NXInstr:
     def make_nx(self, nx_class, *args, **kwargs):
         nx_args = [self.expr2nx(expr) for expr in args]
         nx_kwargs = {name: self.expr2nx(expr) for name, expr in kwargs.items()}
+        # logged parameters are sometimes requested as NXfield objects, but should be links to the real NXlog
+        if nx_class == NXfield and len(nx_args) == 1 and isinstance(nx_args[0], NXcollection) and \
+                'expression' in nx_args[0]:
+            not_expr = [x for x in nx_args[0] if x != 'expression']
+            if len(not_expr) == 1:
+                return nx_args[0][not_expr[0]]
+            else:
+                raise RuntimeError('Not sure what I should do here')
         return nx_class(*nx_args, **nx_kwargs)

moreniius/mccode/mccode.py

@@ -57,7 +57,10 @@ class NXMcCode:
         from nexusformat.nexus import NXinstrument
         nx = NXinstrument()  # this is a NeXus class
         nx['mcstas'] = self.nx_instr.to_nx()
-        for name in self.indexes:
-            nx[name] = self.component(name, only_nx=only_nx).nx
+        # hack the McCode component index into the name of the NeXus group
+        width = len(str(max(self.indexes.values())))
+        for name, index in self.indexes.items():
+            nx_name = f'{index:0{width}d}_{name}'
+            nx[nx_name] = self.component(name, only_nx=only_nx).nx
 
         return nx

moreniius/moreniius.py

@@ -17,7 +17,7 @@ class MorEniius:
                     ):
         from nexusformat.nexus import NXfield
         from .mccode import NXMcCode, NXInstr
-        nxlog_root = nxlog_root or ''
+        nxlog_root = nxlog_root or '/entry/parameters'
         nx_mccode = NXMcCode(NXInstr(instr, nxlog_root=nxlog_root), origin_name=origin)
         nxs_obj = nx_mccode.instrument(only_nx=only_nx)
         nxs_obj['name'] = NXfield(value=instr.name)

moreniius/nexus_structure.py

@@ -34,7 +34,7 @@ def convert():
     import argparse
     parser = argparse.ArgumentParser(description='Convert an Instr (HDF5) or .instr (text) file to an equivalent NeXus Structure JSON string')
     parser.add_argument('filename', type=str, help='the file to convert')
-    parser.add_argument('--format', type=str, default='json', help='the output format, either json or pickle')
+    parser.add_argument('--format', type=str, default='json', help='the output format, currently only json')
     args = parser.parse_args()
     instr = load_instr(args.filename)
     structure = to_nexus_structure(instr)

moreniius/utils.py

@@ -161,6 +161,9 @@ def link_specifier(name: str, source: str) -> NotNXdict:
         source: str
             the target of the link, the location in the eventual NeXus file where the source of data resides
 
+    Reference:
+    https://gitlab.esss.lu.se/ecdc/ess-dmsc/kafka-to-nexus/-/blob/main/documentation/commands.md?ref_type=heads#links
+
     Examples:
     To produce the link in the following NeXus JSON structure, one would use this function
         {
@@ -189,3 +192,19 @@ def link_specifier(name: str, source: str) -> NotNXdict:
     >>> link_specifier('detector0_event_data', '/entry/instrument/detector_panel_0/event_data')
     """
     return ess_flatbuffer_specifier('link', {'name': name, 'source': source})
+
+
+def resolve_parameter_links(instance_parameters: dict):
+    """Component instances have NeXus base class equivalents that require specifying any number of parameters.
+    Sometimes the McCode parameters are instrument-parameters, which may only be specified at runtime.
+    These component parameters are detectable and should already be replaced by NXfield objects holding NotNXdict
+    objects, in turn specifying the file-writer link module that points to their real NXlog dataset.
+    If the link is singular, it should have its name replaced by the NeXus class parameter so that NeXus programs
+    recognize it correctly.
+    """
+    from nexusformat.nexus import NXfield
+    for name, par in instance_parameters.items():
+        if isinstance(par, NXfield) and isinstance(par.nxdata, NotNXdict) and 'link' == par.nxdata.value['module']:
+            par.nxdata.value['config']['name'] = name
+
+    return instance_parameters

{moreniius-0.1.10.dist-info → moreniius-0.2.1.dist-info}/METADATA

@@ -1,14 +1,14 @@
 Metadata-Version: 2.1
 Name: moreniius
-Version: 0.1.10
+Version: 0.2.1
 Author-email: Gregory Tucker <gregory.tucker@ess.eu>
 Classifier: License :: OSI Approved :: BSD License
 Classifier: Development Status :: 2 - Pre-Alpha
 Description-Content-Type: text/markdown
 Requires-Dist: zenlog ==1.1
 Requires-Dist: platformdirs ==3.11
-Requires-Dist: mccode-antlr[hdf5] ==0.5.3
-Requires-Dist: nexusformat ==1.0.2
+Requires-Dist: mccode-antlr[hdf5] ==0.7.0
+Requires-Dist: nexusformat ==1.0.6
 Requires-Dist: importlib-metadata ; python_version < "3.8"
 
 # moreniius

moreniius-0.2.1.dist-info/RECORD

@@ -0,0 +1,18 @@
+moreniius/__init__.py,sha256=33SUBkXWhH5rog5oaGJr1Kwqjhwz97w4E0Da7rArYi4,154
+moreniius/additions.py,sha256=6Hhhc4LDUsnBj27Iil-EFFzQm1xd2M45hfcVQYEjxiI,17615
+moreniius/moreniius.py,sha256=cU3CrfMC1kOnHO77yq5sZfDqRuA38G5kA3RUXFNGP2U,1455
+moreniius/nexus_structure.py,sha256=i9CxYwJl4eKP9IIYR80MI3f54Yh0RPDFviZaulE5IOc,1709
+moreniius/nxoff.py,sha256=WHp9wYNn_4Hcx8Nzi9rpX1p8_iwI-AdgTQouSAEG8N4,3288
+moreniius/utils.py,sha256=3REIM3nJ3L0PVpIWqu0Kh-znK1ggNNYTCjXatoaAA34,8075
+moreniius/writer.py,sha256=DOwzpDqoXiDXdtV-hRZVtF5lNBBoYy0UO5_bq89d1lc,6325
+moreniius/mccode/__init__.py,sha256=1QiZdh90G3gp_WlVpdJB_ZGauoW0GJEQ13Nelaqa5JE,151
+moreniius/mccode/comp.py,sha256=uR1L5nLfYPHhMKd3XnDbqf5xhkfwfPLRnttREc3jqBg,7382
+moreniius/mccode/instance.py,sha256=4nqJ3ne6yXCEvsa3FIKUcGDYP_z7cAr46JhakDTB6qs,8055
+moreniius/mccode/instr.py,sha256=3BdfYzZnHhCokFQIwp7XUEy9nt6CclqAWunHXfGW228,4363
+moreniius/mccode/mccode.py,sha256=6NEXovuG-6itzlPgPklNOiZQ-MlldKF20p4TxV8n4BA,3228
+moreniius/mccode/orientation.py,sha256=_jyTtabo3ZHujuXead0elZzcCck_v8UwX5tIMp4dXwI,3199
+moreniius-0.2.1.dist-info/METADATA,sha256=IDriQtt4mIeEtG6mTYHH-i860X52N4IGuaO2Y04kGX0,625
+moreniius-0.2.1.dist-info/WHEEL,sha256=UvcQYKBHoFqaQd6LKyqHw9fxEolWLQnlzP0h_LgJAfI,91
+moreniius-0.2.1.dist-info/entry_points.txt,sha256=Ga3k4P4fyBt5_dJ03Oapic2Qlgqv9jufQGdxWiz_j2A,63
+moreniius-0.2.1.dist-info/top_level.txt,sha256=RzMo23UfVhgQeuOYeS5P9I0qVbxx4Gbe6Roc29Mr02c,10
+moreniius-0.2.1.dist-info/RECORD,,

{moreniius-0.1.10.dist-info → moreniius-0.2.1.dist-info}/WHEEL

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

moreniius-0.1.10.dist-info/RECORD

@@ -1,18 +0,0 @@
-moreniius/__init__.py,sha256=33SUBkXWhH5rog5oaGJr1Kwqjhwz97w4E0Da7rArYi4,154
-moreniius/additions.py,sha256=maJXirPwtcETy5nE99dUVlngRZQdq7ynXOwb8MoOPvs,10507
-moreniius/moreniius.py,sha256=tT5JGdhnR19tZ8VPnjNLjcJAQDoapGdfDHvARvAvNTE,1438
-moreniius/nexus_structure.py,sha256=62QckSfg8m8PN0FMN5JNdOotunZzOmbj2rujIr0lUIo,1711
-moreniius/nxoff.py,sha256=WHp9wYNn_4Hcx8Nzi9rpX1p8_iwI-AdgTQouSAEG8N4,3288
-moreniius/utils.py,sha256=mI8SQ0JTqWKKC0RTmiD6z5O0R4t79riACVrMxjx9at0,7010
-moreniius/writer.py,sha256=DOwzpDqoXiDXdtV-hRZVtF5lNBBoYy0UO5_bq89d1lc,6325
-moreniius/mccode/__init__.py,sha256=1QiZdh90G3gp_WlVpdJB_ZGauoW0GJEQ13Nelaqa5JE,151
-moreniius/mccode/comp.py,sha256=7lev6_5P83YHQP9uat5x75m1XuoIRulxUXAg_RG5094,6955
-moreniius/mccode/instance.py,sha256=4jlVliEcGgG81SAJPffThXGKo-8wsbziq6jKbr0fjiQ,7952
-moreniius/mccode/instr.py,sha256=wixWLvOWPOq4pcwVL9olo1-tteJaPkUDFR9GRZLTtrM,3872
-moreniius/mccode/mccode.py,sha256=KQopQNiOi18bP_MQEYkAAd2AIhIFiVUx3gqVl0peWk8,3032
-moreniius/mccode/orientation.py,sha256=_jyTtabo3ZHujuXead0elZzcCck_v8UwX5tIMp4dXwI,3199
-moreniius-0.1.10.dist-info/METADATA,sha256=zjeEO883fEH9vALPsdC-9I6sJiRdEFJ6wFnW0tNnb1A,626
-moreniius-0.1.10.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-moreniius-0.1.10.dist-info/entry_points.txt,sha256=Ga3k4P4fyBt5_dJ03Oapic2Qlgqv9jufQGdxWiz_j2A,63
-moreniius-0.1.10.dist-info/top_level.txt,sha256=RzMo23UfVhgQeuOYeS5P9I0qVbxx4Gbe6Roc29Mr02c,10
-moreniius-0.1.10.dist-info/RECORD,,