ManuelBehrendt/Mera.jl v1.8.0

on GitHub

Mera v1.8.0

Diff since v1.7.0

[1.8.0] "Shana Tova" - 2026-10-20

Everything here is measured against v1.7.0 (July 2025), the last registered version. Work
that changed or fixed features of this version while it was being developed is not listed
separately; the entries describe what the release does.

Not included: the other-code frontends (PLUTO, Chombo, Athena++, FLASH, GADGET/AREPO, AMReX/Quokka), which live
on the unreleased multicode branch, and features developed outside the package under dev/.
Neither ships in a 1.x release.

Highlights

• New analysis that 1.7 did not have: star formation, profiles, phase diagrams and PDFs with full
  per-bin statistics, time series across outputs, and movies.
• Clump finding: seven algorithms behind one call, with a boundedness test, a catalogue and its
  mass function, and synthetic fields with known clumps to score a finder against.
• Look from any angle: off-axis projection where the mass stays the same at every angle, pixel
  size and thread count.
• Volume rendering inside Julia: dense gas hides what lies behind it, with isosurfaces, tone
  curves and a camera that orbits or follows a path for a movie.
• Exact selections: regions are values you combine with ∩ ∪ \ !, and cells cut by a region,
  a field of view or a depth slab count by the fraction inside, so the parts add up to the whole.
• Select by physics: filterdata on any quantity Mera can compute, in any unit, with
  conditions joined by and, or, not.
• Back to RAMSES: rewrite an output for any number of CPUs, or write RAMSES files from Mera
  data or a mera file when the original files are gone, checked against RAMSES itself.
• Less boilerplate: loadall, reusable argument bundles, and macros (@loadall, @project,
  @region, @filter) that fold the common steps into one line.
• A first look in one call: quicklook, and reports you compose and can cost before running.
• Reproducibility: every result records the Mera version, the exact code and the snapshot it
  came from, and fifteen public test simulations with known answers let anyone check an
  installation.
• A reader for your own hydro code: simulation formats plug into a registry, so a reader written in
  your own package works with the whole analysis, without changing Mera.
• Faster: the first projection costs 0.05 s instead of ten, and a benchmark suite tunes reading
  to your machine.

Added

Reading and selecting

• A pipeline API, so opening a snapshot is one line instead of five. loadall reads every
  component a snapshot holds in a single call, across all six data types, and dispatches to
  loaddata when the folder holds a converted MERA file, so the same line serves a raw output and
  a converted one.
• Macros for the repetitive parts. @loadall path 300 hydro particles binds the components to
  variables of those names; @project gas sd=>:Msol_pc2 T=>:K projects several quantities at once,
  takes a unit per quantity, and binds each map to a name instead of leaving you to index
  proj.maps; @region scopes a region to a block. All of them forward any keyword to the
  underlying function, and a test pins each macro to return exactly what the explicit call returns.
• Argument bundles do more. ArgumentsType grew from 19 fields to 31, adding the off-axis view
  (inclination, azimuth, axis, los, up, position_angle, angle_unit), binning
  (binning, nmax) and verbose_threads, so one bundle now carries a whole off-axis setup. It
  is a keyword constructor, so ArgumentsType(lmax=10, xrange=[-10,10], center=[:bc]) replaces
  filling fields one line at a time, and withargs derives a variant from an existing bundle
  without touching the original, which a plain assignment cannot do because the bundle is mutable.
• filterdata / getmask / getparticlemask select in value space on any quantity getvar
  computes, composable with Above, Below, InRange, AbovePercentile, MassAbove,
  Satisfies and boolean combinators, returning a chainable object. Like every other verb they take
  center, center_unit and vcenter, so a condition on :r_cylinder or :mach means what it
  says on an object that is not at the box corner or at rest.
• Regions as values: sphere, cuboid, cylinder, sphericalshell, cylindricalshell,
  combinable with set operations, with exact fractional cell splitting at the boundary, tilted
  axes, geometric refinement (refine=k), and a @region block macro. Selection skips whole
  regions by a conservative bounding box before evaluating membership, with the hot loop behind a
  function barrier, measured at roughly 30x on the maintainer's machine. Region values work on all
  six data types; sinks are points and so are simply in or out, with no fraction. The
  constructors are lowercase because Makie exports a Sphere and a Cylinder too, and a name
  exported by two loaded packages binds to neither; the types are reachable as Mera.Sphere and so
  on for dispatch.
• getrt and getsinks complete the reader set; getvar gains radiative-transfer and sink
  quantities.
• download_testdata() fetches fifteen public test simulations (307 MB, or one at a time by name),
  each carrying an analytic oracle or a published reference value.
• getinfo keeps the whole amr file header in info.grid_info.amr_header, under RAMSES's
  names: time and expansion factor at full precision, time steps per level, step counters, energy
  bookkeeping and cosmology. writeramses needs it to write a restart. Mera files saved earlier
  load with an empty header, and upgrade_merafile fills it in.
• Periodic boundary handling, opt-in rather than assumed. subregion/shellregion take
  periodic=true on every data type, so a region straddling a box face selects the cells that wrap
  instead of clipping them; covering_grid does the same. :r_sphere_periodic and
  :r_cylinder_periodic give minimum-image radii in getvar, and periodic_recenter shifts an
  object that sits across a face back into one piece. It stays explicit because a RAMSES output
  records no boundary condition, so guessing would silently wrap a run with outflow or reflecting
  walls.

Reading other simulation codes

• setcomposition!, so a run can state its own gas composition. Two quantities depend on it and
  no snapshot format records them: :nH needs the hydrogen mass fraction, and a temperature in
  Kelvin needs the mean molecular weight. Both were fixed at the RAMSES convention for every code,
  which on fully ionised gas makes temperatures about twice too high. X_frac and mu are separate
  arguments, because they answer different questions and mu = 1/X is a RAMSES convention rather
  than physics. Opt-in: nothing changes unless you call it.
• getinfo now states the composition in use instead of assuming one silently, and a reader
  that can determine its own reports that instead.
• A reader registry, so a simulation format is a plugin rather than a fork. register_reader!
  declares a reader and the data types it can supply; the public entry points route on the code
  recorded in the snapshot, and the analysis layer never learns which code wrote the file. It can be
  called from your own package, so a new reader can be written and tested without changing Mera.
• capabilities lists what a snapshot's code actually offers and supports answers for one
  data type. A capability a reader does not declare produces an error naming what is available,
  rather than a wrong answer or a missing method.
• select_vars lets a reader declare that it can read a subset of columns, so gethydro(info, vars=[…]) reaches a format that can honour it, and is refused by formats that cannot rather than
  silently returning everything.
• createscales! is public alongside createconstants!: a reader supplies three CGS numbers and
  every unit in Mera follows from them.

Restarting RAMSES

• Restart RAMSES with any number of CPUs: repartition and writeramses. RAMSES only
  restarts with the number of ranks that wrote an output.

  • repartition(output, path, ncpu; outpath) rewrites an output for any other number of ranks;
    every value is copied bit for bit.
  • writeramses(ncpu; hydro, gravity, rt, particles, sinks, outpath) writes RAMSES files from Mera
    data or a mera file, also when the original output is gone.
  • restart_completeness checks that the data is complete before writing, and compareramses
    compares two outputs cell by cell and particle by particle. upgrade_merafile adds what an old
    mera file lacks for a restart while its simulation still exists.

  Hilbert and bisection ordering, IO-group folders, and outputs from older RAMSES versions are
  read and written. Checked against RAMSES itself: its own files are rebuilt exactly, and a run
  restarted from the new files continues to round-off, for hydro, MHD, RT, gravity, particles,
  sinks, clumps and cosmological runs. Large outputs convert on a laptop: a 54 GB output on 5120
  ranks went to 512 ranks in 11 minutes with 6.3 GB of memory. New dependency: Mmap (standard
  library). Details, and what is refused:
  RAMSES restart.

