mcstas-readout-master 0.3.3__tar.gz

mcstas_readout_master-0.3.3/.github/workflows/docs.yml

@@ -0,0 +1,49 @@
+name: Documentation
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+concurrency:
+  group: "docs-${{ github.ref }}"
+  cancel-in-progress: true
+
+jobs:
+  build:
+    name: Build static docs
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Install Doxygen
+        run: sudo apt-get update && sudo apt-get install -y doxygen
+
+      - name: Configure
+        run: cmake -S . -B build -DREADOUT_DOCS_ONLY=ON
+
+      - name: Generate docs
+        run: cmake --build build --target docs -j2
+
+      - name: Upload Pages artifact
+        uses: actions/upload-pages-artifact@v4
+        with:
+          path: build/docs/html
+
+  deploy:
+    name: Deploy to GitHub Pages
+    if: github.event_name != 'pull_request'
+    needs: build
+    runs-on: ubuntu-latest
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    steps:
+      - id: deployment
+        uses: actions/deploy-pages@v4

mcstas_readout_master-0.3.3/.github/workflows/main.yml

@@ -0,0 +1,112 @@
+name: Main
+
+on:
+  push:
+  pull_request:
+
+concurrency:
+  group: "${{ github.workflow }}-${{ github.event.pull_request.head.repo.full_name || github.repository }}-${{ github.head_ref || github.ref_name }}"
+  # supersede in-flight runs on branches/PRs, but let every main run finish
+  cancel-in-progress: ${{ github.ref_name != 'main' }}
+
+jobs:
+  cmake_and_ctest:
+    name: "CMake & CTest, ${{ matrix.cmake-type }} ${{ matrix.variant.os }}, py${{ matrix.python-version }}"
+    runs-on: ${{ matrix.variant.os }}
+    defaults:
+      run:
+        shell: bash -l {0}
+    strategy:
+      fail-fast: false
+      matrix:
+        variant:
+          - { os: ubuntu-latest} 
+          - { os: macos-26-intel}     
+          - { os: macos-26}    
+          - { os: windows-latest} 
+        python-version: ["3.12"]
+        cmake-type: ["Debug", "Release"]
+
+    steps:
+      - name: Setup Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install Python-based dependencies
+        run: |
+          python -m pip install conan numpy mccode-antlr
+          echo "pythonInterpreter=`which python`" >> $GITHUB_ENV
+
+      - name: Cache conan setup
+        id: conan-cache-key
+        run: |
+          echo "key=$(/bin/date -u "+%Y%m%d")" >> $GITHUB_OUTPUT
+          echo "path=$(conan config home)" >> $GITHUB_OUTPUT
+
+      - name: Cache conan
+        uses: actions/cache@v6
+        with:
+          path: ${{ steps.conan-cache-key.outputs.path }}
+          key: conan-${{ matrix.variant.os }}-${{ steps.conan-cache-key.outputs.key }}
+
+      - uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+          fetch-tags: true
+
+      - name: configure
+        run: cmake -S . -B build -D CMAKE_BUILD_TYPE=${{ matrix.cmake-type }} -D Python3_EXECUTABLE=${{ env.pythonInterpreter }}
+
+      - name: build
+        run: cmake --build build --config ${{ matrix.cmake-type }} -j
+
+      - name: test
+        working-directory: build
+        run: ctest -C ${{ matrix.cmake-type }} --verbose -j
+
+  integration_tests:
+    name: "Python integration tests, ${{ matrix.variant.os }} ${{ matrix.mpi }}"
+    runs-on: ${{ matrix.variant.os }}
+    needs: cmake_and_ctest
+    defaults:
+      run:
+        shell: bash -l {0}
+    strategy:
+      fail-fast: false
+      matrix:
+        variant:
+          - { os: ubuntu-latest }
+        mpi: [ 'mpich', 'openmpi', 'intelmpi']
+        python-version: ["3.12"]
+
+    steps:
+      - name: Setup Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Setup MPI
+        uses: mpi4py/setup-mpi@v1
+        with:
+          mpi: ${{ matrix.mpi }}
+
+      - name: Install system dependencies
+        run: sudo apt-get update && sudo apt-get install -y libhdf5-dev
+
+      - name: Install Python-based dependencies
+        run: |
+          python -m pip install conan numpy mccode-antlr pytest h5py
+
+      - uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+          fetch-tags: true
+
+      - name: Build with development mode
+        run: |
+          cmake -S . -B build-dev
+          cmake --build build-dev -j
+
+      - name: Run integration tests
+        run: python -m pytest tests/ -v --tb=short

