moreniius 0.6.3__tar.gz → 0.8.0__tar.gz

{moreniius-0.6.3/src/moreniius.egg-info → moreniius-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: moreniius
-Version: 0.6.3
+Version: 0.8.0
 Author-email: Gregory Tucker <gregory.tucker@ess.eu>
 Classifier: License :: OSI Approved :: BSD License
 Classifier: Development Status :: 2 - Pre-Alpha
@@ -14,8 +14,8 @@ Classifier: Programming Language :: Python :: 3.14
 Description-Content-Type: text/markdown
 Requires-Dist: zenlog>=1.1
 Requires-Dist: platformdirs>=3.11
-Requires-Dist: mccode-antlr[hdf5]>=0.17.0
-Requires-Dist: nexusformat>=1.0.6
+Requires-Dist: mccode-antlr[hdf5]>=0.17.2
+Requires-Dist: nexusformat>=2.0.0
 Requires-Dist: networkx
 
 # moreniius

{moreniius-0.6.3 → moreniius-0.8.0}/pyproject.toml

@@ -7,8 +7,8 @@ name = "moreniius"
 dependencies = [
     'zenlog>=1.1',
     'platformdirs>=3.11',
-    'mccode-antlr[hdf5]>=0.17.0',
-    'nexusformat>=1.0.6',
+    'mccode-antlr[hdf5]>=0.17.2',
+    'nexusformat>=2.0.0',
     'networkx'
 ]
 readme = "README.md"

{moreniius-0.6.3 → moreniius-0.8.0}/src/moreniius/mccode/instance.py

@@ -122,6 +122,9 @@ class NXInstance:
                 if not hasattr(self.nx[name], 'depends_on'):
                     self.nx[name].attrs['depends_on'] = most_dependent
                 most_dependent = outer_transform_dependency(self.nx['transformations'])
+            # Note: the depends_on entry for NX class objects is an optional dataset
+            #       in the HDF5 group. Tools like chexus can verify its presence and
+            #       scippnexus only uses the dataset member of a group for this.
             self.nx['depends_on'] = f'transformations/{most_dependent}'
 
     def get_nx_type(self):
@@ -131,7 +134,7 @@ class NXInstance:
             return COMPONENT_CATEGORY_TO_NEXUS[self.obj.type.category]
         if any(self.obj.type.name.startswith(x) for x in COMPONENT_GROUP_TO_NEXUS):
             return [t for k, t in COMPONENT_GROUP_TO_NEXUS.items() if self.obj.type.name.startswith(k)][0]
-        return 'NXnote'
+        return 'NXcoordinate_system' if self.transforms else 'NXnote'
 
     def default_translation(self):
         import nexusformat.nexus as nexus

{moreniius-0.6.3 → moreniius-0.8.0}/src/moreniius/mccode/instr.py

@@ -53,7 +53,19 @@ class NXInstr:
         return NXfield(str(self.instr))
 
     def expr2nx(self, expr: Union[str, Expr, Any]):
-        from moreniius.utils import link_specifier
+        """Intended to convert *Expr* objects to NeXus-representable objects"""
+        # FIXME this is called to wrap and re-wrap the same data
+        #       during translation of a component with properties. It may be worth
+        #       separating the parameter and component functionality.
+        from moreniius.utils import link_specifier, NotNXdict
+        from nexusformat.nexus import NXlog
+        if hasattr(expr, '_value') and isinstance(getattr(expr, '_value'), NotNXdict):
+            # Avoid unwrapping the non-NX dictionary at this stage since it is
+            # silently converted to a string-like thing which as an __iter__ property
+            return expr
+        if isinstance(expr, NXlog):
+            # Do not decompose a value if we already wrapped it in NXlog
+            return expr
         if not isinstance(expr, str) and hasattr(expr, '__iter__'):
             parts = [self.expr2nx(x) for x in expr]
             return tuple(parts) if isinstance(expr, tuple) else parts
@@ -68,6 +80,10 @@ class NXInstr:
             return evaluated.value
 
         dependencies = [par.name for par in self.instr.parameters if evaluated.depends_on(par.name)]
+        if len(dependencies) == 1 and str(expr) == str(dependencies[0]):
+            from moreniius.utils import linked_nxlog
+            return linked_nxlog(f'{self.nxlog_root}/{dependencies[0]}')
+
         if len(dependencies):
             log.warn(f'The expression {expr} depends on instrument parameter(s) {dependencies}\n'
                      f'A link will be inserted for each; make sure their values are stored at {self.nxlog_root}/')
@@ -77,36 +93,53 @@ class NXInstr:
         return str(expr)
 
     def make_nx(self, nx_class, *args, **kwargs):
+        from nexusformat.nexus import NXlog
+        from moreniius.utils import NotNXdict
         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']
+
+        # logged parameters are sometimes requested as NXfields, but should be NXlogs
+        want_log = nx_class == NXfield and len(nx_args) == 1
+        nx_arg = nx_args[0] if want_log else None
+        if want_log and isinstance(nx_arg, NXlog):
+            # The NXlog returned by expr2nx doesn't have the needed attributes:
+            for k, v in nx_kwargs.items():
+                nx_arg.attrs[k] = v
+            return nx_arg
+        # Hopefully less often, a collection of links in an NXcollection
+        if want_log and isinstance(nx_arg, NXcollection) and 'expression' in nx_arg:
+            not_expr = [x for x in nx_arg if x != 'expression']
             if len(not_expr) == 1:
-                not_expr_arg = nx_args[0][not_expr[0]]
-                # if isinstance(not_expr_arg, NXfield):
-                #     # We have and want an NXfield, but it might be missing attributes specified in the nx_kwargs
-                #     # Passing the keywords to the NXfield constructor versus this method is not identical,
-                #     # since some keyword arguments are reserved (and only some of which are noted)
-                #     #   Explicit keywords, used in the constructor:
-                #     #       value, name, shape, dtype, group, attrs
-                #     #   Keywords extracted from the kwargs dict, if present (and all controlling HDF5 file attributes?):
-                #     #       chunks, compression, compression_opts, fillvalue, fletcher32, maxshape, scaleoffset, shuffle
-                #     # For now, just assume all keywords provided here are _actually_ attributes for the NXfield
-                #     # which is an extension of a dict, but can *not* use the update method, since the __setitem__
-                #     # method is overridden to wrap inputs in NXattr objects :/
-                #     for k, v in nx_kwargs.items():
-                #         not_expr_arg.attrs[k] = v
-                #     return not_expr_arg
+                arg = nx_arg[not_expr[0]]
+                if isinstance(arg, NXfield):
+                    # if this is a link, we should not add any attributes
+                    # since the filewriter will ignore them
+                    if hasattr(arg, '_value') and isinstance(d:=getattr(arg, '_value'), NotNXdict) and d.get('module', '') == 'link':
+                        return arg
+                    # We have and want an NXfield, but it might be missing attributes specified in the nx_kwargs
+                    # Passing the keywords to the NXfield constructor versus this method is not identical,
+                    # since some keyword arguments are reserved (and only some of which are noted)
+                    #   Explicit keywords, used in the constructor:
+                    #       value, name, shape, dtype, group, attrs
+                    #   Keywords extracted from the kwargs dict, if present (and all controlling HDF5 file attributes?):
+                    #       chunks, compression, compression_opts, fillvalue, fletcher32, maxshape, scaleoffset, shuffle
+                    # For now, just assume all keywords provided here are _actually_ attributes for the NXfield
+                    # which is an extension of a dict, but can *not* use the update method, since the __setitem__
+                    # method is overridden to wrap inputs in NXattr objects :/
+                    for k, v in nx_kwargs.items():
+                        arg.attrs[k] = v
+                    return arg
 
                 # TODO make this return an nx_class once we're sure that nx_kwargs is parseable (no mccode_antlr.Expr)
-                if all(x in not_expr_arg for x in ('module', 'config')):
+                if all(x in arg for x in ('module', 'config')):
                     # This is a file-writer stream directive? So make a group
-                    return NXgroup(entries={not_expr[0]: not_expr_arg}, **nx_kwargs)
+                    grp = NXgroup(entries={not_expr[0]: arg})
+                    for attr, val in nx_kwargs.items():
+                        grp.attrs[attr] = val
+                    return grp
                 print('!!')
-                print(not_expr_arg)
-                return nx_class(not_expr_arg, **nx_kwargs)
+                print(arg)
+                return nx_class(arg, **nx_kwargs)
             else:
                 raise RuntimeError('Not sure what I should do here')
         return nx_class(*nx_args, **nx_kwargs)

moreniius-0.8.0/src/moreniius/mccode/mccode.py

@@ -0,0 +1,154 @@
+from nexusformat.nexus import NXfield
+from zenlog import log
+from dataclasses import dataclass, field
+from networkx import DiGraph
+from typing import Union
+from mccode_antlr.instr import Orient
+from .instr import NXInstr
+
+log.level('error')
+
+@dataclass
+class NXMcCode:
+    nx_instr: NXInstr
+    origin_name: Union[str, None] = None
+    indexes: dict[str, int] = field(default_factory=dict)
+    orientations: dict[str, Orient] = field(default_factory=dict)
+    graph: Union[DiGraph, None] = None
+    reversed_graph: Union[DiGraph, None] = None
+
+    def __post_init__(self):
+        from copy import deepcopy
+
+        for index, instance in enumerate(self.nx_instr.instr.components):
+            self.indexes[instance.name] = index
+            # only absolute-positioned or rotated component orientations are needed
+            if instance.at_relative[1] is None or instance.rotate_relative[1] is None:
+                self.orientations[instance.name] = deepcopy(instance.orientation)
+
+        # Attempt to re-center all component dependent orientations on the sample
+        found = (
+            (lambda x: self.origin_name == x.name)
+            if self.origin_name else
+            (lambda x: 'samples' == x.type.category)
+        )
+        possible_origins = [instance for instance in
+                            self.nx_instr.instr.components if found(instance)]
+        if not possible_origins:
+            msg = '"sample" category components' if self.origin_name is None else f'component named {self.origin_name}'
+            log.warn(f'No {msg} in instrument, using ABSOLUTE positions')
+        elif self.origin_name is not None and len(possible_origins) > 1:
+            log.error(f'{len(possible_origins)} components named {self.origin_name}; using the first')
+        elif len(possible_origins) > 1:
+            log.warn(f'More than one "sample" category component. Using {possible_origins[0].name} for origin name')
+        if possible_origins:
+            self.origin_name = possible_origins[0].name
+            # find the position _and_ rotation of the origin
+            origin = possible_origins[0].orientation
+            # remove this from all (absolute) components (re-centering on the origin)
+            for name, orientation in self.orientations.items():
+                self.orientations[name] = orientation - origin
+
+        if self.graph is None:
+            self.graph = self.build_graph()
+        if self.reversed_graph is None:
+            self.reversed_graph = self.graph.reverse(copy=True)
+
+    def transformations(self, name) -> dict[str, NXfield]:
+        from mccode_antlr.instr.orientation import Vector, Angles, Parts
+        from .orientation import NXOrient, NXParts
+
+        def abs_ref(ref):
+            # FIXME find a better way to ensure this is correct
+            return f'/entry/instrument/{ref}'
+
+        def last_ref(refs: list[tuple[str, NXfield]]) -> str | None:
+            try:
+                return next(reversed(refs))[0]
+            except StopIteration:
+                pass
+
+        at_vec, at_rel = self.nx_instr.instr.components[self.indexes[name]].at_relative
+        rot_ang, rot_rel = self.nx_instr.instr.components[self.indexes[name]].rotate_relative
+
+        nx_orientation = None
+        if at_rel is None or rot_rel is None:
+            nx_orientation = NXOrient(self.nx_instr, self.orientations[name])
+
+        if at_rel is None and rot_rel is None:
+            # ABSOLUTE definition, so we pull information from self.orientations
+            # since we had to remove the (possibly different) origin
+            return nx_orientation.transformations(name)
+
+        trans = []
+        if at_rel is not None and rot_rel is not None and at_rel == rot_rel:
+            at_vec = Vector(*at_vec) if isinstance(at_vec, tuple) else at_vec
+            rot_ang = Angles(*rot_ang) if isinstance(rot_ang, tuple) else rot_ang
+            at_parts = Parts.from_at_rotated(at_vec, Angles(), True)
+            rot_parts = Parts.from_at_rotated(Vector(), rot_ang, True)
+            nx_parts = NXParts(self.nx_instr, at_parts, rot_parts)
+            trans.extend(nx_parts.transformations(name, abs_ref(at_rel.name)))
+        else:
+            raise RuntimeError("All mixed reference-type orientations untested. "
+                               "Only 'AT (x, y, z) ABSOLUTE ROTATE (a, b, c) REF' might work")
+        # elif at_rel is None:
+        #     # absolute position with relative rotation
+        #     trans.extend(nx_orientation.position_transformations(name))
+        #     # Get the _rotation_ of the reference to add here before any new rotation
+        #     # FIXME this can only work if rot_rel.name is in self.orientations!
+        #     rel_ori = NXOrient(self.nx_instr, self.orientations[rot_rel.name])
+        #     trans.extend(rel_ori.rotation_transformations(rot_rel.name, last_ref(trans)))
+        #     # Now add our relative rotation onto the referenced rotation
+        #     rot_ang = Angles(*rot_ang) if isinstance(rot_ang, tuple) else rot_ang
+        #     rot = Parts(Parts.from_at_rotated(Vector(), rot_ang, True).stack()).reduce()
+        #     nx_parts = NXParts(self.nx_instr, rot, rot)
+        #     trans.extend(nx_parts.rotation_transformations(name, last_ref(trans)))
+        # elif rot_rel is None:
+        #     # relative position with absolute rotations
+        #     raise RuntimeError("I can not handle this yet")
+        # else:
+        #     # relative position and rotation but different references.
+        #     raise RuntimeError("I cnat no handle this ytet")
+
+        return {k: v for k, v in trans}
+
+    def inputs(self, name):
+        """Return the other end of edges ending at the named node"""
+        return list(self.reversed_graph[name])
+
+    def outputs(self, name):
+        """Return the other end of edges starting at the named node"""
+        return list(self.graph[name])
+
+    def component(self, name, only_nx=True):
+        """Return a NeXus NXcomponent corresponding to the named McStas component instance"""
+        from .instance import NXInstance
+        instance = self.nx_instr.instr.components[self.indexes[name]]
+        transformations = self.transformations(name)
+        nxinst = NXInstance(self.nx_instr, instance, self.indexes[name], transformations, only_nx=only_nx)
+        if transformations and nxinst.nx['transformations'] != transformations and name in self.orientations:
+            # if the component modifed the transformations group, make sure we don't use our version again
+            del self.orientations[name]
+        if len(inputs := self.inputs(name)):
+            nxinst.nx.attrs['inputs'] = inputs
+        if len(outputs := self.outputs(name)):
+            nxinst.nx.attrs['outputs'] = outputs
+        return nxinst
+
+    def instrument(self, only_nx=True):
+        from nexusformat.nexus import NXinstrument
+        nx = NXinstrument()  # this is a NeXus class
+        nx['mcstas'] = self.nx_instr.to_nx()
+        for name in self.indexes.keys():
+            nx[name] = self.component(name, only_nx=only_nx).nx
+
+        return nx
+
+    def build_graph(self):
+        # FIXME expand this to a full-description if/when McCode includes graph information
+        graph = DiGraph()
+        names = [x.name for x in self.nx_instr.instr.components]
+        graph.add_nodes_from(names)
+        # By default, any McCode instrument is a linear object:
+        graph.add_edges_from([(names[i], names[i+1]) for i in range(len(names)-1)])
+        return graph

{moreniius-0.6.3 → moreniius-0.8.0}/src/moreniius/mccode/orientation.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from zenlog import log
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from mccode_antlr.instr import Orient, Parts, Part
 from nexusformat.nexus import NXfield
 from .instr import NXInstr
@@ -73,27 +73,52 @@ class NXParts:
     position: Parts
     rotation: Parts
 
-    def transformations(self, name: str) -> list[tuple[str, NXfield]]:
-        nxt = []
-        dep = '.'
-        for index, o in enumerate(self.position.stack()):
-            nxt.extend(NXPart(self.instr, o).transformations(f'{name}_t{index}', dep))
-            dep = nxt[-1][0] if len(nxt) and len(nxt[-1]) else '.'
-        for index, o in enumerate(self.rotation.stack()):
-            nxt.extend(NXPart(self.instr, o).transformations(f'{name}_r{index}', dep))
-            dep = nxt[-1][0] if len(nxt) and len(nxt[-1]) else '.'
-        return nxt
+    def _transformations(self, name: str, dep: str, typ: str, stack):
+        nx_transformations = []
+        for i, op in enumerate(stack):
+            parts = NXPart(self.instr, op).transformations(f'{name}_{typ}{i}', dep)
+            nx_transformations.extend(parts)
+            if len(parts) and len(parts[-1]):
+                dep = parts[-1][0]
+        return nx_transformations
+
+    def position_transformations(self, name: str, dep: str | None = None ) -> list[tuple[str, NXfield]]:
+        dep = dep or '.'
+        return self._transformations(name, dep, 't', self.position.stack())
+
+    def rotation_transformations(self, name: str, dep: str | None = None) -> list[tuple[str, NXfield]]:
+        dep = dep or '.'
+        return self._transformations(name, dep, 'r', self.rotation.stack())
+
+    def transformations(self, name: str, dep: str | None = None) -> list[tuple[str, NXfield]]:
+        parts = self.position_transformations(name, dep=dep)
+        # If there were any positioning transformations, we need to update
+        # the dependency chained name, otherwise it should stay the same
+        dep = parts[-1][0] if len(parts) and len(parts[-1]) else dep
+        return parts + self.rotation_transformations(name, dep=dep)
 
 
 @dataclass
 class NXOrient:
     instr: NXInstr
     do: Orient
+    nx_parts: NXParts | None = None
 
-    def transformations(self, name: str) -> dict[str, NXfield]:
+    def __post_init__(self):
         # collapse all possible chained orientation information
         # But keep the rotations and translations separate
         pos, rot = self.do.position_parts(), self.do.rotation_parts()
         # make an ordered list of the requisite NXfield entries
-        nxt = NXParts(self.instr, pos, rot).transformations(name)
-        return {k: v for k, v in nxt}
+        self.nx_parts = NXParts(self.instr, pos, rot)
+
+    def transformations(self, name: str) -> dict[str, NXfield]:
+        # make an ordered list of the requisite NXfield entries, and turn it into a dict
+        return {k: v for k, v in self.nx_parts.transformations(name)}
+
+    def position_transformations(self, name: str, dep: str | None = None) -> list[tuple[str, NXfield]]:
+        return self.nx_parts.position_transformations(name, dep)
+
+    def rotation_transformations(self, name: str, dep: str | None = None) -> list[tuple[str, NXfield]]:
+        return self.nx_parts.rotation_transformations(name, dep)
+
+

{moreniius-0.6.3 → moreniius-0.8.0}/src/moreniius/utils.py

@@ -1,5 +1,5 @@
 from mccode_antlr.instr import Instance
-from nexusformat.nexus import NXevent_data, NXfield
+from nexusformat.nexus import NXevent_data, NXfield, NXlog
 
 class NotNXdict:
     """Wrapper class to prevent NXfield-parsing of the held dictionary"""
@@ -16,6 +16,10 @@ class NotNXdict:
         from json import dumps
         return dumps(self.value)
 
+    def get(self, item, default=None):
+        return self.value.get(item, default)
+
+
 
 def outer_transform_dependency(transformations):
     """For a NXtransformations group, find the most-dependent transformation name
@@ -175,6 +179,26 @@ def ev44_event_data_group(source: str, topic: str) -> NXevent_data:
     return NXevent_data(data=ess_flatbuffer_specifier('ev44', {'source': source, 'topic': topic}))
 
 
+def nxlog_data_links(source: str):
+    """
+    Return link module specifications for the datasets inserted by a f144 module
+    """
+    datasets = (
+        'alarm_message', 'alarm_severity', 'alarm_time', 'average_value',
+        'connection_status', 'connection_status_time', 'cue_index',
+        'cue_timestamp_zero', 'description', 'maximum_value', 'minimum_value',
+        'time', 'value'
+    )
+    return {k: link_specifier(k, f'{source}/{k}') for k in datasets}
+
+
+def linked_nxlog(source: str, attrs: dict | None = None) -> NXlog:
+    nxlog = NXlog(**nxlog_data_links(source))
+    if attrs:
+        nxlog.attrs.update(attrs)
+    return nxlog
+
+
 def link_specifier(name: str, source: str) -> NotNXdict:
     """
     Constructs a specifier to insert a NeXus link into an ESS produced NeXus file

{moreniius-0.6.3 → moreniius-0.8.0/src/moreniius.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: moreniius
-Version: 0.6.3
+Version: 0.8.0
 Author-email: Gregory Tucker <gregory.tucker@ess.eu>
 Classifier: License :: OSI Approved :: BSD License
 Classifier: Development Status :: 2 - Pre-Alpha
@@ -14,8 +14,8 @@ Classifier: Programming Language :: Python :: 3.14
 Description-Content-Type: text/markdown
 Requires-Dist: zenlog>=1.1
 Requires-Dist: platformdirs>=3.11
-Requires-Dist: mccode-antlr[hdf5]>=0.17.0
-Requires-Dist: nexusformat>=1.0.6
+Requires-Dist: mccode-antlr[hdf5]>=0.17.2
+Requires-Dist: nexusformat>=2.0.0
 Requires-Dist: networkx
 
 # moreniius

{moreniius-0.6.3 → moreniius-0.8.0}/src/moreniius.egg-info/SOURCES.txt

@@ -23,6 +23,8 @@ src/moreniius/mccode/instance.py
 src/moreniius/mccode/instr.py
 src/moreniius/mccode/mccode.py
 src/moreniius/mccode/orientation.py
+tests/bifrost.instr.json
+tests/test_bifrost_nexus_structure.py
 tests/test_elliptic_guide_gravity.py
 tests/test_motorized_positions.py
 tests/test_nexus_structure.py

moreniius-0.8.0/src/moreniius.egg-info/requires.txt

@@ -0,0 +1,5 @@
+zenlog>=1.1
+platformdirs>=3.11
+mccode-antlr[hdf5]>=0.17.2
+nexusformat>=2.0.0
+networkx