Derived quantities

• Magnetic field in cylindrical and spherical components; five entropy measures; kinematics and
  Mach numbers in Cartesian, cylindrical and spherical frames; Jeans length, mass and number;
  virial parameter; free-fall time; binding energies; ionisation states.
• More Jeans conventions: :jeanslength_iso, :jeanslength_ad, :jeansnumber_iso,
  :jeansnumber_ad and :jeansnumber_truelove. The classical Jeans length
  sqrt(π c² / (G ρ)) with the isothermal (c² = P/ρ) or the adiabatic (c² = γP/ρ) sound speed.
  The isothermal one is what RAMSES's jeans_refine tests, and :jeansnumber_iso, the cells per
  Jeans length, is the number that criterion sets. :jeansnumber_truelove is Truelove et al.
  (1997)'s J = Δx/λ_J, the inverse, with their criterion J ≤ 1/4. In a cosmological run RAMSES evaluates the same length in its code units with its
  own G; Mera uses the physical G, and the two differ by one constant factor for every cell
  (1.0014 on the test run).
• add_field / delete_field / list_fields / field_info / field_tree /
  field_dependencies register and introspect derived fields; add_unit / delete_unit /
  list_units do the same for units.
• The unit system roughly tripled, from 52 scale fields to 130, adding force, action, power,
  spectral flux, specific entropy and per-mass energy units among others. They are checked by
  relations between scales on two different unit systems rather than by restating their formulas,
  which is what a dimensional error slips past.
• Cosmology, so a cosmological run reports physical times rather than code ones: cosmology and
  iscosmological set up and detect the model, age_of_universe / cosmic_time / lookback_time
  / redshift convert along the Friedmann table, formation_time / formation_redshift /
  stellar_age / age_from_aform turn a star's birth record into a physical age, and
  critical_density / mean_matter_density / mean_baryon_density plus comoving-proper
  conversions give the background quantities. Note that cosmic_time and lookback_time take the
  scale factor, not the redshift.

Maps and views

• covering_grid and slice produce fixed-resolution buffers from AMR data, with
  covering_grid_memory to size the request first.

• Off-axis projection, which 1.7 had no form of. Views are set with inclination/azimuth
  about any reference axis, with fov / fov_unit / aperture for framing, plus
  offaxis_slice, gridoverlay, and rotation_frame / rotation_sequence / restframe /
  face_on / edge_on / GalaxyFrame. theta/phi are accepted as aliases and are scheduled
  for removal in 2.0; they do not share a zero point with inclination/azimuth (azimuth
  starts a quarter turn later, so azimuth = phi + 90), and Mera prints the conversion once per
  session rather than silently returning a picture rotated by 90 degrees.

• Line-of-sight kinematics :vlos and :σlos. :vlos follows the observational sign
  convention, positive means receding.

• A fidelity ladder for how cells land on the camera plane (binning), since a coarse AMR cell
  covering many pixels is not a point. :ngp and :cic are fast previews that deposit cell
  centres and speckle on coarse cells; :overlap (the default) supersamples each cell's footprint,
  AMR-aligned so there is no moiré and no interior hole, converging to the exact answer and usually
  faster than it, with nmax capping the sub-sampling; :exact integrates the analytic box-spline
  footprint, the line-of-sight chord through each cube over each pixel, with no cap, and is the
  reference for fidelity. All four conserve mass. Point particles have no footprint, so the two
  footprint modes fall back to :cic there and say so rather than silently differing.

• One rule decides which way is up, for every way of pointing the camera. The image up is
  world +z seen across the line of sight, or +y within 3 degrees of the z axis, and
  inclination/azimuth and face_on/edge_on measure from that same reference. So
  :faceon is exactly inclination=0 and :edgeon exactly inclination=90 about
  axis=:angmom, a box-axis los reproduces its preset, and a face-on time series keeps its roll
  while the spin axis stays inside the cone. azimuth = phi + 90 holds about axis=:z.

• Velocity dispersions on every view. :σx, :σy, :σz, :σ and the cylindrical and
  spherical families work on- and off-axis, each built from two ordinary getvar fields, v and
  v². They are box components, so :σz is the
  spread along the simulation z even in a face-on view. Only :r_cylinder, :r_sphere and :ϕ
  are still axis-only, because they describe a pixel's own geometry and an off-axis pixel is a
  slanted column with no single value.

• Camera-frame kinematics: :vcamx/:σcamx and :vcamy/:σcamy, along the two image
  axes, completing the triple with the existing :vlos/:σlos. These exist off-axis only,
  because there is no camera basis on the axis-aligned path, where they raise with a message
  naming the box-frame equivalent. The camera triple and the box triple describe one tensor in
  two frames, so σcamx² + σcamy² + σlos² = σx² + σy² + σz² holds pixel by pixel; measured at
  1e-13 on a 51.5 million cell snapshot, for gas and for particles, across all four kernels.

• angmom, the angular-momentum vector as a value. angmom(obj; center, range_unit, radius, mask, unit) returns the 3-vector, and angmom([gas, stars, dm]) adds the momenta of
  several components, so a plane can be set by gas, stars and dark matter together. radius
  restricts the sum to a sphere and resolves the centre and the radius to one scale, so a
  fractional centre with a radius in kpc means what it says. Feed the result to any view with
  axis=L or los=L. It is also the cheap route, since the presets recompute the sum on every
  call.
  vcenter=:auto (or a vector) measures in another velocity frame; without it the box frame is
  used, as documented, and no hint is printed about it. radius and mask combine: the mask is
  applied first and the sphere cut from what is left.

• angmom_radius on grid and particle projections. :faceon, :edgeon and axis=:angmom
  measure the axis inside a sphere about center instead of from everything loaded, where the halo
  can tilt the plane.

• split=true on projection weights partial cells. A hard test on the cell centre counts a
  cell ten percent inside the depth slab as fully inside, and one grazing the fov sphere with
  its whole mass. split weights each cell by the fraction of
  its volume that is really inside, matching what subregion(...; split=true) already did for
  regions. Default off. Two consequences worth the keyword: stacked slabs become exactly
  additive, and a small aperture holds the mass of the sphere it selected. Without it, on a
  regular grid seen along a rational line of sight, whole lattices of cells land exactly on a
  slab face and a closed cut counts every one of them in both neighbours.

• refine and refine_to on projection, forwarded to the fov sphere. split fixes the
  total but not the edge: a half-in cell still deposits its reduced share over its whole
  footprint, so the boundary is a staircase. refine=N subdivides the cells the sphere crosses
  so the mass sits where it belongs, and refine_to=[length, unit] subdivides to a target size
  instead. Both need fov and split=true and are refused otherwise. Refining moves mass, it
  does not create any.

• mode=:sum for particle projections. projection(part, :mass) is the mass-weighted mean
  particle mass, a useful map but not a budget. mode=:sum returns the per-pixel total and agrees with the
  documented :sd times pixel area route exactly. Asking for :mass on particles without it says once that
  the map is a mean, because its sum drifts with the pixel size and reads as a conservation
  failure: measured at 0.0115, 0.0384, 0.121 and 0.487 of the true total at 200, 100, 50 and
  20 pc.