mcstas_readout_master-0.3.3/.github/workflows/wheels.yml

@@ -0,0 +1,68 @@
+name: Wheels
+
+on:
+  pull_request:
+  release:
+    types: [created, edited, published]
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: ${{ github.event.action == 'published' }}
+
+jobs:
+  source:
+    name: Build source distribution
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+      - run: pipx run build --sdist
+      - run: pipx run twine check dist/*
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist-sdist
+          path: dist/*.tar.gz
+
+  cibuildwheel:
+    name: "Wheels for ${{ matrix.variant.platform }} on ${{ matrix.variant.os }}"
+    runs-on: ${{ matrix.variant.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        variant:
+          - { os: ubuntu-latest, platform: 'manylinux' }
+          - { os: macos-15-intel, platform: 'macosx' }
+          - { os: macos-15, platform: 'macosx' }
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+      - uses: pypa/cibuildwheel@v3.1.4
+        env:
+          CIBW_BUILD: "*-${{ matrix.variant.platform }}*"
+          MACOSX_DEPLOYMENT_TARGET: "14"
+      - name: Verify clean directory
+        run: git diff --exit-code
+        shell: bash
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist-${{ matrix.variant.os }}
+          path: wheelhouse/*.whl
+
+  publish:
+    name: Publish to PyPI
+    needs: [source, cibuildwheel]
+    if: github.event_name == 'release' && github.event.action == 'published'
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: dist-*
+          merge-multiple: true
+          path: dist
+      - uses: pypa/gh-action-pypi-publish@release/v1

mcstas_readout_master-0.3.3/.gitignore

@@ -0,0 +1,64 @@
+*.py[cod]
+*~
+MANIFEST
+
+# C extensions
+*.so
+*.so.*
+*.lo
+*.o
+python/src
+
+# Packages
+*.egg
+*.egg-info
+
+# Installer logs
+pip-log.txt
+
+# Unit test / coverage reports
+.coverage
+.tox
+nosetests.xml
+
+# Translations
+*.mo
+
+# Mr Developer
+.mr.developer.cfg
+.project
+.pydevproject
+
+# Doc
+.buildinfo
+.doctrees
+*.db
+api/
+.doctree
+pages/
+
+# Various build directories
+*build
+*dist
+cmake-build*
+
+# Built version header
+*/version.hpp
+
+# Pipenv environment files
+Pipfile
+Pipfile.lock
+.snakemake
+.status_flag*
+
+# CLion
+.idea/
+
+# devtools generated directories
+devtools/conan
+devtools/wheelhouse
+*.comp.json
+*build-dev
+*tmp
+test_*.c
+references/

mcstas_readout_master-0.3.3/AGENT.md

