Use gt4py staggered dimensions for KHalfDim

[havogt]

Introduces real staggered vertical dimensions using gt4py 1.2.0's
gtx.flip_staggered (ADR next/0026, GridTools/gt4py#2667), replacing the
convention where half-level fields were KDim arrays allocated with
extend={KDim: 1}.

KHalfDim = gtx.flip_staggered(KDim)   # Dimension("_StaggeredK", VERTICAL)

Grid.size[KHalfDim] == num_levels + 1. Static vertical shifts become
half-integer cartesian offsets instead of a FieldOffset.

Index convention

Half level k bounds model level k from above, matching ICON:

read from	expression	resolves to
a K output index	a(KDim - 0.5)	half[k]
a K output index	a(KDim + 0.5)	half[k+1]
a KHalf output index	a(KHalfDim + 0.5)	full[k]
a KHalf output index	a(KHalfDim - 0.5)	full[k-1]

The practical rule: an integer ±1 offset that used to cross the two grids
collapses into the ±0.5.

Scope

All packages that allocate vertical fields: common, diffusion, dycore,
testing, bindings, muphys, microphysics, tracer_advection,
standalone_driver. tools and physics_driver have no vertical allocations.

Points worth review:

• Mixed-grid fused operators use a tuple of per-output domain= dicts, one
  per output field, so a single fused out=(...) can write fields on different
  vertical grids.
• pressure_ifc is computed by keeping the scan on KDim and staggering its
  result in a separate plain field operator with
  concat_where(KHalfDim == nlev, ...). A scan whose axis differs from its
  output's vertical dimension is rejected by the embedded backend, and embedded
  also cannot take tuple domains together with a scan.
• Half↔full copy stencils are split per direction, since a single program
  can no longer serve both.
• no dimension generics in gt4py means vertical-agnostic horizontal helpers
  need one copy per grid (_init_cell_khalf_field_with_zero_wp and friends).
• as_offset on a staggered field: stagger first, then apply the dynamic
  shift — the offset field must carry the dimension being shifted.

Verification

Against serialized reference data on gtfn_cpu:

suite	result
test_velocity_advection.py	22/22
test_solve_nonhydro.py, driver subset	8/8
test_advection.py	4/4
metrics datatests	111

Plus the non-datatest suites (common 606, diffusion 25, dycore stencil 76,
tracer_advection 30, muphys 58, standalone_driver 45), and pre-commit.

Worth flagging for reviewers: the dycore stencil suite's 73 xfails are
backend-conditional. embedded_remap_error and uses_concat_where xfail only
on embedded, which is the backend that suite is normally verified on, so those
fused stencils were never type-checked. Running them on gtfn_cpu showed their
fixtures still allocated half-level fields on KDim and their numpy references
assigned nlev+1-wide results into nlev-wide slices — several of those
assignments are broken on main too, as the shared *_numpy helpers always
return nlev+1. Those are fixed here; 14 of the 17 affected files are now green
on gtfn_cpu.

Draft — open items

• 21 solver-test failures fixed (136a4fce2). Root cause: the numpy helper
  solve_tridiagonal_matrix_for_w_back_substitution_numpy was rewritten to take a
  KHalfDim-wide w, but both composite solver tests still handed it the
  KDim-truncated slice next_w[:, :n_lev]. Its nlev = w.shape[1] - 1 then came
  out one short, so the backward sweep pinned half level nlev-2 instead of nlev-1
  and dropped that level's recurrence term; the error propagated upward through
  w_new[k+1], decaying by the z_q factor per level. That is exactly the
  measured signature (deviations at k=35..38 only, peak k=37/38, k=39 and k=40
  clean, magnitudes in the ratio 1 : 1 : z_q : z_q^2).
  test_vertically_implicit_dycore_solver_at_{predictor,corrector}_step.py now
  pass 9/9 and 12/12 on gtfn_cpu with the fixtures' usual unseeded random data.

• Not yet run: bindings datatests, MPI, diffusion integration,
  test_solve_nonhydro.py in full, and any GPU backend.

• compute_hydrostatic_correction_term keeps the pre-staggering formulation and
  is handed theta_v_ic relabelled onto KDim via a zero-copy view, because
  dace cannot lower as_offset applied to a staggered access (standalone
  reproducer filed separately). It is the one place in the dycore not using
  staggering, marked with a TODO.

🤖 Generated with Claude Code

[github-actions]

When developing, you can test your changes on CSCS CI before merge with the default pipeline: cscs-ci run default. This will run a default subset of tests.

You can pass options to override pipeline variables, for example:

• cscs-ci run default;BACKENDS=gtfn_cpu;LEVELS=unit
• cscs-ci run default;MODEL_SUBPACKAGES=common:driver;SESSIONS=model
  Avoid running the pipeline for all tests when you are developing.

Available options are:

• SESSIONS: model, model_mpi, or tools (correspond to nox sessions)
• MODEL_SUBSETS: datatest, basic, or stencils (correspond to nox session selections)
• MODEL_SUBPACKAGES: subpackages for non-MPI tests (last component, e.g. diffusion, driver)
• MODEL_MPI_SUBPACKAGES: subpackages for MPI tests (as above)
• BACKENDS: backends
• GRIDS: grids for stencil tests (simple, icon_regional, or icon_global)
• LEVELS: testing level for non-stencil tests (unit or integration)

For each option, all can be used as a shorthand for all possible values of that variable, e.g. LEVELS=all.

See scripts/python/generate_ci_pipeline.py and noxfile.py for available values for each option.

The all pipeline can be run with cscs-ci run all. This will run all icon4py tests in CSCS CI which can be expensive. This pipeline runs on a schedule on main, and can be run when extensive validation is needed (e.g. before releases).

Merging

Once your PR is approved and ready for merging, add it to the merge queue. The merge CSCS CI pipeline will run automatically on the merge-queue branch and must pass before the PR is merged. A dummy merge check will be triggered on the PR itself since it's required to add a PR to the merge queue.

Optional Tests

To run benchmarks you can use:

• cscs-ci run benchmark-bencher

For more detailed information please look at CI in the EXCLAIM universe.