.. Generated by docs/check_changelog.py from changelog.d. .. Edit the fragment, not this file. Added ----- - The binding-overhead session times each language wrapper of read, k-nearest neighbours, q6 with q6bar, CHILL, and primitive rings on ice Ih, and records the median and interquartile range. - A CI job compiles the library sources PydSEAMSlib and dseams-r build under Clang 22 with ``-Wsign-conversion -Wunneeded-internal-declaration -Werror``, once without OpenMP or any optional backend and once with them, and builds those libraries with ``-Dwerror=true``. The compiler-warnings workflow also runs on ``release/**`` branches. - The installed C library reads frames from arrays and files. Callers can build neighbour lists and primitive rings, evaluate q3, q4, q6, and q6-bar, and run CHILL, CHILL+, cages, the shell classifier, and the brine front. ``seams.pc`` and ``seams-config.cmake`` ship with the library, and ``examples/c`` builds against that install. - ``Frame.cages_by_signature`` takes ``edge``, and Lua ``dseams.cages_by_signature`` reads ``edge`` from its options table. Both call the same window as ``--cage-edge``: empty keeps ``2.65,3.15``, and ``none`` leaves the cage bound to the face census. The C entry for the libseams path is ``seams_signature_cages_edge``. ``seams_frame_signature_vertices_edge`` returns the vertices of that window. - ``capi_abi_2_13`` holds ``libseams_lang``, the C interface of the 2.13.0 release (``seams_lang.h``), to that release's ABI: it compares a debug build of the library with the libabigail corpus in ``scripts/abi_2.13.0_seams_lang.abi``, passes functions added since, and fails on a removed function or a changed signature. ``capi_abi_2_13_selftest`` edits copies of the corpus to prove both failures are caught. The ``capi-abi`` CI job runs both. Without ``abidiff`` they are skipped. - ``capi_abi`` compares libseams type by type with the 2.14.0 ABI 1 corpus through libabigail's ``abidiff`` when it is installed, and passes only added functions. The ``abi`` pixi environment provides ``abidiff``, and the ``capi-abi`` CI job uses it. Without ``abidiff``, or with one too old to read the corpus, that step is skipped. - Julia, R, and C++ call the analyses ``seams.h`` now exports. Julia uses ``ccall`` on ``libseams``. R keeps the ``libseams_lang`` frame API and adds a C shim. ``seams.hpp`` is a header-only RAII wrapper whose exceptions carry ``seams_handle_error``. - The Rust, Fortran, and Python ctypes bindings call the analyses ``seams.h`` now exports, including frame reading, CHILL, Steinhardt parameters, cages, neighbour lists, the RDF, hydrogen bonds, density, the fingerprint, prisms, and the monolayer. - ``capi_docs_complete`` fails when a function in ``tests/capi_symbols.txt`` lacks a ``seams.h`` doc comment with a brief, every parameter, the return codes, thread safety, and ownership for pointer arguments, or when its C API page section is missing or differs from that comment. ``capi_docs_selftest`` removes each of those pieces from a copy of the header or page and requires the check to report it. - ``docs/examples/c/`` holds one short C program per C API family: neighbours, rings, CHILL+, q4 and q6, cages, and errors. Each checks its own results on the in-tree ice Ih fixture, and ``capi_example_`` compiles it as C11 with ``-Wall -Wextra -Wpedantic -Werror`` and runs it. The C API page includes all six. - C API: ``seams_system_set_positions`` overwrites the coordinates, and optionally the cell, of a stored frame, and ``seams_system_box``, ``seams_system_positions``, ``seams_system_types``, and ``seams_system_ids`` copy the stored frame back out through a const handle. ``seams_system_set_atoms`` reuses the storage of the frame it replaces, and keeps the id index when the ids are 1 to n, so loading 110592 atoms costs about the same as building the frame in C++. - ``-Dcapi_fuzz_coverage=true`` instruments this project's code for libFuzzer under clang, so the fuzzers see coverage inside ``libseams`` and not only in the harness. Subprojects stay uninstrumented, so their examples link without a sanitizer runtime; with sanitizers or coverage on, clang links the shared libraries with ``-z undefs`` and leaves the runtime's symbols to the executable. - ``capi_installed_examples`` installs libseams into a staging directory and builds the six family examples in ``docs/examples/c`` out of tree against it, once with the flags from ``pkg-config seams`` and once through ``find_package(seams)`` with the new ``docs/examples/c/CMakeLists.txt``, both as C11 with ``-Wall -Wextra -Wpedantic -Werror``. Every binary must load the installed ``libseams.so`` and pass its own checks. - ``seams_c_last_stages`` returns the wall seconds of the last ``seams_cutoff_csr`` or ``seams_ql_cutoff`` call on the calling thread, split into point-cloud conversion, cutoff-list build, q_l and copy-out. - ``capi_reload_fuzzer`` drives ``seams_system_set_atoms``, ``seams_system_set_positions`` and ``seams_system_stage_positions`` with random atom counts, NULL pointers, wrong lengths, NaN and infinite values in both reload modes, and reads the frame back after every call. Under clang the libFuzzer harnesses are built with ``-fsanitize=fuzzer`` and the ``capi_sanitize`` sanitizer. - ``-Dcapi_sanitize=address,undefined`` builds the C API suite under ASan and UBSan at once, and every UBSan build also checks float-to-int overflow, which GCC leaves out of ``-fsanitize=undefined``. - C API: ``seams_last_error_message``, ``seams_system_natoms``, ``seams_neighbours_nrows``, ``seams_rings_nrings``, and the length-checked ``seams_chill_plus_n``, ``seams_q4q6_n``, ``seams_rings_labels_n``, and ``seams_rings_histogram_n``. Every public declaration in ``seams.h`` now has a Doxygen block with parameters, ownership, thread safety, and an example. - ``bench/capi_thread_scale.txt`` records ``capi_thread_scale`` on a release build. At 8 threads the cutoff-list build is about 60% of ``seams_ql_cutoff`` and 74% of ``seams_cutoff_csr``, and the serial point-cloud conversion about 15% and 18%. - ``capi_thread_scale`` runs ``seams_cutoff_csr`` and ``seams_ql_cutoff`` at 1, 2, 4 and 8 OpenMP threads on 110592-molecule ice Ic, requires every width to return the one-thread bytes, and logs the per-stage times. - Saved trajectories other than CON are read with chemfiles, including xyz, a LAMMPS dump, gro, pdb, dcd, xtc and Amber NetCDF. A selection expression names water oxygen and hydrogen. The dependency is optional and on by default. - Every target, tests, benchmarks, bindings, engines and subproject examples included, builds under Clang 21 with ``-Dwerror=true``, and a CI job builds that configuration and runs the suite on it. - Add pinned head-to-heads of 5^12 cages against ClavisCage TRACE and of q4, q6 and coordination against PLUMED. - A top-level Comparisons page links the OVITO FindRings, freud, SQQ, and PLUMED head-to-head results already recorded in this book. - A linux-64 pixi environment, ``cycles``, holds Python 3.13 and ``bpy`` 5.3 for the Cycles molecule stills. ``pixi install -e cycles`` is enough: ``render_molecules.py`` finds that interpreter without ``MOLECULES_BPY``. ``docs_render_molecules`` exits 77 only when no interpreter imports ``bpy``. The environment adds lock entries and leaves the default environment's solve alone. - ``meson test --suite engines-e2e`` runs each engine for 200 steps on ice and liquid (mW in LAMMPS and in LAMMPS with ``fix plumed``, TIP4P/Ice in GROMACS, in ``gmx mdrun -plumed`` and in OpenMM), dumps the coordinates d-SEAMS classified in the run with their labels, and requires ``seams chill-plus`` to give the same label to every site of every frame. An engine that is not found is a skip. The Snakemake rule ``engines_e2e`` writes ``data/engines-e2e.csv``. - CI builds each engine plugin against the conda-forge engine and runs its ``engines-e2e`` tests, with LAMMPS on one and two ranks; a skip fails the job. The PLUMED checks take the ``libplumedKernel.so`` beside ``plumed`` when ``PLUMED_KERNEL`` is unset, and ``gromacs_plumed_e2e`` reads the action log from ``PLUMED.OUT`` under GROMACS 2025 and later. C and Fortran snippets link against the patched chemfiles meson builds when the system one is rejected. - The mW front speed was measured again under the other readings of L and tau, under Lechner-Dellago q6, on the three faces, and at a 5 fs step. The one-front speed is a quarter of Espinosa et al. Table I at both 240 K and 260 K, and it matches the primary-prism markers in Shi et al., J. Chem. Phys. 162, 054714 (2025), Figure 3. Equation 2 is unchanged. - The secondary-prism speed is reported under equation 2 and under the solid-count slope, on the 4000-molecule cell. The 2015 CHILL+ thresholds are unchanged. - Local q4 and q6 on the cutoff shell use the solid-harmonic kernel from ``seams steinhardt``, ``seams_q4_q6``, and the Python, R, and Julia ``q4_q6`` fronts. - ``seams_frame_chordless`` lists the chordless cycles of one size on a ``libseams_lang`` frame, with the same rows as ``seams_rings_chordless`` on that frame. ``seams.hpp`` returns them from ``Neighbours::chordless`` and ``rings_chordless``. - Each language front reports rings, cages, signature cages and symmetry, and the binding CI runs those calls. - Every target also builds under GCC 15 in release mode with ``-Dwerror=true``, and a ``gcc15-all`` CI job next to ``clang21-all`` builds that configuration and runs the suite on it. - The mW one-front speed was measured on the basal, primary-prism and secondary-prism faces from 220 K to 265 K. A Wilson-Frenkel curve is fit to the count-slope estimator on each face. - TIP4P/2005 ring updates at 0.01, 0.1 and 1 ps stay inside the hop ball and match a full search. The strict seeded graph is 8.3, 3.3 and 2.6 times a rebuild. - Fortran callers use a ``seams`` module of derived types with final procedures, allocatable results, and an optional ``stat``/``errmsg`` pair (d-SEAMS/dseams-fortran), and Lua callers get a Fennel module, a rockspec, and LDoc comments (d-SEAMS/yodaStruct). The numbers match the existing tests. - ``pydseams`` in ``pydseamslib`` 2.14.0 has the documented Frame handle. ``pydseams.read``, ``from_ase``, ``to_ase``, ``to_solvis``, ``chill_plus``, ``cages``, ``cages_by_signature``, ``steinhardt``, ``rdf_2d``, ``monolayer_rings``, ``find_prisms``, and ``pydseams.band.ring_census`` call ``libseams_lang``. The tutorials keep those calls. - A running molecular dynamics calculation can call the in-situ engine on each frame it chooses. The engine reports the primitive ring census. It also reports the published common neighbour ice labeling (CHILL) labels. The cage flags cover hexagonal and double-diamond cages. LAMMPS, GROMACS, OpenMM, i-PI, and the Atomic Simulation Environment attach through optional adapters. -Dplumed=enabled now errors. Live analysis does not use PLUMED. - Live analysis for LAMMPS, GROMACS, and OpenMM calls the library. The LAMMPS plugin and the in-tree package share one fix. GROMACS uses a module inside mdrun. OpenMM uses a reporter. Chemfiles reads the saved trajectory. - ``interface_order wc`` reports a Willard-Chandler width on the crystal center of mass. ``input/interface/campaign.py`` grows the shipped mW slab at several temperatures and seeds. The 2015 CHILL+ thresholds are unchanged. - ``interface_order`` compares the Nguyen and Molinero 2015 CHILL+ rule with the OVITO 3.17.2 rule on one frame or a short trajectory. The thresholds are unchanged. A square, pentagonal or hexagonal nanotube is labeled by its prism blocks, and a honeycomb sheet by its polygon or bilayer rings. - Meson builds ``compute dseams`` as ``dseamsplugin.so`` for LAMMPS ``plugin load`` when the LAMMPS class headers are installed. The compute takes ``cutoff``, ``graph cutoff|mutual`` and ``rule published|ovito``, and logs its call count and seconds per call when LAMMPS deletes it. - ``-Dlammps_src_include=DIR`` builds ``compute dseams`` against conda-forge LAMMPS, which installs ``library.h`` without the class headers. ``scripts/fetch_lammps_headers.sh DEST`` checks out ``src`` of the release that ``lmp`` reports and prints the directory. - Python, Julia, Rust and Fortran call the C API. Python reads NumPy arrays in place and accepts ASE and MDAnalysis frames. Julia uses ccall. Rust splits the raw FFI from the safe crate. Fortran binds the same symbols with iso_c_binding. - Orthorhombic frames are cut by linkcell's weighted recursive coordinate bisection of the cell grid. The halo is the stencil painted while walking the cells a rank owns, and the same cut is reused on the next frame of that size. Neighbour rows, CHILL+, q6 and primitive rings keep their scratch across that repeat, and the ring search answers a length-2 shortcut that passes below the source. - Add a pinned head-to-head of cutoff neighbours, q4, q6, diamond, rings and local symmetry against mdapy, pyscal3, vesin, IRA and SQQ. - Add optional IRA, SOFI and spglib symmetry reports for ice shells, hydrate cages and rings. - ``require("dseams")`` is a Lua 5.4 and LuaJIT module over ``seams.h``, with userdata handles and a Fennel wrapper on the same module. Reading, CHILL, Steinhardt parameters, cages, neighbour lists, the RDF, hydrogen bonds, density, the fingerprint, prisms, and the monolayer call that header. - The Lua binding (d-SEAMS/yodaStruct) finds the Lua 5.4 module through the ``lua`` pkg-config name that conda-forge and Homebrew use, builds ``dseams_ffi.lua`` by default, and fetches the Fennel 1.5.3 compiler with a checked sha256 when none is installed. - The Rust bindings are the crates ``dseams-sys`` and ``dseams`` (library names ``seams_sys`` and ``seams``), built and published from d-SEAMS/dseams-rs. ``dseams-sys`` compiles a bundled C API by default and links an installed ``libseams`` with the ``system`` feature. The Fortran module is the fpm package ``dseams`` from d-SEAMS/dseams-fortran, and the LuaRocks rock ``dseams`` for Lua 5.1 to 5.4 and LuaJIT comes from d-SEAMS/yodaStruct. Each links an installed ``libseams``; ``ci_packages.yml`` here builds and installs that ``libseams`` prefix. - Direct-coexistence mW growth is scored on basal and secondary-prism slabs of 8064 molecules at 1 bar. The 2015 CHILL+ thresholds are unchanged. - A nucleation-pathway census reports primitive rings by size, both CHILL+ rules, Lechner-Dellago q6-bar, and diamond symmetry labels on every frame. The CHILL+ staggered and eclipsed edges are unchanged. Largest-cluster size and the Ic/Ih fraction are recorded for each definition. ``nucleation-pathway`` writes the table. ``input/nucleation/regenerate.py`` rebuilds the short mW quenches outside the work tree. - Library calls narrow their OpenMP team when other processes hold the cores. Beside an idle resident 8-thread OpenMP team in its default wait, 8-thread CHILL+ on 110592-molecule ice Ic took 74 ms and now takes 7 ms, and the shell match went from 76 to 9 ms, with idle-machine times unchanged. ``SEAMS_FAIR_WIDTH=0`` keeps the requested width. - ``DseamsReporter`` writes its ``dump`` argument: each report appends a LAMMPS dump frame of the classified sites with their CHILL+ labels. ``seconds`` and ``calls`` time the reports. Callers that passed a placeholder name now pass nothing. - Primitive rings are the Franzblau shortest-path census. OVITO FindRings is a subset: K2,3 has three chordless 4-rings and FindRings reports two, and every ring on the 864-atom interface frame at 3.5 Å is primitive. - Meson options ``-Dwith_blas``, ``-Dwith_readcon``, and ``-Dsystem_libseams``. The last builds only the ``dseams`` module against an installed ``libseams``. - A Reproduce the paper catalog lists each seams-core figure and table with the command, the input frame, the printed numbers, and the Snakemake rule or asv class. Small rows run in the suite. Full rows run when ``-Dpaper_full=true``. Each head-to-head names its committed CSV. - ``seams chill`` and ``seams chill-plus`` take ``--per-atom FILE`` and append a LAMMPS dump frame with a ``label`` column, the CHILL or CHILL+ class of each site. Workers under ``--jobs`` append whole frames. - The PLUMED SEAMS collective variable reports q6, the CHILL+ ice fraction and the six-ring fraction, and a restraint can bias q6. - The PLUMED ``SEAMS`` action takes ``MODE=all|q6|q6bar`` and ``DUMP=file``. ``MODE=q6`` and ``MODE=q6bar`` compute only the mean local q6 or the mean q6-bar, without CHILL+ or the ring search. ``DUMP`` appends the coordinates handed to d-SEAMS and the per-atom value, plus the CHILL+ label under ``MODE=all``. - The Snakemake rule ``h2h_plumed_q6`` runs PLUMED's ``Q6``, ``LOCAL_AVERAGE`` and ``LOCAL_Q6`` and d-SEAMS ``q6`` and ``q6bar`` through ``SEAMS`` in ``plumed driver`` on the same mW ice/liquid frames at 4096 and 110592 molecules, serial and with 8 threads, and writes the per-atom agreement and the seconds per frame to ``benchmarks/h2h-plumed-q6.csv``. The asv benchmark ``h2h_plumed_q6`` times the same decks. - The Python Frame reference runs ``read``, ``steinhardt``, ``ring_census``, ``rdf_2d``, ``monolayer_rings``, ``find_prisms``, ``to_ase``, and ``to_solvis`` on ice Ih and shows each result. - seams_frame_q4_q6_chill and the Python wrapper write q4, q6, q4-bar and q6-bar together with the published CHILL+ labels. - The R package ``dseams`` (d-SEAMS/dseams-r) builds as a self-contained source package that carries its own copy of the engine, or links an installed ``libseams_lang`` through ``SEAMS_LIBDIR`` and ``SEAMS_INCLUDE``. The Julia package ``Dseams`` (d-SEAMS/Dseams.jl) takes its engine from ``libseams_jll``, or from the ``libseams_lang`` that ``SEAMS_LANG_LIB`` or ``Dseams.set_library!`` names. ``packaging/yggdrasil/L/libseams`` in this repository is the Yggdrasil recipe for ``libseams_jll``. - One sitting retimes neighbours, q4, q6, CHILL+, rings, symmetry and hydrate cages at 110592 and 884736 molecules on one thread and on eight. The raw lines are benchmarks/rc3-sitting.csv. - Add ``seams_rings_chordless``, which lists every chordless cycle of one size (3 to 12) in a neighbour graph as sorted canonical rows, the same for any thread count, with per-atom counts. It meets two induced half-paths in the middle, and the six-ring census in ``bench/ring_ice.c`` now calls it: 3.1 ms instead of 20.6 ms on 4096 mW molecules, one thread. - ``bench_rings_h2h`` times primitive rings against OVITO FindRings with the cutoff graph outside the timer. A small-graph test checks that census against a brute-force cycle list. - seams rings prints the primitive-ring census by size. seams prisms counts perfect and imperfect prisms of size 3 to 6. seams cluster prints the largest domain, the subset, and whether it percolates. - The ice label is the residual of the seventeen-atom shell after the optimal rotation and scale. The shell is the four bonded neighbours and each of their bonded neighbours. - science::layersOf bins published CHILL+, the shell label and q6 along the interface normal. science::criticalSize is the mean size of the band around the smallest largest cluster. That number is an upper bound when the minimum falls in the first two frames. It is not a committor. - seams.h is ABI 1. A frame carries an orthorhombic or triclinic cell, and the library returns neighbours, both CHILL+ rules, q4 and q6, primitive rings, and ring symmetry labels. - The 884736-molecule sitting adds pyscal3 neighbours and q6, PLUMED q6 with PLUMED_NUM_THREADS set to the row width, and OVITO coordination. Those rows agree with d-SEAMS on the same ice Ic frame. scripts/plot_sitting_large_time.py draws time against threads and does not store the PDF. - One sitting pairs ice Ic at 884736 molecules with freud, mdapy, vesin, OVITO PTM and CHILL+, and rings-statistics-matter, at 1, 2, 4 and 8 threads. The detail column records the agreement check on that frame. The rings row is the cutoff list and the ring search together. The pool-audit rings kernel is ringNetwork alone. - The ice label takes an eclipsed-cosine cutoff, and cage, ring and shell naming runs in parallel. - Each OpenMP thread owns a block of the linkcell weighted cell cut and writes the neighbour rows of those cells. The halo is painted in that owned walk. On 884736 molecules, eight threads build the neighbour rows in 5.72 times the one-thread time. - OpenMM, rings, and cages each have a video slug next to the existing rings-cages slug. Topic pages embed the recording from the same embed.txt as the gallery, using an Odysee /$/embed/ URL when a claim is present and the words video coming soon when it is not. - An ``unsigned-char`` CI job builds every target on x86_64 Linux with ``-funsigned-char`` and runs the suite on it, so code that reads a plain ``char`` as signed fails without an aarch64 runner. - The videos gallery and the README link the d-SEAMS Odysee channel. Every ``docs/videos//script.md`` end card cites Goswami, Goswami, and Singh 2020 and names the 2.0 paper as to be submitted soon. - All nineteen recordings embed their Odysee claims. The cages transcript adds the ice Ih hexagonal-cage census and the cubic double-diamond census, and keeps the clathrate lines. The brine transcript again includes the three-frame front beside the nacl census. The GROMACS ``overhead_s`` timer is machine-dependent. - The rings recording uses the 250-oxygen exampleTraj census and the ice Ih six-ring count. The Rust recording prints the ice Ih census. The GROMACS recording runs gmx-seams after gmx mdrun. A slug with no Odysee claim renders no player. End cards invite questions, issues, discussions, and pull requests. The Python pages show dseams.Frame next to pydseams. - ``recipe/recipe.yaml`` builds ``libseams`` (``libyodaLib``, ``libseams``, ``libseams_lang``, the ``seams`` CLI, headers, pkg-config and CMake files) for conda-forge with rattler-build from the release tag archive. The ``pydseamslib`` wheels and their conda package are built in d-SEAMS/PydSEAMSlib. Changed ------- - Every public symbol of the C headers and the C++ language header is listed in the reference pages with its parameters, return value, ownership, and error behavior. ``docs_api_coverage`` fails when a public symbol is missing from that list or a listed symbol is not in the header. Each binding repository checks its own language the same way. - A repeated neighbourhood builds its bond list once, the first time that ball is seen. - The language bindings move to their own repositories, each released with the seams-core version it binds: Python to d-SEAMS/PydSEAMSlib (``pydseamslib``, ``import dseams`` and ``import pydseams``), Lua and Fennel to d-SEAMS/yodaStruct (LuaRocks ``dseams``), R to d-SEAMS/dseams-r, Julia to d-SEAMS/Dseams.jl, Rust to d-SEAMS/dseams-rs (crates ``dseams-sys`` and ``dseams``), and Fortran to d-SEAMS/dseams-fortran (fpm ``dseams``). seams-core builds the engine, the C API ``libseams``, the C ABI ``libseams_lang``, the ``seams`` CLI and the engine drivers, and releases conda ``libseams`` and the Yggdrasil recipe for ``libseams_jll``. The Meson options ``with_python``, ``with_lua``, ``fennel_lua``, ``with_fortran``, ``julia_wrap``, ``r_libs_user`` and ``system_libseams`` are removed with the bindings they built. The docs run their Python snippets against the installed ``pydseamslib`` of the same version. ``docs/orgmode/contributing/repositories.org`` maps the repositories, the pins and the release order. - The Python and Lua bindings read neighbour lists through ``seams_neighbours_copy`` instead of the deprecated ``seams_neighbours_csr`` borrow, which stays only for ABI 1 callers. - Neighbours, CHILL, CHILL+, rings and cages can keep water oxygens by atom type or by molecule, and leave ions out of that graph. ``seams --mol water`` uses the atom that appears once in a multi-atom molecule. ``seams --mol 1,5-12`` keeps those molecule ids. A type or molecule that is not in the frame is an error. On a LAMMPS dump with multi-atom molecules and no ``--type``, the same choice replaces the old preference for type 2, which labeled hydrogens or sodium. ``compute dseams``, as the LAMMPS plugin and as the copy-in style in ``extras/lammps``, takes ``type I`` and ``mol water`` and scores only those oxygens; the other atoms it is given read 6. A group of several types that sets neither is an error. CHILL+ then reports ``ion-ice``, ``ion-liquid`` and ``ion-front`` when ions remain in the frame. - The C API version macros come from the project version at build time. This release is 2.14.0. - The hexagonal-cage sweep in ``seams cages`` runs across the threads. One thread and several threads mark the same rings. - The seeded cage binding searches one graph when the mutual and union edge sets match. A dirty cage frame starts the backoff before it returns, so the following frames are warm sweeps instead of another diff. - The ice cage search counts distinct atoms in a small buffer and builds only the least ring reading. - The seeded cage call searches once when the mutual and union edge sets match. fellBack() runs before a dirty frame returns, so the following frames are warm sweeps. - A cold cage frame searches six-rings only, and the six triplet walks of the equatorial check share one read of each atom's ring row. - Each function section of the C API page now carries its full ``seams.h`` documentation: purpose, every parameter, return codes, ownership, thread safety, and the header example. ``docs/capi_docs.py --write`` rewrites those sections from the header, and ``docs/render_c_api.py`` uses the same renderer. Every function that takes or returns a pointer now says in ``seams.h`` who owns each argument and how long the library holds it. - C API: ``seams_system_set_atoms`` and ``seams_system_set_positions`` check the coordinates with a vector scan that runs from the end of the input, so the write pass that follows finds the start of it still in cache. A default reload in a trajectory loop costs 2 to 5% more than writing the coordinates into the C++ frame directly at 4096 and 110592 molecules, against 13 to 15% before, and about 12% at 884736. - C API: ``seams_system_stage_positions`` makes ``seams_system_set_positions`` check and write the coordinates in one pass, into a second set of per-atom records that it swaps in only when every value is finite, at about 72 bytes per atom. By default a reload checks every coordinate first and writes in place, with no extra memory; either way a failed reload keeps the old frame. - A ring census counts each size into a per-thread bin and adds the bins after the search, so a dense frame no longer updates one shared counter for every ring. - A sparse ring census keeps one scratch list per thread instead of one empty list per atom. A dense frame still keeps a list per source. - A dense ring census counts size-5 rings on the first shell's own bit rows, and size-7 arms that share a far vertex are kept or dropped together. That census uses the team below the sparse cutoff. - Users who run chill-plus on a cutoff list now see different counts. This is a bug fix in the shell count. The old code counted bonds after the list had been cut to four. A crystal row needs four neighbours inside the cutoff. On the mixed TIP4P fixture, interClathrate moves from 12 to 9. Water on that fixture moves from 238 to 241. Default q3 uses up to four nearest neighbours in the cutoff. Interfacial rows keep the neighbour test from the published table. Users who want the OVITO labels use the ovito-chill+ command. That command averages q3 on the full shell and skips the test. Plain CHILL keeps four closest neighbours and Moore's test. A reader error now returns exit code 2 instead of aborting the process. We print reCubic and reHex as plain text. A path that ends in xyz and cannot be opened returns an error. An exception outside std::exception returns exit code 2. - A dense ring search builds each thread's adjacency bits once, instead of once per atom. - ``seams chill-plus`` on a published cutoff classifies from the fused CSR kernel. ``seams steinhardt`` computes the degrees named by ``--l`` (default ``4,6``). ``seams symmetry`` builds the reported shell from the cells inside 5 Å. Primitive rings and the orthorhombic cutoff list stay on one thread below 2048 atoms. The vendored vesin meson project reports 0.5.7. - Documented seams lines that named FILE, dump.lammpstrj, or water.lammpstrj keep that template and gain a twin on input/traj/il_tiny.lammpstrj or ice1h.lammpstrj. The suite runs every twin, including the ionic-liquid commands and the chill line that exits 2. - A dense frame mixes each repeated neighbour-color signature once, instead of once per vertex. - The fingerprint options use the American spelling. ``seams fingerprint --color-types`` is the name help shows, and ``--colour-types`` remains a hidden deprecated alias of that same option. The Fortran ``frame_fingerprint`` keyword is ``colors``, and ``colours`` remains an optional deprecated keyword with the same meaning; giving both different values is an error. ``seams_fingerprint`` takes ``color_types``. Python ``fingerprint(color_types=...)``, Rust ``FingerprintOptions::color_types``, and the Lua ``colors`` field follow the same rename and do not accept the old names. A key library writes ``colors`` in its header and still reads ``colours`` as a deprecated alias, so a 2.13 library file with ``colours 1`` keeps its type colors. - The Comparisons tables name HaoZeke/seams-core and the benchmark branch, with a GitHub link, instead of a local remote. The long census and timing tables sit in collapsible blocks under a short per-cell summary. The C, C++, Python, Fortran, Julia, R, Rust, and Lua examples are programs or asserted snippets the docs suite runs. - The Comparisons pages are rendered from the vendored head-to-head CSVs. ClavisCage TRACE records the cage-by-cage census, including the seven periodic-wrap cages it drops on the 46-molecule sI cell, and the serial TRACE times against d-SEAMS at one and eight threads. SQQ records the exact edge and ring match on the 4096-molecule TIP4P/2005 frame, and the chordless-census and whole-tool ratios. A timed row names the version, the thread count, the repeat count and the core count. - The orthorhombic cutoff neighbour list is built by a parallel cell sort. Each thread counts its atoms, a prefix sum places them, and the pairs are written straight into one CSR. The same buffers are reused on the next frame. The pair set does not depend on the thread count. q_l reads that CSR. The neighbour average is skipped when only q_l is requested. - A threaded cutoff neighbour list on an orthorhombic cell uses the scaling cell list instead of linkcell's buffered walk. The rows stay the same sorted cutoff set, so the ring search matches the one-thread list. - The triclinic cutoff list uses the same stencil as the orthorhombic list. CHILL+ evaluates the real spherical harmonics on that CSR. The diamond common-neighbour test reads the same rows. The ring census uses the short-hop search on that CSR. - The cutoff list now covers restricted triclinic boxes. A half list keeps each pair on the lower index. A skin reuses the wide list while every atom stays inside the Verlet shell. CHILL+, the ring census, and the template overlay read that CSR. - Per-atom keys of a frame whose neighbourhood is the whole graph are refined on that one graph, counting repeated neighbour colors instead of sorting them. - A dense size-7 ring drops an arm that already fails on its own, and the frame takes that walk as soon as a vertex has two shortest paths. - When a vertex has more shortest paths than the pairing walk stores, the same primitive rings are taken from the breadth-first levels, and a dense census counts them instead of storing each ring. Each search keeps its own count and path cap. - Each bonded neighbourhood is color-refined once, and the hop walk reuses one stamp instead of a fresh map. - A five-ring census walks only the arms that belong to one of the two vertices, skipping the arms they share. - A repeated small neighbourhood is recognised from one flat neighbour list, without rebuilding a graph for every atom. A team of threads keeps the direct row walk. - A four-ring census counts non-adjacent arms from the shell bit rows. - Hydrogen atoms are indexed by molecule once, so a hydrogen bond no longer scans the hydrogen cloud for every oxygen. - Per-atom keys on a sparse frame reuse one repeated neighbourhood instead of refining it again, and the atoms of a large frame are refined together. - The landing page hides the root toctree and replaces that dump with cards for Tutorials, How-to, the language reference, the engines, Comparisons, and the paper reproductions. The suite-stack diagram fills the article column. - Cutoff neighbour lists (``neighListPair``, ``halfNeighList``, ``SkinNeighborList``, and ``neighListO`` / ``getNewNeighbourListByIndex`` below 2048 atoms) come from linkcell's ``lc_pairs_within`` with cells of about 20 atoms, and vesin is the fallback. ``halfNeighList`` on 8192 atoms at water density with a 3.5 Å cutoff goes from 8.9 to 4.7 ms on one thread and 4.0 ms on eight. The first linkcell cutoff list keeps freed pages on the heap for the rest of the process (``M_TRIM_THRESHOLD``, ``M_MMAP_THRESHOLD``). - The linkcell wrap names the v0.4.1 tag and carries no patches. - A neighbourhood row longer than 16 stays in visit order, because that ball does not repeat. - The minimage wrap names the v0.1.4 tag. Distances use mi_displacement_euclidean, and a failed call keeps the in-tree formula. - MPI ring analyses can reduce ring counts and per-atom ring types with ``seams::domain::reduceRings``, which keeps each rank on its own domain and sends only owned atoms to the root instead of gathering every ring on every rank. - CHILL, CHILL+, the shell match, rings, prisms and the 2D RDF use the OpenMP team for more of their work. The kNN graph rows, the shell-match cell sorts, the ring-pool merge and the prism ring index run on the team, and the 2D RDF bins its cells inside the pair-loop region. ``test_thread_invariance`` checks that every result is identical at 1, 2, 4 and 8 threads. - The orthorhombic cutoff list, cutoff q_l and the primitive ring census scale with OpenMP threads. Each thread fills its own CSR rows from a slot-balanced cell range, the C API reuses per-thread frame buffers, and the ring census counts sizes per thread without gathering the rings. On 110592-molecule ice Ic in ``bench/omp-scaling``, 8 threads run the cutoff list 4.8 times, q4 5.8 times, q6 5.9 times and rings 6.1 times faster than 1 thread, and the 1-thread times are no slower than before. The CSR, q_l and ring counts are identical at 1, 2, 4 and 8 threads. - A type-1 crystal is read once; the default oxygen choice no longer parses that frame twice. - The in-plane RDF builds an explicit grid whose cells are the cutoff and bins packed coordinates from the neighbouring cells. Each thread keeps its own histogram until the frame finishes. - The full paper Snakemake tutorials stay out of a default test run. ``meson setup -Dpaper_full=true`` turns them on; otherwise they exit 77 and say they are opt-in. - The carried ring update sorts ring indices and merges the kept rings in parallel, and it keeps dropped ring buffers instead of freeing them on the update. The orthorhombic cutoff list counts each pair once, a z layer at a time, so several threads beat the single-thread walk. One-thread and several-thread results still match. - The one-thread carried ring update copies and sorts its rings directly again. Several threads still sort indices and merge in parallel. A team narrower than the process is bound once to that many cores of the allowed set. Interior cells of the orthorhombic cutoff skip the periodic-shift arithmetic. One-thread and several-thread results still match. - Neighbour, order-parameter, ring and shell calls keep one worker pool and leave the OpenMP team running between a Rayon search and the next region. A per-atom walk runs on the team the caller asked for, whatever the frame size. Ring sources still take one thread per eighty sources. The one-thread and several-thread results match. - The prism search without shape matching, which ``seams_rings_find`` and ``seams_prisms`` run, pairs each ring only with the rings that hold a neighbour of its first atom, the pairs the basal test can accept. On the 21 in-situ frames of 4096 mW molecules from ``engines/lammps/in.mw.lmp``, ``seams_rings_find`` on one thread went from 0.672 to 0.0333 s per frame (median of 8), with the same rings, cages and prism counts. ``bench/seams_ring_frames`` times it on a LAMMPS dump. - The Python binding is released on PyPI as ``pydseamslib`` 2.14.0 from d-SEAMS/PydSEAMSlib, the distribution name of the 2.11 wheels, so ``pip install -U pydseamslib`` upgrades them in place. It provides ``import dseams`` and ``import pydseams``. - Every Python block in the docs runs in the suite, and a printed value is asserted. seams commands that name a frame in the tree run as well, and a quoted count in the following paragraph has to appear in the output. - Neighbour-list q3 uses the one-bond kernel. The eight-bond batch stays on degrees 4 and 6. - An empty Steinhardt shell is 0. The harmonic row stays zero and is not divided by the neighbour count, so freud and pyscal3 store NaN for that same atom. A NaN switch is not added: it would enter every mean and every CHILL+ label, and a neighbour count of zero already names the shell. - ``q4_q6_equal`` compares per-atom and Lechner-Dellago q4 and q6 with freud and pyscal3 on ideal ice Ih, ideal ice Ic, and one liquid. OVITO 3.15 has no Steinhardt modifier, so that test no longer skips on it. pyscal3 matches to 1e-10. freud stores q_l as float32, and an empty shell is 0 here and NaN there. - q4 and q6 share one cutoff list. A multi-thread cutoff walk records each pair once. Seeded cages with identical neighbour rows search rings and cages once, and the k-nearest nomination uses the same thread count as the rest of the command. - The averaged q4 and q6 rows keep m = -l..0. The positive orders are the conjugate partners, and the power adds them in the full order. - q12 is the Cartesian solid harmonic, eight bonds at a time. The value matches the associated-Legendre form. - Release builds define NDEBUG, so the libstdc++ assertions that meson adds when b_ndebug is false no longer run in them. The closed-cage search on the sI 2x2x2 crystal takes 13.2 ms instead of 16.0 ms, with the same output. - A fingerprint and a per-atom ring count tally rings while searching and do not keep the list. ``seams fingerprint --by-atom`` reads those per-atom counts. - Interior cells of the one-thread orthorhombic cutoff skip the periodic-shift branches. A parallel ring search writes each neighbour row, already sorted, into one array, so the walk after the cell list matches the walk after linkcell. - A ring census adds up its seven-rings and publishes one total per atom, instead of one atomic increment per ring. - Seven-rings share the tests of one near vertex across the arms that leave it. - A five-ring census walks the shorter of the two exclusive arm sets. - The documentation sidebar is eight groups: Getting started, Tutorials, How-to, Reference (every language and the C API), Engines, Comparisons, Explanation (the paper and the architecture), and Project. The suite-stack diagram is a top-down figure with body-sized labels in light and dark theme. - A six-ring census drops arm pairs that share a second-shell vertex, or whose second-shell vertices are adjacent, before walking them. - A neighbourhood of fewer than 400 vertices counts a wide color palette instead of sorting each neighbour list. - A large sparse census counts rings from the parent at the previous level instead of copying every shortest path. - The one-thread ring search packs sorted neighbour rows in one pass, and interior cells of a triclinic cutoff skip the image-wrap branches. Both stencils keep the same directed pairs as the branchy walk. - A frame whose shell is three words wide counts five-rings from that fixed width. - The hydrate signature search scales with threads. The cutoff list is the threaded linkcell list, built on one reused worker pool, and crystals under a few thousand molecules stay at four threads so a wider team does not slow them down. Neighbour rows are placed on the calling thread until the pair list is large enough that a parallel sort is the smaller cost. The cage index is merged from per-thread buckets in ring order. Census and cage membership match the one-thread result. - A two-word shell counts seven-rings by testing each neighbour of the far vertex in place. - A regular frame's first color round is the root, its neighbours, and the rest. - A dense neighbourhood counts repeated colors instead of sorting every neighbour list. The frame key is unchanged. - A small ball mixes a wide palette from the colors that occur, in palette order. Deprecated ---------- - ``--types`` is a deprecated exact alias of ``--pair-types``. The exact names both bind, and using ``--types`` prints a one-line warning on stderr. Removed ------- - The d-SEAMS 2.0 manuscript, its benchmark campaign, the record tables and logs under ``benchmarks/``, and the paper reproduction pages leave this repository for the private paper repository; the records and figure data are the ``d-SEAMS/dseams2-benchmark-records`` and ``d-SEAMS/dseams2-paper-figure-data`` datasets. The performance pages show tables rendered once from those records (``docs/records``), and the asv harness and the timing scripts stay. Fixed ----- - The thread pool stays inside the CPU mask it inherited. A restricted taskset or cpuset is no longer widened to every CPU the kernel would allow. - The AMX INT8 product behind ``ozaki-ii-amx`` is checked against exact row, weighted-row and column checksums of its inputs, and recomputed with VNNI or scalar code when one disagrees. On a KVM guest that corrupted AMX tiles while separate processes used AMX at once, ``ozaki`` failed in 62 of 1200 concurrent runs and now passes all of them. - The AVX2 per-atom ice classifier behind ``symmetry`` and the shell labels, and the AVX2 scan that builds a one-thread full neighbour list in a triclinic cell, run only on a CPU that reports AVX2 and FMA. The classifier's file was compiled with ``-mavx2 -mfma`` and called without a check, so ``symmetry`` stopped on an illegal instruction on a CPU without AVX2 or without FMA, and the inline header code that file emitted could replace the library's own copies at link time. The triclinic scan checked the CPU inside a function that was itself compiled for AVX2. The classifier is now built twice, once for any CPU and once with a target pragma below its includes, the scan is split the same way, and each call takes the AVX2 copy only after the check. The double-precision product in ``ozaki`` now also requires FMA, and the AMX INT8 path requires the AMX-TILE and AMX-INT8 bits and the operating system's tile state before it asks Linux for the tiles. One test switch holds the AVX-512 kernels, the classifier and the scan on their generic path, and a test compares the labels, the diamond signatures and the neighbour lists of the two paths. On a CPU with AVX2 and FMA the output is unchanged. - The AVX-512 spherical-harmonic kernels behind Steinhardt q4, q6, q12 and the batched Ylm run only on a CPU that reports AVX-512F, AVX-512DQ and FMA, the three their file is compiled with. The q12 path checked AVX-512F alone and the batched paths AVX-512DQ alone, so a CPU with one of the three but not the others could stop on an illegal instruction. Every call now goes through one check, other CPUs take the scalar path with the same values, and a test forces that path and compares the two. - The backtrace signal handler now outlives static destruction. A sanitizer abort at exit hit the freed handler stack and hung ``lammps_hook`` until its timeout. - Keep BondClassifier at the 2.13 layout, three doubles and one int. Open edges are an argument of classifyBond, so a caller that passes the struct by value is unchanged. - ``docs_brine_cli`` fetches the 230 K brine frame itself, through the same checked download as the science tutorials, and no longer skips on a clone where no other test has fetched it yet. The download takes a lock and lands through a ``.part`` file, so tests that start together do not read a partial frame. - A ring with no edge throws. An empty species pattern throws. A vertex at the minimum integer throws. The sphere test checks tiling before the closed test. - A cage ring is filled only when the cycle closes on a bond. A six-cycle that winds the periodic box is left unfilled, so the still is not a sheet the size of the cell. - A call that narrows the OpenMP team below the caller's width, such as ``seams_prisms`` on a few thousand molecules at eight threads, pinned the calling thread to one cpu for the rest of the process. Every OpenMP worker and Rayon thread created afterwards inherited that cpu, so on 21 frames of 4096 mW molecules ``seams_rings_find`` after ``seams_prisms`` took 0.590 s per frame at eight threads instead of 0.0182 s. The caller now keeps its mask; one thread is unchanged at 0.035 s. - Keep the cutoff shell list and the per-share ring scratch on the calling thread. Overlapping calls no longer share those buffers. - C API: libseams exports only the ``seams_*`` functions in ``seams.h`` (hidden visibility plus a linker export list). No call aborts or exits: the MIS self-test throws instead of calling ``exit``, every allocation in the wrappers is caught, a missing trajectory returns ``SEAMS_ERR_ARG``, and infinite cutoffs are rejected by ``seams_hbonds`` and ``seams_monolayer``. - C API: calls on a const handle no longer write the handle on success, and take a lock to record a failure, so several threads may query one handle at once. The ring label cache that ``seams_rings_labels`` fills on the first symmetry request is now built once under a lock and marked done only when complete; before, a second thread arriving during that request, or any request after a failed one, could read unfinished labels. - C API: ``seams_ql``, ``seams_q4q6``, ``seams_q4q6_n``, ``seams_q6bar``, and ``seams_steinhardt`` kept their q_lm scratch in function-local statics, so two of them on different handles in different threads corrupted each other's results or the heap. The scratch now belongs to the calling thread, and the one-time affinity setup they reach is guarded, so q calls on different handles may run at the same time. - ``capi_symbols``, which holds the exported functions of ``libseams`` to ``tests/capi_symbols.txt``, reads the exports with ``readelf`` when ``nm`` is missing and reports a skip when neither exists; it used to pass without checking. ``capi_symbols_selftest`` proves that the check rejects an unlisted export and a listed function the library no longer exports, and that ``nm`` and ``readelf`` agree. - The vendored fmt 6 in chemfiles 0.10.4 counts format strings without ``std::char_traits``, so the macOS build compiles under libc++ 19. - A MOL2 molecule whose counts line is empty no longer crashes ``seams_path_nframes``. The vendored chemfiles 0.10.4 indexed the first count of an empty line; the build now applies ``cmake/patches/chemfiles-0.10.4-mol2.patch`` and refetches chemfiles when the patch set changes. Found by ``capi_read_fuzzer``. - CHILL+ defaults to the cutoff list on the CLI, the C API, the LAMMPS ``compute dseams``, and every language binding. The mutual four-nearest list is ``graph = mutual``. On ``input/traj/exampleTraj.lammpstrj`` (oxygen, type 2) the cutoff list is 9 interClathrate and 241 water; the mutual list is 1 clathrate, 7 interClathrate, and 242 water. The docs tutorials run against the ``pydseamslib`` 2.14.0 package built from d-SEAMS/PydSEAMSlib. - Keep the 2.13 signatures of ``getCorrelPlus``, ``getIceTypePlus``, and ``getIceTypePlusNoPrint`` as overloads. The longer forms take the open-edge flag and the OVITO neighbour test. - Clang builds record the directory of clang's ``libomp.so`` as a runpath, so the libraries, tests and libFuzzer harnesses start without ``LD_LIBRARY_PATH`` with an EESSI LLVM and with the apt.llvm.org packages, whose ``libomp`` lives in ``/usr/lib/llvm-/lib``. - The library builds with clang again: the prism code in ``topo_one_dim.cpp`` casts its signed ring and atom indices explicitly, as the rest of the tree does, so the ``-Werror=sign-conversion`` and ``-Werror=shorten-64-to-32`` that clang builds use no longer stop it. - The engine builds with clang, libc++ and musl and on macOS. CPU features are read with cpuid instead of ``__builtin_cpu_supports``, which needs compiler-rt's ``__cpu_model`` on macOS. The AVX-512 row work in ``ozaki.cpp`` moved into target functions, since clang does not give an OpenMP region the target attribute of the enclosing function. The dump reader replaces ``__gnu_cxx::stdio_filebuf``, which libc++ lacks, with its own seekable buffer. ``backward.cpp`` compiles to nothing where ```` is missing, the ring profiler ticks use ``steady_clock`` off x86, and the AMX request in ``ozaki.cpp`` is Linux only. - The cutoff neighbour search clamps its cell count and stencil reach before converting them to integers. A cell edge many orders of magnitude shorter or longer than the cutoff overflowed both, which is undefined behavior and in practice left the reach at one cell. Found by ``capi_reload_fuzzer`` under UBSan. - The multi-thread cutoff list records neighbour ids during the count walk, and the linkcell pool is sized to the OpenMP width. - Keep a diamond shell while eight good (4,2,1) signatures, or the ambiguous band, are still reachable. The old count stopped once four bad rows made nine good signatures unreachable. - On a crowded shell the diamond label uses the four nearest neighbours, the list mdapy uses, and the labels stay those of the cutoff list. - A LAMMPS dump whose ``NUMBER OF ATOMS`` line comes after ``ITEM: ATOMS`` no longer indexes past the id table, which was sized for the previous count. Found by ``capi_read_fuzzer``. - A chemfiles LAMMPS dump keeps the reduced cell edge. The bound span was being padded by the tilt a second time, so genice sH reported 31.05 Å instead of 24.84 Å. OVITO FindRings is compared as a subset of the primitive-ring census: K2,3 has three chordless 4-rings and FindRings reports two. - ``dump_index_eintr``, ``dump_index_eio`` and ``dump_fstat_keeps_atoms`` each write their dump under a directory of their own. The three run one driver in parallel and shared a fixed temporary directory, so one test's cleanup could remove the other's file and abort it with ``filesystem error: cannot remove``. - Engine checks load the plugin from the build tree. A copy staged under an install destdir is left alone. - ``docs/howto/test_engines.py`` runs each engine how-to in a temporary directory under ``build/docs-examples`` and removes it afterwards. ``docs_engine_`` and the ``docs_video_tapes`` scenes ran the same engine at once in one fixed directory, and PLUMED, which renames every ``colvar`` it finds to a numbered backup, refused to run once 101 backups had built up over repeated ``meson test`` runs. - ``libSeamsPlumed.so``, ``run_hook`` and ``seams_openmm`` carry an rpath to ``libplumedKernel.so``, ``liblammps.so`` and ``libOpenMM.so``. Without ``LD_LIBRARY_PATH``, PLUMED's ``LOAD`` failed with "libplumedKernel.so: cannot open shared object file" and the two drivers did not start. - The Fortran methods that size a buffer and then fill it (``rdf``, ``running_cn``, ``density``, ``brine_profile``, the fingerprint keys and the neighbour columns) pass the capacity in its own variable. They passed one variable as both the by-value capacity and the ``intent(out)`` length, which leaves the capacity undefined on entry. - The Fortran bindings free the result buffers after the copy, and a dump that cannot be opened names its path. The cubic example drops the arrays it owns after the frame is closed, which LeakSanitizer otherwise reports before a Fortran main finalizes its allocatables. - ``capi_fuzzer`` writes its per-format scratch files under names that include the process id. ``-fork`` jobs and parallel test runs shared fixed names in one working directory, so one process could truncate a file another had mapped and die with SIGBUS. The fuzz targets also rebuild when their source changes. - ``gmx-seams`` classified every site of the trajectory, which for TIP4P/Ice put hydrogens and virtual sites into the CHILL+ graph. ``-select`` now picks the sites (``-s topol.tpr -select 'name OW'``), ``-dump`` writes the classified frames with their labels, and molecules are no longer made whole before classification. The ``gromacs_legacy_include`` option builds it against GROMACS 2023 and later, which install neither the trajectory-analysis headers nor ``libgromacs_export.h``. - A LAMMPS dump that grows while it is read is kept. The language fronts follow the build Python and skip a library mismatch. - Read a halo source from the frame index in share.local. The old index walked the local list as if it were the frame. - Keep spherical-harmonic scratch local to each call so concurrent frames and changing thread counts do not share buffers. - The XYZ and LAMMPS dump readers no longer size their buffers from the header atom count alone. A few-byte file that declared 99999999 atoms made ``seams_system_read`` allocate several gigabytes before reporting the truncated frame, and under ``MALLOC_PERTURB_`` it pushed ``capi_fuzzer`` past its 4 GB limit. Reservations are now capped by what the unread bytes can hold, and the dump id index sizes its bitmap only after the rows confirm the count. ``capi_contract`` checks the peak RSS on Linux. - ``bench_rings_h2h --repl`` answered every sample with the ring search on a graph built before the clock, so the inside row repeated the prebuilt one. An ``in`` line now times the neighbour list, its index and the ring search as one call, and ``scripts/rings_one_thread.py`` records the prebuilt and inside rows side by side and writes them to a CSV next to the JSON. The one-thread table on the Rings on one thread page is the prebuilt row and does not change. - ``c_api_installed`` and ``capi_installed_examples`` install into a fresh directory under ``install-stages`` in the build tree and remove it on exit, so ``meson test --repeat`` can run two copies at once. - ``compute dseams`` on several MPI ranks classified each rank's own atoms as a separate cell, so atoms near a subdomain boundary lost neighbours. On two ranks, 8312 of 86016 labels over 21 frames of 4096-molecule mW ice and liquid differed from ``seams chill-plus`` on the same dump. The compute now gathers every atom to rank 0, classifies the whole cell once, and returns each rank its labels; all 86016 match. ``meson test lammps_e2e_np2`` is the regression. - The landing-page and architecture diagrams quote labels that contain a slash or a quote, so Mermaid 11 draws the suite stack. - ``meson-uninstalled/seams-lang-uninstalled.pc`` and ``seams-core-uninstalled.pc`` name the build tree. They passed ``-L`` a lib directory under the build root that nothing is built into, and no include path, so a binding with ``PKG_CONFIG_PATH`` at ``meson-uninstalled`` did not find ``seams_lang.h`` and did not link ``-lseams_lang`` or ``-lyodaLib``. The installed ``seams-lang.pc`` and ``seams-core.pc`` resolve to the same flags as before. - ``language_fronts`` gives ``cargo test`` the ``SEAMS_SOURCE_ROOT`` and ``SEAMS_CPP_ORACLE`` that the Rust ``cpp_match`` tests read, and builds ``binding_oracle`` first. - ``libyodaLib`` no longer installs backward-cpp's crash handler. Its static ``SignalHandling`` replaced the SIGSEGV handler of any process that loaded the library, so Julia, which faults on purpose at its GC safepoints, died with signal 11 at random points of ``Pkg.test()`` once ``libseams_lang`` was open. ``backward.cpp`` is now compiled into the ``seams``, ``brine_front``, ``science-front`` and ``nucleation-pathway`` executables, which keep their stack traces on a crash. - ``-Dwith_linkcell=disabled`` builds and links again: the k-nearest neighbour list merges its rows on the OpenMP team instead of calling linkcell's slab walk, and the GPU batch helpers build under ``-Werror`` without linkcell. - A Clang build loads one OpenMP runtime. linkcell compiled its OpenMP k-nearest region with the environment's GCC and linked libgomp next to Clang's libomp, and the two runtimes disagreed on thread numbers, so neighbour, ring, CHILL+ and C API calls indexed past their per-thread buffers and aborted. linkcell 0.4.1 compiles that region with the C compiler Meson chose and links that compiler's runtime. - The Lua LuaJIT FFI module ``dseams_ffi.lua`` is written by a plain build of the Lua binding, not only by its example test, so the LuaJIT FFI tutorial runs on a fresh build. The Lua binding lives in d-SEAMS/yodaStruct. - ``require("dseams")`` loads the module built for that interpreter. The Lua binding used to put the LuaJIT module first on the search path, and PUC Lua 5.4 then mapped that shared object. - The 1.x migration guide lists only the Lua globals v1.0.1 registered (readFrame, chillPlus_iceType, getPrimitiveRings and the rest). The dseams table and the later Lua names sit under the yodaStruct release that first shipped each one, and coordination, density, fingerprint, contact pairs, domains, k-NN and signature search are marked new in 2.x. The migrate video narration says the same. - A short LAMMPS frame no longer returns from the reading rank before ``MPI_Gatherv``. Both ranks gather, and the frames that did read still print. On the 11-frame dump cut short, frames 1-10 stay whole and frame 11 keeps its header and two atoms. - The four nearest bonds are ordered by an insertion sort of that bounded count. GCC 15 no longer inlines ``std::sort`` past the end of the stack array once OpenMP outlines the loop, and the order is unchanged. AVX dispatch uses the CPUID helper, which exists on aarch64. - Use the one-cell neighbour stencil from two cells per edge, so a short box is not left on the general walk. - ``topo_bulk`` calls ``omp_get_thread_num`` only when OpenMP is on. - The paper tutorials, the science figures and the gallery render with Tachyon under Qt's ``offscreen`` platform, so no display, OpenGL context or ``libxcb-cursor0`` is needed. The science tutorials no longer start Xvfb with ``QT_QPA_PLATFORM=xcb``, which aborted the process where ``libxcb-cursor0`` is absent. The ``pixi-suite`` CI job keeps the locked OVITO 3.15.5 wheel, which matches the locked PySide6 6.9.3; the OVITO 3.17.2 wheel it installed over it needs PySide6 6.12 and ``import ovito`` failed. ``docs_science_tutorials`` holds a lock while it writes ``docs/source/science/figures``, as the science snippet pages already do. - The Ozaki residue division uses shifts, so clang-cl no longer emits ``__udivti3`` and ``__umodti3`` for a 128-bit operator that lld-link does not pull into the DLL. - Name the site-site pair flag ``--pair-types``. Give the gpulite and vesin wraps their own option files so ``meson configure`` does not copy the engine options onto them. - The opt-in paper runs print the molecule count, the frame count, and the file they read, next to the size the paper states. Rings reads frame 1 of the 11-frame 4096-molecule mW dump. The interface and brine runs read the shipped 864-water frames. Nucleation reads the figshare trajectory, 148 frames of 4096 molecules. - The linux-64 pixi lock keeps PLUMED 2.9, because a LAMMPS build that links PLUMED 2.10 needs glibc 2.38 and this lock is glibc 2.28. It also keeps libcurl before 8.10, because Julia 1.10.4 aborts in Downloads when that libcurl runs the socket callback during ``curl_multi_cleanup``. - ``plumed_driver`` runs PLUMED in a scratch directory under the build tree, not beside the deck in the source tree, so two build trees no longer share its colvar. - The PLUMED q6 derivative is expressed per nanometer. A 0.001 angstrom step matched an independent difference to 3.99e-11 on a shifted eight-molecule cell. - The PLUMED ``SEAMS`` action scaled positions and the box by 10 whatever PLUMED's length unit, so under ``UNITS LENGTH=A`` it saw a cell a hundred times too large: on the ideal 64-molecule cell ``seams.ice`` was 0 and ``seams.q6`` 0 instead of 1 and 0.6285. It now reads the unit from PLUMED. ``meson test plumed_units`` is the regression. - The engine compiles on aarch64, Apple silicon, and musl. The AVX kernels are built for x86_64 only and other targets take the scalar paths, ``backward.cpp`` is skipped without ``execinfo.h``, and ``LinearFit::stderr`` is now ``slopeStdErr`` because musl defines ``stderr`` as a macro. - q4 and q6 build the multi-thread cutoff list in one pass again, instead of copying each linkcell block. - The C API builds q4 and q6 from one cutoff shell and does not fill an atom-index map on that path. - When ``SEAMS_LIBDIR`` is set, the R configure script exports ``DSEAMS_ROOT`` so it can find ``seams.h``. A missing header names that variable. - Require readcon-db 0.1.8 so static consumers receive only the archive and shared consumers receive the runtime search path. - The release checks run on every platform again. ``test_serial_affinity`` counted a sampler thread from its previous call as a library thread, because ``pthread_join`` returns before the joined thread leaves ``/proc/self/task``; each call now waits until it is gone. ``padding_probe`` reads the process cpu mask only on Linux, so the macOS build compiles it and counts every online cpu there. The ThreadSanitizer C API suite runs with address randomisation off, since GCC's libtsan stops with "unexpected memory mapping" under the 32-bit mmap randomisation of newer kernels. The Julia and R binding pages link the README sections by the ids GitHub gives them. - An install is relocatable. The vendored chemfiles is installed beside ``libyodaLib`` as ``libseams-chemfiles.so.0.10``, and the installed ``libyodaLib``, ``libseams``, ``libseams_lang`` and ``libSeamsPlumed`` find each other through an ``$ORIGIN`` rpath instead of a build-tree path. - The primitive ring search no longer crashes on a vertex with more than 48 neighbours when it searches by hops alone, as it does up to six-membered rings. Such a row fell through to the distance table that only the longer search builds; ``seams_rings_find`` over every atom of ``input/traj/dump-bcc`` was one case. - ``seams_rings_find`` classifies prisms from the neighbour index instead of an all-pairs scan, and the ice Ih stacking-plane pass runs across threads. Ring lists and labels on the 4096- and 32768-molecule cells are unchanged. - A sanitized build does not preload AddressSanitizer into Julia, R, or ``nm``. Those hosts abort in their own startup. The runtime is mapped when they load ``libseams``. - Sanitized builds of the ``seams``, ``brine_front``, ``science-front`` and ``nucleation-pathway`` executables leave fatal signals to the sanitizer. The backward-cpp crash handler had replaced the ASan and libFuzzer handlers, so a fuzzer stopped with no report and no saved input. ``capi_signal_owner`` checks that ``libseams`` installs no ``SIGABRT`` handler in plain or sanitized builds. - A one-thread run keeps a single thread, and a bound run keeps the cpus of its OpenMP places. At ``OMP_NUM_THREADS=1`` or after ``seams_set_num_threads(1)``, the neighbour, CHILL+, q6 and ring calls started a Rayon worker beside the caller: ``libseams`` and every executable carried their own copy of linkcell, so the one-thread width never reached the searches ``libyodaLib`` runs, and linkcell's walks asked rayon for its global pool even at width one. ``libyodaLib`` now holds the only copy, and linkcell runs a one-thread search, its walks and its fused k-nearest region on the calling thread. Under ``OMP_PROC_BIND`` the calling thread stayed on the first OpenMP place and the linkcell pool built from it inherited that one cpu, so two threads under ``taskset -c 0,1`` ended on cpu 0; the caller now gets back the cpus of the OpenMP places, and no cpu outside the launch mask. ``test_serial_affinity`` checks the mask and the thread count under taskset. - The library sources PydSEAMSlib and dseams-r compile build without a warning under ``-Wsign-conversion`` and ``-Wshorten-64-to-32`` with GCC and the newest Clang, with or without OpenMP, chemfiles, MPI and sphericart. Indices are ``std::size_t`` or pass a range check on the way, so PydSEAMSlib's ``-Werror`` build on macOS no longer stops on them. Every count is unchanged. - ``ringNetwork``, ``RingUpdater`` and ``seams_rings_find`` keep their odd rings on targets where plain ``char`` is unsigned, such as aarch64. The two-coloring that decides whether odd rings can be skipped stored its unvisited mark of -1 in a plain ``char``; read back as 255, every graph looked bipartite and every three-, five- and seven-membered ring was dropped. The GenIce sII host now gives its 144 five-membered rings there too. The color is a ``std::int8_t``. - ``with_sphericart=auto`` takes sphericart only from pkg-config or CMake. The library inside a pip wheel is used only with ``-Dwith_sphericart=enabled``, and then ``yds_dep`` carries the ``-rpath-link`` a consumer of ``libyodaLib`` needs. The probe calls the constructor and ``compute`` the engine uses and links without ``--allow-shlib-undefined``, and ``sphericart_consumer`` links a program against ``libyodaLib`` alone the same way. - Build the Sphinx book with warnings as errors from the committed sources. Doxygen XML and the C++ pages are optional, and each page is listed in one toctree. - ``seams_status_string`` reads its argument as an ``int``, so a code outside ``seams_status`` returns "unknown status" without undefined behaviour in the C++ library; clang's UBSan enum check aborted on it. - The cutoff cell window is timed with ``steady_clock`` when OpenMP is off, so the macOS R package and the wheels build that loop without ``omp_get_wtime``. - A build with ``-Dwith_tests=false``, including seams-core as a Meson subproject, registers no tests: the CLI, docs, C API, C ABI and engine plugin checks and their test programs follow ``with_tests``, and the wrapped linkcell and minimage get the same ``with_tests`` and ``with_examples``. - ``dseams-sys`` declares the C functions that return nothing without ``-> ()``, so ``cargo clippy --all-targets`` with warnings denied passes on the 1.85 MSRV toolchain as well as on current stable. ``gen_sys.py`` writes the declarations that way. - A tilted cell's cage edge window uses the lattice minimum image, so a GenIce sH dump keeps every 5^12, 4^3 5^6 6^3 and 5^12 6^8 cage. The head-to-head against ClavisCage and cycless is benchmarks/cage-h2h-v8.txt. - Tilted LAMMPS dumps are read by the native reader again. Chemfiles 0.10.4 took the cell edge as ``xhi_bound - xlo_bound`` and kept the tilt padding, so the GenIce sH dump came back with an edge of 31.053 instead of 24.8424228 angstrom. - Builds without OpenMP or chemfiles, such as dseams-r on macOS, no longer carry functions nothing calls, so Clang's ``-Wunneeded-internal-declaration`` and ``-Wunused-function`` stay quiet. The unused ``tallyRing`` in ``shell2_count.cpp`` and the per-atom counting path it served are gone, and helpers that only OpenMP or chemfiles builds call are compiled only there. - ``libyodaLib``, and every program and binding that loads it, finds ``chemfiles::seams_with_frame`` in a pixi or conda environment. The patched chemfiles is built as ``libseams-chemfiles``, with the soname ``libseams-chemfiles.so.0.10``. Meson renamed it only when ``patchelf`` was on ``PATH``, and pixi does not install ``patchelf``. Without it the library kept the soname ``libchemfiles.so.0.10``, and the loader opened the unpatched conda copy that the conda compiler puts first on the RPATH. - The ``recorded.txt`` check of ``docs_video_tapes`` ignores the note LAMMPS prints when ``OMP_NUM_THREADS`` is unset, as it is under ``meson test``, so the lammps transcript matches with or without that variable. The ``using 1 OpenMP thread(s)`` line after it is still compared. - The brine, interface, nucleation, and rings picture tracks now show the paper-frame transcripts: 873 atoms with hexagonal 352 and water 434, the 864-molecule interface, 148 nucleation frames, and the 11-frame mW cell. ``docs_video_tapes`` fails when ``recorded.txt`` disagrees with the tape output or a spoken number is absent from that transcript. - ``docs_video_tapes`` treats a step that exits 77 as an absent engine or frame. That scene is skipped, each scene of the folder that ran still has to match its own section of ``recorded.txt``, the narration check of that folder is left out, and the remaining tapes still run; the test then exits 77 with the reasons. Any other exit is still a failure. - ``-Dwith_cli=false`` configures again; ``seams_lang_fixtures`` referenced the CLI target unconditionally, so ``pip install .`` failed.