• :ncell and :npart, how many cells or particles fed each pixel. Asked for alongside any
  other variable and filled by the same deposit. What the number means depends on the kernel:
  :ngp counts one per object, :cic one per stencil pixel, :overlap one per pixel each sub-point touches and
  :exact one per pixel covered. It is how you find the pixels you cannot quote, since a pixel
  holding one object has a dispersion of exactly zero.

• depth and depth_unit, a slab cut along the line of sight. Every other window is world
  space and does not follow the camera. fov alone gives an uneven depth, because the sphere it
  selects is deepest on axis and reaches zero at the frame boundary; depth is what makes the
  column the same length everywhere. depth=[lo, hi] is an explicit window. Refused on the
  axis-aligned path, where zrange already cuts the same slab.

• A rectangular frame, fov=[wx, wy]. An edge-on disc is a thin strip, and in a square frame
  most pixels are empty sky at the same cost as the ones with the galaxy in them. Requires
  aperture=:square, because a rectangle has no single radius.

• Slices report three per-pixel diagnostics: coverage, cellsize and depth. A slice
  cannot report a cell count, since cells tile space and exactly one owns each pixel, so a count
  would read 1 everywhere. cellsize against pixsize is the useful one: where the cell is
  larger than the pixel, the extra pixels carry no extra information.

• Volume rendering inside Julia: volumerender, volumelook, volumeorbit, volumepath.
  Every cell gets a colour and an opacity from its value, and each line of sight is composited
  front to back, so dense gas in front hides what lies behind it; a projection cannot show that.
  volumelook resolves how a quantity looks (colour range from percentiles, colour map, opacity,
  isosurfaces each with its own opacity and width, exposure and a tone curve) once, so a movie
  keeps one look across frames and does not flicker. Opacity is set per unit length
  (tau_unit_length), so it does not change with the pixel size. volumeorbit renders a turning
  sequence through the same rotation-invariant sphere as rotation_sequence, and volumepath
  moves the camera between keyframes. Orthographic only. The line-of-sight velocity is available
  as a quantity, and a cell can be reconstructed linearly from shared corners instead of drawn as
  a flat block. For grid (hydro) data.

• center=:bc may be written as a bare symbol, and either object order works where two objects
  are passed.

Structure finding

• clumpfind with a choice of algorithm, since no single one suits every field:
  ThresholdFoF (friends-of-friends above a threshold, the default), DensityWatershed (splits
  touching peaks at saddles), GraphSegFinder (for smoothly varying density with no clean
  threshold), HDBSCANFinder (clumps spanning a wide density range), PhaseSpaceFoF (6D
  position and velocity, separating overlapping structures kinematically) and PersistenceFinder
  (ranks peaks by topological prominence in crowded fields). Dendrogram and StructureTree give
  the hierarchy, HashGrid / MortonGrid / CellLinkedList the neighbour search.
• clumptable, clump_massfunction, clump_mass_fraction and clumping summarise a catalogue;
  synthetic_clumps plus clump_recovery build fields with known clump positions and score a
  finder against them, so a result is measured rather than eyeballed.

Star formation

• Star formation, measured from the star particles. sfr gives the star-formation history
  SFR(t) and sfr_snapshot the current rate over look-back windows (5, 10, 100 Myr, the
  observational Hα and FUV equivalents) plus the lifetime mean. Both work on non-cosmological and
  cosmological runs, binning physical cosmic formation time rather than the conformal birth time
  RAMSES stores, and the integral of the history is independent of the bin width.
• Birth masses, not surviving masses. A star that formed long ago has already returned part of
  its mass to the gas, so integrating the current :mass understates the rate. sfr prefers a
  stored initial-mass column when the run has one, and otherwise rebuilds birth masses from the
  supernova fraction the run recorded in its own namelist, naming the value it used. On a Milky-Way
  run recording eta_sn = 0.2 this is 23% on SFR(100 Myr) and 25% on the lifetime mean;
  eta_sn=0 integrates the current mass as stored.
• depletion_time gives the gas depletion time M_gas/SFR and the star-formation efficiency per
  free-fall time.
• velocitydispersion gives a radial velocity-dispersion profile in the rest frame: the mean
  is removed per radial bin, so rotation and streaming do not inflate σ. It returns σ_R / σ_φ / σ_z
  (or the spherical triad, which adds the anisotropy parameter β) and with thermal=true adds the
  thermal speed, giving the line width an observer would measure.
• The thermal term is RT-aware. It uses the temperature computed with the local mean molecular
  weight and, by default, the μ the run itself implies: per cell from the ionization state where
  the run tracks it, mass-weighted per bin, and the constant Mera's temperature scaling assumes
  where it does not. On a run without RT this is the previous answer to machine precision; on an
  RT run the constant-μ temperature ran up to 2.6x high in ionized gas, which is about 15% on σ.
  A number still overrides μ, which is what you want when the thermal speed should be that of an
  observed tracer (2.33 molecular, 1.0 atomic H, 0.6 ionized) rather than of the mean gas.
• localdispersion measures small-scale turbulence the TIGRESS/SILCC way: the plane is tiled into
  patchsize patches and the per-patch mass-weighted mean velocity is subtracted, so bulk rotation,
  shear and spiral streaming above that scale are removed rather than counted as turbulence, with
  the thermal term included by default.

Statistics and profiles

• profile reduces any getvar quantity to a weighted radial (or arbitrary-variable) profile with
  mean, standard deviation and per-bin counts. It also takes a projection result directly, so
  the same call gives either the 3D profile from the cells or the Σ(R) surface-brightness profile
  an observer measures from the map, binned by image-plane radius, by :x/:y, or one map against
  another (weight=:sd for a column-weighted :vlos profile). The result says which it was
  (source=:data or :map), because the two answer different questions.
• profile3d bins on a 3D grid and profiletimeseries repeats a profile across snapshots.
• phase builds 2D phase diagrams (density-temperature and any other pair) and pdf the
  mass- or volume-weighted distribution of a single quantity.
• Plot helpers that take these results directly: overviewplot, levelsplot, massfunctionplot,
  clumpplot, benchmarkplot.

Reports and quick looks

• quicklook gives a one-call census of an unfamiliar output, with quicklookplot, cost
  estimation (estimate, preview, calibrate!, CostModel) and a budget.
• report builds a document from cards you compose yourself, one per panel: ProjectionCard for a
  map, PhaseCard for a phase diagram, ProfileCard for a radial profile, SFRCard for a
  star-formation history, ClumpCard for a catalogue, ScalarCard for a single number, and
  CombinedCard to group them. A card skips gracefully when a snapshot lacks what it needs.
  savemap / loadmap / loadreport store the result so a figure can be redrawn without
  re-reading the simulation.

Time series and movies

• timeseries evaluates the same measurement across a sequence of outputs and returns it as one
  table, so an evolution plot does not need a hand-written loop over snapshots.
• getmovie, savemovie, loadmovie, moviefromframes and MeraMovie render a sequence of
  frames and assemble them, including camera moves from rotation_sequence.

Performance

• A benchmark suite you run on your own data, because the answer depends on your AMR structure,
  file count and filesystem. run_benchmark does the full sweep; reading_sweep finds the thread
  count worth reading with (more is not always faster); benchmark_conversion answers whether
  converting to a MERA file pays for itself and after how many re-reads; benchmark_levels shows
  how cost grows with refinement; benchmark_projection_hydro, benchmark_mera_io and
  benchmark_buffer_sizes cover the other bottlenecks. benchmark_report and benchmarkplot
  present the result, and allocated_cpus and filesystem_info record the machine, including the
  cores a scheduler actually granted rather than the cores the node has.
