niess.nexus¶

def literal(self, value):
    """Reduce a value -- or an iterable of them -- to plain JSON-able data.

    Used for attribute values such as transformation vectors, which have no
    node of their own to carry a link and so must fold to constants.
    """
    from mccode_antlr.common import Expr

    if isinstance(value, Expr):
        resolved = self.resolve(value)
        return expression.literal_value(resolved, str(value))
    if isinstance(value, str):
        return value
    if hasattr(value, '__iter__'):
        return [self.literal(item) for item in value]
    return value

def resolve_target(self, rel) -> str | None:
    """The absolute path a relative placement should depend on."""
    node = self.nodes.get(rel.name)
    if node is None:
        raise RuntimeError(f'transformations for {rel.name} defined out of order')
    # The path uses the name the group was *written* under, which a translator may
    # have overridden; self.nodes stays keyed by the McStas instance name, because
    # that is what a placement refers to.
    target = f'{INSTRUMENT_PATH}/{node_name(node)}' 
    if rel.name in self.suppressed:
        # The chain still resolves, but nothing will be written at that path
        logger.warning(
            f'{rel.name} is placed relative to a suppressed component; the emitted '
            'depends_on path will not exist in the written file'
        )

    depends_on = None
    for child in node.get('children') or []:
        if node_name(child) == 'depends_on' and child.get('module') == 'dataset':
            depends_on = child['config'].get('values')
            break
    if depends_on is None:
        return None
    if depends_on.startswith('/'):
        return depends_on
    return None if depends_on == '.' else f'{target}/{depends_on}'

def frame_rotation(self, instance):
    """The turn a component's emitted frame carries that the object's does not.

    ``None`` when there is none, which is everything but a disc chopper today.
    """
    provenance = NiessProvenance.from_instance(instance)
    if provenance is None:
        return None
    rotvec = provenance.extra.get('mccode_frame_rotation')
    if not rotvec or not any(abs(float(a)) > 0 for a in rotvec):
        return None
    return [float(a) for a in rotvec]

def frame_offset(self, instance):
    """The displacement a component's emitted origin carries that the object's does not.

    ``None`` when there is none, which is everything but a disc chopper today.
    """
    provenance = NiessProvenance.from_instance(instance)
    if provenance is None:
        return None
    offset = provenance.extra.get('mccode_frame_offset')
    if not offset or not any(abs(float(v)) > 0 for v in offset):
        return None
    return [float(v) for v in offset]

def resolve(self, name: str, default=None):
    """Resolve a named instance parameter to a literal or a link description."""
    parameter = self.instance.get_parameter(name)
    if parameter is None:
        logger.debug(f'{self.type_name} does not define the parameter {name}')
        return expression.Literal(default)
    return self.context.resolve(parameter.value)

def parameter(self, name: str, default=None, dtype=None):
    """The literal value of a parameter, or ``default`` if it is not constant."""
    resolved = self.resolve(name, default=default)
    value = expression.literal_value(resolved, default)
    if dtype is not None and value is not None:
        try:
            return dtype(value)
        except (TypeError, ValueError):
            return default
    return value

def parameter_node(
        self,
        name: str,
        source: str | None = None,
        dtype=None,
        attrs: dict | None = None,
):
    """A node for a parameter: dataset when constant, link group when not.

    ``dtype`` coerces a constant value only -- a runtime-linked parameter has
    no value here to coerce.
    """
    resolved = self.resolve(source or name)
    if dtype is not None and isinstance(resolved, expression.Literal):
        try:
            resolved = expression.Literal(dtype(resolved.value))
        except (TypeError, ValueError):
            pass
    return expression.parameter_node(name, resolved, attrs=attrs)

def siblings_in_group(self) -> list:
    """Instances sharing this one's ``nexus_group_id`` provenance tag, in order."""
    if self.provenance is None:
        return []
    group_id = self.provenance.extra.get('nexus_group_id')
    if group_id is None:
        return []

    found = []
    for instance in self.instr.components:
        other = NiessProvenance.from_instance(instance)
        if other is not None and other.extra.get('nexus_group_id') == group_id:
            found.append((other.extra.get('nexus_group_index', 0), instance))
    return [instance for _, instance in sorted(found, key=lambda pair: pair[0])]

@classmethod
def from_wedge(cls, l, w1, h1, w2=None, h2=None):
    """A trapezoidal prism, origin at the centre of the entry face, +z downbeam."""
    if w2 is None:
        w2 = w1
    if h2 is None:
        h2 = h1
    x1, y1, x2, y2 = (float(v) / 2 for v in (w1, h1, w2, h2))
    vertices = [
        [-x1, -y1, 0], [-x1, y1, 0], [x1, y1, 0], [x1, -y1, 0],
        [-x2, -y2, l], [-x2, y2, l], [x2, y2, l], [x2, -y2, l],
    ]
    # Clockwise winding, facing out
    faces = [
        [0, 1, 2, 3], [1, 5, 6, 2], [5, 4, 7, 6],
        [6, 7, 3, 2], [7, 4, 0, 3], [1, 0, 4, 5],
    ]
    return cls(vertices, faces)