@@ -0,0 +1,44 @@
+# Description
+This repository contains library functionality for collecting simulated readouts from a McStas
+neutron raytracing runtime and replaying them, statistically correctly, to ESS Event Formation
+Units (EFUs) after the fact — decoupling the simulation runtime from the data-acquisition
+pipeline.
+
+Collection happens through the `Collector{ReadoutType}.comp` component family (CAEN, TTLMonitor,
+CDT, VMM3, BM0, BM2, BMI in share/Readout/). Each component stores whole records through the
+description-based collector engine: the C-struct layout of one record is described by a canonical
+string (lib/readout_type_descriptions.h) parsed at runtime into an HDF5 compound datatype.
+Multiple components write independent named groups into one file, each with the cue-based layout
+`readouts`, `cues`, `weights`, `normalizations`, managed by the singleton CollectorSink
+(lib/CollectorClass.h), which also records instrument parameters. Routing information lives as
+group attributes: the detector identity (from the component's ess_type — it becomes the ESS
+packet-type byte that EFUs filter on at replay) and optional EFU address/port. The record layout
+itself carries no attributes: it is the dataset's own compound datatype.
+
+Users can collect arbitrary additional data by passing their own struct-description string to the
+same engine (`Collector(filename, name, description)` in C++, `collector_star_new` from C); such
+groups are readable and combinable but not EFU-sendable. EFU-sendability is decided by exact
+datatype comparison against the registry (`hdf_compound_type`), never by attributes — an
+attribute cannot lie about the record layout, and an anti-drift unit test pins the canonical
+description strings to the C++ event structs.
+
+Files from repeated or scanned simulation points are combined with the `readout-combine` CLI
+(validate / append / concatenate) into one multi-point file. The Reader/ReaderSource classes
+(lib/reader.h) provide access to points, records, weights, and parameters. `readout-replay`
+(lib/replay.h) steps through the points in a file, publishes each point's parameters through the
+ParameterPublisher interface (EPICS transport plugs in from outside the library), draws
+`n ~ Poisson(w * counting_time)` events per stored readout, and routes them to per-(detector,
+readout) EFU endpoints resolved from explicit configuration, file-embedded attributes, or
+defaults — in that precedence order.
+
+# Current state
+All of the above is implemented and tested (ctest plus mccode-antlr run tests per component).
+The legacy per-ray Readout broadcasting components (ReadoutCAEN, ReadoutTTLMonitor,
+ReadoutDiscreteCAEN) remain for in-simulation streaming use cases.
+
+# Remaining work
+1. EPICS implementation of ParameterPublisher (lives outside this repository; mccode-plumber).
+   The interface contract and implementation requirements are written down in
+   ParameterPublisher.md.
+2. Consider a fixed-count replay mode ("exactly N events") using the retained WRSWR reservoir
+   sampler (lib/IndexSampler.h, lib/ctream).

mcstas_readout_master-0.3.3/CLAUDE.md

