rdb_ocean_kappa_shear Module

Components

Type-Bound Procedures

Largest dt_test <= dt_rem such that, after mixing for 0.5*dt_test with kappa_out_s, the regenerated source stays within the tolerance bands of the accepted-state source (design doc section 5.3): a halving pass followed by a 5-step refinement pass.

Arguments

Return Value real(kind=wp)

Shear-source function K_src at one interface (JHL08 eq. for the source term): nonzero only where N^2 < Ri_c * S^2.

Arguments

Return Value real(kind=wp)

Counted allocatable footprint of the kappa-shear slot (0 when unallocated). One arr_bytes term per array — add a term here when a new allocatable joins the type.

Arguments

Return Value integer(kind=int64)

Run kappa-shear over the domain: fill this%kd_int (interface diffusivity). Call at thermo cadence with the thermo dt. Outer shim: dereferences the tracer-registry hTr arrays on the host (the array-of-DT indirection blocks NVHPC device codegen), then forwards to the column kernel. Velocities reach the kernel as the C-grid face arrays, face-averaged to tracer points inside (same source as the PP81 interior shear).

Arguments

Fold the kappa-shear diffusivity into the vmix interface fields, ADDITIVELY (MOM6 interior-diffusivity semantics). Called EVERY stage (the interior closure rewrites kv/kt each stage; kd_int itself refreshes at thermo cadence). Interior interfaces only — K=1 (bed) and K=nz+1 (surface) stay zero in both source and target.

Arguments

Corner -> tracer-point averaging (MOM6 vertex form, Pass C). Cell (i,j) reads its four corners SW=(i,j), SE=(i+1,j), NW=(i,j+1), NE=(i+1,j+1) — a read-only corner stencil into an own-cell write, safe as its own do concurrent but NEVER fusable with the corner solve (kd_corner is the required snapshot). Two modes: arithmetic (default): 0.25 * ((SW+NE) + (NW+SE)) geometric: 4th root of the product of the four corner values, each floored at kdmin first — a geometric mean is 0 if ANY factor is 0, which would otherwise blank Kd along every shear-zone edge. The floor applies to the CORNER values only, never the output: a land cell still gets exactly 0 via the wet_t multiply. Endpoints (bed K=1, surface K=nzp1) are forced to exactly 0. tke_int is zeroed — the vertex form does not carry a cell-centred TKE (corner TKE deliberately not materialised). Bracketing is reproducible-sum ordering; keep literal.

Arguments

Assemble the surface-down column at corner (ic,jc) from the 2x2 cell patch + 4 adjacent faces (JHL08 vertex form; the interpolation recipes of the reference implementation): u,v : 2-point THICKNESS-weighted average across the corner, with the face thickness itself a mask-weighted 2-cell average (recomputed inline — deterministic, so the repeated evaluation is bitwise identical to MOM6’s precomputed h_at_u/h_at_v Pass A, non-OBC-bug form). T,S : 4-cell mask-AND-thickness-weighted average. The registry stores hTr = hT, which is exactly the weighted quantity, so we sum wethTr directly. h : 4-cell mask-weighted average (no thickness weight — it IS the thickness). Returns RAW h (no floor) — the caller decides floor vs massless-merge exactly as the column path does. The deliberate (SW+NE)+(SE+NW) bracketing is reproducible-sum ordering — do not reassociate.

Arguments

Per-column JHL08 solve. One do concurrent (j, i) over owned cells; every column is solved serially in surface-down order. Per-thread work is fixed-size local() arrays (L1 layout — all live in GPU registers, no shared memory); the column solve bodies are the same-module pure !$acc routine seq helpers below.

Arguments

Per-CORNER JHL08 solve (MOM6 vertex form, Pass B). One do concurrent (jc, ic) over the interior corners [2,nx]x[2,ny] — the set whose full 2x2 cell patch exists in-array, which covers every corner any owned tracer cell needs (nghost >= 1). Ring corners stay 0.

Arguments

The inner Picard solve (design doc section 5.4): alternate a TKE tridiagonal sweep (Dirichlet surface, e1 tail below the deepest active interface) with a kappa tridiagonal sweep (smooth truncation ramp + active-range tracking) until the Picard increment converges. Scratch arrays are supplied by the caller to avoid double-allocating per-thread stack.

Arguments

Build the thickness-derived interface grids that the iteration reuses: 1/h, the interface 1/dz, the harmonic-mean interface FV cell thicknesses h_Int (Sum h_Int = Sum h), and the inverse boundary length scale squared (design doc section 5.1).

Arguments

Mix (u0,v0,T0,S0) implicitly with kappa_ps over dt_now, restricted to the layer band [ks,ke], and recompute N^2/S^2 at interfaces (band edges blend mixed inside / original outside). Backward-Euler tridiagonal; no-slip for u,v iff the band reaches the bed (ke==nz), insulating T,S. N^2 floored at 0 (design doc section 5.5).

Arguments

Full JHL08 column solve in surface-down indices (design doc section 5.1-5.2): background kappa_0 pre-step (no-slip bed for u,v; insulating T,S), frozen interface buoyancy derivatives, e1 tail recursion, then the adaptive predictor-corrector outer loop driving the Picard inner solve. Returns the time-mean diffusivity kappa_avg_sd and TKE tke_avg_sd over dt.

Arguments

Arguments

Arguments

Arguments

Arguments

Arguments

Allocate the persistent fields. Always allocates (configure runs after init, so enable is not known yet); the off-cost is the f_centre + two interface fields.

Arguments

Allocate the vertex-mode corner fields and set at_vertex. Called at CONFIGURE time (after init, before enter_data) — deliberately NOT from init, so the (nx+1,ny+1,nz+1) corner carrier is only ever allocated when the vertex form is actually selected (~327 MB at 1000x800x50).

Arguments

Fill f_centre with the beta-plane Coriolis magnitude at cell centres: |f_0 + beta*(y - y_ref)|. Mirrors EPBL’s set_f_centre. Call after init, before enter_data.

Arguments

Fill f_corner with the SIGNED beta-plane Coriolis at C-grid corners: f_0 + beta(y - y_ref), corner row j at y = (j-1-nghost)dy (half a cell below centre row j — corner (i,j) is the SW corner of cell (i,j)). Bit-identical to metrics_fill_coriolis’s beta-plane corner fill. Call after init_vertex, before enter_data.

Arguments