• IO tuning for the machine you are on, since a laptop SSD and a parallel filesystem want different
  buffer sizes: configure_mera_io sets it by hand, optimize_mera_io / smart_io_setup /
  configure_adaptive_io / ensure_optimal_io! measure and choose, mera_io_status reports what
  is in effect and clear_mera_cache! empties the cache.
• batch_convert_mera converts a whole run to MERA files in one call, and
  interactive_mera_converter walks through the choices (which outputs, which components, level
  cap, compression) for a one-off conversion.

Reproducibility and configuration

• provenance / provenance_string record what produced a number: Mera and Julia versions, the
  simulation and output, the selection and the quantities, so a figure can be traced back to the
  call that made it. On a git checkout they name the branch and commit and mark an uncommitted
  tree, so a result made on development code cannot pass for one made on the release;
  mera_build() returns the same string for scripts, and MERA_PROVENANCE_PLAIN=1 forces the
  plain version number.
• makethumb writes a fixed-size preview image from a figure or an animation, fitting the whole
  picture into the card and padding with its own background so the outer panels of a wide figure
  survive; a crop mode with an anchor fills the card instead. It takes a frame part-way into an
  animation, because frame zero of a movie that opens on a static pose is the dullest one in it.
• A persistent config file so machine-specific choices (thread counts, IO buffers, verbosity) live
  outside your scripts: mera_config, mera_config_path, mera_config_example,
  show_mera_config, and output_mode for how Mera prints.
• Notifications for long runs, so a read that takes an hour can tell you when it is done:
  timed_notify reports how long a block took, send_results sends numbers or figures,
  safe_execute reports a failure instead of losing it, with progress trackers and image
  optimisation for upload.

This lists the features. The public API grew from 77 exported names in 1.7 to 284; the complete
list, including the supporting types (AbstractRegion, AbstractFinder, FilterCondition, the
report cards) and helpers such as downsample, center_of, collect_levels, save_clumps and
getvar_requirements, is in the
API reference.

Changed

• The classic region API no longer refuses a centre, it places the region and says so.
  subregion/shellregion guarded their centre with in(0., center) and raised
  [Mera]: given radius or center should be != 0. Any single zero component was rejected, so a
  sphere on the x = 0 face, or a halo at exactly z = 0 in a centred frame, could not be
  expressed without nudging the coordinate. An omitted centre now places the region at the box
  centre and says so.
• The first projection of a session costs 0.05 s instead of about 10 s, and getvar falls from
  1.5 s to 0.04 s. Precompilation covered the numerical kernels, which take plain arrays, while
  most of those ten seconds were the getvar machinery, which works on the table and was never
  reached. Results are unchanged: precompilation caches machine code, not values.
• Mera's one-off hints follow one policy and one look, and the longest are shorter.
• getvar(:cellsize) is about 330 times faster. It was built row by row through a closure
  over a variable the function reassigns, so Julia dispatched dynamically on every row: 60 s for
  51.5 million cells. It now reads the level column directly and takes 0.18 s, with bit-identical
  values. :volume, :mass and every off-axis projection and slice read it, so all of them gain:
  one off-axis slice on that run fell from 68 s to 7 s. Hydro, gravity and RT alike.

Removed

• PhysicalUnitsType and ScalesType are superseded by PhysicalUnitsType002 and
  ScalesType002 / ScalesType003. Files written by older versions still load.

Fixed

These change numbers you may have relied on

• A classic shell with cell=true dropped the cells on its inner surface. shellregion
  compared the inner radius with the nearest point of each cell, so a cell that touched the inner
  surface was left out, while every cell touching the outer surface was kept. The shell mass was
  therefore neither an upper bound nor a lower one. It now keeps every cell the shell touches, as
  every other classic shape does, so its mass is an upper bound; inverse=true returns exactly
  the other cells. Neighbouring classic shells now share the cells on their common surface: for a
  radial profile from nested shells use cell=false, or sphericalshell, which splits the cells.
  Hydro, gravity and RT.
• Pairing gravity with the wrong hydro cells gave a plausible wrong number. An energy or a
  force takes the cell mass from the hydro object, so pairing it with another cut's potential
  was silently wrong. The old guard only compared lengths, and only when a mask was given, so
  two different cuts holding the same number of cells passed. The cell indices are now compared
  once per call, with an error that names the fix. The mass is also computed once per call rather
  than once per quantity, taking five quantities on mw_L10 from 2.78 s to 2.19 s.
• The astronomical unit was wrong by a factor of 10¹⁵. constants.Au held 149597870700e-13,
  which is 0.015 cm; the figure is the AU in metres and the exponent had to convert to centimetres.
  Any length asked for in :Au was 10¹⁵ too large, and :Au3 volumes 10⁴⁵ too large. The existing
  test compared scale.Au against unit_l / constants.Au, which holds for any value of the
  constant, so it pinned the relationship and never the value. Two tests now pin the value.
• The gravitational potential was too small by a factor boxlen. RAMSES stores the
  potential divided by boxlen (its Poisson source carries an extra boxlen, and the gradient is
  taken in box units, so the stored force is right but the potential is not). getvar now
  multiplies by boxlen for :epot, :specific_gravitational_energy, :gravitational_energy and
  :total_binding_energy, and dataoverview does the same. Everything that reads them through
  getvar (projections, profiles, phase plots, filterdata) follows. Values change by the
  factor boxlen of each run: 48 for a 48 kpc box, nothing for boxlen = 1. Accelerations,
  forces and clumpfind were never affected. The stored column keeps RAMSES's value, so mera
  files saved earlier read correctly without conversion, and writeramses still writes back
  exactly what RAMSES wrote. Checked by differencing the potential against the stored
  acceleration on runs with boxlen 1 and 0.5.
• Velocity dispersion maps with mode=:sum were not widths. On grid data the box-frame maps
  (:σx, :σz, ...) took the root of Σv²w − (Σvw)², two sums. They are now built from the
  weighted means whatever mode says; the velocity components themselves stay sums.

Readers

• Legacy particle files lost their metallicity. In files without part_file_descriptor.txt
  (RAMSES before 2018) the field after the birth time was never read. It is now read as
  :metals, found by counting the fields of the first file.
• Asking only for particle fields beyond the fixed ones read nothing. getparticles(info, [:metals]) returned zeros, because the loop over extra fields ran to the number of selected
  fields instead of the number in the file. Unrequested extra fields are now skipped properly.
• getgravity failed on gravity files with the forces only. Older RAMSES versions store no
  potential; the reader expected four fields and read beyond the record. The fields are now
  counted from the file, and such data loads as [:ax, :ay, :az].
• Outputs written with ordering='bisection' could not be read. getinfo parsed the rank boxes
  as Hilbert walls and failed, and the readers skipped the wrong number of amr header records.
  Such outputs now load; as they list no Hilbert walls, every file is read.
• Outputs written with ordering='planar' or 'angular' crashed the readers with a
  BoundsError. Mera reads Hilbert and bisection outputs; getinfo now refuses the other two
  with a message saying so.
• Axis-aligned particle maps lost the first row and column of a window. The histogram edges
  started one pixel after the map extent, so about 4 % of the mass inside a 48-pixel window was
  silently dropped. The bins are now exactly the pixels of the window, for :x, :y and :z.