@@ -0,0 +1,52 @@
+# 2026-07-04 Status
+
+This project is the interface between the simulation world (McStas based) and the ESS data
+acquisition world (EPICS, Kafka and the EFU). The redevelopment from runtime event streaming
+to decoupled collect → combine → replay is **complete**; see AGENT.md for the architecture
+and PLAN.md for how it got here.
+
+In one paragraph: `Collector{ReadoutType}.comp` components (readout_core/components/) store
+weighted-ray records into cue-based multi-point HDF5 files through a description-based engine
+(a C-struct description string parsed to an HDF5 compound datatype at runtime; canonical
+strings in readout_core/include/readout_type_descriptions.h). Files are combined with the
+`readout-combine` CLI (validate/append/concatenate) and replayed with `readout-replay`, which
+steps through points, publishes each point's parameters through the ParameterPublisher
+interface (EPICS transport is external — see ParameterPublisher.md), draws
+`n ~ Poisson(w * counting_time)` events per stored readout, and routes them to EFUs resolved
+from explicit config > file-embedded attributes > defaults. EFU-sendability of a collector
+group is decided by exact datatype comparison against the registry (`hdf_compound_type`),
+never by attributes, and an anti-drift test pins the canonical descriptions to the C++ event
+structs.
+
+## Layout
+
+- `readout_core/` — the installed package: `include/` (public headers), `src/`, `components/`
+  (McStas `.comp` files plus lib-readout.c/h), `app_config/`, `app_combine/`, `app_replay/`.
+- `test/` — C++ unit tests (repository root, mcpl-style, not installed).
+- `tests/` — pytest McStas-toolchain tests (mccode-antlr compile/run).
+- `docs/` — Doxygen-based site: guide pages, `Doxyfile.in`, `extract_comp_docs.py` (generates
+  per-component markdown from the McDoc headers in the `.comp` files), `theme/`
+  (vendored doxygen-awesome-css). Published via `.github/workflows/docs.yml` → GitHub Pages.
+- `examples/` — runnable collect → combine → replay walkthrough.
+
+## Building and testing
+
+- The `build/` and `build-dev/` directories are configured with the conan **Debug** generators
+  and `-DREADOUT_DEVELOPMENT_MODE=ON` (see DEVELOPMENT.md). Do not reconfigure with different
+  flags; if needed: `cmake -S . -B build -DCMAKE_BUILD_TYPE=Debug -DREADOUT_DEVELOPMENT_MODE=ON`.
+- C++ tests: `cmake --build build -j8 && cd build && ctest`.
+- McStas toolchain tests: `python3 -m pytest tests/` — these prefer `build-dev/` over `build/`
+  (tests/conftest.py), so rebuild **both** directories first or you will test stale binaries.
+- After changing a `.comp` file, delete any stale `readout_core/components/*.comp.json` caches
+  so mccode-antlr re-parses.
+- Documentation: `cmake -S . -B <scratch> -DREADOUT_DOCS_ONLY=ON && cmake --build <scratch>
+  --target docs` (needs doxygen; no conan, no compiled targets).
+
+## Remaining / external work
+
+1. EPICS implementation of ParameterPublisher — requirements in ParameterPublisher.md; the
+   transport lives in mccode-plumber, not here.
+2. Optional: fixed-count replay mode ("exactly N events") on the retained WRSWR reservoir
+   sampler (readout_core/src/IndexSampler.h, readout_core/src/ctream), and paced replay
+   (events spread over the counting time) if downstream consumers need realistic wall-clock
+   intervals.

mcstas_readout_master-0.3.3/CMakeLists.txt

@@ -0,0 +1,119 @@
+cmake_minimum_required(VERSION 3.30)
+cmake_policy(SET CMP0076 NEW) # Ensure target_sources converts relative paths
+cmake_policy(SET CMP0017 NEW) # Prefer cmake's own files for include/find_package before CMAKE_MODULE_PATH
+
+list(INSERT CMAKE_MODULE_PATH 0 "${CMAKE_CURRENT_LIST_DIR}/cmake")
+
+set(READOUT_BUILD_ON_CONDA OFF CACHE BOOL "Set to ON to build for conda")
+set(READOUT_USE_CONAN ON CACHE BOOL "Use Conan to manage dependencies") # Set to OFF to use system libraries
+set(READOUT_BUILD_TESTS ON CACHE BOOL "Build test binary")
+set(READOUT_DOCS_ONLY OFF CACHE BOOL "Configure only the documentation target (no dependencies, no compiled targets)")
+
+if (READOUT_DOCS_ONLY)
+    # Documentation needs only the version string and Doxygen: skip dependency
+    # resolution and every compiled target so a bare runner can configure.
+    set(READOUT_USE_CONAN OFF)
+    set(READOUT_BUILD_TESTS OFF)
+endif()
+
+if (READOUT_USE_CONAN)
+    set(CMAKE_PROJECT_TOP_LEVEL_INCLUDES "${CMAKE_CURRENT_LIST_DIR}/cmake/conan_provider.cmake")
+endif()
+
+# Read the version of readout (from the VERSION file and git metadata);
+# generates version.hpp in ${CMAKE_BINARY_DIR}/gen
+include(check)
+checkSetup(READOUT)
+message(STATUS "Build Readout v${READOUT_VERSION} with type ${CMAKE_BUILD_TYPE}")
+project(Readout LANGUAGES C CXX VERSION "${READOUT_VERSION}")
+
+set(CMAKE_C_STANDARD 17)
+set(CMAKE_CXX_STANDARD 23)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+include(GNUInstallDirs)
+
+# The build tree mirrors the install layout (bin/, lib/, include/, share/Readout)
+# so that the self-locating readout-config resolves the same baked relative paths
+# whether it runs from the build tree or an installed prefix. Multi-config
+# generators (Visual Studio) would otherwise add per-config subdirectories
+# (bin/Debug/...), breaking those relative paths — collapse them: one
+# configuration per build tree.
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_BINDIR}")
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR}")
+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR}")
+foreach(READOUT_CFG IN ITEMS Debug Release RelWithDebInfo MinSizeRel)
+    string(TOUPPER "${READOUT_CFG}" READOUT_CFG_UP)
+    set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_${READOUT_CFG_UP} "${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_BINDIR}")
+    set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_${READOUT_CFG_UP} "${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR}")
+    set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_${READOUT_CFG_UP} "${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR}")
+endforeach()
+
+add_definitions(-DUSE_HIGHFIVE)
+if (MSVC)
+    # warning level 4 -- add /WX for all warnings as errors
+    add_compile_options(/W4)
+    # suppress MSVC warning C4996 about 'localtime' vs 'localtime_s'
+    add_definitions(-D_CRT_SECURE_NO_WARNINGS)
+    # Allow UTF-8 identifiers https://stackoverflow.com/a/47704050
+    add_compile_options("$<$<C_COMPILER_ID:MSVC>:/utf-8>")
+    add_compile_options("$<$<CXX_COMPILER_ID:MSVC>:/utf-8>")
+    # Prevent Windows.h from defining its own min and max macros
+    add_definitions(-DNOMINMAX)
+elseif(APPLE)
+    add_compile_options(-Wall -Wextra -pedantic)
+    if (READOUT_BUILD_ON_CONDA)
+        # Enable use of, e.g. std::filesystem::path on macOS under Conda:
+        # https://conda-forge.org/docs/maintainer/knowledge_base/#newer-c-features-with-old-sdk
+        add_definitions(-D_LIBCPP_DISABLE_AVAILABILITY)
+    endif()
+else()
+    add_compile_options(-Wall -Wextra -pedantic)
+endif()
+
+if(NOT CMAKE_BUILD_TYPE)
+    set(CMAKE_BUILD_TYPE Debug)
+endif(NOT CMAKE_BUILD_TYPE)
+if (${CMAKE_BUILD_TYPE} STREQUAL "Debug")
+    add_definitions(-DDEBUG)
+endif()
+
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+# With GCC 10+ the interprocedural optimization only adds to compilation time without improving performance
+set(CMAKE_INTERPROCEDURAL_OPTIMIZATION FALSE)
+
+if (READOUT_BUILD_TESTS)
+    include(CTest)
+endif()
+
+if (NOT READOUT_DOCS_ONLY)
+    # The library, CLI tools, McStas components, and install rules:
+    add_subdirectory(readout_core)
+
+    # The test suite lives at the repository root (mcpl-style): it exercises the
+    # readout_core targets but is not part of any installed package.
+    if (READOUT_BUILD_TESTS)
+        add_subdirectory(test)
+    endif()
+endif()
+
+find_package(Doxygen QUIET)
+if (DOXYGEN_FOUND)
+    find_package(Python3 COMPONENTS Interpreter REQUIRED)
+    configure_file(
+        "${CMAKE_CURRENT_LIST_DIR}/docs/Doxyfile.in"
+        "${CMAKE_BINARY_DIR}/Doxyfile"
+        @ONLY
+    )
+    add_custom_target(docs
+        COMMAND "${Python3_EXECUTABLE}" "${CMAKE_CURRENT_LIST_DIR}/docs/extract_comp_docs.py"
+                "${CMAKE_CURRENT_LIST_DIR}/readout_core/components"
+                "${CMAKE_BINARY_DIR}/docs/generated"
+        COMMAND "${DOXYGEN_EXECUTABLE}" "${CMAKE_BINARY_DIR}/Doxyfile"
+        WORKING_DIRECTORY "${CMAKE_BINARY_DIR}"
+        COMMENT "Generating static HTML documentation with Doxygen"
+        VERBATIM
+    )
+else()
+    message(STATUS "Doxygen not found: docs target will not be available")
+endif()