Other

• An empty region errored on derived quantities. A region can legitimately select nothing, a
  sphere smaller than one cell or a cut that misses the data, and getvar(:volume) or
  getvar(:cellsize) then failed inside the table machinery with a message naming internal
  fields rather than the empty selection. They now return an empty vector.
• Region selection in code units (range_unit=:standard). subregion/shellregion sphere,
  cylinder and shell shapes now honour center in code-unit mode; previously they ignored it and
  selected the wrong cells. The bug was masked in test simulations where one code length is about
  one kpc.
• Projection mass conservation (mode=:sum). Surface-density and mass maps no longer
  over-count; :sd/:mass and the extensive :ekin/:volume sums conserve to machine precision.
  (The same guarantee covers :etherm and the other extensive quantities added in this release.)
• Uncompressed savedata (compress=false) now saves correctly; an internal compression check
  returned a value jldopen rejected.
• export_vtk: corrected log10 handling, cell-data layout and indexing.
• getvar derived fields: :cz and :ϕ corrections, plus aggregation guards.
• RAMSES readers: namelist mis-parse, lmax clamping and general robustness fixes.

Documentation

• Every tutorial page is generated from a Jupyter notebook that is executed end to end, so the
  numbers and figures on a page were produced by the code above them. 49 notebooks, all current.
• New pages: Pipelines, How Quantities Are Computed, Reproducibility, Periodic Boxes, Coming from
  Other Tools, Julia for Simulation Analysis, First Look, Benchmarks, Star-Formation Rate,
  Clump Finding (with a synthetic ground-truth example), Covering Grid, Statistics, Provenance,
  Derived Fields, Magnetic Fields, Galaxy Frame, Time Series, Movies.
• Navigation restructured by task rather than by difficulty: the More catch-all and the
  Advanced Features grouping are gone, API Reference sits last, and the examples router was
  retired with its pages rehomed by topic.
• center explained in one place; the off-axis guide, profiles and phase tutorial, and the
  sub-region tutorials for gravity, particles and clumps rewritten; README overhauled.
• More new pages: Restart RAMSES with any number of CPUs (built from a notebook that runs
  RAMSES live, with the API page Writing RAMSES), Volume Rendering, an off-axis
  cheatsheet with every option on one page, Where to start (from "I want to ..." to the
  function), Using an AI Assistant with llms.txt and llms-full.txt, and a rewritten
  Testing Framework page around the public test data.
• New page Adding a Reader for Another Simulation Code: the metadata a reader fills, the cell
  convention for grid data and the position convention for particles and moving meshes, a runnable
  example that registers a reader from outside the package, how to test without any simulation
  files, and where the code-blind design stops.

Testing

• 71 test files, all wired into runtests.jl, split into an always-run block that anyone can run
  in a few minutes and a data-backed block the maintainer runs against real snapshots (about 7970
  tests in 24 minutes).

• Fifteen public test simulations with known answers, among them three of RAMSES's own test runs
  checked against the reference values the RAMSES developers publish, and cosmo3d, where
  Poisson's equation is checked in physical units on a cosmological run.

• test/86_ramses_writer_tests.jl. Data-free: Fortran records, Hilbert keys against
  a reference implementation (also beyond 53 bits), text formats, bisection trees. On the public
  fixtures: every rank's amr file rebuilt as RAMSES wrote it, repartition to 1, 3 and 7 ranks
  bit-identical, round trips, bisection and IO groups, walls without a namelist, the Mera-data
  route through a mera file with parents, old files, and refused data. Community samples when
  present: MHD on an AMR grid without descriptor or namelist, RT, and the legacy cosmological run.

• Every kind of run through every route. One test matrix takes each public simulation
  through RAMSES's own rank files, repartition to Hilbert, bisection and IO groups, and its Mera
  data through a mera file written the same three ways, then checks that together they covered AMR
  and uniform grids, both orderings, IO groups, gravity, RT, MHD, modern and legacy particles,
  sinks, clumps, physical walls and a cosmological run. For every output it also checks that the
  file blocks located from the amr headers are the ones found by reading every record, and that
  the domain walls found by bucket counting are the keys a full sort gives.

• Large outputs: benchmark_results/ramses_conversion.jl. Not part of the suite, because it
  writes tens of GB. It takes the public cosmological run to thousands of ranks and back, and
  writes it from Mera data at that rank count, which exercises the costs that grow with the
  square of the rank count; and it repartitions your own large outputs. Every step runs in its own
  process under /usr/bin/time, every result is compared value by value, and time and peak memory
  go to a CSV.

• Four new public fixtures in the testdata-v2 release (fifteen simulations, 307 MB):
  sedov3d_bisection, dm_gas3d_bisection and sedov3d_iogroups (RAMSES's own outputs in these
  layouts), and cosmo3d, a small cosmological run with gas, dark matter, gravity and AMR, run from
  RAMSES's own cosmological initial conditions averaged to 32³ by testdata/make_cosmo3d_ic.py.
  The archive holds the run only, not the initial conditions. The namelists are in
  testdata/namelists, and testdata-v1 is unchanged. A cosmological test checks Poisson's
  equation in physical units on it.

• The Jeans conventions are tested against an independent recomputation from P and ρ, and
  on a cosmological run against RAMSES's own code-unit formula.

• Analytic oracles rather than restated formulas: unit scales are checked by relations between
  scales on two unit systems, kernels against closed-form weighted statistics, the structure finder
  against synthetic ground truth, regions against analytic volumes, and masking by a metamorphic
  identity (getvar(q; mask=m) == getvar(q)[m]) on every data type.

• Aqua quality checks, and coverage reported separately for the CI-runnable tier and the full
  local suite.

Earlier releases

See the release notes for v1.7.0
and before.

Merged pull requests:

• Off-axis projection, derived-field registry, composable reports, SFR, clumpfinder (#64) (@ManuelBehrendt)
• Derived-field follow-ups: custom units + dependency introspection (#65) (@ManuelBehrendt)
• Clumpfinder: watershed deblending + bound-substructure trees (#66) (@ManuelBehrendt)
• Clumpfinder v2: pluggable finder framework + boundedness physics + hierarchy (#67) (@ManuelBehrendt)
• Clumpfinder v2 Phase 4: density-adaptive finders + composition + threading (#68) (@ManuelBehrendt)
• Clumpfinder v2 Phase 5: 6D phase-space FoF + persistence (ToMATo) finders (#69) (@ManuelBehrendt)
• Clumpfind: MortonGrid (Z-order) neighbour backend for cache locality (#70) (@ManuelBehrendt)
• quicklook: quicklookplot Makie extension (3-panel first-look dashboard) (#71) (@ManuelBehrendt)
• covering_grid / slice: AMR → uniform fixed-resolution buffer (with a memory estimator) (#72) (@ManuelBehrendt)
• test: data-free conservation + weighted-statistics oracle (smoke CI) (#73) (@ManuelBehrendt)
• fluxbudget: conservation-correct inflow/outflow flux through a surface (#74) (@ManuelBehrendt)
• fluxbudget: sampling uncertainty + fluxprofile Ṁ(R) (better statistics) (#75) (@ManuelBehrendt)
• fluxbudget follow-ups: off-axis/L-aligned surfaces, fluxmapplot, bootstrap CIs (#76) (@ManuelBehrendt)
• Tidal-tensor truncation (clumpfind) + off-axis fluxshell/fluxmap (#77) (@ManuelBehrendt)
• docs: feature figures for fluxbudget, clumpfind, covering_grid, quicklook (#78) (@ManuelBehrendt)
• bubble / bubbletimeseries: follow a hot SN superbubble from its stellar origin (#79) (@ManuelBehrendt)
• Docs + quicklook: global snapshot budget, Quick Look page, finder gallery, doc fixes (#80) (@ManuelBehrendt)
• clumpfind: panel remediation — plot recipes, public-API tests, validation guards, docs (#81) (@ManuelBehrendt)
• docs(clumpfind): clarify threshold-dependence & boundedness in the catalog example (#82) (@ManuelBehrendt)
• fluxbudget: correctness set — :metals/:energy guards, cosmological warning, conversion-factor tests (#83) (@ManuelBehrendt)
• docs(flux): sensible per-function figures + fix the washed-out fluxmap (#84) (@ManuelBehrendt)
• Projection correctness fixes + docs (parttypes, off-axis clip, LOS-cube qrange) (#85) (@ManuelBehrendt)
• Projection cleanup: remove dead code + document map-type fields (#6, #7) (#86) (@ManuelBehrendt)
• Covering-grid panel remediation: type guard + cleanup + tests/docs (#87) (@ManuelBehrendt)
• getvar/derived-fields panel remediation (all tiers): :cz/:ϕ/escape_speed fixes, aggregation guards, registry tests (#88) (@ManuelBehrendt)
• list_fields: add builtin= to list built-in + custom derived fields (#89) (@ManuelBehrendt)
• docs: render the live list_fields(builtin=true) catalogue in derived_fields (#90) (@ManuelBehrendt)
• docs: render the builtin=false (default) list_fields path live (#91) (@ManuelBehrendt)
• RAMSES readers panel remediation (all tiers): namelist mis-parse, lmax/clamp, robustness, tests (#92) (@ManuelBehrendt)
• docs: declutter the Profiles & Phase tutorial (658→291 lines) (#93) (@ManuelBehrendt)
• profile/phase panel remediation (all tiers): binning guards + consistency + tests (#94) (@ManuelBehrendt)
• docs(profiles tutorial): 3-D per-annulus σ vs local per-pixel :σlos note (#95) (@ManuelBehrendt)
• LOS-cube panel remediation (all tiers): validate moments/qrange/loadcube + tests/docs (#96) (@ManuelBehrendt)
• save/load + VTK panel remediation (all tiers): VTK log10/celldata + uncompressed-save fix + tests (#97) (@ManuelBehrendt)
• regions panel remediation (all tiers): fix :standard center bug + direction + gravity cylinder (#98) (@ManuelBehrendt)
• docs: re-render notebooks (maintainer pipeline) — repairs ANSI-stripper bracket corruption (#99) (@ManuelBehrendt)
• docs: overhaul README (first-look, verified quickstart, honest roadmap) (#100) (@ManuelBehrendt)
• docs: add camera-basis math to off-axis guide (#101) (@ManuelBehrendt)
• docs: add 'How Quantities Are Computed' reference page (#102) (@ManuelBehrendt)
• docs: nav cleanup - remove duplicates, surface orphaned pages (#103) (@ManuelBehrendt)
• docs: scrub leaked temp path from LOS cubes tutorial (#104) (@ManuelBehrendt)
• deps: widen HTTP compat to 1, 2 (#105) (@ManuelBehrendt)
• docs: expand computation_reference (T/μ, RT, γ, projection & profile stats) (#106) (@ManuelBehrendt)
• getvar(RT): H2-aware species layout + xHI/xH2/n_H2 + H2-correct mu (#107) (@ManuelBehrendt)
• docs: mark required data object per quantity (computation_reference) (#108) (@ManuelBehrendt)
• MHD: descriptor-aware variable naming + cell-centred B + magnetosonic Mach (#109) (@ManuelBehrendt)
• MHD: getinfo overview line + AMR MHD dataset + data/quantity/descriptor awareness tests (#110) (@ManuelBehrendt)
• Descriptor-driven database column names for hydro + particles (#111) (@ManuelBehrendt)
• docs: descriptor names in remaining InfoType-dump tutorial snippets (#112) (@ManuelBehrendt)
• docs: descriptor names in remaining column-row / propertynames snippets (#113) (@ManuelBehrendt)
• quicklook: polish dashboard panels + add First Look docs page (#114) (@ManuelBehrendt)
• docs: fix First Look nav (broken ref + duplicate from #114) (#115) (@ManuelBehrendt)
• getvar(MHD): add :bmag, :pmag, :beta, :v_alfven, :e_magnetic (+ :nG unit) (#116) (@ManuelBehrendt)
• quicklook: MHD-aware dashboard — face-on |B| panel + |B|/β census (#117) (@ManuelBehrendt)
• benchmark: built-in I/O benchmark plot (no download) + fix TDist crash (#118) (@ManuelBehrendt)
• fix: revert :nG — it broke loading pre-existing mera files (backward compat) (#119) (@ManuelBehrendt)
• types: versioned ScalesType003 (+ :nG) — old mera files keep loading (#120) (@ManuelBehrendt)
• test: ScalesType version coverage across functions (+ 2 fixes it surfaced) (#121) (@ManuelBehrendt)
• types: forward-compatible loading for InfoType + data containers + sub-structs (#122) (@ManuelBehrendt)
• docs(off-axis): "How each AMR cell is treated" section + vector figure (#123) (@ManuelBehrendt)
• docs(off-axis): vector figure for the :exact per-pixel integration (#124) (@ManuelBehrendt)
• docs(off-axis): rewrite the two figures for a broad audience (#125) (@ManuelBehrendt)
• bell(): 19 selectable notification sounds (by name or number) + ~/bell.txt default (#126) (@ManuelBehrendt)
• timeseries(): multi-snapshot reducer→table over RAMSES & mera files (#127) (@ManuelBehrendt)
• auto-frame: center_of + face_on/edge_on (orientation from gas angular momentum) (#128) (@ManuelBehrendt)
• docs(auto-frame): Method & references section + KaTeX fix (#129) (@ManuelBehrendt)
• docs: mock-observations cookbook (auto-frame → existing mock-obs tools) (#130) (@ManuelBehrendt)
• stats: pdf() — weighted PDFs over hydro/particles/gravity/RT + 2D maps (roadmap #4) (#131) (@ManuelBehrendt)
• provenance: reproducible record of where a result came from (roadmap #5) (#132) (@ManuelBehrendt)
• provenance: human-readable time (Myr/Gyr) + redshift; document .info scope (#133) (@ManuelBehrendt)
• provenance: wire .info into derived results (pdf, position_velocity, GalaxyFrame) (#134) (@ManuelBehrendt)
• timeseries: human-readable time (Myr) by default + redshift/aexp for cosmological runs (#135) (@ManuelBehrendt)
• output_mode master switch + dedicated myargs / verbose-progress docs pages (#136) (@ManuelBehrendt)
• docs(myargs): compare with native NamedTuple splatting; when to use which (#137) (@ManuelBehrendt)
• getmovie / savemovie: projection-over-outputs → frames → animated GIF (#138) (@ManuelBehrendt)
• movie: scratch frames, movie-from-images, and configurable per-frame tags (#139) (@ManuelBehrendt)
• getmovie: expose the full off-axis projection view (#140) (@ManuelBehrendt)
• docs(off-axis): broaden the two cell-treatment figures for a wider audience (#141) (@ManuelBehrendt)
• savemap/loadmap + movie .jld2 persistence (JLD2, the mera-files way) (#142) (@ManuelBehrendt)
• PLUTO frontend: read PLUTO data into Mera, analysis runs unchanged (#143) (@ManuelBehrendt)
• PLUTO: timeseries/getmovie support + complete workflow example (#144) (@ManuelBehrendt)
• PLUTO AMR (Chombo) reader: box-structured AMR → leaf cells, analysis unchanged (#145) (@ManuelBehrendt)
• gridoverlay + absorption_map + PLUTO physical units (#146) (@ManuelBehrendt)
• PLUTO particle reading: getparticles_pluto -> PartDataType (#147) (@ManuelBehrendt)
• docs: add a docstring to loadmap (#148) (@ManuelBehrendt)
• docs: dedicated docstrings for loadcube and verbose (#149) (@ManuelBehrendt)
• feat: total (turbulent⊕thermal) velocity dispersion + de-streaming, SN-corrected SFR, depletion time (#150) (@ManuelBehrendt)
• docs: total/thermal dispersion, localdispersion, depletion-time in computation_reference (#151) (@ManuelBehrendt)
• feat: variable (per-cell) opacity in absorption_map + dust_opacity(λ) helper (#152) (@ManuelBehrendt)
• fix: pin JLD2 to 0.5 (Mera compression incompatible with JLD2 0.6) (#153) (@ManuelBehrendt)
• feat: JLD2 0.6 support (LZ4-only) + read all older Mera file versions (#154) (@ManuelBehrendt)
• docs: correct converter function names + explain loading/converting older Mera files (#155) (@ManuelBehrendt)
• clumpfind: composable ValidatorChain / Bound() value-type API (#156) (@ManuelBehrendt)
• clumpfind: synthetic ground-truth example, accuracy test & docs (#157) (@ManuelBehrendt)
• clumpfind: synthetic ISM backgrounds & noise (clumps vs the floor) (#158) (@ManuelBehrendt)
• clumpfind: synthetic bench into the package + explicit 3-D test/figure + finder guide (#159) (@ManuelBehrendt)
• clumpfind: parameter-sensitivity tuning guide (#160) (@ManuelBehrendt)
• regions: composable region value types + exact edge-cell splitting (Phase 1) (#161) (@ManuelBehrendt)
• regions: boolean combinators + split-error quantification (Phase 2) (#162) (@ManuelBehrendt)
• regions: one-shot hint from legacy symbol API to value-type form (#163) (@ManuelBehrendt)
• regions: projection of split cells — exact region-clipped maps (Phase 3) (#164) (@ManuelBehrendt)
• regions: tilted / arbitrary-axis Cylinder (Phase 4) (#165) (@ManuelBehrendt)
• regions: value-type subregion for particles, gravity & RT (Phase 5) (#166) (@ManuelBehrendt)
• regions: value-type subregion for clumps (point membership) (#167) (@ManuelBehrendt)
• regions: fix value-type subregion on uniform grids (no :level column) (#168) (@ManuelBehrendt)
• docs: value-type region sections in the subregion tutorials (#169) (@ManuelBehrendt)
• regions: CylindricalShell value type + shell tutorial sections (#170) (@ManuelBehrendt)
• filtering: value-space selection on derived quantities (filterdata / getmask) (#171) (@ManuelBehrendt)
• filtering: more condition types + @filter macro routes Mera objects (#172) (@ManuelBehrendt)
• filtering: strengthen tests + real-output tutorial examples (#173) (@ManuelBehrendt)
• docs: pedagogical onramp + integrate filterdata/getmask into the masking tutorial (#174) (@ManuelBehrendt)
• docs: consolidate the legacy filtering sections in the masking tutorial (#175) (@ManuelBehrendt)
• docs: modernize the masking examples to getmask + conditions (#176) (@ManuelBehrendt)
• docs: link Extend-the-Data-Table to the simpler derived-quantities path (#177) (@ManuelBehrendt)
• readers: Athena++ (.athdf) frontend with AMR support (#178) (@ManuelBehrendt)
• readers: validate Athena++ on real data (yt AM06) + fix slow load (#179) (@ManuelBehrendt)
• docs: illustrate Athena++/PLUTO readers with real getinfo output + projections (#180) (@ManuelBehrendt)
• docs: Athena++ MHD figures — B-field streamlines + density–|B| phase diagram (#181) (@ManuelBehrendt)
• docs: AMR refinement-level maps + full CairoMakie code in reader docs (#182) (@ManuelBehrendt)
• docs: collapsible plotting-code blocks in reader docs + dynamic footer year (#183) (@ManuelBehrendt)
• readers: load-time spatial selection for PLUTO/Chombo/Athena++ (align with yt / athena_read / pyPLUTO) (#184) (@ManuelBehrendt)
• readers(Athena++): block-level I/O pruning for spatial sub-regions (yt-style hyperslab reads) (#185) (@ManuelBehrendt)
• readers(Chombo): block-level I/O pruning for spatial sub-regions (#186) (@ManuelBehrendt)
• readers: add FLASH frontend (HDF5 PARAMESH AMR) (#187) (@ManuelBehrendt)
• docs(FLASH): show the sloshing cold front (temperature slice) instead of a look-alike projection (#188) (@ManuelBehrendt)
• docs+test: multi-code capstone (overview page + cross-reader contract test + lmax warning) (#189) (@ManuelBehrendt)
• readers: code-blind output discovery — timeseries/getmovie for Athena++/Chombo/FLASH (#190) (@ManuelBehrendt)
• readers: savedata/loaddata round-trip for external codes (Mera-file interoperability) (#191) (@ManuelBehrendt)
• docs: show reference runs visually + with data/outputs (Athena++ MHD blast time series) (#192) (@ManuelBehrendt)
• readers: expose self-gravity potential as canonical :gpot (code-blind gravity) (#193) (@ManuelBehrendt)
• readers: canonical chemistry/RT species naming for external codes (code-blind) (#194) (@ManuelBehrendt)
• docs: plot + worked examples for the self-gravity and chemistry runs (#195) (@ManuelBehrendt)
• readers: six-ray RT radiation fields → canonical photon groups (:Np1..:Np8) (#196) (@ManuelBehrendt)
• docs/test: evolving six-ray PDR (CVODE) — radiation + chemistry stratification (#197) (@ManuelBehrendt)
• readers: add GADGET frontend (HDF5 particles) — closes the particles gap (#198) (@ManuelBehrendt)
• readers(GADGET): load-time spatial selection for particles (per-type, on read) (#199) (@ManuelBehrendt)
• docs: revise the multi-code reader pages to a consistent structure (#200) (@ManuelBehrendt)
• docs(nav): rename "Other Codes" → "Other Simulation Codes" (#201) (@ManuelBehrendt)
• docs: per-page "Run it yourself" notebook link on every tutorial (#202) (@ManuelBehrendt)
• docs(nav): conservative declutter — consolidate API pages, collapse reference groups (#203) (@ManuelBehrendt)
• docs: link the runnable multi-code notebook from the overview (#204) (@ManuelBehrendt)
• coverage: add notebooks 09-16 to the suite + self-heal Mera dev path (#205) (@ManuelBehrendt)
• docs: 17 feature pages get runnable, coverage-driving notebooks (#206) (@ManuelBehrendt)
• docs(nav): promote Other Simulation Codes to top-level; reorder Analysis & Calculations (#207) (@ManuelBehrendt)
• docs(nav): group Analysis & Calculations into 6 upper topics (#208) (@ManuelBehrendt)
• docs(nav): unify Projection with the map pages into 'Projection & Maps' (#209) (@ManuelBehrendt)
• docs(nav): re-home pages by what they are (holistic consistency pass) (#210) (@ManuelBehrendt)
• docs(nav): promote LOS Cubes & Kinematics to a visible Projection & Maps entry (#211) (@ManuelBehrendt)
• ci: drop redundant docs/deploy job from CI.yml (fixes gh-pages push race) (#212) (@ManuelBehrendt)
• readers(GADGET/AREPO): read gas-cell fields + derive volume/T (Phase 1a) (#213) (@ManuelBehrendt)
• readers(GADGET/AREPO): comoving→physical a/h conversion (Phase 1b) (#214) (@ManuelBehrendt)
• fix(projection): correct volume-weighting of intensive particle fields (#215) (@ManuelBehrendt)
• docs(GADGET): document gas analysis + maps (AREPO/TNG) (#216) (@ManuelBehrendt)
• projection(particles): SPH-kernel deposition for gas maps (Phase 2b) (#217) (@ManuelBehrendt)
• docs(AREPO): notebook parity — link end-to-end gas notebook, fix multi-code table (#218) (@ManuelBehrendt)
• docs: rendered multi-code notebook page (Other Sim Codes → Worked Examples) (#219) (@ManuelBehrendt)
• readers(GADGET): distinguish AREPO/SWIFT from plain GADGET (#220) (@ManuelBehrendt)
• docs: re-render multi-code page — TNG shows "Code: AREPO" (#221) (@ManuelBehrendt)
• docs(AREPO): fix empty gas map (zoom to halo) + explain moving-mesh projection (#222) (@ManuelBehrendt)
• projection(particles): Voronoi (nearest-generator) deposition for moving-mesh gas (#223) (@ManuelBehrendt)
• docs(AREPO): add SPH-vs-Voronoi temperature panel (#224) (@ManuelBehrendt)
• docs: dedicated AREPO / IllustrisTNG reader page (#225) (@ManuelBehrendt)
• docs(AREPO): box-filling ArepoBullet maps + rename page to "AREPO" (#226) (@ManuelBehrendt)
• fix: HDBSCAN noise-label OOB + subregion sphere/cylinder unit inversion (#227) (@ManuelBehrendt)
• test: relink fixtures to code-wise test-data layout (#228) (@ManuelBehrendt)
• docs(graphic): add simulation-code source band to TypeHierarchy (#229) (@ManuelBehrendt)
• docs(graphic): add multi-code capability matrix (#230) (@ManuelBehrendt)
• docs(graphic): TypeHierarchy — show PLUTO also feeds PartDataType (#231) (@ManuelBehrendt)
• docs(graphic): correct capability matrix — PLUTO MHD + gravity field vs object (#232) (@ManuelBehrendt)
• readers(GADGET/AREPO): MagneticField, Potential + bonus gas fields (#233) (@ManuelBehrendt)
• getvar(particles): derived magnetic fields (:bmag/:pmag/:beta/:v_alfven/:mach_*) (#234) (@ManuelBehrendt)
• test: skip particle magnetic fields in FIELD_DEPS compute-branch guard (#235) (@ManuelBehrendt)
• test: resolve full-suite namespace collisions (Sphere/timeseries vs CairoMakie) (#236) (@ManuelBehrendt)
• projection: clarify .extent is code-length units + add getextent(proj, unit) (#237) (@ManuelBehrendt)
• docs(clumpfind): detailed algorithms & implementation section + references (#238) (@ManuelBehrendt)
• docs(clumpfind): note finders are AMR/resolution/code-agnostic (#239) (@ManuelBehrendt)
• feat: overviewplot — visual AMR/particle statistics overview (#240) (@ManuelBehrendt)
• feat(overviewplot): add GravDataType method (#241) (@ManuelBehrendt)
• docs: embed rendered overviewplot example figures (#242) (@ManuelBehrendt)
• fix(storageoverview): RT/particle prefix collision + non-RAMSES footprint (#243) (@ManuelBehrendt)
• docs: explain what Chombo is (AMR framework / file format, not a code) (#244) (@ManuelBehrendt)
• fix(projection): off-axis :overlap holes/moiré on capped AMR cells (LOS cubes) (#245) (@ManuelBehrendt)
• feat(getextent): support LosCubeType (cube sky extent) (#246) (@ManuelBehrendt)
• docs(loscubes): refresh 12_multi_LosCubes from the notebook + figures (#247) (@ManuelBehrendt)
• docs(loscubes): clean kinematic figures on a resolved disk (#248) (@ManuelBehrendt)
• refactor(loscubes): move LOS-cube/kinematics/mock layer to an in-development module (#249) (@ManuelBehrendt)
• refactor(offaxis): move column_integral/emission/absorption/FITS to dev; keep offaxis_slice (fixed) + gridoverlay (#250) (@ManuelBehrendt)
• fix(offaxis_slice): true plane∩cell cross-section + slice & orbit-movie doc examples (#251) (@ManuelBehrendt)
• feat(rotation_sequence): aperture=:square — full rectangular orbit frame (#252) (@ManuelBehrendt)
• docs(offaxis_slice): explain tilted non-square cells in inclined slices (#253) (@ManuelBehrendt)
• docs(offaxis): square aperture in the FOV illustration (#254) (@ManuelBehrendt)
• feat(rotation_sequence): parallel_frames — frame-level multithreading (#255) (@ManuelBehrendt)
• fix(rotation_sequence): orbit/FOV works for particles & RT (max_threads hydro-only) (#256) (@ManuelBehrendt)
• docs(offaxis): reproducible thread-scaling script for offaxis_scaling.png (#257) (@ManuelBehrendt)
• docs(offaxis): offaxis_scaling.png is now the output of the shown benchmark (#258) (@ManuelBehrendt)
• slice: one cutting-plane name for axis-aligned and off-axis cuts (#259) (@ManuelBehrendt)
• feat(immersive): 3-D volume ray-caster in core Mera (public + tested) (#260) (@ManuelBehrendt)
• feat(immersive): isosurface + shading + field-driven absorption + interactive AMR window (#261) (@ManuelBehrendt)
• feat(immersive): optional smooth=:kernel (cubic B-spline) for coarse-cell beauty frames (#262) (@ManuelBehrendt)
• feat(immersive): toggle the occupancy acceleration (occupancy= / set_occupancy) (#263) (@ManuelBehrendt)
• fix(immersive): mode-aware jitter (smooth :max) + save_figure + montage pxsize (#264) (@ManuelBehrendt)
• feat(immersive): P1 batch + science wrappers (signed fields, tone-map, movies, column_map/derived_volume/moment_maps) (#265) (@ManuelBehrendt)
• feat(immersive): P2 correctness — depth-composited stars, iso flythrough kwargs, dial docs (#266) (@ManuelBehrendt)
• feat(immersive): view_colorbar — scalar maps with an aligned value colorbar (#267) (@ManuelBehrendt)
• feat(immersive): isosurface ambient occlusion + self-shadows (#268) (@ManuelBehrendt)
• feat(immersive): pre-integrated transfer function (single-field render_scene) (#269) (@ManuelBehrendt)
• feat(immersive): gradient-shaded render_scene + per-level coloured isosurfaces (#270) (@ManuelBehrendt)
• feat(immersive): overlay_grid — coordinate-system / graticule overlay for view planning (#271) (@ManuelBehrendt)

Closed issues:

• getinfo() throws BoundsError parsing info_rt_NNNNN.txt from ramses-2025.05 RT outputs (#61)