mcstas_readout_master-0.3.3/DEVELOPMENT.md

@@ -0,0 +1,73 @@
+# Development guide
+
+## Layout
+
+The repository follows the mcpl pattern (see layout_plan.md): everything that
+installs lives in `readout_core/` — library sources in `src/`, public headers
+in `include/`, the CLI tools in `app_config`/`app_replay`/`app_combine`, the
+McStas components in `components/` — while the root CMakeLists.txt only wires
+up toolchain options and the repo-level test suite in `test/` and `tests/`.
+
+## Building
+
+```bash
+cmake -S . -B build -DCMAKE_BUILD_TYPE=Debug
+cmake --build build -j
+```
+
+Dependencies (HighFive, HDF5, nlohmann_json, Catch2) come through Conan by
+default (`READOUT_USE_CONAN=ON`); pass `-DREADOUT_USE_CONAN=OFF` to use system
+packages instead.
+
+There are no build modes: **the build tree mirrors the install layout**
+(`bin/`, `lib/`, `include/`, `share/Readout/`), and `readout-config` resolves
+every resource path relative to its own binary through one set of baked
+relative paths. The same binary therefore works unchanged from the build tree,
+an installed prefix, or (later) a wheel — and the build tree is directly
+usable by mccode-antlr:
+
+```bash
+$ build/bin/readout-config --show compdir
+/home/user/project/build/share/Readout
+```
+
+This replaces the former `READOUT_DEVELOPMENT_MODE` option and the
+`run_tests.sh` wrapper, which existed to work around PATH-inheritance problems
+when McStas tools spawned `readout-config`; putting `build/bin` on PATH is all
+that is needed now.
+
+## Testing
+
+```bash
+cd build && ctest                     # C++ unit tests + CLI smoke + integration
+python3 -m pytest tests/             # mccode-antlr compile/run tests
+```
+
+## Documentation
+
+Install Doxygen, then generate the static HTML site locally. Use a dedicated
+build directory with `READOUT_DOCS_ONLY=ON` — it skips conan and every
+compiled target, so it configures anywhere without touching your development
+build directories:
+
+```bash
+cmake -S . -B build-docs -DREADOUT_DOCS_ONLY=ON
+cmake --build build-docs --target docs
+```
+
+The generated site is written to `build-docs/docs/html/`. The `docs` target
+first runs `docs/extract_comp_docs.py`, which turns the McDoc headers
+(`%I`/`%D`/`%P` sections) of `readout_core/components/*.comp` into markdown
+pages — keep those headers up to date when changing component parameters.
+The same headers make the components readable with McStas's `mcdoc`. The site
+is published by `.github/workflows/docs.yml` on pushes to `main` (GitHub Pages
+must be set to deploy from GitHub Actions in the repository settings).
+
+The pytest suite discovers a build directory by looking for
+`<dir>/bin/readout-config` in `build-dev`, `build`, `cmake-build-debug`,
+`cmake-build-release` (in that order — rebuild every directory you keep, or
+remove the stale ones, before trusting pytest results). The ctest
+`integration` test skips (exit 100) when `mcstas-antlr` is not installed.
+
+After editing a `.comp` file, delete any stale `*.comp.json` caches next to it
+and the `~/.cache/mccodeantlr` directory so mccode-antlr re-parses.

mcstas_readout_master-0.3.3/LICENSE

@@ -0,0 +1,11 @@
+Copyright 2025 Gregory Tucker, European Spallation Source ERIC
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.